@etherisc/gif-next 0.0.2-e6ad61d-739 → 0.0.2-e769e2e-077

package/contracts/distribution/IDistributionComponent.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Fee} from "../type/Fee.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {ReferralId, ReferralStatus} from "../type/Referral.sol";
+import {NftId} from "../type/NftId.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IDistributionComponent is IInstanceLinkedComponent {
+
+    event LogDistributorUpdated(address to, address caller);
+
+    function setFees(
+        Fee memory distributionFee,
+        Fee memory minDistributionOwnerFee
+    ) 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 calculateRenewalFeeAmount(
+        ReferralId referralId,
+        uint256 netPremiumAmount
+    ) external view returns (uint256 feeAmount);
+
+    /// @dev callback from product service when a policy is renews for a specific referralId
+    function processRenewal(
+        ReferralId referralId,
+        uint256 feeAmount
+    ) external;
+
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
+
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
+
+    /// @dev returns true iff the component needs to be called when selling/renewing policis
+    function isVerifying() external view returns (bool verifying);
+}

package/contracts/distribution/IDistributionService.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {Fee} from "../type/Fee.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IDistributionService is IService {
+    error ErrorDistributionServiceCallerNotRegistered(address caller);
+    error ErrorIDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
+    error ErrorIDistributionServiceCallerNotDistributor(address caller);
+    error ErrorIDistributionServiceInvalidReferralId(ReferralId referralId);
+    error ErrorIDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
+    error ErrorIDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
+    error ErrorIDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
+    error ErrorIDistributionServiceExpiryTooLong(uint256 maxReferralLifetime, uint256 expiryAt);
+    error ErrorIDistributionServiceInvalidReferral(string code);
+    error ErrorIDistributionServiceExpirationInvalid(Timestamp expiryAt);
+    error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
+    error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
+    error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
+    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
+
+    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);
+
+    // TODO re-enable and reorganize (service contract too large)
+    // 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(
+        NftId distributionNftId,
+        ReferralId referralId,
+        IPolicy.Premium memory premium
+    ) external;
+
+    function referralIsValid(
+        NftId distributorNftId,
+        ReferralId referralId
+    ) external view returns (bool isValid);
+}

package/contracts/instance/BundleManager.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInstance} from "./IInstance.sol";
+import {INSTANCE} from "../type/ObjectType.sol";
+import {InstanceReader} from "./InstanceReader.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId} from "../type/NftId.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+
+import {ObjectManager} from "./base/ObjectManager.sol";
+
+contract BundleManager is 
+    ObjectManager
+{
+
+    event LogBundleManagerPolicyLinked(NftId bundleNftId, NftId policyNftId);
+    event LogBundleManagerPolicyUnlinked(NftId bundleNftId, NftId policyNftId);
+
+    event LogBundleManagerBundleAdded(NftId poolNftId, NftId bundleNftId);
+    event LogBundleManagerBundleUnlocked(NftId poolNftId, NftId bundleNftId);
+    event LogBundleManagerBundleLocked(NftId poolNftId, NftId bundleNftId);
+    event LogBundleManagerBundleClosed(NftId poolNftId, NftId bundleNftId);
+
+    error ErrorBundleManagerPolicyAlreadyActivated(NftId policyNftId);
+    error ErrorBundleManagerBundleLocked(NftId bundleNftId, NftId policyNftId);
+    error ErrorBundleManagerPolicyWithOpenClaims(NftId policyNftId, uint256 openClaimsCount);
+    error ErrorBundleManagerPolicyNotCloseable(NftId policyNftId);
+    error ErrorBundleManagerBundleUnknown(NftId bundleNftId);
+    error ErrorBundleManagerBundleNotRegistered(NftId bundleNftId);
+
+    mapping(NftId bundleNftId => LibNftIdSet.Set policies) internal _activePolicies;
+
+    /// @dev links a policy to its bundle
+    // to link a policy it MUST NOT yet have been linked
+    function linkPolicy(NftId policyNftId) external restricted() {
+        NftId bundleNftId = _instance.getInstanceReader().getPolicyInfo(policyNftId).bundleNftId;
+        // decision will likely depend on the decision what to check here and what in the service
+        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+
+        // ensure bundle is unlocked (in active set) and registered with this instance
+        if (!_isActive(poolNftId, bundleNftId)) {
+            revert ErrorBundleManagerBundleLocked(bundleNftId, policyNftId);
+        }
+
+        LibNftIdSet.add(_activePolicies[bundleNftId], policyNftId);
+        emit LogBundleManagerPolicyLinked(bundleNftId, policyNftId);
+    }
+
+
+    /// @dev unlinks a policy from its bundle
+    // to unlink a policy it must closable, ie. meet one of the following criterias
+    // - the policy MUST be past its expiry period and it MUST NOT have any open claims
+    // - the policy's payoutAmount MUST be equal to its sumInsuredAmount and MUST NOT have any open claims
+    function unlinkPolicy(NftId policyNftId) external restricted() {
+        IPolicy.PolicyInfo memory policyInfo = _instance.getInstanceReader().getPolicyInfo(policyNftId);
+
+        NftId bundleNftId = policyInfo.bundleNftId;
+        // decision will likely depend on the decision what to check here and what in the service
+        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+
+        // ensure bundle is registered with this instance
+        if (!_contains(poolNftId, bundleNftId)) {
+            revert ErrorBundleManagerBundleUnknown(bundleNftId);
+        }
+
+        LibNftIdSet.remove(_activePolicies[bundleNftId], policyNftId);
+        emit LogBundleManagerPolicyUnlinked(policyInfo.bundleNftId, policyNftId);
+    }
+
+
+    /// @dev add a new bundle to a pool registerd with this instance
+    // the corresponding pool is fetched via instance reader
+    function add(NftId bundleNftId) external restricted() {
+        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+
+        // ensure pool is registered with instance
+        if(poolNftId.eqz()) {
+            revert ErrorBundleManagerBundleNotRegistered(bundleNftId);
+        }
+
+        _add(poolNftId, bundleNftId);
+        emit LogBundleManagerBundleAdded(poolNftId, bundleNftId);
+    }
+
+
+    /// @dev unlocked (active) bundles are available to collateralize new policies
+    function unlock(NftId bundleNftId) external restricted() {
+        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        _activate(poolNftId, bundleNftId);
+        emit LogBundleManagerBundleUnlocked(poolNftId, bundleNftId);
+    }
+
+    /// @dev locked (deactivated) bundles may not collateralize any new policies
+    function lock(NftId bundleNftId) external restricted() {
+        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        _deactivate(poolNftId, bundleNftId);
+        emit LogBundleManagerBundleLocked(poolNftId, bundleNftId);
+    }
+
+    function bundles(NftId poolNftId) external view returns(uint256) {
+        return _objects(poolNftId);
+    }
+
+    function getBundleNftId(NftId poolNftId, uint256 idx) external view returns(NftId bundleNftId) {
+        return _getObject(poolNftId, idx);
+    }
+
+    function activeBundles(NftId poolNftId) external view returns(uint256) {
+        return _activeObjs(poolNftId);
+    }
+
+    function getActiveBundleNftId(NftId poolNftId, uint256 idx) external view returns(NftId bundleNftId) {
+        return _getActiveObject(poolNftId, idx);
+    }
+
+    function activePolicies(NftId bundleNftId) external view returns(uint256) {
+        return LibNftIdSet.size(_activePolicies[bundleNftId]);
+    }
+
+    function getActivePolicy(NftId bundleNftId, uint256 idx) external view returns(NftId policyNftId) {
+        return LibNftIdSet.getElementAt(_activePolicies[bundleNftId], idx);
+    }
+}

package/contracts/instance/IInstance.sol

@@ -1,25 +1,77 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {IRegisterable} from "../registry/IRegistry.sol";
-import {IAccessModule} from "./access/IAccess.sol";
-import {ILifecycleModule} from "./lifecycle/ILifecycle.sol";
-import {IComponentModule} from "./component/IComponent.sol";
-import {IProductModule} from "./product/IProductService.sol";
-import {IPolicyModule} from "./policy/IPolicy.sol";
-import {IPoolModule} from "./pool/IPoolModule.sol";
-import {ITreasuryModule} from "./treasury/ITreasury.sol";
-
-// solhint-disable-next-line no-empty-blocks
-interface IInstance is
-    IRegisterable,
-    IAccessModule,
-    ILifecycleModule,
-    IPolicyModule,
-    IPoolModule,
-    IComponentModule,
-    IProductModule,
-    ITreasuryModule
+pragma solidity ^0.8.20;
+
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {ClaimId} from "../type/ClaimId.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {NftId} from "../type/NftId.sol";
+import {StateId} from "../type/StateId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {VersionPart} from "../type/Version.sol";
+import {Key32} from "../type/Key32.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+import {IRegisterable} from "../shared/IRegisterable.sol";
+
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+
+import {InstanceAccessManager} from "./InstanceAccessManager.sol";
+import {BundleManager} from "./BundleManager.sol";
+import {InstanceReader} from "./InstanceReader.sol";
+import {InstanceStore} from "./InstanceStore.sol";
+
+import {IKeyValueStore} from "../shared/IKeyValueStore.sol";
+
+import {IAccess} from "./module/IAccess.sol";
+
+import {IBundleService} from "../pool/IBundleService.sol";
+import {IDistributionService} from "../distribution/IDistributionService.sol";
+import {IPolicyService} from "../product/IPolicyService.sol";
+import {IPoolService} from "../pool/IPoolService.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicyService} from "../product/IPolicyService.sol";
+import {IBundleService} from "../pool/IBundleService.sol";
+
+
+
+interface IInstance is 
+    IRegisterable, 
+    ITransferInterceptor, 
+    IAccessManaged
 {
+    error ErrorInstanceInstanceAccessManagerZero();
+    error ErrorInstanceInstanceAccessManagerAlreadySet(address instanceAccessManager);
+    error ErrorInstanceInstanceAccessManagerAuthorityMismatch(address instanceAuthority);
+
+    error ErrorInstanceBundleManagerAlreadySet(address instanceBundleManager);
+    error ErrorInstanceBundleManagerInstanceMismatch(address instance);
+    error ErrorInstanceBundleManagerAuthorityMismatch(address instanceAuthority);
+
+    error ErrorInstanceInstanceReaderInstanceMismatch(address instanceAuthority);
+
+    error ErrorInstanceInstanceStoreAlreadySet(address instanceStore);
+    error ErrorInstanceInstanceStoreAuthorityMismatch(address instanceAuthority);
+
+    function createRole(string memory roleName, string memory adminName) external returns (RoleId roleId, RoleId admin);
+    function grantRole(RoleId roleId, address account) external;
+    function revokeRole(RoleId roleId, address account) external;
+
+    function createTarget(address target, string memory name) external;
+    function setTargetFunctionRole(string memory targetName, bytes4[] calldata selectors, RoleId roleId) external;
+    function setTargetLocked(address target, bool locked) external;
+
+    function getDistributionService() external view returns (IDistributionService);
+    function getProductService() external view returns (IProductService);
+    function getPoolService() external view returns (IPoolService);
+    function getPolicyService() external view returns (IPolicyService);
+    function getBundleService() external view returns (IBundleService);
 
-}
+    function getMajorVersion() external pure returns (VersionPart majorVersion);
+    function getInstanceReader() external view returns (InstanceReader);
+    function getBundleManager() external view returns (BundleManager);
+    function getInstanceAccessManager() external view returns (InstanceAccessManager);
+    function getInstanceStore() external view returns (InstanceStore);
+}

package/contracts/instance/IInstanceService.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {IService} from "../shared/IService.sol";
+
+import {AccessManagerUpgradeableInitializeable} from "../shared/AccessManagerUpgradeableInitializeable.sol";
+import {InstanceAccessManager} from "./InstanceAccessManager.sol";
+import {Instance} from "./Instance.sol";
+import {InstanceReader} from "./InstanceReader.sol";
+import {BundleManager} from "./BundleManager.sol";
+import {InstanceStore} from "./InstanceStore.sol";
+
+interface IInstanceService is IService {
+
+    error ErrorInstanceServiceComponentNotInstanceLinked(address component);
+
+    error ErrorInstanceServiceMasterInstanceAlreadySet();
+    error ErrorInstanceServiceMasterOzAccessManagerAlreadySet();
+    error ErrorInstanceServiceMasterInstanceAccessManagerAlreadySet();
+    error ErrorInstanceServiceMasterBundleManagerAlreadySet();
+    error ErrorInstanceServiceInstanceAddressZero();
+
+    error ErrorInstanceServiceMasterInstanceReaderNotSet();
+    error ErrorInstanceServiceInstanceReaderAddressZero();
+    error ErrorInstanceServiceInstanceReaderSameAsMasterInstanceReader();
+    error ErrorInstanceServiceInstanceReaderInstanceMismatch();
+
+    error ErrorInstanceServiceInstanceAccessManagerZero();
+    error ErrorInstanceServiceInstanceReaderZero();
+    error ErrorInstanceServiceBundleManagerZero();
+    error ErrorInstanceServiceInstanceStoreZero();
+
+    error ErrorInstanceServiceInstanceAuthorityMismatch();
+    error ErrorInstanceServiceBundleManagerAuthorityMismatch();
+    error ErrorInstanceServiceInstanceReaderInstanceMismatch2();
+    error ErrorInstanceServiceBundleMangerInstanceMismatch();
+    error ErrorInstanceServiceInstanceStoreAuthorityMismatch();
+
+    error ErrorInstanceServiceRequestUnauhorized(address caller);
+    error ErrorInstanceServiceNotInstanceOwner(address caller, NftId instanceNftId);
+    error ErrorInstanceServiceNotInstance(NftId nftId);
+    error ErrorInstanceServiceComponentNotRegistered(address componentAddress);
+    error ErrorInstanceServiceInstanceComponentMismatch(NftId instanceNftId, NftId componentNftId);
+    error ErrorInstanceServiceInvalidComponentType(address componentAddress, ObjectType expectedType, ObjectType componentType);
+    
+    event LogInstanceCloned(
+        address clonedOzAccessManager,
+        address clonedInstanceAccessManager,
+        address clonedInstance,
+        address clonedInstanceStore,
+        address clonedBundleManager, 
+        address clonedInstanceReader, 
+        NftId clonedInstanceNftId
+    );
+
+    function createInstanceClone()
+        external 
+        returns (
+            Instance clonedInstance,
+            NftId instanceNftId
+        );
+
+    function createComponentTarget(
+        NftId instanceNftId,
+        address targetAddress,
+        string memory targetName,
+        bytes4[][] memory selectors,
+        RoleId[] memory roles
+    ) external;
+
+    function createGifTarget(
+        NftId instanceNftId,
+        address targetAddress,
+        string memory targetName,
+        bytes4[][] memory selectors,
+        RoleId[] memory roles
+    ) external;
+
+    function setComponentLocked(bool locked) external;
+}