@etherisc/gif-next 0.0.2-ef2f083-203 → 0.0.2-efd035d-094

package/contracts/instance/module/IComponents.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount} from "../../type/Amount.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RoleId} from "../../type/RoleId.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../type/UFixed.sol";
+
+interface IComponents {
+
+    struct ComponentInfo {
+        string name; // component name (needs to be unique per instance)
+        NftId productNftId;
+        IERC20Metadata token;
+        TokenHandler tokenHandler;
+        address wallet;
+        bytes data; // will hold component type specific additional info (eg encoded pool info)
+    }
+
+
+    struct ProductInfo {
+        NftId distributionNftId;
+        NftId poolNftId;
+        Fee productFee; // product fee on net premium
+        Fee processingFee; // product fee on payout amounts        
+        Fee distributionFee; // distribution fee for sales that do not include commissions
+        Fee minDistributionOwnerFee; // min fee required by distribution owner (not including commissions for distributors)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+
+
+    struct PoolInfo {
+        NftId productNftId; // the nft of the product this pool is linked to
+        RoleId bundleOwnerRole; // the required role for bundle owners
+        // TODO maxCapitalAmount -> maxBalanceAmount
+        Amount maxCapitalAmount; // max capital amount allowed for pool
+        bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
+        bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
+        bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+}

package/contracts/instance/module/IDistribution.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {DistributorType} from "../../types/DistributorType.sol";
-import {NftId} from "../../types/NftId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {Amount} from "../../type/Amount.sol";
+import {DistributorType} from "../../type/DistributorType.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IDistribution {
 
@@ -24,6 +25,8 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
+        Amount commissionAmount;
+        uint32 numPoliciesSold;
     }
 
     struct ReferralInfo {   

package/contracts/instance/module/IPolicy.sol

@@ -1,27 +1,63 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {NumberId} from "../../types/NumberId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+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 Premium {
+        // premium splitting per target wallet
+        Amount productFeeAmount;
+        Amount distributionFeeAndCommissionAmount;
+        Amount poolPremiumAndFeeAmount;
+
+        // detailed positions
+        // this is the net premium calculated by the product 
+        uint256 netPremiumAmount;
+        // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
+        uint256 fullPremiumAmount;
+        // premium = fullPremium - discount
+        uint256 premiumAmount;
+        uint256 productFeeFixAmount;
+        uint256 poolFeeFixAmount;
+        uint256 bundleFeeFixAmount;
+        uint256 distributionFeeFixAmount;
+        uint256 productFeeVarAmount;
+        uint256 poolFeeVarAmount;
+        uint256 bundleFeeVarAmount;
+        uint256 distributionFeeVarAmount;
+        uint256 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)
+        uint256 distributionOwnerFeeVarAmount;
+        // this value is based on distributor type referenced in the referral 
+        uint256 commissionAmount;
+        // this is based on referral used
+        uint256 discountAmount;
+    }
+
+    /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
         NftId productNftId;
         NftId bundleNftId;
         ReferralId referralId;
         RiskId riskId;
-        uint256 sumInsuredAmount;
-        uint256 premiumAmount;
-        uint256 premiumPaidAmount;
-        uint256 lifetime;
+        Amount sumInsuredAmount;
+        Amount premiumAmount; // expected premium at application time
+        Amount premiumPaidAmount; // actual paid premium 
+        Seconds lifetime;
+        // policy application data, no changes after applying for a policy
         bytes applicationData;
-        bytes policyData;
+        bytes processData;
         uint16 claimsCount;
         uint16 openClaimsCount;
-        uint256 payoutAmount;
+        Amount claimAmount; // sum of confirmed claim amounts (max = sum insured amount)
+        Amount payoutAmount; // sum of payouts (max = sum confirmed claim amountst)
         Timestamp activatedAt; // time of underwriting
         Timestamp expiredAt; // no new claims (activatedAt + lifetime)
         Timestamp closedAt; // no locked capital (or declinedAt)
@@ -29,16 +65,19 @@ interface IPolicy {
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct ClaimInfo {
-        uint256 claimAmount;
-        uint256 paidAmount;
-        bytes data;
-        Timestamp closedAt; // payoment of confirmed claim amount (or declinedAt)
+        Amount claimAmount;
+        Amount paidAmount;
+        uint8 payoutsCount;
+        uint8 openPayoutsCount;
+        bytes submissionData; // claim submission data, no changes after submitting the claim
+        bytes processData; // data that may include information supporting confirm or decline
+        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
     }
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct PayoutInfo {
-        NumberId claimId;
-        uint256 amount;
+        ClaimId claimId;
+        Amount amount;
         bytes data;
         Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)
     }

package/contracts/instance/module/IRisk.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
+import {NftId} from "../../type/NftId.sol";
 
 interface IRisk {
     struct RiskInfo {

package/contracts/{test/Usdc.sol → mock/Dip.sol}

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-contract USDC is ERC20 {
+contract Dip is ERC20 {
 
     // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
-    string public constant NAME = "USDC - DUMMY";
-    string public constant SYMBOL = "USDC";
-    uint8 public constant DECIMALS = 6;
+    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()

package/contracts/oracle/IOracle.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../type/NftId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracle {
+
+    struct RequestInfo {
+        NftId requesterNftId; // originator of the request
+        string callbackMethodName; // callback function of the requestor to call to provide response data
+        NftId oracleNftId; // responsible oracle component
+        bytes requestData; 
+        bytes responseData; 
+        Timestamp respondedAt; // response timestamp
+        Timestamp expiredAt; // expiry timestamp
+        bool isCancelled;
+    }
+}

package/contracts/oracle/IOracleComponent.sol

@@ -0,0 +1,16 @@
+// 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 {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IOracleComponent is IInstanceLinkedComponent {
+
+    /// @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,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.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 LogOracleRequestFulfilled(RequestId requestId, NftId oracleNftId);
+    event LogOracleRequestCancelled(RequestId requestId, NftId requesterNftId);
+
+    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.
+    /// permissioned: only registered components may send requests to oracles.
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName // TODO consider to replace with method signature
+    ) external returns (RequestId requestId);
+
+    /// @dev respond to oracle request by oracle compnent.
+    /// persmissioned: only the oracle component linked to the request id may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    ) external;
+
+    /// @dev notify the oracle component that the specified request has become invalid
+    /// permissioned: only the originator of the request may cancel a request
+    function cancel(RequestId requestId) external;
+
+}

package/contracts/oracle/Oracle.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {COMPONENT, ORACLE} from "../type/ObjectType.sol";
+import {IOracleService} from "./IOracleService.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IOracleComponent} from "./IOracleComponent.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+import {UFixed} from "../type/UFixed.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 initializeOracle(
+        address registry,
+        NftId instanceNftId,
+        address initialOwner,
+        string memory name,
+        address token,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // component specifidc data 
+    )
+        public
+        virtual
+        onlyInitializing()
+    {
+        initializeInstanceLinkedComponent(registry, instanceNftId, name, token, ORACLE(), true, initialOwner, registryData, componentData);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        registerInterface(type(IOracleComponent).interfaceId);
+    }
+
+
+    function register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getOracleStorage()._componentService.registerOracle();
+    }
+
+
+    function isVerifying()
+        external 
+        virtual 
+        view 
+        returns (bool verifying)
+    {
+        return false;
+    }
+
+
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        external
+        virtual
+        restricted() // only oracle service
+    {
+        _request(requestId, requesterId, requestData, expiryAt);
+    }
+
+
+    /// @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 handling oracle responses.
+    /// use this function in use case specific external/public functions
+    /// to handle use case specific response handling.
+    function _respond(
+        RequestId requestId,
+        bytes calldata responseData
+    )
+        internal
+        virtual
+    {
+        _getOracleStorage()._oracleService.respond(
+            requestId, responseData);
+    }
+
+    function _getOracleStorage() private pure returns (OracleStorage storage $) {
+        assembly {
+            $.slot := ORACLE_STORAGE_LOCATION_V1
+        }
+    }
+}

package/contracts/oracle/OracleService.sol

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {IComponent} from "../shared/IComponent.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IOracle} from "./IOracle.sol";
+import {IOracleComponent} from "./IOracleComponent.sol";
+import {IOracleService} from "./IOracleService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, ORACLE, INSTANCE} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId, ACTIVE, FULFILLED, CANCELLED} from "../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+
+
+contract OracleService is
+    ComponentVerifyingService,
+    IOracleService
+{
+
+    IInstanceService private _instanceService;
+
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address initialOwner;
+        address registryAddress;
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        initializeService(registryAddress, address(0), owner);
+
+        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
+
+        registerInterface(type(IOracleService).interfaceId);
+    }
+
+    function getDomain() public pure override returns(ObjectType) {
+        return ORACLE();
+    }
+
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName // TODO consider to replace with method signature
+    )
+        external 
+        virtual 
+        // restricted() // add authz
+        returns (
+            RequestId requestId
+        ) 
+    {
+        (
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(COMPONENT());
+
+        // TODO add checks
+        // oracleNftId exists and is active oracle
+        // expiriyAt > 0
+        // callbackMethodName.length > 0
+
+        IOracle.RequestInfo memory request = IOracle.RequestInfo({
+            requesterNftId: componentNftId,
+            callbackMethodName: callbackMethodName,
+            oracleNftId: oracleNftId,
+            requestData: requestData,
+            responseData: "",
+            respondedAt: TimestampLib.zero(),
+            expiredAt: expiryAt,
+            isCancelled: false
+        });
+
+        requestId = instance.getInstanceStore().createRequest(request);
+
+        // TODO add call to oracle component
+
+        emit LogOracleServiceRequestCreated(requestId, componentNftId, oracleNftId, expiryAt);
+    }
+
+
+    /// @dev respond to oracle request by oracle compnent.
+    /// permissioned: only the oracle component linked to the request id may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    )
+        external
+        virtual
+        // restricted() // add authz
+    {
+        (
+            NftId oracleNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(ORACLE());
+
+        bool callerIsOracle = true;
+        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
+        request.responseData = responseData;
+        request.respondedAt = TimestampLib.blockTimestamp();
+
+        instance.getInstanceStore().updateRequest(requestId, request, FULFILLED());
+
+        // TODO add callback to requesting compnent
+
+        emit LogOracleRequestFulfilled(requestId, oracleNftId);
+    }
+
+    /// @dev notify the oracle component that the specified request has become invalid
+    /// permissioned: only the originator of the request may cancel a request
+    function cancel(RequestId requestId)
+        external 
+        virtual 
+        // restricted() // add authz
+    {
+        (
+            NftId requesterNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        ) = _getAndVerifyActiveComponent(COMPONENT());
+
+        bool callerIsOracle = false;
+        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
+        request.isCancelled = true;
+
+        instance.getInstanceStore().updateRequest(requestId, request, CANCELLED());
+
+        emit LogOracleRequestCancelled(requestId, requesterNftId);
+    }
+
+
+    function _checkAndGetRequestInfo(
+        IInstance instance,
+        RequestId requestId,
+        NftId callerNftId,
+        bool callerIsOracle
+    )
+        internal
+        virtual
+        view
+        returns (IOracle.RequestInfo memory info)
+    {
+        InstanceReader reader = instance.getInstanceReader();
+        StateId state = reader.getState(requestId.toKey32());
+
+        // check request state
+        if (state != ACTIVE()) {
+            revert ErrorOracleServiceRequestStateNotActive(requestId, state);
+        }
+
+        // check caller against resonsible oracle or requester
+        info = reader.getRequestInfo(requestId);
+        if (callerIsOracle) {
+            if (callerNftId != info.oracleNftId) {
+                revert ErrorOracleServiceCallerNotResponsibleOracle(requestId, info.oracleNftId, callerNftId);
+            }
+        } else {
+            if (callerNftId != info.requesterNftId) {
+                revert ErrorOracleServiceCallerNotRequester(requestId, info.requesterNftId, callerNftId);
+            }
+        }
+
+        // check expiry
+        if (info.expiredAt < TimestampLib.blockTimestamp()) {
+            revert ErrorOracleServiceRequestExpired(requestId, info.expiredAt);
+        }
+    }
+
+
+    function _getInstanceForComponent(NftId componentNftId)
+        internal
+        view
+        returns(IInstance instance)
+    {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }
+}

package/contracts/oracle/OracleServiceManager.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {OracleService} from "./OracleService.sol";
+import {Registry} from "../registry/Registry.sol";
+import {RegistryService} from "../registry/RegistryService.sol";
+import {REGISTRY} from "../type/ObjectType.sol";
+
+contract OracleServiceManager is ProxyManager {
+
+    OracleService private _oracleService;
+
+    /// @dev initializes proxy manager with service implementation and deploys instance
+    constructor(
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
+    {
+        OracleService orclSrv = new OracleService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
+            address(orclSrv), 
+            data,
+            salt);
+
+        _oracleService = OracleService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getOracleService()
+        external
+        view
+        returns (OracleService oracleService)
+    {
+        return _oracleService;
+    }
+
+}