@etherisc/gif-next 3.0.0-a511887-523 → 3.0.0-a73fc6f-862

package/contracts/examples/flight/FlightOracle.sol

@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+
+import {ACTIVE, FULFILLED, FAILED} from "../../type/StateId.sol";
+import {NftId} from "../../type/NftId.sol";
+import {BasicOracle} from "../../oracle/BasicOracle.sol";
+import {RequestId} from "../../type/RequestId.sol";
+import {LibRequestIdSet} from "../../type/RequestIdSet.sol";
+import {RiskId} from "../../type/RiskId.sol";
+import {StateId} from "../../type/StateId.sol";
+import {Str} from "../../type/String.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
+
+contract FlightOracle is
+    BasicOracle
+{
+
+    struct FlightStatusRequest {
+        RiskId riskId;
+        Str flightData; // "LX 180 ZRH BKK 20241104"
+        Timestamp departureTime; // is this needed or is flight number and date unique aready?
+    }
+
+    struct FlightStatusResponse {
+        RiskId riskId;
+        bytes1 status;
+        int256 delayMinutes;
+    }
+
+    event LogFlightOracleRequestReceived(RequestId requestId, NftId requesterId);
+    event LogFlightOracleResponseSent(RequestId requestId, bytes1 status, int256 delay);
+    event LogFlightOracleRequestCancelled(RequestId requestId);
+
+    // TODO decide if this variable should be moved to instance store
+    // if so it need to manage active requests by requestor nft id
+    LibRequestIdSet.Set internal _activeRequests;
+
+
+    constructor(
+        address registry,
+        NftId productNftId,
+        string memory componentName,
+        IAuthorization authorization
+    ) 
+    {
+        address initialOwner = msg.sender;
+        initialize(
+            registry,
+            productNftId,
+            authorization,
+            initialOwner,
+            componentName
+        );
+    }
+
+
+    function initialize(
+        address registry,
+        NftId productNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name
+    )
+        public
+        virtual
+        initializer()
+    {
+        _initializeBasicOracle(
+            registry,
+            productNftId,
+            authorization,
+            initialOwner,
+            name);
+    }
+
+
+    function respondWithFlightStatus(
+        RequestId requestId,
+        bytes1 status,
+        int256 delayMinutes
+    )
+        external
+        restricted()
+    {
+        // obtain riskId for request
+        bytes memory requestData = _getInstanceReader().getRequestInfo(requestId).requestData;
+        (RiskId riskId,,) = abi.decode(requestData, (RiskId, Str, Timestamp));
+        // assemble response data
+        bytes memory responseData = abi.encode(
+            FlightStatusResponse ({
+                riskId: riskId,
+                status: status,
+                delayMinutes: delayMinutes}));
+
+        // logging
+        emit LogFlightOracleResponseSent(requestId, status, delayMinutes);
+
+        // effects + interaction (via framework to receiving component)
+        _respond(requestId, responseData);
+
+        // TODO decide if the code below should be moved to GIF
+        _updateRequestState(requestId);
+    }
+
+
+    function updateRequestState(
+        RequestId requestId
+    )
+        external
+        restricted()
+    {
+        _updateRequestState(requestId);
+    }
+
+    //--- view functions ----------------------------------------------------//
+
+    // TODO decide if the code below should be moved to GIF
+    function activeRequests()
+        external
+        view
+        returns(uint256 numberOfRequests)
+    {
+        return LibRequestIdSet.size(_activeRequests);
+    }
+
+
+    // TODO decide if the code below should be moved to GIF
+    function getActiveRequest(uint256 idx)
+        external
+        view
+        returns(RequestId requestId)
+    {
+        return LibRequestIdSet.getElementAt(_activeRequests, idx);
+    }
+
+
+    function isActiveRequest(RequestId requestId)
+        external
+        view
+        returns(bool isActive)
+    {
+        return LibRequestIdSet.contains(_activeRequests, requestId);
+    }
+
+
+    function getRequestState(RequestId requestId)
+        external
+        view
+        returns (
+            RiskId riskId,
+            string memory flightData,
+            StateId requestState,
+            bool readyForResponse,
+            bool waitingForResend
+        )
+    {
+        bytes memory requestData = _getInstanceReader().getRequestInfo(requestId).requestData;
+        Str fltData;
+        Timestamp departureTime;
+        (riskId, fltData, departureTime) = abi.decode(requestData, (RiskId, Str, Timestamp));
+
+        flightData = fltData.toString();
+        requestState = _getInstanceReader().getRequestState(requestId);
+        readyForResponse = requestState == ACTIVE() && TimestampLib.current() >= departureTime;
+        waitingForResend = requestState == FAILED();
+    }
+
+
+    function decodeFlightStatusRequestData(bytes memory data) external pure returns (FlightStatusRequest memory) {
+        return abi.decode(data, (FlightStatusRequest));
+    }
+
+    //--- internal functions ------------------------------------------------//
+
+
+    // TODO decide if the code below should be moved to GIF
+    // check callback result
+    function _updateRequestState(
+        RequestId requestId
+    )
+        internal
+    {
+        bool requestFulfilled = _getInstanceReader().getRequestState(
+            requestId) == FULFILLED();
+
+        // remove from active requests when successful
+        if (requestFulfilled && LibRequestIdSet.contains(_activeRequests, requestId)) {
+            LibRequestIdSet.remove(_activeRequests, requestId);
+        } 
+    }
+
+
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that request has been received by oracle component 
+    function _request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        internal
+        virtual override
+    {
+        FlightStatusRequest memory request = abi.decode(requestData, (FlightStatusRequest));
+
+        // TODO decide if the line below should be moved to GIF
+        LibRequestIdSet.add(_activeRequests, requestId);
+        emit LogFlightOracleRequestReceived(requestId, requesterId);
+    }
+
+
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that cancelling has been received by oracle component 
+    function _cancel(
+        RequestId requestId
+    )
+        internal
+        virtual override
+    {
+        // TODO decide if the line below should be moved to GIF
+        LibRequestIdSet.remove(_activeRequests, requestId);
+        emit LogFlightOracleRequestCancelled(requestId);
+    }
+}

package/contracts/examples/flight/FlightOracleAuthorization.sol

@@ -0,0 +1,57 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+
+import {AccessAdminLib} from "../../authorization/AccessAdminLib.sol";
+import {BasicOracleAuthorization} from "../../oracle/BasicOracleAuthorization.sol";
+import {FlightOracle} from "./FlightOracle.sol";
+import {RoleId, ADMIN_ROLE, PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract FlightOracleAuthorization
+    is BasicOracleAuthorization
+{
+
+    uint64 public constant STATUS_PROVIDER_ROLE_IDX = 2; // 2nd custom role for flight oracle
+    string public constant STATUS_PROVIDER_ROLE_NAME = "StatusProviderRole";
+    RoleId public STATUS_PROVIDER_ROLE;
+
+    constructor(string memory oracleName, string memory commitHash)
+        BasicOracleAuthorization(oracleName, commitHash)
+    {  }
+
+
+    function _setupRoles()
+        internal
+        override
+    {
+        STATUS_PROVIDER_ROLE = AccessAdminLib.getCustomRoleId(STATUS_PROVIDER_ROLE_IDX);
+
+        _addRole(
+            STATUS_PROVIDER_ROLE,
+            AccessAdminLib.roleInfo(
+                ADMIN_ROLE(),
+                TargetType.Custom,
+                1, // max member count special case: instance nft owner is sole role owner
+                STATUS_PROVIDER_ROLE_NAME));
+    }
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        functions = _authorizeForTarget(getMainTargetName(), STATUS_PROVIDER_ROLE);
+        _authorize(functions, FlightOracle.respondWithFlightStatus.selector, "respondWithFlightStatus");
+
+        // authorize public role (additional authz via onlyOwner)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        _authorize(functions, FlightOracle.updateRequestState.selector, "updateRequestState");
+    }
+}
+

package/contracts/examples/flight/FlightPool.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
+
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {BasicPool} from "../../pool/BasicPool.sol";
+import {FeeLib} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Seconds, SecondsLib} from "../../type/Seconds.sol";
+import {UFixedLib} from "../../type/UFixed.sol";
+
+
+/// @dev FlightPool implements the pool for the flight delay product.
+/// Only the pool owner is allowed to create and manage bundles.
+contract FlightPool is
+    BasicPool
+{   
+    constructor(
+        address registry,
+        NftId productNftId,
+        string memory componentName,
+        IAuthorization authorization
+    ) 
+    {
+        address initialOwner = msg.sender;
+        _intialize(
+            registry,
+            productNftId,
+            componentName,
+            IComponents.PoolInfo({
+                maxBalanceAmount: AmountLib.max(),
+                isInterceptingBundleTransfers: false,
+                isProcessingConfirmedClaims: false,
+                isExternallyManaged: true,
+                isVerifyingApplications: false,
+                collateralizationLevel: UFixedLib.one(),
+                retentionLevel: UFixedLib.one()
+            }),
+            authorization,
+            initialOwner);
+    }
+
+    function _intialize(
+        address registry,
+        NftId productNftId,
+        string memory componentName,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        initializer
+    {
+        _initializeBasicPool(
+            registry,
+            productNftId,
+            componentName,
+            poolInfo,
+            authorization,
+            initialOwner);
+    }
+
+    function createBundle(
+        Amount initialAmount
+    )
+        external
+        virtual 
+        restricted()
+        onlyOwner()
+        returns(NftId bundleNftId)
+    {
+        address owner = msg.sender;
+        bundleNftId = _createBundle(
+            owner,
+            FeeLib.zero(),
+            SecondsLib.fromDays(90),
+            "" // filter
+        );
+
+        _stake(bundleNftId, initialAmount);
+    }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
+}

package/contracts/examples/flight/FlightPoolAuthorization.sol

@@ -0,0 +1,37 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+
+import {BasicPoolAuthorization} from "../../pool/BasicPoolAuthorization.sol";
+import {FlightPool} from "./FlightPool.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract FlightPoolAuthorization
+    is BasicPoolAuthorization
+{
+
+    constructor(string memory poolName)
+        BasicPoolAuthorization(poolName)
+    {}
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // authorize public role (also protected by onlyOwner)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+
+        // only owner
+        _authorize(functions, FlightPool.createBundle.selector, "createBundle");
+        _authorize(functions, FlightPool.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, FlightPool.setWallet.selector, "setWallet");
+    }
+}
+