1 pragma solidity >=0.4.24 <0.6.0;

2 contract Bar {

3 constructor () public {}

4 function baz(uint p) public pure returns (uint ret) {
5 ret = p + 2;
6 }

7 }
8 contract ExternalFunctionCall {

9 function foo(uint x, Bar y) public pure returns (uint ret) {
10 ret = x + y.baz(2);
11 }

12 function testExternalFunctionCall(uint x) public returns (uint y) {
13 Bar bar = new Bar();
14 y = this.foo(x, bar);
15 }

16 }

assert (y == x + 4);

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(admin == msg.sender, "Ownable: caller is not the owner");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(_whitelist[msg.sender] != address(0), "only white");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(paths.length == 2,"deposit: PE");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(_amount > 0, "deposit: zero");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(paths.length == 2,"deposit: PE");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(vars.newBalance > vars.oldBalance, "B:E");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(vars.liquidity >= _minTokens, "H:S");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(overflow == 0, "Exceeding the ticket limit");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(overflow == 0, "Please withdraw usdt in advance");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(false, "You never staked this ticket before");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(user.amount >= _amount, "withdraw: not good");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");

1 // SPDX-License-Identifier: MIT
2 pragma experimental ABIEncoderV2;
3 pragma solidity 0.6.12;

4 import "./ParaToken.sol";
5 import "./interfaces/IERC20.sol";
6 import "./libraries/SafeERC20.sol";
7 import "./libraries/EnumerableSet.sol";
8 import "./libraries/SafeMath_para.sol";
9 import "./interfaces/IWETH.sol";
10 import './interfaces/IParaRouter02.sol';
11 import './interfaces/IParaPair.sol';
12 import './libraries/TransferHelper.sol';
13 import './interfaces/IFeeDistributor.sol';
14 import './ParaProxy.sol';

15 interface IParaTicket {
16 function level() external pure returns (uint256);
17 function tokensOfOwner(address owner) external view returns (uint256[] memory);
18 function setApprovalForAll(address to, bool approved) external;
19 function safeTransferFrom(address from, address to, uint256 tokenId) external;
20 function setUsed(uint256 tokenId) external;
21 function _used(uint256 tokenId) external view returns(bool);
22 }

23 interface IMigratorChef {
24 function migrate(IERC20 token) external returns (IERC20);
25 }

26 contract MasterChef is ParaProxyAdminStorage {
27 using SafeMath for uint256;
28 using SafeERC20 for IERC20;
29 // Info of each user.
30 struct UserInfo {
31 uint256 amount; // How many LP tokens the user has provided.
32 uint256 rewardDebt; // Reward debt. See explanation below.
33 //
34 // We do some fancy math here. Basically, any point in time, the amount of T42s
35 // entitled to a user but is pending to be distributed is:
36 //
37 // pending reward = (user.amount * pool.accT42PerShare) - user.rewardDebt
38 //
39 // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
40 // 1. The pool's `accT42PerShare` (and `lastRewardBlock`) gets updated.
41 // 2. User receives the pending reward sent to his/her address.
42 // 3. User's `amount` gets updated.
43 // 4. User's `rewardDebt` gets updated.
44 }
45 // Info of each pool.
46 struct PoolInfo {
47 IERC20 lpToken; // Address of LP token contract.
48 uint256 allocPoint; // How many allocation points assigned to this pool. T42s to distribute per block.
49 uint256 lastRewardBlock; // Last block number that T42s distribution occurs.
50 uint256 accT42PerShare; // Accumulated T42s per share, times 1e12. See below.
51 IParaTicket ticket; // if VIP pool, NFT ticket contract, else 0
52 uint256 pooltype;
53 }
54 // every farm's percent of T42 issue
55 uint8[10] public farmPercent;
56 // The T42 TOKEN!
57 ParaToken public t42;
58 // Dev address.
59 address public devaddr;
60 // Treasury address
61 address public treasury;
62 // Fee Distritution contract address
63 address public feeDistributor;
64 // Mining income commission rate, default 5%
65 uint256 public claimFeeRate;
66 // Mining pool withdrawal fee rate, the default is 1.3%
67 uint256 public withdrawFeeRate;
68 // Block number when bonus T42 period ends.
69 uint256 public bonusEndBlock;
70 // Bonus muliplier for early t42 makers.
71 uint256 public constant BONUS_MULTIPLIER = 1;
72 // The migrator contract. It has a lot of power. Can only be set through governance (owner).
73 IMigratorChef public migrator;
74 // Info of each pool.
75 PoolInfo[] public poolInfo;
76 // Info of each user that stakes LP tokens.
77 mapping(uint256 => mapping(address => UserInfo)) public userInfo;
78 // Total allocation poitns. Must be the sum of all allocation points in all pools.
79 uint256 public totalAllocPoint;
80 // The block number when T42 mining starts.
81 uint256 public startBlock;

82 // the address of WETH
83 address public WETH;
84 // the address of Router
85 IParaRouter02 public paraRouter;
86 // Change returned after adding liquidity
87 mapping(address => mapping(address => uint)) public userChange;
88 // record who staked which NFT ticket into this contract
89 mapping(address => mapping(address => uint[])) public ticket_stakes;
90 // record total claimed T42 for per user & per PoolType
91 mapping(address => mapping(uint256 => uint256)) public _totalClaimed;
92 mapping(address => address) public _whitelist;
93 // TOTAL Deposit pid => uint
94 mapping(uint => uint) public poolsTotalDeposit;

95 event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
96 event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
97 event EmergencyWithdraw(
98 address indexed user,
99 uint256 indexed pid,
100 uint256 amount
101 );
102 event WithdrawChange(
103 address indexed user,
104 address indexed token,
105 uint256 change);
106 /**
107 * @dev Throws if called by any account other than the owner.
108 */
109 modifier onlyOwner() {
110 _;
111 }
112 constructor() public {
113 admin = msg.sender;
114 }

115 function initialize(
116 ParaToken _t42,
117 address _treasury,
118 address _feeDistributor,
119 address _devaddr,
120 uint256 _bonusEndBlock,
121 address _WETH,
122 IParaRouter02 _paraRouter
123 ) external onlyOwner {
124 t42 = _t42;
125 treasury = _treasury;
126 feeDistributor = _feeDistributor;
127 devaddr = _devaddr;
128 bonusEndBlock = _bonusEndBlock;
129 startBlock = _t42.startBlock();
130 WETH = _WETH;
131 paraRouter = _paraRouter;
132 claimFeeRate = 500;
133 withdrawFeeRate = 130;
134 }
135 //the beginning of reentrancy bug:
136 function depositSingle(uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
137 depositSingleInternal(msg.sender, msg.sender, _pid, _token, _amount, paths, _minTokens);
138 }

139 //uint256 _minPoolTokens,
140 function depositSingleTo(address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) payable external{
141 //Msg.sender is on the white list
142 IFeeDistributor(feeDistributor).setReferalByChef(_user, _whitelist[msg.sender]);
143 depositSingleInternal(msg.sender, _user, _pid, _token, _amount, paths, _minTokens);
144 }

145 struct DepositVars{
146 uint oldBalance;
147 uint newBalance;
148 uint amountA;
149 uint amountB;
150 uint liquidity;
151 }

152 //During the reentrancy process, the UBT contract deposits 222 genuine LP tokens, which are credited to ParaProxy’s ledger.
153 //After the reentrancy is completed, 222 LP tokens are added to the ParaProxy contract address,
154 //which the ParaProxy contract treats as LPs added by the attack contract and credits to the ledger.
155 function depositSingleInternal(address payer, address _user, uint256 _pid, address _token, uint256 _amount, address[][2] memory paths, uint _minTokens) internal {
156 //Stack too deep, try removing local variables
157 DepositVars memory vars;
158 (_token, _amount) = _doTransferIn(payer, _token, _amount);
159 //swap by path
160 (address[2] memory tokens, uint[2] memory amounts) = depositSwapForTokens(_token, _amount, paths);
161 //Go approve
162 approveIfNeeded(tokens[0], address(paraRouter), amounts[0]);
163 approveIfNeeded(tokens[1], address(paraRouter), amounts[1]);
164 PoolInfo memory pool = poolInfo[_pid];
165 //Non-VIP pool
166 //lp balance check
167 vars.oldBalance = pool.lpToken.balanceOf(address(this));
168 (vars.amountA, vars.amountB, vars.liquidity) = paraRouter.addLiquidity(tokens[0], tokens[1], amounts[0], amounts[1], 1, 1, address(this), block.timestamp + 600);
169 vars.newBalance = pool.lpToken.balanceOf(address(this));
170 //----------------- TODO
171 vars.liquidity = vars.newBalance.sub(vars.oldBalance);
172 addChange(_user, tokens[0], amounts[0].sub(vars.amountA));
173 addChange(_user, tokens[1], amounts[1].sub(vars.amountB));
174 //_deposit
175 _deposit(_pid, vars.liquidity, _user);
176 }



177 // Deposit LP tokens to MasterChef for T42 allocation.
178 function depositInternal(uint256 _pid, uint256 _amount, address _user, address payer) internal {
179 PoolInfo storage pool = poolInfo[_pid];
180 pool.lpToken.safeTransferFrom(
181 address(payer),
182 address(this),
183 _amount
184 );
185 if (address(pool.ticket) != address(0)) {
186 UserInfo storage user = userInfo[_pid][_user];
187 uint256 new_amount = user.amount.add(_amount);
188 uint256 user_ticket_count = pool.ticket.tokensOfOwner(_user).length;
189 uint256 staked_ticket_count = ticket_staked_count(_user, address(pool.ticket));
190 uint256 ticket_level = pool.ticket.level();
191 (, uint overflow) = check_vip_limit(ticket_level, user_ticket_count + staked_ticket_count, new_amount);

192 deposit_all_tickets(pool.ticket);
193 }
194 _deposit(_pid, _amount, _user);
195 }

196 // Deposit LP tokens to MasterChef for para allocation.
197 function _deposit(uint256 _pid, uint256 _amount, address _user) internal {
198 PoolInfo storage pool = poolInfo[_pid];
199 UserInfo storage user = userInfo[_pid][_user];
200 //add total of pool before updatePool
201 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].add(_amount);
202 updatePool(_pid);
203 if (user.amount > 0) {
204 uint256 pending =
205 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
206 user.rewardDebt
207 );
208 //TODO
209 _claim(pool.pooltype, pending);
210 }
211 user.amount = user.amount.add(_amount);
212 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
213 emit Deposit(_user, _pid, _amount);
214 }

215 function withdraw_tickets(uint256 _pid, uint256 tokenId) public {
216 //use memory for reduce gas
217 PoolInfo memory pool = poolInfo[_pid];
218 UserInfo memory user = userInfo[_pid][msg.sender];
219 //use storage because of updating value
220 uint256[] storage idlist = ticket_stakes[msg.sender][address(pool.ticket)];
221 for (uint i; i< idlist.length; i++) {
222 if (idlist[i] == tokenId) {
223 (, uint overflow) = check_vip_limit(pool.ticket.level(), idlist.length - 1, user.amount);

224 pool.ticket.safeTransferFrom(address(this), msg.sender, tokenId);
225 idlist[i] = idlist[idlist.length - 1];
226 idlist.pop();
227 return;
228 }
229 }
230 }

231 // Withdraw LP tokens from MasterChef.
232 function withdraw(uint256 _pid, uint256 _amount) public {
233 _withdrawInternal(_pid, _amount, msg.sender);
234 emit Withdraw(msg.sender, _pid, _amount);
235 }

236 function _withdrawInternal(uint256 _pid, uint256 _amount, address _operator) internal{
237 (address lpToken,uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, _operator);
238 IERC20(lpToken).safeTransfer(_operator, actual_amount);
239 }

240 function _withdrawWithoutTransfer(uint256 _pid, uint256 _amount, address _operator) internal returns (address lpToken, uint actual_amount){
241 PoolInfo storage pool = poolInfo[_pid];
242 UserInfo storage user = userInfo[_pid][_operator];
243 updatePool(_pid);
244 uint256 pending =
245 user.amount.mul(pool.accT42PerShare).div(1e12).sub(
246 user.rewardDebt
247 );
248 _claim(pool.pooltype, pending);
249 user.amount = user.amount.sub(_amount);
250 user.rewardDebt = user.amount.mul(pool.accT42PerShare).div(1e12);
251 //sub total of pool
252 poolsTotalDeposit[_pid] = poolsTotalDeposit[_pid].sub(_amount);
253 lpToken = address(pool.lpToken);
254 uint fee = _amount.mul(withdrawFeeRate).div(10000);
255 IERC20(lpToken).approve(feeDistributor, fee);
256 IFeeDistributor(feeDistributor).incomeWithdrawFee(_operator, lpToken, fee, _amount);
257 actual_amount = _amount.sub(fee);
258 }

259 function withdrawSingle(address tokenOut, uint256 _pid, uint256 _amount, address[][2] memory paths) external{
260 //doWithraw Lp
261 (address lpToken, uint actual_amount) = _withdrawWithoutTransfer(_pid, _amount, msg.sender);
262 //remove liquidity
263 address[2] memory tokens;
264 uint[2] memory amounts;
265 tokens[0] = IParaPair(lpToken).token0();
266 tokens[1] = IParaPair(lpToken).token1();
267 //Go approve
268 approveIfNeeded(lpToken, address(paraRouter), actual_amount);
269 (amounts[0], amounts[1]) = paraRouter.removeLiquidity(
270 tokens[0], tokens[1], actual_amount, 0, 0, address(this), block.timestamp.add(600));
271 //swap to tokenOut
272 for (uint i = 0; i < 2; i++){
273 address[] memory path = paths[i];
274 //Consider the same currency situation
275 if(path[0] == tokens[0]){
276 swapTokensOut(amounts[0], tokenOut, path);
277 }else{
278 swapTokensOut(amounts[1], tokenOut, path);
279 }
280 }
281 emit Withdraw(msg.sender, _pid, _amount);
282 }

283 function approveIfNeeded(address _token, address spender, uint _amount) private{
284 if (IERC20(_token).allowance(address(this), spender) < _amount) {
285 IERC20(_token).approve(spender, _amount);
286 }
287 }

109+ require(admin == msg.sender, "Ownable: caller is not the owner");
141+ require(_whitelist[msg.sender] != address(0), "only white");
155+ require(paths.length == 2,"deposit: PE");
158+ require(_amount > 0, "deposit: zero");
165+ require(address(pool.ticket) == address(0), "T:E");
170+ require(vars.newBalance > vars.oldBalance, "B:E");
171+ require(vars.liquidity >= _minTokens, "H:S");
191+ require(overflow == 0, "Exceeding the ticket limit");
223+ require(overflow == 0, "Please withdraw usdt in advance");
229+ require(false, "You never staked this ticket before");
242+ require(user.amount >= _amount, "withdraw: not good");
259+ require(paths[0].length >= 2 && paths[1].length >= 2, "PE:2");
259+ require(paths[0][paths[0].length - 1] == tokenOut,"invalid path_");
259+ require(paths[1][paths[1].length - 1] == tokenOut,"invalid path_");
273+ require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

require(path[0] == tokens[0] || path[0] == tokens[1], "invalid path_0");

1 pragma solidity >=0.4.24 <0.6.0;

2 contract ExternalFunctionCall {

3 function foo(uint x) public returns (uint ret) {
4 ret = x + 2;
5 }

6 function testExternalFunctionCall(uint x) public {
7 uint y = this.foo(x);
8 }

9 }

assert (y == x + 2);

1 pragma solidity >=0.4.24 <0.6.0;
2 contract B {
3 function funcB() public pure returns (uint) {
4 return 42;
5 }
6 constructor() public {}
7 }

8 contract A {
9 function funcA1() public pure returns (uint) {
10 return 11;
11 }
12 function funcA2(uint x) public pure returns (uint) {
13 return x+1;
14 }
15 function funcA3() public returns (B) {
16 B retVal= new B();
17 return retVal;
18 }
19 constructor() public
20 {

21 }
22 }

20+ assert(funcA2(funcA1())==12);
20+ assert(funcA3().funcB()==42);

assert(funcA2(funcA1())==12);
assert(funcA3().funcB()==42);

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 }
34 }

35 contract D is B, C {
36 constructor (uint x) B(x+3) C(x+4) public
37 {
38 }
39 }

assert(a == x + 1);

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 }
34 }

35 contract D is B, C {
36 constructor (uint x) B(x+3) C(x+4) public
37 {
38 }
39 }

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 }
34 }

35 contract D is B, C {
36 constructor (uint x) B(x+3) C(x+4) public
37 {
38 }
39 }

assert (a == x + 4);
assert (b == x + 4);
assert (c == x + 6);

1 pragma solidity >=0.4.24 <0.6.0;
2 contract B {
3 function funcB() public pure returns (uint) {
4 return 42;
5 }
6 constructor() public {}
7 }

8 contract A {
9 function funcA1() public pure returns (uint) {
10 return 11;
11 }
12 function funcA2(uint x) public pure returns (uint) {
13 return x+1;
14 }
15 function funcA3() public returns (B) {
16 B retVal= new B();
17 return retVal;
18 }
19 constructor() public
20 {
21 }
22 }

20+ assert(funcA2(funcA1())==12);
20+ assert(funcA3().funcB()==42);

assert(funcA2(funcA1())==12);
assert(funcA3().funcB()==42);

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 // passes, but proved to only 4 transactions
34 }
35 }

36 contract D is B, C {
37 constructor (uint x) B(x+3) C(x+4) public
38 {
39 ;
40 }
41 }

assert(a == x + 1);

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 // passes, but proved to only 4 transactions
34 }
35 }

36 contract D is B, C {
37 constructor (uint x) B(x+3) C(x+4) public
38 {
39 ;
40 }
41 }

1 pragma solidity >=0.4.24 <0.6.0;

2 // This test passes, but assertion on line 35 is only proved
3 // up to 4 transactions
4 // This result means that ctor A is only called once, for B, as A(x+1)
5 // Compare this test with ConstructorChaining2_fail.sol: no ctor args there,
6 // so the workaround in the compiler doesn't work, and the base ctor is called twice


7 // Example of the trace:
8 // D(x) is called, where x is 716
9 // B(x+3) called, where x is 716, B's arg is 719
10 // A(x+1) called, where x is 720. A's arg is 720
11 // ctor A {a = x} , where a is 720
12 // ctor B {b = x+1 } , where x is 719, b is 720
13 // C(x+4) is called, where x is 716, C's arg is 720
14 // ctor C { c = x + 2}, where x is 720, c is 722

15 contract A {
16 uint a;
17 constructor (uint x) public {
18 a = x;
19 }
20 }

21 contract B is A {
22 uint b;
23 constructor (uint x) A(x+1) public {
24 b = x + 1;
25 }
26 }

27 contract C is A {
28 uint c;
29 //constructor (uint x) A(x+2) public { // no A with ANY args here, otherwise, solc error:
30 // "Base constr args given twice"
31 constructor (uint x) public {
32 c = x + 2;
33 // passes, but proved to only 4 transactions
34 }
35 }

36 contract D is B, C {
37 constructor (uint x) B(x+3) C(x+4) public
38 {
39 ;
40 }
41 }

assert (a == x + 4);
assert (b == x + 4);
assert (c == x + 6);

1 pragma solidity >=0.4.24<0.6.0;
2 import "./Libraries/VeriSolContracts.sol";


3 contract LoopFor {

4 int x;
5 int y;

6 function ContractInvariant () private view {

7 }

8 // test Loop invariant with for loop
9 constructor(int n) public {
10 require (n >= 0);
11 x = n;
12 y = x;
13 }

14 function Foo() public {
15 if ( x > 0 )
16 {
17 x--;
18 y--;
19 }
20 }
21 }

1 pragma solidity >=0.4.24<0.6.0;
2 import "./Libraries/VeriSolContracts.sol";


3 contract LoopFor {

4 int x;
5 int y;

6 function ContractInvariant () private view {

7 }

8 // test Loop invariant with for loop
9 constructor(int n) public {
10 require (n >= 0);
11 x = n;
12 y = x;
13 }

14 function Foo() public {
15 if ( x > 0 )
16 {
17 x--;
18 y--;
19 }
20 }
21 }

pragma solidity >=0.4.24 <0.6.0;

//simple library with no internal state

library Lib {
function add(uint _a, uint _b) public view returns (uint r) {
address x = address(this);
r = _a + _b;
}
}

contract C {
// using Lib for uint;

function foo() public {
uint x = 1;
uint y = 2;
uint z = Lib.add(x, y);
}
}

5+ assert(x == msg.sender);
14+ assert (z == 3);

assert(x == msg.sender);

pragma solidity >=0.4.24 <0.6.0;

//simple library with no internal state

library Lib {
function add(uint _a, uint _b) public view returns (uint r) {
address x = address(this);
r = _a + _b;
}
}

contract C {
// using Lib for uint;

function foo() public {
uint x = 1;
uint y = 2;
uint z = Lib.add(x, y);
}
}

5+ assert(x == msg.sender);
14+ assert (z == 3);

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

assert(x + y == n);

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

assert(x + y == n);

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

assert(x + y == n);

1 pragma solidity ^0.4.24;
2 import "./../../Libraries/VeriSolContracts.sol";
3 //import "./VeriSolContracts.sol";
4 //import "github.com/microsoft/verisol/blob/master/Libraries/VeriSolContracts.sol";

5 contract LoopFor {

6 // test Loop invariant with for loop
7 constructor(uint n) public {
8 require (n >= 0);
9 uint y = 0;
10 for (uint x = n; x != 0; x --) {
11 y++;
12 }

13 }

14 // test Loop invariant with while loop
15 function Foo(uint n) public {
16 require (n >= 0);
17 uint y = 0;
18 uint x = n;
19 while (x != 0) {
20 y++;
21 x--;
22 }
23 }

24 // test Loop invariant with do-while loop
25 function Bar(uint n) public {
26 require (n > 0);
27 uint y = 0;
28 uint x = n;
29 do {
30 y++;
31 x--;
32 } while (x != 0);
33 }
34 }

1 pragma solidity ^0.5.0;

2 import "./IERC20.sol";
3 import "./SafeMath.sol";
4 import "./Libraries/VeriSolContracts.sol"; //change


5 /**
6 * A highly simplified Token to express basic specifications
7 *
8 * - totalSupply() equals the Sum({balanceOf(a) | a is an address })
9 *
10 */
11 contract ERC20 is IERC20 {

12 mapping (address => uint256) private _balances;
13 uint256 private _totalSupply;


14 /**
15 * A dummy constructor
16 */
17 constructor (uint256 totalSupply) public {
18 _totalSupply = totalSupply;
19 _balances[msg.sender] = totalSupply;
20 }

21 /**
22 * @dev See {IERC20-totalSupply}.
23 */
24 function totalSupply() public view returns (uint256) {
25 return _totalSupply;
26 }

27 /**
28 * @dev See {IERC20-balanceOf}.
29 */
30 function balanceOf(address account) public view returns (uint256) {
31 return _balances[account];
32 }

33 /**
34 * @dev See {IERC20-transfer}.
35 *
36 * Requirements:
37 *
38 * - `recipient` cannot be the zero address.
39 * - the caller must have a balance of at least `amount`.
40 */
41 function transfer(address recipient, uint256 amount) public returns (bool) {
42 uint oldBalanceSender = _balances[msg.sender];

43 _transfer(msg.sender, recipient, amount);

44 //assert (/* msg.sender == recipient || */ _balances[msg.sender] == oldBalanceSender - amount);
45 // the following assertion will fail due to overflow when not using safemath
46 // to detect it, run with /modularArith flag
47 // to prove it, run ERC20 with /modularArith flag
48 return true;
49 }

50 /**
51 * @dev Moves tokens `amount` from `sender` to `recipient`.
52 *
53 * This is internal function is equivalent to {transfer}, and can be used to
54 * e.g. implement automatic token fees, slashing mechanisms, etc.
55 *
56 * Emits a {Transfer} event.
57 *
58 * Requirements:
59 *
60 * - `sender` cannot be the zero address.
61 * - `recipient` cannot be the zero address.
62 * - `sender` must have a balance of at least `amount`.
63 */
64 function _transfer(address sender, address recipient, uint256 amount) internal {
65 require(sender != address(0), "ERC20: transfer from the zero address");
66 require(recipient != address(0), "ERC20: transfer to the zero address");
67 _balances[sender] = SafeMath.sub(_balances[sender], amount);

68 _balances[recipient] = _balances[recipient] + amount; // nosafemath //_balances[recipient] = _balances[recipient].add(amount);
69 }
70 }

17+ require(msg.sender != address(0));
47+ assert (msg.sender == recipient || _balances[recipient] >= VeriSol.Old(_balances[recipient]));
66+ require(_balances[sender] >= amount);

require(msg.sender != address(0));

1 pragma solidity ^0.5.0;

2 import "./IERC20.sol";
3 import "./SafeMath.sol";
4 import "./Libraries/VeriSolContracts.sol"; //change


5 /**
6 * A highly simplified Token to express basic specifications
7 *
8 * - totalSupply() equals the Sum({balanceOf(a) | a is an address })
9 *
10 */
11 contract ERC20 is IERC20 {

12 mapping (address => uint256) private _balances;
13 uint256 private _totalSupply;


14 /**
15 * A dummy constructor
16 */
17 constructor (uint256 totalSupply) public {
18 _totalSupply = totalSupply;
19 _balances[msg.sender] = totalSupply;
20 }

21 /**
22 * @dev See {IERC20-totalSupply}.
23 */
24 function totalSupply() public view returns (uint256) {
25 return _totalSupply;
26 }

27 /**
28 * @dev See {IERC20-balanceOf}.
29 */
30 function balanceOf(address account) public view returns (uint256) {
31 return _balances[account];
32 }

33 /**
34 * @dev See {IERC20-transfer}.
35 *
36 * Requirements:
37 *
38 * - `recipient` cannot be the zero address.
39 * - the caller must have a balance of at least `amount`.
40 */
41 function transfer(address recipient, uint256 amount) public returns (bool) {
42 uint oldBalanceSender = _balances[msg.sender];

43 _transfer(msg.sender, recipient, amount);

44 //assert (/* msg.sender == recipient || */ _balances[msg.sender] == oldBalanceSender - amount);
45 // the following assertion will fail due to overflow when not using safemath
46 // to detect it, run with /modularArith flag
47 // to prove it, run ERC20 with /modularArith flag
48 return true;
49 }

50 /**
51 * @dev Moves tokens `amount` from `sender` to `recipient`.
52 *
53 * This is internal function is equivalent to {transfer}, and can be used to
54 * e.g. implement automatic token fees, slashing mechanisms, etc.
55 *
56 * Emits a {Transfer} event.
57 *
58 * Requirements:
59 *
60 * - `sender` cannot be the zero address.
61 * - `recipient` cannot be the zero address.
62 * - `sender` must have a balance of at least `amount`.
63 */
64 function _transfer(address sender, address recipient, uint256 amount) internal {
65 require(sender != address(0), "ERC20: transfer from the zero address");
66 require(recipient != address(0), "ERC20: transfer to the zero address");
67 _balances[sender] = SafeMath.sub(_balances[sender], amount);

68 _balances[recipient] = _balances[recipient] + amount; // nosafemath //_balances[recipient] = _balances[recipient].add(amount);
69 }
70 }

17+ require(msg.sender != address(0));
47+ assert (msg.sender == recipient || _balances[recipient] >= VeriSol.Old(_balances[recipient]));
66+ require(_balances[sender] >= amount);

assert (msg.sender == recipient || _balances[recipient] >= VeriSol.Old(_balances[recipient]));

1 pragma solidity ^0.5.0;

2 import "./IERC20.sol";
3 import "./SafeMath.sol";
4 import "./Libraries/VeriSolContracts.sol"; //change


5 /**
6 * A highly simplified Token to express basic specifications
7 *
8 * - totalSupply() equals the Sum({balanceOf(a) | a is an address })
9 *
10 */
11 contract ERC20 is IERC20 {

12 mapping (address => uint256) private _balances;
13 uint256 private _totalSupply;


14 /**
15 * A dummy constructor
16 */
17 constructor (uint256 totalSupply) public {
18 _totalSupply = totalSupply;
19 _balances[msg.sender] = totalSupply;
20 }

21 /**
22 * @dev See {IERC20-totalSupply}.
23 */
24 function totalSupply() public view returns (uint256) {
25 return _totalSupply;
26 }

27 /**
28 * @dev See {IERC20-balanceOf}.
29 */
30 function balanceOf(address account) public view returns (uint256) {
31 return _balances[account];
32 }

33 /**
34 * @dev See {IERC20-transfer}.
35 *
36 * Requirements:
37 *
38 * - `recipient` cannot be the zero address.
39 * - the caller must have a balance of at least `amount`.
40 */
41 function transfer(address recipient, uint256 amount) public returns (bool) {
42 uint oldBalanceSender = _balances[msg.sender];

43 _transfer(msg.sender, recipient, amount);

44 //assert (/* msg.sender == recipient || */ _balances[msg.sender] == oldBalanceSender - amount);
45 // the following assertion will fail due to overflow when not using safemath
46 // to detect it, run with /modularArith flag
47 // to prove it, run ERC20 with /modularArith flag
48 return true;
49 }

50 /**
51 * @dev Moves tokens `amount` from `sender` to `recipient`.
52 *
53 * This is internal function is equivalent to {transfer}, and can be used to
54 * e.g. implement automatic token fees, slashing mechanisms, etc.
55 *
56 * Emits a {Transfer} event.
57 *
58 * Requirements:
59 *
60 * - `sender` cannot be the zero address.
61 * - `recipient` cannot be the zero address.
62 * - `sender` must have a balance of at least `amount`.
63 */
64 function _transfer(address sender, address recipient, uint256 amount) internal {
65 require(sender != address(0), "ERC20: transfer from the zero address");
66 require(recipient != address(0), "ERC20: transfer to the zero address");
67 _balances[sender] = SafeMath.sub(_balances[sender], amount);

68 _balances[recipient] = _balances[recipient] + amount; // nosafemath //_balances[recipient] = _balances[recipient].add(amount);
69 }
70 }

17+ require(msg.sender != address(0));
47+ assert (msg.sender == recipient || _balances[recipient] >= VeriSol.Old(_balances[recipient]));
66+ require(_balances[sender] >= amount);

require(_balances[sender] >= amount);

1 //SPDX-License-Identifier: MIT
2 pragma solidity 0.7.5;

3 contract contrived{
4 function withdraw(uint256 amount) override public nonReentrant updateReward(msg.sender) {
5 _totalSupply = _totalSupply - amount;
6 _balances[msg.sender] = _balances[msg.sender].sub(amount);
7 stakingToken.safeTransfer(msg.sender, amount);

8 emit Withdrawn(msg.sender, amount);
9 }
10 }

4+ require(amount > 0, "Cannot withdraw 0");

require(amount > 0, "Cannot withdraw 0");

1 /**
2 *Submitted for verification at Etherscan.io on 2018-02-09
3 */

4 pragma solidity ^0.4.16;

5 /**
6 * @title SafeMath
7 * @dev Math operations with safety checks that throw on error
8 */
9 library SafeMath {
10 function mul(uint256 a, uint256 b) internal constant returns (uint256) {
11 uint256 c = a * b;
12 return c;
13 }

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

20 function sub(uint256 a, uint256 b) internal constant returns (uint256) {
21 return a - b;
22 }

23 function add(uint256 a, uint256 b) internal constant returns (uint256) {
24 uint256 c = a + b;
25 return c;
26 }
27 }

28 /**
29 * @title ERC20Basic
30 * @dev Simpler version of ERC20 interface
31 * @dev see https://github.com/ethereum/EIPs/issues/179
32 */
33 contract ERC20Basic {
34 uint256 public totalSupply;
35 function balanceOf(address who) public constant returns (uint256);
36 function transfer(address to, uint256 value) public returns (bool);
37 event Transfer(address indexed from, address indexed to, uint256 value);
38 }

39 /**
40 * @title Basic token
41 * @dev Basic version of StandardToken, with no allowances.
42 */
43 contract BasicToken is ERC20Basic {
44 using SafeMath for uint256;

45 mapping(address => uint256) balances;

46 /**
47 * @dev transfer token for a specified address
48 * @param _to The address to transfer to.
49 * @param _value The amount to be transferred.
50 */
51 function transfer(address _to, uint256 _value) public returns (bool) {

52 // SafeMath.sub will throw if there is not enough balance.
53 balances[msg.sender] = balances[msg.sender].sub(_value);
54 balances[_to] = balances[_to].add(_value);
55 Transfer(msg.sender, _to, _value);
56 return true;
57 }

58 /**
59 * @dev Gets the balance of the specified address.
60 * @param _owner The address to query the the balance of.
61 * @return An uint256 representing the amount owned by the passed address.
62 */
63 function balanceOf(address _owner) public constant returns (uint256 balance) {
64 return balances[_owner];
65 }
66 }

67 /**
68 * @title ERC20 interface
69 * @dev see https://github.com/ethereum/EIPs/issues/20
70 */
71 contract ERC20 is ERC20Basic {
72 function allowance(address owner, address spender) public constant returns (uint256);
73 function transferFrom(address from, address to, uint256 value) public returns (bool);
74 function approve(address spender, uint256 value) public returns (bool);
75 event Approval(address indexed owner, address indexed spender, uint256 value);
76 }


77 /**
78 * @title Standard ERC20 token
79 *
80 * @dev Implementation of the basic standard token.
81 * @dev https://github.com/ethereum/EIPs/issues/20
82 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
83 */
84 contract StandardToken is ERC20, BasicToken {

85 mapping (address => mapping (address => uint256)) internal allowed;


86 /**
87 * @dev Transfer tokens from one address to another
88 * @param _from address The address which you want to send tokens from
89 * @param _to address The address which you want to transfer to
90 * @param _value uint256 the amount of tokens to be transferred
91 */
92 function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
93 require(_to != address(0));
94 require(_value > 0 && _value <= balances[_from]);
95 require(_value <= allowed[_from][msg.sender]);

96 balances[_from] = balances[_from].sub(_value);
97 balances[_to] = balances[_to].add(_value);
98 allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
99 Transfer(_from, _to, _value);
100 return true;
101 }

102 /**
103 * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
104 *
105 * Beware that changing an allowance with this method brings the risk that someone may use both the old
106 * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
107 * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
108 * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
109 * @param _spender The address which will spend the funds.
110 * @param _value The amount of tokens to be spent.
111 */
112 function approve(address _spender, uint256 _value) public returns (bool) {
113 allowed[msg.sender][_spender] = _value;
114 Approval(msg.sender, _spender, _value);
115 return true;
116 }

117 /**
118 * @dev Function to check the amount of tokens that an owner allowed to a spender.
119 * @param _owner address The address which owns the funds.
120 * @param _spender address The address which will spend the funds.
121 * @return A uint256 specifying the amount of tokens still available for the spender.
122 */
123 function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
124 return allowed[_owner][_spender];
125 }
126 }

127 /**
128 * @title Ownable
129 * @dev The Ownable contract has an owner address, and provides basic authorization control
130 * functions, this simplifies the implementation of "user permissions".
131 */
132 contract Ownable {
133 address public owner;


134 event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


135 /**
136 * @dev The Ownable constructor sets the original `owner` of the contract to the sender
137 * account.
138 */
139 function Ownable() {
140 owner = msg.sender;
141 }


142 /**
143 * @dev Throws if called by any account other than the owner.
144 */
145 modifier onlyOwner() {
146 _;
147 }


148 /**
149 * @dev Allows the current owner to transfer control of the contract to a newOwner.
150 * @param newOwner The address to transfer ownership to.
151 */
152 function transferOwnership(address newOwner) onlyOwner public {
153 OwnershipTransferred(owner, newOwner);
154 owner = newOwner;
155 }

156 }

157 /**
158 * @title Pausable
159 * @dev Base contract which allows children to implement an emergency stop mechanism.
160 */
161 contract Pausable is Ownable {
162 event Pause();
163 event Unpause();

164 bool public paused = false;


165 /**
166 * @dev Modifier to make a function callable only when the contract is not paused.
167 */
168 modifier whenNotPaused() {
169 _;
170 }

171 /**
172 * @dev Modifier to make a function callable only when the contract is paused.
173 */
174 modifier whenPaused() {
175 _;
176 }

177 /**
178 * @dev called by the owner to pause, triggers stopped state
179 */
180 function pause() onlyOwner whenNotPaused public {
181 paused = true;
182 Pause();
183 }

184 /**
185 * @dev called by the owner to unpause, returns to normal state
186 */
187 function unpause() onlyOwner whenPaused public {
188 paused = false;
189 Unpause();
190 }
191 }

192 /**
193 * @title Pausable token
194 *
195 * @dev StandardToken modified with pausable transfers.
196 **/

197 contract PausableToken is StandardToken, Pausable {

198 function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
199 return super.transfer(_to, _value);
200 }

201 function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
202 return super.transferFrom(_from, _to, _value);
203 }

204 function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
205 return super.approve(_spender, _value);
206 }

207 function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
208 uint cnt = _receivers.length;
209 uint256 amount = uint256(cnt) * _value;
210 require(cnt > 0 && cnt <= 20);
211 require(_value > 0 && balances[msg.sender] >= amount);

212 balances[msg.sender] = balances[msg.sender].sub(amount);
213 for (uint i = 0; i < cnt; i++) {
214 balances[_receivers[i]] = balances[_receivers[i]].add(_value);
215 Transfer(msg.sender, _receivers[i], _value);
216 }
217 return true;
218 }
219 }

220 /**
221 * @title Bec Token
222 *
223 * @dev Implementation of Bec Token based on the basic standard token.
224 */
225 contract BecToken is PausableToken {
226 /**
227 * Public variables of the token
228 * The following variables are OPTIONAL vanities. One does not have to include them.
229 * They allow one to customise the token contract & in no way influences the core functionality.
230 * Some wallets/interfaces might not even bother to look at this information.
231 */
232 string public name = "BeautyChain";
233 string public symbol = "BEC";
234 string public version = '1.0.0';
235 uint8 public decimals = 18;

236 /**
237 * @dev Function to check the amount of tokens that an owner allowed to a spender.
238 */
239 function BecToken() {
240 totalSupply = 7000000000 * (10**(uint256(decimals)));
241 balances[msg.sender] = totalSupply; // Give the creator all initial tokens
242 }

243 function () {
244 //if ether is sent to this address, send it back.
245 revert();
246 }
247 }

11+ assert(a == 0 || c / a == b);
20+ assert(b <= a);
24+ assert(c >= a);
51+ require(_to != address(0));
51+ require(_value > 0 && _value <= balances[msg.sender]);
145+ require(msg.sender == owner);
152+ require(newOwner != address(0));
168+ require(!paused);
174+ require(paused);

assert(a == 0 || c / a == b);

1 /**
2 *Submitted for verification at Etherscan.io on 2018-02-09
3 */

4 pragma solidity ^0.4.16;

5 /**
6 * @title SafeMath
7 * @dev Math operations with safety checks that throw on error
8 */
9 library SafeMath {
10 function mul(uint256 a, uint256 b) internal constant returns (uint256) {
11 uint256 c = a * b;
12 return c;
13 }

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

20 function sub(uint256 a, uint256 b) internal constant returns (uint256) {
21 return a - b;
22 }

23 function add(uint256 a, uint256 b) internal constant returns (uint256) {
24 uint256 c = a + b;
25 return c;
26 }
27 }

28 /**
29 * @title ERC20Basic
30 * @dev Simpler version of ERC20 interface
31 * @dev see https://github.com/ethereum/EIPs/issues/179
32 */
33 contract ERC20Basic {
34 uint256 public totalSupply;
35 function balanceOf(address who) public constant returns (uint256);
36 function transfer(address to, uint256 value) public returns (bool);
37 event Transfer(address indexed from, address indexed to, uint256 value);
38 }

39 /**
40 * @title Basic token
41 * @dev Basic version of StandardToken, with no allowances.
42 */
43 contract BasicToken is ERC20Basic {
44 using SafeMath for uint256;

45 mapping(address => uint256) balances;

46 /**
47 * @dev transfer token for a specified address
48 * @param _to The address to transfer to.
49 * @param _value The amount to be transferred.
50 */
51 function transfer(address _to, uint256 _value) public returns (bool) {

52 // SafeMath.sub will throw if there is not enough balance.
53 balances[msg.sender] = balances[msg.sender].sub(_value);
54 balances[_to] = balances[_to].add(_value);
55 Transfer(msg.sender, _to, _value);
56 return true;
57 }

58 /**
59 * @dev Gets the balance of the specified address.
60 * @param _owner The address to query the the balance of.
61 * @return An uint256 representing the amount owned by the passed address.
62 */
63 function balanceOf(address _owner) public constant returns (uint256 balance) {
64 return balances[_owner];
65 }
66 }

67 /**
68 * @title ERC20 interface
69 * @dev see https://github.com/ethereum/EIPs/issues/20
70 */
71 contract ERC20 is ERC20Basic {
72 function allowance(address owner, address spender) public constant returns (uint256);
73 function transferFrom(address from, address to, uint256 value) public returns (bool);
74 function approve(address spender, uint256 value) public returns (bool);
75 event Approval(address indexed owner, address indexed spender, uint256 value);
76 }


77 /**
78 * @title Standard ERC20 token
79 *
80 * @dev Implementation of the basic standard token.
81 * @dev https://github.com/ethereum/EIPs/issues/20
82 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
83 */
84 contract StandardToken is ERC20, BasicToken {

85 mapping (address => mapping (address => uint256)) internal allowed;


86 /**
87 * @dev Transfer tokens from one address to another
88 * @param _from address The address which you want to send tokens from
89 * @param _to address The address which you want to transfer to
90 * @param _value uint256 the amount of tokens to be transferred
91 */
92 function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
93 require(_to != address(0));
94 require(_value > 0 && _value <= balances[_from]);
95 require(_value <= allowed[_from][msg.sender]);

96 balances[_from] = balances[_from].sub(_value);
97 balances[_to] = balances[_to].add(_value);
98 allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
99 Transfer(_from, _to, _value);
100 return true;
101 }

102 /**
103 * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
104 *
105 * Beware that changing an allowance with this method brings the risk that someone may use both the old
106 * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
107 * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
108 * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
109 * @param _spender The address which will spend the funds.
110 * @param _value The amount of tokens to be spent.
111 */
112 function approve(address _spender, uint256 _value) public returns (bool) {
113 allowed[msg.sender][_spender] = _value;
114 Approval(msg.sender, _spender, _value);
115 return true;
116 }

117 /**
118 * @dev Function to check the amount of tokens that an owner allowed to a spender.
119 * @param _owner address The address which owns the funds.
120 * @param _spender address The address which will spend the funds.
121 * @return A uint256 specifying the amount of tokens still available for the spender.
122 */
123 function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
124 return allowed[_owner][_spender];
125 }
126 }

127 /**
128 * @title Ownable
129 * @dev The Ownable contract has an owner address, and provides basic authorization control
130 * functions, this simplifies the implementation of "user permissions".
131 */
132 contract Ownable {
133 address public owner;


134 event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


135 /**
136 * @dev The Ownable constructor sets the original `owner` of the contract to the sender
137 * account.
138 */
139 function Ownable() {
140 owner = msg.sender;
141 }


142 /**
143 * @dev Throws if called by any account other than the owner.
144 */
145 modifier onlyOwner() {
146 _;
147 }


148 /**
149 * @dev Allows the current owner to transfer control of the contract to a newOwner.
150 * @param newOwner The address to transfer ownership to.
151 */
152 function transferOwnership(address newOwner) onlyOwner public {
153 OwnershipTransferred(owner, newOwner);
154 owner = newOwner;
155 }

156 }

157 /**
158 * @title Pausable
159 * @dev Base contract which allows children to implement an emergency stop mechanism.
160 */
161 contract Pausable is Ownable {
162 event Pause();
163 event Unpause();

164 bool public paused = false;


165 /**
166 * @dev Modifier to make a function callable only when the contract is not paused.
167 */
168 modifier whenNotPaused() {
169 _;
170 }

171 /**
172 * @dev Modifier to make a function callable only when the contract is paused.
173 */
174 modifier whenPaused() {
175 _;
176 }

177 /**
178 * @dev called by the owner to pause, triggers stopped state
179 */
180 function pause() onlyOwner whenNotPaused public {
181 paused = true;
182 Pause();
183 }

184 /**
185 * @dev called by the owner to unpause, returns to normal state
186 */
187 function unpause() onlyOwner whenPaused public {
188 paused = false;
189 Unpause();
190 }
191 }

192 /**
193 * @title Pausable token
194 *
195 * @dev StandardToken modified with pausable transfers.
196 **/

197 contract PausableToken is StandardToken, Pausable {

198 function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
199 return super.transfer(_to, _value);
200 }

201 function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
202 return super.transferFrom(_from, _to, _value);
203 }

204 function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
205 return super.approve(_spender, _value);
206 }

207 function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
208 uint cnt = _receivers.length;
209 uint256 amount = uint256(cnt) * _value;
210 require(cnt > 0 && cnt <= 20);
211 require(_value > 0 && balances[msg.sender] >= amount);

212 balances[msg.sender] = balances[msg.sender].sub(amount);
213 for (uint i = 0; i < cnt; i++) {
214 balances[_receivers[i]] = balances[_receivers[i]].add(_value);
215 Transfer(msg.sender, _receivers[i], _value);
216 }
217 return true;
218 }
219 }

220 /**
221 * @title Bec Token
222 *
223 * @dev Implementation of Bec Token based on the basic standard token.
224 */
225 contract BecToken is PausableToken {
226 /**
227 * Public variables of the token
228 * The following variables are OPTIONAL vanities. One does not have to include them.
229 * They allow one to customise the token contract & in no way influences the core functionality.
230 * Some wallets/interfaces might not even bother to look at this information.
231 */
232 string public name = "BeautyChain";
233 string public symbol = "BEC";
234 string public version = '1.0.0';
235 uint8 public decimals = 18;

236 /**
237 * @dev Function to check the amount of tokens that an owner allowed to a spender.
238 */
239 function BecToken() {
240 totalSupply = 7000000000 * (10**(uint256(decimals)));
241 balances[msg.sender] = totalSupply; // Give the creator all initial tokens
242 }

243 function () {
244 //if ether is sent to this address, send it back.
245 revert();
246 }
247 }

11+ assert(a == 0 || c / a == b);
20+ assert(b <= a);
24+ assert(c >= a);
51+ require(_to != address(0));
51+ require(_value > 0 && _value <= balances[msg.sender]);
145+ require(msg.sender == owner);
152+ require(newOwner != address(0));
168+ require(!paused);
174+ require(paused);

1 /**
2 *Submitted for verification at Etherscan.io on 2018-02-09
3 */

4 pragma solidity ^0.4.16;

5 /**
6 * @title SafeMath
7 * @dev Math operations with safety checks that throw on error
8 */
9 library SafeMath {
10 function mul(uint256 a, uint256 b) internal constant returns (uint256) {
11 uint256 c = a * b;
12 return c;
13 }

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

20 function sub(uint256 a, uint256 b) internal constant returns (uint256) {
21 return a - b;
22 }

23 function add(uint256 a, uint256 b) internal constant returns (uint256) {
24 uint256 c = a + b;
25 return c;
26 }
27 }

28 /**
29 * @title ERC20Basic
30 * @dev Simpler version of ERC20 interface
31 * @dev see https://github.com/ethereum/EIPs/issues/179
32 */
33 contract ERC20Basic {
34 uint256 public totalSupply;
35 function balanceOf(address who) public constant returns (uint256);
36 function transfer(address to, uint256 value) public returns (bool);
37 event Transfer(address indexed from, address indexed to, uint256 value);
38 }

39 /**
40 * @title Basic token
41 * @dev Basic version of StandardToken, with no allowances.
42 */
43 contract BasicToken is ERC20Basic {
44 using SafeMath for uint256;

45 mapping(address => uint256) balances;

46 /**
47 * @dev transfer token for a specified address
48 * @param _to The address to transfer to.
49 * @param _value The amount to be transferred.
50 */
51 function transfer(address _to, uint256 _value) public returns (bool) {

52 // SafeMath.sub will throw if there is not enough balance.
53 balances[msg.sender] = balances[msg.sender].sub(_value);
54 balances[_to] = balances[_to].add(_value);
55 Transfer(msg.sender, _to, _value);
56 return true;
57 }

58 /**
59 * @dev Gets the balance of the specified address.
60 * @param _owner The address to query the the balance of.
61 * @return An uint256 representing the amount owned by the passed address.
62 */
63 function balanceOf(address _owner) public constant returns (uint256 balance) {
64 return balances[_owner];
65 }
66 }

67 /**
68 * @title ERC20 interface
69 * @dev see https://github.com/ethereum/EIPs/issues/20
70 */
71 contract ERC20 is ERC20Basic {
72 function allowance(address owner, address spender) public constant returns (uint256);
73 function transferFrom(address from, address to, uint256 value) public returns (bool);
74 function approve(address spender, uint256 value) public returns (bool);
75 event Approval(address indexed owner, address indexed spender, uint256 value);
76 }


77 /**
78 * @title Standard ERC20 token
79 *
80 * @dev Implementation of the basic standard token.
81 * @dev https://github.com/ethereum/EIPs/issues/20
82 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
83 */
84 contract StandardToken is ERC20, BasicToken {

85 mapping (address => mapping (address => uint256)) internal allowed;


86 /**
87 * @dev Transfer tokens from one address to another
88 * @param _from address The address which you want to send tokens from
89 * @param _to address The address which you want to transfer to
90 * @param _value uint256 the amount of tokens to be transferred
91 */
92 function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
93 require(_to != address(0));
94 require(_value > 0 && _value <= balances[_from]);
95 require(_value <= allowed[_from][msg.sender]);

96 balances[_from] = balances[_from].sub(_value);
97 balances[_to] = balances[_to].add(_value);
98 allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
99 Transfer(_from, _to, _value);
100 return true;
101 }

102 /**
103 * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
104 *
105 * Beware that changing an allowance with this method brings the risk that someone may use both the old
106 * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
107 * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
108 * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
109 * @param _spender The address which will spend the funds.
110 * @param _value The amount of tokens to be spent.
111 */
112 function approve(address _spender, uint256 _value) public returns (bool) {
113 allowed[msg.sender][_spender] = _value;
114 Approval(msg.sender, _spender, _value);
115 return true;
116 }

117 /**
118 * @dev Function to check the amount of tokens that an owner allowed to a spender.
119 * @param _owner address The address which owns the funds.
120 * @param _spender address The address which will spend the funds.
121 * @return A uint256 specifying the amount of tokens still available for the spender.
122 */
123 function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
124 return allowed[_owner][_spender];
125 }
126 }

127 /**
128 * @title Ownable
129 * @dev The Ownable contract has an owner address, and provides basic authorization control
130 * functions, this simplifies the implementation of "user permissions".
131 */
132 contract Ownable {
133 address public owner;


134 event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


135 /**
136 * @dev The Ownable constructor sets the original `owner` of the contract to the sender
137 * account.
138 */
139 function Ownable() {
140 owner = msg.sender;
141 }


142 /**
143 * @dev Throws if called by any account other than the owner.
144 */
145 modifier onlyOwner() {
146 _;
147 }


148 /**
149 * @dev Allows the current owner to transfer control of the contract to a newOwner.
150 * @param newOwner The address to transfer ownership to.
151 */
152 function transferOwnership(address newOwner) onlyOwner public {
153 OwnershipTransferred(owner, newOwner);
154 owner = newOwner;
155 }

156 }

157 /**
158 * @title Pausable
159 * @dev Base contract which allows children to implement an emergency stop mechanism.
160 */
161 contract Pausable is Ownable {
162 event Pause();
163 event Unpause();

164 bool public paused = false;


165 /**
166 * @dev Modifier to make a function callable only when the contract is not paused.
167 */
168 modifier whenNotPaused() {
169 _;
170 }

171 /**
172 * @dev Modifier to make a function callable only when the contract is paused.
173 */
174 modifier whenPaused() {
175 _;
176 }

177 /**
178 * @dev called by the owner to pause, triggers stopped state
179 */
180 function pause() onlyOwner whenNotPaused public {
181 paused = true;
182 Pause();
183 }

184 /**
185 * @dev called by the owner to unpause, returns to normal state
186 */
187 function unpause() onlyOwner whenPaused public {
188 paused = false;
189 Unpause();
190 }
191 }

192 /**
193 * @title Pausable token
194 *
195 * @dev StandardToken modified with pausable transfers.
196 **/

197 contract PausableToken is StandardToken, Pausable {

198 function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
199 return super.transfer(_to, _value);
200 }

201 function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
202 return super.transferFrom(_from, _to, _value);
203 }

204 function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
205 return super.approve(_spender, _value);
206 }

207 function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
208 uint cnt = _receivers.length;
209 uint256 amount = uint256(cnt) * _value;
210 require(cnt > 0 && cnt <= 20);
211 require(_value > 0 && balances[msg.sender] >= amount);

212 balances[msg.sender] = balances[msg.sender].sub(amount);
213 for (uint i = 0; i < cnt; i++) {
214 balances[_receivers[i]] = balances[_receivers[i]].add(_value);
215 Transfer(msg.sender, _receivers[i], _value);
216 }
217 return true;
218 }
219 }

220 /**
221 * @title Bec Token
222 *
223 * @dev Implementation of Bec Token based on the basic standard token.
224 */
225 contract BecToken is PausableToken {
226 /**
227 * Public variables of the token
228 * The following variables are OPTIONAL vanities. One does not have to include them.
229 * They allow one to customise the token contract & in no way influences the core functionality.
230 * Some wallets/interfaces might not even bother to look at this information.
231 */
232 string public name = "BeautyChain";
233 string public symbol = "BEC";
234 string public version = '1.0.0';
235 uint8 public decimals = 18;

236 /**
237 * @dev Function to check the amount of tokens that an owner allowed to a spender.
238 */
239 function BecToken() {
240 totalSupply = 7000000000 * (10**(uint256(decimals)));
241 balances[msg.sender] = totalSupply; // Give the creator all initial tokens
242 }

243 function () {
244 //if ether is sent to this address, send it back.
245 revert();
246 }
247 }

11+ assert(a == 0 || c / a == b);
20+ assert(b <= a);
24+ assert(c >= a);
51+ require(_to != address(0));
51+ require(_value > 0 && _value <= balances[msg.sender]);
145+ require(msg.sender == owner);
152+ require(newOwner != address(0));
168+ require(!paused);
174+ require(paused);

1 /**
2 *Submitted for verification at Etherscan.io on 2018-02-09
3 */

4 pragma solidity ^0.4.16;

5 /**
6 * @title SafeMath
7 * @dev Math operations with safety checks that throw on error
8 */
9 library SafeMath {
10 function mul(uint256 a, uint256 b) internal constant returns (uint256) {
11 uint256 c = a * b;
12 return c;
13 }

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

20 function sub(uint256 a, uint256 b) internal constant returns (uint256) {
21 return a - b;
22 }

23 function add(uint256 a, uint256 b) internal constant returns (uint256) {
24 uint256 c = a + b;
25 return c;
26 }
27 }

28 /**
29 * @title ERC20Basic
30 * @dev Simpler version of ERC20 interface
31 * @dev see https://github.com/ethereum/EIPs/issues/179
32 */
33 contract ERC20Basic {
34 uint256 public totalSupply;
35 function balanceOf(address who) public constant returns (uint256);
36 function transfer(address to, uint256 value) public returns (bool);
37 event Transfer(address indexed from, address indexed to, uint256 value);
38 }

39 /**
40 * @title Basic token
41 * @dev Basic version of StandardToken, with no allowances.
42 */
43 contract BasicToken is ERC20Basic {
44 using SafeMath for uint256;

45 mapping(address => uint256) balances;

46 /**
47 * @dev transfer token for a specified address
48 * @param _to The address to transfer to.
49 * @param _value The amount to be transferred.
50 */
51 function transfer(address _to, uint256 _value) public returns (bool) {

52 // SafeMath.sub will throw if there is not enough balance.
53 balances[msg.sender] = balances[msg.sender].sub(_value);
54 balances[_to] = balances[_to].add(_value);
55 Transfer(msg.sender, _to, _value);
56 return true;
57 }

58 /**
59 * @dev Gets the balance of the specified address.
60 * @param _owner The address to query the the balance of.
61 * @return An uint256 representing the amount owned by the passed address.
62 */
63 function balanceOf(address _owner) public constant returns (uint256 balance) {
64 return balances[_owner];
65 }
66 }

67 /**
68 * @title ERC20 interface
69 * @dev see https://github.com/ethereum/EIPs/issues/20
70 */
71 contract ERC20 is ERC20Basic {
72 function allowance(address owner, address spender) public constant returns (uint256);
73 function transferFrom(address from, address to, uint256 value) public returns (bool);
74 function approve(address spender, uint256 value) public returns (bool);
75 event Approval(address indexed owner, address indexed spender, uint256 value);
76 }


77 /**
78 * @title Standard ERC20 token
79 *
80 * @dev Implementation of the basic standard token.
81 * @dev https://github.com/ethereum/EIPs/issues/20
82 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
83 */
84 contract StandardToken is ERC20, BasicToken {

85 mapping (address => mapping (address => uint256)) internal allowed;


86 /**
87 * @dev Transfer tokens from one address to another
88 * @param _from address The address which you want to send tokens from
89 * @param _to address The address which you want to transfer to
90 * @param _value uint256 the amount of tokens to be transferred
91 */
92 function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
93 require(_to != address(0));
94 require(_value > 0 && _value <= balances[_from]);
95 require(_value <= allowed[_from][msg.sender]);

96 balances[_from] = balances[_from].sub(_value);
97 balances[_to] = balances[_to].add(_value);
98 allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
99 Transfer(_from, _to, _value);
100 return true;
101 }

102 /**
103 * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
104 *
105 * Beware that changing an allowance with this method brings the risk that someone may use both the old
106 * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
107 * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
108 * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
109 * @param _spender The address which will spend the funds.
110 * @param _value The amount of tokens to be spent.
111 */
112 function approve(address _spender, uint256 _value) public returns (bool) {
113 allowed[msg.sender][_spender] = _value;
114 Approval(msg.sender, _spender, _value);
115 return true;
116 }

117 /**
118 * @dev Function to check the amount of tokens that an owner allowed to a spender.
119 * @param _owner address The address which owns the funds.
120 * @param _spender address The address which will spend the funds.
121 * @return A uint256 specifying the amount of tokens still available for the spender.
122 */
123 function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
124 return allowed[_owner][_spender];
125 }
126 }

127 /**
128 * @title Ownable
129 * @dev The Ownable contract has an owner address, and provides basic authorization control
130 * functions, this simplifies the implementation of "user permissions".
131 */
132 contract Ownable {
133 address public owner;


134 event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


135 /**
136 * @dev The Ownable constructor sets the original `owner` of the contract to the sender
137 * account.
138 */
139 function Ownable() {
140 owner = msg.sender;
141 }


142 /**
143 * @dev Throws if called by any account other than the owner.
144 */
145 modifier onlyOwner() {
146 _;
147 }


148 /**
149 * @dev Allows the current owner to transfer control of the contract to a newOwner.
150 * @param newOwner The address to transfer ownership to.
151 */
152 function transferOwnership(address newOwner) onlyOwner public {
153 OwnershipTransferred(owner, newOwner);
154 owner = newOwner;
155 }

156 }

157 /**
158 * @title Pausable
159 * @dev Base contract which allows children to implement an emergency stop mechanism.
160 */
161 contract Pausable is Ownable {
162 event Pause();
163 event Unpause();

164 bool public paused = false;


165 /**
166 * @dev Modifier to make a function callable only when the contract is not paused.
167 */
168 modifier whenNotPaused() {
169 _;
170 }

171 /**
172 * @dev Modifier to make a function callable only when the contract is paused.
173 */
174 modifier whenPaused() {
175 _;
176 }

177 /**
178 * @dev called by the owner to pause, triggers stopped state
179 */
180 function pause() onlyOwner whenNotPaused public {
181 paused = true;
182 Pause();
183 }

184 /**
185 * @dev called by the owner to unpause, returns to normal state
186 */
187 function unpause() onlyOwner whenPaused public {
188 paused = false;
189 Unpause();
190 }
191 }

192 /**
193 * @title Pausable token
194 *
195 * @dev StandardToken modified with pausable transfers.
196 **/

197 contract PausableToken is StandardToken, Pausable {

198 function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
199 return super.transfer(_to, _value);
200 }

201 function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
202 return super.transferFrom(_from, _to, _value);
203 }

204 function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
205 return super.approve(_spender, _value);
206 }

207 function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
208 uint cnt = _receivers.length;
209 uint256 amount = uint256(cnt) * _value;
210 require(cnt > 0 && cnt <= 20);
211 require(_value > 0 && balances[msg.sender] >= amount);

212 balances[msg.sender] = balances[msg.sender].sub(amount);
213 for (uint i = 0; i < cnt; i++) {
214 balances[_receivers[i]] = balances[_receivers[i]].add(_value);
215 Transfer(msg.sender, _receivers[i], _value);
216 }
217 return true;
218 }
219 }

220 /**
221 * @title Bec Token
222 *
223 * @dev Implementation of Bec Token based on the basic standard token.
224 */
225 contract BecToken is PausableToken {
226 /**
227 * Public variables of the token
228 * The following variables are OPTIONAL vanities. One does not have to include them.
229 * They allow one to customise the token contract & in no way influences the core functionality.
230 * Some wallets/interfaces might not even bother to look at this information.
231 */
232 string public name = "BeautyChain";
233 string public symbol = "BEC";
234 string public version = '1.0.0';
235 uint8 public decimals = 18;

236 /**
237 * @dev Function to check the amount of tokens that an owner allowed to a spender.
238 */
239 function BecToken() {
240 totalSupply = 7000000000 * (10**(uint256(decimals)));
241 balances[msg.sender] = totalSupply; // Give the creator all initial tokens
242 }

243 function () {
244 //if ether is sent to this address, send it back.
245 revert();
246 }
247 }

11+ assert(a == 0 || c / a == b);
20+ assert(b <= a);
24+ assert(c >= a);
51+ require(_to != address(0));
51+ require(_value > 0 && _value <= balances[msg.sender]);
145+ require(msg.sender == owner);
152+ require(newOwner != address(0));
168+ require(!paused);
174+ require(paused);

require(_to != address(0));
require(_value > 0 && _value <= balances[msg.sender]);