@etherisc/gif-next 0.0.2-da06f3b-803 → 0.0.2-da09ec0-359

package/contracts/instance/service/DistributionService.sol

@@ -6,13 +6,16 @@ import {IInstance} from "../../instance/IInstance.sol";
 import {InstanceAccessManager} from "../InstanceAccessManager.sol";
 import {InstanceReader} from "../../instance/InstanceReader.sol";
 import {ISetup} from "../../instance/module/ISetup.sol";
+import {IPolicy} from "../module/IPolicy.sol";
 
-import {NftId, NftIdLib} from "../../types/NftId.sol";
-import {Fee} from "../../types/Fee.sol";
-import {DISTRIBUTION_OWNER_ROLE} from "../../types/RoleId.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} 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";
 
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
@@ -24,12 +27,26 @@ 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";
+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
     ComponentService,
     IDistributionService
 {
     using NftIdLib for NftId;
+    using TimestampLib for Timestamp;
+    using UFixedLib for UFixed;
+    using FeeLib for Fee;
+    using ReferralLib for ReferralId;
 
     address internal _registryAddress;
     
@@ -46,12 +63,11 @@ contract DistributionService is
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
         // TODO while DistributionService is not deployed in DistributionServiceManager constructor
         //      owner is DistributionServiceManager deployer
-        _initializeService(registryAddress, owner);
-
-        _registerInterface(type(IDistributionService).interfaceId);
+        initializeService(registryAddress, address(0), owner);
+        registerInterface(type(IDistributionService).interfaceId);
     }
 
-    function getDomain() public pure override(Service, IService) returns(ObjectType) {
+    function getDomain() public pure override returns(ObjectType) {
         return DISTRIBUTION();
     }
 
@@ -74,33 +90,259 @@ contract DistributionService is
         distribution.linkToRegisteredNftId();
         distributionNftId = distributionInfo.nftId;
 
-        instance.createDistributionSetup(distributionNftId, distribution.getSetupInfo());
-        getInstanceService().createGifTarget(instanceNftId, distributionAddress, distribution.getName());
-        getInstanceService().grantDistributionDefaultPermissions(instanceNftId, distributionAddress, distribution.getName());
-    }
+        instance.getInstanceStore().createDistributionSetup(distributionNftId, distribution.getSetupInfo());
+        // TODO move to distribution?
+        bytes4[][] memory selectors = new bytes4[][](2);
+        selectors[0] = new bytes4[](1);
+        selectors[1] = new bytes4[](2);
 
-    function _decodeAndVerifyDistributionData(bytes memory data)
-        internal 
-        returns(string memory name)
-    {
-        (name) = abi.decode(data, (string));
+        selectors[0][0] = IDistributionComponent.setFees.selector;
+        selectors[1][0] = IDistributionComponent.processRenewal.selector;
+
+        RoleId[] memory roles = new RoleId[](2);
+        roles[0] = DISTRIBUTION_OWNER_ROLE();
+        roles[1] = PRODUCT_SERVICE_ROLE();
 
-        // TODO add checks if applicable 
+        getInstanceService().createGifTarget(
+            instanceNftId, 
+            distributionAddress, 
+            distribution.getName(), 
+            selectors, 
+            roles);
     }
 
     function setFees(
+        Fee memory minDistributionOwnerFee,
         Fee memory distributionFee
     )
         external
         override
     {
-        (IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        if (minDistributionOwnerFee.fractionalFee > distributionFee.fractionalFee) {
+            revert ErrorIDistributionServiceMinFeeTooHigh(minDistributionOwnerFee.fractionalFee.toInt(), distributionFee.fractionalFee.toInt());
+        }
+
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
         InstanceReader instanceReader = instance.getInstanceReader();
-        NftId distributionNftId = info.nftId;
 
         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(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        uint32 maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        external
+        returns (DistributorType distributorType)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
+
+        {
+            ISetup.DistributionSetupInfo memory setupInfo = instance.getInstanceReader().getDistributionSetupInfo(distributionNftId);
+            UFixed variableFeesPartsTotal = setupInfo.minDistributionOwnerFee.fractionalFee.add(commissionPercentage);
+            UFixed maxDiscountPercentageLimit = setupInfo.distributionFee.fractionalFee.sub(variableFeesPartsTotal);
+            if (maxDiscountPercentage.gt(maxDiscountPercentageLimit)) {
+                revert ErrorIDistributionServiceMaxDiscountTooHigh(maxDiscountPercentage.toInt(), maxDiscountPercentageLimit.toInt());
+            }
+        }
+
+        distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
+        IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
+            name,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+
+        instance.getInstanceStore().createDistributorType(distributorType, info);
+    }
+
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external 
+        virtual
+        returns (NftId distributorNftId)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
+
+        distributorNftId = getRegistryService().registerDistributor(
+            IRegistry.ObjectInfo(
+                zeroNftId(), 
+                distributionNftId,
+                DISTRIBUTOR(),
+                true, // intercepting property for bundles is defined on pool
+                address(0),
+                distributor,
+                ""
+            ));
+
+        IDistribution.DistributorInfo memory info = IDistribution.DistributorInfo(
+            distributorType,
+            true, // active
+            data,
+            AmountLib.zero(),
+            0);
+
+        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 createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        virtual
+        returns (ReferralId referralId)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(DISTRIBUTION());
+
+        if (bytes(code).length == 0) {
+            revert ErrorIDistributionServiceInvalidReferral(code);
+        }
+        if (expiryAt.eqz()) {
+            revert ErrorIDistributionServiceExpirationInvalid(expiryAt);
+        }
+
+        InstanceReader instanceReader = instance.getInstanceReader();
+        DistributorType distributorType = instanceReader.getDistributorInfo(distributorNftId).distributorType;
+        IDistribution.DistributorTypeInfo memory distributorTypeData = instanceReader.getDistributorTypeInfo(distributorType);
+
+        if (distributorTypeData.maxReferralCount < maxReferrals) {
+            revert ErrorIDistributionServiceMaxReferralsExceeded(distributorTypeData.maxReferralCount);
+        }
+        if (distributorTypeData.minDiscountPercentage > discountPercentage) {
+            revert ErrorIDistributionServiceDiscountTooLow(distributorTypeData.minDiscountPercentage.toInt(), discountPercentage.toInt());
+        }
+        if (distributorTypeData.maxDiscountPercentage < discountPercentage) {
+            revert ErrorIDistributionServiceDiscountTooHigh(distributorTypeData.maxDiscountPercentage.toInt(), discountPercentage.toInt());
+        }
+        if (expiryAt.toInt() - TimestampLib.blockTimestamp().toInt() > distributorTypeData.maxReferralLifetime) {
+            revert ErrorIDistributionServiceExpiryTooLong(distributorTypeData.maxReferralLifetime, expiryAt.toInt());
+        }
+
+        referralId = ReferralLib.toReferralId(distributionNftId, code);
+        IDistribution.ReferralInfo memory info = IDistribution.ReferralInfo(
+            distributorNftId,
+            code,
+            discountPercentage,
+            maxReferrals,
+            0, // used referrals
+            expiryAt,
+            data
+        );
+
+        instance.getInstanceStore().createReferral(referralId, info);
+        return referralId;
+    }
+
+    function processSale(
+        NftId distributionNftId, // assume always of distribution type
+        ReferralId referralId,
+        IPolicy.Premium memory premium,
+        Amount transferredDistributionFeeAmount
+    )
+        external
+        virtual
+    {
+        bool isReferral = ! referralId.eqz();
+        bool referralValid = referralIsValid(distributionNftId, referralId);
+
+        if (isReferral && ! referralValid) {
+            revert ErrorIDistributionServiceReferralInvalid(distributionNftId, referralId);
+        }
+
+        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);
+        
+        Amount distributionOwnerFee = AmountLib.toAmount(premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount);
+        Amount commissionAmount = AmountLib.toAmount(premium.commissionAmount);
+
+        if (!(transferredDistributionFeeAmount == distributionOwnerFee + commissionAmount)) {
+            revert ErrorDistributionServiceInvalidFeeTransferred(transferredDistributionFeeAmount, distributionOwnerFee + commissionAmount);
+        }
+
+
+        if (distributionOwnerFee.gtz()) {
+            setupInfo.sumDistributionOwnerFees += distributionOwnerFee.toInt();
+            store.updateDistributionSetup(distributionNftId, setupInfo, KEEP_STATE());
+        }
+
+        if (isReferral) {
+            referralInfo.usedReferrals += 1;
+            store.updateReferral(referralId, referralInfo, KEEP_STATE());
+
+            if (commissionAmount.gtz()) {
+                distributorInfo.commissionAmount = distributorInfo.commissionAmount + commissionAmount;
+                distributorInfo.numPoliciesSold += 1;
+                store.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
+            }
+        }
+    }
+
+    // TODO: zero should return false
+    function referralIsValid(NftId distributionNftId, ReferralId referralId) public view returns (bool isValid) {
+        IInstance instance = _getInstanceForDistribution(distributionNftId);
+        IDistribution.ReferralInfo memory info = instance.getInstanceReader().getReferralInfo(referralId);
+
+        if (info.distributorNftId.eqz()) {
+            return false;
+        }
+
+        isValid = info.expiryAt.eqz() || (info.expiryAt.gtz() && TimestampLib.blockTimestamp() <= info.expiryAt);
+        isValid = isValid && info.usedReferrals < info.maxReferrals;
+    }
+
+    function _getInstanceForDistribution(NftId distributionNftId)
+        internal
+        view
+        returns(IInstance instance)
+    {
+        NftId instanceNftId = getRegistry().getObjectInfo(distributionNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
     }
-}
+}

package/contracts/instance/service/DistributionServiceManager.sol

@@ -16,7 +16,7 @@ contract DistributionServiceManager is ProxyManager {
     constructor(
         address registryAddress
     )
-        ProxyManager()
+        ProxyManager(registryAddress)
     {
         DistributionService distSrv = new DistributionService();
         bytes memory data = abi.encode(registryAddress, address(this));

package/contracts/instance/service/IApplicationService.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../../types/Seconds.sol";
+
+/// @dev gif service responsible for creating applications
+/// only product components may call transaction functions
+interface IApplicationService is IService {
+    
+    error ErrorApplicationServiceNotProduct(NftId callerNftId, ObjectType callerType);
+    error ErrorApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+
+    /// @dev creates a new application based on the specified attributes
+    /// may only be called by a product component
+    function create(
+        address applicationOwner,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    ) external returns (NftId applicationNftId);
+
+    /// @dev updates application attributes
+    /// may only be called while the application is in applied state
+    /// may only be called by the referenced product related to applicationNftId
+    function adjust(
+        NftId applicationNftId,
+        RiskId riskId,
+        NftId bundleNftId,
+        ReferralId referralId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData
+    ) external;
+
+    /// @dev creates a new application that extends the provided policy
+    /// lifetime will seamlessly extend referenced policy, for closed policies
+    /// lifetime will start at underwriting time
+    /// product will need to limit the time window for renewal as underwriting
+    /// will lock the collateral at underwriting time which might be earlier than activation time
+    /// policyNftId needs to refer to an underwritten (or active or closed) policy
+    /// may only be called by the referenced product related to policyNftId
+    function renew(
+        NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
+        NftId bundleNftId // will likely need a newer bundle for underwriting
+    ) external returns (NftId applicationNftId);
+
+    /// @dev revokes the application represented by {policyNftId}
+    /// an application can only be revoked in applied state
+    /// only the application holder may revoke an application
+    function revoke(NftId policyNftId) external;
+}

package/contracts/instance/service/IBundleService.sol

@@ -1,44 +1,118 @@
 // 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 {StateId} from "../../types/StateId.sol";
 import {IService} from "../../shared/IService.sol";
 import {IBundle} from "../module/IBundle.sol";
 import {IInstance} from "../../instance/IInstance.sol";
+import {Seconds} from "../../types/Seconds.sol";
+import {StateId} from "../../types/StateId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IBundleService is IService {
-    error ErrorIBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
 
-    function createBundle(
-        address owner,
-        Fee memory fee, 
-        uint256 amount,
-        uint256 lifetime, 
-        bytes calldata filter
-    ) external returns(NftId bundleNftId);
+    event LogBundleServiceBundleActivated(NftId bundleNftId);
+    event LogBundleServiceBundleLocked(NftId bundleNftId);
 
-    function setBundleFee(
-        NftId bundleNftId,
-        Fee memory fee
-    ) external;
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, Amount amount);
+    error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
+    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, Amount capacityAmount, Amount collateralAmount);
+    error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
+
+    error ErrorBundleServiceBundleUnknown(NftId bundleNftId);
+    error ErrorBundleServiceBundlePoolMismatch(NftId bundleNftId, NftId expectedPool, NftId actualPool);
 
-    function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
+    error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
 
-    function underwritePolicy(IInstance instanceNftId, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount, uint256 netPremium) external;
+    /// @dev create a new bundle for the specified attributes
+    /// may only be called by pool service
+    function create(
+        IInstance instance, // instance relevant for bundle
+        NftId poolNftId, // the pool the bundle will be linked to
+        address owner, // initial bundle owner
+        Fee memory fee, // fees deducted from premium that go to bundle owner
+        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
+        Seconds lifetime, // initial duration for which new policies are covered
+        bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
+    )
+        external 
+        returns(NftId bundleNftId); // the nft id of the newly created bundle
 
-    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
 
-    function closePolicy(IInstance instance, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount) external;
+    /// @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 fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
-    // function defundBundle(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
+    function lock(NftId bundleNftId) external;
 
-    function lockBundle(NftId bundleNftId) external;
+    /// @dev activates the specified bundle
+    /// only locked bundles may be unlocked
+    /// may only be called by registered and unlocked pool components
+    function unlock(NftId bundleNftId) external;
 
-    function unlockBundle(NftId bundleNftId) external;
+    /// @dev closes the specified bundle
+    /// only open bundles (active or locked) may be closed
+    /// to close a bundle it may not have any non-closed polices attached to it
+    /// may only be called by registered and unlocked pool components
+    function close(
+        IInstance instance, 
+        NftId bundleNftId
+    ) external;
+
+    /// @dev set bundle fee to provided value
+    /// may only be called by registered and unlocked pool components
+    function setFee(
+        NftId bundleNftId,
+        Fee memory fee
+    ) external;
+
+
+    /// @dev locks the specified collateral in the bundle
+    /// the locked collateral is added to the bundle locked capital
+    /// the bundles' fees are updated with the fees for this premium
+    /// the premium (minus bundle fee) is added to the bundle capital
+    /// may only be called by pool service
+    function lockCollateral(
+        IInstance instanceNftId, 
+        NftId policyNftId, 
+        NftId bundleNftId, 
+        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, 
+        Amount collateralAmount
+    ) 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;
+
+    /// @dev updates the bundle's fees of with the provided fee amount
+    function updateBundleFees(
+        IInstance instance,
+        NftId bundleNftId,
+        Amount feeAmount
+    ) external;
 
-    // function closeBundle(NftId bundleNftId) external;
+    function increaseBalance(
+        IInstance instance, 
+        NftId bundleNftId,  
+        Amount amount) external;
 }

package/contracts/instance/service/IClaimService.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IInstance} from "../IInstance.sol";
+import {InstanceReader} from "../InstanceReader.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {Amount} from "../../types/Amount.sol";
+import {ClaimId} from "../../types/ClaimId.sol";
+import {PayoutId} from "../../types/PayoutId.sol";
+import {NftId} from "../../types/NftId.sol";
+import {StateId} from "../../types/StateId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {Fee} from "../../types/Fee.sol";
+
+/// @dev gif service responsible for creating claims and payouts
+/// only product components may call transaction functions
+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(
+        NftId policyNftId, 
+        Amount claimAmount,
+        bytes memory claimData
+    ) external returns (ClaimId claimId);
+
+    /// @dev declines the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function decline(
+        NftId policyNftId, 
+        ClaimId claimId) external;
+
+    /// @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 confirm(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount
+    ) external;
+
+    /// @dev closes the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function close(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external;
+
+
+    /// @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(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        bytes memory data
+    )
+        external
+        returns (PayoutId payoutId);
+
+
+    /// @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(
+        NftId policyNftId, 
+        PayoutId payoutId
+    ) external;
+}