@etherisc/gif-next 0.0.2-e79d227-681 → 0.0.2-e7a5428-226

package/contracts/examples/unpermissioned/SimpleProduct.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {Amount, AmountLib} from "../../type/Amount.sol";
 import {BasicProduct} from "../../product/BasicProduct.sol";
 import {ClaimId} from "../../type/ClaimId.sol";
@@ -35,8 +37,8 @@ contract SimpleProduct is
         address registry,
         NftId instanceNftId,
         string memory name,
-        address token,
         IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
         IAuthorization authorization,
         address initialOwner
     )
@@ -45,8 +47,8 @@ contract SimpleProduct is
             registry,
             instanceNftId,
             name,
-            token,
             productInfo,
+            feeInfo,
             authorization,
             initialOwner); 
     }
@@ -56,8 +58,8 @@ contract SimpleProduct is
         address registry,
         NftId instanceNftid,
         string memory name,
-        address token,
         IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
         IAuthorization authorization,
         address initialOwner
     )
@@ -69,20 +71,21 @@ contract SimpleProduct is
             registry,
             instanceNftid,
             name,
-            token,
             productInfo,
+            feeInfo,
             authorization,
             initialOwner); 
 
         _oracleService = IOracleService(_getServiceAddress(ORACLE()));
     }
 
+
     function createRisk(
-        RiskId id,
+        string memory id,
         bytes memory data
-    ) public {
-        _createRisk(
-            id,
+    ) public returns (RiskId) {
+        return _createRisk(
+            bytes32(abi.encodePacked(id)),
             data
         );
     }
@@ -97,16 +100,22 @@ contract SimpleProduct is
         );
     }
 
-    function updateRiskState(
+    function setRiskLocked(
         RiskId id,
-        StateId state
+        bool locked
     ) public {
-        _updateRiskState(
+        _setRiskLocked(
             id,
-            state
+            locked
         );
     }
 
+    function closeRisk(
+        RiskId id
+    ) public {
+        _closeRisk(id);
+    }
+
     function createApplication(
         address applicationOwner,
         RiskId riskId,
@@ -140,12 +149,55 @@ contract SimpleProduct is
         );
     }
 
+    function createApplication2(
+        address applicationOwner,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        public
+        returns (NftId nftId)
+    {
+        return _createApplication(
+            applicationOwner,
+            riskId,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId,
+            referralId,
+            applicationData
+        );
+    }
+    
+    function revoke(
+        NftId applicationNftId
+    ) public {
+        _revoke(applicationNftId);
+    }
+
     function createPolicy(
         NftId applicationNftId,
         bool requirePremiumPayment,
         Timestamp activateAt
     ) public {
-        _createPolicy(applicationNftId, activateAt);
+        _createPolicy(applicationNftId, activateAt, AmountLib.max());
+        if (requirePremiumPayment == true) {
+            _collectPremium(applicationNftId, activateAt);
+        }
+    }
+
+    function createPolicy2(
+        NftId applicationNftId,
+        bool requirePremiumPayment,
+        Timestamp activateAt,
+        Amount maxPremiumAmount
+    ) public {
+        _createPolicy(applicationNftId, activateAt, maxPremiumAmount);
         if (requirePremiumPayment == true) {
             _collectPremium(applicationNftId, activateAt);
         }
@@ -181,6 +233,13 @@ contract SimpleProduct is
         _activate(policyNftId, activateAt);
     }
 
+    function adjustActivation(
+        NftId policyNftId,
+        Timestamp activateAt
+    ) public {
+        _adjustActivation(policyNftId, activateAt);
+    }
+
     function close(
         NftId policyNftId
     ) public {
@@ -195,6 +254,13 @@ contract SimpleProduct is
         return _submitClaim(policyNftId, claimAmount, submissionData);
     }
 
+    function revokeClaim(
+        NftId policyNftId,
+        ClaimId claimId
+    ) public {
+        _revokeClaim(policyNftId, claimId);
+    }
+
     function confirmClaim(
         NftId policyNftId,
         ClaimId claimId,
@@ -212,11 +278,11 @@ contract SimpleProduct is
         _declineClaim(policyNftId, claimId, processData);
     }
 
-    function closeClaim(
+    function cancelConfirmedClaim(
         NftId policyNftId,
         ClaimId claimId
     ) public {
-        _closeClaim(policyNftId, claimId);
+        _cancelConfirmedClaim(policyNftId, claimId);
     }
 
     function createPayout(
@@ -228,6 +294,13 @@ contract SimpleProduct is
         return _createPayout(policyNftId, claimId, amount, data);
     }
 
+    function cancelPayout(
+        NftId policyNftId,
+        PayoutId payoutId
+    ) public {
+        _cancelPayout(policyNftId, payoutId);
+    }
+
     // TODO add test
     function createPayoutForBeneficiary(
         NftId policyNftId,
@@ -242,8 +315,8 @@ contract SimpleProduct is
     function processPayout(
         NftId policyNftId,
         PayoutId payoutId
-    ) public {
-        _processPayout(policyNftId, payoutId);
+    ) public returns (Amount netPayoutAmount, Amount processingFeeAmount) {
+        (netPayoutAmount, processingFeeAmount) = _processPayout(policyNftId, payoutId);
     }
 
     function createOracleRequest(
@@ -275,6 +348,28 @@ contract SimpleProduct is
         }
     }
 
+    function createOracleRequest2(
+        NftId oracleNftId,
+        string memory requestText,
+        Timestamp expiryAt,
+        bool synchronous,
+        string memory callbackMethod
+    )
+        public
+        // restricted()
+        returns (RequestId)
+    {
+        bytes memory requestData = abi.encode(SimpleOracle.SimpleRequest(
+            synchronous,
+            requestText));
+
+        return _oracleService.request(
+            oracleNftId, 
+            requestData, 
+            expiryAt, 
+            callbackMethod);
+    }
+
     function cancelOracleRequest(
         RequestId requestId
     )
@@ -305,7 +400,7 @@ contract SimpleProduct is
         SimpleOracle.SimpleResponse memory response = abi.decode(
             responseData, (SimpleOracle.SimpleResponse));
 
-        if (response.revertInCall && response.revertUntil >= TimestampLib.blockTimestamp()) {
+        if (response.revertInCall && response.revertUntil >= TimestampLib.current()) {
             revert ErrorSimpleProductRevertedWhileProcessingResponse(requestId);
         }
 
@@ -323,23 +418,20 @@ contract SimpleProduct is
     }
 
 
-    function doSomethingSpecial() 
+    function doSomethingOnlyWhenActive() 
         public 
-        restricted()
+        onlyActive()
         returns (bool) 
     {
         return true;
     }
 
-    function doWhenNotLocked() 
-        public 
-        restricted()
-        returns (bool) 
-    {
-        return true;
-    }
 
     function getOracleService() public view returns (IOracleService) {
         return _oracleService;
     }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setLocked(bool locked) external onlyOwner() { _setLocked(locked); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
 }

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/BundleSet.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IPolicy} from "../instance/module/IPolicy.sol";
 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
@@ -60,7 +60,7 @@ contract BundleSet is
     /// @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 = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
 
         // ensure pool is registered with instance
         if(poolNftId.eqz()) {
@@ -74,14 +74,14 @@ contract BundleSet is
 
     /// @dev unlocked (active) bundles are available to collateralize new policies
     function unlock(NftId bundleNftId) external restricted() {
-        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        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 = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
         _deactivate(poolNftId, _toBundleKey32(bundleNftId));
         emit LogBundleSetBundleLocked(poolNftId, bundleNftId);
     }

package/contracts/instance/IInstance.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
 
 import {Amount} from "../type/Amount.sol";
 import {BundleSet} from "./BundleSet.sol";
@@ -9,22 +10,32 @@ import {RiskSet} from "./RiskSet.sol";
 import {InstanceAdmin} from "./InstanceAdmin.sol";
 import {InstanceReader} from "./InstanceReader.sol";
 import {InstanceStore} from "./InstanceStore.sol";
-import {IRegisterable} from "../shared/IRegisterable.sol";
-import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
 import {NftId} from "../type/NftId.sol";
 import {RoleId} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {VersionPart} from "../type/Version.sol";
 
 
 interface IInstance is 
-    IRegisterable, 
-    ITransferInterceptor, 
-    IAccessManaged
+    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);
+
+    // 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 ErrorInstanceInstanceAdminAlreadySet(address instanceAdmin);
     error ErrorInstanceInstanceAdminAuthorityMismatch(address instanceAuthority);
 
     error ErrorInstanceBundleSetAlreadySet(address instanceBundleSet);
@@ -44,29 +55,91 @@ interface IInstance is
         uint64 requestsCount;
     }
 
-    /// @dev Register a product with the instance.
-    function registerProduct(address product) external returns (NftId productNftId);
+    ///--- instance ---------------------------------------------------------//
 
-    function createRole(string memory roleName, string memory adminName) external returns (RoleId roleId, RoleId admin);
-    function grantRole(RoleId roleId, address account) external;
-    function revokeRole(RoleId roleId, address account) external;
+    /// @dev Locks/unlocks the complete instance, including all its components.
+    function setInstanceLocked(bool locked) 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 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;
-    function refillStakingRewardReserves(Amount dipAmount) 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.
-    /// Permissioned: only the target owner may call this function.
     function withdrawStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
 
-    // get instance release and supporting contracts
+    ///--- 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;
+
+    /// @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);
+
+    // get products
+    function products() external view returns (uint256 productCount);
+    function getProductNftId(uint256 idx) external view returns (NftId productNftId);
+
+    // get supporting contracts
     function getInstanceReader() external view returns (InstanceReader);
     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 isTokenRegistryDisabled() external view returns (bool);
 }

package/contracts/instance/IInstanceService.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../type/Amount.sol";
+import {IAccess} from "../authorization/IAccess.sol";
 import {IInstance} from "./IInstance.sol";
-import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.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";
@@ -17,7 +18,7 @@ interface IInstanceService is IService {
     // onlyInstance
     error ErrorInstanceServiceNotRegistered(address instance);
     error ErrorInstanceServiceNotInstance(address instance, ObjectType objectType);
-    error ErrorInstanceServiceInstanceVersionMismatch(address instance, VersionPart instanceVersion);
+    error ErrorInstanceServiceInstanceVersionMismatch(NftId instanceNftId, VersionPart expectedRelease, VersionPart instanceRelease);
 
     error ErrorInstanceServiceComponentNotInstanceLinked(address component);
 
@@ -53,22 +54,64 @@ interface IInstanceService is IService {
     error ErrorInstanceServiceInstanceComponentMismatch(NftId instanceNftId, NftId componentNftId);
     error ErrorInstanceServiceInvalidComponentType(address componentAddress, ObjectType expectedType, ObjectType componentType);
     
-    event LogInstanceCloned(NftId instanceNftId, address instance);
+    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; 
 
-    function createInstance()
+    /// @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 (
             IInstance instance,
             NftId instanceNftId
         );
 
+    function upgradeInstanceReader() external;
+    function upgradeMasterInstanceReader(address instanceReaderAddress) external;
 
     function setStakingLockingPeriod(Seconds stakeLockingPeriod) external;
     function setStakingRewardRate(UFixed rewardRate) external;
-    function refillStakingRewardReserves(address rewardProvider, Amount dipAmount) external;
+    function setStakingMaxAmount(Amount maxStakedAmount) external;
 
-    /// @dev Defunds the staking reward reserves for the specified target.
-    function withdrawStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
+    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);
 }