refactor: add error checks for missing chain id

zetaclient/evm_client.go

@@ -603,8 +603,15 @@ func (ob *EVMChainClient) observeInTX() error {
 			event := logs.Event
 			ob.logger.ExternalChainWatcher.Info().Msgf("TxBlockNumber %d Transaction Hash: %s Message : %s", event.Raw.BlockNumber, event.Raw.TxHash, event.Message)
 			destChain := common.GetChainFromChainID(event.DestinationChainId.Int64())
+			if destChain == nil {
+				ob.logger.ExternalChainWatcher.Warn().Msgf("chain id not supported  %d", event.DestinationChainId.Int64())
+				continue
+			}
 			destAddr := clienttypes.BytesToEthHex(event.DestinationAddress)
-
+			if ob.cfg.EVMChainConfigs[destChain.ChainId] == nil {
+				ob.logger.ExternalChainWatcher.Warn().Msgf("chain id not present in EVMChainConfigs  %d", event.DestinationChainId.Int64())
+				continue
+			}
 			if strings.EqualFold(destAddr, ob.cfg.EVMChainConfigs[destChain.ChainId].CoreParams.ZETATokenContractAddress) {
 				ob.logger.ExternalChainWatcher.Warn().Msgf("potential attack attempt: %s destination address is ZETA token contract address %s", destChain, destAddr)
 				continue

zetaclient/evm_signer.go

@@ -233,10 +233,18 @@ func (signer *EVMSigner) TryProcessOutTx(send *types.CrossChainTx, outTxMan *Out
 	if send.CctxStatus.Status == types.CctxStatus_PendingRevert {
 		to = ethcommon.HexToAddress(send.InboundTxParams.Sender)
 		toChain = common.GetChainFromChainID(send.InboundTxParams.SenderChainId)
+		if toChain == nil {
+			logger.Error().Msgf("Unknown chain: %d", send.InboundTxParams.SenderChainId)
+			return
+		}
 		logger.Info().Msgf("Abort: reverting inbound")
 	} else if send.CctxStatus.Status == types.CctxStatus_PendingOutbound {
 		to = ethcommon.HexToAddress(send.GetCurrentOutTxParam().Receiver)
 		toChain = common.GetChainFromChainID(send.GetCurrentOutTxParam().ReceiverChainId)
+		if toChain == nil {
+			logger.Error().Msgf("Unknown chain: %d", send.GetCurrentOutTxParam().ReceiverChainId)
+			return
+		}
 	}
 	if err != nil {
 		logger.Error().Err(err).Msg("ParseChain fail; skip")

zetaclient/zetabridge.go

@@ -184,7 +184,7 @@ func (b *ZetaCoreBridge) UpdateConfigFromCore(cfg *config.Config) error {
 		}
 		_, found := cfg.EVMChainConfigs[params.ChainId]
 		if !found {
-			panic(fmt.Sprintf("EvmConfig %s is nil for this client ", common.GetChainFromChainID(params.ChainId).String()))
+			panic(fmt.Sprintf("EvmConfig %d is nil for this client ", params.ChainId))
 		}
 		if cfg.EVMChainConfigs[params.ChainId].CoreParams == nil {
 			cfg.EVMChainConfigs[params.ChainId].CoreParams = config.NewCoreParams()

zetaclient/zetacore_observer.go

@@ -149,7 +149,11 @@ func (co *CoreObserver) startSendScheduler() {
 								co.logger.ZetaChainWatcher.Info().Msgf("send outTx already included; do not schedule")
 								continue
 							}
-							chain := GetTargetChain(send)
+							chain, err := GetTargetChain(send)
+							if err != nil {
+								co.logger.ZetaChainWatcher.Error().Err(err).Msgf("GetTargetChain fail , Chain ID : %s", c.ChainName)
+								continue
+							}
 							nonce := send.GetCurrentOutTxParam().OutboundTxTssNonce
 							outTxID := fmt.Sprintf("%s-%d-%d", send.Index, send.GetCurrentOutTxParam().ReceiverChainId, nonce) // should be the outTxID?
 
@@ -210,8 +214,8 @@ func trimSends(sends []*types.CrossChainTx) int {
 func SplitAndSortSendListByChain(sendList []*types.CrossChainTx) map[string][]*types.CrossChainTx {
 	sendMap := make(map[string][]*types.CrossChainTx)
 	for _, send := range sendList {
-		targetChain := GetTargetChain(send)
-		if targetChain == "" {
+		targetChain, err := GetTargetChain(send)
+		if targetChain == "" || err != nil {
 			continue
 		}
 		if _, found := sendMap[targetChain]; !found {
@@ -230,16 +234,25 @@ func SplitAndSortSendListByChain(sendList []*types.CrossChainTx) map[string][]*t
 	return sendMap
 }
 
-func GetTargetChain(send *types.CrossChainTx) string {
+func GetTargetChain(send *types.CrossChainTx) (string, error) {
 	chainID := send.GetCurrentOutTxParam().ReceiverChainId
-	return common.GetChainFromChainID(chainID).GetChainName().String()
+	chain := common.GetChainFromChainID(chainID)
+	if chain == nil {
+		return "", fmt.Errorf("chain %d not found", chainID)
+	}
+	return chain.GetChainName().String(), nil
 }
 
 func (co *CoreObserver) getTargetChainOb(send *types.CrossChainTx) (ChainClient, error) {
-	chainStr := GetTargetChain(send)
+	chainStr, err := GetTargetChain(send)
+	if err != nil {
+		return nil, fmt.Errorf("chain %d not found", send.GetCurrentOutTxParam().ReceiverChainId)
+	}
 	chainName := common.ParseChainName(chainStr)
 	c := common.GetChainFromChainName(chainName)
-
+	if c == nil {
+		return nil, fmt.Errorf("chain %s not found", chainName)
+	}
 	chainOb, found := co.clientMap[*c]
 	if !found {
 		return nil, fmt.Errorf("chain %s not found", c)