@etherisc/gif-next 3.0.0-17b0c29-372 → 3.0.0-185d1a9-624

package/contracts/product/IRiskService.sol

@@ -9,11 +9,11 @@ import {StateId} from "../type/StateId.sol";
 
 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 LogRiskServiceRiskClosed(NftId indexed productNftId, RiskId indexed riskId);
+    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);
     
     error ErrorRiskServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
     error ErrorRiskServiceRiskNotActive(NftId productNftId, RiskId riskId);

package/contracts/registry/ChainNft.sol

@@ -8,7 +8,7 @@ import {ITransferInterceptor} from "./ITransferInterceptor.sol";
 
 contract ChainNft is ERC721Enumerable {
 
-    event LogTokenInterceptorAddress(uint256 indexed tokenId, address indexed interceptor);
+    event LogTokenInterceptorAddress(uint256 tokenId, address interceptor);
 
     // constants
     string public constant NAME = "Decentralized Insurance Protocol NFT";

package/contracts/registry/IRegistry.sol

@@ -19,9 +19,9 @@ interface IRegistry is
     IERC165
 {
 
-    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, uint256 indexed chainId, address indexed chainRegistryAddress);
+    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);
 
     // initialize
     error ErrorRegistryCallerNotDeployer();

package/contracts/registry/ReleaseAdmin.sol

@@ -21,8 +21,8 @@ import {VersionPart} from "../type/Version.sol";
 contract ReleaseAdmin is
     AccessAdmin
 {
-    event LogReleaseAdminReleaseLocked(VersionPart indexed release, bool indexed locked);
-    event LogReleaseAdminServiceLocked(VersionPart indexed release, address indexed service, bool indexed locked);
+    event LogReleaseAdminReleaseLockChanged(VersionPart release, bool locked);
+    event LogReleaseAdminServiceLockChanged(VersionPart release, address service, bool locked);
 
     error ErrorReleaseAdminCallerNotReleaseRegistry(address caller);
     error ErrorReleaseAdminNotService(address notService);
@@ -137,7 +137,7 @@ contract ReleaseAdmin is
         // effects
         accessManager.setLocked(locked);
 
-        emit LogReleaseAdminReleaseLocked(getRelease(), locked);
+        emit LogReleaseAdminReleaseLockChanged(getRelease(), locked);
     }
 
 
@@ -155,7 +155,7 @@ contract ReleaseAdmin is
 
         _setTargetLocked(address(service), locked);
 
-        emit LogReleaseAdminServiceLocked(service.getRelease(), address(service), locked);
+        emit LogReleaseAdminServiceLockChanged(service.getRelease(), address(service), locked);
     }
 
     //--- private functions -------------------------------------------------//

package/contracts/registry/ReleaseRegistry.sol

@@ -38,10 +38,10 @@ 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 LogReleaseActivated(VersionPart indexed release);
-    event LogReleaseDisabled(VersionPart indexed release);
-    event LogReleaseEnabled(VersionPart indexed release);
+    event LogReleaseCreation(IAccessAdmin admin, VersionPart release, bytes32 salt); 
+    event LogReleaseActivation(VersionPart release);
+    event LogReleaseDisabled(VersionPart release);
+    event LogReleaseEnabled(VersionPart release);
 
     // constructor
     error ErrorReleaseRegistryNotRegistry(Registry registry);
@@ -168,7 +168,7 @@ contract ReleaseRegistry is
         _releaseInfo[releaseVersion].auth = serviceAuthorization;
         _releaseInfo[releaseVersion].releaseAdmin = address(releaseAdmin);
 
-        emit LogReleaseCreated(releaseAdmin, releaseVersion, releaseSalt);
+        emit LogReleaseCreation(releaseAdmin, releaseVersion, releaseSalt);
     }
 
     function registerService(IService service) 
@@ -270,7 +270,7 @@ contract ReleaseRegistry is
 
         _setReleaseLocked(release, false);
 
-        emit LogReleaseActivated(release);
+        emit LogReleaseActivation(release);
     }
 
     /// @dev stop/resume operations with restricted functions

package/contracts/registry/TokenRegistry.sol

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

package/contracts/shared/ComponentService.sol

@@ -189,8 +189,8 @@ contract ComponentService is
         emit LogComponentServiceComponentFeesWithdrawn(
             componentNftId, 
             componentOwner, 
-            withdrawnAmount,
-            address(tokenHandler.TOKEN()));
+            address(tokenHandler.TOKEN()), 
+            withdrawnAmount);
 
         // interactions
         // transfer amount to component owner

package/contracts/shared/IComponentService.sol

@@ -45,20 +45,20 @@ interface IComponentService is
     error ErrorComponentServiceWithdrawAmountExceedsLimit(Amount withdrawnAmount, Amount withdrawLimit);
     error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
 
-    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 LogComponentServiceProductFeesUpdated(NftId indexed productNftId);
-    event LogComponentServiceDistributionFeesUpdated(NftId indexed distributionNftId);
-    event LogComponentServicePoolFeesUpdated(NftId indexed poolNftId);
+    event LogComponentServiceComponentLocked(address component, bool locked);
+    event LogComponentServiceTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
+    event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
+    event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
+    event LogComponentServiceProductFeesUpdated(NftId productNftId);
+    event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
+    event LogComponentServicePoolFeesUpdated(NftId poolNftId);
     event LogComponentServiceUpdateFee(
-        NftId indexed nftId, 
+        NftId nftId, 
         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);

package/contracts/shared/INftOwnable.sol

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

package/contracts/shared/TokenHandler.sol

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

package/contracts/staking/IStaking.sol

@@ -25,28 +25,28 @@ interface IStaking is
     IVersionable
 {
 
-    event LogStakingTokenHandlerDeployed(NftId indexed componentNftId, address indexed tokenHandler, address indexed token);
+    event LogStakingTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
     
     // owner functions
-    event LogStakingStakingRateSet(ChainId indexed chainId, address indexed token, UFixed indexed 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 indexed oldApprovalAmount, Amount indexed approvalAmount, address indexed token);
+    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);
 
     // token
-    event LogStakingTokenAdded(ChainId indexed chainId, address indexed token);
-    event LogStakingTargetTokenAdded(NftId indexed targetNftId, address indexed token);
+    event LogStakingTokenAdded(ChainId chainId, address token);
+    event LogStakingTargetTokenAdded(NftId targetNftId, ChainId chainId, address token);
 
     // total value locked
-    event LogStakingTvlIncreased(NftId indexed targetNftId, address indexed token, Amount indexed amount, Amount newBalance, Blocknumber lastUpdateIn);
-    event LogStakingTvlDecreased(NftId indexed targetNftId, address indexed token, Amount indexed amount, Amount newBalance, Blocknumber lastUpdateIn);
+    event LogStakingTvlIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
+    event LogStakingTvlDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
 
     // targets
     event LogStakingSupportInfoSet(
-        ObjectType indexed objectType,
-        bool indexed isSupported,
-        bool indexed allowNewTargets,
+        ObjectType objectType,
+        bool isSupported,
+        bool allowNewTargets,
         bool allowCrossChain,
         Amount minStakingAmount,
         Amount maxStakingAmount,
@@ -56,31 +56,31 @@ interface IStaking is
         UFixed maxRewardRate,
         Blocknumber lastUpdateIn);
 
-    event LogStakingTargetCreated(NftId indexed targetNftId, ObjectType indexed objectType, Seconds indexed lockingPeriod, UFixed rewardRate);
-    event LogStakingLimitsSet(NftId indexed targetNftId, Amount indexed marginAmount, Amount indexed hardLimitAmount, Blocknumber lastUpdateIn);
-    event LogStakingTargetLimitsUpdated(NftId indexed targetNftId, Amount indexed marginAmount, Amount indexed hardLimitAmount, Blocknumber lastUpdateIn);
-    event LogStakingTargetLimitUpdated(NftId indexed targetNftId, Amount indexed limitAmount, Amount indexed hardLimitAmount, Amount requiredStakeAmount, Amount actualStakeAmount, 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);
 
     // target parameters
-    event LogStakingTargetLockingPeriodSet(NftId indexed targetNftId, Seconds indexed oldLockingPeriod, Seconds indexed lockingPeriod, Blocknumber lastUpdateIn);
-    event LogStakingTargetRewardRateSet(NftId indexed targetNftId, UFixed indexed oldRewardRate, UFixed indexed rewardRate, Blocknumber lastUpdateIn);
-    event LogStakingTargetMaxStakedAmountSet(NftId indexed targetNftId, Amount indexed stakeLimitAmount, Blocknumber indexed lastUpdateIn);
-    event LogStakingTargetLimitsSet(NftId indexed targetNftId, Amount indexed stakeLimitAmount, Amount indexed marginAmount, Amount limitAmount);
+    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);
 
     // reward reserves
-    event LogStakingRewardReservesRefilled(NftId indexed targetNftId, Amount indexed dipAmount, address indexed targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
-    event LogStakingRewardReservesWithdrawn(NftId indexed targetNftId, Amount indexed dipAmount, address indexed targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
-    event LogStakingRewardReservesSpent(NftId indexed targetNftId, Amount indexed dipAmount, Amount indexed reserveBalance, Blocknumber lastUpdateIn);
+    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);
 
     // stakes
-    event LogStakingStakeCreated(NftId indexed stakeNftId, NftId indexed targetNftId, Amount indexed stakeAmount, Timestamp lockedUntil, address stakeOwner);
-    event LogStakingStakeRewardsUpdated(NftId indexed stakeNftId, Amount indexed rewardIncrementAmount, Amount indexed stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingRewardsRestaked(NftId indexed stakeNftId, Amount indexed restakedAmount, Amount indexed stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingStaked(NftId indexed stakeNftId, Amount indexed stakedAmount, Amount indexed stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingUnstaked(NftId indexed stakeNftId, Amount indexed unstakedAmount, Amount indexed stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-    event LogStakingRewardsClaimed(NftId indexed stakeNftId, Amount indexed claimedAmount, Amount indexed stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
-
-    event LogStakingStakeRestaked(NftId indexed stakeNftId, NftId indexed targetNftId, Amount indexed stakeAmount, address owner, NftId oldStakeNftId);
+    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);
 
     // 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 indexed protocolNftId);
-    event LogStakingServiceInstanceTargetRegistered(NftId indexed instanceNftId, Seconds indexed initialLockingPeriod, UFixed indexed initialRewardRate);
+    event LogStakingServiceProtocolTargetRegistered(NftId protocolNftId);
+    event LogStakingServiceInstanceTargetRegistered(NftId instanceNftId, uint256 chainId, Seconds initialLockingPeriod, UFixed initialRewardRate);
 
-    event LogStakingServiceRewardReservesIncreased(NftId indexed targetNftId, address indexed rewardProvider, Amount indexed dipAmount, Amount newBalance);
-    event LogStakingServiceRewardReservesDecreased(NftId indexed targetNftId, address indexed targetOwner, Amount indexed dipAmount, Amount newBalance);
+    event LogStakingServiceRewardReservesIncreased(NftId targetNftId, address rewardProvider, Amount dipAmount, Amount newBalance);
+    event LogStakingServiceRewardReservesDecreased(NftId targetNftId, address targetOwner, Amount dipAmount, Amount newBalance);
 
-    event LogStakingServiceStakeCreated(NftId indexed stakeNftId, NftId indexed targetNftId, address indexed stakeOwner);
+    event LogStakingServiceStakeObjectCreated(NftId stakeNftId, NftId targetNftId, address 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, oldStakingRate, stakingRate, lastUpdateIn);
+        emit LogStakingStakingRateSet(chainId, token, stakingRate, oldStakingRate, lastUpdateIn);
     }
 
 
@@ -193,7 +193,7 @@ contract Staking is
         address oldStakingService = address($._stakingService);
         $._stakingService = StakingLib.checkAndGetStakingService(getRegistry(), release);
 
-        emit LogStakingStakingServiceSet(oldStakingService, address($._stakingService), release);
+        emit LogStakingStakingServiceSet(address($._stakingService), release, oldStakingService);
     }
 
 
@@ -250,7 +250,7 @@ contract Staking is
             token, 
             amount);
 
-        emit LogStakingTokenHandlerApproved(oldAllowanceAmount, amount, address(token));
+        emit LogStakingTokenHandlerApproved(address(token), amount, oldAllowanceAmount);
     }
 
     //--- target management -------------------------------------------------//
@@ -422,7 +422,7 @@ contract Staking is
         $._store.addTargetToken(targetNftId, token);
 
         // TODO move logging to store
-        emit LogStakingTargetTokenAdded(targetNftId, token);
+        emit LogStakingTargetTokenAdded(targetNftId, chainId, token);
     }
 
 

package/contracts/staking/StakingService.sol

@@ -59,7 +59,7 @@ contract StakingService is
             initialLockingPeriod,
             initialRewardRate);
 
-        emit LogStakingServiceInstanceTargetRegistered(targetNftId, initialLockingPeriod, initialRewardRate);
+        emit LogStakingServiceInstanceTargetRegistered(targetNftId, chainId, initialLockingPeriod, initialRewardRate);
     }
 
 
@@ -164,7 +164,7 @@ contract StakingService is
                 data: ""
             }));
 
-        emit LogStakingServiceStakeCreated(stakeNftId, targetNftId, stakeOwner);
+        emit LogStakingServiceStakeObjectCreated(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(oldReader, reader);
+        emit IStaking.LogStakingStakingReaderSet(reader, oldReader);
     }
 
 
@@ -162,7 +162,7 @@ contract StakingStore is
         address oldTargetHandler = address(_targetLimitHandler);
         _targetLimitHandler = ITargetLimitHandler(targetLimitHandler );
 
-        emit IStaking.LogStakingTargetHandlerSet(oldTargetHandler, targetLimitHandler);
+        emit IStaking.LogStakingTargetHandlerSet(targetLimitHandler , oldTargetHandler);
     }
 
     //--- target support management -----------------------------------------//
@@ -387,7 +387,7 @@ contract StakingStore is
         targetInfo.lastUpdateIn = BlocknumberLib.current();
 
         // logging
-        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, oldRewardRate, rewardRate, lastUpdateIn);
+        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, rewardRate, oldRewardRate, lastUpdateIn);
     }
 
 

package/contracts/staking/TargetHandler.sol

@@ -20,7 +20,7 @@ contract TargetHandler is
     ITargetLimitHandler
 {
 
-    event LogTargetHandlerUpdateTriggersSet(uint16 indexed tvlUpdatesTrigger, UFixed indexed minTvlRatioTrigger, Blocknumber indexed lastUpdateIn);
+    event LogTargetHandlerUpdateTriggersSet(uint16 tvlUpdatesTrigger, UFixed minTvlRatioTrigger, Blocknumber lastUpdateIn);
 
     IRegistry private _registry;
     StakingStore private _store;

package/contracts/upgradeability/ProxyManager.sol

@@ -27,8 +27,8 @@ contract ProxyManager is
         address activatedBy;
     }
 
-    event LogProxyManagerVersionableDeployed(address indexed proxy, address indexed initialImplementation);
-    event LogProxyManagerVersionableUpgraded(address indexed proxy, address indexed upgradedImplementation);
+    event LogProxyManagerVersionableDeployed(address indexed proxy, address initialImplementation);
+    event LogProxyManagerVersionableUpgraded(address indexed proxy, address upgradedImplementation);
 
     error ErrorProxyManagerAlreadyDeployed();
     error ErrorProxyManagerNotYetDeployed();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "3.0.0-17b0c29-372",
+  "version": "3.0.0-185d1a9-624",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {