Integrate State Proof keys

Makefile

@@ -61,6 +61,10 @@ EXTLDFLAGS := -static -static-libstdc++ -static-libgcc
 export GOBUILDMODE := -buildmode=exe
 endif
 
+ifeq ($(SHORT_PART_PERIOD), 1)
+export SHORT_PART_PERIOD_FLAG := -s
+endif
+
 GOTAGS      := --tags "$(GOTAGSLIST)"
 GOTRIMPATH	:= $(shell GOPATH=$(GOPATH) && go help build | grep -q .-trimpath && echo -trimpath)
 
@@ -76,7 +80,7 @@ GOLDFLAGS := $(GOLDFLAGS_BASE) \
 UNIT_TEST_SOURCES := $(sort $(shell GOPATH=$(GOPATH) && GO111MODULE=off && go list ./... | grep -v /go-algorand/test/ ))
 ALGOD_API_PACKAGES := $(sort $(shell GOPATH=$(GOPATH) && GO111MODULE=off && cd daemon/algod/api; go list ./... ))
 
-MSGP_GENERATE	:= ./protocol ./protocol/test ./crypto ./crypto/compactcert ./data/basics ./data/transactions ./data/committee ./data/bookkeeping ./data/hashable ./agreement ./rpcs ./node ./ledger ./ledger/ledgercore ./compactcert ./data/account
+MSGP_GENERATE	:= ./protocol ./protocol/test ./crypto ./crypto/merklearray ./crypto/merklesignature ./crypto/compactcert ./data/basics ./data/transactions ./data/committee ./data/bookkeeping ./data/hashable ./agreement ./rpcs ./node ./ledger ./ledger/ledgercore ./compactcert ./data/account
 
 default: build
 
@@ -290,7 +294,7 @@ gen/%/genesis.dump: gen/%/genesis.json
 	./scripts/dump_genesis.sh $< > $@
 
 gen/%/genesis.json: gen/%.json gen/generate.go buildsrc
-	$(GOPATH1)/bin/genesis -q -n $(shell basename $(shell dirname $@)) -c $< -d $(subst .json,,$<)
+	$(GOPATH1)/bin/genesis -q $(SHORT_PART_PERIOD_FLAG) -n $(shell basename $(shell dirname $@)) -c $< -d $(subst .json,,$<)
 
 gen: $(addsuffix gen, $(NETWORKS)) mainnetgen
 

agreement/abstractions.go

@@ -224,7 +224,7 @@ type KeyManager interface {
 	// VotingKeys returns an immutable array of voting keys that are
 	// valid for the provided votingRound, and were available at
 	// keysRound.
-	VotingKeys(votingRound, keysRound basics.Round) []account.Participation
+	VotingKeys(votingRound, keysRound basics.Round) []account.ParticipationRecordForRound
 
 	// Record indicates that the given participation action has been taken.
 	// The operation needs to be asynchronous to avoid impacting agreement.

agreement/agreementtest/keyManager.go

@@ -25,11 +25,25 @@ import (
 type SimpleKeyManager []account.Participation
 
 // VotingKeys implements KeyManager.VotingKeys.
-func (m SimpleKeyManager) VotingKeys(votingRound, _ basics.Round) []account.Participation {
-	var km []account.Participation
+func (m SimpleKeyManager) VotingKeys(votingRound, _ basics.Round) []account.ParticipationRecordForRound {
+	var km []account.ParticipationRecordForRound
 	for _, acc := range m {
 		if acc.OverlapsInterval(votingRound, votingRound) {
-			km = append(km, acc)
+			record := account.ParticipationRecord{
+				ParticipationID:   acc.ID(),
+				Account:           acc.Parent,
+				FirstValid:        acc.FirstValid,
+				LastValid:         acc.LastValid,
+				KeyDilution:       acc.KeyDilution,
+				LastVote:          0,
+				LastBlockProposal: 0,
+				LastStateProof:    0,
+				EffectiveFirst:    acc.FirstValid,
+				EffectiveLast:     acc.LastValid,
+				VRF:               acc.VRF,
+				Voting:            acc.Voting,
+			}
+			km = append(km, account.ParticipationRecordForRound{ParticipationRecord: record})
 		}
 	}
 	return km

agreement/keyManager_test.go

@@ -19,9 +19,10 @@ package agreement
 import (
 	"testing"
 
-	"github.com/algorand/go-deadlock"
 	"github.com/stretchr/testify/require"
 
+	"github.com/algorand/go-deadlock"
+
 	"github.com/algorand/go-algorand/data/account"
 	"github.com/algorand/go-algorand/data/basics"
 )
@@ -41,11 +42,27 @@ type recordingKeyManager struct {
 }
 
 // VotingKeys implements KeyManager.VotingKeys.
-func (m *recordingKeyManager) VotingKeys(votingRound, _ basics.Round) []account.Participation {
-	var km []account.Participation
+func (m *recordingKeyManager) VotingKeys(votingRound, _ basics.Round) []account.ParticipationRecordForRound {
+	var km []account.ParticipationRecordForRound
 	for _, acc := range m.keys {
 		if acc.OverlapsInterval(votingRound, votingRound) {
-			km = append(km, acc)
+			partRecordForRound := account.ParticipationRecordForRound{
+				ParticipationRecord: account.ParticipationRecord{
+					ParticipationID:   acc.ID(),
+					Account:           acc.Parent,
+					FirstValid:        acc.FirstValid,
+					LastValid:         acc.LastValid,
+					KeyDilution:       acc.KeyDilution,
+					LastVote:          0,
+					LastBlockProposal: 0,
+					LastStateProof:    0,
+					EffectiveFirst:    0,
+					EffectiveLast:     acc.LastValid,
+					VRF:               acc.VRF,
+					Voting:            acc.Voting,
+				},
+			}
+			km = append(km, partRecordForRound)
 		}
 	}
 	return km

agreement/pseudonode.go

@@ -77,8 +77,8 @@ type asyncPseudonode struct {
 	quit                   chan struct{}   // a quit signal for the verifier goroutines
 	closeWg                *sync.WaitGroup // frontend waitgroup to get notified when all the verifier goroutines are done.
 	monitor                *coserviceMonitor
-	participationKeysRound basics.Round            // the round to which the participationKeys matches
-	participationKeys      []account.Participation // the list of the participation keys for round participationKeysRound
+	participationKeysRound basics.Round                          // the round to which the participationKeys matches
+	participationKeys      []account.ParticipationRecordForRound // the list of the participation keys for round participationKeysRound
 
 	proposalsVerifier *pseudonodeVerifier // dynamically generated verifier goroutine that manages incoming proposals making request.
 	votesVerifier     *pseudonodeVerifier // dynamically generated verifier goroutine that manages incoming votes making request.
@@ -94,7 +94,7 @@ type pseudonodeBaseTask struct {
 	node          *asyncPseudonode
 	context       context.Context // the context associated with that task; context might expire for a single task but remain valid for others.
 	out           chan externalEvent
-	participation []account.Participation
+	participation []account.ParticipationRecordForRound
 }
 
 type pseudonodeVotesTask struct {
@@ -199,7 +199,7 @@ func (n asyncPseudonode) MakeVotes(ctx context.Context, r round, p period, s ste
 
 // load the participation keys from the account manager ( as needed ) for the
 // current round.
-func (n *asyncPseudonode) loadRoundParticipationKeys(voteRound basics.Round) []account.Participation {
+func (n *asyncPseudonode) loadRoundParticipationKeys(voteRound basics.Round) []account.ParticipationRecordForRound {
 	// if we've already loaded up the keys, then just skip loading them.
 	if n.participationKeysRound == voteRound {
 		return n.participationKeys
@@ -277,7 +277,7 @@ func (n asyncPseudonode) makePseudonodeVerifier(voteVerifier *AsyncVoteVerifier)
 }
 
 // makeProposals creates a slice of block proposals for the given round and period.
-func (n asyncPseudonode) makeProposals(round basics.Round, period period, accounts []account.Participation) ([]proposal, []unauthenticatedVote) {
+func (n asyncPseudonode) makeProposals(round basics.Round, period period, accounts []account.ParticipationRecordForRound) ([]proposal, []unauthenticatedVote) {
 	ve, err := n.factory.AssembleBlock(round)
 	if err != nil {
 		if err != ErrAssembleBlockRoundStale {
@@ -288,16 +288,16 @@ func (n asyncPseudonode) makeProposals(round basics.Round, period period, accoun
 
 	votes := make([]unauthenticatedVote, 0, len(accounts))
 	proposals := make([]proposal, 0, len(accounts))
-	for _, account := range accounts {
-		payload, proposal, err := proposalForBlock(account.Address(), account.VRFSecrets(), ve, period, n.ledger)
+	for _, acc := range accounts {
+		payload, proposal, err := proposalForBlock(acc.Account, acc.VRF, ve, period, n.ledger)
 		if err != nil {
-			n.log.Errorf("pseudonode.makeProposals: could not create proposal for block (address %v): %v", account.Address(), err)
+			n.log.Errorf("pseudonode.makeProposals: could not create proposal for block (address %v): %v", acc.Account, err)
 			continue
 		}
 
 		// attempt to make the vote
-		rv := rawVote{Sender: account.Address(), Round: round, Period: period, Step: propose, Proposal: proposal}
-		uv, err := makeVote(rv, account.VotingSigner(), account.VRFSecrets(), n.ledger)
+		rv := rawVote{Sender: acc.Account, Round: round, Period: period, Step: propose, Proposal: proposal}
+		uv, err := makeVote(rv, acc.VotingSigner(), acc.VRF, n.ledger)
 		if err != nil {
 			n.log.Warnf("pseudonode.makeProposals: could not create vote: %v", err)
 			continue
@@ -313,11 +313,11 @@ func (n asyncPseudonode) makeProposals(round basics.Round, period period, accoun
 
 // makeVotes creates a slice of votes for a given proposal value in a given
 // round, period, and step.
-func (n asyncPseudonode) makeVotes(round basics.Round, period period, step step, proposal proposalValue, participation []account.Participation) []unauthenticatedVote {
+func (n asyncPseudonode) makeVotes(round basics.Round, period period, step step, proposal proposalValue, participation []account.ParticipationRecordForRound) []unauthenticatedVote {
 	votes := make([]unauthenticatedVote, 0)
-	for _, account := range participation {
-		rv := rawVote{Sender: account.Address(), Round: round, Period: period, Step: step, Proposal: proposal}
-		uv, err := makeVote(rv, account.VotingSigner(), account.VRFSecrets(), n.ledger)
+	for _, part := range participation {
+		rv := rawVote{Sender: part.Account, Round: round, Period: period, Step: step, Proposal: proposal}
+		uv, err := makeVote(rv, part.VotingSigner(), part.VRF, n.ledger)
 		if err != nil {
 			n.log.Warnf("pseudonode.makeVotes: could not create vote: %v", err)
 			continue

agreement/pseudonode_test.go

@@ -388,10 +388,10 @@ func (n serializedPseudonode) Quit() {
 }
 
 type KeyManagerProxy struct {
-	target func(basics.Round, basics.Round) []account.Participation
+	target func(basics.Round, basics.Round) []account.ParticipationRecordForRound
 }
 
-func (k *KeyManagerProxy) VotingKeys(votingRound, balanceRound basics.Round) []account.Participation {
+func (k *KeyManagerProxy) VotingKeys(votingRound, balanceRound basics.Round) []account.ParticipationRecordForRound {
 	return k.target(votingRound, balanceRound)
 }
 
@@ -447,7 +447,7 @@ func TestPseudonodeLoadingOfParticipationKeys(t *testing.T) {
 	pb.keys = keyManagerProxy
 	cparams, _ := ledger.ConsensusParams(0)
 	for rnd := basics.Round(3); rnd < 1000; rnd += 43 {
-		keyManagerProxy.target = func(votingRound, balanceRnd basics.Round) []account.Participation {
+		keyManagerProxy.target = func(votingRound, balanceRnd basics.Round) []account.ParticipationRecordForRound {
 			require.Equal(t, rnd, votingRound)
 			require.Equal(t, balanceRound(rnd, cparams), balanceRnd)
 			return keyManager.VotingKeys(votingRound, balanceRnd)

cmd/algokey/part.go

@@ -26,6 +26,7 @@ import (
 
 	"github.com/algorand/go-algorand/data/account"
 	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/util"
 	"github.com/algorand/go-algorand/util/db"
 )
 
@@ -75,12 +76,26 @@ var partGenerateCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		partkey, err := account.FillDBWithParticipationKeys(partdb, parent, basics.Round(partFirstRound), basics.Round(partLastRound), partKeyDilution)
+		fmt.Println("Please stand by while generating keys. This might take a few minutes...")
+
+		var partkey account.PersistedParticipation
+		participationGen := func() {
+			partkey, err = account.FillDBWithParticipationKeys(partdb, parent, basics.Round(partFirstRound), basics.Round(partLastRound), partKeyDilution)
+		}
+
+		util.RunFuncWithSpinningCursor(participationGen)
+
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Cannot generate partkey database %s: %v\n", partKeyfile, err)
+			err = os.Remove(partKeyfile)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to cleanup the database file %s: %v\n", partKeyfile, err)
+			}
 			os.Exit(1)
 		}
 
+		fmt.Println("Participation key generation successful")
+
 		printPartkey(partkey.Participation)
 	},
 }
@@ -146,6 +161,9 @@ func printPartkey(partkey account.Participation) {
 	fmt.Printf("Parent address:    %s\n", partkey.Parent.String())
 	fmt.Printf("VRF public key:    %s\n", base64.StdEncoding.EncodeToString(partkey.VRF.PK[:]))
 	fmt.Printf("Voting public key: %s\n", base64.StdEncoding.EncodeToString(partkey.Voting.OneTimeSignatureVerifier[:]))
+	if partkey.StateProofSecrets != nil && !partkey.StateProofSecrets.GetVerifier().IsEmpty() {
+		fmt.Printf("State proof key:   %s\n", base64.StdEncoding.EncodeToString(partkey.StateProofSecrets.GetVerifier()[:]))
+	}
 	fmt.Printf("First round:       %d\n", partkey.FirstValid)
 	fmt.Printf("Last round:        %d\n", partkey.LastValid)
 	fmt.Printf("Key dilution:      %d\n", partkey.KeyDilution)

cmd/genesis/newgenesis.go

@@ -32,6 +32,7 @@ var outDir = flag.String("d", "", "The directory containing the generated ledger
 var netName = flag.String("n", "", "The name of the network for this ledger (will override config file).")
 var configFile = flag.String("c", "", "The config file containing the genesis ledger and wallets")
 var quiet = flag.Bool("q", false, "Skip verbose informational messages")
+var short = flag.Bool("s", false, "Cap the last participation key round to 1500")
 
 func init() {
 	flag.Parse()
@@ -60,6 +61,13 @@ func main() {
 	if !*quiet {
 		verboseOut = os.Stdout
 	}
+
+	if *short {
+		if genesisData.LastPartKeyRound > 1500 {
+			genesisData.LastPartKeyRound = 1500
+		}
+	}
+
 	err = gen.GenerateGenesisFiles(genesisData, config.Consensus, *outDir, verboseOut)
 	if err != nil {
 		reportErrorf("Cannot write genesis files: %s", err)

cmd/goal/account.go

@@ -877,11 +877,19 @@ var addParticipationKeyCmd = &cobra.Command{
 		// Generate a participation keys database and install it
 		client := ensureFullClient(dataDir)
 
-		_, _, err := client.GenParticipationKeysTo(accountAddress, roundFirstValid, roundLastValid, keyDilution, partKeyOutDir)
+		reportInfof("Please stand by while generating keys. This might take a few minutes...")
+
+		var err error
+		participationGen := func() {
+			_, _, err = client.GenParticipationKeysTo(accountAddress, roundFirstValid, roundLastValid, keyDilution, partKeyOutDir)
+		}
+
+		util.RunFuncWithSpinningCursor(participationGen)
 		if err != nil {
 			reportErrorf(errorRequestFail, err)
 		}
-		fmt.Println("Participation key generation successful")
+
+		reportInfof("Participation key generation successful")
 	},
 }
 
@@ -964,11 +972,21 @@ var renewParticipationKeyCmd = &cobra.Command{
 
 func generateAndRegisterPartKey(address string, currentRound, keyLastValidRound, txLastValidRound uint64, fee uint64, leaseBytes [32]byte, dilution uint64, wallet string, dataDir string, client libgoal.Client) error {
 	// Generate a participation keys database and install it
-	part, keyPath, err := client.GenParticipationKeysTo(address, currentRound, keyLastValidRound, dilution, "")
+	var part algodAcct.Participation
+	var keyPath string
+	var err error
+	genFunc := func() {
+		part, keyPath, err = client.GenParticipationKeysTo(address, currentRound, keyLastValidRound, dilution, "")
+		if err != nil {
+			err = fmt.Errorf(errorRequestFail, err)
+		}
+		fmt.Println("Participation key generation successful")
+	}
+	fmt.Println("Please stand by while generating keys. This might take a few minutes...")
+	util.RunFuncWithSpinningCursor(genFunc)
 	if err != nil {
-		return fmt.Errorf(errorRequestFail, err)
+		return err
 	}
-	fmt.Printf("  Generated participation key for %s (Valid %d - %d)\n", address, currentRound, keyLastValidRound)
 
 	// Now register it as our new online participation key
 	goOnline := true
@@ -1449,8 +1467,9 @@ var partkeyInfoCmd = &cobra.Command{
 				fmt.Printf("Key dilution:              %d\n", part.Key.VoteKeyDilution)
 				fmt.Printf("Selection key:             %s\n", base64.StdEncoding.EncodeToString(part.Key.SelectionParticipationKey))
 				fmt.Printf("Voting key:                %s\n", base64.StdEncoding.EncodeToString(part.Key.VoteParticipationKey))
-				// PKI TODO: enable with state proof support.
-				//fmt.Printf("State proof key:           %s\n", base64.StdEncoding.EncodeToString(part.StateProofKey))
+				if part.Key.StateProofKey != nil {
+					fmt.Printf("State proof key:           %s\n", base64.StdEncoding.EncodeToString(*part.Key.StateProofKey))
+				}
 			}
 		})
 	},

compactcert/abstractions.go

@@ -54,5 +54,5 @@ type Network interface {
 // Accounts captures the aspects of the AccountManager that are used by
 // this package.
 type Accounts interface {
-	Keys(basics.Round) []account.Participation
+	StateProofKeys(basics.Round) []account.StateProofRecordForRound
 }

compactcert/db.go

@@ -20,7 +20,7 @@ import (
 	"database/sql"
 	"fmt"
 
-	"github.com/algorand/go-algorand/crypto"
+	"github.com/algorand/go-algorand/crypto/merklesignature"
 	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/protocol"
 )
@@ -47,7 +47,7 @@ var schema = []string{
 
 type pendingSig struct {
 	signer       basics.Address
-	sig          crypto.OneTimeSignature
+	sig          merklesignature.Signature
 	fromThisNode bool
 }