walletutil.cpp

Go to the documentation of this file.

// Copyright (c) 2017-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <wallet/walletutil.h>
 
#include <chainparams.h>
#include <common/args.h>
#include <key_io.h>
#include <util/log.h>
 
namespace wallet {
fs::path GetWalletDir()
{
    fs::path path;
 
    if (gArgs.IsArgSet("-walletdir")) {
        path = gArgs.GetPathArg("-walletdir");
        if (!fs::is_directory(path)) {
            // If the path specified doesn't exist, we return the deliberately
            // invalid empty string.
            path = "";
        }
    } else {
        path = gArgs.GetDataDirNet();
        // If a wallets directory exists, use that, otherwise default to GetDataDir
        if (fs::is_directory(path / "wallets")) {
            path /= "wallets";
        }
    }
 
    return path;
}
 
WalletDescriptor GenerateWalletDescriptor(const CExtPubKey& master_key, const OutputType& addr_type, bool internal)
{
    int64_t creation_time = GetTime();
 
    std::string xpub = EncodeExtPubKey(master_key);
 
    // Build descriptor string
    std::string desc_prefix;
    std::string desc_suffix = "/*)";
    switch (addr_type) {
    case OutputType::LEGACY: {
        desc_prefix = "pkh(" + xpub + "/44h";
        break;
    }
    case OutputType::P2SH_SEGWIT: {
        desc_prefix = "sh(wpkh(" + xpub + "/49h";
        desc_suffix += ")";
        break;
    }
    case OutputType::BECH32: {
        desc_prefix = "wpkh(" + xpub + "/84h";
        break;
    }
    case OutputType::BECH32M: {
        desc_prefix = "tr(" + xpub + "/86h";
        break;
    }
    case OutputType::UNKNOWN: {
        // We should never have a DescriptorScriptPubKeyMan for an UNKNOWN OutputType,
        // so if we get to this point something is wrong
        assert(false);
    }
    } // no default case, so the compiler can warn about missing cases
    assert(!desc_prefix.empty());
 
    // Mainnet derives at 0', testnet and regtest derive at 1'
    if (Params().IsTestChain()) {
        desc_prefix += "/1h";
    } else {
        desc_prefix += "/0h";
    }
 
    std::string internal_path = internal ? "/1" : "/0";
    std::string desc_str = desc_prefix + "/0h" + internal_path + desc_suffix;
 
    // Make the descriptor
    FlatSigningProvider keys;
    std::string error;
    std::vector<std::unique_ptr<Descriptor>> desc = Parse(desc_str, keys, error, false);
    WalletDescriptor w_desc(std::move(desc.at(0)), creation_time, 0, 0, 0);
    return w_desc;
}
 
void WalletDescriptor::UpdateFrom(const WalletDescriptor& other)
{
    if (!IsCanonicallyEquivalent(other)) {
        return;
    }
    range_start = other.range_start;
    next_index = other.next_index;
    range_end = other.range_end;
    creation_time = other.creation_time;
    cache = other.cache;
}
 
uint256 WalletDescriptor::GetCanonicalHash() const
{
    if (!m_canonical_hash) {
        m_canonical_hash.emplace();
        std::string canonical = descriptor->ToCanonicalString();
        CSHA256().Write((unsigned char*)canonical.data(), canonical.size()).Finalize(m_canonical_hash->begin());
    }
    return *m_canonical_hash;
}
 
bool WalletDescriptor::IsCanonicallyEquivalent(const WalletDescriptor& other) const
{
    return GetCanonicalHash() == other.GetCanonicalHash();
}
 
} // namespace wallet