11package encoding
22
3+ import (
4+ "crypto/sha256"
5+ "encoding/hex"
6+ "errors"
7+ "fmt"
8+
9+ "github.com/scroll-tech/go-ethereum/common"
10+ "github.com/scroll-tech/go-ethereum/crypto"
11+ "github.com/scroll-tech/go-ethereum/crypto/kzg4844"
12+ "github.com/scroll-tech/go-ethereum/log"
13+
14+ "github.com/scroll-tech/da-codec/encoding/zstd"
15+ )
16+
17+ // DACodecV8 uses zstd.CompressScrollBatchBytesStandard for compression instead of zstd.CompressScrollBatchBytesLegacy.
18+ //
19+ // Note: Due to Go's method receiver behavior, we need to override all methods that call checkCompressedDataCompatibility.
20+ // When a method in DACodecV7 calls d.checkCompressedDataCompatibility(), it will always use DACodecV7's version,
21+ // even if the instance is actually a DACodecV8. Therefore, we must override:
22+ // - checkCompressedDataCompatibility (core method using the new compression)
23+ // - constructBlob (calls checkCompressedDataCompatibility)
24+ // - NewDABatch (calls constructBlob)
25+ // - CheckBatchCompressedDataCompatibility (calls checkCompressedDataCompatibility)
26+ // - estimateL1CommitBatchSizeAndBlobSize (calls checkCompressedDataCompatibility)
27+ // - EstimateChunkL1CommitBatchSizeAndBlobSize (calls estimateL1CommitBatchSizeAndBlobSize)
28+ // - EstimateBatchL1CommitBatchSizeAndBlobSize (calls estimateL1CommitBatchSizeAndBlobSize)
329type DACodecV8 struct {
430 DACodecV7
531}
@@ -12,3 +38,171 @@ func NewDACodecV8() *DACodecV8 {
1238 },
1339 }
1440}
41+
42+ // checkCompressedDataCompatibility checks the compressed data compatibility for a batch.
43+ // It constructs a blob payload, compresses the data, and checks the compressed data compatibility.
44+ // flag checkLength indicates whether to check the length of the compressed data against the original data.
45+ // If checkLength is true, this function returns if compression is needed based on the compressed data's length, which is used when doing batch bytes encoding.
46+ // If checkLength is false, this function returns the result of the compatibility check, which is used when determining the chunk and batch contents.
47+ func (d * DACodecV8 ) checkCompressedDataCompatibility (payloadBytes []byte , checkLength bool ) ([]byte , bool , error ) {
48+ compressedPayloadBytes , err := zstd .CompressScrollBatchBytesStandard (payloadBytes )
49+ if err != nil {
50+ return nil , false , fmt .Errorf ("failed to compress blob payload: %w" , err )
51+ }
52+
53+ if err = checkCompressedDataCompatibilityV8 (compressedPayloadBytes ); err != nil {
54+ log .Warn ("Compressed data compatibility check failed" , "err" , err , "payloadBytes" , hex .EncodeToString (payloadBytes ), "compressedPayloadBytes" , hex .EncodeToString (compressedPayloadBytes ))
55+ return nil , false , nil
56+ }
57+
58+ // check if compressed data is bigger or equal to the original data -> no need to compress
59+ if checkLength && len (compressedPayloadBytes ) >= len (payloadBytes ) {
60+ log .Warn ("Compressed data is bigger or equal to the original data" , "payloadBytes" , hex .EncodeToString (payloadBytes ), "compressedPayloadBytes" , hex .EncodeToString (compressedPayloadBytes ))
61+ return nil , false , nil
62+ }
63+
64+ return compressedPayloadBytes , true , nil
65+ }
66+
67+ // NewDABatch creates a DABatch including blob from the provided Batch.
68+ func (d * DACodecV8 ) NewDABatch (batch * Batch ) (DABatch , error ) {
69+ if len (batch .Blocks ) == 0 {
70+ return nil , errors .New ("batch must contain at least one block" )
71+ }
72+
73+ if err := checkBlocksBatchVSChunksConsistency (batch ); err != nil {
74+ return nil , fmt .Errorf ("failed to check blocks batch vs chunks consistency: %w" , err )
75+ }
76+
77+ blob , blobVersionedHash , blobBytes , challengeDigest , err := d .constructBlob (batch )
78+ if err != nil {
79+ return nil , fmt .Errorf ("failed to construct blob: %w" , err )
80+ }
81+
82+ daBatch , err := newDABatchV7 (d .Version (), batch .Index , blobVersionedHash , batch .ParentBatchHash , blob , blobBytes , challengeDigest )
83+ if err != nil {
84+ return nil , fmt .Errorf ("failed to construct DABatch: %w" , err )
85+ }
86+
87+ return daBatch , nil
88+ }
89+
90+ func (d * DACodecV8 ) constructBlob (batch * Batch ) (* kzg4844.Blob , common.Hash , []byte , common.Hash , error ) {
91+ blobBytes := make ([]byte , blobEnvelopeV7OffsetPayload )
92+
93+ payloadBytes , err := d .constructBlobPayload (batch )
94+ if err != nil {
95+ return nil , common.Hash {}, nil , common.Hash {}, fmt .Errorf ("failed to construct blob payload: %w" , err )
96+ }
97+
98+ compressedPayloadBytes , enableCompression , err := d .checkCompressedDataCompatibility (payloadBytes , true /* checkLength */ )
99+ if err != nil {
100+ return nil , common.Hash {}, nil , common.Hash {}, fmt .Errorf ("failed to check batch compressed data compatibility: %w" , err )
101+ }
102+
103+ isCompressedFlag := uint8 (0x0 )
104+ if enableCompression {
105+ isCompressedFlag = 0x1
106+ payloadBytes = compressedPayloadBytes
107+ }
108+
109+ sizeSlice := encodeSize3Bytes (uint32 (len (payloadBytes )))
110+
111+ blobBytes [blobEnvelopeV7OffsetVersion ] = uint8 (d .Version ())
112+ copy (blobBytes [blobEnvelopeV7OffsetByteSize :blobEnvelopeV7OffsetCompressedFlag ], sizeSlice )
113+ blobBytes [blobEnvelopeV7OffsetCompressedFlag ] = isCompressedFlag
114+ blobBytes = append (blobBytes , payloadBytes ... )
115+
116+ if len (blobBytes ) > maxEffectiveBlobBytes {
117+ log .Error ("ConstructBlob: Blob payload exceeds maximum size" , "size" , len (blobBytes ), "blobBytes" , hex .EncodeToString (blobBytes ))
118+ return nil , common.Hash {}, nil , common.Hash {}, fmt .Errorf ("blob exceeds maximum size: got %d, allowed %d" , len (blobBytes ), maxEffectiveBlobBytes )
119+ }
120+
121+ // convert raw data to BLSFieldElements
122+ blob , err := makeBlobCanonical (blobBytes )
123+ if err != nil {
124+ return nil , common.Hash {}, nil , common.Hash {}, fmt .Errorf ("failed to convert blobBytes to canonical form: %w" , err )
125+ }
126+
127+ // compute blob versioned hash
128+ c , err := kzg4844 .BlobToCommitment (blob )
129+ if err != nil {
130+ return nil , common.Hash {}, nil , common.Hash {}, fmt .Errorf ("failed to create blob commitment: %w" , err )
131+ }
132+ blobVersionedHash := kzg4844 .CalcBlobHashV1 (sha256 .New (), & c )
133+
134+ // compute challenge digest for codecv7, different from previous versions,
135+ // the blob bytes are padded to the max effective blob size, which is 131072 / 32 * 31 due to the blob encoding
136+ paddedBlobBytes := make ([]byte , maxEffectiveBlobBytes )
137+ copy (paddedBlobBytes , blobBytes )
138+
139+ challengeDigest := crypto .Keccak256Hash (crypto .Keccak256 (paddedBlobBytes ), blobVersionedHash [:])
140+
141+ return blob , blobVersionedHash , blobBytes , challengeDigest , nil
142+ }
143+
144+ // CheckBatchCompressedDataCompatibility checks the compressed data compatibility for a batch.
145+ func (d * DACodecV8 ) CheckBatchCompressedDataCompatibility (b * Batch ) (bool , error ) {
146+ if len (b .Blocks ) == 0 {
147+ return false , errors .New ("batch must contain at least one block" )
148+ }
149+
150+ if err := checkBlocksBatchVSChunksConsistency (b ); err != nil {
151+ return false , fmt .Errorf ("failed to check blocks batch vs chunks consistency: %w" , err )
152+ }
153+
154+ payloadBytes , err := d .constructBlobPayload (b )
155+ if err != nil {
156+ return false , fmt .Errorf ("failed to construct blob payload: %w" , err )
157+ }
158+
159+ // This check is only used for sanity checks. If the check fails, it means that the compression did not work as expected.
160+ // rollup-relayer will try popping the last chunk of the batch (or last block of the chunk when in proposing chunks) and try again to see if it works as expected.
161+ // Since length check is used for DA and proving efficiency, it does not need to be checked here.
162+ _ , compatible , err := d .checkCompressedDataCompatibility (payloadBytes , false /* checkLength */ )
163+ if err != nil {
164+ return false , fmt .Errorf ("failed to check batch compressed data compatibility: %w" , err )
165+ }
166+
167+ return compatible , nil
168+ }
169+
170+ func (d * DACodecV8 ) estimateL1CommitBatchSizeAndBlobSize (batch * Batch ) (uint64 , uint64 , error ) {
171+ if len (batch .Blocks ) == 0 {
172+ return 0 , 0 , errors .New ("batch must contain at least one block" )
173+ }
174+
175+ blobBytes := make ([]byte , blobEnvelopeV7OffsetPayload )
176+
177+ payloadBytes , err := d .constructBlobPayload (batch )
178+ if err != nil {
179+ return 0 , 0 , fmt .Errorf ("failed to construct blob payload: %w" , err )
180+ }
181+
182+ compressedPayloadBytes , enableCompression , err := d .checkCompressedDataCompatibility (payloadBytes , true /* checkLength */ )
183+ if err != nil {
184+ return 0 , 0 , fmt .Errorf ("failed to check batch compressed data compatibility: %w" , err )
185+ }
186+
187+ if enableCompression {
188+ blobBytes = append (blobBytes , compressedPayloadBytes ... )
189+ } else {
190+ blobBytes = append (blobBytes , payloadBytes ... )
191+ }
192+
193+ return blobEnvelopeV7OffsetPayload + uint64 (len (payloadBytes )), calculatePaddedBlobSize (uint64 (len (blobBytes ))), nil
194+ }
195+
196+ // EstimateChunkL1CommitBatchSizeAndBlobSize estimates the L1 commit batch size and blob size for a single chunk.
197+ func (d * DACodecV8 ) EstimateChunkL1CommitBatchSizeAndBlobSize (chunk * Chunk ) (uint64 , uint64 , error ) {
198+ return d .estimateL1CommitBatchSizeAndBlobSize (& Batch {
199+ Blocks : chunk .Blocks ,
200+ PrevL1MessageQueueHash : chunk .PrevL1MessageQueueHash ,
201+ PostL1MessageQueueHash : chunk .PostL1MessageQueueHash ,
202+ })
203+ }
204+
205+ // EstimateBatchL1CommitBatchSizeAndBlobSize estimates the L1 commit batch size and blob size for a batch.
206+ func (d * DACodecV8 ) EstimateBatchL1CommitBatchSizeAndBlobSize (batch * Batch ) (uint64 , uint64 , error ) {
207+ return d .estimateL1CommitBatchSizeAndBlobSize (batch )
208+ }
0 commit comments