Merge branch 'develop' into sc/md-dump-parsing

op-chain-ops/genesis/config.go

@@ -3,6 +3,7 @@ package genesis
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"math/big"
 	"os"
 	"path/filepath"
@@ -84,7 +85,7 @@ type DeployConfig struct {
 func NewDeployConfig(path string) (*DeployConfig, error) {
 	file, err := os.ReadFile(path)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("deploy config at %s not found: %w", path, err)
 	}
 
 	var config DeployConfig

op-node/rollup/derive/channel_out.go

@@ -84,7 +84,7 @@ func (co *ChannelOut) AddBlock(block *types.Block) error {
 		return err
 	}
 	// We encode to a temporary buffer to determine the encoded length to
-	// ensure that the total size of all RLP elements is less than MAX_RLP_BYTES_PER_CHANNEL
+	// ensure that the total size of all RLP elements is less than or equal to MAX_RLP_BYTES_PER_CHANNEL
 	var buf bytes.Buffer
 	if err := rlp.Encode(&buf, batch); err != nil {
 		return err

op-node/rollup/derive/channel_out_test.go

 package derive
 
 import (
+	"bytes"
 	"math/big"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/stretchr/testify/require"
 )
 
@@ -25,3 +27,25 @@ func TestChannelOutAddBlock(t *testing.T) {
 		require.Equal(t, ErrNotDepositTx, err)
 	})
 }
+
+// TestRLPByteLimit ensures that stream encoder is properly limiting the length.
+// It will decode the input if `len(input) <= inputLimit`.
+func TestRLPByteLimit(t *testing.T) {
+	// Should succeed if `len(input) == inputLimit`
+	enc := []byte("\x8bhello world") // RLP encoding of the string "hello world"
+	in := bytes.NewBuffer(enc)
+	var out string
+	stream := rlp.NewStream(in, 12)
+	err := stream.Decode(&out)
+	require.Nil(t, err)
+	require.Equal(t, out, "hello world")
+
+	// Should fail if the `inputLimit = len(input) - 1`
+	enc = []byte("\x8bhello world") // RLP encoding of the string "hello world"
+	in = bytes.NewBuffer(enc)
+	var out2 string
+	stream = rlp.NewStream(in, 11)
+	err = stream.Decode(&out2)
+	require.Equal(t, err, rlp.ErrValueTooLarge)
+	require.Equal(t, out2, "")
+}

specs/derivation.md

@@ -363,11 +363,10 @@ where:
 
 When decompressing a channel, we limit the amount of decompressed data to `MAX_RLP_BYTES_PER_CHANNEL` (currently
 10,000,000 bytes), in order to avoid "zip-bomb" types of attack (where a small compressed input decompresses to a
-humongous amount of data). If the decompressed data exceeds the limit, things proceeds as thought the channel contained
-only the first `MAX_RLP_BYTES_PER_CHANNEL` decompressed bytes.
-
-When decoding batches, all batches that can be completly decoded below `MAX_RLP_BYTES_PER_CHANNEL` will be accepted
-even if the size of the channel is greater than `MAX_RLP_BYTES_PER_CHANNEL`.
+humongous amount of data). If the decompressed data exceeds the limit, things proceeds as though the channel contained
+only the first `MAX_RLP_BYTES_PER_CHANNEL` decompressed bytes. The limit is set on RLP decoding, so all batches that
+can be decoded in `MAX_RLP_BYTES_PER_CHANNEL` will be accepted ven if the size of the channel is greater than
+`MAX_RLP_BYTES_PER_CHANNEL`. The exact requirement is that `length(input) <= MAX_RLP_BYTES_PER_CHANNEL`.
 
 While the above pseudocode implies that all batches are known in advance, it is possible to perform streaming
 compression and decompression of RLP-encoded batches. This means it is possible to start including channel frames in a