@etherisc/gif-next 0.0.2-8bdd2eb-413 → 0.0.2-8d9d4d6-542

package/contracts/oracle/OracleService.sol

@@ -0,0 +1,278 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {IComponent} from "../shared/IComponent.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IOracle} from "./IOracle.sol";
+import {IOracleComponent} from "./IOracleComponent.sol";
+import {IOracleService} from "./IOracleService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, ORACLE, INSTANCE} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId, ACTIVE, KEEP_STATE, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+
+
+contract OracleService is
+    ComponentVerifyingService,
+    IOracleService
+{
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address initialOwner;
+        address registryAddress;
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        initializeService(registryAddress, address(0), owner);
+        registerInterface(type(IOracleService).interfaceId);
+    }
+
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName
+    )
+        external 
+        virtual 
+        // restricted() // add authz
+        returns (
+            RequestId requestId
+        ) 
+    {
+        (
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(COMPONENT());
+
+        // oracleNftId exists and is active oracle
+        (
+            IRegistry.ObjectInfo memory oracleInfo, 
+        ) = _getAndVerifyComponentInfo(
+            oracleNftId, 
+            ORACLE(), 
+            true); // only active
+
+        // check that requester and oracle share same instance
+        if (componentInfo.parentNftId != oracleInfo.parentNftId) {
+            revert ErrorOracleServiceInstanceMismatch(componentInfo.parentNftId, oracleInfo.parentNftId);
+        }
+
+        // check expiriyAt >= now
+        if (expiryAt < TimestampLib.blockTimestamp()) {
+            revert ErrorOracleServiceExpiryInThePast(TimestampLib.blockTimestamp(), expiryAt);
+        }
+
+        // check callbackMethodName.length > 0
+        if (bytes(callbackMethodName).length == 0) {
+            revert ErrorOracleServiceCallbackMethodNameEmpty();
+        }
+
+        // create request info
+        IOracle.RequestInfo memory request = IOracle.RequestInfo({
+            requesterNftId: componentNftId,
+            callbackMethodName: callbackMethodName,
+            oracleNftId: oracleNftId,
+            requestData: requestData,
+            responseData: "",
+            respondedAt: TimestampLib.zero(),
+            expiredAt: expiryAt,
+            isCancelled: false
+        });
+
+        // store request with instance
+        requestId = instance.getInstanceStore().createRequest(request);
+
+        // call oracle component
+        IOracleComponent(oracleInfo.objectAddress).request(
+            requestId, 
+            componentNftId, 
+            requestData, 
+            expiryAt);
+
+        emit LogOracleServiceRequestCreated(requestId, componentNftId, oracleNftId, expiryAt);
+    }
+
+
+    /// @dev respond to oracle request by oracle compnent.
+    /// permissioned: only the oracle component linked to the request id may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    )
+        external
+        virtual
+        // restricted() // add authz
+        returns (bool success)
+    {
+        (
+            NftId oracleNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(ORACLE());
+
+        bool callerIsOracle = true;
+        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
+        request.responseData = responseData;
+        request.respondedAt = TimestampLib.blockTimestamp();
+
+        instance.getInstanceStore().updateRequest(
+            requestId, request, KEEP_STATE());
+
+        IRegistry.ObjectInfo memory requesterInfo = getRegistry().getObjectInfo(
+            request.requesterNftId);
+
+        string memory functionSignature = string(
+            abi.encodePacked(
+                request.callbackMethodName,
+                "(uint64,bytes)"
+            ));
+
+        (success, ) = requesterInfo.objectAddress.call(
+            abi.encodeWithSignature(
+                functionSignature, 
+                requestId,
+                responseData));
+
+        // check that calling requestor was successful
+        if (success) {
+            instance.getInstanceStore().updateRequestState(requestId, FULFILLED());
+        } else {
+            instance.getInstanceStore().updateRequestState(requestId, FAILED());
+            emit LogOracleServiceDeliveryFailed(requestId, requesterInfo.objectAddress, functionSignature);
+        }
+
+        emit LogOracleServiceResponseProcessed(requestId, oracleNftId);
+    }
+
+
+    function resend(RequestId requestId)
+        external 
+        virtual 
+        // restricted() // add authz
+    {
+        (
+            NftId requesterNftId,
+            IRegistry.ObjectInfo memory requesterInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(COMPONENT());
+
+        bool callerIsOracle = false;
+        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
+
+        // attempt to deliver response to requester
+        string memory functionSignature = string(
+            abi.encodePacked(
+                request.callbackMethodName,
+                "(uint64,bytes)"
+            ));
+
+        (bool success, bytes memory returnData) = requesterInfo.objectAddress.call(
+            abi.encodeWithSignature(
+                functionSignature, 
+                requestId,
+                request.responseData));
+
+        // check that calling requestor was successful
+        if (success) {
+            instance.getInstanceStore().updateRequestState(requestId, FULFILLED());
+            emit LogOracleServiceResponseResent(requestId, requesterNftId);
+        } else {
+            emit LogOracleServiceDeliveryFailed(requestId, requesterInfo.objectAddress, functionSignature);
+        }
+    }
+
+
+    function cancel(RequestId requestId)
+        external 
+        virtual 
+        // restricted() // add authz
+    {
+        (
+            NftId requesterNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(COMPONENT());
+
+        bool callerIsOracle = false;
+        // TODO property isCancelled and state update to CANCELLED are redundant, get rid of isCancelled
+        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
+        request.isCancelled = true;
+
+        instance.getInstanceStore().updateRequest(requestId, request, CANCELLED());
+
+        // call oracle component
+        // TODO add check that oracle is active?
+        address oracleAddress = getRegistry().getObjectInfo(request.oracleNftId).objectAddress;
+        IOracleComponent(oracleAddress).cancel(requestId);
+
+        emit LogOracleServiceRequestCancelled(requestId, requesterNftId);
+    }
+
+
+    function _checkAndGetRequestInfo(
+        IInstance instance,
+        RequestId requestId,
+        NftId callerNftId,
+        bool callerIsOracle
+    )
+        internal
+        virtual
+        view
+        returns (IOracle.RequestInfo memory info)
+    {
+        InstanceReader reader = instance.getInstanceReader();
+        StateId state = reader.getState(requestId.toKey32());
+
+        // check caller against resonsible oracle or requester
+        info = reader.getRequestInfo(requestId);
+        if (callerIsOracle) {
+            if (state != ACTIVE()) {
+                revert ErrorOracleServiceRequestStateNotActive(requestId, state);
+            }
+
+            if (callerNftId != info.oracleNftId) {
+                revert ErrorOracleServiceCallerNotResponsibleOracle(requestId, info.oracleNftId, callerNftId);
+            }
+        } else {
+            if (state != ACTIVE() && state != FAILED()) {
+                revert ErrorOracleServiceRequestStateNotActive(requestId, state);
+            }
+            if (callerNftId != info.requesterNftId) {
+                revert ErrorOracleServiceCallerNotRequester(requestId, info.requesterNftId, callerNftId);
+            }
+        }
+
+        // check expiry
+        if (info.expiredAt < TimestampLib.blockTimestamp()) {
+            revert ErrorOracleServiceRequestExpired(requestId, info.expiredAt);
+        }
+    }
+
+
+    function _getInstanceForComponent(NftId componentNftId)
+        internal
+        view
+        returns(IInstance instance)
+    {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return ORACLE();
+    }
+}

package/contracts/oracle/OracleServiceManager.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {OracleService} from "./OracleService.sol";
+import {Registry} from "../registry/Registry.sol";
+import {RegistryService} from "../registry/RegistryService.sol";
+import {REGISTRY} from "../type/ObjectType.sol";
+
+contract OracleServiceManager is ProxyManager {
+
+    OracleService private _oracleService;
+
+    /// @dev initializes proxy manager with service implementation and deploys instance
+    constructor(
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
+    {
+        OracleService orclSrv = new OracleService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
+            address(orclSrv), 
+            data,
+            salt);
+
+        _oracleService = OracleService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getOracleService()
+        external
+        view
+        returns (OracleService oracleService)
+    {
+        return _oracleService;
+    }
+
+}

package/contracts/pool/BundleService.sol

@@ -68,10 +68,6 @@ contract BundleService is
         registerInterface(type(IBundleService).interfaceId);
     }
 
-    function getDomain() public pure override returns(ObjectType) {
-        return BUNDLE();
-    }
-
 
     function setFee(
         NftId bundleNftId,
@@ -261,6 +257,23 @@ contract BundleService is
         instance.getInstanceStore().decreaseLocked(bundleNftId, collateralAmount);
     }
 
+    /// @dev unlinks policy from bundle
+    function unlinkPolicy(
+        IInstance instance, 
+        NftId policyNftId
+    ) 
+        external
+        virtual
+        restricted
+    {
+        // ensure policy is closeable
+        if (!instance.getInstanceReader().policyIsCloseable(policyNftId)) {
+            revert ErrorBundleServicePolicyNotCloseable(policyNftId);
+        }
+
+        instance.getBundleManager().unlinkPolicy(policyNftId);
+    }
+
     /// @dev links policy to bundle
     function _linkPolicy(IInstance instance, NftId policyNftId) 
         internal
@@ -277,20 +290,7 @@ contract BundleService is
         bundleManager.linkPolicy(policyNftId);
     }
 
-    /// @dev unlinks policy from bundle
-    function unlinkPolicy(
-        IInstance instance, 
-        NftId policyNftId
-    ) 
-        external
-        virtual
-        restricted
-    {
-        // ensure policy is closeable
-        if (!instance.getInstanceReader().policyIsCloseable(policyNftId)) {
-            revert ErrorBundleServicePolicyNotCloseable(policyNftId);
-        }
-
-        instance.getBundleManager().unlinkPolicy(policyNftId);
+    function _getDomain() internal pure override returns(ObjectType) {
+        return BUNDLE();
     }
 }

package/contracts/pool/PoolService.sol

@@ -84,10 +84,6 @@ contract PoolService is
         registerInterface(type(IPoolService).interfaceId);
     }
 
-    function getDomain() public pure override returns(ObjectType) {
-        return POOL();
-    }
-
 
     function setMaxCapitalAmount(Amount maxCapitalAmount)
         external
@@ -230,7 +226,7 @@ contract PoolService is
     ) 
         external
         virtual
-        restricted
+        restricted()
     {
         IRegistry registry = getRegistry();
         IRegistry.ObjectInfo memory bundleObjectInfo = registry.getObjectInfo(bundleNftId);
@@ -311,7 +307,7 @@ contract PoolService is
     )
         external
         virtual
-        restricted
+        restricted()
     {
         _bundleService.releaseCollateral(
             instance, 
@@ -337,7 +333,7 @@ contract PoolService is
     )
         external
         virtual
-        restricted
+        restricted()
     {
         Amount remainingCollateralAmount = policyInfo.sumInsuredAmount - policyInfo.claimAmount;
 
@@ -450,4 +446,7 @@ contract PoolService is
         }
     }
 
+    function _getDomain() internal pure override returns(ObjectType) {
+        return POOL();
+    }
 }

package/contracts/product/ApplicationService.sol

@@ -80,11 +80,6 @@ contract ApplicationService is
     }
 
 
-    function getDomain() public pure override returns(ObjectType) {
-        return APPLICATION();
-    }
-
-
     function _checkLinkedpplicationParameters(
         InstanceReader instanceReader,
         NftId productNftId,
@@ -251,4 +246,9 @@ contract ApplicationService is
     }
 
     // internal functions
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return APPLICATION();
+    }
 }

package/contracts/product/ClaimService.sol

@@ -73,11 +73,6 @@ contract ClaimService is
         registerInterface(type(IClaimService).interfaceId);
     }
 
-
-    function getDomain() public pure override returns(ObjectType) {
-        return CLAIM();
-    }
-
     function submit(
         NftId policyNftId, 
         Amount claimAmount,
@@ -439,4 +434,9 @@ contract ClaimService is
         // get claim info
         claimInfo = instanceReader.getClaimInfo(policyNftId, claimId);
     }
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return CLAIM();
+    }
 }

package/contracts/product/IClaimService.sol

@@ -45,6 +45,10 @@ interface IClaimService is
         bytes memory claimData
     ) external returns (ClaimId claimId);
 
+
+    // TODO add claim revoke functionality
+
+
     /// @dev declines the specified claim
     /// function can only be called by product, policy needs to match with calling product
     function decline(
@@ -53,6 +57,7 @@ interface IClaimService is
         bytes memory data // claim processing data
     ) external;
 
+
     /// @dev confirms the specified claim and specifies the payout amount
     /// function can only be called by product, policy needs to match with calling product
     function confirm(
@@ -62,6 +67,7 @@ interface IClaimService is
         bytes memory data // claim processing data
     ) external;
 
+
     /// @dev closes the specified claim
     /// function can only be called by product, policy needs to match with calling product
     function close(

package/contracts/product/PolicyService.sol

@@ -85,11 +85,6 @@ contract PolicyService is
     }
 
 
-    function getDomain() public pure override returns(ObjectType) {
-        return POLICY();
-    }
-
-
     function _getAndVerifyInstanceAndProduct() internal view returns (Product product) {
         IRegistry.ObjectInfo memory productInfo;
         (, productInfo,) = _getAndVerifyActiveComponent(PRODUCT());
@@ -472,4 +467,9 @@ contract PolicyService is
         poolWallet = instanceReader.getComponentInfo(productInfo.poolNftId).wallet;
         productWallet = instanceReader.getComponentInfo(productNftId).wallet;
     }
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return POLICY();
+    }
 }

package/contracts/product/PricingService.sol

@@ -56,11 +56,6 @@ contract PricingService is
         _distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION()));
     }
 
-
-    function getDomain() public pure override returns(ObjectType) {
-        return PRICE();
-    }
-
     /// @dev calculates the premium amount for the specified attributes
     /// also returns the various fee components involved with creating a policy
     function calculatePremium(
@@ -87,7 +82,7 @@ contract PricingService is
             (
                 IRegistry.ObjectInfo memory registryInfo, 
                 IInstance instance
-            ) = _getAndVerifyComponentInfo(productNftId, PRODUCT());
+            ) = _getAndVerifyComponentInfo(productNftId, PRODUCT(), false);
 
             reader = instance.getInstanceReader();
 
@@ -298,4 +293,8 @@ contract PricingService is
         premiumWithTargetWalletAmounts = premium;
     }
 
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return PRICE();
+    }
 }

package/contracts/product/ProductService.sol

@@ -75,11 +75,6 @@ contract ProductService is
     }
 
 
-    function getDomain() public pure override returns(ObjectType) {
-        return PRODUCT();
-    }
-
-
     function createRisk(
         RiskId riskId,
         bytes memory data
@@ -121,4 +116,9 @@ contract ProductService is
         (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
         instance.getInstanceStore().updateRiskState(riskId, state);
     }
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return PRODUCT();
+    }
 }

package/contracts/registry/IRegistry.sol

@@ -40,7 +40,7 @@ interface IRegistry is IERC165 {
         bytes data;
     }
 
-
+    // TODO cleanup
     struct ReleaseInfo {
         VersionPart version;
         bytes32 salt;

package/contracts/registry/Registry.sol

@@ -60,6 +60,12 @@ contract Registry is
     address public _stakingAddress;
     ReleaseManager public _releaseManager;
 
+    // TODO 
+    // 1). Registry and ReleaseManager must be treated as whole single entity. 
+    //     But current limitations of EVM does not allow it -> require it to be splitted
+    // 2). Keep onlyReleaseManager modifier
+    // 3). Delete onlyRegistryService in favor of restricted, introduce aditional "domain role", REGISTRY_SERVICE_ROLE
+    // 4). (For GlobalRegistry ONLY) make registerChainRegistry() restricted to GIF_ADMIN_ROLE
     modifier onlyRegistryService() {
         if(!_releaseManager.isActiveRegistryService(msg.sender)) {
             revert ErrorRegistryCallerNotRegistryService();
@@ -525,7 +531,7 @@ contract Registry is
     // 1) EACH object type MUST have only one parent type across ALL mappings
     // 2) DO NOT use object type (e.g. POLCY, BUNDLE, STAKE) as parent type
     // 3) DO NOT use REGISTRY as object type
-    // 2) DO NOT use PROTOCOL and "zeroObjectType"
+    // 2) DO NOT use PROTOCOL and "ObjectTypeLib.zero"
     function _setupValidCoreTypesAndCombinations() 
         private 
     {