@etherisc/gif-next 0.0.2-bc11089-132 → 0.0.2-bc7a257-709

package/contracts/{instance/base → shared}/IKeyValueStore.sol

@@ -1,17 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
-import {Key32, KeyId} from "../../types/Key32.sol";
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../type/Blocknumber.sol";
+import {Key32, KeyId} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId} from "../type/StateId.sol";
 
 import {ILifecycle} from "./ILifecycle.sol";
 
-// TODO remove - internal only?
 interface IKeyValueStore is ILifecycle {
 
+    error ErrorKeyValueStoreTypeUndefined(ObjectType objectType);
+    error ErrorKeyValueStoreAlreadyCreated(Key32 key, ObjectType objectType);
+    error ErrorKeyValueStoreNoLifecycle(ObjectType objectType);
+    error ErrorKeyValueStoreStateZero(Key32 key);
+    error ErrorKeyValueStoreNotExisting(Key32 key);
+
+    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
     struct Value {
         Metadata metadata;
         bytes data;
@@ -24,15 +33,11 @@ interface IKeyValueStore is ILifecycle {
         // eg account outside gif objects that initiated the tx
         // implies the caller needs to be propagated through all calls up to key values store itself
         // to always have the instance address there doesn't seem to make sense
-        address updatedBy;
+        // address updatedBy;
         Blocknumber updatedIn;
         Blocknumber createdIn;
     }
 
-    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
-    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-
     // generic state changing functions
     // function create(Key32 key, bytes memory data) external;
     // function update(Key32 key, bytes memory data, StateId state) external;

package/contracts/{instance/base → shared}/ILifecycle.sol

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId} from "../type/StateId.sol";
 
 interface ILifecycle {
 
-    error ErrorNoLifecycle(NftId nftId, ObjectType objectType);
+    error ErrorNoLifecycle(address contractAddress, ObjectType objectType);
+    error ErrorFromStateMissmatch(address contractAddress, ObjectType objectType, StateId actual, StateId required);
     error ErrorInvalidStateTransition(
+        address contractAddress,
         ObjectType objectType,
         StateId fromStateId,
         StateId toStateId

package/contracts/shared/INftOwnable.sol

@@ -1,22 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-interface INftOwnable {
-    error ErrorNotOwner(address account);
+import {IRegistryLinked} from "./IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 
-    error ErrorAlreadyLinked(address registry, NftId nftId);
-    error ErrorRegistryAlreadyInitialized(address registry);
-    error ErrorRegistryNotInitialized();
-    error ErrorRegistryAddressZero();
-    error ErrorNotRegistry(address registryAddress);
-    error ErrorContractNotRegistered(address contractAddress);
+interface INftOwnable is
+    IERC165,
+    IRegistryLinked
+{
+    error ErrorNftOwnableInitialOwnerZero();
+    error ErrorNftOwnableNotOwner(address account);
+    error ErrorNftOwnableInvalidType(NftId nftId, ObjectType expectedObjectType);
 
-    function linkToRegisteredNftId() external;
+    error ErrorNftOwnableAlreadyLinked(NftId nftId);
+    error ErrorNftOwnableContractNotRegistered(address contractAddress);
+
+    function linkToRegisteredNftId() external returns (NftId);
 
-    function getRegistry() external view returns (IRegistry);
     function getNftId() external view returns (NftId);
     function getOwner() external view returns (address);
 }

package/contracts/shared/IPolicyHolder.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+/// @dev Generic interface for contracts that need to hold policies and receive payouts.
+/// The framework notifies policy holder contracts for policy creation/expiry, claim confirmation and payout execution
+interface IPolicyHolder is
+    IERC165,
+    IERC721Receiver,
+    IRegistryLinked
+{
+
+    /// @dev Callback function that will be called after successful policy activation.
+    /// Active policies may open claims under the activated policy.
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external;
+
+    /// @dev Callback function to indicate the specified policy has expired.
+    /// expired policies no longer accept new claims.
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external;
+
+    /// @dev Callback function to notify the confirmation of the specified claim.
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external;
+
+    /// @dev Callback function to notify the successful payout.
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external;
+}

package/contracts/shared/IRegisterable.sol

@@ -1,17 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {INftOwnable} from "./INftOwnable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
 
-interface IRegisterable is IERC165, INftOwnable {
+/// @title IRegisterable
+/// @dev Marks contracts that are intended to be registered in the registry.
+/// 
+interface IRegisterable is
+    IAccessManaged,
+    INftOwnable,
+    IRelease
+{
+    // __Registerable_init
+    error ErrorAuthorityInvalid(address authority);
 
+    // onlyActive()
+    error ErrorRegisterableNotActive();
+
+    /// @dev Returns true iff this contract managed by its authority is active.
+    /// Queries the IAccessManaged.authority().
+    function isActive() external view returns (bool active);
+
+    /// @dev retuns the object info relevant for registering for this contract 
+    /// IMPORTANT information returned by this function may only be used
+    /// before the contract is registered in the registry.
+    /// Once registered this information MUST only be accessed via the registry.
     function getInitialInfo() 
         external 
         view
-        returns (IRegistry.ObjectInfo memory, bytes memory data);
+        returns (IRegistry.ObjectInfo memory);
 }

package/contracts/shared/IRegistryLinked.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+
+interface IRegistryLinked {
+
+    error ErrorNotRegistry(address registryAddress);
+
+    function getRegistry() external view returns (IRegistry);
+}

package/contracts/shared/IService.sol

@@ -1,15 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {VersionPart} from "../types/Version.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {IRegisterable} from "./IRegisterable.sol";
-import {IVersionable} from "./IVersionable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {RoleId} from "../type/RoleId.sol";
 
 interface IService is 
+    IAccessManaged,
     IRegisterable,
     IVersionable
 {
-    function getName() external pure returns(string memory name);
-    function getMajorVersion() external view returns(VersionPart majorVersion);
+    /// @dev returns the domain for this service.
+    /// In any GIF release only one service for any given domain may be deployed.
+    function getDomain() external pure returns(ObjectType serviceDomain);
+
+    /// @dev returns the GIF release specific role id.
+    /// These role ids are used to authorize service to service communication.
+    function getRoleId() external view returns(RoleId serviceRoleId);
 }

package/contracts/shared/InitializableERC165.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+contract InitializableERC165 is
+    Initializable,
+    IERC165
+{
+    mapping(bytes4 => bool) private _isSupported;
+
+    // @dev initializes with support for ERC165
+    function __ERC165_init() internal onlyInitializing() {
+        _initializeERC165();
+    }
+
+    function _initializeERC165() internal {
+        _isSupported[type(IERC165).interfaceId] = true;
+    }
+
+    // @dev register support for provided interfaceId
+    // includes initialization for ERC165_ID if not yet done
+    function _registerInterface(bytes4 interfaceId) internal onlyInitializing() {
+        _registerInterfaceNotInitializing(interfaceId);
+    }
+
+    function _registerInterfaceNotInitializing(bytes4 interfaceId) internal{
+        _isSupported[interfaceId] = true;
+    }
+
+    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
+        return _isSupported[interfaceId];
+    }
+}

package/contracts/shared/InstanceLinkedComponent.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Component} from "./Component.sol";
+import {IComponentService} from "./IComponentService.sol";
+import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {VersionPart} from "../type/Version.sol";
+
+// then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
+// same pattern as for Service which is also upgradeable
+abstract contract InstanceLinkedComponent is
+    Component,
+    IInstanceLinkedComponent
+{
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Component.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant INSTANCE_LINKED_COMPONENT_LOCATION_V1 = 0xffe3d4462bded26a47154f4b8f6db494d2f772496965791d25bd456e342b7f00;
+
+    struct InstanceLinkedComponentStorage {
+        IInstance _instance; // instance for this component
+        InstanceReader _instanceReader; // instance reader for this component
+        IAuthorization _initialAuthorization;
+        IComponentService _componentService;
+    }
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+        returns (Amount withdrawnAmount)
+    {
+        return _withdrawFees(amount);
+    }
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function getInstance() public view override returns (IInstance instance) {
+        return _getInstanceLinkedComponentStorage()._instance;
+    }
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function getAuthorization() external view returns (IAuthorization authorization) {
+        return _getInstanceLinkedComponentStorage()._initialAuthorization;
+    }
+
+    function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
+        assembly {
+            $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
+        }
+    }
+
+    function _initializeInstanceLinkedComponent(
+        address registry,
+        NftId parentNftId,
+        string memory name,
+        ObjectType componentType,
+        IAuthorization authorization,
+        bool isInterceptor,
+        address initialOwner,
+        bytes memory componentData // data that will saved with the component info in the instance store
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        // validate registry, nft ids and get parent nft id
+        NftId instanceNftId = _checkAndGetInstanceNftId(
+            registry, 
+            parentNftId, 
+            componentType);
+
+        // set and check linked instance
+        InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
+        $._instance = IInstance(
+            IRegistry(registry).getObjectAddress(instanceNftId));
+
+        // set component specific parameters
+        _initializeComponent(
+            $._instance.authority(), // instance linked components need to point to instance admin
+            registry, 
+            parentNftId, 
+            name, 
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            "", // registry data
+            componentData);
+
+        // set instance linked specific parameters
+        $._instanceReader = $._instance.getInstanceReader();
+        $._initialAuthorization = authorization;
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        // register interfaces
+        _registerInterface(type(IInstanceLinkedComponent).interfaceId);
+    }
+
+
+    function _checkAndGetInstanceNftId(
+        address registryAddress,
+        NftId parentNftId,
+        ObjectType componentType
+    )
+        internal
+        view
+        returns (NftId instanceNftId)
+    {
+        // if product, then parent is already instance
+        if (componentType == PRODUCT()) {
+            _checkAndGetRegistry(registryAddress, parentNftId, INSTANCE());
+            return parentNftId;
+        }
+
+        // if not product parent is product, and parent of product is instance
+        IRegistry registry = _checkAndGetRegistry(registryAddress, parentNftId, PRODUCT());
+        return registry.getParentNftId(parentNftId);
+    }
+
+    /// @dev checks the and gets registry.
+    /// validates registry using a provided nft id and expected object type.
+    function _checkAndGetRegistry(
+        address registryAddress,
+        NftId objectNftId,
+        ObjectType requiredType
+    )
+        internal
+        view
+        returns (IRegistry registry)
+    {
+        registry = IRegistry(registryAddress);
+        IRegistry.ObjectInfo memory info = registry.getObjectInfo(objectNftId);
+
+        if (info.objectType != requiredType) {
+            revert ErrorInstanceLinkedComponentTypeMismatch(requiredType, info.objectType);
+        }
+    }
+
+
+    /// @dev for instance linked components the wallet address stored in the instance store.
+    /// updating needs to go throug component service
+    function _setWallet(address newWallet) internal virtual override onlyOwner {
+        IComponentService(_getServiceAddress(COMPONENT())).setWallet(newWallet);
+    }
+
+
+    function _getComponentInfo() internal virtual override view returns (IComponents.ComponentInfo memory info) {
+        NftId componentNftId = getRegistry().getNftIdForAddress(address(this));
+
+        // if registered, attempt to return component info via instance reader
+        if (componentNftId.gtz()) {
+            // component registerd with registry
+            info = _getInstanceReader().getComponentInfo(getNftId());
+
+            // check if also registered with instance
+            if (address(info.tokenHandler) != address(0)) {
+                return info;
+            }
+        }
+
+        // return data from component contract if not yet registered
+        return super._getComponentInfo();
+    }
+
+
+    /// @dev returns reader for linked instance
+    function _getInstanceReader() internal view returns (InstanceReader reader) {
+        return _getInstanceLinkedComponentStorage()._instanceReader;
+    }
+
+    function _withdrawFees(Amount amount)
+        internal
+        returns (Amount withdrawnAmount)
+    {
+        return _getInstanceLinkedComponentStorage()._componentService.withdrawFees(amount);
+    }
+}

package/contracts/shared/KeyValueStore.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../type/Blocknumber.sol";
+import {Key32, KeyId, Key32Lib} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+
+import {Lifecycle} from "./Lifecycle.sol";
+import {IKeyValueStore} from "./IKeyValueStore.sol";
+
+abstract contract KeyValueStore is
+    Lifecycle, 
+    IKeyValueStore
+{
+
+    mapping(Key32 key32 => Value value) private _value;
+
+    function _create(
+        Key32 key32, 
+        bytes memory data
+    )
+        internal
+    {
+        ObjectType objectType = key32.toObjectType();
+        if (objectType.eqz()) {
+            revert ErrorKeyValueStoreTypeUndefined(objectType);
+        }
+
+        Metadata storage metadata = _value[key32].metadata;
+        if (metadata.state.gtz()) {
+            revert ErrorKeyValueStoreAlreadyCreated(key32, objectType);
+        }
+
+        if(!hasLifecycle(objectType)) {
+            revert ErrorKeyValueStoreNoLifecycle(objectType);
+        }
+
+        Blocknumber blocknumber = blockBlocknumber();
+        StateId initialState = getInitialState(objectType);
+
+        // set metadata
+        metadata.objectType = objectType;
+        metadata.state = initialState;
+        metadata.updatedIn = blocknumber;
+        metadata.createdIn = blocknumber;
+
+        // set data
+        _value[key32].data = data;
+
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, msg.sender, tx.origin);
+    }
+
+
+    function _update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
+    {
+        // update state
+        Blocknumber lastUpdatedIn = _updateState(key32, state);
+
+        // update data
+        _value[key32].data = data;
+
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+
+    function _updateState(
+        Key32 key32, 
+        StateId state
+    )
+        internal
+        returns (Blocknumber lastUpdatedIn)
+    {
+        if (state.eqz()) {
+            revert ErrorKeyValueStoreStateZero(key32);
+        }
+
+        Metadata storage metadata = _value[key32].metadata;
+        StateId stateOld = metadata.state;
+        lastUpdatedIn = metadata.updatedIn;
+
+        if (stateOld.eqz()) {
+            revert ErrorKeyValueStoreNotExisting(key32);
+        }
+
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(stateOld, metadata.objectType, stateOld, state);
+            metadata.state = state;
+
+            // solhint-disable-next-line avoid-tx-origin
+            emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, msg.sender, tx.origin, lastUpdatedIn);
+        }
+
+        // update metadata
+        metadata.updatedIn = blockBlocknumber();
+    }
+
+    function exists(Key32 key32) public view returns (bool) {
+        return _value[key32].metadata.state.gtz();
+    }
+
+    function get(Key32 key32) public view returns (Value memory value) {
+        return _value[key32];
+    }
+
+    function getMetadata(Key32 key32) public view returns (Metadata memory metadata) {
+        return _value[key32].metadata;
+    }
+
+    function getData(Key32 key32) public view returns (bytes memory data) {
+        return _value[key32].data;
+    }
+
+    function getState(Key32 key32) public view returns (StateId state) {
+        return _value[key32].metadata.state;
+    }
+
+    function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
+        return Key32Lib.toKey32(objectType, id);
+    }
+}

package/contracts/shared/Lifecycle.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId, zeroStateId} from "../type/StateId.sol";
+import {ILifecycle} from "./ILifecycle.sol";
+
+abstract contract Lifecycle is
+    ILifecycle
+{
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    /// @dev child class must implement and CALL setup func at deployment/initializaton time
+    function _setupLifecycle() internal virtual;
+
+    function setInitialState(ObjectType ttype, StateId state) internal virtual {
+        assert(_initialState[ttype] == zeroStateId());
+        _initialState[ttype] = state;
+    }
+
+    function setStateTransition(ObjectType ttype, StateId oldState, StateId newState) internal virtual {
+        assert(_isValidTransition[ttype][oldState][newState] == false);
+        _isValidTransition[ttype][oldState][newState] = true;
+    }
+
+    function hasLifecycle(
+        ObjectType objectType
+    )
+        public
+        view
+        override
+        returns (bool)
+    {
+        return _initialState[objectType].gtz();
+    }
+
+    function getInitialState(
+        ObjectType objectType
+    )
+        public
+        view
+        returns (StateId)
+    {
+        return _initialState[objectType];
+    }
+
+    function checkTransition(
+        StateId stateId,
+        ObjectType objectType,
+        StateId expectedFromId,
+        StateId toId
+    )
+        public
+        view
+    {
+        // revert if no life cycle support
+        if (_initialState[objectType].eqz()) {
+            revert ErrorNoLifecycle(address(this), objectType);
+        }
+
+        // revert if current state is not expected `from` state
+        if(stateId != expectedFromId) {
+            revert ErrorFromStateMissmatch(address(this), objectType, stateId, expectedFromId);
+        }
+
+        // enforce valid state transition
+        if (!_isValidTransition[objectType][stateId][toId]) {
+            revert ErrorInvalidStateTransition(
+                address(this),
+                objectType, 
+                stateId, 
+                toId
+            );
+        }
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+}