load

package
v1.20.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 4, 2025 License: BSD-3-Clause Imports: 25 Imported by: 0

README

Load Testing Framework

This directory contains a comprehensive load testing framework for the Lux network, designed to measure and optimize transaction throughput, latency, and overall network performance.

Overview

The load testing framework provides sophisticated tools to generate, execute, and analyze various load patterns against Lux nodes. It supports TPS (Transactions Per Second) targeting, latency percentile tracking, and multiple load generation scenarios.

Key Features

  • TPS Targeting: Precise control over transaction throughput with feedback-based adjustments
  • Latency Tracking: Real-time percentile calculations (P50, P75, P90, P95, P99, P999)
  • Multiple Load Patterns: Constant rate, ramp-up, burst, wave, and step patterns
  • Comprehensive Metrics: Success rates, error distribution, and performance statistics
  • Scenario Testing: Pre-configured test scenarios for common use cases

Components

Core Components
  • Agent (agent.go): Coordinates transaction issuance and confirmation tracking
  • Orchestrator (orchestrator.go): Manages load generation across multiple agents with TPS control
  • Tracker (tracker.go): Monitors transaction status, latency, and success rates
  • Metrics (metrics.go): Advanced metrics collection with percentile tracking
  • Generator (generator.go): Load pattern generation with various strategies
  • Wallet (wallet.go): Transaction signing and submission management
Test Scenarios
  • Sustained Load: Constant TPS over a specified duration
  • Ramp-Up: Gradually increasing TPS to find maximum capacity
  • Spike Testing: Sudden burst of transactions to test recovery
  • Stress Testing: Finding system breaking points
  • Soak Testing: Long-duration stability testing

Usage

Running All Tests
# Run all load test scenarios
go test ./tests/load -v

# Run specific test scenario
go test ./tests/load -v -run TestScenarioSustainedLoad

# Run with custom timeout
go test ./tests/load -v -timeout 30m
Configuration
Basic Configuration
config := OrchestratorConfig{
    MaxTPS:           5000,     // Maximum target TPS
    MinTPS:           1000,     // Starting TPS
    Step:             1000,     // TPS increment step
    TxRateMultiplier: 1.3,      // Overprovision factor
    SustainedTime:    20 * time.Second,
    MaxAttempts:      3,        // Retry attempts
    Terminate:        true,     // Stop at max TPS
}
Load Patterns
// Constant rate pattern
pattern := NewConstantRatePattern(1000) // 1000 TPS

// Ramp pattern
pattern := NewRampPattern(100, 5000, 5*time.Minute)

// Burst pattern
pattern := NewBurstPattern(1000, 10*time.Second)

// Wave pattern (sinusoidal)
pattern := NewWavePattern(500, 2000, 30*time.Second)

// Step pattern
pattern := NewStepPattern([]float64{100, 500, 1000, 2000}, 30*time.Second)
Example Test Scenarios
1. Sustained Load Test
func TestSustainedLoad(t *testing.T) {
    config := OrchestratorConfig{
        MaxTPS: 1000,
        MinTPS: 1000,
        Step: 0,
        TxRateMultiplier: 1.0,
        SustainedTime: 5 * time.Second,
        Terminate: false,
    }
    
    // Run for 60 seconds at 1000 TPS
    ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
    defer cancel()
    
    orchestrator.Execute(ctx)
}
2. Finding Maximum TPS
func TestFindMaxTPS(t *testing.T) {
    config := OrchestratorConfig{
        MaxTPS: 10000,
        MinTPS: 1000,
        Step: 500,
        TxRateMultiplier: 1.2,
        SustainedTime: 10 * time.Second,
        MaxAttempts: 3,
        Terminate: true,
    }
    
    orchestrator.Execute(ctx)
    maxTPS := orchestrator.GetMaxObservedTPS()
}
3. Spike Recovery Test
func TestSpikeRecovery(t *testing.T) {
    // Burst mode with MaxTPS = -1
    config := OrchestratorConfig{
        MaxTPS: -1,
        MinTPS: 10000,  // Burst size
        Step: 0,
        TxRateMultiplier: 1.0,
        SustainedTime: 5 * time.Second,
        Terminate: true,
    }
    
    orchestrator.Execute(ctx)
}

Metrics and Reporting

Available Metrics

  • Transaction Metrics:

    • Total issued, confirmed, failed
    • Success rate percentage
    • Error distribution by type

  • Performance Metrics:

    • Current TPS
    • Average TPS
    • Peak TPS
    • TPS over time

  • Latency Metrics:

    • Percentiles: P50, P75, P90, P95, P99, P999
    • Min, Max, Mean, StdDev
    • Histogram buckets
Accessing Metrics
// Get latency percentiles
percentiles := metrics.GetLatencyPercentiles()
fmt.Printf("P50: %.2fms, P95: %.2fms, P99: %.2fms\n", 
    percentiles.P50, percentiles.P95, percentiles.P99)

// Get transaction counts
confirmed := tracker.GetObservedConfirmed()
failed := tracker.GetObservedFailed()
issued := tracker.GetObservedIssued()

// Calculate success rate
successRate := float64(confirmed) / float64(confirmed + failed)
Load Report Generation
report := LoadReport{
    StartTime:          startTime,
    EndTime:            time.Now(),
    Duration:           duration,
    TotalTransactions:  issued,
    SuccessfulTx:       confirmed,
    FailedTx:           failed,
    AverageTPS:         avgTPS,
    PeakTPS:            peakTPS,
    SuccessRate:        successRate,
    LatencyPercentiles: percentiles,
}

fmt.Println(report.String())

Performance Targets

  • Minimum Sustained TPS: 1000
  • Target TPS: 5000+
  • P95 Latency: < 500ms
  • P99 Latency: < 1000ms
  • Success Rate: > 99.5%
Stress Testing Targets
  • Burst Capacity: 10x normal load for 10 seconds
  • Recovery Time: < 30 seconds after spike
  • Degradation Threshold: 80% of peak TPS
  • Stability Duration: 1 hour sustained load

Advanced Usage

Custom Load Patterns
type CustomPattern struct {
    // Your pattern implementation
}

func (p *CustomPattern) NextDelay() time.Duration {
    // Calculate delay for next transaction
}

func (p *CustomPattern) ShouldSend() bool {
    // Determine if transaction should be sent
}

func (p *CustomPattern) Reset() {
    // Reset pattern state
}
TPS Controller with Feedback
controller := NewTPSController(1000)

// Update with actual counts
controller.UpdateActualTPS(confirmedCount)

// Get adjusted delay
delay := controller.GetDelay()

// Get statistics
target, actual, adjustment := controller.GetStats()

Troubleshooting

Common Issues

  1. Low TPS Achievement

    • Increase TxRateMultiplier (e.g., 1.5)
    • Add more agents/workers
    • Check network latency

  2. High Failure Rate

    • Reduce target TPS
    • Increase SustainedTime for stability
    • Check node resources

  3. Inconsistent Results

    • Use longer SustainedTime (20+ seconds)
    • Increase sample size
    • Check for network congestion

Contributing

When adding new test scenarios:

  1. Implement in scenarios_test.go
  2. Add corresponding mock helpers if needed
  3. Update metrics collection as appropriate
  4. Document expected behavior and targets
  5. Ensure tests are idempotent and cleanup properly

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrFailedToIssueTx = errors.New("failed to issue transaction")
View Source 
var ErrFailedToReachTargetTPS = errors.New("failed to reach target TPS")

Functions

func TestScenarioRampUpFixed added in v1.20.5 

func TestScenarioRampUpFixed(t *testing.T)

TestScenarioRampUpFixed tests gradually increasing TPS with improved mocks

func TestScenarioSpikeFixed added in v1.20.5 

func TestScenarioSpikeFixed(t *testing.T)

TestScenarioSpikeFixed tests sudden TPS burst with improved synchronization

func TestScenarioStressRecoveryFixed added in v1.20.5 

func TestScenarioStressRecoveryFixed(t *testing.T)

TestScenarioStressRecoveryFixed tests recovery with improved failure handling

func TestScenarioSustainedLoadFixed added in v1.20.5 

func TestScenarioSustainedLoadFixed(t *testing.T)

TestScenarioSustainedLoadFixed tests constant TPS with better timing

Types

type Agent 

type Agent[T TxID] struct {
	Issuer   Issuer[T]
	Listener Listener[T]
}

func NewAgent 

func NewAgent[T TxID](
	issuer Issuer[T],
	listener Listener[T],
) Agent[T]

type BurstPattern added in v1.20.5 

type BurstPattern struct {
	// contains filtered or unexported fields
}

BurstPattern generates bursts of load

func NewBurstPattern added in v1.20.5 

func NewBurstPattern(burstSize int, burstInterval time.Duration) *BurstPattern

func (*BurstPattern) NextDelay added in v1.20.5 

func (b *BurstPattern) NextDelay() time.Duration

func (*BurstPattern) Reset added in v1.20.5 

func (b *BurstPattern) Reset()

func (*BurstPattern) ShouldSend added in v1.20.5 

func (b *BurstPattern) ShouldSend() bool

type CallDepthTest added in v1.11.14 

type CallDepthTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (CallDepthTest) Run added in v1.11.14 

func (c CallDepthTest) Run(tc tests.TestContext, wallet *Wallet)

type ConstantRatePattern added in v1.20.5 

type ConstantRatePattern struct {
	// contains filtered or unexported fields
}

ConstantRatePattern generates load at a constant rate

func NewConstantRatePattern added in v1.20.5 

func NewConstantRatePattern(tps float64) *ConstantRatePattern

func (*ConstantRatePattern) NextDelay added in v1.20.5 

func (c *ConstantRatePattern) NextDelay() time.Duration

func (*ConstantRatePattern) Reset added in v1.20.5 

func (c *ConstantRatePattern) Reset()

func (*ConstantRatePattern) ShouldSend added in v1.20.5 

func (c *ConstantRatePattern) ShouldSend() bool

type ContractCreationTest added in v1.11.14 

type ContractCreationTest struct {
	Contract *contracts.EVMLoadSimulator
}

func (ContractCreationTest) Run added in v1.11.14 

func (c ContractCreationTest) Run(tc tests.TestContext, wallet *Wallet)

type ExternalCallTest added in v1.11.14 

type ExternalCallTest struct {
	Contract *contracts.EVMLoadSimulator
}

func (ExternalCallTest) Run added in v1.11.14 

func (e ExternalCallTest) Run(tc tests.TestContext, wallet *Wallet)

type HashingTest added in v1.11.14 

type HashingTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (HashingTest) Run added in v1.11.14 

func (h HashingTest) Run(tc tests.TestContext, wallet *Wallet)

type Issuer 

type Issuer[T TxID] interface {
	// GenerateAndIssueTx generates and sends a tx to the network, and informs the
	// tracker that it sent said transaction. It returns the sent transaction.
	GenerateAndIssueTx(ctx context.Context) (T, error)
}

type LargeEventTest added in v1.11.14 

type LargeEventTest struct {
	Contract  *contracts.EVMLoadSimulator
	NumEvents *big.Int
}

func (LargeEventTest) Run added in v1.11.14 

func (l LargeEventTest) Run(tc tests.TestContext, wallet *Wallet)

type LatencyPercentiles added in v1.20.5 

type LatencyPercentiles struct {
	P50    float64 `json:"p50"`
	P75    float64 `json:"p75"`
	P90    float64 `json:"p90"`
	P95    float64 `json:"p95"`
	P99    float64 `json:"p99"`
	P999   float64 `json:"p999"`
	Min    float64 `json:"min"`
	Max    float64 `json:"max"`
	Mean   float64 `json:"mean"`
	StdDev float64 `json:"stddev"`
	Count  int     `json:"count"`
}

LatencyPercentiles holds various percentile measurements

type LatencyTracker added in v1.20.5 

type LatencyTracker struct {
	// contains filtered or unexported fields
}

LatencyTracker tracks latency samples for percentile calculation

func NewLatencyTracker added in v1.20.5 

func NewLatencyTracker() *LatencyTracker

func (*LatencyTracker) Clear added in v1.20.5 

func (lt *LatencyTracker) Clear()

func (*LatencyTracker) GetPercentiles added in v1.20.5 

func (lt *LatencyTracker) GetPercentiles() LatencyPercentiles

func (*LatencyTracker) Record added in v1.20.5 

func (lt *LatencyTracker) Record(latencyMS float64)

type Listener 

type Listener[T TxID] interface {
	// Listen for the final status of transactions and notify the tracker
	// Listen stops if the context is done, an error occurs, or if it received
	// all the transactions issued and the issuer no longer issues any.
	// Listen MUST return a nil error if the context is canceled.
	Listen(ctx context.Context) error

	// RegisterIssued informs the listener that a transaction was issued.
	RegisterIssued(txID T)

	// IssuingDone informs the listener that no more transactions will be issued.
	IssuingDone()
}

type LoadConfig added in v1.20.5 

type LoadConfig struct {
	Pattern      LoadPattern
	MaxTPS       float64
	Duration     time.Duration
	WarmupPeriod time.Duration
}

LoadConfig defines configuration for load generation

type LoadGenerator added in v1.11.14 

type LoadGenerator struct {
	// contains filtered or unexported fields
}

func NewLoadGenerator added in v1.11.14 

func NewLoadGenerator(
	workers []Worker,
	chainID *big.Int,
	metricsNamespace string,
	registry metric.Registry,
	test Test,
) (LoadGenerator, error)

func (LoadGenerator) Run added in v1.11.14 

func (l LoadGenerator) Run(
	ctx context.Context,
	log log.Logger,
	loadTimeout time.Duration,
	testTimeout time.Duration,
)

type LoadPattern added in v1.20.5 

type LoadPattern interface {
	// NextDelay returns the delay before the next transaction
	NextDelay() time.Duration
	// ShouldSend determines if a transaction should be sent now
	ShouldSend() bool
	// Reset resets the pattern state
	Reset()
}

LoadPattern defines different load generation patterns

type LoadReport added in v1.20.5 

type LoadReport struct {
	StartTime          time.Time
	EndTime            time.Time
	Duration           time.Duration
	TotalTransactions  uint64
	SuccessfulTx       uint64
	FailedTx           uint64
	AverageTPS         float64
	PeakTPS            float64
	SuccessRate        float64
	LatencyPercentiles LatencyPercentiles
	ErrorDistribution  map[string]uint64
}

LoadReport contains load test results

func (LoadReport) String added in v1.20.5 

func (r LoadReport) String() string

type MemoryTest added in v1.11.14 

type MemoryTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (MemoryTest) Run added in v1.11.14 

func (m MemoryTest) Run(tc tests.TestContext, wallet *Wallet)

type Metrics 

type Metrics struct {
	// contains filtered or unexported fields
}

func NewMetrics 

func NewMetrics(registry metric.Registry) (*Metrics, error)

func (*Metrics) GetLatencyPercentiles added in v1.20.5 

func (m *Metrics) GetLatencyPercentiles() LatencyPercentiles

func (*Metrics) IncIssuedTx 

func (m *Metrics) IncIssuedTx()

func (*Metrics) RecordConfirmedTx 

func (m *Metrics) RecordConfirmedTx(latencyMS float64)

func (*Metrics) RecordFailedTx 

func (m *Metrics) RecordFailedTx(latencyMS float64)

func (*Metrics) UpdateSuccessRate added in v1.20.5 

func (m *Metrics) UpdateSuccessRate(rate float64)

func (*Metrics) UpdateTPS added in v1.20.5 

func (m *Metrics) UpdateTPS(tps float64)

type Orchestrator 

type Orchestrator[T TxID] struct {
	// contains filtered or unexported fields
}

Orchestrator tests the network by continuously sending transactions at a given rate (currTargetTPS) and increasing that rate until it detects that the network can no longer make progress (i.e. the rate at the network accepts transactions is less than currTargetTPS).

func NewOrchestrator 

func NewOrchestrator[T TxID](
	agents []Agent[T],
	tracker *Tracker[T],
	log log.Logger,
	config OrchestratorConfig,
) *Orchestrator[T]

func (*Orchestrator[_]) Execute 

func (o *Orchestrator[_]) Execute(ctx context.Context) error

func (*Orchestrator[_]) GetMaxObservedTPS 

func (o *Orchestrator[_]) GetMaxObservedTPS() int64

GetMaxObservedTPS returns the max TPS the orchestrator observed

type OrchestratorConfig 

type OrchestratorConfig struct {
	// The maximum TPS the orchestrator should aim for.
	//
	// If set to -1, the orchestrator will behave in a burst fashion, instead
	// sending MinTPS transactions at once and waiting sustainedTime seconds
	// before checking if MinTPS transactions were confirmed as accepted.
	MaxTPS int64
	// The minimum TPS the orchestrator should start with.
	MinTPS int64
	// The step size to increase the TPS by.
	Step int64

	// The factor by which to pad the number of txs an issuer sends per second
	// for example, if targetTPS = 1000 and numIssuers = 10, then each issuer
	// will send (1000/10)*TxRateMultiplier transactions per second.
	//
	// Maintaining a multiplier above target provides a toggle to keep load
	// persistently above instead of below target. This ensures load generation
	// does not pause issuance at the target and persistently under-issue and
	// fail to account for the time it takes to add more load.
	TxRateMultiplier float64

	// The time period which TPS is averaged over
	// Similarly, the time period which the orchestrator will wait before
	// computing the average TPS.
	SustainedTime time.Duration
	// The number of attempts to try achieving a given target TPS before giving up.
	MaxAttempts uint64

	// Whether the orchestrator should return if the maxTPS has been reached
	Terminate bool
}

func NewOrchestratorConfig 

func NewOrchestratorConfig() OrchestratorConfig

NewOrchestratorConfig returns a default OrchestratorConfig with pre-set parameters for gradual load testing.

type PureComputeTest added in v1.11.14 

type PureComputeTest struct {
	Contract      *contracts.EVMLoadSimulator
	NumIterations *big.Int
}

func (PureComputeTest) Run added in v1.11.14 

func (p PureComputeTest) Run(tc tests.TestContext, wallet *Wallet)

type RampPattern added in v1.20.5 

type RampPattern struct {
	// contains filtered or unexported fields
}

RampPattern gradually increases load

func NewRampPattern added in v1.20.5 

func NewRampPattern(startTPS, endTPS float64, duration time.Duration) *RampPattern

func (*RampPattern) NextDelay added in v1.20.5 

func (r *RampPattern) NextDelay() time.Duration

func (*RampPattern) Reset added in v1.20.5 

func (r *RampPattern) Reset()

func (*RampPattern) ShouldSend added in v1.20.5 

func (r *RampPattern) ShouldSend() bool

type RandomWeightedTest added in v1.11.14 

type RandomWeightedTest struct {
	// contains filtered or unexported fields
}

func NewRandomTest added in v1.11.14 

func NewRandomTest(
	ctx context.Context,
	chainID *big.Int,
	worker *Worker,
	source rand.Source,
) (*RandomWeightedTest, error)

NewRandomTest creates a RandomWeightedTest containing a collection of EVM load testing scenarios.

This function handles the setup of the tests and also assigns each test an equal weight, making them equally likely to be selected during random test execution.

func NewRandomWeightedTest added in v1.11.14 

func NewRandomWeightedTest(
	weightedTests []WeightedTest,
	source rand.Source,
) (*RandomWeightedTest, error)

func (*RandomWeightedTest) Run added in v1.11.14 

func (r *RandomWeightedTest) Run(tc tests.TestContext, wallet *Wallet)

type ReadTest added in v1.11.14 

type ReadTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (ReadTest) Run added in v1.11.14 

func (r ReadTest) Run(tc tests.TestContext, wallet *Wallet)

type StateModificationTest added in v1.11.14 

type StateModificationTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (StateModificationTest) Run added in v1.11.14 

func (s StateModificationTest) Run(tc tests.TestContext, wallet *Wallet)

type StepPattern added in v1.20.5 

type StepPattern struct {
	// contains filtered or unexported fields
}

StepPattern generates stepped load increases

func NewStepPattern added in v1.20.5 

func NewStepPattern(steps []float64, stepDuration time.Duration) *StepPattern

func (*StepPattern) NextDelay added in v1.20.5 

func (s *StepPattern) NextDelay() time.Duration

func (*StepPattern) Reset added in v1.20.5 

func (s *StepPattern) Reset()

func (*StepPattern) ShouldSend added in v1.20.5 

func (s *StepPattern) ShouldSend() bool

type TPSController added in v1.20.5 

type TPSController struct {
	// contains filtered or unexported fields
}

TPSController manages TPS targeting with feedback control

func NewTPSController added in v1.20.5 

func NewTPSController(targetTPS float64) *TPSController

func (*TPSController) GetDelay added in v1.20.5 

func (c *TPSController) GetDelay() time.Duration

func (*TPSController) GetStats added in v1.20.5 

func (c *TPSController) GetStats() (targetTPS, actualTPS, adjustment float64)

func (*TPSController) SetTargetTPS added in v1.20.5 

func (c *TPSController) SetTargetTPS(tps float64)

func (*TPSController) UpdateActualTPS added in v1.20.5 

func (c *TPSController) UpdateActualTPS(count uint64)

type Test added in v1.11.14 

type Test interface {
	Run(tc tests.TestContext, wallet *Wallet)
}

type Tracker 

type Tracker[T TxID] struct {
	// contains filtered or unexported fields
}

Tracker keeps track of the status of transactions. This is thread-safe and can be called in parallel by the issuer(s) or orchestrator.

func NewTracker 

func NewTracker[T TxID](metrics *Metrics) *Tracker[T]

NewTracker returns a new Tracker instance which records metrics for the number of transactions issued, confirmed, and failed. It also tracks the latency of transactions.

func (*Tracker[_]) GetObservedConfirmed 

func (t *Tracker[_]) GetObservedConfirmed() uint64

GetObservedConfirmed returns the number of transactions that the tracker has confirmed were accepted.

func (*Tracker[_]) GetObservedFailed 

func (t *Tracker[_]) GetObservedFailed() uint64

GetObservedFailed returns the number of transactions that the tracker has confirmed failed.

func (*Tracker[_]) GetObservedIssued 

func (t *Tracker[_]) GetObservedIssued() uint64

GetObservedIssued returns the number of transactions that the tracker has confirmed were issued.

func (*Tracker[T]) Issue 

func (t *Tracker[T]) Issue(txID T)

Issue records a transaction that was submitted, but whose final status is not yet known.

func (*Tracker[T]) ObserveConfirmed 

func (t *Tracker[T]) ObserveConfirmed(txID T)

ObserveConfirmed records a transaction that was confirmed.

func (*Tracker[T]) ObserveFailed 

func (t *Tracker[T]) ObserveFailed(txID T)

ObserveFailed records a transaction that failed (e.g. expired)

type TransferTest added in v1.11.14 

type TransferTest struct {
	Value *big.Int
}

func (TransferTest) Run added in v1.11.14 

func (t TransferTest) Run(tc tests.TestContext, wallet *Wallet)

type TrieStressTest added in v1.11.14 

type TrieStressTest struct {
	Contract  *contracts.TrieStressTest
	NumValues *big.Int
}

func (TrieStressTest) Run added in v1.11.14 

func (t TrieStressTest) Run(tc tests.TestContext, wallet *Wallet)

type TxID 

type TxID interface {
	~[32]byte
}

type Wallet added in v1.11.14 

type Wallet struct {
	// contains filtered or unexported fields
}

func (*Wallet) SendTx added in v1.11.14 

func (w *Wallet) SendTx(
	ctx context.Context,
	tx *types.Transaction,
) error

type WavePattern added in v1.20.5 

type WavePattern struct {
	// contains filtered or unexported fields
}

WavePattern generates sinusoidal load pattern

func NewWavePattern added in v1.20.5 

func NewWavePattern(minTPS, maxTPS float64, period time.Duration) *WavePattern

func (*WavePattern) NextDelay added in v1.20.5 

func (w *WavePattern) NextDelay() time.Duration

func (*WavePattern) Reset added in v1.20.5 

func (w *WavePattern) Reset()

func (*WavePattern) ShouldSend added in v1.20.5 

func (w *WavePattern) ShouldSend() bool

type WeightedTest added in v1.11.14 

type WeightedTest struct {
	Test   Test
	Weight uint64
}

type Worker added in v1.11.14 

type Worker struct {
	PrivKey *ecdsa.PrivateKey
	Nonce   uint64
	Client  *ethclient.Client
}

type WriteTest added in v1.11.14 

type WriteTest struct {
	Contract *contracts.EVMLoadSimulator
	Count    *big.Int
}

func (WriteTest) Run added in v1.11.14 

func (w WriteTest) Run(tc tests.TestContext, wallet *Wallet)

Source Files

View all Source files

Directories

Path Synopsis
c
contracts
listener
main command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.