829906459

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/95da9370b175e426e5994e4936ad685b08ed6ca9">95da9370b<a href="https://github.com/element-fi/elf-contracts/commit/95da9370b175e426e5994e4936ad685b08ed6ca9">">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/8347f722303b7a9b274b36816d737019d31fa89e">8347f7223</a>">8347f7223</a><a href="https://github.com/element-fi/elf-contracts/commit/95da9370b175e426e5994e4936ad685b08ed6ca9"> into 2b52386b1">2b52386b1</a>

Pull Request Pull Request #194: Yearn Shares Zapper

Run Details

154 of 182 branches covered (84.62%)

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

503 of 536 relevant lines covered (93.84%)

162.47 hits per line

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

81.82

/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";
import "hardhat/console.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.
    /// @param _maxLoss The maximum acceptable loss to sustain on withdrawal.
    /// @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 _maxLoss
    ) external notFrozen() returns (uint256, uint256) {
        _vault.transferFrom(msg.sender, address(this), _amount);
        _vault.withdraw(_amount, address(this), _maxLoss);

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

        // ETH vault returns WETH so no need to ETH-specific logic.
        _underlying.transfer(address(_position), balance);

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

element-fi / elf-contracts / 829906459

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