@etherisc/gif-next 0.0.2-83889c4-030 → 0.0.2-839c4b8-393

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -0,0 +1,342 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {
+     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";
+import {IAccountingService} from "../accounting/IAccountingService.sol";
+import {IApplicationService} from "../product/IApplicationService.sol";
+import {IBundleService} from "../pool/IBundleService.sol";
+import {IClaimService} from "../product/IClaimService.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IDistributionService} from "../distribution/IDistributionService.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IOracleService} from "../oracle/IOracleService.sol";
+import {IPolicyService} from "../product/IPolicyService.sol";
+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";
+
+
+contract ServiceAuthorizationV3
+     is ServiceAuthorization
+{
+
+     constructor(string memory commitHash)
+          ServiceAuthorization(
+               "ReleaseAdmin",
+               RELEASE(),
+               3,
+               commitHash)
+     {}
+
+     function _setupDomains()
+          internal
+          override
+     {
+          _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));
+     }
+
+
+     function _setupDomainAuthorizations()
+          internal
+          override
+     {
+          _setupRegistryServiceAuthorization();
+          _setupStakingServiceAuthorization();
+          _setupInstanceServiceAuthorization();
+          _setupAccountingServiceAuthorization();
+          _setupComponentServiceAuthorization();
+          _setupClaimServiceAuthorization();
+          _setupRiskServiceAuthorization();
+          _setupDistributionServiceAuthorization();
+          _setupPoolServiceAuthorization();
+          _setupBundleServiceAuthorization();
+          _setupOracleServiceAuthorization();
+          _setupApplicationServiceAuthorization();
+          _setupPolicyServiceAuthorization();
+     }
+
+
+     /// @dev registry service authorization.
+     /// authorized functions MUST be implemented with a restricted modifier
+     function _setupRegistryServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(REGISTRY(), APPLICATION());
+          _authorize(functions, IRegistryService.registerPolicy.selector, "registerPolicy");
+
+          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.registerDistributor.selector, "registerDistributor");
+
+          functions = _authorizeForService(REGISTRY(), INSTANCE());
+          _authorize(functions, IRegistryService.registerInstance.selector, "registerInstance");
+
+          functions = _authorizeForService(REGISTRY(), STAKING());
+          _authorize(functions, IRegistryService.registerStake.selector, "registerStake");
+     }
+
+
+     /// @dev staking service authorization.
+     /// authorized functions MUST be implemented with a restricted modifier
+     function _setupStakingServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(STAKING(), INSTANCE());
+          _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.createStakeObject.selector, "createStakeObject");
+          _authorize(functions, IStakingService.pullDipToken.selector, "pullDipToken");
+          _authorize(functions, IStakingService.pushDipToken.selector, "pushDipToken");
+     }
+
+
+     /// @dev Instance service function authorization.
+     function _setupInstanceServiceAuthorization()
+          internal
+     {
+          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.setStakingMaxAmount.selector, "setStakingMaxAmount");
+          _authorize(functions, IInstanceService.refillInstanceRewardReserves.selector, "refillInstanceRewardReserves");
+          _authorize(functions, IInstanceService.withdrawInstanceRewardReserves.selector, "withdrawInstanceRewardReserves");
+     }
+
+     /// @dev Accounting service function authorization.
+     function _setupAccountingServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          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");
+          _authorize(functions, IAccountingService.increaseProductFeesForPool.selector, "increaseProductFeesForPool");
+
+     }
+
+
+     /// @dev Component service function authorization.
+     function _setupComponentServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(COMPONENT(), ALL());
+          _authorize(functions, IComponentService.registerComponent.selector, "registerComponent");
+          _authorize(functions, IComponentService.approveTokenHandler.selector, "approveTokenHandler");
+          _authorize(functions, IComponentService.setWallet.selector, "setWallet");
+          _authorize(functions, IComponentService.setLocked.selector, "setLocked");
+          _authorize(functions, IComponentService.withdrawFees.selector, "withdrawFees");
+          _authorize(functions, IComponentService.registerProduct.selector, "registerProduct");
+          _authorize(functions, IComponentService.setProductFees.selector, "setProductFees");
+          _authorize(functions, IComponentService.setDistributionFees.selector, "setDistributionFees");
+          _authorize(functions, IComponentService.setPoolFees.selector, "setPoolFees");
+
+     }
+
+     /// @dev Distribution service function authorization.
+     function _setupRiskServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForService(RISK(), ALL());
+          _authorize(functions, IRiskService.createRisk.selector, "createRisk");
+          _authorize(functions, IRiskService.updateRisk.selector, "updateRisk");
+          _authorize(functions, IRiskService.setRiskLocked.selector, "setRiskLocked");
+          _authorize(functions, IRiskService.closeRisk.selector, "closeRisk");
+     }
+
+     /// @dev Distribution service function authorization.
+     function _setupClaimServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForService(CLAIM(), ALL());
+          _authorize(functions, IClaimService.submit.selector, "submit");
+          _authorize(functions, IClaimService.confirm.selector, "confirm");
+          _authorize(functions, IClaimService.decline.selector, "decline");
+          _authorize(functions, IClaimService.revoke.selector, "revoke");
+          _authorize(functions, IClaimService.cancelConfirmedClaim.selector, "cancelConfirmedClaim");
+          _authorize(functions, IClaimService.createPayoutForBeneficiary.selector, "createPayoutForBeneficiary");
+          _authorize(functions, IClaimService.createPayout.selector, "createPayout");
+          _authorize(functions, IClaimService.processPayout.selector, "processPayout");
+          _authorize(functions, IClaimService.cancelPayout.selector, "cancelPayout");
+     }
+
+     /// @dev Distribution service function authorization.
+     function _setupDistributionServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForService(DISTRIBUTION(), POLICY());
+          _authorize(functions, IDistributionService.processSale.selector, "processSale");
+          _authorize(functions, IDistributionService.processReferral.selector, "processReferral");
+
+          functions = _authorizeForService(DISTRIBUTION(), ALL());
+          _authorize(functions, IDistributionService.createDistributorType.selector, "createDistributorType");
+          _authorize(functions, IDistributionService.createDistributor.selector, "createDistributor");
+          _authorize(functions, IDistributionService.changeDistributorType.selector, "changeDistributorType");
+          _authorize(functions, IDistributionService.createReferral.selector, "createReferral");
+          _authorize(functions, IDistributionService.withdrawCommission.selector, "withdrawCommission");
+     }
+
+
+     /// @dev Pool service function authorization.
+     function _setupPoolServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(POOL(), POLICY());
+          _authorize(functions, IPoolService.lockCollateral.selector, "lockCollateral");
+          _authorize(functions, IPoolService.releaseCollateral.selector, "releaseCollateral");
+          _authorize(functions, IPoolService.processSale.selector, "processSale");
+
+          functions = _authorizeForService(POOL(), CLAIM());
+          _authorize(functions, IPoolService.processPayout.selector, "processPayout");
+
+          functions = _authorizeForService(POOL(), ALL());
+          _authorize(functions, IPoolService.setMaxBalanceAmount.selector, "setMaxBalanceAmount");
+          _authorize(functions, IPoolService.closeBundle.selector, "closeBundle");
+          _authorize(functions, IPoolService.processFundedClaim.selector, "processFundedClaim");
+          _authorize(functions, IPoolService.stake.selector, "stake");
+          _authorize(functions, IPoolService.unstake.selector, "unstake");
+          _authorize(functions, IPoolService.fundPoolWallet.selector, "fundPoolWallet");
+          _authorize(functions, IPoolService.defundPoolWallet.selector, "defundPoolWallet");
+          _authorize(functions, IPoolService.withdrawBundleFees.selector, "withdrawBundleFees");
+     }
+
+
+     /// @dev Instance service function authorization.
+     function _setupBundleServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(BUNDLE(), POOL());
+          _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");
+
+          functions = _authorizeForService(BUNDLE(), ALL());
+          _authorize(functions, IBundleService.create.selector, "create");
+          _authorize(functions, IBundleService.extend.selector, "extend");
+          _authorize(functions, IBundleService.setLocked.selector, "setLocked");
+          _authorize(functions, IBundleService.setFee.selector, "setFee");
+     }
+
+     function _setupOracleServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(ORACLE(), ALL());
+          _authorize(functions, IOracleService.request.selector, "request");
+          _authorize(functions, IOracleService.respond.selector, "respond");
+          _authorize(functions, IOracleService.resend.selector, "resend");
+          _authorize(functions, IOracleService.cancel.selector, "cancel");
+     }
+
+     function _setupApplicationServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(APPLICATION(), ALL());
+          _authorize(functions, IApplicationService.create.selector, "create");
+          _authorize(functions, IApplicationService.renew.selector, "renew");
+          _authorize(functions, IApplicationService.adjust.selector, "adjust");
+          _authorize(functions, IApplicationService.revoke.selector, "revoke");
+     }
+
+     function _setupPolicyServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(POLICY(), ALL());
+          _authorize(functions, IPolicyService.decline.selector, "decline");
+          _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");
+
+     }
+}
+

package/contracts/registry/TokenRegistry.sol

@@ -3,57 +3,56 @@ pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-
-import {REGISTRY} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
-
-import {IRegisterable} from "../shared/IRegisterable.sol";
 
 import {IRegistry} from "./IRegistry.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
-import {ReleaseManager} from "./ReleaseManager.sol";
-import {RegistryAdmin} from "./RegistryAdmin.sol";
+import {IStaking} from "../staking/IStaking.sol";
 
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
+import {RegistryAdmin} from "./RegistryAdmin.sol";
+import {VersionPart} from "../type/Version.sol";
 
-/// @title contract to register token per GIF major release.
+/// @dev The TokenRegistry contract is used to whitelist/manage ERC-20 of tokens per major release.
+/// Only whitelisted tokens can be used as default tokens for products, distribution and pools components.
 contract TokenRegistry is
     AccessManaged,
     IRegistryLinked
 {
-    event LogTokenRegistryTokenRegistered(uint256 chainId, address token, uint256 decimals, string symbol);
-    event LogTokenRegistryTokenGlobalStateSet(uint256 chainId, address token, bool active);
-    event LogTokenRegistryTokenStateSet(uint256 chainId, address token, VersionPart majorVersion, bool active);
+    event LogTokenRegistryTokenRegistered(ChainId chainId, address token, uint256 decimals, string symbol);
+    event LogTokenRegistryTokenGlobalStateSet(ChainId chainId, address token, bool active);
+    event LogTokenRegistryTokenStateSet(ChainId chainId, address token, VersionPart release, bool active);
 
     error ErrorTokenRegistryChainIdZero();
     error ErrorTokenRegistryTokenAddressZero();
 
-    error ErrorTokenRegistryNotRemoteToken(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenAlreadyRegistered(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenNotContract(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenNotErc20(uint256 chainId, address token);
+    error ErrorTokenRegistryNotRemoteToken(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenAlreadyRegistered(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenNotContract(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenNotErc20(ChainId chainId, address token);
 
-    error ErrorTokenRegistryTokenNotRegistered(uint256 chainId, address token);
-    error ErrorTokenRegistryMajorVersionInvalid(VersionPart majorVersion);
+    error ErrorTokenRegistryTokenNotRegistered(ChainId chainId, address token);
+    error ErrorTokenRegistryMajorVersionInvalid(VersionPart release);
 
     struct TokenInfo {
-        uint256 chainId;
-        address token;
-        uint8 decimals;
-        string symbol;
+        // slot 0
+        ChainId chainId; // 96
+        address token; // 20
+        uint8 decimals; // 8
         bool active;
+        // slot 1
+        string symbol;
     }
 
-    mapping(uint256 chainId => mapping(address token => TokenInfo info)) internal _tokenInfo;
-    mapping(uint256 chainId => mapping(address token => mapping(VersionPart majorVersion => bool isActive))) internal _active;
+    mapping(ChainId chainId => mapping(address token => TokenInfo info)) internal _tokenInfo;
+    mapping(ChainId chainId => mapping(address token => mapping(VersionPart release => bool isActive))) internal _active;
     TokenInfo [] internal _token;
 
     IRegistry internal _registry;
-    ReleaseManager internal _releaseManager;
+    ChainId internal _chainId = ChainIdLib.current();
     IERC20Metadata internal _dipToken;
 
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
-    modifier onlyRegisteredToken(uint256 chainId, address token) {
+    modifier onlyRegisteredToken(ChainId chainId, address token) {
         if (!isRegistered(chainId, token)) {
             revert ErrorTokenRegistryTokenNotRegistered(chainId, token);
         }
@@ -68,12 +67,13 @@ contract TokenRegistry is
         setAuthority(authority);
         
         _registry = registry;
-        _dipToken = dipToken;
+
+        // TODO deal with chains without a dip token
+        _dipToken = _verifyOnchainToken(address(dipToken));
 
         // register dip token
-        uint256 chainId = block.chainid;
         _registerToken(
-            chainId, 
+            _chainId, 
             address(_dipToken), 
             _dipToken.decimals(), 
             _dipToken.symbol());
@@ -87,15 +87,18 @@ contract TokenRegistry is
         external
         restricted()
     {
+        // checks
         IERC20Metadata token = _verifyOnchainToken(tokenAddress);
-        _registerToken(block.chainid, tokenAddress, token.decimals(), token.symbol());
+
+        // effects
+        _registerToken(_chainId, tokenAddress, token.decimals(), token.symbol());
     }
 
 
     /// @dev register the remote token with the provided attributes.
     /// this function may not be used for tokens when chainId == block.chainid.
     function registerRemoteToken(
-        uint256 chainId,
+        ChainId chainId,
         address token,
         uint8 decimals,
         string memory symbol
@@ -103,7 +106,7 @@ contract TokenRegistry is
         external
         restricted()
     {
-        if (chainId == block.chainid) {
+        if (chainId == _chainId) {
             revert ErrorTokenRegistryNotRemoteToken(chainId, token);
         }
 
@@ -115,7 +118,7 @@ contract TokenRegistry is
     /// when setting a token to active=false isActive will return false
     /// regardless of release specific active value.
     function setActive(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
         bool active
     )
@@ -128,32 +131,32 @@ contract TokenRegistry is
     }
 
 
-    /// @dev sets active state for specified token and major version.
+    /// @dev sets active state for specified token and release (major version).
     /// internally calls setActiveWithVersionCheck() with enforcing version check.
     /// token state is informative, registry have no clue about used tokens
     /// component owner is responsible for token selection and operations
     /// service MUST deny registration of component with inactive token.
     function setActiveForVersion(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active
     )
         external
         restricted()
         onlyRegisteredToken(chainId, token)
     {
-        _setActiveWithVersionCheck(chainId, token, majorVersion, active, true);
+        _setActiveWithVersionCheck(chainId, token, release, active, true);
     }
 
 
     /// @dev as setActiveForVersion() with the option to skip the version check.
     /// enforcing the version check checks if the provided major version with the release manager. 
-    /// the function reverts if the provided majorVersion is unknown to the release manager.
+    /// the function reverts if the provided release is unknown to the release manager.
     function setActiveWithVersionCheck(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active,
         bool enforceVersionCheck
     )
@@ -161,14 +164,14 @@ contract TokenRegistry is
         restricted()
         onlyRegisteredToken(chainId, token)
     {
-        _setActiveWithVersionCheck(chainId, token, majorVersion, active, enforceVersionCheck);
+        _setActiveWithVersionCheck(chainId, token, release, active, enforceVersionCheck);
     }
 
 
     function _setActiveWithVersionCheck(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active,
         bool enforceVersionCheck
     )
@@ -176,15 +179,15 @@ contract TokenRegistry is
     {
         // verify valid major version
         if(enforceVersionCheck) {
-            uint256 version = majorVersion.toInt();
-            if (!getRegistry().isActiveRelease(majorVersion)) {
-                revert ErrorTokenRegistryMajorVersionInvalid(majorVersion);
+            uint256 version = release.toInt();
+            if (!getRegistry().isActiveRelease(release)) {
+                revert ErrorTokenRegistryMajorVersionInvalid(release);
             }
         }
 
-        _active[chainId][token][majorVersion] = active;
+        _active[chainId][token][release] = active;
 
-        emit LogTokenRegistryTokenStateSet(chainId, token, majorVersion, active);
+        emit LogTokenRegistryTokenStateSet(chainId, token, release, active);
     }
 
     /// @dev returns the dip token for this chain
@@ -203,22 +206,22 @@ contract TokenRegistry is
     }
 
     /// @dev returns the token info for the specified token coordinates.
-    function getTokenInfo(uint256 chainId, address token) external view returns (TokenInfo memory tokenInfo) {
+    function getTokenInfo(ChainId chainId, address token) external view returns (TokenInfo memory tokenInfo) {
         return _tokenInfo[chainId][token];
     }
 
     /// @dev returns true iff the specified token has been registered for this TokenRegistry contract.
-    function isRegistered(uint256 chainId, address token) public view returns (bool) {
-        return _tokenInfo[chainId][token].chainId > 0;
+    function isRegistered(ChainId chainId, address token) public view returns (bool) {
+        return _tokenInfo[chainId][token].chainId.gtz();
     }
 
-    /// @dev returns true iff both the token is active for the specfied version and the global token state is active
-    function isActive(uint256 chainId, address token, VersionPart majorVersion) external view returns (bool) {
+    /// @dev returns true iff both the token is active for the specfied release and the global token state is active
+    function isActive(ChainId chainId, address token, VersionPart release) external view returns (bool) {
         if(!_tokenInfo[chainId][token].active) {
             return false;
         }
 
-        return _active[chainId][token][majorVersion];
+        return _active[chainId][token][release];
     }
 
     function getDipTokenAddress() external view returns (address) {
@@ -244,16 +247,15 @@ contract TokenRegistry is
         returns (IERC20Metadata token)
     {
         token = IERC20Metadata(tokenAddress);
-        uint256 chainId = block.chainid;
 
         // MUST be contract
         if(tokenAddress.code.length == 0) {
-            revert ErrorTokenRegistryTokenNotContract(chainId, tokenAddress);
+            revert ErrorTokenRegistryTokenNotContract(ChainIdLib.current(), tokenAddress);
         }
 
         // MUST implement required erc20 view functions
         if(!_implementsErc20Functions(token)) {
-            revert ErrorTokenRegistryTokenNotErc20(chainId, tokenAddress);
+            revert ErrorTokenRegistryTokenNotErc20(ChainIdLib.current(), tokenAddress);
         }
     }
 
@@ -286,13 +288,13 @@ contract TokenRegistry is
     /// - token not yet registered
     /// - chainId not zero
     /// - token address not zero
-    function _registerToken(uint256 chainId, address token, uint8 decimals, string memory symbol) internal {
+    function _registerToken(ChainId chainId, address token, uint8 decimals, string memory symbol) internal {
 
         if (isRegistered(chainId, token)) {
             revert ErrorTokenRegistryTokenAlreadyRegistered(chainId, token);
         }
 
-        if(chainId == 0) {
+        if(chainId.eqz()) {
             revert ErrorTokenRegistryChainIdZero();
         }