@etherisc/gif-next 0.0.2-ee0f913-209 → 0.0.2-ee54ca6-863

package/contracts/instance/module/IPolicy.sol

@@ -11,7 +11,7 @@ import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IPolicy {
 
-    struct Premium {
+    struct PremiumInfo {
         // premium splitting per target wallet
         Amount productFeeAmount;
         Amount distributionFeeAndCommissionAmount;
@@ -19,26 +19,26 @@ interface IPolicy {
 
         // detailed positions
         // this is the net premium calculated by the product 
-        uint256 netPremiumAmount;
+        Amount 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;
+        Amount fullPremiumAmount;
+        // effective premium = fullPremium - discount 
+        Amount premiumAmount;
+        Amount productFeeFixAmount;
+        Amount poolFeeFixAmount;
+        Amount bundleFeeFixAmount;
+        Amount distributionFeeFixAmount;
+        Amount productFeeVarAmount;
+        Amount poolFeeVarAmount;
+        Amount bundleFeeVarAmount;
+        Amount distributionFeeVarAmount;
+        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;
         // 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
@@ -49,7 +49,6 @@ interface IPolicy {
         RiskId riskId;
         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;
@@ -69,8 +68,8 @@ interface IPolicy {
         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
+        bytes submissionData; // use case specific claim submission data, no changes after submitting the claim
+        bytes processData; // use case specific data that may include information supporting confirm or decline
         Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
     }
 
@@ -78,7 +77,8 @@ interface IPolicy {
     struct PayoutInfo {
         ClaimId claimId;
         Amount amount;
-        bytes data;
-        Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)
+        address beneficiary; // for address(0) beneficiary is policy nft owner
+        bytes data; // use case specific supporting data
+        Timestamp paidAt; // timestamp for actual payout
     }
 }

package/contracts/mock/Dip.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract Dip is ERC20 {
 

package/contracts/oracle/BasicOracle.sol

@@ -0,0 +1,48 @@
+// 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,
+        address token
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+
+        _initializeOracle(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name,
+            token,
+            "",
+            "");
+    }
+}

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -0,0 +1,46 @@
+// 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)
+          Authorization(componentName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          // basic component target
+          _addComponentTargetWithRole(ORACLE()); 
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), 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());
+          _authorize(functions, BasicOracle.respond.selector, "respond");
+     }
+}
+

package/contracts/oracle/IOracle.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {NftId} from "../type/NftId.sol";
+import {RequestId} from "../type/RequestId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
 
@@ -17,4 +18,19 @@ interface IOracle {
         Timestamp expiredAt; // expiry timestamp
         bool isCancelled;
     }
+
+
+    /// @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

@@ -11,7 +11,8 @@ 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,

package/contracts/oracle/Oracle.sol

@@ -1,18 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {Amount} from "../type/Amount.sol";
 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 {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IOracleComponent} from "./IOracleComponent.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {InstanceReader} from "../instance/InstanceReader.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, TimestampLib} from "../type/Timestamp.sol";
-import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
-import {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
 
 abstract contract Oracle is
@@ -28,38 +27,41 @@ abstract contract Oracle is
     }
 
 
-    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
+    function register()
+        external
         virtual
-        onlyInitializing()
+        onlyOwner()
     {
-        initializeInstanceLinkedComponent(registry, instanceNftId, name, token, ORACLE(), true, initialOwner, registryData, componentData);
+        _getOracleStorage()._componentService.registerOracle();
+    }
 
-        OracleStorage storage $ = _getOracleStorage();
-        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
-        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IOracleComponent).interfaceId);
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        external
+        virtual
+        restricted()
+    {
+        _request(requestId, requesterId, requestData, expiryAt);
     }
 
 
-    function register()
+    function cancel(
+        RequestId requestId
+    )
         external
         virtual
-        onlyOwner()
+        restricted()
     {
-        _getOracleStorage()._componentService.registerOracle();
+        _cancel(requestId);
     }
 
 
+    /// @dev Not relevant for oracle components, always returns false.
     function isVerifying()
         external 
         virtual 
@@ -69,36 +71,56 @@ abstract contract Oracle is
         return false;
     }
 
-
-    function request(
-        RequestId requestId,
-        NftId requesterId,
-        bytes calldata requestData,
-        Timestamp expiryAt
-    )
+    /// @dev Not relevant for oracle components
+    function withdrawFees(Amount amount)
         external
         virtual
-        // restricted() // TODO enable: only oracle service
+        override(IInstanceLinkedComponent, InstanceLinkedComponent)
+        onlyOwner()
+        restricted()
+        returns (Amount withdrawnAmount)
     {
-        _request(requestId, requesterId, requestData, expiryAt);
+        revert ErrorOracleNotImplemented("withdrawFees");
     }
 
 
-    function cancel(
-        RequestId requestId
+    function _initializeOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        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 
     )
-        external
+        internal
         virtual
-        // restricted() // TODO enable: only oracle service
+        onlyInitializing()
     {
-        _cancel(requestId);
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            ORACLE(), 
+            authorization,
+            true, 
+            initialOwner, 
+            registryData, 
+            componentData);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        _registerInterface(type(IOracleComponent).interfaceId);
     }
 
 
-    /// @dev internal function for handling requests.
-    /// empty implementation.
-    /// overwrite this function to implement use case specific handling
-    /// for oracle calls.
+    /// @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,
@@ -111,9 +133,9 @@ abstract contract Oracle is
     }
 
 
-    /// @dev internal function for cancelling requests.
-    /// empty implementation.
-    /// overwrite this function to implement use case specific cancelling
+    /// @dev Internal function for cancelling requests.
+    /// Empty implementation.
+    /// Overwrite this function to implement use case specific cancelling.
     function _cancel(
         RequestId requestId
     )
@@ -123,9 +145,9 @@ abstract contract Oracle is
     }
 
 
-    /// @dev internal function for handling oracle responses.
-    /// use this function in use case specific external/public functions
-    /// to handle use case specific response handling.
+    /// @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

package/contracts/oracle/OracleService.sol

@@ -27,14 +27,14 @@ contract OracleService is
         bytes memory data
     )
         internal
-        initializer
         virtual override
+        initializer()
     {
         address initialOwner;
         address registryAddress;
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
-        initializeService(registryAddress, address(0), owner);
-        registerInterface(type(IOracleService).interfaceId);
+        _initializeService(registryAddress, address(0), owner);
+        _registerInterface(type(IOracleService).interfaceId);
     }
 
     function request(
@@ -64,6 +64,7 @@ contract OracleService is
             ORACLE(), 
             true); // only active
 
+        // TODO move to stronger validation, requester and oracle need to belong to same product cluster
         // check that requester and oracle share same instance
         if (componentInfo.parentNftId != oracleInfo.parentNftId) {
             revert ErrorOracleServiceInstanceMismatch(componentInfo.parentNftId, oracleInfo.parentNftId);

package/contracts/oracle/OracleServiceManager.sol

@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/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 {
 

package/contracts/pool/BasicPool.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IBundleService} from "./IBundleService.sol";
+import {IPoolComponent} from "./IPoolComponent.sol";
+import {IPoolService} from "./IPoolService.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+import {Pool} from "./Pool.sol";
+
+abstract contract BasicPool is
+    Pool
+{
+
+    function _initializeBasicPool(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address token,
+        string memory name,
+        address initialOwner
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializePool(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            authorization,
+            false, // isInterceptingNftTransfers, 
+            initialOwner, 
+            "", // registryData
+            ""); // componentData
+    }
+
+    function stake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _stake(bundleNftId, amount);
+    }
+
+
+    function unstake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _unstake(bundleNftId, amount);
+    }
+
+
+    function extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+        returns(Timestamp newExpiredAt)
+    {
+        return _extend(bundleNftId, lifetimeExtension);
+    }
+
+
+    function lockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _lockBundle(bundleNftId);
+    }
+
+
+    function unlockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _unlockBundle(bundleNftId);
+    }
+
+
+    function closeBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _closeBundle(bundleNftId);
+    }
+
+
+    function setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _setBundleFee(bundleNftId, fee);
+    }
+
+
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setMaxBalanceAmount(maxBalanceAmount);
+    }
+
+
+    function setBundleOwnerRole(RoleId bundleOwnerRole)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setBundleOwnerRole(bundleOwnerRole);
+    }
+
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _setPoolFees(poolFee, stakingFee, performanceFee);
+    }
+}

package/contracts/pool/BasicPoolAuthorization.sol

@@ -0,0 +1,58 @@
+// 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 {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicPoolAuthorization
+     is Authorization
+{
+
+     constructor(string memory poolName)
+          Authorization(poolName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          _addComponentTargetWithRole(POOL()); // basic pool target
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), 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.closeBundle.selector, "closeBundle");
+          _authorize(functions, BasicPool.setBundleFee.selector, "setBundleFee");
+
+          _authorize(functions, BasicPool.setMaxBalanceAmount.selector, "setMaxBalanceAmount");
+          _authorize(functions, BasicPool.setBundleOwnerRole.selector, "setBundleOwnerRole");
+          _authorize(functions, BasicPool.setFees.selector, "setFees");
+          _authorize(functions, BasicPool.stake.selector, "stake");
+          _authorize(functions, BasicPool.unstake.selector, "unstake");
+          _authorize(functions, BasicPool.extend.selector, "extend");
+
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
+
+          _authorize(functions, IPoolComponent.withdrawBundleFees.selector, "withdrawBundleFees");
+     }
+}
+