feat: added info, warn, error and debug level logs

Author: 0xNilesh

app/ante/account_init_decorator.go

@@ -31,6 +31,7 @@ func NewAccountInitDecorator(ak AccountKeeper, signModeHandler *txsigning.Handle
 func (aid AccountInitDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
 	if !txpolicy.IsGaslessTx(tx) {
 		// Skip account initialization for non-gasless transactions
+		ctx.Logger().Debug("account init decorator: non-gasless tx, skipping account init")
 		return next(ctx, tx, simulate)
 	}
 
@@ -41,23 +42,41 @@ func (aid AccountInitDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 
 	signers, err := sigTx.GetSigners()
 	if err != nil || len(signers) != 1 {
+		ctx.Logger().Debug("account init decorator: could not get unique signer, passing to next handler",
+			"num_signers", len(signers),
+			"error", err,
+		)
 		return next(ctx, tx, simulate)
 	}
 
 	newAccAddr := signers[0]
 	if !aid.ak.HasAccount(ctx, newAccAddr) {
+		ctx.Logger().Debug("account init decorator: new account detected on gasless tx, verifying signature",
+			"address", sdk.AccAddress(newAccAddr).String(),
+			"simulate", simulate,
+		)
 		// if account does not exist on chain, bypass rest of ante chain (especially gas and signature verification) here.
 		// Perform signature verification on account number e and sequence number e instead.
 		if err := aid.verifySignatureForNewAccount(ctx, tx, simulate); err != nil {
+			ctx.Logger().Debug("account init decorator: signature verification failed for new account",
+				"address", sdk.AccAddress(newAccAddr).String(),
+				"error", err,
+			)
 			return ctx, err
 		}
 
 		acc := aid.ak.NewAccountWithAddress(ctx, newAccAddr)
 		acc.SetSequence(1)
 		aid.ak.SetAccount(ctx, acc)
+		ctx.Logger().Info("account init decorator: new account created via gasless tx",
+			"address", sdk.AccAddress(newAccAddr).String(),
+		)
 		return ctx, nil
 	}
 
+	ctx.Logger().Debug("account init decorator: existing account on gasless tx, passing to next handler",
+		"address", sdk.AccAddress(newAccAddr).String(),
+	)
 	return next(ctx, tx, simulate)
 }
 
@@ -115,6 +134,12 @@ func (aid AccountInitDecorator) verifySignatureForNewAccount(ctx sdk.Context, tx
 				return fmt.Errorf("expected tx to implement V2AdaptableTx, got %T", tx)
 			}
 			txData := adaptableTx.GetSigningTxData()
+			ctx.Logger().Debug("account init decorator: verifying signature for new account",
+				"address", newAccAddr.String(),
+				"chain_id", chainID,
+				"acc_num", accNum,
+				"sequence", accSequence,
+			)
 			err = authsigning.VerifySignature(ctx, pubKey, signerData, sig.Data, aid.signModeHandler, txData)
 			if err != nil {
 				var errMsg string
@@ -125,9 +150,20 @@ func (aid AccountInitDecorator) verifySignatureForNewAccount(ctx sdk.Context, tx
 				} else {
 					errMsg = fmt.Sprintf("signature verification failed; please verify account number (%d) and chain-id (%s): (%s)", accNum, chainID, err.Error())
 				}
+				ctx.Logger().Debug("account init decorator: signature invalid for new account",
+					"address", newAccAddr.String(),
+					"chain_id", chainID,
+				)
 				return errorsmod.Wrap(sdkerrors.ErrUnauthorized, errMsg)
 
 			}
+		} else {
+			ctx.Logger().Debug("account init decorator: skipping signature verification",
+				"address", newAccAddr.String(),
+				"simulate", simulate,
+				"is_recheck_tx", ctx.IsReCheckTx(),
+				"is_sigverify_tx", ctx.IsSigverifyTx(),
+			)
 		}
 	}
 	return nil

app/ante/fee.go

@@ -59,18 +59,35 @@ func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bo
 	// Check if this is a gasless transaction
 	if txpolicy.IsGaslessTx(tx) {
 		// Skip fee deduction for Gasless messages
+		ctx.Logger().Debug("deduct fee decorator: gasless tx detected, skipping fee deduction")
 		return next(ctx, tx, simulate)
 	}
 
 	fee := feeTx.GetFee()
 	if !simulate {
 		fee, priority, err = dfd.txFeeChecker(ctx, tx)
 		if err != nil {
+			ctx.Logger().Debug("deduct fee decorator: tx fee check failed",
+				"fee", feeTx.GetFee().String(),
+				"gas", feeTx.GetGas(),
+				"error", err,
+			)
 			return ctx, err
 		}
 	}
 
+	ctx.Logger().Debug("deduct fee decorator: deducting fees",
+		"fee", fee.String(),
+		"gas", feeTx.GetGas(),
+		"simulate", simulate,
+		"priority", priority,
+	)
+
 	if err := dfd.checkDeductFee(ctx, tx, fee); err != nil {
+		ctx.Logger().Debug("deduct fee decorator: fee deduction failed",
+			"fee", fee.String(),
+			"error", err,
+		)
 		return ctx, err
 	}
 
@@ -101,8 +118,18 @@ func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee
 		if dfd.feegrantKeeper == nil {
 			return sdkerrors.ErrInvalidRequest.Wrap("fee grants are not enabled")
 		} else if !bytes.Equal(feeGranterAddr, feePayer) {
+			ctx.Logger().Debug("deduct fee decorator: using fee grant",
+				"fee_granter", feeGranterAddr.String(),
+				"fee_payer", sdk.AccAddress(feePayer).String(),
+				"fee", fee.String(),
+			)
 			err := dfd.feegrantKeeper.UseGrantedFees(ctx, feeGranterAddr, feePayer, fee, sdkTx.GetMsgs())
 			if err != nil {
+				ctx.Logger().Debug("deduct fee decorator: fee grant use failed",
+					"fee_granter", feeGranterAddr.String(),
+					"fee_payer", sdk.AccAddress(feePayer).String(),
+					"error", err,
+				)
 				return errorsmod.Wrapf(err, "%s does not allow to pay fees for %s", feeGranter, feePayer)
 			}
 		}
@@ -117,10 +144,23 @@ func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee
 
 	// deduct the fees
 	if !fee.IsZero() {
+		ctx.Logger().Debug("deduct fee decorator: sending fees to fee collector",
+			"from", sdk.AccAddress(deductFeesFrom).String(),
+			"fee", fee.String(),
+		)
 		err := DeductFees(dfd.bankKeeper, ctx, deductFeesFromAcc, fee)
 		if err != nil {
+			ctx.Logger().Debug("deduct fee decorator: failed to send fees to fee collector",
+				"from", sdk.AccAddress(deductFeesFrom).String(),
+				"fee", fee.String(),
+				"error", err,
+			)
 			return err
 		}
+	} else {
+		ctx.Logger().Debug("deduct fee decorator: zero fee, skipping bank transfer",
+			"from", sdk.AccAddress(deductFeesFrom).String(),
+		)
 	}
 
 	events := sdk.Events{

app/ante/validator_tx_fee.go

@@ -21,6 +21,12 @@ func checkTxFeeWithValidatorMinGasPrices(ctx sdk.Context, tx sdk.Tx) (sdk.Coins,
 	feeCoins := feeTx.GetFee()
 	gas := feeTx.GetGas()
 
+	ctx.Logger().Debug("validator min gas price check",
+		"fee", feeCoins.String(),
+		"gas", gas,
+		"is_check_tx", ctx.IsCheckTx(),
+	)
+
 	// Ensure that the provided fees meet a minimum threshold for the validator,
 	// if this is a CheckTx. This is only for local mempool purposes, and thus
 	// is only ran on check tx.
@@ -38,12 +44,30 @@ func checkTxFeeWithValidatorMinGasPrices(ctx sdk.Context, tx sdk.Tx) (sdk.Coins,
 			}
 
 			if !feeCoins.IsAnyGTE(requiredFees) {
+				ctx.Logger().Debug("validator min gas price check: insufficient fee rejected",
+					"fee_provided", feeCoins.String(),
+					"fee_required", requiredFees.String(),
+					"gas", gas,
+				)
 				return nil, 0, errorsmod.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %s required: %s", feeCoins, requiredFees)
 			}
+
+			ctx.Logger().Debug("validator min gas price check: fee meets minimum",
+				"fee_provided", feeCoins.String(),
+				"fee_required", requiredFees.String(),
+				"gas", gas,
+			)
+		} else {
+			ctx.Logger().Debug("validator min gas price check: no min gas price set, bypassing check")
 		}
 	}
 
 	priority := getTxPriority(feeCoins, int64(gas))
+	ctx.Logger().Debug("validator min gas price check: computed tx priority",
+		"fee", feeCoins.String(),
+		"gas", gas,
+		"priority", priority,
+	)
 	return feeCoins, priority, nil
 }
 

x/uexecutor/keeper/chain_meta.go

@@ -53,6 +53,12 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 
 	if !found {
 		// First vote for this chain — no height check needed yet.
+		k.Logger().Info("chain meta first vote, initializing entry",
+			"chain_id", observedChainId,
+			"validator", universalValidator.String(),
+			"price", price,
+			"block_number", blockNumber,
+		)
 		priceBig := math.NewUint(price).BigInt()
 		chainHeightBig := math.NewUint(blockNumber).BigInt()
 		if _, evmErr := k.CallUniversalCoreSetChainMeta(sdkCtx, observedChainId, priceBig, chainHeightBig); evmErr != nil {
@@ -77,6 +83,12 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 
 	// Reject votes whose chain height has already been committed to the contract.
 	if blockNumber <= entry.LastAppliedChainHeight {
+		k.Logger().Warn("chain meta vote rejected: stale block height",
+			"chain_id", observedChainId,
+			"validator", universalValidator.String(),
+			"vote_height", blockNumber,
+			"last_applied_height", entry.LastAppliedChainHeight,
+		)
 		return fmt.Errorf(
 			"vote chain height %d is not greater than last applied chain height %d; re-vote with a newer block",
 			blockNumber, entry.LastAppliedChainHeight,
@@ -122,6 +134,10 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 	}
 
 	if len(fresh) == 0 {
+		k.Logger().Debug("chain meta vote recorded, no fresh votes for EVM update",
+			"chain_id", observedChainId,
+			"validator", universalValidator.String(),
+		)
 		// No fresh votes — persist the updated entry but skip EVM call.
 		if err := k.SetChainMeta(ctx, observedChainId, entry); err != nil {
 			return sdkerrors.Wrap(err, "failed to set updated chain meta entry")
@@ -133,6 +149,13 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 	medianPrice := upperMedianUint64(fresh, func(v voteSnapshot) uint64 { return v.price })
 	medianChainHeight := upperMedianUint64(fresh, func(v voteSnapshot) uint64 { return v.chainHeight })
 
+	k.Logger().Debug("chain meta medians computed",
+		"chain_id", observedChainId,
+		"fresh_votes", len(fresh),
+		"median_price", medianPrice,
+		"median_chain_height", medianChainHeight,
+	)
+
 	// Update MedianIndex to reflect the price median position in the full slice
 	// (best-effort; used for storage/querying only).
 	entry.MedianIndex = uint64(computeMedianIndex(entry.Prices))
@@ -148,6 +171,12 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 		return sdkerrors.Wrap(err, "failed to set updated chain meta entry")
 	}
 
+	k.Logger().Info("chain meta updated",
+		"chain_id", observedChainId,
+		"median_price", medianPrice,
+		"median_chain_height", medianChainHeight,
+	)
+
 	return nil
 }
 
@@ -167,10 +196,12 @@ func upperMedianUint64[T any](items []T, key func(T) uint64) uint64 {
 // Called once during the chain-meta upgrade. Existing gas price data (prices, block_nums, median_index)
 // is carried over; StoredAts defaults to zero (treated as stale until validators re-vote).
 func (k Keeper) MigrateGasPricesToChainMeta(ctx context.Context) error {
+	k.Logger().Info("migrating gas prices to chain metas")
 	return k.GasPrices.Walk(ctx, nil, func(chainID string, gp types.GasPrice) (bool, error) {
 		// Skip if already migrated
 		existing, err := k.ChainMetas.Get(ctx, chainID)
 		if err == nil && existing.ObservedChainId != "" {
+			k.Logger().Debug("chain meta migration skipped: already exists", "chain_id", chainID)
 			return false, nil // already exists, skip
 		}
 
@@ -190,6 +221,7 @@ func (k Keeper) MigrateGasPricesToChainMeta(ctx context.Context) error {
 			return true, err
 		}
 
+		k.Logger().Info("chain meta migrated from gas price", "chain_id", chainID, "signer_count", len(gp.Signers))
 		return false, nil
 	})
 }

x/uexecutor/keeper/create_outbound.go

@@ -22,6 +22,8 @@ func (k Keeper) BuildOutboundsFromReceipt(
 	outbounds := []*types.OutboundTx{}
 	universalGatewayPC := strings.ToLower(uregistrytypes.SYSTEM_CONTRACTS["UNIVERSAL_GATEWAY_PC"].Address)
 
+	k.Logger().Debug("building outbounds from receipt", "utx_id", utxId, "tx_hash", receipt.Hash, "log_count", len(receipt.Logs))
+
 	for _, lg := range receipt.Logs {
 		if lg.Removed {
 			continue
@@ -50,6 +52,7 @@ func (k Keeper) BuildOutboundsFromReceipt(
 			return nil, fmt.Errorf("failed to check outbound enabled for chain %s: %w", event.ChainId, err)
 		}
 		if !outboundEnabled {
+			k.Logger().Warn("outbound disabled for chain", "chain_id", event.ChainId, "utx_id", utxId)
 			return nil, fmt.Errorf("outbound is disabled for chain %s", event.ChainId)
 		}
 
@@ -87,9 +90,17 @@ func (k Keeper) BuildOutboundsFromReceipt(
 			Id:             strings.TrimPrefix(event.TxID, "0x"),
 		}
 
+		k.Logger().Debug("outbound built from receipt",
+			"utx_id", utxId,
+			"outbound_id", outbound.Id,
+			"dest_chain", outbound.DestinationChain,
+			"amount", outbound.Amount,
+			"tx_type", outbound.TxType.String(),
+		)
 		outbounds = append(outbounds, outbound)
 	}
 
+	k.Logger().Debug("outbounds built from receipt", "utx_id", utxId, "count", len(outbounds))
 	return outbounds, nil
 }
 
@@ -112,16 +123,18 @@ func (k Keeper) CreateUniversalTxFromPCTx(
 	}
 
 	utx := types.UniversalTx{
-		Id:              universalTxKey,
-		InboundTx:       nil,                  // no inbound
-		PcTx:            []*types.PCTx{&pcTx}, // origin is PC
-		OutboundTx:      nil,
+		Id:         universalTxKey,
+		InboundTx:  nil,                  // no inbound
+		PcTx:       []*types.PCTx{&pcTx}, // origin is PC
+		OutboundTx: nil,
 	}
 
 	if err := k.CreateUniversalTx(ctx, universalTxKey, utx); err != nil {
 		return nil, err
 	}
 
+	k.Logger().Info("utx created from pc tx", "utx_key", universalTxKey, "pc_tx_hash", pcTx.TxHash)
+
 	return &utx, nil
 }
 
@@ -248,13 +261,22 @@ func (k Keeper) AttachRescueOutboundFromReceipt(
 			}
 		}
 
+		k.Logger().Info("rescue outbound detected",
+			"original_utx_id", originalUtxId,
+			"pc_tx_hash", receipt.Hash,
+		)
+
 		// Guard against duplicate rescue outbounds: reject if an active rescue
 		// (PENDING or OBSERVED) already exists. A REVERTED rescue may be retried.
 		for _, ob := range originalUtx.OutboundTx {
 			if ob == nil || ob.TxType != types.TxType_RESCUE_FUNDS {
 				continue
 			}
 			if ob.OutboundStatus == types.Status_PENDING || ob.OutboundStatus == types.Status_OBSERVED {
+				k.Logger().Warn("rescue outbound rejected: active rescue already exists",
+					"original_utx_id", originalUtxId,
+					"existing_outbound_id", ob.Id,
+				)
 				return fmt.Errorf("rescue: UTX %s already has an active rescue outbound (%s)", originalUtxId, ob.Id)
 			}
 		}