move client/asset/dcr package-level chainParams to field

client/asset/dcr/config.go

@@ -23,7 +23,6 @@ const (
 var (
 	// A global *chaincfg.Params will be set if loadConfig completes without
 	// error.
-	chainParams       *chaincfg.Params
 	dcrwHomeDir       = dcrutil.AppDataDir("dcrwallet", false)
 	defaultRPCCert    = filepath.Join(dcrwHomeDir, "rpc.cert")
 	defaultConfigPath = filepath.Join(dcrwHomeDir, "dcrwallet.conf")
@@ -49,10 +48,10 @@ type Config struct {
 // RPCListen or RPCCert in the specified file, default values will be used. If
 // there is no error, the module-level chainParams variable will be set
 // appropriately for the network.
-func loadConfig(settings map[string]string, network dex.Network) (*Config, error) {
+func loadConfig(settings map[string]string, network dex.Network) (*Config, *chaincfg.Params, error) {
 	cfg := new(Config)
 	if err := config.Unmapify(settings, cfg); err != nil {
-		return nil, fmt.Errorf("error parsing config: %w", err)
+		return nil, nil, fmt.Errorf("error parsing config: %w", err)
 	}
 
 	missing := ""
@@ -63,12 +62,13 @@ func loadConfig(settings map[string]string, network dex.Network) (*Config, error
 		missing += " password"
 	}
 	if missing != "" {
-		return nil, fmt.Errorf("missing dcrwallet rpc credentials:%s", missing)
+		return nil, nil, fmt.Errorf("missing dcrwallet rpc credentials:%s", missing)
 	}
 
 	// Get network settings. Zero value is mainnet, but unknown non-zero cfg.Net
 	// is an error.
 	var defaultServer string
+	var chainParams *chaincfg.Params
 	switch network {
 	case dex.Simnet:
 		chainParams = chaincfg.SimNetParams()
@@ -80,7 +80,7 @@ func loadConfig(settings map[string]string, network dex.Network) (*Config, error
 		chainParams = chaincfg.MainNetParams()
 		defaultServer = defaultMainnet
 	default:
-		return nil, fmt.Errorf("unknown network ID: %d", uint8(network))
+		return nil, nil, fmt.Errorf("unknown network ID: %d", uint8(network))
 	}
 	if cfg.RPCListen == "" {
 		cfg.RPCListen = defaultServer
@@ -89,5 +89,5 @@ func loadConfig(settings map[string]string, network dex.Network) (*Config, error
 		cfg.RPCCert = defaultRPCCert
 	}
 
-	return cfg, nil
+	return cfg, chainParams, nil
 }

client/asset/dcr/dcr.go

@@ -29,6 +29,7 @@ import (
 	"decred.org/dcrwallet/rpc/client/dcrwallet"
 	walletjson "decred.org/dcrwallet/rpc/jsonrpc/types"
 	"github.com/decred/dcrd/chaincfg/chainhash"
+	"github.com/decred/dcrd/chaincfg/v3"
 	"github.com/decred/dcrd/dcrec"
 	"github.com/decred/dcrd/dcrec/secp256k1/v3"
 	"github.com/decred/dcrd/dcrec/secp256k1/v3/ecdsa"
@@ -366,6 +367,7 @@ type ExchangeWallet struct {
 	ctx              context.Context // the asset subsystem starts with Connect(ctx)
 	client           *rpcclient.Client
 	node             rpcClient
+	chainParams      *chaincfg.Params
 	log              dex.Logger
 	acct             string
 	tipChange        func(error)
@@ -426,12 +428,12 @@ var _ asset.Wallet = (*ExchangeWallet)(nil)
 func NewWallet(cfg *asset.WalletConfig, logger dex.Logger, network dex.Network) (*ExchangeWallet, error) {
 	// loadConfig will set fields if defaults are used and set the chainParams
 	// package variable.
-	walletCfg, err := loadConfig(cfg.Settings, network)
+	walletCfg, chainParams, err := loadConfig(cfg.Settings, network)
 	if err != nil {
 		return nil, err
 	}
 
-	dcr, err := unconnectedWallet(cfg, walletCfg, logger)
+	dcr, err := unconnectedWallet(cfg, walletCfg, chainParams, logger)
 	if err != nil {
 		return nil, err
 	}
@@ -451,7 +453,7 @@ func NewWallet(cfg *asset.WalletConfig, logger dex.Logger, network dex.Network)
 
 // unconnectedWallet returns an ExchangeWallet without a node. The node should
 // be set before use.
-func unconnectedWallet(cfg *asset.WalletConfig, dcrCfg *Config, logger dex.Logger) (*ExchangeWallet, error) {
+func unconnectedWallet(cfg *asset.WalletConfig, dcrCfg *Config, chainParams *chaincfg.Params, logger dex.Logger) (*ExchangeWallet, error) {
 	// If set in the user config, the fallback fee will be in units of DCR/kB.
 	// Convert to atoms/B.
 	fallbackFeesPerByte := toAtoms(dcrCfg.FallbackFeeRate / 1000)
@@ -480,6 +482,7 @@ func unconnectedWallet(cfg *asset.WalletConfig, dcrCfg *Config, logger dex.Logge
 
 	return &ExchangeWallet{
 		log:                 logger,
+		chainParams:         chainParams,
 		acct:                cfg.Settings["account"],
 		tipChange:           cfg.TipChange,
 		fundingCoins:        make(map[outPoint]*fundingCoin),
@@ -590,7 +593,7 @@ func (dcr *ExchangeWallet) Connect(ctx context.Context) (*sync.WaitGroup, error)
 
 // OwnsAddress indicates if an address belongs to the wallet.
 func (dcr *ExchangeWallet) OwnsAddress(address string) (bool, error) {
-	a, err := dcrutil.DecodeAddress(address, chainParams)
+	a, err := dcrutil.DecodeAddress(address, dcr.chainParams)
 	if err != nil {
 		return false, err
 	}
@@ -987,7 +990,7 @@ func (dcr *ExchangeWallet) split(value uint64, lots uint64, coins asset.Coins, i
 	}
 
 	// Use an internal address for the sized output.
-	addr, err := dcr.node.GetRawChangeAddress(dcr.ctx, dcr.acct, chainParams)
+	addr, err := dcr.node.GetRawChangeAddress(dcr.ctx, dcr.acct, dcr.chainParams)
 	if err != nil {
 		return nil, false, fmt.Errorf("error creating split transaction address: %w", translateRPCCancelErr(err))
 	}
@@ -1207,13 +1210,13 @@ func (dcr *ExchangeWallet) Swap(swaps *asset.Swaps) ([]asset.Receipt, asset.Coin
 			return nil, nil, 0, fmt.Errorf("error creating revocation address: %w", translateRPCCancelErr(err))
 		}
 		// Create the contract, a P2SH redeem script.
-		contractScript, err := dexdcr.MakeContract(contract.Address, revokeAddrV2.String(), contract.SecretHash, int64(contract.LockTime), chainParams)
+		contractScript, err := dexdcr.MakeContract(contract.Address, revokeAddrV2.String(), contract.SecretHash, int64(contract.LockTime), dcr.chainParams)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("unable to create pubkey script for address %s: %w", contract.Address, err)
 		}
 		contracts = append(contracts, contractScript)
 		// Make the P2SH address and pubkey script.
-		scriptAddr, err := dcrutil.NewAddressScriptHash(contractScript, chainParams)
+		scriptAddr, err := dcrutil.NewAddressScriptHash(contractScript, dcr.chainParams)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("error encoding script address: %w", err)
 		}
@@ -1295,7 +1298,7 @@ func (dcr *ExchangeWallet) Redeem(redemptions []*asset.Redemption) ([]dex.Bytes,
 		// Extract the swap contract recipient and secret hash and check the secret
 		// hash against the hash of the provided secret.
 		contract := r.Spends.Contract()
-		_, receiver, _, secretHash, err := dexdcr.ExtractSwapDetails(contract, chainParams)
+		_, receiver, _, secretHash, err := dexdcr.ExtractSwapDetails(contract, dcr.chainParams)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("error extracting swap addresses: %w", err)
 		}
@@ -1403,7 +1406,7 @@ func (dcr *ExchangeWallet) SignMessage(coin asset.Coin, msg dex.Bytes) (pubkeys,
 	if !found {
 		return nil, nil, fmt.Errorf("did not locate coin %s. is this a coin returned from Fund?", coin)
 	}
-	address, err := dcrutil.DecodeAddress(addr, chainParams)
+	address, err := dcrutil.DecodeAddress(addr, dcr.chainParams)
 	if err != nil {
 		return nil, nil, fmt.Errorf("error decoding address: %w", err)
 	}
@@ -1426,7 +1429,7 @@ func (dcr *ExchangeWallet) AuditContract(coinID, contract dex.Bytes) (asset.Audi
 		return nil, err
 	}
 	// Get the receiving address.
-	_, receiver, stamp, secretHash, err := dexdcr.ExtractSwapDetails(contract, chainParams)
+	_, receiver, stamp, secretHash, err := dexdcr.ExtractSwapDetails(contract, dcr.chainParams)
 	if err != nil {
 		return nil, fmt.Errorf("error extracting swap addresses: %w", err)
 	}
@@ -1444,7 +1447,7 @@ func (dcr *ExchangeWallet) AuditContract(coinID, contract dex.Bytes) (asset.Audi
 			txOut.ScriptPubKey.Hex, err)
 	}
 	// Check for standard P2SH.
-	scriptClass, addrs, numReq, err := txscript.ExtractPkScriptAddrs(dexdcr.CurrentScriptVersion, pkScript, chainParams, false)
+	scriptClass, addrs, numReq, err := txscript.ExtractPkScriptAddrs(dexdcr.CurrentScriptVersion, pkScript, dcr.chainParams, false)
 	if err != nil {
 		return nil, fmt.Errorf("error extracting script addresses from '%x': %w", pkScript, err)
 	}
@@ -1476,7 +1479,7 @@ func (dcr *ExchangeWallet) AuditContract(coinID, contract dex.Bytes) (asset.Audi
 // LocktimeExpired returns true if the specified contract's locktime has
 // expired, making it possible to issue a Refund.
 func (dcr *ExchangeWallet) LocktimeExpired(contract dex.Bytes) (bool, time.Time, error) {
-	_, _, locktime, _, err := dexdcr.ExtractSwapDetails(contract, chainParams)
+	_, _, locktime, _, err := dexdcr.ExtractSwapDetails(contract, dcr.chainParams)
 	if err != nil {
 		return false, time.Time{}, fmt.Errorf("error extracting contract locktime: %w", err)
 	}
@@ -1768,7 +1771,7 @@ func (dcr *ExchangeWallet) findRedemptionsInTx(scanPoint string, tx *chainjson.T
 				sigScript, err = hex.DecodeString(input.ScriptSig.Hex)
 			}
 			if err == nil {
-				secret, err = dexdcr.FindKeyPush(sigScript, req.contractHash, chainParams)
+				secret, err = dexdcr.FindKeyPush(sigScript, req.contractHash, dcr.chainParams)
 			}
 
 			if err != nil {
@@ -1836,7 +1839,7 @@ func (dcr *ExchangeWallet) Refund(coinID, contract dex.Bytes) (dex.Bytes, error)
 		return nil, asset.CoinNotFoundError
 	}
 	val := toAtoms(utxo.Value)
-	sender, _, lockTime, _, err := dexdcr.ExtractSwapDetails(contract, chainParams)
+	sender, _, lockTime, _, err := dexdcr.ExtractSwapDetails(contract, dcr.chainParams)
 	if err != nil {
 		return nil, fmt.Errorf("error extracting swap addresses: %w", err)
 	}
@@ -1934,7 +1937,7 @@ func (dcr *ExchangeWallet) Locked() bool {
 // PayFee sends the dex registration fee. Transaction fees are in addition to
 // the registration fee, and the fee rate is taken from the DEX configuration.
 func (dcr *ExchangeWallet) PayFee(address string, regFee uint64) (asset.Coin, error) {
-	addr, err := dcrutil.DecodeAddress(address, chainParams)
+	addr, err := dcrutil.DecodeAddress(address, dcr.chainParams)
 	if err != nil {
 		return nil, err
 	}
@@ -1954,7 +1957,7 @@ func (dcr *ExchangeWallet) PayFee(address string, regFee uint64) (asset.Coin, er
 // Withdraw withdraws funds to the specified address. Fees are subtracted from
 // the value.
 func (dcr *ExchangeWallet) Withdraw(address string, value uint64) (asset.Coin, error) {
-	addr, err := dcrutil.DecodeAddress(address, chainParams)
+	addr, err := dcrutil.DecodeAddress(address, dcr.chainParams)
 	if err != nil {
 		return nil, err
 	}
@@ -2077,7 +2080,7 @@ func (dcr *ExchangeWallet) parseUTXOs(unspents []walletjson.ListUnspentResult) (
 			return nil, fmt.Errorf("error decoding redeem script for %s, script = %s: %w", txout.TxID, txout.RedeemScript, err)
 		}
 
-		nfo, err := dexdcr.InputInfo(scriptPK, redeemScript, chainParams)
+		nfo, err := dexdcr.InputInfo(scriptPK, redeemScript, dcr.chainParams)
 		if err != nil {
 			if errors.Is(err, dex.UnsupportedScriptError) {
 				continue
@@ -2256,7 +2259,7 @@ func (dcr *ExchangeWallet) signTx(baseTx *wire.MsgTx) (*wire.MsgTx, error) {
 }
 
 func (dcr *ExchangeWallet) makeChangeOut(val uint64) (*wire.TxOut, dcrutil.Address, error) {
-	changeAddr, err := dcr.node.GetRawChangeAddress(dcr.ctx, dcr.acct, chainParams)
+	changeAddr, err := dcr.node.GetRawChangeAddress(dcr.ctx, dcr.acct, dcr.chainParams)
 	if err != nil {
 		return nil, nil, fmt.Errorf("error creating change address: %w", translateRPCCancelErr(err))
 	}

client/asset/dcr/dcr_test.go

@@ -52,6 +52,7 @@ var (
 	tTxHash        *chainhash.Hash
 	tPKHAddr       dcrutil.Address
 	tP2PKHScript   []byte
+	tChainParams   = chaincfg.MainNetParams()
 )
 
 func randBytes(l int) []byte {
@@ -150,7 +151,7 @@ func tNewWallet() (*ExchangeWallet, *tRPCClient, func(), error) {
 		TipChange: func(error) {},
 	}
 	walletCtx, shutdown := context.WithCancel(tCtx)
-	wallet, err := unconnectedWallet(walletCfg, &Config{}, tLogger)
+	wallet, err := unconnectedWallet(walletCfg, &Config{}, tChainParams, tLogger)
 	if err != nil {
 		shutdown()
 		return nil, nil, nil, err
@@ -496,8 +497,8 @@ func (c *tRPCClient) RawRequest(_ context.Context, method string, params []json.
 }
 
 func TestMain(m *testing.M) {
-	chainParams = chaincfg.MainNetParams()
-	tPKHAddr, _ = dcrutil.DecodeAddress("DsTya4cCFBgtofDLiRhkyPYEQjgs3HnarVP", chainParams)
+	tChainParams = chaincfg.MainNetParams()
+	tPKHAddr, _ = dcrutil.DecodeAddress("DsTya4cCFBgtofDLiRhkyPYEQjgs3HnarVP", tChainParams)
 	tLogger = dex.StdOutLogger("TEST", dex.LevelTrace)
 	var shutdown func()
 	tCtx, shutdown = context.WithCancel(context.Background())
@@ -1237,7 +1238,7 @@ func TestRedeem(t *testing.T) {
 	lockTime := time.Now().Add(time.Hour * 12)
 	addr := tPKHAddr.String()
 
-	contract, err := dexdcr.MakeContract(addr, addr, secretHash[:], lockTime.Unix(), chainParams)
+	contract, err := dexdcr.MakeContract(addr, addr, secretHash[:], lockTime.Unix(), tChainParams)
 	if err != nil {
 		t.Fatalf("error making swap contract: %v", err)
 	}
@@ -1257,7 +1258,7 @@ func TestRedeem(t *testing.T) {
 	privBytes, _ := hex.DecodeString("b07209eec1a8fb6cfe5cb6ace36567406971a75c330db7101fb21bc679bc5330")
 
 	node.changeAddr = tPKHAddr
-	node.privWIF, err = dcrutil.NewWIF(privBytes, chainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
+	node.privWIF, err = dcrutil.NewWIF(privBytes, tChainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
 	if err != nil {
 		t.Fatalf("NewWIF error: %v", err)
 	}
@@ -1373,7 +1374,7 @@ func TestSignMessage(t *testing.T) {
 		},
 	}
 
-	node.privWIF, err = dcrutil.NewWIF(privBytes, chainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
+	node.privWIF, err = dcrutil.NewWIF(privBytes, tChainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
 	if err != nil {
 		t.Fatalf("NewWIF error: %v", err)
 	}
@@ -1444,11 +1445,11 @@ func TestAuditContract(t *testing.T) {
 	secretHash, _ := hex.DecodeString("5124208c80d33507befa517c08ed01aa8d33adbf37ecd70fb5f9352f7a51a88d")
 	lockTime := time.Now().Add(time.Hour * 12)
 	addrStr := tPKHAddr.String()
-	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash, lockTime.Unix(), chainParams)
+	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash, lockTime.Unix(), tChainParams)
 	if err != nil {
 		t.Fatalf("error making swap contract: %v", err)
 	}
-	addr, _ := dcrutil.NewAddressScriptHash(contract, chainParams)
+	addr, _ := dcrutil.NewAddressScriptHash(contract, tChainParams)
 	pkScript, err := txscript.PayToAddrScript(addr)
 	if err != nil {
 		t.Fatalf("bad address %s (%T)", addr, addr)
@@ -1486,7 +1487,7 @@ func TestAuditContract(t *testing.T) {
 
 	// Wrong contract
 	pkh, _ := hex.DecodeString("c6a704f11af6cbee8738ff19fc28cdc70aba0b82")
-	wrongAddr, _ := dcrutil.NewAddressPubKeyHash(pkh, chainParams, dcrec.STEcdsaSecp256k1)
+	wrongAddr, _ := dcrutil.NewAddressPubKeyHash(pkh, tChainParams, dcrec.STEcdsaSecp256k1)
 	badContract, err := txscript.PayToAddrScript(wrongAddr)
 	if err != nil {
 		t.Fatalf("bad address %s (%T)", wrongAddr, wrongAddr)
@@ -1529,17 +1530,17 @@ func TestFindRedemption(t *testing.T) {
 	secretHash := sha256.Sum256(secret)
 	lockTime := time.Now().Add(time.Hour * 12)
 	addrStr := tPKHAddr.String()
-	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash[:], lockTime.Unix(), chainParams)
+	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash[:], lockTime.Unix(), tChainParams)
 	if err != nil {
 		t.Fatalf("error making swap contract: %v", err)
 	}
-	contractAddr, _ := dcrutil.NewAddressScriptHash(contract, chainParams)
+	contractAddr, _ := dcrutil.NewAddressScriptHash(contract, tChainParams)
 	pkScript, err := txscript.PayToAddrScript(contractAddr)
 	if err != nil {
 		t.Fatalf("bad address %s (%T)", contractAddr, contractAddr)
 	}
 
-	tPKHAddrV3, _ := dcrutil.DecodeAddress(tPKHAddr.String(), chainParams)
+	tPKHAddrV3, _ := dcrutil.DecodeAddress(tPKHAddr.String(), tChainParams)
 	otherScript, err := txscript.PayToAddrScript(tPKHAddrV3)
 	if err != nil {
 		t.Fatalf("bad address %s (%T)", tPKHAddrV3, tPKHAddrV3)
@@ -1650,7 +1651,7 @@ func TestRefund(t *testing.T) {
 	secretHash := sha256.Sum256(secret)
 	lockTime := time.Now().Add(time.Hour * 12)
 	addrStr := tPKHAddr.String()
-	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash[:], lockTime.Unix(), chainParams)
+	contract, err := dexdcr.MakeContract(addrStr, addrStr, secretHash[:], lockTime.Unix(), tChainParams)
 	if err != nil {
 		t.Fatalf("error making swap contract: %v", err)
 	}
@@ -1662,7 +1663,7 @@ func TestRefund(t *testing.T) {
 	node.newAddr = tPKHAddr
 
 	privBytes, _ := hex.DecodeString("b07209eec1a8fb6cfe5cb6ace36567406971a75c330db7101fb21bc679bc5330")
-	node.privWIF, err = dcrutil.NewWIF(privBytes, chainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
+	node.privWIF, err = dcrutil.NewWIF(privBytes, tChainParams.PrivateKeyID, dcrec.STEcdsaSecp256k1)
 	if err != nil {
 		t.Fatalf("NewWIF error: %v", err)
 	}
@@ -1833,7 +1834,7 @@ func Test_sendMinusFees(t *testing.T) {
 		ScriptPubKey:  hex.EncodeToString(tP2PKHScript),
 	}}
 
-	addr, err := dcrutil.DecodeAddress(address, chainParams)
+	addr, err := dcrutil.DecodeAddress(address, tChainParams)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1971,7 +1972,7 @@ func TestSendEdges(t *testing.T) {
 
 	const swapVal = 2e8 // leaving untyped. NewTxOut wants int64
 
-	contractAddr, _ := dcrutil.NewAddressScriptHash(randBytes(20), chainParams)
+	contractAddr, _ := dcrutil.NewAddressScriptHash(randBytes(20), tChainParams)
 	// See dexdcr.IsDust for the source of this dustCoverage voodoo.
 	dustCoverage := (dexdcr.P2PKHOutputSize + 165) * feeRate * 3
 	dexReqFees := dexdcr.InitTxSize * feeRate
@@ -2021,7 +2022,7 @@ func TestSendEdges(t *testing.T) {
 		},
 	}
 
-	// tPKHAddrV3, _ := dcrutil.DecodeAddress(tPKHAddr.String(), chainParams)
+	// tPKHAddrV3, _ := dcrutil.DecodeAddress(tPKHAddr.String(), tChainParams)
 	node.changeAddr = tPKHAddr
 
 	for _, tt := range tests {

client/asset/dcr/simnet_test.go

@@ -28,7 +28,6 @@ import (
 	"decred.org/dcrdex/dex"
 	"decred.org/dcrdex/dex/config"
 	dexdcr "decred.org/dcrdex/dex/networks/dcr"
-	"github.com/decred/dcrd/chaincfg/v3"
 )
 
 const (
@@ -136,7 +135,6 @@ func waitNetwork() {
 }
 
 func TestMain(m *testing.M) {
-	chainParams = chaincfg.SimNetParams()
 	tLogger = dex.StdOutLogger("TEST", dex.LevelTrace)
 	var shutdown func()
 	tCtx, shutdown = context.WithCancel(context.Background())