@etherisc/gif-next 3.0.0-1cf51f6-275 → 3.0.0-46119ac-539

package/contracts/examples/flight/originalV1.sol

@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: Apache-2.0
+// pragma solidity ^0.8.20;
+pragma solidity ^0.8.20;
+
+// import "@etherisc/gif-interface/contracts/0.7/Product.sol";
+
+// contract FlightDelayChainlink is Product {
+contract FlightDelayChainlink {
+
+    bytes32 public constant NAME = "FlightDelayChainlink";
+    bytes32 public constant VERSION = "0.1.6";
+
+    event LogRequestFlightRatings(uint256 requestId, bytes32 carrierFlightNumber, uint256 departureTime, uint256 arrivalTime, bytes32 riskId);
+    event LogRequestFlightStatus(uint256 requestId, uint256 arrivalTime, bytes32 carrierFlightNumber, bytes32 departureYearMonthDay);
+    event LogPayoutTransferred(bytes32 bpKey, uint256 claimId, uint256 payoutId, uint256 amount);
+    event LogError(string error, uint256 index, uint256 stored, uint256 calculated);
+    event LogUnprocessableStatus(bytes32 bpKey, uint256 requestId);
+    event LogPolicyExpired(bytes32 bpKey);
+    event LogRequestPayment(bytes32 bpKey, uint256 requestId);
+    event LogUnexpectedStatus(bytes32 bpKey, uint256 requestId, bytes1 status, int256 delay, address customer);
+
+    event LogCallback(bytes32 _bytes, bytes _data);
+
+
+    bytes32 public constant POLICY_FLOW = "PolicyFlowDefault";
+
+    // Minimum observations for valid prediction
+    uint256 public constant MIN_OBSERVATIONS = 10;
+    // Minimum time before departure for applying
+    uint256 public constant MIN_TIME_BEFORE_DEPARTURE = 14 * 24 hours;
+    // Maximum time before departure for applying
+    uint256 public constant MAX_TIME_BEFORE_DEPARTURE = 90 * 24 hours;
+    // Maximum duration of flight
+    uint256 public constant MAX_FLIGHT_DURATION = 2 days;
+    // Check for delay after .. minutes after scheduled arrival
+    uint256 public constant CHECK_OFFSET = 1 hours;
+
+    // uint256 public constant MIN_PREMIUM = 15 * 10 ** 18; // production
+    // All amounts in cent = multiplier is 10 ** 16!
+    uint256 public constant MIN_PREMIUM = 1500 * 10 ** 16; // for testing purposes
+    uint256 public constant MAX_PREMIUM = 1500 * 10 ** 16; // in cent
+    uint256 public constant MAX_PAYOUT = 75000  * 10 ** 16; // in cent
+    uint256 public constant MARGIN_PERCENT = 30;
+    string public constant RATINGS_CALLBACK = "flightRatingsCallback";
+    string public constant STATUSES_CALLBACK = "flightStatusCallback";
+
+    // ['observations','late15','late30','late45','cancelled','diverted']
+    uint8[6] public weightPattern = [0, 0, 0, 30, 50, 50];
+    uint8 public constant maxWeight = 50;
+
+    // Maximum cumulated weighted premium per risk
+    uint256 public constant MAX_TOTAL_PAYOUT = 3 * MAX_PAYOUT; // Maximum risk per flight is 3x max payout.
+
+    struct Risk {
+        bytes32 carrierFlightNumber;
+        bytes32 departureYearMonthDay;
+        uint256 departureTime;
+        uint256 arrivalTime;
+        uint delayInMinutes;
+        uint8 delay;
+        uint256 estimatedMaxTotalPayout;
+        uint256 premiumMultiplier;
+        uint256 weight;
+    }
+
+    mapping(bytes32 => Risk) public risks;
+    mapping(bytes32 => address) public bpKeyToAddress;
+    mapping(address => bytes32[]) public addressToBpKeys;
+    mapping(address => uint256) public addressToPolicyCount;
+
+    uint256 public uniqueIndex;
+    bytes32 public ratingsOracleType;
+    uint256 public ratingsOracleId;
+    bytes32 public statusesOracleType;
+    uint256 public statusesOracleId;
+
+    address public owner;
+
+    uint256 public productId;
+
+    // empty modifier to support compiling without inheritance from V1 product
+    modifier onlyOwner() { _; }
+    modifier onlyOracle() { _; }
+
+    constructor(
+        address _productServiceAddress,
+        bytes32 _ratingsOracleType,
+        uint256 _ratingsOracleId,
+        bytes32 _statusesOracleType,
+        uint256 _statusesOracleId
+    )
+        // Product(_productServiceAddress, NAME, POLICY_FLOW)
+    {
+        setOracles(_ratingsOracleType, _ratingsOracleId, _statusesOracleType, _statusesOracleId);
+    }
+
+    function setOracles(
+        bytes32 _ratingsOracleType,
+        uint256 _ratingsOracleId,
+        bytes32 _statusesOracleType,
+        uint256 _statusesOracleId
+    )
+        public
+        onlyOwner
+    {
+        ratingsOracleType = _ratingsOracleType;
+        ratingsOracleId = _ratingsOracleId;
+        statusesOracleType = _statusesOracleType;
+        statusesOracleId = _statusesOracleId;
+    }
+
+    function uniqueId(address _addr)
+        internal
+        returns (bytes32 _uniqueId)
+    {
+        uniqueIndex += 1;
+        return keccak256(abi.encode(_addr, productId, uniqueIndex));
+    }
+
+    function getValue() internal returns(uint256) {
+        return msg.value;
+    }
+
+    function applyForPolicy(
+        // domain specific
+        bytes32 _carrierFlightNumber,
+        bytes32 _departureYearMonthDay,
+        uint256 _departureTime,
+        uint256 _arrivalTime,
+        uint256[5] memory _payouts
+    ) external payable {
+        // Validate input parameters
+
+        uint256 premium = getValue();
+        bytes32 bpKey = uniqueId(msg.sender);
+
+        require(premium >= MIN_PREMIUM, "ERROR:FDD-001:INVALID_PREMIUM");
+        require(premium <= MAX_PREMIUM, "ERROR:FDD-002:INVALID_PREMIUM");
+        require(_arrivalTime > _departureTime, "ERROR:FDD-003:ARRIVAL_BEFORE_DEPARTURE_TIME");
+        /* for demo uncommented ********************************************************/
+        require(
+            _arrivalTime <= _departureTime + MAX_FLIGHT_DURATION,
+            "ERROR:FDD-004:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+        require(
+            _departureTime >= block.timestamp + MIN_TIME_BEFORE_DEPARTURE,
+            "ERROR:FDD-012:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+        require(
+            _departureTime <= block.timestamp + MAX_TIME_BEFORE_DEPARTURE,
+            "ERROR:FDD-005:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+
+        // Create risk if not exists
+        bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
+        Risk storage risk = risks[riskId];
+
+        if (risk.carrierFlightNumber == "") {
+            risk.carrierFlightNumber = _carrierFlightNumber;
+            risk.departureYearMonthDay = _departureYearMonthDay;
+            risk.departureTime = _departureTime;
+            risk.arrivalTime = _arrivalTime;
+        }
+
+        require (
+            premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout < MAX_TOTAL_PAYOUT,
+            "ERROR:FDD-006:CLUSTER_RISK"
+        );
+
+        // if this is the first policy for this flight,
+        // we "block" this risk by setting risk.estimatedMaxTotalPayout to
+        // the maximum. Next flight for this risk can only be insured after this one has been underwritten.
+        if (risk.estimatedMaxTotalPayout == 0) {
+            risk.estimatedMaxTotalPayout = MAX_TOTAL_PAYOUT;
+        }
+
+        // Create new application
+        // _newApplication(bpKey, abi.encode(premium, _payouts, msg.sender, riskId));
+
+        // // Request flight ratings
+        uint256 requestId; // = _request(
+        //     bpKey,
+        //     abi.encode(_carrierFlightNumber),
+        //     RATINGS_CALLBACK,
+        //     ratingsOracleType,
+        //     ratingsOracleId
+        // );
+
+        emit LogRequestFlightRatings(
+            requestId,
+            _carrierFlightNumber,
+            _departureTime,
+            _arrivalTime,
+            riskId
+        );
+
+        /**
+         * Record bpKey to address relation for easier lookup.
+         */
+        bpKeyToAddress[bpKey] = msg.sender;
+        addressToBpKeys[msg.sender].push(bpKey);
+        addressToPolicyCount[msg.sender] += 1;
+
+    }
+
+    function checkApplication(
+        bytes32 _carrierFlightNumber,
+        uint256 _departureTime,
+        uint256 _arrivalTime,
+        uint256 _premium
+    )
+    external view
+    returns (uint256 errors)
+    {
+        // Validate input parameters
+        if (_premium < MIN_PREMIUM) errors = errors | (uint256(1) << 0);
+        if (_premium > MAX_PREMIUM) errors = errors | (uint256(1) << 1);
+        if (_arrivalTime < _departureTime) errors = errors | (uint256(1) << 2);
+        if (_arrivalTime > _departureTime + MAX_FLIGHT_DURATION) errors = errors | (uint256(1) << 3);
+        if (_departureTime < block.timestamp + MIN_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 4);
+        if (_departureTime > block.timestamp + MAX_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 5);
+        bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
+        Risk storage risk = risks[riskId];
+        if (_premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout >= MAX_TOTAL_PAYOUT) errors = errors | (uint256(1) << 6);
+
+        return errors;
+    }
+
+    function declineAndPayback(bytes32 _bpKey, address payable _customer, uint256 _premium)
+        internal
+    {
+        // _decline(_bpKey);
+        // _customer.transfer(_premium);
+    }
+
+    function flightRatingsCallback(
+        uint256 _requestId,
+        bytes32 _bpKey,
+        bytes calldata _response
+    ) external onlyOracle {
+
+        // Statistics: ['observations','late15','late30','late45','cancelled','diverted']
+        uint256[6] memory _statistics = abi.decode(_response, (uint256[6]));
+        uint256 premium;
+        uint256[5] memory payouts;
+        address payable customer;
+        // (uint256 premium, uint256[5] memory payouts, address payable customer, bytes32 riskId) =
+        // abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
+        // if (_statistics[0] < MIN_OBSERVATIONS) {
+        //     declineAndPayback(_bpKey, customer, premium);
+        //     return;
+        // }
+
+        (uint256 weight, uint256[5] memory calculatedPayouts) = calculatePayouts(premium, _statistics);
+        Risk storage risk; // = risks[riskId];
+
+        for (uint256 i = 0; i < 5; i++) {
+            if (calculatedPayouts[i] > MAX_PAYOUT) {
+                emit LogError("ERROR:FDD-007:PAYOUT_GT_MAXPAYOUT", i, payouts[i], calculatedPayouts[i]);
+                declineAndPayback(_bpKey, customer, premium);
+                return;
+            }
+            if (calculatedPayouts[i] != payouts[i]) {
+                emit LogError("ERROR:FDD-008:INVALID_PAYOUT_OPTION", i, payouts[i], calculatedPayouts[i]);
+                declineAndPayback(_bpKey, customer, premium);
+                return;
+            }
+        }
+
+        // It's the first policy for this risk, we accept any premium
+        // REMARK: all policy holders for this flight will share the same max payout estimates
+        // trends during the onboarding of policies are not considered
+        // if (risk.premiumMultiplier == 0) {
+        //     risk.premiumMultiplier = maxWeight * 10000 / weight;
+        //     risk.estimatedMaxTotalPayout = 0;
+        // }
+        // uint256 estimatedMaxPayout = premium * risk.premiumMultiplier;
+        // if (estimatedMaxPayout > MAX_PAYOUT) { estimatedMaxPayout = MAX_PAYOUT; }
+        // risk.estimatedMaxTotalPayout = risk.estimatedMaxTotalPayout + estimatedMaxPayout;
+        // risk.weight = weight;
+
+        // _underwrite(_bpKey);
+
+        // uint256 requestId = _request(
+        //     _bpKey,
+        //     abi.encode(
+        //         risk.arrivalTime + CHECK_OFFSET,
+        //         risk.carrierFlightNumber,
+        //         risk.departureYearMonthDay
+        //     ),
+        //     STATUSES_CALLBACK,
+        //     statusesOracleType,
+        //     statusesOracleId
+        // );
+
+        // Now everything is prepared
+        // address(RiskPool).transfer(premium);
+
+        // emit LogRequestFlightStatus(
+        //     requestId,
+        //     risk.arrivalTime + CHECK_OFFSET,
+        //     risk.carrierFlightNumber,
+        //     risk.departureYearMonthDay
+        // );
+    }
+
+    function flightStatusCallback(uint256 _requestId, bytes32 _bpKey, bytes calldata _response)
+        external
+        onlyOracle
+    {
+        (bytes1 status, int256 delay) = abi.decode(_response, (bytes1, int256));
+        // (/* uint256 premium */, uint256[5] memory payouts, address payable customer, /* bytes32 riskId */) =
+        // abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
+
+        if (status != "L" && status != "A" && status != "C" && status != "D") {
+            emit LogUnprocessableStatus(_bpKey, _requestId);
+            return;
+        }
+
+        if (status == "A") {
+            // todo: active, reschedule oracle call + 45 min
+            // emit LogUnexpectedStatus(_bpKey, _requestId, status, delay, customer);
+            return;
+        }
+
+        // if (status == "C") {
+        //     resolvePayout(_bpKey, payouts[3], customer);
+        // } else if (status == "D") {
+        //     resolvePayout(_bpKey, payouts[4], customer);
+        // } else if (delay >= 15 && delay < 30) {
+        //     resolvePayout(_bpKey, payouts[0], customer);
+        // } else if (delay >= 30 && delay < 45) {
+        //     resolvePayout(_bpKey, payouts[1], customer);
+        // } else if (delay >= 45) {
+        //     resolvePayout(_bpKey, payouts[2], customer);
+        // } else {
+        //     resolvePayout(_bpKey, 0, customer);
+        // }
+    }
+
+    function resolvePayout(bytes32 _bpKey, uint256 _payoutAmount, address payable _customer) internal {
+        if (_payoutAmount == 0) {
+            // _expire(_bpKey);
+            emit LogPolicyExpired(_bpKey);
+        } else {
+            // uint256 claimId = _newClaim(_bpKey, abi.encode(_payoutAmount));
+            // uint256 payoutId = _confirmClaim(_bpKey, claimId, abi.encode(_payoutAmount));
+            // _payout(_bpKey, payoutId, true, abi.encode(_payoutAmount));
+            _customer.transfer(_payoutAmount);
+            // emit LogPayoutTransferred(_bpKey, claimId, payoutId, _payoutAmount);
+        }
+    }
+
+    function calculatePayouts(uint256 _premium, uint256[6] memory _statistics)
+        public
+        view
+        returns (uint256 _weight, uint256[5] memory _payoutOptions)
+    {
+        require(_premium >= MIN_PREMIUM, "ERROR:FDD-009:INVALID_PREMIUM");
+        require(_premium <= MAX_PREMIUM, "ERROR:FDD-010:INVALID_PREMIUM");
+        require(_statistics[0] >= MIN_OBSERVATIONS, "ERROR:FDD-011:LOW_OBSERVATIONS");
+
+        _weight = 0;
+        _payoutOptions = [uint256(0), 0, 0, 0, 0];
+
+        for (uint256 i = 1; i < 6; i++) {
+            _weight += weightPattern[i] * _statistics[i] * 10000 / _statistics[0];
+            // 1% = 100 / 100% = 10,000
+        }
+
+        // To avoid div0 in the payout section, we have to make a minimal assumption on weight
+        if (_weight == 0) {
+            _weight = 100000 / _statistics[0];
+        }
+
+        _weight = _weight * (100 + MARGIN_PERCENT) / 100;
+
+        for (uint256 i = 0; i < 5; i++) {
+            _payoutOptions[i] = _premium * weightPattern[i + 1] * 10000 / _weight;
+
+            if (_payoutOptions[i] > MAX_PAYOUT) {
+                _payoutOptions[i] = MAX_PAYOUT;
+            }
+        }
+    }
+
+    function faucet(uint256 _amount) // for testing only
+        public
+        onlyOwner
+    {
+        require(_amount <= address(this).balance);
+        address payable receiver;
+        receiver = payable(owner);
+        receiver.transfer(_amount);
+    }
+}

package/contracts/instance/IInstance.sol

@@ -143,7 +143,7 @@ interface IInstance is
 
     // get products
     function products() external view returns (uint256 productCount);
-    function getProductNftId(uint256 idx) external view returns (NftId productNftId);
+    function getProduct(uint256 idx) external view returns (NftId productNftId);
 
     // get supporting contracts
     function getInstanceReader() external view returns (InstanceReader);

package/contracts/instance/Instance.sol

@@ -317,7 +317,7 @@ contract Instance is
         return _products.length;
     }
 
-    function getProductNftId(uint256 idx) external view returns (NftId productNftId) {
+    function getProduct(uint256 idx) external view returns (NftId productNftId) {
         return _products[idx];
     }
 

package/contracts/instance/InstanceReader.sol

@@ -177,8 +177,8 @@ contract InstanceReader {
 
 
     /// @dev Returns th product NFT ID for the given index.
-    function getProductNftId(uint256 idx) public view returns (NftId productNftId) {
-        return _instance.getProductNftId(idx);
+    function getProduct(uint256 idx) public view returns (NftId productNftId) {
+        return _instance.getProduct(idx);
     }
 
 
@@ -219,6 +219,12 @@ contract InstanceReader {
     }
 
 
+    /// @dev Returns true if the specified risk exists for the given product NFT ID.
+    function isProductRisk(NftId productNftId, RiskId riskId) public view returns (bool exists) {
+        return _riskSet.hasRisk(productNftId, riskId);
+    }
+
+
     /// @dev Returns the risk info for the given risk ID.
     function getRiskInfo(RiskId riskId) public view returns (IRisk.RiskInfo memory info) {
         return _productStore.getRiskInfo(riskId);
@@ -240,10 +246,21 @@ contract InstanceReader {
 
 
     /// @dev Returns the linked policy NFT ID for the given risk ID and index.
-    function getPolicyNftIdForRisk(RiskId riskId, uint256 idx) public view returns (NftId linkedPolicyNftId) {
+    function getPolicyForRisk(RiskId riskId, uint256 idx) public view returns (NftId linkedPolicyNftId) {
         return _riskSet.getLinkedPolicyNftId(riskId, idx);
     }
 
+    /// @dev Returns the number of linked policies for the given bundle NFT ID.
+    function policiesForBundle(NftId bundleNftId) public view returns (uint256 linkedPolicies) {
+        return _bundleSet.activePolicies(bundleNftId);
+    }
+
+
+    /// @dev Returns the linked policy NFT ID for the given risk ID and index.
+    function getPolicyForBundle(NftId bundleNftId, uint256 idx) public view returns (NftId linkedPolicyNftId) {
+        return _bundleSet.getActivePolicy(bundleNftId, idx);
+    }
+
 
     /// @dev Returns the info for the given policy NFT ID.
     function getPolicyInfo(NftId policyNftId) public view returns (IPolicy.PolicyInfo memory info) {
@@ -341,6 +358,11 @@ contract InstanceReader {
         return _store.getRequestInfo(requestId);
     }
 
+    /// @dev Returns the request info for the given oracle request ID.
+    function getRequestState(RequestId requestId) public view returns (StateId state) {
+        return getState(requestId.toKey32());
+    }
+
     //--- pool functions -----------------------------------------------------------//
 
     /// @dev Returns the pool info for the given pool NFT ID.

package/contracts/oracle/IOracleService.sol

@@ -41,26 +41,26 @@ interface IOracleService is IService {
         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)
+    /// @dev Respond to oracle request by oracle compnent.
+    /// The response data is amended 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
+    /// The function returns true iff the state changes to FULFILLED.
+    /// Permissioned: only the receiving oracle component 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
+    /// @dev Resend a failed response to the requester.
+    /// Only requests in state FAILED may be resent.
+    /// The request state changes to FULFILLED when calling the callback method of the requester is successful.
+    /// Permissioned: only the receiving oracle 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
+    /// @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/product/BasicProductAuthorization.sol

@@ -7,7 +7,7 @@ import {IProductComponent} from "./IProductComponent.sol";
 
 import {Authorization} from "../authorization/Authorization.sol";
 import {BasicProduct} from "./BasicProduct.sol"; 
-import {COMPONENT, PRODUCT, POLICY} from "../type/ObjectType.sol";
+import {COMPONENT, ORACLE, PRODUCT, POLICY} from "../type/ObjectType.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 
@@ -30,7 +30,8 @@ contract BasicProductAuthorization
           virtual override
      {
           _authorizeServiceDomain(COMPONENT(), address(10));
-          _authorizeServiceDomain(POLICY(), address(11));
+          _authorizeServiceDomain(ORACLE(), address(11));
+          _authorizeServiceDomain(POLICY(), address(12));
      }
 
      function _setupTokenHandlerAuthorizations() internal virtual override {

package/contracts/shared/EcdsaChecker.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

package/contracts/shared/InstanceLinkedComponent.sol

@@ -1,27 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-import {Amount} from "../type/Amount.sol";
-import {Component} from "./Component.sol";
-import {IComponentService} from "./IComponentService.sol";
-import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IComponentService} from "./IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IOracleService} from "../oracle/IOracleService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Component} from "./Component.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
+import {ObjectType, COMPONENT, INSTANCE, ORACLE, PRODUCT} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
 import {RoleId, RoleIdLib} from "../type/RoleId.sol";
-import {IAccess} from "../authorization/IAccess.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 import {VersionPart} from "../type/Version.sol";
 
 // then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
@@ -38,8 +35,23 @@ abstract contract InstanceLinkedComponent is
         InstanceReader _instanceReader; // instance reader for this component
         IAuthorization _initialAuthorization;
         IComponentService _componentService;
+        IOracleService _oracleService;
     }
 
+    //--- view functions ----------------------------------------------------//
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function getInstance() public view virtual override returns (IInstance instance) {
+        return _getInstanceLinkedComponentStorage()._instance;
+    }
+
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function getAuthorization() external view virtual returns (IAuthorization authorization) {
+        return _getInstanceLinkedComponentStorage()._initialAuthorization;
+    }
+
+
     /// @inheritdoc IInstanceLinkedComponent
     function withdrawFees(Amount amount)
         external
@@ -51,22 +63,49 @@ abstract contract InstanceLinkedComponent is
         return _withdrawFees(amount);
     }
 
-    /// @inheritdoc IInstanceLinkedComponent
-    function getInstance() public view virtual override returns (IInstance instance) {
-        return _getInstanceLinkedComponentStorage()._instance;
+    //--- internal functions ------------------------------------------------//
+
+    function _sendRequest(
+        NftId oracleNftId,
+        bytes memory requestData,
+        Timestamp expiryAt,
+        string memory callbackMethod
+    )
+        internal
+        virtual
+        returns (RequestId requestId)
+    {
+        return _getInstanceLinkedComponentStorage()._oracleService.request(
+            oracleNftId,
+            requestData,
+            expiryAt,
+            callbackMethod);
     }
 
-    /// @inheritdoc IInstanceLinkedComponent
-    function getAuthorization() external view virtual returns (IAuthorization authorization) {
-        return _getInstanceLinkedComponentStorage()._initialAuthorization;
+
+    function _cancelRequest(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.cancel(requestId);
+    }
+
+
+    function _resendRequest(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.resend(requestId);
     }
 
+
     function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
         assembly {
             $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
         }
     }
 
+
     function __InstanceLinkedComponent_init(
         address registry,
         NftId parentNftId,
@@ -106,6 +145,7 @@ abstract contract InstanceLinkedComponent is
         $._instanceReader = $._instance.getInstanceReader();
         $._initialAuthorization = authorization;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE()));
 
         // register interfaces
         _registerInterface(type(IInstanceLinkedComponent).interfaceId);