multi: Add 12 and 24 seed restoration.

Author: JoeGruffins

cgo/types.go

@@ -163,6 +163,7 @@ type Config struct {
 	Net                string `json:"net"`
 	DataDir            string `json:"datadir"`
 	// Only needed during creation.
+	Birthday int64  `json:"birthday"`
 	Pass     string `json:"pass"`
 	Mnemonic string `json:"mnemonic"`
 	// If the wallet existed before but the db was deleted to reduce

cgo/walletloader.go

@@ -4,10 +4,13 @@ import "C"
 import (
 	"context"
 	"encoding/json"
+	"strings"
 	"sync"
+	"time"
 
-	"decred.org/dcrdex/client/mnemonic"
+	dexmnemonic "decred.org/dcrdex/client/mnemonic"
 	"github.com/decred/libwallet/dcr"
+	"github.com/decred/libwallet/mnemonic"
 	"github.com/decred/slog"
 )
 
@@ -59,12 +62,34 @@ func createWallet(cConfig *C.char) *C.char {
 
 	var recoveryConfig *dcr.RecoveryCfg
 	if cfg.Mnemonic != "" {
-		seed, birthday, err := mnemonic.DecodeMnemonic(cfg.Mnemonic)
+		var (
+			seed     []byte
+			birthday time.Time
+			seedType dcr.SeedType
+			err      error
+		)
+		nWords := len(strings.Fields(cfg.Mnemonic))
+		switch nWords {
+		case 15:
+			seed, birthday, err = dexmnemonic.DecodeMnemonic(cfg.Mnemonic)
+			seedType = dcr.STFifteenWords
+		case 12:
+			seed, err = mnemonic.DecodeMnemonic(cfg.Mnemonic)
+			birthday = time.Unix(cfg.Birthday, 0)
+			seedType = dcr.STTwelveWords
+		case 24:
+			seed, err = mnemonic.DecodeMnemonic(cfg.Mnemonic)
+			birthday = time.Unix(cfg.Birthday, 0)
+			seedType = dcr.STTwentyFourWords
+		default:
+			return errCResponse("unknown mnemonic format. expected 12, 15, or 14 words, got %d", nWords)
+		}
 		if err != nil {
 			return errCResponse("unable to decode wallet mnemonic: %v", err)
 		}
 		recoveryConfig = &dcr.RecoveryCfg{
 			Seed:     seed,
+			SeedType: seedType,
 			Birthday: birthday,
 		}
 	}

dcr/loader.go

@@ -48,11 +48,15 @@ func CreateWallet(ctx context.Context, params CreateWalletParams, recovery *Reco
 		return nil, fmt.Errorf("check new wallet data directory error: %w", err)
 	}
 
-	var seed []byte
-	var birthday time.Time
+	var (
+		seed, tweakedSeed []byte
+		birthday          time.Time
+		seedType          SeedType
+	)
+
 	if recovery != nil {
 		if recovery.UseLocalSeed {
-			wd, err := RetreiveWalletData(params.DataDir)
+			wd, err := retrieveWalletData(params.DataDir)
 			if err != nil {
 				return nil, fmt.Errorf("unable to get wallet data: %v", err)
 			}
@@ -65,22 +69,29 @@ func CreateWallet(ctx context.Context, params CreateWalletParams, recovery *Reco
 				return nil, fmt.Errorf("unable to decrypt wallet seed: %v", err)
 			}
 			birthday = time.Unix(wd.Birthday, 0)
+			seedType = wd.SeedType
 		} else {
-			seed, birthday = recovery.Seed, recovery.Birthday
+			seed, birthday, seedType = recovery.Seed, recovery.Birthday, recovery.SeedType
 		}
 	} else {
 		seed, err = hdkeychain.GenerateSeed(entropyBytes)
 		if err != nil {
 			return nil, fmt.Errorf("unable to generate random seed: %v", err)
 		}
 		birthday = time.Now()
+		// Seed type is default fifteen words.
 	}
 
-	// Adjust seed to create the same wallet as dex.
-	b := make([]byte, len(seed)+4)
-	copy(b, seed)
-	binary.BigEndian.PutUint32(b[len(seed):], 42)
-	tweakedSeed := blake256.Sum256(b)
+	if seedType == STFifteenWords {
+		// Adjust seed to create the same wallet as dex.
+		b := make([]byte, len(seed)+4)
+		copy(b, seed)
+		binary.BigEndian.PutUint32(b[len(seed):], 42)
+		ts := blake256.Sum256(b)
+		copy(tweakedSeed, ts[:])
+	} else {
+		copy(tweakedSeed, seed)
+	}
 
 	_, _, _, acctKeySLIP0044Priv, err := udb.HDKeysFromSeed(tweakedSeed[:], chainParams)
 	if err != nil {
@@ -89,9 +100,9 @@ func CreateWallet(ctx context.Context, params CreateWalletParams, recovery *Reco
 	defer acctKeySLIP0044Priv.Zero()
 	xpub := acctKeySLIP0044Priv.Neuter()
 
-	wd, err := SaveWalletData(seed, xpub.String(), birthday, params.DataDir, params.Pass)
+	wd, err := saveWalletData(seed, xpub.String(), birthday, params.DataDir, params.Pass, seedType)
 	if err != nil {
-		return nil, fmt.Errorf("SaveWalletData error: %v", err)
+		return nil, fmt.Errorf("saveWalletData error: %v", err)
 	}
 
 	ctx, cancel := context.WithTimeout(ctx, time.Minute)
@@ -185,7 +196,7 @@ func CreateWatchOnlyWallet(ctx context.Context, extendedPubKey string, params Cr
 	}
 
 	if useLocalSeed {
-		wd, err := RetreiveWalletData(params.DataDir)
+		wd, err := retrieveWalletData(params.DataDir)
 		if err != nil {
 			return nil, fmt.Errorf("unable to get wallet data: %v", err)
 		}
@@ -197,9 +208,9 @@ func CreateWatchOnlyWallet(ctx context.Context, extendedPubKey string, params Cr
 		return nil, fmt.Errorf("unable to parse extended key: %w", err)
 	}
 
-	wd, err := SaveWalletData(nil, xpub.String(), time.Time{}, params.DataDir, nil) // password not required
+	wd, err := saveWalletData(nil, xpub.String(), time.Time{}, params.DataDir, nil, 0) // password not required
 	if err != nil {
-		return nil, fmt.Errorf("SaveWalletData error: %v", err)
+		return nil, fmt.Errorf("saveWalletData error: %v", err)
 	}
 
 	ctx, cancel := context.WithTimeout(ctx, time.Minute)
@@ -266,7 +277,7 @@ func LoadWallet(ctx context.Context, params OpenWalletParams) (*Wallet, error) {
 		return nil, fmt.Errorf("error parsing chain params: %w", err)
 	}
 
-	wd, err := RetreiveWalletData(params.DataDir)
+	wd, err := retrieveWalletData(params.DataDir)
 	if err != nil {
 		return nil, err
 	}

dcr/params.go

@@ -24,6 +24,7 @@ type CreateWalletParams struct {
 // RecoveryCfg is the information used to recover a wallet.
 type RecoveryCfg struct {
 	Seed                 []byte
+	SeedType             SeedType
 	Birthday             time.Time
 	UseLocalSeed         bool
 	NumExternalAddresses uint32

dcr/wallet.go

@@ -3,15 +3,17 @@ package dcr
 import (
 	"context"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"sync"
 	"time"
 
-	"decred.org/dcrdex/client/mnemonic"
+	dexmnemonic "decred.org/dcrdex/client/mnemonic"
 	"decred.org/dcrwallet/v4/spv"
 	"decred.org/dcrwallet/v4/wallet"
 	"github.com/decred/dcrd/chaincfg/v3"
+	"github.com/decred/libwallet/mnemonic"
 	"github.com/decred/slog"
 )
 
@@ -46,10 +48,6 @@ func (w *Wallet) DecryptSeed(passphrase []byte) (string, error) {
 	w.seedMtx.Lock()
 	defer w.seedMtx.Unlock()
 
-	if w.metaData.EncryptedSeedHex == "" {
-		return "", fmt.Errorf("seed has been verified")
-	}
-
 	encryptedSeed, err := hex.DecodeString(w.metaData.EncryptedSeedHex)
 	if err != nil {
 		return "", fmt.Errorf("unable to decode encrypted hex seed: %v", err)
@@ -59,15 +57,23 @@ func (w *Wallet) DecryptSeed(passphrase []byte) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return mnemonic.GenerateMnemonic(seed, time.Unix(w.metaData.Birthday, 0))
+
+	switch len(seed) {
+	case 18:
+		return dexmnemonic.GenerateMnemonic(seed, time.Unix(w.metaData.Birthday, 0))
+	case 16, 32:
+		return mnemonic.GenerateMnemonic(seed)
+	default:
+		return "", fmt.Errorf("invalid saved seed length %d", len(seed))
+	}
 }
 
 func (w *Wallet) ReEncryptSeed(oldPass, newPass []byte) error {
 	w.seedMtx.Lock()
 	defer w.seedMtx.Unlock()
 
 	if w.metaData.EncryptedSeedHex == "" {
-		return nil
+		return errors.New("encrypted seed does not exist")
 	}
 
 	encryptedSeed, err := hex.DecodeString(w.metaData.EncryptedSeedHex)
@@ -81,7 +87,7 @@ func (w *Wallet) ReEncryptSeed(oldPass, newPass []byte) error {
 	}
 
 	birthday := time.Unix(w.metaData.Birthday, 0)
-	updatedMetaData, err := SaveWalletData(seed, w.metaData.DefaultAccountXPub, birthday, w.dir, newPass)
+	updatedMetaData, err := saveWalletData(seed, w.metaData.DefaultAccountXPub, birthday, w.dir, newPass, w.metaData.SeedType)
 	if err != nil {
 		return err
 	}

dcr/walletdata.go

@@ -9,15 +9,29 @@ import (
 	"time"
 )
 
+// SeedType defines the type of seed used by the wallet. Currently all use bip39
+// words but they are different lengths.
+type SeedType int
+
+const (
+	// STFifteenWords encodes a birthday along with the seed. It is also
+	// used by bison wallet and has a tweak that causes it to produce the
+	// same wallet.
+	STFifteenWords    SeedType = iota // 0
+	STTwelveWords                     // 1
+	STTwentyFourWords                 // 2
+)
+
 const walletDataFileName = "walletdata.json"
 
 type walletData struct {
-	EncryptedSeedHex   string `json:"encryptedseedhex,omitempty"`
-	DefaultAccountXPub string `json:"defaultaccountxpub,omitempty"`
-	Birthday           int64  `json:"birthday,omitempty"`
+	EncryptedSeedHex   string   `json:"encryptedseedhex,omitempty"`
+	SeedType           SeedType `json:"seedtype,omitempty"`
+	DefaultAccountXPub string   `json:"defaultaccountxpub,omitempty"`
+	Birthday           int64    `json:"birthday,omitempty"`
 }
 
-func SaveWalletData(seed []byte, defaultAccountXPub string, birthday time.Time, dataDir string, walletPass []byte) (*walletData, error) {
+func saveWalletData(seed []byte, defaultAccountXPub string, birthday time.Time, dataDir string, walletPass []byte, seedType SeedType) (*walletData, error) {
 	encSeed, err := EncryptData(seed, walletPass)
 	if err != nil {
 		return nil, fmt.Errorf("seed encryption error: %v", err)
@@ -28,6 +42,7 @@ func SaveWalletData(seed []byte, defaultAccountXPub string, birthday time.Time,
 		EncryptedSeedHex:   encSeedHex,
 		DefaultAccountXPub: defaultAccountXPub,
 		Birthday:           birthday.Unix(),
+		SeedType:           seedType,
 	}
 	file, err := json.MarshalIndent(wd, "", " ")
 	if err != nil {
@@ -41,8 +56,8 @@ func SaveWalletData(seed []byte, defaultAccountXPub string, birthday time.Time,
 	return wd, nil
 }
 
-// RetreiveWalletData returns the wallet data from the data dir.
-func RetreiveWalletData(dataDir string) (*walletData, error) {
+// retrieveWalletData returns the wallet data from the data dir.
+func retrieveWalletData(dataDir string) (*walletData, error) {
 	fp := filepath.Join(dataDir, walletDataFileName)
 	b, err := os.ReadFile(fp)
 	if err != nil {