@etherisc/gif-next 0.0.2-de7c770-422 → 0.0.2-de9ede4-391

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.20;
 
 import {
-     ALL, REGISTRY, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
+     ALL, ACCOUNTING, REGISTRY, RISK, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
 } from "../../contracts/type/ObjectType.sol";
 
 import {IAccess} from "../authorization/IAccess.sol";
+import {IAccountingService} from "../accounting/IAccountingService.sol";
 import {IBundleService} from "../pool/IBundleService.sol";
 import {IDistributionService} from "../distribution/IDistributionService.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPoolService} from "../pool/IPoolService.sol";
 import {IStakingService} from "../staking/IStakingService.sol";
 import {IRegistryService} from "./IRegistryService.sol";
@@ -20,7 +20,7 @@ contract ServiceAuthorizationV3
 {
 
      constructor(string memory commitHash)
-          ServiceAuthorization(commitHash)
+          ServiceAuthorization(commitHash, 3)
      {}
 
      function _setupDomains()
@@ -30,16 +30,17 @@ contract ServiceAuthorizationV3
           _authorizeDomain(REGISTRY(), address(1));
           _authorizeDomain(STAKING(), address(2));
           _authorizeDomain(INSTANCE(), address(3));
-          _authorizeDomain(COMPONENT(), address(4));
-          _authorizeDomain(DISTRIBUTION(), address(5));
-          _authorizeDomain(PRICE(), address(6));
-          _authorizeDomain(BUNDLE(), address(7));
-          _authorizeDomain(POOL(), address(8));
-          _authorizeDomain(ORACLE(), address(9));
-          _authorizeDomain(PRODUCT(), address(10));
-          _authorizeDomain(CLAIM(), address(11));
-          _authorizeDomain(APPLICATION(), address(12));
-          _authorizeDomain(POLICY(), address(13));
+          _authorizeDomain(ACCOUNTING(), address(4));
+          _authorizeDomain(COMPONENT(), address(5));
+          _authorizeDomain(DISTRIBUTION(), address(6));
+          _authorizeDomain(PRICE(), address(7));
+          _authorizeDomain(BUNDLE(), address(8));
+          _authorizeDomain(POOL(), address(9));
+          _authorizeDomain(ORACLE(), address(10));
+          _authorizeDomain(RISK(), address(11));
+          _authorizeDomain(POLICY(), address(12));
+          _authorizeDomain(CLAIM(), address(13));
+          _authorizeDomain(APPLICATION(), address(14));
      }
 
 
@@ -50,6 +51,7 @@ contract ServiceAuthorizationV3
           _setupIRegistryServiceAuthorization();
           _setupStakingServiceAuthorization();
           _setupInstanceServiceAuthorization();
+          _setupAccountingServiceAuthorization();
           _setupComponentServiceAuthorization();
           _setupDistributionServiceAuthorization();
           _setupPoolServiceAuthorization();
@@ -67,27 +69,21 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(REGISTRY(), APPLICATION());
           _authorize(functions, IRegistryService.registerPolicy.selector, "registerPolicy");
 
-          // functions = _authorizeForService(REGISTRY(), POOL());
-          // _authorize(functions, IRegistryService.registerPool.selector, "registerPool");
-
           functions = _authorizeForService(REGISTRY(), BUNDLE());
           _authorize(functions, IRegistryService.registerBundle.selector, "registerBundle");
 
+          functions = _authorizeForService(REGISTRY(), COMPONENT());
+          _authorize(functions, IRegistryService.registerProduct.selector, "registerProduct");
+          _authorize(functions, IRegistryService.registerProductLinkedComponent.selector, "registerProductLinkedComponent");
+
           functions = _authorizeForService(REGISTRY(), DISTRIBUTION());
-          // _authorize(functions, IRegistryService.registerDistribution.selector, "registerDistribution");
           _authorize(functions, IRegistryService.registerDistributor.selector, "registerDistributor");
 
-          functions = _authorizeForService(REGISTRY(), COMPONENT());
-          _authorize(functions, IRegistryService.registerComponent.selector, "registerComponent");
-
           functions = _authorizeForService(REGISTRY(), INSTANCE());
           _authorize(functions, IRegistryService.registerInstance.selector, "registerInstance");
 
           functions = _authorizeForService(REGISTRY(), STAKING());
           _authorize(functions, IRegistryService.registerStake.selector, "registerStake");
-
-          // functions = _authorizeForService(REGISTRY(), PRODUCT());
-          // _authorize(functions, IRegistryService.registerProduct.selector, "registerProduct");
      }
 
 
@@ -118,11 +114,37 @@ contract ServiceAuthorizationV3
      /// @dev Instance service function authorization.
      function _setupInstanceServiceAuthorization()
           internal
+     {
+     }
+
+     /// @dev Accounting service function authorization.
+     function _setupAccountingServiceAuthorization()
+          internal
      {
           IAccess.FunctionInfo[] storage functions;
 
-          functions = _authorizeForService(INSTANCE(), COMPONENT());
-          _authorize(functions, IInstanceService.initializeAuthorization.selector, "initializeAuthorization");
+          functions = _authorizeForService(ACCOUNTING(), BUNDLE());
+          _authorize(functions, IAccountingService.increaseBundleBalance.selector, "increaseBundleBalance");
+          _authorize(functions, IAccountingService.decreaseBundleBalance.selector, "decreaseBundleBalance");
+
+          functions = _authorizeForService(ACCOUNTING(), COMPONENT());
+          _authorize(functions, IAccountingService.decreaseComponentFees.selector, "decreaseComponentFees");
+
+          functions = _authorizeForService(ACCOUNTING(), DISTRIBUTION());
+          _authorize(functions, IAccountingService.increaseDistributionBalance.selector, "increaseDistributionBalance");
+          _authorize(functions, IAccountingService.decreaseDistributionBalance.selector, "decreaseDistributionBalance");
+          _authorize(functions, IAccountingService.increaseDistributorBalance.selector, "increaseDistributorBalance");
+          _authorize(functions, IAccountingService.decreaseDistributorBalance.selector, "decreaseDistributorBalance");
+
+          functions = _authorizeForService(ACCOUNTING(), POLICY());
+          _authorize(functions, IAccountingService.increaseProductFees.selector, "increaseProductFees");
+          
+          functions = _authorizeForService(ACCOUNTING(), POOL());
+          _authorize(functions, IAccountingService.increasePoolBalance.selector, "increasePoolBalance");
+          _authorize(functions, IAccountingService.decreasePoolBalance.selector, "decreasePoolBalance");
+          _authorize(functions, IAccountingService.increaseBundleBalanceForPool.selector, "increaseBundleBalanceForPool");
+          _authorize(functions, IAccountingService.decreaseBundleBalanceForPool.selector, "decreaseBundleBalanceForPool");
+
      }
 
 
@@ -130,27 +152,6 @@ contract ServiceAuthorizationV3
      function _setupComponentServiceAuthorization()
           internal
      {
-          // authz.authorizations = new DomainAuthorization[](4);
-
-          // authz.authorizations[0].domain = POLICY();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseProductFees.selector, "increaseProductFees"));
-          // authz.authorizations[0].functions = _functions;
-
-          // authz.authorizations[1].domain = DISTRIBUTION();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseDistributionBalance.selector, "increaseDistributionBalance"));
-          // authz.authorizations[1].functions = _functions;
-
-          // authz.authorizations[2].domain = POOL();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increasePoolBalance.selector, "increasePoolBalance"));
-          // authz.authorizations[2].functions = _functions;
-
-          // authz.authorizations[3].domain = BUNDLE();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseBundleBalance.selector, "increaseBundleBalance"));
-          // authz.authorizations[3].functions = _functions;
      }
 
      /// @dev Distribution service function authorization.
@@ -174,11 +175,10 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(POOL(), POLICY());
           _authorize(functions, IPoolService.lockCollateral.selector, "lockCollateral");
           _authorize(functions, IPoolService.releaseCollateral.selector, "releaseCollateral");
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
           _authorize(functions, IPoolService.processSale.selector, "processSale");
 
           functions = _authorizeForService(POOL(), CLAIM());
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
+          _authorize(functions, IPoolService.processPayout.selector, "processPayout");
      }
 
 
@@ -189,11 +189,19 @@ contract ServiceAuthorizationV3
           IAccess.FunctionInfo[] storage functions;
 
           functions = _authorizeForService(BUNDLE(), POOL());
-          _authorize(functions, IBundleService.create.selector, "create");
+          _authorize(functions, IBundleService.stake.selector, "stake");
+          _authorize(functions, IBundleService.unstake.selector, "unstake");
           _authorize(functions, IBundleService.close.selector, "close");
           _authorize(functions, IBundleService.lockCollateral.selector, "lockCollateral");
           _authorize(functions, IBundleService.releaseCollateral.selector, "releaseCollateral");
-          _authorize(functions, IBundleService.unlinkPolicy.selector, "unlinkPolicy");
+
+          functions = _authorizeForService(BUNDLE(), ALL());
+          _authorize(functions, IBundleService.create.selector, "create");
+          _authorize(functions, IBundleService.extend.selector, "extend");
+          _authorize(functions, IBundleService.lock.selector, "lock");
+          _authorize(functions, IBundleService.unlock.selector, "unlock");
+          _authorize(functions, IBundleService.setFee.selector, "setFee");
+          _authorize(functions, IBundleService.withdrawBundleFees.selector, "withdrawBundleFees");
      }
 }
 

package/contracts/shared/Component.sol

@@ -4,16 +4,15 @@ pragma solidity ^0.8.20;
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import {Amount, AmountLib} from "../type/Amount.sol";
+import {Amount} from "../type/Amount.sol";
 import {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType} from "../type/ObjectType.sol";
+import {IComponentService} from "./IComponentService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {VersionPartLib} from "../type/Version.sol";
 
 abstract contract Component is
     AccessManagedUpgradeable,
@@ -26,9 +25,9 @@ abstract contract Component is
     struct ComponentStorage {
         string _name; // unique (per instance) component name
         IERC20Metadata _token; // token for this component
-        address _wallet;
         bool _isInterceptor;
         bytes _data;
+        IComponentService _componentService;
     }
 
 
@@ -39,12 +38,6 @@ abstract contract Component is
         _;
     }
 
-    modifier onlyNftOwner(NftId nftId) {
-        if(msg.sender != getRegistry().ownerOf(nftId)) {
-            revert ErrorNftOwnableNotOwner(msg.sender);
-        }
-        _;
-    }
 
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
         assembly {
@@ -52,6 +45,7 @@ abstract contract Component is
         }
     }
 
+
     function _initializeComponent(
         address authority,
         address registry,
@@ -68,9 +62,6 @@ abstract contract Component is
         virtual
         onlyInitializing()
     {
-        _initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
-        __AccessManaged_init(authority);
-
         if (token == address(0)) {
             revert ErrorComponentTokenAddressZero();
         }
@@ -79,94 +70,51 @@ abstract contract Component is
             revert ErrorComponentNameLengthZero();
         }
 
+        _initializeRegisterable(
+            registry, 
+            parentNftId, 
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData);
+
+        __AccessManaged_init(authority);
+
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
         $._token = IERC20Metadata(token);
-        $._wallet = address(this);
         $._isInterceptor = isInterceptor;
         $._data = componentData;
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
         _registerInterface(type(IAccessManaged).interfaceId);
         _registerInterface(type(IComponent).interfaceId);
     }
 
 
-    function approveTokenHandler(Amount spendingLimitAmount)
-        external
-        virtual
-        onlyOwner
-    {
-        approveTokenHandler(address(getToken()), spendingLimitAmount);
-    }
-
-    function approveTokenHandler(address token, Amount spendingLimitAmount)
-        public
-        virtual
-        onlyOwner
-    {
-        if(getWallet() != address(this)) {
-            revert ErrorComponentWalletNotComponent();
-        }
-
-        emit LogComponentTokenHandlerApproved(address(getTokenHandler()), spendingLimitAmount);
-
-        IERC20Metadata(token).approve(
-            address(getTokenHandler()),
-            spendingLimitAmount.toInt());
-    }
-
-    function setWallet(address newWallet)
-        external
-        virtual
-        override
-        onlyOwner
-    {
-        // checks
-        address currentWallet = getWallet();
-        uint256 currentBalance = getToken().balanceOf(currentWallet);
-
-        // effects
-        _setWallet(newWallet);
-
-        // interactions
-        if (currentBalance > 0) {
-            // move tokens from old to new wallet 
-            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
-
-            if (currentWallet == address(this)) {
-                // transfer from the component requires an allowance
-                getTokenHandler().distributeTokens(currentWallet, newWallet, AmountLib.toAmount(currentBalance));
-            } else {
-                getTokenHandler().collectTokens(currentWallet, newWallet, AmountLib.toAmount(currentBalance));
-            }
-        }
-    }
-
-
-    /// @dev callback function for nft mints
-    /// may only be called by chain nft contract.
-    /// override internal function _nftMint to implement custom behaviour
-    function nftMint(address to, uint256 tokenId) 
-        external 
-        onlyChainNft
-    {
-        _nftMint(to, tokenId);
-    }
+    // function setWallet(address newWallet)
+    //     external
+    //     virtual
+    //     override
+    //     onlyOwner
+    // {
+    //     _setWallet(newWallet);
+    // }
 
     /// @dev callback function for nft transfers
     /// may only be called by chain nft contract.
     /// override internal function _nftTransferFrom to implement custom behaviour
-    function nftTransferFrom(address from, address to, uint256 tokenId)
+    function nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         external
         onlyChainNft
     {
-        _nftTransferFrom(from, to, tokenId);
+        _nftTransferFrom(from, to, tokenId, operator);
     }
 
 
     function getWallet() public view virtual returns (address walletAddress) {
-        return getComponentInfo().wallet;
+        return getTokenHandler().getWallet();
     }
 
     function getTokenHandler() public virtual view returns (TokenHandler tokenHandler) {
@@ -210,16 +158,22 @@ abstract contract Component is
     }
 
 
-    /// @dev internal function for nft transfers.
-    /// handling logic that deals with nft transfers need to overwrite this function
-    function _nftMint(address to, uint256 tokenId)
+    /// @dev Approves token hanlder to spend up to the specified amount of tokens.
+    /// Reverts if component wallet is not token handler itself.
+    /// Only component owner (nft holder) is authorizes to call this function.
+    function _approveTokenHandler(IERC20Metadata token, Amount amount)
         internal
         virtual
-    { }
+    {
+        _getComponentStorage()._componentService.approveTokenHandler(
+            token, 
+            amount);
+    }
+
 
     /// @dev internal function for nft transfers.
     /// handling logic that deals with nft transfers need to overwrite this function
-    function _nftTransferFrom(address from, address to, uint256 tokenId)
+    function _nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         internal
         virtual
     { }
@@ -227,21 +181,20 @@ abstract contract Component is
 
     /// @dev depending on the source of the component information this function needs to be overwritten. 
     /// eg for instance linked components that externally store this information with the instance store contract
-    function _setWallet(address newWallet) internal virtual {
-        ComponentStorage storage $ = _getComponentStorage();
-        address currentWallet = $._wallet;
-
-        if (newWallet == address(0)) {
-            revert ErrorComponentWalletAddressZero();
-        }
-
-        if (newWallet == currentWallet) {
-            revert ErrorComponentWalletAddressIsSameAsCurrent();
-        }
-
-        $._wallet = newWallet;
-        emit LogComponentWalletAddressChanged(currentWallet, newWallet);
+    function _setWallet(
+        address newWallet
+    )
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setWallet(newWallet);
+    }
 
+    function _setLocked(bool locked)
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setLockedFromComponent(address(this), locked);
     }
 
 
@@ -252,17 +205,15 @@ abstract contract Component is
         
         return IComponents.ComponentInfo({
             name: $._name,
-            productNftId: NftIdLib.zero(),
             token: $._token,
             tokenHandler: TokenHandler(address(0)),
-            wallet: $._wallet, // initial wallet address
             data: $._data // user specific component data
         });
     }
 
-    function _approveTokenHandler(uint256 amount) internal {
-        ComponentStorage storage $ = _getComponentStorage();
-        $._token.approve(address(getComponentInfo().tokenHandler), amount);
+    /// @dev returns the service address for the specified domain
+    /// gets address via lookup from registry using the major version form the linked instance
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
-
 }