x/superfluid: ensure events are emitted and tests added

x/superfluid/README.md

@@ -455,7 +455,88 @@ Disable multiple assets from being used for superfluid staking.
 
 ## Events
 
------;
+There are 7 types of events that exist in Superfluid module:
+
+* `types.TypeEvtSetSuperfluidAsset` - "set_superfluid_asset"
+* `types.TypeEvtRemoveSuperfluidAsset` - "remove_superfluid_asset"
+* `types.TypeEvtSuperfluidDelegate` - "superfluid_delegate"
+* `types.TypeEvtSuperfluidIncreaseDelegation` - "superfluid_increase_delegation"
+* `types.TypeEvtSuperfluidUndelegate` - "superfluid_undelegate"
+* `types.TypeEvtSuperfluidUnbondLock` - "superfluid_unbond_lock"
+* `types.TypeEvtUnpoolId` - "unpool_pool_id"
+
+### `types.TypeEvtSetSuperfluidAsset`
+
+This event is emitted in the proposal which set new superfluid asset
+
+It consists of the following attributes:
+
+* `types.AttributeDenom`
+  * The value is the asset denom.
+* `types.AttributeSuperfluidAssetType`
+  * The value is the type of asset.
+
+### `types.TypeEvtRemoveSuperfluidAsset`
+
+This event is emitted in the proposal which removes the superfluid asset
+
+It consists of the following attributes:
+
+* `types.AttributeDenom`
+  * The value is the asset denom.
+
+### `types.TypeEvtSuperfluidDelegate`
+
+This event is emitted in the message server after successfully creating a delegation for the given lock ID and the validator to delegate to.
+
+It consists of the following attributes:
+
+* `types.AttributeLockId`
+  * The value is the given lock ID.
+* `types.AttributeValidator`
+  * The value is the validator address to delegate to.
+
+### `types.TypeEvtSuperfluidIncreaseDelegation`
+
+This event is emitted in the hook after adding more token to the existing lock
+
+It consists of the following attributes:
+
+* `types.AttributeLockId`
+  * The value is the given lock ID.
+* `types.AttributeAmount`
+  * The value is the token amount added to the lock.
+
+### `types.TypeEvtSuperfluidUndelegate`
+
+This event is emitted in the message server after undelegating the currently superfluid delegated position given by lock ID.
+
+It consists of the following attributes:
+
+* `types.AttributeLockId`
+  * The value is the given lock ID.
+
+### `types.TypeEvtSuperfluidUnbondLock`
+
+This event is emitted in the message server after starting unbonding for the currently superfluid undelegating lock.
+
+It consists of the following attributes:
+
+* `types.AttributeLockId`
+  * The value is the given lock ID.
+
+### `types.TypeEvtUnpoolId`
+
+This event is emitted in the message server `UnPoolWhitelistedPool`
+
+It consists of the following attributes:
+
+* `types.AttributeKeySender`
+  * The value is the msg sender address.
+* `types.AttributeLockId`
+  * The value is the pool lpShareDenom.
+* `types.AttributeNewLockIds`
+  * The value is the exited lock ids in byte[].
 
 ### Messages
 

x/superfluid/keeper/gov/gov.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/osmosis-labs/osmosis/v10/x/superfluid/keeper"
+	"github.com/osmosis-labs/osmosis/v10/x/superfluid/keeper/internal/events"
 	"github.com/osmosis-labs/osmosis/v10/x/superfluid/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -12,12 +13,7 @@ import (
 func HandleSetSuperfluidAssetsProposal(ctx sdk.Context, k keeper.Keeper, ek types.EpochKeeper, p *types.SetSuperfluidAssetsProposal) error {
 	for _, asset := range p.Assets {
 		k.AddNewSuperfluidAsset(ctx, asset)
-		event := sdk.NewEvent(
-			types.TypeEvtSetSuperfluidAsset,
-			sdk.NewAttribute(types.AttributeDenom, asset.Denom),
-			sdk.NewAttribute(types.AttributeSuperfluidAssetType, asset.AssetType.String()),
-		)
-		ctx.EventManager().EmitEvent(event)
+		events.EmitSetSuperfluidAssetEvent(ctx, asset.Denom, asset.AssetType)
 	}
 	return nil
 }
@@ -30,11 +26,7 @@ func HandleRemoveSuperfluidAssetsProposal(ctx sdk.Context, k keeper.Keeper, p *t
 			return fmt.Errorf("superfluid asset %s doesn't exist", denom)
 		}
 		k.BeginUnwindSuperfluidAsset(ctx, 0, asset)
-		event := sdk.NewEvent(
-			types.TypeEvtRemoveSuperfluidAsset,
-			sdk.NewAttribute(types.AttributeDenom, denom),
-		)
-		ctx.EventManager().EmitEvent(event)
+		events.EmitRemoveSuperfluidAsset(ctx, denom)
 	}
 	return nil
 }

x/superfluid/keeper/gov/gov_test.go

@@ -59,6 +59,7 @@ func (suite *KeeperTestSuite) TestHandleSetSuperfluidAssetsProposal() {
 		assets         []types.SuperfluidAsset
 		expectedAssets []types.SuperfluidAsset
 		expectErr      bool
+		expectedEvent  string
 	}
 	testCases := []struct {
 		name    string
@@ -68,21 +69,21 @@ func (suite *KeeperTestSuite) TestHandleSetSuperfluidAssetsProposal() {
 			"happy path flow",
 			[]Action{
 				{
-					true, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{asset1}, false,
+					true, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{asset1}, false, types.TypeEvtSetSuperfluidAsset,
 				},
 				{
-					false, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{}, false,
+					false, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{}, false, types.TypeEvtRemoveSuperfluidAsset,
 				},
 			},
 		},
 		{
 			"token does not exist",
 			[]Action{
 				{
-					true, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{asset1}, false,
+					true, []types.SuperfluidAsset{asset1}, []types.SuperfluidAsset{asset1}, false, types.TypeEvtSetSuperfluidAsset,
 				},
 				{
-					false, []types.SuperfluidAsset{asset2}, []types.SuperfluidAsset{asset1}, true,
+					false, []types.SuperfluidAsset{asset2}, []types.SuperfluidAsset{asset1}, true, types.TypeEvtRemoveSuperfluidAsset,
 				},
 			},
 		},
@@ -132,6 +133,7 @@ func (suite *KeeperTestSuite) TestHandleSetSuperfluidAssetsProposal() {
 					suite.Require().Error(err)
 				} else {
 					suite.Require().NoError(err)
+					assertEventEmitted(suite, suite.ctx, action.expectedEvent, 1)
 				}
 
 				// check assets individually

x/superfluid/keeper/gov/suite_test.go

@@ -30,3 +30,15 @@ func (suite *KeeperTestSuite) SetupTest() {
 func TestKeeperTestSuite(t *testing.T) {
 	suite.Run(t, new(KeeperTestSuite))
 }
+
+func assertEventEmitted(suite *KeeperTestSuite, ctx sdk.Context, eventTypeExpected string, numEventsExpected int) {
+	allEvents := ctx.EventManager().Events()
+	// filter out other events
+	actualEvents := make([]sdk.Event, 0, 1)
+	for _, event := range allEvents {
+		if event.Type == eventTypeExpected {
+			actualEvents = append(actualEvents, event)
+		}
+	}
+	suite.Require().Equal(numEventsExpected, len(actualEvents))
+}

x/superfluid/keeper/hooks.go

@@ -1,11 +1,10 @@
 package keeper
 
 import (
-	"fmt"
 	"time"
 
 	epochstypes "github.com/osmosis-labs/osmosis/v10/x/epochs/types"
-	"github.com/osmosis-labs/osmosis/v10/x/superfluid/types"
+	"github.com/osmosis-labs/osmosis/v10/x/superfluid/keeper/internal/events"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -43,11 +42,7 @@ func (h Hooks) AfterAddTokensToLock(ctx sdk.Context, address sdk.AccAddress, loc
 		if err != nil {
 			h.k.Logger(ctx).Error(err.Error())
 		} else {
-			ctx.EventManager().EmitEvent(sdk.NewEvent(
-				types.TypeEvtSuperfluidIncreaseDelegation,
-				sdk.NewAttribute(types.AttributeLockId, fmt.Sprintf("%d", lockID)),
-				sdk.NewAttribute(types.AttributeAmount, amount.String()),
-			))
+			events.EmitSuperfluidIncreaseDelegationEvent(ctx, lockID, amount)
 		}
 	}
 }

x/superfluid/keeper/hooks_test.go

@@ -1,8 +1,14 @@
 package keeper_test
 
 import (
+	"time"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	lockupkeeper "github.com/osmosis-labs/osmosis/v10/x/lockup/keeper"
+	lockuptypes "github.com/osmosis-labs/osmosis/v10/x/lockup/types"
+	"github.com/osmosis-labs/osmosis/v10/x/superfluid/types"
 )
 
 func (suite *KeeperTestSuite) TestSuperfluidAfterEpochEnd() {
@@ -303,3 +309,31 @@ func (suite *KeeperTestSuite) TestBeforeSlashingUnbondingDelegationHook() {
 		})
 	}
 }
+
+// TestAfterAddTokensToLock_Event tests that events are correctly emitted
+// when calling AfterAddTokensToLock.
+func (suite *KeeperTestSuite) TestAfterAddTokensToLock_Event() {
+	suite.SetupTest()
+
+	valAddrs := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded})
+
+	denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20)})
+
+	// setup superfluid delegations
+	_, intermediaryAccs, locks := suite.setupSuperfluidDelegations(valAddrs, []superfluidDelegation{{0, 0, 0, 1000000}}, denoms)
+	suite.checkIntermediaryAccountDelegations(intermediaryAccs)
+
+	for index, lock := range locks {
+		lockupMsgServer := lockupkeeper.NewMsgServerImpl(suite.App.LockupKeeper)
+		c := sdk.WrapSDKContext(suite.Ctx)
+		coinsToLock := sdk.NewCoins(sdk.NewCoin(denoms[index], sdk.NewInt(100)))
+		sender, _ := sdk.AccAddressFromBech32(lock.Owner)
+		suite.FundAcc(sender, coinsToLock)
+
+		_, err := lockupMsgServer.LockTokens(c, lockuptypes.NewMsgLockTokens(sender, time.Hour*504, coinsToLock))
+		suite.Require().NoError(err)
+
+		// should call AfterAddTokensToLock hook and emit event here
+		assertEventEmitted(suite, suite.Ctx, types.TypeEvtSuperfluidIncreaseDelegation, 1)
+	}
+}

x/superfluid/keeper/internal/events/emit.go

@@ -0,0 +1,133 @@
+package events
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/osmosis-labs/osmosis/v10/x/superfluid/types"
+)
+
+func EmitSetSuperfluidAssetEvent(ctx sdk.Context, denom string, assetType types.SuperfluidAssetType) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newSetSuperfluidAssetEvent(denom, assetType),
+	})
+}
+
+func newSetSuperfluidAssetEvent(denom string, assetType types.SuperfluidAssetType) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtSetSuperfluidAsset,
+		sdk.NewAttribute(types.AttributeDenom, denom),
+		sdk.NewAttribute(types.AttributeSuperfluidAssetType, assetType.String()),
+	)
+}
+
+func EmitRemoveSuperfluidAsset(ctx sdk.Context, denom string) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newRemoveSuperfluidAssetEvent(denom),
+	})
+}
+
+func newRemoveSuperfluidAssetEvent(denom string) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtRemoveSuperfluidAsset,
+		sdk.NewAttribute(types.AttributeDenom, denom),
+	)
+}
+
+func EmitSuperfluidDelegateEvent(ctx sdk.Context, lockId uint64, valAddress string) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newSuperfluidDelegateEvent(lockId, valAddress),
+	})
+}
+
+func newSuperfluidDelegateEvent(lockId uint64, valAddress string) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtSuperfluidDelegate,
+		sdk.NewAttribute(types.AttributeLockId, fmt.Sprintf("%d", lockId)),
+		sdk.NewAttribute(types.AttributeValidator, valAddress),
+	)
+}
+
+func EmitSuperfluidIncreaseDelegationEvent(ctx sdk.Context, lockId uint64, amount sdk.Coins) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newSuperfluidIncreaseDelegationEvent(lockId, amount),
+	})
+}
+
+func newSuperfluidIncreaseDelegationEvent(lockId uint64, amount sdk.Coins) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtSuperfluidIncreaseDelegation,
+		sdk.NewAttribute(types.AttributeLockId, fmt.Sprintf("%d", lockId)),
+		sdk.NewAttribute(types.AttributeAmount, amount.String()),
+	)
+}
+
+func EmitSuperfluidUndelegateEvent(ctx sdk.Context, lockId uint64) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newSuperfluidUndelegateEvent(lockId),
+	})
+}
+
+func newSuperfluidUndelegateEvent(lockId uint64) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtSuperfluidUndelegate,
+		sdk.NewAttribute(types.AttributeLockId, fmt.Sprintf("%d", lockId)),
+	)
+}
+
+func EmitSuperfluidUnbondLockEvent(ctx sdk.Context, lockId uint64) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newSuperfluidUnbondLockEvent(lockId),
+	})
+}
+
+func newSuperfluidUnbondLockEvent(lockId uint64) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtSuperfluidUnbondLock,
+		sdk.NewAttribute(types.AttributeLockId, fmt.Sprintf("%d", lockId)),
+	)
+}
+
+func EmitUnpoolIdEvent(ctx sdk.Context, sender string, lpShareDenom string, allExitedLockIDsSerialized []byte) {
+	if ctx.EventManager() == nil {
+		return
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		newUnpoolIdEvent(sender, lpShareDenom, allExitedLockIDsSerialized),
+	})
+}
+
+func newUnpoolIdEvent(sender string, lpShareDenom string, allExitedLockIDsSerialized []byte) sdk.Event {
+	return sdk.NewEvent(
+		types.TypeEvtUnpoolId,
+		sdk.NewAttribute(sdk.AttributeKeySender, sender),
+		sdk.NewAttribute(types.AttributeDenom, lpShareDenom),
+		sdk.NewAttribute(types.AttributeNewLockIds, string(allExitedLockIDsSerialized)),
+	)
+}