@etherisc/gif-next 3.0.0-61b9ecf-774 → 3.0.0-6580d8b-637

package/contracts/pool/IPoolService.sol

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

package/contracts/pool/PoolService.sol

@@ -98,7 +98,7 @@ contract PoolService is
             unstakedAmount +  feeAmount, 
             AmountLib.zero());
         
-        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount, feeAmount);
 
         if ((unstakedAmount + feeAmount).gtz()){
             IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
@@ -553,7 +553,7 @@ contract PoolService is
             address bundleOwner = getRegistry().ownerOf(bundleNftId);
             TokenHandler tokenHandler = reader.getTokenHandler(poolNftId);
             address token = address(tokenHandler.TOKEN());
-            emit LogPoolServiceFeesWithdrawn(bundleNftId, bundleOwner, token, withdrawnAmount);
+            emit LogPoolServiceFeesWithdrawn(bundleNftId, bundleOwner, withdrawnAmount, token);
 
             tokenHandler.pushToken(bundleOwner, withdrawnAmount);
         }

package/contracts/product/ClaimService.sol

@@ -496,7 +496,7 @@ contract ClaimService is
         claimInfo.openPayoutsCount += 1;
         instanceContracts.productStore.updateClaim(policyNftId, claimId, claimInfo, KEEP_STATE());
 
-        emit LogClaimServicePayoutCreated(policyNftId, payoutId, amount, beneficiary);
+        emit LogClaimServicePayoutCreated(policyNftId, claimId, payoutId, amount, beneficiary);
     }
 
     /// @dev Verifies the caller is a product and the policy is active. 

package/contracts/product/IApplicationService.sol

@@ -15,24 +15,24 @@ import {Seconds} from "../type/Seconds.sol";
 interface IApplicationService is IService {
     
     event LogApplicationServiceApplicationCreated(
-        NftId applicationNftId,
-        NftId productNftId,
-        NftId bundleNftId, 
+        NftId indexed applicationNftId,
+        NftId indexed productNftId,
+        NftId indexed bundleNftId, 
         RiskId riskId,
         ReferralId referralId,
         address applicationOwner,
         Amount sumInsuredAmount,
         Amount premiumAmount,
         Seconds lifetime);
-    event LogApplicationServiceApplicationRenewed(NftId policyNftId, NftId bundleNftId);
+    event LogApplicationServiceApplicationRenewed(NftId indexed policyNftId, NftId indexed bundleNftId);
     event LogApplicationServiceApplicationAdjusted(
-        NftId applicationNftId, 
-        NftId bundleNftId, 
-        RiskId riskId, 
+        NftId indexed applicationNftId, 
+        NftId indexed bundleNftId, 
+        RiskId indexed riskId, 
         ReferralId referralId, 
         Amount sumInsuredAmount, 
         Seconds lifetime);
-    event LogApplicationServiceApplicationRevoked(NftId applicationNftId);
+    event LogApplicationServiceApplicationRevoked(NftId indexed applicationNftId);
 
     // _checkLinkedApplicationParameters
     error ErrorApplicationServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);

package/contracts/product/IClaimService.sol

@@ -19,15 +19,15 @@ import {Fee} from "../type/Fee.sol";
 interface IClaimService is
     IService
 {
-    event LogClaimServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
-    event LogClaimServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
-    event LogClaimServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
-    event LogClaimServiceClaimRevoked(NftId policyNftId, ClaimId claimId);
-    event LogClaimServiceClaimCancelled(NftId policyNftId, ClaimId claimId);
-
-    event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary);
-    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount);
-    event LogClaimServicePayoutCancelled(NftId policyNftId, PayoutId payoutId);
+    event LogClaimServiceClaimSubmitted(NftId indexed policyNftId, ClaimId indexed claimId, Amount claimAmount);
+    event LogClaimServiceClaimConfirmed(NftId indexed policyNftId, ClaimId indexed claimId, Amount confirmedAmount);
+    event LogClaimServiceClaimDeclined(NftId indexed policyNftId, ClaimId indexed claimId);
+    event LogClaimServiceClaimRevoked(NftId indexed policyNftId, ClaimId indexed claimId);
+    event LogClaimServiceClaimCancelled(NftId indexed policyNftId, ClaimId indexed claimId);
+
+    event LogClaimServicePayoutCreated(NftId indexed policyNftId, ClaimId indexed claimId, PayoutId indexed payoutId, Amount amount, address beneficiary);
+    event LogClaimServicePayoutProcessed(NftId indexed policyNftId, PayoutId indexed payoutId, Amount amount);
+    event LogClaimServicePayoutCancelled(NftId indexed policyNftId, PayoutId indexed payoutId);
 
     error ErrorClaimServiceBeneficiarySet(NftId policyNftId, PayoutId payoutId, address beneficiary);
 

package/contracts/product/IPolicyService.sol

@@ -11,13 +11,13 @@ import {Timestamp} from "../type/Timestamp.sol";
 
 interface IPolicyService is IService {
 
-    event LogPolicyServicePolicyCreated(NftId policyNftId, Amount premiumAmount, Timestamp activatedAt);
-    event LogPolicyServicePolicyDeclined(NftId policyNftId);
-    event LogPolicyServicePolicyPremiumCollected(NftId policyNftId, Amount premiumAmount);
-    event LogPolicyServicePolicyActivated(NftId policyNftId, Timestamp activatedAt);
-    event LogPolicyServicePolicyActivatedUpdated(NftId policyNftId, Timestamp activatedAt);
-    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
-    event LogPolicyServicePolicyClosed(NftId policyNftId);
+    event LogPolicyServicePolicyCreated(NftId indexed policyNftId, Amount premiumAmount, Timestamp activatedAt);
+    event LogPolicyServicePolicyDeclined(NftId indexed policyNftId);
+    event LogPolicyServicePolicyPremiumCollected(NftId indexed policyNftId, NftId indexed productNftId, Amount premiumAmount, Timestamp activateAt);
+    event LogPolicyServicePolicyActivated(NftId indexed policyNftId, Timestamp activatedAt);
+    event LogPolicyServicePolicyActivatedUpdated(NftId indexed policyNftId, Timestamp activatedAt);
+    event LogPolicyServicePolicyExpirationUpdated(NftId indexed policyNftId, Timestamp expiredAt);
+    event LogPolicyServicePolicyClosed(NftId indexed policyNftId);
 
     error LogPolicyServiceMaxPremiumAmountExceeded(NftId policyNftId, Amount maxPremiumAmount, Amount premiumAmount);
     error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);

package/contracts/product/IRiskService.sol

@@ -9,11 +9,10 @@ import {StateId} from "../type/StateId.sol";
 
 interface IRiskService is IService {
 
-    event LogRiskServiceRiskCreated(NftId productNftId, RiskId riskId);
-    event LogRiskServiceRiskUpdated(NftId productNftId, RiskId riskId);
-    event LogRiskServiceRiskLocked(NftId productNftId, RiskId riskId);
-    event LogRiskServiceRiskUnlocked(NftId productNftId, RiskId riskId);
-    event LogRiskServiceRiskClosed(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskCreated(NftId indexed productNftId, RiskId indexed riskId);
+    event LogRiskServiceRiskUpdated(NftId indexed productNftId, RiskId indexed riskId);
+    event LogRiskServiceRiskLocked(NftId indexed productNftId, RiskId indexed riskId, bool indexed locked);
+    event LogRiskServiceRiskClosed(NftId indexed productNftId, RiskId indexed riskId);
     
     error ErrorRiskServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
     error ErrorRiskServiceRiskNotActive(NftId productNftId, RiskId riskId);

package/contracts/product/PolicyService.sol

@@ -247,7 +247,7 @@ contract PolicyService is
         instance.getProductStore().updatePremiumState(policyNftId, PAID());
 
         // log premium collection before interactions with token
-        emit LogPolicyServicePolicyPremiumCollected(policyNftId, premium.premiumAmount);
+        emit LogPolicyServicePolicyPremiumCollected(policyNftId, policyInfo.productNftId, premium.premiumAmount, activateAt);
 
         // interactions
         _transferPremiumAmounts(instanceReader, policyNftId, policyInfo.productNftId, premium);

package/contracts/product/PolicyServiceLib.sol

@@ -95,13 +95,14 @@ library PolicyServiceLib {
     {
         if (policyState != COLLATERALIZED()) { 
             revert IPolicyService.ErrorPolicyServicePolicyNotActive(policyNftId, policyState);
-        } 
-        if (TimestampLib.current() < policyInfo.activatedAt) { 
+        }
+
+        if (policyInfo.activatedAt.eqz() || TimestampLib.current() < policyInfo.activatedAt) { 
             revert IPolicyService.ErrorPolicyServicePolicyNotActive(policyNftId, policyState);
         } 
 
         // check expiredAt represents a valid expiry time
-        if (newExpiredAt >= policyInfo.expiredAt) {
+        if (newExpiredAt > policyInfo.expiredAt) {
             revert IPolicyService.ErrorPolicyServicePolicyExpirationTooLate(policyNftId, policyInfo.expiredAt, newExpiredAt);
         }
 
@@ -110,6 +111,7 @@ library PolicyServiceLib {
         }
     }
 
+
     function policyIsCloseable(InstanceReader instanceReader, NftId policyNftId)
         external 
         view

package/contracts/product/RiskService.sol

@@ -119,10 +119,10 @@ contract RiskService is
 
         if (locked) {
             instance.getRiskSet().deactivate(riskId);
-            emit LogRiskServiceRiskLocked(productNftId, riskId);
+            emit LogRiskServiceRiskLocked(productNftId, riskId, true);
         } else {
             instance.getRiskSet().activate(riskId);
-            emit LogRiskServiceRiskUnlocked(productNftId, riskId);
+            emit LogRiskServiceRiskLocked(productNftId, riskId, false);
         }
     }
 

package/contracts/registry/ChainNft.sol

@@ -4,14 +4,15 @@ pragma solidity ^0.8.20;
 import {ERC721, ERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
 import {ITransferInterceptor} from "./ITransferInterceptor.sol";
 
 contract ChainNft is ERC721Enumerable {
 
-    event LogTokenInterceptorAddress(uint256 tokenId, address interceptor);
+    event LogTokenInterceptorAddress(uint256 indexed tokenId, address indexed interceptor);
 
     // constants
-    string public constant NAME = "Dezentralized Insurance Protocol NFT";
+    string public constant NAME = "Decentralized Insurance Protocol NFT";
     string public constant SYMBOL = "DIPNFT";
 
     uint256 public constant PROTOCOL_NFT_ID = 1101;
@@ -53,7 +54,7 @@ contract ChainNft is ERC721Enumerable {
         // NFT contract is deployed by the registry
         _registry = registry;
 
-        _chainIdDigits = _calculateChainIdDigits(block.chainid);
+        _chainIdDigits = _calculateChainIdDigits(ChainIdLib.toChainId(block.chainid));
         _chainIdMultiplier = 10 ** _chainIdDigits;
 
         // the first object registered through normal registration starts with id 4
@@ -200,12 +201,12 @@ contract ChainNft is ERC721Enumerable {
     * (42 * 10 ** 10 + 9876543210) * 100 + 10
     * (index * 10 ** digits + chainid) * 100 + digits (1 < digits < 100)
     */
-    function calculateTokenId(uint256 idIndex, uint256 chainId) public view returns (uint256 id) {
-        if(chainId == block.chainid) {
-            return 100 * (idIndex * _chainIdMultiplier + chainId) + _chainIdDigits;
+    function calculateTokenId(uint256 idIndex, ChainId chainId) public view returns (uint256 id) {
+        if(chainId.toInt() == block.chainid) {
+            return 100 * (idIndex * _chainIdMultiplier + chainId.toInt()) + _chainIdDigits;
         } else {
             uint256 chainIdDigits = _calculateChainIdDigits(chainId);
-            return 100 * (idIndex * (10 ** chainIdDigits) + chainId) + chainIdDigits;
+            return 100 * (idIndex * (10 ** chainIdDigits) + chainId.toInt()) + chainIdDigits;
         }
     }
 
@@ -224,8 +225,8 @@ contract ChainNft is ERC721Enumerable {
         _idNext++;
     }
 
-    function _calculateChainIdDigits(uint256 chainId) private pure returns (uint256) {
-        uint256 num = chainId;
+    function _calculateChainIdDigits(ChainId chainId) private pure returns (uint256) {
+        uint256 num = chainId.toInt();
         uint256 digits = 0;
         while (num != 0) {
             digits++;

package/contracts/registry/IRegistry.sol

@@ -5,6 +5,7 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 import {IRelease} from "./IRelease.sol";
 
+import {ChainId} from "../type/ChainId.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {VersionPart} from "../type/Version.sol";
@@ -19,9 +20,9 @@ interface IRegistry is
     IERC165
 {
 
-    event LogRegistryObjectRegistered(NftId nftId, NftId parentNftId, ObjectType objectType, bool isInterceptor, address objectAddress, address initialOwner);
-    event LogRegistryServiceRegistered(VersionPart majorVersion, ObjectType domain);
-    event LogRegistryChainRegistryRegistered(NftId nftId, uint256 chainId, address chainRegistryAddress);
+    event LogRegistryObjectRegistered(NftId indexed nftId, NftId indexed parentNftId, ObjectType indexed objectType, bool isInterceptor, address objectAddress, address initialOwner);
+    event LogRegistryServiceRegistered(NftId indexed nftId, VersionPart indexed majorVersion, ObjectType indexed domain);
+    event LogRegistryChainRegistryRegistered(NftId indexed nftId, ChainId indexed chainId, address indexed chainRegistryAddress);
 
     // initialize
     error ErrorRegistryCallerNotDeployer();
@@ -30,11 +31,11 @@ interface IRegistry is
     error ErrorRegistryObjectTypeNotSupported(ObjectType objectType);
 
     // registerRegistry()
-    error ErrorRegistryNotOnMainnet(uint256 chainId);
+    error ErrorRegistryNotOnMainnet(ChainId chainId);
     error ErrorRegistryChainRegistryChainIdZero(NftId nftId);
-    error ErrorRegistryChainRegistryAddressZero(NftId nftId, uint256 chainId);
-    error ErrorRegistryChainRegistryNftIdInvalid(NftId nftId, uint256 chainId);
-    error ErrorRegistryChainRegistryAlreadyRegistered(NftId nftId, uint256 chainId);
+    error ErrorRegistryChainRegistryAddressZero(NftId nftId, ChainId chainId);
+    error ErrorRegistryChainRegistryNftIdInvalid(NftId nftId, ChainId chainId);
+    error ErrorRegistryChainRegistryAlreadyRegistered(NftId nftId, ChainId chainId);
 
     // registerService()
     error ErrorRegistryServiceAddressZero(); 
@@ -71,7 +72,7 @@ interface IRegistry is
     /// Only one chain registry may be registered per chain
     function registerRegistry(
         NftId nftId, 
-        uint256 chainId, 
+        ChainId chainId, 
         address chainRegistryAddress
     ) external;
 
@@ -107,10 +108,10 @@ interface IRegistry is
     function chainIds() external view returns (uint256);
 
     /// @dev Returns the chain id at the specified index.
-    function getChainId(uint256 idx) external view returns (uint256);
+    function getChainId(uint256 idx) external view returns (ChainId);
 
     /// @dev Returns the NFT ID of the registry for the specified chain.
-    function getRegistryNftId(uint256 chainId) external returns (NftId nftId); 
+    function getRegistryNftId(ChainId chainId) external returns (NftId nftId); 
 
     function getObjectCount() external view returns (uint256);
 

package/contracts/registry/Registry.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
@@ -10,13 +9,13 @@ import {NftId, NftIdLib} from "../type/NftId.sol";
 import {VersionPart, VersionPartLib} from "../type/Version.sol";
 import {ObjectType, ObjectTypeLib, PROTOCOL, REGISTRY, SERVICE, INSTANCE, STAKE, STAKING, PRODUCT, DISTRIBUTION, DISTRIBUTOR, ORACLE, POOL, POLICY, BUNDLE} from "../type/ObjectType.sol";
 
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
 import {ChainNft} from "./ChainNft.sol";
 import {IRegistry} from "./IRegistry.sol";
 import {IRelease} from "./IRelease.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IStaking} from "../staking/IStaking.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
-import {TokenRegistry} from "./TokenRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 
 /// @dev IMPORTANT
@@ -65,8 +64,8 @@ contract Registry is
     string public constant EMPTY_URI = "";
 
     /// @dev keep track of different registries on different chains
-    mapping(uint256 chainId => NftId registryNftId) private _registryNftIdByChainId;
-    uint256[] private _chainId;
+    mapping(ChainId chainId => NftId registryNftId) private _registryNftIdByChainId;
+    ChainId[] private _chainId;
 
     /// @dev keep track of object info and address reverse lookup
     mapping(NftId nftId => ObjectInfo info) private _info;
@@ -145,7 +144,7 @@ contract Registry is
     /// @inheritdoc IRegistry
     function registerRegistry(
         NftId nftId,
-        uint256 chainId, 
+        ChainId chainId, 
         address registryAddress
     )
         external
@@ -153,11 +152,11 @@ contract Registry is
     {
         // registration of chain registries only allowed on mainnet
         if (block.chainid != 1) {
-            revert ErrorRegistryNotOnMainnet(block.chainid);
+            revert ErrorRegistryNotOnMainnet(ChainIdLib.toChainId(block.chainid));
         }
 
         // registry chain id is not zero
-        if(chainId == 0) {
+        if(chainId.eqz()) {
             revert ErrorRegistryChainRegistryChainIdZero(nftId);
         }
 
@@ -231,7 +230,7 @@ contract Registry is
 
         _service[version][domain] = service;
 
-        emit LogRegistryServiceRegistered(version, domain);
+        emit LogRegistryServiceRegistered(info.nftId,version, domain);
 
         nftId = _register(info);
     }
@@ -322,11 +321,11 @@ contract Registry is
         return _chainId.length;
     }
 
-    function getChainId(uint256 idx) public view returns (uint256) {
+    function getChainId(uint256 idx) public view returns (ChainId) {
         return _chainId[idx];
     }
 
-    function getRegistryNftId(uint256 chainId) public view returns (NftId nftId) {
+    function getRegistryNftId(ChainId chainId) public view returns (NftId nftId) {
         return _registryNftIdByChainId[chainId];
     }
 
@@ -566,6 +565,8 @@ contract Registry is
                 initialOwner: NFT_LOCK_ADDRESS,
                 data: ""}),
             true);
+
+        emit LogRegistryObjectRegistered(protocolNftId, NftIdLib.zero(), PROTOCOL(), false, address(0), NFT_LOCK_ADDRESS);
     }
 
     /// @dev register this registry
@@ -579,7 +580,7 @@ contract Registry is
 
         // register global registry
         _registerRegistryForNft(
-            1, // mainnet chain id
+            ChainIdLib.toChainId(1), // mainnet chain id
             ObjectInfo({
                 nftId: GLOBAL_REGISTRY_NFT_ID,
                 parentNftId: PROTOCOL_NFT_ID,
@@ -598,7 +599,7 @@ contract Registry is
                 CHAIN_NFT.calculateTokenId(REGISTRY_TOKEN_SEQUENCE_ID));
 
             _registerRegistryForNft(
-                block.chainid, 
+                ChainIdLib.toChainId(block.chainid), 
                 ObjectInfo({
                     nftId: registryNftId,
                     parentNftId: GLOBAL_REGISTRY_NFT_ID,
@@ -613,7 +614,7 @@ contract Registry is
 
     /// @dev staking registration
     function _registerRegistryForNft(
-        uint256 chainId,
+        ChainId chainId,
         ObjectInfo memory info,
         bool updateAddressLookup
     )
@@ -671,6 +672,8 @@ contract Registry is
 
         // calls nft receiver
         CHAIN_NFT.mint(info.initialOwner, info.nftId.toInt());
+
+        emit LogRegistryObjectRegistered(info.nftId, info.parentNftId, info.objectType, info.isInterceptor, info.objectAddress, info.initialOwner);
     }
 
     function _setAddressForNftId(NftId nftId, address objectAddress)

package/contracts/registry/RegistryAdmin.sol

@@ -85,7 +85,13 @@ contract RegistryAdmin is
                 registry, 
                 release); 
 
-        _checkAuthorization(authorization, REGISTRY(), release, false, true);
+        AccessAdminLib.checkAuthorization(
+            address(_authorization),
+            authorization, 
+            REGISTRY(), 
+            release, 
+            false, // expectServiceAuthorization
+            false); // checkAlreadyInitialized);
 
         _registry = registry;
         _authorization = IAuthorization(authorization);

package/contracts/registry/RegistryAuthorization.sol

@@ -144,8 +144,6 @@ contract RegistryAuthorization
           _setupStakingThAuthorization();
      }
 
-     event LogAccessAdminDebug(string message, string custom, uint256 value);
-
      function _setupRegistryAuthorization() internal {
           IAccess.FunctionInfo[] storage functions;
 

package/contracts/registry/ReleaseAdmin.sol

@@ -21,8 +21,8 @@ import {VersionPart} from "../type/Version.sol";
 contract ReleaseAdmin is
     AccessAdmin
 {
-    event LogReleaseAdminReleaseLockChanged(VersionPart release, bool locked);
-    event LogReleaseAdminServiceLockChanged(VersionPart release, address service, bool locked);
+    event LogReleaseAdminReleaseLocked(VersionPart indexed release, bool indexed locked);
+    event LogReleaseAdminServiceLocked(VersionPart indexed release, address indexed service, bool indexed locked);
 
     error ErrorReleaseAdminCallerNotReleaseRegistry(address caller);
     error ErrorReleaseAdminNotService(address notService);
@@ -72,7 +72,14 @@ contract ReleaseAdmin is
                 release);
 
         IServiceAuthorization serviceAuthorization = IServiceAuthorization(authorization);
-        _checkAuthorization(address(serviceAuthorization), RELEASE(), release, true, true);
+        AccessAdminLib.checkAuthorization(
+            address(_authorization),
+            address(serviceAuthorization), 
+            RELEASE(), 
+            release, 
+            true, // expectServiceAuthorization
+            true); // checkAlreadyInitialized);
+
         _serviceAuthorization = serviceAuthorization;
 
         // link nft ownability to registry
@@ -130,7 +137,7 @@ contract ReleaseAdmin is
         // effects
         accessManager.setLocked(locked);
 
-        emit LogReleaseAdminReleaseLockChanged(getRelease(), locked);
+        emit LogReleaseAdminReleaseLocked(getRelease(), locked);
     }
 
 
@@ -148,7 +155,7 @@ contract ReleaseAdmin is
 
         _setTargetLocked(address(service), locked);
 
-        emit LogReleaseAdminServiceLockChanged(service.getRelease(), address(service), locked);
+        emit LogReleaseAdminServiceLocked(service.getRelease(), address(service), locked);
     }
 
     //--- private functions -------------------------------------------------//

package/contracts/registry/ReleaseRegistry.sol

@@ -38,10 +38,9 @@ contract ReleaseRegistry is
 {
     uint256 public constant INITIAL_GIF_VERSION = 3;// first active release version  
 
-    event LogReleaseCreation(IAccessAdmin admin, VersionPart release, bytes32 salt); 
-    event LogReleaseActivation(VersionPart release);
-    event LogReleaseDisabled(VersionPart release);
-    event LogReleaseEnabled(VersionPart release);
+    event LogReleaseCreated(address indexed releaseAdmin, VersionPart indexed release, bytes32 indexed salt); 
+    event LogReleaseActivated(VersionPart indexed release);
+    event LogReleaseEnabled(VersionPart indexed release, bool indexed active);
 
     // constructor
     error ErrorReleaseRegistryNotRegistry(Registry registry);
@@ -168,7 +167,7 @@ contract ReleaseRegistry is
         _releaseInfo[releaseVersion].auth = serviceAuthorization;
         _releaseInfo[releaseVersion].releaseAdmin = address(releaseAdmin);
 
-        emit LogReleaseCreation(releaseAdmin, releaseVersion, releaseSalt);
+        emit LogReleaseCreated(address(releaseAdmin), releaseVersion, releaseSalt);
     }
 
     function registerService(IService service) 
@@ -270,7 +269,7 @@ contract ReleaseRegistry is
 
         _setReleaseLocked(release, false);
 
-        emit LogReleaseActivation(release);
+        emit LogReleaseActivated(release);
     }
 
     /// @dev stop/resume operations with restricted functions
@@ -284,12 +283,12 @@ contract ReleaseRegistry is
             checkTransition(state, RELEASE(), PAUSED(), ACTIVE());
             _releaseInfo[release].state = ACTIVE();
             _releaseInfo[release].disabledAt = TimestampLib.max();
-            emit LogReleaseEnabled(release);
+            emit LogReleaseEnabled(release, true);
         } else {
             checkTransition(state, RELEASE(), ACTIVE(), PAUSED());
             _releaseInfo[release].state = PAUSED();
             _releaseInfo[release].disabledAt = TimestampLib.current();
-            emit LogReleaseDisabled(release);
+            emit LogReleaseEnabled(release, false);
         }
 
         _setReleaseLocked(release, !active);

package/contracts/registry/TokenRegistry.sol

@@ -18,9 +18,9 @@ contract TokenRegistry is
     AccessManaged,
     IRegistryLinked
 {
-    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);
+    event LogTokenRegistryTokenRegistered(ChainId indexed chainId, address indexed token, uint256 decimals, string symbol);
+    event LogTokenRegistryTokenGlobalStateSet(ChainId indexed chainId, address indexed token, bool indexed active);
+    event LogTokenRegistryTokenStateSet(ChainId indexed chainId, address indexed token, VersionPart indexed release, bool active);
 
     error ErrorTokenRegistryChainIdZero();
     error ErrorTokenRegistryTokenAddressZero();