Refactor/soteria (WIP)

[kyzooghost]

TODO

• Within contracts other than SoteriaCoverageProduct.sol, rename “coverAmount” to “coverLimit”. Looking at PolicyManager.sol in particular.
• Work out specifications for referral discount mechanism, and then implement this
• Work out specifications for staking duration discount mechanism, and then implement this
• Work out specifications for withdraw cooldown mechanism
• For discussion - For chargePremium should we keep require(premiums_[i] <= _minRequiredAccountBalance(coverLimitOf(policyOf(holders_[i]))), "charging more than promised maximum rate");
• For discussion - For canPurchaseNewCover() function, should we keep `if (newTotalCover < existingTotalCover_) return true;`

---

COMMIT LOG

Soteria refactor 6

Realised needed to split _maxRate into _maxRateNum and _maxRateDenom, because 10% annual rate => _maxRate = 1/315360000

Soteria refactor 5

Renamed _closePolicy to _deactivatePolicy, implemented calls to _deactivatePolicy() in both deactivatePolicy() and chargePremiums()

Soteria refactor 4

Added sanity check to withdraw() and _canPurchaseNewCover()

Renamed _rewardPoints mapping to _rewardPointsOf

Changed giftRewardPoints() to setRewardPoints()

Soteria refactor 3

Added _beforeTokenTransfer(…) hook to ensure

• Soteria policies are non-transferable
• Only one Soteria policy can be minted per user

Renamed totalCoverLimit to activeCoverLimit (as per specs)

Added chargeCycle variable, as well as related public getter and governance-only setter functions.

Changed maxChargeableRate to maxRate.

require (minAccountBalance = maxRate chargeCycle coverLimit) is incorporated into activatePolicy(), updatePolicy(), and withdraw()

Made sure withdraw() function follows these specs:

• Cannot withdraw more
• Sends funds to the policyholder
• NEED CLARIFICATION HERE - User can only withdraw such that remaining balance >minAccountBalance, else they will withdraw all available balance (which is the same thing as deactivatePolicy?)
• withdraw(address policyholder, uint256 amount_) internal {…}
• Transfer funds to policyholder

Renamed _soteriaAccountBalance mapping to _accountBalanceOf

Made sure activatePolicy(…) follows these specs:

• require minAccountBalance = maxRate coverLimit_ chargeCycle
• Call _deposit() -> _accountBalanceOf(policyholder) = msg.value
• Call mint()
• require coverLimit <= availableCoverCapacity (this requires a call to maxCover, which requires a call to RiskManager)
• report activeCover to PolicyManager (Need to change to RiskManager)
• Add to mapping: policyOf(policyholder)=policyID
• Add to mapping: coverLimitOf(policyholder)=coverLimit_

Soteria refactor 2

• Renamed cancelPolicy() to deactivatePolicy(), and event PolicyCancelled to PolicyDeactivated
• Removed functions, variables and events related to ‘Signers’ mechanism

Soteria refactor 1

• Removed submitClaim() function (rationale - for the first product iteration, we will assess claims off-chain and send payouts proactively)
• Renamed references of “coverAmount” to “coverLimit” (rationale - coverAmount is misleading, coverLimit is more accurate description)
• Renamed _funds mapping to _soteriaAccountBalance (rationale - more accurate variable name)
• Renamed funds() view function to soteriaAccountBalance() (rationale - more accurate variable name)
• Removed _policyToOwner() mapping (rationale - ERC721.ownerOf() function does the same thing)
• Removed policyholders() function (rationale - We can return all policy holders by using a combination of policyCount() to get total supply => query ERC721.ownerOf() for each number)
• Removed minFundAmount_ parameter from activatePolicy() (rationale - redundant parameter)
• Renamed policyByOwner() to policyIDOf (rationale - more human readable function)
• Renamed mapping _ownerToPolicy to _policyID (rationale - more human readable function)
• Added newCoverCapacity() view function (rationale - useful to view amount of available capacity for new cover)
• Renamed assessRisk() to _canPurchaseNewCover() and made this an internal function (rationale - assessRisk is misleading, since risk managers do this off-chain, and this function actually checks to see if there is capacity for a new requested coverage limit. Made internal function because this should only be called by activatePolicy() and updateCoverLimit() functions)
• Renamed _activeCoverAmount and activeCoverAmount() to _totalActiveCover and totalActiveCover (rationale - more accurate variable name)
• Created _rewardPoints mapping to enable mechanisms of gifting free cover, and getting referral discounts. Incorporated _rewardPoints mapping into chargePremium() logic.
• Added giftRewardPoints() function to enable governance to gift free points to selected address
• Added _maxChargeablePremium internal state variable and maxChargeablePremium public getter function. Added setMaxChargeablePremium governance function.
• Modified updateCoverLimit(...) function to be accessed be either policy holder or governance, and thus added one parameter uint256 policyID_. Also refactored the function logic.
• Added withdraw() function to enable voluntary withdraws. Enforced condition that user cannot withdraw below a soteriaAccountBalance of “currentCoverLimit * maxChargeablePremium”

DISCUSSED CHANGES THAT I’VE DECIDED TO KEEP IN THIS PR

• Removing _totalPolicyCount in favour of using ERC721.totalSupply(). OpenZeppelin implementation of the ERC721 standard does not have a totalSupply() method - https://docs.openzeppelin.com/contracts/2.x/api/token/erc721. To get a totalSupply() method, we need to inherit ERC721Enumerable.sol, or the method (saves 70% gas on NFT mint compared to inheriting ERC721Enumerable.sol) described here https://shiny.mirror.xyz/OUampBbIz9ebEicfGnQf5At_ReMHlZy0tB4glb9xQ0E. Given that both these methods involve bloating the code considerably, in comparison to what we already have with _totalPolicyCount, I propose to keep _totalPolicyCount as it is.
• Storing booleans as a single bit. (refer to https://mudit.blog/solidity-tips-and-tricks-to-save-gas-and-reduce-bytecode-size/#2a76) (My thoughts are we don’t need to use this, we are only using a single boolean storage variable (_paused) in our contract, this trick becomes useful when we want to store >32 booleans)

[leonardishere]

Removing _totalPolicyCount in favour of using ERC721.totalSupply(). OpenZeppelin implementation of the ERC721 standard does not have a totalSupply() method - https://docs.openzeppelin.com/contracts/2.x/api/token/erc721. To get a totalSupply() method, we need to inherit ERC721Enumerable.sol, or the method (saves 70% gas on NFT mint compared to inheriting ERC721Enumerable.sol) described here https://shiny.mirror.xyz/OUampBbIz9ebEicfGnQf5At_ReMHlZy0tB4glb9xQ0E. Given that both these methods involve bloating the code considerably, in comparison to what we already have with _totalPolicyCount, I propose to keep _totalPolicyCount as it is.

I just read the mirror article. _totalPolicyCount acts as a counter as described in the article so this implementation should be more efficient but I haven't gone that deep into testing gas costs.

Since Soteria uses 1 account - 1 policy it might not be necessary to inherit ERC721Enumerable but it would be nice to have some of the functions in case they need to be indexed.

function totalSupply() external view returns (uint256) { return _totalPolicyCount; }
function tokenByIndex(uint256 index) external view returns (uint256) { require(index < _totalPolicyCount); return index+1 }
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256) { require(index == 0); uint256 policyID = _policyOf[owner]; require(policyID != 0); return policyID; }

It might be possible to cut down on the size of the code by overwriting the transfer functionality like https://github.com/solace-fi/solace-core/blob/feat/xSOLACEv2/contracts/xSOLACE.sol#L120-L163. maybe not

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);

[leonardishere]

I also recommend something like this for tokenURI https://github.com/solace-fi/solace-core/blob/feat/xSOLACEv2/contracts/ERC721Enhanced2.sol#L144-L173 https://github.com/solace-fi/solace-core/blob/df60c301e4dce9c2465d0f660e1488d82e9fb3c8/contracts/xsLocker.sol#L388-L396