@etherisc/gif-next 0.0.2-f2df3e2-873 → 0.0.2-f398177-971

package/contracts/instance/service/DistributionService.sol

@@ -8,11 +8,12 @@ import {InstanceReader} from "../../instance/InstanceReader.sol";
 import {ISetup} from "../../instance/module/ISetup.sol";
 import {IPolicy} from "../module/IPolicy.sol";
 
+import {Amount, AmountLib} from "../../types/Amount.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
 import {PRODUCT_SERVICE_ROLE, DISTRIBUTION_OWNER_ROLE} from "../../types/RoleId.sol";
 import {KEEP_STATE} from "../../types/StateId.sol";
-import {ObjectType, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR} from "../../types/ObjectType.sol";
+import {ObjectType, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR, PRICE} from "../../types/ObjectType.sol";
 import {Version, VersionLib} from "../../types/Version.sol";
 import {RoleId} from "../../types/RoleId.sol";
 
@@ -26,6 +27,7 @@ import {InstanceService} from "../InstanceService.sol";
 import {IComponent} from "../../components/IComponent.sol";
 import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
 import {IDistributionService} from "./IDistributionService.sol";
+import {IPricingService} from "./IPricingService.sol";
 
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
 import {DistributorType, DistributorTypeLib} from "../../types/DistributorType.sol";
@@ -33,6 +35,7 @@ import {ReferralId, ReferralStatus, ReferralLib} from "../../types/Referral.sol"
 import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {Key32} from "../../types/Key32.sol";
 import {IDistribution} from "../module/IDistribution.sol";
+import {InstanceStore} from "../InstanceStore.sol";
 
 
 contract DistributionService is
@@ -87,7 +90,7 @@ contract DistributionService is
         distribution.linkToRegisteredNftId();
         distributionNftId = distributionInfo.nftId;
 
-        instance.createDistributionSetup(distributionNftId, distribution.getSetupInfo());
+        instance.getInstanceStore().createDistributionSetup(distributionNftId, distribution.getSetupInfo());
         // TODO move to distribution?
         bytes4[][] memory selectors = new bytes4[][](2);
         selectors[0] = new bytes4[](1);
@@ -119,14 +122,14 @@ contract DistributionService is
             revert ErrorIDistributionServiceMinFeeTooHigh(minDistributionOwnerFee.fractionalFee.toInt(), distributionFee.fractionalFee.toInt());
         }
 
-        (NftId distributionNftId, IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
         InstanceReader instanceReader = instance.getInstanceReader();
 
         ISetup.DistributionSetupInfo memory distSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
         distSetupInfo.minDistributionOwnerFee = minDistributionOwnerFee;
         distSetupInfo.distributionFee = distributionFee;
         
-        instance.updateDistributionSetup(distributionNftId, distSetupInfo, KEEP_STATE());
+        instance.getInstanceStore().updateDistributionSetup(distributionNftId, distSetupInfo, KEEP_STATE());
     }
 
     function createDistributorType(
@@ -143,7 +146,7 @@ contract DistributionService is
         external
         returns (DistributorType distributorType)
     {
-        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
 
         {
             ISetup.DistributionSetupInfo memory setupInfo = instance.getInstanceReader().getDistributionSetupInfo(distributionNftId);
@@ -153,7 +156,7 @@ contract DistributionService is
                 revert ErrorIDistributionServiceMaxDiscountTooHigh(maxDiscountPercentage.toInt(), maxDiscountPercentageLimit.toInt());
             }
         }
-        
+
         distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
         IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
             name,
@@ -166,16 +169,20 @@ contract DistributionService is
             allowRenewals,
             data);
 
-        instance.createDistributorType(distributorType, info);
+        instance.getInstanceStore().createDistributorType(distributorType, info);
     }
 
+
     function createDistributor(
         address distributor,
         DistributorType distributorType,
         bytes memory data
-    ) external returns (NftId distributorNftId)
+    )
+        external 
+        virtual
+        returns (NftId distributorNftId)
     {
-        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
 
         distributorNftId = getRegistryService().registerDistributor(
             IRegistry.ObjectInfo(
@@ -192,25 +199,27 @@ contract DistributionService is
             distributorType,
             true, // active
             data,
-            0,
+            AmountLib.zero(),
             0);
 
-        instance.createDistributor(distributorNftId, info);
+        instance.getInstanceStore().createDistributor(distributorNftId, info);
     }
 
-    function updateDistributorType(
-        NftId distributorNftId,
-        DistributorType distributorType,
-        bytes memory data
-    ) external virtual
-    {
-        (, IInstance instance) = _getAndVerifyCallingDistribution();
-        InstanceReader instanceReader = instance.getInstanceReader();
-        IDistribution.DistributorInfo memory distributorInfo = instanceReader.getDistributorInfo(distributorNftId);
-        distributorInfo.distributorType = distributorType;
-        distributorInfo.data = data;
-        instance.updateDistributor(distributorNftId, distributorInfo, KEEP_STATE());
-    }
+    // function updateDistributorType(
+    //     NftId distributorNftId,
+    //     DistributorType distributorType,
+    //     bytes memory data
+    // )
+    //     external
+    //     virtual
+    // {
+    //     (, IInstance instance) = _getAndVerifyCallingDistribution();
+    //     InstanceReader instanceReader = instance.getInstanceReader();
+    //     IDistribution.DistributorInfo memory distributorInfo = instanceReader.getDistributorInfo(distributorNftId);
+    //     distributorInfo.distributorType = distributorType;
+    //     distributorInfo.data = data;
+    //     instance.updateDistributor(distributorNftId, distributorInfo, KEEP_STATE());
+    // }
 
 
     function createReferral(
@@ -225,7 +234,7 @@ contract DistributionService is
         virtual
         returns (ReferralId referralId)
     {
-        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
 
         if (bytes(code).length == 0) {
             revert ErrorIDistributionServiceInvalidReferral(code);
@@ -235,8 +244,7 @@ contract DistributionService is
         }
 
         InstanceReader instanceReader = instance.getInstanceReader();
-        IDistribution.DistributorInfo memory distributorInfo = instanceReader.getDistributorInfo(distributorNftId);
-        DistributorType distributorType = distributorInfo.distributorType;
+        DistributorType distributorType = instanceReader.getDistributorInfo(distributorNftId).distributorType;
         IDistribution.DistributorTypeInfo memory distributorTypeData = instanceReader.getDistributorTypeInfo(distributorType);
 
         if (distributorTypeData.maxReferralCount < maxReferrals) {
@@ -263,15 +271,15 @@ contract DistributionService is
             data
         );
 
-        instance.createReferral(referralId, info);
+        instance.getInstanceStore().createReferral(referralId, info);
         return referralId;
     }
 
     function processSale(
-        NftId distributionNftId,
+        NftId distributionNftId, // assume always of distribution type
         ReferralId referralId,
         IPolicy.Premium memory premium,
-        uint256 transferredDistributionFeeAmount
+        Amount transferredDistributionFeeAmount
     )
         external
         virtual
@@ -285,104 +293,36 @@ contract DistributionService is
 
         IInstance instance = _getInstanceForDistribution(distributionNftId);
         InstanceReader reader = instance.getInstanceReader();
+        InstanceStore store = instance.getInstanceStore();
         IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
         IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
         ISetup.DistributionSetupInfo memory setupInfo = reader.getDistributionSetupInfo(distributionNftId);
         
-        uint256 distributionOwnerFee = premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount;
-        uint256 commissionAmount = premium.commissionAmount;
+        Amount distributionOwnerFee = AmountLib.toAmount(premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount);
+        Amount commissionAmount = AmountLib.toAmount(premium.commissionAmount);
 
-        if (transferredDistributionFeeAmount != distributionOwnerFee + commissionAmount) {
-            revert ErrorIDistributionServiceInvalidFeeTransferred(transferredDistributionFeeAmount, distributionOwnerFee + commissionAmount);
+        if (!(transferredDistributionFeeAmount == distributionOwnerFee + commissionAmount)) {
+            revert ErrorDistributionServiceInvalidFeeTransferred(transferredDistributionFeeAmount, distributionOwnerFee + commissionAmount);
         }
 
 
-        if (distributionOwnerFee > 0) {
-            setupInfo.sumDistributionOwnerFees += distributionOwnerFee;
-            instance.updateDistributionSetup(distributionNftId, setupInfo, KEEP_STATE());
+        if (distributionOwnerFee.gtz()) {
+            setupInfo.sumDistributionOwnerFees += distributionOwnerFee.toInt();
+            store.updateDistributionSetup(distributionNftId, setupInfo, KEEP_STATE());
         }
 
         if (isReferral) {
             referralInfo.usedReferrals += 1;
-            instance.updateReferral(referralId, referralInfo, KEEP_STATE());
+            store.updateReferral(referralId, referralInfo, KEEP_STATE());
 
-            if (commissionAmount > 0) {
-                distributorInfo.sumCommisions += commissionAmount;
+            if (commissionAmount.gtz()) {
+                distributorInfo.commissionAmount = distributorInfo.commissionAmount + commissionAmount;
                 distributorInfo.numPoliciesSold += 1;
-                instance.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
+                store.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
             }
         }
     }
 
-    function calculateFeeAmount(
-        NftId distributionNftId,
-        ReferralId referralId,
-        IPolicy.Premium memory premium
-    )
-        external
-        virtual
-        view 
-        returns (IPolicy.Premium memory finalPremium)
-    {
-        IInstance instance = _getInstanceForDistribution(distributionNftId);
-        InstanceReader reader = instance.getInstanceReader();
-        
-        // first calculate all fixed and variable fees for the distribution - this will defined the fullPremium
-        ISetup.DistributionSetupInfo memory setupInfo = reader.getDistributionSetupInfo(distributionNftId);
-        Fee memory distributionFee = setupInfo.distributionFee;
-        Fee memory minDistributionOwnerFee = setupInfo.minDistributionOwnerFee;
-        uint256 distributionFeeVarAmount = (UFixedLib.toUFixed(premium.netPremiumAmount) * distributionFee.fractionalFee).toInt();
-        premium.distributionFeeVarAmount = distributionFeeVarAmount;
-        premium.fullPremiumAmount += distributionFeeVarAmount;
-            
-        // if the referral is not valid, then the distribution owner gets everything
-        if (! referralIsValid(distributionNftId, referralId)) {
-            premium.distributionOwnerFeeFixAmount = premium.distributionFeeFixAmount;
-            premium.distributionOwnerFeeVarAmount = premium.distributionFeeVarAmount;
-            premium.premiumAmount = premium.fullPremiumAmount;
-            return premium;
-        }
-
-        // if the referral is valid, the the commission and discount are calculated based in the full premium
-        // the remaing amount goes to the distribution owner
-        {
-            IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
-            IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
-            IDistribution.DistributorTypeInfo memory distributorTypeInfo = reader.getDistributorTypeInfo(distributorInfo.distributorType);
-
-            uint256 commissionAmount = UFixedLib.toUFixed(premium.netPremiumAmount).mul(distributorTypeInfo.commissionPercentage).toInt();
-            premium.commissionAmount = commissionAmount;
-            premium.discountAmount = UFixedLib.toUFixed(premium.fullPremiumAmount).mul(referralInfo.discountPercentage).toInt();
-            premium.distributionOwnerFeeFixAmount = minDistributionOwnerFee.fixedFee;
-            premium.distributionOwnerFeeVarAmount = distributionFeeVarAmount - commissionAmount - premium.discountAmount;
-            premium.premiumAmount = premium.fullPremiumAmount - premium.discountAmount;
-        }
-
-        // sanity check to validate the fee calculation
-        if (premium.distributionOwnerFeeFixAmount < minDistributionOwnerFee.fixedFee) {
-            revert ErrorIDistributionServiceFeeCalculationMismatch(
-                premium.distributionFeeFixAmount,
-                premium.distributionFeeVarAmount,
-                premium.distributionOwnerFeeFixAmount,
-                premium.distributionOwnerFeeVarAmount,
-                premium.commissionAmount,
-                premium.discountAmount
-            );
-        }
-        if ((premium.distributionFeeVarAmount) != (premium.discountAmount + premium.distributionOwnerFeeVarAmount + premium.commissionAmount)) {
-            revert ErrorIDistributionServiceFeeCalculationMismatch(
-                premium.distributionFeeFixAmount,
-                premium.distributionFeeVarAmount,
-                premium.distributionOwnerFeeFixAmount,
-                premium.distributionOwnerFeeVarAmount,
-                premium.commissionAmount,
-                premium.discountAmount
-            );
-        }
-        
-        return premium; 
-    }
-
     // TODO: zero should return false
     function referralIsValid(NftId distributionNftId, ReferralId referralId) public view returns (bool isValid) {
         IInstance instance = _getInstanceForDistribution(distributionNftId);
@@ -396,29 +336,6 @@ contract DistributionService is
         isValid = isValid && info.usedReferrals < info.maxReferrals;
     }
 
-    function _getAndVerifyCallingDistribution()
-        internal
-        view
-        returns(
-            NftId distributionNftId,
-            IInstance instance
-        )
-    {
-        distributionNftId = getRegistry().getNftId(msg.sender);
-        if (distributionNftId.eqz()) {
-            revert ErrorDistributionServiceCallerNotRegistered(msg.sender);
-        }
-
-        IRegistry.ObjectInfo memory info = getRegistry().getObjectInfo(distributionNftId);
-        if(info.objectType != DISTRIBUTION()) {
-            revert ErrorIDistributionServiceCallerNotDistributor(msg.sender);
-        }
-
-        address instanceAddress = getRegistry().getObjectInfo(info.parentNftId).objectAddress;
-        instance = IInstance(instanceAddress);
-    }
-
-
     function _getInstanceForDistribution(NftId distributionNftId)
         internal
         view
@@ -428,4 +345,4 @@ contract DistributionService is
         address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
         return IInstance(instanceAddress);
     }
-}
+}

package/contracts/instance/service/IApplicationService.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.19;
 import {IPolicy} from "../module/IPolicy.sol";
 import {IService} from "../../shared/IService.sol";
 
+import {Amount} from "../../types/Amount.sol";
 import {NftId} from "../../types/NftId.sol";
 import {ObjectType} from "../../types/ObjectType.sol";
 import {ReferralId} from "../../types/Referral.sol";
@@ -22,7 +23,7 @@ interface IApplicationService is IService {
     function create(
         address applicationOwner,
         RiskId riskId,
-        uint256 sumInsuredAmount,
+        Amount sumInsuredAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -37,8 +38,8 @@ interface IApplicationService is IService {
         RiskId riskId,
         NftId bundleNftId,
         ReferralId referralId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
         bytes memory applicationData
     ) external;
 
@@ -58,21 +59,4 @@ interface IApplicationService is IService {
     /// an application can only be revoked in applied state
     /// only the application holder may revoke an application
     function revoke(NftId policyNftId) external;
-
-    /// @dev calculates the premium amount for the specified attributes
-    /// also returns the various fee components involved with creating a policy
-    function calculatePremium(
-        NftId productNftId,
-        RiskId riskId,
-        uint256 sumInsuredAmount,
-        Seconds lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        external
-        view
-        returns (
-            IPolicy.Premium memory premium
-        );
-}
+}

package/contracts/instance/service/IBundleService.sol

@@ -16,13 +16,15 @@ interface IBundleService is IService {
     event LogBundleServiceBundleActivated(NftId bundleNftId);
     event LogBundleServiceBundleLocked(NftId bundleNftId);
 
-    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, Amount amount);
     error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
-    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, uint capacityAmount, uint collateralAmount);
+    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, Amount capacityAmount, Amount collateralAmount);
     error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
 
     error ErrorBundleServiceBundleUnknown(NftId bundleNftId);
-    error ErrorBundleServiceBundlePoolMismatch(NftId expectedPoolNftId, NftId bundlePoolNftId);
+    error ErrorBundleServiceBundlePoolMismatch(NftId bundleNftId, NftId expectedPool, NftId actualPool);
+
+    error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
 
     /// @dev create a new bundle for the specified attributes
     /// may only be called by pool service
@@ -38,6 +40,13 @@ interface IBundleService is IService {
         external 
         returns(NftId bundleNftId); // the nft id of the newly created bundle
 
+
+    /// @dev increase bundle stakes by the specified amount
+    /// may only be called by the bundle owner
+    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
     /// @dev locks the specified bundle, locked bundles are not available to collateralize new policies
     /// only active bundles may be locked
     /// may only be called by registered and unlocked pool components
@@ -74,23 +83,36 @@ interface IBundleService is IService {
         IInstance instanceNftId, 
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount, 
-        uint256 premium // premium amount after pool fee
+        Amount collateralAmount, 
+        Amount premiumAmount // premium after pool fee
     ) external;
 
-
     /// @dev releases the specified collateral in the bundle
     /// may only be called by pool service
     function releaseCollateral(
         IInstance instance, 
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount
+        Amount collateralAmount
     ) external;
 
-    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
+    /// @dev unlink policy from bundle
+    /// policy may only be unlinked if policy is closeable
+    /// may only be called by pool service
+    function unlinkPolicy(
+        IInstance instance, 
+        NftId policyNftId
+    ) external;
 
-    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev updates the bundle's fees of with the provided fee amount
+    function updateBundleFees(
+        IInstance instance,
+        NftId bundleNftId,
+        Amount feeAmount
+    ) external;
 
-    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    function increaseBalance(
+        IInstance instance, 
+        NftId bundleNftId,  
+        Amount amount) external;
 }

package/contracts/instance/service/IClaimService.sol

@@ -20,73 +20,71 @@ interface IClaimService is
     IService
 {
 
+    event LogClaimServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
+    event LogClaimServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
+    event LogClaimServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
+    event LogClaimServiceClaimClosed(NftId policyNftId, ClaimId claimId);
+
+    event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount);
+    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount);
+
+    error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
+    error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+
     error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint8 openPayouts);
     error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
     error ErrorClaimServiceClaimNotInExpectedState(NftId policyNftId, ClaimId claimId, StateId expectedState, StateId actualState);
 
     /// @dev create a new claim for the specified policy
+    /// returns the id of the newly created claim
     /// function can only be called by product, policy needs to match with calling product
     function submit(
-        IInstance instance,
         NftId policyNftId, 
-        ClaimId claimId,
         Amount claimAmount,
         bytes memory claimData
-    ) external;
+    ) external returns (ClaimId claimId);
 
-    /// @dev confirms the specified claim and fixes the final claim amount
+    /// @dev declines the specified claim
     /// function can only be called by product, policy needs to match with calling product
-    function confirm(
-        IInstance instance,
-        InstanceReader instanceReader,
+    function decline(
         NftId policyNftId, 
-        ClaimId claimId, 
-        Amount claimAmount
-    ) external;
+        ClaimId claimId) external;
 
-    /// @dev declares the claim as invalid, no payout(s) will be made
+    /// @dev confirms the specified claim and specifies the payout amount
     /// function can only be called by product, policy needs to match with calling product
-    function decline(
-        IInstance instance,
-        InstanceReader instanceReader,
+    function confirm(
         NftId policyNftId, 
-        ClaimId claimId
+        ClaimId claimId,
+        Amount confirmedAmount
     ) external;
 
-    /// @dev closes the claim
-    /// a claim may only be closed once all existing payouts have been executed and the sum of the paid out amounts has reached the claim amount
+    /// @dev closes the specified claim
     /// function can only be called by product, policy needs to match with calling product
     function close(
-        IInstance instance,
-        InstanceReader instanceReader,
         NftId policyNftId, 
         ClaimId claimId
-    ) external; 
+    ) external;
+
 
-    /// @dev create a new payout for the specified policy
-    /// payoutId may be constructed using PayoutIdLib(claimId, payoutNo)
+    /// @dev creates a new payout for the specified claim
+    /// returns the id of the newly created payout, this id is unique for the specified policy
     /// function can only be called by product, policy needs to match with calling product
     function createPayout(
-        IInstance instance,
         NftId policyNftId, 
-        PayoutId payoutId,
-        Amount payoutAmount,
-        bytes calldata payoutData
-    ) external; 
+        ClaimId claimId,
+        Amount amount,
+        bytes memory data
+    )
+        external
+        returns (PayoutId payoutId);
 
-    /// @dev callback function to confirm transfer of payout token to beneficiary
-    /// allows claim service to update claims/payout book keeping
-    /// only pool service can confirm executed payout
+
+    /// @dev processes the specified payout
+    /// this includes moving the payout token to the beneficiary (default: policy holder)
+    /// function can only be called by product, policy needs to match with calling product
     function processPayout(
-        IInstance instance,
-        InstanceReader instanceReader,
         NftId policyNftId, 
         PayoutId payoutId
-    )
-        external 
-        returns (
-            Amount amount,
-            bool payoutIsClosingClaim
-        );
-
+    ) external;
 }

package/contracts/instance/service/IDistributionService.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {Amount} from "../../types/Amount.sol";
 import {NftId} from "../../types/NftId.sol";
 import {Fee} from "../../types/Fee.sol";
 import {IPolicy} from "../module/IPolicy.sol";
@@ -25,16 +26,8 @@ interface IDistributionService is IService {
     error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
     error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
     error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
-    error ErrorIDistributionServiceFeeCalculationMismatch(
-                uint256 distributionFeeFixAmount,
-                uint256 distributionFeeVarAmount,
-                uint256 distributionOwnerFeeFixAmount,
-                uint256 distributionOwnerFeeVarAmount,
-                uint256 commissionAmount,
-                uint256 discountAmount
-            );
     error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
-    error ErrorIDistributionServiceInvalidFeeTransferred(uint256 transferredDistributionFeeAmount, uint256 expectedDistributionFeeAmount);
+    error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
 
     function setFees(
         Fee memory minDistributionOwnerFee,
@@ -61,11 +54,12 @@ interface IDistributionService is IService {
         bytes memory data
     ) external returns (NftId distributorNftId);
 
-    function updateDistributorType(
-        NftId distributorNftId,
-        DistributorType distributorType,
-        bytes memory data
-    ) external;
+    // TODO re-enable and reorganize (service contract too large)
+    // function updateDistributorType(
+    //     NftId distributorNftId,
+    //     DistributorType distributorType,
+    //     bytes memory data
+    // ) external;
 
     function createReferral(
         NftId distributorNftId,
@@ -83,17 +77,11 @@ interface IDistributionService is IService {
         NftId distributionNftId,
         ReferralId referralId,
         IPolicy.Premium memory premium,
-        uint256 transferredDistributionFeeAmount
+        Amount transferredDistributionFeeAmount
     ) external;
 
-    function calculateFeeAmount(
-        NftId distributionNftId,
-        ReferralId referralId,
-        IPolicy.Premium memory premium
-    ) external view returns (IPolicy.Premium memory finalPremium);
-
     function referralIsValid(
         NftId distributorNftId,
         ReferralId referralId
     ) external view returns (bool isValid);
-}
+}