836225641

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/element-fi/elf-contracts/commit/<a class=hub.com/element-fi/elf-contracts/commit/703a49e55f433f1899baff783287a5021cb67617">703a49e55<a href="https://github.com/element-fi/elf-contracts/commit/703a49e55f433f1899baff783287a5021cb67617">">Merge </a><a class="double-link" href="https://github.com/element-fi/elf-contracts/commit/<a class="double-link" href="https://github.com/element-fi/elf-contracts/commit/8d3630adde19d246a8ff8614121ffd8e89ef8f99">8d3630add</a>">8d3630add</a><a href="https://github.com/element-fi/elf-contracts/commit/703a49e55f433f1899baff783287a5021cb67617"> into 340025e13">340025e13</a>

Pull Request Pull Request #194: Yearn Shares Zapper

Run Details

156 of 184 branches covered (84.78%)

18 of 18 new or added lines in 1 file covered. (100.0%)

510 of 543 relevant lines covered (93.92%)

162.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.33

/contracts/zaps/ZapYearnShares.sol

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

import "../interfaces/IYearnVaultV2.sol";
import "../libraries/Authorizable.sol";
import "../interfaces/IERC20.sol";
import "../interfaces/ITranche.sol";

contract ZapYearnShares is Authorizable {
    // Store the accessibility state of the contract
    bool public isFrozen = false;
    // Tranche factory address for Tranche contract address derivation
    address internal immutable _trancheFactory;
    // Tranche bytecode hash for Tranche contract address derivation.
    // This is constant as long as Tranche does not implement non-constant constructor arguments.
    bytes32 internal immutable _trancheBytecodeHash;

    /// @param __trancheFactory Address of the TrancheFactory contract
    /// @param __trancheBytecodeHash Hash of the Tranche bytecode.
    constructor(address __trancheFactory, bytes32 __trancheBytecodeHash)
        Authorizable()
    {
        _authorize(msg.sender);
        _trancheFactory = __trancheFactory;
        _trancheBytecodeHash = __trancheBytecodeHash;
    }

    /// @dev Requires that the contract is not frozen
    modifier notFrozen() {
        require(!isFrozen, "Contract frozen");
        _;
    }

    /// @dev Allows an authorized address to freeze or unfreeze this contract
    /// @param _newState True for frozen and false for unfrozen
    function setIsFrozen(bool _newState) external onlyAuthorized() {
        isFrozen = _newState;
    }

    /// @notice Mints a Principal/Interest token pair from yearn vault shares.
    ///      then returns the tokens to the caller.
    /// @param _underlying The underlying ERC20 token contract of the yearn vault.
    /// @param _vault The address of the target yearn vault.
    /// @param _amount The amount of yearn shares to turn into tokens
    /// @param _expiration The expiration time of the Tranche contract.
    /// @param _position The contract which manages pooled deposits.
    /// @return returns the minted amounts of principal and yield tokens (PT and YT)
    function zapSharesIn(
        IERC20 _underlying,
        IYearnVault _vault,
        uint256 _amount,
        uint256 _expiration,
        address _position,
        uint256 _ptExpected
    ) external notFrozen() returns (uint256, uint256) {
        _vault.transferFrom(msg.sender, address(this), _amount);
        _vault.withdraw(_amount, _position, 0);

        ITranche tranche = _deriveTranche(address(_position), _expiration);
        uint256 balance = _underlying.balanceOf(_position);

        (uint256 ptMinted, uint256 ytMinted) = tranche.prefundedDeposit(
            msg.sender
        );
        require(ytMinted >= balance, "Not enough YT minted");
        require(ptMinted >= _ptExpected, "Not enough PT minted");
        return (ptMinted, ytMinted);
    }

    /// @dev This internal function produces the deterministic create2
    ///      address of the Tranche contract from a wrapped position contract and expiration
    /// @param _position The wrapped position contract address
    /// @param _expiration The expiration time of the tranche
    /// @return The derived Tranche contract
    function _deriveTranche(address _position, uint256 _expiration)
        internal
        virtual
        view
        returns (ITranche)
    {
        bytes32 salt = keccak256(abi.encodePacked(_position, _expiration));
        bytes32 addressBytes = keccak256(
            abi.encodePacked(
                bytes1(0xff),
                _trancheFactory,
                salt,
                _trancheBytecodeHash
            )
        );
        return ITranche(address(uint160(uint256(addressBytes))));
    }

    /// @dev This contract can hold yearn vault share allowances for addresses so if it is deprecated
    ///      it should be removed so that users do not have to remove allowances.
    ///      Note - onlyOwner is a stronger check than onlyAuthorized, many addresses can be
    ///      authorized to freeze or unfreeze the contract but only the owner address can kill
    function deprecate() external onlyOwner() {
        selfdestruct(payable(msg.sender));
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	pragma solidity ^0.8.0;
3
4	import "../interfaces/IYearnVaultV2.sol";
5	import "../libraries/Authorizable.sol";
6	import "../interfaces/IERC20.sol";
7	import "../interfaces/ITranche.sol";
8
9	contract ZapYearnShares is Authorizable {
10	// Store the accessibility state of the contract
11	bool public isFrozen = false;
12	// Tranche factory address for Tranche contract address derivation
13	address internal immutable _trancheFactory;
14	// Tranche bytecode hash for Tranche contract address derivation.
15	// This is constant as long as Tranche does not implement non-constant constructor arguments.
16	bytes32 internal immutable _trancheBytecodeHash;
17
18	/// @param __trancheFactory Address of the TrancheFactory contract
19	/// @param __trancheBytecodeHash Hash of the Tranche bytecode.
20	constructor(address __trancheFactory, bytes32 __trancheBytecodeHash)
21	Authorizable()
22	{
23	_authorize(msg.sender);	3✔
24	_trancheFactory = __trancheFactory;	3✔
25	_trancheBytecodeHash = __trancheBytecodeHash;	3✔
26	}
27
28	/// @dev Requires that the contract is not frozen
29	modifier notFrozen() {
30	require(!isFrozen, "Contract frozen");	15!
31	_;	15✔
32	}
33
34	/// @dev Allows an authorized address to freeze or unfreeze this contract
35	/// @param _newState True for frozen and false for unfrozen
36	function setIsFrozen(bool _newState) external onlyAuthorized() {
37	isFrozen = _newState;	×
38	}
39
40	/// @notice Mints a Principal/Interest token pair from yearn vault shares.
41	/// then returns the tokens to the caller.
42	/// @param _underlying The underlying ERC20 token contract of the yearn vault.
43	/// @param _vault The address of the target yearn vault.
44	/// @param _amount The amount of yearn shares to turn into tokens
45	/// @param _expiration The expiration time of the Tranche contract.
46	/// @param _position The contract which manages pooled deposits.
47	/// @return returns the minted amounts of principal and yield tokens (PT and YT)
48	function zapSharesIn(
49	IERC20 _underlying,
50	IYearnVault _vault,
51	uint256 _amount,
52	uint256 _expiration,
53	address _position,
54	uint256 _ptExpected
55	) external notFrozen() returns (uint256, uint256) {
56	_vault.transferFrom(msg.sender, address(this), _amount);	15✔
57	_vault.withdraw(_amount, _position, 0);	15✔
58
59	ITranche tranche = _deriveTranche(address(_position), _expiration);	15✔
60	uint256 balance = _underlying.balanceOf(_position);	15✔
61
62	(uint256 ptMinted, uint256 ytMinted) = tranche.prefundedDeposit(	15✔
63	msg.sender
64	);
65	require(ytMinted >= balance, "Not enough YT minted");	11!
66	require(ptMinted >= _ptExpected, "Not enough PT minted");	11✔
67	return (ptMinted, ytMinted);	10✔
68	}
69
70	/// @dev This internal function produces the deterministic create2
71	/// address of the Tranche contract from a wrapped position contract and expiration
72	/// @param _position The wrapped position contract address
73	/// @param _expiration The expiration time of the tranche
74	/// @return The derived Tranche contract
75	function _deriveTranche(address _position, uint256 _expiration)
76	internal
77	virtual
78	view
79	returns (ITranche)
80	{
81	bytes32 salt = keccak256(abi.encodePacked(_position, _expiration));	15✔
82	bytes32 addressBytes = keccak256(	15✔
83	abi.encodePacked(
84	bytes1(0xff),
85	_trancheFactory,
86	salt,
87	_trancheBytecodeHash
88	)
89	);
90	return ITranche(address(uint160(uint256(addressBytes))));	15✔
91	}
92
93	/// @dev This contract can hold yearn vault share allowances for addresses so if it is deprecated
94	/// it should be removed so that users do not have to remove allowances.
95	/// Note - onlyOwner is a stronger check than onlyAuthorized, many addresses can be
96	/// authorized to freeze or unfreeze the contract but only the owner address can kill
97	function deprecate() external onlyOwner() {
98	selfdestruct(payable(msg.sender));	×
99	}
100	}

element-fi / elf-contracts / 836225641

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous