@etherisc/gif-next 0.0.2-803a717-124 → 0.0.2-804cdbf-724

package/contracts/instance/InstanceServiceManager.sol

@@ -7,39 +7,29 @@ import {ProxyManager} from "../shared/ProxyManager.sol";
 import {InstanceService} from "./InstanceService.sol";
 import {Registry} from "../registry/Registry.sol";
 import {RegistryService} from "../registry/RegistryService.sol";
-import {REGISTRY} from "../types/ObjectType.sol";
+import {REGISTRY} from "../type/ObjectType.sol";
 
 contract InstanceServiceManager is ProxyManager {
 
     InstanceService private _instanceService;
 
-    /// @dev initializes proxy manager with instance service implementation and deploys instance
+    /// @dev initializes proxy manager with instance service implementation
     constructor(
-        address registryAddress
-    )
-        ProxyManager()
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
     {
-        InstanceService instSrv = new InstanceService();
+        InstanceService instSrv = new InstanceService{salt: salt}();
         // bytes memory initCode = type(InstanceService).creationCode;
-        bytes memory data = abi.encode(registryAddress, address(this));
-        IVersionable versionable = deploy(
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
             address(instSrv), 
-            data);
+            data,
+            salt);
 
         _instanceService = InstanceService(address(versionable));
-
-        // TODO `this` must have a role or own nft to register service
-        //Registry registry = Registry(registryAddress);
-        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), _instanceService.getMajorVersion());
-        //RegistryService registryService = RegistryService(registryServiceAddress);
-        //registryService.registerService(_instanceService);
-        // RegistryService registryService = _instanceService.getRegistryService();
-
-        // TODO no nft to link yet
-        // link ownership of instance service manager ot nft owner of instance service
-        //_linkToNftOwnable(
-        //    address(registryAddress),
-        //    address(_instanceService));
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/instance/InstanceStore.sol

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Key32} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {ObjectType, BUNDLE, POLICY, POOL, PRODUCT, COMPONENT, DISTRIBUTOR, DISTRIBUTOR_TYPE} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId} from "../type/StateId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+
+import {BalanceStore} from "./base/BalanceStore.sol";
+import {IInstance} from "./IInstance.sol";
+import {KeyValueStore} from "../shared/KeyValueStore.sol";
+import {ObjectCounter} from "./base/ObjectCounter.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 {IOracle} from "../oracle/IOracle.sol";
+import {IRisk} from "./module/IRisk.sol";
+
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
+
+
+contract InstanceStore is
+    AccessManagedUpgradeable, 
+    BalanceStore,
+    KeyValueStore,
+    ObjectCounter,
+    ObjectLifecycle
+{
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize()
+        public 
+        initializer()
+    {
+        address instance = msg.sender;
+        address authority = IInstance(instance).authority();
+
+        __AccessManaged_init(authority);
+        // double initialization, safe
+        _initializeLifecycle();
+    }
+
+    //--- Component ---------------------------------------------------------//
+
+    function createComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo
+    )
+        external 
+        restricted()
+    {
+        _registerBalanceTarget(componentNftId);
+        _create(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo));
+    }
+
+    function updateComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo,
+        StateId newState
+    )
+        external 
+        restricted()
+    {
+        _update(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo), newState);
+    }
+
+    //--- Product -----------------------------------------------------------//
+
+    function createProduct(NftId productNftId, IComponents.ProductInfo memory info) external restricted() {
+        _create(_toNftKey32(productNftId, PRODUCT()), abi.encode(info));
+    }
+
+    function updateProduct(NftId productNftId, IComponents.ProductInfo memory info, StateId newState) external restricted() {
+        _update(_toNftKey32(productNftId, PRODUCT()), abi.encode(info), newState);
+    }
+
+    //--- Pool --------------------------------------------------------------//
+
+    function createPool(
+        NftId poolNftId, 
+        IComponents.PoolInfo memory info
+    )
+        external 
+        restricted()
+    {
+        _create(_toNftKey32(poolNftId, POOL()), abi.encode(info));
+    }
+
+    function updatePool(NftId poolNftId, IComponents.PoolInfo memory info, StateId newState) external restricted() {
+        _update(_toNftKey32(poolNftId, POOL()), abi.encode(info), 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() {
+        _registerBalanceTarget(bundleNftId);
+        _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() {
+        _registerBalanceTarget(applicationNftId);
+        _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);
+    }
+
+    //--- Request -----------------------------------------------------------//
+
+    function createRequest(IOracle.RequestInfo memory request) external restricted() returns (RequestId requestId) {
+        requestId = _createNextRequestId();
+        _create(requestId.toKey32(), abi.encode(request));
+    }
+
+    function updateRequest(RequestId requestId, IOracle.RequestInfo memory request, StateId newState) external restricted() {
+        _update(requestId.toKey32(), abi.encode(request), newState);
+    }
+
+    function updateRequestState(RequestId requestId, StateId newState) external restricted() {
+        _updateState(requestId.toKey32(), newState);
+    }
+
+    //--- balance and fee management functions ------------------------------//
+
+    function increaseBalance(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _increaseBalance(targetNftId, amount);
+    }
+
+    function decreaseBalance(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _decreaseBalance(targetNftId, amount);
+    }
+
+    function increaseFees(NftId targetNftId, Amount amount) external restricted() returns (Amount newFeeBalance) {
+        return _increaseFees(targetNftId, amount);
+    }
+
+    function decreaseFees(NftId targetNftId, Amount amount) external restricted() returns (Amount newFeeBalance) {
+        return _decreaseFees(targetNftId, amount);
+    }
+
+    function increaseLocked(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _increaseLocked(targetNftId, amount);
+    }
+
+    function decreaseLocked(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _decreaseLocked(targetNftId, amount);
+    }
+
+    //--- 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/base/BalanceStore.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, BlocknumberLib} from "../../type/Blocknumber.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Amount} from "../../type/Amount.sol";
+
+contract BalanceStore {
+
+    error ErrorBalanceStoreTargetAlreadyRegistered(NftId targetNftId);
+    error ErrorBalanceStoreTargetNotRegistered(NftId targetNftId);
+
+    event LogBalanceStoreTargetRegistered(NftId targetNftId);
+
+    event LogBalanceStoreFeesIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreFeesDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    event LogBalanceStoreLockedIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreLockedDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    event LogBalanceStoreBalanceIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreBalanceDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    mapping(NftId nftId => Amount balance) private _balanceAmount;
+    mapping(NftId nftId => Amount locked) private _lockedAmount;
+    mapping(NftId nftId => Amount fees) private _feeAmount;
+    mapping(NftId nftId => bool isRegistered) private _isRegistered;
+
+    // TODO check if this is made redundant by *Info struct updates
+    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
+
+    modifier onlyRegisteredTarget(NftId targetNftId) {
+        if (!_isRegistered[targetNftId]) {
+            revert ErrorBalanceStoreTargetNotRegistered(targetNftId);
+        }
+        _;
+    }
+
+    function getBalanceAmount(NftId targetNftId) external view returns (Amount balanceAmount) { return _balanceAmount[targetNftId]; }
+    function getLockedAmount(NftId targetNftId) external view returns (Amount lockedAmount) { return _lockedAmount[targetNftId]; }
+    function getFeeAmount(NftId targetNftId) external view returns (Amount feeAmount) { return _feeAmount[targetNftId]; }
+
+    function getAmounts(NftId targetNftId)
+        external
+        view
+        returns (
+            Amount balanceAmount,
+            Amount lockedAmount,
+            Amount feeAmount
+        )
+    {
+        balanceAmount = _balanceAmount[targetNftId];
+        lockedAmount = _lockedAmount[targetNftId];
+        feeAmount = _feeAmount[targetNftId];
+    }
+
+    function _registerBalanceTarget(NftId targetNftId) internal {
+        if (_isRegistered[targetNftId]) {
+            revert ErrorBalanceStoreTargetAlreadyRegistered(targetNftId);
+        }
+
+        _isRegistered[targetNftId] = true;
+        _setLastUpdatedIn(targetNftId);
+
+        emit LogBalanceStoreTargetRegistered(targetNftId);
+    }
+
+    //--- fee management ----------------------------------------------------//
+    function _increaseFees(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _feeAmount[targetNftId] + amount;
+        _feeAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreFeesIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseFees(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _feeAmount[targetNftId] - amount;
+        _feeAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreFeesDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- locked management -------------------------------------------------//
+    function _increaseLocked(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _lockedAmount[targetNftId] + amount;
+        _lockedAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreLockedIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseLocked(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _lockedAmount[targetNftId] - amount;
+        _lockedAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreLockedDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- balance management ------------------------------------------------//
+    function _increaseBalance(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _balanceAmount[targetNftId] + amount;
+        _balanceAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreBalanceIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseBalance(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _balanceAmount[targetNftId] - amount;
+        _balanceAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreBalanceDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- internal/private functions ----------------------------------------//
+    function _setLastUpdatedIn(NftId targetNftId) internal {
+        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+    }
+}

package/contracts/instance/{Cloneable.sol → base/Cloneable.sol}

@@ -2,42 +2,24 @@
 pragma solidity ^0.8.20;
 
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
 
 abstract contract Cloneable is 
     AccessManagedUpgradeable
 {
-    event CloneableInitialized(address authority, address registry);
-
-    error CloneableRegistryInvalid(address registry);
-
     IRegistry internal _registry;
 
-    constructor() {
-        _registry = IRegistry(address(0));
-    }
-
     /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
-    function initialize(
+    function __Cloneable_init(
         address authority,
         address registry
     )
-        public 
-        initializer
+        internal 
+        onlyInitializing
     {
-        // check/handle access managed
         __AccessManaged_init(authority);
-
-        // check/handle registry
-        if (registry.code.length == 0) {
-            revert CloneableRegistryInvalid(registry);
-        }
-
         _registry = IRegistry(registry);
-
-        emit CloneableInitialized(authority, registry);
     }
 
     function getRegistry() external view returns (IRegistry) {

package/contracts/instance/base/ObjectCounter.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, BlocknumberLib} from "../../type/Blocknumber.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Amount} from "../../type/Amount.sol";
+import {RequestId, RequestIdLib} from "../../type/RequestId.sol";
+
+contract ObjectCounter {
+
+    // TODO refactor risk id
+    // mapping(NftId productNftId => uint64 risks) private _riskCounter;
+
+    uint256 private _requestCounter;
+
+    // TODO introduce RequestId (uint64)
+    function _createNextRequestId() internal returns (RequestId requestId) {
+        _requestCounter++;
+        requestId = RequestIdLib.toRequestId(_requestCounter);
+    }
+}

package/contracts/instance/base/ObjectLifecycle.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL} from "../../type/ObjectType.sol";
+import {ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../../type/StateId.sol";
+import {Lifecycle} from "../../shared/Lifecycle.sol";
+
+contract ObjectLifecycle is
+    Lifecycle,
+    Initializable
+{
+    function _initializeLifecycle() internal onlyInitializing
+    {
+        _setupLifecycle();
+    }
+
+    function _setupLifecycle()
+        internal
+        override
+    {
+        _setupBundleLifecycle();
+        _setupComponentLifecycle();
+        _setupPolicyLifecycle();
+        _setupClaimLifecycle();
+        _setupPayoutLifecycle();
+        _setupRiskLifecycle();
+        _setupRequestLifecycle();
+
+        // setup dummy lifecycles to manage with key value store 
+        _setUpPoolLifecycle();
+        _setUpProductLifecycle();
+        _setUpDistributionLifecycle();
+    }
+
+    function _setupComponentLifecycle() private {
+        setInitialState(COMPONENT(), ACTIVE());
+        setStateTransition(COMPONENT(), ACTIVE(), PAUSED());
+        setStateTransition(COMPONENT(), PAUSED(), ACTIVE());
+        setStateTransition(COMPONENT(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupBundleLifecycle() private {
+        setInitialState(BUNDLE(), ACTIVE());
+        setStateTransition(BUNDLE(), ACTIVE(), PAUSED());
+        setStateTransition(BUNDLE(), ACTIVE(), CLOSED());
+        setStateTransition(BUNDLE(), PAUSED(), ACTIVE());
+        setStateTransition(BUNDLE(), PAUSED(), CLOSED());
+    }
+
+    function _setupPolicyLifecycle() private {
+        setInitialState(POLICY(), APPLIED());
+        setStateTransition(POLICY(), APPLIED(), REVOKED());
+        setStateTransition(POLICY(), APPLIED(), DECLINED());
+        setStateTransition(POLICY(), APPLIED(), COLLATERALIZED());
+        setStateTransition(POLICY(), APPLIED(), ACTIVE());
+        setStateTransition(POLICY(), COLLATERALIZED(), ACTIVE());
+        setStateTransition(POLICY(), ACTIVE(), CLOSED());
+    }
+
+    function _setupClaimLifecycle() private {
+        setInitialState(CLAIM(), SUBMITTED());
+        setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
+        setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
+        setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+    }
+
+    function _setupPayoutLifecycle() private {
+        setInitialState(PAYOUT(), EXPECTED());
+        setStateTransition(PAYOUT(), EXPECTED(), PAID());
+    }
+
+    function _setupRiskLifecycle() private {
+        setInitialState(RISK(), ACTIVE());
+        setStateTransition(RISK(), ACTIVE(), PAUSED());
+        setStateTransition(RISK(), PAUSED(), ACTIVE());
+        setStateTransition(RISK(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupRequestLifecycle() private {
+        setInitialState(REQUEST(), ACTIVE());
+        setStateTransition(REQUEST(), ACTIVE(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), FAILED());
+        setStateTransition(REQUEST(), FAILED(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), CANCELLED());
+    }
+
+    // dummy lifecycle only
+    function _setUpPoolLifecycle() private {
+        setInitialState(POOL(), ACTIVE());
+    }
+
+    // dummy lifecycle only
+    function _setUpProductLifecycle() private {
+        setInitialState(PRODUCT(), ACTIVE());
+    }
+
+    // dummy lifecycles only
+    function _setUpDistributionLifecycle() private {
+        setInitialState(DISTRIBUTION(), ACTIVE());
+        setInitialState(DISTRIBUTOR(), ACTIVE());
+        setInitialState(DISTRIBUTOR_TYPE(), ACTIVE());
+        setInitialState(REFERRAL(), ACTIVE());
+    }
+}