feat: add bidder emulator for stressnet with hoodi

infrastructure/docker/Dockerfile.builder

@@ -15,6 +15,7 @@ COPY cl/go.mod               cl/go.sum              ./cl/
 COPY infrastructure/tools/keystore-generator/go.mod infrastructure/tools/keystore-generator/go.sum ./infrastructure/tools/keystore-generator/
 
 COPY p2p/integrationtest/provider/entrypoint.sh /scripts/provider-emulator-entrypoint.sh
+COPY p2p/integrationtest/real-bidder/entrypoint.sh /scripts/realbidder-emulator-entrypoint.sh
 
 RUN --mount=type=cache,target=/root/.cache/go-build \
     --mount=type=cache,target=/go/pkg/mod \
@@ -39,6 +40,7 @@ ARG TARGETS="./oracle/cmd \
              ./tools/validators-monitor \
              ./tools/points-service \
              ./p2p/integrationtest/provider \
+             ./p2p/integrationtest/real-bidder \
              ./cl/cmd/singlenode"
 
 RUN --mount=type=cache,target=/root/.cache/go-build \

infrastructure/docker/Dockerfile.realbidder

@@ -0,0 +1,9 @@
+# syntax=docker/dockerfile:1.4
+FROM alpine:3.10
+
+COPY --from=builder_ctx /go/bin/real-bidder /usr/local/bin/bidder-emulator
+COPY --from=builder_ctx /scripts/realbidder-emulator-entrypoint.sh entrypoint.sh
+
+EXPOSE 8080
+
+ENTRYPOINT ["./entrypoint.sh"]

infrastructure/docker/docker-bake.hcl

@@ -140,6 +140,17 @@ target "snode" {
   labels = get_labels("snode")
 }
 
+target "realbidder-emulator" {
+  inherits   = ["_common"]
+  context    = "./"
+  dockerfile = "Dockerfile.realbidder"
+  contexts = {
+    builder_ctx = "target:mev-commit-builder"
+  }
+  tags   = [REPO_NAME != "" ? "${REGISTRY}/${REPO_NAME}:${TAG}-realbidder-emulator" : "${REGISTRY}/realbidder-emulator:${TAG}"]
+  labels = get_labels("realbidder-emulator")
+}
+
 group "all" {
   targets = [
     "mev-commit-builder",
@@ -150,6 +161,7 @@ group "all" {
     "preconf-rpc",
     "bidder-emulator",
     "provider-emulator",
+    "realbidder-emulator",
     "relay-emulator",
     "snode"
   ]

oracle/pkg/node/node.go

@@ -114,7 +114,7 @@ func NewNode(opts *Options) (*Node, error) {
 		txmonitor.NewEVMHelperWithLogger(settlementClient, nd.logger, contracts),
 		st,
 		nd.logger.With("component", "tx_monitor"),
-		1024,
+		2048,
 	)
 
 	ctx, cancel := context.WithCancel(context.Background())

p2p/integrationtest/provider/main.go

@@ -225,7 +225,7 @@ func main() {
 		err = providerClient.SendBidResponse(context.Background(), &providerapiv1.BidResponse{
 			BidDigest:         bid.BidDigest,
 			Status:            status,
-			DispatchTimestamp: time.Now().UnixMilli(),
+			DispatchTimestamp: time.Now().Add(2 * time.Second).UnixMilli(),
 		})
 		if err != nil {
 			logger.Error("failed to send bid response", "error", err)

p2p/integrationtest/real-bidder/main.go

@@ -68,7 +68,7 @@ var (
 	)
 	bidWorkers = flag.Int(
 		"bid-workers",
-		2,
+		10,
 		"Number of workers to send bids",
 	)
 )
@@ -206,7 +206,7 @@ func main() {
 	}
 	logger.Info("deposit manager enabled")
 
-	var providerAddress string
+	var providerAddresses []string
 	retries := 10
 	for range retries {
 		resp, err := bidderClient.GetValidProviders(context.Background(), &pb.GetValidProvidersRequest{})
@@ -215,24 +215,27 @@ func main() {
 			continue
 		}
 		if len(resp.ValidProviders) > 0 {
-			providerAddress = resp.ValidProviders[0]
+			providerAddresses = resp.ValidProviders
 			break
 		}
 		time.Sleep(time.Second)
 	}
 
-	if providerAddress == "" {
+	if len(providerAddresses) == 0 {
 		logger.Error("no connected and valid provider found")
 		return
 	}
 
+	targetDeposits := make([]*pb.TargetDeposit, len(providerAddresses))
+	for i, addr := range providerAddresses {
+		targetDeposits[i] = &pb.TargetDeposit{
+			TargetDeposit: minDeposit.String(),
+			Provider:      addr,
+		}
+	}
+
 	resp, err := bidderClient.SetTargetDeposits(context.Background(), &pb.SetTargetDepositsRequest{
-		TargetDeposits: []*pb.TargetDeposit{
-			{
-				TargetDeposit: minDeposit.String(),
-				Provider:      providerAddress,
-			},
-		},
+		TargetDeposits: targetDeposits,
 	})
 	if err != nil {
 		logger.Error("failed to set target deposits", "err", err)
@@ -250,10 +253,7 @@ func main() {
 		txns     []string
 	}
 
-	blockChans := make([]chan *blockWithTxns, *bidWorkers)
-	for i := 0; i < *bidWorkers; i++ {
-		blockChans[i] = make(chan *blockWithTxns, 1)
-	}
+	blockChan := make(chan *blockWithTxns, 1)
 
 	wg.Add(1)
 	go func(logger *slog.Logger) {
@@ -279,63 +279,40 @@ func main() {
 			}
 
 			currentBlkNum = blkNum
-			for _, ch := range blockChans {
-				txns := make([]string, len(block))
-				copy(txns, block)
-
-				ch <- &blockWithTxns{
-					blockNum: int64(blkNum),
-					txns:     txns,
-				}
+			blockChan <- &blockWithTxns{
+				blockNum: int64(blkNum),
+				txns:     block,
 			}
 		}
 	}(logger)
 
-	for i := 0; i < *bidWorkers; i++ {
-		wg.Add(1)
-		go func(logger *slog.Logger, newBlockChan <-chan *blockWithTxns) {
-			defer wg.Done()
-			ticker := time.NewTicker(200 * time.Millisecond)
-			currentBlock := &blockWithTxns{}
-			for {
-				select {
-				case block := <-newBlockChan:
-					if block.blockNum <= currentBlock.blockNum {
-						continue
+	workerSem := make(chan struct{}, *bidWorkers)
+
+	wg.Add(1)
+	go func(logger *slog.Logger) {
+		defer wg.Done()
+
+		for blockWithTxn := range blockChan {
+			logger.Info("new block received", "blockNum", blockWithTxn.blockNum, "numTxns", len(blockWithTxn.txns))
+			for _, txn := range blockWithTxn.txns {
+				workerSem <- struct{}{}
+				go func(txn string) {
+					defer func() { <-workerSem }()
+					err := sendBid(
+						bidderClient,
+						logger,
+						[]string{txn},
+						blockWithTxn.blockNum,
+						time.Now().Add(500*time.Millisecond).UnixMilli(),
+						time.Now().Add(6*time.Second).UnixMilli(),
+					)
+					if err != nil {
+						logger.Error("failed to send bid", "err", err)
 					}
-					currentBlock = block
-				case <-ticker.C:
-				}
-
-				if len(currentBlock.txns) == 0 {
-					continue
-				}
-
-				bundleLen := rand.Intn(10) + 1
-				bundleStart := rand.Intn(len(currentBlock.txns))
-				bundleEnd := bundleStart + bundleLen
-				if bundleEnd >= len(currentBlock.txns) {
-					bundleEnd = len(currentBlock.txns)
-				}
-
-				min := 5000
-				max := 10000
-				startTimeDiff := rand.Intn(max-min+1) + min
-				endTimeDiff := rand.Intn(max-min+1) + min
-				err = sendBid(
-					bidderClient,
-					logger,
-					currentBlock.txns[bundleStart:bundleEnd],
-					currentBlock.blockNum,
-					(time.Now().UnixMilli())-int64(startTimeDiff),
-					(time.Now().UnixMilli())+int64(endTimeDiff),
-				)
-				if err != nil {
-					logger.Error("failed to send bid", "err", err)
-				}
+				}(txn)
 			}
-		}(logger, blockChans[i])
-	}
+		}
+	}(logger)
 
 	wg.Wait()
 }
@@ -370,8 +347,8 @@ func sendBid(
 	if len(txnHashes) == 0 {
 		return errors.New("no txns to send")
 	}
-	amount := rand.Intn(200000)
-	amount += 100000
+	amount := rand.Intn(2000000000)
+	amount += 1000000000
 
 	hashesToSend := make([]string, len(txnHashes))
 	copy(hashesToSend, txnHashes)

p2p/pkg/node/node.go

@@ -276,7 +276,7 @@ func NewNode(opts *Options) (*Node, error) {
 		txmonitor.NewEVMHelperWithLogger(contractRPC, opts.Logger.With("component", "txmonitor"), contracts),
 		txnStore,
 		opts.Logger.With("component", "txmonitor"),
-		1024,
+		2048,
 	)
 	startables = append(
 		startables,