@etherisc/gif-next 0.0.2-d5fac82-078 → 0.0.2-d62f29e-108

package/contracts/pool/PoolServiceManager.sol

@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {PoolService} from "./PoolService.sol";
-import {Registry} from "../registry/Registry.sol";
-import {RegistryService} from "../registry/RegistryService.sol";
-import {REGISTRY} from "../type/ObjectType.sol";
 
 contract PoolServiceManager is ProxyManager {
 

package/contracts/product/ApplicationService.sol

@@ -1,60 +1,36 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {IApplicationService} from "./IApplicationService.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IDistributionService} from "../distribution/IDistributionService.sol";
+import {IPricingService} from "./IPricingService.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
 
 import {AmountLib} from "../type/Amount.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
-import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
-import {ObjectType, DISTRIBUTION, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, BUNDLE, PRICE} from "../type/ObjectType.sol";
-import {APPLIED, REVOKED, ACTIVE, KEEP_STATE} from "../type/StateId.sol";
-import {NftId, NftIdLib, zeroNftId} from "../type/NftId.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {zeroTimestamp} from "../type/Timestamp.sol";
+import {ObjectType, 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";
 import {RiskId} from "../type/RiskId.sol";
-import {StateId} from "../type/StateId.sol";
-import {Version, VersionLib} from "../type/Version.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
-
-import {TokenHandler} from "../shared/TokenHandler.sol";
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-import {IService} from "../shared/IService.sol";
-import {Service} from "../shared/Service.sol";
-
-import {IRegistry} from "../registry/IRegistry.sol";
-
-import {IProductComponent} from "./IProductComponent.sol";
-import {IPoolComponent} from "../pool/IPoolComponent.sol";
-import {IDistributionComponent} from "../distribution/IDistributionComponent.sol";
-import {Product} from "./Product.sol";
-
-import {IComponents} from "../instance/module/IComponents.sol";
-import {IPolicy} from "../instance/module/IPolicy.sol";
-import {IRisk} from "../instance/module/IRisk.sol";
-import {IBundle} from "../instance/module/IBundle.sol";
-import {IProductService} from "./IProductService.sol";
-import {ITreasury} from "../instance/module/ITreasury.sol";
-import {ISetup} from "../instance/module/ISetup.sol";
-
-import {ComponentService} from "../shared/ComponentService.sol";
-
-import {IInstance} from "../instance/IInstance.sol";
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 
-import {IApplicationService} from "./IApplicationService.sol";
-import {IBundleService} from "../pool/IBundleService.sol";
-import {IDistributionService} from "../distribution/IDistributionService.sol";
-import {IPoolService} from "../pool/IPoolService.sol";
-import {IPricingService} from "./IPricingService.sol";
 
 
 contract ApplicationService is 
-    ComponentService, 
+    ComponentVerifyingService, 
     IApplicationService
 {
-    IDistributionService internal _distributionService;
-    IPricingService internal _pricingService;
+    IDistributionService private _distributionService;
+    IPricingService private _pricingService;
+    IRegistryService private _registryService;
 
     function _initialize(
         address owner, 
@@ -70,16 +46,80 @@ contract ApplicationService is
             address authority
         ) = abi.decode(data, (address, address, address));
 
-        initializeService(registryAddress, authority, owner);
-        registerInterface(type(IApplicationService).interfaceId);
+        initializeService(registryAddress, address(0), owner);
 
         _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
         _pricingService = IPricingService(_getServiceAddress(PRICE()));
+        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+
+        registerInterface(type(IApplicationService).interfaceId);
     }
 
 
-    function getDomain() public pure override returns(ObjectType) {
-        return APPLICATION();
+    function _checkLinkedpplicationParameters(
+        InstanceReader instanceReader,
+        NftId productNftId,
+        RiskId rirskId,
+        ReferralId referralId,
+        NftId bundleNftId
+    )
+        internal
+        virtual
+        view
+    {
+        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+
+        // TODO check riskId with product
+
+        // 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);
+        }
+    }
+
+
+    function _registerApplication(
+        NftId productNftId,
+        address applicationOwner
+    )
+        internal
+        virtual
+        returns (NftId applicationNftId)
+    {
+        IRegistry.ObjectInfo memory objectInfo = IRegistry.ObjectInfo(
+            NftIdLib.zero(),
+            productNftId,
+            POLICY(),
+            false, // intercepting property for policies is defined on product
+            address(0),
+            applicationOwner,
+            "");
+
+        applicationNftId = _registryService.registerPolicy(objectInfo);
+    }
+
+
+    function _calculatePremiumAmount(
+        IPolicy.PolicyInfo memory info
+    )
+        internal
+        virtual
+        view
+        returns (Amount premiumAmount)
+    {
+        return _pricingService.calculatePremium(
+                info.productNftId,
+                info.riskId,
+                info.sumInsuredAmount,
+                info.lifetime,
+                info.applicationData,
+                info.bundleNftId,
+                info.referralId
+            ).premiumAmount;
     }
 
 
@@ -87,6 +127,7 @@ contract ApplicationService is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -96,39 +137,60 @@ contract ApplicationService is
         virtual
         returns (NftId applicationNftId)
     {
-        (NftId productNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(PRODUCT());
-        // TODO: add validations (see create bundle in pool service)
-
-        applicationNftId = getRegistryService().registerPolicy(
-            IRegistry.ObjectInfo(
-                zeroNftId(),
-                productNftId,
-                POLICY(),
-                false, // intercepting property for policies is defined on product
-                address(0),
-                applicationOwner,
-                ""
-            )
-        );
-
-        // (uint256 premiumAmount,,,,,) = calculatePremium(
-        IPolicy.Premium memory premium = _pricingService.calculatePremium(
+        (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+
+        // check if provided references are valid and linked to calling product contract
+        InstanceReader instanceReader = instance.getInstanceReader();
+        _checkLinkedpplicationParameters(
+            instanceReader,
+            productNftId,
+            riskId,
+            referralId,
+            bundleNftId);
+
+        // register application with registry
+        applicationNftId = _registerApplication(productNftId, applicationOwner);
+
+        // create policy info for application
+        IPolicy.PolicyInfo memory applicationInfo = _createApplicationInfo(
             productNftId,
             riskId,
             sumInsuredAmount,
+            premiumAmount,
             lifetime,
-            applicationData,
             bundleNftId,
-            referralId
-        );
+            referralId,
+            applicationData);
+
+        // register application with instance
+        instance.getInstanceStore().createApplication(
+            applicationNftId, 
+            applicationInfo);
+
+        // TODO: add logging
+    }
 
-        IPolicy.PolicyInfo memory policyInfo = IPolicy.PolicyInfo({
+    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.toAmount(premium.premiumAmount),
+            premiumAmount:      premiumAmount,
             premiumPaidAmount:  AmountLib.zero(),
             lifetime:           lifetime,
             applicationData:    applicationData,
@@ -141,13 +203,8 @@ contract ApplicationService is
             expiredAt:          zeroTimestamp(),
             closedAt:           zeroTimestamp()
         });
-        
-        instance.getInstanceStore().createApplication(applicationNftId, policyInfo);
-
-        // 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
@@ -156,7 +213,7 @@ contract ApplicationService is
         virtual override
         returns (NftId applicationNftId)
     {
-
+        // TODO implement
     }
 
 
@@ -172,16 +229,21 @@ contract ApplicationService is
         external
         virtual override
     {
-
+        // TODO implement
     }
 
     function revoke(NftId applicationNftId)
         external
         virtual override
     {
-        (,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(PRODUCT());
+        (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
         instance.getInstanceStore().updateApplicationState(applicationNftId, REVOKED());
     }
 
     // internal functions
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return APPLICATION();
+    }
 }

package/contracts/product/ApplicationServiceManager.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {ApplicationService} from "./ApplicationService.sol";
 
 contract ApplicationServiceManager is ProxyManager {

package/contracts/product/BasicProduct.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Fee} from "../type/Fee.sol";
+import {IAuthorization} from "../authorization/IAuthorization.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
+    )
+        external
+        virtual
+        onlyOwner()
+        restricted()
+    {
+        _setFees(productFee, processingFee);
+    }
+
+    function _initializeBasicProduct(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token,
+        bool isInterceptor,
+        address pool,
+        address distribution
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeProduct(
+            registry, 
+            instanceNftId, 
+            authorization, 
+            initialOwner, 
+            name, 
+            token, 
+            isInterceptor, 
+            pool,
+            distribution,
+            "", //registryData, 
+            ""); // componentData
+    }
+}

package/contracts/product/BasicProductAuthorization.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicProduct} from "./BasicProduct.sol"; 
+import {PRODUCT} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicProductAuthorization
+     is Authorization
+{
+
+     constructor(string memory componentName)
+          Authorization(componentName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          // basic component target
+          _addComponentTargetWithRole(PRODUCT()); 
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicProduct.setFees.selector, "setFees");
+
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
+     }
+}
+