eth-tracker/internal/processor/block.go

package processor

import (
	"context"

	"github.com/celo-org/celo-blockchain/common"
	"github.com/celo-org/celo-blockchain/core/types"
	"github.com/grassrootseconomics/celo-tracker/internal/handler"
)

func (p *Processor) processBlock(ctx context.Context, block types.Block) error {
	blockNumber := block.NumberU64()

	txs, err := p.chain.GetTransactions(ctx, block)
	p.logg.Debug("successfully fetched transactions", "txs", len(txs))
	if err != nil {
		return err
	}

	receiptsResp, err := p.chain.GetReceipts(ctx, block)
	p.logg.Debug("successfully fetched receipts", "receipts", len(txs))
	if err != nil {
		return err
	}

	for i, receipt := range receiptsResp {
		if receipt.Status > 0 {
			for _, log := range receipt.Logs {
				if p.cache.Exists(log.Address.Hex()) {
					msg := handler.LogMessage{
						Log:       log,
						BlockTime: block.Time(),
					}

					if err := p.handleLogs(ctx, msg); err != nil {
						p.logg.Error("handler error", "handler_type", "log", "error", err)
					}
				}
			}
		} else {
			if p.cache.Exists(txs[i].To().Hex()) {
				from, err := types.Sender(types.LatestSignerForChainID(txs[i].ChainId()), &txs[i])
				if err != nil {
					p.logg.Error("hanlder error", "handler_type", "revert", "error", err)
				}

				revertReason, err := p.chain.GetRevertReason(ctx, receipt.TxHash, receipt.BlockNumber)
				if err != nil {
					p.logg.Error("handler error", "handler_type", "revert", "error", err)
				}

				msg := handler.RevertMessage{
					From:            from.Hex(),
					RevertReason:    revertReason,
					InputData:       common.Bytes2Hex(txs[i].Data()),
					Block:           blockNumber,
					ContractAddress: txs[i].To().Hex(),
					Timestamp:       block.Time(),
					TxHash:          receipt.TxHash.Hex(),
				}

				if err := p.handleRevert(ctx, msg); err != nil {
					p.logg.Error("handler error", "handler_type", "revert", "error", err)
				}
			}
		}
	}

	if err := p.db.SetValue(blockNumber); err != nil {
		return err
	}
	p.logg.Debug("successfully processed block", "block", blockNumber)

	return nil
}

func (p *Processor) handleLogs(ctx context.Context, msg handler.LogMessage) error {
	for _, handler := range p.handlers {
		if err := handler.HandleLog(ctx, msg, p.emitter); err != nil {
			return err
		}
	}

	return nil
}

func (p *Processor) handleRevert(ctx context.Context, msg handler.RevertMessage) error {
	for _, handler := range p.handlers {
		if err := handler.HandleRevert(ctx, msg, p.emitter); err != nil {
			return err
		}
	}

	return nil
}