Simplify client codec

api/clients/codecs/blob_codec.go

@@ -1,48 +1,73 @@
 package codecs
 
 import (
+	"bytes"
+	"encoding/binary"
 	"fmt"
+
+	"github.com/Layr-Labs/eigenda/encoding/utils/codec"
 )
 
 type BlobEncodingVersion byte
 
 const (
-	// This minimal blob encoding contains a 32 byte header = [0x00, version byte, uint32 len of data, 0x00, 0x00,...]
+	// DefaultBlobEncoding entails a 32 byte header = [0x00, version byte, uint32 len of data, 0x00, 0x00,...]
 	// followed by the encoded data [0x00, 31 bytes of data, 0x00, 31 bytes of data,...]
 	DefaultBlobEncoding BlobEncodingVersion = 0x0
 )
 
-type BlobCodec interface {
-	DecodeBlob(encodedData []byte) ([]byte, error)
-	EncodeBlob(rawData []byte) ([]byte, error)
-}
+// EncodePayload accepts an arbitrary payload byte array, and encodes it.
+//
+// The returned bytes may be interpreted as a polynomial in Eval form, where each contained field element of
+// length 32 represents the evaluation of the polynomial at an expanded root of unity
+//
+// The returned bytes may or may not represent a blob. If the system is configured to distribute blobs in Coeff form,
+// then the data returned from this function must be IFFTed to produce the final blob. If the system is configured to
+// distribute blobs in Eval form, then the data returned from this function is the final blob representation.
+func EncodePayload(payload []byte) []byte {
+	payloadHeader := make([]byte, 32)
+	// first byte is always 0 to ensure the payloadHeader is a valid bn254 element
+	payloadHeader[1] = byte(DefaultBlobEncoding) // encode version byte
 
-func BlobEncodingVersionToCodec(version BlobEncodingVersion) (BlobCodec, error) {
-	switch version {
-	case DefaultBlobEncoding:
-		return DefaultBlobCodec{}, nil
-	default:
-		return nil, fmt.Errorf("unsupported blob encoding version: %x", version)
-	}
+	// encode payload length as uint32
+	binary.BigEndian.PutUint32(
+		payloadHeader[2:6],
+		uint32(len(payload))) // uint32 should be more than enough to store the length (approx 4gb)
+
+	// encode payload modulo bn254
+	// the resulting bytes subsequently may be treated as the evaluation of a polynomial
+	polynomialEval := codec.ConvertByPaddingEmptyByte(payload)
+
+	encodedPayload := append(payloadHeader, polynomialEval...)
+
+	return encodedPayload
 }
 
-func GenericDecodeBlob(data []byte) ([]byte, error) {
-	if len(data) <= 32 {
-		return nil, fmt.Errorf("data is not of length greater than 32 bytes: %d", len(data))
-	}
-	// 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])
-	codec, err := BlobEncodingVersionToCodec(version)
-	if err != nil {
-		return nil, err
+// DecodePayload accepts bytes representing an encoded payload, and returns the decoded payload
+//
+// This function expects the parameter bytes to be a polynomial in Eval form. In other words, if blobs in the system
+// are being distributed in Coeff form, a blob must be FFTed prior to being passed into the function.
+func DecodePayload(encodedPayload []byte) ([]byte, error) {
+	if len(encodedPayload) < 32 {
+		return nil, fmt.Errorf("encoded payload does not contain 32 header bytes, meaning it is malformed")
 	}
 
-	data, err = codec.DecodeBlob(data)
+	payloadLength := binary.BigEndian.Uint32(encodedPayload[2:6])
+
+	// decode raw data modulo bn254
+	nonPaddedData := codec.RemoveEmptyByteFromPaddedBytes(encodedPayload[32:])
+
+	reader := bytes.NewReader(nonPaddedData)
+	payload := make([]byte, payloadLength)
+	readLength, err := reader.Read(payload)
 	if err != nil {
-		return nil, fmt.Errorf("unable to decode blob: %w", err)
+		return nil, fmt.Errorf(
+			"failed to copy unpadded data into final buffer, length: %d, bytes read: %d",
+			payloadLength, readLength)
+	}
+	if uint32(readLength) != payloadLength {
+		return nil, fmt.Errorf("data length does not match length prefix")
 	}
 
-	return data, nil
+	return payload, nil
 }

api/clients/codecs/blob_codec_test.go

@@ -19,11 +19,8 @@ func randomByteSlice(length int64) []byte {
 	return b
 }
 
-// TestIFFTCodec tests the encoding and decoding of random byte streams
-func TestIFFTCodec(t *testing.T) {
-	// Create an instance of the DefaultBlobEncodingCodec
-	codec := codecs.NewIFFTCodec(codecs.NewDefaultBlobCodec())
-
+// TestCodec tests the encoding and decoding of random byte streams
+func TestCodec(t *testing.T) {
 	// Number of test iterations
 	const iterations = 100
 
@@ -36,48 +33,10 @@ func TestIFFTCodec(t *testing.T) {
 		originalData := randomByteSlice(length.Int64() + 1) // ensure it's not length 0
 
 		// Encode the original data
-		encodedData, err := codec.EncodeBlob(originalData)
-		if err != nil {
-			t.Fatalf("Iteration %d: failed to encode blob: %v", i, err)
-		}
-
-		// Decode the encoded data
-		decodedData, err := codec.DecodeBlob(encodedData)
-		if err != nil {
-			t.Fatalf("Iteration %d: failed to decode blob: %v", i, err)
-		}
-
-		// Compare the original data with the decoded data
-		if !bytes.Equal(originalData, decodedData) {
-			t.Fatalf("Iteration %d: original and decoded data do not match\nOriginal: %v\nDecoded: %v", i, originalData, decodedData)
-		}
-	}
-}
-
-// TestIFFTCodec tests the encoding and decoding of random byte streams
-func TestNoIFFTCodec(t *testing.T) {
-	// Create an instance of the DefaultBlobEncodingCodec
-	codec := codecs.NewNoIFFTCodec(codecs.NewDefaultBlobCodec())
-
-	// Number of test iterations
-	const iterations = 100
-
-	for i := 0; i < iterations; i++ {
-		// Generate a random length for the byte slice
-		length, err := rand.Int(rand.Reader, big.NewInt(1024)) // Random length between 0 and 1023
-		if err != nil {
-			panic(err)
-		}
-		originalData := randomByteSlice(length.Int64() + 1) // ensure it's not length 0
-
-		// Encode the original data
-		encodedData, err := codec.EncodeBlob(originalData)
-		if err != nil {
-			t.Fatalf("Iteration %d: failed to encode blob: %v", i, err)
-		}
+		encodedData := codecs.EncodePayload(originalData)
 
 		// Decode the encoded data
-		decodedData, err := codec.DecodeBlob(encodedData)
+		decodedData, err := codecs.DecodePayload(encodedData)
 		if err != nil {
 			t.Fatalf("Iteration %d: failed to decode blob: %v", i, err)
 		}

api/clients/codecs/fft_test.go

@@ -0,0 +1,39 @@
+package codecs
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/Layr-Labs/eigenda/common/testutils/random"
+	"github.com/stretchr/testify/require"
+)
+
+// TestFFT checks that data can be IFFTed and FFTed repeatedly, always getting back the original data
+func TestFFT(t *testing.T) {
+	testRandom := random.NewTestRandom(t)
+
+	// Number of test iterations
+	iterations := testRandom.Intn(100) + 1
+
+	for i := 0; i < iterations; i++ {
+		originalData := testRandom.Bytes(testRandom.Intn(1024) + 1) // ensure it's not length 0
+
+		encodedData := EncodePayload(originalData)
+		coeffPoly, err := IFFT(encodedData)
+		require.NoError(t, err)
+
+		evalPoly, err := FFT(coeffPoly)
+		require.NoError(t, err)
+
+		// Decode the encoded data
+		decodedData, err := DecodePayload(evalPoly)
+		if err != nil {
+			t.Fatalf("Iteration %d: failed to decode blob: %v", i, err)
+		}
+
+		// Compare the original data with the decoded data
+		if !bytes.Equal(originalData, decodedData) {
+			t.Fatalf("Iteration %d: original and decoded data do not match\nOriginal: %v\nDecoded: %v", i, originalData, decodedData)
+		}
+	}
+}

api/clients/codecs/polynomial_form.go

@@ -0,0 +1,12 @@
+package codecs
+
+// PolynomialForm is an enum that represents the different ways that a blob polynomial may be represented
+type PolynomialForm uint
+
+const (
+	// Eval is short for "evaluation form". The field elements represent the evaluation at the polynomial's expanded
+	// roots of unity
+	Eval PolynomialForm = iota
+	// Coeff is short for "coefficient form". The field elements represent the coefficients of the polynomial
+	Coeff
+)