Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor

Gleiches ausblenden

Zeilenumbruch aus

Ansicht

Vergleichsgenauigkeit

Syntaxhervorhebung

Diffchecker Desktop Der sicherste Weg, Diffchecker zu nutzen. Hol dir die Desktop-App: Deine Diffs verlassen nie deinen Computer!Desktop holen

VaultSushiFlipToFlip.sol

Erstellt vor 5 JahrenDiff läuft nie ab

0 Entfernungen

Zeilen
Gesamt
Entfernt

Zeichen
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

310 Zeilen

17 Hinzufügungen

Zeilen
Gesamt
Hinzugefügt

Zeichen
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

327 Zeilen

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

pragma experimental ABIEncoderV2;

___ _ _

| _ )_ _ _ _ _ _ _ _ | | | |

| _ \ || | ' \| ' \ || | |_| |_|

|___/\_,_|_||_|_||_\_, | (_) (_)

|__/

* MIT License

* ===========

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

* The above copyright notice and this permission notice shall be included in all

* copies or substantial portions of the Software.

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

import "@pancakeswap/pancake-swap-lib/contracts/token/BEP20/SafeBEP20.sol";

import "@openzeppelin/contracts/math/Math.sol";

import {PoolConstant} from "../library/PoolConstant.sol";

import "../interfaces/IUniswapV2Pair.sol";

import "../interfaces/IUniswapV2Factory.sol";

import "../interfaces/IStrategy.sol";

import "../interfaces/ISushiMiniChefV2.sol";

import "../interfaces/IZap.sol";

import "./VaultController.sol";

contract VaultSushiFlipToFlip is VaultController, IStrategy {

using SafeBEP20 for IBEP20;

using SafeMath for uint256;

/* ========== CONSTANTS ============= */

IBEP20 private constant SUSHI = IBEP20(0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a);

IBEP20 private constant WMATIC = IBEP20(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);

PoolConstant.PoolTypes public constant override poolType = PoolConstant.PoolTypes.FlipToFlip;

ISushiMiniChefV2 private constant SUSHI_MINI_CHEF = ISushiMiniChefV2(0x0769fd68dFb93167989C6f7254cd0D766Fb2841F);

IZap private constant zap = IZap(0x93bCE7E49E26AF0f87b74583Ba6551DF5E4867B7);

uint private constant DUST = 1000;

/* ========== STATE VARIABLES ========== */

uint public override pid;

address private _token0;

address private _token1;

uint public totalShares;

mapping (address => uint) private _shares;

mapping (address => uint) private _principal;

mapping (address => uint) private _depositedAt;

uint public sushiHarvested;

uint public wmaticHarvested;

uint public totalBalance;

/* ========== MODIFIER ========== */

modifier updateSushiHarvested {

uint _before = SUSHI.balanceOf(address(this));

uint _beforeWmatic = WMATIC.balanceOf(address(this));

uint _after = SUSHI.balanceOf(address(this));

uint _afterWmatic = WMATIC.balanceOf(address(this));

sushiHarvested = sushiHarvested.add(_after).sub(_before);

wmaticHarvested = wmaticHarvested.add(_afterWmatic).sub(_beforeWmatic);

}

/* ========== INITIALIZER ========== */

function initialize(uint _pid, address _token) external initializer {

__VaultController_init(IBEP20(_token));

_stakingToken.safeApprove(address(SUSHI_MINI_CHEF), uint(- 1));

pid = _pid;

SUSHI.safeApprove(address(zap), uint(- 1));

WMATIC.safeApprove(address(zap), uint(- 1));

}

/* ========== VIEW FUNCTIONS ========== */

function totalSupply() external view override returns (uint) {

return totalShares;

}

function balance() public view override returns (uint amount) {

(amount,) = SUSHI_MINI_CHEF.userInfo(pid, address(this));

amount = Math.min(amount, totalBalance);

}

function balanceOf(address account) public view override returns(uint) {

if (totalShares == 0) return 0;

return balance().mul(sharesOf(account)).div(totalShares);

}

function withdrawableBalanceOf(address account) public view override returns (uint) {

return balanceOf(account);

}

function sharesOf(address account) public view override returns (uint) {

return _shares[account];

}

function principalOf(address account) public view override returns (uint) {

return _principal[account];

}

function earned(address account) public view override returns (uint) {

if (balanceOf(account) >= principalOf(account) + DUST) {

return balanceOf(account).sub(principalOf(account));

} else {

return 0;

}

function depositedAt(address account) external view override returns (uint) {

return _depositedAt[account];

}

function rewardsToken() external view override returns (address) {

return address(_stakingToken);

}

function priceShare() external view override returns(uint) {

if (totalShares == 0) return 1e18;

return balance().mul(1e18).div(totalShares);

}

/* ========== MUTATIVE FUNCTIONS ========== */

function deposit(uint _amount) public override {

_depositTo(_amount, msg.sender);

}

function depositAll() external override {

deposit(_stakingToken.balanceOf(msg.sender));

}

function withdrawAll() external override {

uint amount = balanceOf(msg.sender);

uint principal = principalOf(msg.sender);

uint depositTimestamp = _depositedAt[msg.sender];

totalBalance = totalBalance.sub(amount);

totalShares = totalShares.sub(_shares[msg.sender]);

delete _shares[msg.sender];

delete _principal[msg.sender];

delete _depositedAt[msg.sender];

amount = _withdrawTokenWithCorrection(amount);

uint profit = amount > principal ? amount.sub(principal) : 0;

uint withdrawalFee = canMint() ? _minter.withdrawalFee(principal, depositTimestamp) : 0;

uint performanceFee = canMint() ? _minter.performanceFee(profit) : 0;

if (withdrawalFee.add(performanceFee) > DUST) {

_minter.mintForV2(address(_stakingToken), withdrawalFee, performanceFee, msg.sender, depositTimestamp);

if (performanceFee > 0) {

emit ProfitPaid(msg.sender, profit, performanceFee);

}

amount = amount.sub(withdrawalFee).sub(performanceFee);

}

_stakingToken.safeTransfer(msg.sender, amount);

emit Withdrawn(msg.sender, amount, withdrawalFee);

}

function harvest() external override onlyKeeper {

_harvest();

uint before = _stakingToken.balanceOf(address(this));

zap.zapInToken(address(SUSHI), sushiHarvested, address(_stakingToken));

zap.zapInToken(address(WMATIC), wmaticHarvested, address(_stakingToken));

uint harvested = _stakingToken.balanceOf(address(this)).sub(before);

totalBalance = totalBalance.add(harvested);

SUSHI_MINI_CHEF.deposit(pid, harvested, address(this));

emit Harvested(harvested);

sushiHarvested = 0;

wmaticHarvested = 0;

}

function _harvest() private updateSushiHarvested {

SUSHI_MINI_CHEF.harvest(pid, address(this));

}

function withdraw(uint shares) external override onlyWhitelisted {

uint amount = balance().mul(shares).div(totalShares);

totalBalance = totalBalance.sub(amount);

totalShares = totalShares.sub(shares);

_shares[msg.sender] = _shares[msg.sender].sub(shares);

amount = _withdrawTokenWithCorrection(amount);

_stakingToken.safeTransfer(msg.sender, amount);

emit Withdrawn(msg.sender, amount, 0);

}

// @dev underlying only + withdrawal fee + no perf fee

function withdrawUnderlying(uint _amount) external {

uint amount = Math.min(_amount, _principal[msg.sender]);

uint shares = Math.min(amount.mul(totalShares).div(balance()), _shares[msg.sender]);

totalBalance = totalBalance.sub(amount);

totalShares = totalShares.sub(shares);

_shares[msg.sender] = _shares[msg.sender].sub(shares);

_principal[msg.sender] = _principal[msg.sender].sub(amount);

amount = _withdrawTokenWithCorrection(amount);

uint depositTimestamp = _depositedAt[msg.sender];

uint withdrawalFee = canMint() ? _minter.withdrawalFee(amount, depositTimestamp) : 0;

if (withdrawalFee > DUST) {

_minter.mintForV2(address(_stakingToken), withdrawalFee, 0, msg.sender, depositTimestamp);

amount = amount.sub(withdrawalFee);

}

_stakingToken.safeTransfer(msg.sender, amount);

emit Withdrawn(msg.sender, amount, withdrawalFee);

}

// @dev profits only (underlying + bunny) + no withdraw fee + perf fee

function getReward() external override {

uint amount = earned(msg.sender);

uint shares = Math.min(amount.mul(totalShares).div(balance()), _shares[msg.sender]);

totalBalance = totalBalance.sub(amount);

totalShares = totalShares.sub(shares);

_shares[msg.sender] = _shares[msg.sender].sub(shares);

_cleanupIfDustShares();

amount = _withdrawTokenWithCorrection(amount);

uint depositTimestamp = _depositedAt[msg.sender];

uint performanceFee = canMint() ? _minter.performanceFee(amount) : 0;

if (performanceFee > DUST) {

_minter.mintForV2(address(_stakingToken), 0, performanceFee, msg.sender, depositTimestamp);

amount = amount.sub(performanceFee);

}

_stakingToken.safeTransfer(msg.sender, amount);

emit ProfitPaid(msg.sender, amount, performanceFee);

}

/* ========== PRIVATE FUNCTIONS ========== */

function _depositTo(uint _amount, address _to) private notPaused updateSushiHarvested {

uint _pool = balance();

uint _before = _stakingToken.balanceOf(address(this));

_stakingToken.safeTransferFrom(msg.sender, address(this), _amount);

uint _after = _stakingToken.balanceOf(address(this));

_amount = _after.sub(_before); // Additional check for deflationary tokens

uint shares = 0;

if (totalShares == 0) {

shares = _amount;

} else {

shares = (_amount.mul(totalShares)).div(_pool);

}

totalBalance = totalBalance.add(_amount);

totalShares = totalShares.add(shares);

_shares[_to] = _shares[_to].add(shares);

_principal[_to] = _principal[_to].add(_amount);

_depositedAt[_to] = block.timestamp;

SUSHI_MINI_CHEF.deposit(pid, _amount, address(this));

emit Deposited(_to, _amount);

}

function _withdrawTokenWithCorrection(uint amount) private updateSushiHarvested returns (uint) {

uint before = _stakingToken.balanceOf(address(this));

SUSHI_MINI_CHEF.withdraw(pid, amount, address(this));

return _stakingToken.balanceOf(address(this)).sub(before);

}

function _cleanupIfDustShares() private {

uint shares = _shares[msg.sender];

if (shares > 0 && shares < DUST) {

totalShares = totalShares.sub(shares);

delete _shares[msg.sender];

}

/* ========== SALVAGE PURPOSE ONLY ========== */

// @dev stakingToken must not remain balance in this contract. So dev should salvage staking token transferred by mistake.

function recoverToken(address token, uint amount) external override onlyOwner {

if (token == address(SUSHI)) {

uint sushiBalance = SUSHI.balanceOf(address(this));

require(amount <= sushiBalance.sub(sushiHarvested), "VaultFlipToFlip: cannot recover lp's harvested sushi");

}

if (token == address(WMATIC)){

uint wmaticBalance = WMATIC.balanceOf(address(this));

require(amount <= wmaticBalance.sub(wmaticHarvested));

}

IBEP20(token).safeTransfer(owner(), amount);

emit Recovered(token, amount);

}

function setTotalBalance() external onlyOwner {

require(totalBalance == 0, "VaultSushiFlipToFlip: can't update totalBalance");

(uint amount,) = SUSHI_MINI_CHEF.userInfo(pid, address(this));

totalBalance = amount;

}

Gespeicherte Diffs

Originaltext

Datei öffnen

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

/*
  ___                      _   _
 | _ )_  _ _ _  _ _ _  _  | | | |
 | _ \ || | ' \| ' \ || | |_| |_|
 |___/\_,_|_||_|_||_\_, | (_) (_)
                    |__/

*
* MIT License
* ===========
*
* Copyright (c) 2020 BunnyFinance
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*/

import "@pancakeswap/pancake-swap-lib/contracts/token/BEP20/SafeBEP20.sol";
import "@openzeppelin/contracts/math/Math.sol";

import {PoolConstant} from "../library/PoolConstant.sol";
import "../interfaces/IUniswapV2Pair.sol";
import "../interfaces/IUniswapV2Factory.sol";
import "../interfaces/IStrategy.sol";
import "../interfaces/ISushiMiniChefV2.sol";
import "../interfaces/IZap.sol";

import "./VaultController.sol";

contract VaultSushiFlipToFlip is VaultController, IStrategy {
    using SafeBEP20 for IBEP20;
    using SafeMath for uint256;

/* ========== CONSTANTS ============= */

IBEP20 private constant SUSHI = IBEP20(0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a);
    IBEP20 private constant WMATIC = IBEP20(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
    PoolConstant.PoolTypes public constant override poolType = PoolConstant.PoolTypes.FlipToFlip;
    ISushiMiniChefV2 private constant SUSHI_MINI_CHEF = ISushiMiniChefV2(0x0769fd68dFb93167989C6f7254cd0D766Fb2841F);
    IZap private constant zap = IZap(0x93bCE7E49E26AF0f87b74583Ba6551DF5E4867B7);

uint private constant DUST = 1000;

/* ========== STATE VARIABLES ========== */

uint public override pid;

address private _token0;
    address private _token1;

uint public totalShares;
    mapping (address => uint) private _shares;
    mapping (address => uint) private _principal;
    mapping (address => uint) private _depositedAt;

uint public sushiHarvested;
    uint public wmaticHarvested;

/* ========== MODIFIER ========== */

modifier updateSushiHarvested {
        uint _before = SUSHI.balanceOf(address(this));
        uint _beforeWmatic = WMATIC.balanceOf(address(this));
        _;
        uint _after = SUSHI.balanceOf(address(this));
        uint _afterWmatic = WMATIC.balanceOf(address(this));
        sushiHarvested = sushiHarvested.add(_after).sub(_before);
        wmaticHarvested = wmaticHarvested.add(_afterWmatic).sub(_beforeWmatic);
    }

/* ========== INITIALIZER ========== */

function initialize(uint _pid, address _token) external initializer {
        __VaultController_init(IBEP20(_token));
        _stakingToken.safeApprove(address(SUSHI_MINI_CHEF), uint(- 1));
        pid = _pid;

SUSHI.safeApprove(address(zap), uint(- 1));
        WMATIC.safeApprove(address(zap), uint(- 1));
    }

/* ========== VIEW FUNCTIONS ========== */

function totalSupply() external view override returns (uint) {
        return totalShares;
    }

function balance() public view override returns (uint amount) {
        (amount,) = SUSHI_MINI_CHEF.userInfo(pid, address(this));
    }

function balanceOf(address account) public view override returns(uint) {
        if (totalShares == 0) return 0;
        return balance().mul(sharesOf(account)).div(totalShares);
    }

function withdrawableBalanceOf(address account) public view override returns (uint) {
        return balanceOf(account);
    }

function sharesOf(address account) public view override returns (uint) {
        return _shares[account];
    }

function principalOf(address account) public view override returns (uint) {
        return _principal[account];
    }

function earned(address account) public view override returns (uint) {
        if (balanceOf(account) >= principalOf(account) + DUST) {
            return balanceOf(account).sub(principalOf(account));
        } else {
            return 0;
        }
    }

function depositedAt(address account) external view override returns (uint) {
        return _depositedAt[account];
    }

function rewardsToken() external view override returns (address) {
        return address(_stakingToken);
    }

function priceShare() external view override returns(uint) {
        if (totalShares == 0) return 1e18;
        return balance().mul(1e18).div(totalShares);
    }

/* ========== MUTATIVE FUNCTIONS ========== */

function deposit(uint _amount) public override {
        _depositTo(_amount, msg.sender);
    }

function depositAll() external override {
        deposit(_stakingToken.balanceOf(msg.sender));
    }

function withdrawAll() external override {
        uint amount = balanceOf(msg.sender);
        uint principal = principalOf(msg.sender);
        uint depositTimestamp = _depositedAt[msg.sender];

totalShares = totalShares.sub(_shares[msg.sender]);
        delete _shares[msg.sender];
        delete _principal[msg.sender];
        delete _depositedAt[msg.sender];

amount = _withdrawTokenWithCorrection(amount);
        uint profit = amount > principal ? amount.sub(principal) : 0;

uint withdrawalFee = canMint() ? _minter.withdrawalFee(principal, depositTimestamp) : 0;
        uint performanceFee = canMint() ? _minter.performanceFee(profit) : 0;
        if (withdrawalFee.add(performanceFee) > DUST) {
            _minter.mintForV2(address(_stakingToken), withdrawalFee, performanceFee, msg.sender, depositTimestamp);

if (performanceFee > 0) {
                emit ProfitPaid(msg.sender, profit, performanceFee);
            }
            amount = amount.sub(withdrawalFee).sub(performanceFee);
        }

_stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, withdrawalFee);
    }

function harvest() external override onlyKeeper {
        _harvest();

uint before = _stakingToken.balanceOf(address(this));
        zap.zapInToken(address(SUSHI), sushiHarvested, address(_stakingToken));
        zap.zapInToken(address(WMATIC), wmaticHarvested, address(_stakingToken));
        uint harvested = _stakingToken.balanceOf(address(this)).sub(before);

SUSHI_MINI_CHEF.deposit(pid, harvested, address(this));
        emit Harvested(harvested);

sushiHarvested = 0;
        wmaticHarvested = 0;
    }

function _harvest() private updateSushiHarvested {
        SUSHI_MINI_CHEF.harvest(pid, address(this));
    }

function withdraw(uint shares) external override onlyWhitelisted {
        uint amount = balance().mul(shares).div(totalShares);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);

amount = _withdrawTokenWithCorrection(amount);
        _stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, 0);
    }

// @dev underlying only + withdrawal fee + no perf fee
    function withdrawUnderlying(uint _amount) external {
        uint amount = Math.min(_amount, _principal[msg.sender]);
        uint shares = Math.min(amount.mul(totalShares).div(balance()), _shares[msg.sender]);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);
        _principal[msg.sender] = _principal[msg.sender].sub(amount);

amount = _withdrawTokenWithCorrection(amount);
        uint depositTimestamp = _depositedAt[msg.sender];
        uint withdrawalFee = canMint() ? _minter.withdrawalFee(amount, depositTimestamp) : 0;
        if (withdrawalFee > DUST) {
            _minter.mintForV2(address(_stakingToken), withdrawalFee, 0, msg.sender, depositTimestamp);
            amount = amount.sub(withdrawalFee);
        }

_stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, withdrawalFee);
    }

// @dev profits only (underlying + bunny) + no withdraw fee + perf fee
    function getReward() external override {
        uint amount = earned(msg.sender);
        uint shares = Math.min(amount.mul(totalShares).div(balance()), _shares[msg.sender]);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);
        _cleanupIfDustShares();

amount = _withdrawTokenWithCorrection(amount);
        uint depositTimestamp = _depositedAt[msg.sender];
        uint performanceFee = canMint() ? _minter.performanceFee(amount) : 0;
        if (performanceFee > DUST) {
            _minter.mintForV2(address(_stakingToken), 0, performanceFee, msg.sender, depositTimestamp);
            amount = amount.sub(performanceFee);
        }

_stakingToken.safeTransfer(msg.sender, amount);
        emit ProfitPaid(msg.sender, amount, performanceFee);
    }

/* ========== PRIVATE FUNCTIONS ========== */

function _depositTo(uint _amount, address _to) private notPaused updateSushiHarvested {
        uint _pool = balance();
        uint _before = _stakingToken.balanceOf(address(this));
        _stakingToken.safeTransferFrom(msg.sender, address(this), _amount);
        uint _after = _stakingToken.balanceOf(address(this));
        _amount = _after.sub(_before); // Additional check for deflationary tokens
        uint shares = 0;
        if (totalShares == 0) {
            shares = _amount;
        } else {
            shares = (_amount.mul(totalShares)).div(_pool);
        }

totalShares = totalShares.add(shares);
        _shares[_to] = _shares[_to].add(shares);
        _principal[_to] = _principal[_to].add(_amount);
        _depositedAt[_to] = block.timestamp;

SUSHI_MINI_CHEF.deposit(pid, _amount, address(this));
        emit Deposited(_to, _amount);
    }

function _withdrawTokenWithCorrection(uint amount) private updateSushiHarvested returns (uint) {
        uint before = _stakingToken.balanceOf(address(this));
        SUSHI_MINI_CHEF.withdraw(pid, amount, address(this));
        return _stakingToken.balanceOf(address(this)).sub(before);
    }

function _cleanupIfDustShares() private {
        uint shares = _shares[msg.sender];
        if (shares > 0 && shares < DUST) {
            totalShares = totalShares.sub(shares);
            delete _shares[msg.sender];
        }
    }

/* ========== SALVAGE PURPOSE ONLY ========== */

// @dev stakingToken must not remain balance in this contract. So dev should salvage staking token transferred by mistake.
    function recoverToken(address token, uint amount) external override onlyOwner {
        if (token == address(SUSHI)) {
            uint sushiBalance = SUSHI.balanceOf(address(this));
            require(amount <= sushiBalance.sub(sushiHarvested), "VaultFlipToFlip: cannot recover lp's harvested sushi");
        }
        if (token == address(WMATIC)){
            uint wmaticBalance = WMATIC.balanceOf(address(this));
            require(amount <= wmaticBalance.sub(wmaticHarvested));
        }

IBEP20(token).safeTransfer(owner(), amount);
        emit Recovered(token, amount);
    }
}

Bearbeitung

Datei öffnen

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

/*
  ___                      _   _
 | _ )_  _ _ _  _ _ _  _  | | | |
 | _ \ || | ' \| ' \ || | |_| |_|
 |___/\_,_|_||_|_||_\_, | (_) (_)
                    |__/

import "@pancakeswap/pancake-swap-lib/contracts/token/BEP20/SafeBEP20.sol";
import "@openzeppelin/contracts/math/Math.sol";

import "./VaultController.sol";

contract VaultSushiFlipToFlip is VaultController, IStrategy {
    using SafeBEP20 for IBEP20;
    using SafeMath for uint256;

/* ========== CONSTANTS ============= */

uint private constant DUST = 1000;

/* ========== STATE VARIABLES ========== */

uint public override pid;

address private _token0;
    address private _token1;

uint public totalShares;
    mapping (address => uint) private _shares;
    mapping (address => uint) private _principal;
    mapping (address => uint) private _depositedAt;

uint public sushiHarvested;
    uint public wmaticHarvested;

uint public totalBalance;

/* ========== MODIFIER ========== */

/* ========== INITIALIZER ========== */

SUSHI.safeApprove(address(zap), uint(- 1));
        WMATIC.safeApprove(address(zap), uint(- 1));
    }

/* ========== VIEW FUNCTIONS ========== */

function totalSupply() external view override returns (uint) {
        return totalShares;
    }

function balance() public view override returns (uint amount) {
        (amount,) = SUSHI_MINI_CHEF.userInfo(pid, address(this));
        amount = Math.min(amount, totalBalance);
    }

function balanceOf(address account) public view override returns(uint) {
        if (totalShares == 0) return 0;
        return balance().mul(sharesOf(account)).div(totalShares);
    }

function withdrawableBalanceOf(address account) public view override returns (uint) {
        return balanceOf(account);
    }

function sharesOf(address account) public view override returns (uint) {
        return _shares[account];
    }

function principalOf(address account) public view override returns (uint) {
        return _principal[account];
    }

function depositedAt(address account) external view override returns (uint) {
        return _depositedAt[account];
    }

function rewardsToken() external view override returns (address) {
        return address(_stakingToken);
    }

function priceShare() external view override returns(uint) {
        if (totalShares == 0) return 1e18;
        return balance().mul(1e18).div(totalShares);
    }

/* ========== MUTATIVE FUNCTIONS ========== */

function deposit(uint _amount) public override {
        _depositTo(_amount, msg.sender);
    }

function depositAll() external override {
        deposit(_stakingToken.balanceOf(msg.sender));
    }

function withdrawAll() external override {
        uint amount = balanceOf(msg.sender);
        uint principal = principalOf(msg.sender);
        uint depositTimestamp = _depositedAt[msg.sender];

totalBalance = totalBalance.sub(amount);
        totalShares = totalShares.sub(_shares[msg.sender]);
        delete _shares[msg.sender];
        delete _principal[msg.sender];
        delete _depositedAt[msg.sender];

amount = _withdrawTokenWithCorrection(amount);
        uint profit = amount > principal ? amount.sub(principal) : 0;

if (performanceFee > 0) {
                emit ProfitPaid(msg.sender, profit, performanceFee);
            }
            amount = amount.sub(withdrawalFee).sub(performanceFee);
        }

_stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, withdrawalFee);
    }

function harvest() external override onlyKeeper {
        _harvest();

totalBalance = totalBalance.add(harvested);
        SUSHI_MINI_CHEF.deposit(pid, harvested, address(this));
        emit Harvested(harvested);

sushiHarvested = 0;
        wmaticHarvested = 0;
    }

function _harvest() private updateSushiHarvested {
        SUSHI_MINI_CHEF.harvest(pid, address(this));
    }

function withdraw(uint shares) external override onlyWhitelisted {
        uint amount = balance().mul(shares).div(totalShares);
        totalBalance = totalBalance.sub(amount);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);

amount = _withdrawTokenWithCorrection(amount);
        _stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, 0);
    }

totalBalance = totalBalance.sub(amount);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);
        _principal[msg.sender] = _principal[msg.sender].sub(amount);

_stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, withdrawalFee);
    }

// @dev profits only (underlying + bunny) + no withdraw fee + perf fee
    function getReward() external override {
        uint amount = earned(msg.sender);
        uint shares = Math.min(amount.mul(totalShares).div(balance()), _shares[msg.sender]);
        totalBalance = totalBalance.sub(amount);
        totalShares = totalShares.sub(shares);
        _shares[msg.sender] = _shares[msg.sender].sub(shares);
        _cleanupIfDustShares();

_stakingToken.safeTransfer(msg.sender, amount);
        emit ProfitPaid(msg.sender, amount, performanceFee);
    }

/* ========== PRIVATE FUNCTIONS ========== */

totalBalance = totalBalance.add(_amount);
        totalShares = totalShares.add(shares);
        _shares[_to] = _shares[_to].add(shares);
        _principal[_to] = _principal[_to].add(_amount);
        _depositedAt[_to] = block.timestamp;

SUSHI_MINI_CHEF.deposit(pid, _amount, address(this));
        emit Deposited(_to, _amount);
    }

/* ========== SALVAGE PURPOSE ONLY ========== */

IBEP20(token).safeTransfer(owner(), amount);
        emit Recovered(token, amount);
    }

function setTotalBalance() external onlyOwner {
        require(totalBalance == 0, "VaultSushiFlipToFlip: can't update totalBalance");
        (uint amount,) = SUSHI_MINI_CHEF.userInfo(pid, address(this));
        totalBalance = amount;
    }

}