@etherisc/gif-next 0.0.2-b9e43cf-870 → 0.0.2-bab959f-058

package/contracts/oracle/Oracle.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {COMPONENT, 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 register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getOracleStorage()._componentService.registerOracle();
+    }
+
+
+    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;
+    }
+
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        override(IInstanceLinkedComponent, InstanceLinkedComponent)
+        onlyOwner()
+        restricted()
+        returns (Amount withdrawnAmount)
+    {
+        revert ErrorOracleNotImplemented("withdrawFees");
+    }
+
+
+    function _initializeOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // component specifidc data 
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            ORACLE(), 
+            authorization,
+            true, 
+            initialOwner, 
+            registryData, 
+            componentData);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        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,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,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 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/BasicPool.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IBundleService} from "./IBundleService.sol";
+import {IPoolComponent} from "./IPoolComponent.sol";
+import {IPoolService} from "./IPoolService.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+import {Pool} from "./Pool.sol";
+
+abstract contract BasicPool is
+    Pool
+{
+
+    function _initializeBasicPool(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address token,
+        string memory name,
+        address initialOwner
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializePool(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            authorization,
+            false, // isInterceptingNftTransfers, 
+            initialOwner, 
+            "", // registryData
+            ""); // componentData
+    }
+
+    function stake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _stake(bundleNftId, amount);
+    }
+
+
+    function unstake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _unstake(bundleNftId, amount);
+    }
+
+
+    function extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+        returns(Timestamp newExpiredAt)
+    {
+        return _extend(bundleNftId, lifetimeExtension);
+    }
+
+
+    function lockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _lockBundle(bundleNftId);
+    }
+
+
+    function unlockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _unlockBundle(bundleNftId);
+    }
+
+
+    function close(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _close(bundleNftId);
+    }
+
+
+    function setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _setBundleFee(bundleNftId, fee);
+    }
+
+
+    function setMaxCapitalAmount(Amount maxCapitalAmount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setMaxCapitalAmount(maxCapitalAmount);
+    }
+
+
+    function setBundleOwnerRole(RoleId bundleOwnerRole)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setBundleOwnerRole(bundleOwnerRole);
+    }
+
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setPoolFees(poolFee, stakingFee, performanceFee);
+    }
+}

package/contracts/pool/BasicPoolAuthorization.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicPool} from "./BasicPool.sol"; 
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {IPoolComponent} from "./IPoolComponent.sol";
+import {POOL} from "../type/ObjectType.sol";
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicPoolAuthorization
+     is Authorization
+{
+
+     constructor(string memory poolName)
+          Authorization(poolName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          _addComponentTargetWithRole(POOL()); // basic pool target
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicPool.stake.selector, "stake");
+          _authorize(functions, BasicPool.unstake.selector, "unstake");
+          _authorize(functions, BasicPool.extend.selector, "extend");
+          _authorize(functions, BasicPool.lockBundle.selector, "lockBundle");
+          _authorize(functions, BasicPool.unlockBundle.selector, "unlockBundle");
+          _authorize(functions, BasicPool.close.selector, "close");
+          _authorize(functions, BasicPool.setBundleFee.selector, "setBundleFee");
+
+          _authorize(functions, BasicPool.setMaxCapitalAmount.selector, "setMaxCapitalAmount");
+          _authorize(functions, BasicPool.setBundleOwnerRole.selector, "setBundleOwnerRole");
+          _authorize(functions, BasicPool.setFees.selector, "setFees");
+          _authorize(functions, BasicPool.stake.selector, "stake");
+          _authorize(functions, BasicPool.unstake.selector, "unstake");
+          _authorize(functions, BasicPool.extend.selector, "extend");
+
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
+
+          _authorize(functions, IPoolComponent.withdrawBundleFees.selector, "withdrawBundleFees");
+     }
+}
+