diff --git a/.gitignore b/.gitignore index ce4e0058..5f16e099 100644 --- a/.gitignore +++ b/.gitignore @@ -13,5 +13,5 @@ coverage.out coverage.html .idea .idea/* - +build/* data diff --git a/Makefile b/Makefile index 1c1a3bc2..d8fc4feb 100644 --- a/Makefile +++ b/Makefile @@ -86,10 +86,6 @@ stop: ## Stops all services test-unit: trap '$(STOP)' EXIT; MallocNanoZone=0 go test -count=1 -short -race -p 1 -covermode=atomic -coverprofile=coverage.out -coverpkg ./... -timeout 15m ./... -.PHONY: test-seq_sender -test-seq_sender: - trap '$(STOP)' EXIT; MallocNanoZone=0 go test -count=1 -short -race -p 1 -covermode=atomic -coverprofile=../coverage.out -timeout 200s ./sequencesender/... - .PHONY: lint lint: ## Runs the linter export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/golangci-lint run --timeout 5m diff --git a/cmd/run.go b/cmd/run.go index 607d159c..4bff1097 100644 --- a/cmd/run.go +++ b/cmd/run.go @@ -2,17 +2,13 @@ package main import ( "context" - "crypto/ecdsa" "fmt" - "math/big" "os" "os/signal" "runtime" - dataCommitteeClient "github.com/0xPolygon/cdk-data-availability/client" jRPC "github.com/0xPolygon/cdk-rpc/rpc" ethtxman "github.com/0xPolygon/zkevm-ethtx-manager/etherman" - "github.com/0xPolygon/zkevm-ethtx-manager/etherman/etherscan" "github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager" ethtxlog "github.com/0xPolygon/zkevm-ethtx-manager/log" "github.com/agglayer/aggkit" @@ -26,19 +22,13 @@ import ( "github.com/agglayer/aggkit/claimsponsor" aggkitcommon "github.com/agglayer/aggkit/common" "github.com/agglayer/aggkit/config" - "github.com/agglayer/aggkit/dataavailability" - "github.com/agglayer/aggkit/dataavailability/datacommittee" "github.com/agglayer/aggkit/etherman" ethermanconfig "github.com/agglayer/aggkit/etherman/config" - "github.com/agglayer/aggkit/etherman/contracts" "github.com/agglayer/aggkit/l1infotreesync" "github.com/agglayer/aggkit/lastgersync" "github.com/agglayer/aggkit/log" "github.com/agglayer/aggkit/reorgdetector" "github.com/agglayer/aggkit/rpc" - "github.com/agglayer/aggkit/sequencesender" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/translator" "github.com/ethereum/go-ethereum/ethclient" "github.com/urfave/cli/v2" ) @@ -88,12 +78,6 @@ func start(cliCtx *cli.Context) error { var rpcServices []jRPC.Service for _, component := range components { switch component { - case aggkitcommon.SEQUENCE_SENDER: - cfg.SequenceSender.Log = cfg.Log - seqSender := createSequenceSender(*cfg, l1Client, l1InfoTreeSync) - // start sequence sender in a goroutine, checking for errors - go seqSender.Start(cliCtx.Context) - case aggkitcommon.AGGREGATOR: aggregator := createAggregator(cliCtx.Context, *cfg, !cliCtx.Bool(config.FlagMigrations)) // start aggregator in a goroutine, checking for errors @@ -213,118 +197,6 @@ func createAggregator(ctx context.Context, c config.Config, runMigrations bool) return aggregator } -func createSequenceSender( - cfg config.Config, - l1Client *ethclient.Client, - l1InfoTreeSync *l1infotreesync.L1InfoTreeSync, -) *sequencesender.SequenceSender { - logger := log.WithFields("module", aggkitcommon.SEQUENCE_SENDER) - - // Check config - if cfg.SequenceSender.RPCURL == "" { - logger.Fatal("Required field RPCURL is empty in sequence sender config") - } - - ethman, err := etherman.NewClient(ethermanconfig.Config{ - EthermanConfig: ethtxman.Config{ - URL: cfg.SequenceSender.EthTxManager.Etherman.URL, - MultiGasProvider: cfg.SequenceSender.EthTxManager.Etherman.MultiGasProvider, - L1ChainID: cfg.SequenceSender.EthTxManager.Etherman.L1ChainID, - Etherscan: etherscan.Config{ - ApiKey: cfg.SequenceSender.EthTxManager.Etherman.Etherscan.ApiKey, - Url: cfg.SequenceSender.EthTxManager.Etherman.Etherscan.Url, - }, - HTTPHeaders: cfg.SequenceSender.EthTxManager.Etherman.HTTPHeaders, - }, - }, cfg.NetworkConfig.L1Config, cfg.Common) - if err != nil { - logger.Fatalf("Failed to create etherman. Err: %w, ", err) - } - - auth, _, err := ethman.LoadAuthFromKeyStore(cfg.SequenceSender.PrivateKey.Path, cfg.SequenceSender.PrivateKey.Password) - if err != nil { - logger.Fatal(err) - } - cfg.SequenceSender.SenderAddress = auth.From - blockFinalityType := etherman.BlockNumberFinality(cfg.SequenceSender.BlockFinality) - - blockFinality, err := blockFinalityType.ToBlockNum() - if err != nil { - logger.Fatalf("Failed to create block finality. Err: %w, ", err) - } - txBuilder, err := newTxBuilder(cfg, logger, ethman, l1Client, l1InfoTreeSync, blockFinality) - if err != nil { - logger.Fatal(err) - } - seqSender, err := sequencesender.New(cfg.SequenceSender, logger, ethman, txBuilder) - if err != nil { - logger.Fatal(err) - } - - return seqSender -} - -func newTxBuilder( - cfg config.Config, - logger *log.Logger, - ethman *etherman.Client, - l1Client *ethclient.Client, - l1InfoTreeSync *l1infotreesync.L1InfoTreeSync, - blockFinality *big.Int, -) (txbuilder.TxBuilder, error) { - auth, _, err := ethman.LoadAuthFromKeyStore(cfg.SequenceSender.PrivateKey.Path, cfg.SequenceSender.PrivateKey.Password) - if err != nil { - log.Fatal(err) - } - da, err := newDataAvailability(cfg, ethman) - if err != nil { - log.Fatal(err) - } - var txBuilder txbuilder.TxBuilder - - switch contracts.VersionType(cfg.Common.ContractVersions) { - case contracts.VersionBanana: - if cfg.Common.IsValidiumMode { - txBuilder = txbuilder.NewTxBuilderBananaValidium( - logger, - ethman.Contracts.Banana.Rollup, - ethman.Contracts.Banana.GlobalExitRoot, - da, - *auth, - cfg.SequenceSender.MaxBatchesForL1, - l1InfoTreeSync, - l1Client, - blockFinality, - ) - } else { - txBuilder = txbuilder.NewTxBuilderBananaZKEVM( - logger, - ethman.Contracts.Banana.Rollup, - ethman.Contracts.Banana.GlobalExitRoot, - *auth, - cfg.SequenceSender.MaxTxSizeForL1, - l1InfoTreeSync, - l1Client, - blockFinality, - ) - } - case contracts.VersionElderberry: - if cfg.Common.IsValidiumMode { - txBuilder = txbuilder.NewTxBuilderElderberryValidium( - logger, ethman.Contracts.Elderberry.Rollup, da, *auth, cfg.SequenceSender.MaxBatchesForL1, - ) - } else { - txBuilder = txbuilder.NewTxBuilderElderberryZKEVM( - logger, ethman.Contracts.Elderberry.Rollup, *auth, cfg.SequenceSender.MaxTxSizeForL1, - ) - } - default: - err = fmt.Errorf("unknown contract version: %s", cfg.Common.ContractVersions) - } - - return txBuilder, err -} - func createAggoracle( cfg config.Config, l1Client, @@ -377,54 +249,6 @@ func createAggoracle( return aggOracle } -func newDataAvailability(c config.Config, etherman *etherman.Client) (*dataavailability.DataAvailability, error) { - if !c.Common.IsValidiumMode { - return nil, nil - } - logger := log.WithFields("module", "da-committee") - translator := translator.NewTranslatorImpl(logger) - logger.Infof("Translator rules: %v", c.Common.Translator) - translator.AddConfigRules(c.Common.Translator) - - // Backend specific config - daProtocolName, err := etherman.GetDAProtocolName() - if err != nil { - return nil, fmt.Errorf("error getting data availability protocol name: %w", err) - } - var daBackend dataavailability.DABackender - switch daProtocolName { - case string(dataavailability.DataAvailabilityCommittee): - var ( - pk *ecdsa.PrivateKey - err error - ) - _, pk, err = etherman.LoadAuthFromKeyStore(c.SequenceSender.PrivateKey.Path, c.SequenceSender.PrivateKey.Password) - if err != nil { - return nil, err - } - dacAddr, err := etherman.GetDAProtocolAddr() - if err != nil { - return nil, fmt.Errorf("error getting trusted sequencer URI. Error: %w", err) - } - - daBackend, err = datacommittee.New( - logger, - c.SequenceSender.EthTxManager.Etherman.URL, - dacAddr, - pk, - dataCommitteeClient.NewFactory(), - translator, - ) - if err != nil { - return nil, err - } - default: - return nil, fmt.Errorf("unexpected / unsupported DA protocol: %s", daProtocolName) - } - - return dataavailability.New(daBackend) -} - func runAggregatorMigrations(dbPath string) { runMigrations(dbPath, db.AggregatorMigrationName) } diff --git a/config/config.go b/config/config.go index 9481a264..2182c460 100644 --- a/config/config.go +++ b/config/config.go @@ -19,7 +19,6 @@ import ( "github.com/agglayer/aggkit/lastgersync" "github.com/agglayer/aggkit/log" "github.com/agglayer/aggkit/reorgdetector" - "github.com/agglayer/aggkit/sequencesender" "github.com/mitchellh/mapstructure" "github.com/pelletier/go-toml/v2" "github.com/spf13/viper" @@ -103,10 +102,6 @@ type DeprecatedField struct { var ( deprecatedFieldsOnConfig = []DeprecatedField{ - { - FieldNamePattern: "sequencesender.ethtxmanager.persistencefilename", - Reason: deprecatedFieldPersistenceFilename, - }, { FieldNamePattern: "aggregator.synchronizer.db.", Reason: deprecatedFieldSyncDB, @@ -134,8 +129,6 @@ type Config struct { Log log.Config // Configuration of the genesis of the network. This is used to known the initial state of the network NetworkConfig NetworkConfig - // Configuration of the sequence sender service - SequenceSender sequencesender.Config // Common Config that affects all the services Common common.Config // Configuration of the reorg detector service to be used for the L1 diff --git a/config/config_test.go b/config/config_test.go index a7da6481..6bff9cf6 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -30,7 +30,7 @@ func TestLoadDefaultConfig(t *testing.T) { } const configWithDeprecatedFields = ` -[SequenceSender.EthTxManager] +[Aggregator.EthTxManager] nodepretatedfield = "value2" persistencefilename = "value" ` @@ -127,11 +127,6 @@ func TestLoadConfigWithForbiddenFields(t *testing.T) { input: `[Aggregator.Synchronizer.DB] name = "value"`, }, - { - name: "[SequenceSender.EthTxManager] PersistenceFilename", - input: `[SequenceSender.EthTxManager] - PersistenceFilename = "foo.json"`, - }, } for _, c := range cases { diff --git a/config/default.go b/config/default.go index f38d4c40..893214fb 100644 --- a/config/default.go +++ b/config/default.go @@ -77,40 +77,6 @@ NetworkID = 1 IsValidiumMode = {{IsValidiumMode}} ContractVersions = "{{ContractVersions}}" -[SequenceSender] -WaitPeriodSendSequence = "15s" -LastBatchVirtualizationTimeMaxWaitPeriod = "10s" -L1BlockTimestampMargin = "30s" -MaxTxSizeForL1 = 131072 -L2Coinbase = "{{L2Coinbase}}" -PrivateKey = { Path = "{{SequencerPrivateKeyPath}}", Password = "{{SequencerPrivateKeyPassword}}"} -SequencesTxFileName = "sequencesender.json" -GasOffset = 80000 -WaitPeriodPurgeTxFile = "15m" -MaxPendingTx = 1 -MaxBatchesForL1 = 300 -BlockFinality = "FinalizedBlock" -RPCURL = "{{L2URL}}" -GetBatchWaitInterval = "10s" - [SequenceSender.EthTxManager] - FrequencyToMonitorTxs = "1s" - WaitTxToBeMined = "2m" - GetReceiptMaxTime = "250ms" - GetReceiptWaitInterval = "1s" - PrivateKeys = [ - {Path = "{{SequencerPrivateKeyPath}}", Password = "{{SequencerPrivateKeyPassword}}"}, - ] - ForcedGas = 0 - GasPriceMarginFactor = 1 - MaxGasPriceLimit = 0 - StoragePath = "ethtxmanager.sqlite" - ReadPendingL1Txs = false - SafeStatusL1NumberOfBlocks = 0 - FinalizedStatusL1NumberOfBlocks = 0 - [SequenceSender.EthTxManager.Etherman] - URL = "{{L1URL}}" - MultiGasProvider = false - L1ChainID = {{NetworkConfig.L1.L1ChainID}} [Aggregator] # GRPC server host Host = "0.0.0.0" @@ -239,7 +205,7 @@ WaitPeriodNextGER="100ms" ForcedGas = 0 GasPriceMarginFactor = 1 MaxGasPriceLimit = 0 - StoragePath = "{{PathRWData}}/ethtxmanager-sequencesender.sqlite" + StoragePath = "{{PathRWData}}/ethtxmanager-aggoracle.sqlite" ReadPendingL1Txs = false SafeStatusL1NumberOfBlocks = 5 FinalizedStatusL1NumberOfBlocks = 10 diff --git a/crates/aggkit-config/src/lib.rs b/crates/aggkit-config/src/lib.rs index c86e9932..85f66193 100644 --- a/crates/aggkit-config/src/lib.rs +++ b/crates/aggkit-config/src/lib.rs @@ -10,11 +10,9 @@ pub(crate) mod aggregator; pub(crate) mod l1; pub mod log; pub(crate) mod network_config; -pub(crate) mod sequence_sender; pub(crate) mod telemetry; pub use log::Log; -use sequence_sender::SequenceSender; /// The Agglayer configuration. #[derive(Deserialize, Debug)] @@ -32,7 +30,4 @@ pub struct Config { #[serde(rename = "Aggregator", default)] pub aggregator: aggregator::Aggregator, - - #[serde(rename = "SequenceSender", default)] - pub sequence_sender: SequenceSender, } diff --git a/crates/aggkit-config/src/sequence_sender.rs b/crates/aggkit-config/src/sequence_sender.rs deleted file mode 100644 index c4e83cc5..00000000 --- a/crates/aggkit-config/src/sequence_sender.rs +++ /dev/null @@ -1,50 +0,0 @@ -use serde::Deserialize; - -/// The SequenceSender configuration. -#[derive(Deserialize, Debug, Clone)] -pub struct SequenceSender { - #[serde(rename = "WaitPeriodSendSequence", default)] - pub wait_period_send_sequence: String, - #[serde(rename = "LastBatchVirtualizationTimeMaxWaitPeriod", default)] - pub last_batch_virtualization_time_max_wait_period: String, - #[serde(rename = "MaxTxSizeForL1", default)] - pub max_tx_size_for_l1: u32, - #[serde(rename = "L2Coinbase", default)] - pub l2_coinbase: String, - #[serde(rename = "SequencesTxFileName", default)] - pub sequences_tx_file_name: String, - #[serde(rename = "GasOffset", default)] - pub gas_offset: u64, - #[serde(rename = "WaitPeriodPurgeTxFile", default)] - pub wait_period_purge_tx_file: String, - #[serde(rename = "MaxPendingTx", default)] - pub max_pending_tx: u32, - #[serde(rename = "MaxBatchesForL1", default)] - pub max_batches_for_l1: u32, - #[serde(rename = "BlockFinality", default)] - pub block_finality: String, - #[serde(rename = "RPCURL", default)] - pub rpc_url: String, - #[serde(rename = "GetBatchWaitInterval", default)] - pub get_batch_wait_interval: String, -} - -// Default trait implementation -impl Default for SequenceSender { - fn default() -> Self { - Self { - wait_period_send_sequence: "1s".to_string(), - last_batch_virtualization_time_max_wait_period: "1s".to_string(), - max_tx_size_for_l1: 1000, - l2_coinbase: "0x".to_string(), - sequences_tx_file_name: "sequences_tx.json".to_string(), - gas_offset: 0, - wait_period_purge_tx_file: "1s".to_string(), - max_pending_tx: 1000, - max_batches_for_l1: 100, - block_finality: "1s".to_string(), - rpc_url: "http://localhost:8545".to_string(), - get_batch_wait_interval: "1s".to_string(), - } - } -} diff --git a/crates/aggkit/src/cli.rs b/crates/aggkit/src/cli.rs index 5e5fd7ec..f94ee063 100644 --- a/crates/aggkit/src/cli.rs +++ b/crates/aggkit/src/cli.rs @@ -33,26 +33,6 @@ pub(crate) enum Commands { )] components: Option, }, - /// Run cdk-erigon node with the provided default configuration - Erigon { - /// The path to the configuration file - #[arg( - long, - short = 'C', - value_hint = ValueHint::FilePath, - env = "AGGKIT_CONFIG_PATH" - )] - config: PathBuf, - - /// The path to a chain specification file. - #[arg( - long, - short = 'g', - value_hint = ValueHint::FilePath, - env = "AGGKIT_GENESIS_PATH" - )] - chain: PathBuf, - }, /// Output the corresponding versions of the components Versions, } diff --git a/crates/aggkit/src/config_render.rs b/crates/aggkit/src/config_render.rs deleted file mode 100644 index e96971e3..00000000 --- a/crates/aggkit/src/config_render.rs +++ /dev/null @@ -1,128 +0,0 @@ -use crate::allocs_render::Rendered; -use anyhow::Error; -use aggkit_config::Config; -use std::fs; -use std::path::PathBuf; -use tempfile::{tempdir, TempDir}; - -pub fn render(config: &Config, genesis_file: PathBuf, timestamp: u64) -> Result { - // Create a temporary directory - let tmp_dir = tempdir()?; - let chain_id = config.aggregator.chain_id.clone(); - let res = crate::allocs_render::render_allocs(genesis_file.to_str().unwrap())?; - // Write the three files to disk - fs::write( - tmp_dir - .path() - .join(format!("dynamic-{}-allocs.json", chain_id.clone())), - res.output.clone(), - )?; - fs::write( - tmp_dir - .path() - .join(format!("dynamic-{}-chainspec.json", chain_id.clone())), - render_chainspec(chain_id.clone()), - )?; - fs::write( - tmp_dir - .path() - .join(format!("dynamic-{}-conf.json", chain_id.clone())), - render_conf(res.wrapper.root.clone(), timestamp), - )?; - - let contents = render_yaml(config, res); - fs::write( - tmp_dir - .path() - .join(format!("dynamic-{}.yaml", chain_id.clone())), - contents, - )?; - - Ok(tmp_dir) -} - -fn render_chainspec(chain_id: String) -> String { - format!( - r#" -{{ - "ChainName": "dynamic-{chain_id}", - "chainId": {chain_id}, - "consensus": "ethash", - "homesteadBlock": 0, - "daoForkBlock": 0, - "eip150Block": 0, - "eip155Block": 0, - "byzantiumBlock": 0, - "constantinopleBlock": 0, - "petersburgBlock": 0, - "istanbulBlock": 0, - "muirGlacierBlock": 0, - "berlinBlock": 0, - "londonBlock": 9999999999999999999999999999999999999999999999999, - "arrowGlacierBlock": 9999999999999999999999999999999999999999999999999, - "grayGlacierBlock": 9999999999999999999999999999999999999999999999999, - "terminalTotalDifficulty": 58750000000000000000000, - "terminalTotalDifficultyPassed": false, - "shanghaiTime": 9999999999999999999999999999999999999999999999999, - "cancunTime": 9999999999999999999999999999999999999999999999999, - "pragueTime": 9999999999999999999999999999999999999999999999999, - "ethash": {{}} -}} - "# - ) -} - -fn render_conf(root: String, timestamp: u64) -> String { - format!( - r#" -{{ - "root": {:?}, - "timestamp": {:?}, - "gasLimit": 0, - "difficulty": 0 -}} - "#, - root, timestamp - ) -} - -// render_config renders the configuration file for the Erigon node. -fn render_yaml(config: &Config, res: Rendered) -> String { - format!( - r#" -chain: dynamic-{chain_id} -zkevm.l2-chain-id: {chain_id} -zkevm.l2-sequencer-rpc-url: {l2_sequencer_rpc_url} -zkevm.l1-chain-id: {l1_chain_id} -zkevm.l1-rpc-url: {l1_rpc_url} -zkevm.address-sequencer: {sequencer_address} -zkevm.address-zkevm: {zkevm_address} -zkevm.address-rollup: {rollup_address} -zkevm.address-ger-manager: {ger_manager_address} -zkevm.l1-matic-contract-address: {pol_token_address} -zkevm.l1-first-block: {l1_first_block} -datadir: ./data/dynamic-{chain_id} - -externalcl: true -http: true -private.api.addr: "localhost:9092" -zkevm.rpc-ratelimit: 250 -zkevm.datastream-version: 3 -http.api: [eth, debug,net,trace,web3,erigon,zkevm] -http.addr: "0.0.0.0" -http.vhosts: any -http.corsdomain: any -ws: true -"#, - chain_id = config.aggregator.chain_id.clone(), - l2_sequencer_rpc_url = config.aggregator.witness_url.to_string(), - l1_rpc_url = config.aggregator.eth_tx_manager.etherman.url, - l1_chain_id = config.network_config.l1.l1_chain_id, - sequencer_address = config.sequence_sender.l2_coinbase, - zkevm_address = res.wrapper.l1_config.zkevm_address, - rollup_address = res.wrapper.l1_config.rollup_manager_address, - ger_manager_address = res.wrapper.l1_config.zkevm_global_exit_root_address, - pol_token_address = res.wrapper.l1_config.pol_token_address, - l1_first_block = res.wrapper.rollup_creation_block_number - ) -} diff --git a/crates/aggkit/src/main.rs b/crates/aggkit/src/main.rs index 8261d0cf..181c381a 100644 --- a/crates/aggkit/src/main.rs +++ b/crates/aggkit/src/main.rs @@ -1,6 +1,4 @@ //! Command line interface. -use alloy_rpc_client::ClientBuilder; -use alloy_rpc_client::ReqwestClient; use aggkit_config::Config; use clap::Parser; use cli::Cli; @@ -8,17 +6,13 @@ use colored::*; use execute::Execute; use std::path::PathBuf; use std::process::Command; -use url::Url; pub mod allocs_render; mod cli; -mod config_render; mod helpers; mod logging; mod versions; -const CDK_ERIGON_BIN: &str = "cdk-erigon"; - #[tokio::main] async fn main() -> anyhow::Result<()> { dotenvy::dotenv().ok(); @@ -42,7 +36,6 @@ async fn main() -> anyhow::Result<()> { match cli.cmd { cli::Commands::Node { config, components } => node(config, components)?, - cli::Commands::Erigon { config, chain } => erigon(config, chain).await?, cli::Commands::Versions {} => versions::versions(), } @@ -115,70 +108,3 @@ pub fn node(config_path: PathBuf, components: Option) -> anyhow::Result< Ok(()) } - -/// This is the main erigon entrypoint. -/// This function starts everything needed to run an Erigon node. -pub async fn erigon(config_path: PathBuf, genesis_file: PathBuf) -> anyhow::Result<()> { - // Read the config - let config = read_config(config_path.clone())?; - - // Initialize the logger - logging::tracing(&config.log); - - // Render configuration files - let chain_id = config.aggregator.chain_id.clone(); - let rpc_url = Url::parse(&config.sequence_sender.rpc_url).unwrap(); - let timestamp = get_timestamp(rpc_url).await.unwrap(); - let erigon_config_path = config_render::render(&config, genesis_file, timestamp)?; - - println!("Starting erigon with config: {:?}", erigon_config_path); - - // Run cdk-erigon in system path - let output = Command::new(CDK_ERIGON_BIN) - .args(&[ - "--config", - erigon_config_path - .path() - .join(format!("dynamic-{}.yaml", chain_id)) - .to_str() - .unwrap(), - ]) - .execute_output() - .unwrap(); - - if let Some(exit_code) = output.status.code() { - if exit_code != 0 { - eprintln!( - "Failed. Leaving configuration files in: {:?}", - erigon_config_path - ); - std::process::exit(1); - } - } else { - eprintln!("Interrupted!"); - } - - Ok(()) -} - -/// Call the rpc server to retrieve the first batch timestamp -async fn get_timestamp(url: Url) -> Result { - // Instantiate a new client over a transport. - let client: ReqwestClient = ClientBuilder::default().http(url); - - // Prepare a request to the server. - let request = client.request("zkevm_getBatchByNumber", vec!["0"]); - - // Poll the request to completion. - let batch_json: Batch = request.await.unwrap(); - - // Parse the timestamp hex string into u64. - let ts = u64::from_str_radix(batch_json.timestamp.trim_start_matches("0x"), 16)?; - - Ok(ts) -} - -#[derive(serde::Deserialize, Debug, Clone)] -struct Batch { - timestamp: String, -} diff --git a/dataavailability/config.go b/dataavailability/config.go deleted file mode 100644 index 8163e7bc..00000000 --- a/dataavailability/config.go +++ /dev/null @@ -1,9 +0,0 @@ -package dataavailability - -// DABackendType is the data availability protocol for the CDK -type DABackendType string - -const ( - // DataAvailabilityCommittee is the DAC protocol backend - DataAvailabilityCommittee DABackendType = "DataAvailabilityCommittee" -) diff --git a/dataavailability/dataavailability.go b/dataavailability/dataavailability.go deleted file mode 100644 index 39a27468..00000000 --- a/dataavailability/dataavailability.go +++ /dev/null @@ -1,33 +0,0 @@ -package dataavailability - -import ( - "context" - - "github.com/agglayer/aggkit/etherman" -) - -// DataAvailability implements an abstract data availability integration -type DataAvailability struct { - backend DABackender -} - -// New creates a DataAvailability instance -func New(backend DABackender) (*DataAvailability, error) { - da := &DataAvailability{ - backend: backend, - } - - return da, da.backend.Init() -} - -// PostSequenceBanana sends sequence data to the backend and returns a response. -func (d *DataAvailability) PostSequenceBanana( - ctx context.Context, sequenceBanana etherman.SequenceBanana, -) ([]byte, error) { - return d.backend.PostSequenceBanana(ctx, sequenceBanana) -} - -// PostSequenceElderberry sends batch data to the backend and returns a response. -func (d *DataAvailability) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - return d.backend.PostSequenceElderberry(ctx, batchesData) -} diff --git a/dataavailability/datacommittee/datacommittee.go b/dataavailability/datacommittee/datacommittee.go deleted file mode 100644 index be811a13..00000000 --- a/dataavailability/datacommittee/datacommittee.go +++ /dev/null @@ -1,401 +0,0 @@ -package datacommittee - -import ( - "crypto/ecdsa" - "crypto/rand" - "errors" - "fmt" - "math/big" - "sort" - "strings" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygondatacommittee" - "github.com/0xPolygon/cdk-data-availability/client" - daTypes "github.com/0xPolygon/cdk-data-availability/types" - "github.com/0xPolygonHermez/zkevm-synchronizer-l1/translator" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethclient" - "golang.org/x/net/context" -) - -const ( - unexpectedHashTemplate = "missmatch on transaction data. Expected hash %s, actual hash: %s" - translateContextName = "dataCommittee" -) - -// DataCommitteeMember represents a member of the Data Committee -type DataCommitteeMember struct { - Addr common.Address - URL string -} - -// DataCommittee represents a specific committee -type DataCommittee struct { - AddressesHash common.Hash - Members []DataCommitteeMember - RequiredSignatures uint64 -} - -// Backend implements the DAC integration -type Backend struct { - logger *log.Logger - dataCommitteeContract *polygondatacommittee.Polygondatacommittee - privKey *ecdsa.PrivateKey - dataCommitteeClientFactory client.Factory - - committeeMembers []DataCommitteeMember - selectedCommitteeMember int - ctx context.Context - Translator translator.Translator -} - -// New creates an instance of Backend -func New( - logger *log.Logger, - l1RPCURL string, - dataCommitteeAddr common.Address, - privKey *ecdsa.PrivateKey, - dataCommitteeClientFactory client.Factory, - translator translator.Translator, -) (*Backend, error) { - ethClient, err := ethclient.Dial(l1RPCURL) - if err != nil { - logger.Errorf("error connecting to %s: %+v", l1RPCURL, err) - return nil, err - } - - dataCommittee, err := polygondatacommittee.NewPolygondatacommittee(dataCommitteeAddr, ethClient) - if err != nil { - return nil, err - } - - return &Backend{ - logger: logger, - dataCommitteeContract: dataCommittee, - privKey: privKey, - dataCommitteeClientFactory: dataCommitteeClientFactory, - ctx: context.Background(), - Translator: translator, - }, nil -} - -// Init loads the DAC to be cached when needed -func (d *Backend) Init() error { - committee, err := d.getCurrentDataCommittee() - if err != nil { - return err - } - selectedCommitteeMember := -1 - if committee != nil { - d.committeeMembers = committee.Members - if len(committee.Members) > 0 { - nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(committee.Members)))) - if err != nil { - return err - } - selectedCommitteeMember = int(nBig.Int64()) - } - } - d.selectedCommitteeMember = selectedCommitteeMember - - return nil -} - -// GetSequence retrieves backend data by querying committee members for each hash concurrently. -func (d *Backend) GetSequence(_ context.Context, hashes []common.Hash, _ []byte) ([][]byte, error) { - initialMember := d.selectedCommitteeMember - - var batchData [][]byte - for retries := 0; retries < len(d.committeeMembers); retries++ { - member := d.committeeMembers[d.selectedCommitteeMember] - d.logger.Infof("trying to get data from %s at %s", member.Addr.Hex(), member.URL) - - c := d.dataCommitteeClientFactory.New(member.URL) - dataMap, err := c.ListOffChainData(d.ctx, hashes) - if err != nil { - d.logger.Warnf("error getting data from DAC node %s at %s: %s", member.Addr.Hex(), member.URL, err) - d.selectedCommitteeMember = (d.selectedCommitteeMember + 1) % len(d.committeeMembers) - if d.selectedCommitteeMember == initialMember { - break - } - continue - } - - batchData = make([][]byte, 0, len(hashes)) - for _, hash := range hashes { - actualTransactionsHash := crypto.Keccak256Hash(dataMap[hash]) - if actualTransactionsHash != hash { - unexpectedHash := fmt.Errorf(unexpectedHashTemplate, hash, actualTransactionsHash) - d.logger.Warnf("error getting data from DAC node %s at %s: %s", member.Addr.Hex(), member.URL, unexpectedHash) - d.selectedCommitteeMember = (d.selectedCommitteeMember + 1) % len(d.committeeMembers) - if d.selectedCommitteeMember == initialMember { - break - } - continue - } - batchData = append(batchData, dataMap[hash]) - } - return batchData, nil - } - - if err := d.Init(); err != nil { - return nil, fmt.Errorf("error loading data committee: %w", err) - } - - return nil, fmt.Errorf("couldn't get the data from any committee member") -} - -type signatureMsg struct { - addr common.Address - signature []byte - err error -} - -// PostSequenceElderberry submits batches and collects signatures from committee members. -func (d *Backend) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - // Get current committee - committee, err := d.getCurrentDataCommittee() - if err != nil { - return nil, err - } - - // Authenticate as trusted sequencer by signing the sequence - sequence := make(daTypes.Sequence, 0, len(batchesData)) - for _, batchData := range batchesData { - sequence = append(sequence, batchData) - } - signedSequence, err := sequence.Sign(d.privKey) - if err != nil { - return nil, err - } - - // Request signatures to all members in parallel - ch := make(chan signatureMsg, len(committee.Members)) - signatureCtx, cancelSignatureCollection := context.WithCancel(ctx) - for _, member := range committee.Members { - signedSequenceElderberry := daTypes.SignedSequence{ - Sequence: sequence, - Signature: signedSequence, - } - go d.requestSignatureFromMember(signatureCtx, &signedSequenceElderberry, - func(c client.Client) ([]byte, error) { return c.SignSequence(ctx, signedSequenceElderberry) }, member, ch) - } - return d.collectSignatures(committee, ch, cancelSignatureCollection) -} - -// PostSequenceBanana submits a sequence to the data committee and collects the signed response from them. -func (d *Backend) PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) { - // Get current committee - committee, err := d.getCurrentDataCommittee() - if err != nil { - return nil, err - } - - sequenceBatches := make([]daTypes.Batch, 0, len(sequence.Batches)) - for _, batch := range sequence.Batches { - sequenceBatches = append(sequenceBatches, daTypes.Batch{ - L2Data: batch.L2Data, - Coinbase: batch.LastCoinbase, - ForcedBlockHashL1: batch.ForcedBlockHashL1, - ForcedGER: batch.ForcedGlobalExitRoot, - ForcedTimestamp: daTypes.ArgUint64(batch.ForcedBatchTimestamp), - }) - } - - sequenceBanana := daTypes.SequenceBanana{ - Batches: sequenceBatches, - OldAccInputHash: sequence.OldAccInputHash, - L1InfoRoot: sequence.L1InfoRoot, - MaxSequenceTimestamp: daTypes.ArgUint64(sequence.MaxSequenceTimestamp), - } - hashToSign := common.BytesToHash(sequenceBanana.HashToSign()) - if hashToSign != sequence.AccInputHash { - return nil, fmt.Errorf( - "calculated accInputHash diverges: DA = %s vs Seq = %s", - hashToSign, sequence.AccInputHash, - ) - } - - signature, err := sequenceBanana.Sign(d.privKey) - if err != nil { - return nil, err - } - - // Request signatures to all members in parallel - ch := make(chan signatureMsg, len(committee.Members)) - signatureCtx, cancelSignatureCollection := context.WithCancel(ctx) - for _, member := range committee.Members { - signedSequenceBanana := daTypes.SignedSequenceBanana{ - Sequence: sequenceBanana, - Signature: signature, - } - go d.requestSignatureFromMember(signatureCtx, - &signedSequenceBanana, - func(c client.Client) ([]byte, error) { return c.SignSequenceBanana(ctx, signedSequenceBanana) }, - member, ch) - } - - return d.collectSignatures(committee, ch, cancelSignatureCollection) -} - -func (d *Backend) collectSignatures( - committee *DataCommittee, ch chan signatureMsg, cancelSignatureCollection context.CancelFunc) ([]byte, error) { - // Collect signatures - // Stop requesting as soon as we have N valid signatures - var ( - msgs = make(signatureMsgs, 0, len(committee.Members)) - collectedSignatures uint64 - failedToCollect uint64 - ) - for collectedSignatures < committee.RequiredSignatures { - msg := <-ch - if msg.err != nil { - d.logger.Errorf("error when trying to get signature from %s: %s", msg.addr, msg.err) - failedToCollect++ - if len(committee.Members)-int(failedToCollect) < int(committee.RequiredSignatures) { - cancelSignatureCollection() - - return nil, errors.New("too many members failed to send their signature") - } - } else { - d.logger.Infof("received signature from %s", msg.addr) - collectedSignatures++ - } - msgs = append(msgs, msg) - } - - cancelSignatureCollection() - - return d.buildSignaturesAndAddrs(msgs, committee.Members), nil -} - -type funcSignType func(c client.Client) ([]byte, error) - -// funcSetSignatureType: is not possible to define a SetSignature function because -// the type daTypes.SequenceBanana and daTypes.Sequence belong to different packages -// So a future refactor is define a common interface for both -func (d *Backend) requestSignatureFromMember(ctx context.Context, signedSequence daTypes.SignedSequenceInterface, - funcSign funcSignType, - member DataCommitteeMember, ch chan signatureMsg) { - select { - case <-ctx.Done(): - return - default: - } - - // request - c := client.New(member.URL) - d.logger.Infof("sending request to sign the sequence to %s at %s", member.Addr.Hex(), member.URL) - // funcSign must call something like that c.SignSequenceBanana(ctx, signedSequence) - signature, err := funcSign(c) - - if err != nil { - ch <- signatureMsg{ - addr: member.Addr, - err: err, - } - - return - } - // verify returned signature - signedSequence.SetSignature(signature) - signer, err := signedSequence.Signer() - if err != nil { - ch <- signatureMsg{ - addr: member.Addr, - err: err, - } - - return - } - if signer != member.Addr { - ch <- signatureMsg{ - addr: member.Addr, - err: fmt.Errorf("invalid signer. Expected %s, actual %s", member.Addr.Hex(), signer.Hex()), - } - - return - } - ch <- signatureMsg{ - addr: member.Addr, - signature: signature, - } -} - -func (d *Backend) buildSignaturesAndAddrs(sigs signatureMsgs, members []DataCommitteeMember) []byte { - const ( - sigLen = 65 - ) - res := make([]byte, 0, len(sigs)*sigLen+len(members)*common.AddressLength) - sort.Sort(sigs) - for _, msg := range sigs { - d.logger.Debugf("adding signature %s from %s", common.Bytes2Hex(msg.signature), msg.addr.Hex()) - res = append(res, msg.signature...) - } - for _, member := range members { - d.logger.Debugf("adding addr %s", common.Bytes2Hex(member.Addr.Bytes())) - res = append(res, member.Addr.Bytes()...) - } - d.logger.Debugf("full res %s", common.Bytes2Hex(res)) - return res -} - -type signatureMsgs []signatureMsg - -func (s signatureMsgs) Len() int { return len(s) } -func (s signatureMsgs) Less(i, j int) bool { - return strings.ToUpper(s[i].addr.Hex()) < strings.ToUpper(s[j].addr.Hex()) -} -func (s signatureMsgs) Swap(i, j int) { s[i], s[j] = s[j], s[i] } - -// getCurrentDataCommittee return the currently registered data committee -func (d *Backend) getCurrentDataCommittee() (*DataCommittee, error) { - addrsHash, err := d.dataCommitteeContract.CommitteeHash(&bind.CallOpts{Pending: false}) - if err != nil { - return nil, fmt.Errorf("error getting CommitteeHash from L1 SC: %w", err) - } - - reqSign, err := d.dataCommitteeContract.RequiredAmountOfSignatures(&bind.CallOpts{Pending: false}) - if err != nil { - return nil, fmt.Errorf("error getting RequiredAmountOfSignatures from L1 SC: %w", err) - } - - members, err := d.getCurrentDataCommitteeMembers() - if err != nil { - return nil, err - } - - return &DataCommittee{ - AddressesHash: addrsHash, - RequiredSignatures: reqSign.Uint64(), - Members: members, - }, nil -} - -// getCurrentDataCommitteeMembers return the currently registered data committee members -func (d *Backend) getCurrentDataCommitteeMembers() ([]DataCommitteeMember, error) { - nMembers, err := d.dataCommitteeContract.GetAmountOfMembers(&bind.CallOpts{Pending: false}) - if err != nil { - return nil, fmt.Errorf("error getting GetAmountOfMembers from L1 SC: %w", err) - } - members := make([]DataCommitteeMember, 0, nMembers.Int64()) - for i := int64(0); i < nMembers.Int64(); i++ { - member, err := d.dataCommitteeContract.Members(&bind.CallOpts{Pending: false}, big.NewInt(i)) - if err != nil { - return nil, fmt.Errorf("error getting Members %d from L1 SC: %w", i, err) - } - if d.Translator != nil { - member.Url = d.Translator.Translate(translateContextName, member.Url) - } - members = append(members, DataCommitteeMember{ - Addr: member.Addr, - URL: member.Url, - }) - } - - return members, nil -} diff --git a/dataavailability/datacommittee/datacommittee_test.go b/dataavailability/datacommittee/datacommittee_test.go deleted file mode 100644 index 8931e6e8..00000000 --- a/dataavailability/datacommittee/datacommittee_test.go +++ /dev/null @@ -1,142 +0,0 @@ -package datacommittee - -import ( - "errors" - "math/big" - "testing" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygondatacommittee" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/test/contracts/erc1967proxy" - "github.com/agglayer/aggkit/test/helpers" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethclient/simulated" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestUpdateDataCommitteeEvent(t *testing.T) { - // Set up testing environment - dac, ethBackend, da, auth := newSimulatedDACBackend(t) - - // Update the committee - requiredAmountOfSignatures := big.NewInt(2) - URLs := []string{"1", "2", "3"} - addrs := []common.Address{ - common.HexToAddress("0x1"), - common.HexToAddress("0x2"), - common.HexToAddress("0x3"), - } - addrsBytes := []byte{} - for _, addr := range addrs { - addrsBytes = append(addrsBytes, addr.Bytes()...) - } - _, err := da.SetupCommittee(auth, requiredAmountOfSignatures, URLs, addrsBytes) - require.NoError(t, err) - ethBackend.Commit() - - // Assert the committee update - actualSetup, err := dac.getCurrentDataCommittee() - require.NoError(t, err) - expectedMembers := []DataCommitteeMember{} - expectedSetup := DataCommittee{ - RequiredSignatures: uint64(len(URLs) - 1), - AddressesHash: crypto.Keccak256Hash(addrsBytes), - } - for i, url := range URLs { - expectedMembers = append(expectedMembers, DataCommitteeMember{ - URL: url, - Addr: addrs[i], - }) - } - expectedSetup.Members = expectedMembers - assert.Equal(t, expectedSetup, *actualSetup) -} - -func init() { - log.Init(log.Config{ - Level: "debug", - Outputs: []string{"stderr"}, - }) -} - -// NewSimulatedEtherman creates an etherman that uses a simulated blockchain. It's important to notice that the ChainID of the auth -// must be 1337. The address that holds the auth will have an initial balance of 10 ETH -func newSimulatedDACBackend(t *testing.T) ( - *Backend, - *simulated.Backend, - *polygondatacommittee.Polygondatacommittee, - *bind.TransactOpts, -) { - t.Helper() - - deployerAuth, err := helpers.CreateAccount(big.NewInt(1337)) - require.NoError(t, err) - - ethBackend, setup := helpers.NewSimulatedBackend(t, nil, deployerAuth) - - // DAC Setup - addr, _, _, err := polygondatacommittee.DeployPolygondatacommittee(setup.UserAuth, ethBackend.Client()) - require.NoError(t, err) - ethBackend.Commit() - - proxyAddr, err := deployDACProxy(setup.UserAuth, ethBackend.Client(), addr) - require.NoError(t, err) - ethBackend.Commit() - - da, err := polygondatacommittee.NewPolygondatacommittee(proxyAddr, ethBackend.Client()) - require.NoError(t, err) - - _, err = da.SetupCommittee(setup.UserAuth, big.NewInt(0), []string{}, []byte{}) - require.NoError(t, err) - ethBackend.Commit() - - c := &Backend{ - dataCommitteeContract: da, - } - - return c, ethBackend, da, setup.UserAuth -} - -func deployDACProxy(auth *bind.TransactOpts, client bind.ContractBackend, dacImpl common.Address) (common.Address, error) { - // Deploy proxy - dacABI, err := polygondatacommittee.PolygondatacommitteeMetaData.GetAbi() - if err != nil { - return common.Address{}, err - } - if dacABI == nil { - return common.Address{}, errors.New("GetABI returned nil") - } - initializeCallData, err := dacABI.Pack("initialize") - if err != nil { - return common.Address{}, err - } - proxyAddr, err := deployProxy( - auth, - client, - dacImpl, - initializeCallData, - ) - if err != nil { - return common.Address{}, err - } - log.Debugf("DAC proxy deployed at", proxyAddr) - - return proxyAddr, nil -} - -func deployProxy(auth *bind.TransactOpts, - client bind.ContractBackend, - implementationAddr common.Address, - initializeParams []byte) (common.Address, error) { - addr, _, _, err := erc1967proxy.DeployErc1967proxy( - auth, - client, - implementationAddr, - initializeParams, - ) - - return addr, err -} diff --git a/dataavailability/interfaces.go b/dataavailability/interfaces.go deleted file mode 100644 index 6ca62bab..00000000 --- a/dataavailability/interfaces.go +++ /dev/null @@ -1,54 +0,0 @@ -package dataavailability - -import ( - "context" - - "github.com/agglayer/aggkit/etherman" - "github.com/ethereum/go-ethereum/common" -) - -// DABackender is an interface for components that store and retrieve batch data -type DABackender interface { - SequenceRetriever - SequenceSender - // Init initializes the DABackend - Init() error -} - -// SequenceSender is used to send provided sequence of batches -type SequenceSender interface { - SequenceSenderElderberry - SequenceSenderBanana -} - -// SequenceSenderElderberry defines methods for sending sequence data to the data availability backend. -type SequenceSenderElderberry interface { - // PostSequence sends the sequence data to the data availability backend, and returns the dataAvailabilityMessage - // as expected by the contract - PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) -} - -// SequenceSenderBanana defines methods for sending sequence data to the data availability backend. -type SequenceSenderBanana interface { - // PostSequence sends the sequence data to the data availability backend, and returns the dataAvailabilityMessage - // as expected by the contract - PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) -} - -// SequenceRetriever is used to retrieve batch data -type SequenceRetriever interface { - // GetSequence retrieves the sequence data from the data availability backend - GetSequence(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) -} - -// BatchDataProvider is used to retrieve batch data -type BatchDataProvider interface { - // GetBatchL2Data retrieve the data of a batch from the DA backend. The returned data must be the pre-image of the hash - GetBatchL2Data(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) -} - -// DataManager is an interface for components that send and retrieve batch data -type DataManager interface { - BatchDataProvider - SequenceSender -} diff --git a/dataavailability/mocks_da/batch_data_provider.go b/dataavailability/mocks_da/batch_data_provider.go deleted file mode 100644 index 36e782ac..00000000 --- a/dataavailability/mocks_da/batch_data_provider.go +++ /dev/null @@ -1,96 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" -) - -// BatchDataProvider is an autogenerated mock type for the BatchDataProvider type -type BatchDataProvider struct { - mock.Mock -} - -type BatchDataProvider_Expecter struct { - mock *mock.Mock -} - -func (_m *BatchDataProvider) EXPECT() *BatchDataProvider_Expecter { - return &BatchDataProvider_Expecter{mock: &_m.Mock} -} - -// GetBatchL2Data provides a mock function with given fields: batchNum, batchHashes, dataAvailabilityMessage -func (_m *BatchDataProvider) GetBatchL2Data(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) { - ret := _m.Called(batchNum, batchHashes, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for GetBatchL2Data") - } - - var r0 [][]byte - var r1 error - if rf, ok := ret.Get(0).(func([]uint64, []common.Hash, []byte) ([][]byte, error)); ok { - return rf(batchNum, batchHashes, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func([]uint64, []common.Hash, []byte) [][]byte); ok { - r0 = rf(batchNum, batchHashes, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([][]byte) - } - } - - if rf, ok := ret.Get(1).(func([]uint64, []common.Hash, []byte) error); ok { - r1 = rf(batchNum, batchHashes, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// BatchDataProvider_GetBatchL2Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBatchL2Data' -type BatchDataProvider_GetBatchL2Data_Call struct { - *mock.Call -} - -// GetBatchL2Data is a helper method to define mock.On call -// - batchNum []uint64 -// - batchHashes []common.Hash -// - dataAvailabilityMessage []byte -func (_e *BatchDataProvider_Expecter) GetBatchL2Data(batchNum interface{}, batchHashes interface{}, dataAvailabilityMessage interface{}) *BatchDataProvider_GetBatchL2Data_Call { - return &BatchDataProvider_GetBatchL2Data_Call{Call: _e.mock.On("GetBatchL2Data", batchNum, batchHashes, dataAvailabilityMessage)} -} - -func (_c *BatchDataProvider_GetBatchL2Data_Call) Run(run func(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte)) *BatchDataProvider_GetBatchL2Data_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].([]uint64), args[1].([]common.Hash), args[2].([]byte)) - }) - return _c -} - -func (_c *BatchDataProvider_GetBatchL2Data_Call) Return(_a0 [][]byte, _a1 error) *BatchDataProvider_GetBatchL2Data_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *BatchDataProvider_GetBatchL2Data_Call) RunAndReturn(run func([]uint64, []common.Hash, []byte) ([][]byte, error)) *BatchDataProvider_GetBatchL2Data_Call { - _c.Call.Return(run) - return _c -} - -// NewBatchDataProvider creates a new instance of BatchDataProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewBatchDataProvider(t interface { - mock.TestingT - Cleanup(func()) -}) *BatchDataProvider { - mock := &BatchDataProvider{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/da_backender.go b/dataavailability/mocks_da/da_backender.go deleted file mode 100644 index d12e6b35..00000000 --- a/dataavailability/mocks_da/da_backender.go +++ /dev/null @@ -1,263 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - etherman "github.com/agglayer/aggkit/etherman" - - mock "github.com/stretchr/testify/mock" -) - -// DABackender is an autogenerated mock type for the DABackender type -type DABackender struct { - mock.Mock -} - -type DABackender_Expecter struct { - mock *mock.Mock -} - -func (_m *DABackender) EXPECT() *DABackender_Expecter { - return &DABackender_Expecter{mock: &_m.Mock} -} - -// GetSequence provides a mock function with given fields: ctx, batchHashes, dataAvailabilityMessage -func (_m *DABackender) GetSequence(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) { - ret := _m.Called(ctx, batchHashes, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for GetSequence") - } - - var r0 [][]byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []common.Hash, []byte) ([][]byte, error)); ok { - return rf(ctx, batchHashes, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func(context.Context, []common.Hash, []byte) [][]byte); ok { - r0 = rf(ctx, batchHashes, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([][]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []common.Hash, []byte) error); ok { - r1 = rf(ctx, batchHashes, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DABackender_GetSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequence' -type DABackender_GetSequence_Call struct { - *mock.Call -} - -// GetSequence is a helper method to define mock.On call -// - ctx context.Context -// - batchHashes []common.Hash -// - dataAvailabilityMessage []byte -func (_e *DABackender_Expecter) GetSequence(ctx interface{}, batchHashes interface{}, dataAvailabilityMessage interface{}) *DABackender_GetSequence_Call { - return &DABackender_GetSequence_Call{Call: _e.mock.On("GetSequence", ctx, batchHashes, dataAvailabilityMessage)} -} - -func (_c *DABackender_GetSequence_Call) Run(run func(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte)) *DABackender_GetSequence_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]common.Hash), args[2].([]byte)) - }) - return _c -} - -func (_c *DABackender_GetSequence_Call) Return(_a0 [][]byte, _a1 error) *DABackender_GetSequence_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DABackender_GetSequence_Call) RunAndReturn(run func(context.Context, []common.Hash, []byte) ([][]byte, error)) *DABackender_GetSequence_Call { - _c.Call.Return(run) - return _c -} - -// Init provides a mock function with no fields -func (_m *DABackender) Init() error { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for Init") - } - - var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// DABackender_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' -type DABackender_Init_Call struct { - *mock.Call -} - -// Init is a helper method to define mock.On call -func (_e *DABackender_Expecter) Init() *DABackender_Init_Call { - return &DABackender_Init_Call{Call: _e.mock.On("Init")} -} - -func (_c *DABackender_Init_Call) Run(run func()) *DABackender_Init_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *DABackender_Init_Call) Return(_a0 error) *DABackender_Init_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *DABackender_Init_Call) RunAndReturn(run func() error) *DABackender_Init_Call { - _c.Call.Return(run) - return _c -} - -// PostSequenceBanana provides a mock function with given fields: ctx, sequence -func (_m *DABackender) PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) { - ret := _m.Called(ctx, sequence) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceBanana") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) ([]byte, error)); ok { - return rf(ctx, sequence) - } - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) []byte); ok { - r0 = rf(ctx, sequence) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, etherman.SequenceBanana) error); ok { - r1 = rf(ctx, sequence) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DABackender_PostSequenceBanana_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceBanana' -type DABackender_PostSequenceBanana_Call struct { - *mock.Call -} - -// PostSequenceBanana is a helper method to define mock.On call -// - ctx context.Context -// - sequence etherman.SequenceBanana -func (_e *DABackender_Expecter) PostSequenceBanana(ctx interface{}, sequence interface{}) *DABackender_PostSequenceBanana_Call { - return &DABackender_PostSequenceBanana_Call{Call: _e.mock.On("PostSequenceBanana", ctx, sequence)} -} - -func (_c *DABackender_PostSequenceBanana_Call) Run(run func(ctx context.Context, sequence etherman.SequenceBanana)) *DABackender_PostSequenceBanana_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(etherman.SequenceBanana)) - }) - return _c -} - -func (_c *DABackender_PostSequenceBanana_Call) Return(_a0 []byte, _a1 error) *DABackender_PostSequenceBanana_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DABackender_PostSequenceBanana_Call) RunAndReturn(run func(context.Context, etherman.SequenceBanana) ([]byte, error)) *DABackender_PostSequenceBanana_Call { - _c.Call.Return(run) - return _c -} - -// PostSequenceElderberry provides a mock function with given fields: ctx, batchesData -func (_m *DABackender) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - ret := _m.Called(ctx, batchesData) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceElderberry") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) ([]byte, error)); ok { - return rf(ctx, batchesData) - } - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) []byte); ok { - r0 = rf(ctx, batchesData) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, [][]byte) error); ok { - r1 = rf(ctx, batchesData) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DABackender_PostSequenceElderberry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceElderberry' -type DABackender_PostSequenceElderberry_Call struct { - *mock.Call -} - -// PostSequenceElderberry is a helper method to define mock.On call -// - ctx context.Context -// - batchesData [][]byte -func (_e *DABackender_Expecter) PostSequenceElderberry(ctx interface{}, batchesData interface{}) *DABackender_PostSequenceElderberry_Call { - return &DABackender_PostSequenceElderberry_Call{Call: _e.mock.On("PostSequenceElderberry", ctx, batchesData)} -} - -func (_c *DABackender_PostSequenceElderberry_Call) Run(run func(ctx context.Context, batchesData [][]byte)) *DABackender_PostSequenceElderberry_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([][]byte)) - }) - return _c -} - -func (_c *DABackender_PostSequenceElderberry_Call) Return(_a0 []byte, _a1 error) *DABackender_PostSequenceElderberry_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DABackender_PostSequenceElderberry_Call) RunAndReturn(run func(context.Context, [][]byte) ([]byte, error)) *DABackender_PostSequenceElderberry_Call { - _c.Call.Return(run) - return _c -} - -// NewDABackender creates a new instance of DABackender. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewDABackender(t interface { - mock.TestingT - Cleanup(func()) -}) *DABackender { - mock := &DABackender{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/data_manager.go b/dataavailability/mocks_da/data_manager.go deleted file mode 100644 index f2ac6886..00000000 --- a/dataavailability/mocks_da/data_manager.go +++ /dev/null @@ -1,218 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - etherman "github.com/agglayer/aggkit/etherman" - - mock "github.com/stretchr/testify/mock" -) - -// DataManager is an autogenerated mock type for the DataManager type -type DataManager struct { - mock.Mock -} - -type DataManager_Expecter struct { - mock *mock.Mock -} - -func (_m *DataManager) EXPECT() *DataManager_Expecter { - return &DataManager_Expecter{mock: &_m.Mock} -} - -// GetBatchL2Data provides a mock function with given fields: batchNum, batchHashes, dataAvailabilityMessage -func (_m *DataManager) GetBatchL2Data(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) { - ret := _m.Called(batchNum, batchHashes, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for GetBatchL2Data") - } - - var r0 [][]byte - var r1 error - if rf, ok := ret.Get(0).(func([]uint64, []common.Hash, []byte) ([][]byte, error)); ok { - return rf(batchNum, batchHashes, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func([]uint64, []common.Hash, []byte) [][]byte); ok { - r0 = rf(batchNum, batchHashes, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([][]byte) - } - } - - if rf, ok := ret.Get(1).(func([]uint64, []common.Hash, []byte) error); ok { - r1 = rf(batchNum, batchHashes, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DataManager_GetBatchL2Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBatchL2Data' -type DataManager_GetBatchL2Data_Call struct { - *mock.Call -} - -// GetBatchL2Data is a helper method to define mock.On call -// - batchNum []uint64 -// - batchHashes []common.Hash -// - dataAvailabilityMessage []byte -func (_e *DataManager_Expecter) GetBatchL2Data(batchNum interface{}, batchHashes interface{}, dataAvailabilityMessage interface{}) *DataManager_GetBatchL2Data_Call { - return &DataManager_GetBatchL2Data_Call{Call: _e.mock.On("GetBatchL2Data", batchNum, batchHashes, dataAvailabilityMessage)} -} - -func (_c *DataManager_GetBatchL2Data_Call) Run(run func(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte)) *DataManager_GetBatchL2Data_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].([]uint64), args[1].([]common.Hash), args[2].([]byte)) - }) - return _c -} - -func (_c *DataManager_GetBatchL2Data_Call) Return(_a0 [][]byte, _a1 error) *DataManager_GetBatchL2Data_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DataManager_GetBatchL2Data_Call) RunAndReturn(run func([]uint64, []common.Hash, []byte) ([][]byte, error)) *DataManager_GetBatchL2Data_Call { - _c.Call.Return(run) - return _c -} - -// PostSequenceBanana provides a mock function with given fields: ctx, sequence -func (_m *DataManager) PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) { - ret := _m.Called(ctx, sequence) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceBanana") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) ([]byte, error)); ok { - return rf(ctx, sequence) - } - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) []byte); ok { - r0 = rf(ctx, sequence) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, etherman.SequenceBanana) error); ok { - r1 = rf(ctx, sequence) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DataManager_PostSequenceBanana_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceBanana' -type DataManager_PostSequenceBanana_Call struct { - *mock.Call -} - -// PostSequenceBanana is a helper method to define mock.On call -// - ctx context.Context -// - sequence etherman.SequenceBanana -func (_e *DataManager_Expecter) PostSequenceBanana(ctx interface{}, sequence interface{}) *DataManager_PostSequenceBanana_Call { - return &DataManager_PostSequenceBanana_Call{Call: _e.mock.On("PostSequenceBanana", ctx, sequence)} -} - -func (_c *DataManager_PostSequenceBanana_Call) Run(run func(ctx context.Context, sequence etherman.SequenceBanana)) *DataManager_PostSequenceBanana_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(etherman.SequenceBanana)) - }) - return _c -} - -func (_c *DataManager_PostSequenceBanana_Call) Return(_a0 []byte, _a1 error) *DataManager_PostSequenceBanana_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DataManager_PostSequenceBanana_Call) RunAndReturn(run func(context.Context, etherman.SequenceBanana) ([]byte, error)) *DataManager_PostSequenceBanana_Call { - _c.Call.Return(run) - return _c -} - -// PostSequenceElderberry provides a mock function with given fields: ctx, batchesData -func (_m *DataManager) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - ret := _m.Called(ctx, batchesData) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceElderberry") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) ([]byte, error)); ok { - return rf(ctx, batchesData) - } - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) []byte); ok { - r0 = rf(ctx, batchesData) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, [][]byte) error); ok { - r1 = rf(ctx, batchesData) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// DataManager_PostSequenceElderberry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceElderberry' -type DataManager_PostSequenceElderberry_Call struct { - *mock.Call -} - -// PostSequenceElderberry is a helper method to define mock.On call -// - ctx context.Context -// - batchesData [][]byte -func (_e *DataManager_Expecter) PostSequenceElderberry(ctx interface{}, batchesData interface{}) *DataManager_PostSequenceElderberry_Call { - return &DataManager_PostSequenceElderberry_Call{Call: _e.mock.On("PostSequenceElderberry", ctx, batchesData)} -} - -func (_c *DataManager_PostSequenceElderberry_Call) Run(run func(ctx context.Context, batchesData [][]byte)) *DataManager_PostSequenceElderberry_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([][]byte)) - }) - return _c -} - -func (_c *DataManager_PostSequenceElderberry_Call) Return(_a0 []byte, _a1 error) *DataManager_PostSequenceElderberry_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *DataManager_PostSequenceElderberry_Call) RunAndReturn(run func(context.Context, [][]byte) ([]byte, error)) *DataManager_PostSequenceElderberry_Call { - _c.Call.Return(run) - return _c -} - -// NewDataManager creates a new instance of DataManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewDataManager(t interface { - mock.TestingT - Cleanup(func()) -}) *DataManager { - mock := &DataManager{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/func_sign_type.go b/dataavailability/mocks_da/func_sign_type.go deleted file mode 100644 index 6a343269..00000000 --- a/dataavailability/mocks_da/func_sign_type.go +++ /dev/null @@ -1,94 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - client "github.com/0xPolygon/cdk-data-availability/client" - - mock "github.com/stretchr/testify/mock" -) - -// FuncSignType is an autogenerated mock type for the funcSignType type -type FuncSignType struct { - mock.Mock -} - -type FuncSignType_Expecter struct { - mock *mock.Mock -} - -func (_m *FuncSignType) EXPECT() *FuncSignType_Expecter { - return &FuncSignType_Expecter{mock: &_m.Mock} -} - -// Execute provides a mock function with given fields: c -func (_m *FuncSignType) Execute(c client.Client) ([]byte, error) { - ret := _m.Called(c) - - if len(ret) == 0 { - panic("no return value specified for Execute") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(client.Client) ([]byte, error)); ok { - return rf(c) - } - if rf, ok := ret.Get(0).(func(client.Client) []byte); ok { - r0 = rf(c) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(client.Client) error); ok { - r1 = rf(c) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// FuncSignType_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' -type FuncSignType_Execute_Call struct { - *mock.Call -} - -// Execute is a helper method to define mock.On call -// - c client.Client -func (_e *FuncSignType_Expecter) Execute(c interface{}) *FuncSignType_Execute_Call { - return &FuncSignType_Execute_Call{Call: _e.mock.On("Execute", c)} -} - -func (_c *FuncSignType_Execute_Call) Run(run func(c client.Client)) *FuncSignType_Execute_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(client.Client)) - }) - return _c -} - -func (_c *FuncSignType_Execute_Call) Return(_a0 []byte, _a1 error) *FuncSignType_Execute_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *FuncSignType_Execute_Call) RunAndReturn(run func(client.Client) ([]byte, error)) *FuncSignType_Execute_Call { - _c.Call.Return(run) - return _c -} - -// NewFuncSignType creates a new instance of FuncSignType. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewFuncSignType(t interface { - mock.TestingT - Cleanup(func()) -}) *FuncSignType { - mock := &FuncSignType{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/sequence_retriever.go b/dataavailability/mocks_da/sequence_retriever.go deleted file mode 100644 index f82d9a70..00000000 --- a/dataavailability/mocks_da/sequence_retriever.go +++ /dev/null @@ -1,98 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" -) - -// SequenceRetriever is an autogenerated mock type for the SequenceRetriever type -type SequenceRetriever struct { - mock.Mock -} - -type SequenceRetriever_Expecter struct { - mock *mock.Mock -} - -func (_m *SequenceRetriever) EXPECT() *SequenceRetriever_Expecter { - return &SequenceRetriever_Expecter{mock: &_m.Mock} -} - -// GetSequence provides a mock function with given fields: ctx, batchHashes, dataAvailabilityMessage -func (_m *SequenceRetriever) GetSequence(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) { - ret := _m.Called(ctx, batchHashes, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for GetSequence") - } - - var r0 [][]byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []common.Hash, []byte) ([][]byte, error)); ok { - return rf(ctx, batchHashes, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func(context.Context, []common.Hash, []byte) [][]byte); ok { - r0 = rf(ctx, batchHashes, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([][]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []common.Hash, []byte) error); ok { - r1 = rf(ctx, batchHashes, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// SequenceRetriever_GetSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequence' -type SequenceRetriever_GetSequence_Call struct { - *mock.Call -} - -// GetSequence is a helper method to define mock.On call -// - ctx context.Context -// - batchHashes []common.Hash -// - dataAvailabilityMessage []byte -func (_e *SequenceRetriever_Expecter) GetSequence(ctx interface{}, batchHashes interface{}, dataAvailabilityMessage interface{}) *SequenceRetriever_GetSequence_Call { - return &SequenceRetriever_GetSequence_Call{Call: _e.mock.On("GetSequence", ctx, batchHashes, dataAvailabilityMessage)} -} - -func (_c *SequenceRetriever_GetSequence_Call) Run(run func(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte)) *SequenceRetriever_GetSequence_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]common.Hash), args[2].([]byte)) - }) - return _c -} - -func (_c *SequenceRetriever_GetSequence_Call) Return(_a0 [][]byte, _a1 error) *SequenceRetriever_GetSequence_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *SequenceRetriever_GetSequence_Call) RunAndReturn(run func(context.Context, []common.Hash, []byte) ([][]byte, error)) *SequenceRetriever_GetSequence_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceRetriever creates a new instance of SequenceRetriever. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewSequenceRetriever(t interface { - mock.TestingT - Cleanup(func()) -}) *SequenceRetriever { - mock := &SequenceRetriever{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/sequence_sender.go b/dataavailability/mocks_da/sequence_sender.go deleted file mode 100644 index 86a3ff52..00000000 --- a/dataavailability/mocks_da/sequence_sender.go +++ /dev/null @@ -1,156 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - etherman "github.com/agglayer/aggkit/etherman" - - mock "github.com/stretchr/testify/mock" -) - -// SequenceSender is an autogenerated mock type for the SequenceSender type -type SequenceSender struct { - mock.Mock -} - -type SequenceSender_Expecter struct { - mock *mock.Mock -} - -func (_m *SequenceSender) EXPECT() *SequenceSender_Expecter { - return &SequenceSender_Expecter{mock: &_m.Mock} -} - -// PostSequenceBanana provides a mock function with given fields: ctx, sequence -func (_m *SequenceSender) PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) { - ret := _m.Called(ctx, sequence) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceBanana") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) ([]byte, error)); ok { - return rf(ctx, sequence) - } - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) []byte); ok { - r0 = rf(ctx, sequence) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, etherman.SequenceBanana) error); ok { - r1 = rf(ctx, sequence) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// SequenceSender_PostSequenceBanana_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceBanana' -type SequenceSender_PostSequenceBanana_Call struct { - *mock.Call -} - -// PostSequenceBanana is a helper method to define mock.On call -// - ctx context.Context -// - sequence etherman.SequenceBanana -func (_e *SequenceSender_Expecter) PostSequenceBanana(ctx interface{}, sequence interface{}) *SequenceSender_PostSequenceBanana_Call { - return &SequenceSender_PostSequenceBanana_Call{Call: _e.mock.On("PostSequenceBanana", ctx, sequence)} -} - -func (_c *SequenceSender_PostSequenceBanana_Call) Run(run func(ctx context.Context, sequence etherman.SequenceBanana)) *SequenceSender_PostSequenceBanana_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(etherman.SequenceBanana)) - }) - return _c -} - -func (_c *SequenceSender_PostSequenceBanana_Call) Return(_a0 []byte, _a1 error) *SequenceSender_PostSequenceBanana_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *SequenceSender_PostSequenceBanana_Call) RunAndReturn(run func(context.Context, etherman.SequenceBanana) ([]byte, error)) *SequenceSender_PostSequenceBanana_Call { - _c.Call.Return(run) - return _c -} - -// PostSequenceElderberry provides a mock function with given fields: ctx, batchesData -func (_m *SequenceSender) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - ret := _m.Called(ctx, batchesData) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceElderberry") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) ([]byte, error)); ok { - return rf(ctx, batchesData) - } - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) []byte); ok { - r0 = rf(ctx, batchesData) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, [][]byte) error); ok { - r1 = rf(ctx, batchesData) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// SequenceSender_PostSequenceElderberry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceElderberry' -type SequenceSender_PostSequenceElderberry_Call struct { - *mock.Call -} - -// PostSequenceElderberry is a helper method to define mock.On call -// - ctx context.Context -// - batchesData [][]byte -func (_e *SequenceSender_Expecter) PostSequenceElderberry(ctx interface{}, batchesData interface{}) *SequenceSender_PostSequenceElderberry_Call { - return &SequenceSender_PostSequenceElderberry_Call{Call: _e.mock.On("PostSequenceElderberry", ctx, batchesData)} -} - -func (_c *SequenceSender_PostSequenceElderberry_Call) Run(run func(ctx context.Context, batchesData [][]byte)) *SequenceSender_PostSequenceElderberry_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([][]byte)) - }) - return _c -} - -func (_c *SequenceSender_PostSequenceElderberry_Call) Return(_a0 []byte, _a1 error) *SequenceSender_PostSequenceElderberry_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *SequenceSender_PostSequenceElderberry_Call) RunAndReturn(run func(context.Context, [][]byte) ([]byte, error)) *SequenceSender_PostSequenceElderberry_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceSender creates a new instance of SequenceSender. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewSequenceSender(t interface { - mock.TestingT - Cleanup(func()) -}) *SequenceSender { - mock := &SequenceSender{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/sequence_sender_banana.go b/dataavailability/mocks_da/sequence_sender_banana.go deleted file mode 100644 index e6da586e..00000000 --- a/dataavailability/mocks_da/sequence_sender_banana.go +++ /dev/null @@ -1,97 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - etherman "github.com/agglayer/aggkit/etherman" - - mock "github.com/stretchr/testify/mock" -) - -// SequenceSenderBanana is an autogenerated mock type for the SequenceSenderBanana type -type SequenceSenderBanana struct { - mock.Mock -} - -type SequenceSenderBanana_Expecter struct { - mock *mock.Mock -} - -func (_m *SequenceSenderBanana) EXPECT() *SequenceSenderBanana_Expecter { - return &SequenceSenderBanana_Expecter{mock: &_m.Mock} -} - -// PostSequenceBanana provides a mock function with given fields: ctx, sequence -func (_m *SequenceSenderBanana) PostSequenceBanana(ctx context.Context, sequence etherman.SequenceBanana) ([]byte, error) { - ret := _m.Called(ctx, sequence) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceBanana") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) ([]byte, error)); ok { - return rf(ctx, sequence) - } - if rf, ok := ret.Get(0).(func(context.Context, etherman.SequenceBanana) []byte); ok { - r0 = rf(ctx, sequence) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, etherman.SequenceBanana) error); ok { - r1 = rf(ctx, sequence) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// SequenceSenderBanana_PostSequenceBanana_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceBanana' -type SequenceSenderBanana_PostSequenceBanana_Call struct { - *mock.Call -} - -// PostSequenceBanana is a helper method to define mock.On call -// - ctx context.Context -// - sequence etherman.SequenceBanana -func (_e *SequenceSenderBanana_Expecter) PostSequenceBanana(ctx interface{}, sequence interface{}) *SequenceSenderBanana_PostSequenceBanana_Call { - return &SequenceSenderBanana_PostSequenceBanana_Call{Call: _e.mock.On("PostSequenceBanana", ctx, sequence)} -} - -func (_c *SequenceSenderBanana_PostSequenceBanana_Call) Run(run func(ctx context.Context, sequence etherman.SequenceBanana)) *SequenceSenderBanana_PostSequenceBanana_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(etherman.SequenceBanana)) - }) - return _c -} - -func (_c *SequenceSenderBanana_PostSequenceBanana_Call) Return(_a0 []byte, _a1 error) *SequenceSenderBanana_PostSequenceBanana_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *SequenceSenderBanana_PostSequenceBanana_Call) RunAndReturn(run func(context.Context, etherman.SequenceBanana) ([]byte, error)) *SequenceSenderBanana_PostSequenceBanana_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceSenderBanana creates a new instance of SequenceSenderBanana. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewSequenceSenderBanana(t interface { - mock.TestingT - Cleanup(func()) -}) *SequenceSenderBanana { - mock := &SequenceSenderBanana{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/dataavailability/mocks_da/sequence_sender_elderberry.go b/dataavailability/mocks_da/sequence_sender_elderberry.go deleted file mode 100644 index 3816fa1b..00000000 --- a/dataavailability/mocks_da/sequence_sender_elderberry.go +++ /dev/null @@ -1,95 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_da - -import ( - context "context" - - mock "github.com/stretchr/testify/mock" -) - -// SequenceSenderElderberry is an autogenerated mock type for the SequenceSenderElderberry type -type SequenceSenderElderberry struct { - mock.Mock -} - -type SequenceSenderElderberry_Expecter struct { - mock *mock.Mock -} - -func (_m *SequenceSenderElderberry) EXPECT() *SequenceSenderElderberry_Expecter { - return &SequenceSenderElderberry_Expecter{mock: &_m.Mock} -} - -// PostSequenceElderberry provides a mock function with given fields: ctx, batchesData -func (_m *SequenceSenderElderberry) PostSequenceElderberry(ctx context.Context, batchesData [][]byte) ([]byte, error) { - ret := _m.Called(ctx, batchesData) - - if len(ret) == 0 { - panic("no return value specified for PostSequenceElderberry") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) ([]byte, error)); ok { - return rf(ctx, batchesData) - } - if rf, ok := ret.Get(0).(func(context.Context, [][]byte) []byte); ok { - r0 = rf(ctx, batchesData) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, [][]byte) error); ok { - r1 = rf(ctx, batchesData) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// SequenceSenderElderberry_PostSequenceElderberry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostSequenceElderberry' -type SequenceSenderElderberry_PostSequenceElderberry_Call struct { - *mock.Call -} - -// PostSequenceElderberry is a helper method to define mock.On call -// - ctx context.Context -// - batchesData [][]byte -func (_e *SequenceSenderElderberry_Expecter) PostSequenceElderberry(ctx interface{}, batchesData interface{}) *SequenceSenderElderberry_PostSequenceElderberry_Call { - return &SequenceSenderElderberry_PostSequenceElderberry_Call{Call: _e.mock.On("PostSequenceElderberry", ctx, batchesData)} -} - -func (_c *SequenceSenderElderberry_PostSequenceElderberry_Call) Run(run func(ctx context.Context, batchesData [][]byte)) *SequenceSenderElderberry_PostSequenceElderberry_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([][]byte)) - }) - return _c -} - -func (_c *SequenceSenderElderberry_PostSequenceElderberry_Call) Return(_a0 []byte, _a1 error) *SequenceSenderElderberry_PostSequenceElderberry_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *SequenceSenderElderberry_PostSequenceElderberry_Call) RunAndReturn(run func(context.Context, [][]byte) ([]byte, error)) *SequenceSenderElderberry_PostSequenceElderberry_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceSenderElderberry creates a new instance of SequenceSenderElderberry. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewSequenceSenderElderberry(t interface { - mock.TestingT - Cleanup(func()) -}) *SequenceSenderElderberry { - mock := &SequenceSenderElderberry{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/go.mod b/go.mod index 785acaa5..077437aa 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,6 @@ go 1.22.4 require ( github.com/0xPolygon/cdk-contracts-tooling v0.0.1 - github.com/0xPolygon/cdk-data-availability v0.0.11 github.com/0xPolygon/cdk-rpc v0.0.0-20241004114257-6c3cb6eebfb6 github.com/0xPolygon/zkevm-ethtx-manager v0.2.1 github.com/0xPolygonHermez/zkevm-synchronizer-l1 v1.0.6 @@ -40,6 +39,7 @@ require ( require ( github.com/0xPolygon/cdk v0.1.0 // indirect + github.com/0xPolygon/cdk-data-availability v0.0.11 // indirect github.com/DataDog/zstd v1.5.6 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/StackExchange/wmi v1.2.1 // indirect diff --git a/rpc/batch_test.go b/rpc/batch_test.go index d6940bf3..b3e46a4e 100644 --- a/rpc/batch_test.go +++ b/rpc/batch_test.go @@ -105,16 +105,12 @@ func Test_getBatchFromRPC(t *testing.T) { rcpBatchClient := NewBatchEndpoints(srv.URL) rpcBatch, err := rcpBatchClient.GetBatch(tt.batch) - if rpcBatch != nil { - copiedrpcBatch := rpcBatch.DeepCopy() - require.NotNil(t, copiedrpcBatch) - str := copiedrpcBatch.String() - require.NotEmpty(t, str) - } if tt.expectErr != nil { require.Equal(t, tt.expectErr.Error(), err.Error()) } else { require.NoError(t, err) + require.NotNil(t, rpcBatch) + require.NotEmpty(t, rpcBatch.String()) require.Equal(t, tt.expectTimestamp, rpcBatch.LastL2BLockTimestamp()) require.Equal(t, tt.expectData, rpcBatch.L2Data()) } diff --git a/rpc/types/rpcbatch.go b/rpc/types/rpcbatch.go index 41900b9a..89517f7f 100644 --- a/rpc/types/rpcbatch.go +++ b/rpc/types/rpcbatch.go @@ -3,7 +3,6 @@ package types import ( "fmt" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" "github.com/ethereum/go-ethereum/common" ) @@ -37,23 +36,6 @@ func NewRPCBatch(batchNumber uint64, accInputHash common.Hash, blockHashes []str } } -// DeepCopy -func (b *RPCBatch) DeepCopy() seqsendertypes.Batch { - return &RPCBatch{ - accInputHash: b.accInputHash, - batchNumber: b.batchNumber, - blockHashes: b.blockHashes, - batchL2Data: b.batchL2Data, - globalExitRoot: b.globalExitRoot, - localExitRoot: b.localExitRoot, - stateRoot: b.stateRoot, - coinbase: b.coinbase, - closed: b.closed, - lastL2BlockTimestamp: b.lastL2BlockTimestamp, - l1InfoTreeIndex: b.l1InfoTreeIndex, - } -} - // LastCoinbase func (b *RPCBatch) LastCoinbase() common.Address { return b.coinbase diff --git a/scripts/local_config b/scripts/local_config index fbc0beb5..12e7a921 100755 --- a/scripts/local_config +++ b/scripts/local_config @@ -164,18 +164,9 @@ function export_values_of_genesis(){ ############################################################################### function export_values_of_cdk_node_config(){ local _CDK_CONFIG_FILE=$1 - export_key_from_toml_file zkevm_l2_sequencer_address $_CDK_CONFIG_FILE SequenceSender L2Coinbase - if [ $? -ne 0 ]; then - export_key_from_toml_file_or_fatal zkevm_l2_sequencer_address $_CDK_CONFIG_FILE "." L2Coinbase - fi - export_obj_key_from_toml_file zkevm_l2_sequencer_keystore_password $_CDK_CONFIG_FILE SequenceSender PrivateKey Password - if [ $? -ne 0 ]; then - export_key_from_toml_file_or_fatal zkevm_l2_sequencer_keystore_password $_CDK_CONFIG_FILE "." SequencerPrivateKeyPassword - fi - export_key_from_toml_file l1_chain_id $_CDK_CONFIG_FILE SequenceSender.EthTxManager.Etherman L1ChainID - if [ $? -ne 0 ]; then - export_key_from_toml_file_or_fatal l1_chain_id $_CDK_CONFIG_FILE L1Config chainId - fi + export_key_from_toml_file_or_fatal zkevm_l2_sequencer_address $_CDK_CONFIG_FILE "." L2Coinbase + export_key_from_toml_file_or_fatal zkevm_l2_sequencer_keystore_password $_CDK_CONFIG_FILE "." SequencerPrivateKeyPassword + export_key_from_toml_file_or_fatal l1_chain_id $_CDK_CONFIG_FILE L1Config chainId export_key_from_toml_file zkevm_is_validium $_CDK_CONFIG_FILE Common IsValidiumMode if [ $? -ne 0 ]; then export_key_from_toml_file_or_fatal zkevm_is_validium $_CDK_CONFIG_FILE "." IsValidiumMode diff --git a/sequencesender/config.go b/sequencesender/config.go deleted file mode 100644 index 20d61142..00000000 --- a/sequencesender/config.go +++ /dev/null @@ -1,73 +0,0 @@ -package sequencesender - -import ( - "github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager" - "github.com/agglayer/aggkit/config/types" - "github.com/agglayer/aggkit/log" - "github.com/ethereum/go-ethereum/common" -) - -// Config represents the configuration of a sequence sender -type Config struct { - // WaitPeriodSendSequence is the time the sequencer waits until - // trying to send a sequence to L1 - WaitPeriodSendSequence types.Duration `mapstructure:"WaitPeriodSendSequence"` - // LastBatchVirtualizationTimeMaxWaitPeriod is time since sequences should be sent - LastBatchVirtualizationTimeMaxWaitPeriod types.Duration `mapstructure:"LastBatchVirtualizationTimeMaxWaitPeriod"` - // L1BlockTimestampMargin is the time difference (margin) that must exists between last L1 block - // and last L2 block in the sequence before sending the sequence to L1. If the difference is - // lower than this value, then sequencesender will wait until the difference is equal or greater - L1BlockTimestampMargin types.Duration `mapstructure:"L1BlockTimestampMargin"` - // MaxTxSizeForL1 is the maximum size a single transaction can have. This field has - // non-trivial consequences: larger transactions than 128KB are significantly harder and - // more expensive to propagate; larger transactions also take more resources - // to validate whether they fit into the pool or not. - MaxTxSizeForL1 uint64 `mapstructure:"MaxTxSizeForL1"` - // SenderAddress defines which private key the eth tx manager needs to use - // to sign the L1 txs - SenderAddress common.Address - // L2Coinbase defines which address is going to receive the fees - L2Coinbase common.Address `mapstructure:"L2Coinbase"` - // PrivateKey defines all the key store files that are going - // to be read in order to provide the private keys to sign the L1 txs - PrivateKey types.KeystoreFileConfig `mapstructure:"PrivateKey"` - // Batch number where there is a forkid change (fork upgrade) - ForkUpgradeBatchNumber uint64 - // GasOffset is the amount of gas to be added to the gas estimation in order - // to provide an amount that is higher than the estimated one. This is used - // to avoid the TX getting reverted in case something has changed in the network - // state after the estimation which can cause the TX to require more gas to be - // executed. - // - // ex: - // gas estimation: 1000 - // gas offset: 100 - // final gas: 1100 - GasOffset uint64 `mapstructure:"GasOffset"` - - // SequencesTxFileName is the file name to store sequences sent to L1 - SequencesTxFileName string - - // WaitPeriodPurgeTxFile is the time to wait before purging from file the finished sent L1 tx - WaitPeriodPurgeTxFile types.Duration `mapstructure:"WaitPeriodPurgeTxFile"` - - // MaxPendingTx is the maximum number of pending transactions (those that are not in a final state) - MaxPendingTx uint64 - - // EthTxManager is the config for the ethtxmanager - EthTxManager ethtxmanager.Config `mapstructure:"EthTxManager"` - - // Log is the log configuration - Log log.Config `mapstructure:"Log"` - - // MaxBatchesForL1 is the maximum amount of batches to be sequenced in a single L1 tx - MaxBatchesForL1 uint64 `mapstructure:"MaxBatchesForL1"` - // BlockFinality indicates the status of the blocks that will be queried in order to sync - BlockFinality string `jsonschema:"enum=LatestBlock, enum=SafeBlock, enum=PendingBlock, enum=FinalizedBlock, enum=EarliestBlock" mapstructure:"BlockFinality"` //nolint:lll - - // RPCURL is the URL of the RPC server - RPCURL string `mapstructure:"RPCURL"` - - // GetBatchWaitInterval is the time to wait to query for a new batch when there are no more batches available - GetBatchWaitInterval types.Duration `mapstructure:"GetBatchWaitInterval"` -} diff --git a/sequencesender/ethtx.go b/sequencesender/ethtx.go deleted file mode 100644 index 458ad3d1..00000000 --- a/sequencesender/ethtx.go +++ /dev/null @@ -1,398 +0,0 @@ -package sequencesender - -import ( - "context" - "encoding/json" - "errors" - "math" - "math/big" - "os" - "strings" - "sync/atomic" - "time" - - "github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager" - "github.com/0xPolygon/zkevm-ethtx-manager/types" - "github.com/agglayer/aggkit/log" - "github.com/ethereum/go-ethereum/common" -) - -type ethTxData struct { - Nonce uint64 `json:"nonce"` - Status string `json:"status"` - SentL1Timestamp time.Time `json:"sentL1Timestamp"` - StatusTimestamp time.Time `json:"statusTimestamp"` - FromBatch uint64 `json:"fromBatch"` - ToBatch uint64 `json:"toBatch"` - MinedAtBlock big.Int `json:"minedAtBlock"` - OnMonitor bool `json:"onMonitor"` - To common.Address `json:"to"` - StateHistory []string `json:"stateHistory"` - Txs map[common.Hash]ethTxAdditionalData `json:"txs"` - Gas uint64 `json:"gas"` -} - -type ethTxAdditionalData struct { - GasPrice *big.Int `json:"gasPrice,omitempty"` - RevertMessage string `json:"revertMessage,omitempty"` -} - -// sendTx adds transaction to the ethTxManager to send it to L1 -func (s *SequenceSender) sendTx(ctx context.Context, resend bool, txOldHash *common.Hash, to *common.Address, - fromBatch uint64, toBatch uint64, data []byte, gas uint64) error { - // Params if new tx to send or resend a previous tx - var ( - paramTo *common.Address - paramData []byte - valueFromBatch uint64 - valueToBatch uint64 - valueToAddress common.Address - ) - - if !resend { - paramTo = to - paramData = data - valueFromBatch = fromBatch - valueToBatch = toBatch - } else { - if txOldHash == nil { - log.Errorf("trying to resend a tx with nil hash") - return errors.New("resend tx with nil hash monitor id") - } - oldEthTx := s.ethTransactions[*txOldHash] - paramTo = &oldEthTx.To - paramData = s.ethTxData[*txOldHash] - valueFromBatch = oldEthTx.FromBatch - valueToBatch = oldEthTx.ToBatch - } - if paramTo != nil { - valueToAddress = *paramTo - } - - // Add sequence tx - txHash, err := s.ethTxManager.AddWithGas(ctx, paramTo, big.NewInt(0), paramData, s.cfg.GasOffset, nil, gas) - if err != nil { - log.Errorf("error adding sequence to ethtxmanager: %v", err) - return err - } - - // Add new eth tx - txData := ethTxData{ - SentL1Timestamp: time.Now(), - StatusTimestamp: time.Now(), - Status: "*new", - FromBatch: valueFromBatch, - ToBatch: valueToBatch, - OnMonitor: true, - To: valueToAddress, - Gas: gas, - } - - // Add tx to internal structure - s.mutexEthTx.Lock() - s.ethTransactions[txHash] = &txData - txResults := make(map[common.Hash]types.TxResult, 0) - s.copyTxData(txHash, paramData, txResults) - err = s.getResultAndUpdateEthTx(ctx, txHash) - if err != nil { - log.Errorf("error getting result for tx %v: %v", txHash, err) - } - if !resend { - atomic.StoreUint64(&s.latestSentToL1Batch, valueToBatch) - } else { - s.ethTransactions[*txOldHash].Status = "*resent" - } - s.mutexEthTx.Unlock() - - // Save sent sequences - err = s.saveSentSequencesTransactions(ctx) - if err != nil { - log.Errorf("error saving tx sequence sent, error: %v", err) - } - return nil -} - -// purgeEthTx purges transactions from memory structures -func (s *SequenceSender) purgeEthTx(ctx context.Context) { - // If sequence sending is stopped, do not purge - if s.IsStopped() { - return - } - - // Purge old transactions that are finalized - s.mutexEthTx.Lock() - timePurge := time.Now().Add(-s.cfg.WaitPeriodPurgeTxFile.Duration) - toPurge := make([]common.Hash, 0) - for hash, data := range s.ethTransactions { - if !data.StatusTimestamp.Before(timePurge) { - continue - } - - if !data.OnMonitor || data.Status == types.MonitoredTxStatusFinalized.String() { - toPurge = append(toPurge, hash) - - // Remove from tx monitor - if data.OnMonitor { - err := s.ethTxManager.Remove(ctx, hash) - if err != nil { - log.Warnf("error removing monitor tx %v from ethtxmanager: %v", hash, err) - } else { - log.Infof("removed monitor tx %v from ethtxmanager", hash) - } - } - } - } - - if len(toPurge) > 0 { - var firstPurged uint64 = math.MaxUint64 - var lastPurged uint64 - for i := 0; i < len(toPurge); i++ { - if s.ethTransactions[toPurge[i]].Nonce < firstPurged { - firstPurged = s.ethTransactions[toPurge[i]].Nonce - } - if s.ethTransactions[toPurge[i]].Nonce > lastPurged { - lastPurged = s.ethTransactions[toPurge[i]].Nonce - } - delete(s.ethTransactions, toPurge[i]) - delete(s.ethTxData, toPurge[i]) - } - log.Infof("txs purged count: %d, fromNonce: %d, toNonce: %d", len(toPurge), firstPurged, lastPurged) - } - s.mutexEthTx.Unlock() -} - -// syncEthTxResults syncs results from L1 for transactions in the memory structure -func (s *SequenceSender) syncEthTxResults(ctx context.Context) (uint64, error) { - s.mutexEthTx.Lock() - var ( - txPending uint64 - txSync uint64 - ) - for hash, tx := range s.ethTransactions { - if tx.Status == types.MonitoredTxStatusFinalized.String() { - continue - } - - err := s.getResultAndUpdateEthTx(ctx, hash) - if err != nil { - log.Errorf("error getting result for tx %v: %v", hash, err) - return 0, err - } - - txSync++ - txStatus := types.MonitoredTxStatus(tx.Status) - // Count if it is not in a final state - if tx.OnMonitor && - txStatus != types.MonitoredTxStatusFailed && - txStatus != types.MonitoredTxStatusSafe && - txStatus != types.MonitoredTxStatusFinalized { - txPending++ - } - } - s.mutexEthTx.Unlock() - - // Save updated sequences transactions - err := s.saveSentSequencesTransactions(ctx) - if err != nil { - log.Errorf("error saving tx sequence, error: %v", err) - return 0, err - } - - log.Infof("%d tx results synchronized (%d in pending state)", txSync, txPending) - return txPending, nil -} - -// syncAllEthTxResults syncs all tx results from L1 -func (s *SequenceSender) syncAllEthTxResults(ctx context.Context) error { - // Get all results - results, err := s.ethTxManager.ResultsByStatus(ctx, nil) - if err != nil { - log.Warnf("error getting results for all tx: %v", err) - return err - } - - // Check and update tx status - numResults := len(results) - s.mutexEthTx.Lock() - for _, result := range results { - txSequence, exists := s.ethTransactions[result.ID] - if !exists { - log.Debugf("transaction %v missing in memory structure. Adding it", result.ID) - // No info: from/to batch and the sent timestamp - s.ethTransactions[result.ID] = ðTxData{ - SentL1Timestamp: time.Time{}, - StatusTimestamp: time.Now(), - OnMonitor: true, - Status: "*missing", - } - txSequence = s.ethTransactions[result.ID] - } - - s.updateEthTxResult(txSequence, result) - } - s.mutexEthTx.Unlock() - - // Save updated sequences transactions - err = s.saveSentSequencesTransactions(ctx) - if err != nil { - log.Errorf("error saving tx sequence, error: %v", err) - } - - log.Infof("%d tx results synchronized", numResults) - return nil -} - -// copyTxData copies tx data in the internal structure -func (s *SequenceSender) copyTxData( - txHash common.Hash, txData []byte, txsResults map[common.Hash]types.TxResult, -) { - s.ethTxData[txHash] = make([]byte, len(txData)) - copy(s.ethTxData[txHash], txData) - - s.ethTransactions[txHash].Txs = make(map[common.Hash]ethTxAdditionalData, 0) - for hash, result := range txsResults { - var gasPrice *big.Int - if result.Tx != nil { - gasPrice = result.Tx.GasPrice() - } - - add := ethTxAdditionalData{ - GasPrice: gasPrice, - RevertMessage: result.RevertMessage, - } - s.ethTransactions[txHash].Txs[hash] = add - } -} - -// updateEthTxResult handles updating transaction state -func (s *SequenceSender) updateEthTxResult(txData *ethTxData, txResult types.MonitoredTxResult) { - if txData.Status != txResult.Status.String() { - log.Infof("update transaction %v to state %s", txResult.ID, txResult.Status.String()) - txData.StatusTimestamp = time.Now() - stTrans := txData.StatusTimestamp.Format("2006-01-02T15:04:05.000-07:00") + - ", " + txData.Status + ", " + txResult.Status.String() - txData.Status = txResult.Status.String() - txData.StateHistory = append(txData.StateHistory, stTrans) - - // Manage according to the state - statusConsolidated := txData.Status == types.MonitoredTxStatusSafe.String() || - txData.Status == types.MonitoredTxStatusFinalized.String() - if txData.Status == types.MonitoredTxStatusFailed.String() { - s.logFatalf("transaction %v result failed!") - } else if statusConsolidated && txData.ToBatch >= atomic.LoadUint64(&s.latestVirtualBatchNumber) { - s.latestVirtualTime = txData.StatusTimestamp - } - } - - // Update info received from L1 - txData.Nonce = txResult.Nonce - if txResult.To != nil { - txData.To = *txResult.To - } - if txResult.MinedAtBlockNumber != nil { - txData.MinedAtBlock = *txResult.MinedAtBlockNumber - } - s.copyTxData(txResult.ID, txResult.Data, txResult.Txs) -} - -// getResultAndUpdateEthTx updates the tx status from the ethTxManager -func (s *SequenceSender) getResultAndUpdateEthTx(ctx context.Context, txHash common.Hash) error { - txData, exists := s.ethTransactions[txHash] - if !exists { - s.logger.Errorf("transaction %v not found in memory", txHash) - return errors.New("transaction not found in memory structure") - } - - txResult, err := s.ethTxManager.Result(ctx, txHash) - switch { - case errors.Is(err, ethtxmanager.ErrNotFound): - s.logger.Infof("transaction %v does not exist in ethtxmanager. Marking it", txHash) - txData.OnMonitor = false - // Resend tx - errSend := s.sendTx(ctx, true, &txHash, nil, 0, 0, nil, txData.Gas) - if errSend == nil { - txData.OnMonitor = false - } - - case err != nil: - s.logger.Errorf("error getting result for tx %v: %v", txHash, err) - return err - - default: - s.updateEthTxResult(txData, txResult) - } - - return nil -} - -// loadSentSequencesTransactions loads the file into the memory structure -func (s *SequenceSender) loadSentSequencesTransactions() error { - // Check if file exists - if _, err := os.Stat(s.cfg.SequencesTxFileName); os.IsNotExist(err) { - log.Infof("file not found %s: %v", s.cfg.SequencesTxFileName, err) - return nil - } else if err != nil { - log.Errorf("error opening file %s: %v", s.cfg.SequencesTxFileName, err) - return err - } - - // Read file - data, err := os.ReadFile(s.cfg.SequencesTxFileName) - if err != nil { - log.Errorf("error reading file %s: %v", s.cfg.SequencesTxFileName, err) - return err - } - - // Restore memory structure - s.mutexEthTx.Lock() - err = json.Unmarshal(data, &s.ethTransactions) - s.mutexEthTx.Unlock() - if err != nil { - log.Errorf("error decoding data from %s: %v", s.cfg.SequencesTxFileName, err) - return err - } - - return nil -} - -// saveSentSequencesTransactions saves memory structure into persistent file -func (s *SequenceSender) saveSentSequencesTransactions(ctx context.Context) error { - var err error - - // Purge tx - s.purgeEthTx(ctx) - - // Create file - fileName := s.cfg.SequencesTxFileName[0:strings.IndexRune(s.cfg.SequencesTxFileName, '.')] + ".tmp" - s.sequencesTxFile, err = os.Create(fileName) - if err != nil { - log.Errorf("error creating file %s: %v", fileName, err) - return err - } - defer s.sequencesTxFile.Close() - - // Write data JSON encoded - encoder := json.NewEncoder(s.sequencesTxFile) - encoder.SetIndent("", " ") - s.mutexEthTx.Lock() - err = encoder.Encode(s.ethTransactions) - s.mutexEthTx.Unlock() - if err != nil { - log.Errorf("error writing file %s: %v", fileName, err) - return err - } - - // Rename the new file - err = os.Rename(fileName, s.cfg.SequencesTxFileName) - if err != nil { - log.Errorf("error renaming file %s to %s: %v", fileName, s.cfg.SequencesTxFileName, err) - return err - } - - return nil -} - -// IsStopped returns true in case seqSendingStopped is set to 1, otherwise false -func (s *SequenceSender) IsStopped() bool { - return atomic.LoadUint32(&s.seqSendingStopped) == 1 -} diff --git a/sequencesender/ethtx_test.go b/sequencesender/ethtx_test.go deleted file mode 100644 index e890a4b9..00000000 --- a/sequencesender/ethtx_test.go +++ /dev/null @@ -1,786 +0,0 @@ -package sequencesender - -import ( - "context" - "encoding/json" - "errors" - "math/big" - "os" - "testing" - "time" - - "github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager" - ethtxtypes "github.com/0xPolygon/zkevm-ethtx-manager/types" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/mocks" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func Test_sendTx(t *testing.T) { - t.Parallel() - - addr := common.BytesToAddress([]byte{1, 2, 3}) - hash := common.HexToHash("0x1") - oldHash := common.HexToHash("0x2") - - type args struct { - resend bool - txOldHash *common.Hash - to *common.Address - fromBatch uint64 - toBatch uint64 - data []byte - gas uint64 - } - - type state struct { - currentNonce uint64 - ethTxData map[common.Hash][]byte - ethTransactions map[common.Hash]*ethTxData - latestSentToL1Batch uint64 - } - - tests := []struct { - name string - args args - state state - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - expectedState state - expectedErr error - }{ - { - name: "successfully sent", - args: args{ - resend: false, - txOldHash: nil, - to: &addr, - fromBatch: 1, - toBatch: 2, - data: []byte("test"), - gas: 100500, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("AddWithGas", mock.Anything, &addr, big.NewInt(0), []byte("test"), uint64(0), mock.Anything, uint64(100500)).Return(hash, nil) - mngr.On("Result", mock.Anything, hash).Return(ethtxtypes.MonitoredTxResult{ - ID: hash, - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - state: state{ - currentNonce: 10, - ethTxData: map[common.Hash][]byte{ - hash: {}, - }, - ethTransactions: map[common.Hash]*ethTxData{ - hash: {}, - }, - latestSentToL1Batch: 0, - }, - expectedState: state{ - currentNonce: 11, - ethTxData: map[common.Hash][]byte{ - hash: {1, 2, 3}, - }, - ethTransactions: map[common.Hash]*ethTxData{ - hash: { - SentL1Timestamp: now, - StatusTimestamp: now, - FromBatch: 1, - ToBatch: 2, - OnMonitor: true, - To: addr, - Gas: 100500, - StateHistory: []string{now.Format("2006-01-02T15:04:05.000-07:00") + ", *new, "}, - Txs: map[common.Hash]ethTxAdditionalData{}, - }, - }, - latestSentToL1Batch: 2, - }, - expectedErr: nil, - }, - { - name: "successfully sent with resend", - args: args{ - resend: true, - txOldHash: &oldHash, - gas: 100500, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("AddWithGas", mock.Anything, &addr, big.NewInt(0), []byte(nil), uint64(0), mock.Anything, uint64(100500)).Return(hash, nil) - mngr.On("Result", mock.Anything, hash).Return(ethtxtypes.MonitoredTxResult{ - ID: hash, - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - state: state{ - ethTxData: map[common.Hash][]byte{ - hash: []byte("test"), - }, - ethTransactions: map[common.Hash]*ethTxData{ - oldHash: { - To: addr, - Nonce: 10, - FromBatch: 1, - ToBatch: 2, - }, - }, - latestSentToL1Batch: 0, - }, - expectedState: state{ - currentNonce: 0, - ethTxData: map[common.Hash][]byte{ - hash: {1, 2, 3}, - }, - ethTransactions: map[common.Hash]*ethTxData{ - hash: { - SentL1Timestamp: now, - StatusTimestamp: now, - FromBatch: 1, - ToBatch: 2, - OnMonitor: true, - To: addr, - Gas: 100500, - StateHistory: []string{now.Format("2006-01-02T15:04:05.000-07:00") + ", *new, "}, - Txs: map[common.Hash]ethTxAdditionalData{}, - }, - }, - latestSentToL1Batch: 0, - }, - expectedErr: nil, - }, - { - name: "add with gas returns error", - args: args{ - resend: true, - txOldHash: &oldHash, - gas: 100500, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("AddWithGas", mock.Anything, &addr, big.NewInt(0), []byte(nil), uint64(0), mock.Anything, uint64(100500)).Return(nil, errors.New("failed to add with gas")) - return mngr - }, - state: state{ - ethTxData: map[common.Hash][]byte{ - hash: []byte("test"), - }, - ethTransactions: map[common.Hash]*ethTxData{ - oldHash: { - To: addr, - Nonce: 10, - FromBatch: 1, - ToBatch: 2, - }, - }, - latestSentToL1Batch: 0, - }, - expectedErr: errors.New("failed to add with gas"), - }, - { - name: "empty old hash", - args: args{ - resend: true, - gas: 100500, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - return mngr - }, - state: state{ - ethTxData: map[common.Hash][]byte{ - hash: []byte("test"), - }, - ethTransactions: map[common.Hash]*ethTxData{ - oldHash: { - To: addr, - Nonce: 10, - FromBatch: 1, - ToBatch: 2, - }, - }, - latestSentToL1Batch: 0, - }, - expectedErr: errors.New("resend tx with nil hash monitor id"), - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name+".tmp") - require.NoError(t, err) - defer os.RemoveAll(tmpFile.Name() + ".tmp") - - ss := SequenceSender{ - ethTxData: tt.state.ethTxData, - ethTransactions: tt.state.ethTransactions, - ethTxManager: tt.getEthTxManager(t), - latestSentToL1Batch: tt.state.latestSentToL1Batch, - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - }, - logger: log.GetDefaultLogger(), - } - - err = ss.sendTx(context.Background(), tt.args.resend, tt.args.txOldHash, tt.args.to, tt.args.fromBatch, tt.args.toBatch, tt.args.data, tt.args.gas) - if tt.expectedErr != nil { - require.Equal(t, tt.expectedErr, err) - } else { - require.NoError(t, err) - require.Equal(t, tt.expectedState.ethTxData, ss.ethTxData) - require.Equal(t, len(tt.expectedState.ethTransactions), len(ss.ethTransactions)) - for k, v := range tt.expectedState.ethTransactions { - require.Equal(t, v.Gas, ss.ethTransactions[k].Gas) - require.Equal(t, v.To, ss.ethTransactions[k].To) - require.Equal(t, v.Nonce, ss.ethTransactions[k].Nonce) - require.Equal(t, v.Status, ss.ethTransactions[k].Status) - require.Equal(t, v.FromBatch, ss.ethTransactions[k].FromBatch) - require.Equal(t, v.ToBatch, ss.ethTransactions[k].ToBatch) - require.Equal(t, v.OnMonitor, ss.ethTransactions[k].OnMonitor) - } - require.Equal(t, tt.expectedState.latestSentToL1Batch, ss.latestSentToL1Batch) - } - }) - } -} - -func Test_purgeEthTx(t *testing.T) { - t.Parallel() - - firstTimestamp := time.Now().Add(-time.Hour) - secondTimestamp := time.Now().Add(time.Hour) - - tests := []struct { - name string - seqSendingStopped uint32 - ethTransactions map[common.Hash]*ethTxData - ethTxData map[common.Hash][]byte - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - sequenceList []uint64 - expectedEthTransactions map[common.Hash]*ethTxData - expectedEthTxData map[common.Hash][]byte - }{ - { - name: "sequence sender stopped", - seqSendingStopped: 1, - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: firstTimestamp, - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusFinalized.String(), - }, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {1, 2, 3}, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - return mocks.NewEthTxManagerMock(t) - }, - sequenceList: []uint64{1, 2}, - expectedEthTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: firstTimestamp, - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusFinalized.String(), - }, - }, - expectedEthTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {1, 2, 3}, - }, - }, - { - name: "transactions purged", - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: firstTimestamp, - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusFinalized.String(), - }, - common.HexToHash("0x2"): { - StatusTimestamp: secondTimestamp, - }, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {1, 2, 3}, - common.HexToHash("0x2"): {4, 5, 6}, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Remove", mock.Anything, common.HexToHash("0x1")).Return(nil) - return mngr - }, - sequenceList: []uint64{1, 2}, - expectedEthTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x2"): { - StatusTimestamp: secondTimestamp, - }, - }, - expectedEthTxData: map[common.Hash][]byte{ - common.HexToHash("0x2"): {4, 5, 6}, - }, - }, - { - name: "removed with error", - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: firstTimestamp, - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusFinalized.String(), - }, - common.HexToHash("0x2"): { - StatusTimestamp: secondTimestamp, - }, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {1, 2, 3}, - common.HexToHash("0x2"): {4, 5, 6}, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Remove", mock.Anything, common.HexToHash("0x1")).Return(errors.New("test err")) - return mngr - }, - sequenceList: []uint64{1, 2}, - expectedEthTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x2"): { - StatusTimestamp: secondTimestamp, - }, - }, - expectedEthTxData: map[common.Hash][]byte{ - common.HexToHash("0x2"): {4, 5, 6}, - }, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - mngr := tt.getEthTxManager(t) - ss := SequenceSender{ - seqSendingStopped: tt.seqSendingStopped, - ethTransactions: tt.ethTransactions, - ethTxData: tt.ethTxData, - ethTxManager: mngr, - logger: log.GetDefaultLogger(), - } - - ss.purgeEthTx(context.Background()) - - mngr.AssertExpectations(t) - require.Equal(t, tt.expectedEthTransactions, ss.ethTransactions) - require.Equal(t, tt.expectedEthTxData, ss.ethTxData) - }) - } -} - -func Test_syncEthTxResults(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - ethTransactions map[common.Hash]*ethTxData - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - - expectErr error - expectPendingTxs uint64 - }{ - { - name: "successfully synced", - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: time.Now(), - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusCreated.String(), - }, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Result", mock.Anything, common.HexToHash("0x1")).Return(ethtxtypes.MonitoredTxResult{ - ID: common.HexToHash("0x1"), - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - expectPendingTxs: 1, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name) - require.NoError(t, err) - - mngr := tt.getEthTxManager(t) - ss := SequenceSender{ - ethTransactions: tt.ethTransactions, - ethTxManager: mngr, - ethTxData: make(map[common.Hash][]byte), - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - }, - logger: log.GetDefaultLogger(), - } - - pendingTxs, err := ss.syncEthTxResults(context.Background()) - if tt.expectErr != nil { - require.Equal(t, tt.expectErr, err) - } else { - require.NoError(t, err) - require.Equal(t, tt.expectPendingTxs, pendingTxs) - } - - mngr.AssertExpectations(t) - - err = os.RemoveAll(tmpFile.Name() + ".tmp") - require.NoError(t, err) - }) - } -} - -func Test_syncAllEthTxResults(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - ethTransactions map[common.Hash]*ethTxData - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - - expectErr error - expectPendingTxs uint64 - }{ - { - name: "successfully synced", - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - StatusTimestamp: time.Now(), - OnMonitor: true, - Status: ethtxtypes.MonitoredTxStatusCreated.String(), - }, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("ResultsByStatus", mock.Anything, []ethtxtypes.MonitoredTxStatus(nil)).Return([]ethtxtypes.MonitoredTxResult{ - { - ID: common.HexToHash("0x1"), - Data: []byte{1, 2, 3}, - }, - }, nil) - return mngr - }, - expectPendingTxs: 1, - }, - { - name: "successfully synced with missing tx", - ethTransactions: map[common.Hash]*ethTxData{}, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("ResultsByStatus", mock.Anything, []ethtxtypes.MonitoredTxStatus(nil)).Return([]ethtxtypes.MonitoredTxResult{ - { - ID: common.HexToHash("0x1"), - Data: []byte{1, 2, 3}, - }, - }, nil) - return mngr - }, - expectPendingTxs: 1, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name) - require.NoError(t, err) - - mngr := tt.getEthTxManager(t) - ss := SequenceSender{ - ethTransactions: tt.ethTransactions, - ethTxManager: mngr, - ethTxData: make(map[common.Hash][]byte), - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - }, - logger: log.GetDefaultLogger(), - } - - err = ss.syncAllEthTxResults(context.Background()) - if tt.expectErr != nil { - require.Equal(t, tt.expectErr, err) - } else { - require.NoError(t, err) - } - - mngr.AssertExpectations(t) - - err = os.RemoveAll(tmpFile.Name() + ".tmp") - require.NoError(t, err) - }) - } -} - -func Test_copyTxData(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - txHash common.Hash - txData []byte - txsResults map[common.Hash]ethtxtypes.TxResult - ethTxData map[common.Hash][]byte - ethTransactions map[common.Hash]*ethTxData - expectedRthTxData map[common.Hash][]byte - expectedEthTransactions map[common.Hash]*ethTxData - }{ - { - name: "successfully copied", - txHash: common.HexToHash("0x1"), - txData: []byte{1, 2, 3}, - txsResults: map[common.Hash]ethtxtypes.TxResult{ - common.HexToHash("0x1"): {}, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {0, 2, 3}, - }, - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): {}, - }, - expectedRthTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {1, 2, 3}, - }, - expectedEthTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - Txs: map[common.Hash]ethTxAdditionalData{ - common.HexToHash("0x1"): {}, - }, - }, - }, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - s := SequenceSender{ - ethTxData: tt.ethTxData, - ethTransactions: tt.ethTransactions, - } - - s.copyTxData(tt.txHash, tt.txData, tt.txsResults) - require.Equal(t, tt.expectedRthTxData, s.ethTxData) - require.Equal(t, tt.expectedEthTransactions, s.ethTransactions) - }) - } -} - -func Test_getResultAndUpdateEthTx(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - hash common.Hash - ethTransactions map[common.Hash]*ethTxData - ethTxData map[common.Hash][]byte - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - expectedErr error - }{ - { - name: "successfully updated", - hash: common.HexToHash("0x1"), - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): {}, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {}, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Result", mock.Anything, common.HexToHash("0x1")).Return(ethtxtypes.MonitoredTxResult{ - ID: common.HexToHash("0x1"), - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - expectedErr: nil, - }, - { - name: "not found", - hash: common.HexToHash("0x1"), - ethTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): { - Gas: 100500, - }, - }, - ethTxData: map[common.Hash][]byte{ - common.HexToHash("0x1"): {}, - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Result", mock.Anything, common.HexToHash("0x1")).Return(ethtxtypes.MonitoredTxResult{}, ethtxmanager.ErrNotFound) - mngr.On("AddWithGas", mock.Anything, mock.Anything, big.NewInt(0), mock.Anything, mock.Anything, mock.Anything, uint64(100500)).Return(common.Hash{}, nil) - mngr.On("Result", mock.Anything, common.Hash{}).Return(ethtxtypes.MonitoredTxResult{ - ID: common.HexToHash("0x1"), - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - expectedErr: nil, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name+".tmp") - require.NoError(t, err) - defer os.RemoveAll(tmpFile.Name() + ".tmp") - - ss := SequenceSender{ - ethTransactions: tt.ethTransactions, - ethTxData: tt.ethTxData, - ethTxManager: tt.getEthTxManager(t), - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - }, - logger: log.GetDefaultLogger(), - } - - err = ss.getResultAndUpdateEthTx(context.Background(), tt.hash) - if tt.expectedErr != nil { - require.Equal(t, tt.expectedErr, err) - } else { - require.NoError(t, err) - } - }) - } -} - -func Test_loadSentSequencesTransactions(t *testing.T) { - t.Parallel() - - tx := ðTxData{ - FromBatch: 1, - ToBatch: 2, - OnMonitor: true, - To: common.BytesToAddress([]byte{1, 2, 3}), - Gas: 100500, - StateHistory: []string{"2021-09-01T15:04:05.000-07:00, *new, "}, - Txs: map[common.Hash]ethTxAdditionalData{}, - } - - tests := []struct { - name string - getFilename func(t *testing.T) string - expectEthTransactions map[common.Hash]*ethTxData - expectErr error - }{ - { - name: "successfully loaded", - getFilename: func(t *testing.T) string { - t.Helper() - - tmpFile, err := os.CreateTemp(os.TempDir(), "test") - require.NoError(t, err) - - ethTxDataBytes, err := json.Marshal(map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): tx, - }) - require.NoError(t, err) - - _, err = tmpFile.Write(ethTxDataBytes) - require.NoError(t, err) - - t.Cleanup(func() { - err := os.Remove(tmpFile.Name()) - require.NoError(t, err) - }) - - return tmpFile.Name() - }, - expectEthTransactions: map[common.Hash]*ethTxData{ - common.HexToHash("0x1"): tx, - }, - }, - { - name: "file does not exist", - getFilename: func(t *testing.T) string { - t.Helper() - - return "does not exist.tmp" - }, - expectEthTransactions: map[common.Hash]*ethTxData{}, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - s := SequenceSender{ - cfg: Config{ - SequencesTxFileName: tt.getFilename(t), - }, - ethTransactions: map[common.Hash]*ethTxData{}, - logger: log.GetDefaultLogger(), - } - - err := s.loadSentSequencesTransactions() - if tt.expectErr != nil { - require.Equal(t, tt.expectErr, err) - } else { - require.NoError(t, err) - require.Equal(t, tt.expectEthTransactions, s.ethTransactions) - } - }) - } -} diff --git a/sequencesender/mocks/mock_etherman.go b/sequencesender/mocks/mock_etherman.go deleted file mode 100644 index 298d96c3..00000000 --- a/sequencesender/mocks/mock_etherman.go +++ /dev/null @@ -1,271 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks - -import ( - context "context" - big "math/big" - - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// EthermanMock is an autogenerated mock type for the Etherman type -type EthermanMock struct { - mock.Mock -} - -type EthermanMock_Expecter struct { - mock *mock.Mock -} - -func (_m *EthermanMock) EXPECT() *EthermanMock_Expecter { - return &EthermanMock_Expecter{mock: &_m.Mock} -} - -// CurrentNonce provides a mock function with given fields: ctx, address -func (_m *EthermanMock) CurrentNonce(ctx context.Context, address common.Address) (uint64, error) { - ret := _m.Called(ctx, address) - - if len(ret) == 0 { - panic("no return value specified for CurrentNonce") - } - - var r0 uint64 - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, common.Address) (uint64, error)); ok { - return rf(ctx, address) - } - if rf, ok := ret.Get(0).(func(context.Context, common.Address) uint64); ok { - r0 = rf(ctx, address) - } else { - r0 = ret.Get(0).(uint64) - } - - if rf, ok := ret.Get(1).(func(context.Context, common.Address) error); ok { - r1 = rf(ctx, address) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthermanMock_CurrentNonce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentNonce' -type EthermanMock_CurrentNonce_Call struct { - *mock.Call -} - -// CurrentNonce is a helper method to define mock.On call -// - ctx context.Context -// - address common.Address -func (_e *EthermanMock_Expecter) CurrentNonce(ctx interface{}, address interface{}) *EthermanMock_CurrentNonce_Call { - return &EthermanMock_CurrentNonce_Call{Call: _e.mock.On("CurrentNonce", ctx, address)} -} - -func (_c *EthermanMock_CurrentNonce_Call) Run(run func(ctx context.Context, address common.Address)) *EthermanMock_CurrentNonce_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(common.Address)) - }) - return _c -} - -func (_c *EthermanMock_CurrentNonce_Call) Return(_a0 uint64, _a1 error) *EthermanMock_CurrentNonce_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthermanMock_CurrentNonce_Call) RunAndReturn(run func(context.Context, common.Address) (uint64, error)) *EthermanMock_CurrentNonce_Call { - _c.Call.Return(run) - return _c -} - -// EstimateGas provides a mock function with given fields: ctx, from, to, value, data -func (_m *EthermanMock) EstimateGas(ctx context.Context, from common.Address, to *common.Address, value *big.Int, data []byte) (uint64, error) { - ret := _m.Called(ctx, from, to, value, data) - - if len(ret) == 0 { - panic("no return value specified for EstimateGas") - } - - var r0 uint64 - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, common.Address, *common.Address, *big.Int, []byte) (uint64, error)); ok { - return rf(ctx, from, to, value, data) - } - if rf, ok := ret.Get(0).(func(context.Context, common.Address, *common.Address, *big.Int, []byte) uint64); ok { - r0 = rf(ctx, from, to, value, data) - } else { - r0 = ret.Get(0).(uint64) - } - - if rf, ok := ret.Get(1).(func(context.Context, common.Address, *common.Address, *big.Int, []byte) error); ok { - r1 = rf(ctx, from, to, value, data) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthermanMock_EstimateGas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateGas' -type EthermanMock_EstimateGas_Call struct { - *mock.Call -} - -// EstimateGas is a helper method to define mock.On call -// - ctx context.Context -// - from common.Address -// - to *common.Address -// - value *big.Int -// - data []byte -func (_e *EthermanMock_Expecter) EstimateGas(ctx interface{}, from interface{}, to interface{}, value interface{}, data interface{}) *EthermanMock_EstimateGas_Call { - return &EthermanMock_EstimateGas_Call{Call: _e.mock.On("EstimateGas", ctx, from, to, value, data)} -} - -func (_c *EthermanMock_EstimateGas_Call) Run(run func(ctx context.Context, from common.Address, to *common.Address, value *big.Int, data []byte)) *EthermanMock_EstimateGas_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(common.Address), args[2].(*common.Address), args[3].(*big.Int), args[4].([]byte)) - }) - return _c -} - -func (_c *EthermanMock_EstimateGas_Call) Return(_a0 uint64, _a1 error) *EthermanMock_EstimateGas_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthermanMock_EstimateGas_Call) RunAndReturn(run func(context.Context, common.Address, *common.Address, *big.Int, []byte) (uint64, error)) *EthermanMock_EstimateGas_Call { - _c.Call.Return(run) - return _c -} - -// GetLatestBatchNumber provides a mock function with no fields -func (_m *EthermanMock) GetLatestBatchNumber() (uint64, error) { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for GetLatestBatchNumber") - } - - var r0 uint64 - var r1 error - if rf, ok := ret.Get(0).(func() (uint64, error)); ok { - return rf() - } - if rf, ok := ret.Get(0).(func() uint64); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(uint64) - } - - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthermanMock_GetLatestBatchNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestBatchNumber' -type EthermanMock_GetLatestBatchNumber_Call struct { - *mock.Call -} - -// GetLatestBatchNumber is a helper method to define mock.On call -func (_e *EthermanMock_Expecter) GetLatestBatchNumber() *EthermanMock_GetLatestBatchNumber_Call { - return &EthermanMock_GetLatestBatchNumber_Call{Call: _e.mock.On("GetLatestBatchNumber")} -} - -func (_c *EthermanMock_GetLatestBatchNumber_Call) Run(run func()) *EthermanMock_GetLatestBatchNumber_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *EthermanMock_GetLatestBatchNumber_Call) Return(_a0 uint64, _a1 error) *EthermanMock_GetLatestBatchNumber_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthermanMock_GetLatestBatchNumber_Call) RunAndReturn(run func() (uint64, error)) *EthermanMock_GetLatestBatchNumber_Call { - _c.Call.Return(run) - return _c -} - -// GetLatestBlockHeader provides a mock function with given fields: ctx -func (_m *EthermanMock) GetLatestBlockHeader(ctx context.Context) (*types.Header, error) { - ret := _m.Called(ctx) - - if len(ret) == 0 { - panic("no return value specified for GetLatestBlockHeader") - } - - var r0 *types.Header - var r1 error - if rf, ok := ret.Get(0).(func(context.Context) (*types.Header, error)); ok { - return rf(ctx) - } - if rf, ok := ret.Get(0).(func(context.Context) *types.Header); ok { - r0 = rf(ctx) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Header) - } - } - - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthermanMock_GetLatestBlockHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestBlockHeader' -type EthermanMock_GetLatestBlockHeader_Call struct { - *mock.Call -} - -// GetLatestBlockHeader is a helper method to define mock.On call -// - ctx context.Context -func (_e *EthermanMock_Expecter) GetLatestBlockHeader(ctx interface{}) *EthermanMock_GetLatestBlockHeader_Call { - return &EthermanMock_GetLatestBlockHeader_Call{Call: _e.mock.On("GetLatestBlockHeader", ctx)} -} - -func (_c *EthermanMock_GetLatestBlockHeader_Call) Run(run func(ctx context.Context)) *EthermanMock_GetLatestBlockHeader_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context)) - }) - return _c -} - -func (_c *EthermanMock_GetLatestBlockHeader_Call) Return(_a0 *types.Header, _a1 error) *EthermanMock_GetLatestBlockHeader_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthermanMock_GetLatestBlockHeader_Call) RunAndReturn(run func(context.Context) (*types.Header, error)) *EthermanMock_GetLatestBlockHeader_Call { - _c.Call.Return(run) - return _c -} - -// NewEthermanMock creates a new instance of EthermanMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewEthermanMock(t interface { - mock.TestingT - Cleanup(func()) -}) *EthermanMock { - mock := &EthermanMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/mocks/mock_ethtxmanager.go b/sequencesender/mocks/mock_ethtxmanager.go deleted file mode 100644 index b8a58d0d..00000000 --- a/sequencesender/mocks/mock_ethtxmanager.go +++ /dev/null @@ -1,302 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks - -import ( - context "context" - big "math/big" - - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - types "github.com/ethereum/go-ethereum/core/types" - - zkevm_ethtx_managertypes "github.com/0xPolygon/zkevm-ethtx-manager/types" -) - -// EthTxManagerMock is an autogenerated mock type for the EthTxManager type -type EthTxManagerMock struct { - mock.Mock -} - -type EthTxManagerMock_Expecter struct { - mock *mock.Mock -} - -func (_m *EthTxManagerMock) EXPECT() *EthTxManagerMock_Expecter { - return &EthTxManagerMock_Expecter{mock: &_m.Mock} -} - -// AddWithGas provides a mock function with given fields: ctx, to, value, data, gasOffset, sidecar, gas -func (_m *EthTxManagerMock) AddWithGas(ctx context.Context, to *common.Address, value *big.Int, data []byte, gasOffset uint64, sidecar *types.BlobTxSidecar, gas uint64) (common.Hash, error) { - ret := _m.Called(ctx, to, value, data, gasOffset, sidecar, gas) - - if len(ret) == 0 { - panic("no return value specified for AddWithGas") - } - - var r0 common.Hash - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *common.Address, *big.Int, []byte, uint64, *types.BlobTxSidecar, uint64) (common.Hash, error)); ok { - return rf(ctx, to, value, data, gasOffset, sidecar, gas) - } - if rf, ok := ret.Get(0).(func(context.Context, *common.Address, *big.Int, []byte, uint64, *types.BlobTxSidecar, uint64) common.Hash); ok { - r0 = rf(ctx, to, value, data, gasOffset, sidecar, gas) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(common.Hash) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, *common.Address, *big.Int, []byte, uint64, *types.BlobTxSidecar, uint64) error); ok { - r1 = rf(ctx, to, value, data, gasOffset, sidecar, gas) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthTxManagerMock_AddWithGas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddWithGas' -type EthTxManagerMock_AddWithGas_Call struct { - *mock.Call -} - -// AddWithGas is a helper method to define mock.On call -// - ctx context.Context -// - to *common.Address -// - value *big.Int -// - data []byte -// - gasOffset uint64 -// - sidecar *types.BlobTxSidecar -// - gas uint64 -func (_e *EthTxManagerMock_Expecter) AddWithGas(ctx interface{}, to interface{}, value interface{}, data interface{}, gasOffset interface{}, sidecar interface{}, gas interface{}) *EthTxManagerMock_AddWithGas_Call { - return &EthTxManagerMock_AddWithGas_Call{Call: _e.mock.On("AddWithGas", ctx, to, value, data, gasOffset, sidecar, gas)} -} - -func (_c *EthTxManagerMock_AddWithGas_Call) Run(run func(ctx context.Context, to *common.Address, value *big.Int, data []byte, gasOffset uint64, sidecar *types.BlobTxSidecar, gas uint64)) *EthTxManagerMock_AddWithGas_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*common.Address), args[2].(*big.Int), args[3].([]byte), args[4].(uint64), args[5].(*types.BlobTxSidecar), args[6].(uint64)) - }) - return _c -} - -func (_c *EthTxManagerMock_AddWithGas_Call) Return(_a0 common.Hash, _a1 error) *EthTxManagerMock_AddWithGas_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthTxManagerMock_AddWithGas_Call) RunAndReturn(run func(context.Context, *common.Address, *big.Int, []byte, uint64, *types.BlobTxSidecar, uint64) (common.Hash, error)) *EthTxManagerMock_AddWithGas_Call { - _c.Call.Return(run) - return _c -} - -// Remove provides a mock function with given fields: ctx, hash -func (_m *EthTxManagerMock) Remove(ctx context.Context, hash common.Hash) error { - ret := _m.Called(ctx, hash) - - if len(ret) == 0 { - panic("no return value specified for Remove") - } - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, common.Hash) error); ok { - r0 = rf(ctx, hash) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// EthTxManagerMock_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove' -type EthTxManagerMock_Remove_Call struct { - *mock.Call -} - -// Remove is a helper method to define mock.On call -// - ctx context.Context -// - hash common.Hash -func (_e *EthTxManagerMock_Expecter) Remove(ctx interface{}, hash interface{}) *EthTxManagerMock_Remove_Call { - return &EthTxManagerMock_Remove_Call{Call: _e.mock.On("Remove", ctx, hash)} -} - -func (_c *EthTxManagerMock_Remove_Call) Run(run func(ctx context.Context, hash common.Hash)) *EthTxManagerMock_Remove_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(common.Hash)) - }) - return _c -} - -func (_c *EthTxManagerMock_Remove_Call) Return(_a0 error) *EthTxManagerMock_Remove_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *EthTxManagerMock_Remove_Call) RunAndReturn(run func(context.Context, common.Hash) error) *EthTxManagerMock_Remove_Call { - _c.Call.Return(run) - return _c -} - -// Result provides a mock function with given fields: ctx, hash -func (_m *EthTxManagerMock) Result(ctx context.Context, hash common.Hash) (zkevm_ethtx_managertypes.MonitoredTxResult, error) { - ret := _m.Called(ctx, hash) - - if len(ret) == 0 { - panic("no return value specified for Result") - } - - var r0 zkevm_ethtx_managertypes.MonitoredTxResult - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, common.Hash) (zkevm_ethtx_managertypes.MonitoredTxResult, error)); ok { - return rf(ctx, hash) - } - if rf, ok := ret.Get(0).(func(context.Context, common.Hash) zkevm_ethtx_managertypes.MonitoredTxResult); ok { - r0 = rf(ctx, hash) - } else { - r0 = ret.Get(0).(zkevm_ethtx_managertypes.MonitoredTxResult) - } - - if rf, ok := ret.Get(1).(func(context.Context, common.Hash) error); ok { - r1 = rf(ctx, hash) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthTxManagerMock_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result' -type EthTxManagerMock_Result_Call struct { - *mock.Call -} - -// Result is a helper method to define mock.On call -// - ctx context.Context -// - hash common.Hash -func (_e *EthTxManagerMock_Expecter) Result(ctx interface{}, hash interface{}) *EthTxManagerMock_Result_Call { - return &EthTxManagerMock_Result_Call{Call: _e.mock.On("Result", ctx, hash)} -} - -func (_c *EthTxManagerMock_Result_Call) Run(run func(ctx context.Context, hash common.Hash)) *EthTxManagerMock_Result_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(common.Hash)) - }) - return _c -} - -func (_c *EthTxManagerMock_Result_Call) Return(_a0 zkevm_ethtx_managertypes.MonitoredTxResult, _a1 error) *EthTxManagerMock_Result_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthTxManagerMock_Result_Call) RunAndReturn(run func(context.Context, common.Hash) (zkevm_ethtx_managertypes.MonitoredTxResult, error)) *EthTxManagerMock_Result_Call { - _c.Call.Return(run) - return _c -} - -// ResultsByStatus provides a mock function with given fields: ctx, status -func (_m *EthTxManagerMock) ResultsByStatus(ctx context.Context, status []zkevm_ethtx_managertypes.MonitoredTxStatus) ([]zkevm_ethtx_managertypes.MonitoredTxResult, error) { - ret := _m.Called(ctx, status) - - if len(ret) == 0 { - panic("no return value specified for ResultsByStatus") - } - - var r0 []zkevm_ethtx_managertypes.MonitoredTxResult - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []zkevm_ethtx_managertypes.MonitoredTxStatus) ([]zkevm_ethtx_managertypes.MonitoredTxResult, error)); ok { - return rf(ctx, status) - } - if rf, ok := ret.Get(0).(func(context.Context, []zkevm_ethtx_managertypes.MonitoredTxStatus) []zkevm_ethtx_managertypes.MonitoredTxResult); ok { - r0 = rf(ctx, status) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]zkevm_ethtx_managertypes.MonitoredTxResult) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []zkevm_ethtx_managertypes.MonitoredTxStatus) error); ok { - r1 = rf(ctx, status) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// EthTxManagerMock_ResultsByStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResultsByStatus' -type EthTxManagerMock_ResultsByStatus_Call struct { - *mock.Call -} - -// ResultsByStatus is a helper method to define mock.On call -// - ctx context.Context -// - status []zkevm_ethtx_managertypes.MonitoredTxStatus -func (_e *EthTxManagerMock_Expecter) ResultsByStatus(ctx interface{}, status interface{}) *EthTxManagerMock_ResultsByStatus_Call { - return &EthTxManagerMock_ResultsByStatus_Call{Call: _e.mock.On("ResultsByStatus", ctx, status)} -} - -func (_c *EthTxManagerMock_ResultsByStatus_Call) Run(run func(ctx context.Context, status []zkevm_ethtx_managertypes.MonitoredTxStatus)) *EthTxManagerMock_ResultsByStatus_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]zkevm_ethtx_managertypes.MonitoredTxStatus)) - }) - return _c -} - -func (_c *EthTxManagerMock_ResultsByStatus_Call) Return(_a0 []zkevm_ethtx_managertypes.MonitoredTxResult, _a1 error) *EthTxManagerMock_ResultsByStatus_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *EthTxManagerMock_ResultsByStatus_Call) RunAndReturn(run func(context.Context, []zkevm_ethtx_managertypes.MonitoredTxStatus) ([]zkevm_ethtx_managertypes.MonitoredTxResult, error)) *EthTxManagerMock_ResultsByStatus_Call { - _c.Call.Return(run) - return _c -} - -// Start provides a mock function with no fields -func (_m *EthTxManagerMock) Start() { - _m.Called() -} - -// EthTxManagerMock_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' -type EthTxManagerMock_Start_Call struct { - *mock.Call -} - -// Start is a helper method to define mock.On call -func (_e *EthTxManagerMock_Expecter) Start() *EthTxManagerMock_Start_Call { - return &EthTxManagerMock_Start_Call{Call: _e.mock.On("Start")} -} - -func (_c *EthTxManagerMock_Start_Call) Run(run func()) *EthTxManagerMock_Start_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *EthTxManagerMock_Start_Call) Return() *EthTxManagerMock_Start_Call { - _c.Call.Return() - return _c -} - -func (_c *EthTxManagerMock_Start_Call) RunAndReturn(run func()) *EthTxManagerMock_Start_Call { - _c.Run(run) - return _c -} - -// NewEthTxManagerMock creates a new instance of EthTxManagerMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewEthTxManagerMock(t interface { - mock.TestingT - Cleanup(func()) -}) *EthTxManagerMock { - mock := &EthTxManagerMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/mocks/mock_rpc.go b/sequencesender/mocks/mock_rpc.go deleted file mode 100644 index 8dd60588..00000000 --- a/sequencesender/mocks/mock_rpc.go +++ /dev/null @@ -1,153 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" - - types "github.com/agglayer/aggkit/rpc/types" -) - -// RPCInterfaceMock is an autogenerated mock type for the RPCInterface type -type RPCInterfaceMock struct { - mock.Mock -} - -type RPCInterfaceMock_Expecter struct { - mock *mock.Mock -} - -func (_m *RPCInterfaceMock) EXPECT() *RPCInterfaceMock_Expecter { - return &RPCInterfaceMock_Expecter{mock: &_m.Mock} -} - -// GetBatch provides a mock function with given fields: batchNumber -func (_m *RPCInterfaceMock) GetBatch(batchNumber uint64) (*types.RPCBatch, error) { - ret := _m.Called(batchNumber) - - if len(ret) == 0 { - panic("no return value specified for GetBatch") - } - - var r0 *types.RPCBatch - var r1 error - if rf, ok := ret.Get(0).(func(uint64) (*types.RPCBatch, error)); ok { - return rf(batchNumber) - } - if rf, ok := ret.Get(0).(func(uint64) *types.RPCBatch); ok { - r0 = rf(batchNumber) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.RPCBatch) - } - } - - if rf, ok := ret.Get(1).(func(uint64) error); ok { - r1 = rf(batchNumber) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RPCInterfaceMock_GetBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBatch' -type RPCInterfaceMock_GetBatch_Call struct { - *mock.Call -} - -// GetBatch is a helper method to define mock.On call -// - batchNumber uint64 -func (_e *RPCInterfaceMock_Expecter) GetBatch(batchNumber interface{}) *RPCInterfaceMock_GetBatch_Call { - return &RPCInterfaceMock_GetBatch_Call{Call: _e.mock.On("GetBatch", batchNumber)} -} - -func (_c *RPCInterfaceMock_GetBatch_Call) Run(run func(batchNumber uint64)) *RPCInterfaceMock_GetBatch_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(uint64)) - }) - return _c -} - -func (_c *RPCInterfaceMock_GetBatch_Call) Return(_a0 *types.RPCBatch, _a1 error) *RPCInterfaceMock_GetBatch_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RPCInterfaceMock_GetBatch_Call) RunAndReturn(run func(uint64) (*types.RPCBatch, error)) *RPCInterfaceMock_GetBatch_Call { - _c.Call.Return(run) - return _c -} - -// GetWitness provides a mock function with given fields: batchNumber, fullWitness -func (_m *RPCInterfaceMock) GetWitness(batchNumber uint64, fullWitness bool) ([]byte, error) { - ret := _m.Called(batchNumber, fullWitness) - - if len(ret) == 0 { - panic("no return value specified for GetWitness") - } - - var r0 []byte - var r1 error - if rf, ok := ret.Get(0).(func(uint64, bool) ([]byte, error)); ok { - return rf(batchNumber, fullWitness) - } - if rf, ok := ret.Get(0).(func(uint64, bool) []byte); ok { - r0 = rf(batchNumber, fullWitness) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - - if rf, ok := ret.Get(1).(func(uint64, bool) error); ok { - r1 = rf(batchNumber, fullWitness) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RPCInterfaceMock_GetWitness_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWitness' -type RPCInterfaceMock_GetWitness_Call struct { - *mock.Call -} - -// GetWitness is a helper method to define mock.On call -// - batchNumber uint64 -// - fullWitness bool -func (_e *RPCInterfaceMock_Expecter) GetWitness(batchNumber interface{}, fullWitness interface{}) *RPCInterfaceMock_GetWitness_Call { - return &RPCInterfaceMock_GetWitness_Call{Call: _e.mock.On("GetWitness", batchNumber, fullWitness)} -} - -func (_c *RPCInterfaceMock_GetWitness_Call) Run(run func(batchNumber uint64, fullWitness bool)) *RPCInterfaceMock_GetWitness_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(uint64), args[1].(bool)) - }) - return _c -} - -func (_c *RPCInterfaceMock_GetWitness_Call) Return(_a0 []byte, _a1 error) *RPCInterfaceMock_GetWitness_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RPCInterfaceMock_GetWitness_Call) RunAndReturn(run func(uint64, bool) ([]byte, error)) *RPCInterfaceMock_GetWitness_Call { - _c.Call.Return(run) - return _c -} - -// NewRPCInterfaceMock creates a new instance of RPCInterfaceMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRPCInterfaceMock(t interface { - mock.TestingT - Cleanup(func()) -}) *RPCInterfaceMock { - mock := &RPCInterfaceMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/mocks/mock_txbuilder.go b/sequencesender/mocks/mock_txbuilder.go deleted file mode 100644 index 5bb152b8..00000000 --- a/sequencesender/mocks/mock_txbuilder.go +++ /dev/null @@ -1,367 +0,0 @@ -// Code generated by mockery v2.40.1. DO NOT EDIT. - -package mocks - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - datastream "github.com/agglayer/aggkit/state/datastream" - - mock "github.com/stretchr/testify/mock" - - seqsendertypes "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - - txbuilder "github.com/agglayer/aggkit/sequencesender/txbuilder" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// TxBuilderMock is an autogenerated mock type for the TxBuilder type -type TxBuilderMock struct { - mock.Mock -} - -type TxBuilderMock_Expecter struct { - mock *mock.Mock -} - -func (_m *TxBuilderMock) EXPECT() *TxBuilderMock_Expecter { - return &TxBuilderMock_Expecter{mock: &_m.Mock} -} - -// BuildSequenceBatchesTx provides a mock function with given fields: ctx, sequences -func (_m *TxBuilderMock) BuildSequenceBatchesTx(ctx context.Context, sequences seqsendertypes.Sequence) (*types.Transaction, error) { - ret := _m.Called(ctx, sequences) - - if len(ret) == 0 { - panic("no return value specified for BuildSequenceBatchesTx") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, seqsendertypes.Sequence) (*types.Transaction, error)); ok { - return rf(ctx, sequences) - } - if rf, ok := ret.Get(0).(func(context.Context, seqsendertypes.Sequence) *types.Transaction); ok { - r0 = rf(ctx, sequences) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, seqsendertypes.Sequence) error); ok { - r1 = rf(ctx, sequences) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilderMock_BuildSequenceBatchesTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildSequenceBatchesTx' -type TxBuilderMock_BuildSequenceBatchesTx_Call struct { - *mock.Call -} - -// BuildSequenceBatchesTx is a helper method to define mock.On call -// - ctx context.Context -// - sequences seqsendertypes.Sequence -func (_e *TxBuilderMock_Expecter) BuildSequenceBatchesTx(ctx interface{}, sequences interface{}) *TxBuilderMock_BuildSequenceBatchesTx_Call { - return &TxBuilderMock_BuildSequenceBatchesTx_Call{Call: _e.mock.On("BuildSequenceBatchesTx", ctx, sequences)} -} - -func (_c *TxBuilderMock_BuildSequenceBatchesTx_Call) Run(run func(ctx context.Context, sequences seqsendertypes.Sequence)) *TxBuilderMock_BuildSequenceBatchesTx_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(seqsendertypes.Sequence)) - }) - return _c -} - -func (_c *TxBuilderMock_BuildSequenceBatchesTx_Call) Return(_a0 *types.Transaction, _a1 error) *TxBuilderMock_BuildSequenceBatchesTx_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilderMock_BuildSequenceBatchesTx_Call) RunAndReturn(run func(context.Context, seqsendertypes.Sequence) (*types.Transaction, error)) *TxBuilderMock_BuildSequenceBatchesTx_Call { - _c.Call.Return(run) - return _c -} - -// NewBatchFromL2Block provides a mock function with given fields: l2Block -func (_m *TxBuilderMock) NewBatchFromL2Block(l2Block *datastream.L2Block) seqsendertypes.Batch { - ret := _m.Called(l2Block) - - if len(ret) == 0 { - panic("no return value specified for NewBatchFromL2Block") - } - - var r0 seqsendertypes.Batch - if rf, ok := ret.Get(0).(func(*datastream.L2Block) seqsendertypes.Batch); ok { - r0 = rf(l2Block) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Batch) - } - } - - return r0 -} - -// TxBuilderMock_NewBatchFromL2Block_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBatchFromL2Block' -type TxBuilderMock_NewBatchFromL2Block_Call struct { - *mock.Call -} - -// NewBatchFromL2Block is a helper method to define mock.On call -// - l2Block *datastream.L2Block -func (_e *TxBuilderMock_Expecter) NewBatchFromL2Block(l2Block interface{}) *TxBuilderMock_NewBatchFromL2Block_Call { - return &TxBuilderMock_NewBatchFromL2Block_Call{Call: _e.mock.On("NewBatchFromL2Block", l2Block)} -} - -func (_c *TxBuilderMock_NewBatchFromL2Block_Call) Run(run func(l2Block *datastream.L2Block)) *TxBuilderMock_NewBatchFromL2Block_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*datastream.L2Block)) - }) - return _c -} - -func (_c *TxBuilderMock_NewBatchFromL2Block_Call) Return(_a0 seqsendertypes.Batch) *TxBuilderMock_NewBatchFromL2Block_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilderMock_NewBatchFromL2Block_Call) RunAndReturn(run func(*datastream.L2Block) seqsendertypes.Batch) *TxBuilderMock_NewBatchFromL2Block_Call { - _c.Call.Return(run) - return _c -} - -// NewSequence provides a mock function with given fields: ctx, batches, coinbase -func (_m *TxBuilderMock) NewSequence(ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address) (seqsendertypes.Sequence, error) { - ret := _m.Called(ctx, batches, coinbase) - - if len(ret) == 0 { - panic("no return value specified for NewSequence") - } - - var r0 seqsendertypes.Sequence - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)); ok { - return rf(ctx, batches, coinbase) - } - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address) seqsendertypes.Sequence); ok { - r0 = rf(ctx, batches, coinbase) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Sequence) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []seqsendertypes.Batch, common.Address) error); ok { - r1 = rf(ctx, batches, coinbase) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilderMock_NewSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSequence' -type TxBuilderMock_NewSequence_Call struct { - *mock.Call -} - -// NewSequence is a helper method to define mock.On call -// - ctx context.Context -// - batches []seqsendertypes.Batch -// - coinbase common.Address -func (_e *TxBuilderMock_Expecter) NewSequence(ctx interface{}, batches interface{}, coinbase interface{}) *TxBuilderMock_NewSequence_Call { - return &TxBuilderMock_NewSequence_Call{Call: _e.mock.On("NewSequence", ctx, batches, coinbase)} -} - -func (_c *TxBuilderMock_NewSequence_Call) Run(run func(ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address)) *TxBuilderMock_NewSequence_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]seqsendertypes.Batch), args[2].(common.Address)) - }) - return _c -} - -func (_c *TxBuilderMock_NewSequence_Call) Return(_a0 seqsendertypes.Sequence, _a1 error) *TxBuilderMock_NewSequence_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilderMock_NewSequence_Call) RunAndReturn(run func(context.Context, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)) *TxBuilderMock_NewSequence_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceIfWorthToSend provides a mock function with given fields: ctx, sequenceBatches, l2Coinbase, batchNumber -func (_m *TxBuilderMock) NewSequenceIfWorthToSend(ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64) (seqsendertypes.Sequence, error) { - ret := _m.Called(ctx, sequenceBatches, l2Coinbase, batchNumber) - - if len(ret) == 0 { - panic("no return value specified for NewSequenceIfWorthToSend") - } - - var r0 seqsendertypes.Sequence - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) (seqsendertypes.Sequence, error)); ok { - return rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) seqsendertypes.Sequence); ok { - r0 = rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Sequence) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) error); ok { - r1 = rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilderMock_NewSequenceIfWorthToSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSequenceIfWorthToSend' -type TxBuilderMock_NewSequenceIfWorthToSend_Call struct { - *mock.Call -} - -// NewSequenceIfWorthToSend is a helper method to define mock.On call -// - ctx context.Context -// - sequenceBatches []seqsendertypes.Batch -// - l2Coinbase common.Address -// - batchNumber uint64 -func (_e *TxBuilderMock_Expecter) NewSequenceIfWorthToSend(ctx interface{}, sequenceBatches interface{}, l2Coinbase interface{}, batchNumber interface{}) *TxBuilderMock_NewSequenceIfWorthToSend_Call { - return &TxBuilderMock_NewSequenceIfWorthToSend_Call{Call: _e.mock.On("NewSequenceIfWorthToSend", ctx, sequenceBatches, l2Coinbase, batchNumber)} -} - -func (_c *TxBuilderMock_NewSequenceIfWorthToSend_Call) Run(run func(ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64)) *TxBuilderMock_NewSequenceIfWorthToSend_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]seqsendertypes.Batch), args[2].(common.Address), args[3].(uint64)) - }) - return _c -} - -func (_c *TxBuilderMock_NewSequenceIfWorthToSend_Call) Return(_a0 seqsendertypes.Sequence, _a1 error) *TxBuilderMock_NewSequenceIfWorthToSend_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilderMock_NewSequenceIfWorthToSend_Call) RunAndReturn(run func(context.Context, []seqsendertypes.Batch, common.Address, uint64) (seqsendertypes.Sequence, error)) *TxBuilderMock_NewSequenceIfWorthToSend_Call { - _c.Call.Return(run) - return _c -} - -// SetCondNewSeq provides a mock function with given fields: cond -func (_m *TxBuilderMock) SetCondNewSeq(cond txbuilder.CondNewSequence) txbuilder.CondNewSequence { - ret := _m.Called(cond) - - if len(ret) == 0 { - panic("no return value specified for SetCondNewSeq") - } - - var r0 txbuilder.CondNewSequence - if rf, ok := ret.Get(0).(func(txbuilder.CondNewSequence) txbuilder.CondNewSequence); ok { - r0 = rf(cond) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(txbuilder.CondNewSequence) - } - } - - return r0 -} - -// TxBuilderMock_SetCondNewSeq_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCondNewSeq' -type TxBuilderMock_SetCondNewSeq_Call struct { - *mock.Call -} - -// SetCondNewSeq is a helper method to define mock.On call -// - cond txbuilder.CondNewSequence -func (_e *TxBuilderMock_Expecter) SetCondNewSeq(cond interface{}) *TxBuilderMock_SetCondNewSeq_Call { - return &TxBuilderMock_SetCondNewSeq_Call{Call: _e.mock.On("SetCondNewSeq", cond)} -} - -func (_c *TxBuilderMock_SetCondNewSeq_Call) Run(run func(cond txbuilder.CondNewSequence)) *TxBuilderMock_SetCondNewSeq_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(txbuilder.CondNewSequence)) - }) - return _c -} - -func (_c *TxBuilderMock_SetCondNewSeq_Call) Return(_a0 txbuilder.CondNewSequence) *TxBuilderMock_SetCondNewSeq_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilderMock_SetCondNewSeq_Call) RunAndReturn(run func(txbuilder.CondNewSequence) txbuilder.CondNewSequence) *TxBuilderMock_SetCondNewSeq_Call { - _c.Call.Return(run) - return _c -} - -// String provides a mock function with given fields: -func (_m *TxBuilderMock) String() string { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for String") - } - - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// TxBuilderMock_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' -type TxBuilderMock_String_Call struct { - *mock.Call -} - -// String is a helper method to define mock.On call -func (_e *TxBuilderMock_Expecter) String() *TxBuilderMock_String_Call { - return &TxBuilderMock_String_Call{Call: _e.mock.On("String")} -} - -func (_c *TxBuilderMock_String_Call) Run(run func()) *TxBuilderMock_String_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *TxBuilderMock_String_Call) Return(_a0 string) *TxBuilderMock_String_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilderMock_String_Call) RunAndReturn(run func() string) *TxBuilderMock_String_Call { - _c.Call.Return(run) - return _c -} - -// NewTxBuilderMock creates a new instance of TxBuilderMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewTxBuilderMock(t interface { - mock.TestingT - Cleanup(func()) -}) *TxBuilderMock { - mock := &TxBuilderMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/seqsendertypes/types.go b/sequencesender/seqsendertypes/types.go deleted file mode 100644 index 5d903dc5..00000000 --- a/sequencesender/seqsendertypes/types.go +++ /dev/null @@ -1,43 +0,0 @@ -package seqsendertypes - -import ( - "github.com/ethereum/go-ethereum/common" -) - -type Batch interface { - // underlyingType *ethmantypes.Batch - DeepCopy() Batch - LastCoinbase() common.Address - ForcedBatchTimestamp() uint64 - ForcedGlobalExitRoot() common.Hash - ForcedBlockHashL1() common.Hash - L2Data() []byte - LastL2BLockTimestamp() uint64 - BatchNumber() uint64 - GlobalExitRoot() common.Hash - L1InfoTreeIndex() uint32 - - String() string - - // WRITE - SetL2Data(data []byte) - SetLastCoinbase(address common.Address) - SetLastL2BLockTimestamp(ts uint64) - SetL1InfoTreeIndex(index uint32) -} - -type Sequence interface { - IndexL1InfoRoot() uint32 - MaxSequenceTimestamp() uint64 - L1InfoRoot() common.Hash - Batches() []Batch - FirstBatch() Batch - LastBatch() Batch - Len() int - L2Coinbase() common.Address - LastVirtualBatchNumber() uint64 - - String() string - // WRITE - SetLastVirtualBatchNumber(batchNumber uint64) -} diff --git a/sequencesender/sequencesender.go b/sequencesender/sequencesender.go deleted file mode 100644 index e6644121..00000000 --- a/sequencesender/sequencesender.go +++ /dev/null @@ -1,556 +0,0 @@ -package sequencesender - -import ( - "context" - "errors" - "fmt" - "math/big" - "os" - "sync" - "sync/atomic" - "time" - - "github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager" - ethtxlog "github.com/0xPolygon/zkevm-ethtx-manager/log" - ethtxtypes "github.com/0xPolygon/zkevm-ethtx-manager/types" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/rpc" - "github.com/agglayer/aggkit/rpc/types" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/state" - "github.com/ethereum/go-ethereum/common" - ethtypes "github.com/ethereum/go-ethereum/core/types" -) - -const ten = 10 - -// EthTxManager represents the eth tx manager interface -type EthTxManager interface { - Start() - AddWithGas( - ctx context.Context, - to *common.Address, - value *big.Int, - data []byte, - gasOffset uint64, - sidecar *ethtypes.BlobTxSidecar, - gas uint64, - ) (common.Hash, error) - Remove(ctx context.Context, hash common.Hash) error - ResultsByStatus(ctx context.Context, status []ethtxtypes.MonitoredTxStatus) ([]ethtxtypes.MonitoredTxResult, error) - Result(ctx context.Context, hash common.Hash) (ethtxtypes.MonitoredTxResult, error) -} - -// Etherman represents the etherman behaviour -type Etherman interface { - CurrentNonce(ctx context.Context, address common.Address) (uint64, error) - GetLatestBlockHeader(ctx context.Context) (*ethtypes.Header, error) - EstimateGas(ctx context.Context, from common.Address, to *common.Address, value *big.Int, data []byte) (uint64, error) - GetLatestBatchNumber() (uint64, error) -} - -// RPCInterface represents the RPC interface -type RPCInterface interface { - GetBatch(batchNumber uint64) (*types.RPCBatch, error) - GetWitness(batchNumber uint64, fullWitness bool) ([]byte, error) -} - -// SequenceSender represents a sequence sender -type SequenceSender struct { - cfg Config - logger *log.Logger - ethTxManager EthTxManager - etherman Etherman - latestVirtualBatchNumber uint64 // Latest virtualized batch obtained from L1 - latestVirtualTime time.Time // Latest virtual batch timestamp - latestSentToL1Batch uint64 // Latest batch sent to L1 - sequenceList []uint64 // Sequence of batch number to be send to L1 - sequenceData map[uint64]*sequenceData // All the batch data indexed by batch number - mutexSequence sync.Mutex // Mutex to access sequenceData and sequenceList - ethTransactions map[common.Hash]*ethTxData // All the eth tx sent to L1 indexed by hash - ethTxData map[common.Hash][]byte // Tx data send to or received from L1 - mutexEthTx sync.Mutex // Mutex to access ethTransactions - sequencesTxFile *os.File // Persistence of sent transactions - validStream bool // Not valid while receiving data before the desired batch - seqSendingStopped uint32 // If there is a critical error - TxBuilder txbuilder.TxBuilder - rpcClient RPCInterface -} - -type sequenceData struct { - batchClosed bool - batch seqsendertypes.Batch - batchRaw *state.BatchRawV2 -} - -// New inits sequence sender -func New(cfg Config, logger *log.Logger, - etherman *etherman.Client, txBuilder txbuilder.TxBuilder) (*SequenceSender, error) { - // Create sequencesender - s := SequenceSender{ - cfg: cfg, - logger: logger, - etherman: etherman, - ethTransactions: make(map[common.Hash]*ethTxData), - ethTxData: make(map[common.Hash][]byte), - sequenceData: make(map[uint64]*sequenceData), - validStream: false, - TxBuilder: txBuilder, - rpcClient: rpc.NewBatchEndpoints(cfg.RPCURL), - } - - logger.Infof("TxBuilder configuration: %s", txBuilder.String()) - - // Restore pending sent sequences - err := s.loadSentSequencesTransactions() - if err != nil { - s.logger.Fatalf("error restoring sent sequences from file", err) - return nil, err - } - - // Create ethtxmanager client - cfg.EthTxManager.Log = ethtxlog.Config{ - Environment: ethtxlog.LogEnvironment(cfg.Log.Environment), - Level: cfg.Log.Level, - Outputs: cfg.Log.Outputs, - } - - s.ethTxManager, err = ethtxmanager.New(cfg.EthTxManager) - if err != nil { - s.logger.Fatalf("error creating ethtxmanager client: %v", err) - return nil, err - } - - return &s, nil -} - -// Start starts the sequence sender -func (s *SequenceSender) Start(ctx context.Context) { - // Start ethtxmanager client - go s.ethTxManager.Start() - - // Get latest virtual state batch from L1 - err := s.updateLatestVirtualBatch() - if err != nil { - s.logger.Fatalf("error getting latest sequenced batch, error: %v", err) - } - - // Sync all monitored sent L1 tx - err = s.syncAllEthTxResults(ctx) - if err != nil { - s.logger.Fatalf("failed to sync monitored tx results, error: %v", err) - } - - // Current batch to sequence - atomic.StoreUint64(&s.latestSentToL1Batch, atomic.LoadUint64(&s.latestVirtualBatchNumber)) - - // Start retrieving batches from RPC - go func() { - err := s.batchRetrieval(ctx) - if err != nil { - s.logFatalf("error retrieving batches from RPC: %v", err) - } - }() - - // Start sequence sending - go s.sequenceSending(ctx) -} - -// batchRetrieval keeps reading batches from the RPC -func (s *SequenceSender) batchRetrieval(ctx context.Context) error { - ticker := time.NewTicker(s.cfg.GetBatchWaitInterval.Duration) - defer ticker.Stop() - - currentBatchNumber := atomic.LoadUint64(&s.latestVirtualBatchNumber) + 1 - for { - select { - case <-ctx.Done(): - s.logger.Info("context cancelled, stopping batch retrieval") - return ctx.Err() - default: - // Try to retrieve batch from RPC - rpcBatch, err := s.rpcClient.GetBatch(currentBatchNumber) - if err != nil { - if errors.Is(err, ethtxmanager.ErrNotFound) { - s.logger.Infof("batch %d not found in RPC", currentBatchNumber) - } else { - s.logger.Errorf("error getting batch %d from RPC: %v", currentBatchNumber, err) - } - <-ticker.C - continue - } - - // Check if the batch is closed - if !rpcBatch.IsClosed() { - s.logger.Infof("batch %d is not closed yet", currentBatchNumber) - <-ticker.C - continue - } - - // Process and decode the batch - if err := s.populateSequenceData(rpcBatch, currentBatchNumber); err != nil { - return err - } - - // Increment the batch number for the next iteration - currentBatchNumber++ - } - } -} - -func (s *SequenceSender) populateSequenceData(rpcBatch *types.RPCBatch, batchNumber uint64) error { - s.mutexSequence.Lock() - defer s.mutexSequence.Unlock() - - s.sequenceList = append(s.sequenceList, batchNumber) - - // Decode batch to retrieve the l1 info tree index - batchRaw, err := state.DecodeBatchV2(rpcBatch.L2Data()) - if err != nil { - s.logger.Errorf("Failed to decode batch data for batch %d, err: %v", batchNumber, err) - return err - } - - if len(batchRaw.Blocks) > 0 { - rpcBatch.SetL1InfoTreeIndex(batchRaw.Blocks[len(batchRaw.Blocks)-1].IndexL1InfoTree) - } - - s.sequenceData[batchNumber] = &sequenceData{ - batchClosed: rpcBatch.IsClosed(), - batch: rpcBatch, - batchRaw: batchRaw, - } - - return nil -} - -// sequenceSending starts loop to check if there are sequences to send and sends them if it's convenient -func (s *SequenceSender) sequenceSending(ctx context.Context) { - // Create a ticker that fires every WaitPeriodSendSequence - ticker := time.NewTicker(s.cfg.WaitPeriodSendSequence.Duration) - defer ticker.Stop() - - for { - select { - case <-ctx.Done(): - s.logger.Info("context canceled, stopping sequence sending") - return - - case <-ticker.C: - // Trigger the sequence sending when the ticker fires - s.tryToSendSequence(ctx) - } - } -} - -// purgeSequences purges batches from memory structures -func (s *SequenceSender) purgeSequences() { - // If sequence sending is stopped, do not purge - if s.IsStopped() { - return - } - - // Purge the information of batches that are already virtualized - s.mutexSequence.Lock() - defer s.mutexSequence.Unlock() - truncateUntil := 0 - toPurge := make([]uint64, 0) - for i, batchNumber := range s.sequenceList { - if batchNumber <= atomic.LoadUint64(&s.latestVirtualBatchNumber) { - truncateUntil = i + 1 - toPurge = append(toPurge, batchNumber) - } - } - - if len(toPurge) > 0 { - s.sequenceList = s.sequenceList[truncateUntil:] - - firstPurged := toPurge[0] - lastPurged := toPurge[len(toPurge)-1] - for _, batchNum := range toPurge { - delete(s.sequenceData, batchNum) - } - s.logger.Infof("batches purged count: %d, fromBatch: %d, toBatch: %d", len(toPurge), firstPurged, lastPurged) - } -} - -// tryToSendSequence checks if there is a sequence and it's worth it to send to L1 -func (s *SequenceSender) tryToSendSequence(ctx context.Context) { - // Update latest virtual batch - s.logger.Infof("updating virtual batch") - err := s.updateLatestVirtualBatch() - if err != nil { - return - } - - // Check if the sequence sending is stopped - if s.IsStopped() { - s.logger.Warnf("sending is stopped!") - return - } - - // Update state of transactions - s.logger.Infof("updating tx results") - pendingTxsCount, err := s.syncEthTxResults(ctx) - if err != nil { - return - } - - // Check if reached the maximum number of pending transactions - if pendingTxsCount >= s.cfg.MaxPendingTx { - s.logger.Infof("max number of pending txs (%d) reached. Waiting for some to be completed", pendingTxsCount) - return - } - - // Check if should send sequence to L1 - s.logger.Infof("getting sequences to send") - sequence, err := s.getSequencesToSend(ctx) - if err != nil || sequence == nil || sequence.Len() == 0 { - if err != nil { - s.logger.Errorf("error getting sequences: %v", err) - } - return - } - - // Send sequences to L1 - firstBatch := sequence.FirstBatch() - lastBatch := sequence.LastBatch() - - s.logger.Debugf(sequence.String()) - s.logger.Infof("sending sequences to L1. From batch %d to batch %d", firstBatch.BatchNumber(), lastBatch.BatchNumber()) - - // Wait until last L1 block timestamp is L1BlockTimestampMargin seconds above the timestamp - // of the last L2 block in the sequence - timeMargin := int64(s.cfg.L1BlockTimestampMargin.Seconds()) - - err = s.waitForMargin(ctx, lastBatch, timeMargin, "L1 block block timestamp", - func() (uint64, error) { - lastL1BlockHeader, err := s.etherman.GetLatestBlockHeader(ctx) - if err != nil { - return 0, err - } - - return lastL1BlockHeader.Time, nil - }) - if err != nil { - s.logger.Errorf("error waiting for L1 block time margin: %v", err) - return - } - - // Sanity check: Wait until the current time is also L1BlockTimestampMargin seconds above the last L2 block timestamp - err = s.waitForMargin(ctx, lastBatch, timeMargin, "current time", - func() (uint64, error) { return uint64(time.Now().Unix()), nil }) - if err != nil { - s.logger.Errorf("error waiting for current time margin: %v", err) - return - } - - // Send sequences to L1 - s.logger.Debugf(sequence.String()) - s.logger.Infof("sending sequences to L1. From batch %d to batch %d", firstBatch.BatchNumber(), lastBatch.BatchNumber()) - - tx, err := s.TxBuilder.BuildSequenceBatchesTx(ctx, sequence) - if err != nil { - s.logger.Errorf("error building sequenceBatches tx: %v", err) - return - } - - // Get latest virtual state batch from L1 - err = s.updateLatestVirtualBatch() - if err != nil { - s.logger.Fatalf("error getting latest sequenced batch, error: %v", err) - } - - sequence.SetLastVirtualBatchNumber(atomic.LoadUint64(&s.latestVirtualBatchNumber)) - - gas, err := s.etherman.EstimateGas(ctx, s.cfg.SenderAddress, tx.To(), nil, tx.Data()) - if err != nil { - s.logger.Errorf("error estimating gas: ", err) - return - } - - // Add sequence tx - err = s.sendTx(ctx, false, nil, tx.To(), firstBatch.BatchNumber(), lastBatch.BatchNumber(), tx.Data(), gas) - if err != nil { - return - } - - // Purge sequences data from memory - s.purgeSequences() -} - -// waitForMargin ensures that the time difference between the last L2 block and the current -// timestamp exceeds the time margin before proceeding. It checks immediately, and if not -// satisfied, it waits using a ticker and rechecks periodically. -// -// Params: -// - ctx: Context to handle cancellation. -// - lastBatch: The last batch in the sequence. -// - timeMargin: Required time difference in seconds. -// - description: A description for logging purposes. -// - getTimeFn: Function to get the current time (e.g., L1 block time or current time). -func (s *SequenceSender) waitForMargin(ctx context.Context, lastBatch seqsendertypes.Batch, - timeMargin int64, description string, getTimeFn func() (uint64, error)) error { - referentTime, err := getTimeFn() - if err != nil { - return err - } - - lastL2BlockTimestamp := lastBatch.LastL2BLockTimestamp() - elapsed, waitTime := marginTimeElapsed(lastL2BlockTimestamp, referentTime, timeMargin) - if elapsed { - s.logger.Infof("time difference for %s exceeds %d seconds, proceeding (batch number: %d, last l2 block ts: %d)", - description, timeMargin, lastBatch.BatchNumber(), lastL2BlockTimestamp) - return nil - } - - s.logger.Infof("waiting %d seconds for %s, margin less than %d seconds (batch number: %d, last l2 block ts: %d)", - waitTime, description, timeMargin, lastBatch.BatchNumber(), lastL2BlockTimestamp) - ticker := time.NewTicker(time.Duration(waitTime) * time.Second) - defer ticker.Stop() - - for { - select { - case <-ctx.Done(): - s.logger.Infof("context canceled during %s wait (batch number: %d, last l2 block ts: %d)", - description, lastBatch.BatchNumber(), lastL2BlockTimestamp) - return ctx.Err() - - case <-ticker.C: - referentTime, err = getTimeFn() - if err != nil { - return err - } - - elapsed, waitTime = marginTimeElapsed(lastL2BlockTimestamp, referentTime, timeMargin) - if elapsed { - s.logger.Infof("time margin for %s now exceeds %d seconds, proceeding (batch number: %d, last l2 block ts: %d)", - description, timeMargin, lastBatch.BatchNumber(), lastL2BlockTimestamp) - return nil - } - - s.logger.Infof( - "waiting another %d seconds for %s, margin still less than %d seconds (batch number: %d, last l2 block ts: %d)", - waitTime, description, timeMargin, lastBatch.BatchNumber(), lastL2BlockTimestamp) - ticker.Reset(time.Duration(waitTime) * time.Second) - } - } -} - -func (s *SequenceSender) getSequencesToSend(ctx context.Context) (seqsendertypes.Sequence, error) { - // Add sequences until too big for a single L1 tx or last batch is reached - s.mutexSequence.Lock() - defer s.mutexSequence.Unlock() - var prevCoinbase common.Address - sequenceBatches := make([]seqsendertypes.Batch, 0) - for _, batchNumber := range s.sequenceList { - if batchNumber <= atomic.LoadUint64(&s.latestVirtualBatchNumber) || - batchNumber <= atomic.LoadUint64(&s.latestSentToL1Batch) { - continue - } - - // Check if the next batch belongs to a new forkid, in this case we need to stop sequencing as we need to - // wait the upgrade of forkid is completed and s.cfg.NumBatchForkIdUpgrade is disabled (=0) again - if s.cfg.ForkUpgradeBatchNumber != 0 && batchNumber == (s.cfg.ForkUpgradeBatchNumber+1) { - return nil, fmt.Errorf( - "aborting sequencing process as we reached the batch %d where a new forkid is applied (upgrade)", - s.cfg.ForkUpgradeBatchNumber+1, - ) - } - - // New potential batch to add to the sequence - batch := s.sequenceData[batchNumber].batch.DeepCopy() - - // If the coinbase changes, the sequence ends here - if len(sequenceBatches) > 0 && batch.LastCoinbase() != prevCoinbase { - s.logger.Infof( - "batch with different coinbase (batch %v, sequence %v), sequence will be sent to this point", - prevCoinbase, batch.LastCoinbase, - ) - return s.TxBuilder.NewSequence(ctx, sequenceBatches, s.cfg.L2Coinbase) - } - prevCoinbase = batch.LastCoinbase() - - // Add new sequence batch - sequenceBatches = append(sequenceBatches, batch) - - newSeq, err := s.TxBuilder.NewSequenceIfWorthToSend(ctx, sequenceBatches, s.cfg.L2Coinbase, batchNumber) - if err != nil { - return nil, err - } - if newSeq != nil { - return newSeq, nil - } - - // Check if the current batch is the last before a change to a new forkid - // In this case we need to close and send the sequence to L1 - if s.cfg.ForkUpgradeBatchNumber != 0 && batchNumber == s.cfg.ForkUpgradeBatchNumber { - s.logger.Infof("sequence should be sent to L1, as we have reached the batch %d "+ - "from which a new forkid is applied (upgrade)", - s.cfg.ForkUpgradeBatchNumber, - ) - return s.TxBuilder.NewSequence(ctx, sequenceBatches, s.cfg.L2Coinbase) - } - } - - // Reached the latest batch. Decide if it's worth to send the sequence, or wait for new batches - if len(sequenceBatches) == 0 { - s.logger.Infof("no batches to be sequenced") - return nil, nil - } - - if s.latestVirtualTime.Before(time.Now().Add(-s.cfg.LastBatchVirtualizationTimeMaxWaitPeriod.Duration)) { - s.logger.Infof("sequence should be sent, too much time without sending anything to L1") - return s.TxBuilder.NewSequence(ctx, sequenceBatches, s.cfg.L2Coinbase) - } - - s.logger.Infof("not enough time has passed since last batch was virtualized and the sequence could be bigger") - return nil, nil -} - -// updateLatestVirtualBatch queries the value in L1 and updates the latest virtual batch field -func (s *SequenceSender) updateLatestVirtualBatch() error { - // Get latest virtual state batch from L1 - latestVirtualBatchNumber, err := s.etherman.GetLatestBatchNumber() - if err != nil { - s.logger.Errorf("error getting latest virtual batch, error: %v", err) - return errors.New("fail to get latest virtual batch") - } - - atomic.StoreUint64(&s.latestVirtualBatchNumber, latestVirtualBatchNumber) - s.logger.Infof("latest virtual batch is %d", latestVirtualBatchNumber) - - return nil -} - -// logFatalf logs error, activates flag to stop sequencing, and remains in an infinite loop -func (s *SequenceSender) logFatalf(template string, args ...interface{}) { - atomic.StoreUint32(&s.seqSendingStopped, 1) - for { - s.logger.Errorf(template, args...) - s.logger.Errorf("sequence sending stopped.") - time.Sleep(ten * time.Second) - } -} - -// marginTimeElapsed checks if the time between currentTime and l2BlockTimestamp is greater than timeMargin. -// If it's greater returns true, otherwise it returns false and the waitTime needed to achieve this timeMargin -func marginTimeElapsed(l2BlockTimestamp uint64, currentTime uint64, timeMargin int64) (bool, int64) { - if int64(l2BlockTimestamp)-timeMargin > int64(currentTime) { - return true, 0 - } - - timeDiff := int64(currentTime) - int64(l2BlockTimestamp) - - // If the difference is less than the required margin, return false and calculate the remaining wait time - if timeDiff < timeMargin { - // Calculate the wait time needed to reach the timeMargin - waitTime := timeMargin - timeDiff - return false, waitTime - } - - // Time difference is greater than or equal to timeMargin, no need to wait - return true, 0 -} diff --git a/sequencesender/sequencesender_test.go b/sequencesender/sequencesender_test.go deleted file mode 100644 index 27072b1d..00000000 --- a/sequencesender/sequencesender_test.go +++ /dev/null @@ -1,619 +0,0 @@ -package sequencesender - -import ( - "errors" - "math/big" - "os" - "testing" - "time" - - ethtxtypes "github.com/0xPolygon/zkevm-ethtx-manager/types" - types2 "github.com/agglayer/aggkit/config/types" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - rpctypes "github.com/agglayer/aggkit/rpc/types" - "github.com/agglayer/aggkit/sequencesender/mocks" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/state" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" - "golang.org/x/net/context" -) - -const ( - txStreamEncoded1 = "f86508843b9aca0082520894617b3a3528f9cdd6630fd3301b9c8911f7bf063d0a808207f5a0579b72a1c1ffdd845fba45317540982109298e2ec8d67ddf2cdaf22e80903677a01831e9a01291c7ea246742a5b5a543ca6938bfc3f6958c22be06fad99274e4ac" - txStreamEncoded2 = "f86509843b9aca0082520894617b3a3528f9cdd6630fd3301b9c8911f7bf063d0a808207f5a0908a522075e09485166ffa7630cd2b7013897fa1f1238013677d6f0a86efb3d2a0068b12435fcdc8ee254f3b1df8c5b29ed691eeee6065704f061130935976ca99" - txStreamEncoded3 = "b8b402f8b101268505d21dba0085076c363d8982dc60941929761e87667283f087ea9ab8370c174681b4e980b844095ea7b300000000000000000000000080a64c6d7f12c47b7c66c5b4e20e72bc1fcd5d9effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc001a0dd4db494969139a120e8721842455ec13f82757a4fc49b66d447c7d32d095a1da06ef54068a9aa67ecc4f52d885299a04feb6f3531cdfc771f1412cd3331d1ba4c" -) - -var ( - now = time.Now() -) - -func TestMain(t *testing.M) { - t.Run() -} - -func Test_encoding(t *testing.T) { - tx1, err := state.DecodeTx(txStreamEncoded1) - require.NoError(t, err) - tx2, err := state.DecodeTx(txStreamEncoded2) - require.NoError(t, err) - tx3, err := state.DecodeTx(txStreamEncoded3) - require.NoError(t, err) - - txTest := state.L2TxRaw{ - EfficiencyPercentage: 129, - TxAlreadyEncoded: false, - Tx: tx1, - } - txTestEncoded := make([]byte, 0) - txTestEncoded, err = txTest.Encode(txTestEncoded) - require.NoError(t, err) - log.Debugf("%s", common.Bytes2Hex(txTestEncoded)) - - batch := state.BatchRawV2{ - Blocks: []state.L2BlockRaw{ - { - ChangeL2BlockHeader: state.ChangeL2BlockHeader{ - DeltaTimestamp: 3633752, - IndexL1InfoTree: 0, - }, - Transactions: []state.L2TxRaw{ - { - EfficiencyPercentage: 129, - TxAlreadyEncoded: false, - Tx: tx1, - }, - { - EfficiencyPercentage: 97, - TxAlreadyEncoded: false, - Tx: tx2, - }, - { - EfficiencyPercentage: 97, - TxAlreadyEncoded: false, - Tx: tx3, - }, - }, - }, - }, - } - - encodedBatch, err := state.EncodeBatchV2(&batch) - require.NoError(t, err) - - decodedBatch, err := state.DecodeBatchV2(encodedBatch) - require.NoError(t, err) - - require.Equal(t, batch.String(), decodedBatch.String()) -} - -func Test_Start(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - getEtherman func(t *testing.T) *mocks.EthermanMock - getRPC func(t *testing.T) *mocks.RPCInterfaceMock - batchWaitDuration types2.Duration - expectNonce uint64 - expectLastVirtualBatch uint64 - expectFromStreamBatch uint64 - expectWipBatch uint64 - expectLatestSentToL1Batch uint64 - }{ - { - name: "successfully started", - getEtherman: func(t *testing.T) *mocks.EthermanMock { - t.Helper() - - mngr := mocks.NewEthermanMock(t) - mngr.On("GetLatestBatchNumber").Return(uint64(1), nil) - return mngr - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("Start").Return(nil) - mngr.On("ResultsByStatus", mock.Anything, []ethtxtypes.MonitoredTxStatus(nil)).Return(nil, nil) - return mngr - }, - getRPC: func(t *testing.T) *mocks.RPCInterfaceMock { - t.Helper() - - mngr := mocks.NewRPCInterfaceMock(t) - mngr.On("GetBatch", mock.Anything).Return(&rpctypes.RPCBatch{}, nil) - return mngr - }, - - batchWaitDuration: types2.NewDuration(time.Millisecond), - expectNonce: 3, - expectLastVirtualBatch: 1, - expectFromStreamBatch: 1, - expectWipBatch: 2, - expectLatestSentToL1Batch: 1, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name+".tmp") - require.NoError(t, err) - defer os.RemoveAll(tmpFile.Name() + ".tmp") - - s := SequenceSender{ - etherman: tt.getEtherman(t), - ethTxManager: tt.getEthTxManager(t), - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - GetBatchWaitInterval: tt.batchWaitDuration, - WaitPeriodSendSequence: types2.NewDuration(1 * time.Millisecond), - }, - logger: log.GetDefaultLogger(), - rpcClient: tt.getRPC(t), - } - - ctx, cancel := context.WithCancel(context.Background()) - s.Start(ctx) - time.Sleep(time.Second) - cancel() - time.Sleep(time.Second) - - require.Equal(t, tt.expectLatestSentToL1Batch, s.latestSentToL1Batch) - }) - } -} - -func Test_purgeSequences(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - seqSendingStopped uint32 - sequenceList []uint64 - sequenceData map[uint64]*sequenceData - latestVirtualBatchNumber uint64 - expectedSequenceList []uint64 - expectedSequenceData map[uint64]*sequenceData - }{ - { - name: "sequences purged when seqSendingStopped", - seqSendingStopped: 1, - sequenceList: []uint64{1, 2}, - sequenceData: map[uint64]*sequenceData{ - 1: {}, - 2: {}, - }, - expectedSequenceList: []uint64{1, 2}, - expectedSequenceData: map[uint64]*sequenceData{ - 1: {}, - 2: {}, - }, - }, - { - name: "no sequences purged", - seqSendingStopped: 0, - sequenceList: []uint64{4, 5}, - sequenceData: map[uint64]*sequenceData{ - 4: {}, - 5: {}, - }, - expectedSequenceList: []uint64{4, 5}, - expectedSequenceData: map[uint64]*sequenceData{ - 4: {}, - 5: {}, - }, - }, - { - name: "sequences purged", - seqSendingStopped: 0, - sequenceList: []uint64{4, 5, 6}, - sequenceData: map[uint64]*sequenceData{ - 4: {}, - 5: {}, - 6: {}, - }, - latestVirtualBatchNumber: 5, - expectedSequenceList: []uint64{6}, - expectedSequenceData: map[uint64]*sequenceData{ - 6: {}, - }, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - ss := SequenceSender{ - seqSendingStopped: tt.seqSendingStopped, - sequenceList: tt.sequenceList, - sequenceData: tt.sequenceData, - latestVirtualBatchNumber: tt.latestVirtualBatchNumber, - logger: log.GetDefaultLogger(), - } - - ss.purgeSequences() - - require.Equal(t, tt.expectedSequenceList, ss.sequenceList) - require.Equal(t, tt.expectedSequenceData, ss.sequenceData) - }) - } -} - -func Test_tryToSendSequence(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - getEthTxManager func(t *testing.T) *mocks.EthTxManagerMock - getEtherman func(t *testing.T) *mocks.EthermanMock - getTxBuilder func(t *testing.T) *mocks.TxBuilderMock - maxPendingTxn uint64 - sequenceList []uint64 - latestSentToL1Batch uint64 - sequenceData map[uint64]*sequenceData - ethTransactions map[common.Hash]*ethTxData - ethTxData map[common.Hash][]byte - - expectErr error - }{ - { - name: "successfully sent", - getEtherman: func(t *testing.T) *mocks.EthermanMock { - t.Helper() - - mngr := mocks.NewEthermanMock(t) - mngr.On("GetLatestBatchNumber").Return(uint64(1), nil) - return mngr - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - return mngr - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(txbuilder.NewBananaSequence(etherman.SequenceBanana{}), nil) - return mngr - }, - maxPendingTxn: 10, - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - }, - { - name: "successfully sent new sequence", - getEtherman: func(t *testing.T) *mocks.EthermanMock { - t.Helper() - - mngr := mocks.NewEthermanMock(t) - mngr.On("GetLatestBatchNumber").Return(uint64(1), nil) - mngr.On("GetLatestBlockHeader", mock.Anything).Return(&types.Header{ - Number: big.NewInt(1), - }, nil) - mngr.On("EstimateGas", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uint64(100500), nil) - return mngr - }, - getEthTxManager: func(t *testing.T) *mocks.EthTxManagerMock { - t.Helper() - - mngr := mocks.NewEthTxManagerMock(t) - mngr.On("AddWithGas", mock.Anything, mock.Anything, big.NewInt(0), mock.Anything, mock.Anything, mock.Anything, uint64(100500)).Return(common.Hash{}, nil) - mngr.On("Result", mock.Anything, common.Hash{}).Return(ethtxtypes.MonitoredTxResult{ - ID: common.Hash{}, - Data: []byte{1, 2, 3}, - }, nil) - return mngr - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil) - mngr.On("NewSequence", mock.Anything, mock.Anything, mock.Anything).Return(txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), nil) - mngr.On("BuildSequenceBatchesTx", mock.Anything, mock.Anything).Return(types.NewTx(&types.LegacyTx{}), nil) - return mngr - }, - maxPendingTxn: 10, - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - ethTransactions: map[common.Hash]*ethTxData{}, - ethTxData: map[common.Hash][]byte{}, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - tmpFile, err := os.CreateTemp(os.TempDir(), tt.name+".tmp") - require.NoError(t, err) - defer os.RemoveAll(tmpFile.Name() + ".tmp") - - s := SequenceSender{ - ethTxManager: tt.getEthTxManager(t), - etherman: tt.getEtherman(t), - TxBuilder: tt.getTxBuilder(t), - cfg: Config{ - SequencesTxFileName: tmpFile.Name() + ".tmp", - MaxPendingTx: tt.maxPendingTxn, - WaitPeriodSendSequence: types2.NewDuration(time.Millisecond), - }, - sequenceList: tt.sequenceList, - latestSentToL1Batch: tt.latestSentToL1Batch, - sequenceData: tt.sequenceData, - ethTransactions: tt.ethTransactions, - ethTxData: tt.ethTxData, - logger: log.GetDefaultLogger(), - } - - s.tryToSendSequence(context.Background()) - }) - } -} - -func Test_getSequencesToSend(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - sequenceList []uint64 - latestSentToL1Batch uint64 - forkUpgradeBatchNumber uint64 - sequenceData map[uint64]*sequenceData - getTxBuilder func(t *testing.T) *mocks.TxBuilderMock - expectedSequence seqsendertypes.Sequence - expectedErr error - }{ - { - name: "successfully get sequence", - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), nil) - return mngr - }, - expectedSequence: txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), - expectedErr: nil, - }, - { - name: "different coinbase", - sequenceList: []uint64{2, 3}, - latestSentToL1Batch: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - 3: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{ - LastCoinbase: common.HexToAddress("0x2"), - }), - }, - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil) - mngr.On("NewSequence", mock.Anything, mock.Anything, mock.Anything).Return(txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), nil) - return mngr - }, - expectedSequence: txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), - expectedErr: nil, - }, - { - name: "NewSequenceIfWorthToSend return error", - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, errors.New("test error")) - return mngr - }, - expectedErr: errors.New("test error"), - }, - { - name: "fork upgrade", - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - forkUpgradeBatchNumber: 2, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - mngr.On("NewSequenceIfWorthToSend", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil) - mngr.On("NewSequence", mock.Anything, mock.Anything, mock.Anything).Return(txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), nil) - return mngr - }, - expectedSequence: txbuilder.NewBananaSequence(etherman.SequenceBanana{ - Batches: []etherman.Batch{{ - BatchNumber: 2, - }}, - }), - expectedErr: nil, - }, - { - name: "fork upgrade passed", - sequenceList: []uint64{2}, - latestSentToL1Batch: 1, - forkUpgradeBatchNumber: 1, - sequenceData: map[uint64]*sequenceData{ - 2: { - batchClosed: true, - batch: txbuilder.NewBananaBatch(ðerman.Batch{}), - }, - }, - getTxBuilder: func(t *testing.T) *mocks.TxBuilderMock { - t.Helper() - - mngr := mocks.NewTxBuilderMock(t) - return mngr - }, - expectedErr: errors.New("aborting sequencing process as we reached the batch 2 where a new forkid is applied (upgrade)"), - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - ss := SequenceSender{ - sequenceList: tt.sequenceList, - latestSentToL1Batch: tt.latestSentToL1Batch, - cfg: Config{ - ForkUpgradeBatchNumber: tt.forkUpgradeBatchNumber, - }, - sequenceData: tt.sequenceData, - TxBuilder: tt.getTxBuilder(t), - logger: log.GetDefaultLogger(), - } - - sequence, err := ss.getSequencesToSend(context.Background()) - if tt.expectedErr != nil { - require.Equal(t, tt.expectedErr, err) - } else { - require.NoError(t, err) - require.Equal(t, tt.expectedSequence, sequence) - } - }) - } -} - -func Test_marginTimeElapsed(t *testing.T) { - t.Parallel() - - type args struct { - l2BlockTimestamp uint64 - currentTime uint64 - timeMargin int64 - } - tests := []struct { - name string - args args - expectedIsElapsed bool - expectedWaitTime int64 - }{ - { - name: "time elapsed", - args: args{ - l2BlockTimestamp: 100, - currentTime: 200, - timeMargin: 50, - }, - expectedIsElapsed: true, - expectedWaitTime: 0, - }, - { - name: "time not elapsed", - args: args{ - l2BlockTimestamp: 100, - currentTime: 200, - timeMargin: 150, - }, - expectedIsElapsed: false, - expectedWaitTime: 50, - }, - { - name: "l2 block in the future (time margin not enough)", - args: args{ - l2BlockTimestamp: 300, - currentTime: 200, - timeMargin: 50, - }, - expectedIsElapsed: true, - expectedWaitTime: 0, - }, - } - - for _, tt := range tests { - tt := tt - - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - - isElapsed, waitTime := marginTimeElapsed(tt.args.l2BlockTimestamp, tt.args.currentTime, tt.args.timeMargin) - require.Equal(t, tt.expectedIsElapsed, isElapsed, "marginTimeElapsed() isElapsed = %t, want %t", isElapsed, tt.expectedIsElapsed) - require.Equal(t, tt.expectedWaitTime, waitTime, "marginTimeElapsed() got1 = %v, want %v", waitTime, tt.expectedWaitTime) - }) - } -} diff --git a/sequencesender/txbuilder/banana_base.go b/sequencesender/txbuilder/banana_base.go deleted file mode 100644 index 67374415..00000000 --- a/sequencesender/txbuilder/banana_base.go +++ /dev/null @@ -1,247 +0,0 @@ -package txbuilder - -import ( - "context" - "errors" - "fmt" - "math/big" - - aggkitcommon "github.com/agglayer/aggkit/common" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/l1infotreesync" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -type rollupBananaBaseContractor interface { - LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) -} - -type globalExitRootBananaContractor interface { - L1InfoRootMap(opts *bind.CallOpts, index uint32) ([32]byte, error) - String() string -} - -type l1InfoSyncer interface { - GetLatestInfoUntilBlock(ctx context.Context, blockNum uint64) (*l1infotreesync.L1InfoTreeLeaf, error) - GetInitL1InfoRootMap(ctx context.Context) (*l1infotreesync.L1InfoTreeInitial, error) -} - -type l1Client interface { - HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) -} - -type TxBuilderBananaBase struct { - logger *log.Logger - rollupContract rollupBananaBaseContractor - globalExitRootContract globalExitRootBananaContractor - l1InfoTree l1InfoSyncer - ethClient l1Client - blockFinality *big.Int - opts bind.TransactOpts -} - -func NewTxBuilderBananaBase( - logger *log.Logger, - rollupContract rollupBananaBaseContractor, - gerContract globalExitRootBananaContractor, - l1InfoTree l1InfoSyncer, - ethClient l1Client, - blockFinality *big.Int, - opts bind.TransactOpts, -) *TxBuilderBananaBase { - return &TxBuilderBananaBase{ - logger: logger, - rollupContract: rollupContract, - globalExitRootContract: gerContract, - l1InfoTree: l1InfoTree, - ethClient: ethClient, - blockFinality: blockFinality, - opts: opts, - } -} - -func (t *TxBuilderBananaBase) NewBatchFromL2Block(l2Block *datastream.L2Block) seqsendertypes.Batch { - batch := ðerman.Batch{ - LastL2BLockTimestamp: l2Block.Timestamp, - BatchNumber: l2Block.BatchNumber, - L1InfoTreeIndex: l2Block.L1InfotreeIndex, - LastCoinbase: common.BytesToAddress(l2Block.Coinbase), - GlobalExitRoot: common.BytesToHash(l2Block.GlobalExitRoot), - } - return NewBananaBatch(batch) -} - -func getHighestL1InfoIndex(batches []etherman.Batch) uint32 { - var highestL1Index uint32 - for _, b := range batches { - if highestL1Index < b.L1InfoTreeIndex { - highestL1Index = b.L1InfoTreeIndex - } - } - return highestL1Index -} - -// Returns CounterL1InfoRoot to use for this batch -func (t *TxBuilderBananaBase) GetCounterL1InfoRoot(ctx context.Context, highestL1IndexInBatch uint32) (uint32, error) { - header, err := t.ethClient.HeaderByNumber(ctx, t.blockFinality) - if err != nil { - return 0, fmt.Errorf("error calling HeaderByNumber, with block finality %d: %w", t.blockFinality.Int64(), err) - } - var resL1InfoCounter uint32 - - info, err := t.l1InfoTree.GetLatestInfoUntilBlock(ctx, header.Number.Uint64()) - if err == nil { - resL1InfoCounter = info.L1InfoTreeIndex + 1 - } - if errors.Is(err, l1infotreesync.ErrNotFound) { - // There are no L1 Info tree leaves yet, so we can try to use L1InfoRootMap event - l1infotreeInitial, err := t.l1InfoTree.GetInitL1InfoRootMap(ctx) - if l1infotreeInitial == nil || err != nil { - return 0, fmt.Errorf("error no leaves on L1InfoTree yet and GetInitL1InfoRootMap fails: %w", err) - } - // We use this leaf as first one - resL1InfoCounter = l1infotreeInitial.LeafCount - } else if err != nil { - return 0, fmt.Errorf("error calling GetLatestInfoUntilBlock with block num %d: %w", header.Number.Uint64(), err) - } - // special case: there are no leaves in L1InfoTree yet - if resL1InfoCounter == 0 && highestL1IndexInBatch == 0 { - log.Infof("No L1 Info tree leaves yet, batch use no leaf") - return resL1InfoCounter, nil - } - if resL1InfoCounter > highestL1IndexInBatch { - return resL1InfoCounter, nil - } - - return 0, fmt.Errorf( - "sequence contained an L1 Info tree index (%d) that is greater than the one synced with the desired finality (%d)", - highestL1IndexInBatch, resL1InfoCounter, - ) -} - -func (t *TxBuilderBananaBase) CheckL1InfoTreeLeafCounterVsInitL1InfoMap(ctx context.Context, leafCounter uint32) error { - l1infotreeInitial, err := t.l1InfoTree.GetInitL1InfoRootMap(ctx) - if err != nil { - return fmt.Errorf("l1InfoTree.GetInitL1InfoRootMap fails: %w", err) - } - if l1infotreeInitial == nil { - log.Warnf("No InitL1InfoRootMap found, skipping check") - return nil - } - if leafCounter < l1infotreeInitial.LeafCount { - return fmt.Errorf("cant use this leafCounter because is previous to first value on contract Map"+ - "leafCounter(%d) < l1infotreeInitial.LeafCount(%d)", leafCounter, l1infotreeInitial.LeafCount) - } - return nil -} - -func (t *TxBuilderBananaBase) NewSequence( - ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address, -) (seqsendertypes.Sequence, error) { - ethBatches := toEthermanBatches(batches) - sequence := etherman.NewSequenceBanana(ethBatches, coinbase) - greatestL1Index := getHighestL1InfoIndex(sequence.Batches) - - counterL1InfoRoot, err := t.GetCounterL1InfoRoot(ctx, greatestL1Index) - if err != nil { - log.Errorf("error getting CounterL1InfoRoot: %s", err) - return nil, err - } - sequence.CounterL1InfoRoot = counterL1InfoRoot - l1InfoRoot, err := t.getL1InfoRoot(sequence.CounterL1InfoRoot) - if err != nil { - log.Errorf("error getting L1InfoRootMap: %s", err) - return nil, err - } - err = t.CheckL1InfoTreeLeafCounterVsInitL1InfoMap(ctx, sequence.CounterL1InfoRoot) - if err != nil { - log.Errorf("error checking L1InfoTreeLeafCounterVsInitL1InfoMap: %s", err) - return nil, err - } - sequence.L1InfoRoot = l1InfoRoot - - accInputHash, err := t.rollupContract.LastAccInputHash(&bind.CallOpts{Pending: false}) - if err != nil { - log.Errorf("error getting LastAccInputHash: %s", err) - return nil, err - } - - oldAccInputHash := common.BytesToHash(accInputHash[:]) // copy it - - for _, batch := range sequence.Batches { - infoRootHash := sequence.L1InfoRoot - timestamp := sequence.MaxSequenceTimestamp - blockHash := common.Hash{} - - if batch.ForcedBatchTimestamp > 0 { - infoRootHash = batch.ForcedGlobalExitRoot - timestamp = batch.ForcedBatchTimestamp - blockHash = batch.ForcedBlockHashL1 - } - - accInputHash = aggkitcommon.CalculateAccInputHash( - t.logger, accInputHash, batch.L2Data, infoRootHash, timestamp, batch.LastCoinbase, blockHash, - ) - } - - sequence.OldAccInputHash = oldAccInputHash - sequence.AccInputHash = accInputHash - res := NewBananaSequence(*sequence) - return res, nil -} - -func (t *TxBuilderBananaBase) getL1InfoRoot(counterL1InfoRoot uint32) (common.Hash, error) { - return t.globalExitRootContract.L1InfoRootMap(&bind.CallOpts{Pending: false}, counterL1InfoRoot) -} - -func convertToSequenceBanana(sequences seqsendertypes.Sequence) (etherman.SequenceBanana, error) { - seqEth, ok := sequences.(*BananaSequence) - if !ok { - log.Error("sequences is not a BananaSequence") - return etherman.SequenceBanana{}, fmt.Errorf("sequences is not a BananaSequence") - } - - ethermanSequence := etherman.SequenceBanana{ - OldAccInputHash: seqEth.SequenceBanana.OldAccInputHash, - AccInputHash: seqEth.SequenceBanana.AccInputHash, - L1InfoRoot: seqEth.SequenceBanana.L1InfoRoot, - MaxSequenceTimestamp: seqEth.SequenceBanana.MaxSequenceTimestamp, - CounterL1InfoRoot: seqEth.SequenceBanana.CounterL1InfoRoot, - L2Coinbase: seqEth.SequenceBanana.L2Coinbase, - } - - for _, batch := range sequences.Batches() { - ethBatch := toEthermanBatch(batch) - ethermanSequence.Batches = append(ethermanSequence.Batches, ethBatch) - } - - return ethermanSequence, nil -} - -func toEthermanBatch(batch seqsendertypes.Batch) etherman.Batch { - return etherman.Batch{ - L2Data: batch.L2Data(), - LastCoinbase: batch.LastCoinbase(), - ForcedGlobalExitRoot: batch.ForcedGlobalExitRoot(), - ForcedBlockHashL1: batch.ForcedBlockHashL1(), - ForcedBatchTimestamp: batch.ForcedBatchTimestamp(), - BatchNumber: batch.BatchNumber(), - L1InfoTreeIndex: batch.L1InfoTreeIndex(), - LastL2BLockTimestamp: batch.LastL2BLockTimestamp(), - GlobalExitRoot: batch.GlobalExitRoot(), - } -} - -func toEthermanBatches(batch []seqsendertypes.Batch) []etherman.Batch { - result := make([]etherman.Batch, len(batch)) - for i, b := range batch { - result[i] = toEthermanBatch(b) - } - - return result -} diff --git a/sequencesender/txbuilder/banana_base_test.go b/sequencesender/txbuilder/banana_base_test.go deleted file mode 100644 index fdf208f1..00000000 --- a/sequencesender/txbuilder/banana_base_test.go +++ /dev/null @@ -1,162 +0,0 @@ -package txbuilder_test - -import ( - "context" - "fmt" - "math/big" - "testing" - - "github.com/agglayer/aggkit/l1infotreesync" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestBananaBaseNewSequenceEmpty(t *testing.T) { - testData := newBananaBaseTestData(t) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.getContract.On("L1InfoRootMap", mock.Anything, uint32(70)). - Return([32]byte{}, nil) - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 69}, nil) - lastAcc := common.HexToHash("0x8aca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.rollupContract.EXPECT().LastAccInputHash(mock.Anything).Return(lastAcc, nil) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil) - seq, err := testData.sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NotNil(t, seq) - require.NoError(t, err) -} - -func TestBananaBaseNewSequenceErrorHeaderByNumber(t *testing.T) { - testData := newBananaBaseTestData(t) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(nil, fmt.Errorf("error")) - seq, err := testData.sut.NewSequence(context.TODO(), nil, common.Address{}) - require.Nil(t, seq) - require.Error(t, err) -} - -func TestBananaBaseNewBatchFromL2Block(t *testing.T) { - testData := newBananaBaseTestData(t) - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 2, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batch := testData.sut.NewBatchFromL2Block(l2Block) - require.NotNil(t, batch) - require.Equal(t, l2Block.Timestamp, batch.LastL2BLockTimestamp()) - require.Equal(t, l2Block.BatchNumber, batch.BatchNumber()) - require.Equal(t, l2Block.L1InfotreeIndex, batch.L1InfoTreeIndex()) - require.Equal(t, common.BytesToAddress(l2Block.Coinbase), batch.LastCoinbase()) - require.Equal(t, common.BytesToHash(l2Block.GlobalExitRoot), batch.GlobalExitRoot()) -} - -func TestBananaBaseNewSequenceBatch(t *testing.T) { - testData := newBananaBaseTestData(t) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 2, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil).Once() - - batch := testData.sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{batch} - lastAcc := common.HexToHash("0x8aca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.rollupContract.EXPECT().LastAccInputHash(mock.Anything).Return(lastAcc, nil) - l1infoRoot := common.HexToHash("0x66ca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 7}, nil) - testData.getContract.EXPECT().L1InfoRootMap(mock.Anything, uint32(8)).Return(l1infoRoot, nil) - - seq, err := testData.sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NotNil(t, seq) - require.NoError(t, err) - // TODO: check that the seq have the right values -} - -func TestBananaEmptyL1InfoTree(t *testing.T) { - testData := newBananaBaseTestData(t) - - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.l1InfoTreeSync.EXPECT().GetLatestInfoUntilBlock(testData.ctx, uint64(69)).Return(nil, l1infotreesync.ErrNotFound) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(testData.ctx).Return(&l1infotreesync.L1InfoTreeInitial{LeafCount: 10}, nil) - - leafCounter, err := testData.sut.GetCounterL1InfoRoot(testData.ctx, 0) - require.NoError(t, err) - require.Equal(t, uint32(10), leafCounter) -} - -func TestCheckL1InfoTreeLeafCounterVsInitL1InfoMap(t *testing.T) { - testData := newBananaBaseTestData(t) - - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(testData.ctx).Return(&l1infotreesync.L1InfoTreeInitial{LeafCount: 10}, nil) - err := testData.sut.CheckL1InfoTreeLeafCounterVsInitL1InfoMap(testData.ctx, 10) - require.NoError(t, err, "10 == 10 so is accepted") - - err = testData.sut.CheckL1InfoTreeLeafCounterVsInitL1InfoMap(testData.ctx, 9) - require.Error(t, err, "9 < 10 so is rejected") - - err = testData.sut.CheckL1InfoTreeLeafCounterVsInitL1InfoMap(testData.ctx, 11) - require.NoError(t, err, "11 > 10 so is accepted") -} - -func TestCheckL1InfoTreeLeafCounterVsInitL1InfoMapNotFound(t *testing.T) { - testData := newBananaBaseTestData(t) - - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(testData.ctx).Return(nil, nil) - err := testData.sut.CheckL1InfoTreeLeafCounterVsInitL1InfoMap(testData.ctx, 10) - require.NoError(t, err, "10 == 10 so is accepted") -} - -type testDataBananaBase struct { - rollupContract *mocks_txbuilder.RollupBananaBaseContractor - getContract *mocks_txbuilder.GlobalExitRootBananaContractor - opts bind.TransactOpts - sut *txbuilder.TxBuilderBananaBase - l1InfoTreeSync *mocks_txbuilder.L1InfoSyncer - l1Client *mocks_txbuilder.L1Client - ctx context.Context -} - -func newBananaBaseTestData(t *testing.T) *testDataBananaBase { - t.Helper() - - zkevmContractMock := mocks_txbuilder.NewRollupBananaBaseContractor(t) - gerContractMock := mocks_txbuilder.NewGlobalExitRootBananaContractor(t) - opts := bind.TransactOpts{} - l1Client := mocks_txbuilder.NewL1Client(t) - l1InfoSyncer := mocks_txbuilder.NewL1InfoSyncer(t) - sut := txbuilder.NewTxBuilderBananaBase( - log.GetDefaultLogger(), - zkevmContractMock, - gerContractMock, - l1InfoSyncer, l1Client, big.NewInt(0), opts, - ) - require.NotNil(t, sut) - return &testDataBananaBase{ - rollupContract: zkevmContractMock, - getContract: gerContractMock, - opts: opts, - sut: sut, - l1InfoTreeSync: l1InfoSyncer, - l1Client: l1Client, - ctx: context.TODO(), - } -} diff --git a/sequencesender/txbuilder/banana_types.go b/sequencesender/txbuilder/banana_types.go deleted file mode 100644 index 8b0cf5c8..00000000 --- a/sequencesender/txbuilder/banana_types.go +++ /dev/null @@ -1,184 +0,0 @@ -package txbuilder - -import ( - "fmt" - - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/state" - "github.com/ethereum/go-ethereum/common" -) - -type BananaBatch struct { - etherman.Batch -} - -type BananaSequence struct { - etherman.SequenceBanana -} - -func NewBananaBatch(batch *etherman.Batch) *BananaBatch { - return &BananaBatch{*batch} -} - -func NewBananaSequence(ult etherman.SequenceBanana) *BananaSequence { - return &BananaSequence{ult} -} - -func (b *BananaSequence) IndexL1InfoRoot() uint32 { - return b.SequenceBanana.CounterL1InfoRoot -} - -func (b *BananaSequence) MaxSequenceTimestamp() uint64 { - return b.SequenceBanana.MaxSequenceTimestamp -} - -func (b *BananaSequence) L1InfoRoot() common.Hash { - return b.SequenceBanana.L1InfoRoot -} - -func (b *BananaSequence) Batches() []seqsendertypes.Batch { - res := make([]seqsendertypes.Batch, len(b.SequenceBanana.Batches)) - for i, batch := range b.SequenceBanana.Batches { - res[i] = &BananaBatch{batch} - } - return res -} - -func (b *BananaSequence) FirstBatch() seqsendertypes.Batch { - return &BananaBatch{b.SequenceBanana.Batches[0]} -} - -func (b *BananaSequence) LastBatch() seqsendertypes.Batch { - return &BananaBatch{b.SequenceBanana.Batches[b.Len()-1]} -} - -func (b *BananaSequence) Len() int { - return len(b.SequenceBanana.Batches) -} - -func (b *BananaSequence) String() string { - res := fmt.Sprintf( - "Seq/Banana: L2Coinbase: %s, OldAccInputHash: %x, AccInputHash: %x, L1InfoRoot: %x, "+ - "MaxSequenceTimestamp: %d, IndexL1InfoRoot: %d", - b.L2Coinbase().String(), b.OldAccInputHash.String(), b.AccInputHash.String(), b.L1InfoRoot().String(), - b.MaxSequenceTimestamp(), b.IndexL1InfoRoot(), - ) - - for i, batch := range b.Batches() { - res += fmt.Sprintf("\n\tBatch %d: %s", i, batch.String()) - } - return res -} - -func (b *BananaSequence) L2Coinbase() common.Address { - return b.SequenceBanana.L2Coinbase -} - -func (b *BananaBatch) LastCoinbase() common.Address { - return b.Batch.LastCoinbase -} - -func (b *BananaBatch) ForcedBatchTimestamp() uint64 { - return b.Batch.ForcedBatchTimestamp -} - -func (b *BananaBatch) ForcedGlobalExitRoot() common.Hash { - return b.Batch.ForcedGlobalExitRoot -} - -func (b *BananaBatch) ForcedBlockHashL1() common.Hash { - return b.Batch.ForcedBlockHashL1 -} - -func (b *BananaBatch) L2Data() []byte { - return b.Batch.L2Data -} - -func (b *BananaBatch) LastL2BLockTimestamp() uint64 { - return b.Batch.LastL2BLockTimestamp -} - -func (b *BananaBatch) BatchNumber() uint64 { - return b.Batch.BatchNumber -} - -func (b BananaBatch) DeepCopy() seqsendertypes.Batch { - return &BananaBatch{b.Batch} -} - -func (b *BananaBatch) SetL2Data(data []byte) { - b.Batch.L2Data = data -} - -func (b *BananaBatch) SetLastCoinbase(address common.Address) { - b.Batch.LastCoinbase = address -} - -func (b *BananaBatch) SetLastL2BLockTimestamp(ts uint64) { - b.Batch.LastL2BLockTimestamp = ts -} - -func (b *BananaBatch) SetL1InfoTreeIndex(index uint32) { - b.Batch.L1InfoTreeIndex = index -} - -func (b *BananaBatch) GlobalExitRoot() common.Hash { - return b.Batch.GlobalExitRoot -} - -func (b *BananaBatch) L1InfoTreeIndex() uint32 { - return b.Batch.L1InfoTreeIndex -} - -func (b *BananaBatch) String() string { - return fmt.Sprintf("Batch/Banana: LastCoinbase: %s, ForcedBatchTimestamp: %d, ForcedGlobalExitRoot: %x, "+ - "ForcedBlockHashL1: %x, L2Data: %x, LastL2BLockTimestamp: %d, BatchNumber: %d, "+ - "GlobalExitRoot: %x, L1InfoTreeIndex: %d", - b.LastCoinbase().String(), b.ForcedBatchTimestamp(), b.ForcedGlobalExitRoot().String(), - b.ForcedBlockHashL1().String(), b.L2Data(), b.LastL2BLockTimestamp(), b.BatchNumber(), - b.GlobalExitRoot().String(), b.L1InfoTreeIndex(), - ) -} - -func (b *BananaSequence) LastVirtualBatchNumber() uint64 { - return b.SequenceBanana.LastVirtualBatchNumber -} - -func (b *BananaSequence) SetLastVirtualBatchNumber(batchNumber uint64) { - b.SequenceBanana.LastVirtualBatchNumber = batchNumber -} - -func calculateMaxL1InfoTreeIndexInsideL2Data(l2data []byte) (uint32, error) { - batchRawV2, err := state.DecodeBatchV2(l2data) - if err != nil { - return 0, fmt.Errorf("calculateMaxL1InfoTreeIndexInsideL2Data: error decoding batchL2Data, err:%w", err) - } - if batchRawV2 == nil { - return 0, fmt.Errorf("calculateMaxL1InfoTreeIndexInsideL2Data: batchRawV2 is nil") - } - maxIndex := uint32(0) - for _, block := range batchRawV2.Blocks { - if block.IndexL1InfoTree > maxIndex { - maxIndex = block.IndexL1InfoTree - } - } - return maxIndex, nil -} - -func calculateMaxL1InfoTreeIndexInsideSequence(seq *etherman.SequenceBanana) (uint32, error) { - if seq == nil { - return 0, fmt.Errorf("calculateMaxL1InfoTreeIndexInsideSequence: seq is nil") - } - maxIndex := uint32(0) - for _, batch := range seq.Batches { - index, err := calculateMaxL1InfoTreeIndexInsideL2Data(batch.L2Data) - if err != nil { - return 0, fmt.Errorf("calculateMaxL1InfoTreeIndexInsideBatches: error getting batch L1InfoTree , err:%w", err) - } - if index > maxIndex { - maxIndex = index - } - } - return maxIndex, nil -} diff --git a/sequencesender/txbuilder/banana_validium.go b/sequencesender/txbuilder/banana_validium.go deleted file mode 100644 index 69a94536..00000000 --- a/sequencesender/txbuilder/banana_validium.go +++ /dev/null @@ -1,153 +0,0 @@ -package txbuilder - -import ( - "context" - "fmt" - "math/big" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygonvalidiumetrog" - "github.com/agglayer/aggkit/dataavailability" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "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" -) - -type TxBuilderBananaValidium struct { - TxBuilderBananaBase - da dataavailability.SequenceSenderBanana - condNewSeq CondNewSequence - rollupContract rollupBananaValidiumContractor -} - -type rollupBananaValidiumContractor interface { - rollupBananaBaseContractor - SequenceBatchesValidium( - opts *bind.TransactOpts, - batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, - indexL1InfoRoot uint32, - maxSequenceTimestamp uint64, - expectedFinalAccInputHash [32]byte, - l2Coinbase common.Address, - dataAvailabilityMessage []byte, - ) (*types.Transaction, error) -} - -func NewTxBuilderBananaValidium( - logger *log.Logger, - rollupContract rollupBananaValidiumContractor, - gerContract globalExitRootBananaContractor, - da dataavailability.SequenceSenderBanana, opts bind.TransactOpts, maxBatchesForL1 uint64, - l1InfoTree l1InfoSyncer, - ethClient l1Client, - blockFinality *big.Int, -) *TxBuilderBananaValidium { - txBuilderBase := *NewTxBuilderBananaBase(logger, rollupContract, - gerContract, l1InfoTree, ethClient, blockFinality, opts) - - return &TxBuilderBananaValidium{ - TxBuilderBananaBase: txBuilderBase, - da: da, - condNewSeq: NewConditionalNewSequenceNumBatches(maxBatchesForL1), - rollupContract: rollupContract, - } -} - -func (t *TxBuilderBananaValidium) NewSequenceIfWorthToSend( - ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64, -) (seqsendertypes.Sequence, error) { - return t.condNewSeq.NewSequenceIfWorthToSend(ctx, t, sequenceBatches, l2Coinbase) -} - -// SetCondNewSeq allow to override the default conditional for new sequence -func (t *TxBuilderBananaValidium) SetCondNewSeq(cond CondNewSequence) CondNewSequence { - previous := t.condNewSeq - t.condNewSeq = cond - return previous -} - -func (t *TxBuilderBananaValidium) BuildSequenceBatchesTx( - ctx context.Context, sequences seqsendertypes.Sequence, -) (*types.Transaction, error) { - // TODO: param sender - // Post sequences to DA backend - var dataAvailabilityMessage []byte - var err error - ethseq, err := convertToSequenceBanana(sequences) - if err != nil { - t.logger.Error("error converting sequences to etherman: ", err) - return nil, err - } - - dataAvailabilityMessage, err = t.da.PostSequenceBanana(ctx, ethseq) - if err != nil { - t.logger.Error("error posting sequences to the data availability protocol: ", err) - return nil, err - } - if dataAvailabilityMessage == nil { - err := fmt.Errorf("data availability message is nil") - t.logger.Error("error posting sequences to the data availability protocol: ", err.Error()) - return nil, err - } - - // Build sequence data - tx, err := t.internalBuildSequenceBatchesTx(ethseq, dataAvailabilityMessage) - if err != nil { - t.logger.Errorf("error estimating new sequenceBatches to add to ethtxmanager: ", err) - return nil, err - } - return tx, nil -} - -// BuildSequenceBatchesTx builds a tx to be sent to the PoE SC method SequenceBatches. -func (t *TxBuilderBananaValidium) internalBuildSequenceBatchesTx(sequence etherman.SequenceBanana, - dataAvailabilityMessage []byte) (*types.Transaction, error) { - newopts := t.opts - newopts.NoSend = true - - // force nonce, gas limit and gas price to avoid querying it from the chain - newopts.Nonce = big.NewInt(1) - newopts.GasLimit = uint64(1) - newopts.GasPrice = big.NewInt(1) - - return t.sequenceBatchesValidium(newopts, sequence, dataAvailabilityMessage) -} - -func (t *TxBuilderBananaValidium) sequenceBatchesValidium( - opts bind.TransactOpts, sequence etherman.SequenceBanana, dataAvailabilityMessage []byte, -) (*types.Transaction, error) { - batches := make([]polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, len(sequence.Batches)) - for i, batch := range sequence.Batches { - var ger common.Hash - if batch.ForcedBatchTimestamp > 0 { - ger = batch.ForcedGlobalExitRoot - } - - batches[i] = polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData{ - TransactionsHash: crypto.Keccak256Hash(batch.L2Data), - ForcedGlobalExitRoot: ger, - ForcedTimestamp: batch.ForcedBatchTimestamp, - ForcedBlockHashL1: batch.ForcedBlockHashL1, - } - } - - t.logger.Infof("building banana sequence tx. AccInputHash: %s", sequence.AccInputHash.Hex()) - tx, err := t.rollupContract.SequenceBatchesValidium( - &opts, batches, sequence.CounterL1InfoRoot, sequence.MaxSequenceTimestamp, - sequence.AccInputHash, sequence.L2Coinbase, dataAvailabilityMessage, - ) - if err != nil { - t.logger.Debugf("Batches to send: %+v", batches) - t.logger.Debug("l2CoinBase: ", sequence.L2Coinbase) - t.logger.Debug("Sequencer address: ", opts.From) - } - - return tx, err -} - -func (t *TxBuilderBananaValidium) String() string { - return "Banana/Validium" -} diff --git a/sequencesender/txbuilder/banana_validium_test.go b/sequencesender/txbuilder/banana_validium_test.go deleted file mode 100644 index 390522a2..00000000 --- a/sequencesender/txbuilder/banana_validium_test.go +++ /dev/null @@ -1,139 +0,0 @@ -package txbuilder_test - -import ( - "context" - "fmt" - "math/big" - "strings" - "testing" - - "github.com/agglayer/aggkit/dataavailability/mocks_da" - "github.com/agglayer/aggkit/l1infotreesync" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestBananaValidiumName(t *testing.T) { - testData := newBananaValidiumTestData(t, txbuilder.MaxBatchesForL1Disabled) - require.NotNil(t, testData.sut) - require.True(t, strings.Contains(testData.sut.String(), "Banana")) - require.True(t, strings.Contains(testData.sut.String(), "Validium")) -} - -func TestBananaValidiumBuildSequenceBatchesTxSequenceErrorsFromDA(t *testing.T) { - testData := newBananaValidiumTestData(t, txbuilder.MaxBatchesForL1Disabled) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 7}, nil) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil) - - seq, err := newSequenceBananaValidiumForTest(testData) - require.NoError(t, err) - ctx := context.TODO() - testData.da.EXPECT().PostSequenceBanana(ctx, mock.Anything).Return(nil, nil).Once() - - _, err = testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err, "data availability message is nil") - - testData.da.EXPECT().PostSequenceBanana(ctx, mock.Anything).Return(nil, fmt.Errorf("test error")) - _, err = testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err, "error posting sequences to the data availability protocol: test error") -} - -func TestBananaValidiumBuildSequenceBatchesTxSequenceDAOk(t *testing.T) { - testData := newBananaValidiumTestData(t, txbuilder.MaxBatchesForL1Disabled) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 7}, nil) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil) - - seq, err := newSequenceBananaValidiumForTest(testData) - require.NoError(t, err) - ctx := context.TODO() - daMessage := []byte{1} - testData.da.EXPECT().PostSequenceBanana(ctx, mock.Anything).Return(daMessage, nil) - inner := &types.LegacyTx{} - seqBatchesTx := types.NewTx(inner) - testData.rollupContract.EXPECT().SequenceBatchesValidium(mock.MatchedBy(func(opts *bind.TransactOpts) bool { - return opts.NoSend == true - }), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, daMessage).Return(seqBatchesTx, nil).Once() - tx, err := testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.NoError(t, err) - require.Equal(t, seqBatchesTx, tx) -} - -type testDataBananaValidium struct { - rollupContract *mocks_txbuilder.RollupBananaValidiumContractor - getContract *mocks_txbuilder.GlobalExitRootBananaContractor - cond *mocks_txbuilder.CondNewSequence - da *mocks_da.SequenceSenderBanana - opts bind.TransactOpts - sut *txbuilder.TxBuilderBananaValidium - l1InfoTreeSync *mocks_txbuilder.L1InfoSyncer - l1Client *mocks_txbuilder.L1Client -} - -func newBananaValidiumTestData(t *testing.T, maxBatchesForL1 uint64) *testDataBananaValidium { - t.Helper() - - zkevmContractMock := mocks_txbuilder.NewRollupBananaValidiumContractor(t) - gerContractMock := mocks_txbuilder.NewGlobalExitRootBananaContractor(t) - condMock := mocks_txbuilder.NewCondNewSequence(t) - daMock := mocks_da.NewSequenceSenderBanana(t) - l1Client := mocks_txbuilder.NewL1Client(t) - l1InfoSyncer := mocks_txbuilder.NewL1InfoSyncer(t) - - opts := bind.TransactOpts{} - sut := txbuilder.NewTxBuilderBananaValidium( - log.GetDefaultLogger(), - zkevmContractMock, - gerContractMock, - daMock, - opts, - maxBatchesForL1, - l1InfoSyncer, - l1Client, - big.NewInt(0), - ) - require.NotNil(t, sut) - sut.SetCondNewSeq(condMock) - return &testDataBananaValidium{ - rollupContract: zkevmContractMock, - getContract: gerContractMock, - cond: condMock, - da: daMock, - opts: opts, - sut: sut, - l1InfoTreeSync: l1InfoSyncer, - l1Client: l1Client, - } -} - -func newSequenceBananaValidiumForTest(testData *testDataBananaValidium) (seqsendertypes.Sequence, error) { - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batch := testData.sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batch, - } - lastAcc := common.HexToHash("0x8aca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.rollupContract.EXPECT().LastAccInputHash(mock.Anything).Return(lastAcc, nil).Once() - l1infoRoot := common.HexToHash("0x66ca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.getContract.EXPECT().L1InfoRootMap(mock.Anything, uint32(8)).Return(l1infoRoot, nil).Once() - return testData.sut.NewSequence(context.TODO(), batches, common.Address{}) -} diff --git a/sequencesender/txbuilder/banana_zkevm.go b/sequencesender/txbuilder/banana_zkevm.go deleted file mode 100644 index 1151fcdf..00000000 --- a/sequencesender/txbuilder/banana_zkevm.go +++ /dev/null @@ -1,128 +0,0 @@ -package txbuilder - -import ( - "context" - "math/big" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygonvalidiumetrog" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -type TxBuilderBananaZKEVM struct { - TxBuilderBananaBase - condNewSeq CondNewSequence - rollupContract rollupBananaZKEVMContractor -} - -type rollupBananaZKEVMContractor interface { - rollupBananaBaseContractor - SequenceBatches( - opts *bind.TransactOpts, - batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, - indexL1InfoRoot uint32, - maxSequenceTimestamp uint64, - expectedFinalAccInputHash [32]byte, - l2Coinbase common.Address, - ) (*types.Transaction, error) -} - -type globalExitRootBananaZKEVMContractor interface { - globalExitRootBananaContractor -} - -func NewTxBuilderBananaZKEVM( - logger *log.Logger, - rollupContract rollupBananaZKEVMContractor, - gerContract globalExitRootBananaZKEVMContractor, - opts bind.TransactOpts, - maxTxSizeForL1 uint64, - l1InfoTree l1InfoSyncer, - ethClient l1Client, - blockFinality *big.Int, -) *TxBuilderBananaZKEVM { - txBuilderBase := *NewTxBuilderBananaBase(logger, rollupContract, - gerContract, l1InfoTree, ethClient, blockFinality, opts) - - return &TxBuilderBananaZKEVM{ - TxBuilderBananaBase: txBuilderBase, - condNewSeq: NewConditionalNewSequenceMaxSize(maxTxSizeForL1), - rollupContract: rollupContract, - } -} - -func (t *TxBuilderBananaZKEVM) NewSequenceIfWorthToSend( - ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64, -) (seqsendertypes.Sequence, error) { - return t.condNewSeq.NewSequenceIfWorthToSend(ctx, t, sequenceBatches, l2Coinbase) -} - -// SetCondNewSeq allow to override the default conditional for new sequence -func (t *TxBuilderBananaZKEVM) SetCondNewSeq(cond CondNewSequence) CondNewSequence { - previous := t.condNewSeq - t.condNewSeq = cond - return previous -} - -func (t *TxBuilderBananaZKEVM) BuildSequenceBatchesTx( - ctx context.Context, sequences seqsendertypes.Sequence, -) (*types.Transaction, error) { - var err error - ethseq, err := convertToSequenceBanana(sequences) - if err != nil { - t.logger.Error("error converting sequences to etherman: ", err) - return nil, err - } - newopts := t.opts - newopts.NoSend = true - - // force nonce, gas limit and gas price to avoid querying it from the chain - newopts.Nonce = big.NewInt(1) - newopts.GasLimit = uint64(1) - newopts.GasPrice = big.NewInt(1) - // Build sequence data - tx, err := t.sequenceBatchesRollup(newopts, ethseq) - if err != nil { - t.logger.Errorf("error estimating new sequenceBatches to add to ethtxmanager: ", err) - return nil, err - } - return tx, nil -} - -func (t *TxBuilderBananaZKEVM) sequenceBatchesRollup( - opts bind.TransactOpts, sequence etherman.SequenceBanana, -) (*types.Transaction, error) { - batches := make([]polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, len(sequence.Batches)) - for i, batch := range sequence.Batches { - var ger common.Hash - if batch.ForcedBatchTimestamp > 0 { - ger = batch.ForcedGlobalExitRoot - } - - batches[i] = polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData{ - Transactions: batch.L2Data, - ForcedGlobalExitRoot: ger, - ForcedTimestamp: batch.ForcedBatchTimestamp, - ForcedBlockHashL1: batch.ForcedBlockHashL1, - } - } - - tx, err := t.rollupContract.SequenceBatches( - &opts, batches, sequence.CounterL1InfoRoot, sequence.MaxSequenceTimestamp, sequence.AccInputHash, sequence.L2Coinbase, - ) - if err != nil { - t.logger.Debugf("Batches to send: %+v", batches) - t.logger.Debug("l2CoinBase: ", sequence.L2Coinbase) - t.logger.Debug("Sequencer address: ", opts.From) - } - - return tx, err -} - -func (t *TxBuilderBananaZKEVM) String() string { - return "Banana/ZKEVM" -} diff --git a/sequencesender/txbuilder/banana_zkevm_test.go b/sequencesender/txbuilder/banana_zkevm_test.go deleted file mode 100644 index a05d23c4..00000000 --- a/sequencesender/txbuilder/banana_zkevm_test.go +++ /dev/null @@ -1,137 +0,0 @@ -package txbuilder_test - -import ( - "context" - "fmt" - "math/big" - "strings" - "testing" - - "github.com/agglayer/aggkit/l1infotreesync" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestBananaZkevmName(t *testing.T) { - testData := newBananaZKEVMTestData(t, txbuilder.MaxTxSizeForL1Disabled) - require.True(t, strings.Contains(testData.sut.String(), "Banana")) - require.True(t, strings.Contains(testData.sut.String(), "ZKEVM")) -} - -func TestBananaZkevmNewSequenceIfWorthToSend(t *testing.T) { - testData := newBananaZKEVMTestData(t, txbuilder.MaxTxSizeForL1Disabled) - - testSequenceIfWorthToSendNoNewSeq(t, testData.sut) - testSequenceIfWorthToSendErr(t, testData.sut) - testSetCondNewSeq(t, testData.sut) -} - -func TestBananaZkevmBuildSequenceBatchesTxOk(t *testing.T) { - testData := newBananaZKEVMTestData(t, txbuilder.MaxTxSizeForL1Disabled) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 7}, nil) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil) - - seq, err := newSequenceBananaZKEVMForTest(testData) - require.NoError(t, err) - - inner := &types.LegacyTx{} - tx := types.NewTx(inner) - - // It check that SequenceBatches is not going to be send - testData.rollupContract.EXPECT().SequenceBatches(mock.MatchedBy(func(opts *bind.TransactOpts) bool { - return opts.NoSend == true - }), mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tx, nil).Once() - returnTx, err := testData.sut.BuildSequenceBatchesTx(context.TODO(), seq) - require.NoError(t, err) - require.Equal(t, tx, returnTx) -} - -func TestBananaZkevmBuildSequenceBatchesTxErr(t *testing.T) { - testData := newBananaZKEVMTestData(t, txbuilder.MaxTxSizeForL1Disabled) - testData.l1Client.On("HeaderByNumber", mock.Anything, mock.Anything). - Return(&types.Header{Number: big.NewInt(69)}, nil) - testData.l1InfoTreeSync.On("GetLatestInfoUntilBlock", mock.Anything, mock.Anything). - Return(&l1infotreesync.L1InfoTreeLeaf{L1InfoTreeIndex: 7}, nil) - testData.l1InfoTreeSync.EXPECT().GetInitL1InfoRootMap(mock.Anything).Return(nil, nil) - - seq, err := newSequenceBananaZKEVMForTest(testData) - require.NoError(t, err) - - err = fmt.Errorf("test-error") - testData.rollupContract.EXPECT().SequenceBatches(mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, err).Once() - returnedTx, returnedErr := testData.sut.BuildSequenceBatchesTx(context.TODO(), seq) - require.ErrorContains(t, returnedErr, err.Error()) - require.Nil(t, returnedTx) -} - -type testDataBananaZKEVM struct { - rollupContract *mocks_txbuilder.RollupBananaZKEVMContractor - getContract *mocks_txbuilder.GlobalExitRootBananaContractor - cond *mocks_txbuilder.CondNewSequence - opts bind.TransactOpts - sut *txbuilder.TxBuilderBananaZKEVM - l1InfoTreeSync *mocks_txbuilder.L1InfoSyncer - l1Client *mocks_txbuilder.L1Client -} - -func newBananaZKEVMTestData(t *testing.T, maxTxSizeForL1 uint64) *testDataBananaZKEVM { - t.Helper() - - zkevmContractMock := mocks_txbuilder.NewRollupBananaZKEVMContractor(t) - gerContractMock := mocks_txbuilder.NewGlobalExitRootBananaContractor(t) - condMock := mocks_txbuilder.NewCondNewSequence(t) - opts := bind.TransactOpts{} - l1Client := mocks_txbuilder.NewL1Client(t) - l1InfoSyncer := mocks_txbuilder.NewL1InfoSyncer(t) - sut := txbuilder.NewTxBuilderBananaZKEVM( - log.GetDefaultLogger(), - zkevmContractMock, - gerContractMock, - opts, - maxTxSizeForL1, - l1InfoSyncer, - l1Client, - big.NewInt(0), - ) - require.NotNil(t, sut) - sut.SetCondNewSeq(condMock) - return &testDataBananaZKEVM{ - rollupContract: zkevmContractMock, - getContract: gerContractMock, - cond: condMock, - opts: opts, - sut: sut, - l1InfoTreeSync: l1InfoSyncer, - l1Client: l1Client, - } -} - -func newSequenceBananaZKEVMForTest(testData *testDataBananaZKEVM) (seqsendertypes.Sequence, error) { - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batch := testData.sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batch, - } - lastAcc := common.HexToHash("0x8aca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.rollupContract.EXPECT().LastAccInputHash(mock.Anything).Return(lastAcc, nil).Once() - l1infoRoot := common.HexToHash("0x66ca9664752dbae36135fd0956c956fc4a370feeac67485b49bcd4b99608ae41") - testData.getContract.EXPECT().L1InfoRootMap(mock.Anything, uint32(8)).Return(l1infoRoot, nil).Once() - return testData.sut.NewSequence(context.TODO(), batches, common.Address{}) -} diff --git a/sequencesender/txbuilder/elderberry_base.go b/sequencesender/txbuilder/elderberry_base.go deleted file mode 100644 index f8d8b307..00000000 --- a/sequencesender/txbuilder/elderberry_base.go +++ /dev/null @@ -1,63 +0,0 @@ -package txbuilder - -import ( - "context" - - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" -) - -type TxBuilderElderberryBase struct { - logger *log.Logger - opts bind.TransactOpts -} - -func NewTxBuilderElderberryBase(logger *log.Logger, opts bind.TransactOpts) *TxBuilderElderberryBase { - return &TxBuilderElderberryBase{ - logger: logger, - opts: opts, - } -} - -// SetAuth sets the auth for the tx builder -func (t *TxBuilderElderberryBase) SetAuth(auth *bind.TransactOpts) { - t.opts = *auth -} - -func (t *TxBuilderElderberryBase) NewSequence( - ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address, -) (seqsendertypes.Sequence, error) { - seq := ElderberrySequence{ - l2Coinbase: coinbase, - batches: batches, - } - return &seq, nil -} - -func (t *TxBuilderElderberryBase) NewBatchFromL2Block(l2Block *datastream.L2Block) seqsendertypes.Batch { - batch := ðerman.Batch{ - LastL2BLockTimestamp: l2Block.Timestamp, - BatchNumber: l2Block.BatchNumber, - L1InfoTreeIndex: l2Block.L1InfotreeIndex, - LastCoinbase: common.BytesToAddress(l2Block.Coinbase), - GlobalExitRoot: common.BytesToHash(l2Block.GlobalExitRoot), - } - return NewBananaBatch(batch) -} - -func getLastSequencedBatchNumber(sequences seqsendertypes.Sequence) uint64 { - if sequences.Len() == 0 { - return 0 - } - if sequences.FirstBatch().BatchNumber() == 0 { - panic("First batch number is 0, that is not allowed!") - } - if sequences.LastVirtualBatchNumber() != 0 { - return sequences.LastVirtualBatchNumber() - } - return sequences.FirstBatch().BatchNumber() - 1 -} diff --git a/sequencesender/txbuilder/elderberry_base_test.go b/sequencesender/txbuilder/elderberry_base_test.go deleted file mode 100644 index 46a16148..00000000 --- a/sequencesender/txbuilder/elderberry_base_test.go +++ /dev/null @@ -1,101 +0,0 @@ -package txbuilder - -import ( - "context" - "testing" - - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/require" -) - -func TestElderberryBaseNewSequence(t *testing.T) { - opts := bind.TransactOpts{} - sut := NewTxBuilderElderberryBase(log.GetDefaultLogger(), opts) - require.NotNil(t, sut) - seq, err := sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NotNil(t, seq) - require.NoError(t, err) -} - -func TestElderberryBaseNewBatchFromL2Block(t *testing.T) { - sut := newElderberryBaseSUT(t) - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 2, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batch := sut.NewBatchFromL2Block(l2Block) - require.NotNil(t, batch) - require.Equal(t, l2Block.Timestamp, batch.LastL2BLockTimestamp()) - require.Equal(t, l2Block.BatchNumber, batch.BatchNumber()) - require.Equal(t, l2Block.L1InfotreeIndex, batch.L1InfoTreeIndex()) - require.Equal(t, common.BytesToAddress(l2Block.Coinbase), batch.LastCoinbase()) - require.Equal(t, common.BytesToHash(l2Block.GlobalExitRoot), batch.GlobalExitRoot()) -} - -func TestElderberryBasegetLastSequencedBatchNumberEmpty(t *testing.T) { - sut := newElderberryBaseSUT(t) - seq, err := sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NoError(t, err) - - require.Equal(t, uint64(0), getLastSequencedBatchNumber(seq)) -} - -func TestElderberryBasegetLastSequencedBatch1Batch(t *testing.T) { - sut := newElderberryBaseSUT(t) - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 2, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - - seq, err := sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - - require.Equal(t, l2Block.BatchNumber-1, getLastSequencedBatchNumber(seq)) -} - -func TestElderberryBaseGetLastSequencedBatchFirstBatchIsZeroThrowAPanic(t *testing.T) { - sut := newElderberryBaseSUT(t) - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 0, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - - seq, err := sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - defer func() { - if r := recover(); r == nil { - t.Errorf("The code did not panic") - } - }() - getLastSequencedBatchNumber(seq) -} - -func newElderberryBaseSUT(t *testing.T) *TxBuilderElderberryBase { - t.Helper() - - opts := bind.TransactOpts{} - sut := NewTxBuilderElderberryBase(log.GetDefaultLogger(), opts) - require.NotNil(t, sut) - return sut -} diff --git a/sequencesender/txbuilder/elderberry_types.go b/sequencesender/txbuilder/elderberry_types.go deleted file mode 100644 index 8800ab21..00000000 --- a/sequencesender/txbuilder/elderberry_types.go +++ /dev/null @@ -1,72 +0,0 @@ -package txbuilder - -import ( - "fmt" - "log" - - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/ethereum/go-ethereum/common" -) - -type ElderberrySequence struct { - l2Coinbase common.Address - batches []seqsendertypes.Batch - lastVirtualBatchNumber uint64 -} - -func NewElderberrySequence(batches []seqsendertypes.Batch, l2Coinbase common.Address) *ElderberrySequence { - return &ElderberrySequence{ - l2Coinbase: l2Coinbase, - batches: batches, - } -} - -func (b *ElderberrySequence) IndexL1InfoRoot() uint32 { - log.Fatal("Elderberry Sequence does not have IndexL1InfoRoot") - return 0 -} - -func (b *ElderberrySequence) MaxSequenceTimestamp() uint64 { - return b.LastBatch().LastL2BLockTimestamp() -} - -func (b *ElderberrySequence) L1InfoRoot() common.Hash { - log.Fatal("Elderberry Sequence does not have L1InfoRoot") - return common.Hash{} -} - -func (b *ElderberrySequence) Batches() []seqsendertypes.Batch { - return b.batches -} - -func (b *ElderberrySequence) FirstBatch() seqsendertypes.Batch { - return b.batches[0] -} - -func (b *ElderberrySequence) LastBatch() seqsendertypes.Batch { - return b.batches[b.Len()-1] -} - -func (b *ElderberrySequence) Len() int { - return len(b.batches) -} - -func (b *ElderberrySequence) L2Coinbase() common.Address { - return b.l2Coinbase -} - -func (b *ElderberrySequence) String() string { - res := fmt.Sprintf("Seq/Elderberry: L2Coinbase: %s, Batches: %d", b.l2Coinbase.String(), len(b.batches)) - for i, batch := range b.Batches() { - res += fmt.Sprintf("\n\tBatch %d: %s", i, batch.String()) - } - return res -} - -func (b *ElderberrySequence) SetLastVirtualBatchNumber(batchNumber uint64) { - b.lastVirtualBatchNumber = batchNumber -} - -func (b *ElderberrySequence) LastVirtualBatchNumber() uint64 { - return b.lastVirtualBatchNumber -} diff --git a/sequencesender/txbuilder/elderberry_validium.go b/sequencesender/txbuilder/elderberry_validium.go deleted file mode 100644 index ff0cf693..00000000 --- a/sequencesender/txbuilder/elderberry_validium.go +++ /dev/null @@ -1,134 +0,0 @@ -package txbuilder - -import ( - "context" - "encoding/hex" - "fmt" - "math/big" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - "github.com/agglayer/aggkit/dataavailability" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/etherman/contracts" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "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" -) - -type TxBuilderElderberryValidium struct { - TxBuilderElderberryBase - da dataavailability.SequenceSenderElderberry - condNewSeq CondNewSequence - rollupContract rollupElderberryValidiumContractor -} - -type rollupElderberryValidiumContractor interface { - SequenceBatchesValidium( - opts *bind.TransactOpts, - batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, - maxSequenceTimestamp uint64, - initSequencedBatch uint64, - l2Coinbase common.Address, - dataAvailabilityMessage []byte, - ) (*types.Transaction, error) -} - -func NewTxBuilderElderberryValidium( - logger *log.Logger, - zkevm contracts.RollupElderberryType, - da dataavailability.SequenceSenderElderberry, - opts bind.TransactOpts, maxBatchesForL1 uint64) *TxBuilderElderberryValidium { - return &TxBuilderElderberryValidium{ - da: da, - TxBuilderElderberryBase: *NewTxBuilderElderberryBase(logger, opts), - condNewSeq: NewConditionalNewSequenceNumBatches(maxBatchesForL1), - rollupContract: zkevm, - } -} -func (t *TxBuilderElderberryValidium) NewSequenceIfWorthToSend( - ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64, -) (seqsendertypes.Sequence, error) { - return t.condNewSeq.NewSequenceIfWorthToSend(ctx, t, sequenceBatches, l2Coinbase) -} - -// SetCondNewSeq allow to override the default conditional for new sequence -func (t *TxBuilderElderberryValidium) SetCondNewSeq(cond CondNewSequence) CondNewSequence { - previous := t.condNewSeq - t.condNewSeq = cond - return previous -} - -func (t *TxBuilderElderberryValidium) BuildSequenceBatchesTx( - ctx context.Context, sequences seqsendertypes.Sequence, -) (*types.Transaction, error) { - if sequences == nil || sequences.Len() == 0 { - return nil, fmt.Errorf("can't sequence an empty sequence") - } - batchesData := convertToBatchesData(sequences) - dataAvailabilityMessage, err := t.da.PostSequenceElderberry(ctx, batchesData) - if err != nil { - t.logger.Error("error posting sequences to the data availability protocol: ", err) - return nil, err - } - if dataAvailabilityMessage == nil { - err := fmt.Errorf("data availability message is nil") - t.logger.Error("error posting sequences to the data availability protocol: ", err.Error()) - return nil, err - } - newopts := t.opts - newopts.NoSend = true - - // force nonce, gas limit and gas price to avoid querying it from the chain - newopts.Nonce = big.NewInt(1) - newopts.GasLimit = uint64(1) - newopts.GasPrice = big.NewInt(1) - - return t.buildSequenceBatchesTxValidium(&newopts, sequences, dataAvailabilityMessage) -} - -func (t *TxBuilderElderberryValidium) buildSequenceBatchesTxValidium(opts *bind.TransactOpts, - sequences seqsendertypes.Sequence, dataAvailabilityMessage []byte) (*types.Transaction, error) { - batches := make([]polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, sequences.Len()) - for i, seq := range sequences.Batches() { - var ger common.Hash - if seq.ForcedBatchTimestamp() > 0 { - ger = seq.GlobalExitRoot() - } - batches[i] = polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData{ - TransactionsHash: crypto.Keccak256Hash(seq.L2Data()), - ForcedGlobalExitRoot: ger, - ForcedTimestamp: seq.ForcedBatchTimestamp(), - ForcedBlockHashL1: seq.ForcedBlockHashL1(), - } - } - lastSequencedBatchNumber := getLastSequencedBatchNumber(sequences) - t.logger.Infof("SequenceBatchesValidium(from=%s, len(batches)=%d, MaxSequenceTimestamp=%d, "+ - "lastSequencedBatchNumber=%d, L2Coinbase=%s, dataAvailabilityMessage=%s)", - t.opts.From.String(), len(batches), sequences.MaxSequenceTimestamp(), lastSequencedBatchNumber, - sequences.L2Coinbase().String(), hex.EncodeToString(dataAvailabilityMessage), - ) - tx, err := t.rollupContract.SequenceBatchesValidium(opts, batches, sequences.MaxSequenceTimestamp(), - lastSequencedBatchNumber, sequences.L2Coinbase(), dataAvailabilityMessage) - if err != nil { - if parsedErr, ok := etherman.TryParseError(err); ok { - err = parsedErr - } - } - - return tx, err -} - -func (t *TxBuilderElderberryValidium) String() string { - return "Elderberry/Validium" -} - -func convertToBatchesData(sequences seqsendertypes.Sequence) [][]byte { - batches := make([][]byte, sequences.Len()) - for i, batch := range sequences.Batches() { - batches[i] = batch.L2Data() - } - return batches -} diff --git a/sequencesender/txbuilder/elderberry_validium_test.go b/sequencesender/txbuilder/elderberry_validium_test.go deleted file mode 100644 index ee6b10f8..00000000 --- a/sequencesender/txbuilder/elderberry_validium_test.go +++ /dev/null @@ -1,119 +0,0 @@ -package txbuilder_test - -import ( - "context" - "fmt" - "math/big" - "strings" - "testing" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - "github.com/agglayer/aggkit/dataavailability/mocks_da" - "github.com/agglayer/aggkit/etherman/contracts" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestElderberryValidiumName(t *testing.T) { - testData := newElderberryValidiumSUT(t) - require.NotNil(t, testData.sut) - require.True(t, strings.Contains(testData.sut.String(), "Elderberry")) - require.True(t, strings.Contains(testData.sut.String(), "Validium")) -} - -func TestElderberryValidiumBuildSequenceBatchesTxEmtpySequence(t *testing.T) { - testData := newElderberryValidiumSUT(t) - ctx := context.TODO() - _, err := testData.sut.BuildSequenceBatchesTx(ctx, nil) - require.Error(t, err) - - seq, err := testData.sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NoError(t, err) - _, err = testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err) -} - -func TestElderberryValidiumBuildSequenceBatchesTxSequenceErrorsFromDA(t *testing.T) { - testData := newElderberryValidiumSUT(t) - ctx := context.TODO() - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := testData.sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - seq, err := testData.sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - testData.mockDA.EXPECT().PostSequenceElderberry(ctx, mock.Anything).Return(nil, nil) - _, err = testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err, "data availability message is nil") - testData.mockDA.EXPECT().PostSequenceElderberry(ctx, mock.Anything).Return(nil, fmt.Errorf("test error")) - _, err = testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err, "error posting sequences to the data availability protocol: test error") -} - -func TestElderberryValidiumBuildSequenceBatchesTxSequenceDAOk(t *testing.T) { - testData := newElderberryValidiumSUT(t) - ctx := context.TODO() - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := testData.sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - seq, err := testData.sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - testData.mockDA.EXPECT().PostSequenceElderberry(ctx, mock.Anything).Return([]byte{1}, nil) - tx, err := testData.sut.BuildSequenceBatchesTx(ctx, seq) - require.NoError(t, err) - require.NotNil(t, tx) -} - -func TestElderberryValidiumNewSequenceIfWorthToSend(t *testing.T) { - testData := newElderberryValidiumSUT(t) - testSequenceIfWorthToSendNoNewSeq(t, testData.sut) - testSequenceIfWorthToSendErr(t, testData.sut) - testSetCondNewSeq(t, testData.sut) -} - -type testDataElderberryValidium struct { - mockDA *mocks_da.SequenceSenderElderberry - sut *txbuilder.TxBuilderElderberryValidium -} - -func newElderberryValidiumSUT(t *testing.T) *testDataElderberryValidium { - t.Helper() - - zkevmContract, err := contracts.NewContractMagic[contracts.RollupElderberryType](polygonvalidiumetrog.NewPolygonvalidiumetrog, common.Address{}, nil, contracts.ContractNameRollup, contracts.VersionElderberry) - require.NoError(t, err) - privateKey, err := crypto.HexToECDSA("64e679029f5032046955d41713dcc4b565de77ab891748d31bcf38864b54c175") - require.NoError(t, err) - opts, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1)) - require.NoError(t, err) - - da := mocks_da.NewSequenceSenderElderberry(t) - - sut := txbuilder.NewTxBuilderElderberryValidium(log.GetDefaultLogger(), *zkevmContract, da, *opts, uint64(100)) - require.NotNil(t, sut) - return &testDataElderberryValidium{ - mockDA: da, - sut: sut, - } -} diff --git a/sequencesender/txbuilder/elderberry_zkevm.go b/sequencesender/txbuilder/elderberry_zkevm.go deleted file mode 100644 index 53b22f58..00000000 --- a/sequencesender/txbuilder/elderberry_zkevm.go +++ /dev/null @@ -1,113 +0,0 @@ -package txbuilder - -import ( - "context" - "fmt" - "math/big" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -type TxBuilderElderberryZKEVM struct { - TxBuilderElderberryBase - condNewSeq CondNewSequence - rollupContract rollupElderberryZKEVMContractor -} - -type rollupElderberryZKEVMContractor interface { - SequenceBatches( - opts *bind.TransactOpts, - batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, - maxSequenceTimestamp uint64, - initSequencedBatch uint64, - l2Coinbase common.Address, - ) (*types.Transaction, error) -} - -func NewTxBuilderElderberryZKEVM( - logger *log.Logger, zkevm rollupElderberryZKEVMContractor, - opts bind.TransactOpts, maxTxSizeForL1 uint64, -) *TxBuilderElderberryZKEVM { - return &TxBuilderElderberryZKEVM{ - TxBuilderElderberryBase: *NewTxBuilderElderberryBase(logger, opts), - condNewSeq: NewConditionalNewSequenceMaxSize(maxTxSizeForL1), - rollupContract: zkevm, - } -} - -func (t *TxBuilderElderberryZKEVM) NewSequenceIfWorthToSend( - ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64, -) (seqsendertypes.Sequence, error) { - return t.condNewSeq.NewSequenceIfWorthToSend(ctx, t, sequenceBatches, l2Coinbase) -} - -// SetCondNewSeq allow to override the default conditional for new sequence -func (t *TxBuilderElderberryZKEVM) SetCondNewSeq(cond CondNewSequence) CondNewSequence { - previous := t.condNewSeq - t.condNewSeq = cond - return previous -} - -func (t *TxBuilderElderberryZKEVM) BuildSequenceBatchesTx( - ctx context.Context, sequences seqsendertypes.Sequence, -) (*types.Transaction, error) { - newopts := t.opts - newopts.NoSend = true - - // force nonce, gas limit and gas price to avoid querying it from the chain - newopts.Nonce = big.NewInt(1) - newopts.GasLimit = uint64(1) - newopts.GasPrice = big.NewInt(1) - - return t.sequenceBatchesRollup(newopts, sequences) -} - -func (t *TxBuilderElderberryZKEVM) sequenceBatchesRollup( - opts bind.TransactOpts, sequences seqsendertypes.Sequence, -) (*types.Transaction, error) { - if sequences == nil || sequences.Len() == 0 { - return nil, fmt.Errorf("can't sequence an empty sequence") - } - batches := make([]polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, sequences.Len()) - for i, seq := range sequences.Batches() { - var ger common.Hash - if seq.ForcedBatchTimestamp() > 0 { - ger = seq.GlobalExitRoot() - } - - batches[i] = polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData{ - Transactions: seq.L2Data(), - ForcedGlobalExitRoot: ger, - ForcedTimestamp: seq.ForcedBatchTimestamp(), - // TODO: Check that is ok to use ForcedBlockHashL1 instead PrevBlockHash - ForcedBlockHashL1: seq.ForcedBlockHashL1(), - } - } - lastSequencedBatchNumber := getLastSequencedBatchNumber(sequences) - tx, err := t.rollupContract.SequenceBatches( - &opts, batches, sequences.MaxSequenceTimestamp(), lastSequencedBatchNumber, sequences.L2Coinbase(), - ) - if err != nil { - t.warningMessage(batches, sequences.L2Coinbase(), &opts) - if parsedErr, ok := etherman.TryParseError(err); ok { - err = parsedErr - } - } - - return tx, err -} - -func (t *TxBuilderElderberryZKEVM) warningMessage( - batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address, opts *bind.TransactOpts) { - t.logger.Warnf("Sequencer address: ", opts.From, "l2CoinBase: ", l2Coinbase, " Batches to send: %+v", batches) -} - -func (t *TxBuilderElderberryZKEVM) String() string { - return "Elderberry/ZKEVM" -} diff --git a/sequencesender/txbuilder/elderberry_zkevm_test.go b/sequencesender/txbuilder/elderberry_zkevm_test.go deleted file mode 100644 index fdc8e40e..00000000 --- a/sequencesender/txbuilder/elderberry_zkevm_test.go +++ /dev/null @@ -1,113 +0,0 @@ -package txbuilder_test - -import ( - "context" - "math/big" - "strings" - "testing" - - "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - "github.com/agglayer/aggkit/etherman/contracts" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/stretchr/testify/require" -) - -func TestElderberryZkevmName(t *testing.T) { - zkevmContract := contracts.RollupElderberryType{} - opts := bind.TransactOpts{} - sut := txbuilder.NewTxBuilderElderberryZKEVM(log.GetDefaultLogger(), zkevmContract, opts, 100) - require.NotNil(t, sut) - require.True(t, strings.Contains(sut.String(), "Elderberry")) - require.True(t, strings.Contains(sut.String(), "ZKEVM")) -} - -func TestElderberryZkevmNewSequence(t *testing.T) { - zkevmContract := contracts.RollupElderberryType{} - opts := bind.TransactOpts{} - sut := txbuilder.NewTxBuilderElderberryZKEVM(log.GetDefaultLogger(), zkevmContract, opts, 100) - require.NotNil(t, sut) - seq, err := sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NoError(t, err) - require.NotNil(t, seq) -} - -func TestElderberryZkevmBuildSequenceBatchesTxEmtpySequence(t *testing.T) { - sut := newElderberryZkevmSUT(t) - ctx := context.TODO() - _, err := sut.BuildSequenceBatchesTx(ctx, nil) - require.Error(t, err) - - seq, err := sut.NewSequence(context.TODO(), nil, common.Address{}) - require.NoError(t, err) - _, err = sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err) -} - -func TestElderberryZkevmBuildSequenceBatchesTxSequence1Batch(t *testing.T) { - sut := newElderberryZkevmSUT(t) - ctx := context.TODO() - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - seq, err := sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - _, err = sut.BuildSequenceBatchesTx(ctx, seq) - require.NoError(t, err) -} - -// This have to signer so produce an error -func TestElderberryZkevmBuildSequenceBatchesTxSequence1BatchError(t *testing.T) { - sut := newElderberryZkevmSUT(t) - sut.SetAuth(&bind.TransactOpts{}) - ctx := context.TODO() - l2Block := &datastream.L2Block{ - Timestamp: 1, - BatchNumber: 1, - L1InfotreeIndex: 3, - Coinbase: []byte{1, 2, 3}, - GlobalExitRoot: []byte{4, 5, 6}, - } - batchElder := sut.NewBatchFromL2Block(l2Block) - batches := []seqsendertypes.Batch{ - batchElder, - } - seq, err := sut.NewSequence(context.TODO(), batches, common.Address{}) - require.NoError(t, err) - _, err = sut.BuildSequenceBatchesTx(ctx, seq) - require.Error(t, err) -} - -func TestElderberryZkevmNewSequenceIfWorthToSend(t *testing.T) { - sut := newElderberryZkevmSUT(t) - testSequenceIfWorthToSendNoNewSeq(t, sut) - testSequenceIfWorthToSendErr(t, sut) - testSetCondNewSeq(t, sut) -} - -func newElderberryZkevmSUT(t *testing.T) *txbuilder.TxBuilderElderberryZKEVM { - t.Helper() - - zkevmContract, err := contracts.NewContractMagic[contracts.RollupElderberryType](polygonvalidiumetrog.NewPolygonvalidiumetrog, common.Address{}, nil, contracts.ContractNameRollup, contracts.VersionElderberry) - require.NoError(t, err) - privateKey, err := crypto.HexToECDSA("64e679029f5032046955d41713dcc4b565de77ab891748d31bcf38864b54c175") - require.NoError(t, err) - opts, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1)) - require.NoError(t, err) - sut := txbuilder.NewTxBuilderElderberryZKEVM(log.GetDefaultLogger(), *zkevmContract, *opts, 100) - require.NotNil(t, sut) - return sut -} diff --git a/sequencesender/txbuilder/interface.go b/sequencesender/txbuilder/interface.go deleted file mode 100644 index 1d018cdb..00000000 --- a/sequencesender/txbuilder/interface.go +++ /dev/null @@ -1,38 +0,0 @@ -package txbuilder - -import ( - "context" - "fmt" - - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/state/datastream" - "github.com/ethereum/go-ethereum/common" - ethtypes "github.com/ethereum/go-ethereum/core/types" -) - -type TxBuilder interface { - // Stringer interface - fmt.Stringer - - // BuildSequenceBatchesTx Builds a sequence of batches transaction - BuildSequenceBatchesTx(ctx context.Context, sequences seqsendertypes.Sequence) (*ethtypes.Transaction, error) - // NewSequence Creates a new sequence - NewSequence( - ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address, - ) (seqsendertypes.Sequence, error) - // NewSequenceIfWorthToSend Creates a new sequence if it is worth sending - NewSequenceIfWorthToSend( - ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64, - ) (seqsendertypes.Sequence, error) - // NewBatchFromL2Block Creates a new batch from the L2 block from a datastream - NewBatchFromL2Block(l2Block *datastream.L2Block) seqsendertypes.Batch - // SetCondNewSeq Allows to override the condition to send a new sequence, returns previous one - SetCondNewSeq(cond CondNewSequence) CondNewSequence -} - -type CondNewSequence interface { - // NewSequenceIfWorthToSend Return nil, nil if the sequence is not worth sending - NewSequenceIfWorthToSend( - ctx context.Context, txBuilder TxBuilder, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, - ) (seqsendertypes.Sequence, error) -} diff --git a/sequencesender/txbuilder/interface_test.go b/sequencesender/txbuilder/interface_test.go deleted file mode 100644 index 8ad3157d..00000000 --- a/sequencesender/txbuilder/interface_test.go +++ /dev/null @@ -1,50 +0,0 @@ -package txbuilder_test - -import ( - "context" - "fmt" - "testing" - - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -/* -This test ara auxiliars function based on the common behaviour of the interfaces -*/ - -func testSequenceIfWorthToSendNoNewSeq(t *testing.T, sut txbuilder.TxBuilder) { - t.Helper() - - cond := mocks_txbuilder.NewCondNewSequence(t) - sut.SetCondNewSeq(cond) - cond.EXPECT().NewSequenceIfWorthToSend(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil).Once() - seq, err := sut.NewSequenceIfWorthToSend(context.TODO(), nil, common.Address{}, 0) - require.NoError(t, err) - require.Nil(t, seq) -} - -func testSequenceIfWorthToSendErr(t *testing.T, sut txbuilder.TxBuilder) { - t.Helper() - - cond := mocks_txbuilder.NewCondNewSequence(t) - sut.SetCondNewSeq(cond) - returnErr := fmt.Errorf("test-error") - cond.EXPECT().NewSequenceIfWorthToSend(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, returnErr).Once() - seq, err := sut.NewSequenceIfWorthToSend(context.TODO(), nil, common.Address{}, 0) - require.ErrorIs(t, returnErr, err) - require.Nil(t, seq) -} - -func testSetCondNewSeq(t *testing.T, sut txbuilder.TxBuilder) { - t.Helper() - - cond := mocks_txbuilder.NewCondNewSequence(t) - sut.SetCondNewSeq(cond) - cond2 := mocks_txbuilder.NewCondNewSequence(t) - previous := sut.SetCondNewSeq(cond2) - require.Equal(t, cond, previous) -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/cond_new_sequence.go b/sequencesender/txbuilder/mocks_txbuilder/cond_new_sequence.go deleted file mode 100644 index e80ddd3d..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/cond_new_sequence.go +++ /dev/null @@ -1,103 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - seqsendertypes "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - - txbuilder "github.com/agglayer/aggkit/sequencesender/txbuilder" -) - -// CondNewSequence is an autogenerated mock type for the CondNewSequence type -type CondNewSequence struct { - mock.Mock -} - -type CondNewSequence_Expecter struct { - mock *mock.Mock -} - -func (_m *CondNewSequence) EXPECT() *CondNewSequence_Expecter { - return &CondNewSequence_Expecter{mock: &_m.Mock} -} - -// NewSequenceIfWorthToSend provides a mock function with given fields: ctx, txBuilder, sequenceBatches, l2Coinbase -func (_m *CondNewSequence) NewSequenceIfWorthToSend(ctx context.Context, txBuilder txbuilder.TxBuilder, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address) (seqsendertypes.Sequence, error) { - ret := _m.Called(ctx, txBuilder, sequenceBatches, l2Coinbase) - - if len(ret) == 0 { - panic("no return value specified for NewSequenceIfWorthToSend") - } - - var r0 seqsendertypes.Sequence - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, txbuilder.TxBuilder, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)); ok { - return rf(ctx, txBuilder, sequenceBatches, l2Coinbase) - } - if rf, ok := ret.Get(0).(func(context.Context, txbuilder.TxBuilder, []seqsendertypes.Batch, common.Address) seqsendertypes.Sequence); ok { - r0 = rf(ctx, txBuilder, sequenceBatches, l2Coinbase) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Sequence) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, txbuilder.TxBuilder, []seqsendertypes.Batch, common.Address) error); ok { - r1 = rf(ctx, txBuilder, sequenceBatches, l2Coinbase) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// CondNewSequence_NewSequenceIfWorthToSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSequenceIfWorthToSend' -type CondNewSequence_NewSequenceIfWorthToSend_Call struct { - *mock.Call -} - -// NewSequenceIfWorthToSend is a helper method to define mock.On call -// - ctx context.Context -// - txBuilder txbuilder.TxBuilder -// - sequenceBatches []seqsendertypes.Batch -// - l2Coinbase common.Address -func (_e *CondNewSequence_Expecter) NewSequenceIfWorthToSend(ctx interface{}, txBuilder interface{}, sequenceBatches interface{}, l2Coinbase interface{}) *CondNewSequence_NewSequenceIfWorthToSend_Call { - return &CondNewSequence_NewSequenceIfWorthToSend_Call{Call: _e.mock.On("NewSequenceIfWorthToSend", ctx, txBuilder, sequenceBatches, l2Coinbase)} -} - -func (_c *CondNewSequence_NewSequenceIfWorthToSend_Call) Run(run func(ctx context.Context, txBuilder txbuilder.TxBuilder, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address)) *CondNewSequence_NewSequenceIfWorthToSend_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(txbuilder.TxBuilder), args[2].([]seqsendertypes.Batch), args[3].(common.Address)) - }) - return _c -} - -func (_c *CondNewSequence_NewSequenceIfWorthToSend_Call) Return(_a0 seqsendertypes.Sequence, _a1 error) *CondNewSequence_NewSequenceIfWorthToSend_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *CondNewSequence_NewSequenceIfWorthToSend_Call) RunAndReturn(run func(context.Context, txbuilder.TxBuilder, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)) *CondNewSequence_NewSequenceIfWorthToSend_Call { - _c.Call.Return(run) - return _c -} - -// NewCondNewSequence creates a new instance of CondNewSequence. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewCondNewSequence(t interface { - mock.TestingT - Cleanup(func()) -}) *CondNewSequence { - mock := &CondNewSequence{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_contractor.go deleted file mode 100644 index 86fd4366..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_contractor.go +++ /dev/null @@ -1,139 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - mock "github.com/stretchr/testify/mock" -) - -// GlobalExitRootBananaContractor is an autogenerated mock type for the globalExitRootBananaContractor type -type GlobalExitRootBananaContractor struct { - mock.Mock -} - -type GlobalExitRootBananaContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *GlobalExitRootBananaContractor) EXPECT() *GlobalExitRootBananaContractor_Expecter { - return &GlobalExitRootBananaContractor_Expecter{mock: &_m.Mock} -} - -// L1InfoRootMap provides a mock function with given fields: opts, index -func (_m *GlobalExitRootBananaContractor) L1InfoRootMap(opts *bind.CallOpts, index uint32) ([32]byte, error) { - ret := _m.Called(opts, index) - - if len(ret) == 0 { - panic("no return value specified for L1InfoRootMap") - } - - var r0 [32]byte - var r1 error - if rf, ok := ret.Get(0).(func(*bind.CallOpts, uint32) ([32]byte, error)); ok { - return rf(opts, index) - } - if rf, ok := ret.Get(0).(func(*bind.CallOpts, uint32) [32]byte); ok { - r0 = rf(opts, index) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([32]byte) - } - } - - if rf, ok := ret.Get(1).(func(*bind.CallOpts, uint32) error); ok { - r1 = rf(opts, index) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// GlobalExitRootBananaContractor_L1InfoRootMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'L1InfoRootMap' -type GlobalExitRootBananaContractor_L1InfoRootMap_Call struct { - *mock.Call -} - -// L1InfoRootMap is a helper method to define mock.On call -// - opts *bind.CallOpts -// - index uint32 -func (_e *GlobalExitRootBananaContractor_Expecter) L1InfoRootMap(opts interface{}, index interface{}) *GlobalExitRootBananaContractor_L1InfoRootMap_Call { - return &GlobalExitRootBananaContractor_L1InfoRootMap_Call{Call: _e.mock.On("L1InfoRootMap", opts, index)} -} - -func (_c *GlobalExitRootBananaContractor_L1InfoRootMap_Call) Run(run func(opts *bind.CallOpts, index uint32)) *GlobalExitRootBananaContractor_L1InfoRootMap_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.CallOpts), args[1].(uint32)) - }) - return _c -} - -func (_c *GlobalExitRootBananaContractor_L1InfoRootMap_Call) Return(_a0 [32]byte, _a1 error) *GlobalExitRootBananaContractor_L1InfoRootMap_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *GlobalExitRootBananaContractor_L1InfoRootMap_Call) RunAndReturn(run func(*bind.CallOpts, uint32) ([32]byte, error)) *GlobalExitRootBananaContractor_L1InfoRootMap_Call { - _c.Call.Return(run) - return _c -} - -// String provides a mock function with no fields -func (_m *GlobalExitRootBananaContractor) String() string { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for String") - } - - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// GlobalExitRootBananaContractor_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' -type GlobalExitRootBananaContractor_String_Call struct { - *mock.Call -} - -// String is a helper method to define mock.On call -func (_e *GlobalExitRootBananaContractor_Expecter) String() *GlobalExitRootBananaContractor_String_Call { - return &GlobalExitRootBananaContractor_String_Call{Call: _e.mock.On("String")} -} - -func (_c *GlobalExitRootBananaContractor_String_Call) Run(run func()) *GlobalExitRootBananaContractor_String_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *GlobalExitRootBananaContractor_String_Call) Return(_a0 string) *GlobalExitRootBananaContractor_String_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *GlobalExitRootBananaContractor_String_Call) RunAndReturn(run func() string) *GlobalExitRootBananaContractor_String_Call { - _c.Call.Return(run) - return _c -} - -// NewGlobalExitRootBananaContractor creates a new instance of GlobalExitRootBananaContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGlobalExitRootBananaContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *GlobalExitRootBananaContractor { - mock := &GlobalExitRootBananaContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_zkevm_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_zkevm_contractor.go deleted file mode 100644 index 57c6c157..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/global_exit_root_banana_zkevm_contractor.go +++ /dev/null @@ -1,139 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - mock "github.com/stretchr/testify/mock" -) - -// GlobalExitRootBananaZKEVMContractor is an autogenerated mock type for the globalExitRootBananaZKEVMContractor type -type GlobalExitRootBananaZKEVMContractor struct { - mock.Mock -} - -type GlobalExitRootBananaZKEVMContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *GlobalExitRootBananaZKEVMContractor) EXPECT() *GlobalExitRootBananaZKEVMContractor_Expecter { - return &GlobalExitRootBananaZKEVMContractor_Expecter{mock: &_m.Mock} -} - -// L1InfoRootMap provides a mock function with given fields: opts, index -func (_m *GlobalExitRootBananaZKEVMContractor) L1InfoRootMap(opts *bind.CallOpts, index uint32) ([32]byte, error) { - ret := _m.Called(opts, index) - - if len(ret) == 0 { - panic("no return value specified for L1InfoRootMap") - } - - var r0 [32]byte - var r1 error - if rf, ok := ret.Get(0).(func(*bind.CallOpts, uint32) ([32]byte, error)); ok { - return rf(opts, index) - } - if rf, ok := ret.Get(0).(func(*bind.CallOpts, uint32) [32]byte); ok { - r0 = rf(opts, index) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([32]byte) - } - } - - if rf, ok := ret.Get(1).(func(*bind.CallOpts, uint32) error); ok { - r1 = rf(opts, index) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'L1InfoRootMap' -type GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call struct { - *mock.Call -} - -// L1InfoRootMap is a helper method to define mock.On call -// - opts *bind.CallOpts -// - index uint32 -func (_e *GlobalExitRootBananaZKEVMContractor_Expecter) L1InfoRootMap(opts interface{}, index interface{}) *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call { - return &GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call{Call: _e.mock.On("L1InfoRootMap", opts, index)} -} - -func (_c *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call) Run(run func(opts *bind.CallOpts, index uint32)) *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.CallOpts), args[1].(uint32)) - }) - return _c -} - -func (_c *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call) Return(_a0 [32]byte, _a1 error) *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call) RunAndReturn(run func(*bind.CallOpts, uint32) ([32]byte, error)) *GlobalExitRootBananaZKEVMContractor_L1InfoRootMap_Call { - _c.Call.Return(run) - return _c -} - -// String provides a mock function with no fields -func (_m *GlobalExitRootBananaZKEVMContractor) String() string { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for String") - } - - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// GlobalExitRootBananaZKEVMContractor_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' -type GlobalExitRootBananaZKEVMContractor_String_Call struct { - *mock.Call -} - -// String is a helper method to define mock.On call -func (_e *GlobalExitRootBananaZKEVMContractor_Expecter) String() *GlobalExitRootBananaZKEVMContractor_String_Call { - return &GlobalExitRootBananaZKEVMContractor_String_Call{Call: _e.mock.On("String")} -} - -func (_c *GlobalExitRootBananaZKEVMContractor_String_Call) Run(run func()) *GlobalExitRootBananaZKEVMContractor_String_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *GlobalExitRootBananaZKEVMContractor_String_Call) Return(_a0 string) *GlobalExitRootBananaZKEVMContractor_String_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *GlobalExitRootBananaZKEVMContractor_String_Call) RunAndReturn(run func() string) *GlobalExitRootBananaZKEVMContractor_String_Call { - _c.Call.Return(run) - return _c -} - -// NewGlobalExitRootBananaZKEVMContractor creates a new instance of GlobalExitRootBananaZKEVMContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGlobalExitRootBananaZKEVMContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *GlobalExitRootBananaZKEVMContractor { - mock := &GlobalExitRootBananaZKEVMContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/l1_client.go b/sequencesender/txbuilder/mocks_txbuilder/l1_client.go deleted file mode 100644 index 853494f9..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/l1_client.go +++ /dev/null @@ -1,98 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - context "context" - big "math/big" - - mock "github.com/stretchr/testify/mock" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// L1Client is an autogenerated mock type for the l1Client type -type L1Client struct { - mock.Mock -} - -type L1Client_Expecter struct { - mock *mock.Mock -} - -func (_m *L1Client) EXPECT() *L1Client_Expecter { - return &L1Client_Expecter{mock: &_m.Mock} -} - -// HeaderByNumber provides a mock function with given fields: ctx, number -func (_m *L1Client) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) { - ret := _m.Called(ctx, number) - - if len(ret) == 0 { - panic("no return value specified for HeaderByNumber") - } - - var r0 *types.Header - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *big.Int) (*types.Header, error)); ok { - return rf(ctx, number) - } - if rf, ok := ret.Get(0).(func(context.Context, *big.Int) *types.Header); ok { - r0 = rf(ctx, number) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Header) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, *big.Int) error); ok { - r1 = rf(ctx, number) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// L1Client_HeaderByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByNumber' -type L1Client_HeaderByNumber_Call struct { - *mock.Call -} - -// HeaderByNumber is a helper method to define mock.On call -// - ctx context.Context -// - number *big.Int -func (_e *L1Client_Expecter) HeaderByNumber(ctx interface{}, number interface{}) *L1Client_HeaderByNumber_Call { - return &L1Client_HeaderByNumber_Call{Call: _e.mock.On("HeaderByNumber", ctx, number)} -} - -func (_c *L1Client_HeaderByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *L1Client_HeaderByNumber_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*big.Int)) - }) - return _c -} - -func (_c *L1Client_HeaderByNumber_Call) Return(_a0 *types.Header, _a1 error) *L1Client_HeaderByNumber_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *L1Client_HeaderByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Header, error)) *L1Client_HeaderByNumber_Call { - _c.Call.Return(run) - return _c -} - -// NewL1Client creates a new instance of L1Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewL1Client(t interface { - mock.TestingT - Cleanup(func()) -}) *L1Client { - mock := &L1Client{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/l1_info_syncer.go b/sequencesender/txbuilder/mocks_txbuilder/l1_info_syncer.go deleted file mode 100644 index 1ff380d5..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/l1_info_syncer.go +++ /dev/null @@ -1,154 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - context "context" - - l1infotreesync "github.com/agglayer/aggkit/l1infotreesync" - mock "github.com/stretchr/testify/mock" -) - -// L1InfoSyncer is an autogenerated mock type for the l1InfoSyncer type -type L1InfoSyncer struct { - mock.Mock -} - -type L1InfoSyncer_Expecter struct { - mock *mock.Mock -} - -func (_m *L1InfoSyncer) EXPECT() *L1InfoSyncer_Expecter { - return &L1InfoSyncer_Expecter{mock: &_m.Mock} -} - -// GetInitL1InfoRootMap provides a mock function with given fields: ctx -func (_m *L1InfoSyncer) GetInitL1InfoRootMap(ctx context.Context) (*l1infotreesync.L1InfoTreeInitial, error) { - ret := _m.Called(ctx) - - if len(ret) == 0 { - panic("no return value specified for GetInitL1InfoRootMap") - } - - var r0 *l1infotreesync.L1InfoTreeInitial - var r1 error - if rf, ok := ret.Get(0).(func(context.Context) (*l1infotreesync.L1InfoTreeInitial, error)); ok { - return rf(ctx) - } - if rf, ok := ret.Get(0).(func(context.Context) *l1infotreesync.L1InfoTreeInitial); ok { - r0 = rf(ctx) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*l1infotreesync.L1InfoTreeInitial) - } - } - - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// L1InfoSyncer_GetInitL1InfoRootMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInitL1InfoRootMap' -type L1InfoSyncer_GetInitL1InfoRootMap_Call struct { - *mock.Call -} - -// GetInitL1InfoRootMap is a helper method to define mock.On call -// - ctx context.Context -func (_e *L1InfoSyncer_Expecter) GetInitL1InfoRootMap(ctx interface{}) *L1InfoSyncer_GetInitL1InfoRootMap_Call { - return &L1InfoSyncer_GetInitL1InfoRootMap_Call{Call: _e.mock.On("GetInitL1InfoRootMap", ctx)} -} - -func (_c *L1InfoSyncer_GetInitL1InfoRootMap_Call) Run(run func(ctx context.Context)) *L1InfoSyncer_GetInitL1InfoRootMap_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context)) - }) - return _c -} - -func (_c *L1InfoSyncer_GetInitL1InfoRootMap_Call) Return(_a0 *l1infotreesync.L1InfoTreeInitial, _a1 error) *L1InfoSyncer_GetInitL1InfoRootMap_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *L1InfoSyncer_GetInitL1InfoRootMap_Call) RunAndReturn(run func(context.Context) (*l1infotreesync.L1InfoTreeInitial, error)) *L1InfoSyncer_GetInitL1InfoRootMap_Call { - _c.Call.Return(run) - return _c -} - -// GetLatestInfoUntilBlock provides a mock function with given fields: ctx, blockNum -func (_m *L1InfoSyncer) GetLatestInfoUntilBlock(ctx context.Context, blockNum uint64) (*l1infotreesync.L1InfoTreeLeaf, error) { - ret := _m.Called(ctx, blockNum) - - if len(ret) == 0 { - panic("no return value specified for GetLatestInfoUntilBlock") - } - - var r0 *l1infotreesync.L1InfoTreeLeaf - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, uint64) (*l1infotreesync.L1InfoTreeLeaf, error)); ok { - return rf(ctx, blockNum) - } - if rf, ok := ret.Get(0).(func(context.Context, uint64) *l1infotreesync.L1InfoTreeLeaf); ok { - r0 = rf(ctx, blockNum) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*l1infotreesync.L1InfoTreeLeaf) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, uint64) error); ok { - r1 = rf(ctx, blockNum) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// L1InfoSyncer_GetLatestInfoUntilBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestInfoUntilBlock' -type L1InfoSyncer_GetLatestInfoUntilBlock_Call struct { - *mock.Call -} - -// GetLatestInfoUntilBlock is a helper method to define mock.On call -// - ctx context.Context -// - blockNum uint64 -func (_e *L1InfoSyncer_Expecter) GetLatestInfoUntilBlock(ctx interface{}, blockNum interface{}) *L1InfoSyncer_GetLatestInfoUntilBlock_Call { - return &L1InfoSyncer_GetLatestInfoUntilBlock_Call{Call: _e.mock.On("GetLatestInfoUntilBlock", ctx, blockNum)} -} - -func (_c *L1InfoSyncer_GetLatestInfoUntilBlock_Call) Run(run func(ctx context.Context, blockNum uint64)) *L1InfoSyncer_GetLatestInfoUntilBlock_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(uint64)) - }) - return _c -} - -func (_c *L1InfoSyncer_GetLatestInfoUntilBlock_Call) Return(_a0 *l1infotreesync.L1InfoTreeLeaf, _a1 error) *L1InfoSyncer_GetLatestInfoUntilBlock_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *L1InfoSyncer_GetLatestInfoUntilBlock_Call) RunAndReturn(run func(context.Context, uint64) (*l1infotreesync.L1InfoTreeLeaf, error)) *L1InfoSyncer_GetLatestInfoUntilBlock_Call { - _c.Call.Return(run) - return _c -} - -// NewL1InfoSyncer creates a new instance of L1InfoSyncer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewL1InfoSyncer(t interface { - mock.TestingT - Cleanup(func()) -}) *L1InfoSyncer { - mock := &L1InfoSyncer{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_base_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_base_contractor.go deleted file mode 100644 index acd82a4e..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_base_contractor.go +++ /dev/null @@ -1,93 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - mock "github.com/stretchr/testify/mock" -) - -// RollupBananaBaseContractor is an autogenerated mock type for the rollupBananaBaseContractor type -type RollupBananaBaseContractor struct { - mock.Mock -} - -type RollupBananaBaseContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *RollupBananaBaseContractor) EXPECT() *RollupBananaBaseContractor_Expecter { - return &RollupBananaBaseContractor_Expecter{mock: &_m.Mock} -} - -// LastAccInputHash provides a mock function with given fields: opts -func (_m *RollupBananaBaseContractor) LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) { - ret := _m.Called(opts) - - if len(ret) == 0 { - panic("no return value specified for LastAccInputHash") - } - - var r0 [32]byte - var r1 error - if rf, ok := ret.Get(0).(func(*bind.CallOpts) ([32]byte, error)); ok { - return rf(opts) - } - if rf, ok := ret.Get(0).(func(*bind.CallOpts) [32]byte); ok { - r0 = rf(opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([32]byte) - } - } - - if rf, ok := ret.Get(1).(func(*bind.CallOpts) error); ok { - r1 = rf(opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupBananaBaseContractor_LastAccInputHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastAccInputHash' -type RollupBananaBaseContractor_LastAccInputHash_Call struct { - *mock.Call -} - -// LastAccInputHash is a helper method to define mock.On call -// - opts *bind.CallOpts -func (_e *RollupBananaBaseContractor_Expecter) LastAccInputHash(opts interface{}) *RollupBananaBaseContractor_LastAccInputHash_Call { - return &RollupBananaBaseContractor_LastAccInputHash_Call{Call: _e.mock.On("LastAccInputHash", opts)} -} - -func (_c *RollupBananaBaseContractor_LastAccInputHash_Call) Run(run func(opts *bind.CallOpts)) *RollupBananaBaseContractor_LastAccInputHash_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.CallOpts)) - }) - return _c -} - -func (_c *RollupBananaBaseContractor_LastAccInputHash_Call) Return(_a0 [32]byte, _a1 error) *RollupBananaBaseContractor_LastAccInputHash_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupBananaBaseContractor_LastAccInputHash_Call) RunAndReturn(run func(*bind.CallOpts) ([32]byte, error)) *RollupBananaBaseContractor_LastAccInputHash_Call { - _c.Call.Return(run) - return _c -} - -// NewRollupBananaBaseContractor creates a new instance of RollupBananaBaseContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRollupBananaBaseContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *RollupBananaBaseContractor { - mock := &RollupBananaBaseContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_validium_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_validium_contractor.go deleted file mode 100644 index a59b88dd..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_validium_contractor.go +++ /dev/null @@ -1,163 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - polygonvalidiumetrog "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygonvalidiumetrog" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// RollupBananaValidiumContractor is an autogenerated mock type for the rollupBananaValidiumContractor type -type RollupBananaValidiumContractor struct { - mock.Mock -} - -type RollupBananaValidiumContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *RollupBananaValidiumContractor) EXPECT() *RollupBananaValidiumContractor_Expecter { - return &RollupBananaValidiumContractor_Expecter{mock: &_m.Mock} -} - -// LastAccInputHash provides a mock function with given fields: opts -func (_m *RollupBananaValidiumContractor) LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) { - ret := _m.Called(opts) - - if len(ret) == 0 { - panic("no return value specified for LastAccInputHash") - } - - var r0 [32]byte - var r1 error - if rf, ok := ret.Get(0).(func(*bind.CallOpts) ([32]byte, error)); ok { - return rf(opts) - } - if rf, ok := ret.Get(0).(func(*bind.CallOpts) [32]byte); ok { - r0 = rf(opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([32]byte) - } - } - - if rf, ok := ret.Get(1).(func(*bind.CallOpts) error); ok { - r1 = rf(opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupBananaValidiumContractor_LastAccInputHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastAccInputHash' -type RollupBananaValidiumContractor_LastAccInputHash_Call struct { - *mock.Call -} - -// LastAccInputHash is a helper method to define mock.On call -// - opts *bind.CallOpts -func (_e *RollupBananaValidiumContractor_Expecter) LastAccInputHash(opts interface{}) *RollupBananaValidiumContractor_LastAccInputHash_Call { - return &RollupBananaValidiumContractor_LastAccInputHash_Call{Call: _e.mock.On("LastAccInputHash", opts)} -} - -func (_c *RollupBananaValidiumContractor_LastAccInputHash_Call) Run(run func(opts *bind.CallOpts)) *RollupBananaValidiumContractor_LastAccInputHash_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.CallOpts)) - }) - return _c -} - -func (_c *RollupBananaValidiumContractor_LastAccInputHash_Call) Return(_a0 [32]byte, _a1 error) *RollupBananaValidiumContractor_LastAccInputHash_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupBananaValidiumContractor_LastAccInputHash_Call) RunAndReturn(run func(*bind.CallOpts) ([32]byte, error)) *RollupBananaValidiumContractor_LastAccInputHash_Call { - _c.Call.Return(run) - return _c -} - -// SequenceBatchesValidium provides a mock function with given fields: opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage -func (_m *RollupBananaValidiumContractor) SequenceBatchesValidium(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, indexL1InfoRoot uint32, maxSequenceTimestamp uint64, expectedFinalAccInputHash [32]byte, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { - ret := _m.Called(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for SequenceBatchesValidium") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint32, uint64, [32]byte, common.Address, []byte) (*types.Transaction, error)); ok { - return rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint32, uint64, [32]byte, common.Address, []byte) *types.Transaction); ok { - r0 = rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint32, uint64, [32]byte, common.Address, []byte) error); ok { - r1 = rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupBananaValidiumContractor_SequenceBatchesValidium_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SequenceBatchesValidium' -type RollupBananaValidiumContractor_SequenceBatchesValidium_Call struct { - *mock.Call -} - -// SequenceBatchesValidium is a helper method to define mock.On call -// - opts *bind.TransactOpts -// - batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData -// - indexL1InfoRoot uint32 -// - maxSequenceTimestamp uint64 -// - expectedFinalAccInputHash [32]byte -// - l2Coinbase common.Address -// - dataAvailabilityMessage []byte -func (_e *RollupBananaValidiumContractor_Expecter) SequenceBatchesValidium(opts interface{}, batches interface{}, indexL1InfoRoot interface{}, maxSequenceTimestamp interface{}, expectedFinalAccInputHash interface{}, l2Coinbase interface{}, dataAvailabilityMessage interface{}) *RollupBananaValidiumContractor_SequenceBatchesValidium_Call { - return &RollupBananaValidiumContractor_SequenceBatchesValidium_Call{Call: _e.mock.On("SequenceBatchesValidium", opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase, dataAvailabilityMessage)} -} - -func (_c *RollupBananaValidiumContractor_SequenceBatchesValidium_Call) Run(run func(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, indexL1InfoRoot uint32, maxSequenceTimestamp uint64, expectedFinalAccInputHash [32]byte, l2Coinbase common.Address, dataAvailabilityMessage []byte)) *RollupBananaValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.TransactOpts), args[1].([]polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData), args[2].(uint32), args[3].(uint64), args[4].([32]byte), args[5].(common.Address), args[6].([]byte)) - }) - return _c -} - -func (_c *RollupBananaValidiumContractor_SequenceBatchesValidium_Call) Return(_a0 *types.Transaction, _a1 error) *RollupBananaValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupBananaValidiumContractor_SequenceBatchesValidium_Call) RunAndReturn(run func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint32, uint64, [32]byte, common.Address, []byte) (*types.Transaction, error)) *RollupBananaValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Return(run) - return _c -} - -// NewRollupBananaValidiumContractor creates a new instance of RollupBananaValidiumContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRollupBananaValidiumContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *RollupBananaValidiumContractor { - mock := &RollupBananaValidiumContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_zkevm_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_zkevm_contractor.go deleted file mode 100644 index e29e3252..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/rollup_banana_zkevm_contractor.go +++ /dev/null @@ -1,162 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - polygonvalidiumetrog "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygonvalidiumetrog" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// RollupBananaZKEVMContractor is an autogenerated mock type for the rollupBananaZKEVMContractor type -type RollupBananaZKEVMContractor struct { - mock.Mock -} - -type RollupBananaZKEVMContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *RollupBananaZKEVMContractor) EXPECT() *RollupBananaZKEVMContractor_Expecter { - return &RollupBananaZKEVMContractor_Expecter{mock: &_m.Mock} -} - -// LastAccInputHash provides a mock function with given fields: opts -func (_m *RollupBananaZKEVMContractor) LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) { - ret := _m.Called(opts) - - if len(ret) == 0 { - panic("no return value specified for LastAccInputHash") - } - - var r0 [32]byte - var r1 error - if rf, ok := ret.Get(0).(func(*bind.CallOpts) ([32]byte, error)); ok { - return rf(opts) - } - if rf, ok := ret.Get(0).(func(*bind.CallOpts) [32]byte); ok { - r0 = rf(opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([32]byte) - } - } - - if rf, ok := ret.Get(1).(func(*bind.CallOpts) error); ok { - r1 = rf(opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupBananaZKEVMContractor_LastAccInputHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastAccInputHash' -type RollupBananaZKEVMContractor_LastAccInputHash_Call struct { - *mock.Call -} - -// LastAccInputHash is a helper method to define mock.On call -// - opts *bind.CallOpts -func (_e *RollupBananaZKEVMContractor_Expecter) LastAccInputHash(opts interface{}) *RollupBananaZKEVMContractor_LastAccInputHash_Call { - return &RollupBananaZKEVMContractor_LastAccInputHash_Call{Call: _e.mock.On("LastAccInputHash", opts)} -} - -func (_c *RollupBananaZKEVMContractor_LastAccInputHash_Call) Run(run func(opts *bind.CallOpts)) *RollupBananaZKEVMContractor_LastAccInputHash_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.CallOpts)) - }) - return _c -} - -func (_c *RollupBananaZKEVMContractor_LastAccInputHash_Call) Return(_a0 [32]byte, _a1 error) *RollupBananaZKEVMContractor_LastAccInputHash_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupBananaZKEVMContractor_LastAccInputHash_Call) RunAndReturn(run func(*bind.CallOpts) ([32]byte, error)) *RollupBananaZKEVMContractor_LastAccInputHash_Call { - _c.Call.Return(run) - return _c -} - -// SequenceBatches provides a mock function with given fields: opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase -func (_m *RollupBananaZKEVMContractor) SequenceBatches(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, indexL1InfoRoot uint32, maxSequenceTimestamp uint64, expectedFinalAccInputHash [32]byte, l2Coinbase common.Address) (*types.Transaction, error) { - ret := _m.Called(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase) - - if len(ret) == 0 { - panic("no return value specified for SequenceBatches") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint32, uint64, [32]byte, common.Address) (*types.Transaction, error)); ok { - return rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase) - } - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint32, uint64, [32]byte, common.Address) *types.Transaction); ok { - r0 = rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint32, uint64, [32]byte, common.Address) error); ok { - r1 = rf(opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupBananaZKEVMContractor_SequenceBatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SequenceBatches' -type RollupBananaZKEVMContractor_SequenceBatches_Call struct { - *mock.Call -} - -// SequenceBatches is a helper method to define mock.On call -// - opts *bind.TransactOpts -// - batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData -// - indexL1InfoRoot uint32 -// - maxSequenceTimestamp uint64 -// - expectedFinalAccInputHash [32]byte -// - l2Coinbase common.Address -func (_e *RollupBananaZKEVMContractor_Expecter) SequenceBatches(opts interface{}, batches interface{}, indexL1InfoRoot interface{}, maxSequenceTimestamp interface{}, expectedFinalAccInputHash interface{}, l2Coinbase interface{}) *RollupBananaZKEVMContractor_SequenceBatches_Call { - return &RollupBananaZKEVMContractor_SequenceBatches_Call{Call: _e.mock.On("SequenceBatches", opts, batches, indexL1InfoRoot, maxSequenceTimestamp, expectedFinalAccInputHash, l2Coinbase)} -} - -func (_c *RollupBananaZKEVMContractor_SequenceBatches_Call) Run(run func(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, indexL1InfoRoot uint32, maxSequenceTimestamp uint64, expectedFinalAccInputHash [32]byte, l2Coinbase common.Address)) *RollupBananaZKEVMContractor_SequenceBatches_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.TransactOpts), args[1].([]polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData), args[2].(uint32), args[3].(uint64), args[4].([32]byte), args[5].(common.Address)) - }) - return _c -} - -func (_c *RollupBananaZKEVMContractor_SequenceBatches_Call) Return(_a0 *types.Transaction, _a1 error) *RollupBananaZKEVMContractor_SequenceBatches_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupBananaZKEVMContractor_SequenceBatches_Call) RunAndReturn(run func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint32, uint64, [32]byte, common.Address) (*types.Transaction, error)) *RollupBananaZKEVMContractor_SequenceBatches_Call { - _c.Call.Return(run) - return _c -} - -// NewRollupBananaZKEVMContractor creates a new instance of RollupBananaZKEVMContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRollupBananaZKEVMContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *RollupBananaZKEVMContractor { - mock := &RollupBananaZKEVMContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_validium_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_validium_contractor.go deleted file mode 100644 index 0d94c081..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_validium_contractor.go +++ /dev/null @@ -1,104 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - polygonvalidiumetrog "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// RollupElderberryValidiumContractor is an autogenerated mock type for the rollupElderberryValidiumContractor type -type RollupElderberryValidiumContractor struct { - mock.Mock -} - -type RollupElderberryValidiumContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *RollupElderberryValidiumContractor) EXPECT() *RollupElderberryValidiumContractor_Expecter { - return &RollupElderberryValidiumContractor_Expecter{mock: &_m.Mock} -} - -// SequenceBatchesValidium provides a mock function with given fields: opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage -func (_m *RollupElderberryValidiumContractor) SequenceBatchesValidium(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { - ret := _m.Called(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) - - if len(ret) == 0 { - panic("no return value specified for SequenceBatchesValidium") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint64, uint64, common.Address, []byte) (*types.Transaction, error)); ok { - return rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) - } - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint64, uint64, common.Address, []byte) *types.Transaction); ok { - r0 = rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint64, uint64, common.Address, []byte) error); ok { - r1 = rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupElderberryValidiumContractor_SequenceBatchesValidium_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SequenceBatchesValidium' -type RollupElderberryValidiumContractor_SequenceBatchesValidium_Call struct { - *mock.Call -} - -// SequenceBatchesValidium is a helper method to define mock.On call -// - opts *bind.TransactOpts -// - batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData -// - maxSequenceTimestamp uint64 -// - initSequencedBatch uint64 -// - l2Coinbase common.Address -// - dataAvailabilityMessage []byte -func (_e *RollupElderberryValidiumContractor_Expecter) SequenceBatchesValidium(opts interface{}, batches interface{}, maxSequenceTimestamp interface{}, initSequencedBatch interface{}, l2Coinbase interface{}, dataAvailabilityMessage interface{}) *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call { - return &RollupElderberryValidiumContractor_SequenceBatchesValidium_Call{Call: _e.mock.On("SequenceBatchesValidium", opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage)} -} - -func (_c *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call) Run(run func(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte)) *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.TransactOpts), args[1].([]polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData), args[2].(uint64), args[3].(uint64), args[4].(common.Address), args[5].([]byte)) - }) - return _c -} - -func (_c *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call) Return(_a0 *types.Transaction, _a1 error) *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call) RunAndReturn(run func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonValidiumEtrogValidiumBatchData, uint64, uint64, common.Address, []byte) (*types.Transaction, error)) *RollupElderberryValidiumContractor_SequenceBatchesValidium_Call { - _c.Call.Return(run) - return _c -} - -// NewRollupElderberryValidiumContractor creates a new instance of RollupElderberryValidiumContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRollupElderberryValidiumContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *RollupElderberryValidiumContractor { - mock := &RollupElderberryValidiumContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_zkevm_contractor.go b/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_zkevm_contractor.go deleted file mode 100644 index 1ed208ab..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/rollup_elderberry_zkevm_contractor.go +++ /dev/null @@ -1,103 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - bind "github.com/ethereum/go-ethereum/accounts/abi/bind" - common "github.com/ethereum/go-ethereum/common" - - mock "github.com/stretchr/testify/mock" - - polygonvalidiumetrog "github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry/polygonvalidiumetrog" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// RollupElderberryZKEVMContractor is an autogenerated mock type for the rollupElderberryZKEVMContractor type -type RollupElderberryZKEVMContractor struct { - mock.Mock -} - -type RollupElderberryZKEVMContractor_Expecter struct { - mock *mock.Mock -} - -func (_m *RollupElderberryZKEVMContractor) EXPECT() *RollupElderberryZKEVMContractor_Expecter { - return &RollupElderberryZKEVMContractor_Expecter{mock: &_m.Mock} -} - -// SequenceBatches provides a mock function with given fields: opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase -func (_m *RollupElderberryZKEVMContractor) SequenceBatches(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address) (*types.Transaction, error) { - ret := _m.Called(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) - - if len(ret) == 0 { - panic("no return value specified for SequenceBatches") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint64, uint64, common.Address) (*types.Transaction, error)); ok { - return rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) - } - if rf, ok := ret.Get(0).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint64, uint64, common.Address) *types.Transaction); ok { - r0 = rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint64, uint64, common.Address) error); ok { - r1 = rf(opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// RollupElderberryZKEVMContractor_SequenceBatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SequenceBatches' -type RollupElderberryZKEVMContractor_SequenceBatches_Call struct { - *mock.Call -} - -// SequenceBatches is a helper method to define mock.On call -// - opts *bind.TransactOpts -// - batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData -// - maxSequenceTimestamp uint64 -// - initSequencedBatch uint64 -// - l2Coinbase common.Address -func (_e *RollupElderberryZKEVMContractor_Expecter) SequenceBatches(opts interface{}, batches interface{}, maxSequenceTimestamp interface{}, initSequencedBatch interface{}, l2Coinbase interface{}) *RollupElderberryZKEVMContractor_SequenceBatches_Call { - return &RollupElderberryZKEVMContractor_SequenceBatches_Call{Call: _e.mock.On("SequenceBatches", opts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase)} -} - -func (_c *RollupElderberryZKEVMContractor_SequenceBatches_Call) Run(run func(opts *bind.TransactOpts, batches []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address)) *RollupElderberryZKEVMContractor_SequenceBatches_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*bind.TransactOpts), args[1].([]polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData), args[2].(uint64), args[3].(uint64), args[4].(common.Address)) - }) - return _c -} - -func (_c *RollupElderberryZKEVMContractor_SequenceBatches_Call) Return(_a0 *types.Transaction, _a1 error) *RollupElderberryZKEVMContractor_SequenceBatches_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *RollupElderberryZKEVMContractor_SequenceBatches_Call) RunAndReturn(run func(*bind.TransactOpts, []polygonvalidiumetrog.PolygonRollupBaseEtrogBatchData, uint64, uint64, common.Address) (*types.Transaction, error)) *RollupElderberryZKEVMContractor_SequenceBatches_Call { - _c.Call.Return(run) - return _c -} - -// NewRollupElderberryZKEVMContractor creates a new instance of RollupElderberryZKEVMContractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRollupElderberryZKEVMContractor(t interface { - mock.TestingT - Cleanup(func()) -}) *RollupElderberryZKEVMContractor { - mock := &RollupElderberryZKEVMContractor{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/mocks_txbuilder/tx_builder.go b/sequencesender/txbuilder/mocks_txbuilder/tx_builder.go deleted file mode 100644 index bebb7dd2..00000000 --- a/sequencesender/txbuilder/mocks_txbuilder/tx_builder.go +++ /dev/null @@ -1,367 +0,0 @@ -// Code generated by mockery. DO NOT EDIT. - -package mocks_txbuilder - -import ( - context "context" - - common "github.com/ethereum/go-ethereum/common" - - datastream "github.com/agglayer/aggkit/state/datastream" - - mock "github.com/stretchr/testify/mock" - - seqsendertypes "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - - txbuilder "github.com/agglayer/aggkit/sequencesender/txbuilder" - - types "github.com/ethereum/go-ethereum/core/types" -) - -// TxBuilder is an autogenerated mock type for the TxBuilder type -type TxBuilder struct { - mock.Mock -} - -type TxBuilder_Expecter struct { - mock *mock.Mock -} - -func (_m *TxBuilder) EXPECT() *TxBuilder_Expecter { - return &TxBuilder_Expecter{mock: &_m.Mock} -} - -// BuildSequenceBatchesTx provides a mock function with given fields: ctx, sequences -func (_m *TxBuilder) BuildSequenceBatchesTx(ctx context.Context, sequences seqsendertypes.Sequence) (*types.Transaction, error) { - ret := _m.Called(ctx, sequences) - - if len(ret) == 0 { - panic("no return value specified for BuildSequenceBatchesTx") - } - - var r0 *types.Transaction - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, seqsendertypes.Sequence) (*types.Transaction, error)); ok { - return rf(ctx, sequences) - } - if rf, ok := ret.Get(0).(func(context.Context, seqsendertypes.Sequence) *types.Transaction); ok { - r0 = rf(ctx, sequences) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.Transaction) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, seqsendertypes.Sequence) error); ok { - r1 = rf(ctx, sequences) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilder_BuildSequenceBatchesTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildSequenceBatchesTx' -type TxBuilder_BuildSequenceBatchesTx_Call struct { - *mock.Call -} - -// BuildSequenceBatchesTx is a helper method to define mock.On call -// - ctx context.Context -// - sequences seqsendertypes.Sequence -func (_e *TxBuilder_Expecter) BuildSequenceBatchesTx(ctx interface{}, sequences interface{}) *TxBuilder_BuildSequenceBatchesTx_Call { - return &TxBuilder_BuildSequenceBatchesTx_Call{Call: _e.mock.On("BuildSequenceBatchesTx", ctx, sequences)} -} - -func (_c *TxBuilder_BuildSequenceBatchesTx_Call) Run(run func(ctx context.Context, sequences seqsendertypes.Sequence)) *TxBuilder_BuildSequenceBatchesTx_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(seqsendertypes.Sequence)) - }) - return _c -} - -func (_c *TxBuilder_BuildSequenceBatchesTx_Call) Return(_a0 *types.Transaction, _a1 error) *TxBuilder_BuildSequenceBatchesTx_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilder_BuildSequenceBatchesTx_Call) RunAndReturn(run func(context.Context, seqsendertypes.Sequence) (*types.Transaction, error)) *TxBuilder_BuildSequenceBatchesTx_Call { - _c.Call.Return(run) - return _c -} - -// NewBatchFromL2Block provides a mock function with given fields: l2Block -func (_m *TxBuilder) NewBatchFromL2Block(l2Block *datastream.L2Block) seqsendertypes.Batch { - ret := _m.Called(l2Block) - - if len(ret) == 0 { - panic("no return value specified for NewBatchFromL2Block") - } - - var r0 seqsendertypes.Batch - if rf, ok := ret.Get(0).(func(*datastream.L2Block) seqsendertypes.Batch); ok { - r0 = rf(l2Block) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Batch) - } - } - - return r0 -} - -// TxBuilder_NewBatchFromL2Block_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBatchFromL2Block' -type TxBuilder_NewBatchFromL2Block_Call struct { - *mock.Call -} - -// NewBatchFromL2Block is a helper method to define mock.On call -// - l2Block *datastream.L2Block -func (_e *TxBuilder_Expecter) NewBatchFromL2Block(l2Block interface{}) *TxBuilder_NewBatchFromL2Block_Call { - return &TxBuilder_NewBatchFromL2Block_Call{Call: _e.mock.On("NewBatchFromL2Block", l2Block)} -} - -func (_c *TxBuilder_NewBatchFromL2Block_Call) Run(run func(l2Block *datastream.L2Block)) *TxBuilder_NewBatchFromL2Block_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*datastream.L2Block)) - }) - return _c -} - -func (_c *TxBuilder_NewBatchFromL2Block_Call) Return(_a0 seqsendertypes.Batch) *TxBuilder_NewBatchFromL2Block_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilder_NewBatchFromL2Block_Call) RunAndReturn(run func(*datastream.L2Block) seqsendertypes.Batch) *TxBuilder_NewBatchFromL2Block_Call { - _c.Call.Return(run) - return _c -} - -// NewSequence provides a mock function with given fields: ctx, batches, coinbase -func (_m *TxBuilder) NewSequence(ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address) (seqsendertypes.Sequence, error) { - ret := _m.Called(ctx, batches, coinbase) - - if len(ret) == 0 { - panic("no return value specified for NewSequence") - } - - var r0 seqsendertypes.Sequence - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)); ok { - return rf(ctx, batches, coinbase) - } - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address) seqsendertypes.Sequence); ok { - r0 = rf(ctx, batches, coinbase) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Sequence) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []seqsendertypes.Batch, common.Address) error); ok { - r1 = rf(ctx, batches, coinbase) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilder_NewSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSequence' -type TxBuilder_NewSequence_Call struct { - *mock.Call -} - -// NewSequence is a helper method to define mock.On call -// - ctx context.Context -// - batches []seqsendertypes.Batch -// - coinbase common.Address -func (_e *TxBuilder_Expecter) NewSequence(ctx interface{}, batches interface{}, coinbase interface{}) *TxBuilder_NewSequence_Call { - return &TxBuilder_NewSequence_Call{Call: _e.mock.On("NewSequence", ctx, batches, coinbase)} -} - -func (_c *TxBuilder_NewSequence_Call) Run(run func(ctx context.Context, batches []seqsendertypes.Batch, coinbase common.Address)) *TxBuilder_NewSequence_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]seqsendertypes.Batch), args[2].(common.Address)) - }) - return _c -} - -func (_c *TxBuilder_NewSequence_Call) Return(_a0 seqsendertypes.Sequence, _a1 error) *TxBuilder_NewSequence_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilder_NewSequence_Call) RunAndReturn(run func(context.Context, []seqsendertypes.Batch, common.Address) (seqsendertypes.Sequence, error)) *TxBuilder_NewSequence_Call { - _c.Call.Return(run) - return _c -} - -// NewSequenceIfWorthToSend provides a mock function with given fields: ctx, sequenceBatches, l2Coinbase, batchNumber -func (_m *TxBuilder) NewSequenceIfWorthToSend(ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64) (seqsendertypes.Sequence, error) { - ret := _m.Called(ctx, sequenceBatches, l2Coinbase, batchNumber) - - if len(ret) == 0 { - panic("no return value specified for NewSequenceIfWorthToSend") - } - - var r0 seqsendertypes.Sequence - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) (seqsendertypes.Sequence, error)); ok { - return rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } - if rf, ok := ret.Get(0).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) seqsendertypes.Sequence); ok { - r0 = rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(seqsendertypes.Sequence) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, []seqsendertypes.Batch, common.Address, uint64) error); ok { - r1 = rf(ctx, sequenceBatches, l2Coinbase, batchNumber) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// TxBuilder_NewSequenceIfWorthToSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSequenceIfWorthToSend' -type TxBuilder_NewSequenceIfWorthToSend_Call struct { - *mock.Call -} - -// NewSequenceIfWorthToSend is a helper method to define mock.On call -// - ctx context.Context -// - sequenceBatches []seqsendertypes.Batch -// - l2Coinbase common.Address -// - batchNumber uint64 -func (_e *TxBuilder_Expecter) NewSequenceIfWorthToSend(ctx interface{}, sequenceBatches interface{}, l2Coinbase interface{}, batchNumber interface{}) *TxBuilder_NewSequenceIfWorthToSend_Call { - return &TxBuilder_NewSequenceIfWorthToSend_Call{Call: _e.mock.On("NewSequenceIfWorthToSend", ctx, sequenceBatches, l2Coinbase, batchNumber)} -} - -func (_c *TxBuilder_NewSequenceIfWorthToSend_Call) Run(run func(ctx context.Context, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, batchNumber uint64)) *TxBuilder_NewSequenceIfWorthToSend_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].([]seqsendertypes.Batch), args[2].(common.Address), args[3].(uint64)) - }) - return _c -} - -func (_c *TxBuilder_NewSequenceIfWorthToSend_Call) Return(_a0 seqsendertypes.Sequence, _a1 error) *TxBuilder_NewSequenceIfWorthToSend_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *TxBuilder_NewSequenceIfWorthToSend_Call) RunAndReturn(run func(context.Context, []seqsendertypes.Batch, common.Address, uint64) (seqsendertypes.Sequence, error)) *TxBuilder_NewSequenceIfWorthToSend_Call { - _c.Call.Return(run) - return _c -} - -// SetCondNewSeq provides a mock function with given fields: cond -func (_m *TxBuilder) SetCondNewSeq(cond txbuilder.CondNewSequence) txbuilder.CondNewSequence { - ret := _m.Called(cond) - - if len(ret) == 0 { - panic("no return value specified for SetCondNewSeq") - } - - var r0 txbuilder.CondNewSequence - if rf, ok := ret.Get(0).(func(txbuilder.CondNewSequence) txbuilder.CondNewSequence); ok { - r0 = rf(cond) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(txbuilder.CondNewSequence) - } - } - - return r0 -} - -// TxBuilder_SetCondNewSeq_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCondNewSeq' -type TxBuilder_SetCondNewSeq_Call struct { - *mock.Call -} - -// SetCondNewSeq is a helper method to define mock.On call -// - cond txbuilder.CondNewSequence -func (_e *TxBuilder_Expecter) SetCondNewSeq(cond interface{}) *TxBuilder_SetCondNewSeq_Call { - return &TxBuilder_SetCondNewSeq_Call{Call: _e.mock.On("SetCondNewSeq", cond)} -} - -func (_c *TxBuilder_SetCondNewSeq_Call) Run(run func(cond txbuilder.CondNewSequence)) *TxBuilder_SetCondNewSeq_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(txbuilder.CondNewSequence)) - }) - return _c -} - -func (_c *TxBuilder_SetCondNewSeq_Call) Return(_a0 txbuilder.CondNewSequence) *TxBuilder_SetCondNewSeq_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilder_SetCondNewSeq_Call) RunAndReturn(run func(txbuilder.CondNewSequence) txbuilder.CondNewSequence) *TxBuilder_SetCondNewSeq_Call { - _c.Call.Return(run) - return _c -} - -// String provides a mock function with no fields -func (_m *TxBuilder) String() string { - ret := _m.Called() - - if len(ret) == 0 { - panic("no return value specified for String") - } - - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } - - return r0 -} - -// TxBuilder_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' -type TxBuilder_String_Call struct { - *mock.Call -} - -// String is a helper method to define mock.On call -func (_e *TxBuilder_Expecter) String() *TxBuilder_String_Call { - return &TxBuilder_String_Call{Call: _e.mock.On("String")} -} - -func (_c *TxBuilder_String_Call) Run(run func()) *TxBuilder_String_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *TxBuilder_String_Call) Return(_a0 string) *TxBuilder_String_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *TxBuilder_String_Call) RunAndReturn(run func() string) *TxBuilder_String_Call { - _c.Call.Return(run) - return _c -} - -// NewTxBuilder creates a new instance of TxBuilder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewTxBuilder(t interface { - mock.TestingT - Cleanup(func()) -}) *TxBuilder { - mock := &TxBuilder{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/sequencesender/txbuilder/validium_cond_num_batches.go b/sequencesender/txbuilder/validium_cond_num_batches.go deleted file mode 100644 index 947551bd..00000000 --- a/sequencesender/txbuilder/validium_cond_num_batches.go +++ /dev/null @@ -1,34 +0,0 @@ -package txbuilder - -import ( - "context" - - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/ethereum/go-ethereum/common" -) - -var MaxBatchesForL1Disabled = uint64(0) - -type ConditionalNewSequenceNumBatches struct { - maxBatchesForL1 uint64 // cfg.MaxBatchesForL1 -} - -func NewConditionalNewSequenceNumBatches(maxBatchesForL1 uint64) *ConditionalNewSequenceNumBatches { - return &ConditionalNewSequenceNumBatches{ - maxBatchesForL1: maxBatchesForL1, - } -} - -func (c *ConditionalNewSequenceNumBatches) NewSequenceIfWorthToSend( - ctx context.Context, txBuilder TxBuilder, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, -) (seqsendertypes.Sequence, error) { - if c.maxBatchesForL1 != MaxBatchesForL1Disabled && uint64(len(sequenceBatches)) >= c.maxBatchesForL1 { - log.Infof( - "sequence should be sent to L1, because MaxBatchesForL1 (%d) has been reached", - c.maxBatchesForL1, - ) - return txBuilder.NewSequence(ctx, sequenceBatches, l2Coinbase) - } - return nil, nil -} diff --git a/sequencesender/txbuilder/validium_cond_num_batches_test.go b/sequencesender/txbuilder/validium_cond_num_batches_test.go deleted file mode 100644 index 882dbe77..00000000 --- a/sequencesender/txbuilder/validium_cond_num_batches_test.go +++ /dev/null @@ -1,46 +0,0 @@ -package txbuilder_test - -import ( - "context" - "testing" - - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestConditionalNumBatchesDisabled(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceNumBatches(0) - - tx, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, nil, common.Address{}) - require.NoError(t, err) - require.Nil(t, tx) -} - -// It have 1 batch and minium are 2, so no new sequence -func TestConditionalNumBatchesDontFulfillCondition(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceNumBatches(2) - var sequenceBatches []seqsendertypes.Batch - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - tx, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, sequenceBatches, common.Address{}) - require.NoError(t, err) - require.Nil(t, tx) -} - -// It have 2 batch and minium are 2, so new sequence -func TestConditionalNumBatchesFulfillCondition(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceNumBatches(2) - var sequenceBatches []seqsendertypes.Batch - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - mockTxBuilder.EXPECT().NewSequence(context.TODO(), mock.Anything, mock.Anything).Return(nil, nil) - tx, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, sequenceBatches, common.Address{}) - require.NoError(t, err) - require.Nil(t, tx) -} diff --git a/sequencesender/txbuilder/zkevm_cond_max_size.go b/sequencesender/txbuilder/zkevm_cond_max_size.go deleted file mode 100644 index d07077d7..00000000 --- a/sequencesender/txbuilder/zkevm_cond_max_size.go +++ /dev/null @@ -1,124 +0,0 @@ -package txbuilder - -import ( - "context" - "errors" - "fmt" - - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/log" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/ethereum/go-ethereum/common" -) - -var ( - // ErrOversizedData when transaction input data is greater than a limit (DOS protection) - ErrOversizedData = errors.New("oversized data") - MaxTxSizeForL1Disabled = uint64(0) -) - -type ConditionalNewSequenceMaxSize struct { - maxTxSizeForL1 uint64 // cfg.MaxTxSizeForL1 -} - -func NewConditionalNewSequenceMaxSize(maxTxSizeForL1 uint64) *ConditionalNewSequenceMaxSize { - return &ConditionalNewSequenceMaxSize{ - maxTxSizeForL1: maxTxSizeForL1, - } -} - -func (c *ConditionalNewSequenceMaxSize) NewSequenceIfWorthToSend( - ctx context.Context, txBuilder TxBuilder, sequenceBatches []seqsendertypes.Batch, l2Coinbase common.Address, -) (seqsendertypes.Sequence, error) { - if c.maxTxSizeForL1 == MaxTxSizeForL1Disabled { - log.Debugf("maxTxSizeForL1 is %d, so is disabled", MaxTxSizeForL1Disabled) - return nil, nil - } - sequence, err := txBuilder.NewSequence(ctx, sequenceBatches, l2Coinbase) - if err != nil { - return nil, err - } - if sequence == nil { - err = fmt.Errorf("error txBuilder.NewSequence, returns sequence=nil and err==nil, is not expected") - log.Errorf(err.Error()) - return nil, err - } - - // Check if can be sent - tx, err := txBuilder.BuildSequenceBatchesTx(ctx, sequence) - if tx == nil && err == nil { - err = fmt.Errorf("error txBuilder.BuildSequenceBatchesTx, returns tx=nil and err==nil, is not expected") - log.Errorf(err.Error()) - return nil, err - } - if err == nil && tx != nil && tx.Size() > c.maxTxSizeForL1 { - log.Infof("Oversized Data on TX oldHash %s (txSize %d > %d)", tx.Hash(), tx.Size(), c.maxTxSizeForL1) - err = ErrOversizedData - } - - if err != nil { - log.Debugf("Handling estimate gas send sequence error: %v", err) - sequenceBatches, err = handleEstimateGasSendSequenceErr(sequence.Batches(), err) - if sequenceBatches != nil { - // Handling the error gracefully, re-processing the sequence as a sanity check - sequence, err = txBuilder.NewSequence(ctx, sequenceBatches, l2Coinbase) - if err != nil { - return nil, err - } - - txReduced, err := txBuilder.BuildSequenceBatchesTx(ctx, sequence) - log.Debugf("After reducing batches: (txSize %d -> %d)", tx.Size(), txReduced.Size()) - if err == nil && txReduced != nil && txReduced.Size() > c.maxTxSizeForL1 { - log.Warnf("After reducing batches: (txSize %d -> %d) is still too big > %d", - tx.Size(), txReduced.Size(), c.maxTxSizeForL1, - ) - } - return sequence, err - } - - return sequence, err - } - log.Debugf( - "Current size:%d < max_size:%d num_batches: %d, no sequence promoted yet", - tx.Size(), c.maxTxSizeForL1, sequence.Len(), - ) - return nil, nil -} - -// handleEstimateGasSendSequenceErr handles an error on the estimate gas. -// Results: (nil,nil)=requires waiting, (nil,error)=no handled gracefully, (seq,nil) handled gracefully -func handleEstimateGasSendSequenceErr( - sequenceBatches []seqsendertypes.Batch, err error, -) ([]seqsendertypes.Batch, error) { - // Insufficient allowance - if errors.Is(err, etherman.ErrInsufficientAllowance) { - return nil, err - } - errMsg := fmt.Sprintf("due to unknown error: %v", err) - if isDataForEthTxTooBig(err) { - errMsg = fmt.Sprintf("caused the L1 tx to be too big: %v", err) - } - var adjustMsg string - if len(sequenceBatches) > 1 { - lastPrevious := sequenceBatches[len(sequenceBatches)-1].BatchNumber() - sequenceBatches = sequenceBatches[:len(sequenceBatches)-1] - lastCurrent := sequenceBatches[len(sequenceBatches)-1].BatchNumber() - adjustMsg = fmt.Sprintf( - "removing last batch: old BatchNumber:%d -> %d, new length: %d", - lastPrevious, lastCurrent, len(sequenceBatches), - ) - } else { - sequenceBatches = nil - adjustMsg = "removing all batches" - log.Warnf("No more batches to remove, sequence is empty... it could be a deadlock situation") - } - log.Infof("Adjusted sequence, %s, because %s", adjustMsg, errMsg) - return sequenceBatches, nil -} - -// isDataForEthTxTooBig checks if tx oversize error -func isDataForEthTxTooBig(err error) bool { - return errors.Is(err, etherman.ErrGasRequiredExceedsAllowance) || - errors.Is(err, ErrOversizedData) || - errors.Is(err, etherman.ErrContentLengthTooLarge) -} diff --git a/sequencesender/txbuilder/zkevm_cond_max_size_test.go b/sequencesender/txbuilder/zkevm_cond_max_size_test.go deleted file mode 100644 index 541ef661..00000000 --- a/sequencesender/txbuilder/zkevm_cond_max_size_test.go +++ /dev/null @@ -1,95 +0,0 @@ -package txbuilder_test - -import ( - "context" - "testing" - - "github.com/agglayer/aggkit/etherman" - "github.com/agglayer/aggkit/sequencesender/seqsendertypes" - "github.com/agglayer/aggkit/sequencesender/txbuilder" - "github.com/agglayer/aggkit/sequencesender/txbuilder/mocks_txbuilder" - "github.com/ethereum/go-ethereum/common" - ethtypes "github.com/ethereum/go-ethereum/core/types" - "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" -) - -func TestConditionalMaxSizeDisabled(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceMaxSize(txbuilder.MaxTxSizeForL1Disabled) - - tx, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, nil, common.Address{}) - require.NoError(t, err) - require.Nil(t, tx) -} - -func TestConditionalMaxSizeTxBuilderNewSequenceReturnsNil(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceMaxSize(1024) - var sequenceBatches []seqsendertypes.Batch - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - mockTxBuilder.EXPECT().NewSequence(context.TODO(), sequenceBatches, common.Address{}).Return(nil, nil) - _, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, sequenceBatches, common.Address{}) - require.Error(t, err) -} - -func TestConditionalMaxSizeTxBuilderBuildSequenceBatchesTxReturnsNil(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceMaxSize(1024) - var sequenceBatches []seqsendertypes.Batch - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - seq := &txbuilder.ElderberrySequence{} - mockTxBuilder.EXPECT().NewSequence(context.TODO(), sequenceBatches, common.Address{}).Return(seq, nil) - mockTxBuilder.EXPECT().BuildSequenceBatchesTx(mock.Anything, mock.Anything).Return(nil, nil) - _, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, sequenceBatches, common.Address{}) - require.Error(t, err) -} - -func TestConditionalMaxSizeTxBuilderDontFulFill(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceMaxSize(1024) - var sequenceBatches []seqsendertypes.Batch - sequenceBatches = append(sequenceBatches, &txbuilder.BananaBatch{}) - seq := &txbuilder.ElderberrySequence{} - mockTxBuilder.EXPECT().NewSequence(context.TODO(), sequenceBatches, common.Address{}).Return(seq, nil) - inner := ðtypes.LegacyTx{} - tx := ethtypes.NewTx(inner) - mockTxBuilder.EXPECT().BuildSequenceBatchesTx(mock.Anything, mock.Anything).Return(tx, nil) - - res, err := sut.NewSequenceIfWorthToSend(context.TODO(), mockTxBuilder, sequenceBatches, common.Address{}) - - require.NoError(t, err) - require.Nil(t, res) -} - -func TestConditionalMaxSizeTxBuilderFulFill(t *testing.T) { - mockTxBuilder := mocks_txbuilder.NewTxBuilder(t) - sut := txbuilder.NewConditionalNewSequenceMaxSize(10) - l2coinbase := common.Address{} - ctx := context.TODO() - - newSeq := newTestSeq(3, 100, l2coinbase) - mockTxBuilder.EXPECT().NewSequence(context.TODO(), newSeq.Batches(), l2coinbase).Return(newSeq, nil) - inner := ðtypes.LegacyTx{ - Data: []byte{0x01, 0x02, 0x03, 0x04}, - } - tx := ethtypes.NewTx(inner) - mockTxBuilder.EXPECT().BuildSequenceBatchesTx(ctx, newSeq).Return(tx, nil) - // The size of result Tx is 14 that is > 10, so it reduce 1 batch - newSeqReduced := newTestSeq(2, 100, l2coinbase) - mockTxBuilder.EXPECT().NewSequence(context.TODO(), newSeqReduced.Batches(), l2coinbase).Return(newSeqReduced, nil) - mockTxBuilder.EXPECT().BuildSequenceBatchesTx(ctx, newSeqReduced).Return(tx, nil) - - res, err := sut.NewSequenceIfWorthToSend(ctx, mockTxBuilder, newSeq.Batches(), l2coinbase) - - require.NoError(t, err) - require.NotNil(t, res) -} - -func newTestSeq(numBatches int, firstBatch uint64, l2coinbase common.Address) *txbuilder.ElderberrySequence { - var sequenceBatches []seqsendertypes.Batch - for i := 0; i < numBatches; i++ { - sequenceBatches = append(sequenceBatches, txbuilder.NewBananaBatch(ðerman.Batch{BatchNumber: firstBatch + uint64(i)})) - } - return txbuilder.NewElderberrySequence(sequenceBatches, l2coinbase) -} diff --git a/test/Makefile b/test/Makefile index 46492f87..66148f53 100644 --- a/test/Makefile +++ b/test/Makefile @@ -1,10 +1,12 @@ .PHONY: generate-mocks generate-mocks: generate-mocks-bridgesync generate-mocks-reorgdetector \ - generate-mocks-sequencesender generate-mocks-da \ + generate-mocks-da \ generate-mocks-l1infotreesync generate-mocks-helpers \ generate-mocks-sync generate-mocks-aggregator \ generate-mocks-aggsender generate-mocks-agglayer +COMMON_MOCKERY_PARAMS=--disable-version-string --with-expecter --exported + .PHONY: generate-mocks-bridgesync generate-mocks-bridgesync: ## Generates mocks for bridgesync, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --all --case snake --dir ../bridgesync --output ../bridgesync/mocks --outpkg mocks_bridgesync ${COMMON_MOCKERY_PARAMS} @@ -13,18 +15,6 @@ generate-mocks-bridgesync: ## Generates mocks for bridgesync, using mockery tool generate-mocks-reorgdetector: ## Generates mocks for reorgdetector, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=EthClient --dir=../reorgdetector --output=../reorgdetector --outpkg=reorgdetector --inpackage --structname=EthClientMock --filename=mock_eth_client.go ${COMMON_MOCKERY_PARAMS} -COMMON_MOCKERY_PARAMS=--disable-version-string --with-expecter --exported -.PHONY: generate-mocks-sequencesender -generate-mocks-sequencesender: ## Generates mocks for sequencesender, using mockery tool - export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --all --case snake --dir ../sequencesender/txbuilder --output ../sequencesender/txbuilder/mocks_txbuilder --outpkg mocks_txbuilder ${COMMON_MOCKERY_PARAMS} - export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=EthTxManager --dir=../sequencesender --output=../sequencesender/mocks --outpkg=mocks --structname=EthTxManagerMock --filename=mock_ethtxmanager.go ${COMMON_MOCKERY_PARAMS} - export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=Etherman --dir=../sequencesender --output=../sequencesender/mocks --outpkg=mocks --structname=EthermanMock --filename=mock_etherman.go ${COMMON_MOCKERY_PARAMS} - export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=RPCInterface --dir=../sequencesender --output=../sequencesender/mocks --outpkg=mocks --structname=RPCInterfaceMock --filename=mock_rpc.go ${COMMON_MOCKERY_PARAMS} - -.PHONY: generate-mocks-da -generate-mocks-da: ## Generates mocks for dataavailability, using mockery tool - export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --all --case snake --dir ../dataavailability --output ../dataavailability/mocks_da --outpkg mocks_da ${COMMON_MOCKERY_PARAMS} - .PHONY: generate-mocks-rpc generate-mocks-rpc: ## Generates mocks for rpc, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --all --case snake --dir ../rpc --output ../rpc/mocks --outpkg mocks ${COMMON_MOCKERY_PARAMS} @@ -50,7 +40,6 @@ generate-mocks-sync: ## Generates mocks for sync, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=processorInterface --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ProcessorMock --filename=mock_processor_test.go ${COMMON_MOCKERY_PARAMS} export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=ReorgDetector --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ReorgDetectorMock --filename=mock_reorgdetector_test.go ${COMMON_MOCKERY_PARAMS} - .PHONY: generate-mocks-aggregator generate-mocks-aggregator: ## Generates mocks for aggregator, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=ProverInterface --dir=../aggregator --output=../aggregator/mocks --outpkg=mocks --structname=ProverInterfaceMock --filename=mock_prover.go ${COMMON_MOCKERY_PARAMS} @@ -62,7 +51,6 @@ generate-mocks-aggregator: ## Generates mocks for aggregator, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=RPCInterface --dir=../aggregator --output=../aggregator/mocks --outpkg=mocks --structname=RPCInterfaceMock --filename=mock_rpc.go ${COMMON_MOCKERY_PARAMS} export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=AggregatorService_ChannelServer --dir=../aggregator/prover --output=../aggregator/prover/mocks --outpkg=mocks --structname=ChannelMock --filename=mock_channel.go ${COMMON_MOCKERY_PARAMS} - .PHONY: generate-mocks-aggsender generate-mocks-aggsender: ## Generates mocks for aggsender, using mockery tool export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --all --case snake --dir ../aggsender --output ../aggsender/mocks --outpkg mocks ${COMMON_MOCKERY_PARAMS} diff --git a/test/config/test.config.toml b/test/config/test.config.toml index 7ed0e7b0..36eea7a3 100644 --- a/test/config/test.config.toml +++ b/test/config/test.config.toml @@ -2,40 +2,6 @@ IsValidiumMode = false ContractVersions = "banana" -[SequenceSender] -WaitPeriodSendSequence = "15s" -LastBatchVirtualizationTimeMaxWaitPeriod = "10s" -L1BlockTimestampMargin = "30s" -MaxTxSizeForL1 = 131072 -L2Coinbase = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266" -PrivateKey = {Path = "./test/sequencer.keystore", Password = "testonly"} -SequencesTxFileName = "sequencesender.json" -GasOffset = 80000 -WaitPeriodPurgeTxFile = "60m" -MaxPendingTx = 1 -RPCURL = "http://127.0.0.1:8123" -GetBatchWaitInterval = "10s" - [SequenceSender.EthTxManager] - FrequencyToMonitorTxs = "1s" - WaitTxToBeMined = "2m" - GetReceiptMaxTime = "250ms" - GetReceiptWaitInterval = "1s" - PrivateKeys = [ - {Path = "./test/sequencer.keystore", Password = "testonly"}, - ] - ForcedGas = 0 - GasPriceMarginFactor = 1 - MaxGasPriceLimit = 0 - StoragePath = "ethtxmanager.db" - ReadPendingL1Txs = false - SafeStatusL1NumberOfBlocks = 5 - FinalizedStatusL1NumberOfBlocks = 10 - [SequenceSender.EthTxManager.Etherman] - URL = "http://127.0.0.1:8545" - MultiGasProvider = false - L1ChainID = 1337 - HTTPHeaders = [] - [Aggregator] Host = "0.0.0.0" Port = 50081