diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..ace0e5a Binary files /dev/null and b/.DS_Store differ diff --git a/fix_trie_brancher.sh b/fix_trie_brancher.sh new file mode 100755 index 0000000..e8fde56 --- /dev/null +++ b/fix_trie_brancher.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +# Fix the compilation issues in storage_trie_brancher + +# Fix wallet selection constant +find scenarios/statebloat/storage_trie_brancher -name "*.go" -exec perl -pi -e 's/WalletSelectionByIndex/SelectWalletByIndex/g' {} \; + +# Fix GetChainID to GetChainId +find scenarios/statebloat/storage_trie_brancher -name "*.go" -exec perl -pi -e 's/GetChainID\(\)/GetChainId()/g' {} \; + +# Remove unused json import +perl -pi -e 's/"encoding\/json"\n//g' scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go + +# Fix GetRPCClient +perl -pi -e 's/s\.walletPool\.GetRPCClient\(\)/s.walletPool.GetRPCHost()/g' scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go + +echo "Fixes applied" \ No newline at end of file diff --git a/quick_fix.sh b/quick_fix.sh new file mode 100755 index 0000000..e0af8b2 --- /dev/null +++ b/quick_fix.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +# Fix remaining compilation errors + +# Fix GetChainId() - it already returns *big.Int, no need to wrap +perl -pi -e 's/big\.NewInt\(wallet\.GetChainId\(\)\)/wallet.GetChainId()/g' scenarios/statebloat/storage_trie_brancher/*.go + +# Fix string multiplication +perl -pi -e 's/"=" \* 60/strings.Repeat("=", 60)/g' scenarios/statebloat/storage_trie_brancher/verify_depth.go + +# Remove unused os import +perl -pi -e 's/^\s*"os"\n//g' scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go + +# Fix GetRPCHost to GetRPCEndpoint +perl -pi -e 's/GetRPCHost\(\)/GetRPCEndpoint()/g' scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go + +# Add strings import to verify_depth.go +perl -pi -e 's/^import \(/import (\n\t"strings"/g if /^import \(/' scenarios/statebloat/storage_trie_brancher/verify_depth.go + +echo "Fixes applied" \ No newline at end of file diff --git a/scenarios/scenarios.go b/scenarios/scenarios.go index d46c974..e0302ec 100644 --- a/scenarios/scenarios.go +++ b/scenarios/scenarios.go @@ -19,6 +19,8 @@ import ( "github.com/ethpandaops/spamoor/scenarios/geastx" "github.com/ethpandaops/spamoor/scenarios/setcodetx" erc20bloater "github.com/ethpandaops/spamoor/scenarios/statebloat/erc20_bloater" + extcodesizesetup "github.com/ethpandaops/spamoor/scenarios/statebloat/extcodesize_setup" + storagetriebrancher "github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher" "github.com/ethpandaops/spamoor/scenarios/storagespam" "github.com/ethpandaops/spamoor/scenarios/taskrunner" uniswapswaps "github.com/ethpandaops/spamoor/scenarios/uniswap-swaps" @@ -42,10 +44,12 @@ var ScenarioDescriptors = []*scenario.Descriptor{ &erc20bloater.ScenarioDescriptor, &erctx.ScenarioDescriptor, &evmfuzz.ScenarioDescriptor, + &extcodesizesetup.ScenarioDescriptor, &factorydeploytx.ScenarioDescriptor, &gasburnertx.ScenarioDescriptor, &geastx.ScenarioDescriptor, &setcodetx.ScenarioDescriptor, + &storagetriebrancher.ScenarioDescriptor, &storagespam.ScenarioDescriptor, &taskrunner.ScenarioDescriptor, &uniswapswaps.ScenarioDescriptor, diff --git a/scenarios/statebloat/extcodesize_setup/extcodesize_setup.go b/scenarios/statebloat/extcodesize_setup/extcodesize_setup.go new file mode 100644 index 0000000..85cff8e --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup/extcodesize_setup.go @@ -0,0 +1,996 @@ +package extcodesizesetup + +import ( + "context" + "encoding/hex" + "fmt" + "math/big" + "strings" + + geas "github.com/fjl/geas/asm" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/holiman/uint256" + "github.com/sirupsen/logrus" + "github.com/spf13/pflag" + "gopkg.in/yaml.v3" + + "github.com/ethpandaops/spamoor/scenario" + "github.com/ethpandaops/spamoor/spamoor" + "github.com/ethpandaops/spamoor/txbuilder" + "github.com/ethpandaops/spamoor/utils" +) + +// Contract sizes in KB - default set for backwards compatibility +var DefaultContractSizesKB = []float64{0.5, 1, 2, 5, 10, 24} + +// AllContractSizesKB includes all supported sizes (including post-EIP-7907 sizes) +var AllContractSizesKB = []float64{0.5, 1, 2, 5, 10, 24, 32, 64} + +// MaxContractSize is the maximum contract size in bytes +// Pre-Prague: 24KB (EIP-170) +// Post-Prague: 48KB (EIP-7907), but testnets may allow larger +const MaxContractSize = 65536 // 64KB for testnet support + +// InitcodeInfo stores information about a deployed initcode contract +type InitcodeInfo struct { + SizeKB float64 `yaml:"size_kb" json:"size_kb"` + Address common.Address `yaml:"address" json:"address"` + Hash common.Hash `yaml:"hash" json:"hash"` + BytecodeSize int `yaml:"bytecode_size" json:"bytecode_size"` +} + +// FactoryInfo stores information about a deployed factory contract +type FactoryInfo struct { + SizeKB float64 `yaml:"size_kb" json:"size_kb"` + Address common.Address `yaml:"address" json:"address"` + InitcodeAddress common.Address `yaml:"initcode_address" json:"initcode_address"` + InitcodeHash common.Hash `yaml:"initcode_hash" json:"initcode_hash"` + InitcodeSize int `yaml:"initcode_size" json:"initcode_size"` +} + +// PredeployedAddresses allows users to provide pre-deployed contract addresses +type PredeployedAddresses struct { + Initcode map[string]common.Address `yaml:"initcode" json:"initcode"` // e.g., "0_5kb": "0x..." + Factories map[string]common.Address `yaml:"factories" json:"factories"` // e.g., "0_5kb": "0x..." +} + +type ScenarioOptions struct { + ContractsPerSize uint64 `yaml:"contracts_per_size" json:"contracts_per_size"` + ContractSizes []float64 `yaml:"contract_sizes" json:"contract_sizes"` // Sizes in KB to deploy (e.g., [0.5, 1, 2, 5, 10, 24, 32, 64]) + MaxWallets uint64 `yaml:"max_wallets" json:"max_wallets"` + MaxPending uint64 `yaml:"max_pending" json:"max_pending"` // Maximum pending transactions (0 = auto-calculate based on wallet count) + BaseFee float64 `yaml:"base_fee" json:"base_fee"` + TipFee float64 `yaml:"tip_fee" json:"tip_fee"` + Throughput uint64 `yaml:"throughput" json:"throughput"` + PredeployedAddresses PredeployedAddresses `yaml:"predeployed" json:"predeployed"` +} + +type Scenario struct { + options ScenarioOptions + logger *logrus.Entry + walletPool *spamoor.WalletPool + + // Deployed contract addresses + initcodeContracts map[string]*InitcodeInfo + factoryContracts map[string]*FactoryInfo +} + +var ScenarioName = "extcodesize_setup" +var ScenarioDefaultOptions = ScenarioOptions{ + ContractsPerSize: 1000, + ContractSizes: AllContractSizesKB, // [0.5, 1, 2, 5, 10, 24, 32, 64] + MaxWallets: 50, + MaxPending: 0, // 0 = auto-calculate based on wallet count + BaseFee: 20, + TipFee: 2, + Throughput: 0, // 0 = auto-calculate based on block gas limit + PredeployedAddresses: PredeployedAddresses{ + Initcode: make(map[string]common.Address), + Factories: make(map[string]common.Address), + }, +} +var ScenarioDescriptor = scenario.Descriptor{ + Name: ScenarioName, + Description: "Deploy extcodesize benchmark setup (initcode contracts, factories, and test contracts)", + DefaultOptions: ScenarioDefaultOptions, + NewScenario: newScenario, +} + +func newScenario(logger logrus.FieldLogger) scenario.Scenario { + return &Scenario{ + options: ScenarioDefaultOptions, + logger: logger.WithField("scenario", ScenarioName), + initcodeContracts: make(map[string]*InitcodeInfo), + factoryContracts: make(map[string]*FactoryInfo), + } +} + +func (s *Scenario) Flags(flags *pflag.FlagSet) error { + flags.Uint64VarP(&s.options.ContractsPerSize, "contracts-per-size", "c", ScenarioDefaultOptions.ContractsPerSize, "Number of contracts to deploy per size") + flags.Uint64Var(&s.options.MaxWallets, "max-wallets", ScenarioDefaultOptions.MaxWallets, "Maximum number of wallets to use for parallel execution") + flags.Float64Var(&s.options.BaseFee, "basefee", ScenarioDefaultOptions.BaseFee, "Base fee per gas in gwei") + flags.Float64Var(&s.options.TipFee, "tipfee", ScenarioDefaultOptions.TipFee, "Tip fee per gas in gwei") + flags.Uint64VarP(&s.options.Throughput, "throughput", "t", ScenarioDefaultOptions.Throughput, "Max deployments per slot (0=auto based on block gas limit)") + return nil +} + +func (s *Scenario) Init(options *scenario.Options) error { + s.walletPool = options.WalletPool + + if options.Config != "" { + err := yaml.Unmarshal([]byte(options.Config), &s.options) + if err != nil { + return fmt.Errorf("failed to unmarshal config: %w", err) + } + } + + // Initialize maps if nil (in case config didn't have them) + if s.options.PredeployedAddresses.Initcode == nil { + s.options.PredeployedAddresses.Initcode = make(map[string]common.Address) + } + if s.options.PredeployedAddresses.Factories == nil { + s.options.PredeployedAddresses.Factories = make(map[string]common.Address) + } + + // Use default contract sizes if not specified + if len(s.options.ContractSizes) == 0 { + s.options.ContractSizes = AllContractSizesKB + } + + // Set up wallets for parallel execution + if s.options.MaxWallets > 0 { + s.walletPool.SetWalletCount(s.options.MaxWallets) + } else { + s.walletPool.SetWalletCount(50) // Default fallback + } + + return nil +} + +func (s *Scenario) Config() string { + type ConfigWithState struct { + ScenarioOptions + InitcodeContracts map[string]*InitcodeInfo `yaml:"initcode_contracts,omitempty" json:"initcode_contracts,omitempty"` + FactoryContracts map[string]*FactoryInfo `yaml:"factory_contracts,omitempty" json:"factory_contracts,omitempty"` + } + + cfg := ConfigWithState{ + ScenarioOptions: s.options, + InitcodeContracts: s.initcodeContracts, + FactoryContracts: s.factoryContracts, + } + + yamlBytes, _ := yaml.Marshal(&cfg) + return string(yamlBytes) +} + +func (s *Scenario) Run(ctx context.Context) error { + s.logger.Infof("starting scenario: %s", ScenarioName) + defer s.logger.Infof("scenario %s finished", ScenarioName) + + // Phase 1: Deploy initcode contracts for all sizes + s.logger.Info("=== Phase 1: Deploying initcode contracts ===") + for _, sizeKB := range s.options.ContractSizes { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + sizeKey := sizeKeyFromKB(sizeKB) + + // Check if pre-deployed address is provided + if predeployed, ok := s.options.PredeployedAddresses.Initcode[sizeKey]; ok && predeployed != (common.Address{}) { + s.logger.Infof("using pre-deployed initcode for %sKB at %s", sizeKey, predeployed.Hex()) + // We need to fetch the code to compute the hash + info, err := s.loadInitcodeInfo(ctx, sizeKB, predeployed) + if err != nil { + return fmt.Errorf("failed to load pre-deployed initcode for %sKB: %w", sizeKey, err) + } + s.initcodeContracts[sizeKey] = info + continue + } + + info, err := s.deployInitcode(ctx, sizeKB) + if err != nil { + return fmt.Errorf("failed to deploy initcode for %sKB: %w", sizeKey, err) + } + s.initcodeContracts[sizeKey] = info + s.logger.Infof("deployed initcode for %.1fKB at %s (hash: %s)", sizeKB, info.Address.Hex(), info.Hash.Hex()[:18]+"...") + } + + // Phase 2: Deploy factory contracts for all sizes + s.logger.Info("=== Phase 2: Deploying factory contracts ===") + for _, sizeKB := range s.options.ContractSizes { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + sizeKey := sizeKeyFromKB(sizeKB) + initcodeInfo := s.initcodeContracts[sizeKey] + + // Check if pre-deployed factory address is provided + if predeployed, ok := s.options.PredeployedAddresses.Factories[sizeKey]; ok && predeployed != (common.Address{}) { + s.logger.Infof("using pre-deployed factory for %sKB at %s", sizeKey, predeployed.Hex()) + s.factoryContracts[sizeKey] = &FactoryInfo{ + SizeKB: sizeKB, + Address: predeployed, + InitcodeAddress: initcodeInfo.Address, + InitcodeHash: initcodeInfo.Hash, + InitcodeSize: initcodeInfo.BytecodeSize, + } + continue + } + + factoryInfo, err := s.deployFactory(ctx, sizeKB, initcodeInfo) + if err != nil { + return fmt.Errorf("failed to deploy factory for %sKB: %w", sizeKey, err) + } + s.factoryContracts[sizeKey] = factoryInfo + s.logger.Infof("deployed factory for %.1fKB at %s", sizeKB, factoryInfo.Address.Hex()) + } + + // Phase 3: Deploy contracts via factories + s.logger.Info("=== Phase 3: Deploying contracts via factories ===") + for _, sizeKB := range s.options.ContractSizes { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + sizeKey := sizeKeyFromKB(sizeKB) + factoryInfo := s.factoryContracts[sizeKey] + + err := s.deployContractsViaFactory(ctx, sizeKB, factoryInfo) + if err != nil { + return fmt.Errorf("failed to deploy contracts for %sKB: %w", sizeKey, err) + } + } + + // Log summary in stubs.json format for execution-spec-tests compatibility + s.logger.Info("=== Deployment Summary ===") + s.logger.Info("Factory addresses (stubs.json format):") + s.logger.Info("{") + for i, sizeKB := range s.options.ContractSizes { + sizeKey := sizeKeyFromKB(sizeKB) + factoryInfo := s.factoryContracts[sizeKey] + stubKey := fmt.Sprintf("bloatnet_factory_%s", sizeKey) + comma := "," + if i == len(s.options.ContractSizes)-1 { + comma = "" + } + s.logger.Infof(" \"%s\": \"%s\"%s", stubKey, factoryInfo.Address.Hex(), comma) + } + s.logger.Info("}") + + // Also log in a more readable format + s.logger.Info("") + s.logger.Info("=== Factory Addresses ===") + for _, sizeKB := range s.options.ContractSizes { + sizeKey := sizeKeyFromKB(sizeKB) + factoryInfo := s.factoryContracts[sizeKey] + stubKey := fmt.Sprintf("bloatnet_factory_%s", sizeKey) + s.logger.Infof("%s: %s", stubKey, factoryInfo.Address.Hex()) + } + + return nil +} + +// sizeKeyFromKB converts a size in KB to a string key (e.g., 0.5 -> "0_5kb", 1.0 -> "1kb") +func sizeKeyFromKB(sizeKB float64) string { + if sizeKB == float64(int(sizeKB)) { + return fmt.Sprintf("%dkb", int(sizeKB)) + } + return strings.ReplaceAll(fmt.Sprintf("%.1fkb", sizeKB), ".", "_") +} + +// loadInitcodeInfo loads info for a pre-deployed initcode contract +func (s *Scenario) loadInitcodeInfo(ctx context.Context, sizeKB float64, address common.Address) (*InitcodeInfo, error) { + client := s.walletPool.GetClient(spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, 0)) + if client == nil { + return nil, fmt.Errorf("no client available") + } + + code, err := client.GetEthClient().CodeAt(ctx, address, nil) + if err != nil { + return nil, fmt.Errorf("failed to get code: %w", err) + } + + if len(code) == 0 { + return nil, fmt.Errorf("no code at address %s", address.Hex()) + } + + hash := crypto.Keccak256Hash(code) + + return &InitcodeInfo{ + SizeKB: sizeKB, + Address: address, + Hash: hash, + BytecodeSize: len(code), + }, nil +} + +// deployInitcode deploys an initcode contract for a specific size +func (s *Scenario) deployInitcode(ctx context.Context, sizeKB float64) (*InitcodeInfo, error) { + client := s.walletPool.GetClient(spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, 0)) + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, 0) + + if client == nil { + return nil, fmt.Errorf("no client available") + } + if wallet == nil { + return nil, fmt.Errorf("no wallet available") + } + + // Build initcode bytecode + initcodeBytecode, err := buildInitcode(sizeKB) + if err != nil { + return nil, fmt.Errorf("failed to build initcode: %w", err) + } + + initcodeHash := crypto.Keccak256Hash(initcodeBytecode) + s.logger.Debugf("built initcode for %.1fKB: %d bytes, hash: %s", sizeKB, len(initcodeBytecode), initcodeHash.Hex()[:18]+"...") + + // Build deployment bytecode that returns the initcode as contract code + deploymentBytecode := buildInitcodeDeployer(initcodeBytecode) + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return nil, fmt.Errorf("failed to get suggested fees: %w", err) + } + + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: 16_000_000, // High gas for large initcode + To: nil, + Value: uint256.NewInt(0), + Data: deploymentBytecode, + }) + if err != nil { + return nil, fmt.Errorf("failed to build tx data: %w", err) + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, fmt.Errorf("failed to build tx: %w", err) + } + + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + Rebroadcast: true, + }) + if err != nil { + return nil, fmt.Errorf("failed to send tx: %w", err) + } + + if receipt.Status != types.ReceiptStatusSuccessful { + return nil, fmt.Errorf("deployment failed with status %d", receipt.Status) + } + + return &InitcodeInfo{ + SizeKB: sizeKB, + Address: receipt.ContractAddress, + Hash: initcodeHash, + BytecodeSize: len(initcodeBytecode), + }, nil +} + +// deployFactory deploys a CREATE2 factory contract for a specific size +func (s *Scenario) deployFactory(ctx context.Context, sizeKB float64, initcodeInfo *InitcodeInfo) (*FactoryInfo, error) { + client := s.walletPool.GetClient(spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, 0)) + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, 0) + + if client == nil { + return nil, fmt.Errorf("no client available") + } + if wallet == nil { + return nil, fmt.Errorf("no wallet available") + } + + // Build factory bytecode + factoryBytecode, err := buildFactory(initcodeInfo.Address, initcodeInfo.Hash, initcodeInfo.BytecodeSize) + if err != nil { + return nil, fmt.Errorf("failed to build factory: %w", err) + } + + s.logger.Debugf("built factory bytecode for %.1fKB: %d bytes", sizeKB, len(factoryBytecode)) + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return nil, fmt.Errorf("failed to get suggested fees: %w", err) + } + + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: 10_000_000, + To: nil, + Value: uint256.NewInt(0), + Data: factoryBytecode, + }) + if err != nil { + return nil, fmt.Errorf("failed to build tx data: %w", err) + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, fmt.Errorf("failed to build tx: %w", err) + } + + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + Rebroadcast: true, + }) + if err != nil { + return nil, fmt.Errorf("failed to send tx: %w", err) + } + + if receipt.Status != types.ReceiptStatusSuccessful { + return nil, fmt.Errorf("deployment failed with status %d", receipt.Status) + } + + // Verify factory storage + counter, err := client.GetEthClient().StorageAt(ctx, receipt.ContractAddress, common.Hash{}, nil) + if err != nil { + s.logger.Warnf("failed to verify factory storage: %v", err) + } else { + s.logger.Debugf("factory storage slot 0 (counter): %s", hex.EncodeToString(counter)) + } + + return &FactoryInfo{ + SizeKB: sizeKB, + Address: receipt.ContractAddress, + InitcodeAddress: initcodeInfo.Address, + InitcodeHash: initcodeInfo.Hash, + InitcodeSize: initcodeInfo.BytecodeSize, + }, nil +} + +// deployContractsViaFactory deploys multiple contracts via a CREATE2 factory using parallel transactions +func (s *Scenario) deployContractsViaFactory(ctx context.Context, sizeKB float64, factoryInfo *FactoryInfo) error { + sizeKey := sizeKeyFromKB(sizeKB) + + // Get current counter from factory + client := s.walletPool.GetClient(spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, 0)) + if client == nil { + return fmt.Errorf("no client available") + } + + counterBytes, err := client.GetEthClient().StorageAt(ctx, factoryInfo.Address, common.Hash{}, nil) + if err != nil { + return fmt.Errorf("failed to get factory counter: %w", err) + } + currentCounter := new(big.Int).SetBytes(counterBytes).Uint64() + + if currentCounter >= s.options.ContractsPerSize { + s.logger.Infof("factory for %s already has %d contracts (target: %d), skipping", sizeKey, currentCounter, s.options.ContractsPerSize) + return nil + } + + remaining := s.options.ContractsPerSize - currentCounter + + // Get block gas limit to calculate optimal throughput + blockGasLimit, err := s.walletPool.GetTxPool().GetCurrentGasLimitWithInit() + if err != nil { + return fmt.Errorf("failed to get block gas limit: %w", err) + } + + // Calculate gas per deployment based on contract size + gasPerDeployment := calculateGasForSize(sizeKB, blockGasLimit) + + // Calculate how many transactions can fit per block (use 90% of block gas limit for safety) + usableGas := uint64(float64(blockGasLimit) * 0.9) + txsPerBlock := usableGas / gasPerDeployment + if txsPerBlock < 1 { + txsPerBlock = 1 + } + + s.logger.Infof("deploying %d contracts for %s: block_gas=%dM, tx_gas=%d, txs_per_block=%d", + remaining, sizeKey, blockGasLimit/1_000_000, gasPerDeployment, txsPerBlock) + + // Calculate maxPending - use config value if set, otherwise auto-calculate + maxPending := s.options.MaxPending + if maxPending == 0 { + maxPending = s.walletPool.GetConfiguredWalletCount() * 10 + if maxPending < 100 { + maxPending = 100 + } + } + + err = scenario.RunTransactionScenario(ctx, scenario.TransactionScenarioOptions{ + TotalCount: remaining, + Throughput: s.options.Throughput, // 0 = unlimited, send as fast as possible + MaxPending: maxPending, + WalletPool: s.walletPool, + Logger: s.logger.WithField("size", sizeKey), + ProcessNextTxFn: func(ctx context.Context, params *scenario.ProcessNextTxParams) error { + return s.sendFactoryDeployTx(ctx, params, factoryInfo, gasPerDeployment, sizeKey) + }, + }) + if err != nil { + return fmt.Errorf("failed to deploy contracts: %w", err) + } + + // Verify final count + counterBytes, err = client.GetEthClient().StorageAt(ctx, factoryInfo.Address, common.Hash{}, nil) + if err != nil { + s.logger.Warnf("failed to verify final counter: %v", err) + } else { + finalCounter := new(big.Int).SetBytes(counterBytes).Uint64() + s.logger.Infof("%s: final contract count: %d", sizeKey, finalCounter) + } + + return nil +} + +// sendFactoryDeployTx sends a transaction to deploy a contract via the factory +func (s *Scenario) sendFactoryDeployTx(ctx context.Context, params *scenario.ProcessNextTxParams, factoryInfo *FactoryInfo, gasLimit uint64, sizeKey string) error { + // Get client and wallet using txIdx for distribution across wallets + client := s.walletPool.GetClient( + spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, int(params.TxIdx)), + ) + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, int(params.TxIdx)) + + if client == nil { + return scenario.ErrNoClients + } + if wallet == nil { + return scenario.ErrNoWallet + } + + if err := wallet.ResetNoncesIfNeeded(ctx, client); err != nil { + return err + } + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return err + } + + // Build transaction to call factory (non-empty calldata triggers CREATE2) + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: gasLimit, + To: &factoryInfo.Address, + Value: uint256.NewInt(0), + Data: []byte{0x01}, // Non-empty data triggers CREATE2 path + }) + if err != nil { + return err + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return err + } + + // Send transaction and wait for receipt + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + Rebroadcast: true, + }) + + params.NotifySubmitted() + + logger := s.logger.WithFields(logrus.Fields{ + "size": sizeKey, + "rpc": client.GetName(), + "nonce": tx.Nonce(), + "wallet": s.walletPool.GetWalletName(wallet.GetAddress()), + }) + + params.OrderedLogCb(func() { + if err != nil { + logger.Warnf("tx %d failed to send: %v", params.TxIdx+1, err) + } else { + logger.Debugf("sent tx #%d: %v", params.TxIdx+1, tx.Hash().Hex()) + } + }) + + if receipt != nil && receipt.Status != 1 { + logger.Warnf("tx %d failed with status %d", params.TxIdx+1, receipt.Status) + } + + // Mark wallet for nonce resync if transaction failed to send + if err != nil { + wallet.MarkNeedResync() + } + + return err +} + +// calculateGasForSize calculates gas needed to deploy a contract of given size +// Gas costs breakdown: +// - Transaction intrinsic: 21,000 +// - Factory execution overhead: ~5,000 +// - CREATE2 overhead: ~32,000 +// - Contract bytecode storage: 200 gas per byte +// - Init code execution: scales with size (keccak256 expansion loops) +func calculateGasForSize(sizeKB float64, blockGasLimit uint64) uint64 { + sizeBytes := uint64(sizeKB * 1024) + + // Base costs + intrinsicGas := uint64(21_000) + factoryOverhead := uint64(5_000) + create2Overhead := uint64(32_000) + bytecodeStorageCost := sizeBytes * 200 + + // Init code execution cost scales with size due to keccak256 expansion loops + // Larger contracts require more iterations to generate unique bytecode + var initExecutionCost uint64 + if sizeKB < 1 { + // Small contracts: simple padding, minimal execution + initExecutionCost = uint64(sizeKB * 30_000) + } else { + // Larger contracts: keccak256 expansion loop + // Each iteration does SHA3 + XOR operations + // Roughly: (size / 256) iterations * ~3000 gas per iteration + iterations := sizeBytes / 256 + if iterations < 1 { + iterations = 1 + } + initExecutionCost = iterations * 3_000 + } + + // Total gas with 15% buffer for safety + totalGas := uint64(float64(intrinsicGas+factoryOverhead+create2Overhead+bytecodeStorageCost+initExecutionCost) * 1.15) + + // Cap at block gas limit (single tx shouldn't exceed block limit) + if totalGas > blockGasLimit { + totalGas = blockGasLimit + } + + // Also cap at EIP-7825 limit if applicable + if totalGas > utils.MaxGasLimitPerTx { + totalGas = utils.MaxGasLimitPerTx + } + + return totalGas +} + +// buildInitcode builds initcode bytecode that generates contracts of specific size +func buildInitcode(targetSizeKB float64) ([]byte, error) { + targetSize := int(targetSizeKB * 1024) + if targetSize > MaxContractSize { + targetSize = MaxContractSize + } + + compiler := geas.NewCompiler(nil) + + if targetSize < 1024 { + // For small contracts (< 1KB), use simple padding with JUMPDEST opcodes + // The contract will store ADDRESS at memory[0] for uniqueness, then pad with JUMPDESTs + paddingSize := targetSize - 33 - 10 // Account for MSTORE(ADDRESS) and RETURN opcodes + if paddingSize < 0 { + paddingSize = 0 + } + + // Build padding string + padding := "" + for i := 0; i < paddingSize; i++ { + padding += "jumpdest\n" + } + + initcodeGeas := fmt.Sprintf(` + ;; Store deployer address for uniqueness + address + push 0 + mstore + + ;; Padding with JUMPDESTs + %s + + ;; Set first byte to STOP for efficient CALL handling + push 0x00 + push 0 + mstore8 + + ;; Return the contract bytecode + push %d + push 0 + return + `, padding, targetSize) + + code := compiler.CompileString(initcodeGeas) + if code == nil { + return nil, fmt.Errorf("failed to compile initcode for small contract") + } + return code, nil + } + + // For larger contracts, use keccak256 expansion pattern + // We generate an XOR table and use SHA3 to expand the bytecode + xorTableSize := min(256, targetSize/256) + if xorTableSize < 1 { + xorTableSize = 1 + } + + // Generate XOR table values + xorValues := make([]string, xorTableSize) + for i := 0; i < xorTableSize; i++ { + // Use keccak256(i) as XOR value + hash := crypto.Keccak256(big.NewInt(int64(i)).Bytes()) + xorValues[i] = "0x" + hex.EncodeToString(hash) + } + + // Build XOR expansion loop body + xorExpansion := "" + for _, xorVal := range xorValues { + xorExpansion += fmt.Sprintf(` + push %s + xor + dup1 + msize + mstore + `, xorVal) + } + + initcodeGeas := fmt.Sprintf(` + ;; Store ADDRESS as initial seed - creates uniqueness per deployment + address + push 0 + mstore + + loop: + ;; Check if we've reached target size + msize + push %d + lt + iszero + jumpi @done + + ;; keccak256 of last 32 bytes to expand + push 32 + msize + push 32 + sub + keccak256 + + ;; XOR expansion + %s + pop + + jump @loop + + done: + ;; Set first byte to STOP for efficient CALL handling + push 0x00 + push 0 + mstore8 + + ;; Return the full contract + push %d + push 0 + return + `, targetSize, xorExpansion, targetSize) + + code := compiler.CompileString(initcodeGeas) + if code == nil { + return nil, fmt.Errorf("failed to compile initcode for large contract") + } + return code, nil +} + +// buildInitcodeDeployer builds deployment bytecode that returns the initcode as contract code +func buildInitcodeDeployer(initcode []byte) []byte { + compiler := geas.NewCompiler(nil) + + // Prefix size is 12 bytes (hardcoded based on geas output) + prefixSize := 12 + + deployerGeas := fmt.Sprintf(` + ;; CODECOPY(destOffset=0, offset=prefix_size, size=initcode_size) + push %d ;; initcode size + dup1 ;; duplicate for RETURN + push %d ;; offset (after this prefix) + push 0 ;; dest offset in memory + codecopy + + ;; RETURN(offset=0, size=initcode_size) + push 0 + return + `, len(initcode), prefixSize) + + deployerCode := compiler.CompileString(deployerGeas) + if deployerCode == nil { + // Fallback to manual bytecode construction + return buildInitcodeDeployerManual(initcode) + } + + // Adjust offset if actual deployer size differs + actualPrefixSize := len(deployerCode) + if actualPrefixSize != prefixSize { + deployerGeas = fmt.Sprintf(` + push %d + dup1 + push %d + push 0 + codecopy + push 0 + return + `, len(initcode), actualPrefixSize) + deployerCode = compiler.CompileString(deployerGeas) + } + + return append(deployerCode, initcode...) +} + +// buildInitcodeDeployerManual is a fallback that builds the deployer bytecode manually +func buildInitcodeDeployerManual(initcode []byte) []byte { + size := len(initcode) + + // PUSH2 size, DUP1, PUSH1 offset, PUSH1 0, CODECOPY, PUSH1 0, RETURN + // Total: 12 bytes + deployer := []byte{ + 0x61, byte(size >> 8), byte(size), // PUSH2 size + 0x80, // DUP1 + 0x60, 0x0c, // PUSH1 12 (offset after this prefix) + 0x60, 0x00, // PUSH1 0 (dest) + 0x39, // CODECOPY + 0x60, 0x00, // PUSH1 0 + 0xf3, // RETURN + } + + return append(deployer, initcode...) +} + +// buildFactory builds a CREATE2 factory contract bytecode +func buildFactory(initcodeAddr common.Address, initcodeHash common.Hash, initcodeSize int) ([]byte, error) { + compiler := geas.NewCompiler(nil) + + // Factory layout: + // - Storage slot 0: Counter (number of deployed contracts) + // - Storage slot 1: Init code hash for CREATE2 address calculation + // - Storage slot 2: Init code address + // + // Interface: + // - When called with CALLDATASIZE == 0: Returns (num_deployed_contracts, init_code_hash) + // - When called otherwise: Deploys a new contract via CREATE2 + + // Constructor: store init code hash and address + constructorGeas := fmt.Sprintf(` + ;; Store init code hash in slot 1 + push %s + push 1 + sstore + + ;; Store initcode address in slot 2 + push %s + push 2 + sstore + `, initcodeHash.Hex(), initcodeAddr.Hex()) + + // Runtime code + runtimeGeas := fmt.Sprintf(` + runtime_start: + ;; Check if this is a getConfig() call (CALLDATASIZE == 0) + calldatasize + iszero + jumpi @getconfig + + ;; === CREATE2 DEPLOYMENT PATH === + ;; Load initcode address from storage slot 2 + push 2 + sload + + ;; EXTCODECOPY: copy initcode to memory + push %d ;; size + push 0 ;; source offset + push 0 ;; dest offset + dup4 ;; address + extcodecopy + + ;; Prepare for CREATE2 + push %d ;; size + swap1 + pop ;; remove address from stack + + ;; CREATE2 with current counter as salt + push 0 ;; slot 0 + sload ;; load counter (use as salt) + swap1 ;; put size on top + push 0 ;; offset in memory + push 0 ;; value + create2 ;; create contract + + ;; Store the created address for return + dup1 + push 0 + mstore + + ;; Increment counter + push 0 ;; slot 0 + dup1 ;; duplicate + sload ;; load counter + push 1 ;; increment + add ;; add + swap1 ;; swap + sstore ;; store new counter + + ;; Return the created address + push 32 ;; return 32 bytes + push 0 ;; from memory position 0 + return + + getconfig: + ;; === GETCONFIG PATH === + push 0 ;; slot 0 + sload ;; load number of deployed contracts + push 0 ;; memory position 0 + mstore ;; store in memory + + push 1 ;; slot 1 + sload ;; load init code hash + push 32 ;; memory position 32 + mstore ;; store in memory + + push 64 ;; return 64 bytes (2 * 32) + push 0 ;; from memory position 0 + return + `, initcodeSize, initcodeSize) + + // Compile constructor + constructorCode := compiler.CompileString(constructorGeas) + if constructorCode == nil { + return nil, fmt.Errorf("failed to compile factory constructor") + } + + // Compile runtime + runtimeCode := compiler.CompileString(runtimeGeas) + if runtimeCode == nil { + return nil, fmt.Errorf("failed to compile factory runtime") + } + + // Build deployer that executes constructor and returns runtime + runtimeSize := len(runtimeCode) + constructorSize := len(constructorCode) + + // Deployer code: execute constructor, then copy and return runtime + deployerGeas := fmt.Sprintf(` + ;; Copy runtime code to memory + push %d ;; runtime size + push %d ;; offset to runtime + push 0 ;; dest in memory + codecopy + + ;; Return runtime code + push %d ;; size to return + push 0 ;; offset in memory + return + `, runtimeSize, constructorSize+14, runtimeSize) // 14 is approximate deployer size + + deployerCode := compiler.CompileString(deployerGeas) + if deployerCode == nil { + return nil, fmt.Errorf("failed to compile factory deployer") + } + + // Adjust offset based on actual deployer size + actualDeployerSize := len(deployerCode) + runtimeOffset := constructorSize + actualDeployerSize + + deployerGeas = fmt.Sprintf(` + push %d + push %d + push 0 + codecopy + push %d + push 0 + return + `, runtimeSize, runtimeOffset, runtimeSize) + + deployerCode = compiler.CompileString(deployerGeas) + if deployerCode == nil { + return nil, fmt.Errorf("failed to compile adjusted factory deployer") + } + + // Final bytecode: constructor + deployer + runtime + return append(append(constructorCode, deployerCode...), runtimeCode...), nil +} diff --git a/scenarios/statebloat/extcodesize_setup_deployment/__pycache__/deploy_contracts_multi.cpython-313.pyc b/scenarios/statebloat/extcodesize_setup_deployment/__pycache__/deploy_contracts_multi.cpython-313.pyc new file mode 100644 index 0000000..82e4ee4 Binary files /dev/null and b/scenarios/statebloat/extcodesize_setup_deployment/__pycache__/deploy_contracts_multi.cpython-313.pyc differ diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_0_5kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_0_5kb.yaml new file mode 100644 index 0000000..24d6eb6 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_0_5kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 0.5KB contracts' + seed: extcodesize-0_5kb + config: + contracts_per_size: 18100 + contract_sizes: [0.5] + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "0_5kb": "0x63bd83eb22ef344b06eed74b05660068880bc71f" + factories: + "0_5kb": "0x5d4D348A2E1cEcdceAEa71C0Aded0c3a662a19D0" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_10kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_10kb.yaml new file mode 100644 index 0000000..b3f6ada --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_10kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 10KB contracts' + seed: extcodesize-10kb + config: + contracts_per_size: 18100 + contract_sizes: [10] + max_wallets: 100 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "10kb": "0xe3a974aeb654a29030e2f8086db94abe5d5eace9" + factories: + "10kb": "0x899282dd9415E6d970FD8850C423b557F2026A1E" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_1kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_1kb.yaml new file mode 100644 index 0000000..47b7548 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_1kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 1KB contracts' + seed: extcodesize-1kb + config: + contracts_per_size: 18100 + contract_sizes: [1] + max_wallets: 100 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "1kb": "0x2060843ac3b59d39f0adaa02541678c73c34e743" + factories: + "1kb": "0x6B1BA1790adA5420f16CE127C168e9546d5D8b7c" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_24kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_24kb.yaml new file mode 100644 index 0000000..d2520ab --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_24kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 24KB contracts' + seed: extcodesize-24kb + config: + contracts_per_size: 18100 + contract_sizes: [24] + max_wallets: 150 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "24kb": "0x00563d8ae8d8d84c43862507cb90ed9c135fb6af" + factories: + "24kb": "0x905fa13dC990ae761f6273aB89f4959812095a92" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_2kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_2kb.yaml new file mode 100644 index 0000000..43c179a --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_2kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 2KB contracts' + seed: extcodesize-2kb + config: + contracts_per_size: 18100 + contract_sizes: [2] + max_wallets: 100 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "2kb": "0x590e5c913fa1e5b6a4ce428f0a6ce0ab8f07ba36" + factories: + "2kb": "0x1B7be25943B9977DDD73316D90C893222D1D9AeE" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_32kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_32kb.yaml new file mode 100644 index 0000000..4e80904 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_32kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 32KB contracts' + seed: extcodesize-32kb + config: + contracts_per_size: 18100 + contract_sizes: [32] + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "32kb": "0x5b5b11ce2b0579d270d18d32eeaa2a3a4fe5a56f" + factories: + "32kb": "0xaE323771D42C79Fd26D4cAf73b0424A09CE194d3" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_5kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_5kb.yaml new file mode 100644 index 0000000..68eb7e3 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_5kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 5KB contracts' + seed: extcodesize-5kb + config: + contracts_per_size: 18100 + contract_sizes: [5] + max_wallets: 100 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "5kb": "0x3a960ff8e25d9e8c3601b2aaa1af065ae5e00d49" + factories: + "5kb": "0x8A8D9D2949b20b50a9Af89C4C4D6B1C32b79b849" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_64kb.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_64kb.yaml new file mode 100644 index 0000000..94591e7 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_64kb.yaml @@ -0,0 +1,14 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 64KB contracts' + seed: extcodesize-64kb + config: + contracts_per_size: 18100 + contract_sizes: [64] + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "64kb": "0x463e623339706777bd76720dea84ea303f3744a1" + factories: + "64kb": "0x73133d0a242bDC5add4f721911e6A91077879b86" diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_all_infra.yaml b/scenarios/statebloat/extcodesize_setup_deployment/deploy_all_infra.yaml new file mode 100644 index 0000000..6fc2799 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_all_infra.yaml @@ -0,0 +1,12 @@ +# Name: EXTCODESIZE Infrastructure Deployment +# Description: Deploy all initcode and factory contracts for all sizes (0.5kb to 64kb) + +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy all infrastructure' + seed: extcodesize-infra-all + config: + contracts_per_size: 0 + contract_sizes: [0.5, 1, 2, 5, 10, 24, 32, 64] + max_wallets: 1 + base_fee: 20 + tip_fee: 2 diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_contracts_multi.py b/scenarios/statebloat/extcodesize_setup_deployment/deploy_contracts_multi.py new file mode 100644 index 0000000..5ebdac0 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_contracts_multi.py @@ -0,0 +1,504 @@ +#!/usr/bin/env python3 +""" +Deploy multiple contracts via CREATE2 factories for different sizes for BloatNet benchmarks. + +This script deploys contracts of specific sizes using the corresponding CREATE2 factories. + +USAGE: + 1. First deploy initcode contracts: + python3 deploy_initcode_multi.py + + 2. Then deploy the factories: + python3 deploy_factory_multi.py + + 3. Finally deploy contracts: + python3 deploy_contracts_multi.py --size 5 --count 1000 + python3 deploy_contracts_multi.py --size 24 --count 350 + + 4. Or deploy remaining contracts for all incomplete sizes (mainnet): + python3 deploy_contracts_multi.py --deploy-remaining --count 18100 + + 5. Or use a specific factory address directly: + python3 deploy_contracts_multi.py --size 24 --count 18100 --factory 0xa4a1aF502114DAA5856b6FBD849e14a535A69eE8 + + 6. Run EEST benchmarks: + uv run execute remote --fork Prague \\ + --rpc-endpoint http://127.0.0.1:8545 \\ + --address-stubs stubs.json \\ + -- --gas-benchmark-values 30 \\ + tests/benchmark/stateful/bloatnet/test_extcodesize_bytecode_sizes.py -v + +REQUIREMENTS: + - web3.py + - eth-utils + - Local geth instance running on http://127.0.0.1:8545 + - stubs.json from deploy_factory_multi.py (or use --factory flag) +""" + +import sys +import json +import time +from eth_utils import keccak +from web3 import Web3 +from eth_account import Account + +# Mainnet factory addresses (from extcodesize_setup_mainnet deployment) +MAINNET_FACTORIES = { + 0.5: "0xE19DA6B7c3716e79dccb84a591B2F36aF03487D5", + 1: "0x6bB03b0bB8b6528243912834D520FA71d77D420B", + 2: "0x61b25103ff58A81c3079C23e57352a62f05d38dd", + 5: "0xa35C3fDdCa307786E74d657A6b4c8952db440076", + 10: "0x401ef5eBd3F749B839e13363aDD39bb85Bb8B204", + 24: "0xa4a1aF502114DAA5856b6FBD849e14a535A69eE8", + 32: "0xFc7c3eda39Aa275fA0483942ba7e56195C7aE321", + 64: "0xd7238974c4d3c3241a974b8e1A7C0b594a5d1e14", +} + + +def estimate_gas_for_size(size_kb: float, block_gas_limit: int) -> int: + """Estimate gas needed to deploy a contract of given size, respecting network limits. + + Based on actual measurements: + - 0.5KB deployment used ~183,163 gas + + Gas costs breakdown: + - Transaction intrinsic: 21,000 + - Factory execution: ~1,000 + - CREATE2 overhead: ~32,000 + - Contract bytecode storage: 200 gas per byte + - Init code execution: varies by size + """ + size_bytes = int(size_kb * 1024) + + # Precise gas calculation based on actual measurements + if size_kb <= 0.5: + # 0.5KB used 183,163 gas = ~21K intrinsic + ~32K CREATE2 + ~102K storage (512*200) + ~28K execution + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 30_000 + elif size_kb <= 1: + # 1KB: similar but with more storage cost + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 35_000 + elif size_kb <= 5: + # 5KB uses While loop for init, more execution cost + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 150_000 + elif size_kb <= 10: + # 10KB: more While iterations + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 300_000 + elif size_kb <= 24: + # 24KB: maximum standard contract size + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 500_000 + elif size_kb <= 32: + # 32KB: exceeds EIP-170 limit, needs more execution + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 700_000 + else: + # 64KB: very large contracts + base_gas = 21_000 + 32_000 + (size_bytes * 200) + 1_000_000 + + # Add 10% buffer for safety + final_gas = int(base_gas * 1.1) + + # Cap at 80% of block gas limit to ensure inclusion + max_safe_gas = int(block_gas_limit * 0.8) + + return min(final_gas, max_safe_gas) + + +def deploy_contracts(w3: Web3, factory_address: str, count: int, size_kb: float, + private_key: str = None, sender_address: str = None) -> int: + """Deploy contracts via a CREATE2 factory. + + If private_key is provided, transactions are signed locally. + Otherwise, uses w3.eth.accounts[0] (requires unlocked account on node). + """ + if private_key: + account = sender_address + use_local_signing = True + else: + account = w3.eth.accounts[0] + use_local_signing = False + + # Get network parameters dynamically + latest_block = w3.eth.get_block('latest') + block_gas_limit = latest_block.gasLimit + print(f"Network block gas limit: {block_gas_limit:,}") + + # Get current counter + current = int.from_bytes(w3.eth.get_storage_at(factory_address, 0), 'big') + print(f"Factory has already deployed {current} contracts") + + if count <= current: + print(f"✅ Already have {current} contracts (target: {count})") + return current + + remaining = count - current + print(f"Deploying {remaining} more contracts of {size_kb}KB...") + + # Estimate gas needed based on network's block gas limit + gas_limit = estimate_gas_for_size(size_kb, block_gas_limit) + print(f"Using gas limit: {gas_limit:,} per deployment") + print(f" (Network allows up to {int(block_gas_limit * 0.8):,} per transaction)") + + # Calculate optimal batch size based on gas costs + # Use actual network block gas limit to maximize throughput + # Each deployment is a separate transaction with our current factory + # Leave some margin for safety (use 95% of block gas limit) + usable_gas = int(block_gas_limit * 0.95) + deployments_per_block = usable_gas // gas_limit + + print(f"Optimal batch size: {deployments_per_block} deployments per block") + print(f" (Each deployment uses {gas_limit:,} gas)") + print(f" (Network block limit is {block_gas_limit:,}, using {usable_gas:,})") + + # Deploy contracts in optimized batches + batch_size = deployments_per_block + deployed = 0 + failed = 0 + start_time = time.time() + + print(f"\nDeploying {remaining} contracts in batches of {batch_size}...") + print(f"Expected blocks needed: {(remaining + batch_size - 1) // batch_size}") + + for batch_start in range(0, remaining, batch_size): + batch_end = min(batch_start + batch_size, remaining) + batch_count = batch_end - batch_start + + # Get fresh nonce for this batch including pending txs to avoid "already known" errors + nonce = w3.eth.get_transaction_count(account, "pending") + + # Send batch of transactions rapidly to fill a block + tx_hashes = [] + batch_time = time.time() + + print(f"\nBatch {batch_start//batch_size + 1}: Sending {batch_count} transactions rapidly to fill block...") + print(f" Starting nonce: {nonce}") + + # Send all transactions as fast as possible with pre-calculated nonces + for i in range(batch_count): + try: + tx = { + "from": account, + "to": factory_address, + "data": "0x01", # Non-empty data to trigger CREATE2 + "gas": gas_limit, + "gasPrice": w3.to_wei(22, 'gwei'), # base_fee(20) + tip(2) to match spamoor config + "nonce": nonce + i, # Pre-calculate nonce for speed + "chainId": w3.eth.chain_id, + } + + if use_local_signing: + # Sign locally and send raw transaction + signed_tx = Account.sign_transaction(tx, private_key) + tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction) + else: + # Use node's unlocked account + tx_hash = w3.eth.send_transaction(tx) + + tx_hashes.append(tx_hash) + except Exception as e: + print(f" Error sending tx {batch_start + i + 1}: {e}") + # Try to recover and continue + break + + send_time = time.time() - batch_time + print(f" Sent {len(tx_hashes)} transactions in {send_time:.2f}s ({len(tx_hashes)/send_time:.1f} tx/s)") + print(f" Waiting for confirmations...") + + # Wait for batch receipts + batch_deployed = 0 + for j, tx_hash in enumerate(tx_hashes): + try: + receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60) + if receipt['status'] == 1: + deployed += 1 + batch_deployed += 1 + else: + failed += 1 + print(f" Transaction {j+1} failed") + except Exception as e: + print(f" Transaction {j+1} failed or timed out: {e}") + failed += 1 + + # Progress update + counter = int.from_bytes(w3.eth.get_storage_at(factory_address, 0), 'big') + elapsed = time.time() - start_time + rate = deployed / elapsed if elapsed > 0 else 0 + eta = (remaining - deployed) / rate if rate > 0 else 0 + batch_elapsed = time.time() - batch_time + + print(f" Batch complete: {batch_deployed}/{batch_count} deployed in {batch_elapsed:.1f}s") + print(f" Gas used per deployment: {gas_limit:,} ({batch_deployed * gas_limit:,} total)") + print(f" Overall: {counter}/{count} contracts ({deployed}/{remaining} new)") + print(f" Rate: {rate:.1f} contracts/sec, ETA: {eta:.0f}s") + + if failed > 20: + print("\n⚠️ Too many failures, stopping...") + break + + # Final check + final_counter = int.from_bytes(w3.eth.get_storage_at(factory_address, 0), 'big') + elapsed = time.time() - start_time + print(f"\n✅ Deployment complete in {elapsed:.1f} seconds") + print(f"Total contracts deployed: {final_counter}") + + return final_counter + + +def verify_contracts(w3: Web3, factory_address: str, count: int, size_kb: float) -> bool: + """Verify that contracts exist at expected CREATE2 addresses.""" + print(f"\n--- Verifying CREATE2 Addresses for {size_kb}KB contracts ---") + + # Get init code hash from factory storage + stored_hash = w3.eth.get_storage_at(factory_address, 1) + + # Verify a sample of contracts + sample_size = min(5, count) + verified = 0 + + for salt in range(sample_size): + # Calculate CREATE2 address + create2_input = ( + b"\xff" + + bytes.fromhex(factory_address[2:].lower()) + + salt.to_bytes(32, "big") + + stored_hash + ) + expected_addr = Web3.to_checksum_address("0x" + keccak(create2_input)[-20:].hex()) + + # Check if contract exists + code = w3.eth.get_code(expected_addr) + if len(code) > 0: + print(f" Salt {salt}: ✅ Found at {expected_addr} ({len(code)} bytes)") + verified += 1 + else: + print(f" Salt {salt}: ❌ Not found at {expected_addr}") + + return verified == sample_size + + +def get_deployment_status(w3: Web3, target_count: int) -> dict: + """Get current deployment status for all mainnet factories.""" + status = {} + for size_kb, factory_addr in MAINNET_FACTORIES.items(): + current = int.from_bytes(w3.eth.get_storage_at(factory_addr, 0), 'big') + remaining = max(0, target_count - current) + status[size_kb] = { + 'factory': factory_addr, + 'deployed': current, + 'target': target_count, + 'remaining': remaining, + 'complete': current >= target_count + } + return status + + +def deploy_remaining_contracts(w3: Web3, target_count: int, + private_key: str = None, sender_address: str = None) -> None: + """Deploy remaining contracts for all incomplete sizes.""" + print("=" * 60) + print("DEPLOYING REMAINING CONTRACTS FOR ALL INCOMPLETE SIZES") + print("=" * 60) + + status = get_deployment_status(w3, target_count) + + # Show current status + print("\nCurrent deployment status:") + for size_kb in sorted(status.keys()): + info = status[size_kb] + pct = (info['deployed'] / info['target'] * 100) if info['target'] > 0 else 0 + marker = "✅" if info['complete'] else "🔄" + print(f" {size_kb:>5}KB: {info['deployed']:>6} / {info['target']:>6} ({pct:5.1f}%) {marker}") + + # Deploy for each incomplete size + incomplete = [(size_kb, info) for size_kb, info in status.items() if not info['complete']] + + if not incomplete: + print("\n✅ All sizes are complete!") + return + + print(f"\n{len(incomplete)} sizes need more contracts:") + for size_kb, info in incomplete: + print(f" {size_kb}KB: {info['remaining']} remaining") + + for size_kb, info in incomplete: + print(f"\n{'=' * 60}") + print(f"DEPLOYING {size_kb}KB CONTRACTS") + print(f"{'=' * 60}") + deploy_contracts(w3, info['factory'], target_count, size_kb, private_key, sender_address) + + # Final status + print(f"\n{'=' * 60}") + print("FINAL DEPLOYMENT STATUS") + print("=" * 60) + final_status = get_deployment_status(w3, target_count) + for size_kb in sorted(final_status.keys()): + info = final_status[size_kb] + pct = (info['deployed'] / info['target'] * 100) if info['target'] > 0 else 0 + marker = "✅" if info['complete'] else "❌" + print(f" {size_kb:>5}KB: {info['deployed']:>6} / {info['target']:>6} ({pct:5.1f}%) {marker}") + + +def main(): + """Main deployment script.""" + import argparse + + # Anvil's default account private key + ANVIL_DEFAULT_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + + parser = argparse.ArgumentParser(description='Deploy BloatNet contracts via CREATE2 factory') + parser.add_argument('--size', type=float, + choices=[0.5, 1, 2, 5, 10, 24, 32, 64], + help='Contract size in KB') + parser.add_argument('--count', type=int, + help='Total number of contracts to deploy') + parser.add_argument('--rpc-url', default='http://127.0.0.1:8545', + help='RPC URL') + parser.add_argument('--stubs', default='stubs.json', + help='Path to stubs JSON file') + parser.add_argument('--factory', type=str, + help='Factory address (overrides stubs.json lookup)') + parser.add_argument('--use-mainnet-factories', action='store_true', + help='Use hardcoded mainnet factory addresses') + parser.add_argument('--deploy-remaining', action='store_true', + help='Deploy remaining contracts for all incomplete sizes') + parser.add_argument('--status', action='store_true', + help='Show deployment status and exit') + parser.add_argument('--private-key', '-p', type=str, + help='Private key for signing transactions (signs locally instead of using node account)') + parser.add_argument('--anvil', action='store_true', + help='Use Anvil default account (0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)') + args = parser.parse_args() + + # Validate arguments + if not args.deploy_remaining and not args.status and not args.size: + parser.error("--size is required unless using --deploy-remaining or --status") + if not args.deploy_remaining and not args.status and not args.count: + parser.error("--count is required unless using --deploy-remaining or --status") + + # Connect to local geth instance + w3 = Web3(Web3.HTTPProvider(args.rpc_url)) + if not w3.is_connected(): + print(f"❌ Failed to connect to {args.rpc_url}") + sys.exit(1) + + print(f"Connected to: {args.rpc_url}") + + # Handle private key / account setup + private_key = None + sender_address = None + + if args.anvil: + private_key = ANVIL_DEFAULT_PRIVATE_KEY + sender_address = Account.from_key(private_key).address + print(f"Using Anvil default account: {sender_address}") + elif args.private_key: + private_key = args.private_key + sender_address = Account.from_key(private_key).address + print(f"Using account from private key: {sender_address}") + else: + try: + sender_address = w3.eth.accounts[0] + print(f"Using node account: {sender_address}") + except Exception: + print("❌ No accounts available on node. Use --private-key or --anvil") + sys.exit(1) + + # Show account balance + balance = w3.eth.get_balance(sender_address) + print(f"Account balance: {w3.from_wei(balance, 'ether'):.4f} ETH") + + # Handle --status mode + if args.status: + target = args.count or 18100 + status = get_deployment_status(w3, target) + print(f"\nDeployment status (target: {target}):") + for size_kb in sorted(status.keys()): + info = status[size_kb] + pct = (info['deployed'] / info['target'] * 100) if info['target'] > 0 else 0 + marker = "✅" if info['complete'] else "🔄" + print(f" {size_kb:>5}KB: {info['deployed']:>6} / {info['target']:>6} ({pct:5.1f}%) {marker} {info['factory']}") + return + + # Handle --deploy-remaining mode + if args.deploy_remaining: + target = args.count or 18100 + deploy_remaining_contracts(w3, target, private_key, sender_address) + return + + # Single size deployment mode + factory_address = None + + # Priority: --factory > --use-mainnet-factories > stubs.json + if args.factory: + factory_address = args.factory + print(f"Using provided factory address: {factory_address}") + elif args.use_mainnet_factories: + factory_address = MAINNET_FACTORIES.get(args.size) + if not factory_address: + print(f"❌ No mainnet factory for {args.size}KB") + print(f"Available sizes: {list(MAINNET_FACTORIES.keys())}") + sys.exit(1) + print(f"Using mainnet factory: {factory_address}") + else: + # Load factory address from stubs + try: + with open(args.stubs, 'r') as f: + stubs = json.load(f) + except FileNotFoundError: + # Fall back to mainnet factories + print(f"⚠️ Stubs file not found: {args.stubs}, using mainnet factories") + factory_address = MAINNET_FACTORIES.get(args.size) + if not factory_address: + print(f"❌ No mainnet factory for {args.size}KB") + sys.exit(1) + print(f"Using mainnet factory: {factory_address}") + + if not factory_address: + # Find the appropriate factory from stubs + # Handle size key naming: 0.5 -> "0_5kb", 1.0 -> "1kb", 24.0 -> "24kb" + if args.size == int(args.size): + size_key = f"{int(args.size)}kb" + else: + size_key = f"{args.size}kb".replace(".", "_") + factory_key = f"bloatnet_factory_{size_key}" + factory_address = stubs.get(factory_key) + + if not factory_address: + print(f"❌ Factory not found for {args.size}KB contracts") + print(f"Looking for key: {factory_key}") + print(f"Available factories: {list(stubs.keys())}") + print(f"\nTip: Use --use-mainnet-factories to use hardcoded addresses") + sys.exit(1) + + print(f"Using factory from stubs: {factory_address}") + + # Deploy contracts + final_count = deploy_contracts(w3, factory_address, args.count, args.size, private_key, sender_address) + + # Verify deployment + if verify_contracts(w3, factory_address, final_count, args.size): + print(f"\n✅ Successfully verified {args.size}KB contracts") + + # Calculate gas requirements for testing + cost_per_contract = 2660 # Approximate gas per EXTCODESIZE with CREATE2 + test_gas_30m = 30_000_000 + max_contracts_30m = (test_gas_30m - 21000 - 1000) // cost_per_contract + + print(f"\n=== Ready for Testing ===") + print(f"Contract size: {args.size}KB") + print(f"Contracts deployed: {final_count}") + print(f"Factory address: {factory_address}") + print(f"Max contracts for 30M gas: ~{max_contracts_30m}") + + if final_count < max_contracts_30m: + print(f"⚠️ Consider deploying {max_contracts_30m - final_count} more contracts " + f"to fully utilize 30M gas") + + print("\nTo run the benchmark test:") + print("uv run execute remote --fork Prague \\") + print(f" --rpc-endpoint {args.rpc_url} \\") + print(f" --address-stubs {args.stubs} \\") + print(" -- --gas-benchmark-values 30 \\") + print(" tests/benchmark/stateful/bloatnet/test_extcodesize_bytecode_sizes.py \\") + print(f" -k '{args.size}KB' -v") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_factory_multi.py b/scenarios/statebloat/extcodesize_setup_deployment/deploy_factory_multi.py new file mode 100644 index 0000000..7e161c2 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_factory_multi.py @@ -0,0 +1,292 @@ +#!/usr/bin/env python3 +""" +Deploy CREATE2 factories for different contract sizes for BloatNet benchmarks. + +This script deploys CREATE2 factories that can deploy contracts of specific sizes +(0.5, 1, 2, 5, 10, 24 KB) using the corresponding initcode contracts. + +USAGE: + 1. First deploy initcode contracts: + python3 deploy_initcode_multi.py + + 2. Then deploy the factories: + python3 deploy_factory_multi.py + + 3. The factory addresses will be saved to stubs.json + +REQUIREMENTS: + - web3.py + - eth-utils + - ethereum-test-tools (for Opcodes) + - Local geth instance running on http://127.0.0.1:8545 + - initcode_addresses.json from deploy_initcode_multi.py +""" + +import sys +import json +from pathlib import Path +from typing import Dict, Any, Tuple + +# Add path to execution-spec-tests if needed +# sys.path.insert(0, "/path/to/execution-spec-tests") + +from execution_testing import Op +from eth_utils import keccak +from web3 import Web3 + + +def build_factory(initcode_address: str, initcode_hash: bytes, initcode_size: int) -> bytes: + """ + Build a CREATE2 factory contract with getConfig() method. + + Storage layout: + - Slot 0: Counter (number of deployed contracts) + - Slot 1: Init code hash for CREATE2 address calculation + - Slot 2: Init code address + + Interface: + - When called with CALLDATASIZE == 0: Returns (num_deployed_contracts, init_code_hash) + - When called otherwise: Deploys a new contract via CREATE2 + """ + + # Factory constructor: Store init code hash and address + factory_constructor = ( + Op.PUSH32(initcode_hash) # Push init code hash + + Op.PUSH1(1) # Slot 1 + + Op.SSTORE # Store init code hash + + Op.PUSH20(bytes.fromhex(initcode_address[2:])) # Push initcode address + + Op.PUSH1(2) # Slot 2 + + Op.SSTORE # Store initcode address + ) + + # Factory runtime code + factory_runtime = ( + # Check if this is a getConfig() call (CALLDATASIZE == 0) + Op.CALLDATASIZE + + Op.ISZERO + + Op.PUSH1(0x31) # Jump to getConfig (hardcoded offset) + + Op.JUMPI + + # === CREATE2 DEPLOYMENT PATH === + # Load initcode address from storage slot 2 + + Op.PUSH1(2) # Slot 2 + + Op.SLOAD # Load initcode address + + # EXTCODECOPY: copy initcode to memory + + Op.PUSH2(initcode_size) # Size + + Op.PUSH1(0) # Source offset + + Op.PUSH1(0) # Dest offset + + Op.DUP4 # Address (from bottom of stack) + + Op.EXTCODECOPY # Copy initcode to memory + + # Prepare for CREATE2 + + Op.PUSH2(initcode_size) # Size + + Op.SWAP1 # Put size under address + + Op.POP # Remove address + + # CREATE2 with current counter as salt + + Op.PUSH1(0) # Slot 0 + + Op.SLOAD # Load counter (use as salt) + + Op.SWAP1 # Put size on top + + Op.PUSH1(0) # Offset in memory + + Op.PUSH1(0) # Value + + Op.CREATE2 # Create contract + + # Store the created address for return + + Op.DUP1 + + Op.PUSH1(0) + + Op.MSTORE + + # Increment counter + + Op.PUSH1(0) # Slot 0 + + Op.DUP1 # Duplicate + + Op.SLOAD # Load counter + + Op.PUSH1(1) # Increment + + Op.ADD # Add + + Op.SWAP1 # Swap + + Op.SSTORE # Store new counter + + # Return the created address + + Op.PUSH1(32) # Return 32 bytes + + Op.PUSH1(0) # From memory position 0 + + Op.RETURN + + # === GETCONFIG PATH === + + Op.JUMPDEST # Destination for getConfig (0x31) + + Op.PUSH1(0) # Slot 0 + + Op.SLOAD # Load number of deployed contracts + + Op.PUSH1(0) # Memory position 0 + + Op.MSTORE # Store in memory + + + Op.PUSH1(1) # Slot 1 + + Op.SLOAD # Load init code hash + + Op.PUSH1(32) # Memory position 32 + + Op.MSTORE # Store in memory + + + Op.PUSH1(64) # Return 64 bytes (2 * 32) + + Op.PUSH1(0) # From memory position 0 + + Op.RETURN + ) + + # Build deployment bytecode + factory_runtime_bytes = bytes(factory_runtime) + runtime_size = len(factory_runtime_bytes) + + # Deployment code that copies and returns runtime + constructor_bytes = bytes(factory_constructor) + constructor_size = len(constructor_bytes) + deployer_size = 14 # Size of deployer code below + runtime_offset = constructor_size + deployer_size + + deployer = ( + # Copy runtime code to memory + Op.PUSH2(runtime_size) # Size of runtime (3 bytes) + + Op.PUSH1(runtime_offset) # Offset to runtime (2 bytes) + + Op.PUSH1(0) # Dest in memory (2 bytes) + + Op.CODECOPY # (1 byte) + # Return runtime code + + Op.PUSH2(runtime_size) # Size to return (3 bytes) + + Op.PUSH1(0) # Offset in memory (2 bytes) + + Op.RETURN # (1 byte) = Total: 14 bytes + ) + + factory_deployment = factory_constructor + deployer + factory_runtime + return bytes(factory_deployment) + + +def deploy_factory(w3: Web3, size_kb: float, initcode_info: Dict[str, Any]) -> Tuple[str, bytes]: + """Deploy a CREATE2 factory for a specific contract size.""" + account = w3.eth.accounts[0] + + print(f"\n--- Deploying Factory for {size_kb}KB contracts ---") + + initcode_address = initcode_info["address"] + initcode_hash_str = initcode_info["hash"] + initcode_size = initcode_info["bytecode_size"] + + # Convert hash string to bytes + initcode_hash = bytes.fromhex(initcode_hash_str[2:] if initcode_hash_str.startswith("0x") else initcode_hash_str) + + print(f"Using initcode at: {initcode_address}") + print(f"Init code hash: {initcode_hash_str}") + print(f"Init code size: {initcode_size} bytes") + + # Build factory bytecode + factory_bytecode = build_factory(initcode_address, initcode_hash, initcode_size) + print(f"Factory deployment size: {len(factory_bytecode)} bytes") + + # Deploy factory + tx_hash = w3.eth.send_transaction({ + "from": account, + "data": "0x" + factory_bytecode.hex(), + "gas": 10000000 # 10M gas for deployment + }) + receipt = w3.eth.wait_for_transaction_receipt(tx_hash) + + if receipt['status'] != 1: + print(f"❌ Failed to deploy factory for {size_kb}KB") + return None, None + + factory_address = receipt['contractAddress'] + print(f"✅ Factory deployed at: {factory_address}") + + # Verify factory storage + counter = w3.eth.get_storage_at(factory_address, 0) + stored_hash = w3.eth.get_storage_at(factory_address, 1) + stored_initcode_addr = w3.eth.get_storage_at(factory_address, 2) + + print(f"Factory storage verification:") + print(f" Slot 0 (counter): {int.from_bytes(counter, 'big')}") + print(f" Slot 1 (hash): 0x{stored_hash.hex()}") + print(f" Slot 2 (initcode): 0x{stored_initcode_addr.hex()}") + print(f" Hash matches: {stored_hash == initcode_hash}") + + return factory_address, initcode_hash + + +def test_getconfig(w3: Web3, factory_address: str, expected_hash: bytes) -> bool: + """Test the getConfig() method of a factory.""" + print(f"Testing getConfig() on factory at {factory_address}...") + + # Call getConfig() with empty calldata + result = w3.eth.call({ + "to": factory_address, + "data": "" # Empty calldata triggers getConfig + }) + + if len(result) != 64: + print(f"❌ Unexpected result length: {len(result)} (expected 64)") + return False + + # Parse the result + num_deployed = int.from_bytes(result[:32], 'big') + returned_hash = result[32:64] + + print(f" Number of deployed contracts: {num_deployed}") + print(f" Init code hash: 0x{returned_hash.hex()}") + print(f" Hash matches expected: {returned_hash == expected_hash}") + + return returned_hash == expected_hash + + +def main(): + """Deploy factories for all contract sizes.""" + import argparse + + parser = argparse.ArgumentParser(description='Deploy CREATE2 factories for multiple sizes') + parser.add_argument('--rpc-url', default='http://127.0.0.1:8545', help='RPC URL') + parser.add_argument('--initcode-file', default='initcode_addresses.json', + help='Path to initcode addresses JSON file') + parser.add_argument('--output', default='stubs.json', + help='Output file for factory addresses (default: stubs.json)') + args = parser.parse_args() + + # Connect to local geth instance + w3 = Web3(Web3.HTTPProvider(args.rpc_url)) + if not w3.is_connected(): + print(f"❌ Failed to connect to {args.rpc_url}") + sys.exit(1) + + print(f"Connected to: {args.rpc_url}") + print(f"Account: {w3.eth.accounts[0]}") + + # Load initcode addresses + try: + with open(args.initcode_file, 'r') as f: + initcode_data = json.load(f) + except FileNotFoundError: + print(f"❌ {args.initcode_file} not found") + print("Run deploy_initcode_multi.py first") + sys.exit(1) + + # Deploy factory for each size + stubs = {} + for key, initcode_info in initcode_data.items(): + size_kb = initcode_info["size_kb"] + factory_address, initcode_hash = deploy_factory(w3, size_kb, initcode_info) + + if factory_address: + # Test getConfig + if test_getconfig(w3, factory_address, initcode_hash): + print(f"✅ Factory for {size_kb}KB working correctly") + + # Add to stubs with descriptive key + stub_key = f"bloatnet_factory_{key}" + stubs[stub_key] = factory_address + + # Save stubs to file + if stubs: + with open(args.output, 'w') as f: + json.dump(stubs, f, indent=2) + print(f"\n✅ All factory addresses saved to {args.output}") + + # Print summary + print("\n=== Factory Summary ===") + for stub_key, address in stubs.items(): + print(f"{stub_key}: {address}") + else: + print("\n❌ No factories deployed successfully") + sys.exit(1) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scenarios/statebloat/extcodesize_setup_deployment/deploy_initcode_multi.py b/scenarios/statebloat/extcodesize_setup_deployment/deploy_initcode_multi.py new file mode 100644 index 0000000..96e4f47 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_deployment/deploy_initcode_multi.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +""" +Deploy multiple initcode contracts for different bytecode sizes for BloatNet benchmarks. + +This script deploys initcode contracts that will be used by CREATE2 factories +to create contracts of different sizes (0.5, 1, 2, 5, 10, 24 KB). + +USAGE: + 1. Start a local geth instance: + geth --dev --http --http.api eth,web3,net,debug --http.corsdomain "*" + + 2. Run this script to deploy all initcode contracts: + python3 deploy_initcode_multi.py + + 3. The initcode addresses will be saved to initcode_addresses.json + +REQUIREMENTS: + - web3.py + - eth-utils + - ethereum-test-tools (for Opcodes) + - Local geth instance running on http://127.0.0.1:8545 +""" + +import sys +import json +from pathlib import Path +from typing import Dict, Any + +# Add path to execution-spec-tests if needed +# sys.path.insert(0, "/path/to/execution-spec-tests") + +from execution_testing import Op, While +from eth_utils import keccak +from web3 import Web3 + +# Contract size configurations (in KB) +CONTRACT_SIZES_KB = [0.5, 1, 2, 5, 10, 24] + +# Maximum contract size in bytes (24 KB) +MAX_CONTRACT_SIZE = 24576 + +def build_initcode(target_size_kb: float) -> bytes: + """ + Build initcode that generates contracts of specific size using ADDRESS for randomness. + + Args: + target_size_kb: Target contract size in kilobytes + + Returns: + The initcode bytecode that will generate a contract of the specified size + """ + target_size = int(target_size_kb * 1024) + + if target_size > MAX_CONTRACT_SIZE: + target_size = MAX_CONTRACT_SIZE + + # For small contracts (< 1KB), use simple padding + if target_size < 1024: + initcode = ( + # Store deployer address for uniqueness + Op.MSTORE(0, Op.ADDRESS) + # Pad with JUMPDEST opcodes (1 byte each) + + Op.JUMPDEST * max(0, target_size - 33 - 10) # Account for other opcodes + # Ensure first byte is STOP + + Op.MSTORE8(0, 0x00) + # Return the contract + + Op.RETURN(0, target_size) + ) + else: + # For larger contracts, use the keccak256 expansion pattern + # Generate XOR table for expansion + xor_table_size = min(256, target_size // 256) + xor_table = [keccak(i.to_bytes(32, "big")) for i in range(xor_table_size)] + + initcode = ( + # Store ADDRESS as initial seed - creates uniqueness per deployment + Op.MSTORE(0, Op.ADDRESS) + # Loop to expand bytecode using SHA3 and XOR operations + + While( + body=( + Op.SHA3(Op.SUB(Op.MSIZE, 32), 32) + # Use XOR table to expand without excessive SHA3 calls + + sum( + (Op.PUSH32(xor_value) + Op.XOR + Op.DUP1 + Op.MSIZE + Op.MSTORE) + for xor_value in xor_table + ) + + Op.POP + ), + condition=Op.LT(Op.MSIZE, target_size), + ) + # Set first byte to STOP for efficient CALL handling + + Op.MSTORE8(0, 0x00) + # Return the full contract + + Op.RETURN(0, target_size) + ) + + return bytes(initcode) + +def deploy_initcode(w3: Web3, size_kb: float) -> Dict[str, Any]: + """Deploy an initcode contract for a specific size.""" + account = w3.eth.accounts[0] + + print(f"\n--- Building initcode for {size_kb}KB contracts ---") + initcode_bytes = build_initcode(size_kb) + print(f"Initcode size: {len(initcode_bytes)} bytes") + + # Calculate the hash for verification + initcode_hash = keccak(initcode_bytes) + print(f"Initcode hash: 0x{initcode_hash.hex()}") + + # Deploy the initcode as a contract + # We need to deploy the raw initcode bytecode without executing it + # To do this, we create deployment code that just returns the initcode + print(f"Deploying initcode contract for {size_kb}KB...") + + # Create simple deployment bytecode that returns the initcode as-is + deployment_code = ( + # CODECOPY(destOffset=0, offset=codesize_of_prefix, size=initcode_size) + bytes(Op.PUSH2(len(initcode_bytes))) # Push initcode size (3 bytes) + + bytes(Op.DUP1) # Duplicate for RETURN (1 byte) + + bytes(Op.PUSH1(0x0c)) # Offset after this prefix (2 bytes) + + bytes(Op.PUSH1(0)) # Dest offset (2 bytes) + + bytes(Op.CODECOPY) # Copy initcode (1 byte) + # RETURN(offset=0, size=initcode_size) + + bytes(Op.PUSH1(0)) # Offset (2 bytes) + + bytes(Op.RETURN) # Return (1 byte) = Total: 12 bytes (0x0c) + + initcode_bytes # Actual initcode + ) + + # Deploy the contract + tx_hash = w3.eth.send_transaction({ + "from": account, + "data": "0x" + deployment_code.hex(), + "gas": 16_000_000 # Fusaka tx gas limit (16M) + }) + receipt = w3.eth.wait_for_transaction_receipt(tx_hash) + + if receipt['status'] != 1: + print(f"❌ Failed to deploy initcode for {size_kb}KB") + return None + + initcode_address = receipt['contractAddress'] + print(f"✅ Initcode deployed at: {initcode_address}") + + # Verify the deployed bytecode + deployed_code = w3.eth.get_code(initcode_address) + print(f"Deployed bytecode size: {len(deployed_code)} bytes") + + # Verify hash + actual_hash = keccak(deployed_code) + print(f"Actual hash: 0x{actual_hash.hex()}") + + if actual_hash == initcode_hash: + print(f"✅ Hash verification successful") + else: + print(f"⚠️ Hash mismatch! Expected: 0x{initcode_hash.hex()}") + + return { + "size_kb": size_kb, + "address": initcode_address, + "hash": "0x" + initcode_hash.hex(), + "bytecode_size": len(initcode_bytes) + } + +def main(): + """Deploy all initcode contracts for different sizes.""" + import argparse + + parser = argparse.ArgumentParser(description='Deploy initcode contracts for multiple sizes') + parser.add_argument('--rpc-url', default='http://127.0.0.1:8545', help='RPC URL') + parser.add_argument('--sizes', nargs='+', type=float, + help='Contract sizes in KB (default: 0.5 1 2 5 10 24)') + args = parser.parse_args() + + # Use custom sizes if provided + sizes = args.sizes if args.sizes else CONTRACT_SIZES_KB + + # Connect to local geth instance + w3 = Web3(Web3.HTTPProvider(args.rpc_url)) + if not w3.is_connected(): + print(f"❌ Failed to connect to {args.rpc_url}") + sys.exit(1) + + print(f"Connected to: {args.rpc_url}") + print(f"Account: {w3.eth.accounts[0]}") + + # Deploy initcode for each size + results = {} + for size_kb in sizes: + result = deploy_initcode(w3, size_kb) + if result: + # Use string key for JSON compatibility + key = f"{size_kb}kb".replace(".", "_") + results[key] = result + + # Save all results to file + if results: + output_file = "initcode_addresses.json" + with open(output_file, "w") as f: + json.dump(results, f, indent=2) + print(f"\n✅ All initcode addresses saved to {output_file}") + + # Print summary + print("\n=== Summary ===") + for key, info in results.items(): + print(f"{info['size_kb']}KB: {info['address']} (hash: {info['hash'][:10]}...)") + else: + print("\n❌ No initcode contracts deployed successfully") + sys.exit(1) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_0_5kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_0_5kb.yaml new file mode 100644 index 0000000..00757ce --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_0_5kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 0.5KB contracts' + seed: extcodesize-0_5kb + refill_amount: 10000 + refill_balance: 1000 + refill_interval: 20 + config: + contracts_per_size: 18100 + contract_sizes: [0.5] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "0_5kb": "0xBaA3F054b37A1813283D669cEE0178Bea1f0315D" + factories: + "0_5kb": "0xE19DA6B7c3716e79dccb84a591B2F36aF03487D5" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_10kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_10kb.yaml new file mode 100644 index 0000000..40d287e --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_10kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 10KB contracts' + config: + seed: extcodesize-10kb + refill_amount: "100000000000000000000000" + refill_balance: "10000000000000000000000" + refill_interval: 20 + contracts_per_size: 18100 + contract_sizes: [10] + max_wallets: 2 + max_pending: 20 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "10kb": "0x07f335C5B675ee692C2D57AC805EdA02A708078a" + factories: + "10kb": "0x401ef5eBd3F749B839e13363aDD39bb85Bb8B204" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_1kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_1kb.yaml new file mode 100644 index 0000000..a305f76 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_1kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 1KB contracts' + seed: extcodesize-1kb + refill_amount: 10000 + refill_balance: 1000 + refill_interval: 20 + config: + contracts_per_size: 18100 + contract_sizes: [1] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "1kb": "0xa6bA5cE65AAf34c487cb9948f3b570138B311c6b" + factories: + "1kb": "0x6bB03b0bB8b6528243912834D520FA71d77D420B" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_24kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_24kb.yaml new file mode 100644 index 0000000..1772468 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_24kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 24KB contracts' + config: + seed: extcodesize-24kb + refill_amount: "100000000000000000000000" + refill_balance: "10000000000000000000000" + refill_interval: 20 + contracts_per_size: 18100 + contract_sizes: [24] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "24kb": "0xab1A4c374822b9F4B3F847C13CcDC120E8654dc6" + factories: + "24kb": "0xa4a1aF502114DAA5856b6FBD849e14a535A69eE8" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_2kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_2kb.yaml new file mode 100644 index 0000000..c351af3 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_2kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 2KB contracts' + seed: extcodesize-2kb + refill_amount: 10000 + refill_balance: 1000 + refill_interval: 20 + config: + contracts_per_size: 18100 + contract_sizes: [2] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "2kb": "0x76Dda1f877AFa9A15E07F522B024BBD8Cec09426" + factories: + "2kb": "0x61b25103ff58A81c3079C23e57352a62f05d38dd" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_32kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_32kb.yaml new file mode 100644 index 0000000..4ba161d --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_32kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 32KB contracts' + config: + seed: extcodesize-32kb + refill_amount: "100000000000000000000000" + refill_balance: "10000000000000000000000" + refill_interval: 20 + contracts_per_size: 18100 + contract_sizes: [32] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "32kb": "0xe4EDc88E606Bf7fEfCe7DfF4cbBf38ccbFA2cd74" + factories: + "32kb": "0xFc7c3eda39Aa275fA0483942ba7e56195C7aE321" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_5kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_5kb.yaml new file mode 100644 index 0000000..c3c0b26 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_5kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 5KB contracts' + config: + seed: extcodesize-5kb + refill_amount: "100000000000000000000000" + refill_balance: "10000000000000000000000" + refill_interval: 20 + contracts_per_size: 18100 + contract_sizes: [5] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "5kb": "0x30Eb03600ccCecc09Bf28F8722b0Fb2d0E1B9e76" + factories: + "5kb": "0xa35C3fDdCa307786E74d657A6b4c8952db440076" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_64kb.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_64kb.yaml new file mode 100644 index 0000000..d6f80af --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_64kb.yaml @@ -0,0 +1,18 @@ +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy 64KB contracts' + config: + seed: extcodesize-64kb + refill_amount: "100000000000000000000000" + refill_balance: "10000000000000000000000" + refill_interval: 20 + contracts_per_size: 18100 + contract_sizes: [64] + max_wallets: 1 + max_pending: 50 + base_fee: 20 + tip_fee: 2 + predeployed: + initcode: + "64kb": "0x6094A50218E4dBEaCa9624063cb9DecBcb9A483b" + factories: + "64kb": "0xd7238974c4d3c3241a974b8e1A7C0b594a5d1e14" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all.sh b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all.sh new file mode 100755 index 0000000..3f3f243 --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all.sh @@ -0,0 +1,55 @@ +#!/bin/bash + +# Deploy all extcodesize contracts sequentially +# Usage: ./deploy_all.sh [RPC_URL] [PRIVATE_KEY] + +RPC_URL="${1:-http://localhost:8545}" +PRIVATE_KEY="${2:-0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +SPAMOOR_BIN="${SCRIPT_DIR}/../../../bin/spamoor" + +echo "=== EXTCODESIZE Contract Deployment ===" +echo "RPC: $RPC_URL" +echo "" + +# # Deploy 0.5KB contracts +# echo "[1/8] Deploying 0.5KB contracts..." +# $SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_0_5kb.yaml" +# echo "" + +# # Deploy 1KB contracts +# echo "[2/8] Deploying 1KB contracts..." +# $SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_1kb.yaml" +# echo "" + +# # Deploy 2KB contracts +# echo "[3/8] Deploying 2KB contracts..." +# $SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_2kb.yaml" +# echo "" + +# Deploy 5KB contracts +echo "[4/8] Deploying 5KB contracts..." +$SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_5kb.yaml" +echo "" + +# Deploy 10KB contracts +echo "[5/8] Deploying 10KB contracts..." +$SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_10kb.yaml" +echo "" + +# Deploy 24KB contracts +echo "[6/8] Deploying 24KB contracts..." +$SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_24kb.yaml" +echo "" + +# Deploy 32KB contracts +echo "[7/8] Deploying 32KB contracts..." +$SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_32kb.yaml" +echo "" + +# Deploy 64KB contracts +echo "[8/8] Deploying 64KB contracts..." +$SPAMOOR_BIN run -h "$RPC_URL" -p "$PRIVATE_KEY" "$SCRIPT_DIR/deploy_64kb.yaml" +echo "" + +echo "=== All deployments complete ===" diff --git a/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all_infra.yaml b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all_infra.yaml new file mode 100644 index 0000000..eb39b3f --- /dev/null +++ b/scenarios/statebloat/extcodesize_setup_mainnet/deploy_all_infra.yaml @@ -0,0 +1,12 @@ +# Name: EXTCODESIZE Infrastructure Deployment (Mainnet) +# Description: Deploy all initcode and factory contracts for all sizes (0.5kb to 64kb) + +- scenario: extcodesize_setup + name: '[EXTCODESIZE] Deploy all infrastructure' + seed: extcodesize-infra-all + config: + contracts_per_size: 0 + contract_sizes: [0.5, 1, 2, 5, 10, 24, 32, 64] + max_wallets: 1 + base_fee: 20 + tip_fee: 2 diff --git a/scenarios/statebloat/storage_trie_brancher/README.md b/scenarios/statebloat/storage_trie_brancher/README.md new file mode 100644 index 0000000..1c12e03 --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher/README.md @@ -0,0 +1,203 @@ +# Depth Benchmark Tests + +This directory contains tests for worst-case depth attacks on Ethereum state and account tries. + +## Scenario Description + +These benchmarks test the worst-case scenario for Ethereum clients when dealing with extremely deep state and account tries. The attack involves: + +1. **Pre-deployed contracts** with deep storage tries that maximize trie traversal costs +2. **CREATE2-based addressing** for deterministic contract addresses across test runs +3. **Optimized batched attacks** using an AttackOrchestrator contract that can execute up to 2,510 attacks per transaction (8.3x improvement over previous implementation) +4. **Account trie depth** increased by funding auxiliary accounts that make the path deeper + +The test measures the performance impact of state root recomputation and IO when modifying deep storage slots across thousands of contracts, simulating the maximum theoretical load on the state trie. + +For complete deployment setup and instructions, see the gist: https://gist.github.com/CPerezz/44d521c0f9e6adf7d84187a4f2c11978 + +## Prerequisites + +- Python with `uv` package manager +- Anvil (Ethereum node implementation) +- Solc (Solidity compiler) +- Nick's factory deployed at `0x4e59b44847b379578588920ca78fbf26c0b4956c` + +## Workflow + +### Step 1: Generate Artifacts + +Use [worst_case_miner](https://github.com/CPerezz/worst_case_miner) to generate the necessary artifacts: + +```bash +# Clone and build worst_case_miner +git clone https://github.com/CPerezz/worst_case_miner +cd worst_case_miner +cargo build --release + +# Generate artifacts (example for depth 9, account depth 3) +./target/release/worst_case_miner --storage-depth 9 --account-depth 3 --output s9_acc3.json +``` + +This generates: +- `depth_9.sol` - Solidity contract with deep storage trie +- `s9_acc3.json` - Pre-computed CREATE2 addresses and auxiliary accounts + +### Step 2: Start the Node (Anvil in this example) + +```bash +# Start Anvil with high gas limit and auto-mining +anvil --hardfork prague --block-time 6 --steps-tracing --gas-limit 500000000 --balance 99999999999999 --port 8545 +``` + +### Step 3: Deploy Contracts + +Deploy contracts using the provided script with batched transactions: + +```bash +# Deploy 1,000 contracts (recommended for testing) +uv run python deploy_worst_case_contracts.py \ + --rpc-url http://localhost:8546 \ + --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --storage-depth 9 \ + --account-depth 3 \ + --num-contracts 1000 \ + --output deployed_contracts.json + + +The script: +- Funds auxiliary accounts in batches (3 accounts per contract) +- Deploys contracts via CREATE2 for deterministic addresses +- Dynamically calculates batch sizes based on network gas limit + +### Step 4: Run Attack Test + +Execute the worst-case depth attack test: + +```bash +# Update NUM_CONTRACTS in deep_branch_testing.py to match deployed count (1000 or 15000) + +# Run the attack test +uv run execute remote \ + --rpc-endpoint=http://localhost:8546 \ + --rpc-seed-key=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --rpc-chain-id=31337 \ + --gas-benchmark-values 60 \ + --fork Prague \ + -m stateful \ + deep_branch_testing.py::test_worst_depth_stateroot_recomp +``` + +## Spamoor Scenario Usage + +### Command Line Usage + +```bash +./bin/spamoor storage-trie-brancher \ + --count 1000 \ + --storage-depth 10 \ + --account-depth 5 \ + --data-file "https://example.com/s10_acc5.json" \ + --bytecode "https://example.com/depth_10.bin" \ + --rpchost http://localhost:8545 \ + --privkey 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --seed "test-seed" \ + --basefee 20 \ + --tipfee 2 \ + --max-wallets 50 +``` + +Note: Both `--data-file` and `--bytecode` are required parameters and can be: +- Local file paths +- HTTP/HTTPS URLs +- For bytecode: direct hex string (e.g., "0x608060...") + +### YAML Configuration Example + +Create a file `storage_trie_brancher_config.yaml`: + +```yaml +scenarios: + - name: storage-trie-brancher + config: + # Number of contracts to deploy + total_contracts: 1000 + + # Storage trie depth (9 or 10) + storage_depth: 10 + + # Account trie depth (3, 4, or 5) + account_depth: 5 + + # Maximum number of wallets for parallel execution + max_wallets: 50 + + # Skip contract deployment (only fund EOAs) + skip_contracts: false + + # Skip EOA funding (only deploy contracts) + skip_funding: false + + # Path or URL to CREATE2 data JSON file (required) + # Can be a local file path or HTTP/HTTPS URL + data_file: "https://raw.githubusercontent.com/example/repo/main/s10_acc5.json" + + # Contract bytecode (required) + # Can be: + # - Direct hex string: "0x608060405260..." + # - Local file path: "./bytecode.bin" + # - URL: "https://raw.githubusercontent.com/example/repo/main/depth_10.bin" + bytecode: "https://raw.githubusercontent.com/example/repo/main/depth_10.bin" + + # Gas settings (in gwei) + base_fee: 20 + tip_fee: 2 + + # Client group for transaction routing (optional) + client_group: "" + + # Log all submitted transactions + log_txs: true +``` + +Run with the YAML config: + +```bash +# Using spamoor directly with config file +./bin/spamoor storage-trie-brancher \ + --config storage_trie_brancher_config.yaml \ + --rpchost http://localhost:8545 \ + --privkey 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --seed "test-seed" + +# Or using spamoor-daemon for web interface +./bin/spamoor-daemon \ + --rpchost http://localhost:8545 \ + --privkey 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --scenario-file storage_trie_brancher_config.yaml +``` + +### Using External URLs + +The scenario supports loading files from external sources: + +```yaml +scenarios: + - name: storage-trie-brancher + config: + total_contracts: 5000 + storage_depth: 10 + account_depth: 5 + max_wallets: 100 + + # Load from GitHub raw URLs or any HTTP server + data_file: "https://raw.githubusercontent.com/CPerezz/worst-case-artifacts/main/s10_acc5.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst-case-artifacts/main/depth_10.bin" + + base_fee: 20 + tip_fee: 2 + log_txs: true +``` + +## Configuration + +Adjust `NUM_CONTRACTS` in `deep_branch_testing.py` to match your deployment: diff --git a/scenarios/statebloat/storage_trie_brancher/deploy_deep_branches.py b/scenarios/statebloat/storage_trie_brancher/deploy_deep_branches.py new file mode 100644 index 0000000..27e0a12 --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher/deploy_deep_branches.py @@ -0,0 +1,466 @@ +#!/usr/bin/env python3 +""" +Deploy worst-case attack contracts to an Ethereum node. + +This script deploys X WorstCaseERC20.sol contracts using Nick's factory method, +funds auxiliary accounts, and saves all deployed addresses to a JSON file. + +Usage: + python deploy_worst_case_contracts.py --rpc-url http://localhost:8546 \ + --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80 \ + --storage-depth 9 --account-depth 3 --num-contracts 15000 + +The script will: +1. Load CREATE2 salt data from s9_acc3.json (or similar) +2. Deploy all contracts via Nick's factory +3. Fund auxiliary accounts for trie depth +4. Save deployed addresses to deployed_contracts.json +""" + +import argparse +import json +import sys +import time +from pathlib import Path +from typing import Dict, List, Any +from eth_account import Account +from web3 import Web3 +from web3.types import TxParams, HexBytes +from eth_utils import keccak, to_checksum_address +import subprocess + +# Nick's factory address +NICK_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c" + +# Gas settings +MAX_GAS_PER_TX = 16_000_000 # Fusaka limit +DEPLOY_GAS_LIMIT = 3_000_000 # Gas for deploying one contract +FUND_GAS_LIMIT = 21_000 # Gas for funding accounts + +def compile_contract(storage_depth: int, account_depth: int) -> bytes: + """Compile the depth contract and return init bytecode.""" + sol_path = Path(f"depth_{storage_depth}.sol") + if not sol_path.exists(): + raise FileNotFoundError(f"Contract file not found: {sol_path}") + + print(f"Compiling {sol_path}...") + + # Compile to get init code (with constructor) + # MUST use same flags as pre-mining to get matching bytecode + result = subprocess.run( + [ + "solc", + "--bin", + "--optimize", + "--optimize-runs", "200", + "--metadata-hash", "none", # Critical for reproducible bytecode + str(sol_path) + ], + capture_output=True, + text=True + ) + + if result.returncode != 0: + raise Exception(f"Failed to compile: {result.stderr}") + + # Extract bytecode from solc output + lines = result.stdout.split('\n') + init_code_hex = None + in_binary_section = False + for line in lines: + if "Binary:" in line: + in_binary_section = True + elif in_binary_section and line.strip() and not line.startswith("="): + init_code_hex = line.strip() + break + + if init_code_hex.startswith("0x"): + init_code_hex = init_code_hex[2:] + + return bytes.fromhex(init_code_hex) + +def load_create2_data(storage_depth: int, account_depth: int) -> Dict: + """Load pre-mined CREATE2 salt data.""" + filename = f"s{storage_depth}_acc{account_depth}.json" + filepath = Path(filename) + + if not filepath.exists(): + raise FileNotFoundError(f"CREATE2 data file not found: {filename}") + + with open(filepath, 'r') as f: + return json.load(f) + +def calculate_create2_address(deployer: str, salt: bytes, init_code: bytes) -> str: + """Calculate CREATE2 address.""" + init_code_hash = keccak(init_code) + create2_input = ( + bytes.fromhex("ff") + + bytes.fromhex(deployer[2:]) + + salt + + init_code_hash + ) + addr = keccak(create2_input)[-20:] + return to_checksum_address("0x" + addr.hex()) + +def deploy_via_nick_factory( + w3: Web3, + account: Account, + init_code: bytes, + salt: bytes, + nonce: int +) -> tuple[str, int]: + """Deploy contract via Nick's factory.""" + # Call Nick's factory with salt + init_code + factory_data = salt + init_code + + tx: TxParams = { + 'from': account.address, + 'to': to_checksum_address(NICK_FACTORY), + 'data': factory_data, + 'gas': DEPLOY_GAS_LIMIT, + 'gasPrice': w3.eth.gas_price, + 'nonce': nonce, + } + + signed_tx = account.sign_transaction(tx) + tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction) + + # Calculate deployed address + deployed_addr = calculate_create2_address(NICK_FACTORY, salt, init_code) + + return deployed_addr, nonce + 1 + +def fund_account( + w3: Web3, + account: Account, + recipient: str, + amount: int, + nonce: int +) -> int: + """Fund an account with specified amount.""" + tx: TxParams = { + 'from': account.address, + 'to': to_checksum_address(recipient), + 'value': amount, + 'gas': FUND_GAS_LIMIT, + 'gasPrice': w3.eth.gas_price, + 'nonce': nonce, + } + + signed_tx = account.sign_transaction(tx) + w3.eth.send_raw_transaction(signed_tx.raw_transaction) + + return nonce + 1 + +def batch_transactions(transactions: List[Any], batch_size: int = 100): + """Batch transactions to avoid overwhelming the RPC.""" + for i in range(0, len(transactions), batch_size): + yield transactions[i:i + batch_size] + +def main(): + parser = argparse.ArgumentParser(description='Deploy worst-case attack contracts') + parser.add_argument('--rpc-url', default='http://localhost:8546', help='RPC endpoint URL (can include auth like https://user:pass@host)') + parser.add_argument('--private-key', required=True, help='Private key for deployment') + parser.add_argument('--storage-depth', type=int, default=9, help='Storage depth') + parser.add_argument('--account-depth', type=int, default=3, help='Account depth') + parser.add_argument('--num-contracts', type=int, default=15000, help='Number of contracts to deploy') + parser.add_argument('--output', default='deployed_contracts.json', help='Output JSON file') + parser.add_argument('--skip-contracts', action='store_true', help='Skip contract deployment (only fund EOAs)') + parser.add_argument('--skip-funding', action='store_true', help='Skip EOA funding (only deploy contracts)') + + args = parser.parse_args() + + # Validate arguments + if args.skip_contracts and args.skip_funding: + print("Error: Cannot skip both contracts and funding. Nothing to do!") + sys.exit(1) + + # Connect to node - HTTPProvider automatically handles basic auth in URL + print(f"Connecting to RPC endpoint...") + # Mask credentials in output + display_url = args.rpc_url + if '@' in display_url: + # Extract and mask the auth part + protocol_end = display_url.find('://') + 3 + auth_end = display_url.find('@', protocol_end) + if auth_end > protocol_end: + masked_url = display_url[:protocol_end] + '***:***@' + display_url[auth_end+1:] + print(f" URL: {masked_url}") + else: + print(f" URL: {display_url}") + + w3 = Web3(Web3.HTTPProvider(args.rpc_url)) + + if not w3.is_connected(): + print("Failed to connect to Ethereum node") + sys.exit(1) + + # Setup account + account = Account.from_key(args.private_key) + print(f"Deploying from account: {account.address}") + + balance = w3.eth.get_balance(account.address) + print(f"Account balance: {Web3.from_wei(balance, 'ether')} ETH") + + if balance == 0: + print("\nWARNING: Account has 0 ETH balance!") + print("You need to fund this account before deploying contracts or funding EOAs.") + print(f"Send ETH to: {account.address}") + response = input("\nDo you want to continue anyway? (y/n): ") + if response.lower() != 'y': + print("Exiting...") + sys.exit(1) + + # Load CREATE2 data + print(f"\nLoading CREATE2 data for depth {args.storage_depth}, account depth {args.account_depth}...") + create2_data = load_create2_data(args.storage_depth, args.account_depth) + contracts = create2_data.get("contracts", [])[:args.num_contracts] + + if len(contracts) < args.num_contracts: + print(f"Warning: Only {len(contracts)} contracts available in data file") + + # We always need to compile or know the init code to calculate addresses + if not args.skip_contracts: + print(f"Will deploy {len(contracts)} contracts") + else: + print("Skipping contract deployment (--skip-contracts flag set)") + + # Compile contract (needed for address calculation even if skipping deployment) + init_code = compile_contract(args.storage_depth, args.account_depth) + print(f"Contract init code size: {len(init_code)} bytes") + + # Get starting nonce + nonce = w3.eth.get_transaction_count(account.address) + print(f"Starting nonce: {nonce}") + + # Deployed contracts info + deployed_info = { + "storage_depth": args.storage_depth, + "account_depth": args.account_depth, + "deployer": account.address, + "nick_factory": NICK_FACTORY, + "contracts": [] + } + + # Phase 1: Fund auxiliary accounts + funded_count = 0 + total_aux_accounts = 0 + + if not args.skip_funding: + print("\n=== Phase 1: Funding Auxiliary Accounts ===") + + # Collect all unique auxiliary accounts to fund + aux_accounts_to_fund = set() + for contract_data in contracts: + auxiliary_accounts = contract_data.get("auxiliary_accounts", []) + aux_accounts_to_fund.update(auxiliary_accounts) + + total_aux_accounts = len(aux_accounts_to_fund) + print(f"Total unique auxiliary accounts to fund: {total_aux_accounts}") + + # Calculate batch size for funding transactions + # Simple transfers use about 21,000 gas each + FUND_GAS_LIMIT = 21000 + latest_block = w3.eth.get_block('latest') + network_gas_limit = latest_block['gasLimit'] + print(f"Network gas limit: {network_gas_limit:,}") + + # Target 50% of network gas limit for funding batches + target_gas_per_batch = network_gas_limit // 2 + funding_batch_size = max(1, target_gas_per_batch // FUND_GAS_LIMIT) + print(f"Calculated funding batch size: {funding_batch_size} accounts per batch") + + # Convert set to list for batching + aux_accounts_list = list(aux_accounts_to_fund) + + # Process funding in batches + for batch_num, batch_start in enumerate(range(0, len(aux_accounts_list), funding_batch_size)): + batch = aux_accounts_list[batch_start:batch_start + funding_batch_size] + print(f"\nFunding batch {batch_num + 1} ({len(batch)} accounts)...") + + tx_hashes = [] + batch_start_nonce = nonce + + # Send all funding transactions in the batch + for aux_account in batch: + try: + tx = { + 'from': account.address, + 'to': to_checksum_address(aux_account), + 'value': 1, # 1 wei to create the account + 'gas': FUND_GAS_LIMIT, + 'gasPrice': w3.eth.gas_price, + 'nonce': nonce, + 'chainId': w3.eth.chain_id, # Add EIP-155 replay protection + } + signed = account.sign_transaction(tx) + tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction) + tx_hashes.append(tx_hash) + nonce += 1 + except Exception as e: + print(f" Error funding {aux_account}: {e}") + # Try to get more details about the error + if "invalid fields" in str(e): + print(f" Debug: Original address: {aux_account}") + print(f" Debug: Checksummed: {to_checksum_address(aux_account)}") + # Only show first few errors in detail + if batch.index(aux_account) < 3: + print(f" Debug: Full tx: {tx}") + + # Wait for all transactions in batch to be mined + if tx_hashes: + print(f" Waiting for {len(tx_hashes)} funding transactions to be mined...") + for tx_hash in tx_hashes: + try: + receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60) + if receipt.status == 1: + funded_count += 1 + else: + print(f" Funding transaction failed: {tx_hash.hex()}") + except Exception as e: + print(f" Error waiting for funding tx receipt: {e}") + + print(f" Funded {funded_count}/{total_aux_accounts} accounts so far") + + print(f"\nTotal auxiliary accounts funded: {funded_count}") + else: + print("\n=== Phase 1: Skipping EOA Funding (--skip-funding flag set) ===") + + # Phase 2: Deploy contracts via Nick's factory + if not args.skip_contracts: + print("\n=== Phase 2: Deploying Contracts ===") + + # Get the network gas limit + latest_block = w3.eth.get_block('latest') + network_gas_limit = latest_block['gasLimit'] + print(f"Network gas limit: {network_gas_limit:,}") + + # Calculate batch size: target 50% of network gas limit + # Each deployment uses approximately DEPLOY_GAS_LIMIT + target_gas_per_batch = network_gas_limit // 2 # Use 50% of gas limit + batch_size = max(1, target_gas_per_batch // DEPLOY_GAS_LIMIT) + print(f"Calculated batch size: {batch_size} contracts per batch (targeting 50% of gas limit)") + + for batch_num, batch in enumerate(batch_transactions(contracts, batch_size)): + print(f"\nDeploying batch {batch_num + 1} ({len(batch)} contracts)...") + + batch_start_nonce = nonce + deployed_in_batch = [] + tx_hashes = [] + + # Send all transactions in the batch + for contract_data in batch: + salt = contract_data["salt"] + + # Convert salt to bytes + if isinstance(salt, int): + salt_bytes = salt.to_bytes(32, 'big') + else: + salt_bytes = bytes.fromhex(salt[2:] if salt.startswith("0x") else salt) + + # Deploy via Nick's factory + try: + # Call Nick's factory with salt + init_code + factory_data = salt_bytes + init_code + tx: TxParams = { + 'from': account.address, + 'to': to_checksum_address(NICK_FACTORY), + 'data': factory_data, + 'gas': DEPLOY_GAS_LIMIT, + 'gasPrice': w3.eth.gas_price, + 'nonce': nonce, + 'chainId': w3.eth.chain_id, # Add EIP-155 replay protection + } + + signed_tx = account.sign_transaction(tx) + tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction) + tx_hashes.append(tx_hash) + + # Calculate deployed address + deployed_addr = calculate_create2_address(NICK_FACTORY, salt_bytes, init_code) + + # Store deployed info + contract_info = { + "address": deployed_addr, + "salt": "0x" + salt_bytes.hex(), + "auxiliary_accounts": contract_data.get("auxiliary_accounts", []) + } + deployed_info["contracts"].append(contract_info) + deployed_in_batch.append(deployed_addr) + + nonce += 1 + + except Exception as e: + print(f" Error sending deployment tx: {e}") + continue + + # Wait for all transactions in batch to be mined + if tx_hashes: + print(f" Waiting for {len(tx_hashes)} transactions to be mined...") + for tx_hash in tx_hashes: + try: + receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60) + if receipt.status == 0: + print(f" Transaction failed: {tx_hash.hex()}") + except Exception as e: + print(f" Error waiting for tx receipt: {e}") + + # Verify deployments + verified = 0 + for addr in deployed_in_batch: + code = w3.eth.get_code(addr) + if len(code) > 0: + verified += 1 + + print(f" Verified {verified}/{len(deployed_in_batch)} contracts deployed") + + # Progress update + total_deployed = len(deployed_info["contracts"]) + print(f"Total progress: {total_deployed}/{len(contracts)} contracts deployed") + else: + print("\n=== Phase 2: Skipping Contract Deployment (--skip-contracts flag set) ===") + # When skipping contracts, populate deployed_info with pre-calculated addresses + for contract_data in contracts: + salt = contract_data["salt"] + # Convert salt to bytes + if isinstance(salt, int): + salt_bytes = salt.to_bytes(32, 'big') + else: + salt_bytes = bytes.fromhex(salt[2:] if salt.startswith("0x") else salt) + + # Calculate what the deployed address would be + deployed_addr = calculate_create2_address(NICK_FACTORY, salt_bytes, init_code) + + contract_info = { + "address": deployed_addr, + "salt": "0x" + salt_bytes.hex(), + "auxiliary_accounts": contract_data.get("auxiliary_accounts", []) + } + deployed_info["contracts"].append(contract_info) + + # Save deployed contracts info + print(f"\n=== Saving Deployment Info ===") + output_path = Path(args.output) + with open(output_path, 'w') as f: + json.dump(deployed_info, f, indent=2) + + print(f"Deployment info saved to: {output_path}") + + # Also save just the contract addresses to stubs.json + stubs_path = Path("stubs.json") + contract_addresses = [contract["address"] for contract in deployed_info["contracts"]] + with open(stubs_path, 'w') as f: + json.dump(contract_addresses, f, indent=2) + + print(f"Contract addresses saved to: {stubs_path}") + print(f"\nOperation complete!") + if not args.skip_contracts: + print(f" Total contracts deployed: {len(deployed_info['contracts'])}") + else: + print(f" Total contract addresses calculated: {len(deployed_info['contracts'])}") + if not args.skip_funding: + print(f" Total auxiliary accounts funded: {funded_count}") + print(f" Final nonce: {nonce}") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go b/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go new file mode 100644 index 0000000..b791020 --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go @@ -0,0 +1,800 @@ +package storagetriebrancher + +import ( + "context" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "math/big" + "net/http" + "os" + "strings" + "sync" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/holiman/uint256" + "github.com/sirupsen/logrus" + "github.com/spf13/pflag" + + "github.com/ethpandaops/spamoor/scenario" + "github.com/ethpandaops/spamoor/spamoor" + "github.com/ethpandaops/spamoor/txbuilder" +) + +const ( + // Nick's factory address for CREATE2 deployments + NickFactoryAddress = "0x4e59b44847b379578588920ca78fbf26c0b4956c" + + // Gas limits + DeployGasLimit = 3000000 + FundGasLimit = 21000 + + // Funding amount for auxiliary accounts (1 wei to create the account) + FundingAmount = 1 +) + +type ScenarioOptions struct { + TotalContracts uint64 `yaml:"total_contracts"` + StorageDepth uint64 `yaml:"storage_depth"` + AccountDepth uint64 `yaml:"account_depth"` + MaxWallets uint64 `yaml:"max_wallets"` + SkipContracts bool `yaml:"skip_contracts"` + SkipFunding bool `yaml:"skip_funding"` + DataFile string `yaml:"data_file"` + Bytecode string `yaml:"bytecode"` // Bytecode hex string (or path/URL to bytecode file) + BaseFee float64 `yaml:"base_fee"` + TipFee float64 `yaml:"tip_fee"` + ClientGroup string `yaml:"client_group"` + LogTxs bool `yaml:"log_txs"` +} + +type Scenario struct { + options ScenarioOptions + logger *logrus.Entry + walletPool *spamoor.WalletPool + + // Deployment data + deployData *DeploymentData + initCode []byte + deployments []DeploymentInfo + factoryAddress common.Address // Actual factory address (might differ from Nick's canonical address) + + // Progress tracking + fundedAccounts map[string]bool + deployedContracts map[string]bool + currentIndex uint64 + phase string // "funding" or "deploying" + mu sync.RWMutex +} + +type DeploymentData struct { + Deployer string `json:"deployer"` + InitCodeHash string `json:"init_code_hash"` + TargetDepth int `json:"target_depth"` + NumContracts int `json:"num_contracts"` + Contracts []ContractData `json:"contracts"` +} + +type ContractData struct { + Salt interface{} `json:"salt"` // Can be number or string + ContractAddress string `json:"contract_address"` + AuxiliaryAccounts []string `json:"auxiliary_accounts"` +} + +type DeploymentInfo struct { + Address string `json:"address"` + Salt string `json:"salt"` + AuxiliaryAccounts []string `json:"auxiliary_accounts"` +} + +var ScenarioName = "storage-trie-brancher" +var ScenarioDefaultOptions = ScenarioOptions{ + TotalContracts: 1000, + StorageDepth: 9, + AccountDepth: 3, + MaxWallets: 50, + SkipContracts: false, + SkipFunding: false, + DataFile: "", + Bytecode: "", + BaseFee: 20, + TipFee: 2, + ClientGroup: "", + LogTxs: false, +} + +var ScenarioDescriptor = scenario.Descriptor{ + Name: ScenarioName, + Description: "Deploy worst-case depth attack contracts (deep storage tries with auxiliary accounts)", + DefaultOptions: ScenarioDefaultOptions, + NewScenario: newScenario, +} + +func newScenario(logger logrus.FieldLogger) scenario.Scenario { + return &Scenario{ + options: ScenarioDefaultOptions, + logger: logger.WithField("scenario", ScenarioName), + fundedAccounts: make(map[string]bool), + deployedContracts: make(map[string]bool), + } +} + +func (s *Scenario) Flags(flags *pflag.FlagSet) error { + flags.Uint64VarP(&s.options.TotalContracts, "count", "c", ScenarioDefaultOptions.TotalContracts, "Total number of contracts to deploy") + flags.Uint64Var(&s.options.StorageDepth, "storage-depth", ScenarioDefaultOptions.StorageDepth, "Storage trie depth (9 or 10)") + flags.Uint64Var(&s.options.AccountDepth, "account-depth", ScenarioDefaultOptions.AccountDepth, "Account trie depth (3, 4, or 5)") + flags.Uint64Var(&s.options.MaxWallets, "max-wallets", ScenarioDefaultOptions.MaxWallets, "Maximum number of wallets to use for parallel execution") + flags.BoolVar(&s.options.SkipContracts, "skip-contracts", ScenarioDefaultOptions.SkipContracts, "Skip contract deployment (only fund EOAs)") + flags.BoolVar(&s.options.SkipFunding, "skip-funding", ScenarioDefaultOptions.SkipFunding, "Skip EOA funding (only deploy contracts)") + flags.StringVar(&s.options.DataFile, "data-file", ScenarioDefaultOptions.DataFile, "Path or URL to CREATE2 data JSON file (required)") + flags.StringVar(&s.options.Bytecode, "bytecode", ScenarioDefaultOptions.Bytecode, "Contract bytecode hex string or path/URL to bytecode file (required)") + flags.Float64Var(&s.options.BaseFee, "basefee", ScenarioDefaultOptions.BaseFee, "Max fee per gas (in gwei)") + flags.Float64Var(&s.options.TipFee, "tipfee", ScenarioDefaultOptions.TipFee, "Max tip per gas (in gwei)") + flags.StringVar(&s.options.ClientGroup, "client-group", ScenarioDefaultOptions.ClientGroup, "Client group to use for sending transactions") + flags.BoolVar(&s.options.LogTxs, "log-txs", ScenarioDefaultOptions.LogTxs, "Log all submitted transactions") + return nil +} + +func (s *Scenario) Init(options *scenario.Options) error { + s.walletPool = options.WalletPool + + if options.Config != "" { + // Use the generalized config validation and parsing helper + err := scenario.ParseAndValidateConfig(&ScenarioDescriptor, options.Config, &s.options, s.logger) + if err != nil { + return err + } + } + + // Validate options + if s.options.SkipContracts && s.options.SkipFunding { + return fmt.Errorf("cannot skip both contracts and funding - nothing to do") + } + + if s.options.TotalContracts == 0 { + return fmt.Errorf("total contracts must be greater than 0") + } + + // Set up wallets for parallel execution + // Use the configured MaxWallets, or default to 50 if not specified + if s.options.MaxWallets > 0 { + s.walletPool.SetWalletCount(s.options.MaxWallets) + } else { + s.walletPool.SetWalletCount(50) // Default fallback + } + + // Validate required parameters + if s.options.DataFile == "" { + return fmt.Errorf("data-file is required") + } + + if s.options.Bytecode == "" { + return fmt.Errorf("bytecode is required") + } + + // Load deployment data + if err := s.loadDeploymentData(); err != nil { + return fmt.Errorf("failed to load deployment data: %w", err) + } + + // Load bytecode + if err := s.loadBytecode(); err != nil { + return fmt.Errorf("failed to load bytecode: %w", err) + } + + s.logger.WithFields(logrus.Fields{ + "contracts": s.options.TotalContracts, + "storage_depth": s.options.StorageDepth, + "account_depth": s.options.AccountDepth, + "data_file": s.options.DataFile, + "bytecode_length": len(s.initCode), + }).Info("initialized storage trie brancher scenario") + + return nil +} + +// loadDataFromPathOrURL loads data from a file path or URL +func (s *Scenario) loadDataFromPathOrURL(pathOrURL string) ([]byte, error) { + if strings.HasPrefix(pathOrURL, "http://") || strings.HasPrefix(pathOrURL, "https://") { + // Load from URL + s.logger.WithField("url", pathOrURL).Debug("Loading data from URL") + resp, err := http.Get(pathOrURL) + if err != nil { + return nil, fmt.Errorf("failed to fetch URL: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP error: %s", resp.Status) + } + + data, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("failed to read response: %w", err) + } + return data, nil + } + + // Load from file + s.logger.WithField("file", pathOrURL).Debug("Loading data from file") + return os.ReadFile(pathOrURL) +} + +func (s *Scenario) loadDeploymentData() error { + data, err := s.loadDataFromPathOrURL(s.options.DataFile) + if err != nil { + return fmt.Errorf("failed to load data file: %w", err) + } + + s.deployData = &DeploymentData{} + if err := json.Unmarshal(data, s.deployData); err != nil { + return fmt.Errorf("failed to parse JSON data: %w", err) + } + + // Limit contracts to requested count + if uint64(len(s.deployData.Contracts)) > s.options.TotalContracts { + s.deployData.Contracts = s.deployData.Contracts[:s.options.TotalContracts] + } else if uint64(len(s.deployData.Contracts)) < s.options.TotalContracts { + s.logger.Warnf("Only %d contracts available in data file, requested %d", + len(s.deployData.Contracts), s.options.TotalContracts) + s.options.TotalContracts = uint64(len(s.deployData.Contracts)) + } + + return nil +} + +func (s *Scenario) loadBytecode() error { + bytecodeInput := s.options.Bytecode + + // Check if it's a file path or URL + if strings.HasPrefix(bytecodeInput, "http://") || strings.HasPrefix(bytecodeInput, "https://") || + strings.Contains(bytecodeInput, "/") || strings.HasSuffix(bytecodeInput, ".bin") { + // It's a path or URL, load from file/URL + s.logger.WithField("source", bytecodeInput).Debug("Loading bytecode from file/URL") + data, err := s.loadDataFromPathOrURL(bytecodeInput) + if err != nil { + return fmt.Errorf("failed to load bytecode file: %w", err) + } + bytecodeInput = string(data) + } + + // Clean up the bytecode hex string + bytecodeHex := strings.TrimSpace(bytecodeInput) + bytecodeHex = strings.TrimPrefix(bytecodeHex, "0x") + + // Decode hex string to bytes + var err error + s.initCode, err = hex.DecodeString(bytecodeHex) + if err != nil { + return fmt.Errorf("failed to decode bytecode hex: %w", err) + } + + if len(s.initCode) == 0 { + return fmt.Errorf("bytecode is empty") + } + + s.logger.Infof("Loaded bytecode, init code size: %d bytes", len(s.initCode)) + return nil +} + +func (s *Scenario) ensureNicksFactory(ctx context.Context) error { + s.logger.Info("Phase 2: Checking if Nick's factory exists") + + // Get a client to check factory existence + client := s.walletPool.GetClient(spamoor.WithClientGroup(s.options.ClientGroup)) + if client == nil { + return scenario.ErrNoClients + } + + // First check canonical Nick's factory address + canonicalAddr := common.HexToAddress(NickFactoryAddress) + code, err := client.GetEthClient().CodeAt(ctx, canonicalAddr, nil) + if err != nil { + return fmt.Errorf("failed to check factory existence: %w", err) + } + + if len(code) > 0 { + s.logger.Infof("Nick's factory already exists at canonical address %s", NickFactoryAddress) + s.factoryAddress = canonicalAddr + return nil + } + + s.logger.Infof("Nick's factory not found at canonical address, deploying it now") + + // Deploy Nick's factory at the canonical address + if err := s.deployNicksFactory(ctx); err != nil { + return fmt.Errorf("failed to deploy Nick's factory: %w", err) + } + + // Verify deployment + code, err = client.GetEthClient().CodeAt(ctx, canonicalAddr, nil) + if err != nil { + return fmt.Errorf("failed to verify factory deployment: %w", err) + } + + if len(code) == 0 { + return fmt.Errorf("factory deployment failed - no code at canonical address") + } + + s.factoryAddress = canonicalAddr + s.logger.Infof("Successfully deployed Nick's factory at canonical address %s", NickFactoryAddress) + return nil +} + +func (s *Scenario) deployNicksFactory(ctx context.Context) error { + // Nick's factory deployment method: + // 1. Fund the deployment address 0x3fab184622dc19b6109349b94811493bf2a45362 + // 2. Send the pre-signed deployment transaction + + client := s.walletPool.GetClient(spamoor.WithClientGroup(s.options.ClientGroup)) + if client == nil { + return scenario.ErrNoClients + } + + // The deployment address that needs to be funded + deployerAddr := common.HexToAddress("0x3fab184622dc19b6109349b94811493bf2a45362") + + // Check if deployer already has funds + balance, err := client.GetEthClient().BalanceAt(ctx, deployerAddr, nil) + if err != nil { + return fmt.Errorf("failed to check deployer balance: %w", err) + } + + // Need at least 0.04 ETH for deployment + requiredBalance := new(big.Int).Mul(big.NewInt(4), big.NewInt(1e16)) // 0.04 ETH + + if balance.Cmp(requiredBalance) < 0 { + s.logger.Infof("Funding Nick's factory deployer address with 0.05 ETH") + + // Fund the deployer address + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, 0) + if wallet == nil { + return scenario.ErrNoWallet + } + + if err := wallet.ResetNoncesIfNeeded(ctx, client); err != nil { + return err + } + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return err + } + + // Send 0.05 ETH to the deployer address + fundAmount := new(big.Int).Mul(big.NewInt(5), big.NewInt(1e16)) // 0.05 ETH + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + Gas: 21000, + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + To: &deployerAddr, + Value: uint256.MustFromBig(fundAmount), + }) + + if err != nil { + return fmt.Errorf("failed to build funding tx: %w", err) + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return fmt.Errorf("failed to sign funding tx: %w", err) + } + + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + ClientGroup: s.options.ClientGroup, + Rebroadcast: true, + }) + + if err != nil { + return fmt.Errorf("failed to fund deployer address: %w", err) + } + + if receipt == nil || receipt.Status != 1 { + return fmt.Errorf("funding transaction failed") + } + + s.logger.Infof("Funded deployer address in block %s", receipt.BlockNumber.String()) + } + + // Now send the pre-signed deployment transaction + // This is the actual signed transaction from Nick that deploys the factory + rawTx := "0xf8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222" + + var tx types.Transaction + if err := tx.UnmarshalBinary(common.FromHex(rawTx)); err != nil { + return fmt.Errorf("failed to unmarshal pre-signed transaction: %w", err) + } + + // Send the pre-signed transaction + if err := client.GetEthClient().SendTransaction(ctx, &tx); err != nil { + // Check if the error is because factory already exists + if strings.Contains(err.Error(), "already known") || strings.Contains(err.Error(), "nonce too low") { + s.logger.Info("Factory deployment transaction already processed") + return nil + } + return fmt.Errorf("failed to send deployment transaction: %w", err) + } + + // Wait for the transaction to be mined + receipt, err := bind.WaitMined(ctx, client.GetEthClient(), &tx) + if err != nil { + return fmt.Errorf("failed to wait for deployment: %w", err) + } + + if receipt.Status != 1 { + return fmt.Errorf("factory deployment transaction failed") + } + + s.logger.Infof("Nick's factory deployed successfully in block %s", receipt.BlockNumber.String()) + return nil +} + +func (s *Scenario) Run(ctx context.Context) error { + // Phase 1: Fund auxiliary accounts + if !s.options.SkipFunding { + s.phase = "funding" + s.logger.Info("Phase 1: Funding auxiliary accounts") + + // Count total auxiliary accounts + auxAccounts := make(map[string]bool) + for _, contract := range s.deployData.Contracts { + for _, acc := range contract.AuxiliaryAccounts { + auxAccounts[acc] = true + } + } + totalAuxAccounts := uint64(len(auxAccounts)) + s.logger.Infof("Total unique auxiliary accounts to fund: %d", totalAuxAccounts) + + // Run funding scenario - deploy all as fast as possible + err := scenario.RunTransactionScenario(ctx, scenario.TransactionScenarioOptions{ + TotalCount: totalAuxAccounts, + Throughput: 0, // No throughput limit - send as fast as possible + MaxPending: 100, // Reasonable pending limit + ThroughputIncrementInterval: 0, + Timeout: 0, + WalletPool: s.walletPool, + Logger: s.logger, + ProcessNextTxFn: s.sendFundingTx, + }) + + if err != nil { + s.logger.Warnf("Error during funding phase: %v", err) + } + + s.logger.Infof("Funded %d auxiliary accounts", len(s.fundedAccounts)) + } + + // Phase 2: Ensure Nick's factory exists + if !s.options.SkipContracts { + if err := s.ensureNicksFactory(ctx); err != nil { + return fmt.Errorf("failed to ensure Nick's factory exists: %w", err) + } + } + + // Phase 3: Deploy contracts via Nick's factory + if !s.options.SkipContracts { + s.phase = "deploying" + s.currentIndex = 0 + s.logger.Info("Phase 3: Deploying contracts via Nick's factory") + + err := scenario.RunTransactionScenario(ctx, scenario.TransactionScenarioOptions{ + TotalCount: s.options.TotalContracts, + Throughput: 0, // No throughput limit - deploy as fast as possible + MaxPending: 50, // Lower limit for deployments due to higher gas usage + ThroughputIncrementInterval: 0, + Timeout: 0, + WalletPool: s.walletPool, + Logger: s.logger, + ProcessNextTxFn: s.sendDeploymentTx, + }) + + if err != nil { + s.logger.Warnf("Error during deployment phase: %v", err) + } + + s.logger.Infof("Deployed %d contracts", len(s.deployedContracts)) + } + + // Log deployment info + s.logDeploymentInfo() + + s.logger.WithFields(logrus.Fields{ + "contracts_deployed": len(s.deployedContracts), + "accounts_funded": len(s.fundedAccounts), + }).Info("storage trie brancher scenario completed") + + return nil +} + +func (s *Scenario) sendFundingTx(ctx context.Context, params *scenario.ProcessNextTxParams) error { + // Collect all unique auxiliary accounts with proper locking + s.mu.RLock() + auxAccounts := make([]string, 0) + for _, contract := range s.deployData.Contracts { + for _, acc := range contract.AuxiliaryAccounts { + if !s.fundedAccounts[acc] { + auxAccounts = append(auxAccounts, acc) + } + } + } + s.mu.RUnlock() + + if params.TxIdx >= uint64(len(auxAccounts)) { + return fmt.Errorf("funding index out of range") + } + + account := auxAccounts[params.TxIdx] + + // Get client and wallet + client := s.walletPool.GetClient( + spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, int(params.TxIdx)), + spamoor.WithClientGroup(s.options.ClientGroup), + ) + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, int(params.TxIdx)) + + if client == nil { + return scenario.ErrNoClients + } + if wallet == nil { + return scenario.ErrNoWallet + } + + if err := wallet.ResetNoncesIfNeeded(ctx, client); err != nil { + return err + } + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return err + } + + // Build funding transaction + toAddr := common.HexToAddress(account) + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + Gas: FundGasLimit, + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + To: &toAddr, + Value: uint256.NewInt(FundingAmount), + }) + + if err != nil { + return fmt.Errorf("failed to build funding tx for %s: %w", account, err) + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return fmt.Errorf("failed to sign funding tx for %s: %w", account, err) + } + + // Send transaction + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + ClientGroup: s.options.ClientGroup, + Rebroadcast: true, // Always use rebroadcast for reliability + }) + + params.NotifySubmitted() + + logger := s.logger.WithFields(logrus.Fields{ + "rpc": client.GetName(), + "nonce": tx.Nonce(), + "wallet": s.walletPool.GetWalletName(wallet.GetAddress()), + }) + + params.OrderedLogCb(func() { + if err != nil { + logger.Warnf("could not send funding transaction: %v", err) + } else if s.options.LogTxs { + logger.Infof("sent funding tx #%6d: %v to %s", params.TxIdx+1, tx.Hash().String(), account) + } else { + logger.Debugf("sent funding tx #%6d: %v to %s", params.TxIdx+1, tx.Hash().String(), account) + } + }) + + if receipt != nil { + s.mu.Lock() + s.fundedAccounts[account] = true + s.mu.Unlock() + } + + return err +} + +func (s *Scenario) sendDeploymentTx(ctx context.Context, params *scenario.ProcessNextTxParams) error { + if params.TxIdx >= uint64(len(s.deployData.Contracts)) { + return fmt.Errorf("deployment index out of range") + } + + contract := s.deployData.Contracts[params.TxIdx] + + // Skip if already deployed + s.mu.RLock() + if s.deployedContracts[contract.ContractAddress] { + s.mu.RUnlock() + return nil + } + s.mu.RUnlock() + + // Get client and wallet + client := s.walletPool.GetClient( + spamoor.WithClientSelectionMode(spamoor.SelectClientByIndex, int(params.TxIdx)), + spamoor.WithClientGroup(s.options.ClientGroup), + ) + wallet := s.walletPool.GetWallet(spamoor.SelectWalletByIndex, int(params.TxIdx)) + + if client == nil { + return scenario.ErrNoClients + } + if wallet == nil { + return scenario.ErrNoWallet + } + + if err := wallet.ResetNoncesIfNeeded(ctx, client); err != nil { + return err + } + + feeCap, tipCap, err := s.walletPool.GetTxPool().GetSuggestedFees(client, s.options.BaseFee, s.options.TipFee) + if err != nil { + return err + } + + // Convert salt to bytes + saltBytes, err := s.saltToBytes(contract.Salt) + if err != nil { + return fmt.Errorf("failed to convert salt: %w", err) + } + + // Build factory call data (salt + init code) + factoryData := append(saltBytes, s.initCode...) + + // Build deployment transaction + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + Gas: DeployGasLimit, + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + To: &s.factoryAddress, + Data: factoryData, + }) + + if err != nil { + return fmt.Errorf("failed to build deployment tx: %w", err) + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return fmt.Errorf("failed to sign deployment tx: %w", err) + } + + // Send transaction + receipt, err := s.walletPool.GetTxPool().SendAndAwaitTransaction(ctx, wallet, tx, &spamoor.SendTransactionOptions{ + Client: client, + ClientGroup: s.options.ClientGroup, + Rebroadcast: true, // Always use rebroadcast for reliability + }) + + params.NotifySubmitted() + + logger := s.logger.WithFields(logrus.Fields{ + "rpc": client.GetName(), + "nonce": tx.Nonce(), + "wallet": s.walletPool.GetWalletName(wallet.GetAddress()), + }) + + params.OrderedLogCb(func() { + if err != nil { + logger.Warnf("could not send deployment transaction: %v", err) + } else if s.options.LogTxs { + deployAddr := s.calculateCreate2Address(saltBytes) + logger.Infof("sent deployment tx #%6d: %v (contract: %s)", params.TxIdx+1, tx.Hash().String(), deployAddr.Hex()) + } else { + logger.Debugf("sent deployment tx #%6d: %v", params.TxIdx+1, tx.Hash().String()) + } + }) + + if receipt != nil && receipt.Status == 1 { + // Calculate deployment address + deployAddr := s.calculateCreate2Address(saltBytes) + + s.mu.Lock() + s.deployedContracts[contract.ContractAddress] = true + s.deployments = append(s.deployments, DeploymentInfo{ + Address: deployAddr.Hex(), + Salt: "0x" + hex.EncodeToString(saltBytes), + AuxiliaryAccounts: contract.AuxiliaryAccounts, + }) + s.mu.Unlock() + } + + return err +} + +func (s *Scenario) saltToBytes(salt interface{}) ([]byte, error) { + switch v := salt.(type) { + case float64: + // JSON numbers come as float64 + saltBig := big.NewInt(int64(v)) + saltBytes := make([]byte, 32) + saltBig.FillBytes(saltBytes) + return saltBytes, nil + case int: + saltBig := big.NewInt(int64(v)) + saltBytes := make([]byte, 32) + saltBig.FillBytes(saltBytes) + return saltBytes, nil + case string: + saltStr := v + saltStr = strings.TrimPrefix(saltStr, "0x") + saltBytes, err := hex.DecodeString(saltStr) + if err != nil { + return nil, err + } + if len(saltBytes) != 32 { + // Pad with zeros if needed + padded := make([]byte, 32) + copy(padded[32-len(saltBytes):], saltBytes) + return padded, nil + } + return saltBytes, nil + default: + return nil, fmt.Errorf("unsupported salt type: %T", v) + } +} + +func (s *Scenario) calculateCreate2Address(salt []byte) common.Address { + // CREATE2 address = keccak256(0xff ++ deployer ++ salt ++ keccak256(init_code))[12:] + initCodeHash := crypto.Keccak256(s.initCode) + + data := []byte{0xff} + data = append(data, s.factoryAddress.Bytes()...) + data = append(data, salt...) + data = append(data, initCodeHash...) + + hash := crypto.Keccak256(data) + return common.BytesToAddress(hash[12:]) +} + +func (s *Scenario) logDeploymentInfo() { + // Log deployment summary + s.logger.WithFields(logrus.Fields{ + "storage_depth": s.options.StorageDepth, + "account_depth": s.options.AccountDepth, + "deployer": s.factoryAddress.Hex(), + "contracts_deployed": len(s.deployedContracts), + "accounts_funded": len(s.fundedAccounts), + }).Info("Deployment completed - summary") + + // Log deployed contract addresses for reference + if len(s.deployments) > 0 { + addresses := make([]string, 0, len(s.deployments)) + for _, deploy := range s.deployments { + addresses = append(addresses, deploy.Address) + } + + // Log first 10 addresses as example + logCount := 10 + if len(addresses) < logCount { + logCount = len(addresses) + } + + s.logger.WithField("sample_addresses", addresses[:logCount]).Info("Sample deployed contract addresses") + + // Log all deployment details as structured JSON for programmatic access + if s.options.LogTxs { + deploymentData, _ := json.Marshal(map[string]interface{}{ + "storage_depth": s.options.StorageDepth, + "account_depth": s.options.AccountDepth, + "deployer": s.factoryAddress.Hex(), + "contracts_deployed": len(s.deployedContracts), + "accounts_funded": len(s.fundedAccounts), + "contracts": s.deployments, + }) + s.logger.WithField("deployment_data", string(deploymentData)).Debug("Full deployment data (JSON)") + } + } +} diff --git a/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s10.yaml b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s10.yaml new file mode 100644 index 0000000..0bb9700 --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s10.yaml @@ -0,0 +1,62 @@ +# Name: Storage Trie Brancher - Storage Depth 10 +# Description: Deploy worst-case storage trie contracts with depth 10 across 5 account depths (3-7) + +- scenario: storage-trie-brancher + name: '[Storage Trie] s10 acc_depth=3' + config: + total_contracts: 18000 + storage_depth: 10 + account_depth: 3 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/acc_depth3.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s10 acc_depth=4' + config: + total_contracts: 18000 + storage_depth: 10 + account_depth: 4 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/acc_depth4.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s10 acc_depth=5' + config: + total_contracts: 18000 + storage_depth: 10 + account_depth: 5 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/acc_depth5.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s10 acc_depth=6' + config: + total_contracts: 18000 + storage_depth: 10 + account_depth: 6 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/acc_depth6.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s10 acc_depth=7' + config: + total_contracts: 18000 + storage_depth: 10 + account_depth: 7 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/acc_depth7.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s10/bytecode.bin" diff --git a/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s11.yaml b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s11.yaml new file mode 100644 index 0000000..b63f8ae --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s11.yaml @@ -0,0 +1,62 @@ +# Name: Storage Trie Brancher - Storage Depth 11 +# Description: Deploy worst-case storage trie contracts with depth 11 across 5 account depths (3-7) + +- scenario: storage-trie-brancher + name: '[Storage Trie] s11 acc_depth=3' + config: + total_contracts: 18000 + storage_depth: 11 + account_depth: 3 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/acc_depth3.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s11 acc_depth=4' + config: + total_contracts: 18000 + storage_depth: 11 + account_depth: 4 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/acc_depth4.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s11 acc_depth=5' + config: + total_contracts: 18000 + storage_depth: 11 + account_depth: 5 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/acc_depth5.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s11 acc_depth=6' + config: + total_contracts: 18000 + storage_depth: 11 + account_depth: 6 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/acc_depth6.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s11 acc_depth=7' + config: + total_contracts: 18000 + storage_depth: 11 + account_depth: 7 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/acc_depth7.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s11/bytecode.bin" diff --git a/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s12.yaml b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s12.yaml new file mode 100644 index 0000000..fdc5364 --- /dev/null +++ b/scenarios/statebloat/storage_trie_brancher_deployment/deploy_s12.yaml @@ -0,0 +1,38 @@ +# Name: Storage Trie Brancher - Storage Depth 12 +# Description: Deploy worst-case storage trie contracts with depth 12 across 3 account depths (3-5) + +- scenario: storage-trie-brancher + name: '[Storage Trie] s12 acc_depth=3' + config: + total_contracts: 18000 + storage_depth: 12 + account_depth: 3 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/acc_depth3.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s12 acc_depth=4' + config: + total_contracts: 18000 + storage_depth: 12 + account_depth: 4 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/acc_depth4.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/bytecode.bin" + +- scenario: storage-trie-brancher + name: '[Storage Trie] s12 acc_depth=5' + config: + total_contracts: 18000 + storage_depth: 12 + account_depth: 5 + max_wallets: 50 + base_fee: 20 + tip_fee: 2 + data_file: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/acc_depth5.json" + bytecode: "https://raw.githubusercontent.com/CPerezz/worst_case_miner/main/mined_assets/s12/bytecode.bin" diff --git a/spamoor_test.log b/spamoor_test.log new file mode 100644 index 0000000..5e18d26 --- /dev/null +++ b/spamoor_test.log @@ -0,0 +1,2108 @@ +time="2025-12-22T10:59:12+01:00" level=info msg="starting spamoor" buildtime= version=git- +time="2025-12-22T10:59:12+01:00" level=info msg="initialized client pool with 1 clients (chain id: 1337)" module=clientpool +time="2025-12-22T10:59:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T10:59:12+01:00" level=info msg="initialized root wallet (addr: 0xFABB0ac9d68B0B445fB7357272Ff202C5651694a balance: 0 ETH, nonce: 0)" +time="2025-12-22T10:59:12+01:00" level=info msg="processed block 705: 0 total tx, 0 tx confirmed from 0 wallets (291.459µs, 262.375µs)" +time="2025-12-22T10:59:12+01:00" level=info msg="Compiled contract, init code size: 1870 bytes" scenario=storage-trie-brancher +time="2025-12-22T10:59:12+01:00" level=info msg="initialized storage trie brancher scenario" account_depth=3 contract_file=scenarios/statebloat/storage_trie_brancher/depth_9.sol contracts=1000 data_file=scenarios/statebloat/storage_trie_brancher/s9_acc3.json scenario=storage-trie-brancher storage_depth=9 +time="2025-12-22T10:59:12+01:00" level=info msg="root wallet is locked, insufficient root wallet balance. awaiting addtional funds. needed: 51 ETH" module=walletpool +time="2025-12-22T10:59:15+01:00" level=info msg="processed block 706: 0 total tx, 0 tx confirmed from 0 wallets (1.693375ms, 2.375µs)" +time="2025-12-22T10:59:21+01:00" level=info msg="processed block 707: 0 total tx, 0 tx confirmed from 0 wallets (683.709µs, 4.125µs)" +time="2025-12-22T10:59:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T10:59:27+01:00" level=info msg="processed block 708: 0 total tx, 0 tx confirmed from 0 wallets (646.417µs, 3.459µs)" +time="2025-12-22T10:59:33+01:00" level=info msg="processed block 709: 0 total tx, 0 tx confirmed from 0 wallets (689.875µs, 3.5µs)" +time="2025-12-22T10:59:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T10:59:39+01:00" level=info msg="processed block 710: 0 total tx, 0 tx confirmed from 0 wallets (931.959µs, 5.166µs)" +time="2025-12-22T10:59:45+01:00" level=info msg="processed block 711: 0 total tx, 0 tx confirmed from 0 wallets (590.834µs, 2.042µs)" +time="2025-12-22T10:59:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T10:59:51+01:00" level=info msg="processed block 712: 0 total tx, 0 tx confirmed from 0 wallets (738.875µs, 3.959µs)" +time="2025-12-22T10:59:57+01:00" level=info msg="processed block 713: 0 total tx, 0 tx confirmed from 0 wallets (826.125µs, 6.958µs)" +time="2025-12-22T11:00:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:00:03+01:00" level=info msg="processed block 714: 0 total tx, 0 tx confirmed from 0 wallets (976µs, 4.792µs)" +time="2025-12-22T11:00:09+01:00" level=info msg="processed block 715: 0 total tx, 0 tx confirmed from 0 wallets (1.352166ms, 5.75µs)" +time="2025-12-22T11:00:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:00:15+01:00" level=info msg="processed block 716: 0 total tx, 0 tx confirmed from 0 wallets (660.5µs, 3.167µs)" +time="2025-12-22T11:00:21+01:00" level=info msg="processed block 717: 0 total tx, 0 tx confirmed from 0 wallets (1.450458ms, 4.958µs)" +time="2025-12-22T11:00:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:00:27+01:00" level=info msg="processed block 718: 0 total tx, 0 tx confirmed from 0 wallets (1.205084ms, 12.708µs)" +time="2025-12-22T11:00:33+01:00" level=info msg="processed block 719: 0 total tx, 0 tx confirmed from 0 wallets (590.041µs, 4.875µs)" +time="2025-12-22T11:00:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:00:39+01:00" level=info msg="processed block 720: 0 total tx, 0 tx confirmed from 0 wallets (401.708µs, 5.458µs)" +time="2025-12-22T11:00:45+01:00" level=info msg="processed block 721: 0 total tx, 0 tx confirmed from 0 wallets (302.209µs, 2.792µs)" +time="2025-12-22T11:00:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:00:51+01:00" level=info msg="processed block 722: 0 total tx, 0 tx confirmed from 0 wallets (1.185875ms, 10µs)" +time="2025-12-22T11:00:57+01:00" level=info msg="processed block 723: 0 total tx, 0 tx confirmed from 0 wallets (869.208µs, 6.291µs)" +time="2025-12-22T11:01:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:01:03+01:00" level=info msg="processed block 724: 0 total tx, 0 tx confirmed from 0 wallets (701.292µs, 3.375µs)" +time="2025-12-22T11:01:09+01:00" level=info msg="processed block 725: 0 total tx, 0 tx confirmed from 0 wallets (1.094375ms, 6.333µs)" +time="2025-12-22T11:01:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:01:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:01:15+01:00" level=info msg="processed block 726: 0 total tx, 0 tx confirmed from 0 wallets (663.25µs, 3.834µs)" +time="2025-12-22T11:01:21+01:00" level=info msg="processed block 727: 0 total tx, 0 tx confirmed from 0 wallets (505.375µs, 4.375µs)" +time="2025-12-22T11:01:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:01:27+01:00" level=info msg="processed block 728: 0 total tx, 0 tx confirmed from 0 wallets (789.208µs, 6.5µs)" +time="2025-12-22T11:01:33+01:00" level=info msg="processed block 729: 0 total tx, 0 tx confirmed from 0 wallets (815.875µs, 5.459µs)" +time="2025-12-22T11:01:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:01:39+01:00" level=info msg="processed block 730: 0 total tx, 0 tx confirmed from 0 wallets (550.875µs, 4.083µs)" +time="2025-12-22T11:01:45+01:00" level=info msg="processed block 731: 0 total tx, 0 tx confirmed from 0 wallets (551.417µs, 2.75µs)" +time="2025-12-22T11:01:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:01:51+01:00" level=info msg="processed block 732: 0 total tx, 0 tx confirmed from 0 wallets (737.667µs, 3.709µs)" +time="2025-12-22T11:01:57+01:00" level=info msg="processed block 733: 0 total tx, 0 tx confirmed from 0 wallets (292.542µs, 2.042µs)" +time="2025-12-22T11:02:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:02:03+01:00" level=info msg="processed block 734: 0 total tx, 0 tx confirmed from 0 wallets (998.708µs, 7.167µs)" +time="2025-12-22T11:02:09+01:00" level=info msg="processed block 735: 0 total tx, 0 tx confirmed from 0 wallets (1.097959ms, 13.625µs)" +time="2025-12-22T11:02:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:02:15+01:00" level=info msg="processed block 736: 0 total tx, 0 tx confirmed from 0 wallets (510.916µs, 2.166µs)" +time="2025-12-22T11:02:21+01:00" level=info msg="processed block 737: 0 total tx, 0 tx confirmed from 0 wallets (826.458µs, 6.125µs)" +time="2025-12-22T11:02:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:02:27+01:00" level=info msg="processed block 738: 0 total tx, 0 tx confirmed from 0 wallets (819.375µs, 8µs)" +time="2025-12-22T11:02:33+01:00" level=info msg="processed block 739: 0 total tx, 0 tx confirmed from 0 wallets (454.5µs, 4.75µs)" +time="2025-12-22T11:02:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:02:39+01:00" level=info msg="processed block 740: 0 total tx, 0 tx confirmed from 0 wallets (663.459µs, 5.709µs)" +time="2025-12-22T11:02:45+01:00" level=info msg="processed block 741: 0 total tx, 0 tx confirmed from 0 wallets (560.958µs, 4.833µs)" +time="2025-12-22T11:02:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:02:51+01:00" level=info msg="processed block 742: 0 total tx, 0 tx confirmed from 0 wallets (732.083µs, 4.208µs)" +time="2025-12-22T11:02:57+01:00" level=info msg="processed block 743: 0 total tx, 0 tx confirmed from 0 wallets (972.5µs, 6.167µs)" +time="2025-12-22T11:03:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:03:03+01:00" level=info msg="processed block 744: 0 total tx, 0 tx confirmed from 0 wallets (961.584µs, 6.542µs)" +time="2025-12-22T11:03:09+01:00" level=info msg="processed block 745: 0 total tx, 0 tx confirmed from 0 wallets (489.708µs, 3.375µs)" +time="2025-12-22T11:03:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:03:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:03:15+01:00" level=info msg="processed block 746: 0 total tx, 0 tx confirmed from 0 wallets (531.083µs, 4.5µs)" +time="2025-12-22T11:03:21+01:00" level=info msg="processed block 747: 0 total tx, 0 tx confirmed from 0 wallets (604µs, 5.334µs)" +time="2025-12-22T11:03:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:03:27+01:00" level=info msg="processed block 748: 0 total tx, 0 tx confirmed from 0 wallets (1.088458ms, 5.792µs)" +time="2025-12-22T11:03:33+01:00" level=info msg="processed block 749: 0 total tx, 0 tx confirmed from 0 wallets (1.155291ms, 3.625µs)" +time="2025-12-22T11:03:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:03:39+01:00" level=info msg="processed block 750: 0 total tx, 0 tx confirmed from 0 wallets (1.123833ms, 9.209µs)" +time="2025-12-22T11:03:45+01:00" level=info msg="processed block 751: 0 total tx, 0 tx confirmed from 0 wallets (629.5µs, 6.083µs)" +time="2025-12-22T11:03:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:03:51+01:00" level=info msg="processed block 752: 0 total tx, 0 tx confirmed from 0 wallets (2.409958ms, 6.583µs)" +time="2025-12-22T11:03:57+01:00" level=info msg="processed block 753: 0 total tx, 0 tx confirmed from 0 wallets (589.667µs, 6.083µs)" +time="2025-12-22T11:04:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:04:03+01:00" level=info msg="processed block 754: 0 total tx, 0 tx confirmed from 0 wallets (1.15925ms, 5.542µs)" +time="2025-12-22T11:04:09+01:00" level=info msg="processed block 755: 0 total tx, 0 tx confirmed from 0 wallets (600.584µs, 9.625µs)" +time="2025-12-22T11:04:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:04:15+01:00" level=info msg="processed block 756: 0 total tx, 0 tx confirmed from 0 wallets (425.292µs, 3.209µs)" +time="2025-12-22T11:04:21+01:00" level=info msg="processed block 757: 0 total tx, 0 tx confirmed from 0 wallets (399.708µs, 2.917µs)" +time="2025-12-22T11:04:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:04:27+01:00" level=info msg="processed block 758: 0 total tx, 0 tx confirmed from 0 wallets (536.583µs, 6.667µs)" +time="2025-12-22T11:04:33+01:00" level=info msg="processed block 759: 0 total tx, 0 tx confirmed from 0 wallets (543.875µs, 8.291µs)" +time="2025-12-22T11:04:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:04:39+01:00" level=info msg="processed block 760: 0 total tx, 0 tx confirmed from 0 wallets (571.333µs, 6.25µs)" +time="2025-12-22T11:04:45+01:00" level=info msg="processed block 761: 0 total tx, 0 tx confirmed from 0 wallets (1.105709ms, 8.542µs)" +time="2025-12-22T11:04:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:04:51+01:00" level=info msg="processed block 762: 0 total tx, 0 tx confirmed from 0 wallets (295.708µs, 1.875µs)" +time="2025-12-22T11:04:57+01:00" level=info msg="processed block 763: 0 total tx, 0 tx confirmed from 0 wallets (803.708µs, 7.583µs)" +time="2025-12-22T11:05:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:05:03+01:00" level=info msg="processed block 764: 0 total tx, 0 tx confirmed from 0 wallets (2.057209ms, 6.959µs)" +time="2025-12-22T11:05:09+01:00" level=info msg="processed block 765: 0 total tx, 0 tx confirmed from 0 wallets (795.708µs, 6.375µs)" +time="2025-12-22T11:05:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:05:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:05:15+01:00" level=info msg="processed block 766: 0 total tx, 0 tx confirmed from 0 wallets (787.208µs, 6.5µs)" +time="2025-12-22T11:05:21+01:00" level=info msg="processed block 767: 0 total tx, 0 tx confirmed from 0 wallets (1.289792ms, 7.708µs)" +time="2025-12-22T11:05:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:05:27+01:00" level=info msg="processed block 768: 0 total tx, 0 tx confirmed from 0 wallets (478.292µs, 4.541µs)" +time="2025-12-22T11:05:33+01:00" level=info msg="processed block 769: 0 total tx, 0 tx confirmed from 0 wallets (1.258166ms, 6.958µs)" +time="2025-12-22T11:05:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:05:39+01:00" level=info msg="processed block 770: 0 total tx, 0 tx confirmed from 0 wallets (949.958µs, 5.416µs)" +time="2025-12-22T11:05:45+01:00" level=info msg="processed block 771: 0 total tx, 0 tx confirmed from 0 wallets (1.204416ms, 8.917µs)" +time="2025-12-22T11:05:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:05:51+01:00" level=info msg="processed block 772: 0 total tx, 0 tx confirmed from 0 wallets (479.917µs, 3.292µs)" +time="2025-12-22T11:05:57+01:00" level=info msg="processed block 773: 0 total tx, 0 tx confirmed from 0 wallets (628.375µs, 4.542µs)" +time="2025-12-22T11:06:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:06:03+01:00" level=info msg="processed block 774: 0 total tx, 0 tx confirmed from 0 wallets (1.080125ms, 7.416µs)" +time="2025-12-22T11:06:09+01:00" level=info msg="processed block 775: 0 total tx, 0 tx confirmed from 0 wallets (611.084µs, 5.083µs)" +time="2025-12-22T11:06:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:06:15+01:00" level=info msg="processed block 776: 0 total tx, 0 tx confirmed from 0 wallets (375µs, 4.5µs)" +time="2025-12-22T11:06:21+01:00" level=info msg="processed block 777: 0 total tx, 0 tx confirmed from 0 wallets (518.292µs, 3.167µs)" +time="2025-12-22T11:06:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:06:27+01:00" level=info msg="processed block 778: 0 total tx, 0 tx confirmed from 0 wallets (722.833µs, 7.667µs)" +time="2025-12-22T11:06:33+01:00" level=info msg="processed block 779: 0 total tx, 0 tx confirmed from 0 wallets (529.25µs, 5.208µs)" +time="2025-12-22T11:06:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:06:39+01:00" level=info msg="processed block 780: 0 total tx, 0 tx confirmed from 0 wallets (1.305166ms, 22.334µs)" +time="2025-12-22T11:06:45+01:00" level=info msg="processed block 781: 0 total tx, 0 tx confirmed from 0 wallets (957.959µs, 4.834µs)" +time="2025-12-22T11:06:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:06:51+01:00" level=info msg="processed block 782: 0 total tx, 0 tx confirmed from 0 wallets (922.25µs, 5.917µs)" +time="2025-12-22T11:06:57+01:00" level=info msg="processed block 783: 0 total tx, 0 tx confirmed from 0 wallets (964.625µs, 5.791µs)" +time="2025-12-22T11:07:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:07:03+01:00" level=info msg="processed block 784: 0 total tx, 0 tx confirmed from 0 wallets (560.084µs, 4.875µs)" +time="2025-12-22T11:07:09+01:00" level=info msg="processed block 785: 0 total tx, 0 tx confirmed from 0 wallets (447.458µs, 2.333µs)" +time="2025-12-22T11:07:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:07:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:07:15+01:00" level=info msg="processed block 786: 0 total tx, 0 tx confirmed from 0 wallets (370.458µs, 3.917µs)" +time="2025-12-22T11:07:21+01:00" level=info msg="processed block 787: 0 total tx, 0 tx confirmed from 0 wallets (634.875µs, 6.625µs)" +time="2025-12-22T11:07:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:07:27+01:00" level=info msg="processed block 788: 0 total tx, 0 tx confirmed from 0 wallets (670.333µs, 5.125µs)" +time="2025-12-22T11:07:33+01:00" level=info msg="processed block 789: 0 total tx, 0 tx confirmed from 0 wallets (981.292µs, 5.709µs)" +time="2025-12-22T11:07:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:07:39+01:00" level=info msg="processed block 790: 0 total tx, 0 tx confirmed from 0 wallets (557.125µs, 7.125µs)" +time="2025-12-22T11:07:45+01:00" level=info msg="processed block 791: 0 total tx, 0 tx confirmed from 0 wallets (382.167µs, 4.708µs)" +time="2025-12-22T11:07:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:07:51+01:00" level=info msg="processed block 792: 0 total tx, 0 tx confirmed from 0 wallets (696.584µs, 5.209µs)" +time="2025-12-22T11:07:58+01:00" level=info msg="processed block 793: 0 total tx, 0 tx confirmed from 0 wallets (484.792µs, 5µs)" +time="2025-12-22T11:08:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:08:04+01:00" level=info msg="processed block 794: 0 total tx, 0 tx confirmed from 0 wallets (890.084µs, 6.125µs)" +time="2025-12-22T11:08:10+01:00" level=info msg="processed block 795: 0 total tx, 0 tx confirmed from 0 wallets (832.042µs, 5.625µs)" +time="2025-12-22T11:08:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:08:16+01:00" level=info msg="processed block 796: 0 total tx, 0 tx confirmed from 0 wallets (461.541µs, 3.875µs)" +time="2025-12-22T11:08:22+01:00" level=info msg="processed block 797: 0 total tx, 0 tx confirmed from 0 wallets (1.063416ms, 6.458µs)" +time="2025-12-22T11:08:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:08:28+01:00" level=info msg="processed block 798: 0 total tx, 0 tx confirmed from 0 wallets (768.5µs, 5.959µs)" +time="2025-12-22T11:08:34+01:00" level=info msg="processed block 799: 0 total tx, 0 tx confirmed from 0 wallets (558.5µs, 5.958µs)" +time="2025-12-22T11:08:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:08:40+01:00" level=info msg="processed block 800: 0 total tx, 0 tx confirmed from 0 wallets (991.875µs, 9.333µs)" +time="2025-12-22T11:08:46+01:00" level=info msg="processed block 801: 0 total tx, 0 tx confirmed from 0 wallets (503.875µs, 3µs)" +time="2025-12-22T11:08:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:08:52+01:00" level=info msg="processed block 802: 0 total tx, 0 tx confirmed from 0 wallets (662.584µs, 3.417µs)" +time="2025-12-22T11:08:58+01:00" level=info msg="processed block 803: 0 total tx, 0 tx confirmed from 0 wallets (1.010042ms, 5.458µs)" +time="2025-12-22T11:09:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:09:04+01:00" level=info msg="processed block 804: 0 total tx, 0 tx confirmed from 0 wallets (398.583µs, 3.375µs)" +time="2025-12-22T11:09:10+01:00" level=info msg="processed block 805: 0 total tx, 0 tx confirmed from 0 wallets (779.25µs, 5.583µs)" +time="2025-12-22T11:09:12+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:09:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:09:16+01:00" level=info msg="processed block 806: 0 total tx, 0 tx confirmed from 0 wallets (790.583µs, 4.667µs)" +time="2025-12-22T11:09:22+01:00" level=info msg="processed block 807: 0 total tx, 0 tx confirmed from 0 wallets (799.292µs, 7µs)" +time="2025-12-22T11:09:24+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:09:28+01:00" level=info msg="processed block 808: 0 total tx, 0 tx confirmed from 0 wallets (1.524ms, 6.708µs)" +time="2025-12-22T11:09:34+01:00" level=info msg="processed block 809: 0 total tx, 0 tx confirmed from 0 wallets (933.625µs, 4.042µs)" +time="2025-12-22T11:09:36+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:09:40+01:00" level=info msg="processed block 810: 0 total tx, 0 tx confirmed from 0 wallets (656.917µs, 5.417µs)" +time="2025-12-22T11:09:46+01:00" level=info msg="processed block 811: 0 total tx, 0 tx confirmed from 0 wallets (1.165083ms, 4.75µs)" +time="2025-12-22T11:09:48+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:09:52+01:00" level=info msg="processed block 812: 0 total tx, 0 tx confirmed from 0 wallets (510.625µs, 2.708µs)" +time="2025-12-22T11:09:58+01:00" level=info msg="processed block 813: 0 total tx, 0 tx confirmed from 0 wallets (610.416µs, 6.417µs)" +time="2025-12-22T11:10:00+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:10:04+01:00" level=info msg="processed block 814: 0 total tx, 0 tx confirmed from 0 wallets (495.458µs, 2.334µs)" +time="2025-12-22T11:10:10+01:00" level=info msg="processed block 815: 0 total tx, 0 tx confirmed from 0 wallets (598.709µs, 6µs)" +time="2025-12-22T11:10:12+01:00" level=info msg="waiting for root wallet funding. Current: 0 ETH, still need: 51 ETH" +time="2025-12-22T11:10:16+01:00" level=info msg="processed block 816: 1 total tx, 0 tx confirmed from 0 wallets (1.476042ms, 1.287375ms)" +time="2025-12-22T11:10:22+01:00" level=info msg="processed block 817: 0 total tx, 0 tx confirmed from 0 wallets (597µs, 4.167µs)" +time="2025-12-22T11:10:24+01:00" level=info msg="funding child wallets... (0/10)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=info msg="processed block 818: 10 total tx, 10 tx confirmed from 1 wallets (1.997708ms, 935.875µs)" +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 0 (addr: 0x49b27a073d042a7F73155Db2f44a04132FEb3eae, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 1 (addr: 0x7Da575c39544CA67F7EF4181F936a4e2d52Ac349, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 2 (addr: 0x934d68410DB4e1Fa621B40F69AaC614Cde0CA77E, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 3 (addr: 0x153e43a9af68Ef5690d11ceF67e59C98fF71AF7A, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 4 (addr: 0xDFbdD9d845AB539d204063888D07Bcac08C3De6F, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 5 (addr: 0xd7690f43dc85e3aDE052da1867AC076809240fB7, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 6 (addr: 0x6F67d4E02Abe855c822C2b3eee93ADe597CE9ad2, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 7 (addr: 0x3c480A8BC69e7b05479be4Cd99702DC5bB6261Cc, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 8 (addr: 0x5eaF6160243f3E73deBEcAf21B91AF1Ed113c39c, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=debug msg="initialized child wallet 9 (addr: 0x0E287f6E99A65Bcb8D26Da3cf9c9A82D3CDfD752, balance: 5 ETH, nonce: 0)" module=walletpool +time="2025-12-22T11:10:28+01:00" level=info msg="initialized 10 child wallets" module=walletpool +time="2025-12-22T11:10:28+01:00" level=info msg="Phase 1: Funding auxiliary accounts" scenario=storage-trie-brancher +time="2025-12-22T11:10:28+01:00" level=info msg="Total unique auxiliary accounts to fund: 3000" scenario=storage-trie-brancher +time="2025-12-22T11:10:34+01:00" level=info msg="sent funding tx # 92: 0x894f480d92a961f2ebc7812e6c28fc171b8a790245cf8a380dd2060b666b1694 to 0x4397fbaf5e1f5a2da7a51a17947c6c93dc73f232" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=2 +time="2025-12-22T11:10:34+01:00" level=info msg="sent funding tx # 25: 0x9e233e586cfc42ad8ed9cda67832ed282f1bf6b43c1675cab8052f1006910f0f to 0x3aa0217c1f33a050c47d576500d75a924f864a64" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=5 +fatal error: concurrent map read and map write + +goroutine 1478 [running]: +internal/runtime/maps.fatal({0x1048b6a40?, 0x10445647c?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/runtime/panic.go:1058 +0x20 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140002830c8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:343 +0x80c +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x64, 0x14000e12fa0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 1 [runnable]: +sync.runtime_notifyListWait(0x1400050c910, 0x1) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/runtime/sema.go:597 +0x150 +sync.(*Cond).Wait(0x1400050c900) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/sync/cond.go:71 +0xc4 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario({0x104bade80, 0x140002b8000}, {0xbb8, 0x0, 0x64, 0x0, 0x0, 0x14000160360, 0x0, 0x14000280310, ...}) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:232 +0xb24 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).Run(0x140002c6000, {0x104bade80, 0x140002b8000}) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:283 +0x628 +main.main() + /Users/random_anon/dev/spamoor/cmd/spamoor/main.go:185 +0xf20 + +goroutine 4 [chan receive]: +github.com/ethereum/go-ethereum/metrics.(*meterTicker).loop(0x104efd480) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/metrics/meter.go:159 +0x50 +created by github.com/ethereum/go-ethereum/metrics.(*meterTicker).add in goroutine 1 + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/metrics/meter.go:145 +0xc0 + +goroutine 24 [select]: +github.com/ethpandaops/spamoor/spamoor.(*RootWallet).balanceUpdateLoop(0x14000118360, 0x140002803f0) + /Users/random_anon/dev/spamoor/spamoor/rootwallet.go:186 +0xa8 +created by github.com/ethpandaops/spamoor/spamoor.InitRootWallet in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/rootwallet.go:74 +0x31c + +goroutine 25 [runnable]: +github.com/ethereum/go-ethereum/crypto/secp256k1._Cfunc_secp256k1_ext_ecdsa_recover(0x156704aa0, 0x1400160a550, 0x1400160a500, 0x140003e80a0) + _cgo_gotypes.go:254 +0x34 +github.com/ethereum/go-ethereum/crypto/secp256k1.RecoverPubkey.func1(...) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/crypto/secp256k1/secp256.go:121 +github.com/ethereum/go-ethereum/crypto/secp256k1.RecoverPubkey({0x140003e80a0, 0x14000bda8a0?, 0x14000bda8c0?}, {0x1400160a500, 0x41, 0x0?}) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/crypto/secp256k1/secp256.go:121 +0xe4 +github.com/ethereum/go-ethereum/crypto.Ecrecover(...) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/crypto/signature_cgo.go:33 +github.com/ethereum/go-ethereum/core/types.recoverPlain({0xdb, 0xbd, 0xa, 0xe5, 0xd, 0xa1, 0x45, 0x3e, 0xed, 0x8c, ...}, ...) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/core/types/transaction_signing.go:635 +0x1b4 +github.com/ethereum/go-ethereum/core/types.londonSigner.Sender({{{0x14000110120?, 0x14001095380?}}}, 0x14000fc4ac0) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/core/types/transaction_signing.go:343 +0x1c8 +github.com/ethereum/go-ethereum/core/types.cancunSigner.Sender({{{{0x14000110120?, 0x14001095380?}}}}, 0x14000fc4ac0) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/core/types/transaction_signing.go:266 +0x228 +github.com/ethereum/go-ethereum/core/types.pragueSigner.Sender({{{{{...}}}}}, 0x14000fc4ac0?) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/core/types/transaction_signing.go:197 +0x228 +github.com/ethereum/go-ethereum/core/types.Sender({0x104baef60, 0x14000d96e70}, 0x140008d2000?) + /Users/random_anon/go/pkg/mod/github.com/!marius!van!der!wijden/go-ethereum@v0.0.0-20250401090816-5ab5127f5408/core/types/transaction_signing.go:150 +0x80 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).processBlockTxs(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002ba6c0, 0x333, 0x140009ae480, 0x14000110120, 0x14000041cd8, 0x140002e9560) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:356 +0x28c +github.com/ethpandaops/spamoor/spamoor.(*TxPool).processBlock(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002ba6c0, 0x333) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:324 +0x66c +github.com/ethpandaops/spamoor/spamoor.(*TxPool).runTxPoolLoop(0x1400017a000) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:197 +0x2ec +created by github.com/ethpandaops/spamoor/spamoor.NewTxPool in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:168 +0x22c + +goroutine 26 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).processStaleTransactionsLoop(0x1400017a000) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:238 +0xa4 +created by github.com/ethpandaops/spamoor/spamoor.NewTxPool in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:169 +0x26c + +goroutine 933 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011ad70}, 0x140002e00b0, 0x14000e02300, 0x140009a8170) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 608 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 157 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fe640}, 0x140000dc210, 0x14000e02480, 0x14000c16160) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 573 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 23 [select, 2 minutes]: +github.com/ethpandaops/spamoor/spamoor.(*ClientPool).watchClientStatusLoop(0x140002803f0) + /Users/random_anon/dev/spamoor/spamoor/clientpool.go:187 +0x8c +created by github.com/ethpandaops/spamoor/spamoor.(*ClientPool).PrepareClients in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/clientpool.go:176 +0x64 + +goroutine 27 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).runRebroadcastLoop(0x1400017a000) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:1440 +0xc4 +created by github.com/ethpandaops/spamoor/spamoor.NewTxPool in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:170 +0x2ac + +goroutine 563 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000be3400, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140009b0030) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xa, 0x14000201520) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 575 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x1400050ca80, 0x1400090f880?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e10078) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x16, 0x14000201840) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 762 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8410}, 0x14000d8a000, 0x14000c12080, 0x14000c16120) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 630 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 574 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x14000f020c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140009b0060) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x15, 0x14000201800) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 542 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000e02c80, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000782678) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5, 0x140002013c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 567 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x14000f02500, 0x10459ae84?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140007826a8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xe, 0x14000201620) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 573 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000e02480, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000282948) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x14, 0x140002017c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 576 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000e9a2c0, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006824b0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x17, 0x14000201880) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 565 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x140011b0980, 0x1044b30d8?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000602108) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xc, 0x140002015a0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 541 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x14000e9a040, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006820c0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4, 0x14000201380) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 568 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000e02600, 0x104458a78?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a180) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xf, 0x14000201680) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 572 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400100a780, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000282918) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x13, 0x14000201780) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 564 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x14000be2880, 0x10459ae84?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000134918) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xb, 0x14000201560) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 570 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000e02900, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140002828b8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x11, 0x14000201700) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 675 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140005005f0}, 0x140001620b0, 0x1400108a600, 0x14000be0530) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 594 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 214 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000708140}, 0x140000dc210, 0x14000890080, 0x14000710100) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 633 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 543 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x1400108a740, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682240) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x6, 0x14000201400) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 539 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x14000be2700, 0x1044b30d8?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400000e810) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2, 0x14000201300) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 158 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000600140}, 0x140001620b0, 0x1400100a0c0, 0x14000f8a0f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 634 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 569 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x14000e02a40, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a120) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x10, 0x140002016c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 566 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x140011b0e00, 0x10459ae84?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a150) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0xd, 0x140002015e0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 540 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x1400050d5c0, 0x14000538ae0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c060) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3, 0x14000201340) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 571 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x14000be2a80, 0x104458a78?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140002828e8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x12, 0x14000201740) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 526 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000780500}, 0x14000f0c000, 0x1400050c280, 0x14000d881b0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 631 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 536 [select]: +github.com/ethpandaops/spamoor/spamoor.(*WalletPool).watchWalletBalancesLoop(0x14000160360) + /Users/random_anon/dev/spamoor/spamoor/walletpool.go:609 +0x118 +created by github.com/ethpandaops/spamoor/spamoor.(*WalletPool).PrepareWallets in goroutine 1 + /Users/random_anon/dev/spamoor/spamoor/walletpool.go:481 +0x614 + +goroutine 548 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011a190}, 0x140001620b0, 0x14000be2880, 0x14000d5c1c0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 564 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 545 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x14000c7e900, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a1b0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x8, 0x14000201480) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 495 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8190}, 0x140001620b0, 0x14000e02100, 0x14000f0a0f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 624 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 562 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400050da40, 0x104458a78?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000d98150) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x9, 0x140002014e0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 690 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000680140}, 0x1400101c000, 0x140007c2080, 0x14000e92180) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 619 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 550 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011a500}, 0x1400101c000, 0x14000be2ac0, 0x14000d5c4f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 589 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 160 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140006003c0}, 0x14000d7a000, 0x1400100a340, 0x14000f8a1f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 632 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 547 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011a0a0}, 0x140000dc210, 0x14000be2740, 0x14000d5c0d0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 613 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 537 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x140011b0180, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400000e840) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x0, 0x14000201280) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 538 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x140011b0680, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000c2e018) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1, 0x140002012c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 544 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x1400050c080, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000c2e000) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x7, 0x14000201440) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 144 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fe190}, 0x14000f0c000, 0x14000c12140, 0x14000c16180) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 591 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 513 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140005003c0}, 0x140002e00b0, 0x1400108a300, 0x14000be0450) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 648 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 746 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000f3a190}, 0x14000e94000, 0x14000e9a500, 0x14000d5c570) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 625 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 496 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8370}, 0x140000dc210, 0x14000e02380, 0x14000f0a1e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 643 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 555 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000680190}, 0x14000d8a000, 0x140011b0000, 0x14000e92070) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 600 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 170 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b20f0}, 0x140000dc210, 0x140011b0180, 0x140009a80d0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 537 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 524 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140007802d0}, 0x14000d8a000, 0x1400050c080, 0x14000d880a0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 544 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 578 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000c7e600, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006824e0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x19, 0x14000201900) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 579 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x1400050c6c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682348) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1a, 0x14000201940) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 580 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x1400100a100, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c240) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1b, 0x14000201980) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 581 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400050cac0, 0x2a?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682390) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1c, 0x140002019c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 582 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400050c880, 0x1?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682378) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1d, 0x14000201a20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 583 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000e9a1c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006823a8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1e, 0x14000201a60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 584 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x140007c2a80, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006823d8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x1f, 0x14000201aa0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 585 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x14000e02740, 0x10445528c?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682408) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x20, 0x14000201ae0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 586 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x1400050d8c0, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000282888) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x21, 0x14000201b20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 587 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x1400108aac0, 0x1044b30d8?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000d981b0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x22, 0x14000201b60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 588 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x1400050d140, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c210) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x23, 0x14000201ba0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 589 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x14000be2ac0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000d982b8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x24, 0x14000201be0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 590 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000f02800, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c1e0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x25, 0x14000201c20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 591 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x14000c12140, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a318) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x26, 0x14000201c60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 592 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400108a900, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a300) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x27, 0x14000201ca0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 593 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000be3280, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e10048) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x28, 0x14000201ce0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 594 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x1400108a600, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000d98180) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x29, 0x14000201d20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 595 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x14000c7e300, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a240) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2a, 0x14000201d60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 596 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000f02980, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a270) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2b, 0x14000201da0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 597 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x140011b0b00, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a2a0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2c, 0x14000201de0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 598 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000c12740, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a2d0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2d, 0x14000201e20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 599 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x1400108ae00, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000d981e0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2e, 0x14000201e60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 600 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x140011b0000, 0x140007dcbc0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140009b00d8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x2f, 0x14000201ea0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 601 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400050d440, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000c2e048) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x30, 0x14000201ee0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 602 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x14000c128c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a210) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x31, 0x14000201f20) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 603 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x1400100a680, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000602168) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x32, 0x14000201f60) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 604 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x14000be3840, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000602198) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x33, 0x1400029a100) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 605 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x140011b0c80, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006021c8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x34, 0x1400029a180) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 606 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000c7e480, 0x2a?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000782798) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x35, 0x1400029a1c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 607 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x1400050cfc0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682318) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x36, 0x1400029a200) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 608 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000e02300, 0x1400095a420?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000782768) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x37, 0x1400029a240) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 609 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x140011b0800, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000282288) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x38, 0x1400029a280) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 610 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x140011b0440, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682330) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x39, 0x1400029a2e0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 611 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400050cc80, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682360) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3a, 0x1400029a320) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 612 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x14000be3080, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e10000) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3b, 0x1400029a360) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 613 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000be2740, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006021f8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3c, 0x1400029a3a0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 614 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x1400100a640, 0x140007dcbc0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e10030) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3d, 0x1400029a3e0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 615 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x1400108a100, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140007827c8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3e, 0x1400029a440) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 616 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x1400108ac40, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000502690) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x3f, 0x1400029a4a0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 617 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x140001161c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140009b00f0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x40, 0x1400029a4e0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 618 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x1400108b140, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140009b00c0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x41, 0x1400029a540) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 619 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x140007c2080, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000602138) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x42, 0x1400029a580) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 620 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000be2d40, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c0c0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x43, 0x1400029a5c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 621 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400100a900, 0x14000c1de20?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682120) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x44, 0x1400029a600) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 622 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400050cc40, 0x14000c1d7e0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682150) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x45, 0x1400029a640) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 623 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000c7ee00, 0x1044b30d8?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682180) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x46, 0x1400029a680) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 624 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x14000e02100, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006821b0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x47, 0x1400029a6c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 625 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x14000e9a500, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006821e0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x48, 0x1400029a700) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 626 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000e02780, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682210) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x49, 0x1400029a740) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 627 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x14000e02200, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006820f0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4a, 0x1400029a780) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 628 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x1400108af80, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c0f0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4b, 0x1400029a7c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 629 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x14000e02b40, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c120) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4c, 0x1400029a800) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 630 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000c12080, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c150) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4d, 0x1400029a840) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 631 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400050c280, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682270) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4e, 0x1400029a880) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 632 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400100a340, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000782738) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x4f, 0x1400029a8c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 633 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000890080, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c180) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x50, 0x1400029a900) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 634 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140001620b0, 0x1400100a0c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c1b0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x51, 0x1400029a940) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 635 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x140011b0200, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400080c090) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x52, 0x1400029a980) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 636 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000c7e100, 0x10474a018?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000134978) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x53, 0x1400029a9c0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 637 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x1400050d2c0, 0x10449f0bc?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140001349a8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x54, 0x1400029aa00) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 638 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x14000f02680, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140001349d8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x55, 0x1400029aa40) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 639 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x1400100aa80, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000782708) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x56, 0x1400029aa80) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 640 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000c7e780, 0x10459ae84?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140007826d8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x57, 0x1400029aac0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 641 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x14000c7ea80, 0x1044b30d8?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x1400070a1e0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x58, 0x1400029ab00) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 642 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x140008901c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e80000) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x59, 0x1400029ab40) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 643 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140000dc210, 0x14000e02380, 0x140006d1730?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000134948) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5a, 0x1400029ab80) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 645 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000e94000, 0x14000fc4580, 0x104458a78?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000502600) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5c, 0x1400029ac00) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 646 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000c18000, 0x14000c12380, 0x1044cee40?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000502630) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5d, 0x1400029ac40) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 647 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f8c000, 0x14000c125c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000282960) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5e, 0x1400029ac80) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 648 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x140002e00b0, 0x1400108a300, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000e80030) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x5f, 0x1400029acc0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 649 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x1400101c000, 0x14000fc43c0, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000502660) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x60, 0x1400029ad00) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 650 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d8a000, 0x14000c7ec00, 0x38500000394?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140006822e8) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x61, 0x1400029ad40) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 651 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000f0c000, 0x1400100a480, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x14000682300) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x62, 0x1400029ad80) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 652 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).SendAndAwaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8000}, 0x14000d7a000, 0x1400108a580, 0x0?) + /Users/random_anon/dev/spamoor/spamoor/submitter.go:170 +0x1f4 +github.com/ethpandaops/spamoor/scenarios/statebloat/storage_trie_brancher.(*Scenario).sendFundingTx(0x140002c6000, {0x104bade80, 0x140002b8000}, 0x140005025a0) + /Users/random_anon/dev/spamoor/scenarios/statebloat/storage_trie_brancher/storage_trie_brancher.go:398 +0x424 +github.com/ethpandaops/spamoor/scenario.RunTransactionScenario.func4(0x63, 0x1400029adc0) + /Users/random_anon/dev/spamoor/scenario/txscenario.go:294 +0x1c0 +created by github.com/ethpandaops/spamoor/scenario.RunTransactionScenario in goroutine 1 + /Users/random_anon/dev/spamoor/scenario/txscenario.go:254 +0xac4 + +goroutine 935 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011b450}, 0x14000e94000, 0x14000e02740, 0x140009a82a0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 585 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 937 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011b680}, 0x1400101c000, 0x14000e02a40, 0x140009a8410) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 569 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 703 [select]: +net/http.(*persistConn).writeLoop(0x1400069e240) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2590 +0x9c +created by net/http.(*Transport).dialConn in goroutine 552 + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:1945 +0x120c + +goroutine 676 [runnable]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140005007d0}, 0x1400101c000, 0x1400108a740, 0x14000be0630) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 543 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 708 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000600690}, 0x140000dc210, 0x1400100a680, 0x14000f8a310) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 603 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1018 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000601180}, 0x1400101c000, 0x1400100aa80, 0x14000710480) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 639 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 653 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140007800a0}, 0x14000f8c000, 0x14000e9a040, 0x14000794050) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 541 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 679 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000500c30}, 0x14000d7a000, 0x1400108a900, 0x14000be0830) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 592 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 710 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140006008c0}, 0x14000d7a000, 0x1400100a780, 0x14000f8a380) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 572 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 680 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000500e10}, 0x14000f8c000, 0x1400108aac0, 0x14000be0990) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 587 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 711 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a6190}, 0x14000c18000, 0x14000c7e100, 0x14000f8a100) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 636 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 528 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000780730}, 0x1400101c000, 0x1400050c6c0, 0x14000d88290) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 579 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 681 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fe1e0}, 0x14000e94000, 0x1400108a100, 0x14000f0a0f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 615 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 738 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000780960}, 0x14000d7a000, 0x1400050c880, 0x14000d88380) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 582 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 754 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b61e0}, 0x14000e94000, 0x14000be2700, 0x14000c16120) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 539 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 661 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011a410}, 0x14000f8c000, 0x14000e02200, 0x14000794160) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 627 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 682 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fe5a0}, 0x14000d7a000, 0x1400108a580, 0x14000f0a2c0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 652 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 741 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000780b90}, 0x14000f0c000, 0x1400050cac0, 0x14000d88460) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 581 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 663 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011a8c0}, 0x140002e00b0, 0x14000e02600, 0x14000794240) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 568 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 684 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fe870}, 0x14000c18000, 0x1400108ac40, 0x14000f0a390) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 616 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 756 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b6640}, 0x14000f0c000, 0x14000be2a80, 0x14000c16260) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 571 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 665 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011aaf0}, 0x14000c18000, 0x14000e02780, 0x14000794330) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 626 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 686 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000feaa0}, 0x1400101c000, 0x1400108ae00, 0x14000f0a460) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 599 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 667 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011ad20}, 0x14000d8a000, 0x14000e02900, 0x14000794440) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 570 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 743 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000780dc0}, 0x14000f0c000, 0x1400050cc80, 0x14000d88570) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 611 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 688 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fecd0}, 0x140002e00b0, 0x1400108af80, 0x14000f0a540) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 628 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 758 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b6910}, 0x14000d8a000, 0x14000be2d40, 0x14000c16350) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 620 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 669 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011b040}, 0x1400101c000, 0x14000e02b40, 0x140007945e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 629 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 770 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140000fef00}, 0x140002e00b0, 0x1400108b140, 0x14000f0a610) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 618 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 692 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400084a0f0}, 0x140001620b0, 0x14000f020c0, 0x140009a8200) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 574 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 694 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400084a320}, 0x14000f8c000, 0x14000f02500, 0x140009a82e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 567 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 696 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400084a550}, 0x140002e00b0, 0x14000f02680, 0x140009a83b0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 638 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 698 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400084a780}, 0x14000d8a000, 0x14000f02800, 0x140009a8480) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 590 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 700 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400084a9b0}, 0x14000c18000, 0x14000f02980, 0x140009a8550) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 596 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 802 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000708320}, 0x14000d7a000, 0x140008901c0, 0x14000860160) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 642 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 702 [IO wait]: +internal/poll.runtime_pollWait(0x14be77548, 0x72) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/runtime/netpoll.go:351 +0xa0 +internal/poll.(*pollDesc).wait(0x14000eb4680?, 0x1400051c000?, 0x0) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_poll_runtime.go:84 +0x28 +internal/poll.(*pollDesc).waitRead(...) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_poll_runtime.go:89 +internal/poll.(*FD).Read(0x14000eb4680, {0x1400051c000, 0x1000, 0x1000}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_unix.go:165 +0x1fc +net.(*netFD).Read(0x14000eb4680, {0x1400051c000?, 0xf?, 0x8?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/fd_posix.go:55 +0x28 +net.(*conn).Read(0x14000dea028, {0x1400051c000?, 0x14000284c30?, 0xb2fc4305bd1956b3?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/net.go:194 +0x34 +net/http.(*persistConn).Read(0x1400069e240, {0x1400051c000?, 0x104ba9888?, 0x104ee5ed0?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2122 +0x4c +bufio.(*Reader).fill(0x14000118ae0) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/bufio/bufio.go:113 +0xf8 +bufio.(*Reader).Peek(0x14000118ae0, 0x1) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/bufio/bufio.go:152 +0x60 +net/http.(*persistConn).readLoop(0x1400069e240) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2275 +0x12c +created by net/http.(*Transport).dialConn in goroutine 552 + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:1944 +0x11c4 + +goroutine 810 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000f2e050}, 0x14000f8c000, 0x140001161c0, 0x14000a02090) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 617 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 826 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000f3a5f0}, 0x14000c18000, 0x14000e9a2c0, 0x14000d5c070) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 576 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 939 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x1400011b8b0}, 0x140002e00b0, 0x14000e02c80, 0x140009a8520) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 542 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 907 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000781810}, 0x14000e94000, 0x1400050ca80, 0x14000d884e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 575 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 914 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000680af0}, 0x14000d8a000, 0x140011b0440, 0x14000e922a0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 610 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 918 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000680e10}, 0x140001620b0, 0x140011b0680, 0x14000e92380) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 538 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 920 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000681040}, 0x1400101c000, 0x140011b0800, 0x14000e92440) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 609 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 922 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000681270}, 0x14000e94000, 0x140011b0980, 0x14000e92500) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 565 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 924 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140006814a0}, 0x14000f8c000, 0x140011b0b00, 0x14000e925d0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 597 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 926 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140006816d0}, 0x14000e94000, 0x140011b0c80, 0x14000e92690) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 605 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 928 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000681900}, 0x14000c18000, 0x140011b0e00, 0x14000e92760) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 566 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 910 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000781950}, 0x14000d7a000, 0x1400050cc40, 0x14000d88a80) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 622 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 912 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000781b80}, 0x14000f8c000, 0x1400050cfc0, 0x14000d88b50) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 607 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 946 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000781db0}, 0x140002e00b0, 0x1400050d140, 0x14000d88c10) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 588 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 948 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b2230}, 0x14000f8c000, 0x1400050d2c0, 0x14000d88cd0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 637 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 950 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b3220}, 0x14000f0c000, 0x1400050d440, 0x14000d88da0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 601 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 952 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b3450}, 0x14000c18000, 0x1400050d5c0, 0x14000d88e60) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 540 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 848 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140006001e0}, 0x14000d8a000, 0x1400100a100, 0x14000710150) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 580 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 764 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b86e0}, 0x14000f8c000, 0x14000c125c0, 0x14000c162e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 647 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1010 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000600820}, 0x14000f0c000, 0x1400100a480, 0x14000710220) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 651 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 766 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8910}, 0x140002e00b0, 0x14000c12740, 0x14000c16420) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 598 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1340 [IO wait]: +internal/poll.runtime_pollWait(0x14bf638f0, 0x72) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/runtime/netpoll.go:351 +0xa0 +internal/poll.(*pollDesc).wait(0x1400152c380?, 0x1400040e000?, 0x0) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_poll_runtime.go:84 +0x28 +internal/poll.(*pollDesc).waitRead(...) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_poll_runtime.go:89 +internal/poll.(*FD).Read(0x1400152c380, {0x1400040e000, 0x1000, 0x1000}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/internal/poll/fd_unix.go:165 +0x1fc +net.(*netFD).Read(0x1400152c380, {0x1400040e000?, 0xf?, 0x8?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/fd_posix.go:55 +0x28 +net.(*conn).Read(0x1400050a090, {0x1400040e000?, 0x14000284c30?, 0x901bacedd0dd58eb?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/net.go:194 +0x34 +net/http.(*persistConn).Read(0x1400150a120, {0x1400040e000?, 0x104ba9888?, 0x104ee5ed0?}) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2122 +0x4c +bufio.(*Reader).fill(0x140011a42a0) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/bufio/bufio.go:113 +0xf8 +bufio.(*Reader).Peek(0x140011a42a0, 0x1) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/bufio/bufio.go:152 +0x60 +net/http.(*persistConn).readLoop(0x1400150a120) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2275 +0x12c +created by net/http.(*Transport).dialConn in goroutine 1432 + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:1944 +0x11c4 + +goroutine 1229 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140015d0b90}, 0x14000e94000, 0x14000fc4580, 0x14000be06d0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 645 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1016 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000600f50}, 0x14000f0c000, 0x1400100a900, 0x140007103c0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 621 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1012 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000600af0}, 0x140001620b0, 0x1400100a640, 0x140007102f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 614 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 768 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8b90}, 0x14000d7a000, 0x14000c128c0, 0x14000c164f0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 602 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 713 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a63c0}, 0x14000e94000, 0x14000c7e300, 0x14000f8a260) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 595 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 957 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b38b0}, 0x14000c18000, 0x1400050d8c0, 0x14000d88fc0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 586 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 959 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b3ae0}, 0x14000d7a000, 0x1400050da40, 0x14000d89080) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 562 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 715 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a65f0}, 0x14000c18000, 0x14000c7e480, 0x14000f8a3a0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 606 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 717 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a6820}, 0x140002e00b0, 0x14000c7e600, 0x14000f8a460) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 578 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 719 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a6a50}, 0x14000d8a000, 0x14000c7e780, 0x14000f8a520) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 640 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 721 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a6c80}, 0x14000f0c000, 0x14000c7e900, 0x14000f8a5e0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 545 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1107 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a6eb0}, 0x14000f0c000, 0x14000c7ea80, 0x14000f8a6b0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 641 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1109 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a70e0}, 0x14000d8a000, 0x14000c7ec00, 0x14000f8a770) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 650 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1133 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b71d0}, 0x14000d7a000, 0x14000be3080, 0x14000794290) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 612 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1135 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b7400}, 0x140000dc210, 0x14000be3280, 0x14000794490) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 593 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1137 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b7630}, 0x140000dc210, 0x14000be3400, 0x14000794640) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 563 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1181 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009b7d60}, 0x140001620b0, 0x14000be3840, 0x140007946b0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 604 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1065 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000501ea0}, 0x140001620b0, 0x140007c2a80, 0x14000be0560) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 584 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1111 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140009a7360}, 0x140000dc210, 0x14000c7ee00, 0x14000f8a8b0) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 623 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1431 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140002b8500}, 0x14000c18000, 0x14000c12380, 0x14000e92140) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 646 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1384 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x14000faea50}, 0x14000e94000, 0x140011b0200, 0x14000d88160) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 635 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1228 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140015d09b0}, 0x1400101c000, 0x14000fc43c0, 0x14000be0340) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 649 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 + +goroutine 1341 [select]: +net/http.(*persistConn).writeLoop(0x1400150a120) + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:2590 +0x9c +created by net/http.(*Transport).dialConn in goroutine 1432 + /Users/random_anon/go/pkg/mod/golang.org/toolchain@v0.0.1-go1.24.1.darwin-arm64/src/net/http/transport.go:1945 +0x120c + +goroutine 1338 [select]: +github.com/ethpandaops/spamoor/spamoor.(*TxPool).awaitTransaction(0x1400017a000, {0x104bade80, 0x140014fd040}, 0x140000dc210, 0x14000e9a1c0, 0x14000d5c210) + /Users/random_anon/dev/spamoor/spamoor/txpool.go:995 +0xf4 +github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction.func1() + /Users/random_anon/dev/spamoor/spamoor/txpool.go:882 +0xb8 +created by github.com/ethpandaops/spamoor/spamoor.(*TxPool).submitTransaction in goroutine 583 + /Users/random_anon/dev/spamoor/spamoor/txpool.go:841 +0x150 diff --git a/spamoor_test2.log b/spamoor_test2.log new file mode 100644 index 0000000..e80a6ef --- /dev/null +++ b/spamoor_test2.log @@ -0,0 +1,189 @@ +time="2025-12-22T11:21:44+01:00" level=info msg="starting spamoor" buildtime= version=git- +time="2025-12-22T11:21:44+01:00" level=info msg="initialized client pool with 1 clients (chain id: 1337)" module=clientpool +time="2025-12-22T11:21:44+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:21:44+01:00" level=info msg="initialized root wallet (addr: 0xFABB0ac9d68B0B445fB7357272Ff202C5651694a balance: 49 ETH, nonce: 10)" +time="2025-12-22T11:21:44+01:00" level=info msg="processed block 931: 0 total tx, 0 tx confirmed from 0 wallets (424.791µs, 14.541µs)" +time="2025-12-22T11:21:45+01:00" level=info msg="Compiled contract, init code size: 1870 bytes" scenario=storage-trie-brancher +time="2025-12-22T11:21:45+01:00" level=info msg="initialized storage trie brancher scenario" account_depth=3 contract_file=scenarios/statebloat/storage_trie_brancher/depth_9.sol contracts=10 data_file=scenarios/statebloat/storage_trie_brancher/s9_acc3.json scenario=storage-trie-brancher storage_depth=9 +time="2025-12-22T11:21:45+01:00" level=info msg="root wallet is locked, insufficient root wallet balance. awaiting addtional funds. needed: 51 ETH" module=walletpool +time="2025-12-22T11:21:50+01:00" level=info msg="processed block 932: 0 total tx, 0 tx confirmed from 0 wallets (438.625µs, 2.125µs)" +time="2025-12-22T11:21:57+01:00" level=info msg="processed block 933: 0 total tx, 0 tx confirmed from 0 wallets (618.458µs, 6.167µs)" +time="2025-12-22T11:21:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:03+01:00" level=info msg="processed block 934: 0 total tx, 0 tx confirmed from 0 wallets (309.708µs, 1.958µs)" +time="2025-12-22T11:22:09+01:00" level=info msg="processed block 935: 0 total tx, 0 tx confirmed from 0 wallets (397.833µs, 3.542µs)" +time="2025-12-22T11:22:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:15+01:00" level=info msg="processed block 936: 0 total tx, 0 tx confirmed from 0 wallets (1.156334ms, 4.875µs)" +time="2025-12-22T11:22:21+01:00" level=info msg="processed block 937: 0 total tx, 0 tx confirmed from 0 wallets (629.625µs, 4.333µs)" +time="2025-12-22T11:22:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:27+01:00" level=info msg="processed block 938: 0 total tx, 0 tx confirmed from 0 wallets (712.917µs, 5.125µs)" +time="2025-12-22T11:22:33+01:00" level=info msg="processed block 939: 0 total tx, 0 tx confirmed from 0 wallets (792.375µs, 4.916µs)" +time="2025-12-22T11:22:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:39+01:00" level=info msg="processed block 940: 0 total tx, 0 tx confirmed from 0 wallets (664µs, 5.625µs)" +time="2025-12-22T11:22:45+01:00" level=info msg="processed block 941: 0 total tx, 0 tx confirmed from 0 wallets (939.709µs, 5.333µs)" +time="2025-12-22T11:22:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:51+01:00" level=info msg="processed block 942: 0 total tx, 0 tx confirmed from 0 wallets (909.625µs, 6.792µs)" +time="2025-12-22T11:22:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:22:57+01:00" level=info msg="processed block 943: 0 total tx, 0 tx confirmed from 0 wallets (628.334µs, 3.625µs)" +time="2025-12-22T11:23:03+01:00" level=info msg="processed block 944: 0 total tx, 0 tx confirmed from 0 wallets (523.167µs, 2.125µs)" +time="2025-12-22T11:23:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:23:09+01:00" level=info msg="processed block 945: 0 total tx, 0 tx confirmed from 0 wallets (455.709µs, 3.041µs)" +time="2025-12-22T11:23:15+01:00" level=info msg="processed block 946: 0 total tx, 0 tx confirmed from 0 wallets (354.542µs, 3.916µs)" +time="2025-12-22T11:23:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:23:21+01:00" level=info msg="processed block 947: 0 total tx, 0 tx confirmed from 0 wallets (635.625µs, 6.292µs)" +time="2025-12-22T11:23:27+01:00" level=info msg="processed block 948: 0 total tx, 0 tx confirmed from 0 wallets (407.792µs, 5.208µs)" +time="2025-12-22T11:23:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:23:33+01:00" level=info msg="processed block 949: 0 total tx, 0 tx confirmed from 0 wallets (323.166µs, 3.042µs)" +time="2025-12-22T11:23:39+01:00" level=info msg="processed block 950: 0 total tx, 0 tx confirmed from 0 wallets (559.916µs, 5.792µs)" +time="2025-12-22T11:23:44+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:23:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:23:45+01:00" level=info msg="processed block 951: 0 total tx, 0 tx confirmed from 0 wallets (1.116875ms, 7.208µs)" +time="2025-12-22T11:23:51+01:00" level=info msg="processed block 952: 0 total tx, 0 tx confirmed from 0 wallets (557.791µs, 6.417µs)" +time="2025-12-22T11:23:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:23:57+01:00" level=info msg="processed block 953: 0 total tx, 0 tx confirmed from 0 wallets (634.583µs, 5.875µs)" +time="2025-12-22T11:24:03+01:00" level=info msg="processed block 954: 0 total tx, 0 tx confirmed from 0 wallets (1.096833ms, 5.375µs)" +time="2025-12-22T11:24:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:24:09+01:00" level=info msg="processed block 955: 0 total tx, 0 tx confirmed from 0 wallets (672.5µs, 2.916µs)" +time="2025-12-22T11:24:15+01:00" level=info msg="processed block 956: 0 total tx, 0 tx confirmed from 0 wallets (1.348167ms, 6µs)" +time="2025-12-22T11:24:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:24:21+01:00" level=info msg="processed block 957: 0 total tx, 0 tx confirmed from 0 wallets (767.25µs, 5.583µs)" +time="2025-12-22T11:24:27+01:00" level=info msg="processed block 958: 0 total tx, 0 tx confirmed from 0 wallets (689.5µs, 5.833µs)" +time="2025-12-22T11:24:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:24:33+01:00" level=info msg="processed block 959: 0 total tx, 0 tx confirmed from 0 wallets (1.126209ms, 7.292µs)" +time="2025-12-22T11:24:39+01:00" level=info msg="processed block 960: 0 total tx, 0 tx confirmed from 0 wallets (1.454292ms, 3.625µs)" +time="2025-12-22T11:24:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:24:45+01:00" level=info msg="processed block 961: 0 total tx, 0 tx confirmed from 0 wallets (1.030334ms, 5.333µs)" +time="2025-12-22T11:24:51+01:00" level=info msg="processed block 962: 0 total tx, 0 tx confirmed from 0 wallets (983.416µs, 5.5µs)" +time="2025-12-22T11:24:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:24:57+01:00" level=info msg="processed block 963: 0 total tx, 0 tx confirmed from 0 wallets (574µs, 2.417µs)" +time="2025-12-22T11:25:03+01:00" level=info msg="processed block 964: 0 total tx, 0 tx confirmed from 0 wallets (1.326208ms, 7.125µs)" +time="2025-12-22T11:25:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:25:09+01:00" level=info msg="processed block 965: 0 total tx, 0 tx confirmed from 0 wallets (1.026458ms, 9.917µs)" +time="2025-12-22T11:25:15+01:00" level=info msg="processed block 966: 0 total tx, 0 tx confirmed from 0 wallets (1.128541ms, 7µs)" +time="2025-12-22T11:25:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:25:21+01:00" level=info msg="processed block 967: 0 total tx, 0 tx confirmed from 0 wallets (444.583µs, 5.583µs)" +time="2025-12-22T11:25:27+01:00" level=info msg="processed block 968: 0 total tx, 0 tx confirmed from 0 wallets (477.667µs, 3.083µs)" +time="2025-12-22T11:25:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:25:33+01:00" level=info msg="processed block 969: 0 total tx, 0 tx confirmed from 0 wallets (1.096458ms, 7.125µs)" +time="2025-12-22T11:25:39+01:00" level=info msg="processed block 970: 0 total tx, 0 tx confirmed from 0 wallets (961.542µs, 6.583µs)" +time="2025-12-22T11:25:44+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:25:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:25:45+01:00" level=info msg="processed block 971: 0 total tx, 0 tx confirmed from 0 wallets (491.916µs, 4.875µs)" +time="2025-12-22T11:25:51+01:00" level=info msg="processed block 972: 0 total tx, 0 tx confirmed from 0 wallets (415.5µs, 3.834µs)" +time="2025-12-22T11:25:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:25:57+01:00" level=info msg="processed block 973: 0 total tx, 0 tx confirmed from 0 wallets (496.583µs, 3.25µs)" +time="2025-12-22T11:26:03+01:00" level=info msg="processed block 974: 0 total tx, 0 tx confirmed from 0 wallets (668.708µs, 5.875µs)" +time="2025-12-22T11:26:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:26:09+01:00" level=info msg="processed block 975: 0 total tx, 0 tx confirmed from 0 wallets (1.149292ms, 5.25µs)" +time="2025-12-22T11:26:15+01:00" level=info msg="processed block 976: 0 total tx, 0 tx confirmed from 0 wallets (1.274959ms, 9.125µs)" +time="2025-12-22T11:26:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:26:21+01:00" level=info msg="processed block 977: 0 total tx, 0 tx confirmed from 0 wallets (958.583µs, 5.416µs)" +time="2025-12-22T11:26:27+01:00" level=info msg="processed block 978: 0 total tx, 0 tx confirmed from 0 wallets (508.25µs, 2.292µs)" +time="2025-12-22T11:26:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:26:33+01:00" level=info msg="processed block 979: 0 total tx, 0 tx confirmed from 0 wallets (830.833µs, 6.041µs)" +time="2025-12-22T11:26:39+01:00" level=info msg="processed block 980: 0 total tx, 0 tx confirmed from 0 wallets (317.417µs, 2.916µs)" +time="2025-12-22T11:26:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:26:45+01:00" level=info msg="processed block 981: 0 total tx, 0 tx confirmed from 0 wallets (829.458µs, 7.416µs)" +time="2025-12-22T11:26:51+01:00" level=info msg="processed block 982: 0 total tx, 0 tx confirmed from 0 wallets (719.708µs, 8.042µs)" +time="2025-12-22T11:26:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:26:57+01:00" level=info msg="processed block 983: 0 total tx, 0 tx confirmed from 0 wallets (1.245208ms, 7.917µs)" +time="2025-12-22T11:27:03+01:00" level=info msg="processed block 984: 0 total tx, 0 tx confirmed from 0 wallets (507.958µs, 2.666µs)" +time="2025-12-22T11:27:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:27:09+01:00" level=info msg="processed block 985: 0 total tx, 0 tx confirmed from 0 wallets (928.75µs, 6.541µs)" +time="2025-12-22T11:27:15+01:00" level=info msg="processed block 986: 0 total tx, 0 tx confirmed from 0 wallets (1.02225ms, 6.709µs)" +time="2025-12-22T11:27:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:27:21+01:00" level=info msg="processed block 987: 0 total tx, 0 tx confirmed from 0 wallets (381.042µs, 4.916µs)" +time="2025-12-22T11:27:27+01:00" level=info msg="processed block 988: 0 total tx, 0 tx confirmed from 0 wallets (948.208µs, 6.833µs)" +time="2025-12-22T11:27:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:27:33+01:00" level=info msg="processed block 989: 0 total tx, 0 tx confirmed from 0 wallets (1.328125ms, 6.667µs)" +time="2025-12-22T11:27:39+01:00" level=info msg="processed block 990: 0 total tx, 0 tx confirmed from 0 wallets (1.218458ms, 6.292µs)" +time="2025-12-22T11:27:45+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:27:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:27:45+01:00" level=info msg="processed block 991: 0 total tx, 0 tx confirmed from 0 wallets (1.431042ms, 7.875µs)" +time="2025-12-22T11:27:51+01:00" level=info msg="processed block 992: 0 total tx, 0 tx confirmed from 0 wallets (750.833µs, 7.125µs)" +time="2025-12-22T11:27:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:27:57+01:00" level=info msg="processed block 993: 0 total tx, 0 tx confirmed from 0 wallets (1.16225ms, 6.125µs)" +time="2025-12-22T11:28:03+01:00" level=info msg="processed block 994: 0 total tx, 0 tx confirmed from 0 wallets (503.333µs, 4.917µs)" +time="2025-12-22T11:28:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:28:09+01:00" level=info msg="processed block 995: 0 total tx, 0 tx confirmed from 0 wallets (576.667µs, 4.083µs)" +time="2025-12-22T11:28:15+01:00" level=info msg="processed block 996: 0 total tx, 0 tx confirmed from 0 wallets (969.25µs, 5.25µs)" +time="2025-12-22T11:28:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:28:21+01:00" level=info msg="processed block 997: 0 total tx, 0 tx confirmed from 0 wallets (1.113458ms, 6µs)" +time="2025-12-22T11:28:27+01:00" level=info msg="processed block 998: 0 total tx, 0 tx confirmed from 0 wallets (1.029709ms, 7.292µs)" +time="2025-12-22T11:28:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:28:33+01:00" level=info msg="processed block 999: 0 total tx, 0 tx confirmed from 0 wallets (891.625µs, 6.584µs)" +time="2025-12-22T11:28:39+01:00" level=info msg="processed block 1000: 0 total tx, 0 tx confirmed from 0 wallets (862.833µs, 4.667µs)" +time="2025-12-22T11:28:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:28:45+01:00" level=info msg="processed block 1001: 0 total tx, 0 tx confirmed from 0 wallets (619.834µs, 4.75µs)" +time="2025-12-22T11:28:51+01:00" level=info msg="processed block 1002: 0 total tx, 0 tx confirmed from 0 wallets (584.542µs, 3.084µs)" +time="2025-12-22T11:28:57+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:28:57+01:00" level=info msg="processed block 1003: 0 total tx, 0 tx confirmed from 0 wallets (810.959µs, 7.125µs)" +time="2025-12-22T11:29:03+01:00" level=info msg="processed block 1004: 0 total tx, 0 tx confirmed from 0 wallets (609.875µs, 5.583µs)" +time="2025-12-22T11:29:09+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:29:09+01:00" level=info msg="processed block 1005: 0 total tx, 0 tx confirmed from 0 wallets (892.708µs, 8.125µs)" +time="2025-12-22T11:29:15+01:00" level=info msg="processed block 1006: 0 total tx, 0 tx confirmed from 0 wallets (864.084µs, 4.833µs)" +time="2025-12-22T11:29:21+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:29:21+01:00" level=info msg="processed block 1007: 0 total tx, 0 tx confirmed from 0 wallets (541.792µs, 4.042µs)" +time="2025-12-22T11:29:27+01:00" level=info msg="processed block 1008: 0 total tx, 0 tx confirmed from 0 wallets (900.292µs, 6.625µs)" +time="2025-12-22T11:29:33+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:29:33+01:00" level=info msg="processed block 1009: 0 total tx, 0 tx confirmed from 0 wallets (545.209µs, 4.917µs)" +time="2025-12-22T11:29:39+01:00" level=info msg="processed block 1010: 0 total tx, 0 tx confirmed from 0 wallets (1.529625ms, 7.083µs)" +time="2025-12-22T11:29:45+01:00" level=info msg="client check completed (1 good clients, 0 bad clients)" module=clientpool +time="2025-12-22T11:29:45+01:00" level=info msg="waiting for root wallet funding. Current: 49 ETH, still need: 1 ETH" +time="2025-12-22T11:29:45+01:00" level=info msg="processed block 1011: 0 total tx, 0 tx confirmed from 0 wallets (679.458µs, 5.834µs)" +time="2025-12-22T11:29:51+01:00" level=info msg="processed block 1012: 1 total tx, 0 tx confirmed from 0 wallets (426.25µs, 192.541µs)" +time="2025-12-22T11:29:57+01:00" level=info msg="funding child wallets... (0/10)" module=walletpool +time="2025-12-22T11:29:57+01:00" level=info msg="processed block 1013: 0 total tx, 0 tx confirmed from 0 wallets (315.709µs, 2.375µs)" +time="2025-12-22T11:30:03+01:00" level=info msg="processed block 1014: 10 total tx, 10 tx confirmed from 1 wallets (2.022ms, 759.292µs)" +time="2025-12-22T11:30:03+01:00" level=info msg="initialized 10 child wallets" module=walletpool +time="2025-12-22T11:30:03+01:00" level=info msg="Phase 1: Funding auxiliary accounts" scenario=storage-trie-brancher +time="2025-12-22T11:30:03+01:00" level=info msg="Total unique auxiliary accounts to fund: 30" scenario=storage-trie-brancher +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 30: 0x04cdfb59808f72bd363d5931e128de808bd6ef997bc07bdab07deb559d148b36 to 0x4343e2ae9abbfdba0aa7d1225c275ed1e6f00e31" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=10 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 14: 0x5df1f7d0e357ed993b1f654517bf83daff71a1691bccd75e57da1273c1253a6a to 0x0773103e2026e25890c0eaffd929eb7271e344cb" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=4 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 18: 0xc50d7b41f76d3650d79ad220956205893b87abf144c343711ed29ad0b6a2b9bd to 0x2b721072c4fe4f955378dc36fe3834bd8f0f484f" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=8 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 1: 0xbd7040aa94299050a875c23f179f0a83530435cbdcbede01d5b1f57b63dbd121 to 0xe0edaf8adb497c92b7ed31a39752f3f625a373b5" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=1 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 22: 0x92999713f2be4620b87b80d3460221c430cdf3c8cd8721db131bcf200df56733 to 0x5485b886e74f3a7a7530b40d306437f5967f3613" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=2 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 4: 0x68b279f6a020e422e9a8a565e0e563e82e8acefc03457db7198016361f2cb055 to 0x4eb376d917de77c432927e7541971fafd99d4ea4" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=4 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 10: 0x3d73a8130e32834d268014e62cdeb302ec384652965c2b0f53b29a94fab1088d to 0xbbc3c1390eab0bb3ef3dbdebc62a24903d2a33d7" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=10 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 8: 0xeb2b7a7a7ee72961e3c1b454b3eada875b2d62de3aa076404b795c523c11bd05 to 0x8104633b06773a7b2038c8fcaaf2a375e3ad8f5e" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=8 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 20: 0xf208396ccfeac9bf81ded0248200ba28d6c54084ba12ac100fd5718b467050e9 to 0xa58f77279e40a07be0ca1fcde0e9e22a2e1152dd" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=10 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 5: 0x60b1bcb84d0b2704a866e2487303a73adb6e3c07feb591f7ebdc9b16f6d67994 to 0xe10370a3794ee2fed9c8058be2a7f98c0aeca95f" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=5 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 6: 0x9d724e9b11fc3fb3fabe1027384276fdb226c83ed93b2e78db30ee142dc25b45 to 0xded36c055104964abe7f45419379879775e6fe67" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=6 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 16: 0x49ccec528ab443409f7e76fd706cac99567ad0ebd8b586da76f5f25d5213b7a9 to 0x0b9bcecfe5b86397c9304c5e5c1122d22f2ccdd0" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=6 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 26: 0x23539b64bbb5def38ea298fe7e0703e00b4087739dd4d189e6919bee19105d72 to 0xe2fe872901ec2c7eee80a818a47fcc193f8f6c84" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=6 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 3: 0x7ea1ae51cf25514fa563ae7a800f69e5098ebd91a3ba52af140340e5113c428e to 0x1d00b0e559030297853c5746b14ffc054ac0878b" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=3 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 2: 0x39cb540c41d41b574181147bf6469aeccb9e1769dfbbb0e81640dc76d97ebc9c to 0x6a62703a01592f1fde45c2c29d9effc8d631c3f0" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=2 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 12: 0x222e94796a27715ced16726db8c8e90603f4ec519b6c4d70c3ce1a2b604fe624 to 0x9b9091a48e9fc72e399bc5ea9e5dffef7056cc0f" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=2 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 23: 0x20d51e1e370f17fc3921cef1f31b94245359aa472844e9ed0f7d86fb72d4bf01 to 0xd9a87069bd5034e94f872ff8ebd4d2cbeeea7340" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=3 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 13: 0x7898b35d3679c8fe4f8e2216e40efd7b85195bc7ac7a1f32a9d5c7e5d55a70fc to 0x1b1e0166b6d5ec1b1154f2a36dc6d25c1a92ac39" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=3 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 28: 0x3c0fdfea69573c9b2a719a32d408cfc8e641d06fa1380bd2aa986305f291b876 to 0xaf32e1f91cf0e3ee8fe906d1f88005872120b441" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=8 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 7: 0x204bbfc13efac4828e1a83aadac85d7d461147490353069fd1168a4367b3d6e2 to 0x33dd9bdf7168f3fe1dc6a69f883f03f6f12120e3" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=7 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 27: 0xfdfec8c9a95bd9163501d2ed37b830ecd6b8fa856e5207f303112769368569bb to 0x90d6414112e7a9a184a8859ac622c0755cdd6726" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=7 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 17: 0xe43724605c895343b500be5ac747e4d16348deea70143494ebea6504e532d57d to 0xe7b6086e50ea91f71bdd4a90be1a2fa54a19d7bf" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=7 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 15: 0x95cda37ab269f73de192b2c249f009ec1c5cfe00754797b5e63c5a33f90f62e8 to 0x460e6f08338ec3a5fe9a4f18ccf34d774c75381a" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=5 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 25: 0x2046185f2426f3ba9ab89072e0e2973d0ea3d41cc6efd695e15af4d26e6e2afe to 0x3aa0217c1f33a050c47d576500d75a924f864a64" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=5 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 24: 0x786f67c0298f22f0caf73dc011bdc7f9fef9067babf6f7a7cf9cc3f05f63a872 to 0xf96d1ad6e1f6227caa4a0fcbff8207cc4301bbdd" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=4 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 9: 0x8960fc22336a8aca38d3ed834e73f058816f3190a4fd2ea2f4d2d15ef042e3dc to 0x058e15417f3a06220fee658c1b212e0a160ec80b" nonce=0 rpc="localhost:8545" scenario=storage-trie-brancher wallet=9 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 29: 0x69bd616f9e76b808c2840f777e7fa5f8001e9479dba70f0e94cf953ba82121aa to 0x4ab617cc8c21e8f94e90f12fb385b5e7c07cd7c3" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=9 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 19: 0x8f8d141e317769c88457440fb8f9d38cde546e5598036fe1ccea47d48aa25566 to 0x9bd9e77578899b168bcc3657f39b1ed0a7c17f19" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=9 +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 11: 0x4ab637ef4d2de8ad09caa469f0357d9617f523100c0c8e33b2d982e77ce2df2d to 0xd5890c51cd2070add5c3b001059c8b773dcef730" nonce=1 rpc="localhost:8545" scenario=storage-trie-brancher wallet=1 +time="2025-12-22T11:30:09+01:00" level=info msg="processed block 1015: 30 total tx, 30 tx confirmed from 10 wallets (3.301ms, 4.36825ms)" +time="2025-12-22T11:30:09+01:00" level=info msg="sent funding tx # 21: 0xf9fe5b38893a6a07ec045ffdaa37fceccbf2a650e8a69305348354cb331b7bf2 to 0xe25e73f13c319895f3fab5d4365ef228dc43211d" nonce=2 rpc="localhost:8545" scenario=storage-trie-brancher wallet=1 +time="2025-12-22T11:30:09+01:00" level=info msg="Funded 30 auxiliary accounts" scenario=storage-trie-brancher +time="2025-12-22T11:30:09+01:00" level=info msg="Phase 2: Deploying contracts via Nick's factory" scenario=storage-trie-brancher +time="2025-12-22T11:30:09+01:00" level=info msg="block 1015: submitted=30, pending=0, confirmed=30, throughput: 5B=30.00 tx/B, 20B=30.00 tx/B, 60B=30.00 tx/B" scenario=storage-trie-brancher wallets=10 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 2: 0xb6bc2c7771b6e3157ff86b74d0b3e79717af2200899329272df858767252196f (contract: 0x1Fa25EDA39aD5E256C00A805732f449D97AC5b7F)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=2 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 10: 0xb1cc411338f5508952a9a0149c7562b383e79840a1d78069aeb602adac951997 (contract: 0x7f7BEDc0F00617fBa88eE895F346ABF16A5660fb)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=10 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 5: 0xc0869ee94b3c79ec2d0cbf1b6a22df03b5ba2683aab1ce5a84cdf608ef4bd4a3 (contract: 0xd63A1339627c1e14dC1f8c632c03C0CAE55667F7)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=5 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 1: 0x856f7b0520a63ce538797cc1db9b02bdce83bfe4acef80702df3810edcff7bb7 (contract: 0x64b0879E1Dd6637c0A56CcE9d4b24DBee095c6DC)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=1 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 4: 0xcc028cbaaff79128971cf06993d1c104c1c7d6249658386d23650eb950ec6d88 (contract: 0x91EE288937E5Ac8dCeCa64759b714cF141146b03)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=4 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 7: 0x74543896763a4ccdebdaa3e138a7ee4480e14f7f62ee141fb7af70f9913e7ee6 (contract: 0x4d51c7842c380BaD2Dc1c904cb67038a599b75F9)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=7 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 8: 0xe16162dfbe0d7d2367384a6aedbd49e971c4533e827d1d256024bc9d4c3f72e0 (contract: 0x279831D1933c33F57ab46690bF0D01A011cc336e)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=8 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 6: 0x4dd6f4c58ed362d65bfd575b68b62e9b9279bc99ac2c8470205256836ccca3e0 (contract: 0x2c303B8f04500e74cDa725F170662e0Ed8d8eB32)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=6 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 9: 0x9f44c83733da0c98c0243f855272f65ed562599a6cf9061d158509b921a7838c (contract: 0xBB47D3115f13b3ea43640bF53Ae57F29E3BF0179)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=9 +time="2025-12-22T11:30:15+01:00" level=info msg="processed block 1016: 10 total tx, 10 tx confirmed from 10 wallets (1.123958ms, 1.373333ms)" +time="2025-12-22T11:30:15+01:00" level=info msg="block 1016: submitted=40, pending=0, confirmed=10, throughput: 5B=10.00 tx/B, 20B=10.00 tx/B, 60B=10.00 tx/B" scenario=storage-trie-brancher wallets=10 +time="2025-12-22T11:30:15+01:00" level=info msg="sent deployment tx # 3: 0x847ed3cce8f4e6cd5cda664f0409fb47cd7ee783ca0598b230fd49bd7b1a2c5e (contract: 0x2125fCE343EA04Df58FEe480f2fBb99F2d318471)" nonce=3 rpc="localhost:8545" scenario=storage-trie-brancher wallet=3 +time="2025-12-22T11:30:15+01:00" level=info msg="Deployed 10 contracts" scenario=storage-trie-brancher +time="2025-12-22T11:30:15+01:00" level=info msg="Deployment info saved to scenarios/statebloat/storage_trie_brancher/deployed_contracts.json" scenario=storage-trie-brancher +time="2025-12-22T11:30:15+01:00" level=info msg="Contract addresses saved to scenarios/statebloat/storage_trie_brancher/stubs.json" scenario=storage-trie-brancher +time="2025-12-22T11:30:15+01:00" level=info msg="storage trie brancher scenario completed" accounts_funded=30 contracts_deployed=10 scenario=storage-trie-brancher diff --git a/test_depth_12.yaml b/test_depth_12.yaml new file mode 100644 index 0000000..1aaa0b0 --- /dev/null +++ b/test_depth_12.yaml @@ -0,0 +1,23 @@ +# Test mining 1 branch at depth 12 nibbles +# This will test how long it takes to find a 12-nibble collision + +target_branches: 1 # Just find 1 branch +target_depth: 12 # Exactly 12 nibbles deep (6 bytes) +seed: "depth-12-test" # Deterministic seed + +# Mining configuration +mining_workers: 8 # Use 8 parallel workers +batch_size: 1 # 1 address per tx +mining_iterations: 100000000 # 100M iterations per round (depth 12 needs many) + +# Checkpointing +checkpoint_every: 1 # Save after the single transaction + +# Gas settings +basefee: 1 +tipfee: 1 +gas_limit: 5000000 # 5M gas + +# Tracking +min_recordable: 10 # Track branches >= 10 nibbles +max_tracked: 100 # Keep top 100 branches \ No newline at end of file diff --git a/test_depth_verification.sh b/test_depth_verification.sh new file mode 100755 index 0000000..b037610 --- /dev/null +++ b/test_depth_verification.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +echo "=== Storage Trie Branch Depth Verification Test ===" +echo "" +echo "This test demonstrates how to verify that branches are exactly 3 nibbles deep" +echo "" + +# Test addresses that would create different depths +echo "Example 1: Testing a random address" +echo "----------------------------------------" +go run verify_branch_depth.go 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7 + +echo "" +echo "Example 2: Testing another address" +echo "----------------------------------------" +go run verify_branch_depth.go 0x5aAeb6053f3E94C9b9A09f33669435E7Ef1BeAed + +echo "" +echo "How to verify depth 3:" +echo "----------------------" +echo "1. Look at the computed storage slot" +echo "2. Check if exactly the first 3 nibbles match the target prefix" +echo "3. The 4th nibble must be different (divergence point)" +echo "" +echo "For example:" +echo " Target prefix: 0xABC..." +echo " Storage slot: 0xABC7... → Depth 3 ✓ (first 3 match, 4th differs)" +echo " Storage slot: 0xAB57... → Depth 2 ✗ (only 2 match)" +echo " Storage slot: 0xABCD... → Depth 4 ✗ (too deep)" \ No newline at end of file diff --git a/test_storage_trie_brancher.yaml b/test_storage_trie_brancher.yaml new file mode 100644 index 0000000..2dde3e4 --- /dev/null +++ b/test_storage_trie_brancher.yaml @@ -0,0 +1,27 @@ +# Storage Trie Brancher Test Configuration +# This scenario creates deep branches in Ethereum storage tries through hash collisions + +# Core parameters +target_branches: 10 # Create 10 branches for testing +target_depth: 16 # Each exactly 16 nibbles deep (8 bytes) +seed: "trie-branch-test-1" # Deterministic seed for reproducibility + +# Mining configuration +mining_workers: 4 # 4 parallel mining threads +batch_size: 1 # 1 address per tx (for exact depth targeting) +mining_iterations: 100000 # Try 100k addresses per round + +# Checkpointing +checkpoint_every: 5 # Save every 5 transactions + +# Gas settings +basefee: 1 +tipfee: 1 +gas_limit: 10000000 # 10M gas per transaction + +# Tracking +min_recordable: 12 # Only track branches >= 12 nibbles +max_tracked: 100 # Keep top 100 branches + +# Wallet configuration (inherits from global settings) +wallet_count: 5 # Use 5 wallets for parallelism \ No newline at end of file diff --git a/test_trie_brancher_depth3.yaml b/test_trie_brancher_depth3.yaml new file mode 100644 index 0000000..884b3f5 --- /dev/null +++ b/test_trie_brancher_depth3.yaml @@ -0,0 +1,23 @@ +# Storage Trie Brancher Test - Depth 3 nibbles +# Testing with 10 branches at depth 3 + +target_branches: 10 # Create 10 branches +target_depth: 3 # Each exactly 3 nibbles deep +seed: "test-depth-3" # Deterministic seed + +# Mining configuration +mining_workers: 4 # 4 parallel mining threads +batch_size: 1 # 1 address per tx +mining_iterations: 10000 # Try 10k addresses per round (depth 3 is easier to find) + +# Checkpointing +checkpoint_every: 5 # Save every 5 transactions + +# Gas settings +basefee: 1 +tipfee: 1 +gas_limit: 5000000 # 5M gas per transaction + +# Tracking +min_recordable: 3 # Track branches >= 3 nibbles +max_tracked: 100 # Keep top 100 branches \ No newline at end of file diff --git a/verify_branch_depth.go b/verify_branch_depth.go new file mode 100644 index 0000000..56af8c5 --- /dev/null +++ b/verify_branch_depth.go @@ -0,0 +1,72 @@ +package main + +import ( + "fmt" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "os" +) + +// This utility verifies the depth of storage trie branches +// Usage: go run verify_branch_depth.go
[spender] + +func main() { + if len(os.Args) < 2 { + fmt.Println("Usage: go run verify_branch_depth.go
[spender]") + fmt.Println("Example (balance): go run verify_branch_depth.go 0x123...") + fmt.Println("Example (allowance): go run verify_branch_depth.go 0x123... 0x456...") + os.Exit(1) + } + + address := common.HexToAddress(os.Args[1]) + + var storageSlot common.Hash + if len(os.Args) == 2 { + // Balance mapping: keccak256(address || uint256(0)) + storageSlot = crypto.Keccak256Hash( + common.LeftPadBytes(address.Bytes(), 32), + common.LeftPadBytes([]byte{0}, 32), + ) + fmt.Println("Type: Balance mapping") + fmt.Printf("Address: %s\n", address.Hex()) + } else { + // Allowance mapping: keccak256(spender || keccak256(owner || uint256(1))) + spender := common.HexToAddress(os.Args[2]) + innerHash := crypto.Keccak256Hash( + common.LeftPadBytes(address.Bytes(), 32), + common.LeftPadBytes([]byte{1}, 32), + ) + storageSlot = crypto.Keccak256Hash( + common.LeftPadBytes(spender.Bytes(), 32), + innerHash.Bytes(), + ) + fmt.Println("Type: Allowance mapping") + fmt.Printf("Owner: %s\n", address.Hex()) + fmt.Printf("Spender: %s\n", spender.Hex()) + } + + fmt.Printf("\nComputed Storage Slot: %s\n", storageSlot.Hex()) + fmt.Println("\nNibble breakdown:") + + slotHex := storageSlot.Hex()[2:] // Remove "0x" + for i := 0; i < len(slotHex) && i < 16; i++ { // Show first 8 bytes (16 nibbles) + if i%2 == 0 && i > 0 { + fmt.Print(" ") + } + fmt.Printf("%c", slotHex[i]) + } + fmt.Println("...") + + // Show how to verify depth against a target + fmt.Println("\nTo verify depth against a target prefix:") + fmt.Println("- Count matching nibbles from the start") + fmt.Println("- Depth 3 = first 3 nibbles match") + fmt.Printf("- Example: If target is 0xABC..., this slot has depth 3 if it starts with 0xABC\n") + + // Example depth check + fmt.Println("\nDepth Analysis:") + for depth := uint8(1); depth <= 8; depth++ { + prefix := slotHex[:depth] + fmt.Printf(" Depth %d: Prefix is %s\n", depth, prefix) + } +}