op-node: L1BlockInfo MarshalBinary&UnmarshalBinary migrated to writer&reader based API

op-node/rollup/derive/l1_block_info.go

@@ -45,68 +45,112 @@ type L1BlockInfo struct {
 	L1FeeScalar   eth.Bytes32
 }
 
+//+---------+--------------------------+
+//| Bytes   | Field                    |
+//+---------+--------------------------+
+//| 4       | Function signature       |
+//| 24      | Padding for Number       |
+//| 8       | Number                   |
+//| 24      | Padding for Time         |
+//| 8       | Time                     |
+//| 32      | BaseFee                  |
+//| 32      | BlockHash                |
+//| 24      | Padding for SequenceNumber|
+//| 8       | SequenceNumber           |
+//| 12      | Padding for BatcherAddr  |
+//| 20      | BatcherAddr              |
+//| 32      | L1FeeOverhead            |
+//| 32      | L1FeeScalar              |
+//+---------+--------------------------+
+
 func (info *L1BlockInfo) MarshalBinary() ([]byte, error) {
-	data := make([]byte, L1InfoLen)
-	offset := 0
-	copy(data[offset:4], L1InfoFuncBytes4)
-	offset += 4
-	binary.BigEndian.PutUint64(data[offset+24:offset+32], info.Number)
-	offset += 32
-	binary.BigEndian.PutUint64(data[offset+24:offset+32], info.Time)
-	offset += 32
+	writer := bytes.NewBuffer(make([]byte, 0, L1InfoLen))
+	writer.Write(L1InfoFuncBytes4)
+
+	var padding [24]byte
+	writer.Write(padding[:])
+	binary.Write(writer, binary.BigEndian, info.Number)
+	writer.Write(padding[:])
+	binary.Write(writer, binary.BigEndian, info.Time)
 	// Ensure that the baseFee is not too large.
 	if info.BaseFee.BitLen() > 256 {
 		return nil, fmt.Errorf("base fee exceeds 256 bits: %d", info.BaseFee)
 	}
-	info.BaseFee.FillBytes(data[offset : offset+32])
-	offset += 32
-	copy(data[offset:offset+32], info.BlockHash.Bytes())
-	offset += 32
-	binary.BigEndian.PutUint64(data[offset+24:offset+32], info.SequenceNumber)
-	offset += 32
-	copy(data[offset+12:offset+32], info.BatcherAddr[:])
-	offset += 32
-	copy(data[offset:offset+32], info.L1FeeOverhead[:])
-	offset += 32
-	copy(data[offset:offset+32], info.L1FeeScalar[:])
-	return data, nil
+	var baseFeeBuf [32]byte
+	info.BaseFee.FillBytes(baseFeeBuf[:])
+	writer.Write(baseFeeBuf[:])
+	writer.Write(info.BlockHash.Bytes())
+	writer.Write(padding[:])
+	binary.Write(writer, binary.BigEndian, info.SequenceNumber)
+
+	var addrPadding [12]byte
+	writer.Write(addrPadding[:])
+	writer.Write(info.BatcherAddr.Bytes())
+	writer.Write(info.L1FeeOverhead[:])
+	writer.Write(info.L1FeeScalar[:])
+	return writer.Bytes(), nil
 }
 
 func (info *L1BlockInfo) UnmarshalBinary(data []byte) error {
 	if len(data) != L1InfoLen {
 		return fmt.Errorf("data is unexpected length: %d", len(data))
 	}
-	var padding [24]byte
-	offset := 4
-
-	if !bytes.Equal(data[0:offset], L1InfoFuncBytes4) {
-		return fmt.Errorf("data does not match L1 info function signature: 0x%x", data[offset:4])
-	}
-
-	info.Number = binary.BigEndian.Uint64(data[offset+24 : offset+32])
-	if !bytes.Equal(data[offset:offset+24], padding[:]) {
-		return fmt.Errorf("l1 info number exceeds uint64 bounds: %x", data[offset:offset+32])
-	}
-	offset += 32
-	info.Time = binary.BigEndian.Uint64(data[offset+24 : offset+32])
-	if !bytes.Equal(data[offset:offset+24], padding[:]) {
-		return fmt.Errorf("l1 info time exceeds uint64 bounds: %x", data[offset:offset+32])
-	}
-	offset += 32
-	info.BaseFee = new(big.Int).SetBytes(data[offset : offset+32])
-	offset += 32
-	info.BlockHash.SetBytes(data[offset : offset+32])
-	offset += 32
-	info.SequenceNumber = binary.BigEndian.Uint64(data[offset+24 : offset+32])
-	if !bytes.Equal(data[offset:offset+24], padding[:]) {
-		return fmt.Errorf("l1 info sequence number exceeds uint64 bounds: %x", data[offset:offset+32])
-	}
-	offset += 32
-	info.BatcherAddr.SetBytes(data[offset+12 : offset+32])
-	offset += 32
-	copy(info.L1FeeOverhead[:], data[offset:offset+32])
-	offset += 32
-	copy(info.L1FeeScalar[:], data[offset:offset+32])
+	reader := bytes.NewReader(data)
+
+	funcSignature := make([]byte, 4)
+	if _, err := reader.Read(funcSignature); err != nil || !bytes.Equal(funcSignature, L1InfoFuncBytes4) {
+		return fmt.Errorf("data does not match L1 info function signature: 0x%x", funcSignature)
+	}
+
+	var padding, readPadding [24]byte
+
+	if _, err := reader.Read(readPadding[:]); err != nil || !bytes.Equal(readPadding[:], padding[:]) {
+		return fmt.Errorf("l1 info number exceeds uint64 bounds: %x", readPadding[:])
+	}
+	if err := binary.Read(reader, binary.BigEndian, &info.Number); err != nil {
+		return err
+	}
+
+	if _, err := reader.Read(readPadding[:]); err != nil || !bytes.Equal(readPadding[:], padding[:]) {
+		return fmt.Errorf("l1 info time exceeds uint64 bounds: %x", readPadding[:])
+	}
+	if err := binary.Read(reader, binary.BigEndian, &info.Time); err != nil {
+		return err
+	}
+
+	var baseFeeBytes [32]byte
+	if _, err := reader.Read(baseFeeBytes[:]); err != nil {
+		return err
+	}
+	info.BaseFee = new(big.Int).SetBytes(baseFeeBytes[:])
+
+	var blockHashBytes [32]byte
+	if _, err := reader.Read(blockHashBytes[:]); err != nil {
+		return err
+	}
+	info.BlockHash.SetBytes(blockHashBytes[:])
+
+	if _, err := reader.Read(readPadding[:]); err != nil || !bytes.Equal(readPadding[:], padding[:]) {
+		return fmt.Errorf("l1 info sequence number exceeds uint64 bounds: %x", readPadding[:])
+	}
+	if err := binary.Read(reader, binary.BigEndian, &info.SequenceNumber); err != nil {
+		return err
+	}
+
+	var addrPadding [12]byte
+	if _, err := reader.Read(addrPadding[:]); err != nil {
+		return err
+	}
+	if _, err := reader.Read(info.BatcherAddr[:]); err != nil {
+		return err
+	}
+	if _, err := reader.Read(info.L1FeeOverhead[:]); err != nil {
+		return err
+	}
+	if _, err := reader.Read(info.L1FeeScalar[:]); err != nil {
+		return err
+	}
+
 	return nil
 }