Add query param to GET and PUT for commitment interpretation type

.github/workflows/actions.yml

@@ -70,12 +70,11 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v3
       with:
-        go-version: 1.21        
+        go-version: 1.21
 
     - name: Install project dependencies
       run: | 
         go mod download
-
     - name: Run holesky tests
       env: 
         SIGNER_PRIVATE_KEY:  ${{ secrets.SIGNER_PRIVATE_KEY }}

client/client.go

@@ -7,14 +7,7 @@ import (
 	"io"
 	"net/http"
 
-	"github.com/Layr-Labs/eigenda-proxy/common"
-	"github.com/Layr-Labs/eigenda-proxy/eigenda"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-const (
-	// NOTE: this will need to be updated as plasma's implementation changes
-	decodingOffset = 3
+	"github.com/Layr-Labs/eigenda-proxy/server"
 )
 
 // TODO: Add support for custom http client option
@@ -25,8 +18,8 @@ type Config struct {
 // ProxyClient is an interface for communicating with the EigenDA proxy server
 type ProxyClient interface {
 	Health() error
-	GetData(ctx context.Context, cert *common.Certificate, domain common.DomainType) ([]byte, error)
-	SetData(ctx context.Context, b []byte) (*common.Certificate, error)
+	GetData(ctx context.Context, cert []byte, domain server.DomainType) ([]byte, error)
+	SetData(ctx context.Context, b []byte) ([]byte, error)
 }
 
 // client is the implementation of ProxyClient
@@ -35,6 +28,8 @@ type client struct {
 	httpClient *http.Client
 }
 
+var _ ProxyClient = (*client)(nil)
+
 func New(cfg *Config) ProxyClient {
 	return &client{
 		cfg,
@@ -64,16 +59,8 @@ func (c *client) Health() error {
 }
 
 // GetData fetches blob data associated with a DA certificate
-func (c *client) GetData(ctx context.Context, cert *common.Certificate, domain common.DomainType) ([]byte, error) {
-	b, err := rlp.EncodeToBytes(cert)
-	if err != nil {
-		return nil, err
-	}
-
-	// encode prefix bytes
-	b = eigenda.Commitment(b).Encode()
-
-	url := fmt.Sprintf("%s/get/0x%x?domain=%s", c.cfg.URL, b, domain.String())
+func (c *client) GetData(ctx context.Context, comm []byte, domain server.DomainType) ([]byte, error) {
+	url := fmt.Sprintf("%s/get/0x%x?domain=%s&commitment_mode=simple", c.cfg.URL, comm, domain.String())
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -96,8 +83,8 @@ func (c *client) GetData(ctx context.Context, cert *common.Certificate, domain c
 }
 
 // SetData writes raw byte data to DA and returns the respective certificate
-func (c *client) SetData(ctx context.Context, b []byte) (*common.Certificate, error) {
-	url := fmt.Sprintf("%s/put/", c.cfg.URL)
+func (c *client) SetData(ctx context.Context, b []byte) ([]byte, error) {
+	url := fmt.Sprintf("%s/put/?commitment_mode=simple", c.cfg.URL)
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(b))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
@@ -117,14 +104,9 @@ func (c *client) SetData(ctx context.Context, b []byte) (*common.Certificate, er
 		return nil, err
 	}
 
-	if len(b) < decodingOffset {
-		return nil, fmt.Errorf("read certificate is of invalid length: %d", len(b))
-	}
-
-	var cert *common.Certificate
-	if err = rlp.DecodeBytes(b[decodingOffset:], &cert); err != nil {
-		return nil, err
+	if len(b) == 0 {
+		return nil, fmt.Errorf("read certificate is empty")
 	}
 
-	return cert, err
+	return b, err
 }

cmd/server/entrypoint.go

@@ -5,9 +5,9 @@ import (
 	"fmt"
 
 	"github.com/Layr-Labs/eigenda-proxy/metrics"
+	"github.com/Layr-Labs/eigenda-proxy/server"
 	"github.com/urfave/cli/v2"
 
-	"github.com/Layr-Labs/eigenda-proxy/server"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum-optimism/optimism/op-service/opio"
 )

commitments/da_service_op.go

@@ -0,0 +1,67 @@
+package commitments
+
+import (
+	"fmt"
+	"log"
+)
+
+type DAServiceOPCommitmentType byte
+
+const (
+	EigenDAByte DAServiceOPCommitmentType = 0
+)
+
+// DAServiceOPCommitment represents a value of one of two possible types (Keccak256Commitment or DAServiceCommitment).
+type DAServiceOPCommitment struct {
+	eigendaCommitment *EigenDACommitment
+}
+
+var _ Commitment = (*DAServiceOPCommitment)(nil)
+
+func OptimismEigenDACommitment(value EigenDACommitment) DAServiceOPCommitment {
+	return DAServiceOPCommitment{eigendaCommitment: &value}
+}
+
+func (e DAServiceOPCommitment) IsEigenDA() bool {
+	return e.eigendaCommitment != nil
+}
+
+func (e DAServiceOPCommitment) MustEigenDAValue() EigenDACommitment {
+	if e.eigendaCommitment != nil {
+		return *e.eigendaCommitment
+	}
+	log.Panic("CommitmentEither does not contain a Keccak256Commitment value")
+	return EigenDACommitment{} // This will never be reached, but is required for compilation.
+}
+
+func (e DAServiceOPCommitment) Marshal() ([]byte, error) {
+	if e.IsEigenDA() {
+		eigenDABytes, err := e.MustEigenDAValue().Marshal()
+		if err != nil {
+			return nil, err
+		}
+		return append([]byte{byte(EigenDAByte)}, eigenDABytes...), nil
+	} else {
+		return nil, fmt.Errorf("DAServiceOPCommitment is neither a keccak256 commitment or a DA service commitment")
+	}
+}
+
+func (e *DAServiceOPCommitment) Unmarshal(bz []byte) error {
+	if len(bz) < 1 {
+		return fmt.Errorf("OP commitment does not contain generic commitment type prefix byte")
+	}
+	head := DAServiceOPCommitmentType(bz[0])
+	tail := bz[1:]
+	switch head {
+	case EigenDAByte:
+		eigendaCommitment := EigenDACommitment{}
+		err := eigendaCommitment.Unmarshal(tail)
+		if err != nil {
+			return err
+		}
+		e.eigendaCommitment = &eigendaCommitment
+	default:
+		return fmt.Errorf("unrecognized generic commitment type byte: %x", bz[0])
+	}
+	return nil
+}

commitments/eigenda.go

@@ -0,0 +1,58 @@
+package commitments
+
+import (
+	"fmt"
+	"log"
+)
+
+// Define the parent and child types
+type CertEncodingVersion byte
+
+const (
+	CertEncodingV0 CertEncodingVersion = 0
+)
+
+type EigenDACommitment struct {
+	certV0 []byte
+}
+
+var _ Commitment = (*EigenDACommitment)(nil)
+
+func EigenDACertV0(value []byte) EigenDACommitment {
+	return EigenDACommitment{certV0: value}
+}
+
+func (e EigenDACommitment) IsCertV0() bool {
+	return e.certV0 != nil
+}
+
+func (e EigenDACommitment) MustCertV0Value() []byte {
+	if e.certV0 != nil {
+		return e.certV0
+	}
+	log.Panic("CommitmentEither does not contain a Keccak256Commitment value")
+	return nil // This will never be reached, but is required for compilation.
+}
+
+func (e EigenDACommitment) Marshal() ([]byte, error) {
+	if e.IsCertV0() {
+		return append([]byte{byte(CertEncodingV0)}, e.certV0...), nil
+	} else {
+		return nil, fmt.Errorf("EigenDADAServiceOPCommitment is of unknown type")
+	}
+}
+
+func (e *EigenDACommitment) Unmarshal(bz []byte) error {
+	if len(bz) < 1 {
+		return fmt.Errorf("OP commitment does not contain eigenda commitment encoding version prefix byte")
+	}
+	head := CertEncodingVersion(bz[0])
+	tail := bz[1:]
+	switch head {
+	case CertEncodingV0:
+		e.certV0 = tail
+	default:
+		return fmt.Errorf("unrecognized EigenDA commitment encoding type byte: %x", bz[0])
+	}
+	return nil
+}

commitments/interface.go

@@ -0,0 +1,6 @@
+package commitments
+
+type Commitment interface {
+	Marshal() ([]byte, error)
+	Unmarshal([]byte) error
+}

commitments/op.go

@@ -0,0 +1,90 @@
+package commitments
+
+import (
+	"fmt"
+	"log"
+)
+
+type OPCommitmentType byte
+
+const (
+	// Keccak256CommitmentTypeByte represents a commitment using Keccak256 hashing.
+	Keccak256CommitmentTypeByte OPCommitmentType = 0
+	// GenericCommitmentTypeByte represents a commitment using a DA service.
+	GenericCommitmentTypeByte OPCommitmentType = 1
+)
+
+type OPCommitment struct {
+	keccak256Commitment []byte
+	genericCommitment   *DAServiceOPCommitment
+}
+
+var _ Commitment = (*OPCommitment)(nil)
+
+func Keccak256Commitment(value []byte) OPCommitment {
+	return OPCommitment{keccak256Commitment: value}
+}
+
+func GenericCommitment(value DAServiceOPCommitment) OPCommitment {
+	return OPCommitment{genericCommitment: &value}
+}
+
+func (e OPCommitment) IsKeccak256Commitment() bool {
+	return e.keccak256Commitment != nil
+}
+
+func (e OPCommitment) IsGenericCommitment() bool {
+	return e.genericCommitment != nil
+}
+
+func (e OPCommitment) MustKeccak256CommitmentValue() []byte {
+	if e.keccak256Commitment != nil {
+		return e.keccak256Commitment
+	}
+	log.Panic("OPCommitment does not contain a Keccak256Commitment value")
+	return nil // This will never be reached, but is required for compilation.
+}
+
+func (e OPCommitment) MustGenericCommitmentValue() DAServiceOPCommitment {
+	if e.genericCommitment != nil {
+		return *e.genericCommitment
+	}
+	log.Panic("OPCommitment does not contain a DAServiceCommitment value")
+	return DAServiceOPCommitment{} // This will never be reached, but is required for compilation.
+}
+
+func (e OPCommitment) Marshal() ([]byte, error) {
+	if e.IsGenericCommitment() {
+		bytes, err := e.MustGenericCommitmentValue().Marshal()
+		if err != nil {
+			return nil, err
+		}
+		return append([]byte{byte(GenericCommitmentTypeByte)}, bytes...), nil
+	} else if e.IsKeccak256Commitment() {
+		return append([]byte{byte(Keccak256CommitmentTypeByte)}, e.MustKeccak256CommitmentValue()...), nil
+	} else {
+		return nil, fmt.Errorf("OPCommitment is neither a Keccak256 commitment nor a DA service commitment")
+	}
+}
+
+func (e *OPCommitment) Unmarshal(bz []byte) error {
+	if len(bz) < 1 {
+		return fmt.Errorf("OPCommitment does not contain a commitment type prefix byte")
+	}
+	head := OPCommitmentType(bz[0])
+	tail := bz[1:]
+	switch head {
+	case Keccak256CommitmentTypeByte:
+		e.keccak256Commitment = tail
+	case GenericCommitmentTypeByte:
+		daServiceCommitment := DAServiceOPCommitment{}
+		err := daServiceCommitment.Unmarshal(tail)
+		if err != nil {
+			return err
+		}
+		e.genericCommitment = &daServiceCommitment
+	default:
+		return fmt.Errorf("unrecognized commitment type byte: %x", bz[0])
+	}
+	return nil
+}