@etherisc/gif-next 0.0.2-d10d6b3-916 → 0.0.2-d1f0662-893

package/contracts/instance/InstanceStore.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {Key32, KeyId, Key32Lib} from "../types/Key32.sol";
+import {NftId} from "../types/NftId.sol";
+import {ClaimId} from "../types/ClaimId.sol";
+import {NumberId} from "../types/NumberId.sol";
+import {ObjectType, BUNDLE, DISTRIBUTION, INSTANCE, POLICY, POOL, ROLE, PRODUCT, TARGET, COMPONENT, DISTRIBUTOR, DISTRIBUTOR_TYPE} from "../types/ObjectType.sol";
+import {RiskId, RiskIdLib} from "../types/RiskId.sol";
+import {RoleId, RoleIdLib, INSTANCE_ROLE, INSTANCE_OWNER_ROLE} from "../types/RoleId.sol";
+import {StateId, ACTIVE} from "../types/StateId.sol";
+import {TimestampLib} from "../types/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../types/Version.sol";
+import {ReferralId} from "../types/Referral.sol";
+import {DistributorType} from "../types/DistributorType.sol";
+import {PayoutId} from "../types/PayoutId.sol";
+
+import {IInstance} from "./IInstance.sol";
+import {KeyValueStore} from "./base/KeyValueStore.sol";
+import {IKeyValueStore} from "./base/KeyValueStore.sol";
+
+import {IBundle} from "./module/IBundle.sol";
+import {IComponents} from "./module/IComponents.sol";
+import {IDistribution} from "./module/IDistribution.sol";
+import {IPolicy} from "./module/IPolicy.sol";
+import {IRisk} from "./module/IRisk.sol";
+import {ISetup} from "./module/ISetup.sol";
+
+
+// TODO combine with instance reader?
+contract InstanceStore is AccessManagedUpgradeable, KeyValueStore
+{
+    function initialize(address instance)
+        public 
+        initializer()
+    {
+        address authority = IInstance(instance).authority();
+        __AccessManaged_init(authority);
+        initializeLifecycle();
+    }
+
+    //--- ProductSetup ------------------------------------------------------//
+    function createProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup) external restricted() {
+        create(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup));
+    }
+
+    function updateProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup, StateId newState) external restricted() {
+        update(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup), newState);
+    }
+
+    function updateProductSetupState(NftId productNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(productNftId, PRODUCT()), newState);
+    }
+
+    //--- DistributionSetup ------------------------------------------------------//
+    function createDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup) external restricted() {
+        create(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup));
+    }
+
+    function updateDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup, StateId newState) external restricted() {
+        update(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup), newState);
+    }
+
+    function updateDistributionSetupState(NftId distributionNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(distributionNftId, DISTRIBUTION()), newState);
+    }
+
+    //--- PoolSetup ------------------------------------------------------//
+    function createPoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info) external restricted() {
+        create(_toNftKey32(poolNftId, POOL()), abi.encode(info));
+    }
+
+    function updatePoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info, StateId newState) external restricted() {
+        update(_toNftKey32(poolNftId, POOL()), abi.encode(info), newState);
+    }
+
+    function updatePoolSetupState(NftId poolNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(poolNftId, POOL()), newState);
+    }
+
+    //--- DistributorType -------------------------------------------------------//
+    function createDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info) external restricted() {
+        create(distributorType.toKey32(), abi.encode(info));
+    }
+
+    function updateDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info, StateId newState) external restricted() {
+        update(distributorType.toKey32(), abi.encode(info), newState);
+    }
+
+    function updateDistributorTypeState(DistributorType distributorType, StateId newState) external restricted() {
+        updateState(distributorType.toKey32(), newState);
+    }
+
+    //--- Distributor -------------------------------------------------------//
+    function createDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info) external restricted() {
+        create(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info));
+    }
+
+    function updateDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info, StateId newState) external restricted() {
+        update(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info), newState);
+    }
+
+    function updateDistributorState(NftId distributorNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(distributorNftId, DISTRIBUTOR()), newState);
+    }
+
+    //--- Referral ----------------------------------------------------------//
+    function createReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo) external restricted() {
+        create(referralId.toKey32(), abi.encode(referralInfo));
+    }
+
+    function updateReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo, StateId newState) external restricted() {
+        update(referralId.toKey32(), abi.encode(referralInfo), newState);
+    }
+
+    function updateReferralState(ReferralId referralId, StateId newState) external restricted() {
+        updateState(referralId.toKey32(), newState);
+    }
+
+    //--- Bundle ------------------------------------------------------------//
+    function createBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle) external restricted() {
+        create(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle));
+    }
+
+    function updateBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle, StateId newState) external restricted() {
+        update(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle), newState);
+    }
+
+    function updateBundleState(NftId bundleNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(bundleNftId, BUNDLE()), newState);
+    }
+
+    //--- Risk --------------------------------------------------------------//
+    function createRisk(RiskId riskId, IRisk.RiskInfo memory risk) external restricted() {
+        create(riskId.toKey32(), abi.encode(risk));
+    }
+
+    function updateRisk(RiskId riskId, IRisk.RiskInfo memory risk, StateId newState) external restricted() {
+        update(riskId.toKey32(), abi.encode(risk), newState);
+    }
+
+    function updateRiskState(RiskId riskId, StateId newState) external restricted() {
+        updateState(riskId.toKey32(), newState);
+    }
+
+    //--- Application (Policy) ----------------------------------------------//
+    function createApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy) external restricted() {
+        create(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy));
+    }
+
+    function updateApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy), newState);
+    }
+
+    function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(applicationNftId, POLICY()), newState);
+    }
+
+    //--- Policy ------------------------------------------------------------//
+    function updatePolicy(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
+    }
+
+    function updatePolicyClaims(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
+    }
+
+    function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(policyNftId, POLICY()), newState);
+    }
+
+    //--- Claim -------------------------------------------------------------//
+    function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
+        create(_toClaimKey32(policyNftId, claimId), abi.encode(claim));
+    }
+
+    function updateClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim, StateId newState) external restricted() {
+        update(_toClaimKey32(policyNftId, claimId), abi.encode(claim), newState);
+    }
+
+    function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
+        updateState(_toClaimKey32(policyNftId, claimId), newState);
+    }
+
+    //--- Payout ------------------------------------------------------------//
+    function createPayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout) external restricted() {
+        create(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout));
+    }
+
+    function updatePayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
+        update(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout), newState);
+    }
+
+    function updatePayoutState(NftId policyNftId, PayoutId payoutId, StateId newState) external restricted() {
+        updateState(_toPayoutKey32(policyNftId, payoutId), newState);
+    }
+
+    //--- internal view/pure functions --------------------------------------//
+    function _toNftKey32(NftId nftId, ObjectType objectType) private pure returns (Key32) {
+        return nftId.toKey32(objectType);
+    }
+
+    function _toClaimKey32(NftId policyNftId, ClaimId claimId) private pure returns (Key32) {
+        return claimId.toKey32(policyNftId);
+    }
+
+    function _toPayoutKey32(NftId policyNftId, PayoutId payoutId) private pure returns (Key32) {
+        return payoutId.toKey32(policyNftId);
+    }
+}

package/contracts/instance/ObjectManager.sol

@@ -14,43 +14,30 @@ contract ObjectManager is
     Cloneable
 {
 
-    event LogObjectManagerInitialized(NftId instanceNftId, address instanceReader);
+    event LogObjectManagerInitialized(address instance);
 
     error ErrorObjectManagerNftIdInvalid(NftId instanceNftId);
     error ErrorObjectManagerAlreadyAdded(NftId componentNftId, NftId objectNftId);
 
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _activeObjects;
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _allObjects;
-    InstanceReader internal _instanceReader;
-
-    constructor() Cloneable() {
-        _instanceReader = InstanceReader(address(0));
-    }
+    IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectManager initialization
 
     /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
-    function initialize(
-        address authority,
-        address registry,
-        NftId instanceNftId
-    )
+    function initialize(address instanceAddress) 
+        initializer
         external 
     {
-        initialize(authority, registry);
-
-        // check/handle instance nft id/instance reader
-        IRegistry.ObjectInfo memory instanceInfo = _registry.getObjectInfo(instanceNftId);
-        if (instanceInfo.objectType != INSTANCE()) {
-            revert ErrorObjectManagerNftIdInvalid(instanceNftId);
-        }
-
-        IInstance instance = IInstance(instanceInfo.objectAddress);
-        _instanceReader = instance.getInstanceReader();
+        IInstance instance = IInstance(instanceAddress);
+        initialize(instance.authority(), address(instance.getRegistry()));
 
-        emit LogObjectManagerInitialized(instanceNftId, address(_instanceReader));
+        _instance = instance;
+        
+        emit LogObjectManagerInitialized(instanceAddress);
     }
 
-    function getInstanceReader() external view returns (InstanceReader) {
-        return _instanceReader;
+    function getInstance() external view returns (IInstance) {
+        return _instance;
     }
 
     function _add(NftId componentNftId, NftId objectNftId) internal {

package/contracts/instance/base/ComponentService.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponent} from "../../components/IComponent.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IAccess} from "../module/IAccess.sol";
+import {ObjectType, INSTANCE, REGISTRY} from "../../types/ObjectType.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+
+import {Service} from "../../shared/Service.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {InstanceAccessManager} from "../InstanceAccessManager.sol";
+
+abstract contract ComponentService is Service {
+
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
+    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
+    error ErrorComponentServiceComponentLocked(address component);
+    error ErrorComponentServiceSenderNotService(address sender);
+    error ErrorComponentServiceComponentTypeInvalid(address component, ObjectType expectedType, ObjectType foundType);
+
+    /// @dev modifier to check if caller is a registered service
+    modifier onlyService() {
+        address caller = msg.sender;
+        if(!getRegistry().isRegisteredService(caller)) {
+            revert ErrorComponentServiceSenderNotService(caller);
+        }
+        _;
+    }
+
+    // view functions
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        return IRegistryService(_getServiceAddress(REGISTRY()));
+    }
+
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    // internal functions
+    function _checkComponentForRegistration(
+        address componentAddress,
+        ObjectType requiredType,
+        RoleId requiredRole
+    )
+        internal
+        view
+        returns (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        )
+    {
+        // component may only be registerd by initial owner of component
+        owner = msg.sender;
+
+        // check this is a component
+        component = IComponent(componentAddress);
+        if(!component.supportsInterface(type(IComponent).interfaceId)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
+
+        // check component is of required type
+        IRegistry.ObjectInfo memory componentInfo = component.getInitialInfo();
+        if(componentInfo.objectType != requiredType) {
+            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, componentInfo.objectType);
+        }
+
+        // check msg.sender is component owner
+        address initialOwner = componentInfo.initialOwner;
+        if(owner != initialOwner) {
+            revert ErrorComponentServiceSenderNotOwner(componentAddress, componentInfo.initialOwner, owner);
+        }
+
+        // check instance has assigned required role to owner
+        instanceNftId = componentInfo.parentNftId;
+        instance = _getInstance(instanceNftId);
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
+            revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
+        }
+    }
+
+    // internal view functions
+    function _getAndVerifyCallingComponentAndInstance(
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentNftId = getRegistry().getNftId(msg.sender);
+        (componentInfo, instance) = _getAndVerifyComponentInfoAndInstance(componentNftId, expectedType);
+
+        // locked component can not call services
+        if (instance.getInstanceAccessManager().isTargetLocked(componentInfo.objectAddress)) {
+            revert IAccess.ErrorIAccessTargetLocked(componentInfo.objectAddress);
+        }
+    }
+
+    function _getAndVerifyComponentInfoAndInstance(
+        NftId componentNftId,
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentInfo = getRegistry().getObjectInfo(componentNftId);
+        if(componentInfo.objectType != expectedType) {
+            revert ErrorComponentServiceComponentTypeInvalid(
+                componentInfo.objectAddress, 
+                expectedType, 
+                componentInfo.objectType);
+        }
+
+        instance = _getInstance(componentInfo.parentNftId);
+    }
+    // assume componentNftId is always of `instance` type
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+    // assume componentNftId is always of `component` type
+    /*function _getInstanceForComponent(NftId componentNftId) internal view returns (IInstance) {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }*/
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+    }
+}

package/contracts/instance/base/KeyValueStore.sol

@@ -5,7 +5,7 @@ import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blockn
 import {Key32, KeyId, Key32Lib} from "../../types/Key32.sol";
 import {NftId} from "../../types/NftId.sol";
 import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE} from "../../types/StateId.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
 import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
 
 import {Lifecycle} from "./Lifecycle.sol";
@@ -20,15 +20,6 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         bytes memory data
     )
         internal
-    {
-        _create(key32, data);
-    }
-
-    function _create(
-        Key32 key32, 
-        bytes memory data
-    )
-        internal
     {
         ObjectType objectType = key32.toObjectType();
         require(objectType.gtz(), "ERROR:KVS-010:TYPE_UNDEFINED");
@@ -60,16 +51,6 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         StateId state
     ) 
         internal
-    {
-        _update(key32, data, state);
-    }
-
-    function _update(
-        Key32 key32, 
-        bytes memory data,
-        StateId state
-    ) 
-        internal
     {
         require(state.gtz(), "ERROR:KVS-020:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
@@ -79,28 +60,27 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         // update data
         _value[key32].data = data;
 
-        // update metadata (and state)
+        // update state 
+        if(state != KEEP_STATE()) {
+            metadata.state = state;
+        }
+
+        // update reest of metadata
         address updatedBy = msg.sender;
         Blocknumber lastUpdatedIn = metadata.updatedIn;
-        metadata.state = state;
+
         metadata.updatedBy = updatedBy;
         metadata.updatedIn = blockBlocknumber();
 
         // create log entries
         // solhint-disable avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
         emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
         // solhing-enable
     }
 
     function updateData(Key32 key32, bytes memory data) 
         internal
-    {
-        _updateData(key32, data);
-    }
-
-    function _updateData(Key32 key32, bytes memory data) 
-        internal
     {
         Metadata storage metadata = _value[key32].metadata;
         StateId state = metadata.state;
@@ -122,18 +102,15 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
     function updateState(Key32 key32, StateId state)
         internal
-    {
-        _updateState(key32, state);
-    }
-
-    function _updateState(Key32 key32, StateId state)
-        internal
     {
         require(state.gtz(), "ERROR:KVS-040:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
         StateId stateOld = metadata.state;
         require(stateOld.gtz(), "ERROR:KVS-041:NOT_EXISTING");
 
+        // ensure state transistion is valid
+        checkTransition(metadata.objectType, stateOld, state);
+
         // update metadata (and state)
         address updatedBy = msg.sender;
         Blocknumber lastUpdatedIn = metadata.updatedIn;
@@ -143,7 +120,7 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
         // create log entry
         // solhint-disable-next-line avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function exists(Key32 key32) public view returns (bool) {

package/contracts/instance/base/Lifecycle.sol

@@ -1,22 +1,31 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
 import {NftId} from "../../types/NftId.sol";
-import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, UNDERWRITTEN, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM, PAYOUT} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID} from "../../types/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
-contract Lifecycle is ILifecycle {
+contract Lifecycle is
+    Initializable,
+    ILifecycle
+{
     mapping(ObjectType objectType => StateId initialState)
         private _initialState;
 
     mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
         private _isValidTransition;
 
-    constructor() {
+    function initializeLifecycle()
+        public
+        onlyInitializing
+    {
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
     }
 
@@ -78,6 +87,7 @@ contract Lifecycle is ILifecycle {
     function _setupBundleLifecycle() internal {
         _initialState[BUNDLE()] = ACTIVE();
         _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][ACTIVE()][CLOSED()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
     }
@@ -86,11 +96,21 @@ contract Lifecycle is ILifecycle {
         _initialState[POLICY()] = APPLIED();
         _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
         _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
-        _isValidTransition[POLICY()][APPLIED()][UNDERWRITTEN()] = true;
-        _isValidTransition[POLICY()][UNDERWRITTEN()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][APPLIED()][COLLATERALIZED()] = true;
+        _isValidTransition[POLICY()][COLLATERALIZED()][ACTIVE()] = true;
         _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
     }
 
+    function _setupClaimAndPayoutLifecycle() internal {
+        _initialState[CLAIM()] = SUBMITTED();
+        _isValidTransition[CLAIM()][SUBMITTED()][CONFIRMED()] = true;
+        _isValidTransition[CLAIM()][SUBMITTED()][DECLINED()] = true;
+        _isValidTransition[CLAIM()][CONFIRMED()][CLOSED()] = true;
+
+        _initialState[PAYOUT()] = EXPECTED();
+        _isValidTransition[PAYOUT()][EXPECTED()][PAID()] = true;
+    }
+
     function _setupRiskLifecycle() internal {
         _initialState[RISK()] = ACTIVE();
         _isValidTransition[RISK()][ACTIVE()][PAUSED()] = true;

package/contracts/instance/module/IAccess.sol

@@ -1,38 +1,54 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
 
 import {RoleId} from "../../types/RoleId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IAccess {
+
+    enum Type {
+        NotInitialized,
+        Core,
+        Gif,
+        Custom        
+    }
+
     struct RoleInfo {
         ShortString name;
-        bool isCustom;
+        Type rtype;
+        //bool isLocked;
+        RoleId admin;
+        Timestamp createdAt;
+        Timestamp updatedAt;
     }
 
     struct TargetInfo {
         ShortString name;
-        bool isCustom;
+        Type ttype;
+        bool isLocked;
+        Timestamp createdAt;
+        Timestamp updatedAt;
     }
 
-    error ErrorTargetAddressZero();
-    error ErrorTargetAlreadyExists(address target, ShortString name);
-    error ErrorTargetDoesNotExist(address target);
-    error ErrorTargetNameEmpty(address target);
-    error ErrorTargetNameExists(address target, address existingTarget, ShortString name);
-
-    error ErrorRoleIdInvalid(RoleId roleId);
-    error ErrorRoleIdTooBig(RoleId roleId);
-    error ErrorRoleIdTooSmall(RoleId roleId);
-    error ErrorRoleIdAlreadyExists(RoleId roleId, ShortString name);
-    error ErrorRoleIdNotActive(RoleId roleId);
-    error ErrorRoleNameEmpty(RoleId roleId);
-    error ErrorRoleNameNotUnique(RoleId roleId, ShortString name);
-    error ErrorRoleInvalidUpdate(RoleId roleId, bool isCustom);
-    error ErrorGrantNonexstentRole(RoleId roleId);
-    error ErrorRevokeNonexstentRole(RoleId roleId);
-    error ErrorRenounceNonexstentRole(RoleId roleId);
+    error ErrorIAccessCallerIsNotRoleAdmin(address caller, RoleId roleId);
+
+    error ErrorIAccessRoleIdDoesNotExist(RoleId roleId);
+    error ErrorIAccessRoleIdTooBig(RoleId roleId);
+    error ErrorIAccessRoleIdTooSmall(RoleId roleId);
+    error ErrorIAccessRoleIdExists(RoleId roleId);
+    error ErrorIAccessRoleNameEmpty(RoleId roleId);
+    error ErrorIAccessRoleNameExists(RoleId roleId, RoleId existingRoleId, ShortString name);
+    error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
 
+    error ErrorIAccessTargetAddressZero();
+    error ErrorIAccessTargetDoesNotExist(address target);
+    error ErrorIAccessTargetExists(address target, ShortString name);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
+    error ErrorIAccessTargetNameEmpty(address target);
+    error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
+    error ErrorIAccessTargetLocked(address target);
+    error ErrorIAccessTargetNotRegistered(address target);
+    error ErrorIAccessTargetAuthorityInvalid(address target, address targetAuthority);
 }