Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity ^0.8.18;

import "@openzeppelin/contracts-v4/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts-v4/utils/cryptography/ECDSA.sol";

import "../../abstract/MasterAwareV2.sol";
import "../../interfaces/IPool.sol";
import "../../interfaces/IMemberRoles.sol";
import "../../interfaces/IQuotationData.sol";
import "../../interfaces/ITokenController.sol";
import "../../interfaces/ICover.sol";
import "../../interfaces/ISAFURAToken.sol";
import "../../interfaces/IStakingPool.sol";
import "../../interfaces/IPooledStaking.sol";
import "../../interfaces/IAssessment.sol";
import "./external/Governed.sol";

contract MemberRoles is IMemberRoles, Governed, MasterAwareV2 {

  struct MemberRoleDetails {
    uint memberCounter;
    mapping(address => bool) memberActive;
    address[] memberAddress;
    address authorized;
  }

  // used to be ITokenController public tc;
  address internal _unused5;
  // used to be address payable public poolAddress;
  address internal _unused6;

  address public kycAuthAddress;
  // used to be ICover internal cover;
  address internal _unused7;
  address internal _unused0;
  address internal _unused1;
  // used to be ISAFURAToken public nxm;
  address internal _unused8;

  MemberRoleDetails[] internal memberRoleData;
  bool internal _unused2;

  uint public maxABCount;
  bool public launched;
  uint public launchedOn;

  mapping(address => address) internal _unused3;
  mapping(address => bool) internal _unused4;

  mapping(bytes32 => bool) public usedMessageHashes;

  // Prefixes for ECDSA signatures' scope
  bytes32 public constant MEMBERSHIP_APPROVAL = bytes32('MEMBERSHIP_APPROVAL');
  uint public constant joiningFee = 0.002 ether;

  ISAFURAToken public immutable token;

  modifier checkRoleAuthority(uint _memberRoleId) {
    if (memberRoleData[_memberRoleId].authorized != address(0)) {
      require(msg.sender == memberRoleData[_memberRoleId].authorized);
    } else {
      require(master.checkIsAuthToGoverned(msg.sender), "Not Authorized");
    }
    _;
  }

  constructor(address tokenAddress) {
    token = ISAFURAToken(tokenAddress);
  }

  /// Replaces an advisory board member with another.
  ///
  /// @param _newABAddress  The address of new advisory board member
  /// @param _removeAB      The advisory board member to be removed
  function swapABMember(
    address _newABAddress,
    address _removeAB
  ) external checkRoleAuthority(uint(Role.AdvisoryBoard)) {
    _updateRole(_newABAddress, uint(Role.AdvisoryBoard), true);
    _updateRole(_removeAB, uint(Role.AdvisoryBoard), false);
  }

  /// Changes the maximum number of advisory board members.
  ///
  /// @param _val  The new maximum number of advisory board members.
  function changeMaxABCount(uint _val) external onlyGovernance {
    maxABCount = _val;
  }

  /// Sets the address of kyc notarising address.
  ///
  /// @param _add is the new address
  function setKycAuthAddress(address _add) external onlyGovernance {
    kycAuthAddress = _add;
  }

    /// Sets the address of kyc notarising address. callable by Advisory Board members
  ///
  /// @param _add is the new address
  function setKycAuthAddressAB(address _add) external {
    require(checkRole(msg.sender, uint(Role.AdvisoryBoard)), "only by advisory boad member");
    kycAuthAddress = _add;
  }

  /* ========== DEPENDENCIES ========== */

  function pool() internal view returns (IPool) {
    return IPool(internalContracts[uint(ID.P1)]);
  }

  function tokenController() internal view returns (ITokenController) {
    return ITokenController(internalContracts[uint(ID.TC)]);
  }

  function cover() internal view returns (ICover) {
    return ICover(internalContracts[uint(ID.CO)]);
  }

  function legacyPooledStaking() internal view returns (IPooledStaking) {
    return IPooledStaking(internalContracts[uint(ID.PS)]);
  }

  function assessment() internal view returns (IAssessment) {
    return IAssessment(internalContracts[uint(ID.AS)]);
  }

  /// Updates contracts dependencies.
  ///
  /// @dev Iupgradable Interface to update dependent contract address
  function changeDependentContractAddress() public override {
    // qd storage variable was renamed to kycAuthAddress hence this check handles the migration
    // 0x1776651F58a17a50098d31ba3C3cD259C1903f7A is the address of QuotationData

    if (kycAuthAddress == 0x1776651F58a17a50098d31ba3C3cD259C1903f7A) {
      kycAuthAddress = IQuotationData(0x1776651F58a17a50098d31ba3C3cD259C1903f7A).kycAuthAddress();
    }

    internalContracts[uint(ID.TC)] = master.getLatestAddress("TC");
    internalContracts[uint(ID.P1)] = master.getLatestAddress("P1");
    internalContracts[uint(ID.CO)] = master.getLatestAddress("CO");
    internalContracts[uint(ID.PS)] = master.getLatestAddress("PS");
    internalContracts[uint(ID.AS)] = master.getLatestAddress("AS");
  }

  /// Adds a new member role.
  ///
  /// @param _roleName         New role name.
  /// @param _roleDescription  New description hash.
  /// @param _authorized       Authorized member against every role id.
  function addRole(
    bytes32 _roleName,
    string memory _roleDescription,
    address _authorized
  ) public onlyGovernance {
    _addRole(_roleName, _roleDescription, _authorized);
  }

  /// Adds an auditor to the system.
  ///
  /// @param _memberAddress The address of the auditor to add.
  function addAuditor(address _memberAddress) external {
    require(checkRole(msg.sender, uint(Role.AdvisoryBoard)), "Caller is not an advisory board member");

    _updateRole(_memberAddress, uint(Role.Auditor), true); //solhint-disable-line
  }

  /// Removes an auditor from the system.
  ///
  /// @param _memberAddress The address of the auditor to remove.
  function removeAuditor(address _memberAddress) external {
    require(checkRole(msg.sender, uint(Role.AdvisoryBoard)), "Caller is not an advisory board member");

    _updateRole(_memberAddress, uint(Role.Auditor), false);
  }

  /// Assign or Delete a member from a specific role.
  ///
  /// @param _memberAddress  Address of the scoped member.
  /// @param _roleId         The role id to update.
  /// @param _active         True if we want to assign this role to member or false otherwise.
  function updateRole(
    address _memberAddress,
    uint _roleId,
    bool _active
  ) public checkRoleAuthority(_roleId) {
    _updateRole(_memberAddress, _roleId, _active);
  }

  /// Finalises the sign up process by allowing the user to pay the joining fee and marks the
  /// address as a member.
  ///
  /// @dev A signature is required to verify if the address was approved. It is verified against
  /// the address and a nonce (incremented if a new signature is required for the same address).
  ///
  /// @param _userAddress  The address of the user for whom the joining fee is paid.
  /// @param nonce        Signers nonce. Increments if new signature needed for the same address
  /// @param  signature   The signed message hash
  function join(
    address _userAddress,
    uint nonce,
    bytes calldata signature
  ) public override payable {
    require(_userAddress != address(0), "MemberRoles: Address 0 cannot be used");
    require(!master.isPause(), "MemberRoles: Emergency pause applied");
    require(!isMember(_userAddress), "MemberRoles: This address is already a member");
    require(
      msg.value == joiningFee,
      "MemberRoles: The transaction value should equal to the joining fee"
    );

    // Reconstruct the original message hash.
    bytes32 messageHash = keccak256(abi.encode(MEMBERSHIP_APPROVAL, nonce, _userAddress, block.chainid));

    // Verify if the message hash hasn't been used before. If it has, it means that the nonce for
    // the given _userAddress needs to be higher and the signature should use the first available
    // one.
    require(
      usedMessageHashes[messageHash] == false,
      "MemberRoles: Signature already used"
    );

    // Mark it as used to avoid whitelisting an unbounded number of addresses when combining this
    // function with the switchMembership function.
    usedMessageHashes[messageHash] = true;

    // Signatures are obtained by signing the hash of the messageHash prefixed with
    // "\x19Ethereum Signed Message:\n32". This gives us the actual hash that was signed off chain.
    bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(messageHash);

    // Verify the signature to see if membership has been approved.
    address recoveredAddress = ECDSA.recover(ethSignedMessageHash, signature);
    require(recoveredAddress == kycAuthAddress, "MemberRoles: Signature is invalid");

    // Whitelist the address.
    tokenController().addToWhitelist(_userAddress);
    _updateRole(_userAddress, uint(Role.Member), true);

    // Transfer the joining fee to the pool.
    (bool ok, /* data */) = address(pool()).call{value: joiningFee}("");
    require(ok, "MemberRoles: The joining fee transfer to the pool failed");

    emit MemberJoined(_userAddress, nonce);
  }

  /// Withdraws membership
  function withdrawMembership() public whenNotPaused {

    ITokenController _tokenController = tokenController();

    require(isMember(msg.sender), "MemberRoles: Caller is not a member");

    require(
      block.timestamp > token.isLockedForMV(msg.sender),
      "MemberRoles: Locked for voting in governance"
    );

    require(
      tokenController().isStakingPoolManager(msg.sender) == false,
      "MemberRoles: Member is a staking pool manager"
    );

    IPooledStaking _legacyPooledStaking = legacyPooledStaking();

    // check that there are no tokens left to withdraw
    require(_legacyPooledStaking.stakerDeposit(msg.sender) == 0, "Member has NXM staked in Pooled Staking");
    require(_legacyPooledStaking.stakerReward(msg.sender) == 0, "Member has NXM rewards in Pooled Staking");

    require(_tokenController.tokensLocked(msg.sender, "CLA") == 0, "Member has NXM staked in Claim Assessment V1");
    (, , uint coverNotesAmount) = _tokenController.getWithdrawableCoverNotes(msg.sender);
    require(coverNotesAmount == 0, "Member has withdrawable cover notes");
    // _tokenController.getPendingRewards includes both assessment and governance rewards
    require(_tokenController.getPendingRewards(msg.sender) == 0, "Member has pending rewards in Token Controller");

    (uint96 stakeAmount, ,) = assessment().stakeOf(msg.sender);
    require(stakeAmount == 0, "Member has Assessment stake");

    _tokenController.burnFrom(msg.sender, token.balanceOf(msg.sender));
    _updateRole(msg.sender, uint(Role.Member), false);
    _tokenController.removeFromWhitelist(msg.sender); // need clarification on whitelist

    emit MembershipWithdrawn(msg.sender, block.timestamp);
  }

  /// Switches membership from the sender's address to a new address.
  /// @param newAddress  The new address where membership will be switched to.
  function switchMembership(address newAddress) external override {
    _switchMembership(msg.sender, newAddress);
    token.transferFrom(msg.sender, newAddress, token.balanceOf(msg.sender));
    tokenController().transferStakingPoolsOwnership(msg.sender, newAddress);
  }

  /// Switches the membership from the sender's address to the new address and transfers the
  /// sender's assets in a single transaction.
  ///
  /// @param newAddress           Address of user to forward membership.
  /// @param coverIds             Array of cover ids to transfer to the new address.
  /// @param stakingTokenIds      Arrays of staking nft token ids to transfer to the new address.
  ///                             through stakingPool parameter.
  function switchMembershipAndAssets(
    address newAddress,
    uint[] calldata coverIds,
    uint[] calldata stakingTokenIds
  ) external override {

    _switchMembership(msg.sender, newAddress);
    token.transferFrom(msg.sender, newAddress, token.balanceOf(msg.sender));
    tokenController().transferStakingPoolsOwnership(msg.sender, newAddress);

    ICover _cover = cover();

    // Transfer the cover NFTs to the new address, if any were given
    if (coverIds.length > 0) {
      ICoverNFT coverNFT = _cover.coverNFT();
      for (uint i = 0; i < coverIds.length; i++) {
        coverNFT.transferFrom(msg.sender, newAddress, coverIds[i]);
      }
    }

    // Transfer the staking pool NFTs to the new address, if any were given
    if (stakingTokenIds.length > 0) {
      IStakingNFT stakingNFT = _cover.stakingNFT();
      for (uint i = 0; i < stakingTokenIds.length; i++) {
        stakingNFT.transferFrom(msg.sender, newAddress, stakingTokenIds[i]);
      }
    }
  }

  function switchMembershipOf(address member, address newAddress) external override onlyInternal {
    _switchMembership(member, newAddress);
  }

  function storageCleanup(address[] memory payoutAddresses) external {
    _unused0 = 0x0000000000000000000000000000000000000000;
    _unused1 = 0x0000000000000000000000000000000000000000;
    _unused2 = false;
    _unused3[0x181Aea6936B407514ebFC0754A37704eB8d98F91] = payable(0x0000000000000000000000000000000000000000);
    _unused5 = 0x0000000000000000000000000000000000000000;
    _unused6 = 0x0000000000000000000000000000000000000000;
    _unused7 = 0x0000000000000000000000000000000000000000;
    _unused8 = 0x0000000000000000000000000000000000000000;

    for (uint i = 0; i < payoutAddresses.length; i++) {
      delete _unused3[payoutAddresses[i]];
    }
  }

  function isMember(address member) public view returns (bool) {
    return checkRole(member, uint(IMemberRoles.Role.Member));
  }

  function _switchMembership(address currentAddress, address newAddress) internal {
    require(!master.isPause(), "System is paused");
    require(isMember(currentAddress), "The current address is not a member");
    require(!isMember(newAddress), "The new address is already a member");
    // No locked tokens for Governance voting
    require(block.timestamp > token.isLockedForMV(currentAddress), "Locked for governance voting");

    ITokenController _tokenController = tokenController();
    IPooledStaking _legacyPooledStaking = legacyPooledStaking();

    // check that there are no tokens left to withdraw
    require(_legacyPooledStaking.stakerDeposit(currentAddress) == 0, "Member has NXM staked in Pooled Staking");
    require(_legacyPooledStaking.stakerReward(currentAddress) == 0, "Member has NXM rewards in Pooled Staking");

    require(_tokenController.tokensLocked(currentAddress, "CLA") == 0, "Member has NXM staked in Claim Assessment V1");
    (, , uint coverNotesAmount) = _tokenController.getWithdrawableCoverNotes(currentAddress);
    require(coverNotesAmount == 0, "Member has withdrawable cover notes");
    // _tokenController.getPendingRewards includes both assessment and governance rewards
    require(_tokenController.getPendingRewards(currentAddress) == 0, "Member has pending rewards in Token Controller");

    (uint96 stakeAmount, ,) = assessment().stakeOf(currentAddress);
    require(stakeAmount == 0, "Member has Assessment stake");


    _tokenController.addToWhitelist(newAddress);
    _updateRole(currentAddress, uint(Role.Member), false);
    _updateRole(newAddress, uint(Role.Member), true);

    if (checkRole(currentAddress, uint(Role.AdvisoryBoard))) {
      _updateRole(currentAddress, uint(Role.AdvisoryBoard), false);
      _updateRole(newAddress, uint(Role.AdvisoryBoard), true);
    }

    _tokenController.removeFromWhitelist(currentAddress);

    emit switchedMembership(currentAddress, newAddress, block.timestamp);
  }

  /// Returns the number of member roles.
  function totalRoles() public override view returns (uint256) {//solhint-disable-line
    return memberRoleData.length;
  }

  /// Changes the member address who holds the authority to add or delete any member from specific
  /// role.
  ///
  /// @param _roleId         The role id to update its authorized address.
  /// @param _newAuthorized  The new authorized address against role id.
  function changeAuthorized(
    uint _roleId,
    address _newAuthorized
  ) public override checkRoleAuthority(_roleId) {//solhint-disable-line
    memberRoleData[_roleId].authorized = _newAuthorized;
  }

  /// Gets the member addresses assigned by a specific role.
  ///
  /// @param _memberRoleId  Member role id.
  /// @return roleId        Role id.
  /// @return memberArray   Member addresses of specified role id.
  function members(
    uint _memberRoleId
  ) public override view returns (uint, address[] memory memberArray) {//solhint-disable-line
    uint length = memberRoleData[_memberRoleId].memberAddress.length;
    uint i;
    uint j = 0;
    memberArray = new address[](memberRoleData[_memberRoleId].memberCounter);
    for (i = 0; i < length; i++) {
      address member = memberRoleData[_memberRoleId].memberAddress[i];
      if (memberRoleData[_memberRoleId].memberActive[member] && !_checkMemberInArray(member, memberArray)) {//solhint-disable-line
        memberArray[j] = member;
        j++;
      }
    }

    return (_memberRoleId, memberArray);
  }

  /// Gets all members' length
  ///
  /// @param _memberRoleId                                 The member role id
  ///
  /// @return memberRoleData[_memberRoleId].memberCounter  Total number of members with the given
  /// role id.
  function numberOfMembers(
    uint _memberRoleId
  ) public override view returns (uint) {//solhint-disable-line
    return memberRoleData[_memberRoleId].memberCounter;
  }

  /// Returns the member address who holds the right to add or remove any member from specific role.
  function authorized(
    uint _memberRoleId
  ) public override view returns (address) {//solhint-disable-line
    return memberRoleData[_memberRoleId].authorized;
  }

  /// Returns all role ids that have been assigned to a member so far.
  function roles(
    address _memberAddress
  ) public override view returns (uint[] memory) {//solhint-disable-line
    uint length = memberRoleData.length;
    uint[] memory assignedRoles = new uint[](length);
    uint counter = 0;
    for (uint i = 1; i < length; i++) {
      if (memberRoleData[i].memberActive[_memberAddress]) {
        assignedRoles[counter] = i;
        counter++;
      }
    }
    return assignedRoles;
  }

  /// Returns true if the given role id is assigned to a member.
  ///
  /// @param _memberAddress  Address of member.
  /// @param _roleId         The role id for which member address is checked against.
  function checkRole(
    address _memberAddress,
    uint _roleId
  ) public override view returns (bool) {//solhint-disable-line
    if (_roleId == uint(Role.Unassigned))
      return true;
    else
      if (memberRoleData[_roleId].memberActive[_memberAddress]) //solhint-disable-line
        return true;
      else
        return false;
  }

  /// Returns the total number of members assigned against each role id.
  ///
  /// @return totalMembers  Total number of members for each particular role id
  function getMemberLengthForAllRoles() public override view returns (
    uint[] memory totalMembers
  ) {//solhint-disable-line
    totalMembers = new uint[](memberRoleData.length);
    for (uint i = 0; i < memberRoleData.length; i++) {
      totalMembers[i] = numberOfMembers(i);
    }
  }

  /// Update the member roles
  ///
  /// @param _memberAddress in concern
  /// @param _roleId the id of role
  /// @param _active if active is true, add the member, else remove it
  function _updateRole(address _memberAddress,
    uint _roleId,
    bool _active) internal {
    // require(_roleId != uint(Role.TokenHolder), "Membership to Token holder is detected automatically");
    if (_active) {
      require(!memberRoleData[_roleId].memberActive[_memberAddress]);
      memberRoleData[_roleId].memberCounter = memberRoleData[_roleId].memberCounter + 1;
      memberRoleData[_roleId].memberActive[_memberAddress] = true;
      memberRoleData[_roleId].memberAddress.push(_memberAddress);
    } else {
      require(memberRoleData[_roleId].memberActive[_memberAddress]);
      memberRoleData[_roleId].memberCounter = memberRoleData[_roleId].memberCounter - 1;
      delete memberRoleData[_roleId].memberActive[_memberAddress];
    }
  }

  /// Adds a new member role.
  ///
  /// @param _roleName         New role name.
  /// @param _roleDescription  New description hash.
  /// @param _authorized       Authorized member against every role id.
  function _addRole(
    bytes32 _roleName,
    string memory _roleDescription,
    address _authorized
  ) internal {
    emit MemberRole(memberRoleData.length, _roleName, _roleDescription);
    MemberRoleDetails storage newMemberRoleData = memberRoleData.push();
    newMemberRoleData.memberCounter = 0;
    newMemberRoleData.memberAddress = new address[](0);
    newMemberRoleData.authorized = _authorized;
  }

  /// Checks if a member address is in the given members array.
  ///
  /// @param _memberAddress  The address that's checked against memberArray.
  /// @param memberArray     Array of member addresses.
  /// @return memberExists   True if the member exists.
  function _checkMemberInArray(
    address _memberAddress,
    address[] memory memberArray
  )
  internal
  pure
  returns (bool memberExists)
  {
    uint i;
    for (i = 0; i < memberArray.length; i++) {
      if (memberArray[i] == _memberAddress) {
        memberExists = true;
        break;
      }
    }
  }

  /// Returns the member address and it's status for a given role and address index.
  ///
  /// @param _memberRoleId  The role id of the member.
  /// @param index          The index of the member in the memberAddress list.
  function memberAtIndex(
    uint _memberRoleId,
    uint index
  ) external override view returns (address, bool) {
    address memberAddress = memberRoleData[_memberRoleId].memberAddress[index];
    return (memberAddress, memberRoleData[_memberRoleId].memberActive[memberAddress]);
  }

  /// Returns the total number of addresses asigned to a given role.
  ///
  /// @param _memberRoleId  The role id for which the total address count is requested.
  function membersLength(
    uint _memberRoleId
  ) external override view returns (uint) {
    return memberRoleData[_memberRoleId].memberAddress.length;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity ^0.8.18;

import "../interfaces/ISAFURAMaster.sol";
import "../interfaces/IMasterAwareV2.sol";
import "../interfaces/IMemberRoles.sol";

abstract contract MasterAwareV2 is IMasterAwareV2 {

  ISAFURAMaster public master;

  mapping(uint => address payable) public internalContracts;

  modifier onlyMember {
    require(
      IMemberRoles(internalContracts[uint(ID.MR)]).checkRole(
        msg.sender,
        uint(IMemberRoles.Role.Member)
      ),
      "Caller is not a member"
    );
    _;
  }

  modifier onlyAdvisoryBoard {
    require(
      IMemberRoles(internalContracts[uint(ID.MR)]).checkRole(
        msg.sender,
        uint(IMemberRoles.Role.AdvisoryBoard)
      ),
      "Caller is not an advisory board member"
    );
    _;
  }

  modifier onlyInternal {
    require(master.isInternal(msg.sender), "Caller is not an internal contract");
    _;
  }

  modifier onlyMaster {
    if (address(master) != address(0)) {
      require(address(master) == msg.sender, "Not master");
    }
    _;
  }

  modifier onlyGovernance {
    require(
      master.checkIsAuthToGoverned(msg.sender),
      "Caller is not authorized to govern"
    );
    _;
  }

  modifier onlyEmergencyAdmin {
    require(
      msg.sender == master.emergencyAdmin(),
      "Caller is not emergency admin"
    );
    _;
  }

  modifier whenPaused {
    require(master.isPause(), "System is not paused");
    _;
  }

  modifier whenNotPaused {
    require(!master.isPause(), "System is paused");
    _;
  }

  function getInternalContractAddress(ID id) internal view returns (address payable) {
    return internalContracts[uint(id)];
  }

  function changeMasterAddress(address masterAddress) public onlyMaster {
    master = ISAFURAMaster(masterAddress);
  }

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IAssessment {

  /* ========== DATA STRUCTURES ========== */

  enum UintParams {
    minVotingPeriodInDays,
    stakeLockupPeriodInDays,
    payoutCooldownInDays,
    silentEndingPeriodInDays
  }

  struct Configuration {
    // The minimum number of days the users can vote on polls
    uint8 minVotingPeriodInDays;

    // Number of days the users must wait from their last vote to withdraw their stake.
    uint8 stakeLockupPeriodInDays;

    // Number of days the users must wait after a poll closes to redeem payouts.
    uint8 payoutCooldownInDays;

    // Number of days representing the silence period. It is used to extend a poll's end date when
    // a vote is cast during the silence period before the end date.
    uint8 silentEndingPeriodInDays;
  }

  struct Stake {
    uint96 amount;
    uint104 rewardsWithdrawableFromIndex;
    uint16 fraudCount;
    /*uint32 unused,*/
  }

  // Holds data for a vote belonging to an assessor.
  //
  // The structure is used to keep track of user's votes. Each vote is used to determine
  // a user's share of rewards or to create a fraud resolution which excludes fraudulent votes
  // from the initial poll.
  struct Vote {
    // Identifier of the claim or incident
    uint80 assessmentId;

    // If the assessor votes to accept the event it's true otherwise it's false
    bool accepted;

    // Date and time when the vote was cast
    uint32 timestamp;

    // How many tokens were staked when the vote was cast
    uint96 stakedAmount;
  }

  // Holds poll results for an assessment.
  //
  // The structure is used to keep track of all votes on a given assessment such as how many NXM were
  // used to cast accept and deny votes as well as when the poll started and when it ends.
  struct Poll {
    // The amount of NXM from accept votes
    uint96 accepted;

    // The amount of NXM from deny votes
    uint96 denied;

    // Timestamp of when the poll started.
    uint32 start;

    // Timestamp of when the poll ends.
    uint32 end;
  }

  // Holds data for an assessment belonging to an assessable event (individual claims, yield token
  // incidents etc.).
  //
  // The structure is used to keep track of the total reward that should be distributed to
  // assessors, the assessment deposit the claimants made to start the assessment, and the poll
  // coresponding to this assessment.
  struct Assessment {
    // See Poll struct
    Poll poll;

    // The amount of NXM representing the assessment reward which is split among those who voted.
    uint128 totalRewardInNXM;

    // An amount of ETH which is sent back to the claimant when the poll result is positive,
    // otherwise it is kep it the pool to back the assessment rewards. This allows claimants to
    // open an unlimited amount of claims and prevents unbacked NXM to be minted through the
    // assessment process.
    uint128 assessmentDepositInETH;
  }

  /* ========== VIEWS ========== */

  function getAssessmentsCount() external view returns (uint);

  function assessments(uint id) external view
  returns (Poll memory poll, uint128 totalReward, uint128 assessmentDeposit);

  function getPoll(uint assessmentId) external view returns (Poll memory);

  function getRewards(address user) external view returns (
    uint totalPendingAmount,
    uint withdrawableAmount,
    uint withdrawableUntilIndex
  );

  function getVoteCountOfAssessor(address assessor) external view returns (uint);

  function votesOf(address user, uint id) external view
  returns (uint80 assessmentId, bool accepted, uint32 timestamp, uint96 stakedAmount);

  function stakeOf(address user) external view
  returns (uint96 amount, uint104 rewardsWithdrawableFromIndex, uint16 fraudCount);

  function config() external view returns (
    uint8 minVotingPeriodInDays,
    uint8 stakeLockupPeriodInDays,
    uint8 payoutCooldownInDays,
    uint8 silentEndingPeriodInDays
  );

  function hasAlreadyVotedOn(address voter, uint pollId) external view returns (bool);


  /* === MUTATIVE FUNCTIONS ==== */

  function stake(uint96 amount) external;

  function unstake(uint96 amount, address to) external;

  function withdrawRewards(
    address user,
    uint104 batchSize
  ) external returns (uint withdrawn, uint withdrawnUntilIndex);

  function withdrawRewardsTo(
    address destination,
    uint104 batchSize
  ) external returns (uint withdrawn, uint withdrawnUntilIndex);

  function startAssessment(uint totalReward, uint assessmentDeposit) external
  returns (uint);

  function castVotes(
    uint[] calldata assessmentIds,
    bool[] calldata votes,
    string[] calldata ipfsAssessmentDataHashes,
    uint96 stakeIncrease
  ) external;

  function submitFraud(bytes32 root) external;

  function processFraud(
    uint256 rootIndex,
    bytes32[] calldata proof,
    address assessor,
    uint256 lastFraudulentVoteIndex,
    uint96 burnAmount,
    uint16 fraudCount,
    uint256 voteBatchSize
  ) external;

  function updateUintParameters(UintParams[] calldata paramNames, uint[] calldata values) external;

  /* ========== EVENTS ========== */

  event StakeDeposited(address user, uint104 amount);
  event StakeWithdrawn(address indexed user, address to, uint96 amount);
  event VoteCast(address indexed user, uint256 assessmentId, uint96 stakedAmount, bool accepted, string ipfsAssessmentDataHash);
  event RewardWithdrawn(address user, address to, uint256 amount);
  event FraudProcessed(uint assessmentId, address assessor, Poll poll);
  event FraudSubmitted(bytes32 root);

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "./IStakingPoolFactory.sol";

/**
 * @dev IStakingPoolFactory is missing the changeOperator() and operator() functions.
 * @dev Any change to the original interface will affect staking pool addresses
 * @dev This interface is created to add the missing functions so it can be used in other contracts.
 */
interface ICompleteStakingPoolFactory is IStakingPoolFactory {

  function operator() external view returns (address);

  function changeOperator(address newOperator) external;
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "./ICoverNFT.sol";
import "./IStakingNFT.sol";
import "./IStakingPool.sol";
import "./ICompleteStakingPoolFactory.sol";

/* io structs */

enum ClaimMethod {
  IndividualClaims,
  YieldTokenIncidents
}

struct PoolAllocationRequest {
  uint40 poolId;
  bool skip;
  uint coverAmountInAsset;
}

struct BuyCoverParams {
  uint coverId;
  address owner;
  uint24 productId;
  uint8 coverAsset;
  uint96 amount;
  uint32 period;
  uint maxPremiumInAsset;
  uint8 paymentAsset;
  uint16 commissionRatio;
  address commissionDestination;
  string ipfsData;
}

/* storage structs */

struct PoolAllocation {
  uint40 poolId;
  uint96 coverAmountInNXM;
  uint96 premiumInNXM;
  uint24 allocationId;
}

struct CoverData {
  uint24 productId;
  uint8 coverAsset;
  uint96 amountPaidOut;
}

struct CoverSegment {
  uint96 amount;
  uint32 start;
  uint32 period; // seconds
  uint32 gracePeriod; // seconds
  uint24 globalRewardsRatio;
  uint24 globalCapacityRatio;
}

interface ICover {

  /* ========== DATA STRUCTURES ========== */

  /* internal structs */

  struct RequestAllocationVariables {
    uint previousPoolAllocationsLength;
    uint previousPremiumInNXM;
    uint refund;
    uint coverAmountInNXM;
  }

  /* storage structs */

  struct ActiveCover {
    // Global active cover amount per asset.
    uint192 totalActiveCoverInAsset;
    // The last time activeCoverExpirationBuckets was updated
    uint64 lastBucketUpdateId;
  }

  /* ========== VIEWS ========== */

  function coverData(uint coverId) external view returns (CoverData memory);

  function coverDataCount() external view returns (uint);

  function coverSegmentsCount(uint coverId) external view returns (uint);

  function coverSegments(uint coverId) external view returns (CoverSegment[] memory);

  function coverSegmentWithRemainingAmount(
    uint coverId,
    uint segmentId
  ) external view returns (CoverSegment memory);

  function recalculateActiveCoverInAsset(uint coverAsset) external;

  function totalActiveCoverInAsset(uint coverAsset) external view returns (uint);

  function getGlobalCapacityRatio() external view returns (uint);

  function getGlobalRewardsRatio() external view returns (uint);

  function getGlobalMinPriceRatio() external pure returns (uint);

  function getGlobalCapacityAndPriceRatios() external view returns (
    uint _globalCapacityRatio,
    uint _globalMinPriceRatio
  );

  function GLOBAL_MIN_PRICE_RATIO() external view returns (uint);

  /* === MUTATIVE FUNCTIONS ==== */

  function buyCover(
    BuyCoverParams calldata params,
    PoolAllocationRequest[] calldata coverChunkRequests
  ) external payable returns (uint coverId);

  function burnStake(
    uint coverId,
    uint segmentId,
    uint amount
  ) external returns (address coverOwner);

  function changeStakingPoolFactoryOperator() external;

  function coverNFT() external returns (ICoverNFT);

  function stakingNFT() external returns (IStakingNFT);

  function stakingPoolFactory() external returns (ICompleteStakingPoolFactory);

  /* ========== EVENTS ========== */

  event CoverEdited(uint indexed coverId, uint indexed productId, uint indexed segmentId, address buyer, string ipfsMetadata);

  // Auth
  error OnlyOwnerOrApproved();

  // Cover details
  error CoverPeriodTooShort();
  error CoverPeriodTooLong();
  error CoverOutsideOfTheGracePeriod();
  error CoverAmountIsZero();

  // Products
  error ProductNotFound();
  error ProductDeprecated();
  error UnexpectedProductId();

  // Cover and payment assets
  error CoverAssetNotSupported();
  error InvalidPaymentAsset();
  error UnexpectedCoverAsset();
  error UnexpectedEthSent();
  error EditNotSupported();

  // Price & Commission
  error PriceExceedsMaxPremiumInAsset();
  error CommissionRateTooHigh();

  // ETH transfers
  error InsufficientEthSent();
  error SendingEthToPoolFailed();
  error SendingEthToCommissionDestinationFailed();
  error ReturningEthRemainderToSenderFailed();

  // Misc
  error ExpiredCoversCannotBeEdited();
  error CoverNotYetExpired(uint coverId);
  error InsufficientCoverAmountAllocated();
  error UnexpectedPoolId();
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "@openzeppelin/contracts-v4/token/ERC721/IERC721.sol";

interface ICoverNFT is IERC721 {

  function isApprovedOrOwner(address spender, uint tokenId) external returns (bool);

  function mint(address to) external returns (uint tokenId);

  function changeOperator(address newOperator) external;

  function changeNFTDescriptor(address newNFTDescriptor) external;

  function totalSupply() external view returns (uint);

  function name() external view returns (string memory);

  error NotOperator();
  error NotMinted();
  error WrongFrom();
  error InvalidRecipient();
  error InvalidNewOperatorAddress();
  error InvalidNewNFTDescriptorAddress();
  error NotAuthorized();
  error UnsafeRecipient();
  error AlreadyMinted();

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IMasterAwareV2 {

  // TODO: if you update this enum, update lib/constants.js as well
  enum ID {
    TC, // TokenController.sol
    P1, // Pool.sol
    MR, // MemberRoles.sol
    MC, // MCR.sol
    CO, // Cover.sol
    SP, // StakingProducts.sol
    PS, // LegacyPooledStaking.sol
    GV, // Governance.sol
    GW, // LegacyGateway.sol - removed
    CL, // CoverMigrator.sol - removed
    AS, // Assessment.sol
    CI, // IndividualClaims.sol - Claims for Individuals
    CG, // YieldTokenIncidents.sol - Claims for Groups
    RA, // Ramm.sol
    ST,  // SafeTracker.sol
    CP  // CoverProducts.sol
  }

  function changeMasterAddress(address masterAddress) external;

  function changeDependentContractAddress() external;

  function internalContracts(uint) external view returns (address payable);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IMemberRoles {

  enum Role {Unassigned, AdvisoryBoard, Member, Owner, Auditor}

  function join(address _userAddress, uint nonce, bytes calldata signature) external payable;

  function switchMembership(address _newAddress) external;

  function switchMembershipAndAssets(
    address newAddress,
    uint[] calldata coverIds,
    uint[] calldata stakingTokenIds
  ) external;

  function switchMembershipOf(address member, address _newAddress) external;

  function totalRoles() external view returns (uint256);

  function changeAuthorized(uint _roleId, address _newAuthorized) external;

  function setKycAuthAddress(address _add) external;

  function members(uint _memberRoleId) external view returns (uint, address[] memory memberArray);

  function numberOfMembers(uint _memberRoleId) external view returns (uint);

  function authorized(uint _memberRoleId) external view returns (address);

  function roles(address _memberAddress) external view returns (uint[] memory);

  function checkRole(address _memberAddress, uint _roleId) external view returns (bool);

  function getMemberLengthForAllRoles() external view returns (uint[] memory totalMembers);

  function memberAtIndex(uint _memberRoleId, uint index) external view returns (address, bool);

  function membersLength(uint _memberRoleId) external view returns (uint);

  event MemberRole(uint256 indexed roleId, bytes32 roleName, string roleDescription);

  event MemberJoined(address indexed newMember, uint indexed nonce);

  event switchedMembership(address indexed previousMember, address indexed newMember, uint timeStamp);
  
  event MembershipWithdrawn(address indexed member, uint timestamp);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "./IPriceFeedOracle.sol";

struct SwapDetails {
  uint104 minAmount;
  uint104 maxAmount;
  uint32 lastSwapTime;
  // 2 decimals of precision. 0.01% -> 0.0001 -> 1e14
  uint16 maxSlippageRatio;
}

struct Asset {
  address assetAddress;
  bool isCoverAsset;
  bool isAbandoned;
}

interface IPool {

  function swapOperator() external view returns (address);

  function getAsset(uint assetId) external view returns (Asset memory);

  function getAssets() external view returns (Asset[] memory);

  function transferAssetToSwapOperator(address asset, uint amount) external;

  function setSwapDetailsLastSwapTime(address asset, uint32 lastSwapTime) external;

  function getAssetSwapDetails(address assetAddress) external view returns (SwapDetails memory);

  function sendPayout(uint assetIndex, address payable payoutAddress, uint amount, uint ethDepositAmount) external;

  function sendEth(address payoutAddress, uint amount) external;

  function upgradeCapitalPool(address payable newPoolAddress) external;

  function priceFeedOracle() external view returns (IPriceFeedOracle);

  function getPoolValueInEth() external view returns (uint);

  function calculateMCRRatio(uint totalAssetValue, uint mcrEth) external pure returns (uint);

  function getInternalTokenPriceInAsset(uint assetId) external view returns (uint tokenPrice);

  function getInternalTokenPriceInAssetAndUpdateTwap(uint assetId) external returns (uint tokenPrice);

  function getTokenPrice() external view returns (uint tokenPrice);

  function getMCRRatio() external view returns (uint);

  function setSwapValue(uint value) external;
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IPooledStaking {

  struct Staker {
    uint deposit; // total amount of deposit nxm
    uint reward; // total amount that is ready to be claimed
    address[] contracts; // list of contracts the staker has staked on

    // staked amounts for each contract
    mapping(address => uint) stakes;

    // amount pending to be subtracted after all unstake requests will be processed
    mapping(address => uint) pendingUnstakeRequestsTotal;

    // flag to indicate the presence of this staker in the array of stakers of each contract
    mapping(address => bool) isInContractStakers;
  }

  struct Burn {
    uint amount;
    uint burnedAt;
    address contractAddress;
  }

  struct Reward {
    uint amount;
    uint rewardedAt;
    address contractAddress;
  }

  struct UnstakeRequest {
    uint amount;
    uint unstakeAt;
    address contractAddress;
    address stakerAddress;
    uint next; // id of the next unstake request in the linked list
  }

  struct ContractReward {
    uint amount;
    uint lastDistributionRound;
  }

  function accumulateReward(address contractAddress, uint amount) external;

  function pushBurn(address contractAddress, uint amount) external;

  function hasPendingActions() external view returns (bool);

  function processPendingActions(uint maxIterations) external returns (bool finished);

  function contractStake(address contractAddress) external view returns (uint);

  function stakerReward(address staker) external view returns (uint);

  function stakerDeposit(address staker) external view returns (uint);

  function stakerContractStake(address staker, address contractAddress) external view returns (uint);

  function withdraw(uint amount) external;

  function withdrawForUser(address user) external;

  function stakerMaxWithdrawable(address stakerAddress) external view returns (uint);

  function withdrawReward(address stakerAddress) external;
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface Aggregator {
  function decimals() external view returns (uint8);
  function latestAnswer() external view returns (int);
}

interface IPriceFeedOracle {

  struct OracleAsset {
    Aggregator aggregator;
    uint8 decimals;
  }

  function ETH() external view returns (address);
  function assets(address) external view returns (Aggregator, uint8);

  function getAssetToEthRate(address asset) external view returns (uint);
  function getAssetForEth(address asset, uint ethIn) external view returns (uint);
  function getEthForAsset(address asset, uint amount) external view returns (uint);

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IQuotationData {

  function authQuoteEngine() external view returns (address);
  function stlp() external view returns (uint);
  function stl() external view returns (uint);
  function pm() external view returns (uint);
  function minDays() external view returns (uint);
  function tokensRetained() external view returns (uint);
  function kycAuthAddress() external view returns (address);

  function refundEligible(address) external view returns (bool);
  function holdedCoverIDStatus(uint) external view returns (uint);
  function timestampRepeated(uint) external view returns (bool);

  enum HCIDStatus {NA, kycPending, kycPass, kycFailedOrRefunded, kycPassNoCover}
  enum CoverStatus {Active, ClaimAccepted, ClaimDenied, CoverExpired, ClaimSubmitted, Requested}

  function addInTotalSumAssuredSC(address _add, bytes4 _curr, uint _amount) external;

  function subFromTotalSumAssuredSC(address _add, bytes4 _curr, uint _amount) external;

  function subFromTotalSumAssured(bytes4 _curr, uint _amount) external;

  function addInTotalSumAssured(bytes4 _curr, uint _amount) external;

  function setTimestampRepeated(uint _timestamp) external;

  /// @dev Creates a blank new cover.
  function addCover(
    uint16 _coverPeriod,
    uint _sumAssured,
    address payable _userAddress,
    bytes4 _currencyCode,
    address _scAddress,
    uint premium,
    uint premiumNXM
  ) external;


  function addHoldCover(
    address payable from,
    address scAddress,
    bytes4 coverCurr,
    uint[] calldata coverDetails,
    uint16 coverPeriod
  ) external;

  function setRefundEligible(address _add, bool status) external;

  function setHoldedCoverIDStatus(uint holdedCoverID, uint status) external;

  function setKycAuthAddress(address _add) external;

  function changeAuthQuoteEngine(address _add) external;

  function getUintParameters(bytes8 code) external view returns (bytes8 codeVal, uint val);

  function getProductDetails()
  external
  view
  returns (
    uint _minDays,
    uint _pm,
    uint _stl,
    uint _stlp
  );

  function getCoverLength() external view returns (uint len);

  function getAuthQuoteEngine() external view returns (address _add);

  function getTotalSumAssured(bytes4 _curr) external view returns (uint amount);

  function getAllCoversOfUser(address _add) external view returns (uint[] memory allCover);

  function getUserCoverLength(address _add) external view returns (uint len);

  function getCoverStatusNo(uint _cid) external view returns (uint8);

  function getCoverPeriod(uint _cid) external view returns (uint32 cp);

  function getCoverSumAssured(uint _cid) external view returns (uint sa);

  function getCurrencyOfCover(uint _cid) external view returns (bytes4 curr);

  function getValidityOfCover(uint _cid) external view returns (uint date);

  function getscAddressOfCover(uint _cid) external view returns (uint, address);

  function getCoverMemberAddress(uint _cid) external view returns (address payable _add);

  function getCoverPremiumNXM(uint _cid) external view returns (uint _premiumNXM);

  function getCoverDetailsByCoverID1(
    uint _cid
  )
  external
  view
  returns (
    uint cid,
    address _memberAddress,
    address _scAddress,
    bytes4 _currencyCode,
    uint _sumAssured,
    uint premiumNXM
  );

  function getCoverDetailsByCoverID2(
    uint _cid
  )
  external
  view
  returns (
    uint cid,
    uint8 status,
    uint sumAssured,
    uint16 coverPeriod,
    uint validUntil
  );

  function getHoldedCoverDetailsByID1(
    uint _hcid
  )
  external
  view
  returns (
    uint hcid,
    address scAddress,
    bytes4 coverCurr,
    uint16 coverPeriod
  );

  function getUserHoldedCoverLength(address _add) external view returns (uint);

  function getUserHoldedCoverByIndex(address _add, uint index) external view returns (uint);

  function getHoldedCoverDetailsByID2(
    uint _hcid
  )
  external
  view
  returns (
    uint hcid,
    address payable memberAddress,
    uint[] memory coverDetails
  );

  function getTotalSumAssuredSC(address _add, bytes4 _curr) external view returns (uint amount);

  function changeCoverStatusNo(uint _cid, uint8 _stat) external;

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface ISAFURAMaster {

  function tokenAddress() external view returns (address);

  function owner() external view returns (address);

  function emergencyAdmin() external view returns (address);

  function masterInitialized() external view returns (bool);

  function isInternal(address _add) external view returns (bool);

  function isPause() external view returns (bool check);

  function isMember(address _add) external view returns (bool);

  function checkIsAuthToGoverned(address _add) external view returns (bool);

  function getLatestAddress(bytes2 _contractName) external view returns (address payable contractAddress);

  function contractAddresses(bytes2 code) external view returns (address payable);

  function upgradeMultipleContracts(
    bytes2[] calldata _contractCodes,
    address payable[] calldata newAddresses
  ) external;

  function removeContracts(bytes2[] calldata contractCodesToRemove) external;

  function addNewInternalContracts(
    bytes2[] calldata _contractCodes,
    address payable[] calldata newAddresses,
    uint[] calldata _types
  ) external;

  function updateOwnerParameters(bytes8 code, address payable val) external;
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface ISAFURAToken {

  function burn(uint256 amount) external returns (bool);

  function burnFrom(address from, uint256 value) external returns (bool);

  function operatorTransfer(address from, uint256 value) external returns (bool);

  function mint(address account, uint256 amount) external;

  function isLockedForMV(address member) external view returns (uint);

  function whiteListed(address member) external view returns (bool);

  function addToWhiteList(address _member) external returns (bool);

  function removeFromWhiteList(address _member) external returns (bool);

  function changeOperator(address _newOperator) external returns (bool);

  function lockForMemberVote(address _of, uint _days) external;

  /**
 * @dev Returns the amount of tokens in existence.
 */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the amount of tokens owned by `account`.
   */
  function balanceOf(address account) external view returns (uint256);

  /**
   * @dev Moves `amount` tokens from the caller's account to `recipient`.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transfer(address recipient, uint256 amount) external returns (bool);

  /**
   * @dev Returns the remaining number of tokens that `spender` will be
   * allowed to spend on behalf of `owner` through {transferFrom}. This is
   * zero by default.
   *
   * This value changes when {approve} or {transferFrom} are called.
   */
  function allowance(address owner, address spender) external view returns (uint256);

  /**
   * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * IMPORTANT: Beware that changing an allowance with this method brings the risk
   * that someone may use both the old and the new allowance by unfortunate
   * transaction ordering. One possible solution to mitigate this race
   * condition is to first reduce the spender's allowance to 0 and set the
   * desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   *
   * Emits an {Approval} event.
   */
  function approve(address spender, uint256 amount) external returns (bool);

  /**
   * @dev Moves `amount` tokens from `sender` to `recipient` using the
   * allowance mechanism. `amount` is then deducted from the caller's
   * allowance.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

  /**
   * @dev Emitted when `value` tokens are moved from one account (`from`) to
   * another (`to`).
   *
   * Note that `value` may be zero.
   */
  event Transfer(address indexed from, address indexed to, uint256 value);

  /**
   * @dev Emitted when the allowance of a `spender` for an `owner` is set by
   * a call to {approve}. `value` is the new allowance.
   */
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "@openzeppelin/contracts-v4/token/ERC721/IERC721.sol";

interface IStakingNFT is IERC721 {

  function isApprovedOrOwner(address spender, uint tokenId) external returns (bool);

  function mint(uint poolId, address to) external returns (uint tokenId);

  function changeOperator(address newOperator) external;

  function changeNFTDescriptor(address newNFTDescriptor) external;

  function totalSupply() external returns (uint);

  function tokenInfo(uint tokenId) external view returns (uint poolId, address owner);

  function stakingPoolOf(uint tokenId) external view returns (uint poolId);

  function stakingPoolFactory() external view returns (address);

  function name() external view returns (string memory);

  error NotOperator();
  error NotMinted();
  error WrongFrom();
  error InvalidRecipient();
  error InvalidNewOperatorAddress();
  error InvalidNewNFTDescriptorAddress();
  error NotAuthorized();
  error UnsafeRecipient();
  error AlreadyMinted();
  error NotStakingPool();

}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

/* structs for io */

struct AllocationRequest {
  uint productId;
  uint coverId;
  uint allocationId;
  uint period;
  uint gracePeriod;
  bool useFixedPrice;
  uint previousStart;
  uint previousExpiration;
  uint previousRewardsRatio;
  uint globalCapacityRatio;
  uint capacityReductionRatio;
  uint rewardRatio;
  uint globalMinPrice;
}

struct BurnStakeParams {
  uint allocationId;
  uint productId;
  uint start;
  uint period;
  uint deallocationAmount;
}

interface IStakingPool {

  /* structs for storage */

  // stakers are grouped in tranches based on the timelock expiration
  // tranche index is calculated based on the expiration date
  // the initial proposal is to have 4 tranches per year (1 tranche per quarter)
  struct Tranche {
    uint128 stakeShares;
    uint128 rewardsShares;
  }

  struct ExpiredTranche {
    uint96 accNxmPerRewardShareAtExpiry;
    uint96 stakeAmountAtExpiry; // nxm total supply is 6.7e24 and uint96.max is 7.9e28
    uint128 stakeSharesSupplyAtExpiry;
  }

  struct Deposit {
    uint96 lastAccNxmPerRewardShare;
    uint96 pendingRewards;
    uint128 stakeShares;
    uint128 rewardsShares;
  }

  function initialize(
    bool isPrivatePool,
    uint initialPoolFee,
    uint maxPoolFee,
    uint _poolId,
    string memory ipfsDescriptionHash
  ) external;

  function processExpirations(bool updateUntilCurrentTimestamp) external;

  function requestAllocation(
    uint amount,
    uint previousPremium,
    AllocationRequest calldata request
  ) external returns (uint premium, uint allocationId);

  function burnStake(uint amount, BurnStakeParams calldata params) external;

  function depositTo(
    uint amount,
    uint trancheId,
    uint requestTokenId,
    address destination
  ) external returns (uint tokenId);

  function withdraw(
    uint tokenId,
    bool withdrawStake,
    bool withdrawRewards,
    uint[] memory trancheIds
  ) external returns (uint withdrawnStake, uint withdrawnRewards);

  function isPrivatePool() external view returns (bool);

  function isHalted() external view returns (bool);

  function manager() external view returns (address);

  function getPoolId() external view returns (uint);

  function getPoolFee() external view returns (uint);

  function getMaxPoolFee() external view returns (uint);

  function getActiveStake() external view returns (uint);

  function getStakeSharesSupply() external view returns (uint);

  function getRewardsSharesSupply() external view returns (uint);

  function getRewardPerSecond() external view returns (uint);

  function getAccNxmPerRewardsShare() external view returns (uint);

  function getLastAccNxmUpdate() external view returns (uint);

  function getFirstActiveTrancheId() external view returns (uint);

  function getFirstActiveBucketId() external view returns (uint);

  function getNextAllocationId() external view returns (uint);

  function getDeposit(uint tokenId, uint trancheId) external view returns (
    uint lastAccNxmPerRewardShare,
    uint pendingRewards,
    uint stakeShares,
    uint rewardsShares
  );

  function getTranche(uint trancheId) external view returns (
    uint stakeShares,
    uint rewardsShares
  );

  function getExpiredTranche(uint trancheId) external view returns (
    uint accNxmPerRewardShareAtExpiry,
    uint stakeAmountAtExpiry,
    uint stakeShareSupplyAtExpiry
  );

  function setPoolFee(uint newFee) external;

  function setPoolPrivacy(bool isPrivatePool) external;

  function getActiveAllocations(
    uint productId
  ) external view returns (uint[] memory trancheAllocations);

  function getTrancheCapacities(
    uint productId,
    uint firstTrancheId,
    uint trancheCount,
    uint capacityRatio,
    uint reductionRatio
  ) external view returns (uint[] memory trancheCapacities);

  /* ========== EVENTS ========== */

  event StakeDeposited(address indexed user, uint256 amount, uint256 trancheId, uint256 tokenId);

  event DepositExtended(address indexed user, uint256 tokenId, uint256 initialTrancheId, uint256 newTrancheId, uint256 topUpAmount);

  event PoolPrivacyChanged(address indexed manager, bool isPrivate);

  event PoolFeeChanged(address indexed manager, uint newFee);

  event PoolDescriptionSet(string ipfsDescriptionHash);

  event Withdraw(address indexed user, uint indexed tokenId, uint tranche, uint amountStakeWithdrawn, uint amountRewardsWithdrawn);

  event StakeBurned(uint amount);

  event Deallocated(uint productId);

  event BucketExpired(uint bucketId);

  event TrancheExpired(uint trancheId);

  // Auth
  error OnlyCoverContract();
  error OnlyStakingProductsContract();
  error OnlyManager();
  error PrivatePool();
  error SystemPaused();
  error PoolHalted();

  // Fees
  error PoolFeeExceedsMax();
  error MaxPoolFeeAbove100();

  // Voting
  error NxmIsLockedForGovernanceVote();
  error ManagerNxmIsLockedForGovernanceVote();

  // Deposit
  error InsufficientDepositAmount();
  error RewardRatioTooHigh();

  // Staking NFTs
  error InvalidTokenId();
  error NotTokenOwnerOrApproved();
  error InvalidStakingPoolForToken();

  // Tranche & capacity
  error NewTrancheEndsBeforeInitialTranche();
  error RequestedTrancheIsNotYetActive();
  error RequestedTrancheIsExpired();
  error InsufficientCapacity();

  // Allocation
  error AlreadyDeallocated(uint allocationId);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IStakingPoolFactory {

  function stakingPoolCount() external view returns (uint);

  function beacon() external view returns (address);

  function create(address beacon) external returns (uint poolId, address stakingPoolAddress);

  event StakingPoolCreated(uint indexed poolId, address indexed stakingPoolAddress);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

import "./ISAFURAToken.sol";

interface ITokenController {

  struct StakingPoolNXMBalances {
    uint128 rewards;
    uint128 deposits;
  }

  struct CoverInfo {
    uint16 claimCount;
    bool hasOpenClaim;
    bool hasAcceptedClaim;
    uint96 requestedPayoutAmount;
    // note: still 128 bits available here, can be used later
  }

  struct StakingPoolOwnershipOffer {
    address proposedManager;
    uint96 deadline;
  }

  function coverInfo(uint id) external view returns (
    uint16 claimCount,
    bool hasOpenClaim,
    bool hasAcceptedClaim,
    uint96 requestedPayoutAmount
  );

  function withdrawCoverNote(
    address _of,
    uint[] calldata _coverIds,
    uint[] calldata _indexes
  ) external;

  function changeOperator(address _newOperator) external;

  function operatorTransfer(address _from, address _to, uint _value) external returns (bool);

  function burnFrom(address _of, uint amount) external returns (bool);

  function addToWhitelist(address _member) external;

  function removeFromWhitelist(address _member) external;

  function mint(address _member, uint _amount) external;

  function lockForMemberVote(address _of, uint _days) external;

  function withdrawClaimAssessmentTokens(address[] calldata users) external;

  function getLockReasons(address _of) external view returns (bytes32[] memory reasons);

  function totalSupply() external view returns (uint);

  function totalBalanceOf(address _of) external view returns (uint amount);

  function totalBalanceOfWithoutDelegations(address _of) external view returns (uint amount);

  function getTokenPrice() external view returns (uint tokenPrice);

  function token() external view returns (ISAFURAToken);

  function getStakingPoolManager(uint poolId) external view returns (address manager);

  function getManagerStakingPools(address manager) external view returns (uint[] memory poolIds);

  function isStakingPoolManager(address member) external view returns (bool);

  function getStakingPoolOwnershipOffer(uint poolId) external view returns (address proposedManager, uint deadline);

  function transferStakingPoolsOwnership(address from, address to) external;

  function assignStakingPoolManager(uint poolId, address manager) external;

  function createStakingPoolOwnershipOffer(uint poolId, address proposedManager, uint deadline) external;

  function acceptStakingPoolOwnershipOffer(uint poolId) external;

  function cancelStakingPoolOwnershipOffer(uint poolId) external;

  function mintStakingPoolNXMRewards(uint amount, uint poolId) external;

  function burnStakingPoolNXMRewards(uint amount, uint poolId) external;

  function depositStakedNXM(address from, uint amount, uint poolId) external;

  function withdrawNXMStakeAndRewards(address to, uint stakeToWithdraw, uint rewardsToWithdraw, uint poolId) external;

  function burnStakedNXM(uint amount, uint poolId) external;

  function stakingPoolNXMBalances(uint poolId) external view returns(uint128 rewards, uint128 deposits);

  function tokensLocked(address _of, bytes32 _reason) external view returns (uint256 amount);

  function getWithdrawableCoverNotes(
    address coverOwner
  ) external view returns (
    uint[] memory coverIds,
    bytes32[] memory lockReasons,
    uint withdrawableAmount
  );

  function getPendingRewards(address member) external view returns (uint);
}

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.5.0;

interface IMaster {
  function getLatestAddress(bytes2 _module) external view returns (address);
}

contract Governed {

  address public masterAddress; // Name of the dApp, needs to be set by contracts inheriting this contract

  /// @dev modifier that allows only the authorized addresses to execute the function
  modifier onlyAuthorizedToGovern() {
    IMaster ms = IMaster(masterAddress);
    require(ms.getLatestAddress("GV") == msg.sender, "Not authorized");
    _;
  }

  /// @dev checks if an address is authorized to govern
  function isAuthorizedToGovern(address _toCheck) public view returns (bool) {
    IMaster ms = IMaster(masterAddress);
    return (ms.getLatestAddress("GV") == _toCheck);
  }

}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newMember","type":"address"},{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"MemberJoined","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roleId","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"roleName","type":"bytes32"},{"indexed":false,"internalType":"string","name":"roleDescription","type":"string"}],"name":"MemberRole","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"member","type":"address"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"MembershipWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousMember","type":"address"},{"indexed":true,"internalType":"address","name":"newMember","type":"address"},{"indexed":false,"internalType":"uint256","name":"timeStamp","type":"uint256"}],"name":"switchedMembership","type":"event"},{"inputs":[],"name":"MEMBERSHIP_APPROVAL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_memberAddress","type":"address"}],"name":"addAuditor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_roleName","type":"bytes32"},{"internalType":"string","name":"_roleDescription","type":"string"},{"internalType":"address","name":"_authorized","type":"address"}],"name":"addRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_memberRoleId","type":"uint256"}],"name":"authorized","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_roleId","type":"uint256"},{"internalType":"address","name":"_newAuthorized","type":"address"}],"name":"changeAuthorized","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"changeDependentContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"masterAddress","type":"address"}],"name":"changeMasterAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_val","type":"uint256"}],"name":"changeMaxABCount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_memberAddress","type":"address"},{"internalType":"uint256","name":"_roleId","type":"uint256"}],"name":"checkRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMemberLengthForAllRoles","outputs":[{"internalType":"uint256[]","name":"totalMembers","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"internalContracts","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_toCheck","type":"address"}],"name":"isAuthorizedToGovern","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"member","type":"address"}],"name":"isMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"join","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"joiningFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kycAuthAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launched","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchedOn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"master","outputs":[{"internalType":"contract ISAFURAMaster","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxABCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_memberRoleId","type":"uint256"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"memberAtIndex","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_memberRoleId","type":"uint256"}],"name":"members","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address[]","name":"memberArray","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_memberRoleId","type":"uint256"}],"name":"membersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_memberRoleId","type":"uint256"}],"name":"numberOfMembers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_memberAddress","type":"address"}],"name":"removeAuditor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_memberAddress","type":"address"}],"name":"roles","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_add","type":"address"}],"name":"setKycAuthAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_add","type":"address"}],"name":"setKycAuthAddressAB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"payoutAddresses","type":"address[]"}],"name":"storageCleanup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newABAddress","type":"address"},{"internalType":"address","name":"_removeAB","type":"address"}],"name":"swapABMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAddress","type":"address"}],"name":"switchMembership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAddress","type":"address"},{"internalType":"uint256[]","name":"coverIds","type":"uint256[]"},{"internalType":"uint256[]","name":"stakingTokenIds","type":"uint256[]"}],"name":"switchMembershipAndAssets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"member","type":"address"},{"internalType":"address","name":"newAddress","type":"address"}],"name":"switchMembershipOf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract ISAFURAToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRoles","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_memberAddress","type":"address"},{"internalType":"uint256","name":"_roleId","type":"uint256"},{"internalType":"bool","name":"_active","type":"bool"}],"name":"updateRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"usedMessageHashes","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawMembership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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