@etherisc/gif-next 0.0.2-f034782-101 → 0.0.2-f080b71-868

package/contracts/instance/base/ComponentService.sol

@@ -16,30 +16,31 @@ import {InstanceAccessManager} from "../InstanceAccessManager.sol";
 
 abstract contract ComponentService is Service {
 
-    error ErrorComponentServiceAlreadyRegistered(address component, NftId nftId);
     error ErrorComponentServiceNotComponent(address component);
     error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
     error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
     error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
     error ErrorComponentServiceComponentLocked(address component);
+    error ErrorComponentServiceSenderNotService(address sender);
+    error ErrorComponentServiceComponentTypeInvalid(address component, ObjectType expectedType, ObjectType foundType);
 
     /// @dev modifier to check if caller is a registered service
     modifier onlyService() {
         address caller = msg.sender;
-        require(getRegistry().isRegisteredService(caller), "ERROR_NOT_SERVICE");
+        if(!getRegistry().isRegisteredService(caller)) {
+            revert ErrorComponentServiceSenderNotService(caller);
+        }
         _;
     }
 
     // view functions
 
     function getRegistryService() public view virtual returns (IRegistryService) {
-        address service = getRegistry().getServiceAddress(REGISTRY(), getMajorVersion());
-        return IRegistryService(service);
+        return IRegistryService(_getServiceAddress(REGISTRY()));
     }
 
     function getInstanceService() public view returns (InstanceService) {
-        address service = getRegistry().getServiceAddress(INSTANCE(), getMajorVersion());
-        return InstanceService(service);
+        return InstanceService(_getServiceAddress(INSTANCE()));
     }
 
     // internal functions
@@ -60,12 +61,6 @@ abstract contract ComponentService is Service {
         // component may only be registerd by initial owner of component
         owner = msg.sender;
 
-        // check component has not already been registerd
-        NftId compoentNftId = getRegistry().getNftId(componentAddress);
-        if(compoentNftId.gtz()) {
-            revert ErrorComponentServiceAlreadyRegistered(componentAddress, compoentNftId);
-        }
-
         // check this is a component
         component = IComponent(componentAddress);
         if(!component.supportsInterface(type(IComponent).interfaceId)) {
@@ -87,48 +82,66 @@ abstract contract ComponentService is Service {
         // check instance has assigned required role to owner
         instanceNftId = componentInfo.parentNftId;
         instance = _getInstance(instanceNftId);
-        InstanceAccessManager accessManager = instance.getInstanceAccessManager();
-        bool hasRole = accessManager.hasRole(
-            requiredRole,
-            owner);
-
-        if(!hasRole) {
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
             revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
         }
     }
 
     // internal view functions
+    function _getAndVerifyCallingComponentAndInstance(
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentNftId = getRegistry().getNftId(msg.sender);
+        (componentInfo, instance) = _getAndVerifyComponentInfoAndInstance(componentNftId, expectedType);
 
-    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
-        IRegistry.ObjectInfo memory instanceInfo = getRegistry().getObjectInfo(instanceNftId);
-        return IInstance(instanceInfo.objectAddress);
+        if (instance.getInstanceAccessManager().isTargetLocked(componentInfo.objectAddress)) {
+            revert IAccess.ErrorIAccessTargetLocked(componentInfo.objectAddress);
+        }
     }
 
     function _getAndVerifyComponentInfoAndInstance(
-        //address component,
-        ObjectType expectedType
+        NftId componentNftId,
+        ObjectType expectedType // assume always of `component` type
     )
         internal
         view
         returns(
-            IRegistry.ObjectInfo memory info, 
+            IRegistry.ObjectInfo memory componentInfo, 
             IInstance instance
         )
     {
-        IRegistry registry = getRegistry();
-        //TODO redundant check -> just check type
-        //NftId componentNftId = registry.getNftId(component); 
-        //require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
-
-        info = registry.getObjectInfo(msg.sender);
-        require(info.objectType == expectedType, "OBJECT_TYPE_INVALID");
-
-        address instanceAddress = registry.getObjectInfo(info.parentNftId).objectAddress;
-        instance = IInstance(instanceAddress);
-
-        InstanceAccessManager accessManager = instance.getInstanceAccessManager();
-        if (accessManager.isTargetLocked(info.objectAddress)) {
-            revert IAccess.ErrorIAccessTargetLocked(info.objectAddress);
+        componentInfo = getRegistry().getObjectInfo(componentNftId);
+        if(componentInfo.objectType != expectedType) {
+            revert ErrorComponentServiceComponentTypeInvalid(
+                componentInfo.objectAddress, 
+                expectedType, 
+                componentInfo.objectType);
         }
+
+        instance = _getInstance(componentInfo.parentNftId);
+    }
+    // assume componentNftId is always of `instance` type
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+    // assume componentNftId is always of `component` type
+    /*function _getInstanceForComponent(NftId componentNftId) internal view returns (IInstance) {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }*/
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
     }
 }

package/contracts/instance/base/KeyValueStore.sol

@@ -5,7 +5,7 @@ import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blockn
 import {Key32, KeyId, Key32Lib} from "../../types/Key32.sol";
 import {NftId} from "../../types/NftId.sol";
 import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE} from "../../types/StateId.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
 import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
 
 import {Lifecycle} from "./Lifecycle.sol";
@@ -79,10 +79,15 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         // update data
         _value[key32].data = data;
 
-        // update metadata (and state)
+        // update state 
+        if(state != KEEP_STATE()) {
+            metadata.state = state;
+        }
+
+        // update reest of metadata
         address updatedBy = msg.sender;
         Blocknumber lastUpdatedIn = metadata.updatedIn;
-        metadata.state = state;
+
         metadata.updatedBy = updatedBy;
         metadata.updatedIn = blockBlocknumber();
 

package/contracts/instance/module/IAccess.sol

@@ -43,9 +43,9 @@ interface IAccess {
     error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
 
     error ErrorIAccessTargetAddressZero();
-    error ErrorIAccessTargetDoesNotExist(ShortString name);
+    error ErrorIAccessTargetDoesNotExist(address target);
     error ErrorIAccessTargetExists(address target, ShortString name);
-    error ErrorIAccessTargetTypeInvalid(ShortString name, Type ttype);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
     error ErrorIAccessTargetNameEmpty(address target);
     error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
     error ErrorIAccessTargetLocked(address target);

package/contracts/instance/module/IBundle.sol

@@ -1,21 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {Amount} from "../../types/Amount.sol";
 import {NftId} from "../../types/NftId.sol";
 import {Fee} from "../../types/Fee.sol";
 import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IBundle {
+
     struct BundleInfo {
         NftId poolNftId;
         Fee fee; // bundle fee on net premium amounts
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
-        uint256 capitalAmount; // net investment capital + net premiums - payouts
-        uint256 lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= balance)
-        uint256 balanceAmount; // total amount of funds: capitalAmount + fees (balance >= captial)
+        Amount capitalAmount; // net stakings + net premiums - payouts
+        Amount lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= capital amount)
+        Amount feeAmount; // accumulated fee amount
         Seconds lifetime;
-        Timestamp expiredAt; // no new policies
+        Timestamp expiredAt; // no new policies starting with this timestamp
         Timestamp closedAt; // no open policies, locked amount = 0
     }
 }

package/contracts/instance/module/IComponents.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
+import {Amount} from "../../types/Amount.sol";
 import {Fee} from "../../types/Fee.sol";
 import {NftId} from "../../types/NftId.sol";
 import {RoleId} from "../../types/RoleId.sol";
@@ -16,13 +17,18 @@ interface IComponents {
         IERC20Metadata token;
         TokenHandler tokenHandler;
         address wallet;
+        Amount balanceAmount; // calculated balance (may not necessarily match withg wallet balance)
+        Amount feeAmount; // accumulated fees belonging to component owner
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
     struct PoolInfo {
         NftId productNftId; // the nft of the product this pool is linked to
         RoleId bundleOwnerRole; // the required role for bundle owners
+        // TODO maxCapitalAmount -> maxBalanceAmount
         uint256 maxCapitalAmount; // max capital amount allowed for pool
+        uint256 balanceAmount; // current pool balance (accounting view)
+        uint256 feeAmount; // accumulated fee amount
         bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
         bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
         bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 

package/contracts/instance/service/ApplicationService.sol

@@ -27,7 +27,7 @@ import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
 import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
-import {ObjectType, DISTRIBUTION, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, BUNDLE} from "../../types/ObjectType.sol";
+import {ObjectType, DISTRIBUTION, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, BUNDLE, PRICE} from "../../types/ObjectType.sol";
 import {APPLIED, REVOKED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
@@ -44,6 +44,7 @@ import {IDistributionService} from "./IDistributionService.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IService} from "../../shared/IService.sol";
 import {Service} from "../../shared/Service.sol";
+import {IPricingService} from "./IPricingService.sol";
 
 
 contract ApplicationService is 
@@ -51,6 +52,7 @@ contract ApplicationService is
     IApplicationService
 {
     IDistributionService internal _distributionService;
+    IPricingService internal _pricingService;
 
     function _initialize(
         address owner, 
@@ -65,14 +67,15 @@ contract ApplicationService is
         address initialOwner;
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, owner);
+        initializeService(registryAddress, address(0), owner);
         registerInterface(type(IApplicationService).interfaceId);
 
-        _distributionService = IDistributionService(getRegistry().getServiceAddress(DISTRIBUTION(), getMajorVersion()));
+        _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
+        _pricingService = IPricingService(_getServiceAddress(PRICE()));
     }
 
 
-    function getDomain() public pure override(IService, Service) returns(ObjectType) {
+    function getDomain() public pure override returns(ObjectType) {
         return APPLICATION();
     }
 
@@ -90,13 +93,13 @@ contract ApplicationService is
         virtual
         returns (NftId applicationNftId)
     {
-        (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        (NftId productNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(PRODUCT());
         // TODO: add validations (see create bundle in pool service)
 
         applicationNftId = getRegistryService().registerPolicy(
             IRegistry.ObjectInfo(
                 zeroNftId(),
-                productInfo.nftId,
+                productNftId,
                 POLICY(),
                 false, // intercepting property for policies is defined on product
                 address(0),
@@ -106,36 +109,36 @@ contract ApplicationService is
         );
 
         // (uint256 premiumAmount,,,,,) = calculatePremium(
-        IPolicy.Premium memory premium = calculatePremium(
-            productInfo.nftId,
-            riskId,
-            sumInsuredAmount,
-            lifetime,
-            applicationData,
+        IPolicy.Premium memory premium = _pricingService.calculatePremium(
+            productNftId,
             bundleNftId,
-            referralId
-        );
-
-        IPolicy.PolicyInfo memory policyInfo = IPolicy.PolicyInfo(
-            productInfo.nftId,
-            bundleNftId,
-            referralId,
             riskId,
+            referralId,
             sumInsuredAmount,
-            premium.premiumAmount,
-            0,
             lifetime,
-            applicationData,
-            "",
-            0,
-            0,
-            0,
-            zeroTimestamp(),
-            zeroTimestamp(),
-            zeroTimestamp()
+            applicationData
         );
+
+        IPolicy.PolicyInfo memory policyInfo = IPolicy.PolicyInfo({
+            productNftId:       productNftId,
+            bundleNftId:        bundleNftId,
+            referralId:         referralId,
+            riskId:             riskId,
+            sumInsuredAmount:   sumInsuredAmount,
+            premiumAmount:      premium.premiumAmount,
+            premiumPaidAmount:  0,
+            lifetime:           lifetime,
+            applicationData:    applicationData,
+            policyData:         "",
+            claimsCount:        0,
+            openClaimsCount:    0,
+            payoutAmount:       0,
+            activatedAt:        zeroTimestamp(),
+            expiredAt:          zeroTimestamp(),
+            closedAt:           zeroTimestamp()
+        });
         
-        instance.createApplication(applicationNftId, policyInfo);
+        instance.getInstanceStore().createApplication(applicationNftId, policyInfo);
 
         // TODO: add logging
     }
@@ -172,179 +175,9 @@ contract ApplicationService is
         external
         virtual override
     {
-        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
-        instance.updateApplicationState(applicationNftId, REVOKED());
+        (,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(PRODUCT());
+        instance.getInstanceStore().updateApplicationState(applicationNftId, REVOKED());
     }
 
-    // TODO: maybe move this to a pricing service later
-    function calculatePremium(
-        NftId productNftId,
-        RiskId riskId,
-        uint256 sumInsuredAmount,
-        Seconds lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        public
-        view
-        virtual override
-        returns (
-            IPolicy.Premium memory premium
-        )
-    {
-        uint256 netPremiumAmount = _getAndVerifyProduct(productNftId).calculateNetPremium(
-            sumInsuredAmount,
-            riskId,
-            lifetime,
-            applicationData
-        );
-
-        premium = _getFixedFeeAmounts(
-            netPremiumAmount,
-            _getAndVerifyProduct(productNftId),
-            bundleNftId,
-            referralId
-        );
-
-        (
-            premium
-        ) = _calculateVariableFeeAmounts(
-            premium,
-            _getAndVerifyProduct(productNftId),
-            bundleNftId,
-            referralId
-        );
-    }
-
-
     // internal functions
-    function _getFixedFeeAmounts(
-        uint256 netPremiumAmount,
-        Product product,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        internal
-        view
-        returns (
-            IPolicy.Premium memory premium
-        )
-    {
-        InstanceReader instanceReader;
-        {
-            IInstance instance = product.getInstance();
-            instanceReader = instance.getInstanceReader();
-        }
-        
-        NftId poolNftId = product.getPoolNftId();
-        premium = IPolicy.Premium(
-            netPremiumAmount, // net premium
-            netPremiumAmount, // full premium
-            0, // premium
-            0, 0, 0, 0, // fix fees
-            0, 0, 0, 0, // variable fees
-            0, 0, 0, 0); // distribution owner fee/commission/discount
-
-        {
-            {
-                ISetup.ProductSetupInfo memory productSetupInfo = instanceReader.getProductSetupInfo(product.getProductNftId());
-                uint256 t = productSetupInfo.productFee.fixedFee;
-                premium.productFeeFixAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                bytes memory componentData = instanceReader.getComponentInfo(poolNftId).data;
-                uint256 t = abi.decode(componentData, (IComponents.PoolInfo)).poolFee.fixedFee;
-                premium.poolFeeFixAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-                if(bundleInfo.poolNftId != poolNftId) {
-                    revert IApplicationServiceBundlePoolMismatch(bundleNftId, bundleInfo.poolNftId, poolNftId);
-                }
-                uint256 t = bundleInfo.fee.fixedFee;
-                premium.bundleFeeFixAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                ISetup.DistributionSetupInfo memory distInto = instanceReader.getDistributionSetupInfo(product.getDistributionNftId());
-                uint256 t = distInto.distributionFee.fixedFee;
-                premium.distributionFeeFixAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-        }
-        
-    }
-
-    function _calculateVariableFeeAmounts(
-        IPolicy.Premium memory premium,
-        Product product,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        internal
-        view
-        returns (
-            IPolicy.Premium memory finalPremium
-        )
-    {
-        InstanceReader instanceReader;
-        {
-            IInstance instance = product.getInstance();
-            instanceReader = instance.getInstanceReader();
-        }
-        
-        NftId poolNftId = product.getPoolNftId();
-        uint256 netPremiumAmount = premium.netPremiumAmount;
-
-        {
-            {
-                ISetup.ProductSetupInfo memory productSetupInfo = instanceReader.getProductSetupInfo(product.getProductNftId());
-                uint256 t = (UFixedLib.toUFixed(netPremiumAmount) * productSetupInfo.productFee.fractionalFee).toInt();
-                premium.productFeeVarAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                bytes memory componentData = instanceReader.getComponentInfo(poolNftId).data;
-                UFixed poolFractionalFee = abi.decode(componentData, (IComponents.PoolInfo)).poolFee.fractionalFee;
-                uint256 t = (UFixedLib.toUFixed(netPremiumAmount) * poolFractionalFee).toInt();
-                premium.poolFeeVarAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-                if(bundleInfo.poolNftId != poolNftId) {
-                    revert IApplicationServiceBundlePoolMismatch(bundleNftId, bundleInfo.poolNftId, poolNftId);
-                }
-                uint256 t = (UFixedLib.toUFixed(netPremiumAmount) * bundleInfo.fee.fractionalFee).toInt();
-                premium.bundleFeeVarAmount = t;
-                premium.fullPremiumAmount += t;
-            }
-            {
-                premium = _distributionService.calculateFeeAmount(
-                    product.getDistributionNftId(),
-                    referralId,
-                    premium
-                );
-            }
-        }
-
-        return premium;
-    }
-
-
-    function _getAndVerifyInstanceAndProduct() internal view returns (Product product) {
-        IRegistry.ObjectInfo memory productInfo;
-        (productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
-        product = Product(productInfo.objectAddress);
-    }
-
-    function _getAndVerifyProduct(NftId productNftId) internal view returns (Product product) {
-        IRegistry registry = getRegistry();        
-        IRegistry.ObjectInfo memory productInfo = registry.getObjectInfo(productNftId);
-        require(productInfo.objectType == PRODUCT(), "OBJECT_TYPE_INVALID");
-        product = Product(productInfo.objectAddress);
-    }
 }