review changes

Signed-off-by: Philemon Ukane <ukanephilemon@gmail.com>

dexcore/core.go

@@ -2,19 +2,15 @@ package dexcore
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"sync"
 	"time"
 
 	"decred.org/dcrdex/client/core"
 	"decred.org/dcrdex/dex"
 	libutils "github.com/crypto-power/cryptopower/libwallet/utils"
-	"github.com/jrick/logrotate/rotator"
 )
 
-var dexLogFile = "dexc.log"
-
 type DEXCore struct {
 	*core.Core
 	bondBufMtx      sync.Mutex
@@ -24,26 +20,21 @@ type DEXCore struct {
 
 // New returns a *DEXCore that satisfies Core.
 func New(root, lang string, net libutils.NetworkType, log dex.Logger) (*DEXCore, error) {
+	dexNet, err := parseDEXNet(net)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing network: %w", err)
+	}
+
 	// Use cryptopower's network data directory in core so we don't have to
 	// manage two different network directories for dex db incase we are running
 	// simnet or regnet.
 	dbPath := filepath.Join(root, string(net), "dexc.db")
-	if net == libutils.Simulation || net == libutils.Regression {
-		net = "simnet"
-	}
-
-	dexNet, err := dex.NetFromString(string(net))
-	if err != nil {
-		return nil, fmt.Errorf("dex.NetFromString error: %w", err)
-	}
-
 	cfg := &core.Config{
 		DBPath:             dbPath,
 		Net:                dexNet,
 		Logger:             log,
 		Language:           lang,
-		UnlockCoinsOnLogin: true,
-		NoAutoWalletLock:   false, // TODO: Make configurable.
+		UnlockCoinsOnLogin: false, // TODO: Make configurable.
 	}
 
 	clientCore, err := core.New(cfg)
@@ -54,32 +45,21 @@ func New(root, lang string, net libutils.NetworkType, log dex.Logger) (*DEXCore,
 	return &DEXCore{
 		Core:            clientCore,
 		bondBufferCache: make(map[uint32]valStamp),
-		log:             log.SubLogger("DEXCORE"),
+		log:             log,
 	}, nil
 }
 
-// NewDexLogger initializes a new dex.Logger.
-func NewDexLogger(logDir, lvl string, maxRolls int) (dex.Logger, func(), error) {
-	err := os.MkdirAll(logDir, libutils.UserFilePerm)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create log directory: %w", err)
+func parseDEXNet(net libutils.NetworkType) (dex.Network, error) {
+	switch net {
+	case libutils.Mainnet:
+		return dex.Mainnet, nil
+	case libutils.Testnet:
+		return dex.Testnet, nil
+	case libutils.Regression, libutils.Simulation:
+		return dex.Simnet, nil
+	default:
+		return 0, fmt.Errorf("unknown network %s", net)
 	}
-
-	r, err := rotator.New(filepath.Join(logDir, dexLogFile), 32*1024, false, maxRolls)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create file rotator: %w", err)
-	}
-
-	logCloser := func() {
-		r.Close()
-	}
-
-	l, err := dex.NewLoggerMaker(r, lvl, true /* TODO: Make configurable */)
-	if err != nil {
-		return nil, nil, fmt.Errorf("Failed to initialize log: %w", err)
-	}
-
-	return l.NewLogger("DCRDEX", l.DefaultLevel), logCloser, nil
 }
 
 type valStamp struct {

dexcore/log.go

@@ -0,0 +1,37 @@
+package dexcore
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"decred.org/dcrdex/dex"
+	libutils "github.com/crypto-power/cryptopower/libwallet/utils"
+	"github.com/jrick/logrotate/rotator"
+)
+
+var dexLogFile = "dexc.log"
+
+// NewDexLogger initializes a new dex.Logger.
+func NewDexLogger(logDir, lvl string, maxRolls int) (dex.Logger, func(), error) {
+	err := os.MkdirAll(logDir, libutils.UserFilePerm)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to create log directory: %w", err)
+	}
+
+	r, err := rotator.New(filepath.Join(logDir, dexLogFile), 32*1024, false, maxRolls)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to create file rotator: %w", err)
+	}
+
+	logCloser := func() {
+		r.Close()
+	}
+
+	l, err := dex.NewLoggerMaker(r, lvl, true /* TODO: Make configurable */)
+	if err != nil {
+		return nil, nil, fmt.Errorf("Failed to initialize log: %w", err)
+	}
+
+	return l.NewLogger("DEXC"), logCloser, nil
+}

libwallet/assets_manager.go

@@ -112,14 +112,9 @@ func initializeAssetsFields(rootDir, dbDriver, logDir string, netType utils.Netw
 }
 
 // NewAssetsManager creates a new AssetsManager instance.
-func NewAssetsManager(rootDir, logDir, net string) (*AssetsManager, error) {
+func NewAssetsManager(rootDir, logDir string, netType utils.NetworkType) (*AssetsManager, error) {
 	errors.Separator = ":: "
 
-	netType := utils.ToNetworkType(net)
-	if netType == utils.Unknown {
-		return nil, fmt.Errorf("network type is not supportted: %s", net)
-	}
-
 	// Create a root dir that has the path up the network folder.
 	rootDir = filepath.Join(rootDir, string(netType))
 	if err := os.MkdirAll(rootDir, utils.UserFilePerm); err != nil {

libwallet/utils/config.go

@@ -90,7 +90,7 @@ func (str AssetType) ToFull() string {
 	case LTCWalletAsset:
 		return "Litecoin"
 	default:
-		return string(str)
+		return "Unknown"
 	}
 }
 

log.go

@@ -76,7 +76,7 @@ func (l logWriter) Write(p []byte) (n int, err error) {
 // log file.  This must be performed early during application startup by calling
 // initLogRotator.
 var (
-	// dcrLogger, btcLogger, mainLogger indentifies the respective loggers.
+	// dcrLogger, btcLogger, mainLogger identifies the respective loggers.
 	dcrLogger, btcLogger, mainLogger = "dcr.log", "btc.log", libwallet.LogFilename
 	ltcLogger                        = "ltc.log"
 	// backendLog is the logging backend used to create all subsystem loggers.
@@ -87,8 +87,11 @@ var (
 	ltcBackendLog = btclog.NewBackend(logWriter{ltcLogger})
 	backendLog    = slog.NewBackend(logWriter{mainLogger})
 
-	// logRotator is one of the logging outputs.  It should be closed on
-	// application shutdown.
+	// logRotator is one of the logging outputs.
+	// NOTE: There are concurrency issues with closing the log rotators used by
+	// btcd and btcwallet since they (btcd and btcwallet) have unsupervised
+	// goroutines still running after shutdown. So we leave the rotator running
+	// at the risk of losing some logs.
 	logRotators map[string]*rotator.Rotator
 
 	log          = backendLog.Logger("CRPW")

main.go

@@ -65,9 +65,8 @@ func main() {
 		buildDate = time.Now()
 	}
 
-	net := string(cfg.net)
-	logDir := filepath.Join(cfg.LogDir, net)
-	assetsManager, err := libwallet.NewAssetsManager(cfg.HomeDir, logDir, net)
+	logDir := filepath.Join(cfg.LogDir, string(cfg.net))
+	assetsManager, err := libwallet.NewAssetsManager(cfg.HomeDir, logDir, cfg.net)
 	if err != nil {
 		log.Errorf("init assetsManager error: %v", err)
 		return

ui/page/dcrdex/dcrdex_page.go

@@ -1,12 +1,11 @@
 package dcrdex
 
 import (
-	"context"
-
 	"gioui.org/layout"
 	"github.com/crypto-power/cryptopower/app"
 	"github.com/crypto-power/cryptopower/dexcore"
 	"github.com/crypto-power/cryptopower/libwallet/utils"
+	libutils "github.com/crypto-power/cryptopower/libwallet/utils"
 	"github.com/crypto-power/cryptopower/ui/cryptomaterial"
 	"github.com/crypto-power/cryptopower/ui/load"
 	"github.com/crypto-power/cryptopower/ui/page/components"
@@ -27,25 +26,21 @@ type DEXPage struct {
 	*load.Load
 
 	dexCore Core
+	inited  bool // TODO: Set value
 
-	ctx                context.Context // page context
-	ctxCancel          context.CancelFunc
 	generalSettingsBtn cryptomaterial.Button
-
-	openTradeMainPage *cryptomaterial.Clickable
-	inited            bool // TODO: Set value
+	openTradeMainPage  *cryptomaterial.Clickable
 }
 
 func NewDEXPage(l *load.Load, dexCore Core) *DEXPage {
 	pg := &DEXPage{
-		Load:              l,
-		MasterPage:        app.NewMasterPage(DCRDEXPageID),
-		openTradeMainPage: l.Theme.NewClickable(false),
-		dexCore:           dexCore,
+		Load:               l,
+		MasterPage:         app.NewMasterPage(DCRDEXPageID),
+		openTradeMainPage:  l.Theme.NewClickable(false),
+		dexCore:            dexCore,
+		generalSettingsBtn: l.Theme.Button(values.StringF(values.StrEnableAPI, values.String(values.StrExchange))),
 	}
 
-	pg.generalSettingsBtn = pg.Theme.Button(values.StringF(values.StrEnableAPI, values.String(values.StrExchange)))
-
 	return pg
 }
 
@@ -61,84 +56,57 @@ func (pg *DEXPage) ID() string {
 // displayed.
 // Part of the load.Page interface.
 func (pg *DEXPage) OnNavigatedTo() {
-	pg.ctx, pg.ctxCancel = context.WithCancel(context.TODO())
-
 	if pg.CurrentPage() == nil {
 		// TODO: Handle pg.inited
 		pg.Display(NewDEXOnboarding(pg.Load, pg.dexCore))
+	} else {
+		pg.CurrentPage().OnNavigatedTo()
 	}
-
-	pg.CurrentPage().OnNavigatedTo()
 }
 
 // Layout draws the page UI components into the provided layout context to be
 // eventually drawn on screen.
 // Part of the load.Page interface.
 func (pg *DEXPage) Layout(gtx C) D {
-	noMultipleWalMsg := pg.isMultipleAssetTypeWalletAvailable()
-	dexDisableMsg := pg.dexEnabled()
-	overlay := layout.Stacked(func(gtx C) D { return D{} })
-	c, _ := pg.dexCore.(*dexcore.DEXCore)
-	dexSet := c != nil
-	if noMultipleWalMsg != "" || dexDisableMsg != "" || !dexSet {
-		msg := dexDisableMsg
-		actionBtn := &pg.generalSettingsBtn
-		if msg == "" {
-			msg = noMultipleWalMsg
-			actionBtn = nil
-		}
-		if !dexSet {
-			msg = values.String(values.StrDEXInitErrorMsg)
-			actionBtn = nil
-		}
+	hasMultipleWallets := pg.isMultipleAssetTypeWalletAvailable()
+	privacyModeOff := pg.WL.AssetsManager.IsHTTPAPIPrivacyModeOff(utils.ExchangeHTTPAPI)
+	var msg string
+	var actionBtn *cryptomaterial.Button
+	if !hasMultipleWallets {
+		msg = values.String(values.StrMultipleAssetTypeRequiredToTradeDEX)
+	} else if !privacyModeOff {
+		actionBtn = &pg.generalSettingsBtn
+		msg = values.StringF(values.StrNotAllowed, values.String(values.StrExchange))
+	} else if dexCore, _ := pg.dexCore.(*dexcore.DEXCore); dexCore == nil {
+		msg = values.String(values.StrDEXInitErrorMsg)
+	}
 
+	if msg != "" {
 		gtxCopy := gtx
-		overlay = layout.Stacked(func(gtx C) D {
-			return components.DisablePageWithOverlay(pg.Load, nil, gtxCopy, msg, actionBtn)
-		})
-		// Disable main page from receiving events.
-		gtx = gtx.Disabled()
+		gtx = gtx.Disabled() // Disable main page from receiving events.
+		return components.DisablePageWithOverlay(pg.Load, nil, gtxCopy, msg, actionBtn)
 	}
-	return layout.Stack{}.Layout(gtx,
-		layout.Expanded(func(gtx C) D {
-			return cryptomaterial.LinearLayout{
-				Width:       cryptomaterial.MatchParent,
-				Height:      cryptomaterial.MatchParent,
-				Orientation: layout.Vertical,
-			}.Layout(gtx,
-				layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
-					if !dexSet {
-						return D{}
-					}
-					return pg.CurrentPage().Layout(gtx)
-				}),
-			)
-		}),
-		overlay,
-	)
-}
 
-func (pg *DEXPage) dexEnabled() string {
-	isAllowed := pg.WL.AssetsManager.IsHTTPAPIPrivacyModeOff(utils.ExchangeHTTPAPI)
-	if !isAllowed {
-		return values.StringF(values.StrNotAllowed, values.String(values.StrExchange))
-	}
-	return ""
+	return cryptomaterial.LinearLayout{
+		Width:       cryptomaterial.MatchParent,
+		Height:      cryptomaterial.MatchParent,
+		Orientation: layout.Vertical,
+	}.Layout2(gtx, pg.CurrentPage().Layout)
 }
 
 // isMultipleAssetTypeWalletAvailable checks if multiple asset types are
 // available for dex functionality to run smoothly. Otherwise dex functionality
 // is disable till different asset type wallets are created.
-func (pg *DEXPage) isMultipleAssetTypeWalletAvailable() string {
-	allWallets := len(pg.WL.AssetsManager.AllWallets())
-	btcWallets := len(pg.WL.AssetsManager.AllBTCWallets())
-	dcrWallets := len(pg.WL.AssetsManager.AllDCRWallets())
-	ltcWallets := len(pg.WL.AssetsManager.AllLTCWallets())
-	hasMultipleWallets := (allWallets > btcWallets && btcWallets > 0) || (allWallets > dcrWallets && dcrWallets > 0) || (allWallets > ltcWallets && ltcWallets > 0)
-	if !hasMultipleWallets {
-		return values.String(values.StrMultipleAssetTypeRequiredToTradeDEX) // no wallets exist
+func (pg *DEXPage) isMultipleAssetTypeWalletAvailable() bool {
+	allWallets := pg.WL.AssetsManager.AllWallets()
+	assetTypes := make(map[libutils.AssetType]bool)
+	for _, wallet := range allWallets {
+		assetTypes[wallet.GetAssetType()] = true
+		if len(assetTypes) > 1 {
+			return true
+		}
 	}
-	return ""
+	return false
 }
 
 // HandleUserInteractions is called just before Layout() to determine if any