Skip to content

Commit

Permalink
code refactor
Browse files Browse the repository at this point in the history
  • Loading branch information
Ubuntu committed Nov 30, 2023
1 parent 0352b05 commit 327699f
Showing 1 changed file with 91 additions and 119 deletions.
210 changes: 91 additions & 119 deletions core/validator.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@ import (
var (
ErrChunkLengthMismatch = errors.New("chunk length mismatch")
ErrInvalidHeader = errors.New("invalid header")
ErrBlobQuorumSkip = errors.New("blob skipped for a quorum before verification")
)

type ChunkValidator interface {
Expand All @@ -32,81 +33,91 @@ func NewChunkValidator(enc Encoder, asgn AssignmentCoordinator, cst ChainState,
}
}

func (v *chunkValidator) ValidateBlob(blob *BlobMessage, operatorState *OperatorState) error {
if len(blob.Bundles) != len(blob.BlobHeader.QuorumInfos) {
return errors.New("number of bundles does not match number of quorums")
func (v *chunkValidator) preprocessBlob(quorumHeader *BlobQuorumInfo, blob *BlobMessage, operatorState *OperatorState) ([]*Chunk, *Assignment, *EncodingParams, error) {
if quorumHeader.AdversaryThreshold >= quorumHeader.QuorumThreshold {
return nil, nil, nil, errors.New("invalid header: quorum threshold does not exceed adversary threshold")
}

// Validate the blob length
err := v.encoder.VerifyBlobLength(blob.BlobHeader.BlobCommitments)
if err != nil {
return err
// Check if the operator is a member of the quorum
if _, ok := operatorState.Operators[quorumHeader.QuorumID]; !ok {
return nil, nil, nil, ErrBlobQuorumSkip
}

for _, quorumHeader := range blob.BlobHeader.QuorumInfos {
// Get the assignments for the quorum
assignment, info, err := v.assignment.GetOperatorAssignment(operatorState, quorumHeader.QuorumID, quorumHeader.QuantizationFactor, v.operatorID)
if err != nil {
return nil, nil, nil, err
}

if quorumHeader.AdversaryThreshold >= quorumHeader.QuorumThreshold {
return errors.New("invalid header: quorum threshold does not exceed adversary threshold")
}
// Validate the number of chunks
if assignment.NumChunks == 0 {
return nil, nil, nil, ErrBlobQuorumSkip
}
if assignment.NumChunks != uint(len(blob.Bundles[quorumHeader.QuorumID])) {
return nil, nil, nil, errors.New("number of chunks does not match assignment")
}

// Check if the operator is a member of the quorum
if _, ok := operatorState.Operators[quorumHeader.QuorumID]; !ok {
continue
}
chunkLength, err := v.assignment.GetChunkLengthFromHeader(operatorState, quorumHeader)
if err != nil {
return nil, nil, nil, err
}

// Get the assignments for the quorum
assignment, info, err := v.assignment.GetOperatorAssignment(operatorState, quorumHeader.QuorumID, quorumHeader.QuantizationFactor, v.operatorID)
if err != nil {
return err
}
// Validate the chunkLength against the quorum and adversary threshold parameters
numOperators := uint(len(operatorState.Operators[quorumHeader.QuorumID]))
minChunkLength, err := v.assignment.GetMinimumChunkLength(numOperators, blob.BlobHeader.BlobCommitments.Length, quorumHeader.QuantizationFactor, quorumHeader.QuorumThreshold, quorumHeader.AdversaryThreshold)
if err != nil {
return nil, nil, nil, err
}
params, err := GetEncodingParams(minChunkLength, info.TotalChunks)
if err != nil {
return nil, nil, nil, err
}

// Validate the number of chunks
if assignment.NumChunks == 0 {
continue
}
if assignment.NumChunks != uint(len(blob.Bundles[quorumHeader.QuorumID])) {
return errors.New("number of chunks does not match assignment")
}
if params.ChunkLength != chunkLength {
return nil, nil, nil, errors.New("number of chunks does not match assignment")
}

chunkLength, err := v.assignment.GetChunkLengthFromHeader(operatorState, quorumHeader)
if err != nil {
return err
// Get the chunk length
chunks := blob.Bundles[quorumHeader.QuorumID]
for _, chunk := range chunks {
if uint(chunk.Length()) != chunkLength {
return nil, nil, nil, ErrChunkLengthMismatch
}
}

// Validate the chunkLength against the quorum and adversary threshold parameters
numOperators := uint(len(operatorState.Operators[quorumHeader.QuorumID]))
minChunkLength, err := v.assignment.GetMinimumChunkLength(numOperators, blob.BlobHeader.BlobCommitments.Length, quorumHeader.QuantizationFactor, quorumHeader.QuorumThreshold, quorumHeader.AdversaryThreshold)
if err != nil {
return err
}
params, err := GetEncodingParams(minChunkLength, info.TotalChunks)
if err != nil {
return err
}
// Validate the chunk length
if chunkLength*quorumHeader.QuantizationFactor*numOperators != quorumHeader.EncodedBlobLength {
return nil, nil, nil, ErrInvalidHeader
}

if params.ChunkLength != chunkLength {
return errors.New("number of chunks does not match assignment")
}
return chunks, &assignment, &params, nil
}

// Get the chunk length
chunks := blob.Bundles[quorumHeader.QuorumID]
for _, chunk := range chunks {
if uint(chunk.Length()) != chunkLength {
return ErrChunkLengthMismatch
}
}
func (v *chunkValidator) ValidateBlob(blob *BlobMessage, operatorState *OperatorState) error {
if len(blob.Bundles) != len(blob.BlobHeader.QuorumInfos) {
return errors.New("number of bundles does not match number of quorums")
}

// Validate the chunk length
if chunkLength*quorumHeader.QuantizationFactor*numOperators != quorumHeader.EncodedBlobLength {
return ErrInvalidHeader
}
// Validate the blob length
err := v.encoder.VerifyBlobLength(blob.BlobHeader.BlobCommitments)
if err != nil {
return err
}

// Check the received chunks against the commitment
err = v.encoder.VerifyChunks(chunks, assignment.GetIndices(), blob.BlobHeader.BlobCommitments, params)
if err != nil {
for _, quorumHeader := range blob.BlobHeader.QuorumInfos {
// preprocess validation info
chunks, assignment, params, err := v.preprocessBlob(quorumHeader, blob, operatorState)
if err == ErrBlobQuorumSkip {
continue
} else if err != nil {
return err
} else {
// Check the received chunks against the commitment
err = v.encoder.VerifyChunks(chunks, assignment.GetIndices(), blob.BlobHeader.BlobCommitments, *params)
if err != nil {
return err
}
}

}

return nil
Expand All @@ -133,72 +144,33 @@ func (v *chunkValidator) ValidateBatch(blobs []*BlobMessage, operatorState *Oper
// for each quorum
for _, quorumHeader := range blob.BlobHeader.QuorumInfos {
// Check if the operator is a member of the quorum
if _, ok := operatorState.Operators[quorumHeader.QuorumID]; !ok {
chunks, assignment, params, err := v.preprocessBlob(quorumHeader, blob, operatorState)
if err == ErrBlobQuorumSkip {
continue
}

// Get the assignments for the quorum
assignment, info, err := v.assignment.GetOperatorAssignment(
operatorState,
quorumHeader.QuorumID,
quorumHeader.QuantizationFactor,
v.operatorID,
)
if err != nil {
return err
}

// Validate the number of chunks
if assignment.NumChunks == 0 {
continue
}
if assignment.NumChunks != uint(len(blob.Bundles[quorumHeader.QuorumID])) {
return errors.New("number of chunks does not match assignment")
}

chunkLength, err := v.assignment.GetChunkLengthFromHeader(operatorState, quorumHeader)
if err != nil {
} else if err != nil {
return err
}

// Get the chunk length
chunks := blob.Bundles[quorumHeader.QuorumID]
for _, chunk := range chunks {
if uint(chunk.Length()) != chunkLength {
return ErrChunkLengthMismatch
} else {
// Check the received chunks against the commitment
indices := assignment.GetIndices()
samples := make([]Sample, len(chunks))
for ind := range chunks {
samples[ind] = Sample{
Commitment: blob.BlobHeader.BlobCommitments.Commitment,
Chunk: chunks[ind],
EvalIndex: uint(indices[ind]),
BlobIndex: i,
}
}
}

// Validate the chunk length
numOperators := uint(len(operatorState.Operators[quorumHeader.QuorumID]))
if chunkLength*quorumHeader.QuantizationFactor*numOperators != quorumHeader.EncodedBlobLength {
return ErrInvalidHeader
}

// Get Encoding Params
params := EncodingParams{ChunkLength: chunkLength, NumChunks: info.TotalChunks}

// Check the received chunks against the commitment
indices := assignment.GetIndices()
samples := make([]Sample, 0)
for ind := range chunks {
sample := Sample{
Commitment: blob.BlobHeader.BlobCommitments.Commitment,
Chunk: chunks[ind],
EvalIndex: uint(indices[ind]),
BlobIndex: i,
// Add into subBatch
subBatch, ok := subBatchMap[*params]
if !ok {
subBatch.Samples = samples
subBatch.NumBlobs = 1
} else {
subBatch.Samples = append(subBatch.Samples, samples...)
subBatch.NumBlobs += 1
}
samples = append(samples, sample)
}

// Sort into subBatch
subBatch, ok := subBatchMap[params]
if !ok {
subBatch.Samples = samples
subBatch.NumBlobs = 1
} else {
subBatch.Samples = append(subBatch.Samples, samples...)
subBatch.NumBlobs += 1
}
}
}
Expand Down

0 comments on commit 327699f

Please sign in to comment.