test: add test for multiple rollups using the same namespace (#1613)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.
-->

## Overview

A new test has been added to `full_node_integration_test.go` to simulate
multiple rollups within the same namespace. This helps validate the
operation of the app in a more complex environment. Additional debugging
information is also now logged in `manager.go` if a block from an
unexpected sequencer is skipped.

Resolves #883 

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 
-->

## Checklist

<!-- 
Please complete the checklist to ensure that the PR is ready to be
reviewed.

IMPORTANT:
PRs should be left in Draft until the below checklist is completed.
-->

- [x] New and updated code has appropriate documentation
- [x] New and updated code has new and/or updated testing
- [x] Required CI checks are passing
- [x] Visual proof for any user facing features like CLI or
documentation updates
- [x] Linked issues closed with keywords


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit


- **New Features**
- Introduced a new integration test for validating the functionality of
two rollup networks within a single namespace.
- **Bug Fixes**
- Enhanced block processing logic to skip blocks from unexpected
sequencers under specific conditions.
- **Tests**
- Added support for `chainID` parameter in test setup functions to
facilitate more comprehensive testing scenarios.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: tzdybal

block/manager.go

@@ -634,6 +634,9 @@ func (m *Manager) processNextDABlock(ctx context.Context) error {
 			for _, block := range blockResp.Blocks {
 				// early validation to reject junk blocks
 				if !m.isUsingExpectedCentralizedSequencer(block) {
+					m.logger.Debug("skipping block from unexpected sequencer",
+						"blockHeight", block.Height(),
+						"blockHash", block.Hash().String())
 					continue
 				}
 				blockHash := block.Hash().String()

node/full_node_integration_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	goDA "github.com/rollkit/go-da"
+	"github.com/rollkit/rollkit/block"
 	"github.com/rollkit/rollkit/config"
 	"github.com/rollkit/rollkit/da"
 	test "github.com/rollkit/rollkit/test/log"
@@ -93,7 +94,7 @@ func TestTxGossipingAndAggregation(t *testing.T) {
 	clientNodes := 4
 	aggCtx := context.Background()
 	ctx := context.Background()
-	nodes, apps := createNodes(aggCtx, ctx, clientNodes+1, getBMConfig(), t)
+	nodes, apps := createNodes(aggCtx, ctx, clientNodes+1, getBMConfig(), types.TestChainID, t)
 	startNodes(nodes, apps, t)
 	defer func() {
 		for _, n := range nodes {
@@ -235,7 +236,7 @@ func TestFastDASync(t *testing.T) {
 	const numberOfBlocksToSyncTill = 5
 
 	// Create the 2 nodes
-	nodes, _ := createNodes(aggCtx, ctx, clientNodes, bmConfig, t)
+	nodes, _ := createNodes(aggCtx, ctx, clientNodes, bmConfig, types.TestChainID, t)
 
 	node1 := nodes[0]
 	node2 := nodes[1]
@@ -328,7 +329,7 @@ func TestSingleAggregatorTwoFullNodesBlockSyncSpeed(t *testing.T) {
 			return
 		}
 	}()
-	nodes, _ := createNodes(aggCtx, ctx, clientNodes, bmConfig, t)
+	nodes, _ := createNodes(aggCtx, ctx, clientNodes, bmConfig, types.TestChainID, t)
 
 	node1 := nodes[0]
 	node2 := nodes[1]
@@ -386,6 +387,7 @@ func TestSubmitBlocksToDA(t *testing.T) {
 			DABlockTime: 20 * time.Millisecond,
 			BlockTime:   10 * time.Millisecond,
 		},
+		types.TestChainID,
 		t,
 	)
 	seq := nodes[0]
@@ -408,6 +410,121 @@ func TestSubmitBlocksToDA(t *testing.T) {
 	}
 }
 
+func TestTwoRollupsInOneNamespace(t *testing.T) {
+	cases := []struct {
+		name     string
+		chainID1 string
+		chainID2 string
+	}{
+		{
+			name:     "same chain ID",
+			chainID1: "test-1",
+			chainID2: "test-1",
+		},
+		{
+			name:     "different chain IDs",
+			chainID1: "foo-1",
+			chainID2: "bar-2",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			doTestTwoRollupsInOneNamespace(t, tc.chainID1, tc.chainID1)
+		})
+	}
+}
+
+func doTestTwoRollupsInOneNamespace(t *testing.T, chainID1, chainID2 string) {
+	require := require.New(t)
+
+	const (
+		n             = 2
+		daStartHeight = 1
+		daMempoolTTL  = 5
+		blockTime1    = 100 * time.Millisecond
+		blockTime2    = 50 * time.Millisecond
+	)
+
+	mainCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	agg1Ctx := context.WithoutCancel(mainCtx)
+	nodes1Ctx := context.WithoutCancel(mainCtx)
+
+	rollupNetwork1, apps1 := createNodes(agg1Ctx, nodes1Ctx, n, config.BlockManagerConfig{
+		BlockTime:     blockTime1,
+		DABlockTime:   blockTime1,
+		DAStartHeight: daStartHeight,
+		DAMempoolTTL:  daMempoolTTL,
+	}, chainID1, t)
+
+	require.Len(rollupNetwork1, n)
+	require.Len(apps1, n)
+
+	agg2Ctx := context.WithoutCancel(mainCtx)
+	nodes2Ctx := context.WithoutCancel(mainCtx)
+
+	rollupNetwork2, apps2 := createNodes(agg2Ctx, nodes2Ctx, n, config.BlockManagerConfig{
+		BlockTime:     blockTime2,
+		DABlockTime:   blockTime2,
+		DAStartHeight: daStartHeight,
+		DAMempoolTTL:  daMempoolTTL,
+	}, chainID2, t)
+
+	require.Len(rollupNetwork2, n)
+	require.Len(apps2, n)
+
+	// same mock DA has to be used by all nodes to simulate posting to/retrieving from same namespace
+	dalc := getMockDA(t)
+	for _, node := range append(rollupNetwork1, rollupNetwork2...) {
+		node.dalc = dalc
+		node.blockManager.SetDALC(dalc)
+	}
+
+	agg1 := rollupNetwork1[0]
+	agg2 := rollupNetwork2[0]
+
+	node1 := rollupNetwork1[1]
+	node2 := rollupNetwork2[1]
+
+	// start both aggregators and wait for 10 blocks
+	require.NoError(agg1.Start())
+	require.NoError(agg2.Start())
+
+	require.NoError(waitForAtLeastNBlocks(agg1, 10, Store))
+	require.NoError(waitForAtLeastNBlocks(agg2, 10, Store))
+
+	// get the number of submitted blocks from aggregators before stopping (as it closes the store)
+	lastSubmittedHeight1 := getLastSubmittedHeight(agg1Ctx, agg1, t)
+	lastSubmittedHeight2 := getLastSubmittedHeight(agg2Ctx, agg2, t)
+
+	// make sure that there are any blocks for syncing
+	require.Greater(lastSubmittedHeight1, 1)
+	require.Greater(lastSubmittedHeight2, 1)
+
+	// now stop the aggregators and run the full nodes to ensure sync from D
+	require.NoError(agg1.Stop())
+	require.NoError(agg2.Stop())
+
+	startNodeWithCleanup(t, node1)
+	startNodeWithCleanup(t, node2)
+
+	// check that full nodes are able to sync blocks from DA
+	require.NoError(waitForAtLeastNBlocks(node1, lastSubmittedHeight1, Store))
+	require.NoError(waitForAtLeastNBlocks(node2, lastSubmittedHeight2, Store))
+}
+
+func getLastSubmittedHeight(ctx context.Context, node *FullNode, t *testing.T) int {
+	raw, err := node.Store.GetMetadata(ctx, block.LastSubmittedHeightKey)
+	require.NoError(t, err)
+	require.NotEmpty(t, raw)
+
+	val, err := strconv.ParseUint(string(raw), 10, 64)
+	require.NoError(t, err)
+	return int(val)
+}
+
 func TestMaxPending(t *testing.T) {
 	cases := []struct {
 		name       string
@@ -449,6 +566,7 @@ func doTestMaxPending(maxPending uint64, t *testing.T) {
 			BlockTime:        10 * time.Millisecond,
 			MaxPendingBlocks: maxPending,
 		},
+		types.TestChainID,
 		t,
 	)
 	seq := nodes[0]
@@ -499,7 +617,7 @@ func testSingleAggregatorSingleFullNode(t *testing.T, source Source) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	clientNodes := 2
-	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), t)
+	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), types.TestChainID, t)
 
 	node1 := nodes[0]
 	node2 := nodes[1]
@@ -521,7 +639,7 @@ func testSingleAggregatorTwoFullNode(t *testing.T, source Source) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	clientNodes := 3
-	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), t)
+	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), types.TestChainID, t)
 
 	node1 := nodes[0]
 	node2 := nodes[1]
@@ -548,7 +666,7 @@ func testSingleAggregatorSingleFullNodeTrustedHash(t *testing.T, source Source)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	clientNodes := 2
-	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), t)
+	nodes, _ := createNodes(aggCtx, ctx, clientNodes, getBMConfig(), types.TestChainID, t)
 
 	node1 := nodes[0]
 	node2 := nodes[1]
@@ -583,7 +701,7 @@ func testSingleAggregatorSingleFullNodeSingleLightNode(t *testing.T) {
 	bmConfig := getBMConfig()
 	sequencer, _ := createAndConfigureNode(aggCtx, 0, true, false, keys, bmConfig, dalc, t)
 	fullNode, _ := createAndConfigureNode(ctx, 1, false, false, keys, bmConfig, dalc, t)
-	lightNode, _ := createNode(ctx, 2, false, true, keys, bmConfig, t)
+	lightNode, _ := createNode(ctx, 2, false, true, keys, bmConfig, types.TestChainID, t)
 
 	startNodeWithCleanup(t, sequencer)
 	startNodeWithCleanup(t, fullNode)
@@ -654,7 +772,7 @@ func startNodes(nodes []*FullNode, apps []*mocks.Application, t *testing.T) {
 }
 
 // Creates the given number of nodes the given nodes using the given wait group to synchornize them
-func createNodes(aggCtx, ctx context.Context, num int, bmConfig config.BlockManagerConfig, t *testing.T) ([]*FullNode, []*mocks.Application) {
+func createNodes(aggCtx, ctx context.Context, num int, bmConfig config.BlockManagerConfig, chainID string, t *testing.T) ([]*FullNode, []*mocks.Application) {
 	t.Helper()
 
 	if aggCtx == nil {
@@ -673,14 +791,14 @@ func createNodes(aggCtx, ctx context.Context, num int, bmConfig config.BlockMana
 	nodes := make([]*FullNode, num)
 	apps := make([]*mocks.Application, num)
 	dalc := getMockDA(t)
-	node, app := createNode(aggCtx, 0, true, false, keys, bmConfig, t)
+	node, app := createNode(aggCtx, 0, true, false, keys, bmConfig, chainID, t)
 	apps[0] = app
 	nodes[0] = node.(*FullNode)
 	// use same, common DALC, so nodes can share data
 	nodes[0].dalc = dalc
 	nodes[0].blockManager.SetDALC(dalc)
 	for i := 1; i < num; i++ {
-		node, apps[i] = createNode(ctx, i, false, false, keys, bmConfig, t)
+		node, apps[i] = createNode(ctx, i, false, false, keys, bmConfig, chainID, t)
 		nodes[i] = node.(*FullNode)
 		nodes[i].dalc = dalc
 		nodes[i].blockManager.SetDALC(dalc)
@@ -689,7 +807,7 @@ func createNodes(aggCtx, ctx context.Context, num int, bmConfig config.BlockMana
 	return nodes, apps
 }
 
-func createNode(ctx context.Context, n int, aggregator bool, isLight bool, keys []crypto.PrivKey, bmConfig config.BlockManagerConfig, t *testing.T) (Node, *mocks.Application) {
+func createNode(ctx context.Context, n int, aggregator bool, isLight bool, keys []crypto.PrivKey, bmConfig config.BlockManagerConfig, chainID string, t *testing.T) (Node, *mocks.Application) {
 	t.Helper()
 	require := require.New(t)
 	// nodes will listen on consecutive ports on local interface
@@ -727,7 +845,7 @@ func createNode(ctx context.Context, n int, aggregator bool, isLight bool, keys
 		},
 	}
 
-	genesis := &cmtypes.GenesisDoc{ChainID: "test", Validators: genesisValidators}
+	genesis := &cmtypes.GenesisDoc{ChainID: chainID, Validators: genesisValidators}
 	// TODO: need to investigate why this needs to be done for light nodes
 	genesis.InitialHeight = 1
 	node, err := NewNode(
@@ -754,7 +872,7 @@ func createNode(ctx context.Context, n int, aggregator bool, isLight bool, keys
 
 func createAndConfigureNode(ctx context.Context, n int, aggregator bool, isLight bool, keys []crypto.PrivKey, bmConfig config.BlockManagerConfig, dalc *da.DAClient, t *testing.T) (Node, *mocks.Application) {
 	t.Helper()
-	node, app := createNode(ctx, n, aggregator, isLight, keys, bmConfig, t)
+	node, app := createNode(ctx, n, aggregator, isLight, keys, bmConfig, types.TestChainID, t)
 	node.(*FullNode).dalc = dalc
 	node.(*FullNode).blockManager.SetDALC(dalc)
 

node/helpers_test.go

@@ -15,6 +15,7 @@ import (
 
 	goDATest "github.com/rollkit/go-da/test"
 	"github.com/rollkit/rollkit/da"
+	"github.com/rollkit/rollkit/types"
 )
 
 func getMockDA(t *testing.T) *da.DAClient {
@@ -44,7 +45,7 @@ func TestGetNodeHeight(t *testing.T) {
 	}
 	bmConfig := getBMConfig()
 	fullNode, _ := createAndConfigureNode(ctx, 0, true, false, keys, bmConfig, dalc, t)
-	lightNode, _ := createNode(ctx, 1, true, true, keys, bmConfig, t)
+	lightNode, _ := createNode(ctx, 1, true, true, keys, bmConfig, types.TestChainID, t)
 
 	startNodeWithCleanup(t, fullNode)
 	startNodeWithCleanup(t, lightNode)