Hegic V8888

1import "../Interfaces/Interfaces.sol";
2import "../Interfaces/IOptionsManager.sol";
3​
4/**
5 * @author 0mllwntrmt3
6 * @title Hegic Protocol V8888 Facade Contract
7 * @notice The contract that calculates the options prices,
8 * conducts the process of buying options, converts the premiums
9 * into the token that the pool is denominated in and grants
10 * permissions to the contracts such as GSN (Gas Station Network).
11 **/
12​
13contract Facade is Ownable {
14    using SafeERC20 for IERC20;
15​
16    IWETH public immutable WETH;
17    IUniswapV2Router01 public immutable exchange;
18    IOptionsManager public immutable optionsManager;
19    address public _trustedForwarder;
20​
21    constructor(
22        IWETH weth,
23        IUniswapV2Router01 router,
24        IOptionsManager manager,
25        address trustedForwarder
26    ) {
27        WETH = weth;
28        exchange = router;
29        _trustedForwarder = trustedForwarder;
30        optionsManager = manager;
31    }
32​
33    /**
34     * @notice Used for calculating the option price (the premium) and using
35     * the swap router (if needed) to convert the tokens with which the user
36     * pays the premium into the token in which the pool is denominated.
37     * @param period The option period
38     * @param amount The option size
39     * @param strike The option strike
40     * @param total The total premium
41     * @param baseTotal The part of the premium that
42     * is distributed among the liquidity providers
43     * @param settlementFee The part of the premium that
44     * is distributed among the HEGIC staking participants
45     **/
46    function getOptionPrice(
47        IHegicPool pool,
48        uint256 period,
49        uint256 amount,
50        uint256 strike,
51        address[] calldata swappath
52    )
53        public
54        view
55        returns (
56            uint256 total,
57            uint256 baseTotal,
58            uint256 settlementFee,
59            uint256 premium
60        )
61    {
62        (uint256 _baseTotal, uint256 baseSettlementFee, uint256 basePremium) =
63            getBaseOptionCost(pool, period, amount, strike);
64        if (swappath.length > 1)
65            total = exchange.getAmountsIn(_baseTotal, swappath)[0];
66        else total = _baseTotal;
67​
68        baseTotal = _baseTotal;
69        settlementFee = (total * baseSettlementFee) / baseTotal;
70        premium = (total * basePremium) / baseTotal;
71    }
72​
73    /**
74     * @notice Used for calculating the option price (the premium)
75     * in the token in which the pool is denominated.
76     * @param period The option period
77     * @param amount The option size
78     * @param strike The option strike
79     **/
80    function getBaseOptionCost(
81        IHegicPool pool,
82        uint256 period,
83        uint256 amount,
84        uint256 strike
85    )
86        public
87        view
88        returns (
89            uint256 total,
90            uint256 settlementFee,
91            uint256 premium
92        )
93    {
94        (settlementFee, premium) = pool.calculateTotalPremium(
95            period,
96            amount,
97            strike
98        );
99        total = premium + settlementFee;
100    }
101​
102    /*
103     * @notice Used for approving the pools contracts addresses.
104     **/
105    function poolApprove(IHegicPool pool) external {
106        pool.token().safeApprove(address(pool), 0);
107        pool.token().safeApprove(address(pool), type(uint256).max);
108    }
109​
110    /*
111     * @notice Used for buying the option contract and converting
112     * the buyer's tokens (the total premium) into the token
113     * in which the pool is denominated.
114     * @param period The option period
115     * @param amount The option size
116     * @param strike The option strike
117     * @param acceptablePrice The highest acceptable price
118     **/
119    function createOption(
120        IHegicPool pool,
121        uint256 period,
122        uint256 amount,
123        uint256 strike,
124        address[] calldata swappath,
125        uint256 acceptablePrice
126    ) external {
127        address buyer = _msgSender();
128        (uint256 optionPrice, uint256 rawOptionPrice, , ) =
129            getOptionPrice(pool, period, amount, strike, swappath);
130        require(
131            optionPrice <= acceptablePrice,
132            "Facade Error: The option price is too high"
133        );
134        IERC20 paymentToken = IERC20(swappath[0]);
135        paymentToken.safeTransferFrom(buyer, address(this), optionPrice);
136        if (swappath.length > 1) {
137            if (
138                paymentToken.allowance(address(this), address(exchange)) <
139                optionPrice
140            ) {
141                paymentToken.safeApprove(address(exchange), 0);
142                paymentToken.safeApprove(address(exchange), type(uint256).max);
143            }
144​
145            exchange.swapTokensForExactTokens(
146                rawOptionPrice,
147                optionPrice,
148                swappath,
149                address(this),
150                block.timestamp
151            );
152        }
153        pool.sellOption(buyer, period, amount, strike);
154    }
155​
156    /**
157     * @notice Used for converting the liquidity provider's Ether (ETH)
158     * into Wrapped Ether (WETH) and providing the funds into the pool.
159     * @param hedged The liquidity tranche type: hedged or unhedged (classic)
160     **/
161    function provideEthToPool(
162        IHegicPool pool,
163        bool hedged,
164        uint256 minShare
165    ) external payable returns (uint256) {
166        WETH.deposit{value: msg.value}();
167        if (WETH.allowance(address(this), address(pool)) < msg.value)
168            WETH.approve(address(pool), type(uint256).max);
169        return pool.provideFrom(msg.sender, msg.value, hedged, minShare);
170    }
171​
172    /**
173     * @notice Unlocks the array of options.
174     * @param optionIDs The array of options
175     **/
176    function unlockAll(IHegicPool pool, uint256[] calldata optionIDs) external {
177        uint256 arrayLength = optionIDs.length;
178        for (uint256 i = 0; i < arrayLength; i++) {
179            pool.unlock(optionIDs[i]);
180        }
181    }
182​
183    /**
184     * @notice Used for granting the GSN (Gas Station Network) contract
185     * the permission to pay the gas (transaction) fees for the users.
186     * @param forwarder GSN (Gas Station Network) contract address
187     **/
188    function isTrustedForwarder(address forwarder) public view returns (bool) {
189        return forwarder == _trustedForwarder;
190    }

Solidity Contracts

JavaScript Tests