Update internal data structures

api/clients/disperser_client.go

@@ -173,13 +173,13 @@ func (c *disperserClient) DisperseBlobAuthenticated(ctx context.Context, data []
 		return nil, nil, errors.New("expected challenge")
 	}
 
-	authHeader := core.BlobAuthHeader{
+	header := core.BlobHeader{
 		BlobCommitments: encoding.BlobCommitments{},
 		AccountID:       "",
 		Nonce:           authHeaderReply.BlobAuthHeader.ChallengeParameter,
 	}
 
-	authData, err := c.signer.SignBlobRequest(authHeader)
+	authData, err := c.signer.SignBlobRequest(header)
 	if err != nil {
 		return nil, nil, errors.New("error signing blob request")
 	}

api/clients/mock/node_client.go

@@ -19,7 +19,7 @@ func NewNodeClient() *MockNodeClient {
 	return &MockNodeClient{}
 }
 
-func (c *MockNodeClient) GetBlobHeader(ctx context.Context, socket string, batchHeaderHash [32]byte, blobIndex uint32) (*core.BlobHeader, *merkletree.Proof, error) {
+func (c *MockNodeClient) GetBlobCert(ctx context.Context, socket string, batchHeaderHash [32]byte, blobIndex uint32) (*core.BlobCertificate, *merkletree.Proof, error) {
 	args := c.Called(socket, batchHeaderHash, blobIndex)
 	var hashes [][]byte
 	if args.Get(1) != nil {
@@ -40,7 +40,7 @@ func (c *MockNodeClient) GetBlobHeader(ctx context.Context, socket string, batch
 		Hashes: hashes,
 		Index:  index,
 	}
-	return (args.Get(0)).(*core.BlobHeader), proof, err
+	return (args.Get(0)).(*core.BlobCertificate), proof, err
 }
 
 func (c *MockNodeClient) GetChunks(

api/clients/node_client.go

@@ -21,7 +21,7 @@ type RetrievedChunks struct {
 }
 
 type NodeClient interface {
-	GetBlobHeader(ctx context.Context, socket string, batchHeaderHash [32]byte, blobIndex uint32) (*core.BlobHeader, *merkletree.Proof, error)
+	GetBlobCert(ctx context.Context, socket string, batchHeaderHash [32]byte, blobIndex uint32) (*core.BlobCertificate, *merkletree.Proof, error)
 	GetChunks(ctx context.Context, opID core.OperatorID, opInfo *core.IndexedOperatorInfo, batchHeaderHash [32]byte, blobIndex uint32, quorumID core.QuorumID, chunksChan chan RetrievedChunks)
 }
 
@@ -35,12 +35,12 @@ func NewNodeClient(timeout time.Duration) NodeClient {
 	}
 }
 
-func (c client) GetBlobHeader(
+func (c client) GetBlobCert(
 	ctx context.Context,
 	socket string,
 	batchHeaderHash [32]byte,
 	blobIndex uint32,
-) (*core.BlobHeader, *merkletree.Proof, error) {
+) (*core.BlobCertificate, *merkletree.Proof, error) {
 	conn, err := grpc.Dial(
 		core.OperatorSocket(socket).GetRetrievalSocket(),
 		grpc.WithTransportCredentials(insecure.NewCredentials()),
@@ -64,7 +64,7 @@ func (c client) GetBlobHeader(
 		return nil, nil, err
 	}
 
-	blobHeader, err := node.GetBlobHeaderFromProto(reply.GetBlobHeader())
+	blobCert, err := node.GetBlobCertFromProto(reply.GetBlobHeader())
 	if err != nil {
 		return nil, nil, err
 	}
@@ -74,7 +74,7 @@ func (c client) GetBlobHeader(
 		Index:  uint64(reply.GetProof().GetIndex()),
 	}
 
-	return blobHeader, proof, nil
+	return blobCert, proof, nil
 }
 
 func (c client) GetChunks(

api/clients/retrieval_client.go

@@ -71,19 +71,19 @@ func (r *retrievalClient) RetrieveBlob(
 	}
 
 	// Get blob header from any operator
-	var blobHeader *core.BlobHeader
+	var blobCert *core.BlobCertificate
 	var proof *merkletree.Proof
 	var proofVerified bool
 	for opID := range operators {
 		opInfo := indexedOperatorState.IndexedOperators[opID]
-		blobHeader, proof, err = r.nodeClient.GetBlobHeader(ctx, opInfo.Socket, batchHeaderHash, blobIndex)
+		blobCert, proof, err = r.nodeClient.GetBlobCert(ctx, opInfo.Socket, batchHeaderHash, blobIndex)
 		if err != nil {
 			// try another operator
 			r.logger.Warn("failed to dial operator while fetching BlobHeader, trying different operator", "operator", opInfo.Socket, "err", err)
 			continue
 		}
 
-		blobHeaderHash, err := blobHeader.GetBlobHeaderHash()
+		blobHeaderHash, err := blobCert.GetHash()
 		if err != nil {
 			r.logger.Warn("got invalid blob header, trying different operator", "operator", opInfo.Socket, "err", err)
 			continue
@@ -100,12 +100,12 @@ func (r *retrievalClient) RetrieveBlob(
 
 		break
 	}
-	if blobHeader == nil || proof == nil || !proofVerified {
+	if blobCert == nil || proof == nil || !proofVerified {
 		return nil, fmt.Errorf("failed to get blob header from all operators (header hash: %s, index: %d)", batchHeaderHash, blobIndex)
 	}
 
 	var quorumHeader *core.BlobQuorumInfo
-	for _, header := range blobHeader.QuorumInfos {
+	for _, header := range blobCert.QuorumInfos {
 		if header.QuorumID == quorumID {
 			quorumHeader = header
 			break
@@ -117,19 +117,19 @@ func (r *retrievalClient) RetrieveBlob(
 	}
 
 	// Validate the blob length
-	err = r.verifier.VerifyBlobLength(blobHeader.BlobCommitments)
+	err = r.verifier.VerifyBlobLength(blobCert.BlobCommitments)
 	if err != nil {
 		return nil, err
 	}
 
 	// Validate the commitments are equivalent
-	commitmentBatch := []encoding.BlobCommitments{blobHeader.BlobCommitments}
+	commitmentBatch := []encoding.BlobCommitments{blobCert.BlobCommitments}
 	err = r.verifier.VerifyCommitEquivalenceBatch(commitmentBatch)
 	if err != nil {
 		return nil, err
 	}
 
-	assignments, info, err := r.assignmentCoordinator.GetAssignments(indexedOperatorState.OperatorState, blobHeader.Length, quorumHeader)
+	assignments, info, err := r.assignmentCoordinator.GetAssignments(indexedOperatorState.OperatorState, blobCert.Length, quorumHeader)
 	if err != nil {
 		return nil, errors.New("failed to get assignments")
 	}
@@ -161,7 +161,7 @@ func (r *retrievalClient) RetrieveBlob(
 			return nil, fmt.Errorf("no assignment to operator %s", reply.OperatorID.Hex())
 		}
 
-		err = r.verifier.VerifyFrames(reply.Chunks, assignment.GetIndices(), blobHeader.BlobCommitments, encodingParams)
+		err = r.verifier.VerifyFrames(reply.Chunks, assignment.GetIndices(), blobCert.BlobCommitments, encodingParams)
 		if err != nil {
 			r.logger.Error("failed to verify chunks from operator", "operator", reply.OperatorID.Hex(), "err", err)
 			continue
@@ -173,5 +173,5 @@ func (r *retrievalClient) RetrieveBlob(
 		indices = append(indices, assignment.GetIndices()...)
 	}
 
-	return r.verifier.Decode(chunks, indices, encodingParams, uint64(blobHeader.Length)*encoding.BYTES_PER_SYMBOL)
+	return r.verifier.Decode(chunks, indices, encodingParams, uint64(blobCert.Length)*encoding.BYTES_PER_SYMBOL)
 }

api/clients/retrieval_client_test.go

@@ -58,9 +58,9 @@ var (
 	nodeClient        *clientsmock.MockNodeClient
 	coordinator       *core.StdAssignmentCoordinator
 	retrievalClient   clients.RetrievalClient
-	blobHeader        *core.BlobHeader
+	blobCert          *core.BlobCertificate
 	encodedBlob       core.EncodedBlob = core.EncodedBlob{
-		BlobHeader:               nil,
+		BlobCert:                 nil,
 		EncodedBundlesByOperator: make(map[core.OperatorID]core.EncodedBundles),
 	}
 	batchHeaderHash        [32]byte
@@ -165,17 +165,19 @@ func setup(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	blobHeader = &core.BlobHeader{
-		BlobCommitments: encoding.BlobCommitments{
-			Commitment:       commitments.Commitment,
-			LengthCommitment: commitments.LengthCommitment,
-			LengthProof:      commitments.LengthProof,
-			Length:           commitments.Length,
+	blobCert = &core.BlobCertificate{
+		BlobHeader: core.BlobHeader{
+			BlobCommitments: encoding.BlobCommitments{
+				Commitment:       commitments.Commitment,
+				LengthCommitment: commitments.LengthCommitment,
+				LengthProof:      commitments.LengthProof,
+				Length:           commitments.Length,
+			},
 		},
 		QuorumInfos: []*core.BlobQuorumInfo{quorumHeader},
 	}
 
-	blobHeaderHash, err := blobHeader.GetBlobHeaderHash()
+	blobHeaderHash, err := blobCert.GetHash()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -195,9 +197,9 @@ func setup(t *testing.T) {
 	}
 
 	for id, assignment := range assignments {
-		bundles := make(map[core.QuorumID]core.Bundle, len(blobHeader.QuorumInfos))
+		bundles := make(map[core.QuorumID]core.Bundle, len(blobCert.QuorumInfos))
 		bundles[quorumID] = chunks[assignment.StartIndex : assignment.StartIndex+assignment.NumChunks]
-		encodedBlob.BlobHeader = blobHeader
+		encodedBlob.BlobCert = blobCert
 		eb, err := core.Bundles(bundles).ToEncodedBundles()
 		if err != nil {
 			t.Fatal(err)
@@ -244,7 +246,7 @@ func TestInvalidBlobHeader(t *testing.T) {
 	setup(t)
 
 	// TODO: add the blob proof to the response
-	nodeClient.On("GetBlobHeader", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(blobHeader, [][]byte{{1}}, uint64(0), nil).Times(numOperators)
+	nodeClient.On("GetBlobCert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(blobCert, [][]byte{{1}}, uint64(0), nil).Times(numOperators)
 	nodeClient.
 		On("GetChunks", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return(encodedBlob)
@@ -265,7 +267,7 @@ func TestValidBlobHeader(t *testing.T) {
 	setup(t)
 
 	// TODO: add the blob proof to the response
-	nodeClient.On("GetBlobHeader", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(blobHeader, [][]byte{}, uint64(0), nil).Once()
+	nodeClient.On("GetBlobCert", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(blobCert, [][]byte{}, uint64(0), nil).Once()
 	nodeClient.
 		On("GetChunks", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return(encodedBlob)

core/assignment.go

@@ -87,7 +87,7 @@ type AssignmentCoordinator interface {
 	GetAssignments(state *OperatorState, blobLength uint, info *BlobQuorumInfo) (map[OperatorID]Assignment, AssignmentInfo, error)
 
 	// GetOperatorAssignment calculates the assignment for a specific DA node
-	GetOperatorAssignment(state *OperatorState, header *BlobHeader, quorum QuorumID, id OperatorID) (Assignment, AssignmentInfo, error)
+	GetOperatorAssignment(state *OperatorState, header *BlobCertificate, quorum QuorumID, id OperatorID) (Assignment, AssignmentInfo, error)
 
 	// ValidateChunkLength validates that the chunk length for the given quorum satisfies all protocol constraints
 	ValidateChunkLength(state *OperatorState, blobLength uint, info *BlobQuorumInfo) (bool, error)
@@ -162,14 +162,14 @@ func (c *StdAssignmentCoordinator) GetAssignments(state *OperatorState, blobLeng
 
 }
 
-func (c *StdAssignmentCoordinator) GetOperatorAssignment(state *OperatorState, header *BlobHeader, quorum QuorumID, id OperatorID) (Assignment, AssignmentInfo, error) {
+func (c *StdAssignmentCoordinator) GetOperatorAssignment(state *OperatorState, cert *BlobCertificate, quorum QuorumID, id OperatorID) (Assignment, AssignmentInfo, error) {
 
-	quorumInfo := header.GetQuorumInfo(quorum)
+	quorumInfo := cert.GetQuorumInfo(quorum)
 	if quorumInfo == nil {
 		return Assignment{}, AssignmentInfo{}, fmt.Errorf("invalid request: quorum ID %d not found in blob header", quorum)
 	}
 
-	assignments, info, err := c.GetAssignments(state, header.Length, quorumInfo)
+	assignments, info, err := c.GetAssignments(state, cert.Length, quorumInfo)
 	if err != nil {
 		return Assignment{}, AssignmentInfo{}, err
 	}

core/assignment_test.go

@@ -82,9 +82,11 @@ func TestOperatorAssignments(t *testing.T) {
 	for operatorID, assignment := range assignments {
 		assert.Equal(t, assignment, expectedAssignments[operatorID])
 
-		header := &core.BlobHeader{
-			BlobCommitments: encoding.BlobCommitments{
-				Length: blobLength,
+		header := &core.BlobCertificate{
+			BlobHeader: core.BlobHeader{
+				BlobCommitments: encoding.BlobCommitments{
+					Length: blobLength,
+				},
 			},
 			QuorumInfos: []*core.BlobQuorumInfo{quorumInfo},
 		}

core/auth.go

@@ -1,10 +1,10 @@
 package core
 
 type BlobRequestAuthenticator interface {
-	AuthenticateBlobRequest(header BlobAuthHeader) error
+	AuthenticateBlobRequest(header BlobHeader) error
 }
 
 type BlobRequestSigner interface {
-	SignBlobRequest(header BlobAuthHeader) ([]byte, error)
+	SignBlobRequest(header BlobHeader) ([]byte, error)
 	GetAccountID() (string, error)
 }

core/auth/auth_test.go

@@ -22,7 +22,7 @@ func TestAuthentication(t *testing.T) {
 	accountId, err := signer.GetAccountID()
 	assert.NoError(t, err)
 
-	testHeader := core.BlobAuthHeader{
+	testHeader := core.BlobHeader{
 		BlobCommitments:    encoding.BlobCommitments{},
 		AccountID:          accountId,
 		Nonce:              rand.Uint32(),
@@ -52,7 +52,7 @@ func TestAuthenticationFail(t *testing.T) {
 	accountId, err := signer.GetAccountID()
 	assert.NoError(t, err)
 
-	testHeader := core.BlobAuthHeader{
+	testHeader := core.BlobHeader{
 		BlobCommitments:    encoding.BlobCommitments{},
 		AccountID:          accountId,
 		Nonce:              rand.Uint32(),
@@ -78,7 +78,7 @@ func TestNoopSignerFail(t *testing.T) {
 	accountId, err := signer.GetAccountID()
 	assert.EqualError(t, err, "noop signer cannot get accountID")
 
-	testHeader := core.BlobAuthHeader{
+	testHeader := core.BlobHeader{
 		BlobCommitments:    encoding.BlobCommitments{},
 		AccountID:          accountId,
 		Nonce:              rand.Uint32(),

core/auth/authenticator.go

@@ -26,7 +26,7 @@ func NewAuthenticator(config AuthConfig) core.BlobRequestAuthenticator {
 	}
 }
 
-func (*authenticator) AuthenticateBlobRequest(header core.BlobAuthHeader) error {
+func (*authenticator) AuthenticateBlobRequest(header core.BlobHeader) error {
 	sig := header.AuthenticationData
 
 	// Ensure the signature is 65 bytes (Recovery ID is the last byte)

core/auth/signer.go

@@ -31,7 +31,7 @@ func NewLocalBlobRequestSigner(privateKeyHex string) *LocalBlobRequestSigner {
 	}
 }
 
-func (s *LocalBlobRequestSigner) SignBlobRequest(header core.BlobAuthHeader) ([]byte, error) {
+func (s *LocalBlobRequestSigner) SignBlobRequest(header core.BlobHeader) ([]byte, error) {
 
 	// Message you want to sign
 	buf := make([]byte, 4)
@@ -60,7 +60,7 @@ func NewLocalNoopSigner() *LocalNoopSigner {
 	return &LocalNoopSigner{}
 }
 
-func (s *LocalNoopSigner) SignBlobRequest(header core.BlobAuthHeader) ([]byte, error) {
+func (s *LocalNoopSigner) SignBlobRequest(header core.BlobHeader) ([]byte, error) {
 	return nil, fmt.Errorf("noop signer cannot sign blob request")
 }