@etherisc/gif-next 0.0.2-95f8cce-959 → 0.0.2-9628b30-648

package/contracts/instance/base/ObjectLifecycle.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PREMIUM, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL, FEE} from "../../type/ObjectType.sol";
+import {ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../../type/StateId.sol";
+import {Lifecycle} from "../../shared/Lifecycle.sol";
+
+contract ObjectLifecycle is
+    Lifecycle,
+    Initializable
+{
+    function _initializeLifecycle() internal onlyInitializing
+    {
+        _setupLifecycle();
+    }
+
+    function _setupLifecycle()
+        internal
+        override
+    {
+        _setupBundleLifecycle();
+        _setupComponentLifecycle();
+        _setupPolicyLifecycle();
+        _setupPremiumLifecycle();
+        _setupClaimLifecycle();
+        _setupPayoutLifecycle();
+        _setupRiskLifecycle();
+        _setupRequestLifecycle();
+
+        // setup dummy lifecycles to manage with key value store 
+        _setUpPoolLifecycle();
+        _setUpProductLifecycle();
+        _setUpDistributionLifecycle();
+    }
+
+    function _setupComponentLifecycle() private {
+        setInitialState(COMPONENT(), ACTIVE());
+        setStateTransition(COMPONENT(), ACTIVE(), PAUSED());
+        setStateTransition(COMPONENT(), PAUSED(), ACTIVE());
+        setStateTransition(COMPONENT(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupBundleLifecycle() private {
+        setInitialState(BUNDLE(), ACTIVE());
+        setStateTransition(BUNDLE(), ACTIVE(), CLOSED());
+    }
+
+    function _setupPolicyLifecycle() private {
+        setInitialState(POLICY(), APPLIED());
+        setStateTransition(POLICY(), APPLIED(), REVOKED());
+        setStateTransition(POLICY(), APPLIED(), DECLINED());
+        setStateTransition(POLICY(), APPLIED(), COLLATERALIZED());
+        setStateTransition(POLICY(), COLLATERALIZED(), CLOSED());
+    }
+
+    function _setupPremiumLifecycle() private {
+        setInitialState(PREMIUM(), EXPECTED());
+        setStateTransition(PREMIUM(), EXPECTED(), PAID());
+    }
+
+    function _setupClaimLifecycle() private {
+        setInitialState(CLAIM(), SUBMITTED());
+        setStateTransition(CLAIM(), SUBMITTED(), REVOKED());
+        setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
+        setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
+        setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+        setStateTransition(CLAIM(), CONFIRMED(), CANCELLED());
+    }
+
+    function _setupPayoutLifecycle() private {
+        setInitialState(PAYOUT(), EXPECTED());
+        setStateTransition(PAYOUT(), EXPECTED(), PAID());
+        setStateTransition(PAYOUT(), EXPECTED(), CANCELLED());
+    }
+
+    function _setupRiskLifecycle() private {
+        setInitialState(RISK(), ACTIVE());
+        setStateTransition(RISK(), ACTIVE(), CLOSED());
+    }
+
+    function _setupRequestLifecycle() private {
+        setInitialState(REQUEST(), ACTIVE());
+        setStateTransition(REQUEST(), ACTIVE(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), FAILED());
+        setStateTransition(REQUEST(), FAILED(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), CANCELLED());
+    }
+
+    // dummy lifecycle only
+    function _setUpPoolLifecycle() private {
+        setInitialState(POOL(), ACTIVE());
+    }
+
+    // dummy lifecycle only
+    function _setUpProductLifecycle() private {
+        setInitialState(PRODUCT(), ACTIVE());
+        setInitialState(FEE(), ACTIVE());
+    }
+
+    // dummy lifecycles only
+    function _setUpDistributionLifecycle() private {
+        setInitialState(DISTRIBUTION(), ACTIVE());
+        setInitialState(DISTRIBUTOR(), ACTIVE());
+        setInitialState(DISTRIBUTOR_TYPE(), ACTIVE());
+        setInitialState(REFERRAL(), ACTIVE());
+    }
+}

package/contracts/instance/base/ObjectSet.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Cloneable} from "./Cloneable.sol";
+
+import {LibKey32Set} from "../../type/Key32Set.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Key32} from "../../type/Key32.sol";
+
+contract ObjectSet is
+    Cloneable
+{
+    using LibKey32Set for LibKey32Set.Set;
+
+    event LogObjectSetInitialized(address instance);
+
+    error ErrorObjectSetNftIdInvalid(NftId instanceNftId);
+
+    mapping(NftId compnentNftId => LibKey32Set.Set objects) internal _activeObjects;
+    mapping(NftId compnentNftId => LibKey32Set.Set objects) internal _allObjects;
+    address internal _instanceAddress;
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize(address authority, address registry) 
+        external
+        initializer()
+    {
+        _instanceAddress = msg.sender;
+        __Cloneable_init(authority, registry);
+        
+        emit LogObjectSetInitialized(address(_instanceAddress));
+    }
+
+    function getInstanceAddress() external view returns (address) {
+        return _instanceAddress;
+    }
+
+    function _add(NftId componentNftId, Key32 key) internal {
+        LibKey32Set.Set storage allSet = _allObjects[componentNftId];
+        LibKey32Set.Set storage activeSet = _activeObjects[componentNftId];
+
+        allSet.add(key);
+        activeSet.add(key);
+    }
+
+    function _activate(NftId componentNftId, Key32 key) internal {
+        _activeObjects[componentNftId].add(key);
+    }
+
+    function _deactivate(NftId componentNftId, Key32 key) internal {
+        _activeObjects[componentNftId].remove(key);
+    }
+
+    function _objects(NftId componentNftId) internal view returns (uint256) {
+        return _allObjects[componentNftId].size();
+    }
+
+    function _contains(NftId componentNftId, Key32 key) internal view returns (bool) {
+        return _allObjects[componentNftId].contains(key);
+    }
+
+    function _getObject(NftId componentNftId, uint256 idx) internal view returns (Key32) {
+        return _allObjects[componentNftId].getElementAt(idx);
+    }
+
+    function _activeObjs(NftId componentNftId) internal view returns (uint256)  {
+        return _activeObjects[componentNftId].size();
+    }
+
+    function _isActive(NftId componentNftId, Key32 key) internal view returns (bool) {
+        return _activeObjects[componentNftId].contains(key);
+    }
+
+    function _getActiveObject(NftId componentNftId, uint256 idx) internal view returns (Key32) {
+        return _activeObjects[componentNftId].getElementAt(idx);
+    }
+}

package/contracts/instance/base/ObjectSetHelperLib.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IBundle} from "../module/IBundle.sol";
+import {IInstance} from "../IInstance.sol";
+import {IRisk} from "../module/IRisk.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RiskId} from "../../type/RiskId.sol";
+
+
+library ObjectSetHelperLib {
+
+    function getRiskInfo(address instanceAddress, RiskId riskId) public view returns (IRisk.RiskInfo memory) {
+
+        return IInstance(instanceAddress).getInstanceReader().getRiskInfo(riskId);
+    }
+
+    function getProductNftId(address instanceAddress, RiskId riskId) public view returns (NftId) {
+        return getRiskInfo(instanceAddress, riskId).productNftId;
+    }
+
+    function getBundleInfo(address instanceAddress, NftId bundleNftId) public view returns (IBundle.BundleInfo memory) {
+        return IInstance(instanceAddress).getInstanceReader().getBundleInfo(bundleNftId);
+    }
+
+    function getPoolNftId(address instanceAddress, NftId bundleNftId) public view returns (NftId) {
+        return getBundleInfo(instanceAddress, bundleNftId).poolNftId;
+    }
+
+}

package/contracts/instance/module/IBundle.sol

@@ -1,23 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../../types/Amount.sol";
-import {NftId} from "../../types/NftId.sol";
-import {Fee} from "../../types/Fee.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Fee} from "../../type/Fee.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IBundle {
 
     struct BundleInfo {
+        // slot 0
+        Timestamp activatedAt; 
+        Timestamp expiredAt; // no new policies starting with this timestamp
+        Timestamp closedAt; // no open policies, locked amount = 0
         NftId poolNftId;
+        // slot 1
         Fee fee; // bundle fee on net premium amounts
+        // slot 2
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
-        Amount capitalAmount; // net stakings + net premiums - payouts
-        Amount lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= capital amount)
-        Amount feeAmount; // accumulated fee amount
-        Seconds lifetime;
-        Timestamp expiredAt; // no new policies starting with this timestamp
-        Timestamp closedAt; // no open policies, locked amount = 0
     }
 }

package/contracts/instance/module/IComponents.sol

@@ -1,41 +1,62 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-import {Amount} from "../../types/Amount.sol";
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
-import {RoleId} from "../../types/RoleId.sol";
+import {Amount} from "../../type/Amount.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IComponents {
 
     struct ComponentInfo {
+        // slot 0
         string name; // component name (needs to be unique per instance)
-        IERC20Metadata token;
+        // slot 1
         TokenHandler tokenHandler;
-        address wallet;
-        Amount balanceAmount; // calculated balance (may not necessarily match withg wallet balance)
-        Amount feeAmount; // accumulated fees belonging to component owner
+        // slot 2
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
-    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
-        uint256 maxCapitalAmount; // max capital amount allowed for pool
-        uint256 balanceAmount; // current pool balance (accounting view)
-        uint256 feeAmount; // accumulated fee amount
-        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%)
+    struct ProductInfo {
+        // slot 0
+        bool isProcessingFundedClaims; // custom logic to react to pool events for funded claims
+        bool isInterceptingPolicyTransfers; // custom logic for policy nft transfers
+        bool hasDistribution; // flag to indicate if distribution is enabled
+        uint8 expectedNumberOfOracles; // expected number of oracles
+        uint8 numberOfOracles; // actual number of oracles
+        NftId poolNftId; // mandatory
+        NftId distributionNftId; // 0..1 (optional)
+        // slot 1
+        NftId [] oracleNftId; // 0..n (optional)
+    }
+
+    struct FeeInfo {
+        // slot 0
+        Fee productFee; // product fee on net premium
+        // slot 1
+        Fee processingFee; // product fee on payout amounts        
+        // slot 2
+        Fee distributionFee; // distribution fee for sales that do not include commissions
+        // slot 3
+        Fee minDistributionOwnerFee; // min fee required by distribution owner (not including commissions for distributors)
+        // slot 4
         Fee poolFee; // pool fee on net premium
+        // slot 5
         Fee stakingFee; // pool fee on staked capital from investor
+        // slot 6
         Fee performanceFee; // pool fee on profits from capital investors
     }
+
+    struct PoolInfo {
+        // slot 0
+        Amount maxBalanceAmount; // max balance amount allowed for pool
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        // slot 1
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        bool isInterceptingBundleTransfers; // custom logic for bundle nft transfers
+        bool isProcessingConfirmedClaims; // custom logic for claims confirmation
+        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 
+    }
 }

package/contracts/instance/module/IDistribution.sol

@@ -1,40 +1,53 @@
 // 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 {DistributorType} from "../../type/DistributorType.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IDistribution {
 
     struct DistributorTypeInfo {
-        string name;
+        // slot 0
         UFixed minDiscountPercentage;
+        NftId distributionNftId;
+        // slot 1
         UFixed maxDiscountPercentage;
-        UFixed commissionPercentage;
         uint32 maxReferralCount;
-        uint32 maxReferralLifetime;
+        Seconds maxReferralLifetime;
         bool allowSelfReferrals;
         bool allowRenewals;
+        // slot 2
+        UFixed commissionPercentage;
+        // slot 3
+        string name;                
+        // slot 4
         bytes data;
     }
 
     struct DistributorInfo {
+        // slot 0
         DistributorType distributorType;
         bool active;
+        uint32 numPoliciesSold;
+        // slot 1
         bytes data;
-        uint256 sumCommisions;
-        uint256 numPoliciesSold;
     }
 
-    struct ReferralInfo {   
+    struct ReferralInfo {
+        // slot 0
+        NftId distributionNftId;
         NftId distributorNftId;
-        string referralCode;
-        UFixed discountPercentage;
         uint32 maxReferrals;
         uint32 usedReferrals;
+        // slot 1
+        UFixed discountPercentage;
         Timestamp expiryAt;
+        // slot 2
+        string referralCode;
+        // slot 3
         bytes data;
     }
 

package/contracts/instance/module/IPolicy.sol

@@ -1,72 +1,105 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {ClaimId} from "../../types/ClaimId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
-import {Seconds} from "../../types/Seconds.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 {
+    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 
-        uint256 netPremiumAmount;
+        Amount netPremiumAmount;
+        // slot 2
         // 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;
+        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)
-        uint256 distributionOwnerFeeVarAmount;
+        Amount distributionOwnerFeeVarAmount;
+        // slot 8
         // this value is based on distributor type referenced in the referral 
-        uint256 commissionAmount;
+        Amount commissionAmount;
         // this is based on referral used
-        uint256 discountAmount;
+        Amount discountAmount;
     }
 
     /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
+        // slot 0
         NftId productNftId;
         NftId bundleNftId;
-        ReferralId referralId;
         RiskId riskId;
-        uint256 sumInsuredAmount;
-        uint256 premiumAmount;
-        uint256 premiumPaidAmount;
-        Seconds lifetime;
-        bytes applicationData;
-        bytes policyData;
+        // slot 1
+        Amount sumInsuredAmount;
+        Amount premiumAmount; // expected premium at application time
+        ReferralId referralId;
+        // slot 2
         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)
+        // 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 {
-        uint256 claimAmount;
-        uint256 paidAmount;
-        bytes data;
-        Timestamp closedAt; // payoment of confirmed claim amount (or declinedAt)
+        // 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;
-        uint256 amount;
-        bytes data;
-        Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)
+        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

@@ -1,11 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
+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/{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";
+import {ERC20} from "@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/BasicOracle.sol

@@ -0,0 +1,45 @@
+// 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,
+            "");
+    }
+}