@ensuro/core 2.0.0-beta9 → 2.0.0

package/contracts/SignedQuoteRiskModule.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
+import {RiskModule} from "./RiskModule.sol";
+import {Policy} from "./Policy.sol";
+
+/**
+ * @title SignedQuote Risk Module
+ * @dev Risk Module that for policy creation verifies the different components of the price have been signed by a
+        trusted account (PRICER_ROLE). For the resolution (resolvePolicy), it has to be called by an authorized user
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract SignedQuoteRiskModule is RiskModule {
+  bytes32 public constant POLICY_CREATOR_ROLE = keccak256("POLICY_CREATOR_ROLE");
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
+
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  bool internal immutable _creationIsOpen;
+
+  /**
+   * @dev Event emitted every time a new policy is created. It allows to link the policyData with a particular policy
+   *
+   * @param policyId The id of the policy
+   * @param policyData The value sent in `policyData` parameter that's the hash of the off-chain stored data.
+   */
+  event NewSignedPolicy(uint256 indexed policyId, bytes32 policyData);
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor(
+    IPolicyPool policyPool_,
+    IPremiumsAccount premiumsAccount_,
+    bool creationIsOpen_
+  ) RiskModule(policyPool_, premiumsAccount_) {
+    _creationIsOpen = creationIsOpen_;
+  }
+
+  /**
+   * @dev Initializes the RiskModule
+   * @param name_ Name of the Risk Module
+   * @param collRatio_ Collateralization ratio to compute solvency requirement as % of payout (in ray)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in ray)
+   * @param srRoc_ return on capital paid to Senior LPs (annualized percentage - in ray)
+   * @param maxPayoutPerPolicy_ Maximum payout per policy (in wad)
+   * @param exposureLimit_ Max exposure (sum of payouts) to be allocated to this module (in wad)
+   * @param wallet_ Address of the RiskModule provider
+   */
+  function initialize(
+    string memory name_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
+    address wallet_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
+      wallet_
+    );
+  }
+
+  function _newPolicySigned(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil,
+    address payer,
+    address onBehalfOf
+  ) internal returns (Policy.PolicyData memory createdPolicy) {
+    if (!_creationIsOpen)
+      _policyPool.access().checkComponentRole(
+        address(this),
+        POLICY_CREATOR_ROLE,
+        _msgSender(),
+        false
+      );
+    require(quoteValidUntil >= block.timestamp, "Quote expired");
+
+    /**
+     * Checks the quote has been signed by an authorized user
+     * The "quote" is computed as hash of the following fields (encodePacked):
+     * - address(this): the address of this RiskModule
+     * - payout, premium, lossProb, expiration: the base parameters of the policy
+     * - policyData: a hash of the private details of the policy. The calculation should include some
+     *   unique id (quoteId), so each policyData identifies a policy.
+     * - quoteValidUntil: the maximum validity of the quote
+     */
+    bytes32 quoteHash = ECDSA.toEthSignedMessageHash(
+      abi.encodePacked(
+        address(this),
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteValidUntil
+      )
+    );
+    address signer = ECDSA.recover(quoteHash, quoteSignatureR, quoteSignatureVS);
+    _policyPool.access().checkComponentRole(address(this), PRICER_ROLE, signer, false);
+    uint96 internalId = uint96(uint256(policyData) % 2**96);
+
+    createdPolicy = _newPolicy(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      payer,
+      onBehalfOf,
+      internalId
+    );
+    emit NewSignedPolicy(createdPolicy.id, policyData);
+    return createdPolicy;
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. The caller is the payer of the policy. Returns all the struct, not just the id.
+   *
+   * Requirements:
+   * - The caller approved the spending of the premium to the PolicyPool
+   * - The quote has been signed by an address with the component role PRICER_ROLE
+   *
+   *  Emits:
+   * - {PolicyPool.NewPolicy}
+   *  - {NewSignedPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the payer
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param policyData A hash of the private details of the policy. The last 96 bits will be used as internalId
+   * @param quoteSignatureR The signature of the quote. R component (EIP-2098 signature)
+   * @param quoteSignatureVS The signature of the quote. VS component (EIP-2098 signature)
+   * @param quoteValidUntil The expiration of the quote
+   * @return createdPolicy Returns the created policy
+   */
+  function newPolicyFull(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external returns (Policy.PolicyData memory createdPolicy) {
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteSignatureR,
+        quoteSignatureVS,
+        quoteValidUntil,
+        _msgSender(),
+        onBehalfOf
+      );
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. The caller is the payer of the policy.
+   *
+   * Requirements:
+   * - The caller approved the spending of the premium to the PolicyPool
+   * - The quote has been signed by an address with the component role PRICER_ROLE
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   * - {NewSignedPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the payer
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param policyData A hash of the private details of the policy. The last 96 bits will be used as internalId
+   * @param quoteSignatureR The signature of the quote. R component (EIP-2098 signature)
+   * @param quoteSignatureVS The signature of the quote. VS component (EIP-2098 signature)
+   * @param quoteValidUntil The expiration of the quote
+   * @return Returns the id of the created policy
+   */
+  function newPolicy(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external returns (uint256) {
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteSignatureR,
+        quoteSignatureVS,
+        quoteValidUntil,
+        _msgSender(),
+        onBehalfOf
+      ).id;
+  }
+
+  /**
+   * @dev Creates a new Policy using a signed quote. The payer is the policy holder
+   *
+   * Requirements:
+   * - currency().allowance(onBehalfOf, _msgSender()) > 0
+   * - The quote has been signed by an address with the component role PRICER_ROLE
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   * - {NewSignedPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the payer
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param policyData A hash of the private details of the policy. The last 96 bits will be used as internalId
+   * @param quoteSignatureR The signature of the quote. R component (EIP-2098 signature)
+   * @param quoteSignatureVS The signature of the quote. VS component (EIP-2098 signature)
+   * @param quoteValidUntil The expiration of the quote
+   * @return Returns the id of the created policy
+   */
+  function newPolicyPaidByHolder(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    bytes32 policyData,
+    bytes32 quoteSignatureR,
+    bytes32 quoteSignatureVS,
+    uint40 quoteValidUntil
+  ) external returns (uint256) {
+    require(
+      onBehalfOf == _msgSender() || currency().allowance(onBehalfOf, _msgSender()) > 0,
+      "Sender is not authorized to create policies onBehalfOf"
+    );
+    /**
+     * The standard is the payer should be the _msgSender() but usually, in this type of module,
+     * the sender is an operative account managed by software, where the onBehalfOf is a more
+     * secure account (hardware wallet) that does the cash movements.
+     * This non standard behaviour allows for a more secure setup, where the sender never manages
+     * cash.
+     * We leverage the currency's allowance mechanism to allow the sender access to the payer's
+     * funds.
+     * Note that this allowance won't be spent, so anything above 0 is accepted.
+     */
+    return
+      _newPolicySigned(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        policyData,
+        quoteSignatureR,
+        quoteSignatureVS,
+        quoteValidUntil,
+        onBehalfOf,
+        onBehalfOf
+      ).id;
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+    whenNotPaused
+  {
+    _policyPool.resolvePolicy(policy, payout);
+  }
+
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+    whenNotPaused
+  {
+    _policyPool.resolvePolicyFullPayout(policy, customerWon);
+  }
+
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[50] private __gap;
+}

package/contracts/TrustfulRiskModule.sol

@@ -54,6 +54,23 @@ contract TrustfulRiskModule is RiskModule {
     );
   }
 
+  /**
+   * @dev Creates a new Policy
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(PRICER_ROLE)
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the policyHolder
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param internalId An id that's unique within this module and it will be used to identify the policy
+   * @return Returns the id of the created policy
+   */
   function newPolicy(
     uint256 payout,
     uint256 premium,
@@ -62,7 +79,57 @@ contract TrustfulRiskModule is RiskModule {
     address onBehalfOf,
     uint96 internalId
   ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
-    address payer = onBehalfOf;
+    return
+      _newPolicy(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _getPayer(onBehalfOf, premium),
+        onBehalfOf,
+        internalId
+      ).id;
+  }
+
+  /**
+   * @dev Creates a new Policy. Version that returns all the PolicyData struct, not just the id.
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(PRICER_ROLE)
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the policyHolder
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param internalId An id that's unique within this module and it will be used to identify the policy
+   * @return createdPolicy Returns the id of the created policy
+   */
+  function newPolicyFull(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    uint96 internalId
+  ) external onlyComponentRole(PRICER_ROLE) returns (Policy.PolicyData memory createdPolicy) {
+    return
+      _newPolicy(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _getPayer(onBehalfOf, premium),
+        onBehalfOf,
+        internalId
+      );
+  }
+
+  function _getPayer(address onBehalfOf, uint256 premium) internal view returns (address payer) {
+    payer = onBehalfOf;
     if (payer != _msgSender() && _policyPool.currency().allowance(payer, _msgSender()) < premium)
       /**
        * The standard is the payer should be the _msgSender() but usually, in this type of module,
@@ -76,10 +143,23 @@ contract TrustfulRiskModule is RiskModule {
        * premium even for multiple policies.
        */
       payer = _msgSender();
-
-    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
+    return payer;
   }
 
+  /**
+   * @dev Resolves a policy, if payout > 0, it pays to the policy holder.
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(RESOLVER_ROLE)
+   * - payout <= policy.payout
+   * - block.timestamp >= policy.expiration
+   *
+   * Emits:
+   * - {PolicyPool.PolicyResolved}
+   *
+   * @param policy The policy previously created (from {NewPolicy} event)
+   * @param payout The payout to transfer to the policy holder
+   */
   function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
     external
     onlyComponentRole(RESOLVER_ROLE)
@@ -88,6 +168,20 @@ contract TrustfulRiskModule is RiskModule {
     _policyPool.resolvePolicy(policy, payout);
   }
 
+  /**
+   * @dev Resolves a policy with full payout (policy.payout) if customerWon == true
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(RESOLVER_ROLE)
+   * - block.timestamp >= policy.expiration
+   *
+   * Emits:
+   * - {PolicyPool.PolicyResolved}
+   *
+   * @param policy The policy previously created (from {NewPolicy} event)
+   * @param customerWon If true, policy.payout is transferred to the policy holder. If false, the policy is resolved
+   * without payout and can't be longer claimed.
+   */
   function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
     external
     onlyComponentRole(RESOLVER_ROLE)
@@ -95,4 +189,11 @@ contract TrustfulRiskModule is RiskModule {
   {
     _policyPool.resolvePolicyFullPayout(policy, customerWon);
   }
+
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[50] private __gap;
 }

package/contracts/interfaces/IAssetManager.sol

@@ -1,14 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
 /**
  * @title IAssetManager - Interface of the asset management strategy that's plugged into the reserves
  * @dev The asset manager is a contract that's plugged and called with `delegatecall` (operates in the context of the
  *      reserve - see {Reserve}). The asset manager contract applies a strategy to invest the reserve funds and
  *      get additional yields.
+ *
+ *      All implementations of this contract should use the Diamond Storage pattern to avoid overwriting the calling contract's state.
+ *      See https://eips.ethereum.org/EIPS/eip-2535#storage
  * @author Ensuro
  */
-interface IAssetManager {
+interface IAssetManager is IERC165 {
   /**
    * @dev Event emitted when funds are removed from Reserve liquidity and invested in the investment strategy,
    * @param amount The amount invested
@@ -57,8 +62,8 @@ interface IAssetManager {
   function recordEarnings() external returns (int256);
 
   /**
-   * @dev Refills the reserve balance with enought money to do a payment. Called from the reserve when a payment needs
-   * to be made and there's no enought liquid balance (`currency().balanceOf(reserve) < paymentAmount`)
+   * @dev Refills the reserve balance with enough money to do a payment. Called from the reserve when a payment needs
+   * to be made and there's no enough liquid balance (`currency().balanceOf(reserve) < paymentAmount`)
    *
    * Events:
    * - Emits {MoneyDeinvested} with the amount transferred to the liquid balance.

package/contracts/interfaces/IPolicyPool.sol

@@ -101,12 +101,23 @@ interface IPolicyPool {
   function expirePolicy(Policy.PolicyData calldata policy) external;
 
   /**
-   * @dev Returns whether or not a policy is active
-   * @param policyId The id of the policy we are querying
-   * @return Returns true if a policy with that id was created and wasn't yet resolved or expired, or false otherwise.
+   * @dev Returns whether a policy is active, i.e., it's still in the PolicyPool, not yet resolved or expired.
+   *      Be aware that a policy might be active but the `block.timestamp` might be after the expiration date, so it
+   *      can't be triggered with a payout.
+   *
+   * @param policyId The id of the policy queried
+   * @return Whether the policy is active or not
    */
   function isActive(uint256 policyId) external view returns (bool);
 
+  /**
+   * @dev Returns the stored hash of the policy. It's `bytes32(0)` is the policy isn't active.
+   *
+   * @param policyId The id of the policy queried
+   * @return Returns the hash of a given policy id
+   */
+  function getPolicyHash(uint256 policyId) external view returns (bytes32);
+
   /**
    * @dev Deposits liquidity into an eToken. Forwards the call to {EToken-deposit}, after transferring the funds.
    * The user will receive etokens for the same amount deposited.
@@ -137,7 +148,7 @@ interface IPolicyPool {
    *
    * @param eToken The address of the eToken from where the user wants to withdraw liquidity
    * @param amount The amount to withdraw. If equal to type(uint256).max, means full withdrawal.
-   *               If the balance is not enought or can't be withdrawn (locked as SCR), it withdraws
+   *               If the balance is not enough or can't be withdrawn (locked as SCR), it withdraws
    *               as much as it can, but doesn't fails.
    * @return Returns the actual amount withdrawn.
    */

package/contracts/interfaces/IPolicyPoolComponent.sol

@@ -2,13 +2,14 @@
 pragma solidity ^0.8.0;
 
 import {IPolicyPool} from "./IPolicyPool.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /**
  * @title IPolicyPoolComponent interface
  * @dev Interface for Contracts linked (owned) by a PolicyPool. Useful to avoid cyclic dependencies
  * @author Ensuro
  */
-interface IPolicyPoolComponent {
+interface IPolicyPoolComponent is IERC165 {
   /**
    * @dev Returns the address of the PolicyPool (see {PolicyPool}) where this component belongs.
    */

package/contracts/mocks/InterfaceIdCalculator.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
+import {IEToken} from "../interfaces/IEToken.sol";
+import {IRiskModule} from "../interfaces/IRiskModule.sol";
+import {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
+import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
+import {IAccessManager} from "../interfaces/IAccessManager.sol";
+import {IAssetManager} from "../interfaces/IAssetManager.sol";
+
+contract InterfaceIdCalculator {
+  bytes4 public constant IERC165_INTERFACEID = type(IERC165).interfaceId;
+  bytes4 public constant IERC20_INTERFACEID = type(IERC20).interfaceId;
+  bytes4 public constant IERC20METADATA_INTERFACEID = type(IERC20Metadata).interfaceId;
+  bytes4 public constant IERC721_INTERFACEID = type(IERC721).interfaceId;
+  bytes4 public constant IACCESSCONTROL_INTERFACEID = type(IAccessControl).interfaceId;
+  bytes4 public constant IPOLICYPOOL_INTERFACEID = type(IPolicyPool).interfaceId;
+  bytes4 public constant IPOLICYPOOLCOMPONENT_INTERFACEID = type(IPolicyPoolComponent).interfaceId;
+  bytes4 public constant IETOKEN_INTERFACEID = type(IEToken).interfaceId;
+  bytes4 public constant IRISKMODULE_INTERFACEID = type(IRiskModule).interfaceId;
+  bytes4 public constant IPREMIUMSACCOUNT_INTERFACEID = type(IPremiumsAccount).interfaceId;
+  bytes4 public constant ILPWHITELIST_INTERFACEID = type(ILPWhitelist).interfaceId;
+  bytes4 public constant IACCESSMANAGER_INTERFACEID = type(IAccessManager).interfaceId;
+  bytes4 public constant IASSETMANAGER_INTERFACEID = type(IAssetManager).interfaceId;
+}

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
 
@@ -14,4 +15,13 @@ contract PolicyPoolComponentMock is IPolicyPoolComponent {
   function policyPool() external view override returns (IPolicyPool) {
     return _policyPool;
   }
+
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   */
+  function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+    return
+      interfaceId == type(IERC165).interfaceId ||
+      interfaceId == type(IPolicyPoolComponent).interfaceId;
+  }
 }

package/contracts/mocks/PolicyPoolMock.sol

@@ -85,6 +85,10 @@ contract PolicyPoolMock is IPolicyPool {
     return policyHashes[policyId] != bytes32(0);
   }
 
+  function getPolicyHash(uint256 policyId) external view override returns (bytes32) {
+    return policyHashes[policyId];
+  }
+
   function deposit(IEToken, uint256) external pure override {
     revert("Not Implemented deposit");
   }