Merge pull request #531 from neutron-org/feat/dex-telemetry

NTRN-282 dex telemetry

x/dex/keeper/core.go

@@ -211,6 +211,7 @@ func (k Keeper) WithdrawCore(
 			receiverAddr,
 			sdk.Coins{coin0},
 		)
+		ctx.EventManager().EmitEvents(types.GetEventsWithdrawnAmount(sdk.Coins{coin0}))
 		if err != nil {
 			return err
 		}
@@ -225,6 +226,7 @@ func (k Keeper) WithdrawCore(
 			receiverAddr,
 			sdk.Coins{coin1},
 		)
+		ctx.EventManager().EmitEvents(types.GetEventsWithdrawnAmount(sdk.Coins{coin1}))
 		if err != nil {
 			return err
 		}
@@ -605,6 +607,7 @@ func (k Keeper) WithdrawFilledLimitOrderCore(
 		coinTakerDenomOut := sdk.NewCoin(tradePairID.TakerDenom, amountOutTokenOut)
 		coinMakerDenomRefund := sdk.NewCoin(tradePairID.MakerDenom, remainingTokenIn)
 		coins := sdk.NewCoins(coinTakerDenomOut, coinMakerDenomRefund)
+		ctx.EventManager().EmitEvents(types.GetEventsWithdrawnAmount(sdk.NewCoins(coinTakerDenomOut)))
 		if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, callerAddr, coins); err != nil {
 			return err
 		}

x/dex/keeper/limit_order_expiration.go

@@ -140,7 +140,7 @@ func (k Keeper) PurgeExpiredLimitOrders(ctx sdk.Context, curTime time.Time) {
 
 			return
 		}
-
+		var pairID types.TradePairID
 		if _, ok := archivedTranches[string(val.TrancheRef)]; !ok {
 			tranche, found := k.GetLimitOrderTrancheByKey(ctx, val.TrancheRef)
 			if found {
@@ -149,10 +149,12 @@ func (k Keeper) PurgeExpiredLimitOrders(ctx sdk.Context, curTime time.Time) {
 				k.RemoveLimitOrderTranche(ctx, tranche.Key)
 				archivedTranches[string(val.TrancheRef)] = true
 
+				pairID = *tranche.Key.TradePairId
 				ctx.EventManager().EmitEvent(types.CreateTickUpdateLimitOrderTranchePurge(tranche))
 			}
 		}
 
 		k.RemoveLimitOrderExpirationByKey(ctx, iterator.Key())
+		ctx.EventManager().EmitEvents(types.GetEventsDecExpiringOrders(&pairID))
 	}
 }

x/dex/keeper/limit_order_tranche.go

@@ -57,6 +57,7 @@ func (k Keeper) SaveTranche(ctx sdk.Context, tranche *types.LimitOrderTranche) {
 	} else {
 		k.SetInactiveLimitOrderTranche(ctx, tranche)
 		k.RemoveLimitOrderTranche(ctx, tranche.Key)
+ctx.EventManager().EmitEvents(types.GetEventsDecTotalOrders(tranche.Key.TradePairId))
 	}
 
 	ctx.EventManager().EmitEvent(types.CreateTickUpdateLimitOrderTranche(tranche))
@@ -221,13 +222,15 @@ func (k Keeper) GetOrInitPlaceTranche(ctx sdk.Context,
 			TrancheKey:            NewTrancheKey(ctx),
 		}
 		placeTranche, err = NewLimitOrderTranche(limitOrderTrancheKey, &JITGoodTilTime)
+		ctx.EventManager().EmitEvents(types.GetEventsIncTotalOrders(tradePairID))
 	case types.LimitOrderType_GOOD_TIL_TIME:
 		limitOrderTrancheKey := &types.LimitOrderTrancheKey{
 			TradePairId:           tradePairID,
 			TickIndexTakerToMaker: tickIndexTakerToMaker,
 			TrancheKey:            NewTrancheKey(ctx),
 		}
 		placeTranche, err = NewLimitOrderTranche(limitOrderTrancheKey, goodTil)
+		ctx.EventManager().EmitEvents(types.GetEventsIncExpiringOrders(tradePairID))
 	default:
 		placeTranche = k.GetGTCPlaceTranche(ctx, tradePairID, tickIndexTakerToMaker)
 		if placeTranche == nil {
@@ -237,6 +240,7 @@ func (k Keeper) GetOrInitPlaceTranche(ctx sdk.Context,
 				TrancheKey:            NewTrancheKey(ctx),
 			}
 			placeTranche, err = NewLimitOrderTranche(limitOrderTrancheKey, nil)
+			ctx.EventManager().EmitEvents(types.GetEventsIncTotalOrders(tradePairID))
 			if err != nil {
 				return nil, err
 			}

x/dex/keeper/liquidity.go

@@ -15,6 +15,7 @@ func (k Keeper) Swap(
 	maxAmountMakerDenom *math.Int,
 	limitPrice *math_utils.PrecDec,
 ) (totalTakerCoin, totalMakerCoin sdk.Coin, orderFilled bool, err error) {
+	gasBefore := ctx.GasMeter().GasConsumed()
 	useMaxOut := maxAmountMakerDenom != nil
 	var remainingMakerDenom *math.Int
 	if useMaxOut {
@@ -73,6 +74,9 @@ func (k Keeper) Swap(
 	}
 	totalTakerDenom := maxAmountTakerDenom.Sub(remainingTakerDenom)
 
+	gasAfter := ctx.GasMeter().GasConsumed()
+	ctx.EventManager().EmitEvents(types.GetEventsGasConsumed(gasBefore, gasAfter))
+
 	return sdk.NewCoin(
 			tradePairID.TakerDenom,
 			totalTakerDenom,

x/dex/keeper/msg_server.go

@@ -238,7 +238,6 @@ func (k MsgServer) MultiHopSwap(
 	if err != nil {
 		return &types.MsgMultiHopSwapResponse{}, err
 	}
-
 	return &types.MsgMultiHopSwapResponse{CoinOut: coinOut}, nil
 }
 

x/dex/keeper/pool.go

@@ -20,7 +20,7 @@ func (k Keeper) GetOrInitPool(
 	if found {
 		return pool, nil
 	}
-
+	ctx.EventManager().EmitEvents(types.GetEventsIncTotalPoolReserves(*pairID))
 	return k.InitPool(ctx, pairID, centerTickIndexNormalized, fee)
 }
 
@@ -149,6 +149,7 @@ func (k Keeper) updatePoolReserves(ctx sdk.Context, reserves *types.PoolReserves
 	if reserves.HasToken() {
 		k.SetPoolReserves(ctx, reserves)
 	} else {
+		ctx.EventManager().EmitEvents(types.GetEventsDecTotalPoolReserves(*reserves.Key.TradePairId.MustPairID()))
 		k.RemovePoolReserves(ctx, reserves.Key)
 	}
 }

x/dex/types/events.go

@@ -244,3 +244,105 @@ func GoodTilPurgeHitLimitEvent(gas types.Gas) sdk.Event {
 
 	return sdk.NewEvent(EventTypeGoodTilPurgeHitGasLimit, attrs...)
 }
+
+func GetEventsWithdrawnAmount(coins sdk.Coins) sdk.Events {
+	events := sdk.Events{}
+	for _, coin := range coins {
+		event := sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(AttributeDenom, coin.Denom),
+			sdk.NewAttribute(AttributeWithdrawn, coin.Amount.String()),
+		)
+		events = append(events, event)
+	}
+	return events
+}
+
+func GetEventsGasConsumed(gasBefore, gasAfter types.Gas) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(AttributeGasConsumed, strconv.FormatUint(gasAfter-gasBefore, 10)),
+		),
+	}
+}
+
+func GetEventsIncExpiringOrders(pairID *TradePairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeInc),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLimitOrder),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(true)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}
+
+func GetEventsDecExpiringOrders(pairID *TradePairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeDec),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLimitOrder),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(true)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}
+
+func GetEventsIncTotalOrders(pairID *TradePairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeInc),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLimitOrder),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(false)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}
+
+func GetEventsDecTotalOrders(pairID *TradePairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeDec),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLimitOrder),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(false)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}
+
+func GetEventsIncTotalPoolReserves(pairID PairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeInc),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLp),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(false)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}
+
+func GetEventsDecTotalPoolReserves(pairID PairID) sdk.Events {
+	return sdk.Events{
+		sdk.NewEvent(
+			EventTypeNeutronMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, ModuleName),
+			sdk.NewAttribute(sdk.AttributeKeyAction, AttributeDec),
+			sdk.NewAttribute(AttributeLiquidityTickType, AttributeLp),
+			sdk.NewAttribute(AttributeIsExpiringLimitOrder, strconv.FormatBool(false)),
+			sdk.NewAttribute(AttributePairID, pairID.String()),
+		),
+	}
+}

x/dex/types/types.go

@@ -1 +1,17 @@
 package types
+
+const (
+	// EventTypeNeutronMessage defines the event type used by the Interchain Queries module events.
+	EventTypeNeutronMessage = "neutron"
+
+	AttributeDenom                = "denom"
+	AttributeWithdrawn            = "total_withdrawn"
+	AttributeGasConsumed          = "gas_consumed"
+	AttributeLiquidityTickType    = "liquidity_tick_type"
+	AttributeLp                   = "lp"
+	AttributeLimitOrder           = "limit_order"
+	AttributeIsExpiringLimitOrder = "is_expiring_limit_order"
+	AttributeInc                  = "inc"
+	AttributeDec                  = "dec"
+	AttributePairID               = "pair_id"
+)