Create payload->blob type system

api/clients/codecs/blob.go

@@ -0,0 +1,79 @@
+package codecs
+
+import (
+	"fmt"
+)
+
+// Blob is data that is dispersed on eigenDA.
+//
+// A Blob is represented under the hood by a coeff polynomial
+type Blob struct {
+	coeffPolynomial *coeffPoly
+	// blobLength must be a power of 2, and should match the blobLength claimed in the BlobCommitment
+	// This is the blob length IN SYMBOLS, not in bytes
+	blobLength uint32
+}
+
+// BlobFromBytes initializes a Blob from bytes
+//
+// blobLength is the length of the blob IN SYMBOLS
+func BlobFromBytes(bytes []byte, blobLength uint32) (*Blob, error) {
+	poly, err := coeffPolyFromBytes(bytes)
+	if err != nil {
+		return nil, fmt.Errorf("polynomial from bytes: %w", err)
+	}
+
+	return BlobFromPolynomial(poly, blobLength)
+}
+
+// BlobFromPolynomial initializes a blob from a polynomial
+//
+// blobLength is the length of the blob IN SYMBOLS
+func BlobFromPolynomial(coeffPolynomial *coeffPoly, blobLength uint32) (*Blob, error) {
+	return &Blob{
+		coeffPolynomial: coeffPolynomial,
+		blobLength:      blobLength,
+	}, nil
+}
+
+// GetBytes gets the raw bytes of the Blob
+func (b *Blob) GetBytes() []byte {
+	return b.coeffPolynomial.getBytes()
+}
+
+// ToPayload converts the Blob into a Payload
+//
+// The payloadStartingForm indicates how payloads are constructed by the dispersing client. Based on the starting form
+// of the payload, we can determine what operations must be done to the blob in order to reconstruct the original payload
+func (b *Blob) ToPayload(payloadStartingForm PolynomialForm) (*Payload, error) {
+	var encodedPayload *encodedPayload
+	var err error
+	switch payloadStartingForm {
+	case PolynomialFormCoeff:
+		// the payload started off in coefficient form, so no conversion needs to be done
+		encodedPayload, err = b.coeffPolynomial.toEncodedPayload(b.blobLength)
+		if err != nil {
+			return nil, fmt.Errorf("coeff poly to encoded payload: %w", err)
+		}
+	case PolynomialFormEval:
+		// the payload started off in evaluation form, so we first need to convert the blob's coeff poly into an eval poly
+		evalPoly, err := b.coeffPolynomial.toEvalPoly(b.blobLength)
+		if err != nil {
+			return nil, fmt.Errorf("coeff poly to eval poly: %w", err)
+		}
+
+		encodedPayload, err = evalPoly.toEncodedPayload(b.blobLength)
+		if err != nil {
+			return nil, fmt.Errorf("eval poly to encoded payload: %w", err)
+		}
+	default:
+		return nil, fmt.Errorf("invalid polynomial form")
+	}
+
+	payload, err := encodedPayload.decode()
+	if err != nil {
+		return nil, fmt.Errorf("decode payload: %w", err)
+	}
+
+	return payload, nil
+}

api/clients/codecs/blob_codec.go

@@ -4,22 +4,22 @@ import (
 	"fmt"
 )
 
-type BlobEncodingVersion byte
+type PayloadEncodingVersion byte
 
 const (
-	// This minimal blob encoding contains a 32 byte header = [0x00, version byte, uint32 len of data, 0x00, 0x00,...]
+	// PayloadEncodingVersion0 entails a 32 byte header = [0x00, version byte, big-endian uint32 len of payload, 0x00, 0x00,...]
 	// followed by the encoded data [0x00, 31 bytes of data, 0x00, 31 bytes of data,...]
-	DefaultBlobEncoding BlobEncodingVersion = 0x0
+	PayloadEncodingVersion0 PayloadEncodingVersion = 0x0
 )
 
 type BlobCodec interface {
 	DecodeBlob(encodedData []byte) ([]byte, error)
 	EncodeBlob(rawData []byte) ([]byte, error)
 }
 
-func BlobEncodingVersionToCodec(version BlobEncodingVersion) (BlobCodec, error) {
+func BlobEncodingVersionToCodec(version PayloadEncodingVersion) (BlobCodec, error) {
 	switch version {
-	case DefaultBlobEncoding:
+	case PayloadEncodingVersion0:
 		return DefaultBlobCodec{}, nil
 	default:
 		return nil, fmt.Errorf("unsupported blob encoding version: %x", version)
@@ -33,7 +33,7 @@ func GenericDecodeBlob(data []byte) ([]byte, error) {
 	// version byte is stored in [1], because [0] is always 0 to ensure the codecBlobHeader is a valid bn254 element
 	// see https://github.com/Layr-Labs/eigenda/blob/master/api/clients/codecs/default_blob_codec.go#L21
 	// TODO: we should prob be working over a struct with methods such as GetBlobEncodingVersion() to prevent index errors
-	version := BlobEncodingVersion(data[1])
+	version := PayloadEncodingVersion(data[1])
 	codec, err := BlobEncodingVersionToCodec(version)
 	if err != nil {
 		return nil, err
@@ -49,7 +49,7 @@ func GenericDecodeBlob(data []byte) ([]byte, error) {
 
 // CreateCodec creates a new BlobCodec based on the defined polynomial form of payloads, and the desired
 // BlobEncodingVersion
-func CreateCodec(payloadPolynomialForm PolynomialForm, version BlobEncodingVersion) (BlobCodec, error) {
+func CreateCodec(payloadPolynomialForm PolynomialForm, version PayloadEncodingVersion) (BlobCodec, error) {
 	lowLevelCodec, err := BlobEncodingVersionToCodec(version)
 	if err != nil {
 		return nil, fmt.Errorf("create low level codec: %w", err)

api/clients/codecs/blob_test.go

@@ -0,0 +1,39 @@
+package codecs
+
+import (
+	"testing"
+
+	"github.com/Layr-Labs/eigenda/common/testutils/random"
+	"github.com/stretchr/testify/require"
+)
+
+// TestBlobConversion checks that internal blob conversion methods produce consistent results
+func TestBlobConversion(t *testing.T) {
+	testRandom := random.NewTestRandom(t)
+
+	iterations := 1000
+
+	for i := 0; i < iterations; i++ {
+		originalData := testRandom.Bytes(testRandom.Intn(1024) + 1)
+		testBlobConversionForForm(t, originalData, PolynomialFormEval)
+		testBlobConversionForForm(t, originalData, PolynomialFormCoeff)
+	}
+}
+
+func testBlobConversionForForm(t *testing.T, payloadBytes []byte, form PolynomialForm) {
+	payload := NewPayload(payloadBytes)
+
+	blob, err := payload.ToBlob(form)
+	require.NoError(t, err)
+
+	blobBytes := blob.GetBytes()
+	blobFromBytes, err := BlobFromBytes(blobBytes, blob.blobLength)
+	require.NoError(t, err)
+
+	decodedPayload, err := blobFromBytes.ToPayload(form)
+	require.NoError(t, err)
+
+	decodedPayloadBytes := decodedPayload.GetBytes()
+
+	require.Equal(t, payloadBytes, decodedPayloadBytes)
+}

api/clients/codecs/coeff_poly.go

@@ -0,0 +1,63 @@
+package codecs
+
+import (
+	"fmt"
+
+	"github.com/Layr-Labs/eigenda/encoding/fft"
+	"github.com/Layr-Labs/eigenda/encoding/rs"
+	"github.com/consensys/gnark-crypto/ecc/bn254/fr"
+)
+
+// coeffPoly is a polynomial in coefficient form.
+//
+// The underlying bytes represent 32 byte field elements, and each field element represents a coefficient
+type coeffPoly struct {
+	fieldElements []fr.Element
+}
+
+// coeffPolyFromBytes creates a new polynomial from bytes. This function performs the necessary checks to guarantee that the
+// bytes are well-formed, and returns a new object if they are
+func coeffPolyFromBytes(bytes []byte) (*coeffPoly, error) {
+	fieldElements, err := rs.ToFrArray(bytes)
+	if err != nil {
+		return nil, fmt.Errorf("deserialize field elements: %w", err)
+	}
+
+	return &coeffPoly{fieldElements: fieldElements}, nil
+}
+
+// coeffPolyFromElements creates a new coeffPoly from field elements.
+func coeffPolyFromElements(elements []fr.Element) *coeffPoly {
+	return &coeffPoly{fieldElements: elements}
+}
+
+// toEvalPoly converts a coeffPoly to an evalPoly, using the FFT operation
+//
+// blobLength (in SYMBOLS) is required, to be able to choose the correct parameters when performing FFT
+func (p *coeffPoly) toEvalPoly(blobLength uint32) (*evalPoly, error) {
+	// TODO (litt3): this could conceivably be optimized, so that multiple objects share an instance of FFTSettings,
+	//  which has enough roots of unity for general use. If the following construction of FFTSettings ever proves
+	//  to present a computational burden, consider making this change.
+	fftSettings := fft.FFTSettingsFromBlobLength(blobLength)
+
+	// the FFT method pads to the next power of 2, so we don't need to do that manually
+	fftedElements, err := fftSettings.FFT(p.fieldElements, false)
+	if err != nil {
+		return nil, fmt.Errorf("perform FFT: %w", err)
+	}
+
+	return evalPolyFromElements(fftedElements), nil
+}
+
+// GetBytes returns the bytes that underlie the polynomial
+func (p *coeffPoly) getBytes() []byte {
+	return rs.FieldElementsToBytes(p.fieldElements)
+}
+
+// toEncodedPayload converts a coeffPoly into an encoded payload
+//
+// blobLength is required, to be able to perform length checks on the encoded payload during construction.
+// blobLength is in symbols, NOT bytes
+func (p *coeffPoly) toEncodedPayload(blobLength uint32) (*encodedPayload, error) {
+	return encodedPayloadFromElements(p.fieldElements, blobLength)
+}

api/clients/codecs/conversion_test.go

@@ -0,0 +1,52 @@
+package codecs
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/Layr-Labs/eigenda/common/testutils/random"
+	"github.com/stretchr/testify/require"
+)
+
+// TestConversionConsistency checks that data can be encoded and decoded repeatedly, always getting back the original data
+// TODO: we should probably be using fuzzing instead of this kind of ad-hoc random search testing
+func TestConversionConsistency(t *testing.T) {
+	testRandom := random.NewTestRandom(t)
+
+	iterations := 100
+
+	for i := 0; i < iterations; i++ {
+		originalData := testRandom.Bytes(testRandom.Intn(1024) + 1) // ensure it's not length 0
+
+		payload := NewPayload(originalData)
+
+		blob1, err := payload.ToBlob(PolynomialFormEval)
+		require.NoError(t, err)
+
+		blob2, err := payload.ToBlob(PolynomialFormCoeff)
+		require.NoError(t, err)
+
+		decodedPayload1, err := blob1.ToPayload(PolynomialFormEval)
+		require.NoError(t, err)
+
+		decodedPayload2, err := blob2.ToPayload(PolynomialFormCoeff)
+		require.NoError(t, err)
+
+		// Compare the original data with the decoded data
+		if !bytes.Equal(originalData, decodedPayload1.GetBytes()) {
+			t.Fatalf(
+				"Iteration %d: original and data decoded from blob1 do not match\nOriginal: %v\nDecoded: %v",
+				i,
+				originalData,
+				decodedPayload1.GetBytes())
+		}
+
+		if !bytes.Equal(originalData, decodedPayload2.GetBytes()) {
+			t.Fatalf(
+				"Iteration %d: original and data decoded from blob2 do not match\nOriginal: %v\nDecoded: %v",
+				i,
+				originalData,
+				decodedPayload1.GetBytes())
+		}
+	}
+}

api/clients/codecs/default_blob_codec.go

@@ -22,7 +22,7 @@ func (v DefaultBlobCodec) EncodeBlob(rawData []byte) ([]byte, error) {
 	codecBlobHeader := make([]byte, 32)
 	// first byte is always 0 to ensure the codecBlobHeader is a valid bn254 element
 	// encode version byte
-	codecBlobHeader[1] = byte(DefaultBlobEncoding)
+	codecBlobHeader[1] = byte(PayloadEncodingVersion0)
 
 	// encode length as uint32
 	binary.BigEndian.PutUint32(codecBlobHeader[2:6], uint32(len(rawData))) // uint32 should be more than enough to store the length (approx 4gb)