@etherisc/gif-next 0.0.2-f634e5c-828 → 0.0.2-f689687-279

package/contracts/instance/module/IRisk.sol

@@ -2,11 +2,13 @@
 pragma solidity ^0.8.20;
 
 import {NftId} from "../../type/NftId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IRisk {
 
     struct RiskInfo {
         NftId productNftId;
+        Timestamp createdAt;
         bytes data;
     }
 }

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -15,18 +15,9 @@ contract BasicOracleAuthorization
 {
 
      constructor(string memory componentName)
-          Authorization(componentName)
+          Authorization(componentName, ORACLE())
      {}
 
-     function _setupTargets()
-          internal
-          virtual override
-     {
-          // basic component target
-          _addComponentTargetWithRole(ORACLE()); 
-     }
-
-
      function _setupTargetAuthorizations()
           internal
           virtual override
@@ -34,12 +25,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/Oracle.sol

@@ -69,7 +69,7 @@ abstract contract Oracle is
         override(IInstanceLinkedComponent, InstanceLinkedComponent)
         onlyOwner()
         restricted()
-        returns (Amount withdrawnAmount)
+        returns (Amount)
     {
         revert ErrorOracleNotImplemented("withdrawFees");
     }

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);
     }
 
@@ -52,11 +52,10 @@ contract OracleService is
         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);
     }
 
 
@@ -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,17 +238,17 @@ 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);
             }
         }
 

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/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,30 @@ contract BasicPoolAuthorization
 {
 
      constructor(string memory poolName)
-          Authorization(poolName)
+          Authorization(poolName, POOL())
      {}
 
      function _setupServiceTargets()
           internal
           virtual override
      {
+          _addServiceTargetWithRole(COMPONENT());
           _addServiceTargetWithRole(POOL());
      }
 
-     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,7 +50,7 @@ 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");
@@ -57,11 +66,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");
      }
 }

package/contracts/pool/BundleService.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccountingService} from "../accounting/IAccountingService.sol";
 import {IBundle} from "../instance/module/IBundle.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
@@ -9,7 +10,6 @@ import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
-import {IPolicy} from "../instance/module/IPolicy.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {BundleSet} from "../instance/BundleSet.sol";
@@ -17,7 +17,7 @@ import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol
 import {Fee} from "../type/Fee.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, POOL, BUNDLE, POLICY, REGISTRY} from "../type/ObjectType.sol";
+import {ObjectType, ACCOUNTING, COMPONENT, POOL, BUNDLE, POLICY, REGISTRY} from "../type/ObjectType.sol";
 import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
@@ -33,6 +33,7 @@ contract BundleService is
 
     address private _registryAddress;
     IRegistryService private _registryService;
+    IAccountingService private _accountingService;
     IComponentService private _componentService;
 
     function _initialize(
@@ -44,13 +45,14 @@ contract BundleService is
         initializer()
     {
         (
-            address registryAddress,
-            address authority
+            address authority,
+            address registry
         ) = abi.decode(data, (address, address));
 
-        _initializeService(registryAddress, authority, owner);
+        __Service_init(authority, registry, owner);
 
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
         _registerInterface(type(IBundleService).interfaceId);
@@ -142,6 +144,7 @@ contract BundleService is
         virtual
         restricted()
     {
+        // checks
         _checkNftType(policyNftId, POLICY());
         _checkNftType(bundleNftId, BUNDLE());
 
@@ -173,6 +176,7 @@ contract BundleService is
             }
         }
 
+        // effects
         // updated locked amount
         instanceStore.increaseLocked(bundleNftId, collateralAmount);
     }
@@ -183,6 +187,7 @@ contract BundleService is
         virtual
         restricted()
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
         (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
@@ -190,6 +195,7 @@ contract BundleService is
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, PAUSED());
 
+        // effects
         // update set of active bundles
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.lock(bundleNftId);
@@ -203,10 +209,12 @@ contract BundleService is
         virtual
         restricted()
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
         (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
+        // effects
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, ACTIVE());
 
@@ -227,6 +235,7 @@ contract BundleService is
         restricted()
         returns (Amount unstakedAmount, Amount feeAmount)
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
         InstanceReader instanceReader = instance.getInstanceReader();
@@ -238,6 +247,7 @@ contract BundleService is
             revert ErrorBundleServiceBundleWithOpenPolicies(bundleNftId, openPolicies);
         }
 
+        // effects
         {
             // update bundle state
             InstanceStore instanceStore = instance.getInstanceStore();
@@ -248,13 +258,14 @@ contract BundleService is
             Amount balanceAmountWithFees = instanceReader.getBalanceAmount(bundleNftId);
             feeAmount = instanceReader.getFeeAmount(bundleNftId);
             unstakedAmount = balanceAmountWithFees - feeAmount;
-            _componentService.decreaseBundleBalance(instanceStore, bundleNftId, unstakedAmount, feeAmount);
+            _accountingService.decreaseBundleBalance(instanceStore, bundleNftId, unstakedAmount, feeAmount);
         }
     }
 
     /// @inheritdoc IBundleService
     function stake(
-        IInstance instance,
+        InstanceReader instanceReader,
+        InstanceStore instanceStore,
         NftId bundleNftId, 
         Amount amount
     ) 
@@ -262,10 +273,11 @@ contract BundleService is
         virtual
         restricted()
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
-        IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
-        StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        StateId bundleState = instanceReader.getBundleState(bundleNftId);
 
         if( (bundleState != ACTIVE() && bundleState != PAUSED()) // locked bundles can be staked
             || bundleInfo.expiredAt < TimestampLib.blockTimestamp() 
@@ -273,8 +285,9 @@ contract BundleService is
             revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
         }
 
-        _componentService.increaseBundleBalance(
-            instance.getInstanceStore(), 
+        // effects
+        _accountingService.increaseBundleBalance(
+            instanceStore, 
             bundleNftId, 
             amount, 
             AmountLib.zero());
@@ -282,7 +295,7 @@ contract BundleService is
 
     /// @inheritdoc IBundleService
     function unstake(
-        IInstance instance, 
+        InstanceStore instanceStore,
         NftId bundleNftId, 
         Amount amount
     ) 
@@ -291,9 +304,9 @@ contract BundleService is
         restricted()
         returns (Amount unstakedAmount)
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
-        InstanceStore instanceStore = instance.getInstanceStore();
         (
             Amount balanceAmount,
             Amount lockedAmount,
@@ -313,7 +326,8 @@ contract BundleService is
             revert ErrorBundleServiceUnstakeAmountExceedsLimit(amount, availableAmount);
         }
 
-        _componentService.decreaseBundleBalance(
+        // effects
+        _accountingService.decreaseBundleBalance(
             instanceStore, 
             bundleNftId, 
             unstakedAmount, 
@@ -327,6 +341,7 @@ contract BundleService is
         restricted()
         returns (Timestamp extendedExpiredAt) 
     {
+        // checks
         _checkNftType(bundleNftId, BUNDLE());
 
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
@@ -347,17 +362,18 @@ contract BundleService is
             revert ErrorBundleServiceExtensionLifetimeIsZero();
         }
 
+        // effects
         bundleInfo.expiredAt = bundleInfo.expiredAt.addSeconds(lifetimeExtension);
-        instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
+        extendedExpiredAt = bundleInfo.expiredAt;
 
-        emit LogBundleServiceBundleExtended(bundleNftId, lifetimeExtension, bundleInfo.expiredAt);
+        instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
 
-        return bundleInfo.expiredAt;
+        emit LogBundleServiceBundleExtended(bundleNftId, lifetimeExtension, extendedExpiredAt);
     }
 
 
     function releaseCollateral(
-        IInstance instance,
+        InstanceStore instanceStore,
         NftId policyNftId, 
         NftId bundleNftId, 
         Amount collateralAmount
@@ -369,54 +385,10 @@ contract BundleService is
         _checkNftType(policyNftId, POLICY());
         _checkNftType(bundleNftId, BUNDLE());
 
-        instance.getInstanceStore().decreaseLocked(bundleNftId, collateralAmount);
+        instanceStore.decreaseLocked(bundleNftId, collateralAmount);
     }
 
 
-    /// @inheritdoc IBundleService
-    function withdrawBundleFees(NftId bundleNftId, Amount amount) 
-        public 
-        virtual
-        restricted()
-        returns (Amount withdrawnAmount) 
-    {
-        _checkNftType(bundleNftId, BUNDLE());
-
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader reader = instance.getInstanceReader();
-        
-        IComponents.ComponentInfo memory poolInfo = reader.getComponentInfo(poolNftId);
-        address poolWallet = poolInfo.tokenHandler.getWallet();
-        
-        // IBundle.BundleInfo memory bundleInfo = reader.getBundleInfo(bundleNftId);
-        
-        // determine withdrawn amount
-        withdrawnAmount = amount;
-        if (withdrawnAmount.gte(AmountLib.max())) {
-            withdrawnAmount = reader.getFeeAmount(bundleNftId);
-        } else {
-            if (withdrawnAmount.gt(reader.getFeeAmount(bundleNftId))) {
-                revert ErrorBundleServiceFeesWithdrawAmountExceedsLimit(withdrawnAmount, reader.getFeeAmount(bundleNftId));
-            }
-        }
-
-        // decrease fee counters by withdrawnAmount
-        {
-            InstanceStore store = instance.getInstanceStore();
-            // decrease fee amount of the bundle
-            _componentService.decreaseBundleBalance(store, bundleNftId, AmountLib.zero(), withdrawnAmount);
-            // decrease pool balance 
-            _componentService.decreasePoolBalance(store, poolNftId, withdrawnAmount, AmountLib.zero());
-        }
-
-        // transfer amount to bundle owner
-        {
-            address owner = getRegistry().ownerOf(bundleNftId);
-            emit LogBundleServiceFeesWithdrawn(bundleNftId, owner, address(poolInfo.token), withdrawnAmount);
-            poolInfo.tokenHandler.distributeTokens(poolWallet, owner, withdrawnAmount);
-        }
-    }
-
     function _getDomain() internal pure override returns(ObjectType) {
         return BUNDLE();
     }

package/contracts/pool/BundleServiceManager.sol

@@ -17,7 +17,7 @@ contract BundleServiceManager is ProxyManager {
     ) 
     {
         BundleService svc = new BundleService{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/IBundleService.sol

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IService} from "../shared/IService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+
 import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
 import {Fee} from "../type/Fee.sol";
-import {IService} from "../shared/IService.sol";
-import {IBundle} from "../instance/module/IBundle.sol";
-import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StateId} from "../type/StateId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
@@ -26,14 +28,11 @@ interface IBundleService is IService {
     error ErrorBundleServiceBundlePoolMismatch(NftId bundleNftId, NftId expectedPool, NftId actualPool);
 
     error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
-
-    error ErrorBundleServiceFeesWithdrawAmountExceedsLimit(Amount amount, Amount limit);
     
     error ErrorBundleServiceUnstakeAmountExceedsLimit(Amount amount, Amount limit);
 
     error ErrorBundleServiceExtensionLifetimeIsZero();
 
-    event LogBundleServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
     event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
 
     /// @dev Create a new bundle for the specified attributes.
@@ -49,15 +48,16 @@ interface IBundleService is IService {
 
     /// @dev increase bundle stakes by the specified amount. bundle must not be expired or closed
     /// may only be called by the pool service
-    function stake(IInstance instance, NftId bundleNftId, Amount amount) external;
+    function stake(
+        InstanceReader instanceReader,
+        InstanceStore instanceStore,
+        NftId bundleNftId, 
+        Amount amount
+    ) external;
 
     /// @dev decrease bundle stakes by the specified amount
     /// may only be called by the pool service
-    /// @param instance the instance relevant for the bundle
-    /// @param bundleNftId the bundle nft id
-    /// @param amount the amount to unstake (set to AmountLib.max() to unstake all available stakes)
-    /// @return unstakedAmount the effective unstaked amount
-    function unstake(IInstance instance, NftId bundleNftId, Amount amount) external returns (Amount unstakedAmount);
+    function unstake(InstanceStore instanceStore, NftId bundleNftId, Amount amount) external returns (Amount unstakedAmount);
 
     /// @dev extend the lifetime of the bundle by the specified time in seconds
     function extend(NftId bundleNftId, Seconds lifetimeExtension) external returns (Timestamp extendedExpiredAt);
@@ -107,16 +107,9 @@ interface IBundleService is IService {
     /// @dev releases the specified collateral in the bundle
     /// may only be called by pool service
     function releaseCollateral(
-        IInstance instance, 
+        InstanceStore instanceStore, 
         NftId policyNftId, 
         NftId bundleNftId, 
         Amount collateralAmount
     ) external;
-
-    // FIXME: move to pool service
-    /// @dev Withdraw bundle feeds for the given bundle
-    /// @param bundleNftId the bundle Nft Id
-    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
-    /// @return withdrawnAmount the effective withdrawn amount
-    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
 }