@etherisc/gif-next 3.0.0-80e6cc5-373 → 3.0.0-8200b30-160

package/contracts/examples/flight/FlightLib.sol

@@ -11,6 +11,7 @@ import {InstanceReader} from "../../instance/InstanceReader.sol";
 import {NftId} from "../../type/NftId.sol";
 import {RequestId} from "../../type/RequestId.sol";
 import {RiskId, RiskIdLib} from "../../type/RiskId.sol";
+import {Seconds} from "../../type/Seconds.sol";
 import {StateId} from "../../type/StateId.sol";
 import {Str} from "../../type/String.sol";
 import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
@@ -18,39 +19,30 @@ import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
 
 library FlightLib {
 
-    function checkApplicationDataAndSignature(
+    event LogFlightProductErrorUnprocessableStatus(RequestId requestId, RiskId riskId, bytes1 status);
+    event LogFlightProductErrorUnexpectedStatus(RequestId requestId, RiskId riskId, bytes1 status, int256 delayMinutes);
+
+    error ErrorFlightProductRiskInvalid(RiskId riskId);
+    error ErrorFlightProductPremiumAmountTooSmall(Amount premiumAmount, Amount minPremium);
+    error ErrorFlightProductPremiumAmountTooLarge(Amount premiumAmount, Amount maxPremium);
+    error ErrorFlightProductArrivalBeforeDepartureTime(Timestamp departureTime, Timestamp arrivalTime);
+    error ErrorFlightProductArrivalAfterMaxFlightDuration(Timestamp arrivalTime, Timestamp maxArrivalTime, Seconds maxDuration);
+    error ErrorFlightProductDepartureBeforeMinTimeBeforeDeparture(Timestamp departureTime, Timestamp now, Seconds minTimeBeforeDeparture);
+    error ErrorFlightProductDepartureAfterMaxTimeBeforeDeparture(Timestamp departureTime, Timestamp now, Seconds maxTimeBeforeDeparture);
+    error ErrorFlightProductNotEnoughObservations(uint256 observations, uint256 minObservations);
+    error ErrorFlightProductClusterRisk(Amount totalSumInsured, Amount maxTotalPayout);
+
+    function checkApplicationData(
         FlightProduct flightProduct,
         Str flightData, 
         Timestamp departureTime,
         Timestamp arrivalTime,
-        Amount premiumAmount,
-        uint256[6] memory statistics,
-        // signature fields
-        uint8 v, 
-        bytes32 r, 
-        bytes32 s
+        Amount premiumAmount
     )
         public
         view
     {
         _checkApplicationData(flightProduct, premiumAmount, arrivalTime, departureTime);
-
-        (
-            address actualSigner,,
-            bool success
-        ) = flightProduct.getFlightMessageVerifier().verifyRatingsHash(
-            flightData,
-            departureTime,
-            arrivalTime,
-            premiumAmount,
-            statistics,
-            v, r, s);
-
-        if (!success) {
-            revert FlightProduct.ErrorApplicationDataSignatureMismatch(
-                flightProduct.getFlightMessageVerifier().getExpectedSigner(),
-                actualSigner);
-        }
     }
 
 
@@ -63,62 +55,49 @@ library FlightLib {
         internal
         view
     {
+        bool testMode = flightProduct.isTestMode();
+
         // solhint-disable
-        require(premiumAmount >= flightProduct.MIN_PREMIUM(), "ERROR:FDD-001:INVALID_PREMIUM");
-        require(premiumAmount <= flightProduct.MAX_PREMIUM(), "ERROR:FDD-002:INVALID_PREMIUM");
-        require(arrivalTime > departureTime, "ERROR:FDD-003:ARRIVAL_BEFORE_DEPARTURE_TIME");
-
-        // TODO decide how to handle demo mode
-        require(
-            arrivalTime <= departureTime.addSeconds(flightProduct.MAX_FLIGHT_DURATION()),
-            "ERROR:FDD-004:INVALID_ARRIVAL/DEPARTURE_TIME");
-        require(
-            TimestampLib.current() >= departureTime.subtractSeconds(flightProduct.MAX_TIME_BEFORE_DEPARTURE()),
-            "ERROR:FDD-005:INVALID_ARRIVAL/DEPARTURE_TIME");
-        require(
-            TimestampLib.current() <= departureTime.subtractSeconds(flightProduct.MIN_TIME_BEFORE_DEPARTURE()),
-            "ERROR:FDD-012:INVALID_ARRIVAL/DEPARTURE_TIME");
+        if (premiumAmount < flightProduct.MIN_PREMIUM()) {
+            revert ErrorFlightProductPremiumAmountTooSmall(premiumAmount, flightProduct.MIN_PREMIUM());
+        }
+        if (premiumAmount > flightProduct.MAX_PREMIUM()) {
+            revert ErrorFlightProductPremiumAmountTooLarge(premiumAmount, flightProduct.MAX_PREMIUM());
+        }
+        if (arrivalTime <= departureTime) {
+            revert ErrorFlightProductArrivalBeforeDepartureTime(departureTime, arrivalTime);
+        }
+        if (arrivalTime > departureTime.addSeconds(flightProduct.MAX_FLIGHT_DURATION())) {
+            revert ErrorFlightProductArrivalAfterMaxFlightDuration(arrivalTime, departureTime, flightProduct.MAX_FLIGHT_DURATION());
+        }
+
+        // test mode allows the creation for policies that are outside restricted policy creation times
+        if (!testMode && departureTime < TimestampLib.current().addSeconds(flightProduct.MIN_TIME_BEFORE_DEPARTURE())) {
+            revert ErrorFlightProductDepartureBeforeMinTimeBeforeDeparture(departureTime, TimestampLib.current(), flightProduct.MIN_TIME_BEFORE_DEPARTURE());
+        }
+        if (!testMode && departureTime > TimestampLib.current().addSeconds(flightProduct.MAX_TIME_BEFORE_DEPARTURE())) {
+            revert ErrorFlightProductDepartureAfterMaxTimeBeforeDeparture(departureTime, TimestampLib.current(), flightProduct.MAX_TIME_BEFORE_DEPARTURE());
+        }
         // solhint-enable
     }
 
 
-    // TODO fix or cleanup
-    // function checkApplication(
-    //     FlightProduct flightProduct,
-    //     Str carrierFlightNumber,
-    //     Timestamp departureTime,
-    //     Timestamp arrivalTime,
-    //     Amount premium
-    // )
-    //     external
-    //     view
-    //     returns (uint256 errors)
-    // {
-    //     // Validate input parameters
-    //     if (premium < flightProduct.MIN_PREMIUM()) { errors = errors | (uint256(1) << 0); }
-    //     if (premium > flightProduct.MAX_PREMIUM()) { errors = errors | (uint256(1) << 1); }
-    //     if (arrivalTime < departureTime) { errors = errors | (uint256(1) << 2); }
-    //     if (arrivalTime > departureTime.addSeconds(flightProduct.MAX_FLIGHT_DURATION())) { errors = errors | (uint256(1) << 3); }
-    //     if (departureTime < TimestampLib.current().addSeconds(flightProduct.MIN_TIME_BEFORE_DEPARTURE())) { errors = errors | (uint256(1) << 4); }
-    //     if (departureTime > TimestampLib.current().addSeconds(flightProduct.MAX_TIME_BEFORE_DEPARTURE())) { errors = errors | (uint256(1) << 5); }
-
-    //     (, bool exists, FlightProduct.FlightRisk memory flightRisk) = getFlightRisk(
-    //         flightProduct.getInstanceReader(), flightProduct.getNftId(), carrierFlightNumber, departureTime, arrivalTime);
-
-    //     if (exists) {
-    //         Amount sumInsured = AmountLib.toAmount(premium.toInt() * flightRisk.premiumMultiplier);
-    //         if (flightRisk.sumOfSumInsuredAmounts + sumInsured > flightProduct.MAX_TOTAL_PAYOUT()) {
-    //             errors = errors | (uint256(1) << 6);
-    //         }
-    //     }
-
-    //     return errors;
-    // }
+    function checkClusterRisk(
+        Amount sumOfSumInsuredAmounts,
+        Amount sumInsuredAmount,
+        Amount maxTotalPayout
+    )
+        public
+        pure
+    {
+        if (sumOfSumInsuredAmounts + sumInsuredAmount > maxTotalPayout) {
+            revert ErrorFlightProductClusterRisk(sumOfSumInsuredAmounts + sumInsuredAmount, maxTotalPayout);
+        }
+    }
 
 
     /// @dev calculates payout option based on flight status and delay minutes.
     /// Is not a view function as it emits log evens in case of unexpected status.
-    // TODO decide if reverts instead of log events could work too (and convert the function into a view function)
     function checkAndGetPayoutOption(
         RequestId requestId,
         RiskId riskId, 
@@ -133,13 +112,13 @@ library FlightLib {
 
         // check status
         if (status != "L" && status != "A" && status != "C" && status != "D") {
-            emit FlightProduct.LogErrorUnprocessableStatus(requestId, riskId, status);
+            emit LogFlightProductErrorUnprocessableStatus(requestId, riskId, status);
             return payoutOption;
         }
 
         if (status == "A") {
             // todo: active, reschedule oracle call + 45 min
-            emit FlightProduct.LogErrorUnexpectedStatus(requestId, riskId, status, delayMinutes);
+            emit LogFlightProductErrorUnexpectedStatus(requestId, riskId, status, delayMinutes);
             return payoutOption;
         }
 
@@ -161,7 +140,9 @@ library FlightLib {
         returns (uint256 weight)
     {
         // check we have enough observations
-        require(statistics[0] >= flightProduct.MIN_OBSERVATIONS(), "ERROR:FDD-011:LOW_OBSERVATIONS");
+        if (statistics[0] < flightProduct.MIN_OBSERVATIONS()) {
+            revert ErrorFlightProductNotEnoughObservations(statistics[0], flightProduct.MIN_OBSERVATIONS());
+        }
 
         weight = 0;
         for (uint256 i = 1; i < 6; i++) {
@@ -192,8 +173,12 @@ library FlightLib {
             Amount sumInsuredAmount // simply the max of payoutAmounts 
         )
     {
-        require(premium >= flightProduct.MIN_PREMIUM(), "ERROR:FDD-009:INVALID_PREMIUM");
-        require(premium <= flightProduct.MAX_PREMIUM(), "ERROR:FDD-010:INVALID_PREMIUM");
+        if (premium < flightProduct.MIN_PREMIUM()) { 
+            revert ErrorFlightProductPremiumAmountTooSmall(premium, flightProduct.MIN_PREMIUM()); 
+        }
+        if (premium > flightProduct.MAX_PREMIUM()) { 
+            revert ErrorFlightProductPremiumAmountTooLarge(premium, flightProduct.MAX_PREMIUM()); 
+        }
 
         sumInsuredAmount = AmountLib.zero();
         weight = calculateWeight(flightProduct, statistics);
@@ -211,13 +196,43 @@ library FlightLib {
     }
 
 
+    function getPayoutOption(
+        InstanceReader reader,
+        NftId productNftId,
+        RiskId riskId
+    )
+        public
+        view
+        returns (
+            bool exists,
+            bool statusAvailable,
+            uint8 payoutOption
+        )
+    {
+        FlightProduct.FlightRisk memory flightRisk;
+        (exists, flightRisk) = getFlightRisk(
+            reader, 
+            productNftId, 
+            riskId,
+            false);
+        
+        statusAvailable = flightRisk.statusUpdatedAt.gtz();
+        payoutOption = flightRisk.payoutOption;
+    }
+
+
     function getPayoutAmount(
         bytes memory applicationData, 
         uint8 payoutOption
     )
         public
+        pure
         returns (Amount payoutAmount)
     {
+        if (payoutOption == type(uint8).max) {
+            return AmountLib.zero();
+        }
+
         // retrieve payout amounts from application data
         (, Amount[5] memory payoutAmounts) = abi.decode(
             applicationData, (Amount, Amount[5]));
@@ -232,7 +247,9 @@ library FlightLib {
         NftId productNftId, 
         Str flightData,
         Timestamp departureTime, 
-        Timestamp arrivalTime
+        string memory departureTimeLocal,
+        Timestamp arrivalTime,
+        string memory arrivalTimeLocal
     )
         public
         view
@@ -243,17 +260,21 @@ library FlightLib {
         )
     {
         riskId = getRiskId(productNftId, flightData);
-        (exists, flightRisk) = getFlightRisk(reader, productNftId, riskId);
+        (exists, flightRisk) = getFlightRisk(reader, productNftId, riskId, false);
 
         // create new risk if not existing
         if (!exists) {
             flightRisk = FlightProduct.FlightRisk({
                 flightData: flightData,
                 departureTime: departureTime,
+                departureTimeLocal: departureTimeLocal,
                 arrivalTime: arrivalTime,
+                arrivalTimeLocal: arrivalTimeLocal,
                 sumOfSumInsuredAmounts: AmountLib.toAmount(0),
                 status: bytes1(0),
-                delayMinutes: 0});
+                delayMinutes: 0,
+                payoutOption: uint8(0),
+                statusUpdatedAt: TimestampLib.zero()});
         }
     }
 
@@ -261,7 +282,8 @@ library FlightLib {
     function getFlightRisk(
         InstanceReader reader,
         NftId productNftId,
-        RiskId riskId
+        RiskId riskId,
+        bool requireRiskExists
     )
         public
         view
@@ -273,6 +295,10 @@ library FlightLib {
         // check if risk exists
         exists = reader.isProductRisk(productNftId, riskId);
 
+        if (!exists && requireRiskExists) {
+            revert ErrorFlightProductRiskInvalid(riskId);
+        }
+
         // get risk data if risk exists
         if (exists) {
             flightRisk = abi.decode(

package/contracts/examples/flight/FlightNft.sol

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {IPolicy} from "../../instance/module/IPolicy.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+
+import {Amount} from "../../type/Amount.sol";
+import {ChainNft} from "../../registry/ChainNft.sol";
+import {FlightProduct} from "./FlightProduct.sol";
+import {InstanceReader} from "../../instance/InstanceReader.sol";
+import {NftId, NftIdLib} from "../../type/NftId.sol";
+import {RiskId} from "../../type/RiskId.sol";
+
+
+/**
+ * @title FlightNft
+ * @dev FlightNft provides NFT data for flight delay policies.
+ */
+// contract FlightNft is IERC721Metadata {
+contract FlightNft is
+    ERC721, 
+    Ownable
+{
+
+    error ErrorFlightNftNotMinter();
+    error ErrorFlightNftAlreadyMinted(uint256 tokenId);
+    error ErrorFlightNftNotAvailable(uint256 tokenId);
+    error ErrorFlightNftNotFlightPolicy(uint256 tokenId);
+
+    ChainNft public immutable chainNft;
+    FlightProduct public immutable flightProduct;
+    InstanceReader public immutable instanceReader;
+    IRegistry public registry;
+
+    address public minter;
+    string private _baseUri;
+
+
+    modifier onlyMinter() {
+        if(msg.sender != minter) {
+            revert ErrorFlightNftNotMinter();
+        }
+        _;
+    }
+
+
+    constructor(
+        address flightProductAddress,
+        string memory nftName,
+        string memory nftSymbol,
+        string memory baseUri
+    ) 
+        ERC721(nftName, nftSymbol)
+        Ownable(msg.sender)
+    {
+        flightProduct = FlightProduct(flightProductAddress);
+        registry = flightProduct.getRegistry();
+        chainNft = ChainNft(registry.getChainNftAddress());
+        instanceReader = flightProduct.getInstance().getInstanceReader();
+
+        minter = msg.sender;
+        _baseUri = baseUri;
+    }
+
+
+    /**
+     * Set the base URI to the specified value.
+     * Once set, this results in tokenURI() to return <baseUri><tokenId>.
+     */
+    function setBaseURI(string memory baseUri)
+        public 
+        onlyOwner()
+    {
+        _baseUri = baseUri;
+    }
+
+
+    /**
+     * Set the minter address.
+     */
+    function setMinter(address minterAddress)
+        public 
+        onlyOwner()
+    {
+        minter = minterAddress;
+    }
+
+
+    /**
+     * Mints a metadata NFT for the specified chainNft NFT.
+     * Only the minter can mint such NFTs.
+     */
+    function mint(uint256 tokenId)
+        external
+        onlyMinter()
+    {
+        // verify nft does not yet exist
+        if (_ownerOf(tokenId) != address(0)) {
+            revert ErrorFlightNftAlreadyMinted(tokenId);
+        }
+
+        // verify nft on chainNft exists
+        // also checks if nft exists (ERC721NonexistentToken)
+        address nftOwner = chainNft.ownerOf(tokenId);
+
+        // verify nft is flight delay policy
+        if (registry.getParentNftId(NftIdLib.toNftId(tokenId)) != registry.getNftIdForAddress(address(flightProduct))) {
+            revert ErrorFlightNftNotFlightPolicy(tokenId);
+        }   
+
+        _mint(nftOwner, tokenId);
+    }
+
+
+    /**
+     * @dev Return the NFT token URI for the specified token.
+     * No check is performed to ensure the token exists.
+     */
+    function tokenURI(uint256 tokenId) public view override returns (string memory) {
+        string memory baseURI = _baseURI();
+        return bytes(baseURI).length > 0 ? string.concat(baseURI, toString(tokenId)) : "";
+    }
+
+
+    /**
+     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
+     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
+     * by default, can be overridden in child contracts.
+     */
+    function _baseURI() internal override view returns (string memory) {
+        return _baseUri;
+    }
+
+
+    function approve(address to, uint256 tokenId) public override { _revert(); }
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override { _revert(); }
+    function setApprovalForAll(address operator, bool approved) public override { _revert(); }
+    function transferFrom(address from, address to, uint256 tokenId) public override { _revert(); }
+
+    function balanceOf(address owner) public override view returns (uint256 balance) {
+        return chainNft.balanceOf(owner);
+    }
+
+    function getApproved(uint256 tokenId) public override view returns (address operator) {
+        return chainNft.getApproved(tokenId);
+    }
+
+    function isApprovedForAll(address owner, address operator) public override view returns (bool) {
+        return chainNft.isApprovedForAll(owner, operator);
+    }
+
+    function ownerOf(uint256 tokenId) public override view returns (address owner) {
+        return chainNft.ownerOf(tokenId);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public override view returns (bool) {
+        return chainNft.supportsInterface(interfaceId);
+    }
+
+
+    function getPolicyData(NftId policyNftId)
+        public
+        view
+        returns (
+            RiskId riskId,
+            string memory flightData,
+            string memory departureTimeLocal,
+            string memory arrivalTimeLocal,
+            Amount premiumAmount, 
+            Amount[5] memory payoutAmounts,
+            bytes1 status,
+            int256 delayMinutes
+        )
+    {
+        IPolicy.PolicyInfo memory info = instanceReader.getPolicyInfo(policyNftId);
+
+        // get financial data
+        premiumAmount = info.premiumAmount;
+
+        if (info.applicationData.length > 0) {
+            (, payoutAmounts) = abi.decode(info.applicationData, (Amount, Amount[5]));
+        }
+
+        // get risk data
+        riskId = info.riskId;
+        bytes memory data = instanceReader.getRiskInfo(riskId).data;
+
+        if (data.length > 0) {
+            FlightProduct.FlightRisk memory flightRisk = flightProduct.decodeFlightRiskData(data);
+            flightData = flightRisk.flightData.toString();
+            departureTimeLocal = flightRisk.departureTimeLocal;
+            arrivalTimeLocal = flightRisk.arrivalTimeLocal;
+            status = flightRisk.status;
+            delayMinutes = flightRisk.delayMinutes;
+        }
+    }
+
+
+    function toString(uint256 value) public pure returns (string memory) {
+        if (value == 0) {
+            return "0";
+        }
+
+        uint256 temp = value;
+        uint256 digits = 0;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+
+        bytes memory buffer = new bytes(digits);
+        uint index = digits - 1;
+
+        temp = value;
+        while (temp != 0) {
+            buffer[index] = bytes1(uint8(48 + temp % 10));
+            temp /= 10;
+
+            if (index > 0) {
+                index--;
+            }
+        }
+
+        return string(buffer);
+    }
+
+    function _revert() private pure {
+        revert("FlightNft: Use GIF Chain NFT contract to interact with NFTs. See function getChainNft()");
+    }
+}

package/contracts/examples/flight/FlightOracle.sol

@@ -3,14 +3,15 @@ pragma solidity ^0.8.20;
 
 import {IAuthorization} from "../../authorization/IAuthorization.sol";
 
-import {FULFILLED} from "../../type/StateId.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} from "../../type/Timestamp.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
 
 contract FlightOracle is
     BasicOracle
@@ -100,14 +101,17 @@ contract FlightOracle is
         _respond(requestId, responseData);
 
         // TODO decide if the code below should be moved to GIF
-        // check callback result
-        bool requestFulfilled = _getInstanceReader().getRequestState(
-            requestId) == FULFILLED();
+        _updateRequestState(requestId);
+    }
 
-        // remove from active requests when successful
-        if (requestFulfilled) {
-            LibRequestIdSet.remove(_activeRequests, requestId);
-        }
+
+    function updateRequestState(
+        RequestId requestId
+    )
+        external
+        restricted()
+    {
+        _updateRequestState(requestId);
     }
 
     //--- view functions ----------------------------------------------------//
@@ -131,8 +135,63 @@ contract FlightOracle is
         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(