MUL-2: MVP for generating seed pharase, private/publick keys and addresses for BTC and ETH

C++ library with a C-style interface, tests and third-party dependencies as git subtrees.

Features:

    BIP39 entropy to seed phrase and root key derivation.
    BIP44 account derivation.
    Bitcoin and Ethereum accounts as leafs of the same derivation tree, originating from single seed phrase.
    P2PKH addresses for Bitcoin accounts.
    Importing existing Bitcoin accounts in WIF.
    Importing existing Ethereum accounts.

Author: Enmk

CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.1)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+option(WITH_TESTS "Build tests shared library (DLL)" NO)
+set(LIBWALLY_BIN "" CACHE FILEPATH "Path to prebuild libwally-core")
+set(LIBWALLY_BIN_PATH "" CACHE PATH "Path to directory with prebuild libwally-core")
+set(LIBSECP256K1_BIN "" CACHE FILEPATH "Path to prebuild libsecp256k1")
+set(LIBSECP256K1_BIN_PATH "" CACHE PATH "Path to directory with prebuild libsecp256k1")
+
+project(multy)
+
+add_executable(
+    multy
+    main.cpp
+)
+target_link_libraries(multy PRIVATE multy_core)
+target_include_directories(multy PRIVATE .)
+
+add_subdirectory(multy_core)
+add_subdirectory(third-party)
+
+if(WITH_TESTS)
+    target_compile_definitions(multy PRIVATE WITH_TESTS)
+    add_subdirectory(multy_test)
+    target_link_libraries(multy PRIVATE multy_test)
+endif()
+

CMakeLists.txt.user

@@ -0,0 +1,75 @@
+First of all, use common scene.
+
+Code has to be written for humans to read, do not overenginner nor overcomplicate.
+
+## Exceptions
+All rules are soft enough to be lifted upon violation of common sense, but before breaking any rule, please discuss the case, since the rule itself might have an error on its own. Explicitly mark the exception with "CODING STYLE EXCEPTION" in comments.
+
+Following does not apply to the code borrowed from other projects, like the dependencies in third-party.
+That is required to simplify merging when bumping version of dependency and\or updating the snippet.
+
+## Formatting
+Use clang-format with enclosed clang-format.txt style on modified files before pushing them upstream.
+**Notice:** Sometime clang-format (as of version 3.8) produces very ugly results. In this case please don't just blindly commit your changes, but revert pieces that are utterly ugly. Notable examples are C++11 lambdas and array initializers.
+
+## Global
+C++11, not C-with-classes.
+
+Why C++11 but not 14, 17? This project aim is to be core of mobile app, and some target toolchains\SDKs do not support C++14 and above (in fact, even C++11 is not fully supported).
+
+That means you are encouraged to use:
+
+- STL
+- smart-pointers
+- exceptions
+- auto (with moderation)
+- GLSL (TODO)
+
+## Interfaces
+We use C++11, however, due to ABI compatibility reasons and to simplify integration with other languages\platforms, core library has a C-like interface.
+That means:
+
+- API functions should be ```extern "C"```
+- API functions take only primitive types and structs as argument, no C++ classes.
+- API functions throw no exceptions
+- Public headers do no include C++ headers (even standard ones).
+
+General rules of thumb: 
+
+- API functions should have an explanation comment, stating function purpose, expectation on arguments values and promises on produced values.
+- If function is complicated enough, please put a comment at the very to, briefly describing what and why at the top-level.
+- All data\objects allocated within the library should be freed in the library.
+	- Preferably a data\objects allocated\created in the translation unit, should be deallocated from that same unit.
+- Function arguments
+
+## Naming
+
+- All types, that is classes, structs, enums, typedefs are camel-case and begin with capital letter. 
+- All functions use snake_case and NOT capitalized.
+	- Function name should begin with verb. 
+	- Function that creates new object should have `make_` prefix, like `make_acount()`.
+- Variables (function parameters too) are all `snake_case` (all lower case), must be a noun.
+- Struct members follow rules for variables, and should have no prefixes.
+- Class members follow rules for variables, but also have a `m_` prefix.
+- Global constants and enum values, are `SNAKE_CASE`.
+
+```
+class Foo
+{
+};
+
+struct Bar
+{
+};
+
+```
+
+## Tests
+Write code with tests in mind, code which is not tested can't be really used. Please write tests even for trivial functions. However, do not test libc, OS, network and\or other external stuff, unless that is required specifically.
+We use gtest framework for unit-tests.
+Every library shipped should have a corresponding test library, where all unit-tests reside. That allows to ship  test libraries to the target devices and verify correctness of the library. It is Ok to include in the test library specific tests for the dependencies of the shipped library.
+
+## Dependencies
+We would like to minimizer library footprint and hence tend to minimize dependency, please do not bring you super-huge-and-cool-framewok if you need only a string-to-hex convertion function.
+Prefer C-libraries as dependencies over C++ counterparts, since those are generally more portable, easier to read and maintain.
+Right now we would like to avoid dependency on boost.

CODING_STYLE.md

@@ -0,0 +1,11 @@
+Note: the modules in the third-party or tools directories have their own licenses, but except where noted in an individual source file, the rest of the code is covered by the following license:
+
+Copyright 2017 Idealnaya rabota LLC (Republic of Belarus)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute (with limitations described below), sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+You shall not distribute in binary form any substantial portion of the Software if it has any modifications (in source code or assets) compared to original distribution from Idealnaya rabota LLC (Republic of Belarus) obtained from the official repository at https://github.com/Multy-io/ or https://github.com/Appscrunch.
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE

@@ -0,0 +1,77 @@
+/* Copyright 2017 by Multy.io
+ * Licensed under Multy.io license.
+ *
+ * See LICENSE for details
+ */
+
+#include "multy_core/mnemonic.h"
+
+#include "multy_core/common.h"
+#include "multy_core/error.h"
+#include "multy_core/internal/utility.h"
+
+#include "multy_test/run_tests.h"
+
+#include <iostream>
+#include <memory>
+#include <string.h>
+
+namespace
+{
+
+size_t entropySource(size_t size, void* dest)
+{
+    /** Poor man's entropy, using uninitialized data from stack, which is:
+     * - Fast;
+     * - Unsecure;
+     * - Somewhat predictable;
+     * And hence SHOULD not be used in production, but Ok in POC driver program.
+     */
+    static const size_t entropy_max_size = 1024;
+    unsigned char silly_entropy[entropy_max_size];
+
+    if (size > entropy_max_size)
+    {
+        return 0;
+    }
+
+    memcpy(dest, silly_entropy, size);
+    return size;
+}
+
+using namespace wallet_core::internal;
+
+} // namespace
+
+int main(int argc, char** argv)
+{
+#ifdef WITH_TESTS
+    return run_tests(argc, argv);
+#else
+    try
+    {
+        auto mnemonic = null_unique_ptr<const char>(free_mnemonic);
+        throw_if_error(make_mnemonic(&entropySource, reset_sp(mnemonic)));
+        std::cout << "Generated mnemonic: " << mnemonic.get() << std::endl;
+
+        std::cout << "Enter password: ";
+        std::string password;
+        std::getline(std::cin, password);
+
+        auto seed = null_unique_ptr<BinaryData>(free_binarydata);
+        throw_if_error(
+                make_seed(mnemonic.get(), password.c_str(), reset_sp(seed)));
+
+        auto seed_string = null_unique_ptr<const char>(free_string);
+        throw_if_error(seed_to_string(seed.get(), reset_sp(seed_string)));
+        std::cout << "Seed: " << seed_string.get() << std::endl;
+    }
+    catch (Error* e)
+    {
+        std::cerr << "Got error: " << e->message << std::endl;
+        free_error(e);
+        return -1;
+    }
+    return 0;
+#endif
+}

main.cpp

@@ -0,0 +1,33 @@
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(multy_core
+    SHARED
+
+    src/account.cpp
+    src/common.cpp
+    src/error.cpp
+    src/keys.cpp
+    src/mnemonic.cpp
+
+    internal/account_base.cpp
+    internal/account.cpp
+    internal/bitcoin_account.cpp
+    internal/ethereum_account.cpp
+    internal/hd_path.cpp
+    internal/key.cpp
+    internal/u_ptr.cpp
+    internal/utility.cpp
+)
+
+target_compile_definitions(multy_core PRIVATE BUILDING_MULTY_CORE=1)
+target_include_directories(multy_core PRIVATE
+    ..
+    ../third-party/libwally-core/include/
+    ../third-party/libwally-core/src/ccan
+    ../third-party
+)
+
+target_link_libraries(multy_core libwally-core keccak-tiny)
+set_target_properties(multy_core PROPERTIES CXX_VISIBILITY_PRESET hidden)
+

multy_core/CMakeLists.txt

@@ -0,0 +1,128 @@
+/* Copyright 2017 by Multy.io
+ * Licensed under Multy.io license.
+ *
+ * See LICENSE for details
+ */
+
+#ifndef MULTY_CORE_ACCOUNT_H
+#define MULTY_CORE_ACCOUNT_H
+
+#include "multy_core/api.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct HDAccount;
+struct Account;
+struct Error;
+struct ExtendedKey;
+struct Key;
+
+enum Currency
+{
+    CURRENCY_BITCOIN,
+    CURRENCY_ETHEREUM,
+};
+
+enum AddressType
+{
+    ADDRESS_EXTERNAL,
+    ADDRESS_INTERNAL /** change-address **/
+};
+
+enum KeyType
+{
+    KEY_TYPE_PRIVATE,
+    KEY_TYPE_PUBLIC,
+};
+
+/** Make an account of given currency with given id.
+ *
+ * @param master_key - master key, generated from seed.
+ * @param currency - currency to use account for.
+ * @param index - acccount index
+ * @param account - (out) new account
+ */
+MULTY_CORE_API struct Error* make_hd_account(
+        const ExtendedKey* master_key,
+        Currency currency,
+        uint32_t index,
+        struct HDAccount** new_account);
+
+/** Make a leaf HD account - the one that has an address and can be paid from/to.
+ * @param base_account - base account, for which leaf is generated.
+ * @param address_type - type of address for account: internal or external.
+ * @param index - index of account within base account.
+ * @param new_account - newly created account, must be freed by caller with
+ * free_account().
+ */
+MULTY_CORE_API struct Error* make_hd_leaf_account(
+        const struct HDAccount* base_account,
+        AddressType address_type,
+        uint32_t index,
+        struct Account** new_account);
+
+/** Make regular account from private key and currency.
+ * @param currency - currency to use account for.
+ * @param serialized_private_key - private key for account.
+ * @param new_account - newly created account, must be freed by caller with
+ * free_account().
+ */
+MULTY_CORE_API struct Error* make_account(
+        Currency currency,
+        const char* serialized_private_key,
+        struct Account** new_account);
+
+/** Get a key from account.
+ *
+ * See keys.h for key manipulation API.
+ * @param account - the account to get the key from.
+ * @param key_type - either KEY_TYPE_PUBLIC or KEY_TYPE_PRIVTAE.
+ * @param out_key - resulting key, must be freed by caller with free_key().
+ */
+MULTY_CORE_API struct Error* get_account_key(
+        const struct Account* account,
+        KeyType key_type,
+        Key** out_key);
+
+/** Get account address as a string.
+ * @param account - account.
+ * @param out_address - address string, must be feed by caller with free_string().
+ */
+MULTY_CORE_API struct Error* get_account_address_string(
+        const struct Account* account,
+        const char** out_address);
+
+/** Get account HD path as a string.
+ *
+ * The path might be empty if account is not an HD-account, but an imported one.
+ * @param account - account.
+ * @param out_address_path - HD path string, must be feed by caller with free_string().
+ */
+MULTY_CORE_API struct Error* get_account_address_path(
+        const struct Account* account,
+        const char** out_address_path);
+
+/** Get account currency.
+ * @param account - account.
+ * @param out_currency - where to store the currency value.
+ */
+MULTY_CORE_API struct Error* get_account_currency(
+        const struct Account* account,
+        Currency* out_currency);
+
+/** Frees HDAccount instance, can accept nullptr. **/
+MULTY_CORE_API void free_hdaccount(struct HDAccount*);
+
+/** Frees Account instance, can accept nullptr. **/
+MULTY_CORE_API void free_account(struct Account*);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* MULTY_CORE_ACCOUNT_H */

multy_core/account.h

@@ -0,0 +1,26 @@
+/* Copyright 2017 by Multy.io
+ * Licensed under Multy.io license.
+ *
+ * See LICENSE for details
+ */
+
+#ifndef MULTY_CORE_API_H_INCLUDED
+#define MULTY_CORE_API_H_INCLUDED
+
+#ifndef BUILDING_MULTY_CORE
+#    define BUILDING_MULTY_CORE 0
+#endif
+
+#if defined(_WIN32)
+#    if (BUILDING_MULTY_CORE)
+#        define MULTY_CORE_API __declspec(dllexport)
+#    else
+#        define MULTY_CORE_API
+#    endif
+#elif defined(__GNUC__) && (BUILDING_MULTY_CORE)
+#    define MULTY_CORE_API __attribute__ ((visibility ("default")))
+#else
+#    define MULTY_CORE_API
+#endif
+
+#endif // MULTY_CORE_API_H_INCLUDED