@etherisc/gif-next 0.0.2-7631288 → 0.0.2-770fd3b-604

package/contracts/instance/service/DistributionService.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+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 {NftId, NftIdLib} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {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 {Version, VersionLib} from "../../types/Version.sol";
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+
+import {IService} from "../../shared/IService.sol";
+import {Service} from "../../shared/Service.sol";
+import {ComponentService} from "../base/ComponentService.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {IComponent} from "../../components/IComponent.sol";
+import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+
+import {UFixed} 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";
+
+
+contract DistributionService is
+    ComponentService,
+    IDistributionService
+{
+    using NftIdLib for NftId;
+
+    address internal _registryAddress;
+    
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address initialOwner;
+        address registryAddress;
+        (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);
+    }
+
+    function getDomain() public pure override(Service, IService) returns(ObjectType) {
+        return DISTRIBUTION();
+    }
+
+    function register(address distributionAddress) 
+        external
+        returns(NftId distributionNftId)
+    {
+        (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        ) = _checkComponentForRegistration(
+            distributionAddress,
+            DISTRIBUTION(),
+            DISTRIBUTION_OWNER_ROLE());
+
+        IRegistry.ObjectInfo memory distributionInfo = getRegistryService().registerDistribution(component, owner);
+        IDistributionComponent distribution = IDistributionComponent(distributionAddress);
+        distribution.linkToRegisteredNftId();
+        distributionNftId = distributionInfo.nftId;
+
+        instance.createDistributionSetup(distributionNftId, distribution.getSetupInfo());
+        getInstanceService().createGifTarget(instanceNftId, distributionAddress, distribution.getName());
+        getInstanceService().grantDistributionDefaultPermissions(instanceNftId, distributionAddress, distribution.getName());
+    }
+
+    function setFees(
+        Fee memory distributionFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId distributionNftId = info.nftId;
+
+        ISetup.DistributionSetupInfo memory distSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
+        distSetupInfo.distributionFee = distributionFee;
+        
+        instance.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) = _getAndVerifyCallingDistribution();
+        distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
+        Key32 key32 = distributorType.toKey32();
+
+        if(!instance.exists(key32)) {
+            IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
+                name,
+                minDiscountPercentage,
+                maxDiscountPercentage,
+                commissionPercentage,
+                maxReferralCount,
+                maxReferralLifetime,
+                allowSelfReferrals,
+                allowRenewals,
+                data);
+
+            instance.createDistributorType(key32, info);
+        }
+    }
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    ) external returns (NftId distributorNftId)
+    {
+        (, NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+
+        // FIXME: add this function
+        // distributorNftId = _registryService.registerDistributor(
+        //     distributionNftId,
+        //     DISTRIBUTOR(),
+        //     true, // distribution module is intercepting
+        //     distributor,
+        //     "");
+
+        IDistribution.DistributorInfo memory info = IDistribution.DistributorInfo(
+            distributorType,
+            true, // active
+            data);
+
+        instance.createDistributor(distributorNftId, info);
+    }
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external virtual
+    {
+        (,, IInstance instance) = _getAndVerifyCallingDistribution();
+
+        IDistribution.DistributorInfo memory info = IDistribution.DistributorInfo(
+            distributorType,
+            true, // active
+            data);
+
+        instance.updateDistributor(distributorNftId, info, 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) = _getAndVerifyCallingDistribution();
+        require(bytes(code).length > 0, "ERROR:DSV-030:CODE_INVALID");
+        require(expiryAt > zeroTimestamp(), "ERROR:DSV-031:EXPIRY_AT_ZERO");
+
+        referralId = ReferralLib.toReferralId(distributionNftId, code);
+        IDistribution.ReferralInfo memory info = IDistribution.ReferralInfo(
+            distributorNftId,
+            code,
+            discountPercentage,
+            maxReferrals,
+            0, // used referrals
+            expiryAt,
+            data
+        );
+
+        instance.createReferral(referralId.toKey32(), info);
+        return referralId;
+    }
+
+    function processSale(
+        ReferralId referralId,
+        uint256 premiumAmount
+    )
+        external
+        virtual
+    {
+        revert("NOT_IMPLEMENTED_YET");
+    }
+
+    function calculateFeeAmount(
+        ReferralId referralId,
+        uint256 premiumAmount
+    )
+        external
+        virtual
+        view 
+        returns (uint256 feeAmount)
+    {
+        revert("NOT_IMPLEMENTED_YET");
+    }
+
+    function _getAndVerifyCallingDistribution()
+        internal
+        view
+        returns(
+            address distributionAddress,
+            NftId distributionNftId,
+            IInstance instance
+        )
+    {
+        ObjectType objectType;
+        (
+            distributionAddress,
+            distributionNftId,
+            objectType,
+            instance
+        ) = _getAndVerifyCaller();
+
+        require(objectType == DISTRIBUTION(), "ERROR:PRS-031:CALLER_NOT_DISTRUBUTION");
+    }
+
+    function _getAndVerifyCaller()
+        internal
+        view
+        returns(
+            address objectAddress,
+            NftId objectNftId,
+            ObjectType objectType,
+            IInstance instance
+        )
+    {
+        objectAddress = msg.sender;
+        objectNftId = getRegistry().getNftId(objectAddress);
+        require(objectNftId.gtz(), "ERROR:SRV-030:CALLER_UNKNOWN");
+        IRegistry.ObjectInfo memory info = getRegistry().getObjectInfo(objectNftId);
+        objectType = info.objectType;
+
+        IRegistry.ObjectInfo memory parentInfo = getRegistry().getObjectInfo(info.parentNftId);
+        require(parentInfo.objectType == INSTANCE(), "ERROR:SRV-031:PARENT_NOT_INSTANCE");
+        instance = IInstance(parentInfo.objectAddress);
+    }
+
+}

package/contracts/instance/service/DistributionServiceManager.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {ProxyManager} from "../../shared/ProxyManager.sol";
+import {DistributionService} from "./DistributionService.sol";
+import {Registry} from "../../registry/Registry.sol";
+import {RegistryService} from "../../registry/RegistryService.sol";
+import {REGISTRY} from "../../types/ObjectType.sol";
+
+contract DistributionServiceManager is ProxyManager {
+
+    DistributionService private _distributionService;
+
+    /// @dev initializes proxy manager with distribution service implementation and deploys instance
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        DistributionService distSrv = new DistributionService();
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(distSrv), 
+            data);
+
+        _distributionService = DistributionService(address(versionable));
+        
+        // TODO `thi` must have a role or own nft to register service
+        //Registry registry = Registry(registryAddress);
+        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), _distributionService.getMajorVersion());
+        //RegistryService registryService = RegistryService(registryServiceAddress);
+        //registryService.registerService(_distributionService);
+        
+        // TODO no nft to link yet
+        // link ownership of instance service manager ot nft owner of instance service
+        //_linkToNftOwnable(
+        //    address(registryAddress),
+        //    address(_distributionService));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getDistributionService()
+        external
+        view
+        returns (DistributionService distributionService)
+    {
+        return _distributionService;
+    }
+
+}

package/contracts/instance/service/IApplicationService.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.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 applications
+/// only product components may call transaction functions
+interface IApplicationService is IService {
+    
+    error IApplicationServicePolicyNotApplied(NftId applicationNftId);
+
+    /// @dev creates a new application based on the specified attributes
+    /// may only be called by a product component
+    function create(
+        address applicationOwner,
+        RiskId riskId,
+        NftId bundleNftId,
+        ReferralId referralId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        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 ajust(
+        NftId applicationNftId,
+        RiskId riskId,
+        NftId bundleNftId,
+        ReferralId referralId,
+        uint256 sumInsuredAmount,
+        uint256 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;
+
+    /// @dev calculates the premium amount for the specified attributes
+    /// also returns the various fee components involved with creating a policy
+    function calculatePremium(
+        RiskId riskId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (
+            uint256 premiumAmount,
+            uint256 distributionFeeAmount,
+            uint256 productFeeAmount,
+            uint256 poolFeeAmount,
+            uint256 bundleFeeAmount
+        );
+}

package/contracts/instance/service/IBundleService.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+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";
+
+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);
+
+    function setBundleFee(
+        NftId bundleNftId,
+        Fee memory fee
+    ) external;
+
+    function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
+
+    function lockCollateral(
+        IInstance instanceNftId, 
+        NftId policyNftId, 
+        NftId bundleNftId, 
+        uint256 collateralAmount, 
+        uint256 netPremium
+    )
+        external
+        returns (
+            IBundle.BundleInfo memory bundleInfo
+        );
+
+    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
+
+    function closePolicy(IInstance instance, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount) external;
+
+    // function fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+    // function defundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+    function lockBundle(NftId bundleNftId) external;
+
+    function unlockBundle(NftId bundleNftId) external;
+
+    // function closeBundle(NftId bundleNftId) external;
+}

package/contracts/instance/service/IDistributionService.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {IService} from "../../shared/IService.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {DistributorType} from "../../types/DistributorType.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+
+
+interface IDistributionService is IService {
+    function setFees(
+        Fee memory distributionFee
+    ) external;
+    
+    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);
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    ) external returns (NftId distributorNftId);
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
+
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        returns (ReferralId referralId);
+
+    /// @dev callback from product service when selling a policy for a specific referralId
+    function processSale(
+        ReferralId referralId,
+        uint256 premiumAmount
+    ) external;
+
+    function calculateFeeAmount(
+        ReferralId referralId,
+        uint256 premiumAmount
+    ) external view returns (uint256 feeAmount);
+}

package/contracts/instance/service/IPolicyService.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.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";
+
+interface IPolicyService is IService {
+    
+    error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
+    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorIPolicyServicePremiumNotFullyPaid(NftId policyNftId, uint256 premiumAmount, uint256 premiumPaidAmount);
+    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
+    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+    
+    function calculatePremium(
+        RiskId riskId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (
+            uint256 premiumAmount,
+            uint256 productFeeAmount,
+            uint256 poolFeeAmount,
+            uint256 bundleFeeAmount,
+            uint256 distributionFeeAmount
+        );
+
+
+    function createApplication(
+        address applicationOwner,
+        RiskId riskId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    ) external returns (NftId nftId);
+
+    /// @dev declines an application represented by {policyNftId}
+    /// an application can only be declined in applied state
+    /// only the related product may decline an application
+    function decline(NftId policyNftId) external;
+
+    /// @dev underwrites the policy represented by {policyNftId}.
+    /// optionally collects premiums and activates the policy.
+    /// - premium payment is only attempted if requirePremiumPayment is set to true
+    /// - activation is only done if activateAt is a non-zero timestamp
+    /// an application can only be underwritten in applied state
+    /// only the related product may underwrite an application
+    function underwrite(
+        NftId policyNftId,
+        bool requirePremiumPayment,
+        Timestamp activateAt
+    ) external;
+
+    function collectPremium(NftId policyNftId, Timestamp activateAt) external;
+
+    function activate(NftId policyNftId, Timestamp activateAt) external;
+
+    function close(NftId nftId) external;
+
+    // function createClaim(uint256 nftId, uint256 claimAmount) external;
+    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
+    // function declineClaim(uint256 nftId, uint256 claimId) external;
+    // function closeClaim(uint256 nftId, uint256 claimId) external; // TODO payoutClaim() -> implicit close when payed out in full
+
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        uint256 sumInsuredAmount
+    ) external pure returns(uint256 collateralAmount);
+
+}

package/contracts/instance/service/IPoolService.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+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";
+
+interface IPoolService is IService {
+
+    function register(address poolAddress) external returns(NftId);
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+}

package/contracts/instance/service/IProductService.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.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";
+
+interface IProductService is IService {
+    
+    function register(address productAddress) external returns(NftId);
+
+    function setFees(
+        Fee memory productFee,
+        Fee memory processingFee
+    ) external;
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId newState
+    ) external;
+}