Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIXED

// File @boringcrypto/boring-solidity/contracts/libraries/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
        require((c = a + b) >= b, "BoringMath: Add Overflow");
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
        require((c = a - b) <= a, "BoringMath: Underflow");
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
    }

    function to128(uint256 a) internal pure returns (uint128 c) {
        require(a <= uint128(-1), "BoringMath: uint128 Overflow");
        c = uint128(a);
    }

    function to64(uint256 a) internal pure returns (uint64 c) {
        require(a <= uint64(-1), "BoringMath: uint64 Overflow");
        c = uint64(a);
    }

    function to32(uint256 a) internal pure returns (uint32 c) {
        require(a <= uint32(-1), "BoringMath: uint32 Overflow");
        c = uint32(a);
    }
}

/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint128.
library BoringMath128 {
    function add(uint128 a, uint128 b) internal pure returns (uint128 c) {
        require((c = a + b) >= b, "BoringMath: Add Overflow");
    }

    function sub(uint128 a, uint128 b) internal pure returns (uint128 c) {
        require((c = a - b) <= a, "BoringMath: Underflow");
    }
}

/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint64.
library BoringMath64 {
    function add(uint64 a, uint64 b) internal pure returns (uint64 c) {
        require((c = a + b) >= b, "BoringMath: Add Overflow");
    }

    function sub(uint64 a, uint64 b) internal pure returns (uint64 c) {
        require((c = a - b) <= a, "BoringMath: Underflow");
    }
}

/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint32.
library BoringMath32 {
    function add(uint32 a, uint32 b) internal pure returns (uint32 c) {
        require((c = a + b) >= b, "BoringMath: Add Overflow");
    }

    function sub(uint32 a, uint32 b) internal pure returns (uint32 c) {
        require((c = a - b) <= a, "BoringMath: Underflow");
    }
}

// File @boringcrypto/boring-solidity/contracts/interfaces/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, 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);

    /// @notice EIP 2612
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// File @boringcrypto/boring-solidity/contracts/libraries/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

// solhint-disable avoid-low-level-calls

library BoringERC20 {
    bytes4 private constant SIG_SYMBOL = 0x95d89b41; // symbol()
    bytes4 private constant SIG_NAME = 0x06fdde03; // name()
    bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals()
    bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
    bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)

    function returnDataToString(bytes memory data) internal pure returns (string memory) {
        if (data.length >= 64) {
            return abi.decode(data, (string));
        } else if (data.length == 32) {
            uint8 i = 0;
            while(i < 32 && data[i] != 0) {
                i++;
            }
            bytes memory bytesArray = new bytes(i);
            for (i = 0; i < 32 && data[i] != 0; i++) {
                bytesArray[i] = data[i];
            }
            return string(bytesArray);
        } else {
            return "???";
        }
    }

    /// @notice Provides a safe ERC20.symbol version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token symbol.
    function safeSymbol(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_SYMBOL));
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.name version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token name.
    function safeName(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_NAME));
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value.
    /// @param token The address of the ERC-20 token contract.
    /// @return (uint8) Token decimals.
    function safeDecimals(IERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_DECIMALS));
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }

    /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransfer(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
    }

    /// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param from Transfer tokens from.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
    }
}

// File @boringcrypto/boring-solidity/contracts/libraries/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

struct Rebase {
    uint128 elastic;
    uint128 base;
}

/// @notice A rebasing library using overflow-/underflow-safe math.
library RebaseLibrary {
    using BoringMath for uint256;
    using BoringMath128 for uint128;

    /// @notice Calculates the base value in relationship to `elastic` and `total`.
    function toBase(
        Rebase memory total,
        uint256 elastic,
        bool roundUp
    ) internal pure returns (uint256 base) {
        if (total.elastic == 0) {
            base = elastic;
        } else {
            base = elastic.mul(total.base) / total.elastic;
            if (roundUp && base.mul(total.elastic) / total.base < elastic) {
                base = base.add(1);
            }
        }
    }

    /// @notice Calculates the elastic value in relationship to `base` and `total`.
    function toElastic(
        Rebase memory total,
        uint256 base,
        bool roundUp
    ) internal pure returns (uint256 elastic) {
        if (total.base == 0) {
            elastic = base;
        } else {
            elastic = base.mul(total.elastic) / total.base;
            if (roundUp && elastic.mul(total.base) / total.elastic < base) {
                elastic = elastic.add(1);
            }
        }
    }

    /// @notice Add `elastic` to `total` and doubles `total.base`.
    /// @return (Rebase) The new total.
    /// @return base in relationship to `elastic`.
    function add(
        Rebase memory total,
        uint256 elastic,
        bool roundUp
    ) internal pure returns (Rebase memory, uint256 base) {
        base = toBase(total, elastic, roundUp);
        total.elastic = total.elastic.add(elastic.to128());
        total.base = total.base.add(base.to128());
        return (total, base);
    }

    /// @notice Sub `base` from `total` and update `total.elastic`.
    /// @return (Rebase) The new total.
    /// @return elastic in relationship to `base`.
    function sub(
        Rebase memory total,
        uint256 base,
        bool roundUp
    ) internal pure returns (Rebase memory, uint256 elastic) {
        elastic = toElastic(total, base, roundUp);
        total.elastic = total.elastic.sub(elastic.to128());
        total.base = total.base.sub(base.to128());
        return (total, elastic);
    }

    /// @notice Add `elastic` and `base` to `total`.
    function add(
        Rebase memory total,
        uint256 elastic,
        uint256 base
    ) internal pure returns (Rebase memory) {
        total.elastic = total.elastic.add(elastic.to128());
        total.base = total.base.add(base.to128());
        return total;
    }

    /// @notice Subtract `elastic` and `base` to `total`.
    function sub(
        Rebase memory total,
        uint256 elastic,
        uint256 base
    ) internal pure returns (Rebase memory) {
        total.elastic = total.elastic.sub(elastic.to128());
        total.base = total.base.sub(base.to128());
        return total;
    }

    /// @notice Add `elastic` to `total` and update storage.
    /// @return newElastic Returns updated `elastic`.
    function addElastic(Rebase storage total, uint256 elastic) internal returns (uint256 newElastic) {
        newElastic = total.elastic = total.elastic.add(elastic.to128());
    }

    /// @notice Subtract `elastic` from `total` and update storage.
    /// @return newElastic Returns updated `elastic`.
    function subElastic(Rebase storage total, uint256 elastic) internal returns (uint256 newElastic) {
        newElastic = total.elastic = total.elastic.sub(elastic.to128());
    }
}

// File @sushiswap/bentobox-sdk/contracts/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

interface IBatchFlashBorrower {
    function onBatchFlashLoan(
        address sender,
        IERC20[] calldata tokens,
        uint256[] calldata amounts,
        uint256[] calldata fees,
        bytes calldata data
    ) external;
}

// File @sushiswap/bentobox-sdk/contracts/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

interface IFlashBorrower {
    function onFlashLoan(
        address sender,
        IERC20 token,
        uint256 amount,
        uint256 fee,
        bytes calldata data
    ) external;
}

// File @sushiswap/bentobox-sdk/contracts/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;

interface IStrategy {
    // Send the assets to the Strategy and call skim to invest them
    function skim(uint256 amount) external;

    // Harvest any profits made converted to the asset and pass them to the caller
    function harvest(uint256 balance, address sender) external returns (int256 amountAdded);

    // Withdraw assets. The returned amount can differ from the requested amount due to rounding.
    // The actualAmount should be very close to the amount. The difference should NOT be used to report a loss. That's what harvest is for.
    function withdraw(uint256 amount) external returns (uint256 actualAmount);

    // Withdraw all assets in the safest way possible. This shouldn't fail.
    function exit(uint256 balance) external returns (int256 amountAdded);
}

// File @sushiswap/bentobox-sdk/contracts/[email protected]
// License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;





interface IBentoBoxV1 {
    event LogDeploy(address indexed masterContract, bytes data, address indexed cloneAddress);
    event LogDeposit(address indexed token, address indexed from, address indexed to, uint256 amount, uint256 share);
    event LogFlashLoan(address indexed borrower, address indexed token, uint256 amount, uint256 feeAmount, address indexed receiver);
    event LogRegisterProtocol(address indexed protocol);
    event LogSetMasterContractApproval(address indexed masterContract, address indexed user, bool approved);
    event LogStrategyDivest(address indexed token, uint256 amount);
    event LogStrategyInvest(address indexed token, uint256 amount);
    event LogStrategyLoss(address indexed token, uint256 amount);
    event LogStrategyProfit(address indexed token, uint256 amount);
    event LogStrategyQueued(address indexed token, address indexed strategy);
    event LogStrategySet(address indexed token, address indexed strategy);
    event LogStrategyTargetPercentage(address indexed token, uint256 targetPercentage);
    event LogTransfer(address indexed token, address indexed from, address indexed to, uint256 share);
    event LogWhiteListMasterContract(address indexed masterContract, bool approved);
    event LogWithdraw(address indexed token, address indexed from, address indexed to, uint256 amount, uint256 share);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    function balanceOf(IERC20, address) external view returns (uint256);
    function batch(bytes[] calldata calls, bool revertOnFail) external payable returns (bool[] memory successes, bytes[] memory results);
    function batchFlashLoan(IBatchFlashBorrower borrower, address[] calldata receivers, IERC20[] calldata tokens, uint256[] calldata amounts, bytes calldata data) external;
    function claimOwnership() external;
    function deploy(address masterContract, bytes calldata data, bool useCreate2) external payable;
    function deposit(IERC20 token_, address from, address to, uint256 amount, uint256 share) external payable returns (uint256 amountOut, uint256 shareOut);
    function flashLoan(IFlashBorrower borrower, address receiver, IERC20 token, uint256 amount, bytes calldata data) external;
    function harvest(IERC20 token, bool balance, uint256 maxChangeAmount) external;
    function masterContractApproved(address, address) external view returns (bool);
    function masterContractOf(address) external view returns (address);
    function nonces(address) external view returns (uint256);
    function owner() external view returns (address);
    function pendingOwner() external view returns (address);
    function pendingStrategy(IERC20) external view returns (IStrategy);
    function permitToken(IERC20 token, address from, address to, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
    function registerProtocol() external;
    function setMasterContractApproval(address user, address masterContract, bool approved, uint8 v, bytes32 r, bytes32 s) external;
    function setStrategy(IERC20 token, IStrategy newStrategy) external;
    function setStrategyTargetPercentage(IERC20 token, uint64 targetPercentage_) external;
    function strategy(IERC20) external view returns (IStrategy);
    function strategyData(IERC20) external view returns (uint64 strategyStartDate, uint64 targetPercentage, uint128 balance);
    function toAmount(IERC20 token, uint256 share, bool roundUp) external view returns (uint256 amount);
    function toShare(IERC20 token, uint256 amount, bool roundUp) external view returns (uint256 share);
    function totals(IERC20) external view returns (Rebase memory totals_);
    function transfer(IERC20 token, address from, address to, uint256 share) external;
    function transferMultiple(IERC20 token, address from, address[] calldata tos, uint256[] calldata shares) external;
    function transferOwnership(address newOwner, bool direct, bool renounce) external;
    function whitelistMasterContract(address masterContract, bool approved) external;
    function whitelistedMasterContracts(address) external view returns (bool);
    function withdraw(IERC20 token_, address from, address to, uint256 amount, uint256 share) external returns (uint256 amountOut, uint256 shareOut);
}

// File contracts/swappers/Leverage/YVIBLevSwapper.sol
// License-Identifier: MIT
pragma solidity 0.6.12;



interface CurvePool {
    function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver) external returns (uint256);
    function approve(address _spender, uint256 _value) external returns (bool);
    function add_liquidity(uint256[3] memory amounts, uint256 _min_mint_amount) external;
}

interface YearnVault {
    function withdraw() external returns (uint256);
    function deposit(uint256 amount, address recipient) external returns (uint256);
}
interface TetherToken {
    function approve(address _spender, uint256 _value) external;
}

interface IConvex is IERC20{
    function withdrawAndUnwrap(uint256 _amount) external;
    //deposit a curve token
    function deposit(uint256 _amount, address _to) external;
}

contract ThreeCrvLevSwapperV1 {
    using BoringMath for uint256;
    using BoringERC20 for IERC20;

     // Local variables
    IBentoBoxV1 public constant bentoBox = IBentoBoxV1(0xF5BCE5077908a1b7370B9ae04AdC565EBd643966);
    CurvePool public constant MIM3POOL = CurvePool(0x5a6A4D54456819380173272A5E8E9B9904BdF41B);
    CurvePool constant public threecrv = CurvePool(0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7);
    IConvex public constant cvx3CRV = IConvex(0x3Ba207c25A278524e1cC7FaAea950753049072A4);
    TetherToken public constant TETHER = TetherToken(0xdAC17F958D2ee523a2206206994597C13D831ec7); 
    IERC20 public constant MIM = IERC20(0x99D8a9C45b2ecA8864373A26D1459e3Dff1e17F3);
    IERC20 public constant CurveToken = IERC20(0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490);

    constructor() public {
        MIM.approve(address(MIM3POOL), type(uint256).max);
        TETHER.approve(address(threecrv), type(uint256).max);
        CurveToken.approve(address(cvx3CRV), type(uint256).max);
    }


    // Swaps to a flexible amount, from an exact input amount
    function swap(
        address recipient,
        uint256 shareToMin,
        uint256 shareFrom
    ) public returns (uint256 extraShare, uint256 shareReturned) {

        (uint256 amountFrom, ) = bentoBox.withdraw(MIM, address(this), address(this), 0, shareFrom);

        uint256 amountIntermediate = MIM3POOL.exchange_underlying(0, 3, amountFrom, 0, address(this));

        uint256[3] memory amountsAdded = [0,0, amountIntermediate];

        threecrv.add_liquidity(amountsAdded, 0);

        uint256 amountTo = CurveToken.balanceOf(address(this));

        cvx3CRV.deposit(amountTo, address(bentoBox));

        (, shareReturned) = bentoBox.deposit(cvx3CRV, address(bentoBox), recipient, amountTo, 0);
        extraShare = shareReturned.sub(shareToMin);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CurveToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIM","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIM3POOL","outputs":[{"internalType":"contract CurvePool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TETHER","outputs":[{"internalType":"contract TetherToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bentoBox","outputs":[{"internalType":"contract IBentoBoxV1","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cvx3CRV","outputs":[{"internalType":"contract IConvex","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"shareToMin","type":"uint256"},{"internalType":"uint256","name":"shareFrom","type":"uint256"}],"name":"swap","outputs":[{"internalType":"uint256","name":"extraShare","type":"uint256"},{"internalType":"uint256","name":"shareReturned","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"threecrv","outputs":[{"internalType":"contract CurvePool","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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