@etherisc/gif-next 0.0.2-f08d150-296 → 0.0.2-f0ccf08-591

package/contracts/oracle/IOracleService.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracleService is IService {
+
+    event LogOracleServiceRequestCreated(RequestId requestId, NftId requesterNftId, NftId oracleNftId, Timestamp expiryAt);
+    event LogOracleServiceResponseProcessed(RequestId requestId, NftId oracleNftId);
+    event LogOracleServiceDeliveryFailed(RequestId requestId, address requesterAddress, string functionSignature);
+    event LogOracleServiceResponseResent(RequestId requestId, NftId requesterNftId);
+    event LogOracleServiceRequestCancelled(RequestId requestId, NftId requesterNftId);
+
+    // create request
+    error ErrorOracleServiceProductMismatch(ObjectType callerObjectType, NftId productNft, NftId oracleParentNftId);
+    error ErrorOracleServiceExpiryInThePast(Timestamp blockTimestamp, Timestamp expiryAt);
+    error ErrorOracleServiceCallbackMethodNameEmpty();
+
+    // respond
+    error ErrorOracleServiceNotResponsibleOracle(RequestId requestId, NftId expectedOracleNftId, NftId oracleNftId);
+
+    // get request info
+    error ErrorOracleServiceRequestStateNotActive(RequestId requestId, StateId state);
+    error ErrorOracleServiceCallerNotResponsibleOracle(RequestId requestId, NftId oracleNftId, NftId callerNftId);
+    error ErrorOracleServiceCallerNotRequester(RequestId requestId, NftId requesterNftId, NftId callerNftId);
+    error ErrorOracleServiceRequestExpired(RequestId requestId, Timestamp expiredAt);
+    
+    /// @dev send an oracle request to the specified oracle component.
+    /// the function returns the id of the newly created request.
+    /// permissioned: only registered components may send requests to oracles.
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName
+    ) external returns (RequestId requestId);
+
+    /// @dev respond to oracle request by oracle compnent.
+    /// the response data is amende in the request info stored with the instance.
+    /// the request state changes to FULFILLED (when calling the callback method of the requester is successful)
+    /// or to FAILED when calling the requester is not succesful.
+    /// the function returns true iff the state changes to FULFILLED.
+    /// permissioned: only the oracle component linked to the request id may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    ) external returns (bool success);
+
+    /// @dev re send a failed response to the requester.
+    /// only requests in state FAILED may be re sent.
+    /// the request state changes to FULFILLED when calling the callback method of the requester is successful.
+    /// permissioned: only the requester may resend a request
+    function resend(RequestId requestId) external;
+
+    /// @dev notify the oracle component that the specified request has become invalid.
+    /// only requests in state ACTIVE may be cancelled.
+    /// permissioned: only the requester may cancel a request
+    function cancel(RequestId requestId) external;
+
+}

package/contracts/oracle/Oracle.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {COMPONENT, PRODUCT, ORACLE} from "../type/ObjectType.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {IOracleComponent} from "./IOracleComponent.sol";
+import {IOracleService} from "./IOracleService.sol";
+import {NftId} from "../type/NftId.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+abstract contract Oracle is
+    InstanceLinkedComponent,
+    IOracleComponent
+{
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Oracle")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant ORACLE_STORAGE_LOCATION_V1 = 0xaab7c0ea03d290e56d6c060e0733d3ebcbe647f7694616a2ec52738a64b2f900;
+
+    struct OracleStorage {
+        IComponentService _componentService;
+        IOracleService _oracleService;
+    }
+
+
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        external
+        virtual
+        restricted()
+    {
+        _request(requestId, requesterId, requestData, expiryAt);
+    }
+
+
+    function cancel(
+        RequestId requestId
+    )
+        external
+        virtual
+        restricted()
+    {
+        _cancel(requestId);
+    }
+
+
+    /// @dev Not relevant for oracle components, always returns false.
+    function isVerifying()
+        external 
+        virtual 
+        view 
+        returns (bool verifying)
+    {
+        return false;
+    }
+
+    /// @dev Not relevant for oracle components
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        override(IInstanceLinkedComponent, InstanceLinkedComponent)
+        onlyOwner()
+        restricted()
+        returns (Amount)
+    {
+        revert ErrorOracleNotImplemented("withdrawFees");
+    }
+
+
+    function _initializeOracle(
+        address registry,
+        NftId productNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        bytes memory componentData // component specifidc data 
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeInstanceLinkedComponent(
+            registry, 
+            productNftId, 
+            name, 
+            ORACLE(), 
+            authorization,
+            true, 
+            initialOwner, 
+            componentData);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+
+        _registerInterface(type(IOracleComponent).interfaceId);
+    }
+
+
+    /// @dev Internal function for handling requests.
+    /// Empty implementation.
+    /// Overwrite this function to implement use case specific handling for oracle calls.
+    function _request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        internal
+        virtual
+    {
+    }
+
+
+    /// @dev Internal function for cancelling requests.
+    /// Empty implementation.
+    /// Overwrite this function to implement use case specific cancelling.
+    function _cancel(
+        RequestId requestId
+    )
+        internal
+        virtual
+    {
+    }
+
+
+    /// @dev Internal function for handling oracle responses.
+    /// Default implementation sends response back to oracle service.
+    /// Use this function in use case specific external/public functions to handle use case specific response handling.
+    function _respond(
+        RequestId requestId,
+        bytes memory responseData
+    )
+        internal
+        virtual
+    {
+        _getOracleStorage()._oracleService.respond(
+            requestId, responseData);
+    }
+
+    function _getOracleStorage() private pure returns (OracleStorage storage $) {
+        assembly {
+            $.slot := ORACLE_STORAGE_LOCATION_V1
+        }
+    }
+}

package/contracts/oracle/OracleService.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ContractLib} from "../shared/ContractLib.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, PRODUCT} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {Service} from "../shared/Service.sol";
+import {StateId, ACTIVE, KEEP_STATE, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+
+
+contract OracleService is
+    Service,
+    IOracleService
+{
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer()
+    {
+        (
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
+
+        __Service_init(authority, registry, owner);
+        _registerInterface(type(IOracleService).interfaceId);
+    }
+
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName
+    )
+        external 
+        virtual 
+        restricted()
+        onlyNftOfType(oracleNftId, ORACLE())
+        returns (RequestId requestId) 
+    {
+        // checks
+        // get and check active caller
+        (
+            IRegistry.ObjectInfo memory requesterInfo, 
+            address instance
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+
+        (
+            NftId requesterNftId,
+            IOracleComponent oracle
+        ) = _checkRequestParams(
+            getRegistry(), oracleNftId, requesterInfo, expiryAt, callbackMethodName);
+
+        // effects
+        {
+            // create request info
+            IOracle.RequestInfo memory request = IOracle.RequestInfo({
+                requesterNftId: requesterNftId,
+                callbackMethodName: callbackMethodName,
+                oracleNftId: oracleNftId,
+                requestData: requestData,
+                responseData: "",
+                respondedAt: TimestampLib.zero(),
+                expiredAt: expiryAt,
+                isCancelled: false
+            });
+
+            // store request with instance
+            requestId = IInstance(instance).getInstanceStore().createRequest(request);
+        }
+
+        emit LogOracleServiceRequestCreated(requestId, requesterNftId, oracleNftId, expiryAt);
+
+        // interactions
+        // callback to oracle component
+        oracle.request(
+            requestId, 
+            requesterNftId, 
+            requestData, 
+            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()
+        returns (bool success)
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            getRegistry(), msg.sender, ORACLE(), true);
+
+        NftId oracleNftId = info.nftId;
+        IInstance instance = IInstance(instanceAddress);
+        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()
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+
+        NftId requesterNftId = info.nftId;
+        IInstance instance = IInstance(instanceAddress);
+        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) = info.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, info.objectAddress, functionSignature);
+        }
+    }
+
+
+    function cancel(RequestId requestId)
+        external 
+        virtual 
+        restricted()
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+
+        NftId requesterNftId = info.nftId;
+        IInstance instance = IInstance(instanceAddress);
+        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().getObjectAddress(request.oracleNftId);
+        IOracleComponent(oracleAddress).cancel(requestId);
+
+        emit LogOracleServiceRequestCancelled(requestId, requesterNftId);
+    }
+
+
+    function _checkRequestParams(
+        IRegistry registry,
+        NftId oracleNftId,
+        IRegistry.ObjectInfo memory requesterInfo,
+        Timestamp expiryAt,
+        string memory callbackMethodName
+    )
+        internal
+        virtual
+        view
+        returns (
+            NftId requesterNftId,
+            IOracleComponent oracle
+        )
+    {
+        // get oracle info
+        (IRegistry.ObjectInfo memory oracleInfo,) = ContractLib.getInfoAndInstance(
+            registry, oracleNftId, true);
+
+        // obtain return values
+        requesterNftId = requesterInfo.nftId;
+        oracle = IOracleComponent(oracleInfo.objectAddress);
+
+        // check that requester and oracle share same product cluster
+        if (requesterInfo.objectType == PRODUCT()) {
+            if (oracleInfo.parentNftId != requesterNftId) {
+                revert ErrorOracleServiceProductMismatch(requesterInfo.objectType, requesterNftId, oracleInfo.parentNftId);
+            }
+        } else {
+            if (oracleInfo.parentNftId != requesterInfo.parentNftId) {
+                revert ErrorOracleServiceProductMismatch(requesterInfo.objectType, requesterInfo.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();
+        }
+    }
+
+
+    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 _getDomain() internal pure override returns(ObjectType) {
+        return ORACLE();
+    }
+}

package/contracts/oracle/OracleServiceManager.sol

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