Premia Finance

1pragma solidity ^0.8.0;
2​
3import {AggregatorInterface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol";
4import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
5import {EnumerableSet, ERC1155EnumerableStorage} from "@solidstate/contracts/token/ERC1155/enumerable/ERC1155EnumerableStorage.sol";
6​
7import {ABDKMath64x64} from "abdk-libraries-solidity/ABDKMath64x64.sol";
8import {ABDKMath64x64Token} from "../libraries/ABDKMath64x64Token.sol";
9import {OptionMath} from "../libraries/OptionMath.sol";
10​
11library PoolStorage {
12    using ABDKMath64x64 for int128;
13    using PoolStorage for PoolStorage.Layout;
14​
15    enum TokenType {
16        UNDERLYING_FREE_LIQ,
17        BASE_FREE_LIQ,
18        UNDERLYING_RESERVED_LIQ,
19        BASE_RESERVED_LIQ,
20        LONG_CALL,
21        SHORT_CALL,
22        LONG_PUT,
23        SHORT_PUT
24    }
25​
26    struct PoolSettings {
27        address underlying;
28        address base;
29        address underlyingOracle;
30        address baseOracle;
31    }
32​
33    struct QuoteArgsInternal {
34        address feePayer; // address of the fee payer
35        uint64 maturity; // timestamp of option maturity
36        int128 strike64x64; // 64x64 fixed point representation of strike price
37        int128 spot64x64; // 64x64 fixed point representation of spot price
38        uint256 contractSize; // size of option contract
39        bool isCall; // true for call, false for put
40    }
41​
42    struct QuoteResultInternal {
43        int128 baseCost64x64; // 64x64 fixed point representation of option cost denominated in underlying currency (without fee)
44        int128 feeCost64x64; // 64x64 fixed point representation of option fee cost denominated in underlying currency for call, or base currency for put
45        int128 cLevel64x64; // 64x64 fixed point representation of C-Level of Pool after purchase
46        int128 slippageCoefficient64x64; // 64x64 fixed point representation of slippage coefficient for given order size
47    }
48​
49    struct BatchData {
50        uint256 eta;
51        uint256 totalPendingDeposits;
52    }
53​
54    bytes32 internal constant STORAGE_SLOT =
55        keccak256("premia.contracts.storage.Pool");
56​
57    uint256 private constant C_DECAY_BUFFER = 12 hours;
58    uint256 private constant C_DECAY_INTERVAL = 4 hours;
59​
60    struct Layout {
61        // ERC20 token addresses
62        address base;
63        address underlying;
64        // AggregatorV3Interface oracle addresses
65        address baseOracle;
66        address underlyingOracle;
67        // token metadata
68        uint8 underlyingDecimals;
69        uint8 baseDecimals;
70        // minimum amounts
71        uint256 baseMinimum;
72        uint256 underlyingMinimum;
73        // deposit caps
74        uint256 basePoolCap;
75        uint256 underlyingPoolCap;
76        // market state
77        int128 _deprecated_steepness64x64;
78        int128 cLevelBase64x64;
79        int128 cLevelUnderlying64x64;
80        uint256 cLevelBaseUpdatedAt;
81        uint256 cLevelUnderlyingUpdatedAt;
82        uint256 updatedAt;
83        // User -> isCall -> depositedAt
84        mapping(address => mapping(bool => uint256)) depositedAt;
85        mapping(address => mapping(bool => uint256)) divestmentTimestamps;
86        // doubly linked list of free liquidity intervals
87        // isCall -> User -> User
88        mapping(bool => mapping(address => address)) liquidityQueueAscending;
89        mapping(bool => mapping(address => address)) liquidityQueueDescending;
90        // minimum resolution price bucket => price
91        mapping(uint256 => int128) bucketPrices64x64;
92        // sequence id (minimum resolution price bucket / 256) => price update sequence
93        mapping(uint256 => uint256) priceUpdateSequences;
94        // isCall -> batch data
95        mapping(bool => BatchData) nextDeposits;
96        // user -> batch timestamp -> isCall -> pending amount
97        mapping(address => mapping(uint256 => mapping(bool => uint256))) pendingDeposits;
98        EnumerableSet.UintSet tokenIds;
99        // user -> isCallPool -> total value locked of user (Used for liquidity mining)
100        mapping(address => mapping(bool => uint256)) userTVL;
101        // isCallPool -> total value locked
102        mapping(bool => uint256) totalTVL;
103        // steepness values
104        int128 steepnessBase64x64;
105        int128 steepnessUnderlying64x64;
106    }
107​
108    function layout() internal pure returns (Layout storage l) {
109        bytes32 slot = STORAGE_SLOT;
110        assembly {
111            l.slot := slot
112        }
113    }
114​
115    /*
116     * @notice calculate ERC1155 token id for given option parameters
117     * @param tokenType TokenType enum
118     * @param maturity timestamp of option maturity
119     * @param strike64x64 64x64 fixed point representation of strike price
120     * @return tokenId token id
121     */
122    function formatTokenId(
123        TokenType tokenType,
124        uint64 maturity,
125        int128 strike64x64
126    ) internal pure returns (uint256 tokenId) {
127        tokenId =
128            (uint256(tokenType) << 248) +
129            (uint256(maturity) << 128) +
130            uint256(int256(strike64x64));
131    }
132​
133    /*
134     * @notice derive option maturity and strike price from ERC1155 token id
135     * @param tokenId token id
136     * @return tokenType TokenType enum
137     * @return maturity timestamp of option maturity
138     * @return strike64x64 option strike price
139     */
140    function parseTokenId(uint256 tokenId)
141        internal
142        pure
143        returns (
144            TokenType tokenType,
145            uint64 maturity,
146            int128 strike64x64
147        )
148    {
149        assembly {
150            tokenType := shr(248, tokenId)
151            maturity := shr(128, tokenId)
152            strike64x64 := tokenId
153        }
154    }
155​
156    function getTokenDecimals(Layout storage l, bool isCall)
157        internal
158        view
159        returns (uint8 decimals)
160    {
161        decimals = isCall ? l.underlyingDecimals : l.baseDecimals;
162    }
163​
164    /**
165     * @notice get the total supply of free liquidity tokens, minus pending deposits
166     * @param l storage layout struct
167     * @param isCall whether query is for call or put pool
168     * @return 64x64 fixed point representation of total free liquidity
169     */
170    function totalFreeLiquiditySupply64x64(Layout storage l, bool isCall)
171        internal
172        view
173        returns (int128)
174    {
175        uint256 tokenId = formatTokenId(
176            isCall ? TokenType.UNDERLYING_FREE_LIQ : TokenType.BASE_FREE_LIQ,
177            0,
178            0
179        );
180​
181        return
182            ABDKMath64x64Token.fromDecimals(
183                ERC1155EnumerableStorage.layout().totalSupply[tokenId] -
184                    l.nextDeposits[isCall].totalPendingDeposits,
185                l.getTokenDecimals(isCall)
186            );
187    }
188​
189    function getReinvestmentStatus(
190        Layout storage l,
191        address account,
192        bool isCallPool
193    ) internal view returns (bool) {
194        uint256 timestamp = l.divestmentTimestamps[account][isCallPool];
195        return timestamp == 0 || timestamp > block.timestamp;
196    }
197​
198    function addUnderwriter(
199        Layout storage l,
200        address account,
201        bool isCallPool
202    ) internal {
203        require(account != address(0));
204​
205        mapping(address => address) storage asc = l.liquidityQueueAscending[
206            isCallPool
207        ];
208        mapping(address => address) storage desc = l.liquidityQueueDescending[
209            isCallPool
210        ];
211​
212        if (_isInQueue(account, asc, desc)) return;
213​
214        address last = desc[address(0)];
215​
216        asc[last] = account;
217        desc[account] = last;
218        desc[address(0)] = account;
219    }