@etherisc/gif-next 0.0.2-2a59cd5-352 → 0.0.2-2af39ab-356

package/contracts/instance/module/IComponents.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Fee} from "../../types/Fee.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IComponents {
+
+    struct ComponentInfo {
+        string name; // component name (needs to be unique per instance)
+        IERC20Metadata token;
+        TokenHandler tokenHandler;
+        address wallet;
+        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
+        uint256 maxCapitalAmount; // max capital amount allowed for pool
+        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 
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+}

package/contracts/instance/module/IDistribution.sol

@@ -24,6 +24,8 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
+        uint256 sumCommisions;
+        uint256 numPoliciesSold;
     }
 
     struct ReferralInfo {   

package/contracts/instance/module/IPolicy.sol

@@ -2,12 +2,39 @@
 pragma solidity ^0.8.20;
 
 import {NftId} from "../../types/NftId.sol";
-import {NumberId} from "../../types/NumberId.sol";
+import {ClaimId} from "../../types/ClaimId.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IPolicy {
+
+    struct Premium {
+        // this is the net premium calculated by the product 
+        uint256 netPremiumAmount;
+        // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
+        uint256 fullPremiumAmount;
+        // premium = fullPremium - discount
+        uint256 premiumAmount;
+        uint256 productFeeFixAmount;
+        uint256 poolFeeFixAmount;
+        uint256 bundleFeeFixAmount;
+        uint256 distributionFeeFixAmount;
+        uint256 productFeeVarAmount;
+        uint256 poolFeeVarAmount;
+        uint256 bundleFeeVarAmount;
+        uint256 distributionFeeVarAmount;
+        uint256 distributionOwnerFeeFixAmount;
+        // this is the remaining amount when the commission and discount are subtracted from the distribution fee variable part (must be at least the minDistributionOwnerFee)
+        uint256 distributionOwnerFeeVarAmount;
+        // this value is based on distributor type referenced in the referral 
+        uint256 commissionAmount;
+        // this is based on referral used
+        uint256 discountAmount;
+    }
+
+    /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
         NftId productNftId;
         NftId bundleNftId;
@@ -16,7 +43,7 @@ interface IPolicy {
         uint256 sumInsuredAmount;
         uint256 premiumAmount;
         uint256 premiumPaidAmount;
-        uint256 lifetime;
+        Seconds lifetime;
         bytes applicationData;
         bytes policyData;
         uint16 claimsCount;
@@ -37,7 +64,7 @@ interface IPolicy {
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct PayoutInfo {
-        NumberId claimId;
+        ClaimId claimId;
         uint256 amount;
         bytes data;
         Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)

package/contracts/instance/module/ISetup.sol

@@ -5,21 +5,33 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 
 import {Fee} from "../../types/Fee.sol";
 import {NftId} from "../../types/NftId.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {RoleId} from "../../types/RoleId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../types/UFixed.sol";
 
 interface ISetup {
+
+    struct PoolInfo {
+        NftId productNftId; // the nft of the product this pool is linked to
+        RoleId bundleOwnerRole; // the required role for bundle owners
+        uint256 maxCapitalAmount; // max capital amount allowed for pool
+        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 
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+
     struct ProductSetupInfo {
         IERC20Metadata token;
         TokenHandler tokenHandler;
         NftId distributionNftId;
         NftId poolNftId;
-        Fee distributionFee; // default distribution fee (no referral id)
         Fee productFee; // product fee on net premium
-        Fee processingFee; // product fee on payout amounts
-        Fee poolFee; // pool fee on net premium
-        Fee stakingFee; // pool fee on staked capital from investor
-        Fee performanceFee; // pool fee on profits from capital investors
+        Fee processingFee; // product fee on payout amounts        
         bool isIntercepting; // intercepts nft transfers (for products)
         address wallet;
     }
@@ -27,13 +39,17 @@ interface ISetup {
     struct DistributionSetupInfo {
         NftId productNftId;
         TokenHandler tokenHandler;
-        Fee distributionFee; // default distribution fee (no referral id)
+        Fee minDistributionOwnerFee;
+        Fee distributionFee; // recalculated whenever any fee on the product/pool/dist/disttype is changed
         address wallet;
+        uint256 sumDistributionFees;
     }
 
     struct PoolSetupInfo {
         NftId productNftId;
         TokenHandler tokenHandler;
+        RoleId bundleOwnerRole;
+        uint256 maxCapitalAmount; // max capital amount allowed for pool
         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

@@ -10,6 +10,7 @@ import {Product} from "../../components/Product.sol";
 import {IPoolComponent} from "../../components/IPoolComponent.sol";
 import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
 import {IInstance} from "../IInstance.sol";
+import {IComponents} from "../module/IComponents.sol";
 import {IPolicy} from "../module/IPolicy.sol";
 import {IRisk} from "../module/IRisk.sol";
 import {IBundle} from "../module/IBundle.sol";
@@ -22,11 +23,12 @@ import {TokenHandler} from "../../shared/TokenHandler.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
+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, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, BUNDLE} from "../../types/ObjectType.sol";
-import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
+import {ObjectType, DISTRIBUTION, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, BUNDLE} 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";
 import {ReferralId} from "../../types/Referral.sol";
@@ -38,6 +40,7 @@ import {ComponentService} from "../base/ComponentService.sol";
 import {InstanceReader} from "../InstanceReader.sol";
 import {IApplicationService} from "./IApplicationService.sol";
 import {IBundleService} from "./IBundleService.sol";
+import {IDistributionService} from "./IDistributionService.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IService} from "../../shared/IService.sol";
 import {Service} from "../../shared/Service.sol";
@@ -47,14 +50,14 @@ contract ApplicationService is
     ComponentService, 
     IApplicationService
 {
+    IDistributionService internal _distributionService;
 
-
-    function initialize(
+    function _initialize(
         address owner, 
         bytes memory data
     )
-        public
-        virtual
+        internal
+        virtual override
         initializer()
     {
         // TODO check this, might no longer be the way, refactor if necessary
@@ -64,20 +67,27 @@ contract ApplicationService is
 
         initializeService(registryAddress, owner);
         registerInterface(type(IApplicationService).interfaceId);
+
+        _distributionService = IDistributionService(getRegistry().getServiceAddress(DISTRIBUTION(), getMajorVersion()));
+    }
+
+
+    function getDomain() public pure override(IService, Service) returns(ObjectType) {
+        return APPLICATION();
     }
 
 
     function create(
         address applicationOwner,
         RiskId riskId,
+        uint256 sumInsuredAmount,
+        Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
         bytes memory applicationData
     )
         external
-        virtual override
+        virtual
         returns (NftId applicationNftId)
     {
         (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
@@ -95,7 +105,9 @@ contract ApplicationService is
             )
         );
 
-        (uint256 premiumAmount,,,,) = calculatePremium(
+        // (uint256 premiumAmount,,,,,) = calculatePremium(
+        IPolicy.Premium memory premium = calculatePremium(
+            productInfo.nftId,
             riskId,
             sumInsuredAmount,
             lifetime,
@@ -110,7 +122,7 @@ contract ApplicationService is
             referralId,
             riskId,
             sumInsuredAmount,
-            premiumAmount,
+            premium.premiumAmount,
             0,
             lifetime,
             applicationData,
@@ -123,8 +135,7 @@ contract ApplicationService is
             zeroTimestamp()
         );
         
-        instance.createPolicy(applicationNftId, policyInfo);
-        instance.updatePolicyState(applicationNftId, APPLIED());
+        instance.createApplication(applicationNftId, policyInfo);
 
         // TODO: add logging
     }
@@ -142,7 +153,7 @@ contract ApplicationService is
     }
 
 
-    function ajust(
+    function adjust(
         NftId applicationNftId,
         RiskId riskId,
         NftId bundleNftId,
@@ -157,18 +168,20 @@ contract ApplicationService is
 
     }
 
-    function revoke(NftId policyNftId)
+    function revoke(NftId applicationNftId)
         external
         virtual override
     {
-
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        instance.updateApplicationState(applicationNftId, REVOKED());
     }
 
-
+    // TODO: maybe move this to a pricing service later
     function calculatePremium(
+        NftId productNftId,
         RiskId riskId,
         uint256 sumInsuredAmount,
-        uint256 lifetime,
+        Seconds lifetime,
         bytes memory applicationData,
         NftId bundleNftId,
         ReferralId referralId
@@ -177,47 +190,36 @@ contract ApplicationService is
         view
         virtual override
         returns (
-            uint256 premiumAmount,
-            uint256 distributionFeeAmount,
-            uint256 productFeeAmount,
-            uint256 poolFeeAmount,
-            uint256 bundleFeeAmount
+            IPolicy.Premium memory premium
         )
     {
-        Product product = _getAndVerifyInstanceAndProduct();
-        uint256 netPremiumAmount = product.calculateNetPremium(
+        uint256 netPremiumAmount = _getAndVerifyProduct(productNftId).calculateNetPremium(
             sumInsuredAmount,
             riskId,
             lifetime,
             applicationData
         );
 
-        (
-            productFeeAmount,
-            poolFeeAmount,
-            bundleFeeAmount,
-            distributionFeeAmount
-        ) = _calculateFeeAmounts(
+        premium = _getFixedFeeAmounts(
             netPremiumAmount,
-            product,
+            _getAndVerifyProduct(productNftId),
             bundleNftId,
             referralId
         );
 
-        premiumAmount = netPremiumAmount + productFeeAmount;
-        premiumAmount += poolFeeAmount + bundleFeeAmount;
-        premiumAmount += distributionFeeAmount;
-    }
-
-
-    function getDomain() public pure override(IService, Service) returns(ObjectType) {
-        return APPLICATION();
+        (
+            premium
+        ) = _calculateVariableFeeAmounts(
+            premium,
+            _getAndVerifyProduct(productNftId),
+            bundleNftId,
+            referralId
+        );
     }
 
 
     // internal functions
-
-    function _calculateFeeAmounts(
+    function _getFixedFeeAmounts(
         uint256 netPremiumAmount,
         Product product,
         NftId bundleNftId,
@@ -226,10 +228,7 @@ contract ApplicationService is
         internal
         view
         returns (
-            uint256 productFeeAmount,
-            uint256 poolFeeAmount,
-            uint256 bundleFeeAmount,
-            uint256 distributionFeeAmount
+            IPolicy.Premium memory premium
         )
     {
         InstanceReader instanceReader;
@@ -239,24 +238,100 @@ contract ApplicationService is
         }
         
         NftId poolNftId = product.getPoolNftId();
-        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-        require(bundleInfo.poolNftId == poolNftId,"ERROR:PRS-035:BUNDLE_POOL_MISMATCH");
+        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());
-            (productFeeAmount,) = FeeLib.calculateFee(productSetupInfo.productFee, netPremiumAmount);
+            {
+                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;
         {
-            ISetup.PoolSetupInfo memory poolSetupInfo = instanceReader.getPoolSetupInfo(poolNftId);
-            (poolFeeAmount,) = FeeLib.calculateFee(poolSetupInfo.poolFee, netPremiumAmount);
+            IInstance instance = product.getInstance();
+            instanceReader = instance.getInstanceReader();
         }
+        
+        NftId poolNftId = product.getPoolNftId();
+        uint256 netPremiumAmount = premium.netPremiumAmount;
+
         {
-            NftId distributionNftId = product.getDistributionNftId();
-            ISetup.DistributionSetupInfo memory distributionSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
-            (distributionFeeAmount,) = FeeLib.calculateFee(distributionSetupInfo.distributionFee, 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
+                );
+            }
         }
-        
-        (bundleFeeAmount,) = FeeLib.calculateFee(bundleInfo.fee, netPremiumAmount);
+
+        return premium;
     }
 
 
@@ -265,4 +340,11 @@ contract ApplicationService is
         (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);
+    }
 }

package/contracts/instance/service/ApplicationServiceManager.sol

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