From 20ada751e1acfe4a4ed52294225fc9a0647a77ee Mon Sep 17 00:00:00 2001 From: colinlyguo Date: Tue, 7 May 2024 19:00:31 +0800 Subject: [PATCH] feat: sync codec updates --- encoding/codecv0/codecv0.go | 2 - encoding/codecv1/codecv1.go | 145 +++++++++++++++++++++++++++++-- encoding/codecv1/codecv1_test.go | 94 +++++++++++++++++--- go.mod | 7 +- go.sum | 12 +-- 5 files changed, 230 insertions(+), 30 deletions(-) diff --git a/encoding/codecv0/codecv0.go b/encoding/codecv0/codecv0.go index ced47c2..c829b41 100644 --- a/encoding/codecv0/codecv0.go +++ b/encoding/codecv0/codecv0.go @@ -320,8 +320,6 @@ func GetMemoryExpansionCost(memoryByteSize uint64) uint64 { } // EstimateBlockL1CommitCalldataSize calculates the calldata size in l1 commit for this block approximately. -// TODO: The calculation could be more accurate by using 58 + len(l2TxDataBytes) (see Chunk). -// This needs to be adjusted in the future. func EstimateBlockL1CommitCalldataSize(b *encoding.Block) (uint64, error) { var size uint64 for _, txData := range b.Transactions { diff --git a/encoding/codecv1/codecv1.go b/encoding/codecv1/codecv1.go index ee9df81..c6d75b1 100644 --- a/encoding/codecv1/codecv1.go +++ b/encoding/codecv1/codecv1.go @@ -356,7 +356,7 @@ func constructBlobPayload(chunks []*encoding.Chunk) (*kzg4844.Blob, common.Hash, } // compute blob versioned hash - c, err := kzg4844.BlobToCommitment(*blob) + c, err := kzg4844.BlobToCommitment(blob) if err != nil { return nil, common.Hash{}, nil, fmt.Errorf("failed to create blob commitment") } @@ -382,7 +382,7 @@ func constructBlobPayload(chunks []*encoding.Chunk) (*kzg4844.Blob, common.Hash, func makeBlobCanonical(blobBytes []byte) (*kzg4844.Blob, error) { // blob contains 131072 bytes but we can only utilize 31/32 of these if len(blobBytes) > 126976 { - return nil, fmt.Errorf("oversized batch payload") + return nil, fmt.Errorf("oversized batch payload, blob bytes length: %v, max length: %v", len(blobBytes), 126976) } // the canonical (padded) blob payload @@ -453,12 +453,12 @@ func (b *DABatch) BlobDataProof() ([]byte, error) { return nil, errors.New("called BlobDataProof with empty z") } - commitment, err := kzg4844.BlobToCommitment(*b.blob) + commitment, err := kzg4844.BlobToCommitment(b.blob) if err != nil { return nil, fmt.Errorf("failed to create blob commitment") } - proof, y, err := kzg4844.ComputeProof(*b.blob, *b.z) + proof, y, err := kzg4844.ComputeProof(b.blob, *b.z) if err != nil { log.Crit("failed to create KZG proof at point", "err", err, "z", hex.EncodeToString(b.z[:])) } @@ -490,8 +490,7 @@ func EstimateChunkL1CommitBlobSize(c *encoding.Chunk) (uint64, error) { if err != nil { return 0, err } - paddedSize := ((metadataSize + chunkDataSize + 30) / 31) * 32 - return paddedSize, nil + return calculatePaddedBlobSize(metadataSize + chunkDataSize), nil } // EstimateBatchL1CommitBlobSize estimates the total size of the L1 commit blob for a batch. @@ -505,8 +504,7 @@ func EstimateBatchL1CommitBlobSize(b *encoding.Batch) (uint64, error) { } batchDataSize += chunkDataSize } - paddedSize := ((metadataSize + batchDataSize + 30) / 31) * 32 - return paddedSize, nil + return calculatePaddedBlobSize(metadataSize + batchDataSize), nil } func chunkL1CommitBlobDataSize(c *encoding.Chunk) (uint64, error) { @@ -524,3 +522,134 @@ func chunkL1CommitBlobDataSize(c *encoding.Chunk) (uint64, error) { } return dataSize, nil } + +// CalldataNonZeroByteGas is the gas consumption per non zero byte in calldata. +const CalldataNonZeroByteGas = 16 + +// GetKeccak256Gas calculates the gas cost for computing the keccak256 hash of a given size. +func GetKeccak256Gas(size uint64) uint64 { + return GetMemoryExpansionCost(size) + 30 + 6*((size+31)/32) +} + +// GetMemoryExpansionCost calculates the cost of memory expansion for a given memoryByteSize. +func GetMemoryExpansionCost(memoryByteSize uint64) uint64 { + memorySizeWord := (memoryByteSize + 31) / 32 + memoryCost := (memorySizeWord*memorySizeWord)/512 + (3 * memorySizeWord) + return memoryCost +} + +// EstimateBlockL1CommitGas calculates the total L1 commit gas for this block approximately. +func EstimateBlockL1CommitGas(b *encoding.Block) uint64 { + var total uint64 + var numL1Messages uint64 + for _, txData := range b.Transactions { + if txData.Type == types.L1MessageTxType { + numL1Messages++ + continue + } + } + + // 60 bytes BlockContext calldata + total += CalldataNonZeroByteGas * 60 + + // sload + total += 2100 * numL1Messages // numL1Messages times cold sload in L1MessageQueue + + // staticcall + total += 100 * numL1Messages // numL1Messages times call to L1MessageQueue + total += 100 * numL1Messages // numL1Messages times warm address access to L1MessageQueue + + total += GetMemoryExpansionCost(36) * numL1Messages // staticcall to proxy + total += 100 * numL1Messages // read admin in proxy + total += 100 * numL1Messages // read impl in proxy + total += 100 * numL1Messages // access impl + total += GetMemoryExpansionCost(36) * numL1Messages // delegatecall to impl + + return total +} + +// EstimateChunkL1CommitCalldataSize calculates the calldata size needed for committing a chunk to L1 approximately. +func EstimateChunkL1CommitCalldataSize(c *encoding.Chunk) uint64 { + return uint64(60 * len(c.Blocks)) +} + +// EstimateChunkL1CommitGas calculates the total L1 commit gas for this chunk approximately. +func EstimateChunkL1CommitGas(c *encoding.Chunk) uint64 { + var totalNonSkippedL1Messages uint64 + var totalL1CommitGas uint64 + for _, block := range c.Blocks { + totalNonSkippedL1Messages += uint64(len(block.Transactions)) - block.NumL2Transactions() + blockL1CommitGas := EstimateBlockL1CommitGas(block) + totalL1CommitGas += blockL1CommitGas + } + + numBlocks := uint64(len(c.Blocks)) + totalL1CommitGas += 100 * numBlocks // numBlocks times warm sload + totalL1CommitGas += CalldataNonZeroByteGas // numBlocks field of chunk encoding in calldata + totalL1CommitGas += CalldataNonZeroByteGas * numBlocks * 60 // numBlocks of BlockContext in chunk + + totalL1CommitGas += GetKeccak256Gas(58*numBlocks + 32*totalNonSkippedL1Messages) // chunk hash + return totalL1CommitGas +} + +// EstimateBatchL1CommitGas calculates the total L1 commit gas for this batch approximately. +func EstimateBatchL1CommitGas(b *encoding.Batch) uint64 { + var totalL1CommitGas uint64 + + // Add extra gas costs + totalL1CommitGas += 100000 // constant to account for ops like _getAdmin, _implementation, _requireNotPaused, etc + totalL1CommitGas += 4 * 2100 // 4 one-time cold sload for commitBatch + totalL1CommitGas += 20000 // 1 time sstore + totalL1CommitGas += 21000 // base fee for tx + totalL1CommitGas += CalldataNonZeroByteGas // version in calldata + + // adjusting gas: + // add 1 time cold sload (2100 gas) for L1MessageQueue + // add 1 time cold address access (2600 gas) for L1MessageQueue + // minus 1 time warm sload (100 gas) & 1 time warm address access (100 gas) + totalL1CommitGas += (2100 + 2600 - 100 - 100) + totalL1CommitGas += GetKeccak256Gas(89 + 32) // parent batch header hash, length is estimated as 89 (constant part)+ 32 (1 skippedL1MessageBitmap) + totalL1CommitGas += CalldataNonZeroByteGas * (89 + 32) // parent batch header in calldata + + // adjust batch data hash gas cost + totalL1CommitGas += GetKeccak256Gas(uint64(32 * len(b.Chunks))) + + totalL1MessagePoppedBefore := b.TotalL1MessagePoppedBefore + + for _, chunk := range b.Chunks { + chunkL1CommitGas := EstimateChunkL1CommitGas(chunk) + totalL1CommitGas += chunkL1CommitGas + + totalL1MessagePoppedInChunk := chunk.NumL1Messages(totalL1MessagePoppedBefore) + totalL1MessagePoppedBefore += totalL1MessagePoppedInChunk + + totalL1CommitGas += CalldataNonZeroByteGas * (32 * (totalL1MessagePoppedInChunk + 255) / 256) + totalL1CommitGas += GetKeccak256Gas(89 + 32*(totalL1MessagePoppedInChunk+255)/256) + + totalL1CommitCalldataSize := EstimateChunkL1CommitCalldataSize(chunk) + totalL1CommitGas += GetMemoryExpansionCost(totalL1CommitCalldataSize) + } + + return totalL1CommitGas +} + +// EstimateBatchL1CommitCalldataSize calculates the calldata size in l1 commit for this batch approximately. +func EstimateBatchL1CommitCalldataSize(b *encoding.Batch) uint64 { + var totalL1CommitCalldataSize uint64 + for _, chunk := range b.Chunks { + totalL1CommitCalldataSize += EstimateChunkL1CommitCalldataSize(chunk) + } + return totalL1CommitCalldataSize +} + +// calculatePaddedBlobSize calculates the required size on blob storage +// where every 32 bytes can store only 31 bytes of actual data, with the first byte being zero. +func calculatePaddedBlobSize(dataSize uint64) uint64 { + paddedSize := (dataSize / 31) * 32 + + if dataSize%31 != 0 { + paddedSize += 1 + dataSize%31 // Add 1 byte for the first empty byte plus the remainder bytes + } + + return paddedSize +} diff --git a/encoding/codecv1/codecv1_test.go b/encoding/codecv1/codecv1_test.go index 31ac20d..289f849 100644 --- a/encoding/codecv1/codecv1_test.go +++ b/encoding/codecv1/codecv1_test.go @@ -592,7 +592,7 @@ func TestCodecV1BatchChallengeWithStandardTestCases(t *testing.T) { actualZ := hex.EncodeToString(z[:]) assert.Equal(t, tc.expectedz, actualZ) - _, y, err := kzg4844.ComputeProof(*b, *z) + _, y, err := kzg4844.ComputeProof(b, *z) assert.NoError(t, err) actualY := hex.EncodeToString(y[:]) assert.Equal(t, tc.expectedy, actualY) @@ -759,49 +759,121 @@ func TestCodecV1BatchSkipBitmap(t *testing.T) { assert.Equal(t, 42, int(batch.TotalL1MessagePopped)) } -func TestCodecV1ChunkAndBatchBlobSizeEstimation(t *testing.T) { +func TestCodecV1ChunkAndBatchCommitBlobSizeEstimation(t *testing.T) { trace2 := readBlockFromJSON(t, "../testdata/blockTrace_02.json") chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{trace2}} chunk2BlobSize, err := EstimateChunkL1CommitBlobSize(chunk2) assert.NoError(t, err) - assert.Equal(t, uint64(320), chunk2BlobSize) + assert.Equal(t, uint64(302), chunk2BlobSize) batch2 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk2}} batch2BlobSize, err := EstimateBatchL1CommitBlobSize(batch2) assert.NoError(t, err) - assert.Equal(t, uint64(320), batch2BlobSize) + assert.Equal(t, uint64(302), batch2BlobSize) trace3 := readBlockFromJSON(t, "../testdata/blockTrace_03.json") chunk3 := &encoding.Chunk{Blocks: []*encoding.Block{trace3}} chunk3BlobSize, err := EstimateChunkL1CommitBlobSize(chunk3) assert.NoError(t, err) - assert.Equal(t, uint64(5952), chunk3BlobSize) + assert.Equal(t, uint64(5929), chunk3BlobSize) batch3 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk3}} batch3BlobSize, err := EstimateBatchL1CommitBlobSize(batch3) assert.NoError(t, err) - assert.Equal(t, uint64(5952), batch3BlobSize) + assert.Equal(t, uint64(5929), batch3BlobSize) trace4 := readBlockFromJSON(t, "../testdata/blockTrace_04.json") chunk4 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} chunk4BlobSize, err := EstimateChunkL1CommitBlobSize(chunk4) assert.NoError(t, err) - assert.Equal(t, uint64(128), chunk4BlobSize) + assert.Equal(t, uint64(98), chunk4BlobSize) batch4 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk4}} batch4BlobSize, err := EstimateBatchL1CommitBlobSize(batch4) assert.NoError(t, err) - assert.Equal(t, uint64(128), batch4BlobSize) + assert.Equal(t, uint64(98), batch4BlobSize) chunk5 := &encoding.Chunk{Blocks: []*encoding.Block{trace2, trace3}} chunk5BlobSize, err := EstimateChunkL1CommitBlobSize(chunk5) assert.NoError(t, err) - assert.Equal(t, uint64(6176), chunk5BlobSize) + assert.Equal(t, uint64(6166), chunk5BlobSize) chunk6 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} chunk6BlobSize, err := EstimateChunkL1CommitBlobSize(chunk6) assert.NoError(t, err) - assert.Equal(t, uint64(128), chunk6BlobSize) + assert.Equal(t, uint64(98), chunk6BlobSize) batch5 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk5, chunk6}} batch5BlobSize, err := EstimateBatchL1CommitBlobSize(batch5) assert.NoError(t, err) - assert.Equal(t, uint64(6208), batch5BlobSize) + assert.Equal(t, uint64(6199), batch5BlobSize) +} + +func TestCodecV1ChunkAndBatchCommitCalldataSizeEstimation(t *testing.T) { + trace2 := readBlockFromJSON(t, "../testdata/blockTrace_02.json") + chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{trace2}} + chunk2CalldataSize := EstimateChunkL1CommitCalldataSize(chunk2) + assert.Equal(t, uint64(60), chunk2CalldataSize) + batch2 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk2}} + batch2CalldataSize := EstimateBatchL1CommitCalldataSize(batch2) + assert.Equal(t, uint64(60), batch2CalldataSize) + + trace3 := readBlockFromJSON(t, "../testdata/blockTrace_03.json") + chunk3 := &encoding.Chunk{Blocks: []*encoding.Block{trace3}} + chunk3CalldataSize := EstimateChunkL1CommitCalldataSize(chunk3) + assert.Equal(t, uint64(60), chunk3CalldataSize) + batch3 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk3}} + batch3CalldataSize := EstimateBatchL1CommitCalldataSize(batch3) + assert.Equal(t, uint64(60), batch3CalldataSize) + + trace4 := readBlockFromJSON(t, "../testdata/blockTrace_04.json") + chunk4 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} + chunk4CalldataSize := EstimateChunkL1CommitCalldataSize(chunk4) + assert.Equal(t, uint64(60), chunk4CalldataSize) + batch4 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk4}} + batch4BlobSize := EstimateBatchL1CommitCalldataSize(batch4) + assert.Equal(t, uint64(60), batch4BlobSize) + + chunk5 := &encoding.Chunk{Blocks: []*encoding.Block{trace2, trace3}} + chunk5CalldataSize := EstimateChunkL1CommitCalldataSize(chunk5) + assert.Equal(t, uint64(120), chunk5CalldataSize) + chunk6 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} + chunk6BlobSize := EstimateChunkL1CommitCalldataSize(chunk6) + assert.Equal(t, uint64(60), chunk6BlobSize) + batch5 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk5, chunk6}} + batch5CalldataSize := EstimateBatchL1CommitCalldataSize(batch5) + assert.Equal(t, uint64(180), batch5CalldataSize) +} + +func TestCodecV1ChunkAndBatchCommitGasEstimation(t *testing.T) { + trace2 := readBlockFromJSON(t, "../testdata/blockTrace_02.json") + chunk2 := &encoding.Chunk{Blocks: []*encoding.Block{trace2}} + chunk2Gas := EstimateChunkL1CommitGas(chunk2) + assert.Equal(t, uint64(2084), chunk2Gas) + batch2 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk2}} + batch2Gas := EstimateBatchL1CommitGas(batch2) + assert.Equal(t, uint64(158609), batch2Gas) + + trace3 := readBlockFromJSON(t, "../testdata/blockTrace_03.json") + chunk3 := &encoding.Chunk{Blocks: []*encoding.Block{trace3}} + chunk3Gas := EstimateChunkL1CommitGas(chunk3) + assert.Equal(t, uint64(2084), chunk3Gas) + batch3 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk3}} + batch3Gas := EstimateBatchL1CommitGas(batch3) + assert.Equal(t, uint64(158609), batch3Gas) + + trace4 := readBlockFromJSON(t, "../testdata/blockTrace_04.json") + chunk4 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} + chunk4Gas := EstimateChunkL1CommitGas(chunk4) + assert.Equal(t, uint64(4705), chunk4Gas) + batch4 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk4}} + batch4Gas := EstimateBatchL1CommitGas(batch4) + assert.Equal(t, uint64(161262), batch4Gas) + + chunk5 := &encoding.Chunk{Blocks: []*encoding.Block{trace2, trace3}} + chunk5Gas := EstimateChunkL1CommitGas(chunk5) + assert.Equal(t, uint64(4122), chunk5Gas) + chunk6 := &encoding.Chunk{Blocks: []*encoding.Block{trace4}} + chunk6Gas := EstimateChunkL1CommitGas(chunk6) + assert.Equal(t, uint64(4705), chunk6Gas) + batch5 := &encoding.Batch{Chunks: []*encoding.Chunk{chunk5, chunk6}} + batch5Gas := EstimateBatchL1CommitGas(batch5) + assert.Equal(t, uint64(165967), batch5Gas) } func readBlockFromJSON(t *testing.T, filename string) *encoding.Block { diff --git a/go.mod b/go.mod index 09aa2ac..e0bbaf6 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/scroll-tech/da-codec go 1.20 require ( - github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e + github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea github.com/stretchr/testify v1.9.0 ) @@ -13,7 +13,7 @@ require ( github.com/btcsuite/btcd v0.20.1-beta // indirect github.com/consensys/bavard v0.1.13 // indirect github.com/consensys/gnark-crypto v0.12.1 // indirect - github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect + github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4 // indirect github.com/go-ole/go-ole v1.3.0 // indirect @@ -27,10 +27,11 @@ require ( github.com/pmezard/go-difflib v1.0.0 // indirect github.com/rivo/uniseg v0.4.4 // indirect github.com/rogpeppe/go-internal v1.10.0 // indirect - github.com/scroll-tech/zktrie v0.7.1 // indirect + github.com/scroll-tech/zktrie v0.8.2 // indirect github.com/shirou/gopsutil v3.21.11+incompatible // indirect github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2 // indirect github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect github.com/yusufpapurcu/wmi v1.2.3 // indirect golang.org/x/crypto v0.17.0 // indirect golang.org/x/sync v0.6.0 // indirect diff --git a/go.sum b/go.sum index cfb8b05..77b03bf 100644 --- a/go.sum +++ b/go.sum @@ -19,8 +19,8 @@ github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/Yj github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= -github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= +github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -70,10 +70,10 @@ github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= -github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e h1:FcoK0rykAWI+5E7cQM6ALRLd5CmjBTHRvJztRBH2xeM= -github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e/go.mod h1:7Rz2bh9pn42rGuxjh51CG7HL9SKMG3ZugJkL3emdZx8= -github.com/scroll-tech/zktrie v0.7.1 h1:NrmZNjuBzsbrKePqdHDG+t2cXnimbtezPAFS0+L9ElE= -github.com/scroll-tech/zktrie v0.7.1/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk= +github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea h1:CH1WXWrpEpLaP3N+bFs2a1xdE0+lRm1AuJQb5YvE6Ls= +github.com/scroll-tech/go-ethereum v1.10.14-0.20240426041101-a860446ebaea/go.mod h1:i4VBgWoaW/y0D8MmQb7hSOulyw1dKhuiSFAbznwivCA= +github.com/scroll-tech/zktrie v0.8.2 h1:UMuIfA+jdgWMLmTgTL64Emo+zzMOdcnH0+eYdDcshxQ= +github.com/scroll-tech/zktrie v0.8.2/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk= github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=