@etherisc/gif-next 0.0.2-b312c9a-831 → 0.0.2-b37fa8b-169

package/contracts/instance/module/IComponents.sol

@@ -1,25 +1,25 @@
 // 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 {
+        // slot 0
         string name; // component name (needs to be unique per instance)
-        IERC20Metadata token;
+        // slot 1
         TokenHandler tokenHandler;
+        // slot 2
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
     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
@@ -27,24 +27,36 @@ interface IComponents {
         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 
-        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
-        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
     }
 }

package/contracts/instance/module/IDistribution.sol

@@ -1,40 +1,53 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../../type/Amount.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;
-        bytes data;
         uint32 numPoliciesSold;
+        // slot 1
+        bytes data;
     }
 
-    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

@@ -12,29 +12,38 @@ 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
@@ -43,43 +52,54 @@ interface IPolicy {
 
     /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
-        // application data, no changes after applying for a policy
+        // slot 0
         NftId productNftId;
         NftId bundleNftId;
-        ReferralId referralId;
         RiskId riskId;
+        // slot 1
         Amount sumInsuredAmount;
         Amount premiumAmount; // expected premium at application time
-        Seconds lifetime;
-        bytes applicationData;
-        // policy data that may change during the lifecycle
-        bytes processData;
+        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
-        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
     }
 
     // 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
-        Timestamp paidAt; // timestamp for actual payout
     }
 }

package/contracts/instance/module/IRisk.sol

@@ -2,11 +2,15 @@
 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/oracle/BasicOracle.sol

@@ -27,21 +27,19 @@ contract BasicOracle is
         NftId instanceNftId,
         IAuthorization authorization,
         address initialOwner,
-        string memory name,
-        address token
+        string memory name
     )
         internal
         virtual
         onlyInitializing()
     {
 
-        _initializeOracle(
+        __Oracle_init(
             registry,
             instanceNftId,
             authorization,
             initialOwner,
             name,
-            token,
             "");
     }
 }

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -14,19 +14,26 @@ contract BasicOracleAuthorization
      is Authorization
 {
 
-     constructor(string memory componentName)
-          Authorization(componentName)
+     constructor(
+          string memory componentName,
+          string memory commitHash
+     )
+          Authorization(
+               componentName, 
+               ORACLE(), 
+               3, 
+               commitHash, 
+               true, 
+               false)
      {}
 
-     function _setupTargets()
+     function _setupServiceTargets()
           internal
           virtual override
      {
-          // basic component target
-          _addComponentTargetWithRole(ORACLE()); 
+          _authorizeServiceDomain(ORACLE(), address(15));
      }
 
-
      function _setupTargetAuthorizations()
           internal
           virtual override
@@ -34,12 +41,12 @@ contract BasicOracleAuthorization
           IAccess.FunctionInfo[] storage functions;
 
           // authorize public role (open access to any account, only allows to lock target)
-          functions = _authorizeForTarget(getTargetName(), getServiceRole(ORACLE()));
+          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(getTargetName(), PUBLIC_ROLE());
+          functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
           _authorize(functions, BasicOracle.respond.selector, "respond");
      }
 }

package/contracts/oracle/IOracle.sol

@@ -9,14 +9,19 @@ import {Timestamp} from "../type/Timestamp.sol";
 interface IOracle {
 
     struct RequestInfo {
+        // slot 0
         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; 
+        bool isCancelled;
         Timestamp respondedAt; // response timestamp
+        // slot 1
         Timestamp expiredAt; // expiry timestamp
-        bool isCancelled;
+        // slot 2
+        string callbackMethodName; // callback function of the requestor to call to provide response data
+        // slot 3
+        bytes requestData; 
+        // slot 4
+        bytes responseData; 
     }
 
 

package/contracts/oracle/Oracle.sol

@@ -69,30 +69,28 @@ abstract contract Oracle is
         override(IInstanceLinkedComponent, InstanceLinkedComponent)
         onlyOwner()
         restricted()
-        returns (Amount withdrawnAmount)
+        returns (Amount)
     {
         revert ErrorOracleNotImplemented("withdrawFees");
     }
 
 
-    function _initializeOracle(
+    function __Oracle_init(
         address registry,
         NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
         string memory name,
-        address token,
         bytes memory componentData // component specifidc data 
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeInstanceLinkedComponent(
+        __InstanceLinkedComponent_init(
             registry, 
             productNftId, 
             name, 
-            token, 
             ORACLE(), 
             authorization,
             true, 

package/contracts/oracle/OracleService.sol

@@ -32,11 +32,11 @@ contract OracleService is
         initializer()
     {
         (
-            address registryAddress,
-            address authority
+            address authority,
+            address registry
         ) = abi.decode(data, (address, address));
 
-        _initializeService(registryAddress, authority, owner);
+        __Service_init(authority, registry, owner);
         _registerInterface(type(IOracleService).interfaceId);
     }
 
@@ -48,15 +48,14 @@ contract OracleService is
     )
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
         onlyNftOfType(oracleNftId, ORACLE())
         returns (RequestId requestId) 
     {
-        // IRegistry registry = getRegistry();
-
+        // checks
         // get and check active caller
         (
-            IRegistry.ObjectInfo memory info, 
+            IRegistry.ObjectInfo memory requesterInfo, 
             address instance
         ) = ContractLib.getAndVerifyAnyComponent(
             getRegistry(), msg.sender, true);
@@ -65,8 +64,9 @@ contract OracleService is
             NftId requesterNftId,
             IOracleComponent oracle
         ) = _checkRequestParams(
-            getRegistry(), oracleNftId, info, expiryAt, callbackMethodName);
+            getRegistry(), oracleNftId, requesterInfo, expiryAt, callbackMethodName);
 
+        // effects
         {
             // create request info
             IOracle.RequestInfo memory request = IOracle.RequestInfo({
@@ -84,14 +84,15 @@ contract OracleService is
             requestId = IInstance(instance).getInstanceStore().createRequest(request);
         }
 
+        emit LogOracleServiceRequestCreated(requestId, requesterNftId, oracleNftId, expiryAt);
+
+        // interactions
         // callback to oracle component
         oracle.request(
             requestId, 
             requesterNftId, 
             requestData, 
             expiryAt);
-
-        emit LogOracleServiceRequestCreated(requestId, requesterNftId, oracleNftId, expiryAt);
     }
 
 
@@ -103,7 +104,7 @@ contract OracleService is
     )
         external
         virtual
-        // restricted() // add authz
+        restricted()
         returns (bool success)
     {
         (
@@ -117,7 +118,7 @@ contract OracleService is
         bool callerIsOracle = true;
         IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
         request.responseData = responseData;
-        request.respondedAt = TimestampLib.blockTimestamp();
+        request.respondedAt = TimestampLib.current();
 
         instance.getInstanceStore().updateRequest(
             requestId, request, KEEP_STATE());
@@ -152,7 +153,7 @@ contract OracleService is
     function resend(RequestId requestId)
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
     {
         (
             IRegistry.ObjectInfo memory info, 
@@ -191,7 +192,7 @@ contract OracleService is
     function cancel(RequestId requestId)
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
     {
         (
             IRegistry.ObjectInfo memory info, 
@@ -220,7 +221,7 @@ contract OracleService is
     function _checkRequestParams(
         IRegistry registry,
         NftId oracleNftId,
-        IRegistry.ObjectInfo memory info,
+        IRegistry.ObjectInfo memory requesterInfo,
         Timestamp expiryAt,
         string memory callbackMethodName
     )
@@ -237,23 +238,23 @@ contract OracleService is
             registry, oracleNftId, true);
 
         // obtain return values
-        requesterNftId = info.nftId;
+        requesterNftId = requesterInfo.nftId;
         oracle = IOracleComponent(oracleInfo.objectAddress);
 
         // check that requester and oracle share same product cluster
-        if (info.objectType == PRODUCT()) {
+        if (requesterInfo.objectType == PRODUCT()) {
             if (oracleInfo.parentNftId != requesterNftId) {
-                revert ErrorOracleServiceProductMismatch(info.objectType, requesterNftId, oracleInfo.parentNftId);
+                revert ErrorOracleServiceProductMismatch(requesterInfo.objectType, requesterNftId, oracleInfo.parentNftId);
             }
         } else {
-            if (oracleInfo.parentNftId != info.parentNftId) {
-                revert ErrorOracleServiceProductMismatch(info.objectType, info.parentNftId, oracleInfo.parentNftId);
+            if (oracleInfo.parentNftId != requesterInfo.parentNftId) {
+                revert ErrorOracleServiceProductMismatch(requesterInfo.objectType, requesterInfo.parentNftId, oracleInfo.parentNftId);
             }
         }
 
         // check expiriyAt >= now
-        if (expiryAt < TimestampLib.blockTimestamp()) {
-            revert ErrorOracleServiceExpiryInThePast(TimestampLib.blockTimestamp(), expiryAt);
+        if (expiryAt < TimestampLib.current()) {
+            revert ErrorOracleServiceExpiryInThePast(TimestampLib.current(), expiryAt);
         }
 
         // check callbackMethodName.length > 0
@@ -297,7 +298,7 @@ contract OracleService is
         }
 
         // check expiry
-        if (info.expiredAt < TimestampLib.blockTimestamp()) {
+        if (info.expiredAt < TimestampLib.current()) {
             revert ErrorOracleServiceRequestExpired(requestId, info.expiredAt);
         }
     }

package/contracts/oracle/OracleServiceManager.sol

@@ -17,7 +17,7 @@ contract OracleServiceManager is ProxyManager {
     ) 
     {
         OracleService svc = new OracleService{salt: salt}();
-        bytes memory data = abi.encode(registry, authority);
+        bytes memory data = abi.encode(authority, registry);
         IVersionable versionable = initialize(
             registry,
             address(svc), 

package/contracts/pool/BasicPool.sol

@@ -21,7 +21,6 @@ abstract contract BasicPool is
         address registry,
         NftId productNftId,
         string memory name,
-        address token,
         IComponents.PoolInfo memory poolInfo,
         IAuthorization authorization,
         address initialOwner
@@ -30,11 +29,10 @@ abstract contract BasicPool is
         virtual
         onlyInitializing()
     {
-        _initializePool(
+        __Pool_init(
             registry, 
             productNftId, 
             name, 
-            token, 
             poolInfo, 
             authorization,
             initialOwner, 
@@ -84,25 +82,14 @@ abstract contract BasicPool is
     }
 
 
-    function lockBundle(NftId bundleNftId)
+    function setBundleLocked(NftId bundleNftId, bool locked)
         public
         virtual
         restricted()
         onlyBundleOwner(bundleNftId)
         onlyNftOfType(bundleNftId, BUNDLE())
     {
-        _lockBundle(bundleNftId);
-    }
-
-
-    function unlockBundle(NftId bundleNftId)
-        public
-        virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
-        onlyNftOfType(bundleNftId, BUNDLE())
-    {
-        _unlockBundle(bundleNftId);
+        _setBundleLocked(bundleNftId, locked);
     }
 
 

package/contracts/pool/BasicPoolAuthorization.sol

@@ -1,14 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Authorization} from "../authorization/Authorization.sol";
-import {BasicPool} from "./BasicPool.sol"; 
 import {IAccess} from "../authorization/IAccess.sol";
 import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
-import {POOL} from "../type/ObjectType.sol";
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicPool} from "./BasicPool.sol"; 
+import {COMPONENT, POOL} from "../type/ObjectType.sol";
 import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
 import {RoleId} from "../type/RoleId.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 
 
 contract BasicPoolAuthorization
@@ -16,23 +18,36 @@ contract BasicPoolAuthorization
 {
 
      constructor(string memory poolName)
-          Authorization(poolName)
+          Authorization(
+               poolName, 
+               POOL(), 
+               3,
+               COMMIT_HASH,
+               true, 
+               true)
      {}
 
      function _setupServiceTargets()
           internal
           virtual override
      {
-          _addServiceTargetWithRole(POOL());
+          _authorizeServiceDomain(COMPONENT(), address(11));
+          _authorizeServiceDomain(POOL(), address(12));
      }
 
-     function _setupTargets()
-          internal
-          virtual override
-     {
-          _addComponentTargetWithRole(POOL()); // basic pool target
-     }
+     function _setupTokenHandlerAuthorizations() internal virtual override {
+          // authorize token handler functions for component service role
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForTarget(getTokenHandlerName(), getServiceRole(COMPONENT()));
+          _authorize(functions, TokenHandler.approve.selector, "approve");
+          _authorize(functions, TokenHandler.setWallet.selector, "setWallet");
+          _authorize(functions, TokenHandler.pushFeeToken.selector, "pushFeeToken");
 
+          // authorize token handler functions for pool service role
+          functions = _authorizeForTarget(getTokenHandlerName(), getServiceRole(POOL()));
+          _authorize(functions, TokenHandler.pullToken.selector, "pullToken");
+          _authorize(functions, TokenHandler.pushToken.selector, "pushToken");
+     }
 
      function _setupTargetAuthorizations()
           internal
@@ -41,12 +56,11 @@ contract BasicPoolAuthorization
           IAccess.FunctionInfo[] storage functions;
 
           // authorize public role (open access to any account, only allows to lock target)
-          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
           _authorize(functions, BasicPool.stake.selector, "stake");
           _authorize(functions, BasicPool.unstake.selector, "unstake");
           _authorize(functions, BasicPool.extend.selector, "extend");
-          _authorize(functions, BasicPool.lockBundle.selector, "lockBundle");
-          _authorize(functions, BasicPool.unlockBundle.selector, "unlockBundle");
+          _authorize(functions, BasicPool.setBundleLocked.selector, "setBundleLocked");
           _authorize(functions, BasicPool.closeBundle.selector, "closeBundle");
           _authorize(functions, BasicPool.setBundleFee.selector, "setBundleFee");
 
@@ -57,11 +71,10 @@ contract BasicPoolAuthorization
           _authorize(functions, BasicPool.extend.selector, "extend");
 
           _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
-
           _authorize(functions, BasicPool.withdrawBundleFees.selector, "withdrawBundleFees");
 
           // authorize pool service
-          functions = _authorizeForTarget(getTargetName(), getServiceRole(POOL()));
+          functions = _authorizeForTarget(getMainTargetName(), getServiceRole(POOL()));
           _authorize(functions, IPoolComponent.verifyApplication.selector, "verifyApplication");
      }
 }