[wip] Mnemonic support for wallet entropy

src/Makefile.am

@@ -200,6 +200,7 @@ BLSCT_H = \
   blsct/wallet/address.h \
   blsct/wallet/hdchain.h \
   blsct/wallet/helpers.h \
+  blsct/wallet/import_wallet_type.h \
   blsct/wallet/keyman.h \
   blsct/wallet/keyring.h \
   blsct/wallet/txfactory.h \

src/bench/wallet_create.cpp

@@ -34,7 +34,7 @@ static void WalletCreate(benchmark::Bench& bench, bool encrypted)
 
     fs::path wallet_path = test_setup->m_path_root / strprintf("test_wallet_%d", random.rand32()).c_str();
     bench.run([&] {
-        auto wallet = CreateWallet(context, wallet_path.utf8string(), /*load_on_start=*/std::nullopt, options, status, error_string, warnings);
+        auto wallet = CreateWallet(context, wallet_path.utf8string(), {}, blsct::IMPORT_MASTER_KEY, /*load_on_start=*/std::nullopt, options, status, error_string, warnings);
         assert(status == DatabaseStatus::SUCCESS);
         assert(wallet != nullptr);
 

src/bitcoin-wallet.cpp

@@ -43,6 +43,7 @@ static void SetupWalletToolArgs(ArgsManager& argsman)
     argsman.AddArg("-debug=<category>", "Output debugging information (default: 0).", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-descriptors", "Create descriptors wallet. Only for 'create'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blsct", "Create blsct wallet. Only for 'create'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-seed", "Seed used for the wallet creation. Only for 'create'. Can be a master seed or an audit key.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-legacy", "Create legacy wallet. Only for 'create'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-format=<format>", "The format of the wallet file to create. Either \"bdb\" or \"sqlite\". Only used with 'createfromdump'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-printtoconsole", "Send trace/debug info to console (default: 1 when no -debug is true, 0 otherwise).", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

src/blsct/wallet/import_wallet_type.h

@@ -0,0 +1,16 @@
+// Copyright (c) 2023 The Navio developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef NAVIO_BLSCT_IMPORT_WALLET_TYPE_H
+#define NAVIO_BLSCT_IMPORT_WALLET_TYPE_H
+
+namespace blsct {
+enum SeedType {
+    IMPORT_MASTER_KEY,
+    IMPORT_VIEW_KEY
+};
+
+} // namespace blsct
+
+#endif // NAVIO_BLSCT_KEYMAN_H

src/blsct/wallet/keyman.cpp

@@ -248,7 +248,7 @@ void KeyMan::SetHDSeed(const PrivateKey& key)
         throw std::runtime_error(std::string(__func__) + ": AddSpendKey failed");
 
     if (!AddViewKey(viewKey, viewKey.GetPublicKey()))
-        throw std::runtime_error(std::string(__func__) + ": AddKeyPubKey failed");
+        throw std::runtime_error(std::string(__func__) + ": AddViewKey failed");
 
     if (!AddKeyPubKey(tokenKey, tokenKey.GetPublicKey()))
         throw std::runtime_error(std::string(__func__) + ": AddKeyPubKey failed");
@@ -261,13 +261,39 @@ void KeyMan::SetHDSeed(const PrivateKey& key)
     wallet::WalletBatch batch(m_storage.GetDatabase());
 }
 
-bool KeyMan::SetupGeneration(bool force)
+bool KeyMan::SetupGeneration(const std::vector<unsigned char>& seed, const SeedType& type, bool force)
 {
     if ((CanGenerateKeys() && !force) || m_storage.IsLocked()) {
         return false;
     }
 
-    SetHDSeed(GenerateNewSeed());
+    if (seed.size() == 32) {
+        if (type == IMPORT_MASTER_KEY) {
+            MclScalar scalarSeed;
+            scalarSeed.SetVch(seed);
+            SetHDSeed(scalarSeed);
+        }
+    } else if (seed.size() == 80) {
+        if (type == IMPORT_VIEW_KEY) {
+            std::vector<unsigned char> viewVch(seed.begin(), seed.begin() + 32);
+            std::vector<unsigned char> spendingVch(seed.begin() + 32, seed.end());
+
+            MclScalar scalarView;
+            scalarView.SetVch(viewVch);
+
+            MclG1Point pointSpending;
+            pointSpending.SetVch(spendingVch);
+
+            if (!AddViewKey(scalarView, PrivateKey(scalarView).GetPublicKey()))
+                throw std::runtime_error(std::string(__func__) + ": AddViewKey failed");
+
+            if (!AddSpendKey(pointSpending))
+                throw std::runtime_error(std::string(__func__) + ": AddSpendKey failed");
+        }
+    } else {
+        SetHDSeed(GenerateNewSeed());
+    }
+
     if (!NewSubAddressPool() || !NewSubAddressPool(-1) || !NewSubAddressPool(-2)) {
         return false;
     }
@@ -460,17 +486,15 @@ blsct::PrivateKey KeyMan::GetMasterSeedKey() const
 
 blsct::PrivateKey KeyMan::GetPrivateViewKey() const
 {
-    if (!IsHDEnabled())
-        throw std::runtime_error(strprintf("%s: the wallet has no HD enabled"));
+    if (!fViewKeyDefined)
+        throw std::runtime_error(strprintf("%s: the wallet has no view key available"));
 
-    auto viewId = m_hd_chain.view_id;
-
-    PrivateKey ret;
-
-    if (!GetKey(viewId, ret))
-        throw std::runtime_error(strprintf("%s: could not access the private view key", __func__));
+    return viewKey;
+}
 
-    return ret;
+blsct::PublicKey KeyMan::GetPublicSpendingKey() const
+{
+    return spendPublicKey;
 }
 
 blsct::PrivateKey KeyMan::GetSpendingKey() const

src/blsct/wallet/keyman.h

@@ -14,6 +14,7 @@
 #include <blsct/wallet/address.h>
 #include <blsct/wallet/hdchain.h>
 #include <blsct/wallet/helpers.h>
+#include <blsct/wallet/import_wallet_type.h>
 #include <blsct/wallet/keyring.h>
 #include <logging.h>
 #include <wallet/crypter.h>
@@ -34,7 +35,7 @@ class Manager
     explicit Manager(wallet::WalletStorage& storage) : m_storage(storage) {}
     virtual ~Manager(){};
 
-    virtual bool SetupGeneration(bool force = false) { return false; }
+    virtual bool SetupGeneration(const std::vector<unsigned char>& seed, const SeedType& type, bool force = false) { return false; }
 
     /* Returns true if HD is enabled */
     virtual bool IsHDEnabled() const { return false; }
@@ -72,7 +73,7 @@ class KeyMan : public Manager, public KeyRing
     KeyMan(wallet::WalletStorage& storage, int64_t keypool_size)
         : Manager(storage), KeyRing(), m_keypool_size(keypool_size) {}
 
-    bool SetupGeneration(bool force = false) override;
+    bool SetupGeneration(const std::vector<unsigned char>& seed, const SeedType& type = IMPORT_MASTER_KEY, bool force = false) override;
     bool IsHDEnabled() const override;
 
     /* Returns true if the wallet can generate new keys */
@@ -136,6 +137,7 @@ class KeyMan : public Manager, public KeyRing
     CTxDestination GetDestination(const CTxOut& txout) const;
     blsct::PrivateKey GetMasterSeedKey() const;
     blsct::PrivateKey GetPrivateViewKey() const;
+    blsct::PublicKey GetPublicSpendingKey() const;
     blsct::PrivateKey GetSpendingKey() const;
     blsct::PrivateKey GetSpendingKeyForOutput(const CTxOut& out) const;
     blsct::PrivateKey GetSpendingKeyForOutput(const CTxOut& out, const CKeyID& id) const;

src/blsct/wallet/txfactory.h

@@ -28,17 +28,22 @@ class TxFactoryBase
 {
 protected:
     CMutableTransaction tx;
-    std::map<TokenId, std::vector<UnsignedOutput>> vOutputs;
-    std::map<TokenId, std::vector<UnsignedInput>> vInputs;
-    std::map<TokenId, Amounts> nAmounts;
+    std::map<TokenId, std::vector<UnsignedOutput>>
+        vOutputs;
+    std::map<TokenId, std::vector<UnsignedInput>>
+        vInputs;
+    std::map<TokenId, Amounts>
+        nAmounts;
 
 public:
     TxFactoryBase(){};
 
     void AddOutput(const SubAddress& destination, const CAmount& nAmount, std::string sMemo, const TokenId& token_id = TokenId(), const CreateTransactionType& type = NORMAL, const CAmount& minStake = 0, const bool& fSubtractFeeFromAmount = false);
     bool AddInput(const CAmount& amount, const MclScalar& gamma, const blsct::PrivateKey& spendingKey, const TokenId& token_id, const COutPoint& outpoint, const bool& rbf = false);
-    std::optional<CMutableTransaction> BuildTx(const blsct::DoublePublicKey& changeDestination, const CAmount& minStake = 0, const CreateTransactionType& type = NORMAL, const bool& fSubtractedFee = false);
-    static std::optional<CMutableTransaction> CreateTransaction(const std::vector<InputCandidates>& inputCandidates, const blsct::DoublePublicKey& changeDestination, const SubAddress& destination, const CAmount& nAmount, std::string sMemo, const TokenId& token_id = TokenId(), const CreateTransactionType& type = NORMAL, const CAmount& minStake = 0);
+    std::optional<CMutableTransaction>
+    BuildTx(const blsct::DoublePublicKey& changeDestination, const CAmount& minStake = 0, const CreateTransactionType& type = NORMAL, const bool& fSubtractedFee = false);
+    static std::optional<CMutableTransaction>
+    CreateTransaction(const std::vector<InputCandidates>& inputCandidates, const blsct::DoublePublicKey& changeDestination, const SubAddress& destination, const CAmount& nAmount, std::string sMemo, const TokenId& token_id = TokenId(), const CreateTransactionType& type = NORMAL, const CAmount& minStake = 0);
     static void AddAvailableCoins(wallet::CWallet* wallet, blsct::KeyMan* blsct_km, const wallet::CoinFilterParams& coins_params, std::vector<InputCandidates>& inputCandidates) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
     static void AddAvailableCoins(wallet::CWallet* wallet, blsct::KeyMan* blsct_km, const TokenId& token_id, const CreateTransactionType& type, std::vector<InputCandidates>& inputCandidates) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
 };

src/interfaces/wallet.h

@@ -6,6 +6,7 @@
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <addresstype.h>
+#include <blsct/wallet/import_wallet_type.h>
 #include <consensus/amount.h>
 #include <interfaces/chain.h>
 #include <pubkey.h>
@@ -323,7 +324,7 @@ class WalletLoader : public ChainClient
 {
 public:
     //! Create new wallet.
-    virtual util::Result<std::unique_ptr<Wallet>> createWallet(const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, std::vector<bilingual_str>& warnings) = 0;
+    virtual util::Result<std::unique_ptr<Wallet>> createWallet(const std::string& name, const SecureString& passphrase, const std::vector<unsigned char>& seed, const blsct::SeedType& type, uint64_t wallet_creation_flags, std::vector<bilingual_str>& warnings) = 0;
 
     //! Load existing wallet.
     virtual util::Result<std::unique_ptr<Wallet>> loadWallet(const std::string& name, std::vector<bilingual_str>& warnings) = 0;

src/mnemonic/language.h

@@ -0,0 +1,27 @@
+// Copyright (c) 2023-2023 The Navcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_MNEMONIC_LANGUAGE_H
+#define BITCOIN_MNEMONIC_LANGUAGE_H
+
+namespace mnemonic {
+
+typedef enum class language
+{
+    en,
+    es,
+    it,
+    fr,
+    cs,
+    pt,
+    ja,
+    ko,
+    zh_Hans,
+    zh_Hant,
+    none
+} language;
+
+} // namespace mnemonic
+
+#endif // BITCOIN_MNEMONIC_LANGUAGE_H

src/mnemonic/lexicon.cpp

@@ -0,0 +1,9 @@
+// Copyright (c) 2023-2023 The Navcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <mnemonic/lexicon.h>
+
+namespace mnemonic {
+
+} // namespace mnemonic

src/mnemonic/lexicon.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2023-2023 The Navcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_MNEMONIC_LEXICON_H
+#define BITCOIN_MNEMONIC_LEXICON_H
+
+#include <array>
+
+#include <mnemonic/language.h>
+
+namespace mnemonic {
+
+template <std::size_t Size>
+class lexicon final
+{
+public:
+    typedef std::array<const char*, Size> words;
+
+private:
+    // This dictionary creates only this one word of state.
+    const language identifier_;
+
+    // Arrays of words are declared statically and held by reference here.
+    // The array type is POD, so no words are copied into the array. Only
+    // this wrapper dictionary object is created for each word list, for
+    // each dictionaries object constructed by various mnemonic classes.
+    const words& words_;
+};
+
+} // namespace mnemonic
+
+#endif // BITCOIN_MNEMONIC_LEXICON_H