add more cases; specific file for connectors

johnsaigle · johnsaigle · commit c611125b1002 · 2026-07-22T08:45:29.000-04:00
diff --git a/node/pkg/adminrpc/adminserver.go b/node/pkg/adminrpc/adminserver.go
@@ -1110,12 +1110,13 @@ func (s *nodePrivilegedService) fetchMissing(
 		// #nosec G704 -- Admin RPC: BackfillNodes from authorized admin request
 		resp, err := c.Do(req)
 		if err != nil {
+			safeErr := common.SafeErrorForLogging(err, requestURL)
 			s.logger.Warn("failed to fetch missing VAA",
 				zap.String("node", common.SafeURLForLogging(node)),
 				zap.String("chain", chain.String()),
 				zap.String("address", addr),
 				zap.Uint64("sequence", seq),
-				zap.Error(err),
+				zap.String("error", safeErr),
 			)
 			continue
 		}
@@ -1132,7 +1133,7 @@ func (s *nodePrivilegedService) fetchMissing(
 			if err := json.NewDecoder(resp.Body).Decode(&respBody); err != nil {
 				resp.Body.Close()
 				s.logger.Warn("failed to decode VAA response",
-					zap.String("node", node),
+					zap.String("node", common.SafeURLForLogging(node)),
 					zap.String("chain", chain.String()),
 					zap.String("address", addr),
 					zap.Uint64("sequence", seq),
@@ -1146,7 +1147,7 @@ func (s *nodePrivilegedService) fetchMissing(
 			if err != nil {
 				resp.Body.Close()
 				s.logger.Warn("failed to decode VAA body",
-					zap.String("node", node),
+					zap.String("node", common.SafeURLForLogging(node)),
 					zap.String("chain", chain.String()),
 					zap.String("address", addr),
 					zap.Uint64("sequence", seq),
diff --git a/node/pkg/watchers/cosmwasm/watcher.go b/node/pkg/watchers/cosmwasm/watcher.go
@@ -213,9 +213,10 @@ func (e *Watcher) Run(ctx context.Context) error {
 			case <-t.C:
 				msm := time.Now()
 				// Query and report height and set currentSlotHeight
-				resp, err := client.Get(fmt.Sprintf("%s/%s", e.urlLCD, e.latestBlockURL)) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
+				requestURL := fmt.Sprintf("%s/%s", e.urlLCD, e.latestBlockURL)
+				resp, err := client.Get(requestURL) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
 				if err != nil {
-					logger.Error("query latest block response error", zap.String("network", e.networkName), zap.Error(err))
+					logger.Error("query latest block response error", zap.String("network", e.networkName), zap.String("error", common.SafeErrorForLogging(err, requestURL)))
 					continue
 				}
 				blocksBody, err := common.SafeRead(resp.Body)
@@ -269,9 +270,10 @@ func (e *Watcher) Run(ctx context.Context) error {
 				}
 
 				// Query for tx by hash
-				resp, err := client.Get(fmt.Sprintf("%s/cosmos/tx/v1beta1/txs/%s", e.urlLCD, tx)) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
+				requestURL := fmt.Sprintf("%s/cosmos/tx/v1beta1/txs/%s", e.urlLCD, tx)
+				resp, err := client.Get(requestURL) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
 				if err != nil {
-					logger.Error("query tx response error", zap.String("network", e.networkName), zap.Error(err))
+					logger.Error("query tx response error", zap.String("network", e.networkName), zap.String("error", common.SafeErrorForLogging(err, requestURL)))
 					continue
 				}
 				txBody, err := common.SafeRead(resp.Body)
diff --git a/node/pkg/watchers/evm/by_transaction.go b/node/pkg/watchers/evm/by_transaction.go
@@ -21,6 +21,22 @@ var (
 	LogMessagePublishedTopic = eth_common.HexToHash("0x6eb224fb001ed210e379b335e35efe88672a8ce935d981a6896b27ffdf52a3b2")
 )
 
+type connectorWithRPCURL interface {
+	RPCURL() string
+}
+
+func safeConnectorErrorForLogging(err error, ethConn any) string {
+	if err == nil {
+		return ""
+	}
+
+	if connector, ok := ethConn.(connectorWithRPCURL); ok {
+		return common.SafeErrorForLogging(err, connector.RPCURL())
+	}
+
+	return err.Error()
+}
+
 // isValidCoreBridgeMessagePublicationLog checks that a log entry was emitted by the expected contract,
 // has the expected LogMessagePublished event topic, and has not been removed
 // due to a chain reorganization. This is called from both the real-time
@@ -55,7 +71,7 @@ func MessageEventsForTransaction(
 	// API only returns transactions that have been included in a block. Nothing in the mempool
 	receipt, err := ethConn.TransactionReceipt(ctx, tx)
 	if receipt == nil || err != nil {
-		return nil, 0, nil, fmt.Errorf("failed to get transaction receipt: %w", err)
+		return nil, 0, nil, fmt.Errorf("failed to get transaction receipt: %s", safeConnectorErrorForLogging(err, ethConn))
 	}
 
 	// SECURITY
@@ -74,7 +90,7 @@ func MessageEventsForTransaction(
 	// Get block
 	blockTime, err := ethConn.TimeOfBlockByHash(ctx, receipt.BlockHash)
 	if err != nil {
-		return nil, 0, nil, fmt.Errorf("failed to get block time: %w", err)
+		return nil, 0, nil, fmt.Errorf("failed to get block time: %s", safeConnectorErrorForLogging(err, ethConn))
 	}
 
 	msgs := make([]*common.MessagePublication, 0, len(receipt.Logs))
diff --git a/node/pkg/watchers/evm/ccq_backfill.go b/node/pkg/watchers/evm/ccq_backfill.go
@@ -193,12 +193,12 @@ func ccqBackFillDetermineMaxBatchSize(ctx context.Context, logger *zap.Logger, c
 			}
 			prevSuccess = batchSize
 		} else {
-			logger.Info("batch query failed", zap.Int64("batchSize", batchSize), zap.Error(err))
+			logger.Info("batch query failed", zap.Int64("batchSize", batchSize), zap.String("error", safeConnectorErrorForLogging(err, conn)))
 			prevFailure = batchSize
 		}
 		batchSize = (prevFailure + prevSuccess) / 2
 		if batchSize == 0 {
-			return 0, nil, fmt.Errorf("failed to determine batch size: %w", err)
+			return 0, nil, fmt.Errorf("failed to determine batch size: %s", safeConnectorErrorForLogging(err, conn))
 		}
 
 		time.Sleep(delay) //nolint:forbidigo // TODO: This code should be refactored to not use time.Sleep
@@ -254,10 +254,10 @@ func (w *Watcher) ccqBackfillGetBlocks(ctx context.Context, initialBlockNum uint
 			zap.Uint64("initialBlockNum", initialBlockNum),
 			zap.Int64("numBlocks", numBlocks),
 			zap.Uint64("finalBlockNum", blockNum),
-			zap.Error(err),
+			zap.String("error", safeConnectorErrorForLogging(err, w.ethConn)),
 		)
 
-		return nil, err
+		return nil, fmt.Errorf("failed to get batch of blocks: %s", safeConnectorErrorForLogging(err, w.ethConn))
 	}
 
 	blocks := Blocks{}
diff --git a/node/pkg/watchers/evm/chain_config.go b/node/pkg/watchers/evm/chain_config.go
@@ -244,7 +244,7 @@ func QueryEvmChainID(ctx context.Context, url string) (uint64, error) {
 	var str string
 	err = c.CallContext(ctx, &str, "eth_chainId")
 	if err != nil {
-		return 0, fmt.Errorf("failed to read evm chain id: %w", err)
+		return 0, fmt.Errorf("failed to read evm chain id: %s", common.SafeErrorForLogging(err, url))
 	}
 
 	evmChainID, err := strconv.ParseUint(strings.TrimPrefix(str, "0x"), 16, 64)
@@ -274,7 +274,7 @@ func (w *Watcher) verifyEvmChainID(ctx context.Context, logger *zap.Logger, url
 	var str string
 	err = c.CallContext(ctx, &str, "eth_chainId")
 	if err != nil {
-		return fmt.Errorf("failed to read evm chain id: %w", err)
+		return fmt.Errorf("failed to read evm chain id: %s", common.SafeErrorForLogging(err, url))
 	}
 
 	evmChainID, err := strconv.ParseUint(strings.TrimPrefix(str, "0x"), 16, 64)
diff --git a/node/pkg/watchers/evm/connectors/batch_poller.go b/node/pkg/watchers/evm/connectors/batch_poller.go
@@ -62,6 +62,14 @@ func NewBatchPollConnector(_ context.Context, logger *zap.Logger, baseConnector
 	return connector
 }
 
+func (b *BatchPollConnector) RPCURL() string {
+	if connector, ok := b.Connector.(rpcURLErrorSanitizer); ok {
+		return connector.RPCURL()
+	}
+
+	return ""
+}
+
 func (b *BatchPollConnector) SubscribeForBlocks(ctx context.Context, errC chan error, sink chan<- *NewBlock) (ethereum.Subscription, error) {
 	// Use the standard geth head sink to get latest blocks. We do this so that we will be notified of rollbacks. The following document
 	// indicates that the subscription will receive a replay of all blocks affected by a rollback. This is important for latest because the
@@ -76,8 +84,8 @@ func (b *BatchPollConnector) SubscribeForBlocks(ctx context.Context, errC chan e
 	// Get the initial blocks.
 	lastBlocks, err := b.getBlocks(ctx, b.logger)
 	if err != nil {
-		b.logger.Error("failed to get initial blocks", zap.Error(err))
-		return headerSubscription, fmt.Errorf("failed to get initial blocks: %w", err)
+		b.logger.Error("failed to get initial blocks", zap.String("error", safeConnectorErrorForLogging(err, b.Connector)))
+		return headerSubscription, fmt.Errorf("failed to get initial blocks: %s", safeConnectorErrorForLogging(err, b.Connector))
 	}
 
 	errCount := 0
@@ -104,9 +112,9 @@ func (b *BatchPollConnector) SubscribeForBlocks(ctx context.Context, errC chan e
 				lastBlocks, err = b.pollBlocks(ctx, sink, lastBlocks)
 				if err != nil {
 					errCount++
-					b.logger.Error("batch polling encountered an error", zap.Int("errCount", errCount), zap.Error(err))
+					b.logger.Error("batch polling encountered an error", zap.Int("errCount", errCount), zap.String("error", safeConnectorErrorForLogging(err, b.Connector)))
 					if errCount > 3 {
-						errC <- fmt.Errorf("polling encountered too many errors: %w", err) // Note on channel capacity: The watcher will exit anyway
+						errC <- fmt.Errorf("polling encountered too many errors: %s", safeConnectorErrorForLogging(err, b.Connector)) // Note on channel capacity: The watcher will exit anyway
 						return nil
 					}
 				} else if errCount != 0 {
@@ -251,7 +259,7 @@ func (b *BatchPollConnector) getBlocks(ctx context.Context, logger *zap.Logger)
 
 	err := b.Connector.RawBatchCallContext(timeout, batch)
 	if err != nil {
-		logger.Error("failed to get blocks", zap.Error(err))
+		logger.Error("failed to get blocks", zap.String("error", safeConnectorErrorForLogging(err, b.Connector)))
 		return nil, err
 	}
 
diff --git a/node/pkg/watchers/evm/connectors/block_utils.go b/node/pkg/watchers/evm/connectors/block_utils.go
@@ -26,7 +26,7 @@ func GetBlock(ctx context.Context, conn Connector, str string, blockFinality Fin
 	var m BlockMarshaller
 	err := conn.RawCallContext(timeout, &m, "eth_getBlockByNumber", str, false)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get block for %s: %w", str, err)
+		return nil, fmt.Errorf("failed to get block for %s: %s", str, safeConnectorErrorForLogging(err, conn))
 	}
 	if m.Number == nil {
 		return nil, fmt.Errorf("failed to unmarshal block for %s: Number is nil", str)
diff --git a/node/pkg/watchers/evm/connectors/ethereum.go b/node/pkg/watchers/evm/connectors/ethereum.go
@@ -28,6 +28,7 @@ type EthereumBaseConnector struct {
 	logger      *zap.Logger
 	client      *ethClient.Client
 	rawClient   *ethRpc.Client
+	rawURL      string
 	filterer    *ethAbi.AbiFilterer
 	caller      *ethAbi.AbiCaller
 	dgCaller    *dgAbi.DelegatedguardiansCaller
@@ -69,6 +70,7 @@ func NewEthereumBaseConnector(ctx context.Context, networkName, rawUrl string, a
 		filterer:    filterer,
 		caller:      caller,
 		rawClient:   rawClient,
+		rawURL:      rawUrl,
 		dgCaller:    dgCaller,
 		dgAddress:   dgAddress,
 	}, nil
@@ -82,6 +84,10 @@ func (e *EthereumBaseConnector) ContractAddress() ethCommon.Address {
 	return e.address
 }
 
+func (e *EthereumBaseConnector) RPCURL() string {
+	return e.rawURL
+}
+
 func (e *EthereumBaseConnector) GetCurrentGuardianSetIndex(ctx context.Context) (uint32, error) {
 	return e.caller.GetCurrentGuardianSetIndex(&ethBind.CallOpts{Context: ctx})
 }
diff --git a/node/pkg/watchers/evm/connectors/instant_finality.go b/node/pkg/watchers/evm/connectors/instant_finality.go
@@ -26,6 +26,14 @@ func NewInstantFinalityConnector(baseConnector Connector, logger *zap.Logger) *I
 	return connector
 }
 
+func (c *InstantFinalityConnector) RPCURL() string {
+	if connector, ok := c.Connector.(rpcURLErrorSanitizer); ok {
+		return connector.RPCURL()
+	}
+
+	return ""
+}
+
 func (c *InstantFinalityConnector) SubscribeForBlocks(ctx context.Context, errC chan error, sink chan<- *NewBlock) (ethereum.Subscription, error) {
 	headSink := make(chan *ethTypes.Header, 2)
 	headerSubscription, err := c.Connector.Client().SubscribeNewHead(ctx, headSink)
diff --git a/node/pkg/watchers/evm/connectors/poller.go b/node/pkg/watchers/evm/connectors/poller.go
@@ -120,14 +120,14 @@ func (p *PollConnector) SubscribeForBlocks(ctx context.Context, errC chan error,
 				lastBlocks, err = p.pollBlocks(ctx, sink, lastBlocks)
 				if err != nil {
 					errCount++
-					p.logger.Error("poll connector encountered an error", zap.Int("errCount", errCount), zap.Error(err))
+					p.logger.Error("poll connector encountered an error", zap.Int("errCount", errCount), zap.String("error", safeConnectorErrorForLogging(err, p.Connector)))
 					if errCount > pollMaxErrors {
 						// Return the error rather than writing to errC directly: a
 						// blocking send could hang if the watcher is already shutting
 						// down and no longer reading errC, which would prevent the
 						// deferred signalUnsubscribed from running. RunWithScissors
 						// delivers the returned error to errC without blocking.
-						return fmt.Errorf("polling encountered too many errors: %w", err)
+						return fmt.Errorf("polling encountered too many errors: %s", safeConnectorErrorForLogging(err, p.Connector))
 					}
 				} else if errCount != 0 {
 					errCount = 0
@@ -178,13 +178,13 @@ func (p *PollConnector) watchLogMessagePublishedFrom(ctx context.Context, errC c
 				latest, err := GetBlockByFinality(ctx, p.Connector, Latest)
 				if err != nil {
 					errCount++
-					p.logger.Error("log poller failed to get latest block", zap.Int("errCount", errCount), zap.Error(err))
+					p.logger.Error("log poller failed to get latest block", zap.Int("errCount", errCount), zap.String("error", safeConnectorErrorForLogging(err, p.Connector)))
 					if errCount > pollMaxErrors {
 						// Return rather than send to errC directly: a blocking send could hang
 						// during watcher shutdown and strand the deferred signalUnsubscribed,
 						// re-introducing the Unsubscribe deadlock. RunWithScissors forwards
 						// the returned error to errC without blocking.
-						return fmt.Errorf("log polling encountered too many errors: %w", err)
+						return fmt.Errorf("log polling encountered too many errors: %s", safeConnectorErrorForLogging(err, p.Connector))
 					}
 					timer.Reset(p.Delay)
 					continue
@@ -214,13 +214,13 @@ func (p *PollConnector) watchLogMessagePublishedFrom(ctx context.Context, errC c
 					cancel()
 					if err != nil {
 						errCount++
-						p.logger.Error("log poller failed to get logs", zap.Int("errCount", errCount), zap.Error(err), zap.Uint64("fromBlock", fromBlock), zap.Uint64("toBlock", toBlock))
+						p.logger.Error("log poller failed to get logs", zap.Int("errCount", errCount), zap.String("error", safeConnectorErrorForLogging(err, p.Connector)), zap.Uint64("fromBlock", fromBlock), zap.Uint64("toBlock", toBlock))
 						if errCount > pollMaxErrors {
 							// Return rather than send to errC directly: a blocking send could hang
 							// during watcher shutdown and strand the deferred signalUnsubscribed,
 							// re-introducing the Unsubscribe deadlock. RunWithScissors forwards
 							// the returned error to errC without blocking.
-							return fmt.Errorf("log polling encountered too many errors: %w", err)
+							return fmt.Errorf("log polling encountered too many errors: %s", safeConnectorErrorForLogging(err, p.Connector))
 						}
 						timer.Reset(p.Delay)
 						continue
@@ -257,7 +257,7 @@ func (p *PollConnector) TimeOfBlockByHash(ctx context.Context, hash ethCommon.Ha
 	var m *BlockMarshaller
 	err := p.RawCallContext(ctx, &m, "eth_getBlockByHash", hash, false)
 	if err != nil {
-		return 0, fmt.Errorf("failed to get block by hash: %w", err)
+		return 0, fmt.Errorf("failed to get block by hash: %s", safeConnectorErrorForLogging(err, p.Connector))
 	}
 	// eth_getBlockByHash returns a JSON null result for an unknown block, which
 	// unmarshals into a nil pointer without an error. Mirror go-ethereum's
diff --git a/node/pkg/watchers/evm/connectors/url_sanitization.go b/node/pkg/watchers/evm/connectors/url_sanitization.go
@@ -0,0 +1,19 @@
+package connectors
+
+import nodeCommon "github.com/certusone/wormhole/node/pkg/common"
+
+type rpcURLErrorSanitizer interface {
+	RPCURL() string
+}
+
+func safeConnectorErrorForLogging(err error, connector Connector) string {
+	if err == nil {
+		return ""
+	}
+
+	if sanitizer, ok := connector.(rpcURLErrorSanitizer); ok {
+		return nodeCommon.SafeErrorForLogging(err, sanitizer.RPCURL())
+	}
+
+	return err.Error()
+}
diff --git a/node/pkg/watchers/evm/reobserve.go b/node/pkg/watchers/evm/reobserve.go
@@ -165,7 +165,7 @@ func (w *Watcher) Reobserve(ctx context.Context, chainID vaa.ChainID, txID []byt
 	// Get the current finalized and safe blocks.
 	_, finalized, safe, err := ethConn.GetLatest(timeout)
 	if err != nil {
-		return 0, fmt.Errorf(`failed to get latest blocks: %w`, err)
+		return 0, fmt.Errorf(`failed to get latest blocks: %s`, common.SafeErrorForLogging(err, customEndpoint))
 	}
 
 	// Finally, do the reobservation and return the number of messages observed.
diff --git a/node/pkg/watchers/evm/verify_chain_config/verify.go b/node/pkg/watchers/evm/verify_chain_config/verify.go
@@ -187,7 +187,7 @@ func verifyContractAddr(ctx context.Context, url string, contractAddr string) er
 
 	_, err = caller.GetCurrentGuardianSetIndex(&ethBind.CallOpts{Context: timeout})
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to verify contract address: %s", common.SafeErrorForLogging(err, url))
 	}
 
 	return nil
@@ -206,7 +206,7 @@ func verifyCCLContractAddr(ctx context.Context, url string, contractAddr string)
 
 	_, err = evm.CCLReadContract(ctx, client, ethCommon.HexToAddress(contractAddr), ethCommon.Address{})
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to verify ccl contract address: %s", common.SafeErrorForLogging(err, url))
 	}
 
 	return nil
diff --git a/node/pkg/watchers/ibc/watcher.go b/node/pkg/watchers/ibc/watcher.go
@@ -388,7 +388,7 @@ func (w *Watcher) handleQueryBlockHeight(ctx context.Context, queryUrl string) e
 		case <-t.C:
 			resp, err := client.Get(queryUrl) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
 			if err != nil {
-				return fmt.Errorf("failed to query latest block: %w", err)
+				return fmt.Errorf("failed to query latest block: %s", common.SafeErrorForLogging(err, queryUrl))
 			}
 			body, err := common.SafeRead(resp.Body)
 			resp.Body.Close()
@@ -453,9 +453,10 @@ func (w *Watcher) handleObservationRequests(ctx context.Context, ce *chainEntry)
 			}
 
 			// Query for tx by hash.
-			resp, err := client.Get(fmt.Sprintf("%s/cosmos/tx/v1beta1/txs/%s", w.lcdUrl, reqTxHashStr)) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
+			requestURL := fmt.Sprintf("%s/cosmos/tx/v1beta1/txs/%s", w.lcdUrl, reqTxHashStr)
+			resp, err := client.Get(requestURL) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
 			if err != nil {
-				w.logger.Error("query tx response error", zap.String("chain", ce.chainName), zap.Error(err))
+				w.logger.Error("query tx response error", zap.String("chain", ce.chainName), zap.String("error", common.SafeErrorForLogging(err, requestURL)))
 				continue
 			}
 			txBody, err := common.SafeRead(resp.Body)
@@ -764,7 +765,7 @@ func (w *Watcher) queryChannelIdToChainIdMapping() (map[string]vaa.ChainID, erro
 	query := fmt.Sprintf(`%s/cosmwasm/wasm/v1/contract/%s/smart/%s`, w.lcdUrl, w.contractAddress, allChannelChainsQuery)
 	resp, err := client.Get(query) //nolint:noctx // TODO FIXME we should propagate context with Deadline here.
 	if err != nil {
-		return nil, fmt.Errorf("query failed: %w", err)
+		return nil, fmt.Errorf("query failed: %s", common.SafeErrorForLogging(err, query))
 	}
 	body, err := common.SafeRead(resp.Body)
 	if err != nil {
diff --git a/node/pkg/watchers/solana/ccq.go b/node/pkg/watchers/solana/ccq.go
diff --git a/node/pkg/watchers/solana/client.go b/node/pkg/watchers/solana/client.go
diff --git a/node/pkg/watchers/solana/client_test.go b/node/pkg/watchers/solana/client_test.go
diff --git a/node/pkg/watchers/solana/close_event_test.go b/node/pkg/watchers/solana/close_event_test.go
diff --git a/node/pkg/watchers/solana/reobserve.go b/node/pkg/watchers/solana/reobserve.go
diff --git a/node/pkg/watchers/solana/tx_for_addr.go b/node/pkg/watchers/solana/tx_for_addr.go

Original file line number	Diff line number	Diff line change
`@@ -193,12 +193,12 @@ func ccqBackFillDetermineMaxBatchSize(ctx context.Context, logger *zap.Logger, c`
`193`	`193`	`}`
`194`	`194`	`prevSuccess = batchSize`
`195`	`195`	`} else {`
`196`		`- logger.Info("batch query failed", zap.Int64("batchSize", batchSize), zap.Error(err))`
	`196`	`+ logger.Info("batch query failed", zap.Int64("batchSize", batchSize), zap.String("error", safeConnectorErrorForLogging(err, conn)))`
`197`	`197`	`prevFailure = batchSize`
`198`	`198`	`}`
`199`	`199`	`batchSize = (prevFailure + prevSuccess) / 2`
`200`	`200`	`if batchSize == 0 {`
`201`		`- return 0, nil, fmt.Errorf("failed to determine batch size: %w", err)`
	`201`	`+ return 0, nil, fmt.Errorf("failed to determine batch size: %s", safeConnectorErrorForLogging(err, conn))`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`time.Sleep(delay) //nolint:forbidigo // TODO: This code should be refactored to not use time.Sleep`
`@@ -254,10 +254,10 @@ func (w *Watcher) ccqBackfillGetBlocks(ctx context.Context, initialBlockNum uint`
`254`	`254`	`zap.Uint64("initialBlockNum", initialBlockNum),`
`255`	`255`	`zap.Int64("numBlocks", numBlocks),`
`256`	`256`	`zap.Uint64("finalBlockNum", blockNum),`
`257`		`- zap.Error(err),`
	`257`	`+ zap.String("error", safeConnectorErrorForLogging(err, w.ethConn)),`
`258`	`258`	`)`
`259`	`259`
`260`		`- return nil, err`
	`260`	`+ return nil, fmt.Errorf("failed to get batch of blocks: %s", safeConnectorErrorForLogging(err, w.ethConn))`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`blocks := Blocks{}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func GetBlock(ctx context.Context, conn Connector, str string, blockFinality Fin`
`26`	`26`	`var m BlockMarshaller`
`27`	`27`	`err := conn.RawCallContext(timeout, &m, "eth_getBlockByNumber", str, false)`
`28`	`28`	`if err != nil {`
`29`		`- return nil, fmt.Errorf("failed to get block for %s: %w", str, err)`
	`29`	`+ return nil, fmt.Errorf("failed to get block for %s: %s", str, safeConnectorErrorForLogging(err, conn))`
`30`	`30`	`}`
`31`	`31`	`if m.Number == nil {`
`32`	`32`	`return nil, fmt.Errorf("failed to unmarshal block for %s: Number is nil", str)`