fix: updating linkedmap to use generic

sandbox/sandbox.go

@@ -74,8 +74,8 @@ func (sb *sandbox) shouldPanicForUnknownAddress() {
 }
 
 func (sb *sandbox) Account(addr crypto.Address) *account.Account {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	s, ok := sb.accounts[addr]
 	if ok {
@@ -95,8 +95,8 @@ func (sb *sandbox) Account(addr crypto.Address) *account.Account {
 	return acc
 }
 func (sb *sandbox) MakeNewAccount(addr crypto.Address) *account.Account {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	if sb.store.HasAccount(addr) {
 		sb.shouldPanicForDuplicatedAddress()
@@ -112,8 +112,8 @@ func (sb *sandbox) MakeNewAccount(addr crypto.Address) *account.Account {
 }
 
 func (sb *sandbox) UpdateAccount(addr crypto.Address, acc *account.Account) {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	s, ok := sb.accounts[addr]
 	if !ok {
@@ -124,8 +124,8 @@ func (sb *sandbox) UpdateAccount(addr crypto.Address, acc *account.Account) {
 }
 
 func (sb *sandbox) Validator(addr crypto.Address) *validator.Validator {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	s, ok := sb.validators[addr]
 	if ok {
@@ -145,8 +145,8 @@ func (sb *sandbox) Validator(addr crypto.Address) *validator.Validator {
 }
 
 func (sb *sandbox) MakeNewValidator(pub *bls.PublicKey) *validator.Validator {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	addr := pub.Address()
 	if sb.store.HasValidator(addr) {
@@ -163,8 +163,8 @@ func (sb *sandbox) MakeNewValidator(pub *bls.PublicKey) *validator.Validator {
 }
 
 func (sb *sandbox) UpdateValidator(val *validator.Validator) {
-	sb.lk.RLock()
-	defer sb.lk.RUnlock()
+	sb.lk.Lock()
+	defer sb.lk.Unlock()
 
 	addr := val.Address()
 	s, ok := sb.validators[addr]

store/store.go

@@ -57,7 +57,7 @@ type store struct {
 	txStore        *txStore
 	accountStore   *accountStore
 	validatorStore *validatorStore
-	stampLookup    *linkedmap.LinkedMap
+	stampLookup    *linkedmap.LinkedMap[hash.Stamp, hashPair]
 }
 
 func NewStore(conf *Config, stampLookupCapacity int) (Store, error) {
@@ -78,7 +78,7 @@ func NewStore(conf *Config, stampLookupCapacity int) (Store, error) {
 		txStore:        newTxStore(db),
 		accountStore:   newAccountStore(db),
 		validatorStore: newValidatorStore(db),
-		stampLookup:    linkedmap.NewLinkedMap(stampLookupCapacity),
+		stampLookup:    linkedmap.NewLinkedMap[hash.Stamp, hashPair](stampLookupCapacity),
 	}
 
 	lastHeight, _ := s.LastCertificate()
@@ -99,7 +99,7 @@ func (s *store) Close() error {
 }
 
 func (s *store) appendStamp(hash hash.Hash, height uint32) {
-	pair := &hashPair{
+	pair := hashPair{
 		Height: height,
 		Hash:   hash,
 	}
@@ -174,31 +174,31 @@ func (s *store) BlockHash(height uint32) hash.Hash {
 }
 
 func (s *store) FindBlockHashByStamp(stamp hash.Stamp) (hash.Hash, bool) {
-	s.lk.Lock()
-	defer s.lk.Unlock()
+	s.lk.RLock()
+	defer s.lk.RUnlock()
 
 	if stamp.EqualsTo(hash.UndefHash.Stamp()) {
 		return hash.UndefHash, true
 	}
 
-	v, ok := s.stampLookup.Get(stamp)
-	if ok {
-		return v.(*hashPair).Hash, true
+	n := s.stampLookup.GetNode(stamp)
+	if n != nil {
+		return n.Data.Value.Hash, true
 	}
 	return hash.UndefHash, false
 }
 
 func (s *store) FindBlockHeightByStamp(stamp hash.Stamp) (uint32, bool) {
-	s.lk.Lock()
-	defer s.lk.Unlock()
+	s.lk.RLock()
+	defer s.lk.RUnlock()
 
 	if stamp.EqualsTo(hash.UndefHash.Stamp()) {
 		return 0, true
 	}
 
-	v, ok := s.stampLookup.Get(stamp)
-	if ok {
-		return v.(*hashPair).Height, true
+	n := s.stampLookup.GetNode(stamp)
+	if n != nil {
+		return n.Data.Value.Height, true
 	}
 	return 0, false
 }

txpool/pool.go

@@ -1,7 +1,6 @@
 package txpool
 
 import (
-	"container/list"
 	"fmt"
 	"sync"
 
@@ -21,24 +20,24 @@ type txPool struct {
 	config      *Config
 	checker     *execution.Execution
 	sandbox     sandbox.Sandbox
-	pools       map[payload.Type]*linkedmap.LinkedMap
+	pools       map[payload.Type]*linkedmap.LinkedMap[tx.ID, *tx.Tx]
 	broadcastCh chan message.Message
 	logger      *logger.Logger
 }
 
 func NewTxPool(conf *Config, broadcastCh chan message.Message) TxPool {
-	pendings := make(map[payload.Type]*linkedmap.LinkedMap)
+	pending := make(map[payload.Type]*linkedmap.LinkedMap[tx.ID, *tx.Tx])
 
-	pendings[payload.PayloadTypeTransfer] = linkedmap.NewLinkedMap(conf.sendPoolSize())
-	pendings[payload.PayloadTypeBond] = linkedmap.NewLinkedMap(conf.bondPoolSize())
-	pendings[payload.PayloadTypeUnbond] = linkedmap.NewLinkedMap(conf.unbondPoolSize())
-	pendings[payload.PayloadTypeWithdraw] = linkedmap.NewLinkedMap(conf.withdrawPoolSize())
-	pendings[payload.PayloadTypeSortition] = linkedmap.NewLinkedMap(conf.sortitionPoolSize())
+	pending[payload.PayloadTypeTransfer] = linkedmap.NewLinkedMap[tx.ID, *tx.Tx](conf.sendPoolSize())
+	pending[payload.PayloadTypeBond] = linkedmap.NewLinkedMap[tx.ID, *tx.Tx](conf.bondPoolSize())
+	pending[payload.PayloadTypeUnbond] = linkedmap.NewLinkedMap[tx.ID, *tx.Tx](conf.unbondPoolSize())
+	pending[payload.PayloadTypeWithdraw] = linkedmap.NewLinkedMap[tx.ID, *tx.Tx](conf.withdrawPoolSize())
+	pending[payload.PayloadTypeSortition] = linkedmap.NewLinkedMap[tx.ID, *tx.Tx](conf.sortitionPoolSize())
 
 	pool := &txPool{
 		config:      conf,
 		checker:     execution.NewChecker(),
-		pools:       pendings,
+		pools:       pending,
 		broadcastCh: broadcastCh,
 	}
 
@@ -53,11 +52,11 @@ func (p *txPool) SetNewSandboxAndRecheck(sb sandbox.Sandbox) {
 	p.sandbox = sb
 	p.logger.Debug("set new sandbox")
 
-	var next *list.Element
+	var next *linkedmap.LinkNode[linkedmap.Pair[tx.ID, *tx.Tx]]
 	for _, pool := range p.pools {
-		for e := pool.FirstElement(); e != nil; e = next {
-			next = e.Next()
-			trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
+		for e := pool.FirstNode(); e != nil; e = next {
+			next = e.Next
+			trx := e.Data.Value
 
 			if err := p.checkTx(trx); err != nil {
 				p.logger.Debug("invalid transaction after rechecking", "id", trx.ID())
@@ -136,10 +135,9 @@ func (p *txPool) PendingTx(id tx.ID) *tx.Tx {
 	defer p.lk.Unlock()
 
 	for _, pool := range p.pools {
-		val, found := pool.Get(id)
-		if found {
-			trx := val.(*tx.Tx)
-			return trx
+		n := pool.GetNode(id)
+		if n != nil {
+			return n.Data.Value
 		}
 	}
 
@@ -154,37 +152,32 @@ func (p *txPool) PrepareBlockTransactions() block.Txs {
 
 	// Appending one sortition transaction
 	poolSortition := p.pools[payload.PayloadTypeSortition]
-	for e := poolSortition.FirstElement(); e != nil; e = e.Next() {
-		trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
-		trxs = append(trxs, trx)
+	for n := poolSortition.FirstNode(); n != nil; n = n.Next {
+		trxs = append(trxs, n.Data.Value)
 	}
 
 	// Appending bond transactions
 	poolBond := p.pools[payload.PayloadTypeBond]
-	for e := poolBond.FirstElement(); e != nil; e = e.Next() {
-		trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
-		trxs = append(trxs, trx)
+	for n := poolBond.FirstNode(); n != nil; n = n.Next {
+		trxs = append(trxs, n.Data.Value)
 	}
 
 	// Appending unbond transactions
 	poolUnbond := p.pools[payload.PayloadTypeUnbond]
-	for e := poolUnbond.FirstElement(); e != nil; e = e.Next() {
-		trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
-		trxs = append(trxs, trx)
+	for n := poolUnbond.FirstNode(); n != nil; n = n.Next {
+		trxs = append(trxs, n.Data.Value)
 	}
 
 	// Appending withdraw transactions
 	poolWithdraw := p.pools[payload.PayloadTypeWithdraw]
-	for e := poolWithdraw.FirstElement(); e != nil; e = e.Next() {
-		trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
-		trxs = append(trxs, trx)
+	for n := poolWithdraw.FirstNode(); n != nil; n = n.Next {
+		trxs = append(trxs, n.Data.Value)
 	}
 
 	// Appending send transactions
 	poolSend := p.pools[payload.PayloadTypeTransfer]
-	for e := poolSend.FirstElement(); e != nil; e = e.Next() {
-		trx := e.Value.(*linkedmap.Pair).Second.(*tx.Tx)
-		trxs = append(trxs, trx)
+	for n := poolSend.FirstNode(); n != nil; n = n.Next {
+		trxs = append(trxs, n.Data.Value)
 	}
 
 	return trxs

util/encoding/encoding.go

@@ -20,8 +20,8 @@ const (
 )
 
 var (
-	ErrOverflow     = errors.New("Overflow")
-	ErrNonCanonical = errors.New("NonCanonical")
+	ErrOverflow     = errors.New("overflow")
+	ErrNonCanonical = errors.New("non canonical")
 )
 
 // binaryFreeList defines a concurrent safe free list of byte slices (up to the