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/utils/SafeERC20.sol";
import "@openzeppelin/contracts-v4/security/ReentrancyGuard.sol";

import "../../abstract/MasterAwareV2.sol";
import "../../interfaces/IMCR.sol";
import "../../interfaces/IRamm.sol";
import "../../interfaces/ISAFURAToken.sol";
import "../../interfaces/ILegacyPool.sol";
import "../../interfaces/IPool.sol";
import "../../interfaces/IPriceFeedOracle.sol";
import "../../interfaces/ISwapOperator.sol";
import "../../libraries/Math.sol";
import "../../libraries/SafeUintCast.sol";

contract Pool is IPool, MasterAwareV2, ReentrancyGuard {
  using SafeERC20 for IERC20;
  using SafeUintCast for uint;

  /* storage */

  Asset[] public assets;
  mapping(address => SwapDetails) public swapDetails;

  // parameters
  IPriceFeedOracle public override priceFeedOracle;
  address public swapOperator;
  uint96 public swapValue;

  /* constants */

  address constant public ETH = 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38; // 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

  uint public constant MCR_RATIO_DECIMALS = 4;
  uint internal constant MAX_SLIPPAGE_DENOMINATOR = 10000;

  ISAFURAToken public immutable nxmToken;

  /* events */
  event Payout(address indexed to, address indexed assetAddress, uint amount);
  event DepositReturned(address indexed to, uint amount);

  /* logic */
  modifier onlySwapOperator {
    require(msg.sender == swapOperator, "Pool: Not swapOperator");
    _;
  }

  modifier onlyRamm {
    require(msg.sender == internalContracts[uint(ID.RA)], "Pool: Not Ramm");
    _;
  }

  /* ========== CONSTRUCTOR ========== */

  constructor (
    address _master,
    address _priceOracle,
    address _swapOperator,
    address _nxmTokenAddress,
    address _previousPool
  ) {
    master = ISAFURAMaster(_master);
    nxmToken = ISAFURAToken(_nxmTokenAddress);
    swapOperator = _swapOperator;

    ILegacyPool previousPool = ILegacyPool(_previousPool);

    // copy over assets and swap details
    ILegacyPool.Asset[] memory previousAssets = previousPool.getAssets();

    for (uint i = 0; i < previousAssets.length; i++) {

      address assetAddress = previousAssets[i].assetAddress;

      assets.push(
        Asset(
          previousAssets[i].assetAddress,
          previousAssets[i].isCoverAsset,
          previousAssets[i].isAbandoned
        )
      );

      if (assetAddress != ETH) {
        ILegacyPool.SwapDetails memory previousSwapDetails = previousPool.getAssetSwapDetails(assetAddress);
        swapDetails[assetAddress] = SwapDetails(
          previousSwapDetails.minAmount,
          previousSwapDetails.maxAmount,
          previousSwapDetails.lastSwapTime,
          previousSwapDetails.maxSlippageRatio
        );
      }
    }

    _setPriceFeedOracle(IPriceFeedOracle(_priceOracle));
  }

  receive() external payable {}

  /* ========== ASSET RELATED VIEW FUNCTIONS ========== */

  function getAssetValueInEth(address assetAddress) internal view returns (uint) {

    uint assetBalance;

    if (assetAddress.code.length != 0) {
      try IERC20(assetAddress).balanceOf(address(this)) returns (uint balance) {
        assetBalance = balance;
      } catch {
        // If balanceOf reverts consider it 0
      }
    }

    // If the assetBalance is 0 skip the oracle call to save gas
    if (assetBalance == 0) {
      return 0;
    }

    return priceFeedOracle.getEthForAsset(assetAddress, assetBalance);
  }

  ///
  /// @dev Calculates total value of all pool assets in ether
  ///
  function getPoolValueInEth() public override view returns (uint) {

    uint total = address(this).balance + swapValue;
    uint assetCount = assets.length;

    // Skip ETH (index 0)
    for (uint i = 1; i < assetCount; i++) {

      if (assets[i].isAbandoned) {
        continue;
      }

      total += getAssetValueInEth(assets[i].assetAddress);
    }

    return total;
  }

  function getAsset(uint assetId) external override view returns (Asset memory) {
    require(assetId < assets.length, "Pool: Invalid asset id");
    return assets[assetId];
  }

  function getAssets() external override view returns (Asset[] memory) {
    return assets;
  }

  function getAssetSwapDetails(address assetAddress) external view returns (SwapDetails memory) {
    return swapDetails[assetAddress];
  }

  /* ========== ASSET RELATED MUTATIVE FUNCTIONS ========== */

  function addAsset(
    address assetAddress,
    bool isCoverAsset,
    uint _min,
    uint _max,
    uint _maxSlippageRatio
  ) external onlyGovernance {

    require(assetAddress != address(0), "Pool: Asset is zero address");
    require(_max >= _min, "Pool: max < min");
    require(_maxSlippageRatio <= MAX_SLIPPAGE_DENOMINATOR, "Pool: Max slippage ratio > 1");

    (Aggregator aggregator,) = priceFeedOracle.assets(assetAddress);
    require(address(aggregator) != address(0), "Pool: PriceFeedOracle lacks aggregator for asset");

    // Check whether the new asset already exists as a cover asset
    uint assetCount = assets.length;

    for (uint i = 0; i < assetCount; i++) {
      require(assetAddress != assets[i].assetAddress, "Pool: Asset exists");
    }

    assets.push(
      Asset(
        assetAddress,
        isCoverAsset,
        false  // is abandoned
      )
    );

    // Set the swap details
    swapDetails[assetAddress] = SwapDetails(
      _min.toUint104(),
      _max.toUint104(),
      0, // last swap time
      _maxSlippageRatio.toUint16()
    );
  }

  function setAssetDetails(
    uint assetId,
    bool isCoverAsset,
    bool isAbandoned
  ) external onlyGovernance {
    require(assets.length > assetId, "Pool: Asset does not exist");
    assets[assetId].isCoverAsset = isCoverAsset;
    assets[assetId].isAbandoned = isAbandoned;
  }

  function setSwapDetails(
    address assetAddress,
    uint _min,
    uint _max,
    uint _maxSlippageRatio
  ) external onlyGovernance {

    require(_min <= _max, "Pool: min > max");
    require(_maxSlippageRatio <= MAX_SLIPPAGE_DENOMINATOR, "Pool: Max slippage ratio > 1");

    uint assetCount = assets.length;

    for (uint i = 0; i < assetCount; i++) {

      if (assetAddress != assets[i].assetAddress) {
        continue;
      }

      swapDetails[assetAddress].minAmount = _min.toUint104();
      swapDetails[assetAddress].maxAmount = _max.toUint104();
      swapDetails[assetAddress].maxSlippageRatio = _maxSlippageRatio.toUint16();

      return;
    }

    revert("Pool: Asset not found");
  }

  function transferAsset(
    address assetAddress,
    address payable destination,
    uint amount
  ) external onlyGovernance nonReentrant {

    require(swapDetails[assetAddress].maxAmount == 0, "Pool: Max not zero");
    require(destination != address(0), "Pool: Dest zero");

    IERC20 token = IERC20(assetAddress);
    uint balance = token.balanceOf(address(this));
    uint transferableAmount = amount > balance ? balance : amount;

    token.safeTransfer(destination, transferableAmount);
  }

  /* ========== SWAPOPERATOR RELATED MUTATIVE FUNCTIONS ========== */

  function transferAssetToSwapOperator(
    address assetAddress,
    uint amount
  ) public override onlySwapOperator nonReentrant whenNotPaused {

    if (assetAddress == ETH) {
      (bool ok, /* data */) = swapOperator.call{value: amount}("");
      require(ok, "Pool: ETH transfer failed");
      return;
    }

    IERC20 token = IERC20(assetAddress);
    token.safeTransfer(swapOperator, amount);
  }

  function setSwapDetailsLastSwapTime(
    address assetAddress,
    uint32 lastSwapTime
  ) public override onlySwapOperator whenNotPaused {
    swapDetails[assetAddress].lastSwapTime = lastSwapTime;
  }

  function setSwapValue(uint newValue) external onlySwapOperator whenNotPaused {
    swapValue = newValue.toUint96();
  }

  /* ========== CLAIMS RELATED MUTATIVE FUNCTIONS ========== */

  /// @dev Executes a payout
  /// @param assetId        Index of the cover asset
  /// @param payoutAddress  Send funds to this address
  /// @param amount         Amount to send
  /// @param ethDepositAmount  Deposit amount to send
  ///
  function sendPayout(
    uint assetId,
    address payable payoutAddress,
    uint amount,
    uint ethDepositAmount
  ) external override onlyInternal nonReentrant {

    Asset memory asset = assets[assetId];

    if (asset.assetAddress == ETH) {
      // solhint-disable-next-line avoid-low-level-calls
      (bool transferSucceeded, /* data */) = payoutAddress.call{value: amount}("");
      require(transferSucceeded, "Pool: ETH transfer failed");
    } else {
      IERC20(asset.assetAddress).safeTransfer(payoutAddress, amount);
    }

    if (ethDepositAmount > 0) {
      // solhint-disable-next-line avoid-low-level-calls
      (bool transferSucceeded, /* data */) = payoutAddress.call{value: ethDepositAmount}("");
      require(transferSucceeded, "Pool: ETH transfer failed");
      emit DepositReturned(payoutAddress, ethDepositAmount);
    }

    emit Payout(payoutAddress, asset.assetAddress, amount);

    mcr().updateMCRInternal(true);
  }

  /* ========== TOKEN RELATED MUTATIVE FUNCTIONS ========== */

  /// @dev Sends ETH to a member in exchange for NXM tokens.
  /// @param member  Member address
  /// @param amount  Amount of ETH to send
  ///
  function sendEth(address member, uint amount) external override onlyRamm nonReentrant {
    (bool transferSucceeded, /* data */) = member.call{value: amount}("");
    require(transferSucceeded, "Pool: ETH transfer failed");
  }

  function calculateMCRRatio(
    uint totalAssetValue,
    uint mcrEth
  ) public override pure returns (uint) {
    return totalAssetValue * (10 ** MCR_RATIO_DECIMALS) / mcrEth;
  }

  /* ========== TOKEN RELATED VIEW FUNCTIONS ========== */

  /// Uses internal price for calculating the token price in ETH
  /// It's being used in Cover and IndividualClaims
  /// Returns the internal NXM price in a given asset.
  ///
  /// @dev The pool contract is not a proxy and its address will change as we upgrade it.
  /// @dev You may want TokenController.getTokenPrice() for a stable address since it's a proxy.
  ///
  /// @param assetId  Index of the cover asset.
  ///
  function getInternalTokenPriceInAsset(uint assetId) public view override returns (uint tokenPrice) {

    require(assetId < assets.length, "Pool: Unknown cover asset");
    address assetAddress = assets[assetId].assetAddress;

    uint tokenInternalPrice = ramm().getInternalPrice();

    return priceFeedOracle.getAssetForEth(assetAddress, tokenInternalPrice);
  }

  /// Uses internal price for calculating the token price in ETH and updates TWAP
  /// It's being used in Cover
  /// Returns the internal NXM price in a given asset.
  ///
  /// @dev The pool contract is not a proxy and its address will change as we upgrade it.
  /// @dev You may want TokenController.getTokenPrice() for a stable address since it's a proxy.
  ///
  /// @param assetId  Index of the cover asset.
  ///
  function getInternalTokenPriceInAssetAndUpdateTwap(uint assetId) public override returns (uint tokenPrice) {

    require(assetId < assets.length, "Pool: Unknown cover asset");
    address assetAddress = assets[assetId].assetAddress;

    uint tokenInternalPrice = ramm().getInternalPriceAndUpdateTwap();

    return priceFeedOracle.getAssetForEth(assetAddress, tokenInternalPrice);
  }

  /// [deprecated] Returns spot NXM price in ETH from ramm contract.
  ///
  /// @dev The pool contract is not a proxy and its address will change as we upgrade it.
  /// @dev You may want TokenController.getTokenPrice() for a stable address since it's a proxy.
  ///
  function getTokenPrice() public override view returns (uint tokenPrice) {
    (, tokenPrice) = ramm().getSpotPrices();
    return tokenPrice;
  }

  function getMCRRatio() public override view returns (uint) {
    uint totalAssetValue = getPoolValueInEth();
    uint mcrEth = mcr().getMCR();
    return calculateMCRRatio(totalAssetValue, mcrEth);
  }

  /* ========== POOL UPGRADE RELATED MUTATIVE FUNCTIONS ========== */

  // Revert if any of the asset functions revert while not being marked for getting abandoned.
  // Otherwise, continue without reverting while the marked asset will remain stuck in the
  // previous pool contract.
  function upgradeCapitalPool(address payable newPoolAddress) external override onlyMaster nonReentrant {

    // transfer ETH
    (bool ok, /* data */) = newPoolAddress.call{value: address(this).balance}("");
    require(ok, "Pool: Transfer failed");

    uint assetCount = assets.length;

    // start from 1 (0 is ETH)
    for (uint i = 1; i < assetCount; i++) {

      if (assets[i].isAbandoned) {
        continue;
      }

      IERC20 asset = IERC20(assets[i].assetAddress);
      uint balance = asset.balanceOf(address(this));
      asset.safeTransfer(newPoolAddress, balance);
    }
  }

  function _setPriceFeedOracle(IPriceFeedOracle _priceFeedOracle) internal {
    uint assetCount = assets.length;

    // start from 1 (0 is ETH and doesn't need an oracle)
    for (uint i = 1; i < assetCount; i++) {
      (Aggregator aggregator,) = _priceFeedOracle.assets(assets[i].assetAddress);
      require(address(aggregator) != address(0), "Pool: PriceFeedOracle lacks aggregator for asset");
    }

    priceFeedOracle = _priceFeedOracle;
  }

  function updateUintParameters(bytes8 /* code */, uint /* value */) external view onlyGovernance {
    revert("Pool: Unknown parameter");
  }

  function updateAddressParameters(bytes8 code, address value) external onlyGovernance {

    if (code == "SWP_OP") {
      if (swapOperator != address(0)) {
        require(!ISwapOperator(swapOperator).orderInProgress(), 'Pool: Cancel all swaps before changing swapOperator');
      }
      swapOperator = value;
      return;
    }

    if (code == "PRC_FEED") {
      _setPriceFeedOracle(IPriceFeedOracle(value));
      return;
    }

    revert("Pool: Unknown parameter");
  }

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

  function mcr() internal view returns (IMCR) {
    return IMCR(internalContracts[uint(ID.MC)]);
  }

  function ramm() internal view returns (IRamm) {
    return IRamm(internalContracts[uint(ID.RA)]);
  }

  /**
   * @dev Update dependent contract address
   * @dev Implements MasterAware interface function
   */
  function changeDependentContractAddress() public {
    internalContracts[uint(ID.MC)] = master.getLatestAddress("MC");
    internalContracts[uint(ID.RA)] = master.getLatestAddress("RA");
    // needed for onlyMember modifier
    internalContracts[uint(ID.MR)] = master.getLatestAddress("MR");
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// 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/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// 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: LGPL-3.0-or-later
pragma solidity ^0.8.18;

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

/// @title Gnosis Protocol v2 Order Library
/// @author Gnosis Developers
library GPv2Order {
    /// @dev The complete data for a Gnosis Protocol order. This struct contains
    /// all order parameters that are signed for submitting to GP.
    struct Data {
        IERC20 sellToken;
        IERC20 buyToken;
        address receiver;
        uint256 sellAmount;
        uint256 buyAmount;
        uint32 validTo;
        bytes32 appData;
        uint256 feeAmount;
        bytes32 kind;
        bool partiallyFillable;
        bytes32 sellTokenBalance;
        bytes32 buyTokenBalance;
    }

    /// @dev The order EIP-712 type hash for the [`GPv2Order.Data`] struct.
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256(
    ///     "Order(" +
    ///         "address sellToken," +
    ///         "address buyToken," +
    ///         "address receiver," +
    ///         "uint256 sellAmount," +
    ///         "uint256 buyAmount," +
    ///         "uint32 validTo," +
    ///         "bytes32 appData," +
    ///         "uint256 feeAmount," +
    ///         "string kind," +
    ///         "bool partiallyFillable" +
    ///         "string sellTokenBalance" +
    ///         "string buyTokenBalance" +
    ///     ")"
    /// )
    /// ```
    bytes32 internal constant TYPE_HASH =
        hex"d5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489";

    /// @dev The marker value for a sell order for computing the order struct
    /// hash. This allows the EIP-712 compatible wallets to display a
    /// descriptive string for the order kind (instead of 0 or 1).
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256("sell")
    /// ```
    bytes32 internal constant KIND_SELL =
        hex"f3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775";

    /// @dev The OrderKind marker value for a buy order for computing the order
    /// struct hash.
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256("buy")
    /// ```
    bytes32 internal constant KIND_BUY =
        hex"6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc";

    /// @dev The TokenBalance marker value for using direct ERC20 balances for
    /// computing the order struct hash.
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256("erc20")
    /// ```
    bytes32 internal constant BALANCE_ERC20 =
        hex"5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9";

    /// @dev The TokenBalance marker value for using Balancer Vault external
    /// balances (in order to re-use Vault ERC20 approvals) for computing the
    /// order struct hash.
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256("external")
    /// ```
    bytes32 internal constant BALANCE_EXTERNAL =
        hex"abee3b73373acd583a130924aad6dc38cfdc44ba0555ba94ce2ff63980ea0632";

    /// @dev The TokenBalance marker value for using Balancer Vault internal
    /// balances for computing the order struct hash.
    ///
    /// This value is pre-computed from the following expression:
    /// ```
    /// keccak256("internal")
    /// ```
    bytes32 internal constant BALANCE_INTERNAL =
        hex"4ac99ace14ee0a5ef932dc609df0943ab7ac16b7583634612f8dc35a4289a6ce";

    /// @dev Marker address used to indicate that the receiver of the trade
    /// proceeds should the owner of the order.
    ///
    /// This is chosen to be `address(0)` for gas efficiency as it is expected
    /// to be the most common case.
    address internal constant RECEIVER_SAME_AS_OWNER = address(0);

    /// @dev The byte length of an order unique identifier.
    uint256 internal constant UID_LENGTH = 56;

    /// @dev Returns the actual receiver for an order. This function checks
    /// whether or not the [`receiver`] field uses the marker value to indicate
    /// it is the same as the order owner.
    ///
    /// @return receiver The actual receiver of trade proceeds.
    function actualReceiver(Data memory order, address owner)
        internal
        pure
        returns (address receiver)
    {
        if (order.receiver == RECEIVER_SAME_AS_OWNER) {
            receiver = owner;
        } else {
            receiver = order.receiver;
        }
    }

    /// @dev Return the EIP-712 signing hash for the specified order.
    ///
    /// @param order The order to compute the EIP-712 signing hash for.
    /// @param domainSeparator The EIP-712 domain separator to use.
    /// @return orderDigest The 32 byte EIP-712 struct hash.
    function hash(Data memory order, bytes32 domainSeparator)
        internal
        pure
        returns (bytes32 orderDigest)
    {
        bytes32 structHash;

        // NOTE: Compute the EIP-712 order struct hash in place. As suggested
        // in the EIP proposal, noting that the order struct has 10 fields, and
        // including the type hash `(12 + 1) * 32 = 416` bytes to hash.
        // <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#rationale-for-encodedata>
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let dataStart := sub(order, 32)
            let temp := mload(dataStart)
            mstore(dataStart, TYPE_HASH)
            structHash := keccak256(dataStart, 416)
            mstore(dataStart, temp)
        }

        // NOTE: Now that we have the struct hash, compute the EIP-712 signing
        // hash using scratch memory past the free memory pointer. The signing
        // hash is computed from `"\x19\x01" || domainSeparator || structHash`.
        // <https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html#layout-in-memory>
        // <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#specification>
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let freeMemoryPointer := mload(0x40)
            mstore(freeMemoryPointer, "\x19\x01")
            mstore(add(freeMemoryPointer, 2), domainSeparator)
            mstore(add(freeMemoryPointer, 34), structHash)
            orderDigest := keccak256(freeMemoryPointer, 66)
        }
    }

    /// @dev Packs order UID parameters into the specified memory location. The
    /// result is equivalent to `abi.encodePacked(...)` with the difference that
    /// it allows re-using the memory for packing the order UID.
    ///
    /// This function reverts if the order UID buffer is not the correct size.
    ///
    /// @param orderUid The buffer pack the order UID parameters into.
    /// @param orderDigest The EIP-712 struct digest derived from the order
    /// parameters.
    /// @param owner The address of the user who owns this order.
    /// @param validTo The epoch time at which the order will stop being valid.
    function packOrderUidParams(
        bytes memory orderUid,
        bytes32 orderDigest,
        address owner,
        uint32 validTo
    ) internal pure {
        require(orderUid.length == UID_LENGTH, "GPv2: uid buffer overflow");

        // NOTE: Write the order UID to the allocated memory buffer. The order
        // parameters are written to memory in **reverse order** as memory
        // operations write 32-bytes at a time and we want to use a packed
        // encoding. This means, for example, that after writing the value of
        // `owner` to bytes `20:52`, writing the `orderDigest` to bytes `0:32`
        // will **overwrite** bytes `20:32`. This is desirable as addresses are
        // only 20 bytes and `20:32` should be `0`s:
        //
        //        |           1111111111222222222233333333334444444444555555
        //   byte | 01234567890123456789012345678901234567890123456789012345
        // -------+---------------------------------------------------------
        //  field | [.........orderDigest..........][......owner.......][vT]
        // -------+---------------------------------------------------------
        // mstore |                         [000000000000000000000000000.vT]
        //        |                     [00000000000.......owner.......]
        //        | [.........orderDigest..........]
        //
        // Additionally, since Solidity `bytes memory` are length prefixed,
        // 32 needs to be added to all the offsets.
        //
        // solhint-disable-next-line no-inline-assembly
        assembly {
            mstore(add(orderUid, 56), validTo)
            mstore(add(orderUid, 52), owner)
            mstore(add(orderUid, 32), orderDigest)
        }
    }

    /// @dev Extracts specific order information from the standardized unique
    /// order id of the protocol.
    ///
    /// @param orderUid The unique identifier used to represent an order in
    /// the protocol. This uid is the packed concatenation of the order digest,
    /// the validTo order parameter and the address of the user who created the
    /// order. It is used by the user to interface with the contract directly,
    /// and not by calls that are triggered by the solvers.
    /// @return orderDigest The EIP-712 signing digest derived from the order
    /// parameters.
    /// @return owner The address of the user who owns this order.
    /// @return validTo The epoch time at which the order will stop being valid.
    function extractOrderUidParams(bytes calldata orderUid)
        internal
        pure
        returns (
            bytes32 orderDigest,
            address owner,
            uint32 validTo
        )
    {
        require(orderUid.length == UID_LENGTH, "GPv2: invalid uid");

        // Use assembly to efficiently decode packed calldata.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            orderDigest := calldataload(orderUid.offset)
            owner := shr(96, calldataload(add(orderUid.offset, 32)))
            validTo := shr(224, calldataload(add(orderUid.offset, 52)))
        }
    }
}

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

pragma solidity >=0.5.0;

import "./IPriceFeedOracle.sol";

interface ILegacyPool {

  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;
  }

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

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

  function buyNXM(uint minTokensOut) external payable;

  function sellNXM(uint tokenAmount, uint minEthOut) external;

  function sellNXMTokens(uint tokenAmount) external returns (bool);

  function transferAssetToSwapOperator(address asset, uint amount) external;

  function setSwapDetailsLastSwapTime(address asset, uint32 lastSwapTime) external;

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

  function getNXMForEth(uint ethAmount) external view returns (uint);

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

  function upgradeCapitalPool(address payable newPoolAddress) external;

  function priceFeedOracle() external view returns (IPriceFeedOracle);

  function getPoolValueInEth() external view returns (uint);

  function getEthForNXM(uint nxmAmount) external view returns (uint ethAmount);

  function calculateEthForNXM(uint nxmAmount, uint currentTotalAssetValue, uint mcrEth) external pure returns (uint);

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

  function calculateTokenSpotPrice(uint totalAssetValue, uint mcrEth) external pure returns (uint tokenPrice);

  function getTokenPriceInAsset(uint assetId) external view 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 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 IMCR {

  function updateMCRInternal(bool forceUpdate) external;

  function getMCR() external view returns (uint);

  function mcr() external view returns (uint80);

  function desiredMCR() external view returns (uint80);

  function lastUpdateTime() external view returns (uint32);

  function maxMCRIncrement() external view returns (uint16);

  function gearingFactor() external view returns (uint24);

  function minUpdateTime() external view returns (uint16);

}

// 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 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;

import "./IPool.sol";
import "./ISAFURAToken.sol";
import "./ITokenController.sol";

interface IRamm {

  // storage structs

  struct Slot0 {
    uint128 nxmReserveA;
    uint128 nxmReserveB;
  }

  struct Slot1 {
    uint128 ethReserve;
    uint88 budget;
    uint32 updatedAt;
    bool swapPaused; // emergency pause
  }

  struct Observation {
    uint32 timestamp;
    uint112 priceCumulativeAbove;
    uint112 priceCumulativeBelow;
  }

  // memory structs

  struct State {
    uint nxmA;
    uint nxmB;
    uint eth;
    uint budget;
    uint ratchetSpeedB;
    uint timestamp;
  }

  struct Context {
    uint capital;
    uint supply;
    uint mcr;
  }

  struct CumulativePriceCalculationProps {
    uint previousEthReserve;
    uint currentEthReserve;
    uint previousNxmA;
    uint currentNxmA;
    uint previousNxmB;
    uint currentNxmB;
    uint previousTimestamp;
    uint observationTimestamp;
  }

  struct CumulativePriceCalculationTimes {
    uint secondsUntilBVAbove;
    uint secondsUntilBVBelow;
    uint timeElapsed;
    uint bvTimeBelow;
    uint bvTimeAbove;
    uint ratchetTimeAbove;
    uint ratchetTimeBelow;
  }

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

  function getReserves() external view returns (
    uint ethReserve,
    uint nxmA,
    uint nxmB,
    uint remainingBudget
  );

  function getSpotPrices() external view returns (uint spotPriceA, uint spotPriceB);

  function getBookValue() external view returns (uint bookValue);

  function getInternalPrice() external view returns (uint internalPrice);

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

  function updateTwap() external;

  function getInternalPriceAndUpdateTwap() external returns (uint internalPrice);

  function swap(uint nxmIn, uint minAmountOut, uint deadline) external payable returns (uint amountOut);

  function removeBudget() external;

  function setEmergencySwapPause(bool _swapPaused) external;

  /* ========== EVENTS AND ERRORS ========== */

  event EthSwappedForNxm(address indexed member, uint ethIn, uint nxmOut);
  event NxmSwappedForEth(address indexed member, uint nxmIn, uint ethOut);
  event ObservationUpdated(uint32 timestamp, uint112 priceCumulativeAbove, uint112 priceCumulativeBelow);
  event BudgetRemoved();
  event SwapPauseConfigured(bool paused);
  event EthInjected(uint value);
  event EthExtracted(uint value);

  // Pause
  error SystemPaused();
  error SwapPaused();

  // Input
  error OneInputOnly();
  error OneInputRequired();

  // Expiry
  error SwapExpired(uint deadline, uint blockTimestamp);

  // Insufficient amount out
  error InsufficientAmountOut(uint amountOut, uint minAmountOut);

  // Buffer Zone
  error NoSwapsInBufferZone();

  // ETH Transfer
  error EthTransferFailed();

  // Circuit breakers
  error EthCircuitBreakerHit();
  error NxmCircuitBreakerHit();
}

// 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 "../external/cow/GPv2Order.sol";
import "../interfaces/IPool.sol";

interface ISwapOperator {

  enum SwapOperationType {
    EthToAsset,
    AssetToEth,
    AssetToAsset
  }

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

  function getDigest(GPv2Order.Data calldata order) external view returns (bytes32);

  function getUID(GPv2Order.Data calldata order) external view returns (bytes memory);

  function orderInProgress() external view returns (bool);

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

  function placeOrder(GPv2Order.Data calldata order, bytes calldata orderUID) external;

  function closeOrder(GPv2Order.Data calldata order) external;

  function swapEnzymeVaultShareForETH(uint amountIn, uint amountOutMin) external;

  function swapETHForEnzymeVaultShare(uint amountIn, uint amountOutMin) external;

  function recoverAsset(address assetAddress, address receiver) external;

  function requestAsset(address asset, uint amount) external;

  function transferRequestedAsset(address requestedAsset, uint requestedAmount) external;

  /* ========== EVENTS AND ERRORS ========== */

  event OrderPlaced(GPv2Order.Data order);
  event OrderClosed(GPv2Order.Data order, uint filledAmount);
  event Swapped(address indexed fromAsset, address indexed toAsset, uint amountIn, uint amountOut);
  event TransferredToSafe(address asset, uint amount);

  // Swap Order
  error OrderInProgress(bytes currentOrderUID);
  error NoOrderInPlace();
  error OrderUidMismatch(bytes providedOrderUID, bytes expectedOrderUID);
  error UnsupportedTokenBalance(string kind);
  error InvalidReceiver(address validReceiver);
  error TokenDisabled(address token);
  error AmountOutTooLow(uint amountOut, uint minAmount);
  error InvalidTokenAddress(string token);
  error InvalidDenominationAsset(address invalidAsset, address validAsset);

  // Valid To
  error BelowMinValidTo(uint minValidTo);
  error AboveMaxValidTo(uint maxValidTo);

  // Balance
  error InvalidBalance(uint tokenBalance, uint limit);
  error InvalidPostSwapBalance(uint postSwapBalance, uint limit);

  // Access Controls
  error OnlyController();

  // Transfer
  error TransferFailed(address to, uint value, address token);

  // Cool down
  error InsufficientTimeBetweenSwaps(uint minValidSwapTime);

  // Fee
  error AboveMaxFee(uint feeInEth, uint maxFee);
}

// 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.8.18;

/**
 * @dev Simple library that defines min, max and babylonian sqrt functions
 */
library Math {

  function min(uint a, uint b) internal pure returns (uint) {
    return a < b ? a : b;
  }

  function max(uint a, uint b) internal pure returns (uint) {
    return a > b ? a : b;
  }

  function sum(uint[] memory items) internal pure returns (uint) {
    uint count = items.length;
    uint total;

    for (uint i = 0; i < count; i++) {
      total += items[i];
    }

    return total;
  }

  function divRound(uint a, uint b) internal pure returns (uint) {
    return (a + b / 2) / b;
  }

  function divCeil(uint a, uint b) internal pure returns (uint) {
    return (a + b - 1) / b;
  }

  function roundUp(uint a, uint b) internal pure returns (uint) {
    return divCeil(a, b) * b;
  }

  // babylonian method
  function sqrt(uint y) internal pure returns (uint) {

    if (y > 3) {
      uint z = y;
      uint x = y / 2 + 1;
      while (x < z) {
        z = x;
        x = (y / x + x) / 2;
      }
      return z;
    }

    if (y != 0) {
      return 1;
    }

    return 0;
  }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

/**
 * @dev Wrappers over Solidity's uintXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeUintCast {
  /**
   * @dev Returns the downcasted uint248 from uint256, reverting on
   * overflow (when the input is greater than largest uint248).
   *
   * Counterpart to Solidity's `uint248` operator.
   *
   * Requirements:
   *
   * - input must fit into 248 bits
   */
  function toUint248(uint256 value) internal pure returns (uint248) {
    require(value < 2**248, "SafeCast: value doesn\'t fit in 248 bits");
    return uint248(value);
  }

  /**
   * @dev Returns the downcasted uint240 from uint256, reverting on
   * overflow (when the input is greater than largest uint240).
   *
   * Counterpart to Solidity's `uint240` operator.
   *
   * Requirements:
   *
   * - input must fit into 240 bits
   */
  function toUint240(uint256 value) internal pure returns (uint240) {
    require(value < 2**240, "SafeCast: value doesn\'t fit in 240 bits");
    return uint240(value);
  }

  /**
   * @dev Returns the downcasted uint232 from uint256, reverting on
   * overflow (when the input is greater than largest uint232).
   *
   * Counterpart to Solidity's `uint232` operator.
   *
   * Requirements:
   *
   * - input must fit into 232 bits
   */
  function toUint232(uint256 value) internal pure returns (uint232) {
    require(value < 2**232, "SafeCast: value doesn\'t fit in 232 bits");
    return uint232(value);
  }

  /**
   * @dev Returns the downcasted uint224 from uint256, reverting on
   * overflow (when the input is greater than largest uint224).
   *
   * Counterpart to Solidity's `uint224` operator.
   *
   * Requirements:
   *
   * - input must fit into 224 bits
   */
  function toUint224(uint256 value) internal pure returns (uint224) {
    require(value < 2**224, "SafeCast: value doesn\'t fit in 224 bits");
    return uint224(value);
  }

  /**
   * @dev Returns the downcasted uint216 from uint256, reverting on
   * overflow (when the input is greater than largest uint216).
   *
   * Counterpart to Solidity's `uint216` operator.
   *
   * Requirements:
   *
   * - input must fit into 216 bits
   */
  function toUint216(uint256 value) internal pure returns (uint216) {
    require(value < 2**216, "SafeCast: value doesn\'t fit in 216 bits");
    return uint216(value);
  }

  /**
   * @dev Returns the downcasted uint208 from uint256, reverting on
   * overflow (when the input is greater than largest uint208).
   *
   * Counterpart to Solidity's `uint208` operator.
   *
   * Requirements:
   *
   * - input must fit into 208 bits
   */
  function toUint208(uint256 value) internal pure returns (uint208) {
    require(value < 2**208, "SafeCast: value doesn\'t fit in 208 bits");
    return uint208(value);
  }

  /**
   * @dev Returns the downcasted uint200 from uint256, reverting on
   * overflow (when the input is greater than largest uint200).
   *
   * Counterpart to Solidity's `uint200` operator.
   *
   * Requirements:
   *
   * - input must fit into 200 bits
   */
  function toUint200(uint256 value) internal pure returns (uint200) {
    require(value < 2**200, "SafeCast: value doesn\'t fit in 200 bits");
    return uint200(value);
  }

  /**
   * @dev Returns the downcasted uint192 from uint256, reverting on
   * overflow (when the input is greater than largest uint192).
   *
   * Counterpart to Solidity's `uint192` operator.
   *
   * Requirements:
   *
   * - input must fit into 192 bits
   */
  function toUint192(uint256 value) internal pure returns (uint192) {
    require(value < 2**192, "SafeCast: value doesn\'t fit in 192 bits");
    return uint192(value);
  }

  /**
   * @dev Returns the downcasted uint184 from uint256, reverting on
   * overflow (when the input is greater than largest uint184).
   *
   * Counterpart to Solidity's `uint184` operator.
   *
   * Requirements:
   *
   * - input must fit into 184 bits
   */
  function toUint184(uint256 value) internal pure returns (uint184) {
    require(value < 2**184, "SafeCast: value doesn\'t fit in 184 bits");
    return uint184(value);
  }

  /**
   * @dev Returns the downcasted uint176 from uint256, reverting on
   * overflow (when the input is greater than largest uint176).
   *
   * Counterpart to Solidity's `uint176` operator.
   *
   * Requirements:
   *
   * - input must fit into 176 bits
   */
  function toUint176(uint256 value) internal pure returns (uint176) {
    require(value < 2**176, "SafeCast: value doesn\'t fit in 176 bits");
    return uint176(value);
  }

  /**
   * @dev Returns the downcasted uint168 from uint256, reverting on
   * overflow (when the input is greater than largest uint168).
   *
   * Counterpart to Solidity's `uint168` operator.
   *
   * Requirements:
   *
   * - input must fit into 168 bits
   */
  function toUint168(uint256 value) internal pure returns (uint168) {
    require(value < 2**168, "SafeCast: value doesn\'t fit in 168 bits");
    return uint168(value);
  }

  /**
   * @dev Returns the downcasted uint160 from uint256, reverting on
   * overflow (when the input is greater than largest uint160).
   *
   * Counterpart to Solidity's `uint160` operator.
   *
   * Requirements:
   *
   * - input must fit into 160 bits
   */
  function toUint160(uint256 value) internal pure returns (uint160) {
    require(value < 2**160, "SafeCast: value doesn\'t fit in 160 bits");
    return uint160(value);
  }

  /**
   * @dev Returns the downcasted uint152 from uint256, reverting on
   * overflow (when the input is greater than largest uint152).
   *
   * Counterpart to Solidity's `uint152` operator.
   *
   * Requirements:
   *
   * - input must fit into 152 bits
   */
  function toUint152(uint256 value) internal pure returns (uint152) {
    require(value < 2**152, "SafeCast: value doesn\'t fit in 152 bits");
    return uint152(value);
  }

  /**
   * @dev Returns the downcasted uint144 from uint256, reverting on
   * overflow (when the input is greater than largest uint144).
   *
   * Counterpart to Solidity's `uint144` operator.
   *
   * Requirements:
   *
   * - input must fit into 144 bits
   */
  function toUint144(uint256 value) internal pure returns (uint144) {
    require(value < 2**144, "SafeCast: value doesn\'t fit in 144 bits");
    return uint144(value);
  }

  /**
   * @dev Returns the downcasted uint136 from uint256, reverting on
   * overflow (when the input is greater than largest uint136).
   *
   * Counterpart to Solidity's `uint136` operator.
   *
   * Requirements:
   *
   * - input must fit into 136 bits
   */
  function toUint136(uint256 value) internal pure returns (uint136) {
    require(value < 2**136, "SafeCast: value doesn\'t fit in 136 bits");
    return uint136(value);
  }

  /**
   * @dev Returns the downcasted uint128 from uint256, reverting on
   * overflow (when the input is greater than largest uint128).
   *
   * Counterpart to Solidity's `uint128` operator.
   *
   * Requirements:
   *
   * - input must fit into 128 bits
   */
  function toUint128(uint256 value) internal pure returns (uint128) {
    require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
    return uint128(value);
  }

  /**
   * @dev Returns the downcasted uint120 from uint256, reverting on
   * overflow (when the input is greater than largest uint120).
   *
   * Counterpart to Solidity's `uint120` operator.
   *
   * Requirements:
   *
   * - input must fit into 120 bits
   */
  function toUint120(uint256 value) internal pure returns (uint120) {
    require(value < 2**120, "SafeCast: value doesn\'t fit in 120 bits");
    return uint120(value);
  }

  /**
   * @dev Returns the downcasted uint112 from uint256, reverting on
   * overflow (when the input is greater than largest uint112).
   *
   * Counterpart to Solidity's `uint112` operator.
   *
   * Requirements:
   *
   * - input must fit into 112 bits
   */
  function toUint112(uint256 value) internal pure returns (uint112) {
    require(value < 2**112, "SafeCast: value doesn\'t fit in 112 bits");
    return uint112(value);
  }

  /**
   * @dev Returns the downcasted uint104 from uint256, reverting on
   * overflow (when the input is greater than largest uint104).
   *
   * Counterpart to Solidity's `uint104` operator.
   *
   * Requirements:
   *
   * - input must fit into 104 bits
   */
  function toUint104(uint256 value) internal pure returns (uint104) {
    require(value < 2**104, "SafeCast: value doesn\'t fit in 104 bits");
    return uint104(value);
  }

  /**
   * @dev Returns the downcasted uint96 from uint256, reverting on
   * overflow (when the input is greater than largest uint96).
   *
   * Counterpart to Solidity's `uint104` operator.
   *
   * Requirements:
   *
   * - input must fit into 96 bits
   */
  function toUint96(uint256 value) internal pure returns (uint96) {
    require(value < 2**96, "SafeCast: value doesn\'t fit in 96 bits");
    return uint96(value);
  }

  /**
   * @dev Returns the downcasted uint88 from uint256, reverting on
   * overflow (when the input is greater than largest uint88).
   *
   * Counterpart to Solidity's `uint104` operator.
   *
   * Requirements:
   *
   * - input must fit into 88 bits
   */
  function toUint88(uint256 value) internal pure returns (uint88) {
    require(value < 2**88, "SafeCast: value doesn\'t fit in 88 bits");
    return uint88(value);
  }

  /**
   * @dev Returns the downcasted uint80 from uint256, reverting on
   * overflow (when the input is greater than largest uint80).
   *
   * Counterpart to Solidity's `uint104` operator.
   *
   * Requirements:
   *
   * - input must fit into 80 bits
   */
  function toUint80(uint256 value) internal pure returns (uint80) {
    require(value < 2**80, "SafeCast: value doesn\'t fit in 80 bits");
    return uint80(value);
  }

  /**
   * @dev Returns the downcasted uint64 from uint256, reverting on
   * overflow (when the input is greater than largest uint64).
   *
   * Counterpart to Solidity's `uint64` operator.
   *
   * Requirements:
   *
   * - input must fit into 64 bits
   */
  function toUint64(uint256 value) internal pure returns (uint64) {
    require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
    return uint64(value);
  }

  /**
   * @dev Returns the downcasted uint56 from uint256, reverting on
   * overflow (when the input is greater than largest uint56).
   *
   * Counterpart to Solidity's `uint56` operator.
   *
   * Requirements:
   *
   * - input must fit into 56 bits
   */
  function toUint56(uint256 value) internal pure returns (uint56) {
    require(value < 2**56, "SafeCast: value doesn\'t fit in 56 bits");
    return uint56(value);
  }

  /**
   * @dev Returns the downcasted uint48 from uint256, reverting on
   * overflow (when the input is greater than largest uint48).
   *
   * Counterpart to Solidity's `uint48` operator.
   *
   * Requirements:
   *
   * - input must fit into 48 bits
   */
  function toUint48(uint256 value) internal pure returns (uint48) {
    require(value < 2**48, "SafeCast: value doesn\'t fit in 48 bits");
    return uint48(value);
  }

  /**
   * @dev Returns the downcasted uint40 from uint256, reverting on
   * overflow (when the input is greater than largest uint40).
   *
   * Counterpart to Solidity's `uint40` operator.
   *
   * Requirements:
   *
   * - input must fit into 40 bits
   */
  function toUint40(uint256 value) internal pure returns (uint40) {
    require(value < 2**40, "SafeCast: value doesn\'t fit in 40 bits");
    return uint40(value);
  }

  /**
   * @dev Returns the downcasted uint32 from uint256, reverting on
   * overflow (when the input is greater than largest uint32).
   *
   * Counterpart to Solidity's `uint32` operator.
   *
   * Requirements:
   *
   * - input must fit into 32 bits
   */
  function toUint32(uint256 value) internal pure returns (uint32) {
    require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
    return uint32(value);
  }

  /**
   * @dev Returns the downcasted uint24 from uint256, reverting on
   * overflow (when the input is greater than largest uint24).
   *
   * Counterpart to Solidity's `uint24` operator.
   *
   * Requirements:
   *
   * - input must fit into 24 bits
   */
  function toUint24(uint256 value) internal pure returns (uint24) {
    require(value < 2**24, "SafeCast: value doesn\'t fit in 24 bits");
    return uint24(value);
  }

  /**
   * @dev Returns the downcasted uint16 from uint256, reverting on
   * overflow (when the input is greater than largest uint16).
   *
   * Counterpart to Solidity's `uint16` operator.
   *
   * Requirements:
   *
   * - input must fit into 16 bits
   */
  function toUint16(uint256 value) internal pure returns (uint16) {
    require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
    return uint16(value);
  }

  /**
   * @dev Returns the downcasted uint8 from uint256, reverting on
   * overflow (when the input is greater than largest uint8).
   *
   * Counterpart to Solidity's `uint8` operator.
   *
   * Requirements:
   *
   * - input must fit into 8 bits.
   */
  function toUint8(uint256 value) internal pure returns (uint8) {
    require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
    return uint8(value);
  }
}

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

[{"inputs":[{"internalType":"address","name":"_master","type":"address"},{"internalType":"address","name":"_priceOracle","type":"address"},{"internalType":"address","name":"_swapOperator","type":"address"},{"internalType":"address","name":"_nxmTokenAddress","type":"address"},{"internalType":"address","name":"_previousPool","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositReturned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"assetAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Payout","type":"event"},{"inputs":[],"name":"ETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MCR_RATIO_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"bool","name":"isCoverAsset","type":"bool"},{"internalType":"uint256","name":"_min","type":"uint256"},{"internalType":"uint256","name":"_max","type":"uint256"},{"internalType":"uint256","name":"_maxSlippageRatio","type":"uint256"}],"name":"addAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"assets","outputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"bool","name":"isCoverAsset","type":"bool"},{"internalType":"bool","name":"isAbandoned","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalAssetValue","type":"uint256"},{"internalType":"uint256","name":"mcrEth","type":"uint256"}],"name":"calculateMCRRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","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":"assetId","type":"uint256"}],"name":"getAsset","outputs":[{"components":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"bool","name":"isCoverAsset","type":"bool"},{"internalType":"bool","name":"isAbandoned","type":"bool"}],"internalType":"struct Asset","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"}],"name":"getAssetSwapDetails","outputs":[{"components":[{"internalType":"uint104","name":"minAmount","type":"uint104"},{"internalType":"uint104","name":"maxAmount","type":"uint104"},{"internalType":"uint32","name":"lastSwapTime","type":"uint32"},{"internalType":"uint16","name":"maxSlippageRatio","type":"uint16"}],"internalType":"struct SwapDetails","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAssets","outputs":[{"components":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"bool","name":"isCoverAsset","type":"bool"},{"internalType":"bool","name":"isAbandoned","type":"bool"}],"internalType":"struct Asset[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"name":"getInternalTokenPriceInAsset","outputs":[{"internalType":"uint256","name":"tokenPrice","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"name":"getInternalTokenPriceInAssetAndUpdateTwap","outputs":[{"internalType":"uint256","name":"tokenPrice","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getMCRRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPoolValueInEth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenPrice","outputs":[{"internalType":"uint256","name":"tokenPrice","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":[],"name":"master","outputs":[{"internalType":"contract ISAFURAMaster","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nxmToken","outputs":[{"internalType":"contract ISAFURAToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceFeedOracle","outputs":[{"internalType":"contract IPriceFeedOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"member","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"sendEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"},{"internalType":"address payable","name":"payoutAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"ethDepositAmount","type":"uint256"}],"name":"sendPayout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"},{"internalType":"bool","name":"isCoverAsset","type":"bool"},{"internalType":"bool","name":"isAbandoned","type":"bool"}],"name":"setAssetDetails","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"uint256","name":"_min","type":"uint256"},{"internalType":"uint256","name":"_max","type":"uint256"},{"internalType":"uint256","name":"_maxSlippageRatio","type":"uint256"}],"name":"setSwapDetails","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"uint32","name":"lastSwapTime","type":"uint32"}],"name":"setSwapDetailsLastSwapTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"setSwapValue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"swapDetails","outputs":[{"internalType":"uint104","name":"minAmount","type":"uint104"},{"internalType":"uint104","name":"maxAmount","type":"uint104"},{"internalType":"uint32","name":"lastSwapTime","type":"uint32"},{"internalType":"uint16","name":"maxSlippageRatio","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapOperator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapValue","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferAssetToSwapOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes8","name":"code","type":"bytes8"},{"internalType":"address","name":"value","type":"address"}],"name":"updateAddressParameters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes8","name":"","type":"bytes8"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"updateUintParameters","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"newPoolAddress","type":"address"}],"name":"upgradeCapitalPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009ce9d59d0767b0ea087342d57da14e99b1192dfe000000000000000000000000347e4950d0d8aa5b01102ec29be7a00ca958ac97000000000000000000000000c3fa7dd9b546188d87f91c5f52fecfda94512120000000000000000000000000ecef1e050432c9304b23b3226659bf8981cf83a200000000000000000000000026578b93a907a99b52af0299cd4eba254780a668

-----Decoded View---------------
Arg [0] : _master (address): 0x9ce9d59D0767b0Ea087342d57dA14e99b1192Dfe
Arg [1] : _priceOracle (address): 0x347E4950D0D8aA5b01102ec29Be7a00Ca958Ac97
Arg [2] : _swapOperator (address): 0xC3Fa7dd9B546188d87f91C5f52fEcfDA94512120
Arg [3] : _nxmTokenAddress (address): 0xeceF1e050432c9304B23b3226659bF8981Cf83a2
Arg [4] : _previousPool (address): 0x26578b93A907a99B52AF0299Cd4eBa254780A668

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000009ce9d59d0767b0ea087342d57da14e99b1192dfe
Arg [1] : 000000000000000000000000347e4950d0d8aa5b01102ec29be7a00ca958ac97
Arg [2] : 000000000000000000000000c3fa7dd9b546188d87f91c5f52fecfda94512120
Arg [3] : 000000000000000000000000ecef1e050432c9304b23b3226659bf8981cf83a2
Arg [4] : 00000000000000000000000026578b93a907a99b52af0299cd4eba254780a668