@etherisc/gif-next 0.0.2-81f8acb → 0.0.2-836a512-798

package/contracts/instance/policy/IPolicy.sol

@@ -1,43 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {NftId} from "../../types/NftId.sol";
+import {StateId} from "../../types/StateId.sol";
 
 // TODO check if there is value to introuce IContract and let IPolicy derive from IContract
 interface IPolicy {
 
-    enum PolicyState {
-        Undefined,
-        Applied,
-        Rejected,
-        Active,
-        Closed
-    }
-
     struct PolicyInfo {
         NftId nftId;
-        PolicyState state; // applied, withdrawn, rejected, active, closed
-
+        StateId state; // applied, withdrawn, rejected, active, closed
+        // TODO add beneficiary address
         uint256 sumInsuredAmount;
         uint256 premiumAmount;
+        uint256 premiumPaidAmount;
         uint256 lifetime; // activatedAt + lifetime >= expiredAt
-
         uint256 createdAt;
+        uint256 updatedAt;
         uint256 activatedAt; // time of underwriting
         uint256 expiredAt; // no new claims
         uint256 closedAt; // no locked capital
     }
 }
 
-interface IPolicyModule is
-    IOwnable,
-    IRegistryLinked,
-    IPolicy
-{
+interface IPolicyModule is IOwnable, IRegistryLinked, IPolicy {
 
     function createApplication(
         IRegistry.RegistryInfo memory productInfo,
@@ -46,21 +35,18 @@ interface IPolicyModule is
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    )
-        external
-        returns(NftId nftId);
+    ) external returns (NftId nftId);
 
-    function activate(NftId nftId)
-        external;
+    // process full premium
+    function processPremium(NftId nftId) external;
 
-    function getBundleNftForPolicy(NftId nftId)
-        external
-        view
-        returns(NftId bundleNft);
+    function activate(NftId nftId) external;
 
-    function getPolicyInfo(NftId nftId)
-        external
-        view
-        returns(PolicyInfo memory info);
+    function getBundleNftForPolicy(
+        NftId nftId
+    ) external view returns (NftId bundleNft);
 
+    function getPolicyInfo(
+        NftId nftId
+    ) external view returns (PolicyInfo memory info);
 }

package/contracts/instance/policy/PolicyModule.sol

@@ -1,14 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 // import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
 import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {IPolicy, IPolicyModule} from "./IPolicy.sol";
+import {ObjectType, POLICY} from "../../types/ObjectType.sol";
+import {ACTIVE} from "../../types/StateId.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+
 abstract contract PolicyModule is
     IRegistryLinked,
     IPolicyModule
@@ -18,19 +22,23 @@ abstract contract PolicyModule is
     mapping(NftId nftId => PolicyInfo info) private _policyInfo;
     mapping(NftId nftId => NftId bundleNftId) private _bundleForPolicy;
 
+    LifecycleModule private _lifecycleModule;
     IProductService private _productService;
 
     // TODO find a better place to avoid dupliation
     modifier onlyProductService2() {
-        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        require(
+            address(_productService) == msg.sender,
+            "ERROR:POL-001:NOT_PRODUCT_SERVICE"
+        );
         _;
     }
 
     constructor(address productService) {
+        _lifecycleModule = LifecycleModule(address(this));
         _productService = IProductService(productService);
     }
 
-
     function createApplication(
         IRegistry.RegistryInfo memory productInfo,
         address applicationOwner,
@@ -38,30 +46,29 @@ abstract contract PolicyModule is
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    )
-        external
-        override
-        onlyProductService2
-        returns(NftId nftId)
-    {
+    ) external override onlyProductService2 returns (NftId nftId) {
         // TODO add parameter validation
-        if(bundleNftId.gtz()) {
-            IRegistry.RegistryInfo memory bundleInfo = this.getRegistry().getInfo(bundleNftId);
+        if (bundleNftId.gtz()) {
+            // IRegistry.RegistryInfo memory bundleInfo = this
+            //     .getRegistry()
+            //     .getInfo(bundleNftId);
             // IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
         }
 
         nftId = this.getRegistry().registerObjectForInstance(
             productInfo.nftId,
-            this.getRegistry().POLICY(),
+            POLICY(),
             applicationOwner);
 
         _policyInfo[nftId] = PolicyInfo(
             nftId,
-            PolicyState.Applied,
+            _lifecycleModule.getInitialState(POLICY()),
             sumInsuredAmount,
             premiumAmount,
+            0, // premium paid amount
             lifetime,
-            block.timestamp,
+            block.timestamp, // createdAt
+            block.timestamp, // updatedAt
             0, // activatedAt
             0, // expiredAt
             0 // closedAt
@@ -72,36 +79,29 @@ abstract contract PolicyModule is
         // add logging
     }
 
+    function processPremium(NftId nftId) external override onlyProductService2 {
+        PolicyInfo storage info = _policyInfo[nftId];
+        info.premiumPaidAmount = info.premiumAmount;
+        info.updatedAt = block.timestamp;
+    }
+
 
-    function activate(NftId nftId)
-        external
-        override
-        onlyProductService2
-    {
+    function activate(NftId nftId) external override onlyProductService2 {
         PolicyInfo storage info = _policyInfo[nftId];
         info.activatedAt = block.timestamp;
         info.expiredAt = block.timestamp + info.lifetime;
-        info.state = PolicyState.Active;
-
-        // add logging
+        info.state = _lifecycleModule.checkAndLogTransition(nftId, POLICY(), info.state, ACTIVE());
     }
 
-
-
-    function getBundleNftForPolicy(NftId nftId)
-        external
-        view
-        returns(NftId bundleNft)
-    {
+    function getBundleNftForPolicy(
+        NftId nftId
+    ) external view returns (NftId bundleNft) {
         return _bundleForPolicy[nftId];
     }
 
-
-    function getPolicyInfo(NftId nftId)
-        external
-        view
-        returns(PolicyInfo memory info)
-    {
+    function getPolicyInfo(
+        NftId nftId
+    ) external view returns (PolicyInfo memory info) {
         return _policyInfo[nftId];
     }
 }

package/contracts/instance/pool/IPoolModule.sol

@@ -5,37 +5,18 @@ import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol
 import {NftId} from "../../types/NftId.sol";
 
 interface IPool {
-
     struct PoolInfo {
         NftId nftId;
-        address wallet;
-        address token;
         uint256 capital;
         uint256 lockedCapital;
     }
 }
 
-interface IPoolModule is
-    IOwnable,
-    IRegistryLinked,
-    IPool
-{
-    
-    function underwrite(
-        NftId poolNftId,
-        NftId policyNftId
-    )
-        external;
+interface IPoolModule is IOwnable, IRegistryLinked, IPool {
+
+    function underwrite(NftId policyNftId, NftId productNftId) external;
 
-    function createPoolInfo(
-        NftId nftId,
-        address wallet,
-        address token
-    )
-        external;
+    function registerPool(NftId nftId) external;
 
-    function getPoolInfo(NftId nftId)
-        external
-        view
-        returns(PoolInfo memory info);
-}
+    function getPoolInfo(NftId nftId) external view returns (PoolInfo memory info);
+}

package/contracts/instance/pool/PoolModule.sol

@@ -4,83 +4,79 @@ pragma solidity ^0.8.19;
 import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
+import {ITreasuryModule} from "../treasury/ITreasury.sol";
 import {IPoolModule} from "./IPoolModule.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
-abstract contract PoolModule is
-    IPoolModule
-{
+abstract contract PoolModule is IPoolModule {
     using NftIdLib for NftId;
-    
-    uint256 public constant INITIAL_CAPITAL = 10000*10**6;
+
+    uint256 public constant INITIAL_CAPITAL = 10000 * 10 ** 6;
+    uint256 public constant INITIAL_LOCKED_CAPITAL = 0;
 
     mapping(NftId nftId => PoolInfo info) private _poolInfo;
 
+    IPolicyModule private _policyModule;
+    ITreasuryModule private _treasuryModule;
     IProductService private _productService;
 
     modifier onlyProductService() {
-        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        require(
+            address(_productService) == msg.sender,
+            "ERROR:POL-001:NOT_PRODUCT_SERVICE"
+        );
         _;
     }
 
     constructor(address productService) {
+        _policyModule = IPolicyModule(address(this));
+        _treasuryModule = ITreasuryModule(address(this));
         _productService = IProductService(productService);
     }
 
-    function createPoolInfo(
-        NftId nftId,
-        address wallet,
-        address token
-    )
+    function registerPool(NftId nftId)
         public
         override
     {
-        require(
-            _poolInfo[nftId].nftId.eqz(),
-            "ERROR:PL-001:ALREADY_CREATED");
+        require(_poolInfo[nftId].nftId.eqz(), "ERROR:PL-001:ALREADY_CREATED");
 
         _poolInfo[nftId] = PoolInfo(
             nftId,
-            wallet,
-            token,
             INITIAL_CAPITAL,
-            0 // locked capital
+            INITIAL_LOCKED_CAPITAL
         );
-
     }
 
-
     function underwrite(
-        NftId poolNftId,
-        NftId policyNftId
+        NftId policyNftId,
+        NftId productNftId
     )
         external
         override
         onlyProductService
     {
-        PoolInfo storage poolInfo = _poolInfo[poolNftId];
-        require(
-            poolInfo.nftId == poolNftId,
-            "ERROR:PL-002:POOL_UNKNOWN");
+        IPolicy.PolicyInfo memory policyInfo = _policyModule.getPolicyInfo(policyNftId);
+        require(policyInfo.nftId == policyNftId, "ERROR:PL-002:POLICY_UNKNOWN");
 
-        IPolicyModule policyModule = IPolicyModule(address(this));
-        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(policyNftId);
+        ITreasuryModule.ProductSetup memory product = _treasuryModule.getProductSetup(productNftId);
+        require(product.productNftId == productNftId, "ERROR:PL-003:PRODUCT_SETUP_MISSING");
+
+        NftId poolNftId = product.poolNftId;
+        PoolInfo storage poolInfo = _poolInfo[poolNftId];
+        require(poolInfo.nftId == poolNftId, "ERROR:PL-004:POOL_UNKNOWN");
 
         require(
-            poolInfo.capital - poolInfo.lockedCapital >= policyInfo.sumInsuredAmount,
-            "ERROR:PL-003:CAPACITY_TOO_LOW");
+            poolInfo.capital - poolInfo.lockedCapital >=
+                policyInfo.sumInsuredAmount,
+            "ERROR:PL-005:CAPACITY_TOO_LOW"
+        );
 
         poolInfo.lockedCapital += policyInfo.sumInsuredAmount;
     }
 
-
-    function getPoolInfo(NftId nftId)
-        external
-        view
-        override
-        returns(PoolInfo memory info)
-    {
+    function getPoolInfo(
+        NftId nftId
+    ) external view override returns (PoolInfo memory info) {
         info = _poolInfo[nftId];
     }
-
-}
+}

package/contracts/instance/product/IProductService.sol

@@ -1,35 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
 import {NftId} from "../../types/NftId.sol";
 
-
 // TODO or name this IProtectionService to have Product be something more generic (loan, savings account, ...)
-interface IProductService is
-    IRegistryLinked
-{
-
+interface IProductService is IRegistryLinked {
     function createApplication(
         address applicationOwner,
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    )
-        external 
-        returns(NftId nftId);
+    ) external returns (NftId nftId);
 
     // function revoke(unit256 nftId) external;
 
     function underwrite(NftId nftId) external;
+
     // function decline(uint256 nftId) external;
     // function expire(uint256 nftId) external;
     function close(NftId nftId) external;
 
-    // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
+    function collectPremium(NftId nftId) external;
 
     // function createClaim(uint256 nftId, uint256 claimAmount) external;
     // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
@@ -37,10 +31,6 @@ interface IProductService is
     // function closeClaim(uint256 nftId, uint256 claimId) external;
 }
 
-
-interface IProductModule is
-    IOwnable,
-    IRegistryLinked
-{
-    function getProductService() external view returns(IProductService);
+interface IProductModule is IOwnable, IRegistryLinked {
+    function getProductService() external view returns (IProductService);
 }

package/contracts/instance/product/ProductService.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 // import {IProduct} from "../../components/IProduct.sol";
 // import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
 // import {IInstance} from "../IInstance.sol";
@@ -9,21 +8,16 @@ import {IRegistry} from "../../registry/IRegistry.sol";
 import {IPolicyModule} from "../policy/IPolicy.sol";
 import {RegistryLinked} from "../../registry/Registry.sol";
 import {IProductService, IProductModule} from "./IProductService.sol";
-import {IComponentModule} from "../../instance/component/IComponent.sol";
+import {ITreasuryModule} from "../../instance/treasury/ITreasury.sol";
 import {IPoolModule} from "../../instance/pool/IPoolModule.sol";
+import {ObjectType, INSTANCE, PRODUCT} from "../../types/ObjectType.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 // TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
-contract ProductService is
-    RegistryLinked,
-    IProductService
-{
+contract ProductService is RegistryLinked, IProductService {
     using NftIdLib for NftId;
-    
-    constructor(address registry) 
-        RegistryLinked(registry)
-    { }
 
+    constructor(address registry) RegistryLinked(registry) {}
 
     function createApplication(
         address applicationOwner,
@@ -31,20 +25,16 @@ contract ProductService is
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    )
-        external 
-        override
-        returns(NftId nftId)
-    {
+    ) external override returns (NftId nftId) {
         // same as only registered product
         NftId productNftId = _registry.getNftId(msg.sender);
         require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
         IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
 
         IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
         require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
 
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
         nftId = policyModule.createApplication(
@@ -53,56 +43,76 @@ contract ProductService is
             sumInsuredAmount,
             premiumAmount,
             lifetime,
-            bundleNftId);
+            bundleNftId
+        );
+
+        // add logging
+    }
+
+    function underwrite(NftId policyNftId) external override {
+        // validation
+        // same as only registered product
+        NftId productNftId = _registry.getNftId(msg.sender);
+        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // underwrite policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPoolModule poolModule = IPoolModule(instanceAddress);
+        poolModule.underwrite(policyNftId, productNftId);
+
+        // activate policy
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.activate(policyNftId);
 
         // add logging
     }
 
-    function underwrite(NftId nftId)
+    function collectPremium(NftId policyNftId)
         external
         override
     {
+        // validation same as other functions, eg underwrite
+        // TODO unify validation into modifier and/or other suitable approaches
         // same as only registered product
         NftId productNftId = _registry.getNftId(msg.sender);
         require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
         IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
 
         IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
         require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
-
-        // get responsible pool
-        IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
-        NftId poolNftId = componentModule.getPoolNftId(productNftId);
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
 
-        // lock capital (and update pool accounting)
-        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
-        poolModule.underwrite(
-            poolNftId,
-            nftId);
+        // process/collect premium: book keeping for policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.processPremium(policyNftId);
 
-        // activate policy
-        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
-        policyModule.activate(nftId);
+        // process/collect premium: actual token transfer
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.processPremium(policyNftId, productNftId);
 
-        // add logging
+        // TODO add logging
     }
 
-    function close(NftId nftId) external override {}
+    function close(NftId policyNftId) external override {}
+
 }
 
-abstract contract ProductModule is
-    IProductModule
-{
+abstract contract ProductModule is IProductModule {
     IProductService private _productService;
 
     constructor(address productService) {
         _productService = IProductService(productService);
     }
 
-    function getProductService() external view returns(IProductService) {
+    function getProductService() external view returns (IProductService) {
         return _productService;
     }
-
-}
+}

package/contracts/instance/treasury/ITreasury.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {Fee} from "../../types/Fee.sol";
+
+import {TokenHandler} from "./TokenHandler.sol";
+
+interface ITreasury {
+
+    // TODO add events
+    // TODO add errors
+}
+
+interface ITreasuryModule is
+    IRegistryLinked,
+    ITreasury
+{
+
+    struct ProductSetup {
+        NftId productNftId;
+        NftId distributorNftId;
+        NftId poolNftId;
+        IERC20 token;
+        TokenHandler tokenHandler;
+        address wallet;
+        Fee policyFee;
+        Fee processingFee;
+    }
+
+    struct DistributorSetup {
+        NftId distributorNftId;
+        address wallet;
+        Fee commissionFees;
+    }
+
+    struct PoolSetup {
+        NftId poolNftId;
+        address wallet;
+        Fee stakingFee;
+        Fee performanceFee;
+    }
+
+    function registerProduct(
+            NftId productNftId,
+            NftId distributorNftId,
+            NftId poolNftId,
+            IERC20 token,
+            address wallet,
+            Fee memory policyFee,
+            Fee memory processingFee
+        )
+            external;
+
+    function registerPool(
+            NftId poolNftId,
+            address wallet,
+            Fee memory stakingFee,
+            Fee memory performanceFee
+        )
+            external;
+
+    function getTokenHandler(NftId productNftId) external view returns(TokenHandler tokenHandler);
+    function getProductSetup(NftId productNftId) external view returns(ProductSetup memory setup);
+    function getPoolSetup(NftId poolNftId) external view returns(PoolSetup memory setup);
+
+    function processPremium(NftId policyNftId, NftId productNftId) external;
+}