@etherisc/gif-next 0.0.2-e545d2c-624 → 0.0.2-e586bbf-616

package/contracts/product/ApplicationService.sol

@@ -0,0 +1,327 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {ContractLib} from "../shared/ContractLib.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {zeroTimestamp} from "../type/Timestamp.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";
+import {RiskId} from "../type/RiskId.sol";
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Service} from "../shared/Service.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+
+
+contract ApplicationService is 
+    Service, 
+    IApplicationService
+{
+    IDistributionService private _distributionService;
+    IPricingService private _pricingService;
+    IRegistryService private _registryService;
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer()
+    {
+        (
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
+
+        __Service_init(authority, registry, owner);
+
+        _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
+        _pricingService = IPricingService(_getServiceAddress(PRICE()));
+        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+
+        _registerInterface(type(IApplicationService).interfaceId);
+    }
+
+
+    function _checkLinkedApplicationParameters(
+        InstanceReader instanceReader,
+        NftId productNftId,
+        RiskId riskId,
+        ReferralId referralId,
+        NftId bundleNftId
+    )
+        internal
+        virtual
+        view
+    {
+        // 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); }
+
+        NftId riskProductNftId = instanceReader.getRiskInfo(riskId).productNftId;
+        if (productNftId != riskProductNftId) {
+            revert ErrorApplicationServiceRiskProductMismatch(riskId, riskProductNftId, productNftId);
+        }
+
+        // check bundle with pool
+        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+        {
+            NftId poolNftId = productInfo.poolNftId;
+            (exists, active) = instanceReader.getBundleSet().checkBundle(poolNftId, bundleNftId);
+            if (!exists) { revert ErrorApplicationServiceBundleUnknown(bundleNftId, poolNftId); }
+            if (!active) { revert ErrorApplicationServiceBundleLocked(bundleNftId, poolNftId); }
+        }
+
+        // check referral with distribution
+        {
+            if (productInfo.hasDistribution && ! referralId.eqz()) {
+                if (!_distributionService.referralIsValid(productInfo.distributionNftId, referralId)) {
+                    revert ErrorApplicationServiceReferralInvalid(productNftId, productInfo.distributionNftId, referralId);
+                }
+            }
+        }
+    }
+
+
+    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;
+    }
+
+
+    function create(
+        address applicationOwner,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    )
+        external
+        virtual
+        restricted()
+        nonReentrant()
+        returns (NftId applicationNftId)
+    {
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveProduct();
+
+        // check if provided references are valid and linked to calling product contract
+        InstanceReader instanceReader = instance.getInstanceReader();
+        _checkLinkedApplicationParameters(
+            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,
+            bundleNftId,
+            referralId,
+            applicationData);
+
+        // register application with instance
+        instance.getInstanceStore().createApplication(
+            applicationNftId, 
+            applicationInfo);
+
+        _emitApplicationCreatedEvent(applicationNftId, applicationOwner, applicationInfo);
+    }
+
+    function _emitApplicationCreatedEvent(
+        NftId applicationNftId,
+        address applicationOwner,
+        IPolicy.PolicyInfo memory applicationInfo
+    )
+        internal
+        virtual
+    {
+        emit LogApplicationServiceApplicationCreated(
+            applicationNftId,
+            applicationInfo.productNftId,
+            applicationInfo.bundleNftId, 
+            applicationInfo.riskId,
+            applicationInfo.referralId,
+            applicationOwner,
+            applicationInfo.sumInsuredAmount,
+            applicationInfo.premiumAmount,
+            applicationInfo.lifetime
+        );
+    }
+
+    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:      premiumAmount,
+            lifetime:           lifetime,
+            applicationData:    applicationData,
+            processData:        "",
+            claimsCount:        0,
+            openClaimsCount:    0,
+            claimAmount:        AmountLib.zero(),
+            payoutAmount:       AmountLib.zero(),
+            activatedAt:        zeroTimestamp(),
+            expiredAt:          zeroTimestamp(),
+            closedAt:           zeroTimestamp()
+        });
+    }
+
+    function renew(
+        NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
+        NftId bundleNftId // will likely need a newer bundle for underwriting
+    )
+        external
+        virtual
+        restricted()
+        nonReentrant()
+        returns (NftId applicationNftId)
+    {
+        _checkNftType(policyNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+        
+        // TODO: implement
+
+        emit LogApplicationServiceApplicationRenewed(policyNftId, bundleNftId);
+    }
+
+
+    function adjust(
+        NftId applicationNftId,
+        RiskId riskId,
+        NftId bundleNftId,
+        ReferralId referralId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData
+    )
+        external
+        virtual
+        restricted()
+        nonReentrant()
+    {
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        // TODO: implement
+        
+        emit LogApplicationServiceApplicationAdjusted(applicationNftId, bundleNftId, riskId, referralId, sumInsuredAmount, lifetime);
+    }
+
+    function revoke(NftId applicationNftId)
+        external
+        virtual
+        restricted()
+        nonReentrant()
+    {
+        _checkNftType(applicationNftId, POLICY());
+
+        (, IInstance instance) = _getAndVerifyActiveProduct();
+        instance.getInstanceStore().updateApplicationState(applicationNftId, REVOKED());
+        emit LogApplicationServiceApplicationRevoked(applicationNftId);
+    }
+
+    // internal functions
+
+    function _getAndVerifyActiveProduct()
+        internal
+        view
+        returns (
+            NftId productNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            getRegistry(), 
+            msg.sender,
+            PRODUCT(),
+            true); // only active pools
+
+        productNftId = info.nftId;
+        instance = IInstance(instanceAddress);
+    }
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return APPLICATION();
+    }
+}

package/contracts/product/ApplicationServiceManager.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
+import {ApplicationService} from "./ApplicationService.sol";
+
+contract ApplicationServiceManager is ProxyManager {
+
+    ApplicationService private _applicationService;
+
+    /// @dev initializes proxy manager with service implementation 
+    constructor(
+        address authority, 
+        address registry,
+        bytes32 salt
+    ) 
+    {
+        ApplicationService svc = new ApplicationService{salt: salt}();
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
+            data,
+            salt);
+
+        _applicationService = ApplicationService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getApplicationService()
+        external
+        view
+        returns (ApplicationService)
+    {
+        return _applicationService;
+    }
+}

package/contracts/product/BasicProduct.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Fee} from "../type/Fee.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IComponents} from "../instance/module/IComponents.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,
+        string memory name,
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeProduct(
+            registry, 
+            instanceNftId, 
+            name, 
+            productInfo,
+            feeInfo,
+            authorization, 
+            initialOwner, 
+            ""); // component data
+    }
+}

package/contracts/product/BasicProductAuthorization.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {IProductComponent} from "./IProductComponent.sol";
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicProduct} from "./BasicProduct.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
+     is Authorization
+{
+     constructor(string memory componentName)
+          Authorization(
+               componentName, 
+               PRODUCT(), 
+               3,
+               COMMIT_HASH,
+               true, 
+               true)
+     {}
+
+     function _setupServiceTargets()
+          internal
+          virtual override
+     {
+          _authorizeServiceDomain(COMPONENT(), address(10));
+          _authorizeServiceDomain(POLICY(), address(11));
+     }
+
+     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
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicProduct.setFees.selector, "setFees");
+          _authorize(functions, IProductComponent.registerComponent.selector, "registerComponent");
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
+     }
+}
+