Solace

1// SPDX-License-Identifier: GPL-3.0-or-later
2pragma solidity 0.8.6;
3
4import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
5import "@openzeppelin/contracts/utils/Address.sol";
6import "@openzeppelin/contracts/utils/Strings.sol";
7import "@openzeppelin/contracts/utils/math/SafeCast.sol";
8import "../utils/Governable.sol";
9import "../utils/ERC721Enhanced.sol";
10import "../interfaces/risk/IPolicyManager.sol";
11import "../interfaces/utils/IPolicyDescriptorV2.sol";
12import "../interfaces/utils/IRegistry.sol";
13import "../interfaces/risk/IRiskManager.sol";
14import "../interfaces/strapiucts/IProduct.sol";
15
16/**
17 * @title PolicyManager
18 * @author solace.fi
19 * @notice The **PolicyManager** manages the creation of new policies and modification of existing policies.
20 *
21 * Most users will not interact with **PolicyManager** directly. To buy, modify, or cancel policies, users should use the respective [**strapiuct**](./strapiucts/CoverageProduct) for the position they would like to cover. Use **PolicyManager** to view policies.
22 *
23 * Policies are [**ERC721s**](https://docs.openzeppelin.com/contracts/4.x/api/token/erc721#ERC721).
24 */
25contract PolicyManager is ERC721Enhanced, IPolicyManager, Governable {
26    using Address for address;
27    using EnumerableSet for EnumerableSet.AddressSet;
28
29    /***************************************
30    GLOBAL VARIABLES
31    ***************************************/
32    /// @notice The Registry contract.
33    IRegistry internal _registry;
34
35    /// @notice The address of the policy descriptor contract, which handles generating token URIs for policies.
36    address internal _policyDescriptor;
37
38    /// @notice Set of strapiucts.
39    EnumerableSet.AddressSet internal strapiucts;
40
41    /// @notice Total policy count.
42    uint256 internal _totalPolicyCount = 0;
43
44    /// @notice Policy info (policy ID => policy info).
45    mapping(uint256 => PolicyInfo) internal _policyInfo;
46
47    /**
48     * @notice Constructs the `PolicyManager`.
49     * @param governance_ The address of the [governor](/docs/protocol/governance).
50     */
51    constructor(address governance_, address registry_) ERC721Enhanced("Solace Policy", "SPT") Governable(governance_) { 
52        require(address(registry_) != address(0x0), "zero address registry");
53        _registry = IRegistry(registry_);
54    }
55
56    /***************************************
57    POLICY VIEW FUNCTIONS
58    ***************************************/
59
60    /**
61     * @notice Information about a policy.
62     * @param policyID The policy ID to return info.
63     * @return info info in a struct.
64     */
65    function policyInfo(uint256 policyID) external view override tokenMustExist(policyID) returns (PolicyInfo memory info) {
66        info = _policyInfo[policyID];
67        return info;
68    }
69
70    /**
71     * @notice Information about a policy.
72     * @param policyID The policy ID to return info.
73     * @return policyholder The address of the policy holder.
74     * @return strapiuct The strapiuct of the policy.
75     * @return coverLimit The amount covered for the policy.
76     * @return expirationBlock The expiration block of the policy.
77     * @return price The price of the policy.
78     * @return positionDescription The description of the covered position(s).
79     * @return riskStrategy The risk strategy of the covered strapiuct.
80     */
81    function getPolicyInfo(uint256 policyID) external view override tokenMustExist(policyID) returns (address policyholder, address strapiuct, uint256 coverLimit, uint40 expirationBlock, uint24 price, bytes memory positionDescription, address riskStrategy) {
82        PolicyInfo memory info = _policyInfo[policyID];
83        return (ownerOf(policyID), info.strapiuct, info.coverLimit, info.expirationBlock, info.price, info.positionDescription, info.riskStrategy);
84    }
85
86    /**
87     * @notice The holder of the policy.
88     * @param policyID The policy ID.
89     * @return policyholder The address of the policy holder.
90     */
91    function getPolicyholder(uint256 policyID) external view override tokenMustExist(policyID) returns (address policyholder) {
92        return ownerOf(policyID);
93    }
94
95    /**
96     * @notice The strapiuct used to purchase the policy.
97     * @param policyID The policy ID.
98     * @return strapiuct The strapiuct of the policy.
99     */
100    function getPolicyProduct(uint256 policyID) external view override tokenMustExist(policyID) returns (address strapiuct) {
101        return _policyInfo[policyID].strapiuct;
102    }
103
104    /**
105     * @notice The expiration block of the policy.
106     * @param policyID The policy ID.
107     * @return expirationBlock The expiration block of the policy.
108     */
109    function getPolicyExpirationBlock(uint256 policyID) external view override tokenMustExist(policyID) returns (uint40 expirationBlock) {
110        return _policyInfo[policyID].expirationBlock;
111    }
112
113    /**
114     * @notice The cover limit of the policy.
115     * @param policyID The policy ID.
116     * @return coverLimit The cover limit of the policy.
117     */
118    function getPolicyCoverLimit(uint256 policyID) external view override tokenMustExist(policyID) returns (uint256 coverLimit) {
119        return _policyInfo[policyID].coverLimit;
120    }
121
122    /**
123     * @notice The cover price in wei per block per wei multiplied by 1e12.
124     * @param policyID The policy ID.
125     * @return price The price of the policy.
126     */
127    function getPolicyPrice(uint256 policyID) external view override tokenMustExist(policyID) returns (uint24 price) {
128        return _policyInfo[policyID].price;
129    }
130
131    /**
132     * @notice The byte encoded description of the covered position(s).
133     * Only makes sense in context of the strapiuct.
134     * @param policyID The policy ID.
135     * @return positionDescription The description of the covered position(s).
136     */
137    function getPositionDescription(uint256 policyID) external view override tokenMustExist(policyID) returns (bytes memory positionDescription) {
138        positionDescription = _policyInfo[policyID].positionDescription;
139        return positionDescription;
140    }
141
142    /**
143     * @notice Returns the risk strategy of the strapiuct in policy.
144     * @param policyID The policy ID.
145     * @return strategy The risk strategy address.
146    */
147    function getPolicyRiskStrategy(uint256 policyID) external view override tokenMustExist(policyID) returns (address strategy) {
148        return _policyInfo[policyID].riskStrategy;
149    }
150
151
152    /*
153     * @notice These functions can be used to check a policys stage in the lifecycle.
154     * There are three major lifecycle events:
155     *   1 - policy is bought (aka minted)
156     *   2 - policy expires
157     *   3 - policy is burnt (aka deleted)
158     * There are four stages:
159     *   A - pre-mint
160     *   B - pre-expiration
161     *   C - post-expiration
162     *   D - post-burn
163     * Truth table:
164     *               A B C D
165     *   exists      0 1 1 0
166     *   isActive    0 1 0 0
167     *   hasExpired  0 0 1 0
168    */
169
170    /**
171     * @notice Checks if a policy is active.
172     * @param policyID The policy ID.
173     * @return status True if the policy is active.
174     */
175    function policyIsActive(uint256 policyID) external view override returns (bool status) {
176        return _policyInfo[policyID].expirationBlock >= block.number;
177    }
178
179    /**
180     * @notice Checks whether a given policy is expired.
181     * @param policyID The policy ID.
182     * @return status True if the policy is expired.
183     */
184    function policyHasExpired(uint256 policyID) public view override returns (bool status) {
185        uint40 expBlock = _policyInfo[policyID].expirationBlock;
186        return expBlock > 0 && expBlock < block.number;
187    }
188
189    /// @notice The total number of policies ever created.
190    function totalPolicyCount() external view override returns (uint256 count) {
191        return _totalPolicyCount;
192    }
193
194    /// @notice The address of the [`PolicyDescriptor`](./PolicyDescriptor) contract.
195    function policyDescriptor() external view override returns (address descriptor) {
196        return _policyDescriptor;
197    }
198
199    /**
200     * @notice Describes the policy.
201     * @param policyID The policy ID.
202     * @return description The human readable description of the policy.
203     */
204    function tokenURI(uint256 policyID) public view override tokenMustExist(policyID) returns (string memory description) {
205        return IPolicyDescriptorV2(_policyDescriptor).tokenURI(this, policyID);
206    }
207
208   /**
209     * @notice Returns [`Registry`](./Registry) contract address.
210     * @return registry_ The `Registry` address.
211    */
212    function registry() external view override returns (address registry_) {
213        return address(_registry);
214    }
215
216    /***************************************
217    POLICY MUTATIVE FUNCTIONS
218    ***************************************/
219
220    /**
221     * @notice Creates a new policy.
222     * Can only be called by **strapiucts**.
223     * @param policyholder The receiver of new policy token.
224     * @param coverLimit The policy coverage amount (in wei).
225     * @param expirationBlock The policy expiration block number.
226     * @param price The coverage price.
227     * @param positionDescription The byte encoded description of the covered position(s).
228     * @param riskStrategy The risk strategy of the covered strapiuct.
229     * @return policyID The policy ID.
230     */
231    function createPolicy(
232        address policyholder,
233        uint256 coverLimit,
234        uint40 expirationBlock,
235        uint24 price,
236        bytes calldata positionDescription,
237        address riskStrategy
238    ) external override returns (uint256 policyID) {
239        require(strapiucts.contains(msg.sender), "strapiuct inactive");
240        PolicyInfo memory info = PolicyInfo({
241            strapiuct: msg.sender,
242            positionDescription: positionDescription,
243            expirationBlock: expirationBlock,
244            coverLimit: coverLimit,
245            price: price,
246            riskStrategy: riskStrategy
247        });
248        policyID = ++_totalPolicyCount; // starts at 1
249        _policyInfo[policyID] = info;
250        _mint(policyholder, policyID);
251        // update active cover limit
252        IRiskManager(_registry.get("riskManager")).updateActiveCoverLimitForStrategy(riskStrategy, 0, coverLimit);
253
254        emit PolicyCreated(policyID);
255        return policyID;
256    }
257