Refactor to PayChan, use Mgr() method and unexport manager, ad load ad.

pkg/engine/ads/ads.go

@@ -1,23 +1,31 @@
-package engine
+package ads
 
 import (
 	"github.com/indra-labs/indra/pkg/crypto/nonce"
 	"github.com/indra-labs/indra/pkg/engine/node"
 	"github.com/indra-labs/indra/pkg/onions/adaddress"
+	"github.com/indra-labs/indra/pkg/onions/adload"
 	"github.com/indra-labs/indra/pkg/onions/adpeer"
 	"github.com/indra-labs/indra/pkg/onions/adproto"
 	"github.com/indra-labs/indra/pkg/onions/adservices"
+	log2 "github.com/indra-labs/indra/pkg/proc/log"
 	"github.com/indra-labs/indra/pkg/util/multi"
 	"github.com/multiformats/go-multiaddr"
 	"time"
 )
 
+var (
+	log   = log2.GetLogger()
+	fails = log.E.Chk
+)
+
 const DefaultAdExpiry = time.Hour * 24 * 7 // one week
 
 type NodeAds struct {
 	Peer     adpeer.Ad
 	Address  adaddress.Ad
 	Services adservices.Ad
+	Load     adload.Ad
 }
 
 func GetMultiaddr(n *node.Node) (ma multiaddr.Multiaddr, e error) {
@@ -28,20 +36,19 @@ func GetMultiaddr(n *node.Node) (ma multiaddr.Multiaddr, e error) {
 	return
 }
 
-func GenerateAds(n *node.Node) (na *NodeAds, e error) {
+func GenerateAds(n *node.Node, load byte) (na *NodeAds, e error) {
 	expiry := time.Now().Add(DefaultAdExpiry)
 	var svcs []adservices.Service
 	for i := range n.Services {
 		svcs = append(svcs, adservices.Service{
 			Port:      n.Services[i].Port,
-			RelayRate: uint32(n.Services[i].RelayRate),
+			RelayRate: n.Services[i].RelayRate,
 		})
 	}
 	var ma multiaddr.Multiaddr
-	if ma, e = multi.AddrFromAddrPort(*n.AddrPort); fails(e) {
+	if ma, e = GetMultiaddr(n); fails(e) {
 		return
 	}
-	ma = multi.AddKeyToMultiaddr(ma, n.Identity.Pub)
 	na = &NodeAds{
 		Peer: adpeer.Ad{
 			Ad: adproto.Ad{
@@ -67,6 +74,14 @@ func GenerateAds(n *node.Node) (na *NodeAds, e error) {
 			},
 			Services: svcs,
 		},
+		Load: adload.Ad{
+			Ad: adproto.Ad{
+				ID:     nonce.NewID(),
+				Key:    n.Identity.Pub,
+				Expiry: time.Now().Add(time.Minute * 10),
+			},
+			Load: load,
+		},
 	}
 	return
 }

pkg/engine/eng_senders.go

@@ -29,12 +29,12 @@ func (ng *Engine) SendExit(port uint16, msg slice.Bytes, id nonce.ID,
 	s := make(sessions.Sessions, len(hops))
 	s[2] = bob
 	s[5] = alice
-	se := ng.Manager.SelectHops(hops, s, "exit")
+	se := ng.Mgr().SelectHops(hops, s, "exit")
 	var c sessions.Circuit
 	copy(c[:], se)
 	o := MakeExit(exit.ExitParams{port, msg, id, bob, alice, c, ng.KeySet})
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
 }
 
 func (ng *Engine) SendGetBalance(alice, bob *sessions.Data, hook responses.Callback) {
@@ -42,14 +42,14 @@ func (ng *Engine) SendGetBalance(alice, bob *sessions.Data, hook responses.Callb
 	s := make(sessions.Sessions, len(hops))
 	s[2] = bob
 	s[5] = alice
-	se := ng.Manager.SelectHops(hops, s, "sendgetbalance")
+	se := ng.Mgr().SelectHops(hops, s, "sendgetbalance")
 	var c sessions.Circuit
 	copy(c[:], se)
 	o := MakeGetBalance(getbalance.GetBalanceParams{alice.ID, alice, bob, c,
 		ng.KeySet})
 	log.D.S("sending out getbalance onion", o)
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
 }
 
 func (ng *Engine) SendHiddenService(id nonce.ID, key *crypto.Prv,
@@ -60,18 +60,18 @@ func (ng *Engine) SendHiddenService(id nonce.ID, key *crypto.Prv,
 	hops := sess.StandardCircuit()
 	s := make(sessions.Sessions, len(hops))
 	s[2] = alice
-	se := ng.Manager.SelectHops(hops, s, "sendhiddenservice")
+	se := ng.Mgr().SelectHops(hops, s, "sendhiddenservice")
 	var c sessions.Circuit
 	copy(c[:], se[:len(c)])
 	in = adintro.New(id, key, alice.Node.AddrPort, relayRate, port, expiry)
 	o := MakeHiddenService(in, alice, bob, c, ng.KeySet)
 	log.D.F("%s sending out hidden service onion %s",
-		ng.Manager.GetLocalNodeAddressString(),
+		ng.Mgr().GetLocalNodeAddressString(),
 		color.Yellow.Sprint(alice.Node.AddrPort.String()))
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
 	ng.GetHidden().AddHiddenService(svc, key, in,
-		ng.Manager.GetLocalNodeAddressString())
+		ng.Mgr().GetLocalNodeAddressString())
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
 	return
 }
 
@@ -97,24 +97,24 @@ func (ng *Engine) SendIntroQuery(id nonce.ID, hsk *crypto.Pub,
 	s := make(sessions.Sessions, len(hops))
 	s[2] = bob
 	s[5] = alice
-	se := ng.Manager.SelectHops(hops, s, "sendintroquery")
+	se := ng.Mgr().SelectHops(hops, s, "sendintroquery")
 	var c sessions.Circuit
 	copy(c[:], se)
 	o := MakeIntroQuery(id, hsk, bob, alice, c, ng.KeySet)
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
 	log.D.Ln(res.ID)
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, fn, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, fn, ng.Responses)
 }
 
 func (ng *Engine) SendMessage(mp *message.Message, hook responses.Callback) (id nonce.ID) {
 	// Add another two hops for security against unmasking.
 	preHops := []byte{0, 1}
-	oo := ng.Manager.SelectHops(preHops, mp.Forwards[:], "sendmessage")
+	oo := ng.Mgr().SelectHops(preHops, mp.Forwards[:], "sendmessage")
 	mp.Forwards = [2]*sessions.Data{oo[0], oo[1]}
 	o := []ont.Onion{mp}
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
 	log.D.Ln("sending out message onion")
-	ng.Manager.SendWithOneHook(mp.Forwards[0].Node.AddrPort, res, hook,
+	ng.Mgr().SendWithOneHook(mp.Forwards[0].Node.AddrPort, res, hook,
 		ng.Responses)
 	return res.ID
 }
@@ -123,20 +123,20 @@ func (ng *Engine) SendPing(c sessions.Circuit, hook responses.Callback) {
 	hops := sess.StandardCircuit()
 	s := make(sessions.Sessions, len(hops))
 	copy(s, c[:])
-	se := ng.Manager.SelectHops(hops, s, "sendping")
+	se := ng.Mgr().SelectHops(hops, s, "sendping")
 	copy(c[:], se)
 	id := nonce.NewID()
 	o := Ping(id, se[len(se)-1], c, ng.KeySet)
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
 }
 
 func (ng *Engine) SendRoute(k *crypto.Pub, ap *netip.AddrPort,
 	hook responses.Callback) {
 
-	ng.Manager.FindNodeByAddrPort(ap)
+	ng.Mgr().FindNodeByAddrPort(ap)
 	var ss *sessions.Data
-	ng.Manager.IterateSessions(func(s *sessions.Data) bool {
+	ng.Mgr().IterateSessions(func(s *sessions.Data) bool {
 		if s.Node.AddrPort.String() == ap.String() {
 			ss = s
 			return true
@@ -144,20 +144,20 @@ func (ng *Engine) SendRoute(k *crypto.Pub, ap *netip.AddrPort,
 		return false
 	})
 	if ss == nil {
-		log.E.Ln(ng.Manager.GetLocalNodeAddressString(),
+		log.E.Ln(ng.Mgr().GetLocalNodeAddressString(),
 			"could not find session for address", ap.String())
 		return
 	}
-	log.D.Ln(ng.Manager.GetLocalNodeAddressString(), "sending route",
+	log.D.Ln(ng.Mgr().GetLocalNodeAddressString(), "sending route",
 		k.ToBased32Abbreviated())
 	hops := sess.StandardCircuit()
 	s := make(sessions.Sessions, len(hops))
 	s[2] = ss
-	se := ng.Manager.SelectHops(hops, s, "sendroute")
+	se := ng.Mgr().SelectHops(hops, s, "sendroute")
 	var c sessions.Circuit
 	copy(c[:], se)
 	o := MakeRoute(nonce.NewID(), k, ng.KeySet, se[5], c[2], c)
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
 	log.D.Ln("sending out route request onion")
-	ng.Manager.SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
+	ng.Mgr().SendWithOneHook(c[0].Node.AddrPort, res, hook, ng.Responses)
 }

pkg/engine/eng_sessions.go

@@ -18,7 +18,7 @@ import (
 func (ng *Engine) BuyNewSessions(amount lnwire.MilliSatoshi,
 	fn func()) (e error) {
 	var nodes [5]*node.Node
-	nodes = ng.Manager.SelectUnusedCircuit()
+	nodes = ng.Mgr().SelectUnusedCircuit()
 	for i := range nodes {
 		if nodes[i] == nil {
 			e = fmt.Errorf("failed to find nodes %d", i)
@@ -27,7 +27,7 @@ func (ng *Engine) BuyNewSessions(amount lnwire.MilliSatoshi,
 	}
 	// Get a random return hop session (index 5).
 	var returnSession *sessions.Data
-	returnHops := ng.Manager.GetSessionsAtHop(5)
+	returnHops := ng.Mgr().GetSessionsAtHop(5)
 	if len(returnHops) > 1 {
 		cryptorand.Shuffle(len(returnHops), func(i, j int) {
 			returnHops[i], returnHops[j] = returnHops[j], returnHops[i]
@@ -45,7 +45,7 @@ func (ng *Engine) BuyNewSessions(amount lnwire.MilliSatoshi,
 	var pendingConfirms int
 	for i := range nodes {
 		confirmChans[i] = nodes[i].
-			Chan.Send(amount, s[i].ID, s[i].PreimageHash())
+			PayChan.Send(amount, s[i].ID, s[i].PreimageHash())
 		pendingConfirms++
 	}
 	var success bool
@@ -78,12 +78,12 @@ func (ng *Engine) BuyNewSessions(amount lnwire.MilliSatoshi,
 	}
 	// todo: handle payment failures!
 	o := MakeSession(conf, s, returnSession, nodes[:], ng.KeySet)
-	res := PostAcctOnion(ng.Manager, o)
+	res := PostAcctOnion(ng.Mgr(), o)
-	ng.Manager.SendWithOneHook(nodes[0].AddrPort, res, func(id nonce.ID,
+	ng.Mgr().SendWithOneHook(nodes[0].AddrPort, res, func(id nonce.ID,
 		ifc interface{},
 		b slice.Bytes) (e error) {
-		ng.Manager.Lock()
+		ng.Mgr().Lock()
-		defer ng.Manager.Unlock()
+		defer ng.Mgr().Unlock()
 		var ss [5]*sessions.Data
 		for i := range nodes {
 			log.D.F("confirming and storing session at hop %d %s for %s with"+
@@ -93,9 +93,9 @@ func (ng *Engine) BuyNewSessions(amount lnwire.MilliSatoshi,
 				amount)
 			ss[i] = sessions.NewSessionData(s[i].ID, nodes[i], amount,
 				s[i].Header, s[i].Payload, byte(i))
-			ng.Manager.Add(ss[i])
+			ng.Mgr().Add(ss[i])
-			ng.Manager.Sessions = append(ng.Manager.Sessions, ss[i])
+			ng.Mgr().Sessions = append(ng.manager.Sessions, ss[i])
-			ng.Manager.PendingPayments.Delete(s[i].PreimageHash())
+			ng.Mgr().PendingPayments.Delete(s[i].PreimageHash())
 		}
 		fn()
 		return

pkg/engine/engine.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"github.com/indra-labs/indra/pkg/crypto"
 	"github.com/indra-labs/indra/pkg/crypto/nonce"
+	"github.com/indra-labs/indra/pkg/engine/ads"
 	"github.com/indra-labs/indra/pkg/engine/node"
 	"github.com/indra-labs/indra/pkg/engine/responses"
 	"github.com/indra-labs/indra/pkg/engine/sess"
@@ -33,8 +34,9 @@ type (
 	Engine struct {
 		ctx          context.Context
 		cancel       func()
-		Responses    *responses.Pending
+		Responses *responses.Pending
-		Manager      *sess.Manager
+		manager   *sess.Manager
+		NodeAds   *ads.NodeAds
 		Listener     *transport.Listener
 		PubSub       *pubsub.PubSub
 		topic        *pubsub.Topic
@@ -67,7 +69,7 @@ func (ng *Engine) GetLoad() byte { return byte(ng.Load.Load()) }
 
 func (ng *Engine) HandleMessage(s *splice.Splice, pr ont.Onion) {
 	log.D.F("%s handling received message",
-		ng.Manager.GetLocalNodeAddressString())
+		ng.Mgr().GetLocalNodeAddressString())
 	s.SetCursor(0)
 	s.Segments = s.Segments[:0]
 	on := reg.Recognise(s)
@@ -92,7 +94,7 @@ func (ng *Engine) HandleMessage(s *splice.Splice, pr ont.Onion) {
 
 func (ng *Engine) Handler() (out bool) {
 	log.T.C(func() string {
-		return ng.Manager.GetLocalNodeAddressString() + " awaiting message"
+		return ng.Mgr().GetLocalNodeAddressString() + " awaiting message"
 	})
 	var prev ont.Onion
 	select {
@@ -105,13 +107,13 @@ func (ng *Engine) Handler() (out bool) {
 			log.D.Ln("new connection inbound (TODO):", c.Host.Addrs())
 			_ = c
 		}()
-	case b := <-ng.Manager.ReceiveToLocalNode():
+	case b := <-ng.Mgr().ReceiveToLocalNode():
 		s := splice.Load(b, slice.NewCursor())
 		ng.HandleMessage(s, prev)
-	case p := <-ng.Manager.GetLocalNode().Chan.Receive():
+	case p := <-ng.Mgr().GetLocalNode().PayChan.Receive():
 		log.D.F("incoming payment for %s: %v", p.ID, p.Amount)
 		topUp := false
-		ng.Manager.IterateSessions(func(s *sessions.Data) bool {
+		ng.Mgr().IterateSessions(func(s *sessions.Data) bool {
 			if s.Preimage == p.Preimage {
 				s.IncSats(p.Amount, false, "top-up")
 				topUp = true
@@ -121,7 +123,7 @@ func (ng *Engine) Handler() (out bool) {
 			return false
 		})
 		if !topUp {
-			ng.Manager.AddPendingPayment(p)
+			ng.Mgr().AddPendingPayment(p)
 			log.T.F("awaiting session keys for preimage %s session Keys %s",
 				p.Preimage, p.ID)
 		}
@@ -129,21 +131,21 @@ func (ng *Engine) Handler() (out bool) {
 		// a timeout on the lnd node returning the success to trigger this.
 		p.ConfirmChan <- true
 	case <-ng.Pause:
-		log.D.Ln("pausing", ng.Manager.GetLocalNodeAddressString())
+		log.D.Ln("pausing", ng.Mgr().GetLocalNodeAddressString())
 		// For testing purposes we need to halt this Handler and discard channel
 		// messages.
 	out:
 		for {
 			select {
-			case <-ng.Manager.GetLocalNode().Chan.Receive():
+			case <-ng.Mgr().GetLocalNode().PayChan.Receive():
 				log.D.Ln("discarding payments while in pause")
-			case <-ng.Manager.ReceiveToLocalNode():
+			case <-ng.Mgr().ReceiveToLocalNode():
 				log.D.Ln("discarding messages while in pause")
 			case <-ng.ctx.Done():
 				break out
 			case <-ng.Pause:
 				// This will then resume to the top level select.
-				log.D.Ln("unpausing", ng.Manager.GetLocalNodeAddressString())
+				log.D.Ln("unpausing", ng.Mgr().GetLocalNodeAddressString())
 				break out
 			}
 		}
@@ -153,14 +155,14 @@ func (ng *Engine) Handler() (out bool) {
 
 func (ng *Engine) Keyset() *crypto.KeySet           { return ng.KeySet }
 func (ng *Engine) WaitForShutdown() <-chan struct{} { return ng.ctx.Done() }
-func (ng *Engine) Mgr() *sess.Manager               { return ng.Manager }
+func (ng *Engine) Mgr() *sess.Manager               { return ng.manager }
 func (ng *Engine) Pending() *responses.Pending      { return ng.Responses }
 func (ng *Engine) SetLoad(load byte)                { ng.Load.Store(uint32(load)) }
 
 // Shutdown triggers the shutdown of the client and the Cleanup before
 // finishing.
 func (ng *Engine) Shutdown() {
-	log.T.Ln("shutting down", ng.Manager.GetLocalNodeAddress().String())
+	log.T.Ln("shutting down", ng.Mgr().GetLocalNodeAddress().String())
 	if ng.ShuttingDown.Load() {
 		return
 	}
@@ -184,7 +186,7 @@ func (ng *Engine) Start() {
 }
 
 // New creates a new Engine according to the Params given.
-func New(p Params) (c *Engine, e error) {
+func New(p Params) (ng *Engine, e error) {
 	p.Node.Transport = p.Transport
 	p.Node.Identity = p.Keys
 	var ks *crypto.KeySet
@@ -192,34 +194,40 @@ func New(p Params) (c *Engine, e error) {
 		return
 	}
 	ctx, cancel := context.WithCancel(context.Background())
-	c = &Engine{
+	ng = &Engine{
 		ctx:       ctx,
 		cancel:    cancel,
 		Responses: &responses.Pending{},
 		KeySet:    ks,
 		Listener:  p.Listener,
-		Manager:   sess.NewSessionManager(),
+		manager:   sess.NewSessionManager(),
 		h:         hidden.NewHiddenrouting(),
 		Pause:     qu.T(),
 	}
 	if p.Listener != nil && p.Listener.Host != nil {
-		if c.PubSub, e = pubsub.NewGossipSub(ctx, p.Listener.Host); fails(e) {
+		if ng.PubSub, e = pubsub.NewGossipSub(ctx, p.Listener.Host); fails(e) {
 			cancel()
 			return
 		}
-		if c.topic, e = c.PubSub.Join(PubSubTopic); fails(e) {
+		if ng.topic, e = ng.PubSub.Join(PubSubTopic); fails(e) {
+			cancel()
 			return
 		}
-		if c.sub, e = c.topic.Subscribe(); fails(e) {
+		if ng.sub, e = ng.topic.Subscribe(); fails(e) {
+			cancel()
 			return
 		}
 		log.T.Ln("subscribed to", PubSubTopic, "topic on gossip network")
 	}
-	c.Manager.AddNodes(append([]*node.Node{p.Node}, p.Nodes...)...)
+	if ng.NodeAds, e = ads.GenerateAds(p.Node, 25); fails(e) {
+		cancel()
+		return
+	}
+	ng.Mgr().AddNodes(append([]*node.Node{p.Node}, p.Nodes...)...)
 	// Add return sessions for receiving responses, ideally more of these
 	// will be generated during operation and rotated out over time.
 	for i := 0; i < p.NReturnSessions; i++ {
-		c.Manager.AddSession(sessions.NewSessionData(nonce.NewID(), p.Node, 0,
+		ng.Mgr().AddSession(sessions.NewSessionData(nonce.NewID(), p.Node, 0,
 			nil, nil, 5))
 	}
 	return

pkg/engine/engine_test.go

@@ -35,12 +35,12 @@ func TestClient_SendExit(t *testing.T) {
 		t.FailNow()
 	}
 	client := clients[0]
-	log.D.Ln("client", client.Manager.GetLocalNodeAddressString())
+	log.D.Ln("client", client.Mgr().GetLocalNodeAddressString())
 	// set up forwarding port service
 	const port = 3455
 	sim := transport.NewByteChan(0)
 	for i := range clients {
-		e = clients[i].Manager.AddServiceToLocalNode(&services.Service{
+		e = clients[i].Mgr().AddServiceToLocalNode(&services.Service{
 			Port:      port,
 			Transport: sim,
 			RelayRate: 58000,
@@ -66,7 +66,7 @@ func TestClient_SendExit(t *testing.T) {
 		t.Error("Exit test failed")
 	}()
 out:
-	for i := 3; i < len(clients[0].Manager.Sessions)-1; i++ {
+	for i := 3; i < len(clients[0].Mgr().Sessions)-1; i++ {
 		wg.Add(1)
 		var msg slice.Bytes
 		if msg, _, e = tests.GenMessage(64, "request"); fails(e) {
@@ -80,8 +80,8 @@ out:
 			t.Error(e)
 			t.FailNow()
 		}
-		bob := clients[0].Manager.Sessions[i]
+		bob := clients[0].Mgr().Sessions[i]
-		returnHops := client.Manager.GetSessionsAtHop(5)
+		returnHops := client.Mgr().GetSessionsAtHop(5)
 		var alice *sessions.Data
 		if len(returnHops) > 1 {
 			cryptorand.Shuffle(len(returnHops), func(i, j int) {
@@ -105,7 +105,7 @@ out:
 		})
 		bb := <-clients[3].Mgr().GetLocalNode().ReceiveFrom(port)
 		log.T.S(bb.ToBytes())
-		if e = clients[3].Manager.SendFromLocalNode(port, respMsg); fails(e) {
+		if e = clients[3].Mgr().SendFromLocalNode(port, respMsg); fails(e) {
 			t.Error("fail send")
 		}
 		log.T.Ln("response sent")
@@ -151,11 +151,11 @@ func TestClient_SendPing(t *testing.T) {
 		t.Error("SendPing test failed")
 	}()
 out:
-	for i := 3; i < len(clients[0].Manager.Sessions)-1; i++ {
+	for i := 3; i < len(clients[0].Mgr().Sessions)-1; i++ {
 		wg.Add(1)
 		var c sessions.Circuit
-		sess := clients[0].Manager.Sessions[i]
+		sess := clients[0].Mgr().Sessions[i]
-		c[sess.Hop] = clients[0].Manager.Sessions[i]
+		c[sess.Hop] = clients[0].Mgr().Sessions[i]
 		clients[0].SendPing(c,
 			func(id nonce.ID, ifc interface{}, b slice.Bytes) (e error) {
 				log.D.Ln("success")
@@ -219,8 +219,8 @@ func TestClient_SendSessionKeys(t *testing.T) {
 			counter.Dec()
 		}
 		wg.Wait()
-		for j := range clients[0].Manager.CircuitCache {
+		for j := range clients[0].Mgr().CircuitCache {
-			log.D.F("%d %s %v", i, j, clients[0].Manager.CircuitCache[j])
+			log.D.F("%d %s %v", i, j, clients[0].Mgr().CircuitCache[j])
 		}
 		quit.Q()
 	}

pkg/engine/fail_test.go

@@ -44,7 +44,7 @@ func TestEngine_Message(t *testing.T) {
 		t.FailNow()
 	}
 	client := clients[0]
-	log.D.Ln("client", client.Manager.GetLocalNodeAddressString())
+	log.D.Ln("client", client.Mgr().GetLocalNodeAddressString())
 	// Start up the clients.
 	for _, v := range clients {
 		go v.Start()
@@ -89,9 +89,9 @@ func TestEngine_Message(t *testing.T) {
 	}
 	id := nonce.NewID()
 	_ = id
-	introducerHops := client.Manager.GetSessionsAtHop(2)
+	introducerHops := client.Mgr().GetSessionsAtHop(2)
 	var introducer *sessions.Data
-	returnHops := client.Manager.GetSessionsAtHop(5)
+	returnHops := client.Mgr().GetSessionsAtHop(5)
 	var returner *sessions.Data
 	_ = returner
 	if len(introducerHops) > 1 {
@@ -112,7 +112,7 @@ func TestEngine_Message(t *testing.T) {
 	returner = returnHops[0]
 	log.D.Ln("getting sessions for introducer...")
 	for i := range clients {
-		if introducer.Node.ID == clients[i].Manager.GetLocalNode().ID {
+		if introducer.Node.ID == clients[i].Mgr().GetLocalNode().ID {
 			for j := 0; j < nCircuits; j++ {
 				wg.Add(1)
 				counter.Inc()
@@ -217,7 +217,7 @@ func TestEngine_Route(t *testing.T) {
 		t.FailNow()
 	}
 	client := clients[0]
-	log.W.Ln("client", client.Manager.GetLocalNodeAddressString())
+	log.W.Ln("client", client.Mgr().GetLocalNodeAddressString())
 	// Start up the clients.
 	for _, v := range clients {
 		go v.Start()
@@ -262,9 +262,9 @@ func TestEngine_Route(t *testing.T) {
 	}
 	id := nonce.NewID()
 	_ = id
-	introducerHops := client.Manager.GetSessionsAtHop(2)
+	introducerHops := client.Mgr().GetSessionsAtHop(2)
 	var introducer *sessions.Data
-	returnHops := client.Manager.GetSessionsAtHop(5)
+	returnHops := client.Mgr().GetSessionsAtHop(5)
 	var returner *sessions.Data
 	_ = returner
 	if len(introducerHops) > 1 {
@@ -286,7 +286,7 @@ func TestEngine_Route(t *testing.T) {
 	const localPort = 25234
 	log.D.Ln("getting sessions for introducer...")
 	for i := range clients {
-		if introducer.Node.ID == clients[i].Manager.GetLocalNode().ID {
+		if introducer.Node.ID == clients[i].Mgr().GetLocalNode().ID {
 			for j := 0; j < nCircuits; j++ {
 				wg.Add(1)
 				counter.Inc()
@@ -397,8 +397,8 @@ func TestEngine_SendHiddenService(t *testing.T) {
 		return
 	}
 	id := nonce.NewID()
-	introducerHops := clients[0].Manager.GetSessionsAtHop(2)
+	introducerHops := clients[0].Mgr().GetSessionsAtHop(2)
-	returnHops := clients[0].Manager.GetSessionsAtHop(5)
+	returnHops := clients[0].Mgr().GetSessionsAtHop(5)
 	var introducer *sessions.Data
 	if len(introducerHops) > 1 {
 		cryptorand.Shuffle(len(introducerHops), func(i, j int) {

pkg/engine/mock.go

@@ -60,8 +60,8 @@ func createNMockCircuits(inclSessions bool, nCircuits int,
 		}); fails(e) {
 			return
 		}
-		cl[i].Manager.SetLocalNodeAddress(nodes[i].AddrPort)
+		cl[i].Mgr().SetLocalNodeAddress(nodes[i].AddrPort)
-		cl[i].Manager.SetLocalNode(nodes[i])
+		cl[i].Mgr().SetLocalNode(nodes[i])
 		if inclSessions {
 			// Create a session for all but the first.
 			if i > 0 {
@@ -69,11 +69,11 @@ func createNMockCircuits(inclSessions bool, nCircuits int,
 					1<<16, nil, nil, byte((i-1)/nCircuits))
 				// AddIntro session to node, so it will be able to relay if it
 				// gets a message with the key.
-				cl[i].Manager.AddSession(ss[i-1])
+				cl[i].Mgr().AddSession(ss[i-1])
 				// we need a copy for the node so the balance adjustments don't
 				// double up.
 				s := *ss[i-1]
-				cl[0].Manager.AddSession(&s)
+				cl[0].Mgr().AddSession(&s)
 			}
 		}
 	}
@@ -83,7 +83,7 @@ func createNMockCircuits(inclSessions bool, nCircuits int,
 			if i == j {
 				continue
 			}
-			cl[i].Manager.AddNodes(nodes[j])
+			cl[i].Mgr().AddNodes(nodes[j])
 		}
 	}
 	return

pkg/engine/node/node.go

@@ -31,7 +31,7 @@ type Node struct {
 	Identity  *crypto.Keys
 	RelayRate uint32               // Base relay price mSAT/Mb.
 	Services  services.Services // Services offered by this peer.
-	payments.Chan
+	payments.PayChan
 	Transport tpt.Transport
 }
 
@@ -45,7 +45,7 @@ func NewNode(addr *netip.AddrPort, keys *crypto.Keys, tpt tpt.Transport,
 		AddrPort:  addr,
 		Identity:  keys,
 		RelayRate: relayRate,
-		Chan:      make(payments.Chan, PaymentChanBuffers),
+		PayChan:   make(payments.PayChan, PaymentChanBuffers),
 		Transport: tpt,
 	}
 	return

pkg/engine/payments/payments.go

@@ -11,7 +11,7 @@ func (p PendingPayments) Add(np *Payment) (pp PendingPayments) {
 }
 
 type (
-	Chan    chan *Payment
+	PayChan chan *Payment
 	Payment struct {
 		ID          nonce.ID
 		Preimage    sha256.Hash
@@ -53,11 +53,11 @@ func (p PendingPayments) FindPreimage(pi sha256.Hash) (pp *Payment) {
 	return
 }
 
-// Receive waits on receiving a Payment on a Chan.
+// Receive waits on receiving a Payment on a PayChan.
-func (pc Chan) Receive() <-chan *Payment { return pc }
+func (pc PayChan) Receive() <-chan *Payment { return pc }
 
-// Send a payment on the Chan.
+// Send a payment on the PayChan.
-func (pc Chan) Send(amount lnwire.MilliSatoshi,
+func (pc PayChan) Send(amount lnwire.MilliSatoshi,
 	id nonce.ID, preimage sha256.Hash) (confirmChan chan bool) {
 	confirmChan = make(chan bool)
 	pc <- &Payment{

pkg/engine/peerstore_test.go

@@ -44,7 +44,7 @@ func TestEngine_PeerStore(t *testing.T) {
 	}
 	time.Sleep(time.Second)
 	newAddressAd := adaddress.New(nonce.NewID(),
-		engines[0].Manager.GetLocalNodeIdentityPrv(),
+		engines[0].Mgr().GetLocalNodeIdentityPrv(),
 		engines[0].Listener.Host.Addrs()[0],
 		time.Now().Add(time.Hour*24*7))
 	sa := splice.New(newAddressAd.Len())
@@ -56,8 +56,8 @@ func TestEngine_PeerStore(t *testing.T) {
 	}
 	time.Sleep(time.Second)
 	newIntroAd := adintro.New(nonce.NewID(),
-		engines[0].Manager.GetLocalNodeIdentityPrv(),
+		engines[0].Mgr().GetLocalNodeIdentityPrv(),
-		engines[0].Manager.GetLocalNodeAddress(),
+		engines[0].Mgr().GetLocalNodeAddress(),
 		20000, 443,
 		time.Now().Add(time.Hour*24*7))
 	si := splice.New(newIntroAd.Len())
@@ -69,7 +69,7 @@ func TestEngine_PeerStore(t *testing.T) {
 	}
 	time.Sleep(time.Second)
 	newLoadAd := adload.New(nonce.NewID(),
-		engines[0].Manager.GetLocalNodeIdentityPrv(),
+		engines[0].Mgr().GetLocalNodeIdentityPrv(),
 		17,
 		time.Now().Add(time.Hour*24*7))
 	sl := splice.New(newLoadAd.Len())
@@ -81,7 +81,7 @@ func TestEngine_PeerStore(t *testing.T) {
 	}
 	time.Sleep(time.Second)
 	newPeerAd := adpeer.New(nonce.NewID(),
-		engines[0].Manager.GetLocalNodeIdentityPrv(),
+		engines[0].Mgr().GetLocalNodeIdentityPrv(),
 		20000,
 		time.Now().Add(time.Hour*24*7))
 	log.D.S("peer ad", newPeerAd)
@@ -94,7 +94,7 @@ func TestEngine_PeerStore(t *testing.T) {
 	}
 	time.Sleep(time.Second * 1)
 	newServiceAd := adservices.New(nonce.NewID(),
-		engines[0].Manager.GetLocalNodeIdentityPrv(),
+		engines[0].Mgr().GetLocalNodeIdentityPrv(),
 		[]adservices.Service{{20000, 54321}},
 		time.Now().Add(time.Hour*24*7))
 	ss := splice.New(newServiceAd.Len())

pkg/engine/reply.go

@@ -13,7 +13,7 @@ func MakeReplyHeader(ng *Engine) (returnHeader *hidden.ReplyHeader) {
 	rvKeys := ng.KeySet.Next3()
 	hops := []byte{3, 4, 5}
 	s := make(sessions.Sessions, len(hops))
-	ng.Manager.SelectHops(hops, s, "make message reply header")
+	ng.Mgr().SelectHops(hops, s, "make message reply header")
 	rt := &exit.Routing{
 		Sessions: [3]*sessions.Data{s[0], s[1], s[2]},
 		Keys:     crypto.Privs{rvKeys[0], rvKeys[1], rvKeys[2]},

pkg/engine/sendgetbalance_test.go

@@ -27,7 +27,7 @@ func TestClient_SendGetBalance(t *testing.T) {
 		t.FailNow()
 	}
 	client := clients[0]
-	log.D.Ln("client", client.Manager.GetLocalNodeAddressString())
+	log.D.Ln("client", client.Mgr().GetLocalNodeAddressString())
 	// Start up the clients.
 	for _, v := range clients {
 		go v.Start()
@@ -46,7 +46,7 @@ func TestClient_SendGetBalance(t *testing.T) {
 	}()
  	i := 0
 	wg.Add(1)
-	returnHops := client.Manager.GetSessionsAtHop(5)
+	returnHops := client.Mgr().GetSessionsAtHop(5)
 	var returner *sessions.Data
 	if len(returnHops) > 1 {
 		cryptorand.Shuffle(len(returnHops), func(i, j int) {
@@ -55,7 +55,7 @@ func TestClient_SendGetBalance(t *testing.T) {
 		})
 	}
 	returner = returnHops[0]
-	clients[0].SendGetBalance(returner, clients[0].Manager.Sessions[i],
+	clients[0].SendGetBalance(returner, clients[0].Mgr().Sessions[i],
 		func(cf nonce.ID, ifc interface{}, b slice.Bytes) (e error) {
 			log.I.Ln("success")
 			wg.Done()

pkg/engine/sess/sessionmanager.go

@@ -399,9 +399,9 @@ func (sm *Manager) GetLocalNodeIdentityPrv() (ident *crypto.Prv) {
 	return sm.GetLocalNode().Identity.Prv
 }
 
-// GetLocalNodePaymentChan returns the engine's local Node Chan.
+// GetLocalNodePaymentChan returns the engine's local Node PayChan.
-func (sm *Manager) GetLocalNodePaymentChan() payments.Chan {
+func (sm *Manager) GetLocalNodePaymentChan() payments.PayChan {
-	return sm.nodes[0].Chan
+	return sm.nodes[0].PayChan
 }
 
 // GetLocalNodeRelayRate returns the relay rate for the local node.