@etherisc/gif-next 3.0.0-c458de2-735 → 3.0.0-c517f31-287

package/contracts/pool/BundleService.sol

@@ -12,11 +12,11 @@ import {InstanceStore} from "../instance/InstanceStore.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {BundleSet} from "../instance/BundleSet.sol";
-import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee} from "../type/Fee.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {ObjectType, ACCOUNTING, COMPONENT, POOL, BUNDLE, POLICY, REGISTRY} from "../type/ObjectType.sol";
+import {PoolLib} from "./PoolLib.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Service} from "../shared/Service.sol";
 import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
@@ -41,13 +41,14 @@ contract BundleService is
     )
         internal
         virtual override
-        onlyInitializing()
+        initializer()
     {
         (
-            address authority
-        ) = abi.decode(data, (address));
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
-        __Service_init(authority, owner);
+        __Service_init(authority, registry, owner);
 
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
@@ -65,12 +66,9 @@ contract BundleService is
         virtual
         restricted()
     {
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
+        _checkNftType(bundleNftId, BUNDLE());
 
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
         if(bundleInfo.poolNftId.eqz()) {
@@ -99,10 +97,7 @@ contract BundleService is
         restricted()
         returns(NftId bundleNftId)
     {
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPool(getRelease());
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
 
         // register bundle with registry
         bundleNftId = _registryService.registerBundle(
@@ -110,11 +105,11 @@ contract BundleService is
                 NftIdLib.zero(), 
                 poolNftId,
                 BUNDLE(),
-                getRelease(),
                 false, // intercepting property for bundles is defined on pool
-                address(0)),
-            owner,
-            "" // bundle data to be stored in registry
+                address(0),
+                owner,
+                "" // bundle data to be stored in registry
+            )
         );
 
         // create bundle info in instance
@@ -135,7 +130,7 @@ contract BundleService is
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.add(bundleNftId);
 
-        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId, lifetime);
+        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId, lifetime, bundleFee.fixedFee, bundleFee.fractionalFee);
     }
 
 
@@ -196,8 +191,9 @@ contract BundleService is
         restricted()
     {
         // checks
-        (, IInstance instance) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
 
         // effects
         // update set of active bundles
@@ -335,12 +331,9 @@ contract BundleService is
         returns (Timestamp extendedExpiredAt) 
     {
         // checks
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
+        _checkNftType(bundleNftId, BUNDLE());
 
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
         StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
 
@@ -386,6 +379,7 @@ contract BundleService is
         emit LogBundleServiceCollateralReleased(bundleNftId, policyNftId, collateralAmount);
     }
 
+
     function _getDomain() internal pure override returns(ObjectType) {
         return BUNDLE();
     }

package/contracts/pool/BundleServiceManager.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IUpgradeable} from "../upgradeability/IUpgradeable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
 import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {BundleService} from "./BundleService.sol";
 
@@ -11,18 +11,20 @@ contract BundleServiceManager is ProxyManager {
 
     /// @dev initializes proxy manager with pool service implementation 
     constructor(
-        address authority,
+        address authority, 
+        address registry,
         bytes32 salt
     ) 
     {
         BundleService svc = new BundleService{salt: salt}();
-        bytes memory data = abi.encode(authority);
-        IUpgradeable upgradeable = initialize(
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
             data,
             salt);
 
-        _bundleService = BundleService(address(upgradeable));
+        _bundleService = BundleService(address(versionable));
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/pool/IBundleService.sol

@@ -30,16 +30,16 @@ interface IBundleService is IService {
 
     error ErrorBundleServiceExtensionLifetimeIsZero();
 
-    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId, Seconds lifetime);
-    event LogBundleServiceBundleClosed(NftId bundleNftId);
-    event LogBundleServiceBundleLocked(NftId bundleNftId);
-    event LogBundleServiceBundleUnlocked(NftId bundleNftId);
-    event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
-    event LogBundleServiceBundleFeeUpdated(NftId bundleNftId, Amount fixedFee, UFixed fractionalFee);
-    event LogBundleServiceCollateralLocked(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
-    event LogBundleServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
-    event LogBundleServiceBundleStaked(NftId bundleNftId, Amount amount);
-    event LogBundleServiceBundleUnstaked(NftId bundleNftId, Amount amount);
+    event LogBundleServiceBundleCreated(NftId indexed bundleNftId, NftId indexed poolNftId, Seconds indexed lifetime, Amount fixedFee, UFixed fractionalFee);
+    event LogBundleServiceBundleClosed(NftId indexed bundleNftId);
+    event LogBundleServiceBundleLocked(NftId indexed bundleNftId);
+    event LogBundleServiceBundleUnlocked(NftId indexed bundleNftId);
+    event LogBundleServiceBundleExtended(NftId indexed bundleNftId, Seconds indexed lifetimeExtension, Timestamp indexed extendedExpiredAt);
+    event LogBundleServiceBundleFeeUpdated(NftId indexed bundleNftId, Amount indexed fixedFee, UFixed indexed fractionalFee);
+    event LogBundleServiceCollateralLocked(NftId indexed bundleNftId, NftId indexed policyNftId, Amount indexed collateralAmount);
+    event LogBundleServiceCollateralReleased(NftId indexed bundleNftId, NftId indexed policyNftId, Amount indexed collateralAmount);
+    event LogBundleServiceBundleStaked(NftId indexed bundleNftId, Amount indexed amount);
+    event LogBundleServiceBundleUnstaked(NftId indexed bundleNftId, Amount indexed amount);
 
     /// @dev Create a new bundle for the specified attributes.
     function create(

package/contracts/pool/IPoolComponent.sol

@@ -19,7 +19,7 @@ interface IPoolComponent is IInstanceLinkedComponent {
     error ErrorPoolNotPoolService(address caller);
     error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
-    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, Amount collateralizationAmount);
+    event LogPoolVerifiedByPool(address indexed pool, NftId indexed applicationNftId, Amount indexed collateralizationAmount);
 
     /// @dev This is a callback function that is called by the product service when underwriting a policy.
     /// The pool has the option to check the details and object to underwriting by reverting.

package/contracts/pool/IPoolService.sol

@@ -14,24 +14,25 @@ import {PayoutId} from "../type/PayoutId.sol";
 
 interface IPoolService is IService {
 
-    event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
-    event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);
-    event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
+    event LogPoolServiceMaxBalanceAmountUpdated(NftId indexed poolNftId, Amount indexed previousMaxCapitalAmount, Amount indexed currentMaxCapitalAmount);
+    event LogPoolServiceWalletFunded(NftId indexed poolNftId, address indexed poolOwner, Amount indexed amount);
+    event LogPoolServiceWalletDefunded(NftId indexed poolNftId, address indexed poolOwner, Amount indexed amount);
 
-    event LogPoolServiceBundleClosed(NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleCreated(NftId indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId);
+    event LogPoolServiceBundleClosed(NftId indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId, Amount balanceAmount, Amount feeAmount);
 
-    event LogPoolServiceBundleStaked(NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
-    event LogPoolServiceBundleUnstaked(NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleStaked(NftId indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleUnstaked(NftId indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId, Amount amount, Amount netAmount);
 
-    event LogPoolServiceFeesWithdrawn(NftId poolNftId, NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
+    event LogPoolServiceFeesWithdrawn(NftId indexed bundleNftId, address indexed recipient, Amount indexed amount, address tokenAddress);
 
-    event LogPoolServiceProcessFundedClaim(NftId poolNftId, NftId policyNftId, ClaimId claimId, Amount availableAmount);
+    event LogPoolServiceProcessFundedClaim(NftId indexed policyNftId, ClaimId indexed claimId, Amount indexed availableAmount);
 
-    event LogPoolServiceApplicationVerified(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount);
-    event LogPoolServiceCollateralLocked(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount, Amount lockedCollateralAmount);
-    event LogPoolServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount remainingCollateralAmount);
-    event LogPoolServiceSaleProcessed(NftId poolNftId, NftId bundleNftId, Amount bundleNetAmount, Amount bundleFeeAmount, Amount poolFeeAmount);
-    event LogPoolServicePayoutProcessed(NftId poolNftId, NftId bundleNftId, NftId policyNftId, PayoutId payoutId, Amount netPayoutAmount, Amount processingFeeAmount, address payoutBeneficiary);
+    event LogPoolServiceApplicationVerified(NftId indexed poolNftId, NftId indexed bundleNftId, NftId indexed applicationNftId, Amount totalCollateralAmount);
+    event LogPoolServiceCollateralLocked(NftId indexed poolNftId, NftId indexed bundleNftId, NftId indexed applicationNftId, Amount totalCollateralAmount, Amount lockedCollateralAmount);
+    event LogPoolServiceCollateralReleased(NftId indexed bundleNftId, NftId indexed policyNftId, Amount indexed releasedCollateralAmount);
+    event LogPoolServiceSaleProcessed(NftId indexed poolNftId, NftId indexed bundleNftId, Amount indexed bundleNetAmount, Amount bundleFeeAmount, Amount poolFeeAmount);
+    event LogPoolServicePayoutProcessed(NftId indexed poolNftId, NftId indexed bundleNftId, NftId indexed policyNftId, PayoutId payoutId, Amount netPayoutAmount, Amount processingFeeAmount, address payoutBeneficiary);
 
     error ErrorPoolServicePoolNotExternallyManaged(NftId poolNftId);
     error ErrorPoolServicePolicyPoolMismatch(NftId policyNftId, NftId productNftId, NftId expectedProductNftId);

package/contracts/pool/Pool.sol

@@ -35,7 +35,7 @@ abstract contract Pool is
 
 
     modifier onlyBundleOwner(NftId bundleNftId) {
-        if(msg.sender != _getRegistry().ownerOf(bundleNftId)) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
             revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
         }
         _;
@@ -124,6 +124,7 @@ abstract contract Pool is
     // Internals
 
     function __Pool_init(
+        address registry,
         NftId productNftId,
         string memory name,
         IComponents.PoolInfo memory poolInfo,
@@ -135,6 +136,7 @@ abstract contract Pool is
         onlyInitializing()
     {
         __InstanceLinkedComponent_init(
+            registry, 
             productNftId,  
             name, 
             POOL(), 

package/contracts/pool/PoolLib.sol

@@ -18,7 +18,6 @@ import {ObjectType, BUNDLE, POOL} from "../type/ObjectType.sol";
 import {PayoutId} from "../type/PayoutId.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {VersionPart} from "../type/Version.sol";
 
 library PoolLib {
 
@@ -77,6 +76,7 @@ library PoolLib {
 
 
     function calculateStakingAmounts(
+        IRegistry registry,
         InstanceReader instanceReader,
         NftId poolNftId,
         Amount stakingAmount
@@ -88,7 +88,7 @@ library PoolLib {
             Amount netStakingAmount
         )
     {
-        NftId productNftId = ContractLib.getRegistry().getParentNftId(poolNftId);
+        NftId productNftId = registry.getParentNftId(poolNftId);
         Fee memory stakingFee = instanceReader.getFeeInfo(productNftId).stakingFee;
         (
             feeAmount,
@@ -100,6 +100,7 @@ library PoolLib {
 
 
     function calculatePayoutAmounts(
+        IRegistry registry,
         InstanceReader instanceReader,
         NftId productNftId,
         NftId policyNftId,
@@ -120,7 +121,7 @@ library PoolLib {
             netPayoutAmount = payoutAmount;
 
             if (payoutBeneficiary == address(0)) {
-                beneficiary = ContractLib.getRegistry().ownerOf(policyNftId);
+                beneficiary = registry.ownerOf(policyNftId);
             } else { 
                 beneficiary = payoutBeneficiary;
             }
@@ -135,13 +136,14 @@ library PoolLib {
 
 
     function getPolicyHolder(
+        IRegistry registry, 
         NftId policyNftId
     )
         internal 
         view 
         returns (IPolicyHolder policyHolder)
     {
-        address policyHolderAddress = ContractLib.getRegistry().ownerOf(policyNftId);
+        address policyHolderAddress = registry.ownerOf(policyNftId);
         policyHolder = IPolicyHolder(policyHolderAddress);
 
         if (!ContractLib.isPolicyHolder(policyHolderAddress)) {
@@ -149,7 +151,99 @@ library PoolLib {
         }
     }
 
+
+    function checkAndGetPoolInfo(
+        IRegistry registry,
+        address sender,
+        NftId bundleNftId
+    )
+        public
+        view
+        returns (
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+            IComponents.PoolInfo memory poolInfo
+        )
+    {
+        checkNftType(registry, bundleNftId, BUNDLE());
+
+        IInstance instance;
+        (poolNftId, instance) = getAndVerifyActivePool(registry, sender);
+        instanceReader = instance.getInstanceReader();
+        instanceStore = instance.getInstanceStore();
+        instanceNftId = instance.getNftId();
+        poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        if (registry.getParentNftId(bundleNftId) != poolNftId) {
+            revert IPoolService.ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+    }
+
+
+    function getAndVerifyActivePool(
+        IRegistry registry,
+        address sender
+    )
+        public
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            registry, 
+            sender,
+            POOL(),
+            true); // only active pools
+
+        poolNftId = info.nftId;
+        instance = IInstance(instanceAddress);
+    }
+
+
+    function getAndVerifyActiveComponent(
+        IRegistry registry,
+        address sender,
+        ObjectType expectedComponentType
+    )
+        public
+        view
+        returns (
+            NftId componentNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            registry, 
+            sender,
+            expectedComponentType,
+            true); // only active components
+
+        componentNftId = info.nftId;
+        instance = IInstance(instanceAddress);
+    }
+
+    function checkNftType(
+        IRegistry registry, 
+        NftId nftId, 
+        ObjectType expectedObjectType
+    ) internal view {
+        if(!registry.isObjectType(nftId, expectedObjectType)) {
+            revert INftOwnable.ErrorNftOwnableInvalidType(nftId, expectedObjectType);
+        }
+    }
+
     function transferTokenAndNotifyPolicyHolder(
+        IRegistry registry,
         InstanceReader instanceReader,
         TokenHandler poolTokenHandler,
         NftId productNftId,
@@ -171,6 +265,7 @@ library PoolLib {
             processingFeeAmount,
             beneficiary
         ) = calculatePayoutAmounts(
+            registry,
             instanceReader,
             productNftId, 
             policyNftId,
@@ -192,6 +287,7 @@ library PoolLib {
 
         // callback to policy holder if applicable
         policyHolderPayoutExecuted(
+            registry,
             policyNftId, 
             payoutId, 
             beneficiary, 
@@ -199,6 +295,7 @@ library PoolLib {
     }
 
     function policyHolderPayoutExecuted(
+        IRegistry registry,
         NftId policyNftId, 
         PayoutId payoutId,
         address beneficiary,
@@ -206,7 +303,7 @@ library PoolLib {
     )
         private
     {
-        IPolicyHolder policyHolder = getPolicyHolder(policyNftId);
+        IPolicyHolder policyHolder = getPolicyHolder(registry, policyNftId);
         if(address(policyHolder) != address(0)) {
             policyHolder.payoutExecuted(policyNftId, payoutId, payoutAmount, beneficiary);
         }