Persist StateProof builders on disk

crypto/stateproof/builder.go

@@ -34,19 +34,28 @@ var (
 	ErrCoinIndexError         = errors.New("could not find corresponding index for a given coin")
 )
 
+// VotersAllocBound should be equal to config.Consensus[protocol.ConsensusCurrentVersion].VotersAllocBound
+const VotersAllocBound = 1024
+
+// BuilderPersistingFields is the set of fields of a Builder that are persisted to disk.
+type BuilderPersistingFields struct {
+	_struct        struct{}             `codec:",omitempty,omitemptyarray"`
+	Data           MessageHash          `codec:"data"`
+	Round          uint64               `codec:"rnd"`
+	Participants   []basics.Participant `codec:"parts,allocbound=VotersAllocBound"`
+	Parttree       *merklearray.Tree    `codec:"parttree"`
+	LnProvenWeight uint64               `codec:"lnprv"`
+	ProvenWeight   uint64               `codec:"prv"`
+	StrengthTarget uint64               `codec:"str"`
+}
+
 // Builder keeps track of signatures on a message and eventually produces
 // a state proof for that message.
 type Builder struct {
-	data           MessageHash
-	round          uint64
-	sigs           []sigslot // Indexed by pos in participants
-	signedWeight   uint64    // Total weight of signatures so far
-	participants   []basics.Participant
-	parttree       *merklearray.Tree
-	lnProvenWeight uint64
-	provenWeight   uint64
-	strengthTarget uint64
-	cachedProof    *StateProof
+	BuilderPersistingFields
+	sigs         []sigslot // Indexed by pos in Participants
+	signedWeight uint64    // Total weight of signatures so far
+	cachedProof  *StateProof
 }
 
 // MakeBuilder constructs an empty builder. After adding enough signatures and signed weight, this builder is used to create a stateproof.
@@ -58,16 +67,20 @@ func MakeBuilder(data MessageHash, round uint64, provenWeight uint64, part []bas
 	}
 
 	b := &Builder{
-		data:           data,
-		round:          round,
-		sigs:           make([]sigslot, npart),
-		signedWeight:   0,
-		participants:   part,
-		parttree:       parttree,
-		lnProvenWeight: lnProvenWt,
-		provenWeight:   provenWeight,
-		strengthTarget: strengthTarget,
-		cachedProof:    nil,
+		BuilderPersistingFields: BuilderPersistingFields{
+			Data:           data,
+			Round:          round,
+			Participants:   part,
+			Parttree:       parttree,
+			LnProvenWeight: lnProvenWt,
+			ProvenWeight:   provenWeight,
+			StrengthTarget: strengthTarget,
+		},
+
+		sigs:         make([]sigslot, npart),
+		signedWeight: 0,
+
+		cachedProof: nil,
 	}
 
 	return b, nil
@@ -86,11 +99,11 @@ func (b *Builder) Present(pos uint64) (bool, error) {
 // IsValid verifies that the participant along with the signature can be inserted to the builder.
 // verifySig can be set to false when the signature is already verified (e.g. loaded from the DB)
 func (b *Builder) IsValid(pos uint64, sig *merklesignature.Signature, verifySig bool) error {
-	if pos >= uint64(len(b.participants)) {
-		return fmt.Errorf("%w pos %d >= len(participants) %d", ErrPositionOutOfBound, pos, len(b.participants))
+	if pos >= uint64(len(b.Participants)) {
+		return fmt.Errorf("%w pos %d >= len(participants) %d", ErrPositionOutOfBound, pos, len(b.Participants))
 	}
 
-	p := b.participants[pos]
+	p := b.Participants[pos]
 
 	if p.Weight == 0 {
 		return fmt.Errorf("builder.IsValid: %w: position = %d", ErrPositionWithZeroWeight, pos)
@@ -101,7 +114,7 @@ func (b *Builder) IsValid(pos uint64, sig *merklesignature.Signature, verifySig
 		if err := sig.ValidateSaltVersion(merklesignature.SchemeSaltVersion); err != nil {
 			return err
 		}
-		if err := p.PK.VerifyBytes(b.round, b.data[:], sig); err != nil {
+		if err := p.PK.VerifyBytes(b.Round, b.Data[:], sig); err != nil {
 			return err
 		}
 	}
@@ -118,7 +131,7 @@ func (b *Builder) Add(pos uint64, sig merklesignature.Signature) error {
 		return ErrPositionAlreadyPresent
 	}
 
-	p := b.participants[pos]
+	p := b.Participants[pos]
 
 	// Remember the signature
 	b.sigs[pos].Weight = p.Weight
@@ -130,7 +143,7 @@ func (b *Builder) Add(pos uint64, sig merklesignature.Signature) error {
 
 // Ready returns whether the state proof is ready to be built.
 func (b *Builder) Ready() bool {
-	return b.cachedProof != nil || b.signedWeight > b.provenWeight
+	return b.cachedProof != nil || b.signedWeight > b.ProvenWeight
 }
 
 // SignedWeight returns the total weight of signatures added so far.
@@ -175,7 +188,7 @@ func (b *Builder) Build() (*StateProof, error) {
 	}
 
 	if !b.Ready() {
-		return nil, fmt.Errorf("%w: %d <= %d", ErrSignedWeightLessThanProvenWeight, b.signedWeight, b.provenWeight)
+		return nil, fmt.Errorf("%w: %d <= %d", ErrSignedWeightLessThanProvenWeight, b.signedWeight, b.ProvenWeight)
 	}
 
 	// Commit to the sigs array
@@ -197,17 +210,17 @@ func (b *Builder) Build() (*StateProof, error) {
 		MerkleSignatureSaltVersion: merklesignature.SchemeSaltVersion,
 	}
 
-	nr, err := numReveals(b.signedWeight, b.lnProvenWeight, b.strengthTarget)
+	nr, err := numReveals(b.signedWeight, b.LnProvenWeight, b.StrengthTarget)
 	if err != nil {
 		return nil, err
 	}
 
 	choice := coinChoiceSeed{
-		partCommitment: b.parttree.Root(),
-		lnProvenWeight: b.lnProvenWeight,
+		partCommitment: b.Parttree.Root(),
+		lnProvenWeight: b.LnProvenWeight,
 		sigCommitment:  s.SigCommit,
 		signedWeight:   s.SignedWeight,
-		data:           b.data,
+		data:           b.Data,
 	}
 
 	coinHash := makeCoinGenerator(&choice)
@@ -221,8 +234,8 @@ func (b *Builder) Build() (*StateProof, error) {
 			return nil, err
 		}
 
-		if pos >= uint64(len(b.participants)) {
-			return nil, fmt.Errorf("%w pos %d >= len(participants) %d", ErrPositionOutOfBound, pos, len(b.participants))
+		if pos >= uint64(len(b.Participants)) {
+			return nil, fmt.Errorf("%w pos %d >= len(participants) %d", ErrPositionOutOfBound, pos, len(b.Participants))
 		}
 
 		revealsSequence[j] = pos
@@ -236,7 +249,7 @@ func (b *Builder) Build() (*StateProof, error) {
 		// Generate the reveal for pos
 		s.Reveals[pos] = Reveal{
 			SigSlot: b.sigs[pos].sigslotCommit,
-			Part:    b.participants[pos],
+			Part:    b.Participants[pos],
 		}
 
 		proofPositions = append(proofPositions, pos)
@@ -247,7 +260,7 @@ func (b *Builder) Build() (*StateProof, error) {
 		return nil, err
 	}
 
-	partProofs, err := b.parttree.Prove(proofPositions)
+	partProofs, err := b.Parttree.Prove(proofPositions)
 	if err != nil {
 		return nil, err
 	}
@@ -258,3 +271,8 @@ func (b *Builder) Build() (*StateProof, error) {
 	b.cachedProof = s
 	return s, nil
 }
+
+// AllocSigs should only be used after decoding msgpacked Builder, as the sigs field is not exported and encoded
+func (b *Builder) AllocSigs() {
+	b.sigs = make([]sigslot, len(b.Participants))
+}

crypto/stateproof/builder_test.go

@@ -28,6 +28,7 @@ import (
 
 	"github.com/algorand/falcon"
 
+	"github.com/algorand/go-algorand/config"
 	"github.com/algorand/go-algorand/crypto"
 	"github.com/algorand/go-algorand/crypto/merklearray"
 	"github.com/algorand/go-algorand/crypto/merklesignature"
@@ -496,12 +497,12 @@ func TestBuildAndReady(t *testing.T) {
 	_, err = builder.Build()
 	a.ErrorIs(err, ErrSignedWeightLessThanProvenWeight)
 
-	builder.signedWeight = builder.provenWeight
+	builder.signedWeight = builder.ProvenWeight
 	a.False(builder.Ready())
 	_, err = builder.Build()
 	a.ErrorIs(err, ErrSignedWeightLessThanProvenWeight)
 
-	builder.signedWeight = builder.provenWeight + 1
+	builder.signedWeight = builder.ProvenWeight + 1
 	a.True(builder.Ready())
 	_, err = builder.Build()
 	a.NotErrorIs(err, ErrSignedWeightLessThanProvenWeight)
@@ -516,19 +517,19 @@ func TestErrorCases(t *testing.T) {
 	_, err := builder.Present(1)
 	a.ErrorIs(err, ErrPositionOutOfBound)
 
-	builder.participants = make([]basics.Participant, 1, 1)
+	builder.Participants = make([]basics.Participant, 1, 1)
 	builder.sigs = make([]sigslot, 1, 1)
 	err = builder.IsValid(1, &merklesignature.Signature{}, false)
 	a.ErrorIs(err, ErrPositionOutOfBound)
 
 	err = builder.IsValid(0, &merklesignature.Signature{}, false)
 	require.ErrorIs(t, err, ErrPositionWithZeroWeight)
 
-	builder.participants[0].Weight = 1
+	builder.Participants[0].Weight = 1
 	err = builder.IsValid(0, &merklesignature.Signature{}, true)
 	a.ErrorIs(err, merklesignature.ErrKeyLifetimeIsZero)
 
-	builder.participants[0].PK.KeyLifetime = 20
+	builder.Participants[0].PK.KeyLifetime = 20
 	err = builder.IsValid(0, &merklesignature.Signature{}, true)
 	a.ErrorIs(err, merklesignature.ErrSignatureSchemeVerificationFailed)
 
@@ -631,6 +632,13 @@ func TestBuilder_BuildStateProofCache(t *testing.T) {
 	return
 }
 
+// Verifies that the VotersAllocBound constant is equal to the current consensus parameters.
+// It is used for msgpack allocbound (needs to be static)
+func TestBuilder_StateProofTopVoters(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	require.Equal(t, config.Consensus[protocol.ConsensusCurrentVersion].StateProofTopVoters, uint64(VotersAllocBound))
+}
+
 func BenchmarkBuildVerify(b *testing.B) {
 	totalWeight := 1000000
 	npart := 1000