Contract 0x9a319b959e33369C5eaA494a770117eE3e585318

 
Txn Hash
Block
From
To
Value [Txn Fee]
0x2eb3ebb30b34ccd4db0502160bbdfd008169c8ba6c53e8352eecc1c92667d43784652112021-06-20 15:56:3825 secs ago0x13858bb023d5d9b922b3587d03e474c1a00a5a85 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.000227205
0x9590ccd50658fb11ec6759ff5d14f97e0bc1b369de909c6b2c631fa608cd36d184648442021-06-20 15:38:1718 mins ago0x7f5d44227d3af8cfd7eb19bde8f60fb55d4257a5 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.000072915
0xffe545dab5f33787acde464950b18e7663103bc5913eca6ebd0b844fc1f8afb084646582021-06-20 15:28:5928 mins ago0x2cc94e31d96b4bc71376fd87862a8f0b82e66ef0 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.000072915
0xe3494a38676f82c83d242860eeaf003d5100f64d92ef5b4a3700c5b9e6c70a1f84646452021-06-20 15:28:2028 mins ago0x2cc94e31d96b4bc71376fd87862a8f0b82e66ef0 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.000072915
0x75e75be2cdf8d33cd30239086089f5f80389161953cf0327c2380b3645dc3f6984645682021-06-20 15:24:2932 mins ago0x3fc0945fb806d47078155b27d488444603dad977 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x4ae0cd7149816ca4cf8473b3786c9a300fe59c3fbd136c9f939ffe150078a70284634082021-06-20 14:26:291 hr 30 mins ago0x1adf15a826b8e65b5e6e37b7f009a555fda013ba IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xf42a3d15ebc26215b69c525c9527fa91aba03e41c0dec25af0e679481d12108384616532021-06-20 12:58:442 hrs 58 mins ago0x638b1108f8034cef898712e4b36c01fec0a2b95c IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xfaca4d02c6e3821a8ec6ca96c3b87a1f9dfd41ed094a88dddd2647aeebf7aa5584608852021-06-20 12:20:203 hrs 36 mins ago0x17274907e48a047211e567325c049efdc7db6604 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x960d5eb67f09fa63b0970216bdf34aee8c65f813dc624cb1672547bc5714db1e84600712021-06-20 11:39:384 hrs 17 mins ago0xc9598237aefea347b3d4ce3567fff066fe9543df IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x337cbb3066b8df04d5939b931c387fa5f2461785c37e65a3c1943a72352cf16684600682021-06-20 11:39:294 hrs 17 mins ago0x68cd1279c609d1ec4c89f643dad02f8d353e438e IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x5e72eb415ee76da97c66d25748ef0ed2076f0a1bd04875f76880bcd2474fc88f84594462021-06-20 11:08:234 hrs 48 mins ago0x0d2ea2a2de99d97f4ea3f409e4b6be564c430b1d IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xfc9431e4e4a272c20589800f8a869cc652760155a6415a0ce4dc378d4713280e84593852021-06-20 11:05:204 hrs 51 mins ago0xfb4283cce43d480fae796f0359ed83fcd2a80cbf IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00010652
0xdff67ab1e6f4079a4316263c26192133a0bb402721b5935cdb53f1308f86f00b84588082021-06-20 10:36:295 hrs 20 mins ago0xfda9bd74968120621506c61ff3f9313e33185d74 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xc7a313ad275587175906ff76253b121256eae7dc0b95ab3b027a92690d8db1c784583322021-06-20 10:12:405 hrs 44 mins ago0x5f0829b4684cb88dff75b6ab5b35ec25842b7453 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xf420e28d0a11346590bf32778642d4376c52dce96668df91719ce180b480719984574662021-06-20 9:29:226 hrs 27 mins ago0xd746bd166304744cfb9e11b0b93416ec21fdd6aa IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x00fea1dd69bf97152435a1fef31a06722e309d2238875f6a8147f68c0f6dda0b84571532021-06-20 9:13:316 hrs 43 mins ago0x26dc2816843dfa0e3ef2c6b62795417edbe0c7f2 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x816aad9642f40d5c1ddc0987072ab84ffa9f638097d1b234955d3b03570020ab84569802021-06-20 9:04:076 hrs 52 mins ago0x794ecbe2863d26f3d849313a98f7af3df59b3c33 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xd4057c59459edb370c4a80aa0a92cebe5fdac9fb03b2566388d6bd3cab8620e684565722021-06-20 8:43:437 hrs 13 mins ago0x50c39055469600abd69d4c821438df0195e7c888 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x36e42b3fab396041bb022ff4f7600ef5e855b7d8cc9eda1e80b69dd2bf084fcc84554762021-06-20 7:48:538 hrs 8 mins ago0x6fda0806618c3981a8a7b3075e2ee7887a648acf IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x7fbe63cd830f3b109d68b0a58c41f20435860b4821153895df8bfbbfd2cfbe8d84541192021-06-20 6:41:029 hrs 16 mins ago0xf7e5a901db4fefc5f142f0fd4157d0cf802ed2a8 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.000072915
0x93c3c58fecd3e51933237cbf246eb72ff40118c149f08520ca0f66945895186084540092021-06-20 6:35:329 hrs 21 mins ago0x747a5767e30dbd69a1acc09153a6633e5414abb2 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xd7af28a371d2d96810707cf37b9f115c31a6c45a63d7ebf2bc4c3b2b0bc0b6f484536902021-06-20 6:19:359 hrs 37 mins ago0xe073ed6743c57d5eb968f2216b0767ae9a25fd76 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0x8f6823ae3b16a8102d1574e077a452c72303ac7640bc858afd5e2d99ad33654284535792021-06-20 6:14:029 hrs 43 mins ago0x56ec1e76c44f6d2c4bb477dec447f0169188816e IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
0xbe4a21ea5a47029d935b5477c3964b9e5950d0ff3279abe1e1917eb453634c8884528632021-06-20 5:38:1410 hrs 18 mins ago0xcbc153cc339b6c1f20eed9cbc718b7d9c28b9553 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.0002673
0x278e41934fa81fc0f3a1f243d8b1df762064f59efffbc269d2cb1d9947258e6884527762021-06-20 5:33:5310 hrs 23 mins ago0xb6a6a0edc25f00ba6c946e72a0cd99fe05318b87 IN  0x9a319b959e33369c5eaa494a770117ee3e5853180 BNB0.00022275
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SushiToken

Compiler Version
v0.7.4+commit.3f05b770

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-04-02
*/

pragma solidity >=0.7.0;
pragma experimental ABIEncoderV2;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            if (returndata.length > 0) {
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}
contract Ownable is Context {
    address private _owner;

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

    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }
    function owner() public view returns (address) {
        return _owner;
    }
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory _n, string memory _s) {
        _name = _n;
        _symbol = _s;
        _decimals = 18;
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
}

contract SushiToken is ERC20("HYFI", "HYFI"), Ownable {
    using SafeMath for uint256;

    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }
}

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

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

    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. SUSHIs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that SUSHIs distribution occurs.
        uint256 accSushiPerShare; // Accumulated SUSHIs per share, times 1e12. See below.
    }

    SushiToken public sushi;
    uint256 public sushiPerBlock;

    uint public constant blocksOneWeek = 201600; // 7 * 24 * 60 * 20; 14days
    uint public constant initBlockReward = 656e17;

    uint public constant blocksForCut = 403200; // 14 * 24 * 60 * 20; 14days

    PoolInfo[] public poolInfo;
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    uint256 public totalAllocPoint = 0;

    uint256 public startBlock;
    uint public normalBlock;
    uint256 public allEndBlock;

    address public devaddr;

    uint[] public rewardOfDay;

    address public burnAddress = 0x0000000000000000000000000000000000000001;

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

    struct HarvestInfo {
        uint harvestBlock;
        uint lockedBalance;
    }

    mapping (uint => mapping (address => HarvestInfo)) public harvestInfos;

    address public investorAddr;
    
    constructor(address _sushi, uint256 _startBlock, address _devaddr, address _investorAddr) {
        require(_devaddr != address(0));
        require(_investorAddr != address(0));
        devaddr = _devaddr;
        investorAddr = _investorAddr;
        require(ERC20(_sushi).decimals() >= 0, "!erc20");
        sushi = SushiToken(_sushi);
        sushiPerBlock = 1;
        startBlock = _startBlock;
        normalBlock = _startBlock.add(blocksOneWeek.mul(8)); // 8 weeks
        allEndBlock = _startBlock.add(blocksOneWeek.mul(104)); // 2 years

        rewardOfDay = new uint[](9); 
        rewardOfDay[0] = initBlockReward;
        for (uint i = 1; i <= 3; i++) {
            rewardOfDay[i] = rewardOfDay[i-1].mul(80).div(100);
        }
        for (uint i = 4; i <= 8; i++) {
            rewardOfDay[i] = rewardOfDay[i-1].mul(70).div(100);
        }
    }

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

    function setInvestorAddr(address a) public onlyOwner {
        require(a != address(0));
        investorAddr = a;
    }

    function add(uint256 _allocPoint, address _lpToken, bool _withUpdate) public onlyOwner {
        require(IERC20(_lpToken).totalSupply() >= 0, "!erc20");
        for (uint pid = 0; pid < poolInfo.length; pid++) {
            PoolInfo storage pool = poolInfo[pid];
            require(_lpToken != address(pool.lpToken), "!dup");
        }
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: IERC20(_lpToken),
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accSushiPerShare: 0
        }));
    }

    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        if (_from >= _to) {
            return 0;
        }
        if (_from < startBlock || _from >= allEndBlock) {
            return 0;
        }
        if (_to > allEndBlock) {
            _to = allEndBlock;
        }
        if (_from >= normalBlock) {
            return rewardOfDay[8].mul(_to.sub(_from));
        }
        uint total = 0;
        if (_to >= normalBlock) {
            total += rewardOfDay[8].mul(_to.sub(normalBlock));     
            _to = normalBlock;
        }
        _from = _from.sub(startBlock);
        _to = _to.sub(startBlock);

        uint weekCount = _from.div(blocksOneWeek); // from 0
        uint weekEndBlock = 0;
        uint blockReward = 0;
        while (_from < _to) {
            if (weekCount > 7) {
                break;
            }
            blockReward = rewardOfDay[weekCount];
            weekEndBlock = blocksOneWeek.mul(weekCount.add(1));
            weekCount = weekCount.add(1);
            if (weekEndBlock <= _to) {
                total = total.add(blockReward.mul(weekEndBlock.sub(_from)));
            } else {
                total = total.add(blockReward.mul(_to.sub(_from)));
            }
            _from = weekEndBlock;
        }
        return total;
    }

    function pendingSushi(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accSushiPerShare = pool.accSushiPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accSushiPerShare = accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        }
        uint p = user.amount.mul(accSushiPerShare).div(1e12).sub(user.rewardDebt);

        HarvestInfo storage haInfo = harvestInfos[_pid][_user];
        return p.add(haInfo.lockedBalance);
    }

    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 sushiReward = multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

        sushi.mint(devaddr, sushiReward.mul(13).div(80));
        sushi.mint(investorAddr, sushiReward.mul(5).div(80));
        sushi.mint(address(this), sushiReward);
        pool.accSushiPerShare = pool.accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    function deposit(uint256 _pid, uint256 _amount) public {
        address account = msg.sender;

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        HarvestInfo storage haInfo = harvestInfos[_pid][msg.sender];

        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
            lockSushi(_pid, account, pending);
            if (block.number.sub(haInfo.harvestBlock) >= blocksForCut) {
                _harvest(_pid);
            }
        } else {
            haInfo.harvestBlock = block.number;
        }
        pool.lpToken.safeTransferFrom(account, address(this), _amount);
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);

        emit Deposit(account, _pid, _amount);
    }

    function canHarvestAll(uint _pid) public view returns (bool) {
        HarvestInfo storage haInfo = harvestInfos[_pid][msg.sender];
        uint lastHarvestBlock = haInfo.harvestBlock;
        return block.number.sub(lastHarvestBlock) >= blocksForCut;
    }

    function canHarvestAllBlock(uint _pid, address user) public view returns (uint) {
        HarvestInfo storage haInfo = harvestInfos[_pid][user];
        uint lastHarvestBlock = haInfo.harvestBlock;
        return lastHarvestBlock.add(blocksForCut);
    }

    function lockedBalanceOf(uint _pid) public view returns (uint) {
        HarvestInfo storage haInfo = harvestInfos[_pid][msg.sender];
        return haInfo.lockedBalance;
    }

    function _harvest(uint _pid) internal {
        HarvestInfo storage haInfo = harvestInfos[_pid][msg.sender];
        uint lastHarvestBlock = haInfo.harvestBlock;
        require(lastHarvestBlock > 0);

        if (block.number.sub(lastHarvestBlock) >= blocksForCut) {
            unlockSushi(_pid, msg.sender, false);
        } else {
            unlockSushi(_pid, msg.sender, true);
        }
    }

    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
        lockSushi(_pid, msg.sender, pending);
        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        _harvest(_pid);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    function lockSushi(uint _pid, address _to, uint256 _amount) internal {
        HarvestInfo storage haInfo = harvestInfos[_pid][_to];
        uint256 sushiBal = sushi.balanceOf(address(this));
        uint amt = 0;
        if (_amount > sushiBal) {
            amt = sushiBal;
        } else {
            amt = _amount;
        }
        haInfo.lockedBalance = haInfo.lockedBalance.add(_amount);
    }

    function unlockSushi(uint _pid, address _to, bool cut) internal {
        uint256 sushiBal = sushi.balanceOf(address(this));
        uint amt = 0;
        HarvestInfo storage haInfo = harvestInfos[_pid][_to];
        uint _amount = haInfo.lockedBalance;

        haInfo.harvestBlock = block.number;
        haInfo.lockedBalance = 0;

        if (_amount > sushiBal) {
            amt = sushiBal;
        } else {
            amt = _amount;
        }
        uint burnAmt = 0;
        if (cut) {
            burnAmt = amt.div(2);
            amt = amt.sub(burnAmt);
        }
        if (amt > 0) {
            sushi.transfer(_to, amt);
        }
        if (burnAmt > 0) {
            sushi.transfer(burnAddress, burnAmt);
        }
    }

    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }
}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

10761:198:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7873:83;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8727:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8150:100::-;;;:::i;:::-;;;;;;;:::i;8904:321::-;;;;;;:::i;:::-;;:::i;8059:83::-;;;:::i;:::-;;;;;;;:::i;10857:99::-;;;;;;:::i;:::-;;:::i;:::-;;8258:119;;;;;;:::i;:::-;;:::i;6968:148::-;;;:::i;6758:79::-;;;:::i;:::-;;;;;;;:::i;7964:87::-;;;:::i;8385:175::-;;;;;;:::i;:::-;;:::i;8568:151::-;;;;;;:::i;:::-;;:::i;7122:244::-;;;;;;:::i;:::-;;:::i;7873:83::-;7943:5;7936:12;;;;;;;;-1:-1:-1;;7936:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7910:13;;7936:12;;7943:5;;7936:12;;7943:5;7936:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7873:83;:::o;8727:169::-;8810:4;8827:39;8836:12;:10;:12::i;:::-;8850:7;8859:6;8827:8;:39::i;:::-;-1:-1:-1;8884:4:0;8727:169;;;;:::o;8150:100::-;8230:12;;8150:100;:::o;8904:321::-;9010:4;9027:36;9037:6;9045:9;9056:6;9027:9;:36::i;:::-;9074:121;9083:6;9091:12;:10;:12::i;:::-;9105:89;9143:6;9105:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9105:19:0;;;;;;:11;:19;;;;;;9125:12;:10;:12::i;:::-;-1:-1:-1;;;;;9105:33:0;;;;;;;;;;;;-1:-1:-1;9105:33:0;;;:89;:37;:89::i;:::-;9074:8;:121::i;:::-;-1:-1:-1;9213:4:0;8904:321;;;;;:::o;8059:83::-;8125:9;;;;8059:83;:::o;10857:99::-;6893:12;:10;:12::i;:::-;6883:6;;;;;-1:-1:-1;;;;;6883:6:0;;;:22;;;6875:67;;;;-1:-1:-1;;;6875:67:0;;;;;;;:::i;:::-;;;;;;;;;10929:19:::1;10935:3;10940:7;10929:5;:19::i;:::-;10857:99:::0;;:::o;8258:119::-;-1:-1:-1;;;;;8351:18:0;;8324:7;8351:18;;;;;;;;;;;8258:119;;;;:::o;6968:148::-;6893:12;:10;:12::i;:::-;6883:6;;;;;-1:-1:-1;;;;;6883:6:0;;;:22;;;6875:67;;;;-1:-1:-1;;;6875:67:0;;;;;;;:::i;:::-;7059:6:::1;::::0;7038:40:::1;::::0;7075:1:::1;::::0;7059:6:::1;::::0;::::1;-1:-1:-1::0;;;;;7059:6:0::1;::::0;7038:40:::1;::::0;7075:1;;7038:40:::1;7089:6;:19:::0;;-1:-1:-1;;;;;;7089:19:0::1;::::0;;6968:148::o;6758:79::-;6823:6;;;;;-1:-1:-1;;;;;6823:6:0;;6758:79::o;7964:87::-;8036:7;8029:14;;;;;;;;-1:-1:-1;;8029:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8003:13;;8029:14;;8036:7;;8029:14;;8036:7;8029:14;;;;;;;;;;;;;;;;;;;;;;;;8385:175;8471:4;8488:42;8498:12;:10;:12::i;:::-;8512:9;8523:6;8488:9;:42::i;8568:151::-;-1:-1:-1;;;;;8684:18:0;;;8657:7;8684:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8568:151::o;7122:244::-;6893:12;:10;:12::i;:::-;6883:6;;;;;-1:-1:-1;;;;;6883:6:0;;;:22;;;6875:67;;;;-1:-1:-1;;;6875:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;7211:22:0;::::1;7203:73;;;;-1:-1:-1::0;;;7203:73:0::1;;;;;;;:::i;:::-;7313:6;::::0;7292:38:::1;::::0;-1:-1:-1;;;;;7292:38:0;;::::1;::::0;7313:6:::1;::::0;::::1;;::::0;7292:38:::1;::::0;;;::::1;7341:6;:17:::0;;-1:-1:-1;;;;;7341:17:0;;::::1;;;-1:-1:-1::0;;;;;;7341:17:0;;::::1;::::0;;;::::1;::::0;;7122:244::o;6079:115::-;6175:10;6079:115;:::o;10408:346::-;-1:-1:-1;;;;;10510:19:0;;10502:68;;;;-1:-1:-1;;;10502:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10589:21:0;;10581:68;;;;-1:-1:-1;;;10581:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10662:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;10714:32;;;;;10692:6;;10714:32;:::i;:::-;;;;;;;;10408:346;;;:::o;9233:479::-;-1:-1:-1;;;;;9339:20:0;;9331:70;;;;-1:-1:-1;;;9331:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;9420:23:0;;9412:71;;;;-1:-1:-1;;;9412:71:0;;;;;;;:::i;:::-;9516;9538:6;9516:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9516:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;9496:17:0;;;:9;:17;;;;;;;;;;;:91;;;;9621:20;;;;;;;:32;;9646:6;9621:24;:32::i;:::-;-1:-1:-1;;;;;9598:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;9669:35;;;;;;;;;;9697:6;;9669:35;:::i;1095:190::-;1181:7;1217:12;1209:6;;;;1201:29;;;;-1:-1:-1;;;1201:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;1253:5:0;;;1095:190::o;9720:316::-;-1:-1:-1;;;;;9804:21:0;;9796:65;;;;-1:-1:-1;;;9796:65:0;;;;;;;:::i;:::-;9889:12;;:24;;9906:6;9889:16;:24::i;:::-;9874:12;:39;-1:-1:-1;;;;;9945:18:0;;:9;:18;;;;;;;;;;;:30;;9968:6;9945:22;:30::i;:::-;-1:-1:-1;;;;;9924:18:0;;:9;:18;;;;;;;;;;;:51;;;;9991:37;;9924:18;;:9;9991:37;;;;10021:6;;9991:37;:::i;:::-;;;;;;;;9720:316;;:::o;764:179::-;822:7;854:5;;;878:6;;;;870:46;;;;-1:-1:-1;;;870:46:0;;;;;;;:::i;:::-;934:1;764:179;-1:-1:-1;;;764:179:0:o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:1:o;1294:203::-;-1:-1:-1;;;;;1458:32:1;;;;1440:51;;1428:2;1413:18;;1395:102::o;1502:187::-;1667:14;;1660:22;1642:41;;1630:2;1615:18;;1597:92::o;1694:603::-;;1835:2;1864;1853:9;1846:21;1896:6;1890:13;1939:6;1934:2;1923:9;1919:18;1912:34;1964:4;1977:140;1991:6;1988:1;1985:13;1977:140;;;2086:14;;;2082:23;;2076:30;2052:17;;;2071:2;2048:26;2041:66;2006:10;;1977:140;;;2135:6;2132:1;2129:13;2126:2;;;2205:4;2200:2;2191:6;2180:9;2176:22;2172:31;2165:45;2126:2;-1:-1:-1;2281:2:1;2260:15;-1:-1:-1;;2256:29:1;2241:45;;;;2288:2;2237:54;;1815:482;-1:-1:-1;;;1815:482:1:o;2302:399::-;2504:2;2486:21;;;2543:2;2523:18;;;2516:30;2582:34;2577:2;2562:18;;2555:62;-1:-1:-1;;;2648:2:1;2633:18;;2626:33;2691:3;2676:19;;2476:225::o;2706:402::-;2908:2;2890:21;;;2947:2;2927:18;;;2920:30;2986:34;2981:2;2966:18;;2959:62;-1:-1:-1;;;3052:2:1;3037:18;;3030:36;3098:3;3083:19;;2880:228::o;3113:398::-;3315:2;3297:21;;;3354:2;3334:18;;;3327:30;3393:34;3388:2;3373:18;;3366:62;-1:-1:-1;;;3459:2:1;3444:18;;3437:32;3501:3;3486:19;;3287:224::o;3516:351::-;3718:2;3700:21;;;3757:2;3737:18;;;3730:30;3796:29;3791:2;3776:18;;3769:57;3858:2;3843:18;;3690:177::o;3872:356::-;4074:2;4056:21;;;4093:18;;;4086:30;4152:34;4147:2;4132:18;;4125:62;4219:2;4204:18;;4046:182::o;4233:401::-;4435:2;4417:21;;;4474:2;4454:18;;;4447:30;4513:34;4508:2;4493:18;;4486:62;-1:-1:-1;;;4579:2:1;4564:18;;4557:35;4624:3;4609:19;;4407:227::o;4639:400::-;4841:2;4823:21;;;4880:2;4860:18;;;4853:30;4919:34;4914:2;4899:18;;4892:62;-1:-1:-1;;;4985:2:1;4970:18;;4963:34;5029:3;5014:19;;4813:226::o;5044:355::-;5246:2;5228:21;;;5285:2;5265:18;;;5258:30;5324:33;5319:2;5304:18;;5297:61;5390:2;5375:18;;5218:181::o;5404:177::-;5550:25;;;5538:2;5523:18;;5505:76::o;5586:184::-;5758:4;5746:17;;;;5728:36;;5716:2;5701:18;;5683:87::o

Swarm Source

ipfs://efabf8ef356aaaf8715ef55e2016d745330ea54f43f8cea888615406c37db15c
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.