Skip to content

Commit 2cd9462

Browse files
julienrbrtjulienrbrt
committed
fix changes from #3098 
1 parent 014a25c commit 2cd9462

File tree

1 file changed

+58
-56
lines changed

1 file changed

+58
-56
lines changed

‎test/e2e/evm_force_inclusion_e2e_test.go‎

Lines changed: 58 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -614,11 +614,12 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
614614
// ===== PHASE 1: Setup - Start Sequencer and Sync Node =====
615615
t.Log("Phase 1: Setup - Start Sequencer and Sync Node")
616616

617-
jwtSecret, fullNodeJwtSecret, genesisHash, endpoints, _ := setupCommonEVMTest(t, sut, true)
617+
dockerClient, networkID := tastoradocker.Setup(t)
618+
env := setupCommonEVMEnv(t, sut, dockerClient, networkID, WithFullNode())
618619

619620
// Create passphrase and JWT secret files for sequencer
620621
seqPassphraseFile := createPassphraseFile(t, sequencerHome)
621-
seqJwtSecretFile := createJWTSecretFile(t, sequencerHome, jwtSecret)
622+
seqJwtSecretFile := createJWTSecretFile(t, sequencerHome, env.SequencerJWT)
622623

623624
// Initialize sequencer node
624625
output, err := sut.RunCmd(evmSingleBinaryPath,
@@ -648,57 +649,57 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
648649
seqProcess := sut.ExecCmd(evmSingleBinaryPath,
649650
"start",
650651
"--evm.jwt-secret-file", seqJwtSecretFile,
651-
"--evm.genesis-hash", genesisHash,
652+
"--evm.genesis-hash", env.GenesisHash,
652653
"--evnode.node.block_time", DefaultBlockTime,
653654
"--evnode.node.aggregator=true",
654655
"--evnode.signer.passphrase_file", seqPassphraseFile,
655656
"--home", sequencerHome,
656657
"--evnode.da.block_time", DefaultDABlockTime,
657-
"--evnode.da.address", endpoints.GetDAAddress(),
658+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
658659
"--evnode.da.namespace", DefaultDANamespace,
659660
"--evnode.da.forced_inclusion_namespace", "forced-inc",
660-
"--evnode.rpc.address", endpoints.GetRollkitRPCListen(),
661-
"--evnode.p2p.listen_address", endpoints.GetRollkitP2PAddress(),
662-
"--evm.engine-url", endpoints.GetSequencerEngineURL(),
663-
"--evm.eth-url", endpoints.GetSequencerEthURL(),
661+
"--evnode.rpc.address", env.Endpoints.GetRollkitRPCListen(),
662+
"--evnode.p2p.listen_address", env.Endpoints.GetRollkitP2PAddress(),
663+
"--evm.engine-url", env.Endpoints.GetSequencerEngineURL(),
664+
"--evm.eth-url", env.Endpoints.GetSequencerEthURL(),
664665
)
665-
sut.AwaitNodeUp(t, endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
666+
sut.AwaitNodeUp(t, env.Endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
666667
t.Log("Sequencer is up with force inclusion enabled")
667668

668669
// Get sequencer P2P address for sync node to connect to
669-
sequencerP2PAddress := getNodeP2PAddress(t, sut, sequencerHome, endpoints.RollkitRPCPort)
670+
sequencerP2PAddress := getNodeP2PAddress(t, sut, sequencerHome, env.Endpoints.RollkitRPCPort)
670671
t.Logf("Sequencer P2P address: %s", sequencerP2PAddress)
671672

672673
// Create JWT secret file for full node
673-
fnJwtSecretFile := createJWTSecretFile(t, fullNodeHome, fullNodeJwtSecret)
674+
fnJwtSecretFile := createJWTSecretFile(t, fullNodeHome, env.FullNodeJWT)
674675

675676
// Start sync node (full node) - connects to sequencer via P2P
676677
fnProcess := sut.ExecCmd(evmSingleBinaryPath,
677678
"start",
678679
"--evm.jwt-secret-file", fnJwtSecretFile,
679-
"--evm.genesis-hash", genesisHash,
680+
"--evm.genesis-hash", env.GenesisHash,
680681
"--home", fullNodeHome,
681682
"--evnode.da.block_time", DefaultDABlockTime,
682-
"--evnode.da.address", endpoints.GetDAAddress(),
683+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
683684
"--evnode.da.namespace", DefaultDANamespace,
684685
"--evnode.da.forced_inclusion_namespace", "forced-inc",
685-
"--evnode.rpc.address", endpoints.GetFullNodeRPCListen(),
686-
"--evnode.p2p.listen_address", endpoints.GetFullNodeP2PAddress(),
686+
"--evnode.rpc.address", env.Endpoints.GetFullNodeRPCListen(),
687+
"--evnode.p2p.listen_address", env.Endpoints.GetFullNodeP2PAddress(),
687688
"--evnode.p2p.peers", sequencerP2PAddress,
688-
"--evm.engine-url", endpoints.GetFullNodeEngineURL(),
689-
"--evm.eth-url", endpoints.GetFullNodeEthURL(),
689+
"--evm.engine-url", env.Endpoints.GetFullNodeEngineURL(),
690+
"--evm.eth-url", env.Endpoints.GetFullNodeEthURL(),
690691
)
691-
sut.AwaitNodeLive(t, endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
692+
sut.AwaitNodeLive(t, env.Endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
692693
t.Log("Sync node (full node) is up and syncing from sequencer")
693694

694695
// ===== PHASE 2: Send Transactions and Wait for Sync =====
695696
t.Log("Phase 2: Send Transactions and Wait for Sync")
696697

697-
seqClient, err := ethclient.Dial(endpoints.GetSequencerEthURL())
698+
seqClient, err := ethclient.Dial(env.Endpoints.GetSequencerEthURL())
698699
require.NoError(t, err)
699700
defer seqClient.Close()
700701

701-
fnClient, err := ethclient.Dial(endpoints.GetFullNodeEthURL())
702+
fnClient, err := ethclient.Dial(env.Endpoints.GetFullNodeEthURL())
702703
require.NoError(t, err)
703704
defer fnClient.Close()
704705

@@ -754,29 +755,29 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
754755
"--evnode.node.aggregator=true",
755756
"--evnode.node.based_sequencer=true",
756757
"--evm.jwt-secret-file", fnJwtSecretFile,
757-
"--evm.genesis-hash", genesisHash,
758+
"--evm.genesis-hash", env.GenesisHash,
758759
"--home", fullNodeHome,
759760
"--evnode.da.block_time", DefaultDABlockTime,
760-
"--evnode.da.address", endpoints.GetDAAddress(),
761+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
761762
"--evnode.da.namespace", DefaultDANamespace,
762763
"--evnode.da.forced_inclusion_namespace", "forced-inc",
763-
"--evnode.rpc.address", endpoints.GetFullNodeRPCListen(),
764-
"--evnode.p2p.listen_address", endpoints.GetFullNodeP2PAddress(),
765-
"--evm.engine-url", endpoints.GetFullNodeEngineURL(),
766-
"--evm.eth-url", endpoints.GetFullNodeEthURL(),
764+
"--evnode.rpc.address", env.Endpoints.GetFullNodeRPCListen(),
765+
"--evnode.p2p.listen_address", env.Endpoints.GetFullNodeP2PAddress(),
766+
"--evm.engine-url", env.Endpoints.GetFullNodeEngineURL(),
767+
"--evm.eth-url", env.Endpoints.GetFullNodeEthURL(),
767768
)
768-
sut.AwaitNodeLive(t, endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
769+
sut.AwaitNodeLive(t, env.Endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
769770
t.Log("Sync node restarted as based sequencer")
770771

771772
// Reconnect to based sequencer
772-
basedSeqClient, err := ethclient.Dial(endpoints.GetFullNodeEthURL())
773+
basedSeqClient, err := ethclient.Dial(env.Endpoints.GetFullNodeEthURL())
773774
require.NoError(t, err)
774775
defer basedSeqClient.Close()
775776

776777
// ===== PHASE 5: Submit Forced Inclusion Transactions to DA =====
777778
t.Log("Phase 5: Submit Forced Inclusion Transactions to DA")
778779

779-
blobClient, err := blobrpc.NewClient(ctx, endpoints.GetDAAddress(), "", "")
780+
blobClient, err := blobrpc.NewClient(ctx, env.Endpoints.GetDAAddress(), "", "")
780781
require.NoError(t, err, "Failed to create blob RPC client")
781782
defer blobClient.Close()
782783

@@ -841,25 +842,25 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
841842
seqProcess = sut.ExecCmd(evmSingleBinaryPath,
842843
"start",
843844
"--evm.jwt-secret-file", seqJwtSecretFile,
844-
"--evm.genesis-hash", genesisHash,
845+
"--evm.genesis-hash", env.GenesisHash,
845846
"--evnode.node.block_time", DefaultBlockTime,
846847
"--evnode.node.aggregator=true",
847848
"--evnode.signer.passphrase_file", seqPassphraseFile,
848849
"--home", sequencerHome,
849850
"--evnode.da.block_time", DefaultDABlockTime,
850-
"--evnode.da.address", endpoints.GetDAAddress(),
851+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
851852
"--evnode.da.namespace", DefaultDANamespace,
852853
"--evnode.da.forced_inclusion_namespace", "forced-inc",
853-
"--evnode.rpc.address", endpoints.GetRollkitRPCListen(),
854-
"--evnode.p2p.listen_address", endpoints.GetRollkitP2PAddress(),
855-
"--evm.engine-url", endpoints.GetSequencerEngineURL(),
856-
"--evm.eth-url", endpoints.GetSequencerEthURL(),
854+
"--evnode.rpc.address", env.Endpoints.GetRollkitRPCListen(),
855+
"--evnode.p2p.listen_address", env.Endpoints.GetRollkitP2PAddress(),
856+
"--evm.engine-url", env.Endpoints.GetSequencerEngineURL(),
857+
"--evm.eth-url", env.Endpoints.GetSequencerEthURL(),
857858
)
858-
sut.AwaitNodeUp(t, endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
859+
sut.AwaitNodeUp(t, env.Endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
859860
t.Log("Sequencer restarted successfully")
860861

861862
// Reconnect to sequencer
862-
seqClient, err = ethclient.Dial(endpoints.GetSequencerEthURL())
863+
seqClient, err = ethclient.Dial(env.Endpoints.GetSequencerEthURL())
863864
require.NoError(t, err)
864865

865866
// ===== PHASE 8: Verify Sequencer Catches Up =====
@@ -900,23 +901,23 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
900901
fnProcess = sut.ExecCmd(evmSingleBinaryPath,
901902
"start",
902903
"--evm.jwt-secret-file", fnJwtSecretFile,
903-
"--evm.genesis-hash", genesisHash,
904+
"--evm.genesis-hash", env.GenesisHash,
904905
"--home", fullNodeHome,
905906
"--evnode.da.block_time", DefaultDABlockTime,
906-
"--evnode.da.address", endpoints.GetDAAddress(),
907+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
907908
"--evnode.da.namespace", DefaultDANamespace,
908909
"--evnode.da.forced_inclusion_namespace", "forced-inc",
909-
"--evnode.rpc.address", endpoints.GetFullNodeRPCListen(),
910-
"--evnode.p2p.listen_address", endpoints.GetFullNodeP2PAddress(),
910+
"--evnode.rpc.address", env.Endpoints.GetFullNodeRPCListen(),
911+
"--evnode.p2p.listen_address", env.Endpoints.GetFullNodeP2PAddress(),
911912
"--evnode.p2p.peers", sequencerP2PAddress,
912-
"--evm.engine-url", endpoints.GetFullNodeEngineURL(),
913-
"--evm.eth-url", endpoints.GetFullNodeEthURL(),
913+
"--evm.engine-url", env.Endpoints.GetFullNodeEngineURL(),
914+
"--evm.eth-url", env.Endpoints.GetFullNodeEthURL(),
914915
)
915-
sut.AwaitNodeLive(t, endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
916+
sut.AwaitNodeLive(t, env.Endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
916917
t.Log("Sync node restarted as normal full node")
917918

918919
// Reconnect to sync node
919-
fnClient, err = ethclient.Dial(endpoints.GetFullNodeEthURL())
920+
fnClient, err = ethclient.Dial(env.Endpoints.GetFullNodeEthURL())
920921
require.NoError(t, err)
921922

922923
// ===== PHASE 10: Verify Nodes Are in Sync =====
@@ -972,11 +973,12 @@ func TestEvmBasedSequencerBaselineE2E(t *testing.T) {
972973

973974
t.Log("Setting up fresh based sequencer from genesis")
974975

975-
jwtSecret, _, genesisHash, endpoints, _ := setupCommonEVMTest(t, sut, false)
976+
dockerClient, networkID := tastoradocker.Setup(t)
977+
env := setupCommonEVMEnv(t, sut, dockerClient, networkID, WithFullNode())
976978

977979
// Create passphrase and JWT secret files
978980
passphraseFile := createPassphraseFile(t, basedSeqHome)
979-
jwtSecretFile := createJWTSecretFile(t, basedSeqHome, jwtSecret)
981+
jwtSecretFile := createJWTSecretFile(t, basedSeqHome, env.SequencerJWT)
980982

981983
// Initialize based sequencer node
982984
output, err := sut.RunCmd(evmSingleBinaryPath,
@@ -998,32 +1000,32 @@ func TestEvmBasedSequencerBaselineE2E(t *testing.T) {
9981000
"--evnode.node.aggregator=true",
9991001
"--evnode.node.based_sequencer=true",
10001002
"--evm.jwt-secret-file", jwtSecretFile,
1001-
"--evm.genesis-hash", genesisHash,
1003+
"--evm.genesis-hash", env.GenesisHash,
10021004
"--evnode.node.block_time", DefaultBlockTime,
10031005
"--evnode.signer.passphrase_file", passphraseFile,
10041006
"--home", basedSeqHome,
10051007
"--evnode.da.block_time", DefaultDABlockTime,
1006-
"--evnode.da.address", endpoints.GetDAAddress(),
1008+
"--evnode.da.address", env.Endpoints.GetDAAddress(),
10071009
"--evnode.da.namespace", DefaultDANamespace,
10081010
"--evnode.da.forced_inclusion_namespace", "forced-inc",
1009-
"--evnode.rpc.address", endpoints.GetRollkitRPCListen(),
1010-
"--evnode.p2p.listen_address", endpoints.GetRollkitP2PAddress(),
1011-
"--evm.engine-url", endpoints.GetSequencerEngineURL(),
1012-
"--evm.eth-url", endpoints.GetSequencerEthURL(),
1011+
"--evnode.rpc.address", env.Endpoints.GetRollkitRPCListen(),
1012+
"--evnode.p2p.listen_address", env.Endpoints.GetRollkitP2PAddress(),
1013+
"--evm.engine-url", env.Endpoints.GetSequencerEngineURL(),
1014+
"--evm.eth-url", env.Endpoints.GetSequencerEthURL(),
10131015
"--evnode.log.level", "debug",
10141016
)
1015-
sut.AwaitNodeUp(t, endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
1017+
sut.AwaitNodeUp(t, env.Endpoints.GetRollkitRPCAddress(), NodeStartupTimeout)
10161018
t.Log("Based sequencer is up")
10171019

10181020
// Connect to based sequencer
1019-
basedSeqClient, err := ethclient.Dial(endpoints.GetSequencerEthURL())
1021+
basedSeqClient, err := ethclient.Dial(env.Endpoints.GetSequencerEthURL())
10201022
require.NoError(t, err)
10211023
defer basedSeqClient.Close()
10221024

10231025
ctx := context.Background()
10241026

10251027
t.Log("Submitting forced inclusion transactions to DA")
1026-
blobClient, err := blobrpc.NewClient(ctx, endpoints.GetDAAddress(), "", "")
1028+
blobClient, err := blobrpc.NewClient(ctx, env.Endpoints.GetDAAddress(), "", "")
10271029
require.NoError(t, err, "Failed to create blob RPC client")
10281030
defer blobClient.Close()
10291031

0 commit comments

Comments
 (0)