creating Batch type and serialization for better handling of the prot…

…obuf

proto/sequencing/sequencing.proto

@@ -22,23 +22,18 @@ message SubmitRollupTransactionResponse {
 // SequencerOutput ...
 service SequencerOutput {
     // SubmitRollupTransaction ...
-    rpc GetNextBatch(BatchRequest) returns (BatchResponse) {}
+    rpc GetNextBatch(Batch) returns (Batch) {}
 }
 
-// BatchRequest provides the last batch while requesting for the next batch
-message BatchRequest {
-    repeated bytes transactions = 1;
-}
-
-// BatchResponse contains the transaction batch that is last sequenced
-message BatchResponse {
+// Batch holds a list of transactions
+message Batch {
     repeated bytes transactions = 1;
 }
 
 // BatchVerifier
 service BatchVerifier {
     // VerifyBatch ...
-    rpc VerifyBatch(BatchRequest) returns (VerificationResponse) {}
+    rpc VerifyBatch(Batch) returns (VerificationResponse) {}
 }
 
 // VerificationResponse

proxy/grpc/client.go

@@ -3,6 +3,7 @@ package grpc
 import (
 	"context"
 
+	"github.com/rollkit/go-sequencing"
 	pbseq "github.com/rollkit/go-sequencing/types/pb/sequencing"
 	"google.golang.org/grpc"
 )
@@ -50,21 +51,19 @@ func (c *Client) SubmitRollupTransaction(ctx context.Context, rollupId []byte, t
 }
 
 // GetNextBatch returns the next batch of transactions from sequencer to rollup.
-func (c *Client) GetNextBatch(ctx context.Context, lastBatch [][]byte) ([][]byte, error) {
-	resp, err := c.SequencerOutputClient.GetNextBatch(ctx, &pbseq.BatchRequest{
-		Transactions: lastBatch,
-	})
+func (c *Client) GetNextBatch(ctx context.Context, lastBatch sequencing.Batch) (sequencing.Batch, error) {
+	resp, err := c.SequencerOutputClient.GetNextBatch(ctx, lastBatch.ToProto())
 	if err != nil {
-		return nil, err
+		return sequencing.Batch{}, err
 	}
-	return resp.Transactions, nil
+	b := sequencing.Batch{}
+	b.FromProto(resp)
+	return b, nil
 }
 
 // VerifyBatch verifies a batch of transactions received from the sequencer.
-func (c *Client) VerifyBatch(ctx context.Context, batch [][]byte) (bool, error) {
-	resp, err := c.BatchVerifierClient.VerifyBatch(ctx, &pbseq.BatchRequest{
-		Transactions: batch,
-	})
+func (c *Client) VerifyBatch(ctx context.Context, batch sequencing.Batch) (bool, error) {
+	resp, err := c.BatchVerifierClient.VerifyBatch(ctx, batch.ToProto())
 	if err != nil {
 		return false, err
 	}

proxy/grpc/server.go

@@ -48,16 +48,20 @@ func (s *proxyInputSrv) SubmitRollupTransaction(ctx context.Context, req *pbseq.
 	return &pbseq.SubmitRollupTransactionResponse{}, nil
 }
 
-func (s *proxyOutputSrv) GetNextBatch(ctx context.Context, req *pbseq.BatchRequest) (*pbseq.BatchResponse, error) {
-	batch, err := s.SequencerOutput.GetNextBatch(ctx, req.Transactions)
+func (s *proxyOutputSrv) GetNextBatch(ctx context.Context, req *pbseq.Batch) (*pbseq.Batch, error) {
+	lastBatch := sequencing.Batch{}
+	lastBatch.FromProto(req)
+	batch, err := s.SequencerOutput.GetNextBatch(ctx, lastBatch)
 	if err != nil {
 		return nil, err
 	}
-	return &pbseq.BatchResponse{Transactions: batch}, nil
+	return batch.ToProto(), nil
 }
 
-func (s *proxyVerificationSrv) VerifyBatch(ctx context.Context, req *pbseq.BatchRequest) (*pbseq.VerificationResponse, error) {
-	ok, err := s.BatchVerifier.VerifyBatch(ctx, req.Transactions)
+func (s *proxyVerificationSrv) VerifyBatch(ctx context.Context, req *pbseq.Batch) (*pbseq.VerificationResponse, error) {
+	batch := sequencing.Batch{}
+	batch.FromProto(req)
+	ok, err := s.BatchVerifier.VerifyBatch(ctx, batch)
 	if err != nil {
 		return nil, err
 	}

sequencing.go

@@ -20,17 +20,22 @@ type SequencerOutput interface {
 	// GetNextBatch returns the next batch of transactions from sequencer to rollup
 	// lastBatch is the last batch of transactions received from the sequencer
 	// returns the next batch of transactions and an error if any from the sequencer
-	GetNextBatch(ctx context.Context, lastBatch []Tx) ([]Tx, error)
+	GetNextBatch(ctx context.Context, lastBatch Batch) (Batch, error)
 }
 
 // BatchVerifier provides a method for verifying a batch of transactions received from the sequencer
 type BatchVerifier interface {
 	// VerifyBatch verifies a batch of transactions received from the sequencer
-	VerifyBatch(ctx context.Context, batch []Tx) (bool, error)
+	VerifyBatch(ctx context.Context, batch Batch) (bool, error)
 }
 
 // RollupId is a unique identifier for a rollup chain
 type RollupId = []byte
 
 // Tx is a rollup transaction
 type Tx = []byte
+
+// Batch is a collection of transactions
+type Batch struct {
+	Transactions []Tx
+}

serialization.go

@@ -0,0 +1,45 @@
+package sequencing
+
+import (
+	pbseq "github.com/rollkit/go-sequencing/types/pb/sequencing"
+)
+
+func (batch *Batch) ToProto() *pbseq.Batch {
+	return &pbseq.Batch{Transactions: txsToByteSlices(batch.Transactions)}
+}
+
+func (batch *Batch) FromProto(pb *pbseq.Batch) {
+	batch.Transactions = byteSlicesToTxs(pb.Transactions)
+}
+
+func txsToByteSlices(txs []Tx) [][]byte {
+	if txs == nil {
+		return nil
+	}
+	bytes := make([][]byte, len(txs))
+	copy(bytes, txs)
+	return bytes
+}
+
+func byteSlicesToTxs(bytes [][]byte) []Tx {
+	if len(bytes) == 0 {
+		return nil
+	}
+	txs := make([]Tx, len(bytes))
+	copy(txs, bytes)
+	return txs
+}
+
+func (batch *Batch) Marshal() ([]byte, error) {
+	pb := batch.ToProto()
+	return pb.Marshal()
+}
+
+func (batch *Batch) Unmarshal(data []byte) error {
+	var pb pbseq.Batch
+	if err := pb.Unmarshal(data); err != nil {
+		return err
+	}
+	batch.FromProto(&pb)
+	return nil
+}

test/dummy.go

@@ -32,15 +32,15 @@ func (tq *TransactionQueue) AddTransaction(tx sequencing.Tx) {
 }
 
 // GetBatch extracts a batch of transactions from the queue
-func (tq *TransactionQueue) GetNextBatch() []sequencing.Tx {
+func (tq *TransactionQueue) GetNextBatch() sequencing.Batch {
 	tq.mu.Lock()
 	defer tq.mu.Unlock()
 
 	batchSize := len(tq.queue)
 
 	batch := tq.queue[:batchSize]
 	tq.queue = tq.queue[batchSize:]
-	return batch
+	return sequencing.Batch{Transactions: batch}
 }
 
 // DummySequencer is a dummy sequencer for testing that serves a single rollup
@@ -67,16 +67,24 @@ func (d *DummySequencer) SubmitRollupTransaction(ctx context.Context, rollupId [
 }
 
 // GetNextBatch implements sequencing.Sequencer.
-func (d *DummySequencer) GetNextBatch(ctx context.Context, lastBatch [][]byte) ([][]byte, error) {
+func (d *DummySequencer) GetNextBatch(ctx context.Context, lastBatch sequencing.Batch) (sequencing.Batch, error) {
 	batch := d.tq.GetNextBatch()
-	d.lastBatchHash = hashSHA256(batch[0])
+	batchBytes, err := batch.Marshal()
+	if err != nil {
+		return sequencing.Batch{}, err
+	}
+	d.lastBatchHash = hashSHA256(batchBytes)
 	d.seenBatches[string(d.lastBatchHash)] = struct{}{}
 	return batch, nil
 }
 
 // VerifyBatch implements sequencing.Sequencer.
-func (d *DummySequencer) VerifyBatch(ctx context.Context, batch [][]byte) (bool, error) {
-	hash := hashSHA256(batch[0])
+func (d *DummySequencer) VerifyBatch(ctx context.Context, batch sequencing.Batch) (bool, error) {
+	batchBytes, err := batch.Marshal()
+	if err != nil {
+		return false, err
+	}
+	hash := hashSHA256(batchBytes)
 	_, ok := d.seenBatches[string(hash)]
 	return ok, nil
 }