Participation Key Interface

Makefile

@@ -76,7 +76,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
+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
 
 default: build
 

agreement/abstractions.go

@@ -225,6 +225,10 @@ type KeyManager interface {
 	// valid for the provided votingRound, and were available at
 	// keysRound.
 	VotingKeys(votingRound, keysRound basics.Round) []account.Participation
+
+	// RecordAsync indicates that the given participation action has been taken.
+	// The operation needs to be asynchronous to avoid impacting agreement.
+	RecordAsync(account basics.Address, round basics.Round, participationType account.ParticipationAction)
 }
 
 // MessageHandle is an ID referring to a specific message.

agreement/agreementtest/keyManager.go

@@ -21,7 +21,7 @@ import (
 	"github.com/algorand/go-algorand/data/basics"
 )
 
-// SimpleKeyManager provides a simple implementation of a KeyManager.
+// SimpleKeyManager provides a simple implementation of a KeyManager for unit tests.
 type SimpleKeyManager []account.Participation
 
 // VotingKeys implements KeyManager.VotingKeys.
@@ -37,7 +37,8 @@ func (m SimpleKeyManager) VotingKeys(votingRound, _ basics.Round) []account.Part
 
 // DeleteOldKeys implements KeyManager.DeleteOldKeys.
 func (m SimpleKeyManager) DeleteOldKeys(r basics.Round) {
-	// for _, acc := range m {
-	// acc.DeleteOldKeys(r)
-	// }
+}
+
+// RecordAsync implements KeyManager.RecordAsync.
+func (m SimpleKeyManager) RecordAsync(account basics.Address, round basics.Round, action account.ParticipationAction) {
 }

agreement/cryptoVerifier_test.go

@@ -314,7 +314,7 @@ func BenchmarkCryptoVerifierProposalVertification(b *testing.B) {
 	pn := &asyncPseudonode{
 		factory:   testBlockFactory{Owner: 0},
 		validator: testBlockValidator{},
-		keys:      simpleKeyManager(participations),
+		keys:      makeRecordingKeyManager(participations),
 		ledger:    ledger,
 		log:       serviceLogger{logging.Base()},
 	}

agreement/fuzzer/fuzzer_test.go

@@ -29,6 +29,7 @@ import (
 	"github.com/algorand/go-deadlock"
 
 	"github.com/algorand/go-algorand/agreement"
+	"github.com/algorand/go-algorand/agreement/agreementtest"
 	"github.com/algorand/go-algorand/agreement/gossip"
 	"github.com/algorand/go-algorand/config"
 	"github.com/algorand/go-algorand/crypto"
@@ -132,7 +133,7 @@ func (n *Fuzzer) initAgreementNode(nodeID int, filters ...NetworkFilterFactory)
 		Logger:                  logger,
 		Ledger:                  n.ledgers[nodeID],
 		Network:                 gossip.WrapNetwork(n.facades[nodeID], logger),
-		KeyManager:              simpleKeyManager(n.accounts[nodeID : nodeID+1]),
+		KeyManager:              agreementtest.SimpleKeyManager(n.accounts[nodeID : nodeID+1]),
 		BlockValidator:          n.blockValidator,
 		BlockFactory:            testBlockFactory{Owner: nodeID},
 		Clock:                   n.clocks[nodeID],

agreement/keyManager_test.go

@@ -0,0 +1,63 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand.  If not, see <https://www.gnu.org/licenses/>.
+
+package agreement
+
+import (
+	"github.com/algorand/go-deadlock"
+
+	"github.com/algorand/go-algorand/data/account"
+	"github.com/algorand/go-algorand/data/basics"
+)
+
+func makeRecordingKeyManager(accounts []account.Participation) *recordingKeyManager {
+	return &recordingKeyManager{
+		keys:      accounts,
+		recording: make(map[basics.Address]map[account.ParticipationAction]basics.Round),
+	}
+}
+
+// recordingKeyManager provides a simple implementation of a KeyManager for unit tests.
+type recordingKeyManager struct {
+	keys      []account.Participation
+	recording map[basics.Address]map[account.ParticipationAction]basics.Round
+	mutex     deadlock.Mutex
+}
+
+// VotingKeys implements KeyManager.VotingKeys.
+func (m *recordingKeyManager) VotingKeys(votingRound, _ basics.Round) []account.Participation {
+	var km []account.Participation
+	for _, acc := range m.keys {
+		if acc.OverlapsInterval(votingRound, votingRound) {
+			km = append(km, acc)
+		}
+	}
+	return km
+}
+
+// DeleteOldKeys implements KeyManager.DeleteOldKeys.
+func (m *recordingKeyManager) DeleteOldKeys(r basics.Round) {
+}
+
+// Record implements KeyManager.Record.
+func (m *recordingKeyManager) RecordAsync(acct basics.Address, round basics.Round, action account.ParticipationAction) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+	if _, ok := m.recording[acct]; !ok {
+		m.recording[acct] = make(map[account.ParticipationAction]basics.Round)
+	}
+	m.recording[acct][action] = round
+}

agreement/pseudonode.go

@@ -441,6 +441,7 @@ func (t pseudonodeVotesTask) execute(verifier *AsyncVoteVerifier, quit chan stru
 	for _, r := range verifiedResults {
 		select {
 		case t.out <- messageEvent{T: voteVerified, Input: r.message, Err: makeSerErr(r.err)}:
+			t.node.keys.RecordAsync(r.v.R.Sender, r.v.R.Round, account.Vote)
 		case <-quit:
 			return
 		case <-t.context.Done():
@@ -528,6 +529,7 @@ func (t pseudonodeProposalsTask) execute(verifier *AsyncVoteVerifier, quit chan
 	for _, r := range verifiedVotes {
 		select {
 		case t.out <- messageEvent{T: voteVerified, Input: r.message, Err: makeSerErr(r.err)}:
+			t.node.keys.RecordAsync(r.v.R.Sender, r.v.R.Round, account.BlockProposal)
 		case <-quit:
 			return
 		case <-t.context.Done():

agreement/pseudonode_test.go

@@ -145,7 +145,7 @@ func TestPseudonode(t *testing.T) {
 	sLogger := serviceLogger{logging.NewLogger()}
 	sLogger.SetLevel(logging.Warn)
 
-	keyManager := simpleKeyManager(accounts)
+	keyManager := makeRecordingKeyManager(accounts)
 	pb := makePseudonode(pseudonodeParams{
 		factory:      testBlockFactory{Owner: 0},
 		validator:    testBlockValidator{},
@@ -222,7 +222,12 @@ func TestPseudonode(t *testing.T) {
 		}
 		messageEvent, typeOk := ev.(messageEvent)
 		assert.True(t, true, typeOk)
+		// Verify votes are recorded - everyone is voting and proposing blocks.
+		keyManager.mutex.Lock()
+		assert.Equal(t, startRound, keyManager.recording[messageEvent.Input.Vote.R.Sender][account.Vote])
+		assert.Equal(t, startRound, keyManager.recording[messageEvent.Input.Vote.R.Sender][account.BlockProposal])
 		events[messageEvent.t()] = append(events[messageEvent.t()], messageEvent)
+		keyManager.mutex.Unlock()
 	}
 	assert.Subset(t, []int{5, 6, 7, 8, 9, 10}, []int{len(events[voteVerified])})
 	assert.Equal(t, 0, len(events[payloadVerified]))
@@ -390,6 +395,9 @@ func (k *KeyManagerProxy) VotingKeys(votingRound, balanceRound basics.Round) []a
 	return k.target(votingRound, balanceRound)
 }
 
+func (k *KeyManagerProxy) RecordAsync(account basics.Address, round basics.Round, action account.ParticipationAction) {
+}
+
 func TestPseudonodeLoadingOfParticipationKeys(t *testing.T) {
 	partitiontest.PartitionTest(t)
 
@@ -403,7 +411,7 @@ func TestPseudonodeLoadingOfParticipationKeys(t *testing.T) {
 	sLogger := serviceLogger{logging.NewLogger()}
 	sLogger.SetLevel(logging.Warn)
 
-	keyManager := simpleKeyManager(accounts)
+	keyManager := makeRecordingKeyManager(accounts)
 	pb := makePseudonode(pseudonodeParams{
 		factory:      testBlockFactory{Owner: 0},
 		validator:    testBlockValidator{},

agreement/service_test.go

@@ -105,22 +105,6 @@ func (c *testingClock) fire(d time.Duration) {
 	close(c.TA[d])
 }
 
-type simpleKeyManager []account.Participation
-
-func (m simpleKeyManager) VotingKeys(votingRound, _ basics.Round) []account.Participation {
-	var km []account.Participation
-	for _, acc := range m {
-		if acc.OverlapsInterval(votingRound, votingRound) {
-			km = append(km, acc)
-		}
-	}
-	return km
-}
-
-func (m simpleKeyManager) DeleteOldKeys(basics.Round) {
-	// noop
-}
-
 type testingNetwork struct {
 	validator BlockValidator
 
@@ -743,7 +727,7 @@ func setupAgreementWithValidator(t *testing.T, numNodes int, traceLevel traceLev
 		m.coserviceListener = am.coserviceListener(nodeID(i))
 		clocks[i] = makeTestingClock(m)
 		ledgers[i] = ledgerFactory(balances)
-		keys := simpleKeyManager(accounts[i : i+1])
+		keys := makeRecordingKeyManager(accounts[i : i+1])
 		endpoint := baseNetwork.testingNetworkEndpoint(nodeID(i))
 		ilog := log.WithFields(logging.Fields{"Source": "service-" + strconv.Itoa(i)})