fix: temp

Author: Alok

tools/preconf-rpc/blocktracker/blocktracker.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"log/slog"
 	"math/big"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -22,7 +23,7 @@ type blockTracker struct {
 	blocks        *lru.Cache[uint64, *types.Block]
 	client        EthClient
 	log           *slog.Logger
-	checkTrigger  chan struct{}
+	checkCond     *sync.Cond
 }
 
 func NewBlockTracker(client EthClient, log *slog.Logger) (*blockTracker, error) {
@@ -36,7 +37,7 @@ func NewBlockTracker(client EthClient, log *slog.Logger) (*blockTracker, error)
 		blocks:        cache,
 		client:        client,
 		log:           log,
-		checkTrigger:  make(chan struct{}, 1),
+		checkCond:     sync.NewCond(&sync.Mutex{}),
 	}, nil
 }
 
@@ -73,11 +74,9 @@ func (b *blockTracker) Start(ctx context.Context) <-chan struct{} {
 }
 
 func (b *blockTracker) triggerCheck() {
-	select {
-	case b.checkTrigger <- struct{}{}:
-	default:
-		// Non-blocking send, if channel is full, we skip
-	}
+	b.checkCond.L.Lock()
+	b.checkCond.Broadcast()
+	b.checkCond.L.Unlock()
 }
 
 func (b *blockTracker) LatestBlockNumber() uint64 {
@@ -89,32 +88,43 @@ func (b *blockTracker) CheckTxnInclusion(
 	txHash common.Hash,
 	blockNumber uint64,
 ) (bool, error) {
-WaitForBlock:
-	for {
-		select {
-		case <-ctx.Done():
-			return false, ctx.Err()
-		case <-b.checkTrigger:
-			if blockNumber <= b.latestBlockNo.Load() {
-				break WaitForBlock
-			}
+	if blockNumber <= b.latestBlockNo.Load() {
+		return b.checkTxnInclusion(ctx, txHash, blockNumber)
+	}
+
+	waitCh := make(chan struct{})
+	go func() {
+		b.checkCond.L.Lock()
+		defer b.checkCond.L.Unlock()
+		for blockNumber > b.latestBlockNo.Load() {
+			b.checkCond.Wait()
 		}
+		close(waitCh)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return false, ctx.Err()
+	case <-waitCh:
+		return b.checkTxnInclusion(ctx, txHash, blockNumber)
 	}
+}
 
+func (b *blockTracker) checkTxnInclusion(ctx context.Context, txHash common.Hash, blockNumber uint64) (bool, error) {
+	var err error
 	block, ok := b.blocks.Get(blockNumber)
 	if !ok {
-		block, err := b.client.BlockByNumber(ctx, big.NewInt(int64(blockNumber)))
+		block, err = b.client.BlockByNumber(ctx, big.NewInt(int64(blockNumber)))
 		if err != nil {
 			b.log.Error("Failed to get block by number", "error", err, "blockNumber", blockNumber)
 			return false, err
 		}
 		_ = b.blocks.Add(blockNumber, block)
 	}
 
-	for _, tx := range block.Transactions() {
-		if tx.Hash().Cmp(txHash) == 0 {
-			return true, nil
-		}
+	if txn := block.Transaction(txHash); txn != nil {
+		return true, nil
 	}
+
 	return false, nil
 }

tools/preconf-rpc/pricer/pricer.go

@@ -5,7 +5,9 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
+	"log/slog"
 	"net/http"
+	"sync"
 	"time"
 )
 
@@ -21,23 +23,58 @@ type BlockPrice struct {
 	EstimatedPrices []EstimatedPrice `json:"estimatedPrices"`
 }
 
-type BlockPrices struct {
-	MsSinceLastBlock   int64        `json:"msSinceLastBlock"`
+type blockPrices struct {
 	CurrentBlockNumber int64        `json:"currentBlockNumber"`
 	Prices             []BlockPrice `json:"blockPrices"`
 }
 
 type BidPricer struct {
-	apiKey string
+	apiKey           string
+	log              *slog.Logger
+	mu               sync.RWMutex // Protects currentEstimates
+	currentEstimates map[int64]float64
 }
 
-func NewPricer(apiKey string) *BidPricer {
+func NewPricer(apiKey string, logger *slog.Logger) *BidPricer {
 	return &BidPricer{
 		apiKey: apiKey,
+		log:    logger,
 	}
 }
 
-func (b *BidPricer) EstimatePrice(ctx context.Context) (*BlockPrices, error) {
+func (b *BidPricer) Start(ctx context.Context) <-chan struct{} {
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		ticker := time.NewTicker(2 * time.Second) // Adjust the ticker interval as needed
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if _, err := b.syncEstimate(ctx); err != nil {
+					b.log.Error("Failed to estimate price", "error", err)
+				}
+			}
+		}
+	}()
+	return done
+}
+
+func (b *BidPricer) EstimatePrice(ctx context.Context) map[int64]float64 {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+
+	estimates := make(map[int64]float64)
+	for blockNumber, price := range b.currentEstimates {
+		estimates[blockNumber] = price
+	}
+	return estimates
+}
+
+func (b *BidPricer) SyncEstimate(ctx context.Context) error {
 	client := &http.Client{
 		Timeout: 10 * time.Second,
 	}
@@ -69,7 +106,7 @@ func (b *BidPricer) EstimatePrice(ctx context.Context) (*BlockPrices, error) {
 		return nil, err
 	}
 
-	bp := new(BlockPrices)
+	bp := new(blockPrices)
 	if err := json.Unmarshal(respBuf, bp); err != nil {
 		return nil, err
 	}