feat(load2): add contract tests

[RodrigoVillar]

Why this should be merged

This PR migrates over the existing contract tests from the original load framework into load 2.0. This PR also replaces the type of test used in load 2.0 testing (ZeroTransferTest => RandomTest).

How this works

Migration with the following caveats:

• Rather than simple transfers having a high probability of being selected, each test has an equal probability of being chosen.
• Previously, each individual test utilized a random parameter. Now, the parameters of an individual test are now the responsibility of the caller (i.e. parameter can be hard-coded or random).

How this was tested

CI

Need to be documented in RELEASES.md?

N/A

[RodrigoVillar]

Commenting for context.

[Copilot]

Pull Request Overview

This PR migrates contract tests from the original load framework to load 2.0, replacing the simple ZeroTransferTest with a comprehensive RandomTest that can execute multiple test types with configurable weights.

• Introduces a new RandomTest struct that uses weighted sampling to select from multiple test types
• Adds 10 new contract test implementations (ReadTest, WriteTest, StateModificationTest, etc.)
• Updates the main load generator to deploy a contract and use the new random test selection

Reviewed Changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 4 comments.

File	Description
tests/load2/tests.go	Adds RandomTest implementation and 10 contract test types with shared utility functions
tests/load2/main/main.go	Updates main function to deploy contract and configure RandomTest with equal weights

[Elvis339]

How does this reflect load testing reproducibility, should we consider using a seeded random source?

[Elvis339]

Should we have a config structure for example

type LoadTestConfig struct {
    MaxFeeCap     *big.Int
    DefaultTimeout time.Duration
    GasTipMultiplier int64
}

[Elvis339]

Noticed we're repeating the same setup in pretty much every test:

Contract *contracts.EVMLoadSimulator  // in every struct

// and this exact block everywhere:
txOpts, err := newTxOpts(wallet.privKey, wallet.chainID, maxFeeCap, wallet.nonce)
require.NoError(err)

Could probably clean this up with a base struct or something. Here's one way that might work:

type BaseContractTest struct {
    Contract *contracts.EVMLoadSimulator
}

func (b *BaseContractTest) executeContractTx(
    tc tests.TestContext,
    ctx context.Context, 
    wallet *Wallet,
    txFunc func(*bind.TransactOpts) (*types.Transaction, error),
) {
    require := require.New(tc)
    
    txOpts, err := newTxOpts(wallet.privKey, wallet.chainID, maxFeeCap, wallet.nonce)
    require.NoError(err)
    
    tx, err := txFunc(txOpts)
    require.NoError(err)
    
    require.NoError(wallet.SendTx(ctx, tx, time.Millisecond))
}

// Then tests become much simpler:
type ReadTest struct {
    BaseContractTest
    Count *big.Int
}

func (r ReadTest) Run(tc tests.TestContext, ctx context.Context, wallet *Wallet) {
    r.executeContractTx(tc, ctx, wallet, func(txOpts *bind.TransactOpts) (*types.Transaction, error) {
        return r.Contract.SimulateReads(txOpts, r.Count)
    })
}

Would cut down the boilerplate quite a bit. Though there's probably other ways to approach this too this is just what came to mind first. What do you think?