@etherisc/gif-next 0.0.2-abde86b-349 → 0.0.2-ac4bee9-682

package/contracts/pool/BundleService.sol

@@ -17,7 +17,7 @@ import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol
 import {Fee} from "../type/Fee.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, POOL, BUNDLE, REGISTRY} from "../type/ObjectType.sol";
+import {ObjectType, COMPONENT, POOL, BUNDLE, POLICY, REGISTRY} from "../type/ObjectType.sol";
 import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
@@ -63,7 +63,10 @@ contract BundleService is
     )
         external
         virtual
+        restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
@@ -81,19 +84,18 @@ contract BundleService is
 
 
     function create(
-        IInstance instance,
-        NftId poolNftId,
         address owner, 
         Fee memory bundleFee, 
-        Amount stakingAmount, 
         Seconds lifetime, 
         bytes calldata filter
     )
         external
-        override
-        restricted
+        virtual
+        restricted()
         returns(NftId bundleNftId)
     {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+
         // register bundle with registry
         bundleNftId = _registryService.registerBundle(
             IRegistry.ObjectInfo(
@@ -121,19 +123,11 @@ contract BundleService is
             })
         );
 
-        if (stakingAmount.gtz()) {
-            // bundle book keeping
-            _componentService.increaseBundleBalance(
-                instanceStore, 
-                bundleNftId, 
-                stakingAmount, 
-                AmountLib.zero()); // fee amount
-        }
-
         // put bundle under bundle managemet
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.add(bundleNftId);
-        // TODO add logging
+
+        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId);
     }
 
 
@@ -148,26 +142,35 @@ contract BundleService is
         virtual
         restricted()
     {
+        _checkNftType(policyNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
         InstanceReader instanceReader = instance.getInstanceReader();
-        StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
-        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
 
-        // ensure bundle is active and not yet expired
-        if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.blockTimestamp()) {
-            revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
+        {
+            StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
+            IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+
+            // ensure bundle is active and not yet expired
+            if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.blockTimestamp()) {
+                revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
+            }
         }
 
-        // ensure bundle capacity is sufficent to collateralize policy
         InstanceStore instanceStore = instance.getInstanceStore();
-        (
-            Amount balanceAmount,
-            Amount lockedAmount,
-            Amount feeAmount
-        ) = instanceStore.getAmounts(bundleNftId);
 
-        Amount capacity = balanceAmount - (lockedAmount + feeAmount);
-        if(capacity < collateralAmount) {
-            revert ErrorBundleServiceCapacityInsufficient(bundleNftId, capacity, collateralAmount);
+        {
+            // ensure bundle capacity is sufficent to collateralize policy
+            (
+                Amount balanceAmount,
+                Amount lockedAmount,
+                Amount feeAmount
+            ) = instanceStore.getAmounts(bundleNftId);
+
+            Amount capacity = balanceAmount - (lockedAmount + feeAmount);
+            if(capacity < collateralAmount) {
+                revert ErrorBundleServiceCapacityInsufficient(bundleNftId, capacity, collateralAmount);
+            }
         }
 
         // updated locked amount
@@ -181,7 +184,10 @@ contract BundleService is
     function lock(NftId bundleNftId) 
         external
         virtual
+        restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
         // udpate bundle state
@@ -198,7 +204,10 @@ contract BundleService is
     function unlock(NftId bundleNftId) 
         external
         virtual
+        restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
         // udpate bundle state
@@ -218,9 +227,11 @@ contract BundleService is
     ) 
         external
         virtual
-        restricted
+        restricted()
         returns (Amount unstakedAmount, Amount feeAmount)
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         InstanceReader instanceReader = instance.getInstanceReader();
 
         // ensure no open policies attached to bundle
@@ -252,8 +263,10 @@ contract BundleService is
     ) 
         external 
         virtual
-        // TODO: restricted() (once #462 is done)
+        restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
         StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
 
@@ -278,9 +291,11 @@ contract BundleService is
     ) 
         external 
         virtual
-        // TODO: restricted() (once #462 is done)
+        restricted()
         returns (Amount unstakedAmount)
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         InstanceStore instanceStore = instance.getInstanceStore();
         (
             Amount balanceAmount,
@@ -288,7 +303,7 @@ contract BundleService is
             Amount feeAmount
         ) = instanceStore.getAmounts(bundleNftId);
 
-        Amount unstakedAmount = amount;
+        unstakedAmount = amount;
         Amount availableAmount = balanceAmount - (lockedAmount + feeAmount);
 
         // if amount is max, then unstake all available 
@@ -306,17 +321,17 @@ contract BundleService is
             bundleNftId, 
             unstakedAmount, 
             AmountLib.zero());
-
-        return unstakedAmount;
     }
 
     /// @inheritdoc IBundleService
     function extend(NftId bundleNftId, Seconds lifetimeExtension) 
         external 
         virtual
-        // TODO: restricted() (once #462 is done)
+        restricted()
         returns (Timestamp extendedExpiredAt) 
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
         StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
@@ -354,6 +369,9 @@ contract BundleService is
         virtual
         restricted()
     {
+        _checkNftType(policyNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
         instance.getInstanceStore().decreaseLocked(bundleNftId, collateralAmount);
     }
 
@@ -366,8 +384,10 @@ contract BundleService is
         virtual
         restricted
     {
+        _checkNftType(policyNftId, POLICY());
+
         // ensure policy is closeable
-        if (!instance.getInstanceReader().policyIsCloseable(policyNftId)) {
+        if (!policyIsCloseable(instance, policyNftId)) {
             revert ErrorBundleServicePolicyNotCloseable(policyNftId);
         }
 
@@ -378,16 +398,18 @@ contract BundleService is
     function withdrawBundleFees(NftId bundleNftId, Amount amount) 
         public 
         virtual
-        // TODO: restricted() (once #462 is done)
+        restricted()
         returns (Amount withdrawnAmount) 
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader reader = instance.getInstanceReader();
         
         IComponents.ComponentInfo memory poolInfo = reader.getComponentInfo(poolNftId);
-        address poolWallet = poolInfo.wallet;
+        address poolWallet = poolInfo.tokenHandler.getWallet();
         
-        IBundle.BundleInfo memory bundleInfo = reader.getBundleInfo(bundleNftId);
+        // IBundle.BundleInfo memory bundleInfo = reader.getBundleInfo(bundleNftId);
         
         // determine withdrawn amount
         withdrawnAmount = amount;
@@ -416,6 +438,31 @@ contract BundleService is
         }
     }
 
+    /// @inheritdoc IBundleService
+    function policyIsCloseable(IInstance instance, NftId policyNftId)
+        public
+        view
+        returns (bool isCloseable)
+    {
+        _checkNftType(policyNftId, POLICY());
+
+        IPolicy.PolicyInfo memory info = instance.getInstanceReader().getPolicyInfo(policyNftId);
+        
+        if (info.productNftId.eqz()) { return false; } // not closeable: policy does not exist (or does not belong to this instance)
+        if (info.activatedAt.eqz()) { return false; } // not closeable: not yet activated
+        if (info.closedAt.gtz()) { return false; } // not closeable: already closed
+        if (info.openClaimsCount > 0) { return false; } // not closeable: has open claims
+
+        // closeable: if sum of claims matches sum insured a policy may be closed prior to the expiry date
+        if (info.claimAmount == info.sumInsuredAmount) { return true; }
+
+        // not closeable: not yet expired
+        if (TimestampLib.blockTimestamp() < info.expiredAt) { return false; }
+
+        // all conditionsl to close the policy are met
+        return true; 
+    }
+
     /// @dev links policy to bundle
     function _linkPolicy(IInstance instance, NftId policyNftId) 
         internal

package/contracts/pool/IBundleService.sol

@@ -13,6 +13,7 @@ import {Timestamp} from "../type/Timestamp.sol";
 
 interface IBundleService is IService {
 
+    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId);
     event LogBundleServiceBundleActivated(NftId bundleNftId);
     event LogBundleServiceBundleLocked(NftId bundleNftId);
 
@@ -35,14 +36,10 @@ interface IBundleService is IService {
     event LogBundleServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
     event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
 
-    /// @dev create a new bundle for the specified attributes
-    /// may only be called by pool service
+    /// @dev Create a new bundle for the specified attributes.
     function create(
-        IInstance instance, // instance relevant for bundle
-        NftId poolNftId, // the pool the bundle will be linked to
         address owner, // initial bundle owner
         Fee memory fee, // fees deducted from premium that go to bundle owner
-        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
         Seconds lifetime, // initial duration for which new policies are covered
         bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
     )
@@ -131,4 +128,13 @@ interface IBundleService is IService {
     /// @return withdrawnAmount the effective withdrawn amount
     function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
 
+    /// @dev returns true iff policy may be closed
+    /// a policy can be closed all conditions below are met
+    /// - policy exists
+    /// - has been activated
+    /// - is not yet closed
+    /// - has no open claims
+    /// - claim amount matches sum insured amount or is expired
+    function policyIsCloseable(IInstance instance, NftId policyNftId) external view returns (bool isCloseable);
+
 }

package/contracts/pool/IPoolComponent.sol

@@ -27,9 +27,7 @@ interface IPoolComponent is IInstanceLinkedComponent {
     /// The default implementation is empty.
     function verifyApplication(
         NftId applicationNftId, 
-        bytes memory applicationData,
         NftId bundleNftId, 
-        bytes memory bundleFilter,
         Amount collateralizationAmount
     ) external;
 
@@ -47,6 +45,7 @@ interface IPoolComponent is IInstanceLinkedComponent {
         view
         returns (bool isMatching);
 
+
     /// @dev This is a callback function that is called by the claim service when a claim is confirmed.
     /// The pool has the option to implement custom behavirous such as triggering a reinsurance claim or blocking the claim confirmaation.
     /// The default implementation is empty.
@@ -56,11 +55,6 @@ interface IPoolComponent is IInstanceLinkedComponent {
         Amount amount
     ) external;
 
-    /// @dev Withdraw bundle feeds for the given bundle
-    /// @param bundleNftId the bundle Nft Id
-    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
-    /// @return withdrawnAmount the effective withdrawn amount
-    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
 
     /// @dev Returns initial pool specific infos for this pool
     function getInitialPoolInfo() external view returns (IComponents.PoolInfo memory info);

package/contracts/pool/IPoolService.sol

@@ -19,25 +19,23 @@ import {UFixed} from "../type/UFixed.sol";
 interface IPoolService is IService {
 
     event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
-    event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
+    event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);
+    event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
     event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
 
     event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
-    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
 
     event LogPoolServiceProcessFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount);
 
+    error ErrorPoolServicePoolNotExternallyManaged(NftId poolNftId);
     error ErrorPoolServicePolicyPoolMismatch(NftId policyNftId, NftId productNftId, NftId expectedProductNftId);
     error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
     error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
     error ErrorPoolServiceBundlePoolMismatch(NftId bundleNftId, NftId poolNftId);
     error ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
-    
-    /// @dev defines the required role for bundle owners for the calling pool
-    /// default implementation returns PUBLIC ROLE
-    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
 
     /// @dev sets the max balance amount for the calling pool
     function setMaxBalanceAmount(Amount maxBalanceAmount) external;
@@ -72,10 +70,10 @@ interface IPoolService is IService {
     ) external;
 
 
-    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy and updates pool/bundle counters
     /// every payout of a policy reduces the collateral by the payout amount
     /// may only be called by the claim service for unlocked pool components
-    function reduceCollateral(
+    function processPayout(
         IInstance instance, 
         address token,
         NftId policyNftId, 
@@ -84,16 +82,17 @@ interface IPoolService is IService {
     ) external;
 
 
-    /// @dev create a new empty bundle with the provided parameters
-    /// may only be called by registered and unlocked pool components.
-    function createBundle(
-        address owner, // initial bundle owner
-        Fee memory fee, // fees deducted from premium that go to bundle owner
-        Seconds lifetime, // initial duration for which new policies are covered
-        bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
-    )
-        external 
-        returns(NftId bundleNftId); // the nft id of the newly created bundle
+    // TODO cleanup
+    // /// @dev create a new empty bundle with the provided parameters
+    // /// may only be called by registered and unlocked pool components.
+    // function createBundle(
+    //     address owner, // initial bundle owner
+    //     Fee memory fee, // fees deducted from premium that go to bundle owner
+    //     Seconds lifetime, // initial duration for which new policies are covered
+    //     bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
+    // )
+    //     external 
+    //     returns(NftId bundleNftId); // the nft id of the newly created bundle
 
 
     /// @dev increase stakes for bundle
@@ -121,18 +120,18 @@ interface IPoolService is IService {
     function processFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount) external;
 
 
-    /// @dev Fund the specified pool wallet with the provided amount.
-    /// This function will collect the amount from the sender address and transfers it to the pool wallet.
+    /// @dev Fund the pool wallet with the provided amount.
+    /// This function will collect the amount from the pool owner and transfers it to the pool wallet.
     /// The function will not update balance amounts managed by the framework.
     /// Only available for externally managed pools.
-    function fundPoolWallet(NftId poolNftId, Amount amount) external;
+    function fundPoolWallet(Amount amount) external;
 
 
     /// @dev Defund the specified pool wallet with the provided amount.
-    /// This function will transfer the amount from the pool wallet to the sender address.
+    /// This function will transfer the amount from the pool wallet to the pool owner.
     /// The function will not update balance amounts managed by the framework.
     /// Only available for externally managed pools.
-    function defundPoolWallet(NftId poolNftId, Amount amount) external;
+    function defundPoolWallet(Amount amount) external;
 
 
     /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
@@ -148,8 +147,10 @@ interface IPoolService is IService {
         external
         view 
         returns(
+            NftId poolNftId,
             Amount totalCollateralAmount,
-            Amount localCollateralAmount
+            Amount localCollateralAmount,
+            bool poolIsVerifyingApplications
         );