Feature/extra cover tests

contracts/interfaces/ICover.sol

@@ -133,7 +133,7 @@ interface ICover {
 
   function totalActiveCoverInAsset(uint24 coverAsset) external view returns (uint);
 
-  function calculateCapacity(uint staked, uint capacityReductionRatio) external view returns (uint);
+  function globalCapacityRatio() external view returns (uint24);
 
   /* === MUTATIVE FUNCTIONS ==== */
 
@@ -166,7 +166,7 @@ interface ICover {
     string[] calldata ipfsMetadata
   ) external;
 
-  function performPayoutBurn(
+  function performStakeBurn(
     uint coverId,
     uint segmentId,
     uint amount

contracts/interfaces/IPool.sol

@@ -81,5 +81,7 @@ interface IPool {
 
   function getMCRRatio() external view returns (uint);
 
+  function deprecatedCoverAssetsBitmap() external view returns (uint32);
+
   function setSwapValue(uint value) external;
 }

contracts/mocks/Claims/CLMockCover.sol

@@ -10,7 +10,7 @@ contract CLMockCover {
 
   IERC721Mock public immutable coverNFT;
 
-  struct PerformPayoutBurnCalledWith {
+  struct PerformStakeBurnCalledWith {
     uint coverId;
     uint segmentId;
     uint amount;
@@ -22,7 +22,7 @@ contract CLMockCover {
     address toNewOwner;
   }
 
-  PerformPayoutBurnCalledWith public performPayoutBurnCalledWith;
+  PerformStakeBurnCalledWith public performStakeBurnCalledWith;
   MigrateCoverFromOwnerCalledWith public migrateCoverFromOwnerCalledWith;
   CoverData[] public coverData;
   mapping(uint => CoverSegment[]) _coverSegments;
@@ -122,8 +122,8 @@ contract CLMockCover {
     _products.push(product);
   }
 
-  function performPayoutBurn(uint coverId, uint segmentId, uint amount) external returns (address) {
-    performPayoutBurnCalledWith = PerformPayoutBurnCalledWith(coverId, segmentId, amount);
+  function performStakeBurn(uint coverId, uint segmentId, uint amount) external returns (address) {
+    performStakeBurnCalledWith = PerformStakeBurnCalledWith(coverId, segmentId, amount);
     return coverNFT.ownerOf(coverId);
   }
 

contracts/mocks/Cover/CoverMockPool.sol

@@ -9,6 +9,8 @@ contract CoverMockPool {
   mapping (uint => uint) prices;
   IPool.Asset[] public coverAssets;
 
+  uint32 public deprecatedCoverAssetsBitmap;
+
   address constant public ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
 
   constructor() {
@@ -30,6 +32,10 @@ contract CoverMockPool {
     }
   }
 
+  function setDeprecatedCoverAssetsBitmap(uint32 bitmap) external {
+    deprecatedCoverAssetsBitmap = bitmap;
+  }
+
   fallback() external payable {}
 
   receive() external payable {}

contracts/mocks/Cover/CoverMockStakingPool.sol

@@ -12,6 +12,13 @@ import "../../modules/staking/StakingPool.sol";
 
 contract CoverMockStakingPool is IStakingPool, ERC721 {
 
+  struct BurnStakeCalledWith {
+    uint productId;
+    uint start;
+    uint period;
+    uint amount;
+  }
+
   /* immutables */
   address public immutable memberRoles;
 
@@ -29,6 +36,8 @@ contract CoverMockStakingPool is IStakingPool, ERC721 {
   uint public totalSupply;
   address public manager;
 
+  BurnStakeCalledWith public burnStakeCalledWith;
+
   constructor (
     address /* _nxm */,
     address /* _coverContract */,
@@ -161,8 +170,9 @@ contract CoverMockStakingPool is IStakingPool, ERC721 {
     // noop
   }
 
-  function burnStake(uint /* productId */, uint /* start */, uint /* period */, uint /* amount */) external {
+  function burnStake(uint productId, uint start, uint period, uint amount) external {
     // no-op
+    burnStakeCalledWith = BurnStakeCalledWith(productId, start, period, amount);
   }
 
   function depositTo(DepositRequest[] memory /* requests */) external returns (uint[] memory /* tokenIds */) {

contracts/mocks/Disposables/DisposableGovernance.sol

@@ -124,7 +124,7 @@ contract DisposableGovernance is IGovernance, LegacyMasterAware {
 
   function createProposalwithSolution(string calldata, string calldata, string calldata, uint, string calldata, bytes calldata) external {}
 
-  function submitVote(uint, uint) external {}
+  function submitVote(uint, uint, uint[] calldata) external {}
 
   function closeProposal(uint) external {}
 

contracts/mocks/Incidents/ICMockCover.sol

@@ -7,7 +7,7 @@ import "../../interfaces/IERC721Mock.sol";
 
 contract ICMockCover {
 
-  struct PerformPayoutBurnCalledWith {
+  struct PerformStakeBurnCalledWith {
     uint coverId;
     uint segmentId;
     uint amount;
@@ -16,7 +16,7 @@ contract ICMockCover {
   IERC721Mock public immutable coverNFT;
 
   CoverData[] public coverData;
-  PerformPayoutBurnCalledWith public performPayoutBurnCalledWith;
+  PerformStakeBurnCalledWith public performStakeBurnCalledWith;
   mapping(uint => CoverSegment[]) _coverSegments;
 
   mapping(uint => PoolAllocation[]) poolAllocations;
@@ -121,8 +121,8 @@ contract ICMockCover {
   }
 
 
-  function performPayoutBurn(uint coverId, uint segmentId, uint amount) external returns (address) {
-    performPayoutBurnCalledWith = PerformPayoutBurnCalledWith(coverId, segmentId, amount);
+  function performStakeBurn(uint coverId, uint segmentId, uint amount) external returns (address) {
+    performStakeBurnCalledWith = PerformStakeBurnCalledWith(coverId, segmentId, amount);
     return coverNFT.ownerOf(coverId);
   }
 }

contracts/mocks/integration/IntegrationMockStakingPool.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.8.9;
+
+import "@openzeppelin/contracts-v4/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts-v4/token/ERC721/ERC721.sol";
+import "@openzeppelin/contracts-v4/utils/Strings.sol";
+
+import "../../modules/staking/StakingPool.sol";
+
+contract IntegrationMockStakingPool is StakingPool {
+
+  /* immutables */
+  address public immutable memberRoles;
+
+  mapping (uint => uint) public usedCapacity;
+  mapping (uint => uint) public stakedAmount;
+
+  mapping (uint => uint) public mockPrices;
+
+  uint public constant MAX_PRICE_RATIO = 1e20;
+
+  constructor (
+    address _nxm,
+    address _coverContract,
+    ITokenController _tokenController,
+    address _memberRoles
+  )
+    StakingPool("Nexus Mutual Staking Pool", "NMSPT", _nxm, _coverContract, _tokenController)
+  {
+    memberRoles = _memberRoles;
+  }
+
+  function name() public view override returns (string memory) {
+    return string(abi.encodePacked(super.name(), " ", Strings.toString(poolId)));
+  }
+
+  function initialize(address _manager, uint _poolId) external /*override*/ {
+    _mint(_manager, totalSupply++);
+    poolId = _poolId;
+  }
+
+  function operatorTransferFrom(address from, address to, uint256 amount) external /*override*/ {
+    require(msg.sender == memberRoles, "StakingPool: Caller is not MemberRoles");
+    _transfer(from, to, amount);
+  }
+
+  function allocateCapacity(
+    uint productId,
+    uint amountInNXM,
+    uint period,
+    uint rewardRatio,
+    uint initialPriceRatio
+  ) external /*override*/ returns (uint coveredAmountInNXM, uint premiumInNXM) {
+    period;
+    rewardRatio;
+    initialPriceRatio;
+    usedCapacity[productId] += amountInNXM;
+    return (amountInNXM, calculatePremium(mockPrices[productId], amountInNXM, period));
+  }
+
+  function calculatePremium(uint priceRatio, uint coverAmount, uint period) public pure returns (uint) {
+    return priceRatio * coverAmount / MAX_PRICE_RATIO * period / 365 days;
+  }
+
+  function stake(uint amount) external {
+    _mint(msg.sender, amount);
+  }
+
+  function freeCapacity(
+    uint productId,
+    uint previousPeriod,
+    uint previousStartTime,
+    uint previousRewardAmount,
+    uint periodReduction,
+    uint coveredAmount
+  ) external /*override*/ {
+    // no-op
+  }
+
+  function getAvailableCapacity(uint productId, uint capacityFactor) external /*override*/ view returns (uint) {
+    return stakedAmount[productId] * capacityFactor - usedCapacity[productId];
+  }
+
+  function getCapacity(uint productId, uint capacityFactor) external /*override*/ view returns (uint) {
+    return stakedAmount[productId] * capacityFactor;
+  }
+
+  function getUsedCapacity(uint productId) external /*override*/ view returns (uint) {
+    return usedCapacity[productId];
+  }
+
+  function getTargetPrice(uint productId) external /*override*/ view returns (uint) {
+    return products[productId].targetPrice;
+  }
+
+  function getStake(uint productId) external /*override*/ view returns (uint) {
+    return stakedAmount[productId];
+  }
+
+  function setUsedCapacity(uint productId, uint amount) external {
+    usedCapacity[productId] = amount;
+  }
+
+  function setTargetPrice(uint productId, uint amount) external {
+    products[productId].targetPrice = uint96(amount);
+  }
+
+  function setStake(uint productId, uint amount) external {
+    stakedAmount[productId] = amount;
+  }
+
+  function setPrice(uint productId, uint price) external {
+    mockPrices[productId] = price;
+  }
+
+  function changeMasterAddress(address payable _a) external {
+    // noop
+  }
+
+  function changeDependentContractAddress() external {
+    // noop
+  }
+}

contracts/modules/assessment/IndividualClaims.sol

@@ -351,7 +351,7 @@ contract IndividualClaims is IIndividualClaims, MasterAwareV2 {
     require(!claim.payoutRedeemed, "Payout has already been redeemed");
     claims[claimId].payoutRedeemed = true;
 
-    address payable coverOwner = payable(cover().performPayoutBurn(
+    address payable coverOwner = payable(cover().performStakeBurn(
       claim.coverId,
       claim.segmentId,
       claim.amount

contracts/modules/assessment/YieldTokenIncidents.sol

@@ -285,7 +285,7 @@ contract YieldTokenIncidents is IYieldTokenIncidents, MasterAwareV2 {
     }
 
     require(payoutAmount <= coverSegment.amount, "Payout exceeds covered amount");
-    coverContract.performPayoutBurn(coverId, segmentId, payoutAmount);
+    coverContract.performStakeBurn(coverId, segmentId, payoutAmount);
     SafeERC20.safeTransferFrom(
       IERC20(product.productAddress),
       msg.sender,

contracts/modules/capital/Pool.sol

@@ -41,7 +41,7 @@ contract Pool is IPool, MasterAware, ReentrancyGuard {
   address public swapOperator;
 
   // Binary map where each on bit, starting from the LSB, represents whether the cover asset found
-  // at the same index as the bit's position should be ignored when calulating the value of the pool
+  // at the same index as the bit's position should be ignored when calculating the value of the pool
   // in ETH.
   //
   // Examples: