refactor(logging): migrate commands to core.Print(nil, ...)

Top-level commands (serve, wallet, asset, service) now use core.Print(nil, ...) for package-level logging without Core instance. Chain internals keep log.Printf (pure package, no Core dependency). Co-Authored-By: Charon <charon@lethean.io>
2026-04-02 01:18:37 +01:00 · 2026-04-02 01:18:37 +01:00 · 28e1536d36
commit 28e1536d36
parent 01c9a37902
6 changed files with 42 additions and 48 deletions
--- a/cmd_deploy_itns.go
+++ b/cmd_deploy_itns.go
@ -6,7 +6,6 @@
 package blockchain

 import (
-	"log"

 	"dappco.re/go/core"
 	coreerr "dappco.re/go/core/log"
@ -71,21 +70,21 @@ func runDeployITNS(walletRPC string) error {
 		MetaInfo:     core.Concat(`{"network":"lethean","type":"trust","purpose":"sidechain gateway trust token"}`),
 	}

-	log.Println("Deploying ITNS (IntenseCoin) confidential asset...")
-	log.Printf("  Ticker:     %s", desc.Ticker)
-	log.Printf("  Name:       %s", desc.FullName)
-	log.Printf("  Max supply: %d (1B ITNS)", desc.TotalMax)
-	log.Printf("  Decimals:   %d", desc.DecimalPoint)
+	core.Print(nil, "Deploying ITNS (IntenseCoin) confidential asset...")
+	core.Print(nil, "  Ticker:     %s", desc.Ticker)
+	core.Print(nil, "  Name:       %s", desc.FullName)
+	core.Print(nil, "  Max supply: %d (1B ITNS)", desc.TotalMax)
+	core.Print(nil, "  Decimals:   %d", desc.DecimalPoint)

 	resp, err := client.DeployAsset(desc)
 	if err != nil {
 		return coreerr.E("runDeployITNS", "deploy failed", err)
 	}

-	log.Println("")
-	log.Println("ITNS DEPLOYED!")
-	log.Printf("  Asset ID: %s", resp.AssetID)
-	log.Printf("  TX Hash:  %s", resp.TxID)
+	core.Print(nil, "")
+	core.Print(nil, "ITNS DEPLOYED!")
+	core.Print(nil, "  Asset ID: %s", resp.AssetID)
+	core.Print(nil, "  TX Hash:  %s", resp.TxID)

 	return nil
 }
@ -98,11 +97,11 @@ func runAssetInfo(walletRPC, assetID string) error {
 		return coreerr.E("runAssetInfo", core.Sprintf("asset %s", assetID), err)
 	}

-	log.Printf("Asset: %s (%s)", info.Ticker, info.FullName)
-	log.Printf("  Max supply:     %d", info.TotalMax)
-	log.Printf("  Current supply: %d", info.CurrentSup)
-	log.Printf("  Decimals:       %d", info.DecimalPoint)
-	log.Printf("  Hidden supply:  %v", info.HiddenSupply)
+	core.Print(nil, "Asset: %s (%s)", info.Ticker, info.FullName)
+	core.Print(nil, "  Max supply:     %d", info.TotalMax)
+	core.Print(nil, "  Current supply: %d", info.CurrentSup)
+	core.Print(nil, "  Decimals:       %d", info.DecimalPoint)
+	core.Print(nil, "  Hidden supply:  %v", info.HiddenSupply)

 	return nil
 }
--- a/cmd_serve.go
+++ b/cmd_serve.go
@ -7,7 +7,6 @@ package blockchain

 import (
 	"context"
-	"log"
 	"net/http"
 	"os/signal"
 	"sync"
@ -80,7 +79,7 @@ func runServe(dataDir, seed string, testnet bool, rpcBind, rpcPort string) error
 	// Start JSON-RPC server.
 	srv := daemon.NewServer(c, &cfg)
 	addr := rpcBind + ":" + rpcPort
-	log.Printf("Go daemon RPC on %s (syncing from %s)", addr, seed)
+	core.Print(nil, "Go daemon RPC on %s (syncing from %s)", addr, seed)

 	httpSrv := &http.Server{Addr: addr, Handler: srv}
 	go func() {
@ -126,7 +125,7 @@ func rpcSyncLoop(ctx context.Context, c *chain.Chain, cfg *config.ChainConfig, f
 			if ctx.Err() != nil {
 				return
 			}
-			log.Printf("rpc sync: %v (retrying in 10s)", err)
+			core.Print(nil, "rpc sync: %v (retrying in 10s)", err)
 		}

 		select {
--- a/cmd_sync.go
+++ b/cmd_sync.go
@ -7,7 +7,6 @@ package blockchain

 import (
 	"context"
-	"log"
 	"os/signal"
 	"sync"
 	"syscall"
@ -66,9 +65,9 @@ func runSyncForeground(dataDir, seed string, testnet bool) error {
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()

-	log.Println("Starting headless P2P sync...")
+	core.Print(nil, "Starting headless P2P sync...")
 	syncLoop(ctx, c, &cfg, forks, seed)
-	log.Println("Sync stopped.")
+	core.Print(nil, "Sync stopped.")
 	return nil
 }

@ -107,7 +106,7 @@ func runSyncDaemon(dataDir, seed string, testnet bool) error {
 	defer cancel()

 	d.SetReady(true)
-	log.Println("Sync daemon started.")
+	core.Print(nil, "Sync daemon started.")

 	var wg sync.WaitGroup
 	wg.Add(1)
@ -132,6 +131,6 @@ func stopSyncDaemon(dataDir string) error {
 		return coreerr.E("stopSyncDaemon", core.Sprintf("signal process %d", pid), err)
 	}

-	log.Printf("Sent SIGTERM to sync daemon (PID %d)", pid)
+	core.Print(nil, "Sent SIGTERM to sync daemon (PID %d)", pid)
 	return nil
 }
--- a/cmd_wallet.go
+++ b/cmd_wallet.go
@ -8,7 +8,6 @@ package blockchain
 import (
 	"bytes"
 	"encoding/hex"
-	"log"

 	"dappco.re/go/core"
 	coreerr "dappco.re/go/core/log"
@ -104,10 +103,10 @@ func runWalletCreate(walletFile string) error {
 	addrStr := addr.Encode(0x1eaf7) // iTHN standard prefix
 	seed, _ := account.ToSeed()

-	log.Println("Wallet created!")
-	log.Printf("  Address: %s", addrStr)
-	log.Printf("  Seed:    %s", seed)
-	log.Printf("  File:    %s", walletFile)
+	core.Print(nil, "Wallet created!")
+	core.Print(nil, "  Address: %s", addrStr)
+	core.Print(nil, "  Seed:    %s", seed)
+	core.Print(nil, "  File:    %s", walletFile)

 	return nil
 }
@ -129,7 +128,7 @@ func runWalletAddress(walletFile string) error {
 	}

 	addr := account.Address()
-	log.Printf("%s", addr.Encode(0x1eaf7))
+	core.Print(nil, "%s", addr.Encode(0x1eaf7))
 	return nil
 }

@ -154,7 +153,7 @@ func runWalletSeed(walletFile string) error {
 		return coreerr.E("runWalletSeed", "export seed", err)
 	}

-	log.Printf("%s", seed)
+	core.Print(nil, "%s", seed)
 	return nil
 }

@ -190,7 +189,7 @@ func runWalletScan(walletFile, daemonURL string) error {
 	}

 	addr := account.Address()
-	log.Printf("Scanning for: %s", addr.Encode(0x1eaf7))
+	core.Print(nil, "Scanning for: %s", addr.Encode(0x1eaf7))

 	scanner := wallet.NewV1Scanner(account)
 	client := rpc.NewClient(daemonURL)
@ -240,20 +239,20 @@ func runWalletScan(walletFile, daemonURL string) error {
 				for _, t := range transfers {
 					totalBalance += t.Amount
 					outputCount++
-					log.Printf("  Found output: %d.%012d LTHN at height %d",
+					core.Print(nil, "  Found output: %d.%012d LTHN at height %d",
 						t.Amount/1000000000000, t.Amount%1000000000000, h)
 				}
 			}
 		}

 		if h > 0 && h%1000 == 0 {
-			log.Printf("  Scanned %d/%d blocks... (%d outputs, %d.%012d LTHN)",
+			core.Print(nil, "  Scanned %d/%d blocks... (%d outputs, %d.%012d LTHN)",
 				h, remoteHeight, outputCount,
 				totalBalance/1000000000000, totalBalance%1000000000000)
 		}
 	}

-	log.Printf("Balance: %d.%012d LTHN (%d outputs)",
+	core.Print(nil, "Balance: %d.%012d LTHN (%d outputs)",
 		totalBalance/1000000000000, totalBalance%1000000000000, outputCount)

 	return nil
@ -282,16 +281,16 @@ func runWalletBalance(walletRPC string) error {
 	if err != nil {
 		// The wallet RPC uses same JSON-RPC format but different methods.
 		// Fall back to raw call.
-		log.Printf("Note: wallet RPC does not support getinfo, using getbalance directly")
+		core.Print(nil, "Note: wallet RPC does not support getinfo, using getbalance directly")
 	} else {
 		_ = info
 	}

 	// For now, just report that the command exists. The actual balance
 	// query needs a wallet-specific RPC client (different from daemon RPC).
-	log.Printf("Wallet RPC: %s", walletRPC)
-	log.Printf("Use the C++ wallet for balance queries until Go scanner is optimised")
-	log.Printf("  Go scanner: core-chain wallet scan --daemon http://127.0.0.1:46941")
+	core.Print(nil, "Wallet RPC: %s", walletRPC)
+	core.Print(nil, "Use the C++ wallet for balance queries until Go scanner is optimised")
+	core.Print(nil, "  Go scanner: core-chain wallet scan --daemon http://127.0.0.1:46941")

 	return nil
 }
@ -331,9 +330,9 @@ func runWalletRestore(walletFile, seed string) error {
 	}

 	addr := account.Address()
-	log.Println("Wallet restored!")
-	log.Printf("  Address: %s", addr.Encode(0x1eaf7))
-	log.Printf("  File:    %s", walletFile)
+	core.Print(nil, "Wallet restored!")
+	core.Print(nil, "  Address: %s", addr.Encode(0x1eaf7))
+	core.Print(nil, "  File:    %s", walletFile)

 	return nil
 }
--- a/service.go
+++ b/service.go
@ -7,7 +7,6 @@ package blockchain

 import (
 	"context"
-	"log"
 	"time"
 	"net/http"

@ -98,7 +97,7 @@ func (s *BlockchainService) start() core.Result {
 				if ctx.Err() != nil {
 					return
 				}
-				log.Printf("blockchain sync: %v", err)
+				core.Print(nil, "blockchain sync: %v", err)
 			}
 			select {
 			case <-ctx.Done():
@ -112,11 +111,11 @@ func (s *BlockchainService) start() core.Result {
 	s.daemon = daemon.NewServer(s.chain, &cfg)
 	addr := s.opts.RPCBind + ":" + s.opts.RPCPort
 	go func() {
-		log.Printf("blockchain RPC on %s", addr)
+		core.Print(nil, "blockchain RPC on %s", addr)
 		http.ListenAndServe(addr, s.daemon)
 	}()

-	log.Printf("blockchain service started (testnet=%v, seed=%s)", s.opts.Testnet, s.opts.Seed)
+	core.Print(nil, "blockchain service started (testnet=%v, seed=%s)", s.opts.Testnet, s.opts.Seed)
 	return core.Result{OK: true}
 }

@ -127,7 +126,7 @@ func (s *BlockchainService) stop() core.Result {
 	if s.store != nil {
 		s.store.Close()
 	}
-	log.Printf("blockchain service stopped")
+	core.Print(nil, "blockchain service stopped")
 	return core.Result{OK: true}
 }

--- a/sync_service.go
+++ b/sync_service.go
@ -9,7 +9,6 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/binary"
-	"log"
 	"net"
 	"time"

@ -36,7 +35,7 @@ func syncLoop(ctx context.Context, c *chain.Chain, cfg *config.ChainConfig, fork
 		}

 		if err := syncOnce(ctx, c, cfg, opts, seed); err != nil {
-			log.Printf("sync: %v (retrying in 10s)", err)
+			core.Print(nil, "sync: %v (retrying in 10s)", err)
 			select {
 			case <-ctx.Done():
 				return