Pad upon poly construction

Signed-off-by: litt3 <102969658+litt3@users.noreply.github.com>

api/clients/codecs/coeff_poly.go

@@ -20,11 +20,9 @@ type coeffPoly struct {
 // coeffPolyFromBytes creates a new coeffPoly 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) {
-	if !encoding.IsPowerOfTwo(len(bytes)) {
-		return nil, fmt.Errorf("bytes have length %d, expected a power of 2", len(bytes))
-	}
+	paddedBytes := encoding.PadToPowerOfTwo(bytes)
 
-	fieldElements, err := rs.BytesToFieldElements(bytes)
+	fieldElements, err := rs.BytesToFieldElements(paddedBytes)
 	if err != nil {
 		return nil, fmt.Errorf("deserialize field elements: %w", err)
 	}

api/clients/codecs/encoded_payload.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"fmt"
 
-	"github.com/Layr-Labs/eigenda/core"
 	"github.com/Layr-Labs/eigenda/encoding/utils/codec"
 )
 
@@ -49,13 +48,9 @@ func (ep *encodedPayload) decode() (*Payload, error) {
 	return NewPayload(nonPaddedData[0:claimedLength]), nil
 }
 
-// toEvalPoly converts an encodedPayload into an evalPoly, by padding the encodedPayload bytes to the next power of 2
+// toEvalPoly converts an encodedPayload into an evalPoly
 func (ep *encodedPayload) toEvalPoly() (*evalPoly, error) {
-	paddedLength := core.NextPowerOf2(len(ep.bytes))
-	paddedBytes := make([]byte, paddedLength)
-	copy(paddedBytes, ep.bytes)
-
-	evalPoly, err := evalPolyFromBytes(paddedBytes)
+	evalPoly, err := evalPolyFromBytes(ep.bytes)
 	if err != nil {
 		return nil, fmt.Errorf("new eval poly: %w", err)
 	}

api/clients/codecs/eval_poly.go

@@ -23,11 +23,9 @@ type evalPoly struct {
 // evalPolyFromBytes creates a new evalPoly 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 evalPolyFromBytes(bytes []byte) (*evalPoly, error) {
-	if !encoding.IsPowerOfTwo(len(bytes)) {
-		return nil, fmt.Errorf("bytes have length %d, expected a power of 2", len(bytes))
-	}
+	paddedBytes := encoding.PadToPowerOfTwo(bytes)
 
-	fieldElements, err := rs.BytesToFieldElements(bytes)
+	fieldElements, err := rs.BytesToFieldElements(paddedBytes)
 	if err != nil {
 		return nil, fmt.Errorf("deserialize field elements: %w", err)
 	}

encoding/utils.go

@@ -35,7 +35,10 @@ func NextPowerOf2[T constraints.Integer](d T) T {
 	return T(math.Pow(2.0, nextPower))
 }
 
-// IsPowerOfTwo returns true if the input is a power of 2, otherwise false
-func IsPowerOfTwo[T constraints.Integer](input T) bool {
-	return (input&(input-1) == 0) && input != 0
+// PadToPowerOfTwo pads a byte slice to the next power of 2
+// TODO: test to make sure this doesn't increase size if already a power of 2
+func PadToPowerOfTwo(bytes []byte) []byte {
+	paddedLength := NextPowerOf2(len(bytes))
+	padding := make([]byte, paddedLength-len(bytes))
+	return append(bytes, padding...)
 }