@etherisc/gif-next 3.0.0-db9f1f4-232 → 3.0.0-dcde6c5-549

package/contracts/oracle/OracleService.sol

@@ -2,16 +2,14 @@
 pragma solidity ^0.8.20;
 
 import {ContractLib} from "../shared/ContractLib.sol";
-import {IComponent} from "../shared/IComponent.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IOracle} from "./IOracle.sol";
 import {IOracleComponent} from "./IOracleComponent.sol";
 import {IOracleService} from "./IOracleService.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, ORACLE, PRODUCT} from "../type/ObjectType.sol";
+import {ObjectType, ORACLE, PRODUCT} from "../type/ObjectType.sol";
 import {RequestId} from "../type/RequestId.sol";
 import {Service} from "../shared/Service.sol";
 import {StateId, ACTIVE, KEEP_STATE, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
@@ -56,7 +54,7 @@ contract OracleService is
         // get and check active caller
         (
             IRegistry.ObjectInfo memory requesterInfo, 
-            address instance
+            address instanceAddress
         ) = ContractLib.getAndVerifyAnyComponent(
             getRegistry(), msg.sender, true);
 
@@ -69,7 +67,7 @@ contract OracleService is
         // effects
         {
             // create request info
-            IOracle.RequestInfo memory request = IOracle.RequestInfo({
+            IOracle.RequestInfo memory requestInfo = IOracle.RequestInfo({
                 requesterNftId: requesterNftId,
                 callbackMethodName: callbackMethodName,
                 oracleNftId: oracleNftId,
@@ -80,8 +78,9 @@ contract OracleService is
                 isCancelled: false
             });
 
-            // store request with instance
-            requestId = IInstance(instance).getInstanceStore().createRequest(request);
+            // store request with instance 
+            requestId = IInstance(instanceAddress).getInstanceStore().createRequest(requestInfo);
+            IInstance(instanceAddress).getRequestSet().add(oracleNftId, requestId);
         }
 
         emit LogOracleServiceRequestCreated(requestId, requesterNftId, oracleNftId, expiryAt);
@@ -116,22 +115,23 @@ contract OracleService is
         NftId oracleNftId = info.nftId;
         IInstance instance = IInstance(instanceAddress);
         bool callerIsOracle = true;
-        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
-        request.responseData = responseData;
-        request.respondedAt = TimestampLib.current();
+        IOracle.RequestInfo memory requestInfo = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
+        requestInfo.responseData = responseData;
+        requestInfo.respondedAt = TimestampLib.current();
 
         instance.getInstanceStore().updateRequest(
-            requestId, request, KEEP_STATE());
+            requestId, requestInfo, KEEP_STATE());
 
         IRegistry.ObjectInfo memory requesterInfo = getRegistry().getObjectInfo(
-            request.requesterNftId);
+            requestInfo.requesterNftId);
 
         string memory functionSignature = string(
             abi.encodePacked(
-                request.callbackMethodName,
+                requestInfo.callbackMethodName,
                 "(uint64,bytes)"
             ));
 
+        // solhint-disable-next-line avoid-low-level-calls
         (success, ) = requesterInfo.objectAddress.call(
             abi.encodeWithSignature(
                 functionSignature, 
@@ -141,12 +141,13 @@ contract OracleService is
         // check that calling requestor was successful
         if (success) {
             instance.getInstanceStore().updateRequestState(requestId, FULFILLED());
+            instance.getRequestSet().remove(oracleNftId, requestId);
         } else {
             instance.getInstanceStore().updateRequestState(requestId, FAILED());
             emit LogOracleServiceDeliveryFailed(requestId, requesterInfo.objectAddress, functionSignature);
         }
 
-        emit LogOracleServiceResponseProcessed(requestId, oracleNftId);
+        emit LogOracleServiceResponseProcessed(requestId, requesterInfo.nftId, oracleNftId);
     }
 
 
@@ -164,24 +165,26 @@ contract OracleService is
         NftId requesterNftId = info.nftId;
         IInstance instance = IInstance(instanceAddress);
         bool callerIsOracle = false;
-        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
+        IOracle.RequestInfo memory requestInfo = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
 
         // attempt to deliver response to requester
         string memory functionSignature = string(
             abi.encodePacked(
-                request.callbackMethodName,
+                requestInfo.callbackMethodName,
                 "(uint64,bytes)"
             ));
 
-        (bool success, bytes memory returnData) = info.objectAddress.call(
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, ) = info.objectAddress.call(
             abi.encodeWithSignature(
                 functionSignature, 
                 requestId,
-                request.responseData));
+                requestInfo.responseData));
 
         // check that calling requestor was successful
         if (success) {
             instance.getInstanceStore().updateRequestState(requestId, FULFILLED());
+            instance.getRequestSet().remove(requestInfo.oracleNftId, requestId);
             emit LogOracleServiceResponseResent(requestId, requesterNftId);
         } else {
             emit LogOracleServiceDeliveryFailed(requestId, info.objectAddress, functionSignature);
@@ -204,20 +207,20 @@ contract OracleService is
         IInstance instance = IInstance(instanceAddress);
         bool callerIsOracle = false;
         // TODO property isCancelled and state update to CANCELLED are redundant, get rid of isCancelled
-        IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
-        request.isCancelled = true;
+        IOracle.RequestInfo memory requestInfo = _checkAndGetRequestInfo(instance, requestId, requesterNftId, callerIsOracle);
+        requestInfo.isCancelled = true;
 
-        instance.getInstanceStore().updateRequest(requestId, request, CANCELLED());
+        instance.getInstanceStore().updateRequest(requestId, requestInfo, CANCELLED());
+        instance.getRequestSet().remove(requestInfo.oracleNftId, requestId);
 
         // call oracle component
         // TODO add check that oracle is active?
-        address oracleAddress = getRegistry().getObjectAddress(request.oracleNftId);
+        address oracleAddress = getRegistry().getObjectAddress(requestInfo.oracleNftId);
         IOracleComponent(oracleAddress).cancel(requestId);
 
         emit LogOracleServiceRequestCancelled(requestId, requesterNftId);
     }
 
-
     function _checkRequestParams(
         IRegistry registry,
         NftId oracleNftId,

package/contracts/pool/BundleService.sol

@@ -201,10 +201,10 @@ contract BundleService is
 
         if (locked) {
             bundleManager.lock(bundleNftId);
-            emit LogBundleServiceBundleLocked(bundleNftId);
+            emit LogBundleServiceBundleLocked(bundleNftId, true);
         } else {
             bundleManager.unlock(bundleNftId);
-            emit LogBundleServiceBundleUnlocked(bundleNftId);
+            emit LogBundleServiceBundleLocked(bundleNftId, false);
         }
     }
     

package/contracts/pool/IBundleService.sol

@@ -30,16 +30,15 @@ interface IBundleService is IService {
 
     error ErrorBundleServiceExtensionLifetimeIsZero();
 
-    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId, Seconds lifetime, Amount fixedFee, UFixed fractionalFee);
-    event LogBundleServiceBundleClosed(NftId bundleNftId);
-    event LogBundleServiceBundleLocked(NftId bundleNftId);
-    event LogBundleServiceBundleUnlocked(NftId bundleNftId);
-    event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
-    event LogBundleServiceBundleFeeUpdated(NftId bundleNftId, Amount fixedFee, UFixed fractionalFee);
-    event LogBundleServiceCollateralLocked(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
-    event LogBundleServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
-    event LogBundleServiceBundleStaked(NftId bundleNftId, Amount amount);
-    event LogBundleServiceBundleUnstaked(NftId bundleNftId, Amount amount);
+    event LogBundleServiceBundleCreated(NftId indexed bundleNftId, NftId indexed poolNftId, Seconds lifetime, Amount fixedFee, UFixed fractionalFee);
+    event LogBundleServiceBundleClosed(NftId indexed bundleNftId);
+    event LogBundleServiceBundleLocked(NftId indexed bundleNftId, bool indexed locked);
+    event LogBundleServiceBundleExtended(NftId indexed bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
+    event LogBundleServiceBundleFeeUpdated(NftId indexed bundleNftId, Amount fixedFee, UFixed fractionalFee);
+    event LogBundleServiceCollateralLocked(NftId indexed bundleNftId, NftId indexed policyNftId, Amount collateralAmount);
+    event LogBundleServiceCollateralReleased(NftId indexed bundleNftId, NftId indexed policyNftId, Amount collateralAmount);
+    event LogBundleServiceBundleStaked(NftId indexed bundleNftId, Amount amount);
+    event LogBundleServiceBundleUnstaked(NftId indexed bundleNftId, Amount amount);
 
     /// @dev Create a new bundle for the specified attributes.
     function create(

package/contracts/pool/IPoolComponent.sol

@@ -19,7 +19,7 @@ interface IPoolComponent is IInstanceLinkedComponent {
     error ErrorPoolNotPoolService(address caller);
     error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
-    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, Amount collateralizationAmount);
+    event LogPoolVerifiedByPool(address indexed pool, NftId indexed applicationNftId, Amount collateralizationAmount);
 
     /// @dev This is a callback function that is called by the product service when underwriting a policy.
     /// The pool has the option to check the details and object to underwriting by reverting.

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, Amount balanceAmount, Amount feeAmount);
+    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

@@ -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, NftId productNftId, Amount premiumAmount, Timestamp activateAt);
-    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/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,11 +4,12 @@ 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 = "Decentralized Insurance Protocol NFT";
@@ -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(NftId nftId, 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);
         }
 
@@ -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/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);
@@ -137,7 +137,7 @@ contract ReleaseAdmin is
         // effects
         accessManager.setLocked(locked);
 
-        emit LogReleaseAdminReleaseLockChanged(getRelease(), locked);
+        emit LogReleaseAdminReleaseLocked(getRelease(), locked);
     }
 
 
@@ -155,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 -------------------------------------------------//