@etherisc/gif-next 3.0.0-7dfcc88-359 → 3.0.0-809b911-939

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, request.requesterNftId, 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 indexed bundleNftId, NftId indexed poolNftId, Seconds indexed lifetime, Amount fixedFee, UFixed fractionalFee);
+    event LogBundleServiceBundleCreated(NftId indexed bundleNftId, NftId indexed poolNftId, Seconds lifetime, Amount fixedFee, UFixed fractionalFee);
     event LogBundleServiceBundleClosed(NftId indexed bundleNftId);
-    event LogBundleServiceBundleLocked(NftId indexed bundleNftId);
-    event LogBundleServiceBundleUnlocked(NftId indexed bundleNftId);
-    event LogBundleServiceBundleExtended(NftId indexed bundleNftId, Seconds indexed lifetimeExtension, Timestamp indexed extendedExpiredAt);
-    event LogBundleServiceBundleFeeUpdated(NftId indexed bundleNftId, Amount indexed fixedFee, UFixed indexed fractionalFee);
-    event LogBundleServiceCollateralLocked(NftId indexed bundleNftId, NftId indexed policyNftId, Amount indexed collateralAmount);
-    event LogBundleServiceCollateralReleased(NftId indexed bundleNftId, NftId indexed policyNftId, Amount indexed collateralAmount);
-    event LogBundleServiceBundleStaked(NftId indexed bundleNftId, Amount indexed amount);
-    event LogBundleServiceBundleUnstaked(NftId indexed bundleNftId, Amount indexed amount);
+    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 indexed pool, NftId indexed applicationNftId, Amount indexed 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,9 +14,9 @@ import {PayoutId} from "../type/PayoutId.sol";
 
 interface IPoolService is IService {
 
-    event LogPoolServiceMaxBalanceAmountUpdated(NftId indexed poolNftId, Amount indexed previousMaxCapitalAmount, Amount indexed currentMaxCapitalAmount);
-    event LogPoolServiceWalletFunded(NftId indexed poolNftId, address indexed poolOwner, Amount indexed amount);
-    event LogPoolServiceWalletDefunded(NftId indexed poolNftId, address indexed poolOwner, Amount indexed 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 indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId);
     event LogPoolServiceBundleClosed(NftId indexed instanceNftId, NftId indexed poolNftId, NftId indexed bundleNftId, Amount balanceAmount, Amount feeAmount);
@@ -24,14 +24,14 @@ interface IPoolService is IService {
     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 indexed bundleNftId, address indexed recipient, Amount indexed amount, address tokenAddress);
+    event LogPoolServiceFeesWithdrawn(NftId indexed bundleNftId, address indexed recipient, Amount amount, address indexed tokenAddress);
 
-    event LogPoolServiceProcessFundedClaim(NftId indexed policyNftId, ClaimId indexed claimId, Amount indexed availableAmount);
+    event LogPoolServiceProcessFundedClaim(NftId indexed policyNftId, ClaimId indexed claimId, Amount availableAmount);
 
     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 indexed releasedCollateralAmount);
-    event LogPoolServiceSaleProcessed(NftId indexed poolNftId, NftId indexed bundleNftId, Amount indexed bundleNetAmount, Amount bundleFeeAmount, Amount poolFeeAmount);
+    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);

package/contracts/product/IClaimService.sol

@@ -19,14 +19,14 @@ import {Fee} from "../type/Fee.sol";
 interface IClaimService is
     IService
 {
-    event LogClaimServiceClaimSubmitted(NftId indexed policyNftId, ClaimId indexed claimId, Amount indexed claimAmount);
-    event LogClaimServiceClaimConfirmed(NftId indexed policyNftId, ClaimId indexed claimId, Amount indexed confirmedAmount);
+    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 indexed amount);
+    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,12 +11,12 @@ import {Timestamp} from "../type/Timestamp.sol";
 
 interface IPolicyService is IService {
 
-    event LogPolicyServicePolicyCreated(NftId indexed policyNftId, Amount indexed premiumAmount, Timestamp indexed activatedAt);
+    event LogPolicyServicePolicyCreated(NftId indexed policyNftId, Amount premiumAmount, Timestamp activatedAt);
     event LogPolicyServicePolicyDeclined(NftId indexed policyNftId);
-    event LogPolicyServicePolicyPremiumCollected(NftId indexed policyNftId, NftId indexed productNftId, Amount indexed premiumAmount, Timestamp activateAt);
-    event LogPolicyServicePolicyActivated(NftId indexed policyNftId, Timestamp indexed activatedAt);
-    event LogPolicyServicePolicyActivatedUpdated(NftId indexed policyNftId, Timestamp indexed activatedAt);
-    event LogPolicyServicePolicyExpirationUpdated(NftId indexed policyNftId, Timestamp indexed expiredAt);
+    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);

package/contracts/product/IRiskService.sol

@@ -11,8 +11,7 @@ interface IRiskService is IService {
 
     event LogRiskServiceRiskCreated(NftId indexed productNftId, RiskId indexed riskId);
     event LogRiskServiceRiskUpdated(NftId indexed productNftId, RiskId indexed riskId);
-    event LogRiskServiceRiskLocked(NftId indexed productNftId, RiskId indexed riskId);
-    event LogRiskServiceRiskUnlocked(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);

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/ReleaseRegistry.sol

@@ -38,10 +38,9 @@ contract ReleaseRegistry is
 {
     uint256 public constant INITIAL_GIF_VERSION = 3;// first active release version  
 
-    event LogReleaseCreated(IAccessAdmin indexed admin, VersionPart indexed release, bytes32 indexed salt); 
+    event LogReleaseCreated(address indexed releaseAdmin, VersionPart indexed release, bytes32 indexed salt); 
     event LogReleaseActivated(VersionPart indexed release);
-    event LogReleaseDisabled(VersionPart indexed release);
-    event LogReleaseEnabled(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 LogReleaseCreated(releaseAdmin, releaseVersion, releaseSalt);
+        emit LogReleaseCreated(address(releaseAdmin), releaseVersion, releaseSalt);
     }
 
     function registerService(IService service) 
@@ -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,7 +18,7 @@ contract TokenRegistry is
     AccessManaged,
     IRegistryLinked
 {
-    event LogTokenRegistryTokenRegistered(ChainId indexed chainId, address indexed token, uint256 indexed decimals, string symbol);
+    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);
 

package/contracts/shared/IComponentService.sol

@@ -48,7 +48,7 @@ interface IComponentService is
     event LogComponentServiceComponentLocked(address indexed component, bool indexed locked);
     event LogComponentServiceTokenHandlerDeployed(NftId indexed componentNftId, address indexed tokenHandler, address indexed token);
     event LogComponentServiceRegistered(NftId indexed instanceNftId, NftId indexed componentNftId, ObjectType indexed componentType, address component, address token, address initialOwner); 
-    event LogComponentServiceComponentFeesWithdrawn(NftId indexed componentNftId, address indexed recipient, Amount indexed withdrawnAmount, address token);
+    event LogComponentServiceComponentFeesWithdrawn(NftId indexed componentNftId, address indexed recipient, Amount withdrawnAmount, address indexed token);
     event LogComponentServiceProductFeesUpdated(NftId indexed productNftId);
     event LogComponentServiceDistributionFeesUpdated(NftId indexed distributionNftId);
     event LogComponentServicePoolFeesUpdated(NftId indexed poolNftId);
@@ -57,22 +57,22 @@ interface IComponentService is
         string feeName, 
         UFixed previousFractionalFee, 
         Amount previousFixedFee,
-        UFixed indexed newFractionalFee, 
-        Amount indexed newFixedFee
+        UFixed newFractionalFee, 
+        Amount newFixedFee
     );
     event LogComponentServiceProductCreated(
         NftId indexed productNftId, address indexed productAddress, bool indexed hasDistribution, uint8 expectedNumberOfOracles);
     event LogComponentServiceProductInitialProductFeesSet(
         NftId indexed productNftId, 
-        Amount indexed productFeeFixed, UFixed indexed productFeeFractional,
+        Amount productFeeFixed, UFixed productFeeFractional,
         Amount processingFeeFixed, UFixed processingFeeFractional);
     event LogComponentServiceProductInitialDistributionFeesSet(
         NftId indexed productNftId, 
-        Amount indexed distributionFeeFixed, UFixed indexed distributionFeeFractional,
+        Amount distributionFeeFixed, UFixed distributionFeeFractional,
         Amount minDistributionOwnerFeeFixed, UFixed minDistributionOwnerFeeFractional);
     event LogComponentServiceProductInitialPoolFeesSet(
         NftId indexed productNftId, 
-        Amount indexed poolFeeFixed, UFixed indexed poolFeeFractional,
+        Amount poolFeeFixed, UFixed poolFeeFractional,
         Amount stakingFeeFixed, UFixed stakingFeeFractional,
         Amount performanceFeeFixed, UFixed performanceFeeFractional);
     event LogComponentServicePoolCreated(

package/contracts/shared/INftOwnable.sol

@@ -11,7 +11,7 @@ interface INftOwnable is
     IERC165,
     IRegistryLinked
 {
-    event LogNftOwnableNftLinkedToAddress(NftId nftId, address owner);
+    event LogNftOwnableNftLinkedToAddress(NftId indexed nftId, address indexed owner);
     
     error ErrorNftOwnableInitialOwnerZero();
     error ErrorNftOwnableNotOwner(address account);

package/contracts/shared/InstanceLinkedComponent.sol

@@ -92,7 +92,7 @@ abstract contract InstanceLinkedComponent is
     }
 
 
-    function _resendRequest(RequestId requestId)
+    function _resendResponse(RequestId requestId)
         internal
         virtual
     {

package/contracts/shared/TokenHandler.sol

@@ -19,14 +19,14 @@ import {SERVICE} from "../type/ObjectType.sol";
 contract TokenHandlerBase {
 
     // _setWallet
-    event LogTokenHandlerWalletAddressChanged(NftId componentNftId, address oldWallet, address newWallet);
-    event LogTokenHandlerWalletTokensTransferred(NftId componentNftId, address oldWallet, address newWallet, Amount amount);
+    event LogTokenHandlerWalletAddressChanged(NftId indexed componentNftId, address indexed oldWallet, address indexed newWallet);
+    event LogTokenHandlerWalletTokensTransferred(NftId indexed componentNftId, address indexed oldWallet, address indexed newWallet, Amount amount);
 
     // _approveTokenHandler
-    event LogTokenHandlerTokenApproved(NftId nftId, address tokenHandler, address token, Amount amount, bool isMaxAmount);
+    event LogTokenHandlerTokenApproved(NftId indexed nftId, address indexed tokenHandler, address indexed token, Amount amount, bool isMaxAmount);
 
     // _transfer
-    event LogTokenHandlerTokenTransfer(address token, address from, address to, Amount amount);
+    event LogTokenHandlerTokenTransferred(address indexed token, address indexed from, address indexed to, Amount amount);
 
     // constructor
     error ErrorTokenHandlerNotRegistry(address registry);
@@ -204,7 +204,7 @@ contract TokenHandlerBase {
         }
 
         // transfer the tokens
-        emit LogTokenHandlerTokenTransfer(address(TOKEN), from, to, amount);
+        emit LogTokenHandlerTokenTransferred(address(TOKEN), from, to, amount);
 
         SafeERC20.safeTransferFrom(
             TOKEN, 

package/contracts/staking/IStaking.sol

@@ -25,28 +25,28 @@ interface IStaking is
     IVersionable
 {
 
-    event LogStakingTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
+    event LogStakingTokenHandlerDeployed(NftId indexed componentNftId, address indexed tokenHandler, address indexed token);
     
     // owner functions
-    event LogStakingStakingRateSet(ChainId chainId, address token, UFixed newStakingRate, UFixed oldStakingRate, Blocknumber lastUpdateIn);
-    event LogStakingStakingServiceSet(address stakingService, VersionPart release, address oldStakingService);
-    event LogStakingStakingReaderSet(address stakingReader, address oldStakingReader);
-    event LogStakingTargetHandlerSet(address targetManager, address oldTargetHandler);
-    event LogStakingTokenHandlerApproved(address token, Amount approvalAmount, Amount oldApprovalAmount);
+    event LogStakingStakingRateSet(ChainId indexed chainId, address indexed token, UFixed oldStakingRate, UFixed newStakingRate, Blocknumber lastUpdateIn);
+    event LogStakingStakingServiceSet(address indexed oldStakingService, address indexed  stakingService, VersionPart indexed release);
+    event LogStakingStakingReaderSet(address indexed oldStakingReader, address indexed stakingReader);
+    event LogStakingTargetHandlerSet(address indexed oldTargetHandler, address indexed targetManager);
+    event LogStakingTokenHandlerApproved(Amount oldApprovalAmount, Amount approvalAmount, address indexed token);
 
     // token
-    event LogStakingTokenAdded(ChainId chainId, address token);
-    event LogStakingTargetTokenAdded(NftId targetNftId, ChainId chainId, address token);
+    event LogStakingTokenAdded(ChainId indexed chainId, address indexed token);
+    event LogStakingTargetTokenAdded(NftId indexed targetNftId, address indexed token);
 
     // total value locked
-    event LogStakingTvlIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
-    event LogStakingTvlDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
+    event LogStakingTvlIncreased(NftId indexed targetNftId, address indexed token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
+    event LogStakingTvlDecreased(NftId indexed targetNftId, address indexed token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
 
     // targets
     event LogStakingSupportInfoSet(
-        ObjectType objectType,
-        bool isSupported,
-        bool allowNewTargets,
+        ObjectType indexed objectType,
+        bool indexed isSupported,
+        bool indexed allowNewTargets,
         bool allowCrossChain,
         Amount minStakingAmount,
         Amount maxStakingAmount,
@@ -56,31 +56,31 @@ interface IStaking is
         UFixed maxRewardRate,
         Blocknumber lastUpdateIn);
 
-    event LogStakingTargetCreated(NftId targetNftId, ObjectType objectType, Seconds lockingPeriod, UFixed rewardRate);
-    event LogStakingLimitsSet(NftId targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
-    event LogStakingTargetLimitsUpdated(NftId targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
-    event LogStakingTargetLimitUpdated(NftId targetNftId, Amount limitAmount, Amount hardLimitAmount, Amount requiredStakeAmount, Amount actualStakeAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetCreated(NftId indexed targetNftId, ObjectType indexed objectType, Seconds lockingPeriod, UFixed rewardRate);
+    event LogStakingLimitsSet(NftId indexed targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetLimitsUpdated(NftId indexed targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetLimitUpdated(NftId indexed targetNftId, Amount limitAmount, Amount hardLimitAmount, Amount requiredStakeAmount, Amount actualStakeAmount, Blocknumber lastUpdateIn);
 
     // target parameters
-    event LogStakingTargetLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod, Blocknumber lastUpdateIn);
-    event LogStakingTargetRewardRateSet(NftId targetNftId, UFixed rewardRate, UFixed oldRewardRate, Blocknumber lastUpdateIn);
-    event LogStakingTargetMaxStakedAmountSet(NftId targetNftId, Amount stakeLimitAmount, Blocknumber lastUpdateIn);
-    event LogStakingTargetLimitsSet(NftId targetNftId, Amount stakeLimitAmount, Amount marginAmount, Amount limitAmount);
+    event LogStakingTargetLockingPeriodSet(NftId indexed targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod, Blocknumber lastUpdateIn);
+    event LogStakingTargetRewardRateSet(NftId indexed targetNftId, UFixed oldRewardRate, UFixed rewardRate, Blocknumber lastUpdateIn);
+    event LogStakingTargetMaxStakedAmountSet(NftId indexed targetNftId, Amount stakeLimitAmount, Blocknumber indexed lastUpdateIn);
+    event LogStakingTargetLimitsSet(NftId indexed targetNftId, Amount stakeLimitAmount, Amount marginAmount, Amount limitAmount);
 
     // reward reserves
-    event LogStakingRewardReservesRefilled(NftId targetNftId, Amount dipAmount, address targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
-    event LogStakingRewardReservesWithdrawn(NftId targetNftId, Amount dipAmount, address targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
-    event LogStakingRewardReservesSpent(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdateIn);
+    event LogStakingRewardReservesRefilled(NftId indexed targetNftId, Amount dipAmount, address indexed targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
+    event LogStakingRewardReservesWithdrawn(NftId indexed targetNftId, Amount dipAmount, address indexed targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
+    event LogStakingRewardReservesSpent(NftId indexed targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdateIn);
 
     // stakes
-    event LogStakingStakeCreated(NftId stakeNftId, NftId targetNftId, Amount stakeAmount, Timestamp lockedUntil, address stakeOwner);
-    event LogStakingStakeRewardsUpdated(NftId stakeNftId, Amount rewardIncrementAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingRewardsRestaked(NftId stakeNftId, Amount restakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingStaked(NftId stakeNftId, Amount stakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingUnstaked(NftId stakeNftId, Amount unstakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingRewardsClaimed(NftId stakeNftId, Amount claimedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-
-    event LogStakingStakeRestaked(NftId stakeNftId, NftId targetNftId, Amount stakeAmount, address owner, NftId oldStakeNftId);
+    event LogStakingStakeCreated(NftId indexed stakeNftId, NftId indexed targetNftId, Amount stakeAmount, Timestamp lockedUntil, address stakeOwner);
+    event LogStakingStakeRewardsUpdated(NftId indexed stakeNftId, Amount rewardIncrementAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingRewardsRestaked(NftId indexed stakeNftId, Amount restakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingStaked(NftId indexed stakeNftId, Amount stakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingUnstaked(NftId indexed stakeNftId, Amount unstakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingRewardsClaimed(NftId indexed stakeNftId, Amount claimedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+
+    event LogStakingStakeRestaked(NftId indexed stakeNftId, NftId indexed targetNftId, Amount stakeAmount, address owner, NftId oldStakeNftId);
 
     // modifiers
     error ErrorStakingNotStake(NftId stakeNftId);

package/contracts/staking/IStakingService.sol

@@ -16,13 +16,13 @@ import {UFixed} from "../type/UFixed.sol";
 interface IStakingService is IService
 {
 
-    event LogStakingServiceProtocolTargetRegistered(NftId protocolNftId);
-    event LogStakingServiceInstanceTargetRegistered(NftId instanceNftId, uint256 chainId, Seconds initialLockingPeriod, UFixed initialRewardRate);
+    event LogStakingServiceProtocolTargetRegistered(NftId indexed protocolNftId);
+    event LogStakingServiceInstanceTargetRegistered(NftId indexed instanceNftId, Seconds initialLockingPeriod, UFixed initialRewardRate);
 
-    event LogStakingServiceRewardReservesIncreased(NftId targetNftId, address rewardProvider, Amount dipAmount, Amount newBalance);
-    event LogStakingServiceRewardReservesDecreased(NftId targetNftId, address targetOwner, Amount dipAmount, Amount newBalance);
+    event LogStakingServiceRewardReservesIncreased(NftId indexed targetNftId, address indexed rewardProvider, Amount dipAmount, Amount newBalance);
+    event LogStakingServiceRewardReservesDecreased(NftId indexed targetNftId, address indexed targetOwner, Amount dipAmount, Amount newBalance);
 
-    event LogStakingServiceStakeObjectCreated(NftId stakeNftId, NftId targetNftId, address stakeOwner);
+    event LogStakingServiceStakeCreated(NftId indexed stakeNftId, NftId indexed targetNftId, address indexed stakeOwner);
 
     // modifiers
     error ErrorStakingServiceNotStakingOwner(address account);

package/contracts/staking/Staking.sol

@@ -177,7 +177,7 @@ contract Staking is
             Blocknumber lastUpdateIn
         )  = _getStakingStorage()._store.setStakingRate(chainId, token, stakingRate);
 
-        emit LogStakingStakingRateSet(chainId, token, stakingRate, oldStakingRate, lastUpdateIn);
+        emit LogStakingStakingRateSet(chainId, token, oldStakingRate, stakingRate, lastUpdateIn);
     }
 
 
@@ -193,7 +193,7 @@ contract Staking is
         address oldStakingService = address($._stakingService);
         $._stakingService = StakingLib.checkAndGetStakingService(getRegistry(), release);
 
-        emit LogStakingStakingServiceSet(address($._stakingService), release, oldStakingService);
+        emit LogStakingStakingServiceSet(oldStakingService, address($._stakingService), release);
     }
 
 
@@ -250,7 +250,7 @@ contract Staking is
             token, 
             amount);
 
-        emit LogStakingTokenHandlerApproved(address(token), amount, oldAllowanceAmount);
+        emit LogStakingTokenHandlerApproved(oldAllowanceAmount, amount, address(token));
     }
 
     //--- target management -------------------------------------------------//
@@ -422,7 +422,7 @@ contract Staking is
         $._store.addTargetToken(targetNftId, token);
 
         // TODO move logging to store
-        emit LogStakingTargetTokenAdded(targetNftId, chainId, token);
+        emit LogStakingTargetTokenAdded(targetNftId, token);
     }
 
 

package/contracts/staking/StakingService.sol

@@ -59,7 +59,7 @@ contract StakingService is
             initialLockingPeriod,
             initialRewardRate);
 
-        emit LogStakingServiceInstanceTargetRegistered(targetNftId, chainId, initialLockingPeriod, initialRewardRate);
+        emit LogStakingServiceInstanceTargetRegistered(targetNftId, initialLockingPeriod, initialRewardRate);
     }
 
 
@@ -164,7 +164,7 @@ contract StakingService is
                 data: ""
             }));
 
-        emit LogStakingServiceStakeObjectCreated(stakeNftId, targetNftId, stakeOwner);
+        emit LogStakingServiceStakeCreated(stakeNftId, targetNftId, stakeOwner);
     }
 
 

package/contracts/staking/StakingStore.sol

@@ -151,7 +151,7 @@ contract StakingStore is
         address oldReader = address(_reader);
         _reader = StakingReader(reader);
 
-        emit IStaking.LogStakingStakingReaderSet(reader, oldReader);
+        emit IStaking.LogStakingStakingReaderSet(oldReader, reader);
     }
 
 
@@ -162,7 +162,7 @@ contract StakingStore is
         address oldTargetHandler = address(_targetLimitHandler);
         _targetLimitHandler = ITargetLimitHandler(targetLimitHandler );
 
-        emit IStaking.LogStakingTargetHandlerSet(targetLimitHandler , oldTargetHandler);
+        emit IStaking.LogStakingTargetHandlerSet(oldTargetHandler, targetLimitHandler);
     }
 
     //--- target support management -----------------------------------------//
@@ -387,7 +387,7 @@ contract StakingStore is
         targetInfo.lastUpdateIn = BlocknumberLib.current();
 
         // logging
-        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, rewardRate, oldRewardRate, lastUpdateIn);
+        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, oldRewardRate, rewardRate, lastUpdateIn);
     }