Merge pull request #666 from iotaledger/feat/reelected-committee-retains-seat

Re-elected committee member retains its SeatIndex

Author: jonastheis

components/protocol/component.go

@@ -277,7 +277,7 @@ func configure() error {
 		Component.LogDebugf("SlotCommitmentReceived: %s", commitment.ID())
 	})
 
-	deps.Protocol.Events.Engine.SybilProtection.CommitteeSelected.Hook(func(committee *account.Accounts, epoch iotago.EpochIndex) {
+	deps.Protocol.Events.Engine.SybilProtection.CommitteeSelected.Hook(func(committee *account.SeatedAccounts, epoch iotago.EpochIndex) {
 		Component.LogInfof("CommitteeSelected, epoch: %d, committeeIDs: %s, reused: %t", epoch, committee.IDs(), committee.IsReused())
 	})
 

out.log

@@ -0,0 +1 @@
+?   	github.com/iotaledger/iota-core	[no test files]

pkg/core/account/accounts.go

@@ -1,10 +1,12 @@
 package account
 
 import (
+	"bytes"
 	"io"
-	"sync/atomic"
+	"sort"
 
 	"github.com/iotaledger/hive.go/core/safemath"
+	"github.com/iotaledger/hive.go/ds"
 	"github.com/iotaledger/hive.go/ds/shrinkingmap"
 	"github.com/iotaledger/hive.go/ierrors"
 	"github.com/iotaledger/hive.go/runtime/syncutils"
@@ -19,7 +21,6 @@ type Accounts struct {
 
 	totalStake          iotago.BaseToken
 	totalValidatorStake iotago.BaseToken
-	reused              atomic.Bool
 
 	mutex syncutils.RWMutex
 }
@@ -52,14 +53,6 @@ func (a *Accounts) IDs() []iotago.AccountID {
 	return ids
 }
 
-func (a *Accounts) IsReused() bool {
-	return a.reused.Load()
-}
-
-func (a *Accounts) SetReused() {
-	a.reused.Store(true)
-}
-
 // Get returns the weight of the given identity.
 func (a *Accounts) Get(id iotago.AccountID) (pool *Pool, exists bool) {
 	return a.accountPools.Get(id)
@@ -125,9 +118,54 @@ func (a *Accounts) ForEach(callback func(id iotago.AccountID, pool *Pool) bool)
 	a.accountPools.ForEach(callback)
 }
 
-// SeatedAccounts creates a new SeatedAccounts instance, that maintains the seats of the given members.
-func (a *Accounts) SeatedAccounts(members ...iotago.AccountID) *SeatedAccounts {
-	return NewSeatedAccounts(a, members...)
+// SeatedAccounts creates a new SeatedAccounts instance,
+// that maintains the seat indices of re-elected members from the previous committee, if provided.
+func (a *Accounts) SeatedAccounts(optPrevCommittee ...*SeatedAccounts) *SeatedAccounts {
+	// If optPrevCommittee not given, use empty SeatedAccounts instance as default to skip the behavior to handle re-elected members.
+	prevCommittee := NewSeatedAccounts(NewAccounts())
+	if len(optPrevCommittee) > 0 {
+		prevCommittee = optPrevCommittee[0]
+	}
+
+	newCommittee := NewSeatedAccounts(a)
+
+	// If previous committee exists the seats need to be assigned and re-elected committee members must retain their SeatIndex.
+	// Keep track of re-elected members' seat indices.
+	takenSeatIndices := ds.NewSet[SeatIndex]()
+
+	// Assign re-elected members' SeatIndex.
+	a.ForEach(func(id iotago.AccountID, _ *Pool) bool {
+		if seatIndex, seatExists := prevCommittee.GetSeat(id); seatExists {
+			newCommittee.Set(seatIndex, id)
+			takenSeatIndices.Add(seatIndex)
+		}
+
+		return true
+	})
+
+	// Sort members lexicographically.
+	committeeAccountIDs := a.IDs()
+	sort.Slice(committeeAccountIDs, func(i int, j int) bool {
+		return bytes.Compare(committeeAccountIDs[i][:], committeeAccountIDs[j][:]) < 0
+	})
+
+	// Assign SeatIndex to new committee members.
+	currentSeatIndex := SeatIndex(0)
+	for _, memberID := range committeeAccountIDs {
+		// If SeatIndex is taken by re-elected member, then increment it.
+		for takenSeatIndices.Has(currentSeatIndex) {
+			currentSeatIndex++
+		}
+
+		// Assign SeatIndex of a fresh committee member.
+		if _, seatExists := prevCommittee.GetSeat(memberID); !seatExists {
+			newCommittee.Set(currentSeatIndex, memberID)
+
+			currentSeatIndex++
+		}
+	}
+
+	return newCommittee
 }
 
 func AccountsFromBytes(b []byte) (*Accounts, int, error) {
@@ -164,13 +202,6 @@ func AccountsFromReader(reader io.Reader) (*Accounts, error) {
 		return nil, ierrors.Wrap(err, "failed to read account data")
 	}
 
-	reused, err := stream.Read[bool](reader)
-	if err != nil {
-		return nil, ierrors.Wrap(err, "failed to read reused flag")
-	}
-
-	a.reused.Store(reused)
-
 	return a, nil
 }
 
@@ -202,9 +233,5 @@ func (a *Accounts) Bytes() ([]byte, error) {
 		return nil, ierrors.Wrap(err, "failed to write accounts")
 	}
 
-	if err := stream.Write(byteBuffer, a.reused.Load()); err != nil {
-		return nil, ierrors.Wrap(err, "failed to write reused flag")
-	}
-
 	return byteBuffer.Bytes()
 }

pkg/core/account/accounts_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/iotaledger/hive.go/lo"
 	"github.com/iotaledger/iota-core/pkg/core/account"
 	iotago "github.com/iotaledger/iota.go/v4"
 	"github.com/iotaledger/iota.go/v4/tpkg"
@@ -20,13 +21,11 @@ func TestAccounts(t *testing.T) {
 
 	// check "Set"
 	for id, stake := range issuers {
-		if err := accounts.Set(id, &account.Pool{
-			PoolStake:      iotago.BaseToken(stake),
+		require.NoError(t, accounts.Set(id, &account.Pool{
+			PoolStake:      stake,
 			ValidatorStake: iotago.BaseToken(stake) * 2,
 			FixedCost:      iotago.Mana(stake) * 3,
-		}); err != nil {
-			t.Fatal(err)
-		}
+		}))
 	}
 
 	// check "Size"
@@ -57,13 +56,13 @@ func TestAccounts(t *testing.T) {
 		require.True(t, accounts.Has(id))
 
 		// check "Get"
-		account, exists := accounts.Get(id)
+		member, exists := accounts.Get(id)
 		require.True(t, exists)
 
 		// check the account itself
-		require.Equal(t, stake, account.PoolStake)
-		require.Equal(t, stake*2, account.ValidatorStake)
-		require.Equal(t, iotago.Mana(stake)*3, account.FixedCost)
+		require.Equal(t, stake, member.PoolStake)
+		require.Equal(t, stake*2, member.ValidatorStake)
+		require.Equal(t, iotago.Mana(stake)*3, member.FixedCost)
 	}
 
 	// check total stakes
@@ -74,11 +73,11 @@ func TestAccounts(t *testing.T) {
 	account1, exists := accounts.Get(accountIDs[0])
 	require.True(t, exists)
 
-	accounts.Set(accountIDs[0], &account.Pool{
+	require.NoError(t, accounts.Set(accountIDs[0], &account.Pool{
 		PoolStake:      10 * account1.PoolStake,
 		ValidatorStake: 10 * account1.ValidatorStake,
 		FixedCost:      10 * account1.FixedCost,
-	})
+	}))
 
 	// check if the updated total stakes are correct
 	require.Equal(t, (totalStake-account1.PoolStake)+(account1.PoolStake*10), accounts.TotalStake())
@@ -107,12 +106,8 @@ func TestAccounts(t *testing.T) {
 
 	// check "SelectCommittee"
 
-	// get 1 issuer
-	seated := accounts.SeatedAccounts(accountIDs[0])
-	require.Equal(t, 1, seated.SeatCount())
-
 	// get all issuers
-	seated = accounts.SeatedAccounts(accountIDs...)
+	seated := accounts.SeatedAccounts()
 	require.Equal(t, len(accountIDs), seated.SeatCount())
 
 	/*
@@ -124,14 +119,82 @@ func TestAccounts(t *testing.T) {
 	*/
 }
 
+func TestAccounts_SeatedAccounts(t *testing.T) {
+	committeeSize := 20
+
+	prevCommitteeIssuers, _ := generateAccounts(committeeSize)
+	newCommitteeIssuers, _ := generateAccounts(committeeSize/2 - 1)
+
+	newCommitteeAccounts := account.NewAccounts()
+	prevCommitteeAccounts := account.NewAccounts()
+
+	idx := 0
+	for id, stake := range prevCommitteeIssuers {
+		// half of the accounts from the previous committee should also be added to the new committee
+		if idx%2 == 0 || idx == 1 {
+			require.NoError(t, newCommitteeAccounts.Set(id, &account.Pool{
+				PoolStake:      stake,
+				ValidatorStake: iotago.BaseToken(stake) * 2,
+				FixedCost:      iotago.Mana(stake) * 3,
+			}))
+		}
+
+		require.NoError(t, prevCommitteeAccounts.Set(id, &account.Pool{
+			PoolStake:      stake,
+			ValidatorStake: iotago.BaseToken(stake) * 2,
+			FixedCost:      iotago.Mana(stake) * 3,
+		}))
+
+		idx++
+	}
+
+	// Add remaining accounts to new committee accounts.
+	for id, stake := range newCommitteeIssuers {
+		// half of the accounts from the previous committee should also be added to the new committee
+		require.NoError(t, newCommitteeAccounts.Set(id, &account.Pool{
+			PoolStake:      stake,
+			ValidatorStake: iotago.BaseToken(stake) * 2,
+			FixedCost:      iotago.Mana(stake) * 3,
+		}))
+	}
+
+	// Get prev committee and assign seats by default.
+	prevCommittee := prevCommitteeAccounts.SeatedAccounts()
+
+	// New committee seats should be assigned taking previous committee into account.
+	newCommittee := newCommitteeAccounts.SeatedAccounts(prevCommittee)
+
+	prevCommitteeAccounts.ForEach(func(id iotago.AccountID, _ *account.Pool) bool {
+		if seatIndex, exists := newCommittee.GetSeat(id); exists {
+			require.Equal(t, lo.Return1(prevCommittee.GetSeat(id)), seatIndex)
+		}
+
+		return true
+	})
+
+	// Make sure that the size of the committee and SeatIndex values are sane.
+	require.Equal(t, newCommittee.SeatCount(), committeeSize)
+
+	// Check that SeatIndices are within <0; committeeSize) range.
+	newCommitteeAccounts.ForEach(func(id iotago.AccountID, _ *account.Pool) bool {
+		// SeatIndex must be smaller than CommitteeSize.
+		require.Less(t, int(lo.Return1(newCommittee.GetSeat(id))), committeeSize)
+
+		// SeatIndex must be bigger or equal to 0.
+		require.GreaterOrEqual(t, int(lo.Return1(newCommittee.GetSeat(id))), 0)
+
+		return true
+	})
+}
+
 func generateAccounts(count int) (map[iotago.AccountID]iotago.BaseToken, iotago.BaseToken) {
 	seenIDs := make(map[iotago.AccountID]bool)
 	issuers := make(map[iotago.AccountID]iotago.BaseToken)
 
 	var totalStake iotago.BaseToken
 
 	for i := 0; i < count; i++ {
-		id := iotago.AccountID([32]byte{tpkg.RandByte()})
+		id := iotago.AccountID(tpkg.Rand32ByteArray())
 		if _, exist := seenIDs[id]; exist {
 			i--
 			continue