@etherisc/gif-next 0.0.2-eb7c077-523 → 0.0.2-eba4d8b-925

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(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(poolSrv), 
             data,
             salt);

package/contracts/product/ApplicationService.sol

@@ -13,7 +13,7 @@ import {IRegistryService} from "../registry/IRegistryService.sol";
 import {AmountLib} from "../type/Amount.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {zeroTimestamp} from "../type/Timestamp.sol";
-import {ObjectType, DISTRIBUTION, PRODUCT, REGISTRY, APPLICATION, POLICY, PRICE} from "../type/ObjectType.sol";
+import {ObjectType, BUNDLE, DISTRIBUTION, PRODUCT, REGISTRY, APPLICATION, POLICY, PRICE} from "../type/ObjectType.sol";
 import {REVOKED} from "../type/StateId.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {ReferralId} from "../type/Referral.sol";
@@ -41,25 +41,24 @@ contract ApplicationService is
         initializer()
     {
         (
-            address registryAddress,, 
-            //address managerAddress
-            address authority
-        ) = abi.decode(data, (address, address, address));
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, address(0), owner);
+        __Service_init(authority, registry, owner);
 
         _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
         _pricingService = IPricingService(_getServiceAddress(PRICE()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
 
-        registerInterface(type(IApplicationService).interfaceId);
+        _registerInterface(type(IApplicationService).interfaceId);
     }
 
 
-    function _checkLinkedpplicationParameters(
+    function _checkLinkedApplicationParameters(
         InstanceReader instanceReader,
         NftId productNftId,
-        RiskId rirskId,
+        RiskId riskId,
         ReferralId referralId,
         NftId bundleNftId
     )
@@ -67,18 +66,18 @@ contract ApplicationService is
         virtual
         view
     {
-        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+        // check risk with product
+        (bool exists, bool active) = instanceReader.getRiskSet().checkRisk(productNftId, riskId);
+        if (!exists) { revert ErrorApplicationServiceRiskUnknown(riskId, productNftId); }
+        if (!active) { revert ErrorApplicationServiceRiskPaused(riskId, productNftId); }
 
-        // TODO check riskId with product
+        // check bundle with pool
+        NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+        (exists, active) = instanceReader.getBundleSet().checkBundle(poolNftId, bundleNftId);
+        if (!exists) { revert ErrorApplicationServiceBundleUnknown(bundleNftId, poolNftId); }
+        if (!active) { revert ErrorApplicationServiceBundleLocked(bundleNftId, poolNftId); }
 
         // TODO check referral with distribution
-
-        // check bundle with pool
-        NftId productPoolNftId = productInfo.poolNftId;
-        NftId bundlePoolNftId = instanceReader.getBundleInfo(bundleNftId).poolNftId;
-        if(bundlePoolNftId != productPoolNftId) {
-            revert ErrorApplicationServiceBundlePoolMismatch(bundleNftId, productPoolNftId, bundlePoolNftId);
-        }
     }
 
 
@@ -111,8 +110,7 @@ contract ApplicationService is
         view
         returns (Amount premiumAmount)
     {
-        return AmountLib.toAmount(
-            _pricingService.calculatePremium(
+        return _pricingService.calculatePremium(
                 info.productNftId,
                 info.riskId,
                 info.sumInsuredAmount,
@@ -120,7 +118,7 @@ contract ApplicationService is
                 info.applicationData,
                 info.bundleNftId,
                 info.referralId
-            ).premiumAmount);
+            ).premiumAmount;
     }
 
 
@@ -128,6 +126,7 @@ contract ApplicationService is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -135,13 +134,16 @@ contract ApplicationService is
     )
         external
         virtual
+        nonReentrant()
         returns (NftId applicationNftId)
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
 
         // check if provided references are valid and linked to calling product contract
         InstanceReader instanceReader = instance.getInstanceReader();
-        _checkLinkedpplicationParameters(
+        _checkLinkedApplicationParameters(
             instanceReader,
             productNftId,
             riskId,
@@ -152,14 +154,45 @@ contract ApplicationService is
         applicationNftId = _registerApplication(productNftId, applicationOwner);
 
         // create policy info for application
-        IPolicy.PolicyInfo memory applicationInfo = IPolicy.PolicyInfo({
+        IPolicy.PolicyInfo memory applicationInfo = _createApplicationInfo(
+            productNftId,
+            riskId,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId,
+            referralId,
+            applicationData);
+
+        // register application with instance
+        instance.getInstanceStore().createApplication(
+            applicationNftId, 
+            applicationInfo);
+
+        // TODO: add logging
+    }
+
+    function _createApplicationInfo(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    )
+        internal
+        virtual
+        returns (IPolicy.PolicyInfo memory applicationInfo)
+    {
+        return IPolicy.PolicyInfo({
             productNftId:       productNftId,
             bundleNftId:        bundleNftId,
             referralId:         referralId,
             riskId:             riskId,
             sumInsuredAmount:   sumInsuredAmount,
-            premiumAmount:      AmountLib.zero(),
-            premiumPaidAmount:  AmountLib.zero(),
+            premiumAmount:      premiumAmount,
             lifetime:           lifetime,
             applicationData:    applicationData,
             processData:        "",
@@ -171,30 +204,20 @@ contract ApplicationService is
             expiredAt:          zeroTimestamp(),
             closedAt:           zeroTimestamp()
         });
-
-        // TODO consider to provide this amount externally
-        // actual calculation is done 2nd time anyway for premium collection
-        // calculate premium amount
-        applicationInfo.premiumAmount = _calculatePremiumAmount(applicationInfo);
-
-        // register application with instance
-        instance.getInstanceStore().createApplication(
-            applicationNftId, 
-            applicationInfo);
-
-        // TODO: add logging
     }
 
-
     function renew(
         NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
         NftId bundleNftId // will likely need a newer bundle for underwriting
     )
         external
-        virtual override
+        virtual
+        nonReentrant()
         returns (NftId applicationNftId)
     {
-
+        _checkNftType(policyNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+        // TODO implement
     }
 
 
@@ -208,15 +231,21 @@ contract ApplicationService is
         bytes memory applicationData
     )
         external
-        virtual override
+        virtual
+        nonReentrant()
     {
-
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+        // TODO implement
     }
 
     function revoke(NftId applicationNftId)
         external
-        virtual override
+        virtual
+        nonReentrant()
     {
+        _checkNftType(applicationNftId, POLICY());
+
         (,, 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(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
             data,
             salt);

package/contracts/product/BasicProduct.sol

@@ -1,43 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ClaimId} from "../type/ClaimId.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {IRisk} from "../instance/module/IRisk.sol";
-import {IApplicationService} from "./IApplicationService.sol";
+import {Fee} from "../type/Fee.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
-import {IComponentService} from "../shared/IComponentService.sol";
-import {IPolicyService} from "./IPolicyService.sol";
-import {IProductService} from "./IProductService.sol";
-import {IClaimService} from "./IClaimService.sol";
-import {IPricingService} from "./IPricingService.sol";
-import {IProductComponent} from "./IProductComponent.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {Product} from "../product/Product.sol";
-import {PayoutId} from "../type/PayoutId.sol";
-import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
-import {ReferralId} from "../type/Referral.sol";
-import {RiskId, RiskIdLib} from "../type/RiskId.sol";
-import {Seconds} from "../type/Seconds.sol";
-import {StateId} from "../type/StateId.sol";
-import {Timestamp} from "../type/Timestamp.sol";
-
-import {TokenHandler} from "../shared/TokenHandler.sol";
-
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IPolicy} from "../instance/module/IPolicy.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {Pool} from "../pool/Pool.sol";
-import {Distribution} from "../distribution/Distribution.sol";
+import {NftId} from "../type/NftId.sol";
+import {Product} from "../product/Product.sol";
 
 abstract contract BasicProduct is
     Product
 {
- 
+
     function setFees(
         Fee memory productFee,
         Fee memory processingFee
@@ -50,17 +23,15 @@ abstract contract BasicProduct is
         _setFees(productFee, processingFee);
     }
 
-
     function _initializeBasicProduct(
         address registry,
         NftId instanceNftId,
-        IAuthorization authorization,
-        address initialOwner,
         string memory name,
         address token,
-        bool isInterceptor,
-        address pool,
-        address distribution
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
+        IAuthorization authorization,
+        address initialOwner
     )
         internal
         virtual
@@ -69,14 +40,12 @@ abstract contract BasicProduct is
         _initializeProduct(
             registry, 
             instanceNftId, 
-            authorization, 
-            initialOwner, 
             name, 
             token, 
-            isInterceptor, 
-            pool,
-            distribution,
-            "", //registryData, 
-            ""); // componentData
+            productInfo,
+            feeInfo,
+            authorization, 
+            initialOwner, 
+            ""); // component data
     }
 }

package/contracts/product/BasicProductAuthorization.sol

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+
 import {Authorization} from "../authorization/Authorization.sol";
 import {BasicProduct} from "./BasicProduct.sol"; 
-import {PRODUCT} from "../type/ObjectType.sol";
-import {IAccess} from "../authorization/IAccess.sol";
-import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
-import {RoleId} from "../type/RoleId.sol";
+import {COMPONENT, PRODUCT, POLICY} from "../type/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 
 
 contract BasicProductAuthorization
@@ -14,17 +16,30 @@ contract BasicProductAuthorization
 {
 
      constructor(string memory componentName)
-          Authorization(componentName)
+          Authorization(componentName, PRODUCT())
      {}
 
-     function _setupTargets()
+     function _setupServiceTargets()
           internal
           virtual override
      {
-          // basic component target
-          _addComponentTargetWithRole(PRODUCT()); 
+          _addServiceTargetWithRole(COMPONENT());
+          _addServiceTargetWithRole(POLICY());
      }
 
+     function _setupTokenHandlerAuthorizations() internal virtual override {
+          // authorize token handler functions for component service role
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForTarget(getTokenHandlerName(), getServiceRole(COMPONENT()));
+          _authorize(functions, TokenHandler.approve.selector, "approve");
+          _authorize(functions, TokenHandler.setWallet.selector, "setWallet");
+          _authorize(functions, TokenHandler.pushFeeToken.selector, "pushFeeToken");
+
+          // authorize token handler functions for pool service role
+          functions = _authorizeForTarget(getTokenHandlerName(), getServiceRole(POLICY()));
+          _authorize(functions, TokenHandler.pullToken.selector, "pullToken");
+          _authorize(functions, TokenHandler.pushToken.selector, "pushToken");
+     }
 
      function _setupTargetAuthorizations()
           internal
@@ -33,8 +48,9 @@ contract BasicProductAuthorization
           IAccess.FunctionInfo[] storage functions;
 
           // authorize public role (open access to any account, only allows to lock target)
-          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
           _authorize(functions, BasicProduct.setFees.selector, "setFees");
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
      }
 }