test

ethergo/listener/listener_test.go

@@ -3,24 +3,22 @@ package listener_test
 import (
 	"context"
 	"fmt"
+	"sync"
+
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/synapsecns/sanguine/ethergo/listener"
-	"sync"
 )
 
 func (l *ListenerTestSuite) TestListenForEvents() {
 	_, handle := l.manager.GetCounter(l.GetTestContext(), l.backend)
 	var wg sync.WaitGroup
 	const iterations = 10
 	for i := 0; i < iterations; i++ {
-		i := i
 		wg.Add(1)
-		go func(_ int) {
+		go func() {
 			defer wg.Done()
-
 			auth := l.backend.GetTxContext(l.GetTestContext(), nil)
-
 			//nolint:typecheck
 			bridgeRequestTX, err := handle.IncrementCounter(auth.TransactOpts)
 			l.NoError(err)
@@ -32,18 +30,55 @@ func (l *ListenerTestSuite) TestListenForEvents() {
 			l.NoError(err)
 			l.NotNil(bridgeResponseTX)
 			l.backend.WaitForConfirmation(l.GetTestContext(), bridgeResponseTX)
-		}(i)
+		}()
 	}
 
 	wg.Wait()
 
 	startBlock, err := handle.DeployBlock(&bind.CallOpts{Context: l.GetTestContext()})
 	l.NoError(err)
 
-	cl, err := listener.NewChainListener(l.backend, l.store, handle.Address(), uint64(startBlock.Int64()), l.metrics, listener.WithNewBlockHandler(func(ctx context.Context, block uint64) error {
-		fmt.Println(block)
-		return nil
-	}))
+	cl, err := listener.NewChainListener(
+		l.backend,
+		l.store,
+		handle.Address(),
+		uint64(startBlock.Int64()),
+		l.metrics,
+		listener.WithNewBlockHandler(func(ctx context.Context, block uint64) error {
+			fmt.Println(block)
+			return nil
+		}),
+	)
+	l.NoError(err)
+
+	clSafe, err := listener.NewChainListener(
+		l.backend,
+		l.store,
+		handle.Address(),
+		uint64(startBlock.Int64()),
+		l.metrics,
+		listener.WithNewBlockHandler(func(ctx context.Context, block uint64) error {
+			fmt.Println(block)
+			return nil
+		}),
+		listener.WithFinalityMode("safe"),
+		listener.WithBlockWait(10),
+	)
+	l.NoError(err)
+
+	clFinalized, err := listener.NewChainListener(
+		l.backend,
+		l.store,
+		handle.Address(),
+		uint64(startBlock.Int64()),
+		l.metrics,
+		listener.WithNewBlockHandler(func(ctx context.Context, block uint64) error {
+			fmt.Println(block)
+			return nil
+		}),
+		listener.WithFinalityMode("finalized"),
+		listener.WithBlockWait(10),
+	)
 	l.NoError(err)
 
 	eventCount := 0
@@ -59,4 +94,27 @@ func (l *ListenerTestSuite) TestListenForEvents() {
 
 		return nil
 	})
+
+	_ = clSafe.Listen(listenCtx, func(ctx context.Context, log types.Log) error {
+		eventCount++
+
+		if eventCount == iterations*2 {
+			cancel()
+		}
+
+		return nil
+	})
+
+	_ = clFinalized.Listen(listenCtx, func(ctx context.Context, log types.Log) error {
+		eventCount++
+
+		if eventCount == iterations*2 {
+			cancel()
+		}
+
+		return nil
+	})
+
+	l.NotEqual(cl.LatestBlock(), clFinalized.LatestBlock(), clSafe.LatestBlock())
+
 }

ethergo/listener/options.go

@@ -33,10 +33,6 @@ func WithFinalityMode(mode string) Option {
 		switch mode {
 		case "latest":
 			c.finalityMode = rpc.LatestBlockNumber
-		case "earliest":
-			c.finalityMode = rpc.EarliestBlockNumber
-		case "pending":
-			c.finalityMode = rpc.PendingBlockNumber
 		case "safe":
 			c.finalityMode = rpc.SafeBlockNumber
 		case "finalized":