fix lint and refactor

Author: Manav-Aggarwal

block/manager.go

@@ -991,7 +991,7 @@ func (m *Manager) SaveCache() error {
 
 // isValidSignedData returns true if the data signature is valid for the expected sequencer.
 func (m *Manager) isValidSignedData(signedData *types.SignedData) bool {
-	if signedData == nil || signedData.Data.Txs == nil {
+	if signedData == nil || signedData.Txs == nil {
 		return false
 	}
 	if !bytes.Equal(signedData.Signer.Address, m.genesis.ProposerAddress) {

block/retriever.go

@@ -153,7 +153,7 @@ func (m *Manager) handlePotentialData(ctx context.Context, bz []byte, daHeight u
 		m.logger.Debug("failed to unmarshal signed data", "error", err)
 		return
 	}
-	if signedData.Data.Txs == nil || len(signedData.Data.Txs) == 0 {
+	if len(signedData.Txs) == 0 {
 		m.logger.Debug("ignoring empty signed data", "daHeight", daHeight)
 		return
 	}

block/submitter.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	coreda "github.com/rollkit/rollkit/core/da"
+	coresequencer "github.com/rollkit/rollkit/core/sequencer"
 	"github.com/rollkit/rollkit/types"
 	"google.golang.org/protobuf/proto"
 )
@@ -139,43 +140,49 @@ func (m *Manager) BatchSubmissionLoop(ctx context.Context) {
 			m.logger.Info("batch submission loop stopped")
 			return
 		case batch := <-m.batchSubmissionChan:
-			data := types.Data{
-				Txs: make(types.Txs, len(batch.Transactions)),
-			}
-			for i, tx := range batch.Transactions {
-				data.Txs[i] = types.Tx(tx)
-			}
-
-			signature, err := m.getDataSignature(&data)
+			signedData, err := m.createSignedDataFromBatch(&batch)
 			if err != nil {
-				m.logger.Error("failed to get data signature", "error", err)
+				m.logger.Error("failed to create signed data from batch", "error", err)
 				continue
 			}
 
-			pubKey, err := m.signer.GetPublic()
+			err = m.submitBatchToDA(ctx, signedData)
 			if err != nil {
-				m.logger.Error("failed to get signer public key", "error", err)
-				continue
+				m.logger.Error("failed to submit batch to DA", "error", err)
 			}
+		}
+	}
+}
 
-			signer := types.Signer{
-				PubKey:  pubKey,
-				Address: m.genesis.ProposerAddress,
-			}
+// createSignedDataFromBatch converts a batch to a SignedData, including signing.
+func (m *Manager) createSignedDataFromBatch(batch *coresequencer.Batch) (*types.SignedData, error) {
+	data := types.Data{
+		Txs: make(types.Txs, len(batch.Transactions)),
+	}
+	for i, tx := range batch.Transactions {
+		data.Txs[i] = types.Tx(tx)
+	}
 
-			// Create SignedData
-			signedData := types.SignedData{
-				Data:      data,
-				Signature: signature,
-				Signer:    signer,
-			}
+	signature, err := m.getDataSignature(&data)
+	if err != nil {
+		return nil, err
+	}
 
-			err = m.submitBatchToDA(ctx, &signedData)
-			if err != nil {
-				m.logger.Error("failed to submit batch to DA", "error", err)
-			}
-		}
+	pubKey, err := m.signer.GetPublic()
+	if err != nil {
+		return nil, err
 	}
+
+	signer := types.Signer{
+		PubKey:  pubKey,
+		Address: m.genesis.ProposerAddress,
+	}
+
+	return &types.SignedData{
+		Data:      data,
+		Signature: signature,
+		Signer:    signer,
+	}, nil
 }
 
 // submitBatchToDA submits a batch of transactions to the Data Availability (DA) layer.
@@ -195,7 +202,7 @@ func (m *Manager) submitBatchToDA(ctx context.Context, signedData *types.SignedD
 	currentSignedData := signedData
 	submittedAllTxs := false
 	var backoff time.Duration
-	totalTxCount := len(currentSignedData.Data.Txs)
+	totalTxCount := len(currentSignedData.Txs)
 	submittedTxCount := 0
 	attempt := 0
 
@@ -233,16 +240,16 @@ daSubmitRetryLoop:
 				"gasPrice", gasPrice,
 				"height", res.Height,
 				"submittedTxs", submittedTxs,
-				"remainingTxs", len(currentSignedData.Data.Txs)-submittedTxs)
+				"remainingTxs", len(currentSignedData.Txs)-submittedTxs)
 
 			submittedTxCount += submittedTxs
 
 			// Check if all transactions in the current batch were submitted
-			if submittedTxs == len(currentSignedData.Data.Txs) {
+			if submittedTxs == len(currentSignedData.Txs) {
 				submittedAllTxs = true
 			} else {
 				// Update the current batch to contain only the remaining transactions
-				currentSignedData.Data.Txs = currentSignedData.Data.Txs[submittedTxs:]
+				currentSignedData.Txs = currentSignedData.Txs[submittedTxs:]
 			}
 
 			// Reset submission parameters after success

block/submitter_test.go

@@ -68,9 +68,9 @@ func TestSubmitBatchToDA_Success(t *testing.T) {
 		},
 	}
 
-	signedData.Data.Txs = make(types.Txs, len(batch.Transactions))
+	signedData.Txs = make(types.Txs, len(batch.Transactions))
 	for i, tx := range batch.Transactions {
-		signedData.Data.Txs[i] = types.Tx(tx)
+		signedData.Txs[i] = types.Tx(tx)
 	}
 
 	signature, err := m.getDataSignature(&signedData.Data)
@@ -120,9 +120,9 @@ func TestSubmitBatchToDA_Failure(t *testing.T) {
 				},
 			}
 
-			signedData.Data.Txs = make(types.Txs, len(batch.Transactions))
+			signedData.Txs = make(types.Txs, len(batch.Transactions))
 			for i, tx := range batch.Transactions {
-				signedData.Data.Txs[i] = types.Tx(tx)
+				signedData.Txs[i] = types.Tx(tx)
 			}
 
 			signature, err := m.getDataSignature(&signedData.Data)

types/serialization.go

@@ -350,10 +350,7 @@ func byteSlicesToTxs(bytes [][]byte) Txs {
 
 // ToProto converts SignedData into protobuf representation and returns it.
 func (sd *SignedData) ToProto() (*pb.SignedData, error) {
-	var dataProto *pb.Data
-	if &sd.Data != nil {
-		dataProto = sd.Data.ToProto()
-	}
+	dataProto := sd.Data.ToProto()
 
 	var signerProto *pb.Signer
 	if sd.Signer.PubKey != nil {