release: v1.0.0

internal/processor/processor.go

@@ -0,0 +1,147 @@
+package processor
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+
+	"github.com/celo-org/celo-blockchain/common"
+	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/grassrootseconomics/celo-tracker/internal/cache"
+	"github.com/grassrootseconomics/celo-tracker/internal/chain"
+	"github.com/grassrootseconomics/celo-tracker/internal/db"
+	"github.com/grassrootseconomics/celo-tracker/internal/handler"
+	"github.com/grassrootseconomics/celo-tracker/internal/pub"
+	"github.com/grassrootseconomics/celo-tracker/internal/stats"
+)
+
+type (
+	ProcessorOpts struct {
+		Cache cache.Cache
+		DB    db.DB
+		Chain chain.Chain
+		Pub   pub.Pub
+		Logg  *slog.Logger
+		Stats *stats.Stats
+	}
+
+	Processor struct {
+		cache           cache.Cache
+		db              db.DB
+		chain           chain.Chain
+		handlerPipeline handler.HandlerPipeline
+		logg            *slog.Logger
+		stats           *stats.Stats
+	}
+)
+
+func NewProcessor(o ProcessorOpts) *Processor {
+	return &Processor{
+		cache:           o.Cache,
+		db:              o.DB,
+		handlerPipeline: handler.New(o.Pub, o.Cache),
+		chain:           o.Chain,
+		logg:            o.Logg,
+		stats:           o.Stats,
+	}
+}
+
+func (p *Processor) ProcessBlock(ctx context.Context, blockNumber uint64) error {
+	block, err := p.chain.GetBlock(ctx, blockNumber)
+	if err != nil && !errors.Is(err, context.Canceled) {
+		return fmt.Errorf("block %d error: %v", blockNumber, err)
+	}
+
+	receiptsResp, err := p.chain.GetReceipts(ctx, block)
+	if err != nil && !errors.Is(err, context.Canceled) {
+		return fmt.Errorf("receipts fetch error: block %d: %v", blockNumber, err)
+	}
+
+	for _, receipt := range receiptsResp {
+		if receipt.Status > 0 {
+			for _, log := range receipt.Logs {
+				if p.cache.Exists(log.Address.Hex()) {
+					msg := handler.LogMessage{
+						Log:       log,
+						Timestamp: block.Time(),
+					}
+
+					if err := p.handleLog(ctx, msg); err != nil && !errors.Is(err, context.Canceled) {
+						return fmt.Errorf("handle logs error: block %d: %v", blockNumber, err)
+					}
+				}
+			}
+		} else if p.isTrieAvailable(blockNumber) {
+			tx, err := p.chain.GetTransaction(ctx, receipt.TxHash)
+			if err != nil && !errors.Is(err, context.Canceled) {
+				return fmt.Errorf("get transaction error: tx %s: %v", receipt.TxHash.Hex(), err)
+			}
+
+			if tx.To() == nil {
+				return nil
+			}
+
+			if p.cache.Exists(tx.To().Hex()) {
+				from, err := types.Sender(types.LatestSignerForChainID(tx.ChainId()), tx)
+				if err != nil {
+					return fmt.Errorf("transaction decode error: tx %s: %v", receipt.TxHash.Hex(), err)
+				}
+
+				revertReason, err := p.chain.GetRevertReason(ctx, receipt.TxHash, receipt.BlockNumber)
+				if err != nil && !errors.Is(err, context.Canceled) {
+					return fmt.Errorf("get revert reason error: tx %s: %v", receipt.TxHash.Hex(), err)
+				}
+
+				msg := handler.RevertMessage{
+					From:            from.Hex(),
+					RevertReason:    revertReason,
+					InputData:       common.Bytes2Hex(tx.Data()),
+					Block:           blockNumber,
+					ContractAddress: tx.To().Hex(),
+					Timestamp:       block.Time(),
+					TxHash:          receipt.TxHash.Hex(),
+				}
+
+				if err := p.handleRevert(ctx, msg); err != nil && !errors.Is(err, context.Canceled) {
+					return fmt.Errorf("handle revert error: tx %s: %v", receipt.TxHash.Hex(), err)
+				}
+			}
+		}
+	}
+
+	if err := p.db.SetValue(blockNumber); err != nil {
+		return err
+	}
+	p.logg.Debug("successfully processed block", "block", blockNumber)
+
+	return nil
+}
+
+func (p *Processor) isTrieAvailable(blockNumber uint64) bool {
+	available := p.chain.IsArchiveNode() || p.stats.GetLatestBlock()-blockNumber <= 256
+	if !available {
+		p.logg.Warn("skipping block due to potentially missing trie", "block_number", blockNumber)
+	}
+	return available
+}
+
+func (p *Processor) handleLog(ctx context.Context, msg handler.LogMessage) error {
+	for _, handler := range p.handlerPipeline {
+		if err := handler.HandleLog(ctx, msg); err != nil {
+			return fmt.Errorf("log handler: %s err: %v", handler.Name(), err)
+		}
+	}
+
+	return nil
+}
+
+func (p *Processor) handleRevert(ctx context.Context, msg handler.RevertMessage) error {
+	for _, handler := range p.handlerPipeline {
+		if err := handler.HandleRevert(ctx, msg); err != nil {
+			return fmt.Errorf("revert handler: %s err: %v", handler.Name(), err)
+		}
+	}
+
+	return nil
+}