feat: Add support for avail as a DA

.golangci.yml

@@ -1,4 +1,5 @@
 run:
+  concurrency: 4
   timeout: 5m
   modules-download-mode: readonly
   # mempool and indexer code is borrowed from Tendermint
@@ -13,7 +14,6 @@ run:
 linters:
   disable-all: true
   enable:
-    - deadcode
     - errcheck
     - gofmt
     - goimports
@@ -22,10 +22,8 @@ linters:
     - ineffassign
     - misspell
     - staticcheck
-    - structcheck
     - typecheck
     - unused
-    - varcheck
     - gosec
     - gocyclo
 

block/manager.go

@@ -115,9 +115,9 @@ func NewManager(
 	}
 
 	// TODO((#119): Probably should be validated and manage default on config init.
-	if conf.BlockBatchSizeBytes == 0 {
-		logger.Info("WARNING: using default DA batch size bytes limit", "BlockBatchSizeBytes", config.DefaultNodeConfig.BlockBatchSizeBytes)
-		conf.BlockBatchSizeBytes = config.DefaultNodeConfig.BlockBatchSizeBytes
+	if conf.BlockBatchMaxSizeBytes == 0 {
+		logger.Info("WARNING: using default DA batch size bytes limit", "BlockBatchMaxSizeBytes", config.DefaultNodeConfig.BlockBatchMaxSizeBytes)
+		conf.BlockBatchMaxSizeBytes = config.DefaultNodeConfig.BlockBatchMaxSizeBytes
 	}
 	if conf.BatchSubmitMaxTime == 0 {
 		logger.Info("WARNING: using default DA batch submit max time", "BatchSubmitMaxTime", config.DefaultNodeConfig.BatchSubmitMaxTime)
@@ -315,6 +315,7 @@ func (m *Manager) ProduceBlockLoop(ctx context.Context) {
 
 	var tickerEmptyBlocksMaxTime *time.Ticker
 	var tickerEmptyBlocksMaxTimeCh <-chan time.Time
+	// Setup ticker for empty blocks if enabled
 	if m.conf.EmptyBlocksMaxTime > 0 {
 		tickerEmptyBlocksMaxTime = time.NewTicker(m.conf.EmptyBlocksMaxTime)
 		tickerEmptyBlocksMaxTimeCh = tickerEmptyBlocksMaxTime.C
@@ -330,7 +331,7 @@ func (m *Manager) ProduceBlockLoop(ctx context.Context) {
 			return
 		//Empty blocks timeout
 		case <-tickerEmptyBlocksMaxTimeCh:
-			m.logger.Debug("No transactions for too long, allowing to produce empty block")
+			m.logger.Debug(fmt.Sprintf("No transactions for %.2f seconds, producing empty block", m.conf.EmptyBlocksMaxTime.Seconds()))
 			produceEmptyBlock = true
 		//Produce block
 		case <-ticker.C:
@@ -800,7 +801,7 @@ func (m *Manager) createNextDABatch(startHeight uint64, endHeight uint64) (*type
 
 		//Check if the batch size is too big
 		totalSize := batch.ToProto().Size()
-		if totalSize > int(m.conf.BlockBatchSizeBytes) {
+		if totalSize > int(m.conf.BlockBatchMaxSizeBytes) {
 			// Nil out the last block and commit
 			batch.Blocks[len(batch.Blocks)-1] = nil
 			batch.Commits[len(batch.Commits)-1] = nil

block/manager_test.go

@@ -150,6 +150,8 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 	go manager.ProduceBlockLoop(ctx)
 	<-ctx.Done()
 	assert.Equal(t, lastStoreHeight, manager.store.Height())
+	// Wait until produce block loop is done
+	time.Sleep(time.Second * 1)
 
 	t.Log("Sync the manager")
 	ctx, cancel = context.WithTimeout(context.Background(), time.Second*2)
@@ -158,6 +160,8 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 	<-ctx.Done()
 	require.Greater(t, manager.store.Height(), lastStoreHeight)
 	assert.Equal(t, batch.EndHeight, manager.store.Height())
+	// Wait until manager is done
+	time.Sleep(time.Second * 4)
 
 	t.Log("Validate blocks are produced")
 	ctx, cancel = context.WithTimeout(context.Background(), time.Second*3)
@@ -409,7 +413,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 	// Init manager
 	managerConfig := getManagerConfig()
 	managerConfig.BlockBatchSize = 1000
-	managerConfig.BlockBatchSizeBytes = batchLimitBytes //enough for 2 block, not enough for 10 blocks
+	managerConfig.BlockBatchMaxSizeBytes = batchLimitBytes //enough for 2 block, not enough for 10 blocks
 	manager, err := getManager(managerConfig, nil, nil, 1, 1, 0, proxyApp, nil)
 	require.NoError(err)
 
@@ -447,7 +451,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 			assert.NoError(err)
 
 			assert.Equal(batch.StartHeight, startHeight)
-			assert.LessOrEqual(batch.ToProto().Size(), int(managerConfig.BlockBatchSizeBytes))
+			assert.LessOrEqual(batch.ToProto().Size(), int(managerConfig.BlockBatchMaxSizeBytes))
 
 			if !tc.expectedToBeTruncated {
 				assert.Equal(batch.EndHeight, endHeight)
@@ -457,7 +461,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 
 				//validate next added block to batch would have been actually too big
 				//First relax the byte limit so we could proudce larger batch
-				manager.conf.BlockBatchSizeBytes = 10 * manager.conf.BlockBatchSizeBytes
+				manager.conf.BlockBatchMaxSizeBytes = 10 * manager.conf.BlockBatchMaxSizeBytes
 				newBatch, err := manager.createNextDABatch(startHeight, batch.EndHeight+1)
 				assert.Greater(newBatch.ToProto().Size(), batchLimitBytes)
 
@@ -580,7 +584,6 @@ func getManagerConfig() config.BlockManagerConfig {
 		BlockTime:          100 * time.Millisecond,
 		BlockBatchSize:     defaultBatchSize,
 		BatchSubmitMaxTime: 30 * time.Minute,
-		DAStartHeight:      0,
 		NamespaceID:        "0102030405060708",
 	}
 }

cmd/dymint/main.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/dymensionxyz/dymint/cmd/dymint/commands"
 	"github.com/dymensionxyz/dymint/config"
-	"github.com/tendermint/tendermint/cmd/tendermint/commands/debug"
+	"github.com/tendermint/tendermint/cmd/cometbft/commands/debug"
 	"github.com/tendermint/tendermint/libs/cli"
 )
 

config/config.go

@@ -4,7 +4,7 @@ import (
 	"path/filepath"
 	"time"
 
-	tmcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
+	tmcmd "github.com/tendermint/tendermint/cmd/cometbft/commands"
 
 	"github.com/dymensionxyz/dymint/settlement"
 	"github.com/spf13/cobra"
@@ -19,16 +19,16 @@ const (
 )
 
 const (
-	flagAggregator          = "dymint.aggregator"
-	flagDALayer             = "dymint.da_layer"
-	flagDAConfig            = "dymint.da_config"
-	flagBlockTime           = "dymint.block_time"
-	flagEmptyBlocksMaxTime  = "dymint.empty_blocks_max_time"
-	flagBatchSubmitMaxTime  = "dymint.batch_submit_max_time"
-	flagDAStartHeight       = "dymint.da_start_height"
-	flagNamespaceID         = "dymint.namespace_id"
-	flagBlockBatchSize      = "dymint.block_batch_size"
-	flagBlockBatchSizeBytes = "dymint.block_batch_size_bytes"
+	flagAggregator         = "dymint.aggregator"
+	flagDALayer            = "dymint.da_layer"
+	flagDAConfig           = "dymint.da_config"
+	flagBlockTime          = "dymint.block_time"
+	flagEmptyBlocksMaxTime = "dymint.empty_blocks_max_time"
+	flagBatchSubmitMaxTime = "dymint.batch_submit_max_time"
+	// TODO(omritoptix): Namespace ID should be part of the DA config
+	flagNamespaceID            = "dymint.namespace_id"
+	flagBlockBatchSize         = "dymint.block_batch_size"
+	flagBlockBatchMaxSizeBytes = "dymint.block_batch_max_size_bytes"
 )
 
 const (
@@ -66,13 +66,11 @@ type BlockManagerConfig struct {
 	EmptyBlocksMaxTime time.Duration `mapstructure:"empty_blocks_max_time"`
 	// BatchSubmitMaxTime defines how long should block manager wait for before submitting batch
 	BatchSubmitMaxTime time.Duration `mapstructure:"batch_submit_max_time"`
-	// DAStartHeight allows skipping first DAStartHeight-1 blocks when querying for blocks.
-	DAStartHeight uint64 `mapstructure:"da_start_height"`
-	NamespaceID   string `mapstructure:"namespace_id"`
+	NamespaceID        string        `mapstructure:"namespace_id"`
 	// The size of the batch in blocks. Every batch we'll write to the DA and the settlement layer.
 	BlockBatchSize uint64 `mapstructure:"block_batch_size"`
-	// The size of the batch in Bytes. Every batch we'll write to the DA and the settlement layer.
-	BlockBatchSizeBytes uint64 `mapstructure:"block_batch_size_bytes"`
+	// The max size of the batch in Bytes. Every batch we'll write to the DA and the settlement layer.
+	BlockBatchMaxSizeBytes uint64 `mapstructure:"block_batch_max_size_bytes"`
 }
 
 // GetViperConfig reads configuration parameters from Viper instance.
@@ -122,10 +120,9 @@ func AddNodeFlags(cmd *cobra.Command) {
 	cmd.Flags().Duration(flagBlockTime, def.BlockTime, "block time (for aggregator mode)")
 	cmd.Flags().Duration(flagEmptyBlocksMaxTime, def.EmptyBlocksMaxTime, "max time for empty blocks (for aggregator mode)")
 	cmd.Flags().Duration(flagBatchSubmitMaxTime, def.BatchSubmitMaxTime, "max time for batch submit (for aggregator mode)")
-	cmd.Flags().Uint64(flagDAStartHeight, def.DAStartHeight, "starting DA block height (for syncing)")
 	cmd.Flags().String(flagNamespaceID, def.NamespaceID, "namespace identifies (8 bytes in hex)")
 	cmd.Flags().Uint64(flagBlockBatchSize, def.BlockBatchSize, "block batch size")
-	cmd.Flags().Uint64(flagBlockBatchSizeBytes, def.BlockBatchSizeBytes, "block batch size in bytes")
+	cmd.Flags().Uint64(flagBlockBatchMaxSizeBytes, def.BlockBatchMaxSizeBytes, "block batch max size in bytes")
 
 	cmd.Flags().String(flagSettlementLayer, def.SettlementLayer, "Settlement Layer Client name")
 	cmd.Flags().String(flagSLNodeAddress, def.SettlementConfig.NodeAddress, "Settlement Layer RPC node address")
@@ -156,16 +153,13 @@ func BindDymintFlags(cmd *cobra.Command, v *viper.Viper) error {
 	if err := v.BindPFlag("batch_submit_max_time", cmd.Flags().Lookup(flagBatchSubmitMaxTime)); err != nil {
 		return err
 	}
-	if err := v.BindPFlag("da_start_height", cmd.Flags().Lookup(flagDAStartHeight)); err != nil {
-		return err
-	}
 	if err := v.BindPFlag("namespace_id", cmd.Flags().Lookup(flagNamespaceID)); err != nil {
 		return err
 	}
 	if err := v.BindPFlag("block_batch_size", cmd.Flags().Lookup(flagBlockBatchSize)); err != nil {
 		return err
 	}
-	if err := v.BindPFlag("block_batch_size_bytes", cmd.Flags().Lookup(flagBlockBatchSizeBytes)); err != nil {
+	if err := v.BindPFlag("block_batch_max_size_bytes", cmd.Flags().Lookup(flagBlockBatchMaxSizeBytes)); err != nil {
 		return err
 	}
 	if err := v.BindPFlag("settlement_layer", cmd.Flags().Lookup(flagSettlementLayer)); err != nil {

config/defaults.go

@@ -27,12 +27,12 @@ func DefaultConfig(home, chainId string) *NodeConfig {
 			Seeds:         ""},
 		Aggregator: true,
 		BlockManagerConfig: BlockManagerConfig{
-			BlockTime:           200 * time.Millisecond,
-			EmptyBlocksMaxTime:  60 * time.Second,
-			BatchSubmitMaxTime:  600 * time.Second,
-			NamespaceID:         "000000000000ffff",
-			BlockBatchSize:      500,
-			BlockBatchSizeBytes: 1500000},
+			BlockTime:              200 * time.Millisecond,
+			EmptyBlocksMaxTime:     60 * time.Second,
+			BatchSubmitMaxTime:     600 * time.Second,
+			NamespaceID:            "000000000000ffff",
+			BlockBatchSize:         500,
+			BlockBatchMaxSizeBytes: 1500000},
 		DALayer:         "mock",
 		SettlementLayer: "mock",
 	}

config/toml.go

@@ -78,15 +78,16 @@ batch_submit_max_time = "{{ .BlockManagerConfig.BatchSubmitMaxTime }}"
 
 ### da config ###
 da_layer = "{{ .DALayer }}" # mock, celestia
-da_start_height = {{ .BlockManagerConfig.DAStartHeight }}
 namespace_id = "{{ .BlockManagerConfig.NamespaceID }}"
+da_config = "{{ .DAConfig }}"
 
 # max size of batch in bytes that can be accepted by DA
-block_batch_size_bytes = {{ .BlockManagerConfig.BlockBatchSizeBytes }}
+block_batch_max_size_bytes = {{ .BlockManagerConfig.BlockBatchMaxSizeBytes }}
 
-#celestia config
+#celestia config example:
 # da_config = "{\"base_url\": \"http://127.0.0.1:26659\", \"timeout\": 60000000000, \"fee\":20000, \"gas_limit\": 20000000, \"namespace_id\":\"000000000000ffff\"}"
-da_config = "{{ .DAConfig }}"
+# Avail config example:
+# da_config = “{\“seed\“: \“MNEMONIC\“, \“api_url\“: \“wss://kate.avail.tools/ws\“, \“app_id\“: 0, \“tip\“:10}“,
 
 ### settlement config ###
 settlement_layer = "{{ .SettlementLayer }}" # mock, dymension

contrib/githooks/pre-commit-config.yaml

@@ -92,8 +92,10 @@ repos:
     # - https://github.com/golangci/golangci-lint
     #
     # -   id: golangci-lint
-    -   id: golangci-lint-mod
-    -   id: golangci-lint-repo-mod
+-   repo: https://github.com/golangci/golangci-lint
+    rev: v1.53.3
+    hooks:
+    -   id: golangci-lint
     #
     # # Invoking Custom Go Tools
     # # - Configured *entirely* through the `args` attribute, ie: