poanetwork
/
amb-monitor
mirror of https://github.com/poanetwork/amb-monitor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix varnamelen linter

This commit is contained in:
Kirill Fedoseev 2022-05-23 19:11:24 +04:00
parent 6ec0cac3a8
commit b3d726e48b
9 changed files with 53 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.golangci.yml
View File

@ -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

6
config/config.go
View File

@ -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 {

8
contract/utils.go
View File

@ -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) {

12
entity/log.go
View File

@ -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 {

8
monitor/alerts/alert_manager.go
View File

@ -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 {

20
monitor/contract_monitor.go
View File

@ -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 {

12
monitor/handlers.go
View File

@ -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 {
if l.Topic0 != nil && *l.Topic0 == abi.ErcToNativeABI.Events["Transfer"].ID && l.Topic1 != nil && l.Topic2 != nil && len(l.Data) == 32 {
transferSender := common.BytesToAddress(l.Topic1[:])
transferReceiver := common.BytesToAddress(l.Topic2[:])
transferValue := new(big.Int).SetBytes(l.Data)
for _, txLog := range logs {
if len(txLog.Topics()) >= 3 && *txLog.Topic0 == abi.ErcToNativeABI.Events["Transfer"].ID && len(txLog.Data) == 32 {
transferSender := common.BytesToAddress(txLog.Topic1[:])
transferReceiver := common.BytesToAddress(txLog.Topic2[:])
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
}
}

8
presenter/presenter.go
View File

@ -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
}

6
repository/postgres/block_timestamps.go
View File

@ -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)
err = r.db.GetContext(ctx, ts, q, args...)
bt := new(entity.BlockTimestamp)
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
}