@etherisc/gif-next 0.0.2-ffba655 → 3.0.0-1a7e54a-113

package/contracts/instance/module/IPolicy.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../../type/Amount.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ClaimId} from "../../type/ClaimId.sol";
+import {ReferralId} from "../../type/Referral.sol";
+import {RiskId} from "../../type/RiskId.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+
+interface IPolicy {
+
+    struct PremiumInfo {
+        // slot 0
+        // premium splitting per target wallet
+        Amount productFeeAmount;
+        Amount distributionFeeAndCommissionAmount;
+        // slot 1
+        Amount poolPremiumAndFeeAmount;
+
+        // detailed positions
+        // this is the net premium calculated by the product 
+        Amount netPremiumAmount;
+        // slot 2
+        // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
+        Amount fullPremiumAmount;
+        // effective premium = fullPremium - discount 
+        Amount premiumAmount;
+        // slot 3
+        Amount productFeeFixAmount;
+        Amount poolFeeFixAmount;
+        // slot 4
+        Amount bundleFeeFixAmount;
+        Amount distributionFeeFixAmount;
+        // slot 5
+        Amount productFeeVarAmount;
+        Amount poolFeeVarAmount;
+        // slot 6
+        Amount bundleFeeVarAmount;
+        Amount distributionFeeVarAmount;
+        // slot 7
+        Amount distributionOwnerFeeFixAmount;
+        // this is the remaining amount when the commission and discount are subtracted from the distribution fee variable part (must be at least the minDistributionOwnerFee)
+        Amount distributionOwnerFeeVarAmount;
+        // slot 8
+        // this value is based on distributor type referenced in the referral 
+        Amount commissionAmount;
+        // this is based on referral used
+        Amount discountAmount;
+    }
+
+    /// @dev policy data for the full policy lifecycle
+    struct PolicyInfo {
+        // slot 0
+        NftId productNftId;
+        NftId bundleNftId;
+        RiskId riskId;
+        // slot 1
+        Amount sumInsuredAmount;
+        Amount premiumAmount; // expected premium at application time
+        ReferralId referralId;
+        // slot 2
+        uint16 claimsCount;
+        uint16 openClaimsCount;
+        Amount claimAmount; // sum of confirmed claim amounts (max = sum insured amount)
+        Amount payoutAmount; // sum of payouts (max = sum confirmed claim amountst)
+        // slot 3
+        Timestamp activatedAt; // time of underwriting
+        Seconds lifetime;
+        Timestamp expiredAt; // no new claims (activatedAt + lifetime)
+        Timestamp closedAt; // no locked capital (or declinedAt)
+        // slot 4
+        bytes applicationData;
+        // slot 5
+        bytes processData;
+    }
+
+    // claimId neeeds to be encoded policyNftId:claimId combination
+    struct ClaimInfo {
+        // slot 0
+        Amount claimAmount;
+        Amount paidAmount;
+        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
+        uint24 payoutsCount;
+        // slot 1
+        uint24 openPayoutsCount;
+        // slot 2
+        bytes submissionData; // use case specific claim submission data, no changes after submitting the claim
+        // slot 3
+        bytes processData; // use case specific data that may include information supporting confirm or decline
+    }
+
+    // claimId neeeds to be encoded policyNftId:claimId combination
+    struct PayoutInfo {
+        // slot 0
+        ClaimId claimId;
+        Amount amount;
+        Timestamp paidAt; // timestamp for actual payout
+        // slot 1
+        address beneficiary; // for address(0) beneficiary is policy nft owner
+        // slot 2
+        bytes data; // use case specific supporting data
+    }
+}

package/contracts/instance/module/IRisk.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../../type/NftId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+
+interface IRisk {
+
+    struct RiskInfo {
+        // slot 0
+        NftId productNftId;
+        Timestamp createdAt;
+        // slot 1
+        bytes data;
+    }
+}

package/contracts/mock/Dip.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Dip is ERC20 {
+
+    // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
+    string public constant NAME = "Decentralized Insurance Protocol - DUMMY";
+    string public constant SYMBOL = "DIP";
+    uint8 public constant DECIMALS = 18;
+    uint256 public constant INITIAL_SUPPLY = 10**9 * 10**DECIMALS; // 1 Billion 1'000'000'000
+    // decimals == 18 (openzeppelin erc20 default)
+    constructor()
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/oracle/BasicOracle.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../contracts/authorization/IAuthorization.sol";
+import {NftId} from "../../contracts/type/NftId.sol";
+import {Oracle} from "../../contracts/oracle/Oracle.sol";
+import {RequestId} from "../../contracts/type/RequestId.sol";
+
+contract BasicOracle is
+    Oracle
+{
+
+    /// Function to provide reponse data releated to request id.
+    function respond(
+        RequestId requestId,
+        bytes memory responseData
+    )
+        external
+        virtual
+        restricted()
+    {
+        _respond(requestId, responseData);
+    }
+
+    function _initializeBasicOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+
+        __Oracle_init(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name);
+    }
+}

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicOracle} from "./BasicOracle.sol"; 
+import {ORACLE} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IOracle} from "./IOracle.sol"; 
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicOracleAuthorization
+     is Authorization
+{
+
+     constructor(
+          string memory componentName,
+          string memory commitHash
+     )
+          Authorization(
+               componentName, 
+               ORACLE(), 
+               3, 
+               commitHash, 
+               TargetType.Component, 
+               false)
+     {}
+
+     function _setupServiceTargets()
+          internal
+          virtual override
+     {
+          _authorizeServiceDomain(ORACLE(), address(15));
+     }
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getMainTargetName(), getServiceRole(ORACLE()));
+          _authorize(functions, IOracle.request.selector, "request");
+          _authorize(functions, IOracle.cancel.selector, "cancel");
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicOracle.respond.selector, "respond");
+     }
+}
+

package/contracts/oracle/IOracle.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../type/NftId.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracle {
+
+    struct RequestInfo {
+        // slot 0
+        NftId requesterNftId; // originator of the request
+        NftId oracleNftId; // responsible oracle component
+        bool isCancelled;
+        Timestamp respondedAt; // response timestamp
+        // slot 1
+        Timestamp expiredAt; // expiry timestamp
+        // slot 2
+        string callbackMethodName; // callback function of the requestor to call to provide response data
+        // slot 3
+        bytes requestData; 
+        // slot 4
+        bytes responseData; 
+    }
+
+
+    /// @dev Callback function for oracle service to notify this oracle component to retreive some oracle data.
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    ) external;
+
+
+    /// @dev Callback function for oracle service to notify this oracle component that the specified oracle request has ben cancelled by the requestor.
+    function cancel(
+        RequestId requestId
+    ) external;
+}

package/contracts/oracle/IOracleComponent.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Fee} from "../type/Fee.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {ReferralId, ReferralStatus} from "../type/Referral.sol";
+import {NftId} from "../type/NftId.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IOracleComponent is IInstanceLinkedComponent {
+    error ErrorOracleNotImplemented(string methodName);
+    
+    /// @dev callback method for requesting some data from the oracle
+    function request(
+        RequestId requestId,
+        NftId requesterNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    ) external;
+
+
+    /// @dev callback method for cancelling the specified oracle request
+    function cancel(
+        RequestId requestId
+    ) external;
+
+
+    /// @dev returns true iff the component needs to be called when selling/renewing policis
+    function isVerifying() external view returns (bool verifying);
+}

package/contracts/oracle/IOracleService.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracleService is IService {
+
+    event LogOracleServiceRequestCreated(RequestId requestId, NftId requesterNftId, NftId oracleNftId, Timestamp expiryAt);
+    event LogOracleServiceResponseProcessed(RequestId requestId, NftId oracleNftId);
+    event LogOracleServiceDeliveryFailed(RequestId requestId, address requesterAddress, string functionSignature);
+    event LogOracleServiceResponseResent(RequestId requestId, NftId requesterNftId);
+    event LogOracleServiceRequestCancelled(RequestId requestId, NftId requesterNftId);
+
+    // create request
+    error ErrorOracleServiceProductMismatch(ObjectType callerObjectType, NftId productNft, NftId oracleParentNftId);
+    error ErrorOracleServiceExpiryInThePast(Timestamp blockTimestamp, Timestamp expiryAt);
+    error ErrorOracleServiceCallbackMethodNameEmpty();
+
+    // respond
+    error ErrorOracleServiceNotResponsibleOracle(RequestId requestId, NftId expectedOracleNftId, NftId oracleNftId);
+
+    // get request info
+    error ErrorOracleServiceRequestStateNotActive(RequestId requestId, StateId state);
+    error ErrorOracleServiceCallerNotResponsibleOracle(RequestId requestId, NftId oracleNftId, NftId callerNftId);
+    error ErrorOracleServiceCallerNotRequester(RequestId requestId, NftId requesterNftId, NftId callerNftId);
+    error ErrorOracleServiceRequestExpired(RequestId requestId, Timestamp expiredAt);
+    
+    /// @dev send an oracle request to the specified oracle component.
+    /// the function returns the id of the newly created request.
+    /// permissioned: only registered components may send requests to oracles.
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName
+    ) external returns (RequestId requestId);
+
+    /// @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 receiving oracle component may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    ) external returns (bool success);
+
+    /// @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
+    function cancel(RequestId requestId) external;
+
+}

package/contracts/oracle/Oracle.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {COMPONENT, PRODUCT, 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 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;
+    }
+
+    /// @dev Not relevant for oracle components
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        override(IInstanceLinkedComponent, InstanceLinkedComponent)
+        onlyOwner()
+        restricted()
+        returns (Amount)
+    {
+        revert ErrorOracleNotImplemented("withdrawFees");
+    }
+
+
+    function __Oracle_init(
+        address registry,
+        NftId productNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        __InstanceLinkedComponent_init(
+            registry, 
+            productNftId, 
+            name, 
+            ORACLE(), 
+            authorization,
+            true, 
+            initialOwner);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+
+        _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
+        }
+    }
+}