From d32616fb130138de70bcee4e2d16f6519316d10b Mon Sep 17 00:00:00 2001 From: pk910 Date: Mon, 6 Nov 2023 07:26:20 +0100 Subject: [PATCH 1/5] added blobless `eoatx` & `deploytx` scenarios --- scenarios/deploytx/deploytx.go | 296 +++++++++++++++++++++++++++++++++ scenarios/eoatx/eoatx.go | 262 +++++++++++++++++++++++++++++ scenarios/scenarios.go | 5 + 3 files changed, 563 insertions(+) create mode 100644 scenarios/deploytx/deploytx.go create mode 100644 scenarios/eoatx/eoatx.go diff --git a/scenarios/deploytx/deploytx.go b/scenarios/deploytx/deploytx.go new file mode 100644 index 0000000..1c0a54e --- /dev/null +++ b/scenarios/deploytx/deploytx.go @@ -0,0 +1,296 @@ +package deploytx + +import ( + "bufio" + "fmt" + "math/big" + "os" + "strings" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" + "github.com/sirupsen/logrus" + "github.com/spf13/pflag" + + "github.com/ethpandaops/blob-spammer/scenariotypes" + "github.com/ethpandaops/blob-spammer/tester" + "github.com/ethpandaops/blob-spammer/txbuilder" + "github.com/ethpandaops/blob-spammer/utils" +) + +type ScenarioOptions struct { + TotalCount uint64 + Throughput uint64 + MaxPending uint64 + MaxWallets uint64 + Rebroadcast uint64 + GasLimit uint64 + BaseFee uint64 + TipFee uint64 + Bytecodes string + BytecodesFile string +} + +type Scenario struct { + options ScenarioOptions + logger *logrus.Entry + tester *tester.Tester + + bytecodes [][]byte + + pendingCount uint64 + pendingChan chan bool + pendingWGroup sync.WaitGroup +} + +func NewScenario() scenariotypes.Scenario { + return &Scenario{ + logger: logrus.WithField("scenario", "deploytx"), + } +} + +func (s *Scenario) Flags(flags *pflag.FlagSet) error { + flags.Uint64VarP(&s.options.TotalCount, "count", "c", 0, "Total number of deployment transactions to send") + flags.Uint64VarP(&s.options.Throughput, "throughput", "t", 0, "Number of deployment transactions to send per slot") + flags.Uint64Var(&s.options.MaxPending, "max-pending", 0, "Maximum number of pending transactions") + flags.Uint64Var(&s.options.MaxWallets, "max-wallets", 0, "Maximum number of child wallets to use") + flags.Uint64Var(&s.options.Rebroadcast, "rebroadcast", 120, "Number of seconds to wait before re-broadcasting a transaction") + flags.Uint64Var(&s.options.GasLimit, "gaslimit", 1000000, "Gas limit to use in deployment transactions (in gwei)") + flags.Uint64Var(&s.options.BaseFee, "basefee", 20, "Max fee per gas to use in deployment transactions (in gwei)") + flags.Uint64Var(&s.options.TipFee, "tipfee", 2, "Max tip per gas to use in deployment transactions (in gwei)") + flags.StringVar(&s.options.Bytecodes, "bytecodes", "", "Bytecodes to deploy (, separated list of hex bytecodes)") + flags.StringVar(&s.options.BytecodesFile, "bytecodes-file", "", "File with bytecodes to deploy (list with hex bytecodes)") + + return nil +} + +func (s *Scenario) Init(testerCfg *tester.TesterConfig) error { + if s.options.TotalCount == 0 && s.options.Throughput == 0 { + return fmt.Errorf("neither total count nor throughput limit set, must define at least one of them") + } + + if s.options.MaxWallets > 0 { + testerCfg.WalletCount = s.options.MaxWallets + } else if s.options.TotalCount > 0 { + if s.options.TotalCount < 1000 { + testerCfg.WalletCount = s.options.TotalCount + } else { + testerCfg.WalletCount = 1000 + } + } else { + if s.options.Throughput*10 < 1000 { + testerCfg.WalletCount = s.options.Throughput * 10 + } else { + testerCfg.WalletCount = 1000 + } + } + + if s.options.MaxPending > 0 { + s.pendingChan = make(chan bool, s.options.MaxPending) + } + + s.bytecodes = [][]byte{} + if s.options.Bytecodes != "" { + for _, hexStr := range strings.Split(s.options.Bytecodes, ",") { + s.bytecodes = append(s.bytecodes, common.FromHex(hexStr)) + } + } + if s.options.BytecodesFile != "" { + fp, err := os.Open(s.options.BytecodesFile) + if err != nil { + return fmt.Errorf("cannot open bytecodes list: %w", err) + } + defer fp.Close() + scanner := bufio.NewScanner(fp) + for scanner.Scan() { + hexStr := strings.Trim(scanner.Text(), " \t") + if strings.HasPrefix(hexStr, "#") || hexStr == "" { + continue + } + s.bytecodes = append(s.bytecodes, common.FromHex(hexStr)) + } + } + + return nil +} + +func (s *Scenario) Run(tester *tester.Tester) error { + s.tester = tester + txIdxCounter := uint64(0) + counterMutex := sync.Mutex{} + waitGroup := sync.WaitGroup{} + pendingCount := uint64(0) + txCount := uint64(0) + startTime := time.Now() + + s.logger.Infof("starting scenario: deploytx") + + for { + txIdx := txIdxCounter + txIdxCounter++ + + if s.pendingChan != nil { + // await pending transactions + s.pendingChan <- true + } + waitGroup.Add(1) + counterMutex.Lock() + pendingCount++ + counterMutex.Unlock() + + go func(txIdx uint64) { + defer func() { + counterMutex.Lock() + pendingCount-- + counterMutex.Unlock() + waitGroup.Done() + }() + + logger := s.logger + tx, client, err := s.sendTx(txIdx) + if client != nil { + logger = logger.WithField("rpc", client.GetName()) + } + if err != nil { + logger.Warnf("could not send transaction: %v", err) + <-s.pendingChan + return + } + + counterMutex.Lock() + txCount++ + counterMutex.Unlock() + logger.Infof("sent tx #%6d: %v", txIdx+1, tx.Hash().String()) + }(txIdx) + + count := txCount + pendingCount + if s.options.TotalCount > 0 && count >= s.options.TotalCount { + break + } + if s.options.Throughput > 0 { + for count/((uint64(time.Since(startTime).Seconds())/utils.SecondsPerSlot)+1) >= s.options.Throughput { + time.Sleep(100 * time.Millisecond) + } + } + } + waitGroup.Wait() + + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + s.pendingWGroup.Wait() + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + + return nil +} + +func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, error) { + client := s.tester.GetClient(tester.SelectByIndex, int(txIdx)) + wallet := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)) + + var feeCap *big.Int + var tipCap *big.Int + + if s.options.BaseFee > 0 { + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000)) + } + if s.options.TipFee > 0 { + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000)) + } + + if feeCap == nil || tipCap == nil { + var err error + feeCap, tipCap, err = client.GetSuggestedFee() + if err != nil { + return nil, client, err + } + } + + if feeCap.Cmp(big.NewInt(1000000)) < 0 { + feeCap = big.NewInt(1000000) + } + if tipCap.Cmp(big.NewInt(1000000)) < 0 { + tipCap = big.NewInt(1000000) + } + + deployData := s.bytecodes[int(txIdx)%len(s.bytecodes)] + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: s.options.GasLimit, + To: nil, + Value: uint256.NewInt(0), + Data: deployData, + }) + if err != nil { + return nil, nil, err + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, nil, err + } + + err = client.SendTransaction(tx) + if err != nil { + return nil, client, err + } + + s.pendingWGroup.Add(1) + go s.awaitTx(txIdx, tx, client, wallet) + + return tx, client, nil +} + +func (s *Scenario) awaitTx(txIdx uint64, tx *types.Transaction, client *txbuilder.Client, wallet *txbuilder.Wallet) { + var awaitConfirmation bool = true + defer func() { + awaitConfirmation = false + if s.pendingChan != nil { + <-s.pendingChan + } + s.pendingWGroup.Done() + }() + if s.options.Rebroadcast > 0 { + go s.delayedResend(txIdx, tx, &awaitConfirmation) + } + + receipt, blockNum, err := client.AwaitTransaction(tx) + if err != nil { + s.logger.WithField("client", client.GetName()).Warnf("error while awaiting tx receipt: %v", err) + return + } + + effectiveGasPrice := receipt.EffectiveGasPrice + if effectiveGasPrice == nil { + effectiveGasPrice = big.NewInt(0) + } + blobGasPrice := receipt.BlobGasPrice + if blobGasPrice == nil { + blobGasPrice = big.NewInt(0) + } + feeAmount := new(big.Int).Mul(effectiveGasPrice, big.NewInt(int64(receipt.GasUsed))) + totalAmount := new(big.Int).Add(tx.Value(), feeAmount) + wallet.SubBalance(totalAmount) + + gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000)) + gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000)) + gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000)) + + s.logger.WithField("client", client.GetName()).Infof(" transaction %d confirmed in block #%v. total fee: %v gwei (base: %v, blob: %v)", txIdx+1, blockNum, gweiTotalFee, gweiBaseFee, gweiBlobFee) +} + +func (s *Scenario) delayedResend(txIdx uint64, tx *types.Transaction, awaitConfirmation *bool) { + for { + time.Sleep(time.Duration(s.options.Rebroadcast) * time.Second) + + if !*awaitConfirmation { + break + } + + client := s.tester.GetClient(tester.SelectRandom, 0) + client.SendTransaction(tx) + s.logger.WithField("client", client.GetName()).Infof(" transaction %d re-broadcasted.", txIdx+1) + } +} diff --git a/scenarios/eoatx/eoatx.go b/scenarios/eoatx/eoatx.go new file mode 100644 index 0000000..bf5ebe0 --- /dev/null +++ b/scenarios/eoatx/eoatx.go @@ -0,0 +1,262 @@ +package eoatx + +import ( + "fmt" + "math/big" + "sync" + "time" + + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" + "github.com/sirupsen/logrus" + "github.com/spf13/pflag" + + "github.com/ethpandaops/blob-spammer/scenariotypes" + "github.com/ethpandaops/blob-spammer/tester" + "github.com/ethpandaops/blob-spammer/txbuilder" + "github.com/ethpandaops/blob-spammer/utils" +) + +type ScenarioOptions struct { + TotalCount uint64 + Throughput uint64 + MaxPending uint64 + MaxWallets uint64 + Rebroadcast uint64 + BaseFee uint64 + TipFee uint64 + Amount uint64 +} + +type Scenario struct { + options ScenarioOptions + logger *logrus.Entry + tester *tester.Tester + + pendingCount uint64 + pendingChan chan bool + pendingWGroup sync.WaitGroup +} + +func NewScenario() scenariotypes.Scenario { + return &Scenario{ + logger: logrus.WithField("scenario", "eoatx"), + } +} + +func (s *Scenario) Flags(flags *pflag.FlagSet) error { + flags.Uint64VarP(&s.options.TotalCount, "count", "c", 0, "Total number of transfer transactions to send") + flags.Uint64VarP(&s.options.Throughput, "throughput", "t", 0, "Number of transfer transactions to send per slot") + flags.Uint64Var(&s.options.MaxPending, "max-pending", 0, "Maximum number of pending transactions") + flags.Uint64Var(&s.options.MaxWallets, "max-wallets", 0, "Maximum number of child wallets to use") + flags.Uint64Var(&s.options.Rebroadcast, "rebroadcast", 120, "Number of seconds to wait before re-broadcasting a transaction") + flags.Uint64Var(&s.options.BaseFee, "basefee", 20, "Max fee per gas to use in transfer transactions (in gwei)") + flags.Uint64Var(&s.options.TipFee, "tipfee", 2, "Max tip per gas to use in transfer transactions (in gwei)") + flags.Uint64Var(&s.options.Amount, "amount", 20, "Transfer amount per transaction (in gwei)") + return nil +} + +func (s *Scenario) Init(testerCfg *tester.TesterConfig) error { + if s.options.TotalCount == 0 && s.options.Throughput == 0 { + return fmt.Errorf("neither total count nor throughput limit set, must define at least one of them") + } + + if s.options.MaxWallets > 0 { + testerCfg.WalletCount = s.options.MaxWallets + } else if s.options.TotalCount > 0 { + if s.options.TotalCount < 1000 { + testerCfg.WalletCount = s.options.TotalCount + } else { + testerCfg.WalletCount = 1000 + } + } else { + if s.options.Throughput*10 < 1000 { + testerCfg.WalletCount = s.options.Throughput * 10 + } else { + testerCfg.WalletCount = 1000 + } + } + + if s.options.MaxPending > 0 { + s.pendingChan = make(chan bool, s.options.MaxPending) + } + + return nil +} + +func (s *Scenario) Run(tester *tester.Tester) error { + s.tester = tester + txIdxCounter := uint64(0) + counterMutex := sync.Mutex{} + waitGroup := sync.WaitGroup{} + pendingCount := uint64(0) + txCount := uint64(0) + startTime := time.Now() + + s.logger.Infof("starting scenario: eoatx") + + for { + txIdx := txIdxCounter + txIdxCounter++ + + if s.pendingChan != nil { + // await pending transactions + s.pendingChan <- true + } + waitGroup.Add(1) + counterMutex.Lock() + pendingCount++ + counterMutex.Unlock() + + go func(txIdx uint64) { + defer func() { + counterMutex.Lock() + pendingCount-- + counterMutex.Unlock() + waitGroup.Done() + }() + + logger := s.logger + tx, client, err := s.sendTx(txIdx) + if client != nil { + logger = logger.WithField("rpc", client.GetName()) + } + if err != nil { + logger.Warnf("could not send transaction: %v", err) + <-s.pendingChan + return + } + + counterMutex.Lock() + txCount++ + counterMutex.Unlock() + logger.Infof("sent tx #%6d: %v", txIdx+1, tx.Hash().String()) + }(txIdx) + + count := txCount + pendingCount + if s.options.TotalCount > 0 && count >= s.options.TotalCount { + break + } + if s.options.Throughput > 0 { + for count/((uint64(time.Since(startTime).Seconds())/utils.SecondsPerSlot)+1) >= s.options.Throughput { + time.Sleep(100 * time.Millisecond) + } + } + } + waitGroup.Wait() + + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + s.pendingWGroup.Wait() + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + + return nil +} + +func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, error) { + client := s.tester.GetClient(tester.SelectByIndex, int(txIdx)) + wallet := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)) + + var feeCap *big.Int + var tipCap *big.Int + + if s.options.BaseFee > 0 { + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000)) + } + if s.options.TipFee > 0 { + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000)) + } + + if feeCap == nil || tipCap == nil { + var err error + feeCap, tipCap, err = client.GetSuggestedFee() + if err != nil { + return nil, client, err + } + } + + if feeCap.Cmp(big.NewInt(1000000)) < 0 { + feeCap = big.NewInt(1000000) + } + if tipCap.Cmp(big.NewInt(1000000)) < 0 { + tipCap = big.NewInt(1000000) + } + + toAddr := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)+1).GetAddress() + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: 21000, + To: &toAddr, + Value: uint256.NewInt(s.options.Amount), + }) + if err != nil { + return nil, nil, err + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, nil, err + } + + err = client.SendTransaction(tx) + if err != nil { + return nil, client, err + } + + s.pendingWGroup.Add(1) + go s.awaitTx(txIdx, tx, client, wallet) + + return tx, client, nil +} + +func (s *Scenario) awaitTx(txIdx uint64, tx *types.Transaction, client *txbuilder.Client, wallet *txbuilder.Wallet) { + var awaitConfirmation bool = true + defer func() { + awaitConfirmation = false + if s.pendingChan != nil { + <-s.pendingChan + } + s.pendingWGroup.Done() + }() + if s.options.Rebroadcast > 0 { + go s.delayedResend(txIdx, tx, &awaitConfirmation) + } + + receipt, blockNum, err := client.AwaitTransaction(tx) + if err != nil { + s.logger.WithField("client", client.GetName()).Warnf("error while awaiting tx receipt: %v", err) + return + } + + effectiveGasPrice := receipt.EffectiveGasPrice + if effectiveGasPrice == nil { + effectiveGasPrice = big.NewInt(0) + } + blobGasPrice := receipt.BlobGasPrice + if blobGasPrice == nil { + blobGasPrice = big.NewInt(0) + } + feeAmount := new(big.Int).Mul(effectiveGasPrice, big.NewInt(int64(receipt.GasUsed))) + totalAmount := new(big.Int).Add(tx.Value(), feeAmount) + wallet.SubBalance(totalAmount) + + gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000)) + gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000)) + gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000)) + + s.logger.WithField("client", client.GetName()).Infof(" transaction %d confirmed in block #%v. total fee: %v gwei (base: %v, blob: %v)", txIdx+1, blockNum, gweiTotalFee, gweiBaseFee, gweiBlobFee) +} + +func (s *Scenario) delayedResend(txIdx uint64, tx *types.Transaction, awaitConfirmation *bool) { + for { + time.Sleep(time.Duration(s.options.Rebroadcast) * time.Second) + + if !*awaitConfirmation { + break + } + + client := s.tester.GetClient(tester.SelectRandom, 0) + client.SendTransaction(tx) + s.logger.WithField("client", client.GetName()).Infof(" transaction %d re-broadcasted.", txIdx+1) + } +} diff --git a/scenarios/scenarios.go b/scenarios/scenarios.go index bae5724..5a7c4fb 100644 --- a/scenarios/scenarios.go +++ b/scenarios/scenarios.go @@ -5,6 +5,8 @@ import ( "github.com/ethpandaops/blob-spammer/scenarios/combined" "github.com/ethpandaops/blob-spammer/scenarios/conflicting" + "github.com/ethpandaops/blob-spammer/scenarios/deploytx" + "github.com/ethpandaops/blob-spammer/scenarios/eoatx" "github.com/ethpandaops/blob-spammer/scenarios/normal" "github.com/ethpandaops/blob-spammer/scenarios/replacements" "github.com/ethpandaops/blob-spammer/scenarios/wallets" @@ -16,5 +18,8 @@ var Scenarios map[string]func() scenariotypes.Scenario = map[string]func() scena "normal": normal.NewScenario, "replacements": replacements.NewScenario, + "eoatx": eoatx.NewScenario, + "deploytx": deploytx.NewScenario, + "wallets": wallets.NewScenario, } From b79eaef8c82472cbee636f4c81212ce6e162192c Mon Sep 17 00:00:00 2001 From: pk910 Date: Mon, 6 Nov 2023 08:46:16 +0100 Subject: [PATCH 2/5] fix new scenarios --- scenarios/deploytx/deploytx.go | 18 ++++++------- scenarios/eoatx/eoatx.go | 48 +++++++++++++++++++++------------- 2 files changed, 39 insertions(+), 27 deletions(-) diff --git a/scenarios/deploytx/deploytx.go b/scenarios/deploytx/deploytx.go index 1c0a54e..33e92b2 100644 --- a/scenarios/deploytx/deploytx.go +++ b/scenarios/deploytx/deploytx.go @@ -193,10 +193,10 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, var tipCap *big.Int if s.options.BaseFee > 0 { - feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000)) + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000000)) } if s.options.TipFee > 0 { - tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000)) + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000000)) } if feeCap == nil || tipCap == nil { @@ -207,11 +207,11 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, } } - if feeCap.Cmp(big.NewInt(1000000)) < 0 { - feeCap = big.NewInt(1000000) + if feeCap.Cmp(big.NewInt(1000000000)) < 0 { + feeCap = big.NewInt(1000000000) } - if tipCap.Cmp(big.NewInt(1000000)) < 0 { - tipCap = big.NewInt(1000000) + if tipCap.Cmp(big.NewInt(1000000000)) < 0 { + tipCap = big.NewInt(1000000000) } deployData := s.bytecodes[int(txIdx)%len(s.bytecodes)] @@ -274,9 +274,9 @@ func (s *Scenario) awaitTx(txIdx uint64, tx *types.Transaction, client *txbuilde totalAmount := new(big.Int).Add(tx.Value(), feeAmount) wallet.SubBalance(totalAmount) - gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000)) - gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000)) - gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000)) + gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000000)) + gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000000)) + gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000000)) s.logger.WithField("client", client.GetName()).Infof(" transaction %d confirmed in block #%v. total fee: %v gwei (base: %v, blob: %v)", txIdx+1, blockNum, gweiTotalFee, gweiBaseFee, gweiBlobFee) } diff --git a/scenarios/eoatx/eoatx.go b/scenarios/eoatx/eoatx.go index bf5ebe0..b3c9608 100644 --- a/scenarios/eoatx/eoatx.go +++ b/scenarios/eoatx/eoatx.go @@ -1,6 +1,7 @@ package eoatx import ( + "crypto/rand" "fmt" "math/big" "sync" @@ -18,14 +19,15 @@ import ( ) type ScenarioOptions struct { - TotalCount uint64 - Throughput uint64 - MaxPending uint64 - MaxWallets uint64 - Rebroadcast uint64 - BaseFee uint64 - TipFee uint64 - Amount uint64 + TotalCount uint64 + Throughput uint64 + MaxPending uint64 + MaxWallets uint64 + Rebroadcast uint64 + BaseFee uint64 + TipFee uint64 + Amount uint64 + RandomAmount bool } type Scenario struct { @@ -53,6 +55,7 @@ func (s *Scenario) Flags(flags *pflag.FlagSet) error { flags.Uint64Var(&s.options.BaseFee, "basefee", 20, "Max fee per gas to use in transfer transactions (in gwei)") flags.Uint64Var(&s.options.TipFee, "tipfee", 2, "Max tip per gas to use in transfer transactions (in gwei)") flags.Uint64Var(&s.options.Amount, "amount", 20, "Transfer amount per transaction (in gwei)") + flags.BoolVar(&s.options.RandomAmount, "random-amount", false, "use random amounts for transactions (with --amount as limit)") return nil } @@ -160,10 +163,10 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, var tipCap *big.Int if s.options.BaseFee > 0 { - feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000)) + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000000)) } if s.options.TipFee > 0 { - tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000)) + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000000)) } if feeCap == nil || tipCap == nil { @@ -174,11 +177,20 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, } } - if feeCap.Cmp(big.NewInt(1000000)) < 0 { - feeCap = big.NewInt(1000000) + if feeCap.Cmp(big.NewInt(1000000000)) < 0 { + feeCap = big.NewInt(1000000000) } - if tipCap.Cmp(big.NewInt(1000000)) < 0 { - tipCap = big.NewInt(1000000) + if tipCap.Cmp(big.NewInt(1000000000)) < 0 { + tipCap = big.NewInt(1000000000) + } + + amount := uint256.NewInt(s.options.Amount) + amount = amount.Mul(amount, uint256.NewInt(1000000000)) + if s.options.RandomAmount { + n, err := rand.Int(rand.Reader, amount.ToBig()) + if err == nil { + amount = uint256.MustFromBig(n) + } } toAddr := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)+1).GetAddress() @@ -187,7 +199,7 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, GasTipCap: uint256.MustFromBig(tipCap), Gas: 21000, To: &toAddr, - Value: uint256.NewInt(s.options.Amount), + Value: amount, }) if err != nil { return nil, nil, err @@ -240,9 +252,9 @@ func (s *Scenario) awaitTx(txIdx uint64, tx *types.Transaction, client *txbuilde totalAmount := new(big.Int).Add(tx.Value(), feeAmount) wallet.SubBalance(totalAmount) - gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000)) - gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000)) - gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000)) + gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000000)) + gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000000)) + gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000000)) s.logger.WithField("client", client.GetName()).Infof(" transaction %d confirmed in block #%v. total fee: %v gwei (base: %v, blob: %v)", txIdx+1, blockNum, gweiTotalFee, gweiBaseFee, gweiBlobFee) } From a09ab59444c10dfea90312ab4f58865d6c472a02 Mon Sep 17 00:00:00 2001 From: pk910 Date: Mon, 6 Nov 2023 08:52:36 +0100 Subject: [PATCH 3/5] added `--random-target` flag to `eoatx` --- scenarios/eoatx/eoatx.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/scenarios/eoatx/eoatx.go b/scenarios/eoatx/eoatx.go index b3c9608..6ce044d 100644 --- a/scenarios/eoatx/eoatx.go +++ b/scenarios/eoatx/eoatx.go @@ -7,6 +7,7 @@ import ( "sync" "time" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/holiman/uint256" "github.com/sirupsen/logrus" @@ -28,6 +29,7 @@ type ScenarioOptions struct { TipFee uint64 Amount uint64 RandomAmount bool + RandomTarget bool } type Scenario struct { @@ -55,7 +57,8 @@ func (s *Scenario) Flags(flags *pflag.FlagSet) error { flags.Uint64Var(&s.options.BaseFee, "basefee", 20, "Max fee per gas to use in transfer transactions (in gwei)") flags.Uint64Var(&s.options.TipFee, "tipfee", 2, "Max tip per gas to use in transfer transactions (in gwei)") flags.Uint64Var(&s.options.Amount, "amount", 20, "Transfer amount per transaction (in gwei)") - flags.BoolVar(&s.options.RandomAmount, "random-amount", false, "use random amounts for transactions (with --amount as limit)") + flags.BoolVar(&s.options.RandomAmount, "random-amount", false, "Use random amounts for transactions (with --amount as limit)") + flags.BoolVar(&s.options.RandomTarget, "random-target", false, "Use random to addresses for transactions") return nil } @@ -194,6 +197,12 @@ func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, } toAddr := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)+1).GetAddress() + if s.options.RandomTarget { + addrBytes := make([]byte, 20) + rand.Read(addrBytes) + toAddr = common.Address(addrBytes) + } + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ GasFeeCap: uint256.MustFromBig(feeCap), GasTipCap: uint256.MustFromBig(tipCap), From 17fa6c3258b6e05912a021aecf276b76b500e932 Mon Sep 17 00:00:00 2001 From: pk910 Date: Wed, 8 Nov 2023 03:18:48 +0100 Subject: [PATCH 4/5] added `erctx` scenario --- scenarios/erctx/contract.go | 3 + scenarios/erctx/erctx.go | 363 ++++++++++++++++++++++++++++++++++++ scenarios/scenarios.go | 2 + 3 files changed, 368 insertions(+) create mode 100644 scenarios/erctx/contract.go create mode 100644 scenarios/erctx/erctx.go diff --git a/scenarios/erctx/contract.go b/scenarios/erctx/contract.go new file mode 100644 index 0000000..96cb209 --- /dev/null +++ b/scenarios/erctx/contract.go @@ -0,0 +1,3 @@ +package erctx + +var TokenContractCode string = "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" diff --git a/scenarios/erctx/erctx.go b/scenarios/erctx/erctx.go new file mode 100644 index 0000000..854cde4 --- /dev/null +++ b/scenarios/erctx/erctx.go @@ -0,0 +1,363 @@ +package erctx + +import ( + "crypto/rand" + "fmt" + "math/big" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" + "github.com/sirupsen/logrus" + "github.com/spf13/pflag" + "golang.org/x/crypto/sha3" + + "github.com/ethpandaops/blob-spammer/scenariotypes" + "github.com/ethpandaops/blob-spammer/tester" + "github.com/ethpandaops/blob-spammer/txbuilder" + "github.com/ethpandaops/blob-spammer/utils" +) + +type ScenarioOptions struct { + TotalCount uint64 + Throughput uint64 + MaxPending uint64 + MaxWallets uint64 + Rebroadcast uint64 + BaseFee uint64 + TipFee uint64 + Amount uint64 + RandomAmount bool + RandomTarget bool +} + +type Scenario struct { + options ScenarioOptions + logger *logrus.Entry + tester *tester.Tester + + contractAddr common.Address + + pendingCount uint64 + pendingChan chan bool + pendingWGroup sync.WaitGroup +} + +func NewScenario() scenariotypes.Scenario { + return &Scenario{ + logger: logrus.WithField("scenario", "erctx"), + } +} + +func (s *Scenario) Flags(flags *pflag.FlagSet) error { + flags.Uint64VarP(&s.options.TotalCount, "count", "c", 0, "Total number of transfer transactions to send") + flags.Uint64VarP(&s.options.Throughput, "throughput", "t", 0, "Number of transfer transactions to send per slot") + flags.Uint64Var(&s.options.MaxPending, "max-pending", 0, "Maximum number of pending transactions") + flags.Uint64Var(&s.options.MaxWallets, "max-wallets", 0, "Maximum number of child wallets to use") + flags.Uint64Var(&s.options.Rebroadcast, "rebroadcast", 120, "Number of seconds to wait before re-broadcasting a transaction") + flags.Uint64Var(&s.options.BaseFee, "basefee", 20, "Max fee per gas to use in transfer transactions (in gwei)") + flags.Uint64Var(&s.options.TipFee, "tipfee", 2, "Max tip per gas to use in transfer transactions (in gwei)") + flags.Uint64Var(&s.options.Amount, "amount", 20, "Transfer amount per transaction (in gwei)") + flags.BoolVar(&s.options.RandomAmount, "random-amount", false, "Use random amounts for transactions (with --amount as limit)") + flags.BoolVar(&s.options.RandomTarget, "random-target", false, "Use random to addresses for transactions") + return nil +} + +func (s *Scenario) Init(testerCfg *tester.TesterConfig) error { + if s.options.TotalCount == 0 && s.options.Throughput == 0 { + return fmt.Errorf("neither total count nor throughput limit set, must define at least one of them") + } + + if s.options.MaxWallets > 0 { + testerCfg.WalletCount = s.options.MaxWallets + } else if s.options.TotalCount > 0 { + if s.options.TotalCount < 1000 { + testerCfg.WalletCount = s.options.TotalCount + } else { + testerCfg.WalletCount = 1000 + } + } else { + if s.options.Throughput*10 < 1000 { + testerCfg.WalletCount = s.options.Throughput * 10 + } else { + testerCfg.WalletCount = 1000 + } + } + + if s.options.MaxPending > 0 { + s.pendingChan = make(chan bool, s.options.MaxPending) + } + + return nil +} + +func (s *Scenario) Run(tester *tester.Tester) error { + s.tester = tester + txIdxCounter := uint64(0) + counterMutex := sync.Mutex{} + waitGroup := sync.WaitGroup{} + pendingCount := uint64(0) + txCount := uint64(0) + startTime := time.Now() + + s.logger.Infof("starting scenario: erctx") + contractReceipt, _, err := s.sendDeploymentTx() + if err != nil { + s.logger.Errorf("could not deploy token contract: %v", err) + return err + } + s.contractAddr = contractReceipt.ContractAddress + s.logger.Infof("deployed token contract: %v (confirmed in block #%v)", s.contractAddr.String(), contractReceipt.BlockNumber.String()) + + for { + txIdx := txIdxCounter + txIdxCounter++ + + if s.pendingChan != nil { + // await pending transactions + s.pendingChan <- true + } + waitGroup.Add(1) + counterMutex.Lock() + pendingCount++ + counterMutex.Unlock() + + go func(txIdx uint64) { + defer func() { + counterMutex.Lock() + pendingCount-- + counterMutex.Unlock() + waitGroup.Done() + }() + + logger := s.logger + tx, client, err := s.sendTx(txIdx) + if client != nil { + logger = logger.WithField("rpc", client.GetName()) + } + if err != nil { + logger.Warnf("could not send transaction: %v", err) + <-s.pendingChan + return + } + + counterMutex.Lock() + txCount++ + counterMutex.Unlock() + logger.Infof("sent tx #%6d: %v", txIdx+1, tx.Hash().String()) + }(txIdx) + + count := txCount + pendingCount + if s.options.TotalCount > 0 && count >= s.options.TotalCount { + break + } + if s.options.Throughput > 0 { + for count/((uint64(time.Since(startTime).Seconds())/utils.SecondsPerSlot)+1) >= s.options.Throughput { + time.Sleep(100 * time.Millisecond) + } + } + } + waitGroup.Wait() + + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + s.pendingWGroup.Wait() + s.logger.Infof("finished sending transactions, awaiting block inclusion...") + + return nil +} + +func (s *Scenario) sendDeploymentTx() (*types.Receipt, *txbuilder.Client, error) { + client := s.tester.GetClient(tester.SelectByIndex, 0) + wallet := s.tester.GetWallet(tester.SelectByIndex, 0) + + var feeCap *big.Int + var tipCap *big.Int + + if s.options.BaseFee > 0 { + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000000)) + } + if s.options.TipFee > 0 { + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000000)) + } + + if feeCap == nil || tipCap == nil { + var err error + feeCap, tipCap, err = client.GetSuggestedFee() + if err != nil { + return nil, client, err + } + } + + if feeCap.Cmp(big.NewInt(1000000000)) < 0 { + feeCap = big.NewInt(1000000000) + } + if tipCap.Cmp(big.NewInt(1000000000)) < 0 { + tipCap = big.NewInt(1000000000) + } + + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: 2000000, + To: nil, + Value: uint256.NewInt(0), + Data: common.FromHex(TokenContractCode), + }) + if err != nil { + return nil, nil, err + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, nil, err + } + + err = client.SendTransaction(tx) + if err != nil { + return nil, client, err + } + + receipt, _, err := client.AwaitTransaction(tx) + if err != nil { + return nil, client, err + } + return receipt, client, nil +} + +func (s *Scenario) sendTx(txIdx uint64) (*types.Transaction, *txbuilder.Client, error) { + client := s.tester.GetClient(tester.SelectByIndex, int(txIdx)) + wallet := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)) + + var feeCap *big.Int + var tipCap *big.Int + + if s.options.BaseFee > 0 { + feeCap = new(big.Int).Mul(big.NewInt(int64(s.options.BaseFee)), big.NewInt(1000000000)) + } + if s.options.TipFee > 0 { + tipCap = new(big.Int).Mul(big.NewInt(int64(s.options.TipFee)), big.NewInt(1000000000)) + } + + if feeCap == nil || tipCap == nil { + var err error + feeCap, tipCap, err = client.GetSuggestedFee() + if err != nil { + return nil, client, err + } + } + + if feeCap.Cmp(big.NewInt(1000000000)) < 0 { + feeCap = big.NewInt(1000000000) + } + if tipCap.Cmp(big.NewInt(1000000000)) < 0 { + tipCap = big.NewInt(1000000000) + } + + amount := uint256.NewInt(s.options.Amount) + amount = amount.Mul(amount, uint256.NewInt(1000000000)) + if s.options.RandomAmount { + n, err := rand.Int(rand.Reader, amount.ToBig()) + if err == nil { + amount = uint256.MustFromBig(n) + } + } + + toAddr := s.tester.GetWallet(tester.SelectByIndex, int(txIdx)+1).GetAddress() + if s.options.RandomTarget { + addrBytes := make([]byte, 20) + rand.Read(addrBytes) + toAddr = common.Address(addrBytes) + } + + transferFnSignature := []byte("transferMint(address,uint256)") + hash := sha3.NewLegacyKeccak256() + hash.Write(transferFnSignature) + methodID := hash.Sum(nil)[:4] + paddedAddress := common.LeftPadBytes(toAddr.Bytes(), 32) + paddedAmount := common.LeftPadBytes(amount.Bytes(), 32) + var txCallData []byte + txCallData = append(txCallData, methodID...) + txCallData = append(txCallData, paddedAddress...) + txCallData = append(txCallData, paddedAmount...) + + txData, err := txbuilder.DynFeeTx(&txbuilder.TxMetadata{ + GasFeeCap: uint256.MustFromBig(feeCap), + GasTipCap: uint256.MustFromBig(tipCap), + Gas: 100000, + To: &s.contractAddr, + Value: uint256.NewInt(0), + Data: txCallData, + }) + if err != nil { + return nil, nil, err + } + + tx, err := wallet.BuildDynamicFeeTx(txData) + if err != nil { + return nil, nil, err + } + + err = client.SendTransaction(tx) + if err != nil { + return nil, client, err + } + + s.pendingWGroup.Add(1) + go s.awaitTx(txIdx, tx, client, wallet) + + return tx, client, nil +} + +func (s *Scenario) awaitTx(txIdx uint64, tx *types.Transaction, client *txbuilder.Client, wallet *txbuilder.Wallet) { + var awaitConfirmation bool = true + defer func() { + awaitConfirmation = false + if s.pendingChan != nil { + <-s.pendingChan + } + s.pendingWGroup.Done() + }() + if s.options.Rebroadcast > 0 { + go s.delayedResend(txIdx, tx, &awaitConfirmation) + } + + receipt, blockNum, err := client.AwaitTransaction(tx) + if err != nil { + s.logger.WithField("client", client.GetName()).Warnf("error while awaiting tx receipt: %v", err) + return + } + + effectiveGasPrice := receipt.EffectiveGasPrice + if effectiveGasPrice == nil { + effectiveGasPrice = big.NewInt(0) + } + blobGasPrice := receipt.BlobGasPrice + if blobGasPrice == nil { + blobGasPrice = big.NewInt(0) + } + feeAmount := new(big.Int).Mul(effectiveGasPrice, big.NewInt(int64(receipt.GasUsed))) + totalAmount := new(big.Int).Add(tx.Value(), feeAmount) + wallet.SubBalance(totalAmount) + + gweiTotalFee := new(big.Int).Div(totalAmount, big.NewInt(1000000000)) + gweiBaseFee := new(big.Int).Div(effectiveGasPrice, big.NewInt(1000000000)) + gweiBlobFee := new(big.Int).Div(blobGasPrice, big.NewInt(1000000000)) + + s.logger.WithField("client", client.GetName()).Infof(" transaction %d confirmed in block #%v. total fee: %v gwei (base: %v, blob: %v)", txIdx+1, blockNum, gweiTotalFee, gweiBaseFee, gweiBlobFee) +} + +func (s *Scenario) delayedResend(txIdx uint64, tx *types.Transaction, awaitConfirmation *bool) { + for { + time.Sleep(time.Duration(s.options.Rebroadcast) * time.Second) + + if !*awaitConfirmation { + break + } + + client := s.tester.GetClient(tester.SelectRandom, 0) + client.SendTransaction(tx) + s.logger.WithField("client", client.GetName()).Infof(" transaction %d re-broadcasted.", txIdx+1) + } +} diff --git a/scenarios/scenarios.go b/scenarios/scenarios.go index 5a7c4fb..f168bda 100644 --- a/scenarios/scenarios.go +++ b/scenarios/scenarios.go @@ -7,6 +7,7 @@ import ( "github.com/ethpandaops/blob-spammer/scenarios/conflicting" "github.com/ethpandaops/blob-spammer/scenarios/deploytx" "github.com/ethpandaops/blob-spammer/scenarios/eoatx" + "github.com/ethpandaops/blob-spammer/scenarios/erctx" "github.com/ethpandaops/blob-spammer/scenarios/normal" "github.com/ethpandaops/blob-spammer/scenarios/replacements" "github.com/ethpandaops/blob-spammer/scenarios/wallets" @@ -19,6 +20,7 @@ var Scenarios map[string]func() scenariotypes.Scenario = map[string]func() scena "replacements": replacements.NewScenario, "eoatx": eoatx.NewScenario, + "erctx": erctx.NewScenario, "deploytx": deploytx.NewScenario, "wallets": wallets.NewScenario, From d0888e38dc0a72ba56179cd51547a2ad2593875d Mon Sep 17 00:00:00 2001 From: pk910 Date: Mon, 22 Apr 2024 15:24:05 +0200 Subject: [PATCH 5/5] fix merge conflicts --- go.mod | 5 +- go.sum | 170 ++++++++++++++++++++++++--------- scenarios/deploytx/deploytx.go | 8 +- scenarios/eoatx/eoatx.go | 8 +- scenarios/erctx/erctx.go | 8 +- 5 files changed, 141 insertions(+), 58 deletions(-) diff --git a/go.mod b/go.mod index b637fb3..2d0d41f 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,8 @@ require ( github.com/ethereum/go-ethereum v1.13.10 github.com/holiman/uint256 v1.2.4 github.com/sirupsen/logrus v1.9.3 + github.com/spf13/pflag v1.0.5 + golang.org/x/crypto v0.17.0 ) require ( @@ -20,15 +22,12 @@ require ( github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect github.com/ethereum/c-kzg-4844 v0.4.0 // indirect github.com/go-ole/go-ole v1.2.5 // indirect - github.com/go-stack/stack v1.8.1 // indirect github.com/gorilla/websocket v1.4.2 // indirect github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect - github.com/spf13/pflag v1.0.5 // indirect github.com/supranational/blst v0.3.11 // indirect github.com/tklauser/go-sysconf v0.3.12 // indirect github.com/tklauser/numcpus v0.6.1 // indirect - golang.org/x/crypto v0.17.0 // indirect golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect golang.org/x/mod v0.14.0 // indirect golang.org/x/sync v0.5.0 // indirect diff --git a/go.sum b/go.sum index 884e5cc..35e2882 100644 --- a/go.sum +++ b/go.sum @@ -1,111 +1,195 @@ +github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= -github.com/bits-and-blooms/bitset v1.5.0 h1:NpE8frKRLGHIcEzkR+gZhiioW1+WbYV6fKwD6ZIpQT8= -github.com/bits-and-blooms/bitset v1.5.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= -github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo= -github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k= github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= +github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= +github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.10.0 h1:zRh22SR7o4K35SoNqouS9J/TKHTyU2QWaj5ldehyXtA= -github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU= github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/crate-crypto/go-kzg-4844 v0.3.0 h1:UBlWE0CgyFqqzTI+IFyCzA7A3Zw4iip6uzRv5NIXG0A= -github.com/crate-crypto/go-kzg-4844 v0.3.0/go.mod h1:SBP7ikXEgDnUPONgm33HtuDZEDtWa3L4QtN1ocJSEQ4= -github.com/crate-crypto/go-kzg-4844 v0.6.1-0.20231019121413-3621cc59f0c7 h1:VpZxBC99nEW8Rkz1EBBf7JmaM20H+ZkSmqdxpYEoXuo= -github.com/crate-crypto/go-kzg-4844 v0.6.1-0.20231019121413-3621cc59f0c7/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/ethereum/c-kzg-4844 v0.3.1 h1:sR65+68+WdnMKxseNWxSJuAv2tsUrihTpVBTfM/U5Zg= -github.com/ethereum/c-kzg-4844 v0.3.1/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/c-kzg-4844 v0.3.2-0.20231019020040-748283cced54 h1:jDyQvQjauRyb7TJAF9W7J3NOjn3ukXahd3l+rd1Fak8= -github.com/ethereum/c-kzg-4844 v0.3.2-0.20231019020040-748283cced54/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.13.1 h1:UF2FaUKPIy5jeZk3X06ait3y2Q4wI+vJ1l7+UARp+60= -github.com/ethereum/go-ethereum v1.13.1/go.mod h1:xHQKzwkHSl0gnSjZK1mWa06XEdm9685AHqhRknOzqGQ= github.com/ethereum/go-ethereum v1.13.10 h1:Ppdil79nN+Vc+mXfge0AuUgmKWuVv4eMqzoIVSdqZek= github.com/ethereum/go-ethereum v1.13.10/go.mod h1:sc48XYQxCzH3fG9BcrXCOOgQk2JfZzNAmIKnceogzsA= +github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c= +github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= github.com/go-ole/go-ole v1.2.5 h1:t4MGB5xEDZvXI+0rMjjsfBsD7yAgp/s9ZDkL1JndXwY= github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= -github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/holiman/uint256 v1.2.3 h1:K8UWO1HUJpRMXBxbmaY1Y8IAMZC/RsKB+ArEnnK4l5o= -github.com/holiman/uint256 v1.2.3/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw= +github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/lightclient/go-ethereum v0.0.0-20231019143932-4d161dee0c4c h1:fU86UHyEDl+9bq6kd0FRrwLIDKfrax3UBOuVDUoV3BE= -github.com/lightclient/go-ethereum v0.0.0-20231019143932-4d161dee0c4c/go.mod h1:CLSRGaP4Ev4DJOP+JSk3NHyJIillQLJc/ZAyCLI8NOs= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= +github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.12.0 h1:C+UIj/QWtmqY13Arb8kwMt5j34/0Z2iKamrJ+ryC0Gg= +github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a h1:CmF68hwI0XsOQ5UwlBopMi2Ow4Pbg32akc4KIVCOm+Y= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk= -golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= -golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc= -golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= -golang.org/x/exp v0.0.0-20230810033253-352e893a4cad h1:g0bG7Z4uG+OgH2QDODnjp6ggkk1bJDsINcuWmJN1iJU= -golang.org/x/exp v0.0.0-20230810033253-352e893a4cad/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= -golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= -golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc= -golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E= -golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM= golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= -golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/tools v0.9.1 h1:8WMNJAz3zrtPmnYC7ISf5dEn3MT0gY7jBJfw27yrrLo= -golang.org/x/tools v0.9.1/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc= -golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ= -golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/scenarios/deploytx/deploytx.go b/scenarios/deploytx/deploytx.go index 33e92b2..007443b 100644 --- a/scenarios/deploytx/deploytx.go +++ b/scenarios/deploytx/deploytx.go @@ -15,10 +15,10 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/pflag" - "github.com/ethpandaops/blob-spammer/scenariotypes" - "github.com/ethpandaops/blob-spammer/tester" - "github.com/ethpandaops/blob-spammer/txbuilder" - "github.com/ethpandaops/blob-spammer/utils" + "github.com/ethpandaops/goomy-blob/scenariotypes" + "github.com/ethpandaops/goomy-blob/tester" + "github.com/ethpandaops/goomy-blob/txbuilder" + "github.com/ethpandaops/goomy-blob/utils" ) type ScenarioOptions struct { diff --git a/scenarios/eoatx/eoatx.go b/scenarios/eoatx/eoatx.go index 6ce044d..82c1af5 100644 --- a/scenarios/eoatx/eoatx.go +++ b/scenarios/eoatx/eoatx.go @@ -13,10 +13,10 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/pflag" - "github.com/ethpandaops/blob-spammer/scenariotypes" - "github.com/ethpandaops/blob-spammer/tester" - "github.com/ethpandaops/blob-spammer/txbuilder" - "github.com/ethpandaops/blob-spammer/utils" + "github.com/ethpandaops/goomy-blob/scenariotypes" + "github.com/ethpandaops/goomy-blob/tester" + "github.com/ethpandaops/goomy-blob/txbuilder" + "github.com/ethpandaops/goomy-blob/utils" ) type ScenarioOptions struct { diff --git a/scenarios/erctx/erctx.go b/scenarios/erctx/erctx.go index 854cde4..4cfca04 100644 --- a/scenarios/erctx/erctx.go +++ b/scenarios/erctx/erctx.go @@ -14,10 +14,10 @@ import ( "github.com/spf13/pflag" "golang.org/x/crypto/sha3" - "github.com/ethpandaops/blob-spammer/scenariotypes" - "github.com/ethpandaops/blob-spammer/tester" - "github.com/ethpandaops/blob-spammer/txbuilder" - "github.com/ethpandaops/blob-spammer/utils" + "github.com/ethpandaops/goomy-blob/scenariotypes" + "github.com/ethpandaops/goomy-blob/tester" + "github.com/ethpandaops/goomy-blob/txbuilder" + "github.com/ethpandaops/goomy-blob/utils" ) type ScenarioOptions struct {