@etherisc/gif-next 0.0.2-9d3eab3-323 → 0.0.2-9dd1984-554

package/contracts/instance/service/PolicyService.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.19;
 import {IRegistry} from "../../registry/IRegistry.sol";
 import {IProductComponent} from "../../components/IProductComponent.sol";
 import {Product} from "../../components/Product.sol";
-import {IBaseComponent} from "../../components/IBaseComponent.sol";
 import {IPoolComponent} from "../../components/IPoolComponent.sol";
 import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
 import {IInstance} from "../IInstance.sol";
@@ -20,11 +19,11 @@ import {TokenHandler} from "../../shared/TokenHandler.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
-import {Timestamp, zeroTimestamp} from "../../types/Timestamp.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, INSTANCE, PRODUCT, POOL, POLICY, BUNDLE} from "../../types/ObjectType.sol";
-import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
+import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
 import {ReferralId} from "../../types/Referral.sol";
@@ -35,15 +34,16 @@ import {Version, VersionLib} from "../../types/Version.sol";
 
 import {IService} from "../../shared/IService.sol";
 import {Service} from "../../shared/Service.sol";
-import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {ComponentService} from "../base/ComponentService.sol";
 import {IPolicyService} from "./IPolicyService.sol";
 import {InstanceReader} from "../InstanceReader.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IBundleService} from "./IBundleService.sol";
 
 
-contract PolicyService is ComponentServiceBase, IPolicyService {
+contract PolicyService is ComponentService, IPolicyService {
     using NftIdLib for NftId;
+    using TimestampLib for Timestamp;
 
     IPoolService internal _poolService;
     IBundleService internal _bundleService;
@@ -81,7 +81,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         (productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
         product = Product(productInfo.objectAddress);
     }
-    // TODO no access restrictions
+    // TODO: no access restrictions
     function calculatePremium(
         RiskId riskId,
         uint256 sumInsuredAmount,
@@ -179,7 +179,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         ReferralId referralId
     ) external override returns (NftId policyNftId) {
         (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
-        // TODO add validations (see create bundle in pool service)
+        // TODO: add validations (see create bundle in pool service)
 
         policyNftId = getRegistryService().registerPolicy(
             IRegistry.ObjectInfo(
@@ -224,7 +224,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         instance.createPolicy(policyNftId, policyInfo);
         instance.updatePolicyState(policyNftId, APPLIED());
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function _getAndVerifyUnderwritingSetup(
@@ -384,7 +384,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
             }
         }
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function calculateRequiredCollateral(UFixed collateralizationLevel, uint256 sumInsuredAmount) public pure override returns(uint256 collateralAmount) {
@@ -397,28 +397,30 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         // check caller is registered product
         (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
         InstanceReader instanceReader = instance.getInstanceReader();
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
 
-        // TODO: check if not paid
-        // TODO: transfer premium 
-        // TODO: optionally activate
+        if (policyInfo.premiumPaidAmount == policyInfo.premiumAmount) {
+            revert ErrorIPolicyServicePremiumAlreadyPaid(policyNftId, policyInfo.premiumPaidAmount);
+        }
 
-        // // perform actual token transfers (this code is probably not complete)
-        // IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
-        
-        // uint256 premiumAmount = policyInfo.premiumAmount;
-        // _processPremiumByTreasury(instance, productInfo.nftId, policyNftId, premiumAmount);
+        uint256 unpaidPremiumAmount = policyInfo.premiumAmount - policyInfo.premiumPaidAmount;
 
-        // // policy level book keeping for premium paid
-        // policyInfo.premiumPaidAmount += premiumAmount;
+        uint256 netPremiumAmount = _processPremiumByTreasury(
+                instance, 
+                productInfo.nftId,
+                policyNftId, 
+                unpaidPremiumAmount);
 
-        // instance.updatePolicy(policyNftId, policyInfo, KEEP_STATE());
+        policyInfo.premiumPaidAmount += unpaidPremiumAmount;
 
-        // // optional activation of policy
-        // if(activateAt > zeroTimestamp()) {
-        //     activate(policyNftId, activateAt);
-        // }
+        _bundleService.increaseBalance(instance, policyInfo.bundleNftId, netPremiumAmount);
+        instance.updatePolicy(policyNftId, policyInfo, KEEP_STATE());
 
-        // TODO add logging
+        if(activateAt.gtz() && policyInfo.activatedAt.eqz()) {
+            activate(policyNftId, activateAt);
+        }
+
+        // TODO: add logging
     }
 
     function activate(NftId policyNftId, Timestamp activateAt) public override {
@@ -437,14 +439,47 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
 
         instance.updatePolicy(policyNftId, policyInfo, ACTIVE());
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function close(
         NftId policyNftId
     ) external override // solhint-disable-next-line no-empty-blocks
     {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        InstanceReader instanceReader = instance.getInstanceReader();
+
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
+
+        if (policyInfo.activatedAt.eqz()) {
+            revert ErrorIPolicyServicePolicyNotActivated(policyNftId);
+        }
+
+        StateId state = instanceReader.getPolicyState(policyNftId);
+        if (state != ACTIVE()) {
+            revert ErrorIPolicyServicePolicyNotActive(policyNftId, state);
+        }
+
+        if (policyInfo.closedAt.gtz()) {
+            revert ErrorIPolicyServicePolicyAlreadyClosed(policyNftId);
+        }
+
+        if (policyInfo.premiumAmount != policyInfo.premiumPaidAmount) {
+            revert ErrorIPolicyServicePremiumNotFullyPaid(policyNftId, policyInfo.premiumAmount, policyInfo.premiumPaidAmount);
+        }
+
+        if (policyInfo.openClaimsCount > 0) {
+            revert ErrorIPolicyServiceOpenClaims(policyNftId, policyInfo.openClaimsCount);
+        }
+
+        if (TimestampLib.blockTimestamp().lte(policyInfo.expiredAt) && (policyInfo.payoutAmount < policyInfo.sumInsuredAmount)) {
+            revert ErrorIPolicyServicePolicyHasNotExpired(policyNftId, policyInfo.expiredAt);
+        }
+
+        policyInfo.closedAt = TimestampLib.blockTimestamp();
 
+        _bundleService.closePolicy(instance, policyNftId, policyInfo.bundleNftId, policyInfo.sumInsuredAmount);
+        instance.updatePolicy(policyNftId, policyInfo, CLOSED());
     }
 
     function _getPoolNftId(
@@ -498,6 +533,6 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
             }
         }
 
-        // TODO add logging
+        // TODO: add logging
     }
 }

package/contracts/instance/service/PoolService.sol

@@ -24,17 +24,17 @@ import {TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {IService} from "../../shared/IService.sol";
 import {Service} from "../../shared/Service.sol";
 import {BundleManager} from "../BundleManager.sol";
-import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {ComponentService} from "../base/ComponentService.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IRegistryService} from "../../registry/IRegistryService.sol";
 import {InstanceService} from "../InstanceService.sol";
 import {InstanceReader} from "../InstanceReader.sol";
-import {IBaseComponent} from "../../components/IBaseComponent.sol";
+import {IComponent} from "../../components/IComponent.sol";
 
 string constant POOL_SERVICE_NAME = "PoolService";
 
 contract PoolService is 
-    ComponentServiceBase, 
+    ComponentService, 
     IPoolService 
 {
     using NftIdLib for NftId;
@@ -67,37 +67,57 @@ contract PoolService is
         external
         returns(NftId poolNftId)
     {
-        address poolOwner = msg.sender;
-        IBaseComponent pool = IBaseComponent(poolAddress);
+        (
+            IComponent pool,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        ) = _checkComponentForRegistration(
+            poolAddress,
+            POOL(),
+            POOL_OWNER_ROLE());
+
+        (
+            IRegistry.ObjectInfo memory poolInfo,
+            bytes memory data
+        ) = getRegistryService().registerPool(pool, owner);
+        pool.linkToRegisteredNftId();
+        poolNftId = poolInfo.nftId;
+
+        (
+            string memory name, 
+            ISetup.PoolSetupInfo memory initialSetup
+        ) = _decodeAndVerifyPoolData(data);
+        instance.createPoolSetup(poolNftId, initialSetup);
 
-        IRegistry.ObjectInfo memory info;
-        bytes memory data;
-        (info, data) = getRegistryService().registerPool(pool, poolOwner);
+        getInstanceService().createTarget(instanceNftId, poolAddress, name);
+    }
 
-        IInstance instance = _getInstance(info);
+    function _decodeAndVerifyPoolData(bytes memory data) 
+        internal 
+        returns(string memory name, ISetup.PoolSetupInfo memory setup)
+    {
+        (name, setup) = abi.decode(
+            data,
+            (string, ISetup.PoolSetupInfo)
+        );
 
-        bool hasRole = getInstanceService().hasRole(
-            poolOwner, 
-            POOL_OWNER_ROLE(), 
-            address(instance));
+        // TODO add checks
+        /*IRegistry _registry = getRegistry();
 
-        if(!hasRole) {
-            revert ExpectedRoleMissing(POOL_OWNER_ROLE(), poolOwner);
+        if(wallet == address(0)) {
+            revert WalletIsZero();
         }
 
-        poolNftId = info.nftId;
-        ISetup.PoolSetupInfo memory initialSetup = _decodeAndVerifyPoolSetup(data);
-        instance.createPoolSetup(poolNftId, initialSetup);
-    }
+        ObjectType tokenType = _registry.getObjectInfo(address(token)).objectType;
 
-    function _decodeAndVerifyPoolSetup(bytes memory data) internal returns(ISetup.PoolSetupInfo memory setup)
-    {
-        setup = abi.decode(
-            data,
-            (ISetup.PoolSetupInfo)
-        );
+        if(tokenType != TOKEN()) {
+            revert InvalidToken();
+        } 
 
-        // TODO add checks if applicable 
+        if(UFixedLib.eqz(info.collateralizationLevel)) { 
+            revert CollateralizationLevelIsZero();
+        }*/
     }
 
     function setFees(

package/contracts/instance/service/PoolServiceManager.sol

@@ -6,8 +6,7 @@ import {ProxyManager} from "../../shared/ProxyManager.sol";
 import {PoolService} from "./PoolService.sol";
 import {Registry} from "../../registry/Registry.sol";
 import {RegistryService} from "../../registry/RegistryService.sol";
-import {VersionLib} from "../../types/Version.sol";
-import {SERVICE} from "../../types/ObjectType.sol";
+import {REGISTRY} from "../../types/ObjectType.sol";
 
 contract PoolServiceManager is ProxyManager {
 
@@ -27,10 +26,10 @@ contract PoolServiceManager is ProxyManager {
 
         _poolService = PoolService(address(versionable));
 
-        Registry registry = Registry(registryAddress);
-        address registryServiceAddress = registry.getServiceAddress(SERVICE(), VersionLib.toVersion(3, 0, 0).toMajorPart());
-        RegistryService registryService = RegistryService(registryServiceAddress);
-        // TODO this must have a role or own nft to register service
+        // TODO `this` must have a role or own nft to register service
+        //Registry registry = Registry(registryAddress);
+        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), _poolService.getMajorVersion());
+        //RegistryService registryService = RegistryService(registryServiceAddress);
         //registryService.registerService(_poolService);
         
         // TODO no nft to link yet
@@ -38,9 +37,6 @@ contract PoolServiceManager is ProxyManager {
         //_linkToNftOwnable(
         //    address(registryAddress),
         //    address(_poolService));
-
-        // implies that after this constructor call only upgrade functionality is available
-        _isDeployed = true;
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/instance/service/ProductService.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.19;
 import {IRegistry} from "../../registry/IRegistry.sol";
 import {IProductComponent} from "../../components/IProductComponent.sol";
 import {Product} from "../../components/Product.sol";
-import {IBaseComponent} from "../../components/IBaseComponent.sol";
+import {IComponent} from "../../components/IComponent.sol";
 import {IPoolComponent} from "../../components/IPoolComponent.sol";
 import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
 import {IInstance} from "../IInstance.sol";
@@ -35,13 +35,13 @@ import {RoleId, PRODUCT_OWNER_ROLE} from "../../types/RoleId.sol";
 
 import {IService} from "../../shared/IService.sol";
 import {Service} from "../../shared/Service.sol";
-import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {ComponentService} from "../base/ComponentService.sol";
 import {IProductService} from "./IProductService.sol";
 import {InstanceReader} from "../InstanceReader.sol";
 import {IPoolService} from "./PoolService.sol";
 
 // TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
-contract ProductService is ComponentServiceBase, IProductService {
+contract ProductService is ComponentService, IProductService {
     using NftIdLib for NftId;
 
     IPoolService internal _poolService;
@@ -68,44 +68,117 @@ contract ProductService is ComponentServiceBase, IProductService {
     }
 
 
-    function getDomain() public pure override(IService, Service) returns(ObjectType) {
-        return PRODUCT();
-    }
-
     function register(address productAddress) 
         external
         returns(NftId productNftId)
     {
-        address productOwner = msg.sender;
-        IBaseComponent product = IBaseComponent(productAddress);
-
-        IRegistry.ObjectInfo memory info;
-        bytes memory data;
-        (info, data) = getRegistryService().registerProduct(product, productOwner);
-
-        IInstance instance = _getInstance(info);
-        bool hasRole = getInstanceService().hasRole(
-            productOwner, 
-            PRODUCT_OWNER_ROLE(), 
-            address(instance));
-
-        if(!hasRole) {
-            revert ExpectedRoleMissing(PRODUCT_OWNER_ROLE(), productOwner);
-        }
-
-        productNftId = info.nftId;
-        ISetup.ProductSetupInfo memory initialSetup = _decodeAndVerifyProductSetup(data);
-        instance.createProductSetup(productNftId, initialSetup);
+        (
+            IComponent product,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        ) = _checkComponentForRegistration(
+            productAddress,
+            PRODUCT(),
+            PRODUCT_OWNER_ROLE());
+
+        (
+            IRegistry.ObjectInfo memory productInfo,
+            bytes memory data
+        ) = getRegistryService().registerProduct(product, owner);
+
+        productNftId = productInfo.nftId;
+        _createProductSetup(
+            instance, 
+            product, 
+            productNftId, 
+            data);
+    }
+
+
+    function _createProductSetup(
+        IInstance instance, 
+        IComponent product, 
+        NftId productNftId, 
+        bytes memory data
+    )
+        internal
+        returns (string memory name)
+    {
+        (
+            string memory name, 
+            ISetup.ProductSetupInfo memory setup
+        ) = _decodeAndVerifyProductData(data);
+
+        // wire distribution and pool components to product component
+        IComponent distribution = IComponent(_registry.getObjectInfo(setup.distributionNftId).objectAddress);
+        IComponent pool = IComponent(_registry.getObjectInfo(setup.poolNftId).objectAddress);
+
+        distribution.setProductNftId(productNftId);
+        pool.setProductNftId(productNftId);
+        product.setProductNftId(productNftId);
+        product.linkToRegisteredNftId();
+
+        // create product setup in instance
+        instance.createProductSetup(productNftId, setup);
+
+        // create target for instane access manager
+        getInstanceService().createTarget(
+            _registry.getNftId(address(instance)), 
+            address(product), 
+            name);
     }
 
-    function _decodeAndVerifyProductSetup(bytes memory data) internal returns(ISetup.ProductSetupInfo memory setup)
+    function getDomain() public pure override(IService, Service) returns(ObjectType) {
+        return PRODUCT();
+    }
+
+
+    function _decodeAndVerifyProductData(bytes memory data) 
+        internal 
+        returns(string memory name, ISetup.ProductSetupInfo memory setup)
     {
-        setup = abi.decode(
+        (name, setup) = abi.decode(
             data,
-            (ISetup.ProductSetupInfo)
+            (string, ISetup.ProductSetupInfo)
         );
 
-        // TODO add checks if applicable 
+        // TODO add checks
+        // if(wallet == address(0)) {
+        //     revert WalletIsZero();
+        // }
+
+        // IRegistry.ObjectInfo memory tokenInfo = _registry.getObjectInfo(address(info.token));
+
+        // if(tokenInfo.objectType != TOKEN()) {
+        //     revert InvalidToken();
+        // } 
+
+        // IRegistry.ObjectInfo memory poolInfo = _registry.getObjectInfo(info.poolNftId);
+
+        // if(poolInfo.objectType != POOL()) {
+        //     revert InvalidPool();
+        // }
+
+        // if(poolInfo.parentNftId != instanceNftId) {
+        //     revert InvalidPoolsInstance();
+        // }
+        // // TODO pool have the same token
+        // //ITreasury.PoolSetup memory poolSetup = instance.getPoolSetup(info.poolNftId);
+        // //require(tokenInfo.objectAddress == address(poolSetup.token), "ERROR:COS-018:PRODUCT_POOL_TOKEN_MISMATCH");
+        // // TODO pool is not linked
+
+        // IRegistry.ObjectInfo memory distributionInfo = _registry.getObjectInfo(info.distributionNftId);
+
+        // if(distributionInfo.objectType != DISTRIBUTION()) {
+        //     revert  InvalidDistribution();
+        // } 
+
+        // if(distributionInfo.parentNftId != instanceNftId) {
+        //     revert InvalidDistributionsInstance();
+        // }
+        // // TODO distribution have the same token
+        // // TODO distribution is not linked
     }
 
     function setFees(

package/contracts/registry/IRegistry.sol

@@ -7,11 +7,12 @@ import {ChainNft} from "./ChainNft.sol";
 import {NftId} from "../types/NftId.sol";
 import {ObjectType} from "../types/ObjectType.sol";
 import {VersionPart} from "../types/Version.sol";
+import {Timestamp} from "../types/Timestamp.sol";
 
 interface IRegistry is IERC165 {
 
     event LogRegistration(NftId nftId, NftId parentNftId, ObjectType objectType, bool isInterceptor, address objectAddress, address initialOwner);
-
+    event LogServiceRegistration(VersionPart majorVersion, ObjectType domain);
 
     // register()
     error CallerNotRegistryService();
@@ -19,6 +20,7 @@ interface IRegistry is IERC165 {
 
     // registerService()
     error CallerNotReleaseManager();
+    error ServiceAlreadyRegistered(address service);
 
     // _register()
     error ZeroParentAddress();
@@ -36,7 +38,17 @@ interface IRegistry is IERC165 {
     }// TODO delete nftId and initialOwner(if not used) from struct
     // TODO strong disagree, keep nftId there (lets keep get object info return object consistent)
 
-    function registerService(ObjectInfo memory serviceInfo) external returns(NftId nftId);
+    struct ReleaseInfo {
+        ObjectType[] domains;
+        Timestamp createdAt;
+        //Timestamp updatedAt;
+    }
+
+    function registerService(
+        ObjectInfo memory serviceInfo, 
+        VersionPart serviceVersion, 
+        ObjectType serviceDomain
+    ) external returns(NftId nftId);
 
     function register(ObjectInfo memory info) external returns (NftId nftId);
 
@@ -46,6 +58,8 @@ interface IRegistry is IERC165 {
 
     function getMajorVersion() external view returns (VersionPart);
 
+    function getReleaseInfo(VersionPart version) external view returns (ReleaseInfo memory);
+
     function getObjectCount() external view returns (uint256);
 
     function getNftId() external view returns (NftId nftId);
@@ -67,7 +81,7 @@ interface IRegistry is IERC165 {
     function isRegisteredService(address contractAddress) external view returns (bool);
 
     function getServiceAddress(
-        ObjectType serviceType, 
+        ObjectType serviceDomain, 
         VersionPart releaseVersion
     ) external view returns (address serviceAddress);
 

package/contracts/registry/IRegistryService.sol

@@ -10,7 +10,7 @@ import {IService} from "../shared/IService.sol";
 import {IRegistry} from "./IRegistry.sol";
 
 import {IRegisterable} from "../shared/IRegisterable.sol";
-import {IBaseComponent} from "../components/IBaseComponent.sol";
+import {IComponent} from "../components/IComponent.sol";
 
 interface IRegistryService is 
      IService, 
@@ -35,20 +35,20 @@ interface IRegistryService is
      struct FunctionConfig
      {
           ObjectType serviceDomain;
-          bytes4[] selector;
+          bytes4 selector;
      }
 
      // TODO used by service -> add owner arg 
      function registerInstance(IRegisterable instance)
           external returns(IRegistry.ObjectInfo memory info, bytes memory data); 
 
-     function registerProduct(IBaseComponent product, address owner)
+     function registerProduct(IComponent product, address owner)
           external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
-     function registerPool(IBaseComponent pool, address owner)
+     function registerPool(IComponent pool, address owner)
           external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
-     function registerDistribution(IBaseComponent distribution, address owner)
+     function registerDistribution(IComponent distribution, address owner)
           external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
      function registerPolicy(IRegistry.ObjectInfo memory info) external returns(NftId nftId);