@etherisc/gif-next 0.0.2-b9366f5-670 → 0.0.2-b98b2b0-875

package/contracts/pool/Pool.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
@@ -40,6 +41,16 @@ abstract contract Pool is
     }
 
 
+    function register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getPoolStorage()._componentService.registerPool();
+        _approveTokenHandler(type(uint256).max);
+    }
+
+
     /// @dev see {IPoolComponent.verifyApplication}
     function verifyApplication(
         NftId applicationNftId, 
@@ -67,6 +78,20 @@ abstract contract Pool is
     }
 
 
+    /// @dev see {IPoolComponent.processConfirmedClaim}
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+    {
+        // default implementation is empty
+    }
+
+
     /// @dev see {IPoolComponent.applicationMatchesBundle}
     /// Override this function to implement any custom application verification 
     /// Default implementation always returns true
@@ -85,16 +110,6 @@ abstract contract Pool is
         return true;
     }
 
-
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getPoolStorage()._componentService.registerPool();
-        _approveTokenHandler(type(uint256).max);
-    }
-
     /// @inheritdoc IPoolComponent
     function withdrawBundleFees(NftId bundleNftId, Amount amount) 
         external 
@@ -117,6 +132,7 @@ abstract contract Pool is
             maxBalanceAmount: AmountLib.max(),
             bundleOwnerRole: PUBLIC_ROLE(), 
             isInterceptingBundleTransfers: isNftInterceptor(),
+            isProcessingConfirmedClaims: false,
             isExternallyManaged: false,
             isVerifyingApplications: false,
             collateralizationLevel: UFixedLib.toUFixed(1),
@@ -158,7 +174,7 @@ abstract contract Pool is
         $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IPoolComponent).interfaceId);
+        _registerInterface(type(IPoolComponent).interfaceId);
     }
 
     /// @dev increases the staked tokens by the specified amount
@@ -318,6 +334,17 @@ abstract contract Pool is
         return _getPoolStorage()._bundleService.withdrawBundleFees(bundleNftId, amount);
     }
 
+    function _processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    )
+        internal
+    {
+        _getPoolStorage()._poolService.processFundedClaim(
+            policyNftId, claimId, availableAmount);
+    }
+
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {
             $.slot := POOL_STORAGE_LOCATION_V1

package/contracts/pool/PoolService.sol

@@ -8,12 +8,14 @@ import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IProductComponent} from "../product/IProductComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IStaking} from "../staking/IStaking.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
@@ -21,7 +23,7 @@ import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {UFixed} from "../type/UFixed.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
@@ -44,16 +46,15 @@ contract PoolService is
         bytes memory data
     )
         internal
-        initializer
         virtual override
+        initializer()
     {
         (
-            address registryAddress,, 
-            //address managerAddress
+            address registryAddress,
             address authority
-        ) = abi.decode(data, (address, address, address));
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, authority, owner);
+        _initializeService(registryAddress, authority, owner);
 
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _bundleService = IBundleService(_getServiceAddress(BUNDLE()));
@@ -62,9 +63,10 @@ contract PoolService is
 
         _staking = IStaking(getRegistry().getStakingAddress());
 
-        registerInterface(type(IPoolService).interfaceId);
+        _registerInterface(type(IPoolService).interfaceId);
     }
 
+
     /// @inheritdoc IPoolService
     function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
@@ -81,6 +83,7 @@ contract PoolService is
         emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
+
     function setBundleOwnerRole(RoleId bundleOwnerRole)
         external
         virtual
@@ -102,6 +105,7 @@ contract PoolService is
         emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
     }
 
+
     /// @inheritdoc IPoolService
     function createBundle(
         address bundleOwner, // initial bundle owner
@@ -128,6 +132,7 @@ contract PoolService is
         emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
     }
 
+
     function _getStakingFee(InstanceReader instanceReader, NftId poolNftId)
         internal
         virtual
@@ -138,6 +143,7 @@ contract PoolService is
         return instanceReader.getProductInfo(productNftId).stakingFee;
     }
 
+
     function closeBundle(NftId bundleNftId)
         external
         virtual
@@ -166,6 +172,39 @@ contract PoolService is
         }
     }
 
+
+    /// @inheritdoc IPoolService
+    function processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    ) 
+        external
+        virtual
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
+
+        // check policy matches with calling pool
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
+        if(policyInfo.productNftId != productNftId) {
+            revert ErrorPoolServicePolicyPoolMismatch(
+                policyNftId, 
+                policyInfo.productNftId, 
+                productNftId);
+        }
+
+        emit LogPoolServiceProcessFundedClaim(policyNftId, claimId, availableAmount);
+
+        // callback to product component if applicable
+        if (instanceReader.getProductInfo(productNftId).isProcessingFundedClaims) {
+            address productAddress = getRegistry().getObjectAddress(productNftId);
+            IProductComponent(productAddress).processFundedClaim(policyNftId, claimId, availableAmount);
+        }
+    }
+
+
     /// @inheritdoc IPoolService
     function stake(NftId bundleNftId, Amount amount) 
         external 
@@ -189,6 +228,7 @@ contract PoolService is
             }
         }
 
+
         // calculate fees
         Amount feeAmount;
         (
@@ -327,13 +367,13 @@ contract PoolService is
         virtual
         restricted()
         returns (
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
         (
-            localCollateralAmount,
-            totalCollateralAmount
+            totalCollateralAmount,
+            localCollateralAmount
         ) = calculateRequiredCollateral(
             instance.getInstanceReader(),
             productNftId, 
@@ -359,8 +399,7 @@ contract PoolService is
         }
     }
 
-
-    function reduceCollateral(
+    function processPayout(
         IInstance instance, 
         address token,
         NftId policyNftId, 
@@ -371,6 +410,22 @@ contract PoolService is
         virtual
         restricted()
     {
+        NftId bundleNftId = policyInfo.bundleNftId;
+        NftId poolNftId = getRegistry().getObjectInfo(bundleNftId).parentNftId;
+        InstanceStore instanceStore = instance.getInstanceStore();
+        
+        _componentService.decreasePoolBalance(
+            instanceStore,
+            poolNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
+        _componentService.decreaseBundleBalance(
+            instanceStore,
+            bundleNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
         _bundleService.releaseCollateral(
             instance, 
             policyNftId, 
@@ -425,16 +480,16 @@ contract PoolService is
         public
         view 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
         NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
         (
-            localCollateralAmount,
-            totalCollateralAmount
+            totalCollateralAmount,
+            localCollateralAmount
         ) = calculateRequiredCollateral(
             poolInfo.collateralizationLevel,
             poolInfo.retentionLevel,
@@ -450,18 +505,17 @@ contract PoolService is
         public
         pure 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
-        // TODO define if only applies to local collateral
-        // TODO add minimalistic implementation
-
-        // assumptions 
-        // - collateralizationLevel == 1.0
-        // - retentionLevel == 1.0
-        localCollateralAmount = sumInsuredAmount;
-        totalCollateralAmount = localCollateralAmount;
+        // collateralization is applied to sum insured
+        UFixed totalUFixed = collateralizationLevel * sumInsuredAmount.toUFixed();
+        totalCollateralAmount = AmountLib.toAmount(totalUFixed.toInt());
+
+        // retention level defines how much capital is required locally
+        localCollateralAmount = AmountLib.toAmount(
+            (retentionLevel * totalUFixed).toInt());
     }
 
 

package/contracts/pool/PoolServiceManager.sol

@@ -12,14 +12,14 @@ contract PoolServiceManager is ProxyManager {
     /// @dev initializes proxy manager with pool service implementation 
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
         PoolService poolSrv = new PoolService{salt: salt}();
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
             address(poolSrv), 
             data,
             salt);

package/contracts/product/ApplicationService.sol

@@ -41,18 +41,17 @@ contract ApplicationService is
         initializer()
     {
         (
-            address registryAddress,, 
-            //address managerAddress
+            address registryAddress,
             address authority
-        ) = abi.decode(data, (address, address, address));
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, address(0), owner);
+        _initializeService(registryAddress, authority, owner);
 
         _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
         _pricingService = IPricingService(_getServiceAddress(PRICE()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
 
-        registerInterface(type(IApplicationService).interfaceId);
+        _registerInterface(type(IApplicationService).interfaceId);
     }
 
 
@@ -135,6 +134,7 @@ contract ApplicationService is
     )
         external
         virtual
+        nonReentrant()
         returns (NftId applicationNftId)
     {
         (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
@@ -209,7 +209,8 @@ contract ApplicationService is
         NftId bundleNftId // will likely need a newer bundle for underwriting
     )
         external
-        virtual override
+        virtual
+        nonReentrant()
         returns (NftId applicationNftId)
     {
         // TODO implement
@@ -226,14 +227,16 @@ contract ApplicationService is
         bytes memory applicationData
     )
         external
-        virtual override
+        virtual
+        nonReentrant()
     {
         // TODO implement
     }
 
     function revoke(NftId applicationNftId)
         external
-        virtual override
+        virtual
+        nonReentrant()
     {
         (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
         instance.getInstanceStore().updateApplicationState(applicationNftId, REVOKED());

package/contracts/product/ApplicationServiceManager.sol

@@ -12,14 +12,14 @@ contract ApplicationServiceManager is ProxyManager {
     /// @dev initializes proxy manager with service implementation 
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
         ApplicationService svc = new ApplicationService{salt: salt}();
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
             data,
             salt);