remove redundant fields in log message; unified logs

zetaclient/chains/evm/observer/outbound.go

@@ -13,7 +13,6 @@ import (
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 	"github.com/zeta-chain/protocol-contracts/pkg/contracts/evm/erc20custody.sol"
 	"github.com/zeta-chain/protocol-contracts/pkg/contracts/evm/zetaconnector.non-eth.sol"
 
@@ -414,36 +413,30 @@ func (ob *Observer) checkConfirmedTx(
 	ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
 	defer cancel()
 
+	// prepare logger
+	logger := ob.Logger().Outbound.With().
+		Str(logs.FieldMethod, "checkConfirmedTx").
+		Int64(logs.FieldChain, ob.Chain().ChainId).
+		Uint64(logs.FieldNonce, nonce).
+		Str(logs.FieldTx, txHash).
+		Logger()
+
 	// query transaction
 	transaction, isPending, err := ob.evmClient.TransactionByHash(ctx, ethcommon.HexToHash(txHash))
 	if err != nil {
-		log.Error().
-			Err(err).
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", txHash).
-			Int64("chainID", ob.Chain().ChainId).
-			Msg("error getting transaction for outbound")
+		logger.Error().Err(err).Msg("TransactionByHash error")
 		return nil, nil, false
 	}
 	if transaction == nil { // should not happen
-		log.Error().
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", txHash).
-			Uint64("nonce", nonce).
-			Msg("transaction is nil for txHash")
+		logger.Error().Msg("transaction is nil")
 		return nil, nil, false
 	}
 
 	// check tx sender and nonce
 	signer := ethtypes.NewLondonSigner(big.NewInt(ob.Chain().ChainId))
 	from, err := signer.Sender(transaction)
 	if err != nil {
-		log.Error().
-			Err(err).
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", transaction.Hash().Hex()).
-			Int64("chainID", ob.Chain().ChainId).
-			Msg("local recovery of sender address failed for outbound")
+		logger.Error().Err(err).Msg("local recovery of sender address failed")
 		return nil, nil, false
 	}
 	if from != ob.TSS().EVMAddress() { // must be TSS address
@@ -453,13 +446,8 @@ func (ob *Observer) checkConfirmedTx(
 
 		// TODO : improve this logic to verify that the correct TSS address is the from address.
 		// https://github.com/zeta-chain/node/issues/2487
-		log.Info().
-			Str("function", "confirmTxByHash").
-			Str("sender", from.Hex()).
-			Str("outboundTxHash", transaction.Hash().Hex()).
-			Int64("chainID", ob.Chain().ChainId).
-			Str("currentTSSAddress", ob.TSS().EVMAddress().Hex()).
-			Msg("sender is not current TSS address")
+		logger.Warn().
+			Msgf("tx sender %s is not matching current TSS address %s", from.String(), ob.TSS().EVMAddress().String())
 		addressList := ob.TSS().EVMAddressList()
 		isOldTssAddress := false
 		for _, addr := range addressList {
@@ -468,23 +456,12 @@ func (ob *Observer) checkConfirmedTx(
 			}
 		}
 		if !isOldTssAddress {
-			log.Error().
-				Str("function", "confirmTxByHash").
-				Str("sender", from.Hex()).
-				Str("outboundTxHash", transaction.Hash().Hex()).
-				Int64("chainID", ob.Chain().ChainId).
-				Str("currentTSSAddress", ob.TSS().EVMAddress().Hex()).
-				Msg("sender is not current or old TSS address")
+			logger.Error().Msgf("tx sender %s is not matching any of the TSS addresses", from.String())
 			return nil, nil, false
 		}
 	}
-	if transaction.Nonce() != nonce { // must match cctx nonce
-		log.Error().
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", txHash).
-			Uint64("wantedNonce", nonce).
-			Uint64("gotTxNonce", transaction.Nonce()).
-			Msg("outbound nonce mismatch")
+	if transaction.Nonce() != nonce { // must match tracker nonce
+		logger.Error().Msgf("tx nonce %d is not matching tracker nonce", nonce)
 		return nil, nil, false
 	}
 
@@ -497,55 +474,31 @@ func (ob *Observer) checkConfirmedTx(
 	// query receipt
 	receipt, err := ob.evmClient.TransactionReceipt(ctx, ethcommon.HexToHash(txHash))
 	if err != nil {
-		log.Error().
-			Err(err).
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", txHash).
-			Uint64("nonce", nonce).
-			Msg("transactionReceipt error")
+		logger.Error().Err(err).Msg("TransactionReceipt error")
 		return nil, nil, false
 	}
 	if receipt == nil { // should not happen
-		log.Error().
-			Str("function", "confirmTxByHash").
-			Str("outboundTxHash", txHash).
-			Uint64("nonce", nonce).
-			Msg("receipt is nil")
+		logger.Error().Msg("receipt is nil")
 		return nil, nil, false
 	}
 	ob.LastBlock()
 	// check confirmations
 	lastHeight, err := ob.evmClient.BlockNumber(ctx)
 	if err != nil {
-		log.Error().
-			Str("function", "confirmTxByHash").
-			Err(err).
-			Int64("chainID", ob.GetChainParams().ChainId).
-			Msg("error getting block number for chain")
+		logger.Error().Err(err).Msg("BlockNumber error")
 		return nil, nil, false
 	}
 	if !ob.HasEnoughConfirmations(receipt, lastHeight) {
-		log.Debug().
-			Str("function", "confirmTxByHash").
-			Str("txHash", txHash).
-			Uint64("nonce", nonce).
-			Uint64("receiptBlock", receipt.BlockNumber.Uint64()).
-			Uint64("currentBlock", lastHeight).
-			Msg("txHash included but not confirmed")
+		logger.Debug().
+			Msgf("tx included but not confirmed, receipt block %d current block %d", receipt.BlockNumber.Uint64(), lastHeight)
 		return nil, nil, false
 	}
 
 	// cross-check tx inclusion against the block
 	// Note: a guard for false BlockNumber in receipt. The blob-carrying tx won't come here
 	err = ob.CheckTxInclusion(transaction, receipt)
 	if err != nil {
-		log.Error().
-			Err(err).
-			Str("function", "confirmTxByHash").
-			Str("errorContext", "checkTxInclusion").
-			Str("txHash", txHash).
-			Uint64("nonce", nonce).
-			Msg("checkTxInclusion error")
+		logger.Error().Err(err).Msg("CheckTxInclusion error")
 		return nil, nil, false
 	}
 

zetaclient/chains/evm/signer/outbound_tracker_reporter.go

@@ -61,6 +61,7 @@ func (signer *Signer) reportToOutboundTracker(
 			confirmed, err := rpc.IsTxConfirmed(ctx, signer.client, outboundHash, evm.ReorgProtectBlockCount)
 			if err != nil {
 				logger.Err(err).Msg("unable to check confirmation status of outbound")
+				continue
 			}
 			if !confirmed {
 				continue

zetaclient/chains/solana/observer/outbound.go

@@ -17,6 +17,7 @@ import (
 	crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types"
 	"github.com/zeta-chain/zetacore/zetaclient/chains/interfaces"
 	zctx "github.com/zeta-chain/zetacore/zetaclient/context"
+	"github.com/zeta-chain/zetacore/zetaclient/logs"
 	clienttypes "github.com/zeta-chain/zetacore/zetaclient/types"
 	"github.com/zeta-chain/zetacore/zetaclient/zetacore"
 )
@@ -254,15 +255,15 @@ func (ob *Observer) CheckFinalizedTx(
 	// prepare logger fields
 	chainID := ob.Chain().ChainId
 	logger := ob.Logger().Outbound.With().
-		Str("method", "checkFinalizedTx").
-		Int64("chain", chainID).
-		Uint64("nonce", nonce).
-		Str("tx", txHash).Logger()
+		Str(logs.FieldMethod, "CheckFinalizedTx").
+		Int64(logs.FieldChain, chainID).
+		Uint64(logs.FieldNonce, nonce).
+		Str(logs.FieldTx, txHash).Logger()
 
 	// convert txHash to signature
 	sig, err := solana.SignatureFromBase58(txHash)
 	if err != nil {
-		logger.Error().Err(err).Msgf("SignatureFromBase58 err for chain %d nonce %d", chainID, nonce)
+		logger.Error().Err(err).Msg("SignatureFromBase58 error")
 		return nil, false
 	}
 
@@ -271,40 +272,40 @@ func (ob *Observer) CheckFinalizedTx(
 		Commitment: rpc.CommitmentFinalized,
 	})
 	if err != nil {
-		logger.Error().Err(err).Msgf("GetTransaction err for chain %d nonce %d", chainID, nonce)
+		logger.Error().Err(err).Msg("GetTransaction error")
 		return nil, false
 	}
 
 	// the tx must be successful in order to effectively increment the nonce
 	if txResult.Meta.Err != nil {
-		logger.Error().Any("Err", txResult.Meta.Err).Msgf("tx is not successful for chain %d nonce %d", chainID, nonce)
+		logger.Error().Any("Err", txResult.Meta.Err).Msg("tx is not successful")
 		return nil, false
 	}
 
 	// parse gateway instruction from tx result
 	inst, err := ParseGatewayInstruction(txResult, ob.gatewayID, coinType)
 	if err != nil {
-		logger.Error().Err(err).Msgf("ParseGatewayInstruction err for chain %d nonce %d", chainID, nonce)
+		logger.Error().Err(err).Msg("ParseGatewayInstruction error")
 		return nil, false
 	}
 	txNonce := inst.GatewayNonce()
 
 	// recover ECDSA signer from instruction
 	signerECDSA, err := inst.Signer()
 	if err != nil {
-		logger.Error().Err(err).Msgf("cannot get instruction signer for chain %d nonce %d", chainID, nonce)
+		logger.Error().Err(err).Msg("cannot get instruction signer")
 		return nil, false
 	}
 
 	// check tx authorization
 	if signerECDSA != ob.TSS().EVMAddress() {
-		logger.Error().Msgf("tx signer %s is not matching TSS, chain %d nonce %d", signerECDSA, chainID, nonce)
+		logger.Error().Msgf("tx signer %s is not matching current TSS address %s", signerECDSA, ob.TSS().EVMAddress())
 		return nil, false
 	}
 
 	// check tx nonce
 	if txNonce != nonce {
-		logger.Error().Msgf("tx nonce %d is not matching cctx, chain %d nonce %d", txNonce, chainID, nonce)
+		logger.Error().Msgf("tx nonce %d is not matching tracker nonce", txNonce)
 		return nil, false
 	}