@etherisc/gif-next 0.0.2-b2e620f-736 → 0.0.2-b37fa8b-169

package/contracts/registry/ReleaseRegistry.sol

@@ -4,27 +4,25 @@ pragma solidity ^0.8.20;
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 
-import {ContractLib} from "../shared/ContractLib.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, ObjectTypeLib, POOL, RELEASE, REGISTRY, SERVICE, STAKING} from "../type/ObjectType.sol";
-import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {Seconds} from "../type/Seconds.sol";
-import {StateId, SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED} from "../type/StateId.sol";
-import {VersionPart, VersionPartLib} from "../type/Version.sol";
-
-import {IService} from "../shared/IService.sol";
-
 import {IAccessAdmin} from "../authorization/IAccessAdmin.sol";
 import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
-
 import {IRegistry} from "./IRegistry.sol";
 import {IRelease} from "./IRelease.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {IService} from "../shared/IService.sol";
 import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
+
+import {ContractLib} from "../shared/ContractLib.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, ObjectTypeLib, COMPONENT, POOL, RELEASE, REGISTRY, SERVICE, STAKING} from "../type/ObjectType.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 import {Registry} from "./Registry.sol";
-import {ReleaseLifecycle} from "./ReleaseLifecycle.sol";
 import {ReleaseAdmin} from "./ReleaseAdmin.sol";
+import {ReleaseLifecycle} from "./ReleaseLifecycle.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId, SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED} from "../type/StateId.sol";
+import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 /// @dev The ReleaseRegistry manages the lifecycle of major GIF releases and their services.
 /// The creation of a new GIF release is a multi-step process:
@@ -73,7 +71,7 @@ contract ReleaseRegistry is
     error ErrorReleaseRegistryServiceSelfRegistration(IService service);
     error ErrorReleaseRegistryServiceOwnerRegistered(IService service, address owner);
 
-    RegistryAdmin public immutable _admin;
+    RegistryAdmin public immutable _registryAdmin;
     Registry public immutable _registry;
 
     mapping(VersionPart release => IRelease.ReleaseInfo info) internal _releaseInfo;
@@ -87,6 +85,7 @@ contract ReleaseRegistry is
     uint256 internal _registeredServices = 0;
     uint256 internal _servicesToRegister = 0;
 
+    // TODO move master relase admin outside constructor (same construction as for registry admin)
     constructor(Registry registry)
         AccessManaged(msg.sender)
     {
@@ -97,9 +96,9 @@ contract ReleaseRegistry is
         setAuthority(registry.getAuthority());
 
         _registry = registry;
-        _admin = RegistryAdmin(_registry.getRegistryAdminAddress());
-
-        _masterReleaseAdmin = new ReleaseAdmin();
+        _registryAdmin = RegistryAdmin(_registry.getRegistryAdminAddress());
+        _masterReleaseAdmin = new ReleaseAdmin(
+            _cloneNewAccessManager());
 
         _next = VersionPartLib.toVersionPart(INITIAL_GIF_VERSION - 1);
     }
@@ -151,7 +150,7 @@ contract ReleaseRegistry is
         uint256 serviceDomainsCount = _verifyServiceAuthorization(serviceAuthorization, releaseVersion, salt);
 
         // create and initialize release admin
-        releaseAdmin = _cloneNewReleaseAdmin(releaseVersion);
+        releaseAdmin = _cloneNewReleaseAdmin(serviceAuthorization, releaseVersion);
         releaseSalt = salt;
 
         // ensures unique salt
@@ -183,8 +182,8 @@ contract ReleaseRegistry is
         checkTransition(_releaseInfo[releaseVersion].state, RELEASE(), DEPLOYING(), DEPLOYED());
 
         address releaseAuthority = ReleaseAdmin(_releaseInfo[releaseVersion].releaseAdmin).authority();
-        IServiceAuthorization releaseAuth = _releaseInfo[releaseVersion].auth;
-        ObjectType expectedDomain = releaseAuth.getServiceDomain(_registeredServices);
+        IServiceAuthorization releaseAuthz = _releaseInfo[releaseVersion].auth;
+        ObjectType expectedDomain = releaseAuthz.getServiceDomain(_registeredServices);
 
         // service can work with release registry and release version
         (
@@ -217,7 +216,6 @@ contract ReleaseRegistry is
         ReleaseAdmin releaseAdmin = ReleaseAdmin(_releaseInfo[releaseVersion].releaseAdmin);
         releaseAdmin.setReleaseLocked(false);
         releaseAdmin.authorizeService(
-            releaseAuth, 
             service,
             serviceDomain,
             releaseVersion);
@@ -241,7 +239,7 @@ contract ReleaseRegistry is
 
         _latest = release;
         _releaseInfo[release].state = ACTIVE();
-        _releaseInfo[release].activatedAt = TimestampLib.blockTimestamp();
+        _releaseInfo[release].activatedAt = TimestampLib.current();
         _releaseInfo[release].disabledAt = TimestampLib.max();
 
         // grant special roles for registry/staking/pool services
@@ -253,16 +251,21 @@ contract ReleaseRegistry is
             revert ErrorReleaseRegistryRegistryServiceMissing(release);
         }
 
-        _admin.grantServiceRoleForAllVersions(IService(service), REGISTRY());
+        _registryAdmin.grantServiceRoleForAllVersions(IService(service), REGISTRY());
 
         service = _registry.getServiceAddress(STAKING(), release);
         if(service != address(0)) {
-            _admin.grantServiceRoleForAllVersions(IService(service), STAKING());
+            _registryAdmin.grantServiceRoleForAllVersions(IService(service), STAKING());
+        }
+
+        service = _registry.getServiceAddress(COMPONENT(), release);
+        if(service != address(0)) {
+            _registryAdmin.grantServiceRoleForAllVersions(IService(service), COMPONENT());
         }
 
         service = _registry.getServiceAddress(POOL(), release);
         if(service != address(0)) {
-            _admin.grantServiceRoleForAllVersions(IService(service), POOL());
+            _registryAdmin.grantServiceRoleForAllVersions(IService(service), POOL());
         }
 
         _setReleaseLocked(release, false);
@@ -285,7 +288,7 @@ contract ReleaseRegistry is
         } else {
             checkTransition(state, RELEASE(), ACTIVE(), PAUSED());
             _releaseInfo[release].state = PAUSED();
-            _releaseInfo[release].disabledAt = TimestampLib.blockTimestamp();
+            _releaseInfo[release].disabledAt = TimestampLib.current();
             emit LogReleaseDisabled(release);
         }
 
@@ -350,7 +353,7 @@ contract ReleaseRegistry is
     }
 
     function getRegistryAdmin() external view returns (address) {
-        return address(_admin);
+        return address(_registryAdmin);
     }
 
     //--- IRegistryLinked ------------------------------------------------------//
@@ -368,34 +371,45 @@ contract ReleaseRegistry is
             _releaseInfo[release].releaseAdmin).setReleaseLocked(locked);
     }
 
-
-    function _cloneNewReleaseAdmin(VersionPart release)
+    function _cloneNewReleaseAdmin(
+        IServiceAuthorization serviceAuthorization,
+        VersionPart release
+    )
         private
         returns (ReleaseAdmin clonedAdmin)
     {
-        AccessManagerCloneable clonedAccessManager = AccessManagerCloneable(
-            Clones.clone(
-                _masterReleaseAdmin.authority()
-            )
-        );
-
+        // clone and setup release specific release admin
         clonedAdmin = ReleaseAdmin(
-            Clones.clone(
-                address(_masterReleaseAdmin)
-            )
-        );
+            Clones.clone(address(_masterReleaseAdmin)));
+
+        string memory releaseAdminName = string(
+            abi.encodePacked(
+                "ReleaseAdminV", 
+                release.toString()));
+
+        clonedAdmin.initialize(
+            address(_cloneNewAccessManager()),
+            releaseAdminName);
 
-        clonedAdmin.initialize(clonedAccessManager);
         clonedAdmin.completeSetup(
             address(_registry), 
-            address(this), // release registry (this contract)
-            release);
+            address(serviceAuthorization),
+            release,
+            address(this)); // release registry (this contract)
 
         // lock release (remains locked until activation)
         clonedAdmin.setReleaseLocked(true);
     }
 
 
+    function _cloneNewAccessManager()
+        private
+        returns (address accessManager)
+    {
+        return Clones.clone(address(_registryAdmin.authority()));
+    }
+
+
     function _verifyServiceAuthorization(
         IServiceAuthorization serviceAuthorization,
         VersionPart releaseVersion,
@@ -406,8 +420,8 @@ contract ReleaseRegistry is
         returns (uint256 serviceDomainsCount)
     {
         // authorization contract supports IServiceAuthorization interface
-        if(!serviceAuthorization.supportsInterface(type(IServiceAuthorization).interfaceId)) {
-                revert ErrorReleaseRegistryNotServiceAuth(address(serviceAuthorization));
+        if(!ContractLib.supportsInterface(address(serviceAuthorization), type(IServiceAuthorization).interfaceId)) {
+            revert ErrorReleaseRegistryNotServiceAuth(address(serviceAuthorization));
         }
 
         // authorizaions contract version matches with release version

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {
-     ALL, ACCOUNTING, REGISTRY, RISK, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
+     ALL, RELEASE, 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";
@@ -19,6 +19,7 @@ import {IPoolService} from "../pool/IPoolService.sol";
 import {IStakingService} from "../staking/IStakingService.sol";
 import {IRegistryService} from "./IRegistryService.sol";
 import {IRiskService} from "../product/IRiskService.sol";
+
 import {ServiceAuthorization} from "../authorization/ServiceAuthorization.sol";
 
 
@@ -27,27 +28,31 @@ contract ServiceAuthorizationV3
 {
 
      constructor(string memory commitHash)
-          ServiceAuthorization(commitHash, 3)
+          ServiceAuthorization(
+               "ReleaseAdmin",
+               RELEASE(),
+               3,
+               commitHash)
      {}
 
      function _setupDomains()
           internal
           override
      {
-          _authorizeDomain(REGISTRY(), address(1));
-          _authorizeDomain(STAKING(), address(2));
-          _authorizeDomain(INSTANCE(), address(3));
-          _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));
+          _authorizeServiceDomain(REGISTRY(), address(1));
+          _authorizeServiceDomain(STAKING(), address(2));
+          _authorizeServiceDomain(INSTANCE(), address(3));
+          _authorizeServiceDomain(ACCOUNTING(), address(4));
+          _authorizeServiceDomain(COMPONENT(), address(5));
+          _authorizeServiceDomain(DISTRIBUTION(), address(6));
+          _authorizeServiceDomain(PRICE(), address(7));
+          _authorizeServiceDomain(BUNDLE(), address(8));
+          _authorizeServiceDomain(POOL(), address(9));
+          _authorizeServiceDomain(ORACLE(), address(10));
+          _authorizeServiceDomain(RISK(), address(11));
+          _authorizeServiceDomain(POLICY(), address(12));
+          _authorizeServiceDomain(CLAIM(), address(13));
+          _authorizeServiceDomain(APPLICATION(), address(14));
      }
 
 
@@ -55,10 +60,9 @@ contract ServiceAuthorizationV3
           internal
           override
      {
-          _setupIRegistryServiceAuthorization();
+          _setupRegistryServiceAuthorization();
           _setupStakingServiceAuthorization();
           _setupInstanceServiceAuthorization();
-          _setupInstanceServiceAuthorization();
           _setupAccountingServiceAuthorization();
           _setupComponentServiceAuthorization();
           _setupClaimServiceAuthorization();
@@ -74,7 +78,7 @@ contract ServiceAuthorizationV3
 
      /// @dev registry service authorization.
      /// authorized functions MUST be implemented with a restricted modifier
-     function _setupIRegistryServiceAuthorization()
+     function _setupRegistryServiceAuthorization()
           internal
      {
           IAccess.FunctionInfo[] storage functions;
@@ -111,16 +115,14 @@ contract ServiceAuthorizationV3
           _authorize(functions, IStakingService.createInstanceTarget.selector, "createInstanceTarget");
           _authorize(functions, IStakingService.setInstanceLockingPeriod.selector, "setInstanceLockingPeriod");
           _authorize(functions, IStakingService.setInstanceRewardRate.selector, "setInstanceRewardRate");
+          _authorize(functions, IStakingService.setInstanceMaxStakedAmount.selector, "setInstanceMaxStakedAmount");
           _authorize(functions, IStakingService.refillInstanceRewardReserves.selector, "refillInstanceRewardReserves");
           _authorize(functions, IStakingService.withdrawInstanceRewardReserves.selector, "withdrawInstanceRewardReserves");
 
           functions = _authorizeForService(STAKING(), ALL());
-          _authorize(functions, IStakingService.create.selector, "create");
-          _authorize(functions, IStakingService.stake.selector, "stake");
-          _authorize(functions, IStakingService.restakeToNewTarget.selector, "restakeToNewTarget");
-          _authorize(functions, IStakingService.updateRewards.selector, "updateRewards");
-          _authorize(functions, IStakingService.claimRewards.selector, "claimRewards");
-          _authorize(functions, IStakingService.unstake.selector, "unstake");
+          _authorize(functions, IStakingService.createStakeObject.selector, "createStakeObject");
+          _authorize(functions, IStakingService.pullDipToken.selector, "pullDipToken");
+          _authorize(functions, IStakingService.pushDipToken.selector, "pushDipToken");
      }
 
 
@@ -130,14 +132,26 @@ contract ServiceAuthorizationV3
      {
           IAccess.FunctionInfo[] storage functions;
           functions = _authorizeForService(INSTANCE(), ALL());
+          _authorize(functions, IInstanceService.createRole.selector, "createRole");
+          _authorize(functions, IInstanceService.setRoleActive.selector, "setRoleActive");
+          _authorize(functions, IInstanceService.grantRole.selector, "grantRole");
+          _authorize(functions, IInstanceService.revokeRole.selector, "revokeRole");
+
+          _authorize(functions, IInstanceService.createTarget.selector, "createTarget");
+          _authorize(functions, IInstanceService.authorizeFunctions.selector, "authorizeFunctions");
+          _authorize(functions, IInstanceService.unauthorizeFunctions.selector, "unauthorizeFunctions");
+          _authorize(functions, IInstanceService.setTargetLocked.selector, "setTargetLocked");
+          _authorize(functions, IInstanceService.setInstanceLocked.selector, "setInstanceLocked");
+
           _authorize(functions, IInstanceService.createInstance.selector, "createInstance");
           _authorize(functions, IInstanceService.upgradeInstanceReader.selector, "upgradeInstanceReader");
           _authorize(functions, IInstanceService.upgradeMasterInstanceReader.selector, "upgradeMasterInstanceReader");
 
           _authorize(functions, IInstanceService.setStakingLockingPeriod.selector, "setStakingLockingPeriod");
           _authorize(functions, IInstanceService.setStakingRewardRate.selector, "setStakingRewardRate");
-          _authorize(functions, IInstanceService.refillStakingRewardReserves.selector, "refillStakingRewardReserves");
-          _authorize(functions, IInstanceService.withdrawStakingRewardReserves.selector, "withdrawStakingRewardReserves");
+          _authorize(functions, IInstanceService.setStakingMaxAmount.selector, "setStakingMaxAmount");
+          _authorize(functions, IInstanceService.refillInstanceRewardReserves.selector, "refillInstanceRewardReserves");
+          _authorize(functions, IInstanceService.withdrawInstanceRewardReserves.selector, "withdrawInstanceRewardReserves");
      }
 
      /// @dev Accounting service function authorization.
@@ -167,6 +181,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IAccountingService.decreasePoolBalance.selector, "decreasePoolBalance");
           _authorize(functions, IAccountingService.increaseBundleBalanceForPool.selector, "increaseBundleBalanceForPool");
           _authorize(functions, IAccountingService.decreaseBundleBalanceForPool.selector, "decreaseBundleBalanceForPool");
+          _authorize(functions, IAccountingService.increaseProductFeesForPool.selector, "increaseProductFeesForPool");
 
      }
 
@@ -181,7 +196,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IComponentService.registerComponent.selector, "registerComponent");
           _authorize(functions, IComponentService.approveTokenHandler.selector, "approveTokenHandler");
           _authorize(functions, IComponentService.setWallet.selector, "setWallet");
-          _authorize(functions, IComponentService.setComponentLocked.selector, "setComponentLocked");
+          _authorize(functions, IComponentService.setLocked.selector, "setLocked");
           _authorize(functions, IComponentService.withdrawFees.selector, "withdrawFees");
           _authorize(functions, IComponentService.registerProduct.selector, "registerProduct");
           _authorize(functions, IComponentService.setProductFees.selector, "setProductFees");
@@ -198,7 +213,8 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(RISK(), ALL());
           _authorize(functions, IRiskService.createRisk.selector, "createRisk");
           _authorize(functions, IRiskService.updateRisk.selector, "updateRisk");
-          _authorize(functions, IRiskService.updateRiskState.selector, "updateRiskState");
+          _authorize(functions, IRiskService.setRiskLocked.selector, "setRiskLocked");
+          _authorize(functions, IRiskService.closeRisk.selector, "closeRisk");
      }
 
      /// @dev Distribution service function authorization.
@@ -211,7 +227,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IClaimService.confirm.selector, "confirm");
           _authorize(functions, IClaimService.decline.selector, "decline");
           _authorize(functions, IClaimService.revoke.selector, "revoke");
-          _authorize(functions, IClaimService.close.selector, "close");
+          _authorize(functions, IClaimService.cancelConfirmedClaim.selector, "cancelConfirmedClaim");
           _authorize(functions, IClaimService.createPayoutForBeneficiary.selector, "createPayoutForBeneficiary");
           _authorize(functions, IClaimService.createPayout.selector, "createPayout");
           _authorize(functions, IClaimService.processPayout.selector, "processPayout");
@@ -278,8 +294,7 @@ contract ServiceAuthorizationV3
           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.setLocked.selector, "setLocked");
           _authorize(functions, IBundleService.setFee.selector, "setFee");
      }
 
@@ -317,6 +332,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IPolicyService.createPolicy.selector, "createPolicy");
           _authorize(functions, IPolicyService.collectPremium.selector, "collectPremium");
           _authorize(functions, IPolicyService.activate.selector, "activate");
+          _authorize(functions, IPolicyService.adjustActivation.selector, "adjustActivation");
           _authorize(functions, IPolicyService.expire.selector, "expire");
           _authorize(functions, IPolicyService.expirePolicy.selector, "expirePolicy");
           _authorize(functions, IPolicyService.close.selector, "close");