@etherisc/gif-next 0.0.2-d63a6a1-078 → 0.0.2-d6609af-567

package/contracts/shared/InstanceLinkedComponent.sol

@@ -0,0 +1,171 @@
+// 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} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {IAccess} from "../instance/module/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;
+    }
+
+    function lock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
+    }
+    
+    function unlock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
+    }
+
+    function getInstance() public view override returns (IInstance instance) {
+        return _getInstanceLinkedComponentStorage()._instance;
+    }
+
+    function getProductNftId() public view override returns (NftId productNftId) {
+        return getComponentInfo().productNftId;
+    }
+
+    function getAuthorization() external view returns (IAuthorization authorization) {
+        return _getInstanceLinkedComponentStorage()._initialAuthorization;
+    }
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        onlyOwner()
+        restricted()
+        returns (Amount withdrawnAmount)
+    {
+        return _withdrawFees(amount);
+    }
+
+    function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
+        assembly {
+            $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
+        }
+    }
+
+    function _initializeInstanceLinkedComponent(
+        address registry,
+        NftId instanceNftId,
+        string memory name,
+        address token,
+        ObjectType componentType,
+        IAuthorization authorization,
+        bool isInterceptor,
+        address initialOwner,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // data that will saved with the component info in the instance store
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        // set and check linked instance
+        InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
+        $._instance = IInstance(
+            IRegistry(registry).getObjectAddress(instanceNftId));
+
+        if(!$._instance.supportsInterface(type(IInstance).interfaceId)) {
+            revert ErrorComponentNotInstance(instanceNftId);
+        }
+
+        _initializeComponent(
+            $._instance.authority(), 
+            registry, 
+            instanceNftId, 
+            name, 
+            token,
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData,
+            componentData);
+
+        // set component state
+        $._instanceReader = $._instance.getInstanceReader();
+        $._initialAuthorization = authorization;
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IInstanceLinkedComponent).interfaceId);
+    }
+
+    /// @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 (info.wallet != 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);
+    }
+
+
+    /// @dev returns the service address for the specified domain
+    /// gets address via lookup from registry using the major version form the linked instance
+    function _getServiceAddress(ObjectType domain) internal view returns (address service) {
+        VersionPart majorVersion = _getInstanceLinkedComponentStorage()._instance.getMajorVersion();
+        return getRegistry().getServiceAddress(domain, majorVersion);
+    }
+}

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(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,77 @@
+// 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(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    )
+        public
+        view
+    {
+        // revert if no life cycle support
+        if (_initialState[objectType].eqz()) {
+            revert ErrorNoLifecycle(objectType);
+        }
+
+        // enforce valid state transition
+        if (!_isValidTransition[objectType][fromId][toId]) {
+            revert ErrorInvalidStateTransition(objectType, fromId, toId);
+        }
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+}

package/contracts/shared/NftIdSet.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId} from "../type/NftId.sol";
+
+contract NftIdSet {
+
+    error ErrorNftIdSetManagerNotOwner(address owner, address sender);
+    error ErrorNftIdSetManagerOwnerAlreadySet(address owner);
+    error ErrorNftIdSetManagerNftIdInvalid(NftId objectNftId);
+    error ErrorNftIdSetManagerAlreadyAdded(NftId objectNftId);
+
+    LibNftIdSet.Set private _allObjects;
+    LibNftIdSet.Set private _activeObjects;
+    address private _owner;
+
+    modifier onlyOwner() {
+        if(msg.sender != _owner) {
+            revert ErrorNftIdSetManagerNotOwner(_owner, msg.sender);
+        }
+        _;
+    }
+
+    constructor() {
+        _owner = msg.sender;
+    }
+
+    function add(NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_allObjects, objectNftId);
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function activate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function deactivate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.remove(_activeObjects, objectNftId);
+    }
+
+    function nftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_allObjects);
+    }
+
+    function getNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_allObjects, idx);
+    }
+
+    function exists(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_allObjects, objectNftId);
+    }
+
+    function activeNftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_activeObjects);
+    }
+
+    function getActiveNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_activeObjects, idx);
+    }
+
+    function isActive(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_activeObjects, objectNftId);
+    }
+}

package/contracts/shared/NftOwnable.sol

@@ -1,136 +1,107 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {InitializableERC165} from "./InitializableERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
-
-contract NftOwnable is INftOwnable {
-
-    IRegistry internal _registry;
-    NftId private _nftId;
-    address private _initialOwner; 
+import {NftId} from "../type/NftId.sol";
+import {RegistryLinked} from "./RegistryLinked.sol";
+
+contract NftOwnable is
+    InitializableERC165,
+    RegistryLinked,
+    INftOwnable
+{
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.NftOwnable")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant NFT_OWNABLE_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
+
+    struct NftOwnableStorage {
+        NftId _nftId;
+        address _initialOwner; 
+    }
 
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
     modifier onlyOwner() {
-        address owner = getOwner();
-
-        // owner == address(0) is eg uninitialized upgradable contract
-        if (owner != address(0) && msg.sender != owner) {
-            revert ErrorNotOwner(msg.sender);
+        if (msg.sender != getOwner()) {
+            revert ErrorNftOwnableNotOwner(msg.sender);
         }
         _;
     }
 
-    constructor() {
-        _initialOwner = msg.sender;
-    }
-
-    /// @dev links this contract to nft after registration
-    // needs to be done once per registered contract and 
-    // reduces registry calls to check ownership
-    // does not need any protection as function can only do the "right thing"
-    function linkToRegisteredNftId() public {
-        if (_nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(_registry), _nftId);
-        }
-
-        if (address(_registry) == address(0)) {
-            revert ErrorRegistryNotInitialized();
-        }
 
-        address contractAddress = address(this);
+    /// @dev initialization for upgradable contracts
+    // used in _initializeRegisterable
+    function _initializeNftOwnable(
+        address initialOwner,
+        address registryAddress
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeRegistryLinked(registryAddress);
+        _initializeERC165();
 
-        if (!_registry.isRegistered(contractAddress)) {
-            revert ErrorContractNotRegistered(contractAddress);
+        if(initialOwner == address(0)) {
+            revert ErrorNftOwnableInitialOwnerZero();
         }
 
-        _nftId = _registry.getNftId(contractAddress);
+        _getNftOwnableStorage()._initialOwner = initialOwner;
     }
 
 
-    function getRegistry() public view virtual override returns (IRegistry) {
-        return _registry;
+    /// @dev links this contract to nft after registration
+    // needs to be done once per registered contract and 
+    // reduces registry calls to check ownership
+    // does not need any protection as function can only do the "right thing"
+    function linkToRegisteredNftId()
+        public
+        virtual
+        returns (NftId nftId)
+    {
+        return _linkToNftOwnable(address(this));
     }
 
-
     function getNftId() public view virtual override returns (NftId) {
-        return _nftId;
+        return _getNftOwnableStorage()._nftId;
     }
 
-
     function getOwner() public view virtual override returns (address) {
-        if (_nftId.gtz()) {
-            return _registry.ownerOf(_nftId);
+        NftOwnableStorage storage $ = _getNftOwnableStorage();
+
+        if ($._nftId.gtz()) {
+            return getRegistry().ownerOf($._nftId);
         }
 
-        return _initialOwner;
+        return $._initialOwner;
     }
 
-
-    /// @dev initialization for upgradable contracts
-    // used in _initializeRegisterable
-    function _initializeNftOwnable(
-        address initialOwner,
-        address registryAddress
-    )
-        internal
-        virtual
-    {
-        _initialOwner = initialOwner;
-        _setRegistry(registryAddress);
-    }
-
-
     /// @dev used in constructor of registry service manager
     // links ownership of registry service manager ot nft owner of registry service
     function _linkToNftOwnable(
-        address registryAddress,
         address nftOwnableAddress
     )
         internal
-        onlyOwner()
         returns (NftId)
     {
-        if (_nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(_registry), _nftId);
-        }
+        NftOwnableStorage storage $ = _getNftOwnableStorage();
 
-        _setRegistry(registryAddress);
-
-        if (!_registry.isRegistered(nftOwnableAddress)) {
-            revert ErrorContractNotRegistered(nftOwnableAddress);
+        if ($._nftId.gtz()) {
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
-        _nftId = _registry.getNftId(nftOwnableAddress);
-
-        return _nftId;
-    }
-
-
-    function _setRegistry(address registryAddress)
-        private
-    {
-        if (address(_registry) != address(0)) {
-            revert ErrorRegistryAlreadyInitialized(address(_registry));
+        if (!getRegistry().isRegistered(nftOwnableAddress)) {
+            revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
         }
 
-        if (registryAddress == address(0)) {
-            revert ErrorRegistryAddressZero();
-        }
+        $._nftId = getRegistry().getNftIdForAddress(nftOwnableAddress);
 
-        if (registryAddress.code.length == 0) {
-            revert ErrorNotRegistry(registryAddress);
-        }
+        return $._nftId;
+    }
 
-        _registry = IRegistry(registryAddress);
 
-        try _registry.supportsInterface(type(IRegistry).interfaceId) returns (bool isRegistry) {
-            if (!isRegistry) {
-                revert ErrorNotRegistry(registryAddress);
-            }
-        } catch {
-            revert ErrorNotRegistry(registryAddress);
+    function _getNftOwnableStorage() private pure returns (NftOwnableStorage storage $) {
+        assembly {
+            $.slot := NFT_OWNABLE_STORAGE_LOCATION_V1
         }
     }
 }