Pull in blob and blob_test from PR.

Co-authored-by: protolambda <proto@protolambda.com>
Co-authored-by: Roberto Bayardo <bayardo@alum.mit.edu>

op-service/eth/blob.go

+package eth
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+const (
+	BlobSize        = 4096 * 32
+	MaxBlobDataSize = 4096*31 - 4
+)
+
+type Blob [BlobSize]byte
+
+func (b *Blob) KZGBlob() *kzg4844.Blob {
+	return (*kzg4844.Blob)(b)
+}
+
+func (b *Blob) UnmarshalJSON(text []byte) error {
+	return hexutil.UnmarshalFixedJSON(reflect.TypeOf(b), text, b[:])
+}
+
+func (b *Blob) UnmarshalText(text []byte) error {
+	return hexutil.UnmarshalFixedText("Bytes32", text, b[:])
+}
+
+func (b *Blob) MarshalText() ([]byte, error) {
+	return hexutil.Bytes(b[:]).MarshalText()
+}
+
+func (b *Blob) String() string {
+	return hexutil.Encode(b[:])
+}
+
+// TerminalString implements log.TerminalStringer, formatting a string for console
+// output during logging.
+func (b *Blob) TerminalString() string {
+	return fmt.Sprintf("%x..%x", b[:3], b[BlobSize-3:])
+}
+
+func (b *Blob) ComputeKZGCommitment() (kzg4844.Commitment, error) {
+	return kzg4844.BlobToCommitment(*b.KZGBlob())
+}
+
+// KZGToVersionedHash computes the "blob hash" (a.k.a. versioned-hash) of a blob-commitment, as used in a blob-tx.
+// We implement it here because it is unfortunately not (currently) exposed by geth.
+func KZGToVersionedHash(commitment kzg4844.Commitment) (out common.Hash) {
+	// EIP-4844 spec:
+	//	def kzg_to_versioned_hash(commitment: KZGCommitment) -> VersionedHash:
+	//		return VERSIONED_HASH_VERSION_KZG + sha256(commitment)[1:]
+	h := sha256.New()
+	h.Write(commitment[:])
+	_ = h.Sum(out[:0])
+	out[0] = params.BlobTxHashVersion
+	return out
+}
+
+// VerifyBlobProof verifies that the given blob and proof corresponds to the given commitment,
+// returning error if the verification fails.
+func VerifyBlobProof(blob *Blob, commitment kzg4844.Commitment, proof kzg4844.Proof) error {
+	return kzg4844.VerifyBlobProof(*blob.KZGBlob(), commitment, proof)
+}
+
+// FromData encodes the given input data into this blob. The encoding scheme is as follows:
+//
+// First, field elements are encoded as big-endian uint256 in BLS modulus range. To avoid modulus
+// overflow, we can't use the full 32 bytes, so we write data only to the topmost 31 bytes of each.
+// TODO: we can optimize this to get a bit more data from the blobs by using the top byte
+// partially.
+//
+// The first field element encodes the length of input data as a little endian uint32 in its
+// topmost 4 (out of 31) bytes, and the first 27 bytes of the input data in its remaining 27
+// bytes.
+//
+// The remaining field elements each encode 31 bytes of the remaining input data, up until the end
+// of the input.
+//
+// TODO: version the encoding format to allow for future encoding changes
+func (b *Blob) FromData(data Data) error {
+	if len(data) > MaxBlobDataSize {
+		return fmt.Errorf("data is too large for blob. len=%v", len(data))
+	}
+	b.Clear()
+	// encode 4-byte little-endian length value into topmost 4 bytes (out of 31) of first field
+	// element
+	binary.LittleEndian.PutUint32(b[1:5], uint32(len(data)))
+	// encode first 27 bytes of input data into remaining bytes of first field element
+	offset := copy(b[5:32], data)
+	// encode (up to) 31 bytes of remaining input data at a time into the subsequent field element
+	for i := 1; i < 4096; i++ {
+		offset += copy(b[i*32+1:i*32+32], data[offset:])
+		if offset == len(data) {
+			break
+		}
+	}
+	if offset < len(data) {
+		return fmt.Errorf("failed to fit all data into blob. bytes remaining: %v", len(data)-offset)
+	}
+	return nil
+}
+
+// ToData decodes the blob into raw byte data. See FromData above for details on the encoding
+// format.
+func (b *Blob) ToData() (Data, error) {
+	data := make(Data, 4096*32)
+	for i := 0; i < 4096; i++ {
+		if b[i*32] != 0 {
+			return nil, fmt.Errorf("invalid blob, found non-zero high order byte %x of field element %d", b[i*32], i)
+		}
+		copy(data[i*31:i*31+31], b[i*32+1:i*32+32])
+	}
+	// extract the length prefix & trim the output accordingly
+	dataLen := binary.LittleEndian.Uint32(data[:4])
+	data = data[4:]
+	if dataLen > uint32(len(data)) {
+		return nil, fmt.Errorf("invalid blob, length prefix out of range: %d", dataLen)
+	}
+	data = data[:dataLen]
+	return data, nil
+}
+
+func (b *Blob) Clear() {
+	for i := 0; i < BlobSize; i++ {
+		b[i] = 0
+	}
+}

op-service/eth/blob_test.go

+package eth
+
+import (
+	"testing"
+)
+
+func TestBlobEncodeDecode(t *testing.T) {
+	cases := []string{
+		"this is a test of blob encoding/decoding",
+		"short",
+		"\x00",
+		"\x00\x01\x00",
+		"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+		"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+		"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+		"",
+	}
+
+	var b Blob
+	for _, c := range cases {
+		data := Data(c)
+		if err := b.FromData(data); err != nil {
+			t.Fatalf("failed to encode bytes: %v", err)
+		}
+		decoded, err := b.ToData()
+		if err != nil {
+			t.Fatalf("failed to decode blob: %v", err)
+		}
+		if string(decoded) != c {
+			t.Errorf("decoded != input. got: %v, want: %v", decoded, Data(c))
+		}
+	}
+}
+
+func TestBigBlobEncoding(t *testing.T) {
+	bigData := Data(make([]byte, MaxBlobDataSize))
+	bigData[MaxBlobDataSize-1] = 0xFF
+	var b Blob
+	if err := b.FromData(bigData); err != nil {
+		t.Fatalf("failed to encode bytes: %v", err)
+	}
+	decoded, err := b.ToData()
+	if err != nil {
+		t.Fatalf("failed to decode blob: %v", err)
+	}
+	if string(decoded) != string(bigData) {
+		t.Errorf("decoded blob != big blob input")
+	}
+}
+
+func TestInvalidBlobDecoding(t *testing.T) {
+	data := Data("this is a test of invalid blob decoding")
+	var b Blob
+	if err := b.FromData(data); err != nil {
+		t.Fatalf("failed to encode bytes: %v", err)
+	}
+	b[32] = 0x80 // field elements should never have their highest order bit set
+	if _, err := b.ToData(); err == nil {
+		t.Errorf("expected error, got none")
+	}
+
+	b[32] = 0x00
+	b[4] = 0xFF // encode an invalid (much too long) length prefix
+	if _, err := b.ToData(); err == nil {
+		t.Errorf("expected error, got none")
+	}
+}
+
+func TestTooLongDataEncoding(t *testing.T) {
+	// should never be able to encode data that has size the same as that of the blob due to < 256
+	// bit precision of each field element
+	data := Data(make([]byte, BlobSize))
+	var b Blob
+	err := b.FromData(data)
+	if err == nil {
+		t.Errorf("expected error, got none")
+	}
+}