refactor: pslice variadic add (#1887)

pkg/debugapi/debugapi_test.go

@@ -66,7 +66,7 @@ func newTestServer(t *testing.T, o testServerOptions) *testServer {
 	settlement := swapmock.New(o.SettlementOpts...)
 	chequebook := chequebookmock.NewChequebook(o.ChequebookOpts...)
 	swapserv := swapmock.New(o.SwapOpts...)
-	ln := lightnode.NewContainer()
+	ln := lightnode.NewContainer(o.Overlay)
 	s := debugapi.New(o.Overlay, o.PublicKey, o.PSSPublicKey, o.EthereumAddress, logging.New(ioutil.Discard, 0), nil, o.CORSAllowedOrigins)
 	s.Configure(o.P2P, o.Pingpong, topologyDriver, ln, o.Storer, o.Tags, acc, settlement, true, swapserv, chequebook, o.BatchStore)
 	ts := httptest.NewServer(s)
@@ -133,7 +133,7 @@ func TestServer_Configure(t *testing.T) {
 	settlement := swapmock.New(o.SettlementOpts...)
 	chequebook := chequebookmock.NewChequebook(o.ChequebookOpts...)
 	swapserv := swapmock.New(o.SwapOpts...)
-	ln := lightnode.NewContainer()
+	ln := lightnode.NewContainer(o.Overlay)
 	s := debugapi.New(o.Overlay, o.PublicKey, o.PSSPublicKey, o.EthereumAddress, logging.New(ioutil.Discard, 0), nil, nil)
 	ts := httptest.NewServer(s)
 	t.Cleanup(ts.Close)

pkg/hive/hive.go

@@ -45,7 +45,7 @@ var (
 type Service struct {
 	streamer        p2p.Streamer
 	addressBook     addressbook.GetPutter
-	addPeersHandler func(context.Context, ...swarm.Address) error
+	addPeersHandler func(...swarm.Address)
 	networkID       uint64
 	logger          logging.Logger
 	metrics         metrics
@@ -98,7 +98,7 @@ func (s *Service) BroadcastPeers(ctx context.Context, addressee swarm.Address, p
 	return nil
 }
 
-func (s *Service) SetAddPeersHandler(h func(ctx context.Context, addr ...swarm.Address) error) {
+func (s *Service) SetAddPeersHandler(h func(addr ...swarm.Address)) {
 	s.addPeersHandler = h
 }
 
@@ -182,9 +182,7 @@ func (s *Service) peersHandler(ctx context.Context, peer p2p.Peer, stream p2p.St
 	}
 
 	if s.addPeersHandler != nil {
-		if err := s.addPeersHandler(ctx, peers...); err != nil {
-			return err
-		}
+		s.addPeersHandler(peers...)
 	}
 
 	return nil

pkg/node/node.go

@@ -290,7 +290,7 @@ func NewBee(addr string, swarmAddress swarm.Address, publicKey ecdsa.PublicKey,
 		)
 	}
 
-	lightNodes := lightnode.NewContainer()
+	lightNodes := lightnode.NewContainer(swarmAddress)
 
 	txHash, err := getTxHash(stateStore, logger, o)
 	if err != nil {

pkg/p2p/libp2p/libp2p_test.go

@@ -69,7 +69,7 @@ func newService(t *testing.T, networkID uint64, o libp2pServiceOpts) (s *libp2p.
 
 	ctx, cancel := context.WithCancel(context.Background())
 
-	lightnodes := lightnode.NewContainer()
+	lightnodes := lightnode.NewContainer(overlay)
 
 	opts := o.libp2pOpts
 	opts.Transaction = []byte(hexutil.EncodeUint64(o.PrivateKey.Y.Uint64()))

pkg/topology/kademlia/kademlia.go

@@ -125,8 +125,8 @@ func New(
 		saturationFunc:    o.SaturationFunc,
 		bitSuffixLength:   o.BitSuffixLength,
 		commonBinPrefixes: make([][]swarm.Address, int(swarm.MaxBins)),
-		connectedPeers:    pslice.New(int(swarm.MaxBins)),
-		knownPeers:        pslice.New(int(swarm.MaxBins)),
+		connectedPeers:    pslice.New(int(swarm.MaxBins), base),
+		knownPeers:        pslice.New(int(swarm.MaxBins), base),
 		bootnodes:         o.Bootnodes,
 		manageC:           make(chan struct{}, 1),
 		waitNext:          waitnext.New(),
@@ -335,7 +335,7 @@ func (k *Kad) connectionAttemptsHandler(ctx context.Context, wg *sync.WaitGroup,
 		switch {
 		case errors.Is(err, addressbook.ErrNotFound):
 			k.logger.Debugf("kademlia: empty address book entry for peer %q", peer.addr)
-			k.knownPeers.Remove(peer.addr, swarm.Proximity(k.base.Bytes(), peer.addr.Bytes()))
+			k.knownPeers.Remove(peer.addr)
 			return
 		case err != nil:
 			k.logger.Debugf("kademlia: failed to get address book entry for peer %q: %v", peer.addr, err)
@@ -344,7 +344,7 @@ func (k *Kad) connectionAttemptsHandler(ctx context.Context, wg *sync.WaitGroup,
 
 		remove := func(peer *peerConnInfo) {
 			k.waitNext.Remove(peer.addr)
-			k.knownPeers.Remove(peer.addr, peer.po)
+			k.knownPeers.Remove(peer.addr)
 			if err := k.addressBook.Remove(peer.addr); err != nil {
 				k.logger.Debugf("kademlia: could not remove peer %q from addressbook", peer.addr)
 			}
@@ -367,7 +367,7 @@ func (k *Kad) connectionAttemptsHandler(ctx context.Context, wg *sync.WaitGroup,
 
 		k.waitNext.Set(peer.addr, time.Now().Add(shortRetry), 0)
 
-		k.connectedPeers.Add(peer.addr, peer.po)
+		k.connectedPeers.Add(peer.addr)
 
 		k.collector.Record(peer.addr, metrics.PeerLogIn(time.Now(), metrics.PeerConnectionDirectionOutbound))
 
@@ -492,7 +492,8 @@ func (k *Kad) Start(ctx context.Context) error {
 		return fmt.Errorf("addressbook overlays: %w", err)
 	}
 
-	return k.AddPeers(ctx, addresses...)
+	k.AddPeers(addresses...)
+	return nil
 }
 
 func (k *Kad) connectBootnodes(ctx context.Context) {
@@ -672,7 +673,7 @@ func (k *Kad) connect(ctx context.Context, peer swarm.Address, ma ma.Multiaddr)
 
 			if (k.connectedPeers.Length() > 0 && quickPrune) || failedAttempts > maxConnAttempts {
 				k.waitNext.Remove(peer)
-				k.knownPeers.Remove(peer, swarm.Proximity(k.base.Bytes(), peer.Bytes()))
+				k.knownPeers.Remove(peer)
 				if err := k.addressBook.Remove(peer); err != nil {
 					k.logger.Debugf("could not remove peer from addressbook: %q", peer)
 				}
@@ -737,17 +738,9 @@ func (k *Kad) Announce(ctx context.Context, peer swarm.Address) error {
 // AddPeers adds peers to the knownPeers list.
 // This does not guarantee that a connection will immediately
 // be made to the peer.
-func (k *Kad) AddPeers(ctx context.Context, addrs ...swarm.Address) error {
-	for _, addr := range addrs {
-		if k.knownPeers.Exists(addr) {
-			continue
-		}
-
-		po := swarm.Proximity(k.base.Bytes(), addr.Bytes())
-		k.knownPeers.Add(addr, po)
-	}
+func (k *Kad) AddPeers(addrs ...swarm.Address) {
+	k.knownPeers.Add(addrs...)
 	k.notifyManageLoop()
-	return nil
 }
 
 func (k *Kad) Pick(peer p2p.Peer) bool {
@@ -795,10 +788,8 @@ func (k *Kad) connected(ctx context.Context, addr swarm.Address) error {
 		return err
 	}
 
-	po := swarm.Proximity(k.base.Bytes(), addr.Bytes())
-
-	k.knownPeers.Add(addr, po)
-	k.connectedPeers.Add(addr, po)
+	k.knownPeers.Add(addr)
+	k.connectedPeers.Add(addr)
 
 	k.collector.Record(addr, metrics.PeerLogIn(time.Now(), metrics.PeerConnectionDirectionInbound))
 
@@ -818,8 +809,7 @@ func (k *Kad) Disconnected(peer p2p.Peer) {
 
 	k.logger.Debugf("kademlia: disconnected peer %s", peer.Address)
 
-	po := swarm.Proximity(k.base.Bytes(), peer.Address.Bytes())
-	k.connectedPeers.Remove(peer.Address, po)
+	k.connectedPeers.Remove(peer.Address)
 
 	k.waitNext.SetTryAfter(peer.Address, time.Now().Add(timeToRetry))
 

pkg/topology/kademlia/kademlia_test.go

@@ -742,7 +742,7 @@ func TestAddressBookPrune(t *testing.T) {
 	}
 
 	// add non connectable peer, check connection and failed connection counters
-	_ = kad.AddPeers(context.Background(), nonConnPeer.Overlay)
+	kad.AddPeers(nonConnPeer.Overlay)
 	waitCounter(t, &conns, 0)
 	waitCounter(t, &failedConns, 1)
 
@@ -833,7 +833,7 @@ func TestAddressBookQuickPrune(t *testing.T) {
 	waitCounter(t, &failedConns, 0)
 
 	// add non connectable peer, check connection and failed connection counters
-	_ = kad.AddPeers(context.Background(), nonConnPeer.Overlay)
+	kad.AddPeers(nonConnPeer.Overlay)
 	waitCounter(t, &conns, 0)
 	waitCounter(t, &failedConns, 1)
 
@@ -1269,7 +1269,7 @@ func addOne(t *testing.T, signer beeCrypto.Signer, k *kademlia.Kad, ab addressbo
 	if err := ab.Put(peer, *bzzAddr); err != nil {
 		t.Fatal(err)
 	}
-	_ = k.AddPeers(context.Background(), peer)
+	k.AddPeers(peer)
 }
 
 func add(t *testing.T, signer beeCrypto.Signer, k *kademlia.Kad, ab addressbook.Putter, peers []swarm.Address, offset, number int) {

pkg/topology/kademlia/mock/kademlia.go

@@ -60,7 +60,7 @@ func NewMockKademlia(o ...Option) *Mock {
 
 // AddPeers is called when a peers are added to the topology backlog
 // for further processing by connectivity strategy.
-func (m *Mock) AddPeers(ctx context.Context, addr ...swarm.Address) error {
+func (m *Mock) AddPeers(addr ...swarm.Address) {
 	panic("not implemented") // TODO: Implement
 }
 

pkg/topology/lightnode/container.go

@@ -15,27 +15,27 @@ import (
 )
 
 type Container struct {
+	base              swarm.Address
 	connectedPeers    *pslice.PSlice
 	disconnectedPeers *pslice.PSlice
 	peerMu            sync.Mutex
 }
 
-func NewContainer() *Container {
+func NewContainer(base swarm.Address) *Container {
 	return &Container{
-		connectedPeers:    pslice.New(1),
-		disconnectedPeers: pslice.New(1),
+		base:              base,
+		connectedPeers:    pslice.New(1, base),
+		disconnectedPeers: pslice.New(1, base),
 	}
 }
 
-const defaultBin = uint8(0)
-
 func (c *Container) Connected(ctx context.Context, peer p2p.Peer) {
 	c.peerMu.Lock()
 	defer c.peerMu.Unlock()
 
 	addr := peer.Address
-	c.connectedPeers.Add(addr, defaultBin)
-	c.disconnectedPeers.Remove(addr, defaultBin)
+	c.connectedPeers.Add(addr)
+	c.disconnectedPeers.Remove(addr)
 }
 
 func (c *Container) Disconnected(peer p2p.Peer) {
@@ -44,8 +44,8 @@ func (c *Container) Disconnected(peer p2p.Peer) {
 
 	addr := peer.Address
 	if found := c.connectedPeers.Exists(addr); found {
-		c.connectedPeers.Remove(addr, defaultBin)
-		c.disconnectedPeers.Add(addr, defaultBin)
+		c.connectedPeers.Remove(addr)
+		c.disconnectedPeers.Add(addr)
 	}
 }
 

pkg/topology/lightnode/container_test.go

@@ -11,13 +11,17 @@ import (
 
 	"github.com/ethersphere/bee/pkg/p2p"
 	"github.com/ethersphere/bee/pkg/swarm"
+	"github.com/ethersphere/bee/pkg/swarm/test"
 	"github.com/ethersphere/bee/pkg/topology"
 	"github.com/ethersphere/bee/pkg/topology/lightnode"
 )
 
 func TestContainer(t *testing.T) {
+
+	base := test.RandomAddress()
+
 	t.Run("new container is empty container", func(t *testing.T) {
-		c := lightnode.NewContainer()
+		c := lightnode.NewContainer(base)
 
 		var empty topology.BinInfo
 
@@ -27,7 +31,7 @@ func TestContainer(t *testing.T) {
 	})
 
 	t.Run("can add peers to container", func(t *testing.T) {
-		c := lightnode.NewContainer()
+		c := lightnode.NewContainer(base)
 
 		c.Connected(context.Background(), p2p.Peer{Address: swarm.NewAddress([]byte("123"))})
 		c.Connected(context.Background(), p2p.Peer{Address: swarm.NewAddress([]byte("456"))})
@@ -39,7 +43,7 @@ func TestContainer(t *testing.T) {
 		}
 	})
 	t.Run("empty container after peer disconnect", func(t *testing.T) {
-		c := lightnode.NewContainer()
+		c := lightnode.NewContainer(base)
 
 		peer := p2p.Peer{Address: swarm.NewAddress([]byte("123"))}
 

pkg/topology/mock/mock.go

@@ -67,21 +67,16 @@ func NewTopologyDriver(opts ...Option) topology.Driver {
 	return d
 }
 
-func (d *mock) AddPeers(_ context.Context, addrs ...swarm.Address) error {
-	if d.addPeersErr != nil {
-		return d.addPeersErr
-	}
-
+func (d *mock) AddPeers(addrs ...swarm.Address) {
 	d.mtx.Lock()
 	defer d.mtx.Unlock()
 
 	d.peers = append(d.peers, addrs...)
-
-	return nil
 }
 
 func (d *mock) Connected(ctx context.Context, addr swarm.Address) error {
-	return d.AddPeers(ctx, addr)
+	d.AddPeers(addr)
+	return nil
 }
 
 func (d *mock) Disconnected(swarm.Address) {

pkg/topology/pslice/pslice.go

@@ -16,17 +16,19 @@ import (
 // in order to reduce duplicate PO calculation which is normally known and already needed in the
 // calling context.
 type PSlice struct {
-	peers []swarm.Address // the slice of peers
-	bins  []uint          // the indexes of every proximity order in the peers slice, index is po, value is index of peers slice
+	peers     []swarm.Address // the slice of peers
+	bins      []uint          // the indexes of every proximity order in the peers slice, index is po, value is index of peers slice
+	baseBytes []byte
 
 	sync.RWMutex
 }
 
 // New creates a new PSlice.
-func New(maxBins int) *PSlice {
+func New(maxBins int, base swarm.Address) *PSlice {
 	return &PSlice{
-		peers: make([]swarm.Address, 0),
-		bins:  make([]uint, maxBins),
+		peers:     make([]swarm.Address, 0),
+		bins:      make([]uint, maxBins),
+		baseBytes: base.Bytes(),
 	}
 }
 
@@ -165,25 +167,30 @@ func (s *PSlice) exists(addr swarm.Address) (bool, int) {
 }
 
 // Add a peer at a certain PO.
-func (s *PSlice) Add(addr swarm.Address, po uint8) {
+func (s *PSlice) Add(addrs ...swarm.Address) {
 	s.Lock()
 	defer s.Unlock()
 
-	if e, _ := s.exists(addr); e {
-		return
-	}
+	peers, bins := s.copy(len(addrs))
 
-	peers, bins := s.copy(1)
+	for _, addr := range addrs {
 
-	peers = insertAddresses(peers, int(s.bins[po]), addr)
-	s.peers = peers
+		if e, _ := s.exists(addr); e {
+			return
+		}
 
-	incDeeper(bins, po)
-	s.bins = bins
+		po := swarm.Proximity(s.baseBytes, addr.Bytes())
+
+		peers = insertAddresses(peers, int(s.bins[po]), addr)
+		s.peers = peers
+
+		incDeeper(bins, po)
+		s.bins = bins
+	}
 }
 
 // Remove a peer at a certain PO.
-func (s *PSlice) Remove(addr swarm.Address, po uint8) {
+func (s *PSlice) Remove(addr swarm.Address) {
 	s.Lock()
 	defer s.Unlock()
 
@@ -197,7 +204,7 @@ func (s *PSlice) Remove(addr swarm.Address, po uint8) {
 	peers = append(peers[:i], peers[i+1:]...)
 	s.peers = peers
 
-	decDeeper(bins, po)
+	decDeeper(bins, swarm.Proximity(s.baseBytes, addr.Bytes()))
 	s.bins = bins
 }
 

pkg/topology/pslice/pslice_test.go

@@ -17,8 +17,8 @@ import (
 // TestShallowestEmpty tests that ShallowestEmpty functionality works correctly.
 func TestShallowestEmpty(t *testing.T) {
 	var (
-		ps    = pslice.New(16)
 		base  = test.RandomAddress()
+		ps    = pslice.New(16, base)
 		peers = make([][]swarm.Address, 16)
 	)
 
@@ -31,7 +31,7 @@ func TestShallowestEmpty(t *testing.T) {
 
 	for i, v := range peers {
 		for _, vv := range v {
-			ps.Add(vv, uint8(i))
+			ps.Add(vv)
 		}
 		sd, none := ps.ShallowestEmpty()
 		if i == 15 {
@@ -75,15 +75,14 @@ func TestShallowestEmpty(t *testing.T) {
 		},
 	} {
 		for _, v := range peers[tc.removePo] {
-			po := swarm.Proximity(base.Bytes(), v.Bytes())
-			ps.Remove(v, po)
+			ps.Remove(v)
 		}
 		sd, none := ps.ShallowestEmpty()
 		if sd != tc.expectShallowest || none {
 			t.Fatalf("empty bin mismatch got %d want %d", sd, tc.expectShallowest)
 		}
 	}
-	ps.Add(peers[0][0], 0)
+	ps.Add(peers[0][0])
 	if sd, none := ps.ShallowestEmpty(); sd != 1 || none {
 		t.Fatalf("expected bin 1 to be empty shallowest but got %d", sd)
 	}
@@ -92,75 +91,75 @@ func TestShallowestEmpty(t *testing.T) {
 // TestAddRemove checks that the Add, Remove and Exists methods work as expected.
 func TestAddRemove(t *testing.T) {
 	var (
-		ps    = pslice.New(4)
 		base  = test.RandomAddress()
+		ps    = pslice.New(4, base)
 		peers = make([]swarm.Address, 8)
 	)
 
 	// 2 peers per bin
 	// indexes {0,1} {2,3} {4,5} {6,7}
 	for i := 0; i < 8; i += 2 {
-		a := test.RandomAddressAt(base, i)
+		a := test.RandomAddressAt(base, i/2)
 		peers[i] = a
 
-		b := test.RandomAddressAt(base, i)
+		b := test.RandomAddressAt(base, i/2)
 		peers[i+1] = b
 	}
 
 	// add one
-	ps.Add(peers[0], 0)
+	ps.Add(peers[0])
 	chkLen(t, ps, 1)
 	chkExists(t, ps, peers[:1]...)
 	chkNotExists(t, ps, peers[1:]...)
 
 	// check duplicates
-	ps.Add(peers[0], 0)
+	ps.Add(peers[0])
 	chkLen(t, ps, 1)
 	chkBins(t, ps, []uint{0, 1, 1, 1})
 	chkExists(t, ps, peers[:1]...)
 	chkNotExists(t, ps, peers[1:]...)
 
 	// check empty
-	ps.Remove(peers[0], 0)
+	ps.Remove(peers[0])
 	chkLen(t, ps, 0)
 	chkBins(t, ps, []uint{0, 0, 0, 0})
 	chkNotExists(t, ps, peers...)
 
 	// add two in bin 0
-	ps.Add(peers[0], 0)
-	ps.Add(peers[1], 0)
+	ps.Add(peers[0])
+	ps.Add(peers[1])
 	chkLen(t, ps, 2)
 	chkBins(t, ps, []uint{0, 2, 2, 2})
 	chkExists(t, ps, peers[:2]...)
 	chkNotExists(t, ps, peers[2:]...)
 
-	ps.Add(peers[2], 1)
-	ps.Add(peers[3], 1)
+	ps.Add(peers[2])
+	ps.Add(peers[3])
 	chkLen(t, ps, 4)
 	chkBins(t, ps, []uint{0, 2, 4, 4})
 	chkExists(t, ps, peers[:4]...)
 	chkNotExists(t, ps, peers[4:]...)
 
-	ps.Remove(peers[1], 0)
+	ps.Remove(peers[1])
 	chkLen(t, ps, 3)
 	chkBins(t, ps, []uint{0, 1, 3, 3})
 	chkExists(t, ps, peers[0], peers[2], peers[3])
 	chkNotExists(t, ps, append([]swarm.Address{peers[1]}, peers[4:]...)...)
 
 	// this should not move the last cursor
-	ps.Add(peers[7], 3)
+	ps.Add(peers[7])
 	chkLen(t, ps, 4)
 	chkBins(t, ps, []uint{0, 1, 3, 3})
 	chkExists(t, ps, peers[0], peers[2], peers[3], peers[7])
 	chkNotExists(t, ps, append([]swarm.Address{peers[1]}, peers[4:7]...)...)
 
-	ps.Add(peers[5], 2)
+	ps.Add(peers[5])
 	chkLen(t, ps, 5)
 	chkBins(t, ps, []uint{0, 1, 3, 4})
 	chkExists(t, ps, peers[0], peers[2], peers[3], peers[5], peers[7])
 	chkNotExists(t, ps, []swarm.Address{peers[1], peers[4], peers[6]}...)
 
-	ps.Remove(peers[2], 1)
+	ps.Remove(peers[2])
 	chkLen(t, ps, 4)
 	chkBins(t, ps, []uint{0, 1, 2, 3})
 	chkExists(t, ps, peers[0], peers[3], peers[5], peers[7])
@@ -168,8 +167,8 @@ func TestAddRemove(t *testing.T) {
 
 	p := uint8(0)
 	for i := 0; i < 8; i += 2 {
-		ps.Remove(peers[i], p)
-		ps.Remove(peers[i+1], p)
+		ps.Remove(peers[i])
+		ps.Remove(peers[i+1])
 		p++
 	}
 
@@ -182,13 +181,13 @@ func TestAddRemove(t *testing.T) {
 // TestIteratorError checks that error propagation works correctly in the iterators.
 func TestIteratorError(t *testing.T) {
 	var (
-		ps   = pslice.New(4)
 		base = test.RandomAddress()
+		ps   = pslice.New(4, base)
 		a    = test.RandomAddressAt(base, 0)
 		e    = errors.New("err1")
 	)
 
-	ps.Add(a, 0)
+	ps.Add(a)
 
 	f := func(p swarm.Address, _ uint8) (stop, jumpToNext bool, err error) {
 		return false, false, e
@@ -202,9 +201,11 @@ func TestIteratorError(t *testing.T) {
 
 // TestIterators tests that the EachBin and EachBinRev iterators work as expected.
 func TestIterators(t *testing.T) {
-	ps := pslice.New(4)
 
 	base := test.RandomAddress()
+
+	ps := pslice.New(4, base)
+
 	peers := make([]swarm.Address, 4)
 	for i := 0; i < 4; i++ {
 		a := test.RandomAddressAt(base, i)
@@ -214,26 +215,26 @@ func TestIterators(t *testing.T) {
 	testIterator(t, ps, false, false, 0, []swarm.Address{})
 	testIteratorRev(t, ps, false, false, 0, []swarm.Address{})
 
-	for i, v := range peers {
-		ps.Add(v, uint8(i))
+	for _, v := range peers {
+		ps.Add(v)
 	}
 
 	testIterator(t, ps, false, false, 4, []swarm.Address{peers[3], peers[2], peers[1], peers[0]})
 	testIteratorRev(t, ps, false, false, 4, peers)
 
-	ps.Remove(peers[2], 2)
+	ps.Remove(peers[2])
 	testIterator(t, ps, false, false, 3, []swarm.Address{peers[3], peers[1], peers[0]})
 	testIteratorRev(t, ps, false, false, 3, []swarm.Address{peers[0], peers[1], peers[3]})
 
-	ps.Remove(peers[0], 0)
+	ps.Remove(peers[0])
 	testIterator(t, ps, false, false, 2, []swarm.Address{peers[3], peers[1]})
 	testIteratorRev(t, ps, false, false, 2, []swarm.Address{peers[1], peers[3]})
 
-	ps.Remove(peers[3], 3)
+	ps.Remove(peers[3])
 	testIterator(t, ps, false, false, 1, []swarm.Address{peers[1]})
 	testIteratorRev(t, ps, false, false, 1, []swarm.Address{peers[1]})
 
-	ps.Remove(peers[1], 1)
+	ps.Remove(peers[1])
 	testIterator(t, ps, false, false, 0, []swarm.Address{})
 	testIteratorRev(t, ps, false, false, 0, []swarm.Address{})
 }
@@ -264,15 +265,17 @@ func TestBinPeers(t *testing.T) {
 
 		t.Run(tc.label, func(t *testing.T) {
 
+			base := test.RandomAddress()
+
 			binPeers := make([][]swarm.Address, len(tc.peersCount))
 
 			// prepare slice
-			ps := pslice.New(len(tc.peersCount))
+			ps := pslice.New(len(tc.peersCount), base)
 			for bin, peersCount := range tc.peersCount {
 				for i := 0; i < peersCount; i++ {
-					peer := test.RandomAddress()
+					peer := test.RandomAddressAt(base, bin)
 					binPeers[bin] = append(binPeers[bin], peer)
-					ps.Add(peer, uint8(bin))
+					ps.Add(peer)
 				}
 			}
 
@@ -317,16 +320,16 @@ func isEqual(a, b []swarm.Address) bool {
 
 // TestIteratorsJumpStop tests that the EachBin and EachBinRev iterators jump to next bin and stop as expected.
 func TestIteratorsJumpStop(t *testing.T) {
-	ps := pslice.New(4)
-
 	base := test.RandomAddress()
+	ps := pslice.New(4, base)
+
 	peers := make([]swarm.Address, 12)
 	j := 0
 	for i := 0; i < 4; i++ {
 		for ii := 0; ii < 3; ii++ {
 			a := test.RandomAddressAt(base, i)
 			peers[j] = a
-			ps.Add(a, uint8(i))
+			ps.Add(a)
 			j++
 		}
 	}
@@ -382,16 +385,18 @@ func testIterator(t *testing.T, ps *pslice.PSlice, skipNext, stop bool, iteratio
 }
 
 func chkLen(t *testing.T, ps *pslice.PSlice, l int) {
+	t.Helper()
 	if lp := ps.Length(); lp != l {
 		t.Fatalf("length mismatch, want %d got %d", l, lp)
 	}
 }
 
 func chkBins(t *testing.T, ps *pslice.PSlice, seq []uint) {
+	t.Helper()
 	pb := pslice.PSliceBins(ps)
 	for i, v := range seq {
 		if pb[i] != v {
-			t.Fatalf("bin seq wrong, get %d want %d, index %v", pb[i], v, pb)
+			t.Fatalf("bin seq wrong, got %d want %d, index %v", pb[i], v, pb)
 		}
 	}
 }
@@ -416,13 +421,13 @@ func chkNotExists(t *testing.T, ps *pslice.PSlice, addrs ...swarm.Address) {
 
 func BenchmarkAdd(b *testing.B) {
 	var (
-		ps   = pslice.New(16)
 		base = test.RandomAddress()
+		ps   = pslice.New(16, base)
 	)
 
 	for i := 0; i < 16; i++ {
 		for j := 0; j < 300; j++ {
-			ps.Add(test.RandomAddressAt(base, i), uint8(i))
+			ps.Add(test.RandomAddressAt(base, i))
 		}
 	}
 
@@ -430,6 +435,6 @@ func BenchmarkAdd(b *testing.B) {
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
-		ps.Add(test.RandomAddressAt(base, po), po)
+		ps.Add(test.RandomAddressAt(base, po))
 	}
 }

pkg/topology/topology.go

@@ -7,7 +7,6 @@
 package topology
 
 import (
-	"context"
 	"errors"
 	"io"
 	"time"
@@ -34,7 +33,7 @@ type Driver interface {
 
 type PeerAdder interface {
 	// AddPeers is called when peers are added to the topology backlog
-	AddPeers(ctx context.Context, addr ...swarm.Address) error
+	AddPeers(addr ...swarm.Address)
 }
 
 type ClosestPeerer interface {