feat: Cert encoding byte - address PR feedback

Author: ethenotethan

.devnet-alt-da/addresses.json

@@ -9,7 +9,7 @@
   "DisputeGameFactory": "0x8a1a5F20ADF3005022049880f799FBBF2a188cfC",
   "DisputeGameFactoryProxy": "0xeCb92a686D1ab066fc4E559A305FEB75DD512377",
   "FastPreimageOracle": "0xbc1b15C94465d383bB68F345bEba1F3fcD2af44B",
-  "FaultDisputeGame_0": "0x86a350621ED6d036E2Af9cC68865dEf4B31C13ae",
+  "FaultDisputeGame_0": "0x873112109C538909745B18Dc61CEbf1a167Ccc93",
   "FaultDisputeGame_254": "0x9218181FAb774F8DBD245C8a2544069F9A8C2A8a",
   "FaultDisputeGame_255": "0x401deDFb8536D84096Dd617689E770cB085ADfb7",
   "L1CrossDomainMessenger": "0x2CfFF1c8Df8CE2BA6CBa19699CCBa6F381734938",

.devnet-alt-da/allocs-l1.json

@@ -364,8 +364,8 @@ For `alt-da` Optimism rollups using EigenDA, the following [commitment schemas](
 | commitment_type (byte) | da_layer_byte | version_byte | encoding_byte | payload           |
 | ---------------------- | ------------- | ------------ | ------------- | ----------------- |
 | 0x00                   |               |              |               | keccak_commitment |
-| 0x01                   | 0x00          | 0x00         | N/A           | eigenda_cert_v0   |
-| 0x01                   | 0x00          | 0x01         | N/A           | eigenda_cert_v1   |
+| 0x01                   | 0x00          | 0x00         |               | eigenda_cert_v0   |
+| 0x01                   | 0x00          | 0x01         |               | eigenda_cert_v1   |
 | 0x01                   | 0x00          | 0x02         | 0x00          | eigenda_cert_v2 (RLP) |
 | 0x01                   | 0x00          | 0x02         | 0x01          | eigenda_cert_v2 (ABI_verifyDACertV2) |
 
@@ -376,8 +376,8 @@ For standard clients (i.e, `clients/standard_client/client.go`) communicating wi
 
 | version_byte | encoding_byte | payload         |
 | ------------ | ------------- | --------------- |
-| 0x00         | N/A           | eigenda_cert_v0 |
-| 0x01         | N/A           | eigenda_cert_v1 |
+| 0x00         |               | eigenda_cert_v0 |
+| 0x01         |               | eigenda_cert_v1 |
 | 0x02         | 0x00          | eigenda_cert_v2 (RLP) |
 | 0x02         | 0x01          | eigenda_cert_v2 (ABI_verifyDACertV2) |
 

README.md

@@ -21,7 +21,7 @@ type CertCommitment interface {
 type EigenDACommitment struct {
 	prefix   EigenDACommitmentType
 	b        []byte
-	encoding *EncodingType // Optional encoding type, used only for V2+
+	encoding EncodingType // Optional encoding type, used only for V2+
 }
 
 // NewEigenDACommitment creates a new commitment from the given input.
@@ -38,7 +38,7 @@ func NewEigenDACommitmentWithEncoding(input []byte, commitmentType EigenDACommit
 	return EigenDACommitment{
 		prefix:   commitmentType,
 		b:        input,
-		encoding: &encoding,
+		encoding: encoding,
 	}
 }
 
@@ -50,8 +50,8 @@ func (c EigenDACommitment) CommitmentType() EigenDACommitmentType {
 // Encode adds a commitment type prefix self describing the commitment.
 func (c EigenDACommitment) Encode() []byte {
 	// For V2+ certificates with encoding type
-	if c.prefix >= CertV2 && c.encoding != nil {
-		return append([]byte{byte(c.prefix), byte(*c.encoding)}, c.b...)
+	if c.prefix >= CertV2 {
+		return append([]byte{byte(c.prefix), byte(c.encoding)}, c.b...)
 	}
 
 	// For V0/V1 certificates (backward compatibility)

commitments/eigenda.go

@@ -2,6 +2,7 @@ package commitments
 
 import (
 	"fmt"
+	"strings"
 )
 
 // EncodingType represents the serialization format for the certificate
@@ -44,76 +45,47 @@ func StringToCommitmentMode(s string) (CommitmentMode, error) {
 }
 
 func StringToEncodingType(s string) (EncodingType, error) {
-	switch s {
-	case "rlp", "RLP", "0":
+	switch strings.ToLower(s) {
+	case "rlp", "0":
 		return RLPEncoding, nil
-	case "abi", "ABI", "1":
+	case "abi", "1":
 		return ABIVerifyV2CertEncoding, nil
 	default:
 		return RLPEncoding, fmt.Errorf("unknown encoding type: %s, using default RLP encoding", s)
 	}
 }
 
-// DecodeCommitmentType returns the encoding type from a certificate commitment
-func DecodeCommitmentType(cert []byte) (EigenDACommitmentType, EncodingType, []byte, error) {
-	if len(cert) == 0 {
-		return 0, 0, nil, fmt.Errorf("commitment is empty")
-	}
-
-	// Extract version byte (always present)
-	version := EigenDACommitmentType(cert[0])
-	var encoding EncodingType
-	var payload []byte
-
-	// For CertV2+, we have an encoding byte
-	if version >= CertV2 {
-		if len(cert) < 2 {
-			return 0, 0, nil, fmt.Errorf("commitment too short for CertV2")
-		}
-		encoding = EncodingType(cert[1])
-		payload = cert[2:] // Skip version and encoding bytes
-	} else {
-		// For CertV0/V1, there's no encoding byte (default to RLP)
-		encoding = RLPEncoding
-		payload = cert[1:] // Skip only version byte
-	}
-
-	return version, encoding, payload, nil
-}
-
 func EncodeCommitment(
 	bytes []byte,
-	commitmentMode CommitmentMode,
-	commitmentType EigenDACommitmentType,
-	encodingType EncodingType,
+	cm CommitmentMeta,
 ) ([]byte, error) {
-	switch commitmentMode {
+	switch cm.Mode {
 	case OptimismKeccak:
 		return Keccak256Commitment(bytes).Encode(), nil
 
 	case OptimismGeneric:
 		// For V2 certificates with encoding specified, add encoding byte
-		if commitmentType >= CertV2 {
-			certCommit := NewEigenDACommitmentWithEncoding(bytes, commitmentType, encodingType).Encode()
+		if cm.Version >= CertV2 {
+			certCommit := NewEigenDACommitmentWithEncoding(bytes, cm.Version, cm.Encoding).Encode()
 			svcCommit := EigenDASvcCommitment(certCommit).Encode()
 			altDACommit := NewGenericCommitment(svcCommit).Encode()
 			return altDACommit, nil
 		}
 
 		// Fallback to previous behavior for V0/V1
-		certCommit := NewEigenDACommitment(bytes, commitmentType).Encode()
+		certCommit := NewEigenDACommitment(bytes, cm.Version).Encode()
 		svcCommit := EigenDASvcCommitment(certCommit).Encode()
 		altDACommit := NewGenericCommitment(svcCommit).Encode()
 		return altDACommit, nil
 
 	case Standard:
 		// For V2 certificates with encoding specified, add encoding byte
-		if commitmentType >= CertV2 {
-			return NewEigenDACommitmentWithEncoding(bytes, commitmentType, encodingType).Encode(), nil
+		if cm.Version >= CertV2 {
+			return NewEigenDACommitmentWithEncoding(bytes, cm.Version, cm.Encoding).Encode(), nil
 		}
 
 		// Fallback to previous behavior for V0/V1
-		return NewEigenDACommitment(bytes, commitmentType).Encode(), nil
+		return NewEigenDACommitment(bytes, cm.Version).Encode(), nil
 	}
 
 	return nil, fmt.Errorf("unknown commitment mode")

commitments/mode.go

@@ -56,14 +56,8 @@ func EncodeV2CertToBytes(encoding commitments.EncodingType, cert *coretypes.Eige
 	}
 }
 
-func interfaceToBytesJSON(data interface{}) ([]byte, error) {
-	bytes, err := json.Marshal(data)
-	if err != nil {
-		return nil, err
-	}
-	return bytes, nil
-}
-
+// DecodeV2CertFromBytes ... Decodes a raw DA commitment into an EigenDA V2 certificate
+// provided the respective encoding version
 func DecodeV2CertFromBytes(encoding commitments.EncodingType, commitment []byte) (*coretypes.EigenDACert, error) {
 	switch encoding {
 	case commitments.ABIVerifyV2CertEncoding:
@@ -76,13 +70,13 @@ func DecodeV2CertFromBytes(encoding commitments.EncodingType, commitment []byte)
 
 		// use json as intermediary to cast abstract type to bytes to
 		// then deserialize into structured certificate type
-		b, err := interfaceToBytesJSON(abiMap)
+		bytes, err := json.Marshal(commitment)
 		if err != nil {
 			return nil, err
 		}
 
 		var cert *coretypes.EigenDACert
-		err = json.Unmarshal(b, &cert)
+		err = json.Unmarshal(bytes, &cert)
 
 		if err != nil {
 			return nil, fmt.Errorf("json unmarshal v2 cert: %w", err)

common/serialization.go

@@ -34,18 +34,9 @@ func (svr *Server) handleHealth(w http.ResponseWriter, _ *http.Request) error {
 // GET ROUTES
 // =================================================================================================
 
-// handleGetStdCommitment handles the GET request for std commitments.
-func (svr *Server) handleGetStdCommitment(w http.ResponseWriter, r *http.Request) error {
-	versionByte, err := parseVersionByte(w, r)
-	if err != nil {
-		return fmt.Errorf("error parsing version byte: %w", err)
-	}
-
-	commitmentMeta := commitments.CommitmentMeta{
-		Mode:     commitments.OptimismGeneric,
-		Version:  commitments.EigenDACommitmentType(versionByte),
-		Encoding: commitments.RLPEncoding,
-	}
+// handleGetEigenDA helper function used for processing gets for an eigenda backend type
+func (svr *Server) handleGetEigenDA(w http.ResponseWriter, r *http.Request,
+	cm commitments.CommitmentMeta) error {
 
 	rawCommitmentHex, ok := mux.Vars(r)[routingVarNamePayloadHex]
 	if !ok {
@@ -56,12 +47,28 @@ func (svr *Server) handleGetStdCommitment(w http.ResponseWriter, r *http.Request
 		return fmt.Errorf("failed to decode commitment %s: %w", rawCommitmentHex, err)
 	}
 
-	if versionByte >= byte(commitments.CertV2) {
-		commitmentMeta.Encoding = commitments.EncodingType(commitment[0])
+	if cm.Version >= commitments.CertV2 {
+		cm.Encoding = commitments.EncodingType(commitment[0])
 		commitment = commitment[1:]
 	}
 
-	return svr.handleGetShared(r.Context(), w, commitment, commitmentMeta)
+	return svr.handleGetShared(r.Context(), w, commitment, cm)
+}
+
+// handleGetStdCommitment handles the GET request for std commitments.
+func (svr *Server) handleGetStdCommitment(w http.ResponseWriter, r *http.Request) error {
+	versionByte, err := parseVersionByte(w, r)
+	if err != nil {
+		return fmt.Errorf("error parsing version byte: %w", err)
+	}
+
+	meta := commitments.CommitmentMeta{
+		Mode:     commitments.Standard,
+		Version:  commitments.EigenDACommitmentType(versionByte),
+		Encoding: commitments.RLPEncoding,
+	}
+
+	return svr.handleGetEigenDA(w, r, meta)
 }
 
 // handleGetOPKeccakCommitment handles the GET request for optimism keccak commitments.
@@ -97,27 +104,14 @@ func (svr *Server) handleGetOPGenericCommitment(w http.ResponseWriter, r *http.R
 		return fmt.Errorf("error parsing version byte: %w", err)
 	}
 
-	commitmentMeta := commitments.CommitmentMeta{
+	meta := commitments.CommitmentMeta{
 		Mode:     commitments.OptimismGeneric,
 		Version:  commitments.EigenDACommitmentType(versionByte),
 		Encoding: commitments.RLPEncoding,
 	}
 
-	rawCommitmentHex, ok := mux.Vars(r)[routingVarNamePayloadHex]
-	if !ok {
-		return fmt.Errorf("commitment not found in path: %s", r.URL.Path)
-	}
-	commitment, err := hex.DecodeString(rawCommitmentHex)
-	if err != nil {
-		return fmt.Errorf("failed to decode commitment %s: %w", rawCommitmentHex, err)
-	}
+	return svr.handleGetEigenDA(w, r, meta)
 
-	if versionByte >= byte(commitments.CertV2) {
-		commitmentMeta.Encoding = commitments.EncodingType(commitment[0])
-		commitment = commitment[1:]
-	}
-
-	return svr.handleGetShared(r.Context(), w, commitment, commitmentMeta)
 }
 
 func (svr *Server) handleGetShared(
@@ -173,28 +167,33 @@ func (svr *Server) handleGetEigenDADispersalBackend(w http.ResponseWriter, _ *ht
 // POST ROUTES
 // =================================================================================================
 
-// handlePostStdCommitment handles the POST request for std commitments.
 // parseEncodingQueryParamType parses the encoding query parameter
-func parseEncodingQueryParamType(w http.ResponseWriter, r *http.Request) (commitments.EncodingType, bool, error) {
+func (svr *Server) parseEncodingQueryParamType(w http.ResponseWriter, r *http.Request) (commitments.EncodingType, error) {
 	encodingParam := r.URL.Query().Get(routingQueryParamEncoding)
 	if encodingParam == "" {
 		// If no encoding is provided, use default RLP encoding
-		return commitments.RLPEncoding, false, nil
+		return commitments.RLPEncoding, nil
+	}
+
+	// if encoding param provided but historical V1 backend used then error
+	if svr.sm.GetDispersalBackend() == common.V1EigenDABackend {
+
 	}
 
 	// Parse the encoding type
 	encoding, err := commitments.StringToEncodingType(encodingParam)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("Invalid encoding type: %s", encodingParam), http.StatusBadRequest)
-		return commitments.RLPEncoding, false, err
+		return commitments.RLPEncoding, err
 	}
 
-	return encoding, true, nil
+	return encoding, nil
 }
 
+// handlePostStdCommitment handles the POST request for std commitments.
 func (svr *Server) handlePostStdCommitment(w http.ResponseWriter, r *http.Request) error {
 	// Parse encoding type from query parameter
-	encodingType, hasEncoding, err := parseEncodingQueryParamType(w, r)
+	encodingType, err := svr.parseEncodingQueryParamType(w, r)
 	if err != nil {
 		return err
 	}
@@ -207,11 +206,7 @@ func (svr *Server) handlePostStdCommitment(w http.ResponseWriter, r *http.Reques
 
 	if svr.sm.GetDispersalBackend() == common.V2EigenDABackend {
 		// If encoding is specified and we're using V2, use CertV2
-		if hasEncoding {
-			commitmentMeta.Version = commitments.CertV2
-		} else {
-			commitmentMeta.Version = commitments.CertV1
-		}
+		commitmentMeta.Version = commitments.CertV2
 	}
 
 	return svr.handlePostShared(w, r, nil, commitmentMeta)
@@ -227,16 +222,10 @@ func (svr *Server) handlePostOPKeccakCommitment(w http.ResponseWriter, r *http.R
 	// 	return err
 	// }
 
-	// Parse encoding type from query parameter
-	encodingType, _, err := parseEncodingQueryParamType(w, r)
-	if err != nil {
-		return err
-	}
-
 	commitmentMeta := commitments.CommitmentMeta{
 		Mode:     commitments.OptimismKeccak,
 		Version:  commitments.CertV0,
-		Encoding: encodingType,
+		Encoding: commitments.RLPEncoding,
 	}
 
 	rawCommitmentHex, ok := mux.Vars(r)[routingVarNamePayloadHex]
@@ -254,7 +243,7 @@ func (svr *Server) handlePostOPKeccakCommitment(w http.ResponseWriter, r *http.R
 // handlePostOPGenericCommitment handles the POST request for optimism generic commitments.
 func (svr *Server) handlePostOPGenericCommitment(w http.ResponseWriter, r *http.Request) error {
 	// Parse encoding type from query parameter
-	encodingType, hasEncoding, err := parseEncodingQueryParamType(w, r)
+	encodingType, err := svr.parseEncodingQueryParamType(w, r)
 	if err != nil {
 		return err
 	}
@@ -266,12 +255,7 @@ func (svr *Server) handlePostOPGenericCommitment(w http.ResponseWriter, r *http.
 	}
 
 	if svr.sm.GetDispersalBackend() == common.V2EigenDABackend {
-		// If encoding is specified and we're using V2, use CertV2
-		if hasEncoding {
-			commitmentMeta.Version = commitments.CertV2
-		} else {
-			commitmentMeta.Version = commitments.CertV1
-		}
+		commitmentMeta.Version = commitments.CertV2
 	}
 
 	return svr.handlePostShared(w, r, nil, commitmentMeta)
@@ -314,7 +298,7 @@ func (svr *Server) handlePostShared(
 		return err
 	}
 
-	responseCommit, err := commitments.EncodeCommitment(commitment, meta.Mode, meta.Version, meta.Encoding)
+	responseCommit, err := commitments.EncodeCommitment(commitment, meta)
 	if err != nil {
 		err = MetaError{
 			Err:  fmt.Errorf("failed to encode commitment %v (commitment mode %v): %w", commitment, meta.Mode, err),