diff --git a/contract/r/gnoswap/staker/external_deposit_fee.gno b/contract/r/gnoswap/staker/external_deposit_fee.gno
index 6910309f0..2ea3eeb58 100644
--- a/contract/r/gnoswap/staker/external_deposit_fee.gno
+++ b/contract/r/gnoswap/staker/external_deposit_fee.gno
@@ -35,6 +35,7 @@ func SetDepositGnsAmountByAdmin(amount uint64) {
 		panic(err.Error())
 	}
 
+	prevDepositGnsAmount := getDepositGnsAmount()
 	setDepositGnsAmount(amount)
 
 	prevAddr, prevPkgPath := getPrev()
@@ -43,7 +44,8 @@ func SetDepositGnsAmountByAdmin(amount uint64) {
 		"SetDepositGnsAmountByAdmin",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"amount", formatUint(amount),
+		"prevAmount", formatUint(prevDepositGnsAmount),
+		"newAmount", formatUint(amount),
 	)
 }
 
@@ -56,6 +58,7 @@ func SetDepositGnsAmount(amount uint64) {
 		panic(err.Error())
 	}
 
+	prevDepositGnsAmount := getDepositGnsAmount()
 	setDepositGnsAmount(amount)
 
 	prevAddr, prevPkgPath := getPrev()
@@ -64,10 +67,15 @@ func SetDepositGnsAmount(amount uint64) {
 		"SetDepositGnsAmount",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"amount", formatUint(amount),
+		"prevAmount", formatUint(prevDepositGnsAmount),
+		"newAmount", formatUint(amount),
 	)
 }
 
 func setDepositGnsAmount(amount uint64) {
 	depositGnsAmount = amount
 }
+
+func getDepositGnsAmount() uint64 {
+	return depositGnsAmount
+}
diff --git a/contract/r/gnoswap/staker/manage_pool_tier_and_warmup.gno b/contract/r/gnoswap/staker/manage_pool_tier_and_warmup.gno
index 24705ec71..e0aeafa57 100644
--- a/contract/r/gnoswap/staker/manage_pool_tier_and_warmup.gno
+++ b/contract/r/gnoswap/staker/manage_pool_tier_and_warmup.gno
@@ -34,8 +34,9 @@ func SetPoolTier(poolPath string, tier uint64) {
 func setPoolTier(poolPath string, tier uint64) {
 	en.MintAndDistributeGns()
 
+	currentHeight := std.GetHeight()
 	pools.GetOrCreate(poolPath)
-	poolTier.changeTier(std.GetHeight(), pools, poolPath, tier)
+	poolTier.changeTier(currentHeight, pools, poolPath, tier)
 
 	prevAddr, prevRealm := getPrev()
 	std.Emit(
@@ -44,6 +45,7 @@ func setPoolTier(poolPath string, tier uint64) {
 		"prevRealm", prevRealm,
 		"poolPath", poolPath,
 		"tier", formatUint(tier),
+		"height", formatInt(currentHeight),
 	)
 }
 
@@ -66,7 +68,9 @@ func ChangePoolTier(poolPath string, tier uint64) {
 func changePoolTier(poolPath string, tier uint64) {
 	en.MintAndDistributeGns()
 
-	poolTier.changeTier(std.GetHeight(), pools, poolPath, tier)
+	prevTier := poolTier.CurrentTier(poolPath)
+	currentHeight := std.GetHeight()
+	poolTier.changeTier(currentHeight, pools, poolPath, tier)
 
 	prevAddr, prevRealm := getPrev()
 	std.Emit(
@@ -74,7 +78,9 @@ func changePoolTier(poolPath string, tier uint64) {
 		"prevAddr", prevAddr,
 		"prevRealm", prevRealm,
 		"poolPath", poolPath,
-		"tier", formatUint(tier),
+		"prevTier", formatUint(prevTier),
+		"newTier", formatUint(tier),
+		"height", formatInt(currentHeight),
 	)
 }
 
@@ -97,7 +103,8 @@ func RemovePoolTier(poolPath string) {
 func removePoolTier(poolPath string) {
 	en.MintAndDistributeGns()
 
-	poolTier.changeTier(std.GetHeight(), pools, poolPath, NOT_EMISSION_TARGET_TIER)
+	currentHeight := std.GetHeight()
+	poolTier.changeTier(currentHeight, pools, poolPath, NOT_EMISSION_TARGET_TIER)
 
 	prevAddr, prevRealm := getPrev()
 	std.Emit(
@@ -105,6 +112,7 @@ func removePoolTier(poolPath string) {
 		"prevAddr", prevAddr,
 		"prevRealm", prevRealm,
 		"poolPath", poolPath,
+		"height", formatInt(currentHeight),
 	)
 }
 
diff --git a/contract/r/gnoswap/staker/protocol_fee_unstaking.gno b/contract/r/gnoswap/staker/protocol_fee_unstaking.gno
index 37dacfce4..e9debfb09 100644
--- a/contract/r/gnoswap/staker/protocol_fee_unstaking.gno
+++ b/contract/r/gnoswap/staker/protocol_fee_unstaking.gno
@@ -16,7 +16,7 @@ var (
 	unstakingFee = uint64(100) // 1%
 )
 
-// handleUnstakingFee calculates and applies the unstaking fee.
+// handleUnStakingFee calculates and applies the unstaking fee.
 //
 // The function deducts a fee from the unstaked amount based on the `unstakingFee` rate,
 // sends the fee to the protocol fee address, and emits an event indicating the fee transfer.
@@ -30,7 +30,7 @@ var (
 //
 // Returns:
 // - uint64: The amount after deducting the unstaking fee.
-func handleUnstakingFee(
+func handleUnStakingFee(
 	tokenPath string,
 	amount uint64,
 	internal bool,
@@ -46,7 +46,7 @@ func handleUnstakingFee(
 		return amount
 	}
 
-	prevAddr, prevRealm := getPrev()
+	prevAddr, prevPkgPath := getPrev()
 
 	if internal {
 		// staker contract has fee
@@ -56,11 +56,11 @@ func handleUnstakingFee(
 		std.Emit(
 			"ProtocolFeeInternalReward",
 			"prevAddr", prevAddr,
-			"prevRealm", prevRealm,
-			"internal_lpTokenId", formatUint(tokenId),
-			"internal_poolPath", poolPath,
-			"internal_tokenPath", consts.GNS_PATH,
-			"internal_amount", formatUint(feeAmount),
+			"prevRealm", prevPkgPath,
+			"fromPositionId", formatUint(tokenId),
+			"fromPoolPath", poolPath,
+			"feeTokenPath", consts.GNS_PATH,
+			"feeAmount", formatUint(feeAmount),
 		)
 	} else {
 		// external contract has fee
@@ -71,11 +71,11 @@ func handleUnstakingFee(
 		std.Emit(
 			"ProtocolFeeExternalReward",
 			"prevAddr", prevAddr,
-			"prevRealm", prevRealm,
-			"internal_lpTokenId", formatUint(tokenId),
-			"internal_poolPath", poolPath,
-			"internal_tokenPath", tokenPath,
-			"internal_amount", formatUint(feeAmount),
+			"prevRealm", prevPkgPath,
+			"fromPositionId", formatUint(tokenId),
+			"fromPoolPath", poolPath,
+			"feeTokenPath", tokenPath,
+			"feeAmount", formatUint(feeAmount),
 		)
 	}
 
@@ -88,7 +88,7 @@ func GetUnstakingFee() uint64 {
 	return unstakingFee
 }
 
-// SetUnstakingFeeByAdmin sets the unstaking fee rate by an admin.
+// SetUnStakingFeeByAdmin sets the unstaking fee rate by an admin.
 //
 // This function ensures that only admins can modify the unstaking fee. It validates
 // the input fee and emits an event indicating the change.
@@ -98,53 +98,52 @@ func GetUnstakingFee() uint64 {
 //
 // Panics:
 // - If the caller is not an admin.
-func SetUnstakingFeeByAdmin(fee uint64) {
+func SetUnStakingFeeByAdmin(fee uint64) {
 	caller := std.PrevRealm().Addr()
 	if err := common.AdminOnly(caller); err != nil {
 		panic(err.Error())
 	}
 
-	setUnstakingFee(fee)
+	prevUnStakingFee := getUnStakingFee()
 
-	prevAddr, prevRealm := getPrev()
+	setUnStakingFee(fee)
+
+	prevAddr, prevPkgPath := getPrev()
 
 	std.Emit(
-		"SetUnstakingFeeByAdmin",
+		"SetUnStakingFeeByAdmin",
 		"prevAddr", prevAddr,
-		"prevRealm", prevRealm,
-		"fee", formatUint(fee),
+		"prevRealm", prevPkgPath,
+		"prevFee", formatUint(prevUnStakingFee),
+		"newFee", formatUint(fee),
 	)
 }
 
-// SetUnstakingFee modifies the unstaking fee
+// SetUnStakingFee modifies the unstaking fee
 // Only governance contract can execute this function via proposal
 // ref: https://docs.gnoswap.io/contracts/staker/protocol_fee_unstaking.gno#setunstakingfee
-func SetUnstakingFee(fee uint64) {
-	caller := std.PrevRealm().Addr()
-	if caller != consts.GOV_GOVERNANCE_ADDR {
-		panic(addDetailToError(
-			errNoPermission,
-			ufmt.Sprintf(
-				"reward_fee.gno__SetUnstakingFee() || only governance(%s) can set unstaking fee, called from %s",
-				consts.GOV_GOVERNANCE_ADDR,
-				caller,
-			),
-		))
+func SetUnStakingFee(fee uint64) {
+	caller := getPrevAddr()
+	if err := common.GovernanceOnly(caller); err != nil {
+		panic(addDetailToError(err.Error()))
 	}
 
-	setUnstakingFee(fee)
+	prevUnStakingFee := getUnStakingFee()
 
-	prevAddr, prevRealm := getPrev()
+	setUnStakingFee(fee)
+
+	prevAddr, prevPkgPath := getPrev()
 
 	std.Emit(
-		"SetUnstakingFee",
+		"SetUnStakingFee",
 		"prevAddr", prevAddr,
-		"prevRealm", prevRealm,
-		"fee", formatUint(fee),
+		"prevRealm", prevPkgPath,
+		"prevFee", formatUint(prevUnStakingFee),
+		"newFee", formatUint(fee),
 	)
 }
 
-func setUnstakingFee(fee uint64) {
+func setUnStakingFee(fee uint64) {
 	// 10000 (bps) = 100%
 	if fee > 10000 {
 		panic(addDetailToError(
@@ -155,3 +154,7 @@ func setUnstakingFee(fee uint64) {
 
 	unstakingFee = fee
 }
+
+func getUnStakingFee() uint64 {
+	return unstakingFee
+}
diff --git a/contract/r/gnoswap/staker/protocol_fee_unstaking_test.gno b/contract/r/gnoswap/staker/protocol_fee_unstaking_test.gno
index ad54dac33..6229ac58f 100644
--- a/contract/r/gnoswap/staker/protocol_fee_unstaking_test.gno
+++ b/contract/r/gnoswap/staker/protocol_fee_unstaking_test.gno
@@ -41,7 +41,7 @@ func TestHandleUnstakingFee(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			unstakingFee = tc.expectedFee // Set the fee globally for the test
 
-			netAmount := handleUnstakingFee(tc.tokenPath, tc.amount, tc.internal, tc.tokenId, tc.poolPath)
+			netAmount := handleUnStakingFee(tc.tokenPath, tc.amount, tc.internal, tc.tokenId, tc.poolPath)
 
 			if netAmount != tc.expectedNet {
 				t.Errorf("Expected netAmount %d, got %d", tc.expectedNet, netAmount)
@@ -68,7 +68,7 @@ func TestSetUnstakingFee(t *testing.T) {
 				}
 			}()
 
-			setUnstakingFee(tc.fee)
+			setUnStakingFee(tc.fee)
 
 			if !tc.shouldPanic {
 				if unstakingFee != tc.fee {
diff --git a/contract/r/gnoswap/staker/staker.gno b/contract/r/gnoswap/staker/staker.gno
index 96d623a7a..0fd2cf967 100644
--- a/contract/r/gnoswap/staker/staker.gno
+++ b/contract/r/gnoswap/staker/staker.gno
@@ -2,7 +2,6 @@ package staker
 
 import (
 	"std"
-	"strconv"
 	"time"
 
 	"gno.land/p/demo/avl"
@@ -295,11 +294,13 @@ func StakeToken(tokenId uint64) (string, string, string) {
 		"StakeToken",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"lpTokenId", strconv.FormatUint(tokenId, 10),
+		"positionId", formatUint(tokenId),
 		"poolPath", poolPath,
 		"amount0", token0Amount,
 		"amount1", token1Amount,
 		"liquidity", liquidity.ToString(),
+		"positionUpperTick", formatInt(tickUpper),
+		"positionLowerTick", formatInt(tickLower),
 		"currentTick", formatInt(currentTick),
 		"isInRange", formatBool(isInRange),
 	)
@@ -374,11 +375,11 @@ func transferDeposit(tokenId uint64, owner, caller, to std.Address) error {
 
 ////////////////////////////////////////////////////////////
 
-// ectReward harvests accumulated rewards for a staked position. This includes both
-// inernal GNS emission and external incentive rewards.
+// CollectReward harvests accumulated rewards for a staked position. This includes both
+// internal GNS emission and external incentive rewards.
 //
 // State Transition:
-//  1. Warm-up amounts are cleares for both internal and external rewards
+//  1. Warm-up amounts are clears for both internal and external rewards
 //  2. Reward tokens are transferred to the owner
 //  3. Penalty fees are transferred to protocol/community addresses
 //  4. GNS balance is recalculated
@@ -399,14 +400,14 @@ func transferDeposit(tokenId uint64, owner, caller, to std.Address) error {
 func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 	assertOnlyNotHalted()
 
-	en.MintAndDistributeGns()
-
 	deposit := deposits.Get(tokenId)
 	caller := getPrevAddr()
 	if err := common.SatisfyCond(caller == deposit.owner); err != nil {
 		panic(addDetailToError(errNoPermission, ufmt.Sprintf("caller is not owner of tokenId(%d)", tokenId)))
 	}
 
+	en.MintAndDistributeGns()
+
 	currentHeight := std.GetHeight()
 	// get all internal and external rewards
 	reward := calcPositionReward(currentHeight, tokenId)
@@ -414,6 +415,8 @@ func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 	// update lastCollectHeight to current height
 	deposit.lastCollectHeight = currentHeight
 
+	prevAddr, prevPkgPath := getPrev()
+
 	// transfer external rewards to user
 	externalReward := reward.External
 	for incentiveId, amount := range externalReward {
@@ -428,7 +431,7 @@ func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 		incentive.rewardAmount -= amount
 		externalIncentives.Set(incentiveId, incentive)
 
-		toUser := handleUnstakingFee(rewardToken, amount, false, tokenId, incentive.targetPoolPath)
+		toUser := handleUnStakingFee(rewardToken, amount, false, tokenId, incentive.targetPoolPath)
 
 		teller := common.GetTokenTeller(rewardToken)
 		teller.Transfer(deposit.owner, toUser)
@@ -440,48 +443,61 @@ func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 		if unwrapResult && rewardToken == consts.WUGNOT_PATH {
 			unwrap(toUser)
 		}
+		std.Emit(
+			"CollectReward",
+			"prevAddr", prevAddr,
+			"prevRealm", prevPkgPath,
+			"positionId", formatUint(tokenId),
+			"poolPath", deposit.targetPoolPath,
+			"recipient", deposit.owner.String(),
+			"incentiveId", incentiveId,
+			"rewardToken", rewardToken,
+			"rewardAmount", formatUint(toUser),
+			"rewardPenalty", formatUint(externalPenalty),
+			"rewardFee", formatUint(amount-toUser),
+			"isRequestUnwrap", formatBool(unwrapResult),
+		)
 	}
 
 	// internal reward to user
-	toUser := handleUnstakingFee(consts.GNS_PATH, reward.Internal, true, tokenId, deposit.targetPoolPath)
-	totalEmissionSent += toUser
+	toUser := handleUnStakingFee(consts.GNS_PATH, reward.Internal, true, tokenId, deposit.targetPoolPath)
 
 	if toUser > 0 {
+		// internal reward to user
+		totalEmissionSent += toUser
 		gns.Transfer(deposit.owner, toUser)
 
 		// internal penalty to community pool
-		gns.Transfer(consts.COMMUNITY_POOL_ADDR, reward.InternalPenalty)
 		totalEmissionSent += reward.InternalPenalty
+		gns.Transfer(consts.COMMUNITY_POOL_ADDR, reward.InternalPenalty)
 	}
 
 	unClaimableInternal := ProcessUnClaimableReward(deposit.targetPoolPath, currentHeight)
-	totalEmissionSent += unClaimableInternal
 	if unClaimableInternal > 0 {
-		// internal unclaimable to community pool
+		// internal unClaimable to community pool
+		totalEmissionSent += unClaimableInternal
 		gns.Transfer(consts.COMMUNITY_POOL_ADDR, unClaimableInternal)
 	}
 
-	prevAddr, prevPkgPath := getPrev()
 	std.Emit(
 		"CollectReward",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"lpTokenId", formatUint(tokenId),
-		"internal_poolPath", deposit.targetPoolPath,
-		"internal_incentiveId", "INTERNAL",
-		"internal_rewardToken", consts.GNS_PATH,
-		"internal_recipient", deposit.owner.String(),
-		"internal_reward", formatUint(reward.Internal),
-		"internal_toUser", formatUint(toUser),
-		"internal_toFee", formatUint(reward.Internal-toUser),
-		"internal_toPenalty", formatUint(reward.InternalPenalty),
-		"internal_unClaimable", formatUint(unClaimableInternal),
+		"positionId", formatUint(tokenId),
+		"poolPath", deposit.targetPoolPath,
+		"recipient", deposit.owner.String(),
+		"rewardToken", consts.GNS_PATH,
+		"rewardAmount", formatUint(reward.Internal),
+		"rewardToUser", formatUint(toUser),
+		"rewardToFee", formatUint(reward.Internal-toUser),
+		"rewardPenalty", formatUint(reward.InternalPenalty),
+		"rewardUnClaimableAmount", formatUint(unClaimableInternal),
 	)
 
 	return formatUint(toUser), formatUint(reward.InternalPenalty)
 }
 
-// UnstakeToken withdraws an LP token from staking, collecting all pending rewards
+// UnStakeToken withdraws an LP token from staking, collecting all pending rewards
 // and returning the token to its original owner.
 //
 // State transitions:
@@ -497,7 +513,7 @@ func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 // Requirements:
 // - Contract must not be halted
 // - Position must be staked (have deposit record)
-// - Rewards are automatically collected before unstaking
+// - Rewards are automatically collected before unStaking
 //
 // Params:
 // - tokenId (uint64): ID of the staked LP token
@@ -509,10 +525,10 @@ func CollectReward(tokenId uint64, unwrapResult bool) (string, string) {
 // - token1Amount (string): Final amount of token1 in the position
 //
 // ref: https://docs.gnoswap.io/contracts/staker/staker.gno#unstaketoken
-func UnstakeToken(tokenId uint64, unwrapResult bool) (string, string, string) { // poolPath, token0Amount, token1Amount
+func UnStakeToken(tokenId uint64, unwrapResult bool) (string, string, string) { // poolPath, token0Amount, token1Amount
 	assertOnlyNotHalted()
 
-	// unstaked status
+	// unStaked status
 	deposit := deposits.Get(tokenId)
 	poolPath := deposit.targetPoolPath
 
@@ -528,16 +544,16 @@ func UnstakeToken(tokenId uint64, unwrapResult bool) (string, string, string) {
 
 	prevAddr, prevPkgPath := getPrev()
 	std.Emit(
-		"UnstakeToken",
+		"UnStakeToken",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"lpTokenId", formatUint(tokenId),
-		"unwrapResult", formatBool(unwrapResult),
-		"internal_poolPath", poolPath,
-		"internal_from", deposit.owner.String(),
-		"internal_to", consts.STAKER_ADDR.String(),
-		"internal_amount0", token0Amount,
-		"internal_amount1", token1Amount,
+		"positionId", formatUint(tokenId),
+		"poolPath", poolPath,
+		"isRequestUnwrap", formatBool(unwrapResult),
+		"from", consts.STAKER_ADDR.String(),
+		"to", deposit.owner.String(),
+		"amount0", token0Amount,
+		"amount1", token1Amount,
 	)
 
 	return poolPath, token0Amount, token1Amount
@@ -579,15 +595,19 @@ func applyUnStake(tokenId uint64) {
 
 	prevAddr, prevPkgPath := getPrev()
 	std.Emit(
-		"UnstakeToken",
+		"UnStakeToken",
 		"prevAddr", prevAddr,
 		"prevRealm", prevPkgPath,
-		"lpTokenId", formatUint(tokenId),
-		"internal_poolPath", deposit.targetPoolPath,
-		"internal_from", GetOrigPkgAddr().String(),
-		"internal_to", deposit.owner.String(),
-		"internal_amount0", token0Amount,
-		"internal_amount1", token1Amount,
+		"positionId", formatUint(tokenId),
+		"poolPath", deposit.targetPoolPath,
+		"from", GetOrigPkgAddr().String(),
+		"to", deposit.owner.String(),
+		"amount0", token0Amount,
+		"amount1", token1Amount,
+		"liquidity", deposit.liquidity.ToString(),
+		"positionUpperTick", formatInt(upperTick),
+		"positionLowerTick", formatInt(lowerTick),
+		"currentTick", formatInt(currentTick),
 	)
 }
 
diff --git a/contract/r/gnoswap/staker/staker_external_incentive.gno b/contract/r/gnoswap/staker/staker_external_incentive.gno
index a11b5284f..994ee0625 100644
--- a/contract/r/gnoswap/staker/staker_external_incentive.gno
+++ b/contract/r/gnoswap/staker/staker_external_incentive.gno
@@ -25,9 +25,7 @@ func CreateExternalIncentive(
 	startTimestamp int64,
 	endTimestamp int64,
 ) {
-	common.IsHalted()
-
-	en.MintAndDistributeGns()
+	assertOnlyNotHalted()
 
 	if common.GetLimitCaller() {
 		prev := std.PrevRealm()
@@ -44,6 +42,8 @@ func CreateExternalIncentive(
 		))
 	}
 
+	en.MintAndDistributeGns()
+
 	// check token can be used as reward
 	if err := isAllowedForExternalReward(targetPoolPath, rewardToken); err != nil {
 		panic(err.Error())
@@ -57,7 +57,7 @@ func CreateExternalIncentive(
 		if ugnotSent != rewardAmount {
 			panic(addDetailToError(
 				errInvalidInput,
-				ufmt.Sprintf("staker.gno__CreateExternalIncentive() || user(%s) sent ugnot(%d) amount not equal to rewardAmount(%d)", std.PrevRealm().Addr(), ugnotSent, rewardAmount),
+				ufmt.Sprintf("user(%s) sent ugnot(%d) amount not equal to rewardAmount(%d)", getPrevAddr(), ugnotSent, rewardAmount),
 			))
 		}
 
@@ -81,7 +81,7 @@ func CreateExternalIncentive(
 		))
 	}
 
-	caller := std.PrevRealm().Addr()
+	caller := getPrevAddr()
 
 	// incentiveId := incentiveIdCompute(std.PrevRealm().Addr(), targetPoolPath, rewardToken, startTimestamp, endTimestamp, std.GetHeight())
 	incentiveId := incentiveIdByTime(startTimestamp, endTimestamp, caller, rewardToken)
@@ -125,26 +125,28 @@ func CreateExternalIncentive(
 
 	pool.incentives.create(caller, incentive)
 
-	prevAddr, prevRealm := getPrev()
+	prevAddr, prevPkgPath := getPrev()
 	std.Emit(
 		"CreateExternalIncentive",
 		"prevAddr", prevAddr,
-		"prevRealm", prevRealm,
-		"poolPath", targetPoolPath,
+		"prevRealm", prevPkgPath,
+		"incentiveId", incentiveId,
+		"targetPoolPath", targetPoolPath,
 		"rewardToken", rewardToken,
 		"rewardAmount", formatUint(rewardAmount),
 		"startTimestamp", formatInt(startTimestamp),
 		"endTimestamp", formatInt(endTimestamp),
-		"internal_incentiveId", incentiveId,
-		"internal_depositGnsAmount", formatUint(depositGnsAmount),
-		"internal_external", "created",
+		"depositGnsAmount", formatUint(depositGnsAmount),
+		"currentHeight", formatInt(std.GetHeight()),
+		"currentTime", formatInt(time.Now().Unix()),
+		"avgBlockTimeInMs", formatUint(gns.GetAvgBlockTimeInMs()),
 	)
 }
 
 // EndExternalIncentive ends the external incentive and refunds the remaining reward
 // ref: https://docs.gnoswap.io/contracts/staker/staker.gno#endexternalincentive
 func EndExternalIncentive(refundee std.Address, targetPoolPath, rewardToken string, startTimestamp, endTimestamp, height int64) {
-	common.IsHalted()
+	assertOnlyNotHalted()
 
 	pool, exists := pools.Get(targetPoolPath)
 	if !exists {
@@ -158,25 +160,25 @@ func EndExternalIncentive(refundee std.Address, targetPoolPath, rewardToken stri
 	if !exists {
 		panic(addDetailToError(
 			errCannotEndIncentive,
-			ufmt.Sprintf("staker.gno__EndExternalIncentive() || cannot end non existent incentive(%d:%d:%s:%s)", startTimestamp, endTimestamp, refundee, rewardToken),
+			ufmt.Sprintf("cannot end non existent incentive(%d:%d:%s:%s)", startTimestamp, endTimestamp, refundee, rewardToken),
 		))
 	}
 
-	now := std.GetHeight()
-	if now < ictv.endHeight {
+	currentHeight := std.GetHeight()
+	if currentHeight < ictv.endHeight {
 		panic(addDetailToError(
 			errCannotEndIncentive,
-			ufmt.Sprintf("staker.gno__EndExternalIncentive() || cannot end incentive before endHeight(%d), current(%d)", ictv.endHeight, now),
+			ufmt.Sprintf("cannot end incentive before endHeight(%d), current(%d)", ictv.endHeight, currentHeight),
 		))
 	}
 
 	// when incentive end time is over
 	// admin or refundee can end incentive ( left amount will be refunded )
-	caller := std.PrevRealm().Addr()
+	caller := getPrevAddr()
 	if caller != consts.ADMIN && caller != refundee {
 		panic(addDetailToError(
 			errNoPermission,
-			ufmt.Sprintf("staker.gno__EndExternalIncentive() || only refundee(%s) or admin(%s) can end incentive, but called from %s", refundee, consts.ADMIN, caller),
+			ufmt.Sprintf("only refundee(%s) or admin(%s) can end incentive, but called from %s", refundee, consts.ADMIN, caller),
 		))
 	}
 
@@ -204,18 +206,19 @@ func EndExternalIncentive(refundee std.Address, targetPoolPath, rewardToken stri
 	// also refund deposit gns amount
 	gns.Transfer(ictv.refundee, ictv.depositGnsAmount)
 
-	prevAddr, prevRealm := getPrev()
+	prevAddr, prevPkgPath := getPrev()
 	std.Emit(
 		"EndExternalIncentive",
 		"prevAddr", prevAddr,
-		"prevRealm", prevRealm,
-		"poolPath", targetPoolPath,
-		"rewardToken", rewardToken,
+		"prevRealm", prevPkgPath,
+		"incentiveId", ictv.incentiveId,
+		"targetPoolPath", targetPoolPath,
 		"refundee", refundee.String(),
-		"internal_endBy", ictv.refundee.String(),
-		"internal_refundAmount", formatUint(refund),
-		"internal_refundGnsAmount", formatUint(ictv.depositGnsAmount),
-		"internal_incentiveId", ufmt.Sprintf("%d:%d:%s:%s", startTimestamp, endTimestamp, refundee, rewardToken),
+		"refundToken", rewardToken,
+		"refundAmount", formatUint(refund),
+		"refundGnsAmount", formatUint(ictv.depositGnsAmount),
+		"isRequestUnwrap", ictv.rewardToken == consts.WUGNOT_PATH,
+		"externalIncentiveEndBy", getPrevAddr(),
 	)
 }