diff --git a/main.go b/main.go
index e0f12ed..5e40180 100644
--- a/main.go
+++ b/main.go
@@ -35,17 +35,17 @@ func main() {
 	}
 
 	n := os.Getenv("NODES")
-	var nodes []*config.NodeConfig
-	err := json.Unmarshal([]byte(n), &nodes)
+	var nodeConfigs []*config.NodeConfig
+	err := json.Unmarshal([]byte(n), &nodeConfigs)
 	if err != nil {
 		log.Fatalf("failed to unmarshal NODES env: %v", err)
 	}
 
-	if len(nodes) == 0 {
+	if len(nodeConfigs) == 0 {
 		log.Fatalf("need at least one node configured in NODES.")
 	}
 
-	nodesService, err := shared.NewNodesService(nodes)
+	nodesService, err := shared.NewNodesService(nodeConfigs)
 	if err != nil {
 		log.Fatalf("failed to create nodes service: %v", err)
 	}
@@ -90,36 +90,37 @@ func main() {
 	notificationService := notifications.NewNotificationService(notificationsStore)
 
 	var interceptors []interceptor.HtlcInterceptor
+	nodes := nodesService.GetNodes()
 	for _, node := range nodes {
 		var htlcInterceptor interceptor.HtlcInterceptor
-		if node.Lnd != nil {
-			client, err := lnd.NewLndClient(node.Lnd)
+		if node.NodeConfig.Lnd != nil {
+			client, err := lnd.NewLndClient(node.NodeConfig.Lnd)
 			if err != nil {
 				log.Fatalf("failed to initialize LND client: %v", err)
 			}
 
 			client.StartListeners()
 			fwsync := lnd.NewForwardingHistorySync(client, interceptStore, forwardingStore)
-			interceptor := interceptor.NewInterceptor(client, node, interceptStore, feeEstimator, feeStrategy, notificationService)
-			htlcInterceptor, err = lnd.NewLndHtlcInterceptor(node, client, fwsync, interceptor)
+			interceptor := interceptor.NewInterceptor(client, node.NodeConfig, interceptStore, feeEstimator, feeStrategy, notificationService)
+			htlcInterceptor, err = lnd.NewLndHtlcInterceptor(node.NodeConfig, client, fwsync, interceptor)
 			if err != nil {
 				log.Fatalf("failed to initialize LND interceptor: %v", err)
 			}
 		}
 
-		if node.Cln != nil {
-			client, err := cln.NewClnClient(node.Cln.SocketPath)
+		if node.NodeConfig.Cln != nil {
+			client, err := cln.NewClnClient(node.NodeConfig.Cln.SocketPath)
 			if err != nil {
 				log.Fatalf("failed to initialize CLN client: %v", err)
 			}
 
-			interceptor := interceptor.NewInterceptor(client, node, interceptStore, feeEstimator, feeStrategy, notificationService)
-			htlcInterceptor, err = cln.NewClnHtlcInterceptor(node, client, interceptor)
+			interceptor := interceptor.NewInterceptor(client, node.NodeConfig, interceptStore, feeEstimator, feeStrategy, notificationService)
+			htlcInterceptor, err = cln.NewClnHtlcInterceptor(node.NodeConfig, client, interceptor)
 			if err != nil {
 				log.Fatalf("failed to initialize CLN interceptor: %v", err)
 			}
 
-			msgClient := cln.NewCustomMsgClient(node.Cln, client)
+			msgClient := cln.NewCustomMsgClient(node.NodeConfig.Cln, client)
 			go msgClient.Start()
 			msgServer := lsps0.NewServer()
 			protocolServer := lsps0.NewProtocolServer([]uint32{2})
diff --git a/shared/nodes_service.go b/shared/nodes_service.go
index 89edaa1..f6e9061 100644
--- a/shared/nodes_service.go
+++ b/shared/nodes_service.go
@@ -26,9 +26,11 @@ type Node struct {
 
 type NodesService interface {
 	GetNode(token string) (*Node, error)
+	GetNodes() []*Node
 }
 type nodesService struct {
-	nodes map[string]*Node
+	nodes      []*Node
+	nodeLookup map[string]*Node
 }
 
 func NewNodesService(configs []*config.NodeConfig) (NodesService, error) {
@@ -36,7 +38,8 @@ func NewNodesService(configs []*config.NodeConfig) (NodesService, error) {
 		return nil, fmt.Errorf("no nodes supplied")
 	}
 
-	nodes := make(map[string]*Node)
+	nodes := []*Node{}
+	nodeLookup := make(map[string]*Node)
 	for _, config := range configs {
 		pk, err := hex.DecodeString(config.LspdPrivateKey)
 		if err != nil {
@@ -91,28 +94,34 @@ func NewNodesService(configs []*config.NodeConfig) (NodesService, error) {
 			node.NodeConfig.NodePubkey = info.Pubkey
 		}
 
+		nodes = append(nodes, node)
 		for _, token := range config.Tokens {
-			_, exists := nodes[token]
+			_, exists := nodeLookup[token]
 			if exists {
 				return nil, fmt.Errorf("cannot have multiple nodes with the same token")
 			}
 
-			nodes[token] = node
+			nodeLookup[token] = node
 		}
 	}
 
 	return &nodesService{
-		nodes: nodes,
+		nodes:      nodes,
+		nodeLookup: nodeLookup,
 	}, nil
 }
 
 var ErrNodeNotFound = errors.New("node not found")
 
 func (s *nodesService) GetNode(token string) (*Node, error) {
-	node, ok := s.nodes[token]
+	node, ok := s.nodeLookup[token]
 	if !ok {
 		return nil, ErrNodeNotFound
 	}
 
 	return node, nil
 }
+
+func (s *nodesService) GetNodes() []*Node {
+	return s.nodes
+}