feat(bloatnet): Add first multi-opcode benchmarks for Bloatnet

docs/CHANGELOG.md

@@ -131,6 +131,7 @@ Users can select any of the artifacts depending on their testing needs for their
 
 ### 🧪 Test Cases
 
+- ✨ [BloatNet](bloatnet.info)/Multidimensional Metering: Add benchmarks to be used as part of the BloatNet project and also for Multidimensional Metering.
 - ✨ [EIP-7951](https://eips.ethereum.org/EIPS/eip-7951): Add additional test cases for modular comparison.
 - 🔀 Refactored `BLOBHASH` opcode context tests to use the `pre_alloc` plugin in order to avoid contract and EOA address collisions ([#1637](https://github.com/ethereum/execution-spec-tests/pull/1637)).
 - 🔀 Refactored `SELFDESTRUCT` opcode collision tests to use the `pre_alloc` plugin in order to avoid contract and EOA address collisions ([#1643](https://github.com/ethereum/execution-spec-tests/pull/1643)).

pyproject.toml

@@ -146,6 +146,7 @@ exclude = [
     '^fixtures/',
     '^logs/',
     '^site/',
+    '^tests/benchmark/bloatnet/deploy_.*\.py$',
 ]
 plugins = ["pydantic.mypy"]
 

scripts/test_create2.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Test CREATE2 factory deployment."""
+
+from web3 import Web3
+from eth_utils import keccak
+
+# Connect to Geth
+w3 = Web3(Web3.HTTPProvider("http://127.0.0.1:8545"))
+if not w3.is_connected():
+    print("Failed to connect to Geth")
+    exit(1)
+
+test_account = w3.eth.accounts[0]
+print(f"Using test account: {test_account}")
+print(f"Balance: {w3.eth.get_balance(test_account) / 10**18:.4f} ETH")
+
+# Simple CREATE2 factory that returns the deployed address
+factory_bytecode = (
+    # Constructor: return runtime code
+    "60" + "1f"  # PUSH1 0x1F (runtime size = 31)
+    "80"  # DUP1
+    "60" + "0a"  # PUSH1 0x0A (runtime offset)
+    "60" + "00"  # PUSH1 0x00 (memory dest)
+    "39"  # CODECOPY
+    "60" + "00"  # PUSH1 0x00 (return offset)
+    "f3"  # RETURN
+
+    # Runtime: minimal CREATE2
+    "36"  # CALLDATASIZE
+    "60" + "00"  # PUSH1 0x00
+    "60" + "00"  # PUSH1 0x00
+    "37"  # CALLDATACOPY (copy all calldata to memory)
+
+    "60" + "00"  # PUSH1 0x00 (salt - using 0 for simplicity)
+    "36"  # CALLDATASIZE (size of init code)
+    "60" + "00"  # PUSH1 0x00 (offset in memory)
+    "60" + "00"  # PUSH1 0x00 (value)
+    "f5"  # CREATE2
+
+    "60" + "00"  # PUSH1 0x00
+    "52"  # MSTORE (store address at 0)
+    "60" + "20"  # PUSH1 0x20
+    "60" + "00"  # PUSH1 0x00
+    "f3"  # RETURN (return address)
+)
+
+# Deploy factory
+factory_tx = w3.eth.send_transaction({
+    'from': test_account,
+    'data': '0x' + factory_bytecode,
+    'gas': 3000000
+})
+
+factory_receipt = w3.eth.wait_for_transaction_receipt(factory_tx)
+if factory_receipt.status != 1:
+    print("Failed to deploy factory")
+    exit(1)
+
+factory_address = factory_receipt.contractAddress
+print(f"\nFactory deployed at: {factory_address}")
+
+# Create simple contract bytecode (just returns 42)
+simple_bytecode = "602a60005260206000f3"  # PUSH1 42, PUSH1 0, MSTORE, PUSH1 32, PUSH1 0, RETURN
+
+# Deploy using factory
+print("\nDeploying contract via CREATE2...")
+deploy_tx = w3.eth.send_transaction({
+    'from': test_account,
+    'to': factory_address,
+    'data': '0x' + simple_bytecode,
+    'gas': 1000000
+})
+
+deploy_receipt = w3.eth.wait_for_transaction_receipt(deploy_tx)
+print(f"Transaction status: {deploy_receipt.status}")
+
+# Get return value (the deployed address)
+result = w3.eth.call({
+    'to': factory_address,
+    'data': '0x' + simple_bytecode
+})
+
+if result:
+    deployed_addr = '0x' + result[-20:].hex()
+    print(f"Contract deployed at: {deployed_addr}")
+
+    # Verify by checking code
+    code = w3.eth.get_code(deployed_addr)
+    print(f"Deployed code length: {len(code)} bytes")
+else:
+    print("No return value from factory")

tests/benchmark/bloatnet/README.md

@@ -0,0 +1,133 @@
+# BloatNet Benchmark Tests setup guide
+
+## Overview
+
+The Bloatnet benchmarks work on the following fashion:
+1. They usually require a previously-deployed state (usually quite large) which the benchmarks
+will interact with.
+2. The deployment script helpers help deploying the required bytecode for the specific tests.
+3. The outputs of the deployment scripts get hardcoded into the codebase such that the benchmarks can interact with them.
+
+## Gas Cost Constants
+
+### BALANCE + EXTCODESIZE Pattern
+**Gas per contract: 2,707**
+- `PUSH20` (address): 3 gas
+- `BALANCE` (cold access): 2,600 gas
+- `POP`: 2 gas
+- `EXTCODESIZE` (warm): 100 gas
+- `POP`: 2 gas
+
+### BALANCE + EXTCODECOPY Pattern
+**Gas per contract: ~5,007**
+- `PUSH20` (address): 3 gas
+- `BALANCE` (cold access): 2,600 gas
+- `POP`: 2 gas
+- `EXTCODECOPY` setup: ~100 gas
+- `EXTCODECOPY` (24KB): ~2,300 gas
+- `POP`: 2 gas
+
+## Required Contracts Calculation Example:
+
+### For BALANCE + EXTCODESIZE:
+| Gas Limit | Contracts Needed | Calculation         |
+| --------- | ---------------- | ------------------- |
+| 5M        | 1,838            | 5,000,000 ÷ 2,707   |
+| 50M       | 18,380           | 50,000,000 ÷ 2,707  |
+| 150M      | 55,403           | 150,000,000 ÷ 2,707 |
+
+### For BALANCE + EXTCODECOPY:
+| Gas Limit | Contracts Needed | Calculation         |
+| --------- | ---------------- | ------------------- |
+| 5M        | 998              | 5,000,000 ÷ 5,007   |
+| 50M       | 9,986            | 50,000,000 ÷ 5,007  |
+| 150M      | 29,958           | 150,000,000 ÷ 5,007 |
+
+You can see the associated attack constants inside of the tests in `bloatnet/test_bloatnet.py`
+
+## Quick Start: 150M Gas Attack
+
+### 1. Deploy CREATE2 Factory (you can use an already deployed one if preferred and therefore, skip this step)
+
+```bash
+# One-time setup - deploy the CREATE2 factory
+python3 tests/benchmark/bloatnet/deploy_create2_factory.py
+
+# Output will show:
+# Factory deployed at: 0x...  <-- Save this address
+```
+
+### 2. Deploy Contracts
+
+The deployment script is interactive and will guide you through selecting the appropriate contract type for your benchmark.
+
+#### Contract Types Available
+
+1. **max_size_24kb**: 24KB contracts filled with unique bytecode (EXTCODE_ type of tests)
+2. **sload_heavy**: Contracts optimized for SLOAD benchmarking
+3. **storage_heavy**: Contracts with pre-initialized storage
+4. **custom**: Custom bytecode (for future extensions)
+
+#### Calculate Contracts Needed
+
+Before running the deployment, calculate the number of contracts needed:
+- For 150M gas BALANCE+EXTCODESIZE: 55,403 contracts
+- For 150M gas BALANCE+EXTCODECOPY: 29,958 contracts
+
+_Deploy enough contracts to cover the max gas you plan to use in your tests/benchmarks._
+
+#### Running the Deployment
+
+```bash
+# Run the interactive deployment script
+python3 tests/benchmark/bloatnet/deploy_bloatnet_simple.py \
+    --num-contracts 55403 \
+    --factory-address 0x... # Use factory address from step 1
+```
+
+#### Deployment Output
+
+After successful deployment, the script will:
+
+1. Display the configuration needed for tests:
+```python
+=== Configuration for max_size_24kb tests ===
+CONTRACT_TYPE = "max_size_24kb"
+FACTORY_ADDRESS = Address("0x...")
+INIT_CODE_HASH = bytes.fromhex("...")
+NUM_DEPLOYED_CONTRACTS = 55403
+```
+
+2. Save the configuration to a file:
+```
+Configuration saved to: bloatnet_config_max_size_24kb.txt
+```
+
+This file contains all the values needed to update your test configuration.
+
+### 3. Update Test Configuration
+
+Edit `tests/benchmark/bloatnet/test_bloatnet.py` and update:
+
+```python
+FACTORY_ADDRESS = Address("0x...")  # From deployment output
+INIT_CODE_HASH = bytes.fromhex("...")  # From deployment output
+NUM_DEPLOYED_CONTRACTS = 55403  # Actual deployed count
+```
+
+### 5. Run Benchmark Tests
+
+```bash
+# Run with specific gas values (in millions)
+uv run fill --fork=Prague --gas-benchmark-values=150 \
+    tests/benchmark/bloatnet/test_bloatnet.py --clean
+
+# With EVM traces for analysis
+uv run fill --fork=Prague --gas-benchmark-values=150 \
+    --evm-dump-dir=traces/ --traces \
+    tests/benchmark/bloatnet/test_bloatnet.py
+
+# Multiple gas values
+uv run fill --fork=Prague --gas-benchmark-values=5,50,150 \
+    tests/benchmark/bloatnet/test_bloatnet.py
+```