feat(p2p): disable peer discovery for the sequencer

block/manager_test.go

@@ -76,6 +76,7 @@ func TestInitialState(t *testing.T) {
 		BootstrapRetryTime:           30 * time.Second,
 		BlockSyncRequestIntervalTime: 30 * time.Second,
 		BlockSyncEnabled:             true,
+		DiscoveryEnabled:             true,
 	}, privKey, "TestChain", emptyStore, pubsubServer, datastore.NewMapDatastore(), logger)
 	assert.NoError(err)
 	assert.NotNil(p2pClient)

config/config_test.go

@@ -222,6 +222,7 @@ func fullNodeConfig() config.NodeConfig {
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 			ListenAddress:                config.DefaultListenAddress,
 			BootstrapNodes:               "",
+			DiscoveryEnabled:             true,
 		},
 	}
 }

config/defaults.go

@@ -44,7 +44,7 @@ func DefaultConfig(home string) *NodeConfig {
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 			ListenAddress:                DefaultListenAddress,
 			BootstrapNodes:               "",
-			AdvertisingEnabled:           true,
+			DiscoveryEnabled:             true,
 			BlockSyncEnabled:             true,
 		},
 		DBConfig: DBConfig{

config/p2p.go

@@ -21,8 +21,8 @@ type P2PConfig struct {
 	BlockSyncEnabled bool `mapstructure:"p2p_blocksync_enabled"`
 	// Time interval used by a node to request missing blocks (gap between cached blocks and local height) on demand from other peers using blocksync
 	BlockSyncRequestIntervalTime time.Duration `mapstructure:"p2p_blocksync_block_request_interval"`
-	// Param used to enable the advertisement of the node to be part of the P2P network in the DHT
-	AdvertisingEnabled bool `mapstructure:"p2p_advertising_enabled"`
+	// Param used to enable the advertisement and discovery of other nodes for automatic connection to other peers in the P2P network
+	DiscoveryEnabled bool `mapstructure:"p2p_discovery_enabled"`
 }
 
 // Validate P2PConfig

config/toml.go

@@ -112,8 +112,8 @@ p2p_gossip_cache_size = {{ .P2PConfig.GossipSubCacheSize }}
 # time interval to check if no p2p nodes are connected to bootstrap again
 p2p_bootstrap_retry_time = "{{ .P2PConfig.BootstrapRetryTime }}"
 
-# set to false to disable advertising the node to the P2P network
-p2p_advertising_enabled= "{{ .P2PConfig.AdvertisingEnabled }}"
+# set to false to disable P2P nodes discovery used to auto-connect to other peers in the P2P network
+p2p_discovery_enabled= "{{ .P2PConfig.DiscoveryEnabled }}"
 
 # set to false to disable block syncing from p2p
 p2p_blocksync_enabled= "{{ .P2PConfig.BlockSyncEnabled }}"

da/weavevm/wvm.go

@@ -553,7 +553,7 @@ func (c *DataAvailabilityLayerClient) waitForTxReceipt(ctx context.Context, txHa
 			return nil
 		},
 		retry.Context(ctx),
-		retry.Attempts(uint(*c.config.RetryAttempts)),
+		retry.Attempts(uint(*c.config.RetryAttempts)), //nolint:gosec // RetryAttempts should be always positive
 		retry.Delay(c.config.RetryDelay),
 		retry.DelayType(retry.FixedDelay), // Force fixed delay between attempts
 		retry.LastErrorOnly(true),         // Only log the last error

node/node_test.go

@@ -76,6 +76,7 @@ func TestMempoolDirectly(t *testing.T) {
 			BootstrapRetryTime:           30 * time.Second,
 			BootstrapNodes:               "",
 			BlockSyncRequestIntervalTime: 30 * time.Second,
+			DiscoveryEnabled:             true,
 		},
 		RPC:           config.RPCConfig{},
 		MempoolConfig: *tmcfg.DefaultMempoolConfig(),

p2p/client.go

@@ -145,6 +145,14 @@ func (c *Client) StartWithHost(ctx context.Context, h host.Host) error {
 		return err
 	}
 
+	// to avoid any automatic p2p connectivity via dht, dht needs to be disabled
+	if !c.conf.DiscoveryEnabled {
+		c.logger.Debug("P2P discovery disabled. Blocksync disabled.")
+		// blocksync cannot be used if no dht is set
+		c.conf.BlockSyncEnabled = false
+		return nil
+	}
+
 	c.logger.Debug("Setting up DHT.")
 	err = c.setupDHT(ctx)
 	if err != nil {
@@ -391,11 +399,9 @@ func (c *Client) peerDiscovery(ctx context.Context) error {
 		return err
 	}
 
-	if c.conf.AdvertisingEnabled {
-		err = c.advertise(ctx)
-		if err != nil {
-			return err
-		}
+	err = c.advertise(ctx)
+	if err != nil {
+		return err
 	}
 
 	err = c.findPeers(ctx)

p2p/client_test.go

@@ -39,6 +39,7 @@ func TestClientStartup(t *testing.T) {
 		GossipSubCacheSize:           50,
 		BootstrapRetryTime:           30 * time.Second,
 		BlockSyncRequestIntervalTime: 30 * time.Second,
+		DiscoveryEnabled:             true,
 	}, privKey, "TestChain", store, pubsubServer, datastore.NewMapDatastore(), log.TestingLogger())
 	assert := assert.New(t)
 	assert.NoError(err)
@@ -276,6 +277,7 @@ func TestSeedStringParsing(t *testing.T) {
 			client, err := p2p.NewClient(config.P2PConfig{
 				GossipSubCacheSize: 50,
 				BootstrapRetryTime: 30 * time.Second,
+				DiscoveryEnabled:   true,
 			}, privKey, "TestNetwork", store, pubsubServer, datastore.NewMapDatastore(), logger)
 			require.NoError(err)
 			require.NotNil(client)

rpc/client/client_test.go

@@ -105,6 +105,7 @@ func TestGenesisChunked(t *testing.T) {
 			BootstrapNodes:               "",
 			GossipSubCacheSize:           50,
 			BootstrapRetryTime:           30 * time.Second,
+			DiscoveryEnabled:             true,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 		},
 		RPC: config.RPCConfig{},
@@ -864,6 +865,7 @@ func TestValidatorSetHandling(t *testing.T) {
 			BootstrapNodes:               "",
 			GossipSubCacheSize:           50,
 			BootstrapRetryTime:           30 * time.Second,
+			DiscoveryEnabled:             true,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 		},
 		BlockManagerConfig: config.BlockManagerConfig{
@@ -1022,6 +1024,7 @@ func getRPCInternal(t *testing.T, sequencer bool) (*tmmocks.MockApplication, *cl
 			BootstrapNodes:               "",
 			GossipSubCacheSize:           50,
 			BootstrapRetryTime:           30 * time.Second,
+			DiscoveryEnabled:             true,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 		},
 		RPC:           config.RPCConfig{},
@@ -1133,6 +1136,7 @@ func TestMempool2Nodes(t *testing.T) {
 			GossipSubCacheSize:           50,
 			BootstrapRetryTime:           30 * time.Second,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
+			DiscoveryEnabled:             true,
 		},
 		BlockManagerConfig: config.BlockManagerConfig{
 			BlockTime:                  100 * time.Millisecond,
@@ -1163,6 +1167,7 @@ func TestMempool2Nodes(t *testing.T) {
 			BootstrapNodes:               "/ip4/127.0.0.1/tcp/9001/p2p/" + id1.String(),
 			BootstrapRetryTime:           30 * time.Second,
 			GossipSubCacheSize:           50,
+			DiscoveryEnabled:             true,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 		},
 		MempoolConfig: *tmcfg.DefaultMempoolConfig(),

rpc/json/service_test.go

@@ -331,6 +331,7 @@ func getRPC(t *testing.T) (*tmmocks.MockApplication, *client.Client) {
 			ListenAddress:                config.DefaultListenAddress,
 			GossipSubCacheSize:           50,
 			BootstrapRetryTime:           30 * time.Second,
+			DiscoveryEnabled:             true,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 		},
 	}

testutil/block.go

@@ -102,6 +102,7 @@ func GetManagerWithProposerKey(conf config.BlockManagerConfig, proposerKey crypt
 		GossipSubCacheSize:           50,
 		BootstrapRetryTime:           30 * time.Second,
 		BlockSyncRequestIntervalTime: 30 * time.Second,
+		DiscoveryEnabled:             true,
 		BlockSyncEnabled:             true,
 	}, p2pKey, "TestChain", managerStore, pubsubServer, datastore.NewMapDatastore(), logger)
 	if err != nil {

testutil/p2p.go

@@ -116,6 +116,7 @@ func StartTestNetwork(ctx context.Context, t *testing.T, n int, conf map[int]Hos
 			BootstrapRetryTime:           30 * time.Second,
 			BlockSyncRequestIntervalTime: 30 * time.Second,
 			ListenAddress:                config.DefaultListenAddress,
+			DiscoveryEnabled:             true,
 			BlockSyncEnabled:             true,
 		},
 			mnet.Hosts()[i].Peerstore().PrivKey(mnet.Hosts()[i].ID()),