diff --git a/cmd/sbc/main.go b/cmd/sbc/main.go
index 4bf18bd..bd9dc88 100644
--- a/cmd/sbc/main.go
+++ b/cmd/sbc/main.go
@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"context"
 	"fmt"
-	"log"
 	"os"
 	"strconv"
 	"strings"
@@ -13,14 +12,29 @@ import (
 	"KitsuneSemCalda/SBC/internal/p2p"
 )
 
+const (
+	ColorReset  = "\033[0m"
+	ColorRed    = "\033[31m"
+	ColorGreen  = "\033[32m"
+	ColorYellow = "\033[33m"
+	ColorBlue   = "\033[34m"
+	ColorPurple = "\033[35m"
+	ColorCyan   = "\033[36m"
+	ColorGray   = "\033[90m"
+)
+
 func main() {
 	bc := blockchain.NewBlockchain()
 	cfg := p2p.DefaultConfig()
 	cfg.ParseFlags()
 
+	// Set log level to Warn by default to keep the UI clean
+	p2p.SetLogLevel(p2p.LevelWarn)
+
 	server, err := p2p.NewServer(cfg, bc)
 	if err != nil {
-		log.Fatalf("failed to create server: %v", err)
+		fmt.Printf("%sError: failed to create server: %v%s\n", ColorRed, err, ColorReset)
+		os.Exit(1)
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -28,7 +42,7 @@ func main() {
 
 	go func() {
 		if err := server.Start(ctx); err != nil {
-			log.Printf("Server error: %v", err)
+			p2p.Error("Server", "Server error: %v", err)
 		}
 	}()
 
@@ -37,19 +51,16 @@ func main() {
 			continue
 		}
 		if err := server.ConnectToPeer(addr); err != nil {
-			log.Printf("Can't connect to peer %s: %v", addr, err)
+			p2p.Warn("P2P", "Can't connect to peer %s: %v", addr, err)
 		}
 	}
 
 	reader := bufio.NewReader(os.Stdin)
 
-	fmt.Println("Simple Blockchain CLI (P2P Enabled)")
-	fmt.Printf("Node ID: %s\n", server.GetHostID())
-	fmt.Printf("Listening on: %s\n", server.GetAddrs())
-	fmt.Println("Commands: add <bpm>, print, validate, length, peers, addr, connect <addr>, sync, discover, find <hash>, help, quit")
+	printHeader(server)
 
 	for {
-		fmt.Print("> ")
+		fmt.Printf("%sSBC %s>%s ", ColorBlue, ColorCyan, ColorReset)
 		input, _ := reader.ReadString('\n')
 		input = strings.TrimSpace(input)
 		if input == "" {
@@ -60,70 +71,77 @@ func main() {
 		args := parts[1:]
 		switch command {
 		case "add":
-			if len(parts) < 2 {
+			if len(args) < 1 {
 				fmt.Println("Usage: add <bpm>")
 				continue
 			}
-			bpm, err := strconv.Atoi(parts[1])
+			bpm, err := strconv.Atoi(args[0])
 			if err != nil {
 				fmt.Println("Error: BPM must be a number")
 				continue
 			}
 			bc.AddBlock(bpm)
-			fmt.Printf("Block added and broadcasting...\n")
+			fmt.Printf("%s[+] Block added and broadcasting...%s\n", ColorGreen, ColorReset)
 		case "print":
-			bc.Print()
+			limit := 10
+			if len(args) > 0 {
+				if l, err := strconv.Atoi(args[0]); err == nil {
+					limit = l
+				}
+			}
+			blocks := bc.GetAllBlocks()
+			start := 0
+			if len(blocks) > limit {
+				start = len(blocks) - limit
+			}
+			fmt.Printf("%s--- Last %d blocks (total: %d) ---%s\n", ColorYellow, len(blocks)-start, len(blocks), ColorReset)
+			for i := start; i < len(blocks); i++ {
+				b := blocks[i]
+				fmt.Printf("%s[%d]%s BPM: %s%d%s Hash: %s%s%s\n", 
+					ColorGray, b.Index, ColorReset, 
+					ColorCyan, b.BPM, ColorReset,
+					ColorYellow, b.Hash[:12], ColorReset)
+			}
 		case "validate":
 			if bc.IsValid() {
-				fmt.Println("Blockchain is valid!")
+				fmt.Printf("%sBlockchain is valid!%s\n", ColorGreen, ColorReset)
 			} else {
-				fmt.Println("Blockchain is INVALID!")
+				fmt.Printf("%sBlockchain is INVALID!%s\n", ColorRed, ColorReset)
 			}
 		case "length":
-			fmt.Printf("Blockchain length: %d\n", bc.Length())
+			fmt.Printf("Blockchain length: %s%d%s\n", ColorCyan, bc.Length(), ColorReset)
 		case "peers":
 			peers := server.GetPeers()
 			if len(peers) == 0 {
 				fmt.Println("No peers connected")
 				continue
 			}
-			fmt.Printf("Connected peers (%d):\n", len(peers))
+			fmt.Printf("%sConnected peers (%d):%s\n", ColorYellow, len(peers), ColorReset)
 			for id, p := range peers {
-				fmt.Printf("  - %s (height: %d)\n", id, p.BestHeight)
+				fmt.Printf("  - %s%s%s (height: %s%d%s)\n", ColorCyan, id.String()[:12], ColorReset, ColorYellow, p.BestHeight, ColorReset)
 			}
 		case "addr":
 			addrs := server.GetAddrs()
 			nodeID := server.GetHostID()
 			fmt.Println("Your full addresses (share these to connect):")
 			for _, addr := range addrs {
-				fmt.Printf("  %s/p2p/%s\n", addr, nodeID)
+				fmt.Printf("  %s%s/p2p/%s%s\n", ColorCyan, addr, nodeID, ColorReset)
 			}
 		case "connect":
 			if len(args) < 1 {
 				fmt.Println("Usage: connect <multiaddr>")
-				fmt.Println("Example: connect /ip4/127.0.0.1/tcp/8333/p2p/Qm...")
 				continue
 			}
 			addr := args[0]
 			if err := server.ConnectToPeer(addr); err != nil {
-				fmt.Printf("Error connecting to peer: %v\n", err)
+				fmt.Printf("%sError connecting to peer: %v%s\n", ColorRed, err, ColorReset)
 			} else {
-				fmt.Printf("Connected to %s\n", addr)
+				fmt.Printf("%sConnected to %s%s\n", ColorGreen, addr, ColorReset)
 			}
 		case "sync":
-			peers := server.GetPeers()
-			if len(peers) == 0 {
-				fmt.Println("No peers connected to sync")
-				continue
-			}
 			fmt.Println("Requesting blocks from peers...")
 			server.RequestSync()
 		case "discover":
-			peers := server.GetPeers()
-			if len(peers) == 0 {
-				fmt.Println("No peers connected to discover more")
-				continue
-			}
 			fmt.Println("Discovering more peers...")
 			server.DiscoverPeers()
 		case "find":
@@ -132,33 +150,57 @@ func main() {
 				continue
 			}
 			hash := args[0]
-			peers := server.GetPeers()
-			if len(peers) == 0 {
-				fmt.Println("No peers connected to search")
-				continue
-			}
 			fmt.Printf("Searching for block: %s\n", hash)
 			server.FindBlock(hash)
+		case "log":
+			if len(args) < 1 {
+				fmt.Println("Usage: log <debug|info|warn|error|none>")
+				continue
+			}
+			level := strings.ToLower(args[0])
+			switch level {
+			case "debug": p2p.SetLogLevel(p2p.LevelDebug)
+			case "info":  p2p.SetLogLevel(p2p.LevelInfo)
+			case "warn":  p2p.SetLogLevel(p2p.LevelWarn)
+			case "error": p2p.SetLogLevel(p2p.LevelError)
+			case "none":  p2p.SetLogLevel(p2p.LevelNone)
+			default: fmt.Println("Unknown level. Use: debug, info, warn, error, none")
+			}
+			fmt.Printf("Log level set to: %s\n", level)
 		case "help":
-			fmt.Println("Available commands:")
-			fmt.Println("  add <bpm>       - Add a new block with given BPM")
-			fmt.Println("  print           - Print all blocks in the blockchain")
-			fmt.Println("  validate        - Validate blockchain integrity")
-			fmt.Println("  length          - Show blockchain length")
-			fmt.Println("  peers           - Show connected peers")
-			fmt.Println("  addr            - Show your full addresses to share")
-			fmt.Println("  connect <addr>  - Connect to a peer via multiaddr (use 'addr' on other node)")
-			fmt.Println("  sync            - Request blocks from connected peers")
-			fmt.Println("  discover        - Discover more peers from connected peers")
-			fmt.Println("  find <hash>     - Find a block by hash in the network")
-			fmt.Println("  help            - Show this help message")
-			fmt.Println("  quit            - Exit the program")
+			printHelp()
 		case "quit", "exit":
 			fmt.Println("Goodbye!")
 			return
 		default:
-			fmt.Printf("Unknown command: %s\n", command)
-			fmt.Println("Available commands: add, print, validate, length, peers, addr, connect, sync, discover, find, help, quit")
+			fmt.Printf("Unknown command: %s. Type 'help' for commands.\n", command)
 		}
 	}
 }
+
+func printHeader(server *p2p.Server) {
+	fmt.Printf("%s----------------------------------------%s\n", ColorBlue, ColorReset)
+	fmt.Printf("%s  Simple Blockchain CLI (P2P Enabled)%s\n", ColorCyan, ColorReset)
+	fmt.Printf("%s----------------------------------------%s\n", ColorBlue, ColorReset)
+	fmt.Printf("Node ID: %s%s%s\n", ColorYellow, server.GetHostID(), ColorReset)
+	fmt.Printf("Listening on: %s%v%s\n", ColorYellow, server.GetAddrs(), ColorReset)
+	fmt.Printf("Type %s'help'%s for a list of commands.\n", ColorGreen, ColorReset)
+	fmt.Println()
+}
+
+func printHelp() {
+	fmt.Println("Available commands:")
+	fmt.Printf("  %sadd <bpm>%s       - Add a new block with given BPM\n", ColorCyan, ColorReset)
+	fmt.Printf("  %sprint [n]%s       - Print last n blocks (default 10)\n", ColorCyan, ColorReset)
+	fmt.Printf("  %svalidate%s        - Validate blockchain integrity\n", ColorCyan, ColorReset)
+	fmt.Printf("  %slength%s          - Show blockchain length\n", ColorCyan, ColorReset)
+	fmt.Printf("  %speers%s           - Show connected peers\n", ColorCyan, ColorReset)
+	fmt.Printf("  %saddr%s             - Show your full addresses to share\n", ColorCyan, ColorReset)
+	fmt.Printf("  %sconnect <addr>%s  - Connect to a peer via multiaddr\n", ColorCyan, ColorReset)
+	fmt.Printf("  %ssync%s             - Request blocks from connected peers\n", ColorCyan, ColorReset)
+	fmt.Printf("  %sdiscover%s         - Discover more peers\n", ColorCyan, ColorReset)
+	fmt.Printf("  %sfind <hash>%s      - Find a block by hash\n", ColorCyan, ColorReset)
+	fmt.Printf("  %slog <level>%s      - Set log level (debug, info, warn, error, none)\n", ColorCyan, ColorReset)
+	fmt.Printf("  %shelp%s             - Show this help message\n", ColorCyan, ColorReset)
+	fmt.Printf("  %squit%s             - Exit the program\n", ColorCyan, ColorReset)
+}
diff --git a/cmd/sbcd/main.go b/cmd/sbcd/main.go
index cf9224a..51048a1 100644
--- a/cmd/sbcd/main.go
+++ b/cmd/sbcd/main.go
@@ -3,8 +3,6 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"fmt"
-	"log/slog"
 	"os"
 	"os/signal"
 	"syscall"
@@ -31,15 +29,15 @@ func min(a, b int) int {
 }
 
 func (c *DaemonCallbacks) OnNewPeer(id peer.ID) {
-	logger.Info("new peer connected", "peer", id.String()[:min(16, len(id.String()))])
+	p2p.Info("SBCD", "new peer connected: %s", id.String()[:min(16, len(id.String()))])
 }
 
 func (c *DaemonCallbacks) OnDisconnect(id peer.ID) {
-	logger.Warn("peer disconnected", "peer", id.String()[:min(16, len(id.String()))])
+	p2p.Warn("SBCD", "peer disconnected: %s", id.String()[:min(16, len(id.String()))])
 }
 
 func (c *DaemonCallbacks) OnPeerFound(info peer.AddrInfo) {
-	logger.Debug("peer found via discovery", "peer", info.ID.String()[:min(16, len(info.ID.String()))])
+	p2p.Debug("SBCD", "peer found via discovery: %s", info.ID.String()[:min(16, len(info.ID.String()))])
 }
 
 func (c *DaemonCallbacks) OnBlockReceived(block *blockchain.Block) {
@@ -90,8 +88,9 @@ func (h *ColoredHandler) Handle(ctx context.Context, r slog.Record) error {
 }
 
 func main() {
-	initLogger()
-	logger.Info("starting sbc daemon")
+	// Daemon defaults to Info level
+	p2p.SetLogLevel(p2p.LevelInfo)
+	p2p.Info("SBCD", "starting sbc daemon")
 
 	bc := blockchain.NewBlockchain()
 	cfg := p2p.DefaultConfig()
@@ -101,20 +100,20 @@ func main() {
 
 	store, err := storage.NewStore(cfg.DataDir)
 	if err != nil {
-		logger.Error("failed to open database", "error", err)
+		p2p.Error("SBCD", "failed to open database: %v", err)
 		os.Exit(1)
 	}
 	defer store.Close()
 
 	err = store.Load(bc)
 	if err != nil {
-		logger.Error("failed to load blockchain from store", "error", err)
+		p2p.Error("SBCD", "failed to load blockchain from store: %v", err)
 		os.Exit(1)
 	}
 
 	server, err := p2p.NewServer(cfg, bc)
 	if err != nil {
-		logger.Error("failed to create server", "error", err)
+		p2p.Error("SBCD", "failed to create server: %v", err)
 		os.Exit(1)
 	}
 
@@ -128,7 +127,7 @@ func main() {
 		}
 		err = server.ConnectToPeer(addr)
 		if err != nil {
-			logger.Warn("can't connect to bootnode", "address", addr, "error", err)
+			p2p.Warn("SBCD", "can't connect to bootnode %s: %v", addr, err)
 		}
 	}
 
@@ -144,17 +143,15 @@ func main() {
 		<-stop
 		err := store.Save(bc)
 		if err != nil {
-			logger.Error("failed to save blockchain", "error", err)
+			p2p.Error("SBCD", "failed to save blockchain: %v", err)
 		} else {
-			logger.Info("blockchain saved successfully")
+			p2p.Info("SBCD", "blockchain saved successfully")
 		}
 		cancel()
 	}()
 
-	logger.Info("daemon initialized",
-		"peer_id", server.GetHostID(),
-		"listening", server.GetAddrs(),
-		"height", bc.Length())
+	p2p.Info("SBCD", "daemon initialized: peer_id=%s listening=%v height=%d",
+		server.GetHostID(), server.GetAddrs(), bc.Length())
 
 	announceData := map[string]string{
 		"peer_id": server.GetHostID(),
@@ -166,6 +163,6 @@ func main() {
 
 	err = server.Start(ctx)
 	if err != nil {
-		logger.Error("server error", "error", err)
+		p2p.Error("SBCD", "server error: %v", err)
 	}
 }
diff --git a/cmd/seed/main.go b/cmd/seed/main.go
index bb445f2..04b4b94 100644
--- a/cmd/seed/main.go
+++ b/cmd/seed/main.go
@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"log"
 	"net/http"
 	"os"
 	"os/signal"
@@ -35,20 +34,26 @@ func main() {
 	cfg := p2p.DefaultConfig()
 	cfg.ParseFlags()
 
+	// Seed server usually wants to see what's happening
+	p2p.SetLogLevel(p2p.LevelInfo)
+
 	store, err := storage.NewStore(cfg.DataDir)
 	if err != nil {
-		log.Fatalf("failed to open database: %v", err)
+		p2p.Error("SEED", "failed to open database: %v", err)
+		os.Exit(1)
 	}
 	defer store.Close()
 
 	err = store.Load(bc)
 	if err != nil {
-		log.Fatalf("failed to load blockchain from store: %v", err)
+		p2p.Error("SEED", "failed to load blockchain from store: %v", err)
+		os.Exit(1)
 	}
 
 	server, err := p2p.NewServer(cfg, bc)
 	if err != nil {
-		log.Fatalf("failed to create server: %v", err)
+		p2p.Error("SEED", "failed to create server: %v", err)
+		os.Exit(1)
 	}
 
 	seed := &SeedServer{
@@ -79,12 +84,12 @@ func main() {
 		addr = ":" + env
 	}
 
-	log.Printf("Seed server starting on http://localhost%s", addr)
-	log.Printf("Seed endpoint: http://localhost%s/seeds", addr)
+	p2p.Info("SEED", "Seed server starting on http://localhost%s", addr)
+	p2p.Info("SEED", "Seed endpoint: http://localhost%s/seeds", addr)
 
 	go func() {
 		if err := http.ListenAndServe(addr, nil); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("seed server error: %v", err)
+			p2p.Error("SEED", "seed server error: %v", err)
 		}
 	}()
 
@@ -94,7 +99,7 @@ func main() {
 		}
 		err = server.ConnectToPeer(bootAddr)
 		if err != nil {
-			log.Printf("Can't connect to bootnode %s: %v", bootAddr, err)
+			p2p.Warn("SEED", "Can't connect to bootnode %s: %v", bootAddr, err)
 		}
 	}
 
@@ -108,15 +113,15 @@ func main() {
 		<-stop
 		err := store.Save(bc)
 		if err != nil {
-			log.Printf("failed to save blockchain: %v", err)
+			p2p.Error("SEED", "failed to save blockchain: %v", err)
 		} else {
-			log.Println("blockchain saved successfully")
+			p2p.Info("SEED", "blockchain saved successfully")
 		}
 		cancel()
 	}()
 
-	log.Printf("Daemon Node ID: %s", server.GetHostID())
-	log.Printf("Listening on: %s", server.GetAddrs())
+	p2p.Info("SEED", "Daemon Node ID: %s", server.GetHostID())
+	p2p.Info("SEED", "Listening on: %s", server.GetAddrs())
 
 	server.Start(ctx)
 }
@@ -161,9 +166,9 @@ func (s *SeedServer) handleSeeds(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if len(peers) == 0 {
-		log.Printf("[SEED] No peers available")
+		p2p.Debug("SEED", "No peers available")
 	} else {
-		log.Printf("[SEED] Serving %d peers", len(peers))
+		p2p.Debug("SEED", "Serving %d peers", len(peers))
 	}
 
 	json.NewEncoder(w).Encode(SeedResponse{Peers: peers})
diff --git a/internal/p2p/server.go b/internal/p2p/server.go
index b0884d3..10ce62c 100644
--- a/internal/p2p/server.go
+++ b/internal/p2p/server.go
@@ -4,10 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"net"
 	"net/http"
 	"os"
+	"log"
 	"strings"
 	"sync"
 	"time"
@@ -153,14 +153,14 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgVersion:
 		var payload VersionPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling version: %v", err)
+			Warn("P2P", "Error unmarshaling version: %v", err)
 			return
 		}
 		p.BestHeight = payload.BestHeight
 		verAck, _ := NewMessage(MsgVerAck, VerAckPayload{Accept: true})
 		p.SendMessage(verAck)
 	case MsgVerAck:
-		log.Printf("Handshake completo com peer: %s", p.ID)
+		Info("P2P", "Handshake completo com peer: %s", p.ID)
 		if p.BestHeight > s.blockchain.Length() {
 			s.sendGetBlocks(p)
 		}
@@ -199,7 +199,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgGetBlocks:
 		var payload GetBlocksPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling getblocks: %v", err)
+			Warn("P2P", "Error unmarshaling getblocks: %v", err)
 			return
 		}
 
@@ -216,7 +216,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgInv:
 		var payload InvPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling inv: %v", err)
+			Warn("P2P", "Error unmarshaling inv: %v", err)
 			return
 		}
 
@@ -239,7 +239,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgGetData:
 		var payload InvPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling getdata: %v", err)
+			Warn("P2P", "Error unmarshaling getdata: %v", err)
 			return
 		}
 
@@ -271,7 +271,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgPeers:
 		var payload PeersPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling peers: %v", err)
+			Warn("P2P", "Error unmarshaling peers: %v", err)
 			return
 		}
 		for _, addr := range payload.Peers {
@@ -299,7 +299,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgFindBlock:
 		var payload FindBlockPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling findblock: %v", err)
+			Warn("P2P", "Error unmarshaling findblock: %v", err)
 			return
 		}
 		block := s.blockchain.GetBlockByHash(payload.Hash)
@@ -320,7 +320,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 	case MsgBlockFound:
 		var payload BlockFoundPayload
 		if err := json.Unmarshal(msg.Payload, &payload); err != nil {
-			log.Printf("Error unmarshaling blockfound: %v", err)
+			Warn("P2P", "Error unmarshaling blockfound: %v", err)
 			return
 		}
 		if payload.Found && payload.Block != nil {
@@ -332,7 +332,7 @@ func (s *Server) handleMessage(p *Peer, msg *Message) {
 				PrevHash:  payload.Block.PrevHash,
 			}
 			s.blockchain.ProcessBlock(block)
-			log.Printf("[FIND] Block #%d found!", block.Index)
+			Info("P2P", "[FIND] Block #%d found!", block.Index)
 		}
 	}
 }
@@ -415,12 +415,12 @@ func (s *Server) HandlePeerFound(pi peer.AddrInfo) {
 	defer cancel()
 
 	if err := s.host.ConnectPeer(ctx, pi); err != nil {
-		fmt.Printf("[P2P] Failed to connect to %s: %v\n", pi.ID, err)
+		Warn("P2P", "Failed to connect to %s: %v", pi.ID, err)
 		return
 	}
 	stream, err := s.host.NewStream(ctx, pi.ID)
 	if err != nil {
-		fmt.Printf("[P2P] Failed to open stream to %s: %v\n", pi.ID, err)
+		Warn("P2P", "Failed to open stream to %s: %v", pi.ID, err)
 		return
 	}
 	s.handleStream(stream)
@@ -553,17 +553,17 @@ func (s *Server) connectToBootNodes() {
 			continue
 		}
 
-		fmt.Printf("[BOOT] Trying to connect to bootnode: %s\n", addr)
+		Info("BOOT", "Trying to connect to bootnode: %s", addr)
 
 		ma, err := multiaddr.NewMultiaddr(addr)
 		if err != nil {
-			fmt.Printf("[BOOT] Invalid multiaddr %s: %v\n", addr, err)
+			Warn("BOOT", "Invalid multiaddr %s: %v", addr, err)
 			continue
 		}
 
 		ctx := context.Background()
 		if err := s.host.Connect(ctx, ma); err != nil {
-			fmt.Printf("[BOOT] Could not connect to %s: %v\n", addr, err)
+			Warn("BOOT", "Could not connect to %s: %v", addr, err)
 			continue
 		}
 
@@ -574,12 +574,12 @@ func (s *Server) connectToBootNodes() {
 
 		stream, err := s.host.NewStream(ctx, pi.ID)
 		if err != nil {
-			fmt.Printf("[BOOT] Could not open stream to %s: %v\n", addr, err)
+			Warn("BOOT", "Could not open stream to %s: %v", addr, err)
 			continue
 		}
 
 		s.handleStream(stream)
-		fmt.Printf("[BOOT] Connected to bootnode: %s\n", addr)
+		Info("BOOT", "Connected to bootnode: %s", addr)
 	}
 }
 
@@ -590,7 +590,7 @@ func (s *Server) periodicPeerDiscovery() {
 	for {
 		<-ticker.C
 		if len(s.peers) > 0 {
-			fmt.Printf("[DISCOVERY] Periodic peer discovery (connected peers: %d)\n", len(s.peers))
+			Info("DISCOVERY", "Periodic peer discovery (connected peers: %d)", len(s.peers))
 			s.DiscoverPeers()
 		}
 	}
@@ -627,7 +627,7 @@ func (s *Server) tryLocalDiscovery() {
 				pi, _ := peer.AddrInfoFromP2pAddr(ma)
 				if stream, err := s.host.NewStream(ctx, pi.ID); err == nil {
 					s.handleStream(stream)
-					fmt.Printf("[AUTO] Connected to local daemon: %s\n", daemonAddr)
+					Info("AUTO", "Connected to local daemon: %s", daemonAddr)
 					return
 				}
 			}
@@ -656,11 +656,11 @@ func (s *Server) resolveDNSSeeds(dnsSeed string) {
 			continue
 		}
 
-		fmt.Printf("[DNS] Resolving seed: %s\n", seed)
+		Info("DNS", "Resolving seed: %s", seed)
 
 		ips, err := net.LookupIP(seed)
 		if err != nil {
-			fmt.Printf("[DNS] Failed to resolve %s: %v\n", seed, err)
+			Warn("DNS", "Failed to resolve %s: %v", seed, err)
 			continue
 		}
 
@@ -673,19 +673,19 @@ func (s *Server) resolveDNSSeeds(dnsSeed string) {
 
 			ctx := context.Background()
 			if err := s.host.Connect(ctx, ma); err != nil {
-				fmt.Printf("[DNS] Could not connect to %s: %v\n", addr, err)
+				Warn("DNS", "Could not connect to %s: %v", addr, err)
 				continue
 			}
 
 			pi, _ := peer.AddrInfoFromP2pAddr(ma)
 			stream, err := s.host.NewStream(ctx, pi.ID)
 			if err != nil {
-				fmt.Printf("[DNS] Could not open stream to %s: %v\n", addr, err)
+				Warn("DNS", "Could not open stream to %s: %v", addr, err)
 				continue
 			}
 
 			s.handleStream(stream)
-			fmt.Printf("[DNS] Connected to bootstrap node: %s\n", addr)
+			Info("DNS", "Connected to bootstrap node: %s", addr)
 			return
 		}
 	}
@@ -694,7 +694,7 @@ func (s *Server) resolveDNSSeeds(dnsSeed string) {
 func (s *Server) fetchSeedsFromHTTP(seedURL string) {
 	resp, err := http.Get(seedURL)
 	if err != nil {
-		fmt.Printf("[HTTP SEED] Failed to fetch %s: %v\n", seedURL, err)
+		Warn("HTTP SEED", "Failed to fetch %s: %v", seedURL, err)
 		return
 	}
 	defer resp.Body.Close()
@@ -706,16 +706,16 @@ func (s *Server) fetchSeedsFromHTTP(seedURL string) {
 	}
 
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		fmt.Printf("[HTTP SEED] Failed to decode response: %v\n", err)
+		Warn("HTTP SEED", "Failed to decode response: %v", err)
 		return
 	}
 
 	if len(result.Peers) == 0 {
-		fmt.Printf("[HTTP SEED] No peers found at %s\n", seedURL)
+		Info("HTTP SEED", "No peers found at %s", seedURL)
 		return
 	}
 
-	fmt.Printf("[HTTP SEED] Found %d peers from %s\n", len(result.Peers), seedURL)
+	Info("HTTP SEED", "Found %d peers from %s", len(result.Peers), seedURL)
 
 	for _, p := range result.Peers {
 		if p.Addr == "" {
@@ -739,7 +739,7 @@ func (s *Server) fetchSeedsFromHTTP(seedURL string) {
 		}
 
 		s.handleStream(stream)
-		fmt.Printf("[HTTP SEED] Connected to peer: %s\n", p.Addr)
+		Info("HTTP SEED", "Connected to peer: %s", p.Addr)
 		return
 	}
 }