@etherisc/gif-next 0.0.2-ff282a4-523 → 0.0.2-ff3a8a0-504

package/contracts/examples/unpermissioned/SimpleProductAuthorization.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicProductAuthorization} from "../../product/BasicProductAuthorization.sol";
+import {IAccess} from "../../authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../type/RoleId.sol";
+import {SimpleProduct} from "./SimpleProduct.sol";
+
+contract SimpleProductAuthorization
+    is BasicProductAuthorization
+{
+    constructor(string memory componentName)
+        BasicProductAuthorization(componentName)
+    {}
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+
+        // authorize public role (open access to any account, only allows to lock target)
+        IAccess.FunctionInfo[] storage functions;
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        _authorize(functions, SimpleProduct.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, SimpleProduct.setWallet.selector, "setWallet");
+    }
+}

package/contracts/instance/BaseStore.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IBaseStore} from "./IBaseStore.sol";
+
+import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
+import {Key32, KeyId, Key32Lib} from "../type/Key32.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId, KEEP_STATE} from "../type/StateId.sol";
+import {Lifecycle} from "../shared/Lifecycle.sol";
+
+abstract contract BaseStore is
+    Lifecycle, 
+    IBaseStore
+{
+
+    mapping(Key32 key32 => IBaseStore.Metadata metadata) private _metadata;
+
+    function _createMetadata(
+        Key32 key32
+    )
+        internal
+    {
+        ObjectType objectType = key32.toObjectType();
+        if (objectType.eqz()) {
+            revert ErrorBaseStoreTypeUndefined(objectType);
+        }
+
+        Metadata storage metadata = _metadata[key32];
+        if (metadata.updatedIn.gtz()) {
+            revert ErrorBaseStoreAlreadyCreated(key32, objectType);
+        }
+
+        if(!hasLifecycle(objectType)) {
+            revert ErrorBaseStoreNoLifecycle(objectType);
+        }
+
+        Blocknumber blocknumber = BlocknumberLib.current();
+        StateId initialState = getInitialState(objectType);
+
+        // set metadata
+        metadata.objectType = objectType;
+        metadata.state = initialState;
+        metadata.updatedIn = blocknumber;
+    }
+
+    function _updateState(
+        Key32 key32, 
+        StateId state
+    )
+        internal
+        returns (Blocknumber lastUpdatedIn)
+    {
+        if (state.eqz()) {
+            revert ErrorBaseStoreStateZero(key32);
+        }
+
+        Metadata storage metadata = _metadata[key32];
+        StateId stateOld = metadata.state;
+        lastUpdatedIn = metadata.updatedIn;
+
+        if (stateOld.eqz()) {
+            revert ErrorBaseStoreNotExisting(key32);
+        }
+
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(stateOld, metadata.objectType, stateOld, state);
+            metadata.state = state;
+
+            // solhint-disable-next-line avoid-tx-origin
+        }
+
+        // update metadata
+        metadata.updatedIn = BlocknumberLib.current();
+    }
+
+    function exists(Key32 key32) public view returns (bool) {
+        return _metadata[key32].state.gtz();
+    }
+
+    function getMetadata(Key32 key32) public view returns (Metadata memory metadata) {
+        return _metadata[key32];
+    }
+
+    function getState(Key32 key32) public view returns (StateId state) {
+        return _metadata[key32].state;
+    }
+
+    function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
+        return Key32Lib.toKey32(objectType, id);
+    }
+}

package/contracts/instance/BundleSet.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {Key32} from "../type/Key32.sol";
+import {BUNDLE} from "../type/ObjectType.sol";
+
+import {ObjectSet} from "./base/ObjectSet.sol";
+import {ObjectSetHelperLib} from "./base/ObjectSetHelperLib.sol";
+
+contract BundleSet is 
+    ObjectSet
+{
+    using LibNftIdSet for LibNftIdSet.Set;
+
+    event LogBundleSetPolicyLinked(NftId bundleNftId, NftId policyNftId);
+    event LogBundleSetPolicyUnlinked(NftId bundleNftId, NftId policyNftId);
+
+    event LogBundleSetBundleAdded(NftId poolNftId, NftId bundleNftId);
+    event LogBundleSetBundleUnlocked(NftId poolNftId, NftId bundleNftId);
+    event LogBundleSetBundleLocked(NftId poolNftId, NftId bundleNftId);
+    event LogBundleSetBundleClosed(NftId poolNftId, NftId bundleNftId);
+
+    error ErrorBundleSetPolicyAlreadyActivated(NftId policyNftId);
+    error ErrorBundleSetBundleLocked(NftId bundleNftId, NftId policyNftId);
+    error ErrorBundleSetPolicyWithOpenClaims(NftId policyNftId, uint256 openClaimsCount);
+    error ErrorBundleSetPolicyNotCloseable(NftId policyNftId);
+    error ErrorBundleSetBundleUnknown(NftId bundleNftId);
+    error ErrorBundleSetBundleNotRegistered(NftId bundleNftId);
+
+    mapping(NftId bundleNftId => LibNftIdSet.Set policies) internal _activePolicies;
+
+    /// @dev links a policy to its bundle
+    function linkPolicy(NftId poolNftId, NftId bundleNftId, NftId policyNftId) external restricted() {
+
+        // ensure bundle is unlocked (in active set) and registered with this instance
+        if (!_isActive(poolNftId, _toBundleKey32(bundleNftId))) {
+            revert ErrorBundleSetBundleLocked(bundleNftId, policyNftId);
+        }
+
+        _activePolicies[bundleNftId].add(policyNftId);
+        emit LogBundleSetPolicyLinked(bundleNftId, policyNftId);
+    }
+
+
+    /// @dev unlinks a policy from its bundle
+    function unlinkPolicy(NftId poolNftId, NftId bundleNftId, NftId policyNftId) external restricted() {
+
+        // ensure bundle is registered with this instance
+        if (!_contains(poolNftId, _toBundleKey32(bundleNftId))) {
+            revert ErrorBundleSetBundleUnknown(bundleNftId);
+        }
+
+        _activePolicies[bundleNftId].remove(policyNftId);
+        emit LogBundleSetPolicyUnlinked(bundleNftId, policyNftId);
+    }
+
+
+    /// @dev add a new bundle to a pool registerd with this instance
+    // the corresponding pool is fetched via instance reader
+    function add(NftId bundleNftId) external restricted() {
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
+
+        // ensure pool is registered with instance
+        if(poolNftId.eqz()) {
+            revert ErrorBundleSetBundleNotRegistered(bundleNftId);
+        }
+
+        _add(poolNftId, _toBundleKey32(bundleNftId));
+        emit LogBundleSetBundleAdded(poolNftId, bundleNftId);
+    }
+
+
+    /// @dev unlocked (active) bundles are available to collateralize new policies
+    function unlock(NftId bundleNftId) external restricted() {
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
+        _activate(poolNftId, _toBundleKey32(bundleNftId));
+        emit LogBundleSetBundleUnlocked(poolNftId, bundleNftId);
+    }
+
+    /// @dev locked (deactivated) bundles may not collateralize any new policies
+    function lock(NftId bundleNftId) external restricted() {
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
+        _deactivate(poolNftId, _toBundleKey32(bundleNftId));
+        emit LogBundleSetBundleLocked(poolNftId, bundleNftId);
+    }
+
+
+    function checkBundle(NftId productNftId, NftId bundleId)
+        public
+        view 
+        returns (bool exists, bool active)
+    {
+        Key32 bundleKey32 = bundleId.toKey32(BUNDLE());
+        exists = _contains(productNftId, bundleKey32);
+
+        if (exists) {
+            active = _isActive(productNftId, bundleKey32);
+        }
+    }
+
+    function bundles(NftId poolNftId) external view returns(uint256) {
+        return _objects(poolNftId);
+    }
+
+    function getBundleNftId(NftId poolNftId, uint256 idx) external view returns(NftId) {
+        return NftIdLib.toNftId(_getObject(poolNftId, idx).toKeyId());
+    }
+
+    function activeBundles(NftId poolNftId) external view returns(uint256) {
+        return _activeObjs(poolNftId);
+    }
+
+    function getActiveBundleNftId(NftId poolNftId, uint256 idx) external view returns(NftId) {
+        return NftIdLib.toNftId(_getActiveObject(poolNftId, idx).toKeyId());
+    }
+
+    function activePolicies(NftId bundleNftId) external view returns(uint256) {
+        return _activePolicies[bundleNftId].size();
+    }
+
+    function getActivePolicy(NftId bundleNftId, uint256 idx) external view returns(NftId policyNftId) {
+        return _activePolicies[bundleNftId].getElementAt(idx);
+    }
+
+    function _toBundleKey32(NftId nftId) private pure returns (Key32) {
+        return nftId.toKey32(BUNDLE());
+    }
+}

package/contracts/instance/IBaseStore.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ILifecycle} from "../shared/ILifecycle.sol";
+
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {Key32, KeyId} from "../type/Key32.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId} from "../type/StateId.sol";
+
+
+interface IBaseStore is ILifecycle {
+
+    error ErrorBaseStoreTypeUndefined(ObjectType objectType);
+    error ErrorBaseStoreAlreadyCreated(Key32 key, ObjectType objectType);
+    error ErrorBaseStoreNoLifecycle(ObjectType objectType);
+    error ErrorBaseStoreStateZero(Key32 key);
+    error ErrorBaseStoreNotExisting(Key32 key);
+
+
+    struct Metadata {
+        // slot 0
+        ObjectType objectType;
+        StateId state;
+        Blocknumber updatedIn;
+    }
+
+    /// @dev check if a metadata entry with the key exists
+    function exists(Key32 key) external view returns (bool);
+    /// @dev retrieve the metadata for a given key
+    function getMetadata(Key32 key) external view returns (Metadata memory metadata);
+    /// @dev retrieve the state for a given key
+    function getState(Key32 key) external view returns (StateId state);
+
+    /// @dev convert an object type and an id to a key32
+    function toKey32(ObjectType objectType, KeyId id) external pure returns(Key32);
+}

package/contracts/instance/IInstance.sol

@@ -1,77 +1,156 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
-
-import {ClaimId} from "../type/ClaimId.sol";
-import {DistributorType} from "../type/DistributorType.sol";
-import {PayoutId} from "../type/PayoutId.sol";
-import {NftId} from "../type/NftId.sol";
-import {StateId} from "../type/StateId.sol";
-import {ReferralId} from "../type/Referral.sol";
-import {RiskId} from "../type/RiskId.sol";
-import {VersionPart} from "../type/Version.sol";
-import {Key32} from "../type/Key32.sol";
-import {RoleId} from "../type/RoleId.sol";
-
+import {IAccess} from "../authorization/IAccess.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 
-import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
-
-import {InstanceAccessManager} from "./InstanceAccessManager.sol";
-import {BundleManager} from "./BundleManager.sol";
+import {Amount} from "../type/Amount.sol";
+import {BundleSet} from "./BundleSet.sol";
+import {RiskSet} from "./RiskSet.sol";
+import {InstanceAdmin} from "./InstanceAdmin.sol";
 import {InstanceReader} from "./InstanceReader.sol";
 import {InstanceStore} from "./InstanceStore.sol";
+import {NftId} from "../type/NftId.sol";
+import {ProductStore} from "./ProductStore.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {UFixed} from "../type/UFixed.sol";
 
-import {IKeyValueStore} from "./base/IKeyValueStore.sol";
 
-import {IAccess} from "./module/IAccess.sol";
+interface IInstance is 
+    IRegisterable
+{
+    // role handling
+    event LogInstanceCustomRoleCreated(RoleId roleId, string roleName, RoleId adminRoleId, uint32 maxMemberCount);
+    event LogInstanceCustomRoleActiveSet(RoleId roleId, bool active, address caller);
+    event LogInstanceCustomRoleGranted(RoleId roleId, address account, address caller);
+    event LogInstanceCustomRoleRevoked(RoleId roleId, address account, address caller);
 
-import {IBundleService} from "../pool/IBundleService.sol";
-import {IDistributionService} from "../distribution/IDistributionService.sol";
-import {IPolicyService} from "../product/IPolicyService.sol";
-import {IPoolService} from "../pool/IPoolService.sol";
-import {IProductService} from "../product/IProductService.sol";
-import {IPolicyService} from "../product/IPolicyService.sol";
-import {IBundleService} from "../pool/IBundleService.sol";
+    // target handling
+    event LogInstanceCustomTargetCreated(address target, RoleId targetRoleId, string name);
+    event LogInstanceTargetLocked(address target, bool locked);
+    event LogInstanceCustomTargetFunctionRoleSet(address target, bytes4[] selectors, RoleId roleId);
 
+    // modifier is onlyRoleAdmin
+    error ErrorInstanceNotCustomRole(RoleId roleId);
+    error ErrorInstanceNotRoleAdmin(RoleId roleId, address account);
 
+    error ErrorInstanceInstanceAdminZero();
+    error ErrorInstanceInstanceAdminAlreadySet(address instanceAdmin);
+    error ErrorInstanceInstanceAdminAuthorityMismatch(address instanceAuthority);
 
-interface IInstance is 
-    IRegisterable, 
-    ITransferInterceptor, 
-    IAccessManaged
-{
-    error ErrorInstanceInstanceAccessManagerZero();
-    error ErrorInstanceInstanceAccessManagerAlreadySet(address instanceAccessManager);
-    error ErrorInstanceInstanceAccessManagerAuthorityMismatch(address instanceAuthority);
+    error ErrorInstanceBundleSetAlreadySet(address instanceBundleSet);
+    error ErrorInstanceBundleSetInstanceMismatch(address instance);
+    error ErrorInstanceBundleSetAuthorityMismatch(address instanceAuthority);
 
-    error ErrorInstanceBundleManagerAlreadySet(address instanceBundleManager);
-    error ErrorInstanceBundleManagerInstanceMismatch(address instance);
-    error ErrorInstanceBundleManagerAuthorityMismatch(address instanceAuthority);
+    error ErrorInstanceRiskSetAlreadySet(address instanceRiskSet);
+    error ErrorInstanceRiskSetInstanceMismatch(address instance);
+    error ErrorInstanceRiskSetAuthorityMismatch(address instanceAuthority);
 
     error ErrorInstanceInstanceReaderInstanceMismatch(address instanceAuthority);
 
     error ErrorInstanceInstanceStoreAlreadySet(address instanceStore);
     error ErrorInstanceInstanceStoreAuthorityMismatch(address instanceAuthority);
 
-    function createRole(string memory roleName, string memory adminName) external returns (RoleId roleId, RoleId admin);
+    struct InstanceContracts {
+        InstanceAdmin instanceAdmin;
+        InstanceStore instanceStore;
+        ProductStore productStore;
+        BundleSet bundleSet;
+        RiskSet riskSet;
+        InstanceReader instanceReader;
+    }
+
+    struct InstanceInfo {
+        uint64 requestsCount;
+    }
+
+    ///--- instance ---------------------------------------------------------//
+
+    /// @dev Locks/unlocks the complete instance, including all its components.
+    function setInstanceLocked(bool locked) external;
+
+    /// @dev Upgrades the instance reader to the specified target.
+    function upgradeInstanceReader() external;
+
+    /// @dev Sets the instance reader for the instance.
+    /// Permissioned: only the instance service may call this function.
+    function setInstanceReader(InstanceReader instanceReader) external;
+
+    ///--- staking ----------------------------------------------------------//
+
+    /// @dev Sets the duration for locking new stakes on this instance..
+    function setStakingLockingPeriod(Seconds stakeLockingPeriod) external;
+
+    /// @dev Sets the staking reward rate [apr] for this instance.
+    function setStakingRewardRate(UFixed rewardRate) external;
+
+    /// @dev Sets the maximum staked amount for this instance.
+    function setStakingMaxAmount(Amount maxStakedAmount) external;
+
+    /// @dev Refills the staking reward reserves for the specified target.
+    function refillStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
+
+    /// @dev Defunds the staking reward reserves for the specified target.
+    function withdrawStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
+
+    ///--- product/component ------------------------------------------------//
+
+    /// @dev Locks/unlocks the specified target.
+    function setTargetLocked(address target, bool locked) external;
+
+    /// @dev Register a product with the instance.
+    function registerProduct(address product, address token) external returns (NftId productNftId);
+
+    ///--- authz ------------------------------------------------------------//
+
+    /// @dev Creates a new custom role for the calling instance.
+    /// Custom roles are intended to be used for access control of custom components and its helper contracts.
+    /// Custom roles are not intended to be used as target roles for custom contracts.
+    function createRole(string memory roleName, RoleId adminRoleId, uint32 maxMemberCount) external returns (RoleId roleId);
+
+    /// @dev Activates/deactivates the specified role.
+    /// Only instance owner or account with role admin role can call this function.
+    function setRoleActive(RoleId roleId, bool active) external;
+
+    /// @dev Grants the specified role to the account.
+    /// Only active roles can be granted.
+    /// Only instance owner or account with role admin role can call this function.
     function grantRole(RoleId roleId, address account) external;
+
+    /// @dev Revokes the specified role from the account.
+    /// Only instance owner or account with role admin role can call this function.
     function revokeRole(RoleId roleId, address account) external;
 
-    function createTarget(address target, string memory name) external;
-    function setTargetFunctionRole(string memory targetName, bytes4[] calldata selectors, RoleId roleId) external;
-    function setTargetLocked(address target, bool locked) external;
+    /// @dev Creates a new custom target.
+    /// Custom targets are intended to be used for access control helper contracts of components.
+    /// Custom targets are not intended to be used for components.
+    function createTarget(address target, string memory name) external returns (RoleId contractRoleId);
+
+    /// @dev Authorizes the specified functions for the target and provided role.
+    function authorizeFunctions(address target, RoleId roleId, IAccess.FunctionInfo[] memory functions) external;
+
+    /// @dev Removes any role authorization for the specified functions.
+    function unauthorizeFunctions(address target, IAccess.FunctionInfo[] memory functions) external;
+
+    //--- getters -----------------------------------------------------------//
+
+    /// @dev returns the overall locking state of the instance (including all components)
+    function isInstanceLocked() external view returns (bool isLocked);
+
+    /// @dev returns the locking state of the specified target
+    function isTargetLocked(address target) external view returns (bool isLocked);
 
-    function getDistributionService() external view returns (IDistributionService);
-    function getProductService() external view returns (IProductService);
-    function getPoolService() external view returns (IPoolService);
-    function getPolicyService() external view returns (IPolicyService);
-    function getBundleService() external view returns (IBundleService);
+    // get products
+    function products() external view returns (uint256 productCount);
+    function getProductNftId(uint256 idx) external view returns (NftId productNftId);
 
-    function getMajorVersion() external pure returns (VersionPart majorVersion);
+    // get supporting contracts
     function getInstanceReader() external view returns (InstanceReader);
-    function getBundleManager() external view returns (BundleManager);
-    function getInstanceAccessManager() external view returns (InstanceAccessManager);
+    function getBundleSet() external view returns (BundleSet);
+    function getRiskSet() external view returns (RiskSet);
+    function getInstanceAdmin() external view returns (InstanceAdmin);
     function getInstanceStore() external view returns (InstanceStore);
+    function getProductStore() external view returns (ProductStore);
+    function isTokenRegistryDisabled() external view returns (bool);
 }

package/contracts/instance/IInstanceService.sol

@@ -1,24 +1,31 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstance} from "./IInstance.sol";
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {RoleId} from "../type/RoleId.sol";
-import {IService} from "../shared/IService.sol";
-
-import {AccessManagerUpgradeableInitializeable} from "../shared/AccessManagerUpgradeableInitializeable.sol";
-import {InstanceAccessManager} from "./InstanceAccessManager.sol";
-import {Instance} from "./Instance.sol";
-import {InstanceReader} from "./InstanceReader.sol";
-import {BundleManager} from "./BundleManager.sol";
-import {InstanceStore} from "./InstanceStore.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {VersionPart} from "../type/Version.sol";
 
 interface IInstanceService is IService {
 
+    // onlyInstance
+    error ErrorInstanceServiceNotRegistered(address instance);
+    error ErrorInstanceServiceNotInstance(address instance, ObjectType objectType);
+    error ErrorInstanceServiceInstanceVersionMismatch(NftId instanceNftId, VersionPart expectedRelease, VersionPart instanceRelease);
+
+    error ErrorInstanceServiceComponentNotInstanceLinked(address component);
+
     error ErrorInstanceServiceMasterInstanceAlreadySet();
-    error ErrorInstanceServiceMasterOzAccessManagerAlreadySet();
-    error ErrorInstanceServiceMasterInstanceAccessManagerAlreadySet();
-    error ErrorInstanceServiceMasterBundleManagerAlreadySet();
+    error ErrorInstanceServiceMasterInstanceAdminAlreadySet();
+    error ErrorInstanceServiceMasterBundleSetAlreadySet();
+    error ErrorInstanceServiceMasterRiskSetAlreadySet();
     error ErrorInstanceServiceInstanceAddressZero();
 
     error ErrorInstanceServiceMasterInstanceReaderNotSet();
@@ -26,48 +33,87 @@ interface IInstanceService is IService {
     error ErrorInstanceServiceInstanceReaderSameAsMasterInstanceReader();
     error ErrorInstanceServiceInstanceReaderInstanceMismatch();
 
-    error ErrorInstanceServiceInstanceAccessManagerZero();
+    error ErrorInstanceServiceAccessManagerZero();
+    error ErrorInstanceServiceInstanceAdminZero();
     error ErrorInstanceServiceInstanceReaderZero();
-    error ErrorInstanceServiceBundleManagerZero();
+    error ErrorInstanceServiceBundleSetZero();
+    error ErrorInstanceServiceRiskSetZero();
     error ErrorInstanceServiceInstanceStoreZero();
+    error ErrorInstanceServiceProductStoreZero();
 
     error ErrorInstanceServiceInstanceAuthorityMismatch();
-    error ErrorInstanceServiceBundleManagerAuthorityMismatch();
+    error ErrorInstanceServiceBundleSetAuthorityMismatch();
+    error ErrorInstanceServiceRiskSetAuthorityMismatch();
     error ErrorInstanceServiceInstanceReaderInstanceMismatch2();
-    error ErrorInstanceServiceBundleMangerInstanceMismatch();
+    error ErrorInstanceServiceBundleSetInstanceMismatch();
+    error ErrorInstanceServiceRiskSetInstanceMismatch();
     error ErrorInstanceServiceInstanceStoreAuthorityMismatch();
+    error ErrorInstanceServiceProductStoreAuthorityMismatch();
 
     error ErrorInstanceServiceRequestUnauhorized(address caller);
-    error ErrorInstanceServiceNotInstanceOwner(address caller, NftId instanceNftId);
-    error ErrorInstanceServiceNotInstance(NftId nftId);
+    error ErrorInstanceServiceNotInstanceNftId(NftId nftId);
     error ErrorInstanceServiceComponentNotRegistered(address componentAddress);
     error ErrorInstanceServiceInstanceComponentMismatch(NftId instanceNftId, NftId componentNftId);
     error ErrorInstanceServiceInvalidComponentType(address componentAddress, ObjectType expectedType, ObjectType componentType);
     
-    event LogInstanceCloned(
-        address clonedOzAccessManager,
-        address clonedInstanceAccessManager,
-        address clonedInstance,
-        address clonedInstanceStore,
-        address clonedBundleManager, 
-        address clonedInstanceReader, 
-        NftId clonedInstanceNftId
-    );
-
-    function createInstanceClone()
+    event LogInstanceServiceInstanceLocked(NftId instanceNftId, bool locked);
+    event LogInstanceServiceInstanceCreated(NftId instanceNftId, address instance);
+    event LogInstanceServiceMasterInstanceReaderUpgraded(NftId instanceNfId, address newInstanceReader);
+    event LogInstanceServiceInstanceReaderUpgraded(NftId instanceNfId, address newInstanceReader);
+
+    /// @dev Creates a new custom role for the calling instance.
+    function createRole(string memory roleName, RoleId adminRoleId, uint32 maxMemberCount) external returns (RoleId roleId);
+
+    /// @dev Sets the specified custom role as active or inactive for the calling instance.
+    function setRoleActive(RoleId roleId, bool active) external;
+
+    /// @dev Grants the specified custom role to the specified account for the calling instance.
+    function grantRole(RoleId roleId, address account) external; 
+
+    /// @dev Revokes the specified custom role from the specified account for the calling instance.
+    function revokeRole(RoleId roleId, address account) external; 
+
+    /// @dev Creates a new custom target for the calling instance.
+    /// All custom trargets are created with a corresponding contract role.
+    function createTarget(address target, string memory name) external returns (RoleId contractRoleId);
+
+    /// @dev Authorizes the specified functions for the specified target.
+    function authorizeFunctions(address target, RoleId roleId, IAccess.FunctionInfo[] memory functions) external; 
+
+    /// @dev Removes any role authorization for the specified functions.
+    function unauthorizeFunctions(address target, IAccess.FunctionInfo[] memory functions) external;
+
+    /// @dev Locks/unlocks the specified target constrolled by the corresponding instance admin.
+    function setTargetLocked(address target, bool locked) external;
+
+    /// @dev Locks the complete instance, including all its components.
+    function setInstanceLocked(bool locked) external;
+
+    /// @dev Creates a new instance.
+    /// The caller becomes the owner of the new instance.
+    /// Creation of a new instance is achieved by this service through the creation and registration 
+    /// of a new clone of the master instance and then setting up the initial wiring and authorization 
+    /// of the necessary components.
+    /// @param allowAnyToken specifies whether the new instance is allowed to use any token or 
+    /// only tokens that are registered in the `TokenRegistry`. Use of tokens **not** registered in the
+    /// `TokenRegistry` may result in problems with token handline and is therefor not recommended. The 
+    /// use of such instances **is not supported** by Etherisc. 
+    function createInstance(bool allowAnyToken)
         external 
         returns (
-            Instance clonedInstance,
+            IInstance instance,
             NftId instanceNftId
         );
 
-    function createGifTarget(
-        NftId instanceNftId,
-        address targetAddress,
-        string memory targetName,
-        bytes4[][] memory selectors,
-        RoleId[] memory roles
-    ) external;
+    function upgradeInstanceReader() external;
+    function upgradeMasterInstanceReader(address instanceReaderAddress) external;
+
+    function setStakingLockingPeriod(Seconds stakeLockingPeriod) external;
+    function setStakingRewardRate(UFixed rewardRate) external;
+    function setStakingMaxAmount(Amount maxStakedAmount) external;
+
+    function refillInstanceRewardReserves(address rewardProvider, Amount dipAmount) external returns (Amount newBalance);
 
-    function setComponentLocked(bool locked) external;
+    /// @dev Defunds the staking reward reserves for the specified target.
+    function withdrawInstanceRewardReserves(Amount dipAmount) external returns (Amount newBalance);
 }