test: add multi chain configuration

framework/docker/evmsingle_with_reth_test.go

@@ -23,7 +23,7 @@ func TestEvmSingle_WithReth(t *testing.T) {
 	require.NoError(t, err)
 
 	ctx := context.Background()
-	enodes := stack.EVM.Nodes()
+	enodes := stack.EvmSeq.Nodes()
 	require.Len(t, enodes, 1)
 
 	networkInfo, err := enodes[0].GetNetworkInfo(ctx)

framework/docker/evstack/reth/builder.go

@@ -23,6 +23,7 @@ type NodeBuilder struct {
 	bin                 string
 	genesis             []byte
 	jwtSecretHex        string
+	nextIndex           int
 }
 
 func NewNodeBuilder(t *testing.T) *NodeBuilder {
@@ -104,10 +105,12 @@ func (b *NodeBuilder) Build(ctx context.Context) (*Node, error) {
 		GenesisFileBz:       b.genesis,
 	}
 
-	n, err := newNode(ctx, cfg, b.testName, 0)
+	index := b.nextIndex
+	n, err := newNode(ctx, cfg, b.testName, index)
 	if err != nil {
 		return nil, err
 	}
+	b.nextIndex++
 
 	return n, nil
 }

framework/docker/helpers_test.go

@@ -20,5 +20,20 @@ func DeployMinimalStack(t *testing.T, cfg *TestSetupConfig) (deploy.Stack, error
 		return deploy.Stack{}, fmt.Errorf("deploy: %w", err)
 	}
 
-	return deploy.Stack{Celestia: deployed.Celestia, DA: deployed.DA, Reth: deployed.Reth, EVM: deployed.EVM}, nil
+	return deploy.Stack{Celestia: deployed.Celestia, DA: deployed.DA, Reth: deployed.Reth, EvmSeq: deployed.EvmSeq}, nil
+}
+
+// DeployMultiChainStack is a test helper that spins up a fully-wired stack:
+// - celestia-app (1 validator)
+// - celestia-node (1 bridge) pointed at celestia-app
+// - two evolve chain stacks containg (1 evm-single sequencer node and 1 reth execution client)
+func DeployMultiChainStack(t *testing.T, cfg *TestSetupConfig) (*deploy.MultiChainStack, error) {
+	t.Helper()
+
+	deployed, err := deploy.DeployMultiChain(cfg.Ctx, cfg.ChainBuilder, cfg.DANetworkBuilder, cfg.RethBuilder, cfg.EVMSingleChainBuilder)
+	if err != nil {
+		return &deploy.MultiChainStack{}, fmt.Errorf("deploy: %w", err)
+	}
+
+	return deployed, nil
 }

framework/docker/multi_chain_test.go

@@ -0,0 +1,42 @@
+package docker
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMultiChain(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping due to short mode")
+	}
+	t.Parallel()
+
+	// provision the full stack with defaults.
+	testCfg := setupDockerTest(t)
+	stack, err := DeployMultiChainStack(t, testCfg)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	evnodes := stack.EvmSeq1.Nodes()
+	require.Len(t, evnodes, 1)
+
+	networkInfo, err := evnodes[0].GetNetworkInfo(ctx)
+	require.NoError(t, err)
+	require.NotEmpty(t, networkInfo.External.Ports.RPC)
+
+	healthURL := fmt.Sprintf("http://0.0.0.0:%s/health/ready", networkInfo.External.Ports.RPC)
+	require.Eventually(t, func() bool {
+		req, _ := http.NewRequestWithContext(ctx, http.MethodGet, healthURL, nil)
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			return false
+		}
+		defer func() { _ = resp.Body.Close() }()
+		return resp.StatusCode == http.StatusOK
+	}, 60*time.Second, 2*time.Second, "evm-single did not become healthy")
+}

framework/testutil/deploy/deploy.go

@@ -27,7 +27,18 @@ type Stack struct {
 	Celestia *cosmos.Chain
 	DA       *da.Network
 	Reth     *reth.Node
-	EVM      *evmsingle.Chain
+	EvmSeq   *evmsingle.Chain
+}
+
+type MultiChainStack struct {
+	Celestia *cosmos.Chain
+	DA       *da.Network
+
+	Reth1   *reth.Node
+	EvmSeq1 *evmsingle.Chain
+
+	Reth2   *reth.Node
+	EvmSeq2 *evmsingle.Chain
 }
 
 // WithDefaults deploys a celestia chain, a da network, a reth node and evm single in with default values
@@ -97,7 +108,34 @@ func Deploy(ctx context.Context, chainBuilder *cosmos.ChainBuilder, daBuilder *d
 		Celestia: celestia,
 		DA:       daNetwork,
 		Reth:     rethNode,
-		EVM:      evmSingle,
+		EvmSeq:   evmSingle,
+	}, nil
+}
+
+// DeployMultiChain deploys a 2 chain evolve stack with the provided set of builders. Every component is wired up together and started.
+func DeployMultiChain(ctx context.Context, chainBuilder *cosmos.ChainBuilder, daBuilder *da.NetworkBuilder, rethBuilder *reth.NodeBuilder, evmBuilder *evmsingle.ChainBuilder) (*MultiChainStack, error) {
+	celestia, daNetwork, err := CelestiaWithDA(ctx, chainBuilder, daBuilder)
+	if err != nil {
+		return nil, err
+	}
+
+	rethNode1, evmSingle1, err := RethWithEVMSingle(ctx, rethBuilder, evmBuilder, daNetwork)
+	if err != nil {
+		return nil, err
+	}
+
+	rethNode2, evmSingle2, err := RethWithEVMSingle(ctx, rethBuilder, evmBuilder, daNetwork)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MultiChainStack{
+		Celestia: celestia,
+		DA:       daNetwork,
+		Reth1:    rethNode1,
+		EvmSeq1:  evmSingle1,
+		Reth2:    rethNode2,
+		EvmSeq2:  evmSingle2,
 	}, nil
 }