Merge pull request #1526 from onetechnical/onetechnical/relstable2.1.5

Onetechnical/relstable2.1.5

Author: algojohnlee

agreement/abstractions.go

@@ -128,14 +128,14 @@ type LedgerReader interface {
 	// protocol may lose liveness.
 	Seed(basics.Round) (committee.Seed, error)
 
-	// BalanceRecord returns the BalanceRecord associated with some Address
+	// Lookup returns the AccountData associated with some Address
 	// at the conclusion of a given round.
 	//
 	// This method returns an error if the given Round has not yet been
 	// confirmed. It may also return an error if the given Round is
 	// unavailable by the storage device. In that case, the agreement
 	// protocol may lose liveness.
-	BalanceRecord(basics.Round, basics.Address) (basics.BalanceRecord, error)
+	Lookup(basics.Round, basics.Address) (basics.AccountData, error)
 
 	// Circulation returns the total amount of money in circulation at the
 	// conclusion of a given round.

agreement/agreementtest/simulate_test.go

@@ -104,12 +104,12 @@ type testLedger struct {
 	nextRound basics.Round
 
 	// constant
-	state map[basics.Address]basics.BalanceRecord
+	state map[basics.Address]basics.AccountData
 
 	notifications map[basics.Round]signal
 }
 
-func makeTestLedger(state map[basics.Address]basics.BalanceRecord) agreement.Ledger {
+func makeTestLedger(state map[basics.Address]basics.AccountData) agreement.Ledger {
 	l := new(testLedger)
 	l.entries = make(map[basics.Round]bookkeeping.Block)
 	l.certs = make(map[basics.Round]agreement.Certificate)
@@ -124,7 +124,7 @@ func (l *testLedger) copy() *testLedger {
 
 	dup.entries = make(map[basics.Round]bookkeeping.Block)
 	dup.certs = make(map[basics.Round]agreement.Certificate)
-	dup.state = make(map[basics.Address]basics.BalanceRecord)
+	dup.state = make(map[basics.Address]basics.AccountData)
 	dup.notifications = make(map[basics.Round]signal)
 
 	for k, v := range l.entries {
@@ -202,12 +202,12 @@ func (l *testLedger) LookupDigest(r basics.Round) (crypto.Digest, error) {
 	return l.entries[r].Digest(), nil
 }
 
-func (l *testLedger) BalanceRecord(r basics.Round, a basics.Address) (basics.BalanceRecord, error) {
+func (l *testLedger) Lookup(r basics.Round, a basics.Address) (basics.AccountData, error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
 	if r >= l.nextRound {
-		err := fmt.Errorf("BalanceRecord called on future round: %v > %v! (this is probably a bug)", r, l.nextRound)
+		err := fmt.Errorf("Lookup called on future round: %v > %v! (this is probably a bug)", r, l.nextRound)
 		panic(err)
 	}
 	return l.state[a], nil
@@ -305,24 +305,21 @@ func TestSimulate(t *testing.T) {
 	E := basics.Round(50)     // max round
 
 	// generate accounts
-	genesis := make(map[basics.Address]basics.BalanceRecord)
+	genesis := make(map[basics.Address]basics.AccountData)
 	incentivePoolAtStart := uint64(1000 * 1000)
 	accData := basics.MakeAccountData(basics.NotParticipating, basics.MicroAlgos{Raw: incentivePoolAtStart})
-	genesis[poolAddr] = basics.BalanceRecord{Addr: poolAddr, AccountData: accData}
+	genesis[poolAddr] = accData
 	gen := rand.New(rand.NewSource(2))
 
 	_, accs, release := generateNAccounts(t, numAccounts, 0, E, minMoneyAtStart)
 	defer release()
 	for _, account := range accs {
 		amount := basics.MicroAlgos{Raw: uint64(minMoneyAtStart + (gen.Int() % (maxMoneyAtStart - minMoneyAtStart)))}
-		genesis[account.Address()] = basics.BalanceRecord{
-			Addr: account.Address(),
-			AccountData: basics.AccountData{
-				Status:      basics.Online,
-				MicroAlgos:  amount,
-				SelectionID: account.VRFSecrets().PK,
-				VoteID:      account.VotingSecrets().OneTimeSignatureVerifier,
-			},
+		genesis[account.Address()] = basics.AccountData{
+			Status:      basics.Online,
+			MicroAlgos:  amount,
+			SelectionID: account.VRFSecrets().PK,
+			VoteID:      account.VotingSecrets().OneTimeSignatureVerifier,
 		}
 	}
 

agreement/common_test.go

@@ -40,17 +40,17 @@ const keyBatchesForward = 10
 const minMoneyAtStart = 10000
 const maxMoneyAtStart = 100000
 
-var readOnlyGenesis10 map[basics.Address]basics.BalanceRecord
+var readOnlyGenesis10 map[basics.Address]basics.AccountData
 var readOnlyAddrs10 []basics.Address
 var readOnlyVRF10 []*crypto.VRFSecrets
 var readOnlyOT10 []crypto.OneTimeSigner
 
-var readOnlyGenesis100 map[basics.Address]basics.BalanceRecord
+var readOnlyGenesis100 map[basics.Address]basics.AccountData
 var readOnlyAddrs100 []basics.Address
 var readOnlyVRF100 []*crypto.VRFSecrets
 var readOnlyOT100 []crypto.OneTimeSigner
 
-var readOnlyGenesis7000 map[basics.Address]basics.BalanceRecord
+var readOnlyGenesis7000 map[basics.Address]basics.AccountData
 var readOnlyAddrs7000 []basics.Address
 var readOnlyVRF7000 []*crypto.VRFSecrets
 var readOnlyOT7000 []crypto.OneTimeSigner
@@ -93,8 +93,8 @@ func generateKeys(latest basics.Round, keyBatchesForward uint) (basics.Address,
 	return addr, v, o
 }
 
-func generateEnvironment(numAccounts int) (map[basics.Address]basics.BalanceRecord, []basics.Address, []*crypto.VRFSecrets, []crypto.OneTimeSigner) {
-	genesis := make(map[basics.Address]basics.BalanceRecord)
+func generateEnvironment(numAccounts int) (map[basics.Address]basics.AccountData, []basics.Address, []*crypto.VRFSecrets, []crypto.OneTimeSigner) {
+	genesis := make(map[basics.Address]basics.AccountData)
 	gen := rand.New(rand.NewSource(2))
 	addrs := make([]basics.Address, numAccounts)
 	vrfSecrets := make([]*crypto.VRFSecrets, numAccounts)
@@ -107,14 +107,11 @@ func generateEnvironment(numAccounts int) (map[basics.Address]basics.BalanceReco
 		otSecrets[i].OneTimeSignatureSecrets = otSec
 
 		startamt := uint64(minMoneyAtStart + (gen.Int() % (maxMoneyAtStart - minMoneyAtStart)))
-		genesis[addr] = basics.BalanceRecord{
-			Addr: addr,
-			AccountData: basics.AccountData{
-				Status:      basics.Online,
-				MicroAlgos:  basics.MicroAlgos{Raw: startamt},
-				SelectionID: vrfSec.PK,
-				VoteID:      otSec.OneTimeSignatureVerifier,
-			},
+		genesis[addr] = basics.AccountData{
+			Status:      basics.Online,
+			MicroAlgos:  basics.MicroAlgos{Raw: startamt},
+			SelectionID: vrfSec.PK,
+			VoteID:      otSec.OneTimeSignatureVerifier,
 		}
 		total.Raw += startamt
 	}
@@ -196,19 +193,19 @@ type testLedger struct {
 	nextRound basics.Round
 
 	// constant
-	state map[basics.Address]basics.BalanceRecord
+	state map[basics.Address]basics.AccountData
 
 	notifications map[basics.Round]signal
 }
 
-func makeTestLedger(state map[basics.Address]basics.BalanceRecord) Ledger {
+func makeTestLedger(state map[basics.Address]basics.AccountData) Ledger {
 	l := new(testLedger)
 	l.entries = make(map[basics.Round]bookkeeping.Block)
 	l.certs = make(map[basics.Round]Certificate)
 	l.nextRound = 1
 
 	// deep copy of state
-	l.state = make(map[basics.Address]basics.BalanceRecord)
+	l.state = make(map[basics.Address]basics.AccountData)
 	for k, v := range state {
 		l.state[k] = v
 	}
@@ -274,12 +271,12 @@ func (l *testLedger) LookupDigest(r basics.Round) (crypto.Digest, error) {
 	return l.entries[r].Digest(), nil
 }
 
-func (l *testLedger) BalanceRecord(r basics.Round, a basics.Address) (basics.BalanceRecord, error) {
+func (l *testLedger) Lookup(r basics.Round, a basics.Address) (basics.AccountData, error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
 	if r >= l.nextRound {
-		err := fmt.Errorf("BalanceRecord called on future round: %v >= %v! (this is probably a bug)", r, l.nextRound)
+		err := fmt.Errorf("Lookup called on future round: %v >= %v! (this is probably a bug)", r, l.nextRound)
 		panic(err)
 	}
 	return l.state[a], nil

agreement/demux_test.go

@@ -481,9 +481,9 @@ func (t *demuxTester) LookupDigest(basics.Round) (crypto.Digest, error) {
 }
 
 // implement Ledger
-func (t *demuxTester) BalanceRecord(basics.Round, basics.Address) (basics.BalanceRecord, error) {
+func (t *demuxTester) Lookup(basics.Round, basics.Address) (basics.AccountData, error) {
 	// we don't care about this function in this test.
-	return basics.BalanceRecord{}, nil
+	return basics.AccountData{}, nil
 }
 
 // implement Ledger

agreement/fuzzer/fuzzer_test.go

@@ -52,7 +52,7 @@ type Fuzzer struct {
 	router           *Router
 	log              logging.Logger
 	accounts         []account.Participation
-	balances         map[basics.Address]basics.BalanceRecord
+	balances         map[basics.Address]basics.AccountData
 	accountAccessors []db.Accessor
 	ledgers          []*testLedger
 	tickGranularity  time.Duration
@@ -83,7 +83,7 @@ func MakeFuzzer(config FuzzerConfig) *Fuzzer {
 		disconnected:     make([][]bool, config.NodesCount),
 		crashAccessors:   make([]db.Accessor, config.NodesCount),
 		accounts:         make([]account.Participation, config.NodesCount),
-		balances:         make(map[basics.Address]basics.BalanceRecord),
+		balances:         make(map[basics.Address]basics.AccountData),
 		accountAccessors: make([]db.Accessor, config.NodesCount*2),
 		ledgers:          make([]*testLedger, config.NodesCount),
 		agreementParams:  make([]agreement.Parameters, config.NodesCount),
@@ -239,10 +239,7 @@ func (n *Fuzzer) initAccountsAndBalances(rootSeed []byte, onlineNodes []bool) er
 				acctData.Status = basics.Offline
 			}
 		}
-		n.balances[rootAddress] = basics.BalanceRecord{
-			Addr:        rootAddress,
-			AccountData: acctData,
-		}
+		n.balances[rootAddress] = acctData
 	}
 	return nil
 }

agreement/fuzzer/ledger_test.go

@@ -124,7 +124,7 @@ type testLedger struct {
 	nextRound basics.Round
 
 	// constant
-	state map[basics.Address]basics.BalanceRecord
+	state map[basics.Address]basics.AccountData
 
 	notifications map[basics.Round]signal
 
@@ -137,15 +137,15 @@ type testLedger struct {
 	catchingUp            bool
 }
 
-func makeTestLedger(state map[basics.Address]basics.BalanceRecord, sync testLedgerSyncFunc) *testLedger {
+func makeTestLedger(state map[basics.Address]basics.AccountData, sync testLedgerSyncFunc) *testLedger {
 	l := new(testLedger)
 	l.Sync = sync
 	l.entries = make(map[basics.Round]bookkeeping.Block)
 	l.certs = make(map[basics.Round]agreement.Certificate)
 	l.nextRound = 1
 
 	// deep copy of state
-	l.state = make(map[basics.Address]basics.BalanceRecord)
+	l.state = make(map[basics.Address]basics.AccountData)
 	for k, v := range state {
 		l.state[k] = v
 	}
@@ -226,12 +226,12 @@ func (l *testLedger) LookupDigest(r basics.Round) (crypto.Digest, error) {
 	return l.entries[r].Digest(), nil
 }
 
-func (l *testLedger) BalanceRecord(r basics.Round, a basics.Address) (basics.BalanceRecord, error) {
+func (l *testLedger) Lookup(r basics.Round, a basics.Address) (basics.AccountData, error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
 	if r >= l.nextRound {
-		err := fmt.Errorf("BalanceRecord called on future round: %d >= %d! (this is probably a bug)", r, l.nextRound)
+		err := fmt.Errorf("Lookup called on future round: %d >= %d! (this is probably a bug)", r, l.nextRound)
 		panic(err)
 	}
 	return l.state[a], nil

agreement/proposal.go

@@ -133,7 +133,7 @@ func deriveNewSeed(address basics.Address, vrf *crypto.VRFSecrets, rnd round, pe
 
 	cparams, err := ledger.ConsensusParams(ParamsRound(rnd))
 	if err != nil {
-		err = fmt.Errorf("failed to obtain consensus parameters in round %d: %v", ParamsRound(rnd), err)
+		reterr = fmt.Errorf("failed to obtain consensus parameters in round %d: %v", ParamsRound(rnd), err)
 		return
 	}
 	var alpha crypto.Digest
@@ -184,7 +184,7 @@ func verifyNewSeed(p unauthenticatedProposal, ledger LedgerReader) error {
 	}
 
 	balanceRound := balanceRound(rnd, cparams)
-	proposerRecord, err := ledger.BalanceRecord(balanceRound, value.OriginalProposer)
+	proposerRecord, err := ledger.Lookup(balanceRound, value.OriginalProposer)
 	if err != nil {
 		return fmt.Errorf("failed to obtain balance record for address %v in round %d: %v", value.OriginalProposer, balanceRound, err)
 	}
@@ -201,13 +201,15 @@ func verifyNewSeed(p unauthenticatedProposal, ledger LedgerReader) error {
 		if !ok {
 			return fmt.Errorf("payload seed proof malformed (%v, %v)", prevSeed, p.SeedProof)
 		}
+		// TODO remove the following Hash() call,
+		// redundant with the Verify() call above.
 		vrfOut, ok = p.SeedProof.Hash()
 		if !ok {
 			// If proof2hash fails on a proof we produced with VRF Prove, this indicates our VRF code has a dangerous bug.
 			// Panicking is the only safe thing to do.
 			logging.Base().Panicf("VrfProof.Hash() failed on a proof we ourselves generated; this indicates a bug in the VRF code: %v", p.SeedProof)
 		}
-		alpha = crypto.HashObj(proposerSeed{Addr: proposerRecord.Addr, VRF: vrfOut})
+		alpha = crypto.HashObj(proposerSeed{Addr: value.OriginalProposer, VRF: vrfOut})
 	} else {
 		alpha = crypto.HashObj(prevSeed)
 	}

agreement/selector.go

@@ -64,7 +64,7 @@ func membership(l LedgerReader, addr basics.Address, r basics.Round, p period, s
 	balanceRound := balanceRound(r, cparams)
 	seedRound := seedRound(r, cparams)
 
-	record, err := l.BalanceRecord(balanceRound, addr)
+	record, err := l.Lookup(balanceRound, addr)
 	if err != nil {
 		err = fmt.Errorf("Service.initializeVote (r=%d): Failed to obtain balance record for address %v in round %d: %v", r, addr, balanceRound, err)
 		return
@@ -82,7 +82,7 @@ func membership(l LedgerReader, addr basics.Address, r basics.Round, p period, s
 		return
 	}
 
-	m.Record = record
+	m.Record = committee.BalanceRecord{AccountData: record, Addr: addr}
 	m.Selector = selector{Seed: seed, Round: r, Period: p, Step: s}
 	m.TotalMoney = total
 	return m, nil

agreement/service_test.go

@@ -636,12 +636,12 @@ func generatePseudoRandomVRF(keynum int) *crypto.VRFSecrets {
 	}
 }
 
-func createTestAccountsAndBalances(t *testing.T, numNodes int, rootSeed []byte) (accounts []account.Participation, balances map[basics.Address]basics.BalanceRecord) {
+func createTestAccountsAndBalances(t *testing.T, numNodes int, rootSeed []byte) (accounts []account.Participation, balances map[basics.Address]basics.AccountData) {
 	off := int(rand.Uint32() >> 2) // prevent name collision from running tests more than once
 
 	// system state setup: keygen, stake initialization
 	accounts = make([]account.Participation, numNodes)
-	balances = make(map[basics.Address]basics.BalanceRecord, numNodes)
+	balances = make(map[basics.Address]basics.AccountData, numNodes)
 	var seed crypto.Seed
 	copy(seed[:], rootSeed)
 
@@ -703,10 +703,7 @@ func createTestAccountsAndBalances(t *testing.T, numNodes int, rootSeed []byte)
 			VoteID:      accounts[i].VotingSecrets().OneTimeSignatureVerifier,
 			SelectionID: accounts[i].VRFSecrets().PK,
 		}
-		balances[rootAddress] = basics.BalanceRecord{
-			Addr:        rootAddress,
-			AccountData: acctData,
-		}
+		balances[rootAddress] = acctData
 	}
 	return
 }
@@ -725,12 +722,12 @@ func (testingRand) Uint64() uint64 {
 	return maxuint64 / 2
 }
 
-func setupAgreement(t *testing.T, numNodes int, traceLevel traceLevel, ledgerFactory func(map[basics.Address]basics.BalanceRecord) Ledger) (*testingNetwork, Ledger, func(), []*Service, []timers.Clock, []Ledger, *activityMonitor) {
+func setupAgreement(t *testing.T, numNodes int, traceLevel traceLevel, ledgerFactory func(map[basics.Address]basics.AccountData) Ledger) (*testingNetwork, Ledger, func(), []*Service, []timers.Clock, []Ledger, *activityMonitor) {
 	var validator testBlockValidator
 	return setupAgreementWithValidator(t, numNodes, traceLevel, validator, ledgerFactory)
 }
 
-func setupAgreementWithValidator(t *testing.T, numNodes int, traceLevel traceLevel, validator BlockValidator, ledgerFactory func(map[basics.Address]basics.BalanceRecord) Ledger) (*testingNetwork, Ledger, func(), []*Service, []timers.Clock, []Ledger, *activityMonitor) {
+func setupAgreementWithValidator(t *testing.T, numNodes int, traceLevel traceLevel, validator BlockValidator, ledgerFactory func(map[basics.Address]basics.AccountData) Ledger) (*testingNetwork, Ledger, func(), []*Service, []timers.Clock, []Ledger, *activityMonitor) {
 	bufCap := 1000 // max number of buffered messages
 
 	// system state setup: keygen, stake initialization
@@ -895,7 +892,7 @@ func simulateAgreement(t *testing.T, numNodes int, numRounds int, traceLevel tra
 	simulateAgreementWithLedgerFactory(t, numNodes, numRounds, traceLevel, makeTestLedger)
 }
 
-func simulateAgreementWithLedgerFactory(t *testing.T, numNodes int, numRounds int, traceLevel traceLevel, ledgerFactory func(map[basics.Address]basics.BalanceRecord) Ledger) {
+func simulateAgreementWithLedgerFactory(t *testing.T, numNodes int, numRounds int, traceLevel traceLevel, ledgerFactory func(map[basics.Address]basics.AccountData) Ledger) {
 	_, baseLedger, cleanupFn, services, clocks, ledgers, activityMonitor := setupAgreement(t, numNodes, traceLevel, ledgerFactory)
 	startRound := baseLedger.NextRound()
 	defer cleanupFn()

buildnumber.dat

@@ -1 +1 @@
-4
+5

catchup/service_test.go

@@ -557,8 +557,8 @@ func (m *mockedLedger) Block(r basics.Round) (bookkeeping.Block, error) {
 	return m.blocks[r], nil
 }
 
-func (m *mockedLedger) BalanceRecord(basics.Round, basics.Address) (basics.BalanceRecord, error) {
-	return basics.BalanceRecord{}, errors.New("not needed for mockedLedger")
+func (m *mockedLedger) Lookup(basics.Round, basics.Address) (basics.AccountData, error) {
+	return basics.AccountData{}, errors.New("not needed for mockedLedger")
 }
 func (m *mockedLedger) Circulation(basics.Round) (basics.MicroAlgos, error) {
 	return basics.MicroAlgos{}, errors.New("not needed for mockedLedger")