Fix varnamelen linter

.golangci.yml

@@ -9,7 +9,6 @@ linters:
     - wrapcheck
     - tagliatelle
     - gomnd
-    - varnamelen
     - nlreturn
     - gochecknoglobals
     - lll
@@ -33,3 +32,16 @@ linters-settings:
   funlen:
     lines: 130
     statements: 60
+  varnamelen:
+    ignore-names:
+      - db
+      - tx
+      - q
+    ignore-decls:
+      - w http.ResponseWriter
+      - r *http.Request
+      - r chi.Router
+      - bt *entity.BlockTimestamp
+      - ok bool
+      - wg *sync.WaitGroup
+      - i int

config/config.go

@@ -94,13 +94,13 @@ type Config struct {
 }
 
 func readYamlConfig(cfg *Config) error {
-	f, err := os.ReadFile("config.yml")
+	blob, err := os.ReadFile("config.yml")
 	if err != nil {
 		return fmt.Errorf("can't access config file: %w", err)
 	}
-	f = []byte(os.ExpandEnv(string(f)))
+	blob = []byte(os.ExpandEnv(string(blob)))
 
-	dec := yaml.NewDecoder(bytes.NewReader(f))
+	dec := yaml.NewDecoder(bytes.NewReader(blob))
 	dec.KnownFields(true)
 	err = dec.Decode(cfg)
 	if err != nil {

contract/utils.go

@@ -33,16 +33,16 @@ func FindMatchingEventABI(contractABI abi.ABI, topics []common.Hash) *abi.Event
 
 func DecodeEventLog(event *abi.Event, topics []common.Hash, data []byte) (map[string]interface{}, error) {
 	indexed := Indexed(event.Inputs)
-	m := make(map[string]interface{})
+	values := make(map[string]interface{})
 	if len(indexed) < len(event.Inputs) {
-		if err := event.Inputs.UnpackIntoMap(m, data); err != nil {
+		if err := event.Inputs.UnpackIntoMap(values, data); err != nil {
 			return nil, fmt.Errorf("can't unpack data: %w", err)
 		}
 	}
-	if err := abi.ParseTopicsIntoMap(m, indexed, topics[1:]); err != nil {
+	if err := abi.ParseTopicsIntoMap(values, indexed, topics[1:]); err != nil {
 		return nil, fmt.Errorf("can't unpack topics: %w", err)
 	}
-	return m, nil
+	return values, nil
 }
 
 func ParseLog(contractABI abi.ABI, log *entity.Log) (string, map[string]interface{}, error) {

entity/log.go

@@ -33,7 +33,7 @@ type LogsRepo interface {
 }
 
 func NewLog(chainID string, log types.Log) *Log {
-	e := &Log{
+	res := &Log{
 		ChainID:         chainID,
 		Address:         log.Address,
 		Data:            log.Data,
@@ -42,18 +42,18 @@ func NewLog(chainID string, log types.Log) *Log {
 		TransactionHash: log.TxHash,
 	}
 	if len(log.Topics) > 0 {
-		e.Topic0 = &log.Topics[0]
+		res.Topic0 = &log.Topics[0]
 		if len(log.Topics) > 1 {
-			e.Topic1 = &log.Topics[1]
+			res.Topic1 = &log.Topics[1]
 			if len(log.Topics) > 2 {
-				e.Topic2 = &log.Topics[2]
+				res.Topic2 = &log.Topics[2]
 				if len(log.Topics) > 3 {
-					e.Topic3 = &log.Topics[3]
+					res.Topic3 = &log.Topics[3]
 				}
 			}
 		}
 	}
-	return e
+	return res
 }
 
 func (l *Log) Topics() []common.Hash {

monitor/alerts/alert_manager.go

@@ -142,17 +142,17 @@ func NewAlertManager(logger logging.Logger, db *db.DB, cfg *config.BridgeConfig)
 }
 
 func (m *AlertManager) Start(ctx context.Context, isSynced func() bool) {
-	t := time.NewTicker(10 * time.Second)
+	ticker := time.NewTicker(10 * time.Second)
 	for !isSynced() {
 		select {
 		case <-ctx.Done():
-			t.Stop()
+			ticker.Stop()
 			return
-		case <-t.C:
+		case <-ticker.C:
 			m.logger.Debug("waiting for bridge monitor to be synchronized on both sides")
 		}
 	}
-	t.Stop()
+	ticker.Stop()
 	m.logger.Info("both sides of the monitor are synced, starting alert manager jobs")
 
 	for name, job := range m.jobs {

monitor/contract_monitor.go

@@ -244,7 +244,7 @@ func (m *ContractMonitor) StartLogsFetcher(ctx context.Context) {
 }
 
 func (m *ContractMonitor) buildFilterQueries(blocksRange *BlocksRange) []ethereum.FilterQuery {
-	var qs []ethereum.FilterQuery
+	var queries []ethereum.FilterQuery
 	q := ethereum.FilterQuery{
 		FromBlock: big.NewInt(int64(blocksRange.From)),
 		ToBlock:   big.NewInt(int64(blocksRange.To)),
@@ -253,7 +253,7 @@ func (m *ContractMonitor) buildFilterQueries(blocksRange *BlocksRange) []ethereu
 	if blocksRange.Topic != nil {
 		q.Topics = [][]common.Hash{{*blocksRange.Topic}}
 	}
-	qs = append(qs, q)
+	queries = append(queries, q)
 	if m.bridgeCfg.BridgeMode == config.BridgeModeErcToNative {
 		for _, token := range m.cfg.ErcToNativeTokens {
 			if token.StartBlock > 0 && blocksRange.To < token.StartBlock {
@@ -262,23 +262,23 @@ func (m *ContractMonitor) buildFilterQueries(blocksRange *BlocksRange) []ethereu
 			if token.EndBlock > 0 && blocksRange.From > token.EndBlock {
 				continue
 			}
-			qc := q
+			q = ethereum.FilterQuery{}
 			if blocksRange.Topic != nil {
-				qc.Topics = [][]common.Hash{{*blocksRange.Topic}, {}, {m.cfg.Address.Hash()}}
+				q.Topics = [][]common.Hash{{*blocksRange.Topic}, {}, {m.cfg.Address.Hash()}}
 			} else {
-				qc.Topics = [][]common.Hash{{}, {}, {m.cfg.Address.Hash()}}
+				q.Topics = [][]common.Hash{{}, {}, {m.cfg.Address.Hash()}}
 			}
-			qc.Addresses = []common.Address{token.Address}
+			q.Addresses = []common.Address{token.Address}
 			if token.StartBlock > 0 && token.StartBlock > blocksRange.From {
-				qc.FromBlock = big.NewInt(int64(token.StartBlock))
+				q.FromBlock = big.NewInt(int64(token.StartBlock))
 			}
 			if token.EndBlock > 0 && token.EndBlock < blocksRange.To {
-				qc.ToBlock = big.NewInt(int64(token.EndBlock))
+				q.ToBlock = big.NewInt(int64(token.EndBlock))
 			}
-			qs = append(qs, qc)
+			queries = append(queries, q)
 		}
 	}
-	return qs
+	return queries
 }
 
 func (m *ContractMonitor) tryToFetchLogs(ctx context.Context, blocksRange *BlocksRange) error {

monitor/handlers.go

@@ -146,14 +146,14 @@ func (p *BridgeEventHandler) HandleErcToNativeUserRequestForAffirmation(ctx cont
 		return fmt.Errorf("failed to get transaction logs for %s: %w", log.TransactionHash, err)
 	}
 	var sender common.Address
-	for _, l := range logs {
+	for _, txLog := range logs {
-		if l.Topic0 != nil && *l.Topic0 == abi.ErcToNativeABI.Events["Transfer"].ID && l.Topic1 != nil && l.Topic2 != nil && len(l.Data) == 32 {
+		if len(txLog.Topics()) >= 3 && *txLog.Topic0 == abi.ErcToNativeABI.Events["Transfer"].ID && len(txLog.Data) == 32 {
-			transferSender := common.BytesToAddress(l.Topic1[:])
+			transferSender := common.BytesToAddress(txLog.Topic1[:])
-			transferReceiver := common.BytesToAddress(l.Topic2[:])
+			transferReceiver := common.BytesToAddress(txLog.Topic2[:])
-			transferValue := new(big.Int).SetBytes(l.Data)
+			transferValue := new(big.Int).SetBytes(txLog.Data)
 			if transferReceiver == p.cfg.Foreign.Address && value.Cmp(transferValue) == 0 {
 				for _, t := range p.cfg.Foreign.ErcToNativeTokens {
-					if l.Address == t.Address && l.BlockNumber >= t.StartBlock && (t.EndBlock == 0 || l.BlockNumber <= t.EndBlock) {
+					if txLog.Address == t.Address && txLog.BlockNumber >= t.StartBlock && (t.EndBlock == 0 || txLog.BlockNumber <= t.EndBlock) {
 						sender = transferSender
 					}
 				}

presenter/presenter.go

@@ -82,7 +82,7 @@ func (p *Presenter) Serve(addr string) error {
 	return http.ListenAndServe(addr, p.root)
 }
 
-func (p *Presenter) JSON(w http.ResponseWriter, r *http.Request, status int, v interface{}) {
+func (p *Presenter) JSON(w http.ResponseWriter, r *http.Request, status int, res interface{}) {
 	enc := json.NewEncoder(w)
 
 	if pretty, _ := strconv.ParseBool(chi.URLParam(r, "pretty")); pretty {
@@ -90,7 +90,7 @@ func (p *Presenter) JSON(w http.ResponseWriter, r *http.Request, status int, v i
 	}
 
 	w.WriteHeader(status)
-	if err := enc.Encode(v); err != nil {
+	if err := enc.Encode(res); err != nil {
 		p.Error(w, r, fmt.Errorf("failed to marshal JSON result: %w", err))
 		return
 	}
@@ -680,13 +680,13 @@ func (p *Presenter) getTxInfo(ctx context.Context, logID uint) (*TxInfo, error)
 	if err != nil {
 		return nil, err
 	}
-	ts, err := p.repo.BlockTimestamps.GetByBlockNumber(ctx, log.ChainID, log.BlockNumber)
+	bt, err := p.repo.BlockTimestamps.GetByBlockNumber(ctx, log.ChainID, log.BlockNumber)
 	if err != nil {
 		return nil, err
 	}
 	return &TxInfo{
 		BlockNumber: log.BlockNumber,
-		Timestamp:   ts.Timestamp,
+		Timestamp:   bt.Timestamp,
 		Link:        logToTxLink(log),
 	}, nil
 }

repository/postgres/block_timestamps.go

@@ -47,13 +47,13 @@ func (r *blockTimestampsRepo) GetByBlockNumber(ctx context.Context, chainID stri
 	if err != nil {
 		return nil, fmt.Errorf("can't build query: %w", err)
 	}
-	ts := new(entity.BlockTimestamp)
+	bt := new(entity.BlockTimestamp)
-	err = r.db.GetContext(ctx, ts, q, args...)
+	err = r.db.GetContext(ctx, bt, q, args...)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, db.ErrNotFound
 		}
 		return nil, fmt.Errorf("can't get block timestamp: %w", err)
 	}
-	return ts, nil
+	return bt, nil
 }