bip32.cpp

Go to the documentation of this file.

// Copyright (c) 2019-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 <util/bip32.h>
 
#include <tinyformat.h>
#include <util/strencodings.h>
 
#include <algorithm>
#include <cstdint>
#include <optional>
#include <span>
#include <sstream>
#include <string_view>
 
util::Expected<KeyPathElement, std::string> ParseKeyPathElement(std::span<const char> elem)
{
    const std::string_view raw{elem.begin(), elem.end()};
    if (elem.empty()) {
        return util::Unexpected{strprintf("Key path value '%s' is not valid", raw)};
    }
 
    bool is_hardened = false;
    const char last = elem.back();
    if (last == '\'' || last == 'h') {
        elem = elem.first(elem.size() - 1);
        is_hardened = true;
    }
 
    const auto number{ToIntegral<uint32_t>(std::string_view{elem.begin(), elem.end()})};
    if (!number) {
        return util::Unexpected{strprintf("Key path value '%s' is not a valid uint32", raw)};
    }
    if (*number >= BIP32_HARDENED_FLAG) {
        return util::Unexpected{strprintf("Key path value %u is out of range", *number)};
    }
    return KeyPathElement{*number, is_hardened};
}
 
bool ParseHDKeypath(const std::string& keypath_str, std::vector<uint32_t>& keypath)
{
    std::stringstream ss(keypath_str);
    std::string item;
    bool first = true;
    while (std::getline(ss, item, '/') || std::getline(ss, item, 'h')) {
        if (item.compare("m") == 0) {
            if (first) {
                first = false;
                continue;
            }
            return false;
        }
        const auto parsed{ParseKeyPathElement(std::span<const char>{item.data(), item.size()})};
        if (!parsed) return false;
        keypath.push_back(parsed->ChildNumber());
        first = false;
    }
    return true;
}
 
std::string FormatHDKeypath(const std::vector<uint32_t>& path, bool apostrophe)
{
    std::string ret;
    for (auto i : path) {
        ret += strprintf("/%i", (i << 1) >> 1);
        if (i >> 31) ret += apostrophe ? '\'' : 'h';
    }
    return ret;
}
 
std::string WriteHDKeypath(const std::vector<uint32_t>& keypath, bool apostrophe)
{
    return "m" + FormatHDKeypath(keypath, apostrophe);
}
 
bool HasHardenedDerivation(std::span<const uint32_t> keypath)
{
    return std::any_of(keypath.begin(), keypath.end(), [](uint32_t index) {
        return index >> 31;
    });
}