Biswap

1pragma solidity 0.6.12;
2library SafeBEP20 {
3    using SafeMath for uint256;
4    using Address for address;
5​
6    function safeTransfer(
7        IBEP20 token,
8        address to,
9        uint256 value
10    ) internal {
11        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
12    }
13​
14    function safeTransferFrom(
15        IBEP20 token,
16        address from,
17        address to,
18        uint256 value
19    ) internal {
20        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
21    }
22​
23    /**
24     * @dev Deprecated. This function has issues similar to the ones found in
25     * {IBEP20-approve}, and its usage is discouraged.
26     *
27     * Whenever possible, use {safeIncreaseAllowance} and
28     * {safeDecreaseAllowance} instead.
29     */
30    function safeApprove(
31        IBEP20 token,
32        address spender,
33        uint256 value
34    ) internal {
35        // safeApprove should only be called when setting an initial allowance,
36        // or when resetting it to zero. To increase and decrease it, use
37        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
38        // solhint-disable-next-line max-line-length
39        require(
40            (value == 0) || (token.allowance(address(this), spender) == 0),
41            'SafeBEP20: approve from non-zero to non-zero allowance'
42        );
43        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
44    }
45​
46    function safeIncreaseAllowance(
47        IBEP20 token,
48        address spender,
49        uint256 value
50    ) internal {
51        uint256 newAllowance = token.allowance(address(this), spender).add(value);
52        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
53    }
54​
55    function safeDecreaseAllowance(
56        IBEP20 token,
57        address spender,
58        uint256 value
59    ) internal {
60        uint256 newAllowance = token.allowance(address(this), spender).sub(
61            value,
62            'SafeBEP20: decreased allowance below zero'
63        );
64        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
65    }
66​
67    /**
68     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
69     * on the return value: the return value is optional (but if data is returned, it must not be false).
70     * @param token The token targeted by the call.
71     * @param data The call data (encoded using abi.encode or one of its variants).
72     */
73    function _callOptionalReturn(IBEP20 token, bytes memory data) private {
74        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
75        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
76        // the target address contains contract code and also asserts for success in the low-level call.
77​
78        bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
79        if (returndata.length > 0) {
80            // Return data is optional
81            // solhint-disable-next-line max-line-length
82            require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
83        }
84    }
85}
86import "./BSWToken.sol";
87​
88interface IMigratorChef {
89    function migrate(IBEP20 token) external returns (IBEP20);
90}
91​
92// MasterChef is the master of BSW. He can make BSW and he is a fair guy.
93//
94// Note that it's ownable and the owner wields tremendous power. The ownership
95// will be transferred to a governance smart contract once BSW is sufficiently
96// distributed and the community can show to govern itself.
97//
98// Have fun reading it. Hopefully it's bug-free. God bless.
99contract MasterChef is Ownable {
100    using SafeMath for uint256;
101    using SafeBEP20 for IBEP20;
102    // Info of each user.
103    struct UserInfo {
104        uint256 amount; // How many LP tokens the user has provided.
105        uint256 rewardDebt; // Reward debt. See explanation below.
106        //
107        // We do some fancy math here. Basically, any point in time, the amount of BSWs
108        // entitled to a user but is pending to be distributed is:
109        //
110        //   pending reward = (user.amount * pool.accBSWPerShare) - user.rewardDebt
111        //
112        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
113        //   1. The pool's `accBSWPerShare` (and `lastRewardBlock`) gets updated.
114        //   2. User receives the pending reward sent to his/her address.
115        /   3. User's `amount` gets updated.
116        /   4. User's `rewardDebt` gets updated.
117    }
118    // Info of each pool.
119    struct PoolInfo {
120        IBEP20 lpToken; // Address of LP token contract.
121        uint256 allocPoint; // How many allocation points assigned to this pool. BSWs to distribute per block.
122        uint256 lastRewardBlock; // Last block number that BSWs distribution occurs.
123        uint256 accBSWPerShare; // Accumulated BSWs per share, times 1e12. See below.
124    }
125    // The BSW TOKEN!
126    BSWToken public BSW;
127    //Pools, Farms, Dev, Refs percent decimals
128    uint256 public percentDec = 1000000;
129    //Pools and Farms percent from token per block
130    uint256 public stakingPercent;
131    //Developers percent from token per block
132    uint256 public devPercent;
133    //Referrals percent from token per block
134    uint256 public refPercent;
135    //Safu fund percent from token per block
136    uint256 public safuPercent;
137    // Dev address.
138    address public devaddr;
139    // Safu fund.
140    address public safuaddr;
141    // Refferals commision address.
142    address public refAddr;
143    // Last block then develeper withdraw dev and ref fee
144    uint256 public lastBlockDevWithdraw;
145    // BSW tokens created per block.
146    uint256 public BSWPerBlock;
147    // Bonus muliplier for early BSW makers.
148    uint256 public BONUS_MULTIPLIER = 1;
149    // The migrator contract. It has a lot of power. Can only be set through governance (owner).
150    IMigratorChef public migrator;
151    // Info of each pool.
152    PoolInfo[] public poolInfo;
153    // Info of each user that stakes LP tokens.
154    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
155    // Total allocation poitns. Must be the sum of all allocation points in all pools.
156    uint256 public totalAllocPoint = 0;
157    // The block number when BSW mining starts.
158    uint256 public startBlock;
159    // Deposited amount BSW in MasterChef
160    uint256 public depositedBsw;
161​

Solidity Contracts

JavaScript Tests