@etherisc/gif-next 3.0.0-1cf51f6-275 → 3.0.0-1d08e65-733

package/contracts/examples/flight/FlightLib.sol

@@ -0,0 +1,322 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IPolicy} from "../../instance/module/IPolicy.sol";
+import {IPolicyService} from "../../product/IPolicyService.sol";
+
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {FlightMessageVerifier} from "./FlightMessageVerifier.sol";
+import {FlightProduct} from "./FlightProduct.sol";
+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 {StateId} from "../../type/StateId.sol";
+import {Str} from "../../type/String.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
+
+
+library FlightLib {
+
+    function checkApplicationDataAndSignature(
+        FlightProduct flightProduct,
+        Str flightData, 
+        Timestamp departureTime,
+        Timestamp arrivalTime,
+        Amount premiumAmount,
+        uint256[6] memory statistics
+        // signature fields
+        // uint8 v, 
+        // bytes32 r, 
+        // bytes32 s
+    )
+        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);
+        // }
+    }
+
+
+    function _checkApplicationData(
+        FlightProduct flightProduct,
+        Amount premiumAmount,
+        Timestamp arrivalTime,
+        Timestamp departureTime
+    )
+        internal
+        view
+    {
+        // solhint-disable
+        if (premiumAmount < flightProduct.MIN_PREMIUM()) {
+            revert FlightProduct.ErrorFlightProductPremiumAmountTooSmall(premiumAmount, flightProduct.MIN_PREMIUM());
+        }
+        if (premiumAmount > flightProduct.MAX_PREMIUM()) {
+            revert FlightProduct.ErrorFlightProductPremiumAmountTooLarge(premiumAmount, flightProduct.MAX_PREMIUM());
+        }
+        if (arrivalTime <= departureTime) {
+            revert FlightProduct.ErrorFlightProductArrivalBeforeDepartureTime(departureTime, arrivalTime);
+        }
+
+        if (arrivalTime > departureTime.addSeconds(flightProduct.MAX_FLIGHT_DURATION())) {
+            revert FlightProduct.ErrorFlightProductArrivalAfterMaxFlightDuration(arrivalTime, departureTime, flightProduct.MAX_FLIGHT_DURATION());
+        }
+        if (departureTime < TimestampLib.current().addSeconds(flightProduct.MIN_TIME_BEFORE_DEPARTURE())) {
+            revert FlightProduct.ErrorFlightProductDepartureBeforeMinTimeBeforeDeparture(departureTime, TimestampLib.current(), flightProduct.MIN_TIME_BEFORE_DEPARTURE());
+        }
+        if (departureTime > TimestampLib.current().addSeconds(flightProduct.MAX_TIME_BEFORE_DEPARTURE())) {
+            revert FlightProduct.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;
+    // }
+
+
+    /// @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, 
+        bytes1 status, 
+        int256 delayMinutes
+    )
+        public
+        returns (uint8 payoutOption)
+    {
+        // default: no payout
+        payoutOption = type(uint8).max;
+
+        // check status
+        if (status != "L" && status != "A" && status != "C" && status != "D") {
+            emit FlightProduct.LogErrorUnprocessableStatus(requestId, riskId, status);
+            return payoutOption;
+        }
+
+        if (status == "A") {
+            // todo: active, reschedule oracle call + 45 min
+            emit FlightProduct.LogErrorUnexpectedStatus(requestId, riskId, status, delayMinutes);
+            return payoutOption;
+        }
+
+        // trigger payout if applicable
+        if (status == "C") { payoutOption = 3; } 
+        else if (status == "D") { payoutOption = 4; } 
+        else if (delayMinutes >= 15 && delayMinutes < 30) { payoutOption = 0; } 
+        else if (delayMinutes >= 30 && delayMinutes < 45) { payoutOption = 1; } 
+        else if (delayMinutes >= 45) { payoutOption = 2; }
+    }
+
+
+    function calculateWeight(
+        FlightProduct flightProduct,
+        uint256[6] memory statistics
+    )
+        public
+        view
+        returns (uint256 weight)
+    {
+        // check we have enough observations
+        if (statistics[0] < flightProduct.MIN_OBSERVATIONS()) {
+            revert FlightProduct.ErrorFlightProductNotEnoughObservations(statistics[0], flightProduct.MIN_OBSERVATIONS());
+        }
+
+        weight = 0;
+        for (uint256 i = 1; i < 6; i++) {
+            weight += flightProduct.WEIGHT_PATTERN(i) * statistics[i] * 10000 / statistics[0];
+        }
+
+        // To avoid div0 in the payout section, we have to make a minimal assumption on weight
+        if (weight == 0) {
+            weight = 100000 / statistics[0];
+        }
+
+        // TODO comment on intended effect
+        weight = (weight * (100 + flightProduct.MARGIN_PERCENT())) / 100;
+    }
+
+
+    // REMARK: each flight may get different payouts depending on the latest statics
+    function calculatePayoutAmounts(
+        FlightProduct flightProduct,
+        Amount premium, 
+        uint256[6] memory statistics
+    )
+        public
+        view
+        returns (
+            uint256 weight, 
+            Amount[5] memory payoutAmounts,
+            Amount sumInsuredAmount // simply the max of payoutAmounts 
+        )
+    {
+        if (premium < flightProduct.MIN_PREMIUM()) { 
+            revert FlightProduct.ErrorFlightProductPremiumAmountTooSmall(premium, flightProduct.MIN_PREMIUM()); 
+        }
+        if (premium > flightProduct.MAX_PREMIUM()) { 
+            revert FlightProduct.ErrorFlightProductPremiumAmountTooLarge(premium, flightProduct.MAX_PREMIUM()); 
+        }
+
+        sumInsuredAmount = AmountLib.zero();
+        weight = calculateWeight(flightProduct, statistics);
+
+        for (uint256 i = 0; i < 5; i++) {
+            Amount payoutAmount = AmountLib.toAmount(
+                premium.toInt() * flightProduct.WEIGHT_PATTERN(i + 1) * 10000 / weight);
+
+            // cap payout and update sum insured if applicable
+            if (payoutAmount > flightProduct.MAX_PAYOUT()) { payoutAmount = flightProduct.MAX_PAYOUT(); }
+            if (payoutAmount > sumInsuredAmount) { sumInsuredAmount = payoutAmount; }
+
+            payoutAmounts[i] = payoutAmount;
+        }
+    }
+
+
+    function getPayoutAmount(
+        bytes memory applicationData, 
+        uint8 payoutOption
+    )
+        public
+        returns (Amount payoutAmount)
+    {
+        // retrieve payout amounts from application data
+        (, Amount[5] memory payoutAmounts) = abi.decode(
+            applicationData, (Amount, Amount[5]));
+
+        // get payout amount for selected option
+        payoutAmount = payoutAmounts[payoutOption];
+    }
+
+
+    function getFlightRisk(
+        InstanceReader reader,
+        NftId productNftId, 
+        Str flightData,
+        Timestamp departureTime, 
+        Timestamp arrivalTime
+    )
+        public
+        view
+        returns (
+            RiskId riskId,
+            bool exists,
+            FlightProduct.FlightRisk memory flightRisk
+        )
+    {
+        riskId = getRiskId(productNftId, flightData);
+        (exists, flightRisk) = getFlightRisk(reader, productNftId, riskId);
+
+        // create new risk if not existing
+        if (!exists) {
+            flightRisk = FlightProduct.FlightRisk({
+                flightData: flightData,
+                departureTime: departureTime,
+                arrivalTime: arrivalTime,
+                sumOfSumInsuredAmounts: AmountLib.toAmount(0),
+                status: bytes1(0),
+                delayMinutes: 0});
+        }
+    }
+
+
+    function getFlightRisk(
+        InstanceReader reader,
+        NftId productNftId,
+        RiskId riskId
+    )
+        public
+        view
+        returns (
+            bool exists,
+            FlightProduct.FlightRisk memory flightRisk
+        )
+    {
+        // check if risk exists
+        exists = reader.isProductRisk(productNftId, riskId);
+
+        // get risk data if risk exists
+        if (exists) {
+            flightRisk = abi.decode(
+                reader.getRiskInfo(riskId).data, (FlightProduct.FlightRisk));
+        }
+    }
+
+
+    function getRiskId(
+        NftId productNftId,
+        Str flightData
+    )
+        public
+        view 
+        returns (RiskId riskId)
+    {
+        bytes32 riskKey = getRiskKey(flightData);
+        riskId = getRiskId(productNftId, riskKey);
+    }
+
+
+    function getRiskKey(
+        Str flightData
+    )
+        internal
+        pure
+        returns (bytes32 riskKey)
+    {
+        return keccak256(abi.encode(flightData));
+    }
+
+
+    function getRiskId(NftId productNftId, bytes32 riskKey) internal view returns (RiskId riskId) {
+        return RiskIdLib.toRiskId(productNftId, riskKey);
+    }
+}

package/contracts/examples/flight/FlightMessageVerifier.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+
+import {Amount} from "../../type/Amount.sol";
+import {Str} from "../../type/String.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+
+contract FlightMessageVerifier is 
+    Ownable
+{
+
+    error ErrorFlightMessageVerifierSignerZero();
+    error ErrorFlightMessageVerifierContractSignerNotSupported();
+
+    address private _expectedSigner;
+
+
+    constructor() Ownable(msg.sender) { }
+
+
+    function setExpectedSigner(address signer) external onlyOwner {
+        if (signer == address(0)) { revert ErrorFlightMessageVerifierSignerZero(); }
+        if (signer.code.length > 0) { revert ErrorFlightMessageVerifierContractSignerNotSupported(); }
+        _expectedSigner = signer;
+    }
+
+
+    function getExpectedSigner() external view returns(address) {
+        return _expectedSigner;
+    }
+
+    /// @dev creates digest hash based on application parameters
+    /// proposal:
+    /// use "LX 180 ZRH BKK 20241104" (23 chars, should be enough for all flights)
+    /// carriers, airports: https://www.iata.org/en/publications/directories/code-search/
+    /// flight numbers: https://en.wikipedia.org/wiki/Flight_number
+    /// instead of separate strings, coding/decoding done anyway off-chain
+    function getRatingsHash(
+        Str flightData,
+        Timestamp departureTime,
+        Timestamp arrivalTime,
+        Amount premiumAmount,
+        uint256[6] memory statistics
+    )
+        public
+        view
+        returns(bytes32)
+    {
+        return MessageHashUtils.toEthSignedMessageHash(
+            abi.encode(
+                flightData,
+                departureTime,
+                arrivalTime,
+                premiumAmount,
+                statistics));
+    }
+
+
+    function verifyRatingsHash(
+        Str flightData,
+        Timestamp departureTime,
+        Timestamp arrivalTime,
+        Amount premiumAmount,
+        uint256[6] memory statistics,
+        // bytes memory signature,
+        uint8 v, 
+        bytes32 r, 
+        bytes32 s
+    )
+        public
+        view
+        returns (
+            address actualSigner,
+            ECDSA.RecoverError errorStatus,
+            bool success
+        )
+    {
+        bytes32 messageHash = getRatingsHash(
+            flightData,
+            departureTime,
+            arrivalTime,
+            premiumAmount,
+            statistics);
+
+        (
+            actualSigner, 
+            errorStatus, 
+        ) = ECDSA.tryRecover(messageHash, v, r, s);
+
+        success = (
+            errorStatus == ECDSA.RecoverError.NoError 
+            && actualSigner == _expectedSigner);
+    }
+
+
+    // TODO re-enable or cleanup
+    // function checkAndRegisterSignature (
+    //     address policyHolder,
+    //     address protectedWallet,
+    //     uint256 protectedBalance,
+    //     uint256 duration,
+    //     uint256 bundleId,
+    //     bytes32 signatureId,
+    //     bytes calldata signature
+    // )
+    //     external 
+    // {
+    //     bytes32 signatureHash = keccak256(abi.encode(signature));
+    //     require(!_signatureIsUsed[signatureHash], "ERROR:DMH-001:SIGNATURE_USED");
+
+    //     address signer = getSignerFromDigestAndSignature(
+    //         protectedWallet,
+    //         protectedBalance,
+    //         duration,
+    //         bundleId,
+    //         signatureId,
+    //         signature);
+
+    //     require(policyHolder == signer, "ERROR:DMH-002:SIGNATURE_INVALID");
+
+    //     _signatureIsUsed[signatureHash] = true;
+    // }
+}

package/contracts/examples/flight/FlightOracle.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+
+import {FULFILLED} 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 {Str} from "../../type/String.sol";
+import {Timestamp} 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
+        // check callback result
+        bool requestFulfilled = _getInstanceReader().getRequestState(
+            requestId) == FULFILLED();
+
+        // remove from active requests when successful
+        if (requestFulfilled) {
+            LibRequestIdSet.remove(_activeRequests, 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);
+    }
+
+    //--- internal functions ------------------------------------------------//
+
+    /// @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,34 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+
+import {BasicOracleAuthorization} from "../../oracle/BasicOracleAuthorization.sol";
+import {FlightOracle} from "./FlightOracle.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract FlightOracleAuthorization
+    is BasicOracleAuthorization
+{
+
+    constructor(string memory oracleName, string memory commitHash)
+        BasicOracleAuthorization(oracleName, commitHash)
+    {}
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // TODO IMPORTANT must not be public role for prod!!!
+        // authorize public role (also protected by onlyOwner)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        _authorize(functions, FlightOracle.respondWithFlightStatus.selector, "respondWithFlightStatus");
+    }
+}
+