feat(tests): add EXTCODEHASH tests and inverted opcode order variants

Add comprehensive BloatNet multi-opcode benchmark tests:
- test_bloatnet_balance_extcodehash: BALANCE → EXTCODEHASH
- test_bloatnet_extcodesize_balance: EXTCODESIZE → BALANCE (inverted)
- test_bloatnet_extcodecopy_balance: EXTCODECOPY → BALANCE (inverted)
- test_bloatnet_extcodehash_balance: EXTCODEHASH → BALANCE (inverted)

All tests follow the same pattern:
- Dynamic CREATE2 address generation
- Precise gas cost calculations
- One cold access followed by one warm access
- Factory stub pattern for pre-deployed contracts

Author: CPerezz

CLAUDE.md

@@ -196,3 +196,203 @@ jq -r '.opName' debug_output/**/*.jsonl
 5. Commit with semantic format
 
 **Critical**: Always run linting and type checking. Use `--clean` when filling. Never use hardcoded addresses.
+
+## 🎯 BloatNet Multi-Opcode Benchmarks
+
+### Overview
+
+BloatNet benchmarks stress-test Ethereum clients by rapidly accessing many large (24KB) contracts to measure state-handling performance. The multi-opcode variants test specific EVM opcodes (BALANCE, EXTCODESIZE, EXTCODECOPY) against pre-deployed contracts.
+
+### Architecture
+
+```text
+┌─────────────────────┐      ┌──────────────────┐      ┌──────────────────┐
+│  Initcode Contract  │      │ Factory Contract │      │  24KB Contracts  │
+│      (~9.5KB)       │      │     (116B)       │      │  (N × 24KB each) │
+└──────────┬──────────┘      └────────┬─────────┘      └──────────────────┘
+           │                          │                          │
+           │  EXTCODECOPY             │   CREATE2(salt++)       │
+           └─────────────────────────►├─────────────────────► Contract_0
+                                      ├─────────────────────► Contract_1
+                                      ├─────────────────────► Contract_2
+                                      └─────────────────────► Contract_N
+
+┌──────────────────┐
+│ Attack Contract  │──STATICCALL──► Factory.getConfig()
+│                  │                  returns: (N, hash)
+└────────┬─────────┘
+         │
+         └─► Loop(i=0 to N):
+               1. Generate CREATE2 addr: keccak256(0xFF|factory|i|hash)[12:]
+               2. BALANCE(addr)      → 2600 gas (cold access)
+               3. EXTCODESIZE(addr)  → 100 gas (warm access)
+```
+
+### Key Components
+
+#### 1. Initcode Contract (`deploy_initcode.py`)
+
+- **Purpose**: Stores the template initcode that generates unique 24KB contracts
+- **Size**: ~9.5KB (uses `While` loop expansion)
+- **Uniqueness**: Uses `ADDRESS` opcode as seed, making each deployed contract unique
+- **Algorithm**:
+  - Store `ADDRESS` as initial seed (different per CREATE2 deployment)
+  - Loop: Expand to 24KB using SHA3 + XOR operations with 256-entry XOR table
+  - Set first byte to `0x00` (STOP) for efficient CALL handling
+  - Return 24KB bytecode
+
+#### 2. Factory Contract (`deploy_create2_factory.py`)
+
+- **Purpose**: Deploys contracts via CREATE2 and provides config info to tests
+- **Storage Layout**:
+  - Slot 0: Counter (number of deployed contracts)
+  - Slot 1: Init code hash (for CREATE2 address calculation)
+  - Slot 2: Initcode contract address
+- **Interface**:
+  - `CALLDATASIZE == 0`: Returns `(num_deployed_contracts, init_code_hash)` (64 bytes)
+  - `CALLDATASIZE > 0`: Deploys new contract via CREATE2 with counter as salt
+- **Deployment Flow**:
+  1. Load initcode from stored address via EXTCODECOPY
+  2. CREATE2 with current counter as salt
+  3. Increment counter
+  4. Return deployed address
+
+#### 3. Attack Contract (in test files)
+
+- **Purpose**: Rapidly accesses all deployed contracts to stress state handling
+- **Flow**:
+  1. STATICCALL factory.getConfig() to get N and hash
+  2. Setup memory for CREATE2 address generation: `0xFF + factory_addr + salt + hash`
+  3. Loop N times:
+     - Generate CREATE2 address: `keccak256(memory[11:96])`
+     - Execute opcode tests (BALANCE, EXTCODESIZE, EXTCODECOPY)
+     - Increment salt
+- **Gas Calculation**: Each test calculates exact gas cost per contract iteration
+
+### Test Implementation Pattern
+
+Tests in [test_multi_opcode.py](tests/benchmark/bloatnet/test_multi_opcode.py):
+
+```python
+@pytest.mark.valid_from("Prague")
+def test_bloatnet_balance_extcodesize(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    fork: Fork,
+    gas_benchmark_value: int,
+):
+    # 1. Calculate cost per contract access
+    cost_per_contract = (
+        gas_costs.G_KECCAK_256 + gas_costs.G_KECCAK_256_WORD * 3  # Address gen
+        + gas_costs.G_COLD_ACCOUNT_ACCESS  # BALANCE (cold)
+        + gas_costs.G_WARM_ACCOUNT_ACCESS  # EXTCODESIZE (warm)
+        + /* stack operations */
+    )
+
+    # 2. Deploy factory as stub (must be pre-deployed externally)
+    factory_address = pre.deploy_contract(
+        code=Bytecode(),
+        stub="bloatnet_factory",
+    )
+
+    # 3. Build attack contract that:
+    #    - Calls factory.getConfig() to get N and hash
+    #    - Loops N times, generating CREATE2 addresses and accessing contracts
+    attack_code = (
+        Op.STATICCALL(factory_address, ret_offset=96, ret_size=64)
+        + /* setup CREATE2 address generation */
+        + While(
+            body=(
+                Op.SHA3(11, 85)  # Generate CREATE2 address
+                + Op.DUP1
+                + Op.POP(Op.BALANCE)  # Cold access
+                + Op.POP(Op.EXTCODESIZE)  # Warm access
+                + /* increment salt */
+            ),
+            condition=/* counter > 0 */
+        )
+    )
+```
+
+### Deployment Workflow
+
+1. **Deploy Initcode** (`deploy_initcode.py`):
+   ```bash
+   python3 deploy_initcode.py
+   # Outputs: initcode_address.json with address and hash
+   ```
+
+2. **Deploy Factory** (`deploy_create2_factory.py`):
+   ```bash
+   python3 deploy_create2_factory.py
+   # Outputs: stubs.json with factory address
+   ```
+
+3. **Deploy Contracts** (`deploy_bloatnet_contracts.py`):
+   ```bash
+   python3 deploy_bloatnet_contracts.py 1000 --stubs stubs.json
+   # Deploys 1000 contracts via factory (each uses ~8.6M gas)
+   ```
+
+4. **Run Tests**:
+   ```bash
+   uv run execute remote \
+     --rpc-endpoint http://127.0.0.1:8545 \
+     --address-stubs stubs.json \
+     -- --fork Prague --gas-benchmark-values 5 \
+     tests/benchmark/bloatnet/test_multi_opcode.py
+   ```
+
+### Critical Design Decisions
+
+1. **Stub Contracts**: Tests use `stub="bloatnet_factory"` to reference pre-deployed factory
+   - Avoids hardcoded addresses
+   - Factory address provided via `--address-stubs` flag
+   - Tests read config dynamically via `getConfig()`
+
+2. **Dynamic Address Generation**: Attack contracts generate CREATE2 addresses on-the-fly
+   - Uses same formula: `keccak256(0xFF | factory | salt | hash)[12:]`
+   - No pre-computation or storage of addresses needed
+   - Minimal memory footprint
+
+3. **Gas Precision**: Each test calculates exact gas cost per iteration
+   - Uses `fork.gas_costs()` for accurate opcode costs
+   - Includes SHA3 word costs, stack operations, loop overhead
+   - Ensures tests consume exactly the target gas amount
+
+4. **Unique Contracts**: Each deployed contract has unique bytecode
+   - Uses `ADDRESS` opcode in initcode (different per CREATE2 deployment)
+   - Forces clients to store distinct contract code
+   - Prevents deduplication optimizations
+
+### Available Tests
+
+- `test_bloatnet_balance_extcodesize`: BALANCE (cold) + EXTCODESIZE (warm)
+- `test_bloatnet_balance_extcodecopy`: BALANCE (cold) + EXTCODECOPY (warm, reads last byte)
+
+### Common Patterns
+
+**Reading factory config in attack contract**:
+```python
+Op.STATICCALL(
+    gas=Op.GAS,
+    address=factory_address,
+    args_offset=0,
+    args_size=0,
+    ret_offset=96,
+    ret_size=64,  # Returns 2 × 32 bytes
+)
++ Op.MLOAD(96)   # num_deployed_contracts
++ Op.MLOAD(128)  # init_code_hash
+```
+
+**CREATE2 address generation in memory**:
+```python
+# Memory layout: 0xFF(1) + factory(20) + salt(32) + hash(32) = 85 bytes
+Op.MSTORE(0, factory_address)
++ Op.MSTORE8(11, 0xFF)  # Prefix at position 32-20-1
++ Op.MSTORE(32, 0)      # Salt
++ Op.MSTORE(64, hash)   # Init code hash
+# Generate address:
+Op.SHA3(11, 85)  # Hash from byte 11 for 85 bytes
+```