@etherisc/gif-next 3.0.0-52e15cf-819 → 3.0.0-5438ecb-315

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();

package/contracts/shared/ComponentService.sol

@@ -189,8 +189,8 @@ contract ComponentService is
         emit LogComponentServiceComponentFeesWithdrawn(
             componentNftId, 
             componentOwner, 
-            address(tokenHandler.TOKEN()), 
-            withdrawnAmount);
+            withdrawnAmount,
+            address(tokenHandler.TOKEN()));
 
         // interactions
         // transfer amount to component owner
@@ -312,9 +312,27 @@ contract ComponentService is
             productNftId, 
             initialProductInfo);
 
+        emit LogComponentServiceProductCreated(productNftId, productAddress, initialProductInfo.hasDistribution, initialProductInfo.expectedNumberOfOracles);
+
+        IComponents.FeeInfo memory initialFeeInfo = product.getInitialFeeInfo();
+        
         productStore.createFee(
             productNftId, 
-            product.getInitialFeeInfo());
+            initialFeeInfo);
+
+        emit LogComponentServiceProductInitialProductFeesSet(
+            productNftId, 
+            initialFeeInfo.productFee.fixedFee, initialFeeInfo.productFee.fractionalFee,
+            initialFeeInfo.processingFee.fixedFee, initialFeeInfo.processingFee.fractionalFee);
+        emit LogComponentServiceProductInitialDistributionFeesSet(
+            productNftId, 
+            initialFeeInfo.distributionFee.fixedFee, initialFeeInfo.distributionFee.fractionalFee,
+            initialFeeInfo.minDistributionOwnerFee.fixedFee, initialFeeInfo.minDistributionOwnerFee.fractionalFee);
+        emit LogComponentServiceProductInitialPoolFeesSet(
+            productNftId, 
+            initialFeeInfo.poolFee.fixedFee, initialFeeInfo.poolFee.fractionalFee,
+            initialFeeInfo.stakingFee.fixedFee, initialFeeInfo.stakingFee.fractionalFee,
+            initialFeeInfo.performanceFee.fixedFee, initialFeeInfo.performanceFee.fractionalFee);
     }
 
     //-------- distribution -------------------------------------------------//
@@ -341,6 +359,8 @@ contract ComponentService is
         // set distribution in product info
         productInfo.distributionNftId = distributionNftId;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServiceDistributionCreated(distributionNftId, productNftId);
     }
 
 
@@ -400,6 +420,8 @@ contract ComponentService is
         productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
         productInfo.numberOfOracles++;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServiceOracleCreated(oracleNftId, productNftId);
     }
 
     //-------- pool ---------------------------------------------------------//
@@ -423,13 +445,20 @@ contract ComponentService is
 
         // create info
         IPoolComponent pool = IPoolComponent(componentAddress);
+        IComponents.PoolInfo memory initialPoolInfo = pool.getInitialPoolInfo();
         instanceStore.createPool(
             poolNftId, 
-            pool.getInitialPoolInfo());
+            initialPoolInfo);
 
         // update pool in product info
         productInfo.poolNftId = poolNftId;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServicePoolCreated(
+            poolNftId, productNftId, componentAddress, 
+            initialPoolInfo.maxBalanceAmount, initialPoolInfo.collateralizationLevel, 
+            initialPoolInfo.retentionLevel, initialPoolInfo.isExternallyManaged, 
+            initialPoolInfo.isVerifyingApplications);
     }
 
 
@@ -543,6 +572,11 @@ contract ComponentService is
             address(component), // initially, component is its own wallet
             token, 
             instanceAdmin.authority());
+
+        emit LogComponentServiceTokenHandlerDeployed(
+            componentNftId, 
+            address(componentInfo.tokenHandler), 
+            token);
         
         // register component with instance
         instanceStore.createComponent(

package/contracts/shared/IComponent.sol

@@ -25,10 +25,6 @@ interface IComponent is
     error ErrorComponentWalletAddressIsSameAsCurrent();
     error ErrorComponentWalletNotComponent();
 
-    event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
-    event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
-    event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
-
     /// @dev returns the name of this component
     /// to successfully register the component with an instance the name MUST be unique in the linked instance
     function getName() external view returns (string memory name);

package/contracts/shared/IComponentService.sol

@@ -45,22 +45,44 @@ interface IComponentService is
     error ErrorComponentServiceWithdrawAmountExceedsLimit(Amount withdrawnAmount, Amount withdrawLimit);
     error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
 
-    event LogComponentServiceComponentLocked(address component, bool locked);
-    event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
-    event LogComponentServiceWalletAddressChanged(NftId componentNftId, address currentWallet, address newWallet);
-    event LogComponentServiceWalletTokensTransferred(NftId componentNftId, address currentWallet, address newWallet, uint256 currentBalance);
-    event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
-    event LogComponentServiceProductFeesUpdated(NftId productNftId);
-    event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
-    event LogComponentServicePoolFeesUpdated(NftId poolNftId);
+    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 withdrawnAmount, address indexed token);
+    event LogComponentServiceProductFeesUpdated(NftId indexed productNftId);
+    event LogComponentServiceDistributionFeesUpdated(NftId indexed distributionNftId);
+    event LogComponentServicePoolFeesUpdated(NftId indexed poolNftId);
     event LogComponentServiceUpdateFee(
-        NftId nftId, 
+        NftId indexed nftId, 
         string feeName, 
         UFixed previousFractionalFee, 
         Amount previousFixedFee,
         UFixed newFractionalFee, 
         Amount newFixedFee
     );
+    event LogComponentServiceProductCreated(
+        NftId indexed productNftId, address indexed productAddress, bool indexed hasDistribution, uint8 expectedNumberOfOracles);
+    event LogComponentServiceProductInitialProductFeesSet(
+        NftId indexed productNftId, 
+        Amount productFeeFixed, UFixed productFeeFractional,
+        Amount processingFeeFixed, UFixed processingFeeFractional);
+    event LogComponentServiceProductInitialDistributionFeesSet(
+        NftId indexed productNftId, 
+        Amount distributionFeeFixed, UFixed distributionFeeFractional,
+        Amount minDistributionOwnerFeeFixed, UFixed minDistributionOwnerFeeFractional);
+    event LogComponentServiceProductInitialPoolFeesSet(
+        NftId indexed productNftId, 
+        Amount poolFeeFixed, UFixed poolFeeFractional,
+        Amount stakingFeeFixed, UFixed stakingFeeFractional,
+        Amount performanceFeeFixed, UFixed performanceFeeFractional);
+    event LogComponentServicePoolCreated(
+        NftId indexed poolNftId, NftId indexed productNftId, address indexed componentAddress, 
+        Amount maxBalanceAmount, UFixed collateralizationLevel, UFixed retentionLevel, 
+        bool isExternallyManaged, bool isVerifyingApplications);
+    event LogComponentServiceDistributionCreated(
+        NftId indexed distributionNftId, NftId indexed productNftId);
+    event LogComponentServiceOracleCreated(
+        NftId indexed oracleNftId, NftId indexed productNftId);
     
     //-------- component ----------------------------------------------------//
 

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,26 +25,28 @@ interface IStaking is
     IVersionable
 {
 
+    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,
@@ -54,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,22 +16,13 @@ import {UFixed} from "../type/UFixed.sol";
 interface IStakingService is IService
 {
 
-    event LogStakingServiceProtocolTargetRegistered(NftId protocolNftId);
-    event LogStakingServiceInstanceTargetRegistered(NftId instanceNftId, uint256 chainId);
-    event LogStakingServiceLockingPeriodSet(NftId targetNftId, Seconds oldLockingDuration, Seconds lockingDuration);
-    event LogStakingServiceRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
-
-    event LogStakingServiceRewardReservesIncreased(NftId targetNftId, address rewardProvider, Amount dipAmount, Amount newBalance);
-    event LogStakingServiceRewardReservesDecreased(NftId targetNftId, address targetOwner, Amount dipAmount, Amount newBalance);
-
-    event LogStakingServiceStakeObjectCreated(NftId stakeNftId, NftId targetNftId, address stakeOwner);
-    event LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
-    event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount, Amount stakeBalance);
-    event LogStakingServiceUnstaked(NftId stakeNftId, address stakeOwner, Amount totalAmount);
-    event LogStakingServiceStakeRestaked(address stakeOwner, NftId indexed stakeNftId, NftId newStakeNftId, NftId indexed newTargetNftId, Amount indexed newStakeBalance);
-
-    event LogStakingServiceRewardsUpdated(NftId stakeNftId);
-    event LogStakingServiceRewardsClaimed(NftId stakeNftId, address stakeOwner, Amount rewardsClaimedAmount);
+    event LogStakingServiceProtocolTargetRegistered(NftId indexed protocolNftId);
+    event LogStakingServiceInstanceTargetRegistered(NftId indexed instanceNftId, Seconds initialLockingPeriod, UFixed initialRewardRate);
+
+    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 LogStakingServiceStakeCreated(NftId indexed stakeNftId, NftId indexed targetNftId, address indexed stakeOwner);
 
     // modifiers
     error ErrorStakingServiceNotStakingOwner(address account);

package/contracts/staking/Staking.sol

@@ -86,6 +86,7 @@ contract Staking is
             address(this),
             dipToken, 
             getRegistry().getAuthority());
+        emit LogStakingTokenHandlerDeployed(getNftId(), address($._tokenHandler), dipToken);
     }
 
 
@@ -176,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);
     }
 
 
@@ -192,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);
     }
 
 
@@ -249,7 +250,7 @@ contract Staking is
             token, 
             amount);
 
-        emit LogStakingTokenHandlerApproved(address(token), amount, oldAllowanceAmount);
+        emit LogStakingTokenHandlerApproved(oldAllowanceAmount, amount, address(token));
     }
 
     //--- target management -------------------------------------------------//
@@ -421,7 +422,7 @@ contract Staking is
         $._store.addTargetToken(targetNftId, token);
 
         // TODO move logging to store
-        emit LogStakingTargetTokenAdded(targetNftId, chainId, token);
+        emit LogStakingTargetTokenAdded(targetNftId, token);
     }