Algod: Compcert msg into struct

compactcert/builder.go

@@ -62,7 +62,7 @@ func (ccw *Worker) builderForRound(rnd basics.Round) (builder, error) {
 		return builder{}, err
 	}
 
-	p, err := ledger.CompactCertParams(msg, votersHdr, hdr)
+	p, err := ledger.CompactCertParams(*msg, votersHdr, hdr)
 	if err != nil {
 		return builder{}, err
 	}
@@ -357,7 +357,8 @@ func (ccw *Worker) tryBuilding() {
 		stxn.Txn.GenesisHash = ccw.ledger.GenesisHash()
 		stxn.Txn.CertIntervalLatestRound = rnd
 		stxn.Txn.Cert = *cert
-		stxn.Txn.CertMsg = b.Msg
+
+		stxn.Txn.CertMsg = b.Params.StateProofMessage
 		err = ccw.txnSender.BroadcastSignedTxGroup([]transactions.SignedTxn{stxn})
 		if err != nil {
 			ccw.log.Warnf("ccw.tryBuilding: broadcasting compact cert txn for %d: %v", rnd, err)

compactcert/signer.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/algorand/go-algorand/config"
 	"github.com/algorand/go-algorand/crypto"
+	"github.com/algorand/go-algorand/crypto/compactcert"
 	"github.com/algorand/go-algorand/crypto/merklearray"
 	"github.com/algorand/go-algorand/crypto/merklesignature"
 	"github.com/algorand/go-algorand/data/account"
@@ -109,7 +110,7 @@ restart:
 // GenerateStateProofMessage builds a merkle tree from the block headers of the entire interval (up until current round), and returns the root
 // for the account to sign upon. The tree can be stored for performance but does not have to be since it can always be rebuilt from scratch.
 // This is the message the Compact Certificate will attest to.
-func GenerateStateProofMessage(ledger Ledger, compactCertRound basics.Round, compactCertInterval uint64) ([]byte, error) {
+func GenerateStateProofMessage(ledger Ledger, compactCertRound basics.Round, compactCertInterval uint64) (*compactcert.StateProofMessage, error) {
 	if compactCertRound < basics.Round(compactCertInterval) {
 		return nil, fmt.Errorf("GenerateStateProofMessage compactCertRound must be >= than compactCertInterval (%w)", errInvalidParams)
 	}
@@ -131,7 +132,7 @@ func GenerateStateProofMessage(ledger Ledger, compactCertRound basics.Round, com
 		return nil, err
 	}
 
-	return tree.Root().ToSlice(), nil
+	return &compactcert.StateProofMessage{Payload: tree.Root().ToSlice()}, nil
 }
 
 func (ccw *Worker) signBlock(hdr bookkeeping.BlockHeader) {
@@ -183,7 +184,8 @@ func (ccw *Worker) signBlock(hdr bookkeeping.BlockHeader) {
 			ccw.log.Warnf("ccw.signBlock(%d): GenerateStateProofMessage: %v", hdr.Round, err)
 			continue
 		}
-		sig, err := key.StateProofSecrets.SignBytes(commitment)
+		tmp := commitment.Hash()
+		sig, err := key.StateProofSecrets.SignBytes(tmp[:])
 		if err != nil {
 			ccw.log.Warnf("ccw.signBlock(%d): StateProofSecrets.Sign: %v", hdr.Round, err)
 			continue

compactcert/worker_test.go

@@ -289,16 +289,16 @@ func TestWorkerAllSigs(t *testing.T) {
 
 			msg, err := GenerateStateProofMessage(s, tx.Txn.CertIntervalLatestRound, proto.CompactCertRounds)
 			require.NoError(t, err)
-			require.Equal(t, msg, tx.Txn.CertMsg)
+			require.Equal(t, *msg, tx.Txn.CertMsg)
 
 			provenWeight, overflowed := basics.Muldiv(uint64(s.totalWeight), uint64(proto.CompactCertWeightThreshold), 1<<32)
 			require.False(t, overflowed)
 
 			ccparams := compactcert.Params{
-				Msg:          tx.Txn.CertMsg,
-				ProvenWeight: provenWeight,
-				SigRound:     tx.Txn.CertIntervalLatestRound,
-				SecKQ:        proto.CompactCertSecKQ,
+				StateProofMessage: tx.Txn.CertMsg,
+				ProvenWeight:      provenWeight,
+				SigRound:          tx.Txn.CertIntervalLatestRound,
+				SecKQ:             proto.CompactCertSecKQ,
 			}
 
 			voters, err := s.CompactCertVoters(tx.Txn.CertIntervalLatestRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))
@@ -353,16 +353,16 @@ func TestWorkerPartialSigs(t *testing.T) {
 
 	msg, err := GenerateStateProofMessage(s, tx.Txn.CertIntervalLatestRound, proto.CompactCertRounds)
 	require.NoError(t, err)
-	require.Equal(t, msg, tx.Txn.CertMsg)
+	require.Equal(t, *msg, tx.Txn.CertMsg)
 
 	provenWeight, overflowed := basics.Muldiv(uint64(s.totalWeight), uint64(proto.CompactCertWeightThreshold), 1<<32)
 	require.False(t, overflowed)
 
 	ccparams := compactcert.Params{
-		Msg:          msg,
-		ProvenWeight: provenWeight,
-		SigRound:     basics.Round(tx.Txn.CertIntervalLatestRound),
-		SecKQ:        proto.CompactCertSecKQ,
+		StateProofMessage: *msg,
+		ProvenWeight:      provenWeight,
+		SigRound:          basics.Round(tx.Txn.CertIntervalLatestRound),
+		SecKQ:             proto.CompactCertSecKQ,
 	}
 
 	voters, err := s.CompactCertVoters(tx.Txn.CertIntervalLatestRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))

crypto/compactcert/builder.go

@@ -52,6 +52,7 @@ type Builder struct {
 	// Cached cert, if Build() was called and no subsequent
 	// Add() calls were made.
 	cert *Cert
+	Msg  StateProofMessageHash
 }
 
 // MkBuilder constructs an empty builder (with no signatures).  The message
@@ -62,7 +63,9 @@ func MkBuilder(param Params, part []basics.Participant, parttree *merklearray.Tr
 	npart := len(part)
 
 	b := &Builder{
-		Params:        param,
+		Params: param,
+		Msg:    param.StateProofMessage.Hash(),
+
 		sigs:          make([]sigslot, npart),
 		sigsHasValidL: false,
 		signedWeight:  0,
@@ -98,7 +101,10 @@ func (b *Builder) IsValid(pos uint64, sig merklesignature.Signature, verifySig b
 		if err := sig.ValidateSigVersion(merklesignature.SchemeVersion); err != nil {
 			return err
 		}
-		if err := p.PK.VerifyBytes(uint64(b.SigRound), b.Msg, sig); err != nil {
+
+		cpy := make([]byte, len(b.Msg))
+		copy(cpy, b.Msg[:])
+		if err := p.PK.VerifyBytes(uint64(b.SigRound), cpy, sig); err != nil {
 			return err
 		}
 	}

crypto/compactcert/builder_test.go

@@ -89,7 +89,8 @@ func TestBuildVerify(t *testing.T) {
 	npart := npartHi + npartLo
 
 	param := Params{
-		Msg:          testMessage("hello world"),
+		StateProofMessage: StateProofMessage{Payload: testMessage("hello world")},
+
 		ProvenWeight: uint64(totalWeight / 2),
 		SigRound:     currentRound,
 		SecKQ:        compactCertSecKQForTests,
@@ -103,7 +104,8 @@ func TestBuildVerify(t *testing.T) {
 	parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartLo, key.GetVerifier())...)
 
 	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.Msg)
+	tmp := param.StateProofMessage.Hash()
+	sig, err := signerInRound.SignBytes(tmp[:])
 	require.NoError(t, err, "failed to create keys")
 
 	for i := 0; i < npart; i++ {
@@ -230,7 +232,8 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 	numPart := 4
 
 	param := Params{
-		Msg:          testMessage("test!"),
+		StateProofMessage: StateProofMessage{Payload: testMessage("test!")},
+
 		ProvenWeight: uint64(totalWeight / (2 * numPart)),
 		SigRound:     currentRound,
 		SecKQ:        compactCertSecKQForTests,
@@ -248,7 +251,8 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 		}
 		parts = append(parts, part)
 
-		sig, err := key.GetSigner(uint64(currentRound)).SignBytes(param.Msg)
+		tmp := param.StateProofMessage.Hash()
+		sig, err := key.GetSigner(uint64(currentRound)).SignBytes(tmp[:])
 		require.NoError(t, err, "failed to create keys")
 		sigs = append(sigs, sig)
 
@@ -426,7 +430,8 @@ func BenchmarkBuildVerify(b *testing.B) {
 	a := require.New(b)
 
 	param := Params{
-		Msg:          testMessage("hello world"),
+		StateProofMessage: StateProofMessage{Payload: testMessage("hello world")},
+
 		ProvenWeight: uint64(totalWeight / 2),
 		SigRound:     compactCertRoundsForTests,
 		SecKQ:        compactCertSecKQForTests,
@@ -443,7 +448,8 @@ func BenchmarkBuildVerify(b *testing.B) {
 		}
 
 		signerInRound := signer.GetSigner(uint64(currentRound))
-		sig, err := signerInRound.SignBytes(param.Msg)
+		tmp := param.StateProofMessage.Hash()
+		sig, err := signerInRound.SignBytes(tmp[:])
 		require.NoError(b, err, "failed to create keys")
 
 		partkeys = append(partkeys, signer)
@@ -520,7 +526,8 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 	npartLo := 9
 
 	param := Params{
-		Msg:          testMessage("hello world"),
+		StateProofMessage: StateProofMessage{Payload: testMessage("hello world")},
+
 		ProvenWeight: uint64(totalWeight / 2),
 		SigRound:     currentRound,
 		SecKQ:        compactCertSecKQForTests,
@@ -539,7 +546,8 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 
 	// actual test:
 	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.Msg)
+	tmp := param.Hash()
+	sig, err := signerInRound.SignBytes(tmp[:])
 	require.NoError(t, err, "failed to create keys")
 	// Corrupting the version of the signature:
 	sig.Signature[1]++

crypto/compactcert/common.go

@@ -29,12 +29,12 @@ import (
 type coinChoice struct {
 	_struct struct{} `codec:",omitempty,omitemptyarray"`
 
-	J            uint64               `codec:"j"`
-	SignedWeight uint64               `codec:"sigweight"`
-	ProvenWeight uint64               `codec:"provenweight"`
-	Sigcom       crypto.GenericDigest `codec:"sigcom"`
-	Partcom      crypto.GenericDigest `codec:"partcom"`
-	Msg          []byte               `codec:"msg"`
+	J            uint64                `codec:"j"`
+	SignedWeight uint64                `codec:"sigweight"`
+	ProvenWeight uint64                `codec:"provenweight"`
+	Sigcom       crypto.GenericDigest  `codec:"sigcom"`
+	Partcom      crypto.GenericDigest  `codec:"partcom"`
+	Msg          StateProofMessageHash `codec:"msg"`
 }
 
 // ToBeHashed implements the crypto.Hashable interface.

crypto/compactcert/common_test.go

@@ -29,7 +29,7 @@ func TestHashCoin(t *testing.T) {
 	var slots [32]uint64
 	var sigcom = make(crypto.GenericDigest, HashSize)
 	var partcom = make(crypto.GenericDigest, HashSize)
-	var msgHash = make(crypto.GenericDigest, HashSize)
+	var msgHash = StateProofMessageHash{}
 
 	crypto.RandBytes(sigcom[:])
 	crypto.RandBytes(partcom[:])
@@ -66,7 +66,7 @@ func TestHashCoin(t *testing.T) {
 func BenchmarkHashCoin(b *testing.B) {
 	var sigcom = make(crypto.GenericDigest, HashSize)
 	var partcom = make(crypto.GenericDigest, HashSize)
-	var msgHash = make(crypto.GenericDigest, HashSize)
+	var msgHash = StateProofMessageHash{}
 
 	crypto.RandBytes(sigcom[:])
 	crypto.RandBytes(partcom[:])