fmt

Author: pompon0

generator/prewarm.go

@@ -10,78 +10,78 @@ import (
 
 // PrewarmGenerator generates self-transfer transactions to prewarm account nonces
 type PrewarmGenerator struct {
-	accountPools    []types.AccountPool
-	evmScenario     scenarios.TxGenerator
-	currentPoolIdx  int
-	finished        bool
-	mu              sync.RWMutex
+	accountPools   []types.AccountPool
+	evmScenario    scenarios.TxGenerator
+	currentPoolIdx int
+	finished       bool
+	mu             sync.RWMutex
 }
 
 // NewPrewarmGenerator creates a new prewarm generator using all account pools from the main generator
 func NewPrewarmGenerator(config *config.LoadConfig, mainGenerator Generator) *PrewarmGenerator {
 	// Get all account pools from the main generator
 	accountPools := mainGenerator.GetAccountPools()
-	
+
 	// Create EVMTransfer scenario for prewarming
 	evmScenario := scenarios.NewEVMTransferScenario()
-	
+
 	// Deploy/initialize the scenario (EVMTransfer doesn't need actual deployment)
 	deployerAccounts := types.GenerateAccounts(1)
 	deployer := deployerAccounts[0]
 	evmScenario.Deploy(config, deployer)
-	
+
 	return &PrewarmGenerator{
-		accountPools: accountPools,
-		evmScenario:  evmScenario,
+		accountPools:   accountPools,
+		evmScenario:    evmScenario,
 		currentPoolIdx: 0,
-		finished:     false,
+		finished:       false,
 	}
 }
 
 // Generate generates self-transfer transactions until all accounts are prewarmed
 func (pg *PrewarmGenerator) Generate() (*types.LoadTx, bool) {
 	pg.mu.Lock()
 	defer pg.mu.Unlock()
-	
+
 	// Check if we're already finished
 	if pg.finished || pg.currentPoolIdx >= len(pg.accountPools) {
 		return nil, false
 	}
-	
+
 	// Get current pool
 	currentPool := pg.accountPools[pg.currentPoolIdx]
 	account := currentPool.NextAccount()
-	
+
 	// If this account has nonce > 0, we've already prewarmed it (round-robin means we're done with this pool)
 	if account.Nonce > 0 {
 		// Move to next pool
 		pg.currentPoolIdx++
-		
+
 		// Check if we've finished all pools
 		if pg.currentPoolIdx >= len(pg.accountPools) {
 			pg.finished = true
 			return nil, false
 		}
-		
+
 		// Get account from next pool
 		currentPool = pg.accountPools[pg.currentPoolIdx]
 		account = currentPool.NextAccount()
-		
+
 		// If this account also has nonce > 0, we're completely done
 		if account.Nonce > 0 {
 			pg.finished = true
 			return nil, false
 		}
 	}
-	
+
 	// Create self-transfer transaction
 	scenario := &types.TxScenario{
 		Name:     "EVMTransfer",
 		Sender:   account,
 		Receiver: account.Address, // Send to self
 		Nonce:    account.GetAndIncrementNonce(),
 	}
-	
+
 	// Generate the transaction using EVMTransfer scenario
 	return pg.evmScenario.Generate(scenario), true
 }
@@ -103,7 +103,7 @@ func (pg *PrewarmGenerator) GenerateN(n int) []*types.LoadTx {
 func (pg *PrewarmGenerator) GetAccountPools() []types.AccountPool {
 	pg.mu.RLock()
 	defer pg.mu.RUnlock()
-	
+
 	// Return a copy to prevent external modification
 	pools := make([]types.AccountPool, len(pg.accountPools))
 	copy(pools, pg.accountPools)

generator/scenarios/factory.go

@@ -11,9 +11,9 @@ var scenarioFactories = map[string]ScenarioFactory{
 	// Auto-generated entries will be added below this line by make generate
 	// DO NOT EDIT BELOW THIS LINE - AUTO-GENERATED CONTENT
 	ERC20Conflict: NewERC20ConflictScenario,
-	ERC20Noop: NewERC20NoopScenario,
-	ERC20: NewERC20Scenario,
-	ERC721: NewERC721Scenario,
+	ERC20Noop:     NewERC20NoopScenario,
+	ERC20:         NewERC20Scenario,
+	ERC721:        NewERC721Scenario,
 
 	// DO NOT EDIT ABOVE THIS LINE - AUTO-GENERATED CONTENT
 }

generator/weighted.go

@@ -2,8 +2,8 @@ package generator
 
 import (
 	"context"
-	"math/rand"
 	"github.com/sei-protocol/sei-load/types"
+	"math/rand"
 	"sync"
 )
 

sender/dispatcher.go

@@ -3,14 +3,14 @@ package sender
 import (
 	"context"
 	"fmt"
+	"golang.org/x/time/rate"
+	"log"
 	"sync"
 	"time"
-	"log"
-	"golang.org/x/time/rate"
 
-	"github.com/sei-protocol/sei-load/utils"
 	"github.com/sei-protocol/sei-load/generator"
 	"github.com/sei-protocol/sei-load/stats"
+	"github.com/sei-protocol/sei-load/utils"
 )
 
 // Dispatcher continuously generates transactions and dispatches them to the sender
@@ -20,7 +20,7 @@ type Dispatcher struct {
 	sender     TxSender
 
 	// Configuration
-	limiter  *rate.Limiter
+	limiter *rate.Limiter
 
 	// Statistics
 	totalSent uint64
@@ -33,15 +33,15 @@ func NewDispatcher(gen generator.Generator, sender TxSender) *Dispatcher {
 	return &Dispatcher{
 		generator: gen,
 		sender:    sender,
-		limiter: rate.NewLimiter(rate.Inf, 1), // No rate limiting by default
+		limiter:   rate.NewLimiter(rate.Inf, 1), // No rate limiting by default
 	}
 }
 
 // SetRateLimit sets the minimum time between transaction generations
 func (d *Dispatcher) SetRateLimit(duration time.Duration) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	d.limiter = rate.NewLimiter(rate.Every(duration),1)
+	d.limiter = rate.NewLimiter(rate.Every(duration), 1)
 }
 
 // SetStatsCollector sets the statistics collector for this dispatcher
@@ -65,7 +65,9 @@ func (d *Dispatcher) Prewarm(ctx context.Context) error {
 	d.mu.RUnlock()
 
 	gen, ok := prewarmGen.Get()
-	if !ok { return nil } // No prewarming configured
+	if !ok {
+		return nil
+	} // No prewarming configured
 
 	log.Print("🔥 Starting account prewarming...")
 	processedAccounts := 0
@@ -103,7 +105,7 @@ func (d *Dispatcher) Run(ctx context.Context) error {
 	d.mu.RUnlock()
 
 	for {
-		if err:=limiter.Wait(ctx); err!=nil {
+		if err := limiter.Wait(ctx); err != nil {
 			return err
 		}
 		// Generate a transaction from main generator
@@ -116,7 +118,7 @@ func (d *Dispatcher) Run(ctx context.Context) error {
 		// Send the transaction
 		if err := d.sender.Send(ctx, tx); err != nil {
 			return err
-		} 
+		}
 		d.mu.Lock()
 		d.totalSent++
 		d.mu.Unlock()
@@ -132,7 +134,7 @@ func (d *Dispatcher) RunBatch(ctx context.Context, count int) error {
 	limiter := d.limiter
 	d.mu.RUnlock()
 	for i := range count {
-		if err:=limiter.Wait(ctx); err!=nil {
+		if err := limiter.Wait(ctx); err != nil {
 			return err
 		}
 		// Generate a transaction

sender/sender_test.go

@@ -110,7 +110,7 @@ func TestShardDistributionVerification(t *testing.T) {
 	mockAccount := &types.Account{
 		Address: common.HexToAddress("0x1234567890123456789012345678901234567890"),
 	}
-	
+
 	mockTx := &types.LoadTx{
 		EthTx: ethtypes.NewTransaction(0, common.Address{}, big.NewInt(0), 21000, big.NewInt(1000000000), nil),
 		Scenario: &types.TxScenario{

sender/sharded_sender.go

@@ -1,9 +1,9 @@
 package sender
 
 import (
+	"context"
 	"fmt"
 	"sync"
-	"context"
 
 	"github.com/sei-protocol/sei-load/config"
 	"github.com/sei-protocol/sei-load/stats"

sender/worker.go

@@ -6,34 +6,34 @@ import (
 	"fmt"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"io"
-	"net"
 	"log"
+	"net"
 	"net/http"
 	"time"
 
 	"github.com/sei-protocol/sei-load/stats"
 	"github.com/sei-protocol/sei-load/types"
-	"github.com/sei-protocol/sei-load/utils/service"
 	"github.com/sei-protocol/sei-load/utils"
+	"github.com/sei-protocol/sei-load/utils/service"
 )
 
 // Worker handles sending transactions to a specific endpoint
 type Worker struct {
-	id         int
-	endpoint   string
-	txChan     chan *types.LoadTx
-	sentTxs    chan *types.LoadTx
-	dryRun     bool
-	debug      bool
-	collector  *stats.Collector
-	logger     *stats.Logger
-	workers    int
+	id            int
+	endpoint      string
+	txChan        chan *types.LoadTx
+	sentTxs       chan *types.LoadTx
+	dryRun        bool
+	debug         bool
+	collector     *stats.Collector
+	logger        *stats.Logger
+	workers       int
 	trackReceipts bool
 }
 
 func newHttpClient() *http.Client {
 	return &http.Client{
-		Timeout:   30 * time.Second,
+		Timeout: 30 * time.Second,
 		Transport: &http.Transport{
 			DialContext: (&net.Dialer{
 				Timeout:   10 * time.Second,
@@ -52,11 +52,11 @@ func newHttpClient() *http.Client {
 // NewWorker creates a new worker for a specific endpoint
 func NewWorker(id int, endpoint string, bufferSize int, workers int) *Worker {
 	return &Worker{
-		id:         id,
-		endpoint:   endpoint,	
-		txChan:     make(chan *types.LoadTx, bufferSize),
-		sentTxs:    make(chan *types.LoadTx, bufferSize),
-		workers:    workers,
+		id:            id,
+		endpoint:      endpoint,
+		txChan:        make(chan *types.LoadTx, bufferSize),
+		sentTxs:       make(chan *types.LoadTx, bufferSize),
+		workers:       workers,
 		trackReceipts: true,
 	}
 }
@@ -73,7 +73,7 @@ func (w *Worker) Run(ctx context.Context) error {
 		// Start multiple worker goroutines that share the same channel
 		client := newHttpClient()
 		for range w.workers {
-			s.Spawn(func() error { return w.processTransactions(ctx,client) })
+			s.Spawn(func() error { return w.processTransactions(ctx, client) })
 		}
 		return w.watchTransactions(ctx)
 	})
@@ -109,19 +109,21 @@ func (w *Worker) watchTransactions(ctx context.Context) error {
 	}
 	for {
 		tx, err := utils.Recv(ctx, w.sentTxs)
-		if err!=nil { return err }
-		ctx,cancel := context.WithTimeout(ctx, 10*time.Second)
+		if err != nil {
+			return err
+		}
+		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 		defer cancel()
 		if err := w.waitForReceipt(ctx, eth, tx); err != nil {
-			log.Printf("❌ %v",err)
+			log.Printf("❌ %v", err)
 		}
 	}
 }
 
 func (w *Worker) waitForReceipt(ctx context.Context, eth *ethclient.Client, tx *types.LoadTx) error {
 	ticker := time.NewTicker(100 * time.Millisecond)
 	for {
-		if _,err := utils.Recv(ctx, ticker.C); err != nil {
+		if _, err := utils.Recv(ctx, ticker.C); err != nil {
 			return fmt.Errorf("timeout waiting for receipt for tx %s", tx.EthTx.Hash().Hex())
 		}
 		receipt, err := eth.TransactionReceipt(context.Background(), tx.EthTx.Hash())
@@ -146,16 +148,18 @@ func (w *Worker) waitForReceipt(ctx context.Context, eth *ethclient.Client, tx *
 // processTransactions is the main worker loop that processes transactions
 func (w *Worker) processTransactions(ctx context.Context, client *http.Client) error {
 	for {
-		tx,err := utils.Recv(ctx, w.txChan)
-		if err != nil { return err }
+		tx, err := utils.Recv(ctx, w.txChan)
+		if err != nil {
+			return err
+		}
 		startTime := time.Now()
 		err = w.sendTransaction(ctx, client, tx)
 		// Record statistics if collector is available
 		if w.collector != nil {
-			w.collector.RecordTransaction(tx.Scenario.Name, w.endpoint, time.Since(startTime), err==nil)
+			w.collector.RecordTransaction(tx.Scenario.Name, w.endpoint, time.Since(startTime), err == nil)
 		}
-		if err!=nil {
-			log.Printf("%v",err)
+		if err != nil {
+			log.Printf("%v", err)
 		}
 	}
 }
@@ -165,7 +169,7 @@ func (w *Worker) sendTransaction(ctx context.Context, client *http.Client, tx *t
 	if w.dryRun {
 		// In dry-run mode, simulate processing time and mark as successful
 		// Use very minimal delay to avoid channel overflow
-		return utils.Sleep(ctx, 10 * time.Microsecond) // Much faster simulation
+		return utils.Sleep(ctx, 10*time.Microsecond) // Much faster simulation
 	}
 
 	// Create HTTP request with JSON-RPC payload

stats/block_collector.go

@@ -62,14 +62,18 @@ func (bc *BlockCollector) Run(ctx context.Context, firstEndpoint string) error {
 		}
 		defer sub.Unsubscribe()
 		s.SpawnBg(func() error {
-			subErr,err := utils.Recv(ctx, sub.Err())
-			if err != nil { return err }
+			subErr, err := utils.Recv(ctx, sub.Err())
+			if err != nil {
+				return err
+			}
 			return subErr
 		})
 		log.Printf("📡 Subscribed to new blocks on %s", wsEndpoint)
 		for {
-			header,err := utils.Recv(ctx, headers)
-			if err != nil { return err }
+			header, err := utils.Recv(ctx, headers)
+			if err != nil {
+				return err
+			}
 			bc.processNewBlock(header)
 		}
 	})