@etherisc/gif-next 0.0.2-d13bb9e-069 → 0.0.2-d18e1c5-511

package/contracts/examples/unpermissioned/SimpleProduct.sol

@@ -1,10 +1,13 @@
 // 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";
 import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
 import {IOracleService} from "../../oracle/IOracleService.sol";
 import {ORACLE} from "../../type/ObjectType.sol";
 import {NftId} from "../../type/NftId.sol";
@@ -32,38 +35,33 @@ contract SimpleProduct is
 
     constructor(
         address registry,
-        NftId instanceNftid,
+        NftId instanceNftId,
+        string memory name,
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
         IAuthorization authorization,
-        address initialOwner,
-        address token,
-        bool isInterceptor,
-        address pool,
-        address distribution
+        address initialOwner
     )
     {
         initialize(
             registry,
-            instanceNftid,
+            instanceNftId,
+            name,
+            productInfo,
+            feeInfo,
             authorization,
-            initialOwner,
-            "SimpleProduct",
-            token,
-            isInterceptor,
-            pool,
-            distribution); 
+            initialOwner); 
     }
 
 
     function initialize(
         address registry,
         NftId instanceNftid,
-        IAuthorization authorization,
-        address initialOwner,
         string memory name,
-        address token,
-        bool isInterceptor,
-        address pool,
-        address distribution
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
+        IAuthorization authorization,
+        address initialOwner
     )
         public
         virtual
@@ -72,23 +70,22 @@ contract SimpleProduct is
         _initializeBasicProduct(
             registry,
             instanceNftid,
-            authorization,
-            initialOwner,
             name,
-            token,
-            isInterceptor,
-            pool,
-            distribution); 
+            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
         );
     }
@@ -103,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,
@@ -146,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);
         }
@@ -187,6 +233,13 @@ contract SimpleProduct is
         _activate(policyNftId, activateAt);
     }
 
+    function adjustActivation(
+        NftId policyNftId,
+        Timestamp activateAt
+    ) public {
+        _adjustActivation(policyNftId, activateAt);
+    }
+
     function close(
         NftId policyNftId
     ) public {
@@ -201,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,
@@ -218,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(
@@ -234,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,
@@ -248,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(
@@ -281,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
     )
@@ -311,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);
         }
 
@@ -329,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/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, StateId oldState)
+    {
+        if (state.eqz()) {
+            revert ErrorBaseStoreStateZero(key32);
+        }
+
+        Metadata storage metadata = _metadata[key32];
+        oldState = metadata.state;
+        lastUpdatedIn = metadata.updatedIn;
+
+        if (oldState.eqz()) {
+            revert ErrorBaseStoreNotExisting(key32);
+        }
+
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(oldState, metadata.objectType, oldState, 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

@@ -1,20 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IInstance} from "./IInstance.sol";
-import {INSTANCE} from "../type/ObjectType.sol";
-import {InstanceReader} from "./InstanceReader.sol";
-import {IPolicy} from "../instance/module/IPolicy.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
 import {LibNftIdSet} from "../type/NftIdSet.sol";
-import {NftId} from "../type/NftId.sol";
-import {TimestampLib} from "../type/Timestamp.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);
@@ -34,93 +32,99 @@ contract BundleSet is
     mapping(NftId bundleNftId => LibNftIdSet.Set policies) internal _activePolicies;
 
     /// @dev links a policy to its bundle
-    // to link a policy it MUST NOT yet have been linked
-    function linkPolicy(NftId policyNftId) external restricted() {
-        NftId bundleNftId = _instance.getInstanceReader().getPolicyInfo(policyNftId).bundleNftId;
-        // decision will likely depend on the decision what to check here and what in the service
-        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+    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, bundleNftId)) {
+        if (!_isActive(poolNftId, _toBundleKey32(bundleNftId))) {
             revert ErrorBundleSetBundleLocked(bundleNftId, policyNftId);
         }
 
-        LibNftIdSet.add(_activePolicies[bundleNftId], policyNftId);
+        _activePolicies[bundleNftId].add(policyNftId);
         emit LogBundleSetPolicyLinked(bundleNftId, policyNftId);
     }
 
 
     /// @dev unlinks a policy from its bundle
-    // to unlink a policy it must closable, ie. meet one of the following criterias
-    // - the policy MUST be past its expiry period and it MUST NOT have any open claims
-    // - the policy's payoutAmount MUST be equal to its sumInsuredAmount and MUST NOT have any open claims
-    function unlinkPolicy(NftId policyNftId) external restricted() {
-        IPolicy.PolicyInfo memory policyInfo = _instance.getInstanceReader().getPolicyInfo(policyNftId);
-
-        NftId bundleNftId = policyInfo.bundleNftId;
-        // decision will likely depend on the decision what to check here and what in the service
-        NftId poolNftId = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+    function unlinkPolicy(NftId poolNftId, NftId bundleNftId, NftId policyNftId) external restricted() {
 
         // ensure bundle is registered with this instance
-        if (!_contains(poolNftId, bundleNftId)) {
+        if (!_contains(poolNftId, _toBundleKey32(bundleNftId))) {
             revert ErrorBundleSetBundleUnknown(bundleNftId);
         }
 
-        LibNftIdSet.remove(_activePolicies[bundleNftId], policyNftId);
-        emit LogBundleSetPolicyUnlinked(policyInfo.bundleNftId, policyNftId);
+        _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 = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
+        NftId poolNftId = ObjectSetHelperLib.getPoolNftId(_instanceAddress, bundleNftId);
 
         // ensure pool is registered with instance
         if(poolNftId.eqz()) {
             revert ErrorBundleSetBundleNotRegistered(bundleNftId);
         }
 
-        _add(poolNftId, 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 = _instance.getInstanceReader().getBundleInfo(bundleNftId).poolNftId;
-        _activate(poolNftId, bundleNftId);
+        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;
-        _deactivate(poolNftId, bundleNftId);
+        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 bundleNftId) {
-        return _getObject(poolNftId, idx);
+    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 bundleNftId) {
-        return _getActiveObject(poolNftId, idx);
+    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 LibNftIdSet.size(_activePolicies[bundleNftId]);
+        return _activePolicies[bundleNftId].size();
     }
 
     function getActivePolicy(NftId bundleNftId, uint256 idx) external view returns(NftId policyNftId) {
-        return LibNftIdSet.getElementAt(_activePolicies[bundleNftId], idx);
+        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);
+}