synapsecns/sanguine

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/synapsecns/sanguine/ethergo/client"
    listenerDB "github.com/synapsecns/sanguine/ethergo/listener/db"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/ethergo/listener"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

const (
    ethereumNodeURL = "https://eth.llamarpc.com"                   // Replace with your Ethereum node URL
    contractAddress = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" // Replace with the contract address you want to listen to
    dbPath          = ":memory:"
    initialBlock    = 0 // Replace with the block number you want to start listening from
    startBlock      = 20612563
)

func main() {
    db, err := gorm.Open(sqlite.Open(dbPath), &gorm.Config{})
    if err != nil {
        log.Fatalf("Failed to connect to database: %v", err)
    }

    err = db.AutoMigrate(listenerDB.GetAllModels()...)
    if err != nil {
        log.Fatalf("Failed to migrate database: %v", err)
    }

    // Create a simple metrics handler (you may want to implement a proper one)
    metricsHandler := metrics.NewNullHandler()

    store := listenerDB.NewChainListenerStore(db, metricsHandler)

    _, err = store.LatestBlockForChain(context.Background(), 1)
    if err != nil {
        if !errors.Is(err, listenerDB.ErrNoLatestBlockForChainID) {
            log.Fatalf("Failed to get latest block: %v", err)
        }

        // pick a reasonable start block, will default to 0.
        err = store.PutLatestBlock(context.Background(), 1, startBlock)
        if err != nil {
            log.Fatalf("Failed to put latest block): %v", err)
        }
    }

    ethClient, err := client.DialBackend(context.Background(), ethereumNodeURL, metricsHandler)
    if err != nil {
        log.Fatalf("Failed to connect to Ethereum node: %v", err)
    }

    contractAddr := common.HexToAddress(contractAddress)

    chainListener, err := listener.NewChainListener(
        ethClient,
        store,
        contractAddr,
        uint64(initialBlock),
        metricsHandler,
    )
    if err != nil {
        log.Fatalf("Failed to create chain listener: %v", err)
    }

    ctx := context.Background()

    fmt.Println("Starting listener...")
    err = chainListener.Listen(ctx, handleLog)
    if err != nil {
        log.Fatalf("Listener error: %v", err)
    }
}

func handleLog(_ context.Context, log types.Log) error {
    fmt.Printf("New log: BlockNumber=%d, TxHash=%s\n", log.BlockNumber, log.TxHash.Hex())
    // Here you can process the log as needed
    return nil
}