feat: v3 cert type with new interaction patterns with onchain Router && CertVerifier interfaces

api/clients/v2/cert_builder.go

@@ -0,0 +1,174 @@
+package clients
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/Layr-Labs/eigenda/api/clients/v2/coretypes"
+	coreEth "github.com/Layr-Labs/eigenda/core/eth"
+
+	disperser "github.com/Layr-Labs/eigenda/api/grpc/disperser/v2"
+	"github.com/Layr-Labs/eigenda/common"
+	certTypesBinding "github.com/Layr-Labs/eigenda/contracts/bindings/IEigenDACertTypeBindings"
+	opsrbinding "github.com/Layr-Labs/eigenda/contracts/bindings/OperatorStateRetriever"
+	"github.com/Layr-Labs/eigenda/core"
+	coreV2 "github.com/Layr-Labs/eigenda/core/v2"
+	"github.com/Layr-Labs/eigensdk-go/logging"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	gethcommon "github.com/ethereum/go-ethereum/common"
+)
+
+
+type CertBuilder struct {
+	logger 					logging.Logger
+	opsrCaller				*opsrbinding.ContractOperatorStateRetrieverCaller
+	registryCoordinatorAddr gethcommon.Address
+}
+
+// NewCertBuilder constructs a new CertBuilder instance used to build EigenDA certificates
+// across different versions.
+func NewCertBuilder(
+	logger logging.Logger,
+	opsrAddr gethcommon.Address,
+	registryCoordinatorAddr gethcommon.Address,
+	ethClient common.EthClient,
+) (*CertBuilder, error) {
+	if logger == nil {
+		return nil, fmt.Errorf("logger cannot be nil")
+	}
+	// Create the Operator State Retriever caller
+	opsrCaller, err := opsrbinding.NewContractOperatorStateRetrieverCaller(opsrAddr, ethClient)
+	if err != nil {
+		return nil, fmt.Errorf("create operator state retriever caller: %w", err)
+	}
+
+
+	return &CertBuilder{
+		logger: logger,
+		opsrCaller: opsrCaller,
+		registryCoordinatorAddr: registryCoordinatorAddr,
+	}, nil
+}
+
+// BuildCert builds an EigenDA certificate of the specified version using the provided blob key and blob status reply.
+func (cb *CertBuilder) BuildCert(
+	ctx context.Context,
+	certVersion coretypes.CertificateVersion,
+	blobKey coreV2.BlobKey,
+	blobStatusReply *disperser.BlobStatusReply,
+) (coretypes.EigenDACert, error) {
+	switch certVersion {
+	case coretypes.VersionThreeCert:
+		return cb.buildEigenDAV3Cert(ctx, blobKey, blobStatusReply)
+	default:
+		return nil, fmt.Errorf("unsupported EigenDA cert version: %d", certVersion)
+	}
+}
+
+// buildEigenDAV3Cert builds an EigenDA certificate of version 3 using the provided blob key and blob status reply.
+func (cb *CertBuilder) buildEigenDAV3Cert(
+	ctx context.Context,
+	blobKey coreV2.BlobKey,
+	blobStatusReply *disperser.BlobStatusReply,
+) (*coretypes.EigenDACertV3, error) {
+	// TODO: configurable timeout
+	timeoutCtx, cancel := context.WithTimeout(ctx, time.Second)
+	defer cancel()
+	nonSignerStakesAndSignature, err := cb.getNonSignerStakesAndSignature(
+		timeoutCtx, blobStatusReply.GetSignedBatch())
+	if err != nil {
+		return nil, fmt.Errorf("get non signer stake and signature: %w", err)
+	}
+	cb.logger.Debug("Retrieved NonSignerStakesAndSignature", "blobKey", blobKey.Hex())
+
+	eigenDACert, err := coretypes.BuildEigenDACertV3(blobStatusReply, nonSignerStakesAndSignature)
+	if err != nil {
+		return nil, fmt.Errorf("build eigenda v3 cert: %w", err)
+	}
+	cb.logger.Debug("Constructed EigenDACertV3", "blobKey", blobKey.Hex())
+
+	return eigenDACert, nil
+}
+
+// GetNonSignerStakesAndSignature constructs a NonSignerStakesAndSignature object by calling an
+// onchain OperatorStateRetriever retriever to fetch necessary non-signer metadata
+func (cb *CertBuilder)  getNonSignerStakesAndSignature(
+	ctx context.Context,
+	signedBatch *disperser.SignedBatch,
+) (*certTypesBinding.EigenDATypesV1NonSignerStakesAndSignature, error) {
+	// 1 - Pre-process inputs for operator state retriever call
+	signedBatchBinding, err := coretypes.SignedBatchProtoToV2CertBinding(signedBatch)
+	if err != nil {
+		return nil, fmt.Errorf("convert signed batch: %w", err)
+	}
+
+	nonSignerPubKeys := signedBatchBinding.Attestation.NonSignerPubkeys
+
+	// 2a - create operator IDs by hashing non-signer public keys
+	nonSignerOperatorIDs := make([][32]byte, len(nonSignerPubKeys))
+	for i, pubKeySet := range nonSignerPubKeys {
+		g1Point := core.NewG1Point(pubKeySet.X, pubKeySet.Y)
+		nonSignerOperatorIDs[i] = coreEth.HashPubKeyG1(g1Point)
+	}
+
+	// 2b - cast []uint32 to []byte for quorum numbers
+	quorumNumbers := make([]byte, len(signedBatch.GetAttestation().GetQuorumNumbers()))
+	for i, qn := range signedBatch.GetAttestation().GetQuorumNumbers() {
+		quorumNumbers[i] = byte(qn)
+	}
+
+	// use the reference block # from the disperser generated signed batch header
+	// for referencing operator states at a specific block checkpoint
+	rbn := signedBatch.GetHeader().GetReferenceBlockNumber()
+
+	// 3 - call operator state retriever to fetch signature indices
+	checkSigIndices, err := cb.opsrCaller.GetCheckSignaturesIndices(&bind.CallOpts{Context: ctx, BlockNumber: big.NewInt(int64(rbn))},
+		cb.registryCoordinatorAddr, uint32(rbn), quorumNumbers, nonSignerOperatorIDs)
+
+	if err != nil {
+		return nil, fmt.Errorf("check sig indices call: %w", err)
+	}
+
+	// 4 - translate from CertVerifier binding types to cert type
+	// TODO: Should probably put SignedBatch into the types directly to avoid this downstream conversion
+	nonSignerPubKeysBN254 := make([]certTypesBinding.BN254G1Point, len(signedBatchBinding.Attestation.NonSignerPubkeys))
+	for i, pubKeySet := range signedBatchBinding.Attestation.NonSignerPubkeys {
+		nonSignerPubKeysBN254[i] = certTypesBinding.BN254G1Point{
+			X: pubKeySet.X,
+			Y: pubKeySet.Y,
+		}
+	}
+
+	quorumApksBN254 := make([]certTypesBinding.BN254G1Point, len(signedBatchBinding.Attestation.QuorumApks))
+	for i, apkSet := range signedBatchBinding.Attestation.QuorumApks {
+		quorumApksBN254[i] = certTypesBinding.BN254G1Point{
+			X: apkSet.X,
+			Y: apkSet.Y,
+		}
+	}
+
+	apkG2BN254 := certTypesBinding.BN254G2Point{
+		X: signedBatchBinding.Attestation.ApkG2.X,
+		Y: signedBatchBinding.Attestation.ApkG2.Y,
+	}
+
+	sigmaBN254 := certTypesBinding.BN254G1Point{
+		X: signedBatchBinding.Attestation.Sigma.X,
+		Y: signedBatchBinding.Attestation.Sigma.Y,
+	}
+
+
+	// 5 - construct non signer stakes and signature
+	return &certTypesBinding.EigenDATypesV1NonSignerStakesAndSignature{
+		NonSignerQuorumBitmapIndices: checkSigIndices.NonSignerQuorumBitmapIndices,
+		NonSignerPubkeys:             nonSignerPubKeysBN254,
+		QuorumApks:                   quorumApksBN254,
+		ApkG2:                        apkG2BN254,
+		Sigma:                        sigmaBN254,
+		QuorumApkIndices:             checkSigIndices.QuorumApkIndices,
+		TotalStakeIndices:            checkSigIndices.TotalStakeIndices,
+		NonSignerStakeIndices:        checkSigIndices.NonSignerStakeIndices,
+	}, nil
+}

api/clients/v2/coretypes/conversion_utils.go

@@ -9,15 +9,22 @@ import (
 	commonv2 "github.com/Layr-Labs/eigenda/api/grpc/common/v2"
 	disperserv2 "github.com/Layr-Labs/eigenda/api/grpc/disperser/v2"
 	contractEigenDACertVerifier "github.com/Layr-Labs/eigenda/contracts/bindings/EigenDACertVerifierV2"
+	certTypesBinding "github.com/Layr-Labs/eigenda/contracts/bindings/IEigenDACertTypeBindings"
 	"github.com/Layr-Labs/eigenda/core"
 	"github.com/Layr-Labs/eigenda/encoding"
 	"github.com/consensys/gnark-crypto/ecc/bn254"
 	"github.com/consensys/gnark-crypto/ecc/bn254/fp"
 	"golang.org/x/exp/slices"
 )
 
-func SignedBatchProtoToBinding(inputBatch *disperserv2.SignedBatch) (*contractEigenDACertVerifier.EigenDATypesV2SignedBatch, error) {
-	convertedBatchHeader, err := BatchHeaderProtoToBinding(inputBatch.GetHeader())
+/*
+	NOTE: Two binding types are used here to represent the same data since legacy EigenDACertVerifierV2
+	binding and IEigenDACertTypeBindings leverage the same structs but are not currently interchangeable.
+	This can be changed in the future to use a single binding type once the legacy contract is deprecated.
+*/
+
+func SignedBatchProtoToV2CertBinding(inputBatch *disperserv2.SignedBatch) (*contractEigenDACertVerifier.EigenDATypesV2SignedBatch, error) {
+	convertedBatchHeader, err := BatchHeaderProtoToV2CertVerifierBinding(inputBatch.GetHeader())
 	if err != nil {
 		return nil, fmt.Errorf("convert batch header: %s", err)
 	}
@@ -35,7 +42,7 @@ func SignedBatchProtoToBinding(inputBatch *disperserv2.SignedBatch) (*contractEi
 	return outputSignedBatch, nil
 }
 
-func BatchHeaderProtoToBinding(inputHeader *commonv2.BatchHeader) (*contractEigenDACertVerifier.EigenDATypesV2BatchHeaderV2, error) {
+func BatchHeaderProtoToV2CertVerifierBinding(inputHeader *commonv2.BatchHeader) (*contractEigenDACertVerifier.EigenDATypesV2BatchHeaderV2, error) {
 	var outputBatchRoot [32]byte
 
 	inputBatchRoot := inputHeader.GetBatchRoot()
@@ -59,6 +66,19 @@ func BatchHeaderProtoToBinding(inputHeader *commonv2.BatchHeader) (*contractEige
 
 	return convertedHeader, nil
 }
+func BatchHeaderProtoToIEigenDATypesBinding(inputHeader *commonv2.BatchHeader) (*certTypesBinding.EigenDATypesV2BatchHeaderV2, error) {
+	verifierBatchHeaderBinding, err := BatchHeaderProtoToV2CertVerifierBinding(inputHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	convertedHeader := &certTypesBinding.EigenDATypesV2BatchHeaderV2{
+		BatchRoot:            verifierBatchHeaderBinding.BatchRoot,
+		ReferenceBlockNumber: verifierBatchHeaderBinding.ReferenceBlockNumber,
+	}
+
+	return convertedHeader, nil
+}
 
 func attestationProtoToBinding(inputAttestation *disperserv2.Attestation) (*contractEigenDACertVerifier.EigenDATypesV2Attestation, error) {
 	if len(inputAttestation.QuorumApks) != len(inputAttestation.QuorumNumbers) {
@@ -111,7 +131,37 @@ func attestationProtoToBinding(inputAttestation *disperserv2.Attestation) (*cont
 	return convertedAttestation, nil
 }
 
-func InclusionInfoProtoToBinding(inputInclusionInfo *disperserv2.BlobInclusionInfo) (*contractEigenDACertVerifier.EigenDATypesV2BlobInclusionInfo, error) {
+func InclusionInfoProtoToIEigenDATypesBinding(inputInclusionInfo *disperserv2.BlobInclusionInfo) (*certTypesBinding.EigenDATypesV2BlobInclusionInfo, error) {
+	convertedBlobCertificate, err := blobCertificateProtoToBinding(inputInclusionInfo.GetBlobCertificate())
+	if err != nil {
+		return nil, fmt.Errorf("convert blob certificate: %s", err)
+	}
+
+	blobCertificateTypesBinding := &certTypesBinding.EigenDATypesV2BlobCertificate{
+		BlobHeader: certTypesBinding.EigenDATypesV2BlobHeaderV2{
+			Version: convertedBlobCertificate.BlobHeader.Version,
+			QuorumNumbers: convertedBlobCertificate.BlobHeader.QuorumNumbers,
+			Commitment: certTypesBinding.EigenDATypesV2BlobCommitment{
+				Commitment: certTypesBinding.BN254G1Point(convertedBlobCertificate.BlobHeader.Commitment.Commitment),
+				LengthCommitment: certTypesBinding.BN254G2Point(convertedBlobCertificate.BlobHeader.Commitment.LengthCommitment),
+				LengthProof: certTypesBinding.BN254G2Point(convertedBlobCertificate.BlobHeader.Commitment.LengthProof),
+				Length: convertedBlobCertificate.BlobHeader.Commitment.Length,
+			},
+			PaymentHeaderHash: convertedBlobCertificate.BlobHeader.PaymentHeaderHash,
+		},
+		Signature: convertedBlobCertificate.Signature,
+		RelayKeys: convertedBlobCertificate.RelayKeys,
+	}
+
+
+	return &certTypesBinding.EigenDATypesV2BlobInclusionInfo{
+		BlobCertificate: *blobCertificateTypesBinding,
+		BlobIndex:       inputInclusionInfo.GetBlobIndex(),
+		InclusionProof:  inputInclusionInfo.GetInclusionProof(),
+	}, nil
+}
+
+func InclusionInfoProtoToV2CertVerifierBinding(inputInclusionInfo *disperserv2.BlobInclusionInfo) (*contractEigenDACertVerifier.EigenDATypesV2BlobInclusionInfo, error) {
 	convertedBlobCertificate, err := blobCertificateProtoToBinding(inputInclusionInfo.GetBlobCertificate())
 
 	if err != nil {