feat: make work with arbitrary coin types

Author: AJ ONeal

README.md

@@ -3,7 +3,7 @@
 Sign and Verify messages with Dash Private Keys
 
 ```bash
-dashmsg sign \
+dashmsg sign --cointype 0x4c \
     'XK5DHnAiSj6HQNsNcDkawd9qdp8UFMdYftdVZFuRreTMJtbJhk8i' \
     'dte2022-akerdemelidis|estoever|mmason'
 ```
@@ -28,18 +28,18 @@ dashmsg help
 ```
 
 ```txt
-dashmsg v0.9.0 (gxxxxxx) 2022-03-12T01:33:52-0700
+dashmsg v0.9.1 (xxxxxxx) 2022-03-13T11:45:52-0700
 
 Usage
- dashmsg <command> [flags] args...
+    dashmsg <command> [flags] args...
 
 See usage: dashmsg help <command>
 
 Commands:
     version
-    gen [name.wif]
-    sign <key> <msg>
-    inspect <key | address | signature>
+    gen [--cointype '0xcc'] [name.wif]
+    sign [--cointype '0x4c'] <key> <msg>
+    inspect [--cointype '0x4c'] <key | address | signature>
     decode (alias of inspect)
     verify <payment address> <msg> <signature>
 

cmd/dashmsg/main.go

@@ -26,15 +26,15 @@ func usage() {
 	fmt.Println(ver())
 	fmt.Println()
 	fmt.Println("Usage")
-	fmt.Printf(" %s <command> [flags] args...\n", name)
+	fmt.Printf("    %s <command> [flags] args...\n", name)
 	fmt.Println("")
 	fmt.Printf("See usage: %s help <command>\n", name)
 	fmt.Println("")
 	fmt.Println("Commands:")
 	fmt.Println("    version")
-	fmt.Println("    gen [name.wif]")
-	fmt.Println("    sign <key> <msg>")
-	fmt.Println("    inspect <key | address | signature>")
+	fmt.Println("    gen [--cointype '0xcc'] [name.wif]")
+	fmt.Println("    sign [--cointype '0x4c'] <key> <msg>")
+	fmt.Println("    inspect [--cointype '0x4c'] <key | address | signature>")
 	fmt.Println("    decode (alias of inspect)")
 	fmt.Println("    verify <payment address> <msg> <signature>")
 	fmt.Println("")
@@ -99,26 +99,42 @@ func main() {
 }
 
 func gen(args []string) {
-	wif := dashmsg.GenerateWIF()
+	var cointype string
 
-	if len(args) == 1 {
+	flags := flag.NewFlagSet("gen", flag.ExitOnError)
+	flags.StringVar(&cointype, "cointype", "", "the magic version (hex) string of the private key")
+	flags.Parse(args)
+
+	cointype = strings.TrimPrefix(cointype, "0x")
+
+	wif := dashmsg.GenerateWIF(cointype)
+
+	if len(flags.Args()) == 1 {
 		b := []byte(wif)
 		b = append(b, '\n')
-		ioutil.WriteFile(args[0], b, 0644)
-		fmt.Printf("wrote Private Key (as WIF) to %q\n", args[0])
+		ioutil.WriteFile(flags.Args()[0], b, 0644)
+		fmt.Printf("wrote Private Key (as WIF) to %q\n", flags.Args()[0])
 		return
 	}
 
 	fmt.Println(wif)
 }
 
 func inspect(args []string) {
-	if len(args) != 1 {
+	var cointype string
+
+	flags := flag.NewFlagSet("inspect", flag.ExitOnError)
+	flags.StringVar(&cointype, "cointype", "", "the magic version (hex) string of the private key")
+	flags.Parse(args)
+
+	cointype = strings.TrimPrefix(cointype, "0x")
+
+	if len(flags.Args()) != 1 {
 		fmt.Fprintf(os.Stderr, "usage: %s inspect <addr-or-key>\n", os.Args[0])
 		os.Exit(1)
 		return
 	}
-	input := args[0]
+	input := flags.Args()[0]
 
 	var usererr error
 	inputlen := len(input)
@@ -144,16 +160,19 @@ func inspect(args []string) {
 			break
 		}
 
-		priv, err := dashmsg.WIFToPrivateKey(wif)
+		privCointype, priv, err := dashmsg.WIFToPrivateKey(wif)
 		if nil != err {
 			usererr = err
 			break
 		}
+		if 0 == len(cointype) {
+			cointype = privCointype
+		}
 
 		pubBytes := dashmsg.MarshalPublicKey(priv.PublicKey)
-		pkh := dashmsg.PublicKeyToAddress(priv.PublicKey)
+		pkh := dashmsg.PublicKeyToAddress(cointype, priv.PublicKey)
 
-		fmt.Printf("PrivateKey (hex): %s (coin type)\n", hexstr[:2])
+		fmt.Printf("PrivateKey (hex): %s (coin type)\n", privCointype)
 		fmt.Printf("                : %s\n", hexstr[2:66])
 		fmt.Printf("                : %s (compressed)\n", hexstr[66:])
 		fmt.Println()
@@ -184,9 +203,14 @@ func inspect(args []string) {
 }
 
 func sign(args []string) {
+	var cointype string
+
 	flags := flag.NewFlagSet("sign", flag.ExitOnError)
+	flags.StringVar(&cointype, "cointype", "", "the magic version (hex) string of the private key")
 	flags.Parse(args)
 
+	cointype = strings.TrimPrefix(cointype, "0x")
+
 	if len(flags.Args()) <= 1 {
 		fmt.Fprintf(os.Stderr, "usage: %s sign <addr-or-key> <msg>\n", os.Args[0])
 		os.Exit(1)
@@ -195,7 +219,7 @@ func sign(args []string) {
 	wifname := flags.Args()[0]
 	payload := flags.Args()[1]
 
-	priv, err := readWif(wifname)
+	_, priv, err := readWif(wifname)
 	if nil != err {
 		fmt.Fprintf(os.Stderr, "error: could not decode private key: %v\n", err)
 		os.Exit(1)
@@ -252,7 +276,15 @@ func verify(args []string) {
 		return
 	}
 
-	if dashmsg.PublicKeyToAddress(*pub) == addr {
+	cointype, err := dashmsg.AddressToCointype(addr)
+	if nil != err {
+		// Neither a valid file nor string. Blast!
+		fmt.Printf("can't detect coin type of %q: %v\n", addr, err)
+		os.Exit(1)
+		return
+	}
+
+	if dashmsg.PublicKeyToAddress(cointype, *pub) == addr {
 		fmt.Println("Verified: true")
 		return
 	}
@@ -270,18 +302,18 @@ func readFileOrString(str string) []byte {
 	return b
 }
 
-func readWif(wifname string) (*ecdsa.PrivateKey, error) {
+func readWif(wifname string) (string, *ecdsa.PrivateKey, error) {
 	// Read as file
 	wif := readFileOrString(wifname)
 
-	priv, err := dashmsg.WIFToPrivateKey(string(wif))
+	cointype, priv, err := dashmsg.WIFToPrivateKey(string(wif))
 	if nil != err {
 		// Neither a valid file nor string. Blast!
-		return nil, fmt.Errorf(
+		return "", nil, fmt.Errorf(
 			"could not read private key as file (or parse as string) %q:\n%s",
 			wifname, err,
 		)
 	}
 
-	return priv, nil
+	return cointype, priv, nil
 }

dashmsg.go

@@ -17,38 +17,56 @@ import (
 )
 
 var (
-	// CheckVersion is the magic version byte signifying the payment address coin type (i.e. Dash, Public Key)
-	CheckVersion = "4c" // Dash (vs 0x00 for BC)
+	// CheckVersion is the Base58Check magic version (coin / network type) byte signifying the payment address coin type (i.e. Dash, Public Key, mainnet)
+	CheckVersion = "4c" // Dash mainnet (vs 0x00 for BC)
+
+	// CheckVersionTest is CheckVersion, but for testnet
+	CheckVersionTest = "8c" // Dash testnet
+
+	// WIFVersion is the Base58Check magic version (coin / network type) byte signifying the wallet type (i.e. Dash, Private Key, mainnet)
+	WIFVersion = "cc" // Dash mainnet (vs 0x80 for BC)
+
+	// WIFVersionTest is WIFVersion, but for testnet
+	WIFVersionTest = "ef" // Dash testnet
 
-	// WIFVersion is the magic version byte signifying the wallet type (i.e. Dash, Private Key)
-	WIFVersion = "cc" // Dash (vs 0x80 for BC)
 	// MagicBytes is the secure delimiter that scopes a message to a particular network
 	MagicBytes = []byte("DarkCoin Signed Message:\n")
 )
 
 var randReader io.Reader = rand.Reader
 
 // GenerateWIF creates a new wallet private key as WIF
-func GenerateWIF() string {
+func GenerateWIF(magicVersion string) string {
+	if "" == magicVersion {
+		magicVersion = WIFVersion
+	}
+	if CheckVersion == magicVersion {
+		magicVersion = WIFVersion
+	}
+	if CheckVersionTest == magicVersion {
+		magicVersion = WIFVersionTest
+	}
+
 	priv, _ := ecdsa.GenerateKey(secp256k1.S256(), randReader)
 	b := priv.D.Bytes()
 
 	hexkey := hex.EncodeToString(b)
 	compressed := "01"
-	wif, _ := base58check.Encode(WIFVersion, hexkey+compressed)
+	wif, _ := base58check.Encode(magicVersion, hexkey+compressed)
 
 	return wif
 }
 
-// WIFToPrivateKey converts from base58check (WIF) to a standard(ish) ECDSA private key
-func WIFToPrivateKey(wif string) (*ecdsa.PrivateKey, error) {
+// WIFToPrivateKey decodes the base58check (WIF) into the network magicVersion and a standard(ish) ECDSA private key
+func WIFToPrivateKey(wif string) (string, *ecdsa.PrivateKey, error) {
 	dHex, err := base58check.Decode(wif)
 	if nil != err {
-		return nil, err
+		return "", nil, err
 	}
 	// remove the "version" and "compressed" bytes
 	//fmt.Println("version:", dHex[0:2])
 	//fmt.Println("compressed:", dHex[66:])
+	magicVersion := dHex[0:2]
 	dHex = dHex[2:66]
 
 	// can't get error here because base58check passed
@@ -72,7 +90,18 @@ func WIFToPrivateKey(wif string) (*ecdsa.PrivateKey, error) {
 	//fmt.Println("PrivateKey:", hex.EncodeToString(di.Bytes()))
 	//fmt.Println("PublicKey (x):", hex.EncodeToString(x.Bytes()))
 	//fmt.Println("PublicKey (y):", hex.EncodeToString(y.Bytes()))
-	return priv, nil
+	return magicVersion, priv, nil
+}
+
+// AddressToCointype reads the magic version (coin / network type) from the base58check address
+func AddressToCointype(addr string) (string, error) {
+	dHex, err := base58check.Decode(addr)
+	if nil != err {
+		return "", err
+	}
+
+	magicVersion := dHex[0:2]
+	return magicVersion, nil
 }
 
 /*
@@ -108,10 +137,22 @@ func SigToPub(magichash, dsig []byte) (*ecdsa.PublicKey, error) {
 }
 
 // PublicKeyToAddress transforms a PublicKey into a PubKeyHash address is Base58Check format
-func PublicKeyToAddress(pub ecdsa.PublicKey) string {
+func PublicKeyToAddress(magicVersion string, pub ecdsa.PublicKey) string {
+	if "" == magicVersion {
+		magicVersion = CheckVersion
+	}
+	// just in case a private key was used to get the magic version
+	// (the name says "public key" and all, but...)
+	if WIFVersion == magicVersion {
+		magicVersion = CheckVersion
+	}
+	if WIFVersionTest == magicVersion {
+		magicVersion = CheckVersionTest
+	}
+
 	pubKeyHash := secp256k1crypto.PubkeyToAddress(pub).Bytes()
 	pubKeyHashHex := hex.EncodeToString(pubKeyHash)
-	addr, _ := base58check.Encode(CheckVersion, pubKeyHashHex)
+	addr, _ := base58check.Encode(magicVersion, pubKeyHashHex)
 	//fmt.Println("PubKeyHash Bytes:", pubKeyHash)
 	//fmt.Println("PubKeyHash:", addr)
 

test.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+set -e
+set -u
+
+my_priv="0x00"
+my_coin="0x80"
+my_message='silly message'
+echo "Message: ${my_message}"
+
+my_wif="$(
+    go run cmd/dashmsg/main.go gen --cointype "${my_priv}"
+)"
+
+my_sig="$(
+    go run cmd/dashmsg/main.go sign --cointype "${my_coin}" "${my_wif}" "${my_message}"
+)"
+
+my_addr="$(
+    go run cmd/dashmsg/main.go inspect --cointype "${my_coin}" "${my_wif}" |
+        grep 'Address' | cut -d':' -f2 | cut -d' ' -f2
+)"
+
+go run cmd/dashmsg/main.go verify "${my_addr}" "${my_message}" "${my_sig}"
+
+# Inspect
+echo ""
+echo "Inspect..."
+echo "WIF: ${my_wif} (pub cointype: ${my_coin})"
+go run cmd/dashmsg/main.go inspect --cointype "${my_coin}" "${my_wif}"
+echo ''
+echo ''
+echo "Signature: ${my_sig}"
+go run cmd/dashmsg/main.go inspect "${my_sig}"
+echo ''
+echo ''
+echo "Address: ${my_addr}"
+go run cmd/dashmsg/main.go inspect "${my_addr}"
+
+echo ''
+echo 'PASS'
+echo ''