Initial commit

.gitignore

+*.a
+*.sw*
+
+*.cmake
+CMakeCache.txt
+CMakeFiles
+Makefile
+compile_commands.json
+moc_*
+*.moc
+
+genesis.json
+hardfork.hpp
+
+libraries/utilities/git_revision.cpp
+
+libraries/wallet/Doxyfile
+libraries/wallet/api_documentation.cpp
+libraries/wallet/doxygen
+
+programs/cli_wallet/cli_wallet
+programs/js_operation_serializer/js_operation_serializer
+programs/witness_node/witness_node
+
+tests/app_test
+tests/chain_bench
+tests/chain_test
+tests/intense_test
+tests/performance_test
+
+doxygen
+
+wallet.json
+witness_node_data_dir
+
+*.wallet
+
+programs/witness_node/object_database/*
+
+object_database/*
+
+*.pyc
+*.pyo
+
+build/*
+build-debug/*

.gitmodules

+[submodule "libraries/fc"]
+    path = libraries/fc
+    url = https://github.com/bitshares/bitshares-fc.git
+    ignore = dirty
+[submodule "libraries/chainbase"]
+	path = libraries/chainbase
+	url = https://github.com/bytemaster/chainbase
+[submodule "libraries/wren"]
+	path = libraries/wren
+	url = https://github.com/bytemaster/wren.git

CMakeLists.txt

+# Defines Eos library target.
+project( Eos )
+cmake_minimum_required( VERSION 2.8.12 )
+
+set( BLOCKCHAIN_NAME "BitShares" )
+
+set( CLI_CLIENT_EXECUTABLE_NAME eos_client )
+set( GUI_CLIENT_EXECUTABLE_NAME eos )
+set( CUSTOM_URL_SCHEME "gcs" )
+set( INSTALLER_APP_ID "68ad7005-8eee-49c9-95ce-9eed97e5b347" )
+
+# http://stackoverflow.com/a/18369825
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
+        message(FATAL_ERROR "GCC version must be at least 4.8!")
+    endif()
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.3)
+        message(FATAL_ERROR "Clang version must be at least 3.3!")
+    endif()
+endif()
+
+list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules" )
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS "ON")
+set(EOS_EGENESIS_JSON "${CMAKE_CURRENT_SOURCE_DIR}/genesis.json" )
+
+#set (ENABLE_INSTALLER 1)
+#set (USE_PCH 1)
+
+if (USE_PCH)
+  include (cotire)
+endif(USE_PCH)
+
+list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libraries/fc/CMakeModules" )
+list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libraries/fc/GitVersionGen" )
+include( GetGitRevisionDescription )
+get_git_head_revision( GIT_REFSPEC GIT_SHA2 )
+
+SET(BOOST_COMPONENTS)
+LIST(APPEND BOOST_COMPONENTS thread
+                             date_time
+                             system
+                             filesystem
+                             program_options
+                             signals
+                             serialization
+                             chrono
+                             unit_test_framework
+                             context
+                             locale)
+SET( Boost_USE_STATIC_LIBS ON CACHE STRING "ON or OFF" )
+
+IF( WIN32 )
+  SET(BOOST_ROOT $ENV{BOOST_ROOT})
+  set(Boost_USE_MULTITHREADED ON)
+  set(BOOST_ALL_DYN_LINK OFF) # force dynamic linking for all libraries
+ENDIF(WIN32)
+
+FIND_PACKAGE(Boost 1.57 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+# For Boost 1.53 on windows, coroutine was not in BOOST_LIBRARYDIR and do not need it to build,  but if boost versin >= 1.54, find coroutine otherwise will cause link errors
+IF(NOT "${Boost_VERSION}" MATCHES "1.53(.*)")
+   SET(BOOST_LIBRARIES_TEMP ${Boost_LIBRARIES})
+   FIND_PACKAGE(Boost 1.54 REQUIRED COMPONENTS coroutine)
+   LIST(APPEND BOOST_COMPONENTS coroutine)
+   SET(Boost_LIBRARIES ${BOOST_LIBRARIES_TEMP} ${Boost_LIBRARIES})
+ENDIF()
+
+if( WIN32 )
+
+    message( STATUS "Configuring BitShares on WIN32")
+    set( DB_VERSION 60 )
+    set( BDB_STATIC_LIBS 1 )
+
+    set( ZLIB_LIBRARIES "" )
+    SET( DEFAULT_EXECUTABLE_INSTALL_DIR bin/ )
+
+    set(CRYPTO_LIB)
+
+    #looks like this flag can have different default on some machines.
+    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
+    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
+
+    # Probably cmake has a bug and vcxproj generated for executable in Debug conf. has disabled debug info
+    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /DEBUG")
+
+    # On windows tcl should be installed to the directory pointed by setenv.bat script
+    SET(TCL_INCLUDE_PATH $ENV{TCL_ROOT}/include)
+    MESSAGE(STATUS "tcl INCLUDE PATH: ${TCL_INCLUDE_PATH}")
+
+    FIND_PACKAGE(TCL)
+    MESSAGE(STATUS "tcl_library: ${TCL_LIBRARY}")
+
+    SET(TCL_LIBS "optimized;${TCL_LIBRARY};debug;")
+    get_filename_component(TCL_LIB_PATH "${TCL_LIBRARY}" PATH)
+    get_filename_component(TCL_LIB_NAME "${TCL_LIBRARY}" NAME_WE)
+    get_filename_component(TCL_LIB_EXT "${TCL_LIBRARY}" EXT)
+
+    SET(TCL_LIBS "${TCL_LIBS}${TCL_LIB_PATH}/${TCL_LIB_NAME}g${TCL_LIB_EXT}")
+    SET(TCL_LIBRARY ${TCL_LIBS})
+
+else( WIN32 ) # Apple AND Linux
+
+    find_library(READLINE_LIBRARIES NAMES readline)
+    find_path(READLINE_INCLUDE_DIR readline/readline.h)
+    #if(NOT READLINE_INCLUDE_DIR OR NOT READLINE_LIBRARIES)
+    #  MESSAGE(FATAL_ERROR "Could not find lib readline.")
+    #endif()
+
+    if( APPLE )
+        # Apple Specific Options Here
+        message( STATUS "Configuring BitShares on OS X" )
+        set( CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++11 -stdlib=libc++ -Wall" )
+    else( APPLE )
+        # Linux Specific Options Here
+        message( STATUS "Configuring BitShares on Linux" )
+        set( CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++11 -Wall" )
+        set( rt_library rt )
+        set( pthread_library pthread)
+        if ( NOT DEFINED crypto_library )
+          # I'm not sure why this is here, I guess someone has openssl and can't detect it with find_package()?
+          # if you have a normal install, you can define crypto_library to the empty string to avoid a build error
+          set( crypto_library crypto)
+        endif ()
+        if ( FULL_STATIC_BUILD )
+          set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc")
+        endif ( FULL_STATIC_BUILD )
+    endif( APPLE )
+
+    if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" )
+        set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-memcmp" )
+    endif()
+
+    if( "${CMAKE_GENERATOR}" STREQUAL "Ninja" )
+        if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
+            set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics" )
+        endif()
+    endif()
+
+    # based on http://www.delorie.com/gnu/docs/gdb/gdb_70.html
+    # uncomment this line to tell GDB about macros (slows compile times)
+    # set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-2 -g3" )
+
+endif( WIN32 )
+
+set(ENABLE_COVERAGE_TESTING FALSE CACHE BOOL "Build BitShares for code coverage analysis")
+
+if(ENABLE_COVERAGE_TESTING)
+    SET(CMAKE_CXX_FLAGS "--coverage ${CMAKE_CXX_FLAGS}")
+endif()
+
+add_subdirectory( libraries )
+add_subdirectory( programs )
+add_subdirectory( tests )
+
+if (ENABLE_INSTALLER)
+
+set(VERSION_MAJOR 0)
+set(VERSION_MINOR 1)
+set(VERSION_PATCH 0)
+
+
+include(InstallRequiredSystemLibraries)
+
+set(CPACK_OUTPUT_FILE_PREFIX ${CMAKE_BINARY_DIR}/packages)
+set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/install)
+
+SET(CPACK_PACKAGE_DIRECTORY "${CMAKE_INSTALL_PREFIX}")
+set(CPACK_PACKAGE_NAME "eos")
+set(CPACK_PACKAGE_VENDOR "EOSIO")
+set(CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}")
+set(CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}")
+set(CPACK_PACKAGE_VERSION_PATCH "${VERSION_PATCH}")
+set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+set(CPACK_PACKAGE_DESCRIPTION "A client for the BitShares network")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A client for the BitShares network")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "BitShares ${CPACK_PACKAGE_VERSION}")
+
+if(WIN32)
+ SET(CPACK_GENERATOR "ZIP;NSIS")
+ set(CPACK_PACKAGE_NAME "BitShares") # override above
+ set(CPACK_NSIS_EXECUTABLES_DIRECTORY .)
+ set(CPACK_NSIS_PACKAGE_NAME "BitShares v${CPACK_PACKAGE_VERSION}")
+ set(CPACK_NSIS_DISPLAY_NAME "${CPACK_NSIS_PACKAGE_NAME}")
+ set(CPACK_NSIS_DEFINES "  !define MUI_STARTMENUPAGE_DEFAULTFOLDER \\\"BitShares\\\"")
+ # it seems like windows zip files usually don't have a single directory inside them, unix tgz frequently do
+ SET(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
+
+endif(WIN32)
+
+if(APPLE)
+  set(CPACK_GENERATOR "DragNDrop")
+endif()
+
+if(LINUX)
+  # Linux gets a .tgz
+  SET(CPACK_GENERATOR "TGZ")
+  SET(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 1)
+endif(LINUX)
+
+ include(CPack)
+endif(ENABLE_INSTALLER)

CMakeModules/FindGperftools.cmake

+# Tries to find Gperftools.
+#
+# Usage of this module as follows:
+#
+#     find_package(Gperftools)
+#
+# Variables used by this module, they can change the default behaviour and need
+# to be set before calling find_package:
+#
+#  Gperftools_ROOT_DIR  Set this variable to the root installation of
+#                       Gperftools if the module has problems finding
+#                       the proper installation path.
+#
+# Variables defined by this module:
+#
+#  GPERFTOOLS_FOUND              System has Gperftools libs/headers
+#  GPERFTOOLS_LIBRARIES          The Gperftools libraries (tcmalloc & profiler)
+#  GPERFTOOLS_INCLUDE_DIR        The location of Gperftools headers
+
+find_library(GPERFTOOLS_TCMALLOC
+  NAMES tcmalloc
+  HINTS ${Gperftools_ROOT_DIR}/lib)
+
+find_library(GPERFTOOLS_PROFILER
+  NAMES profiler
+  HINTS ${Gperftools_ROOT_DIR}/lib)
+
+find_library(GPERFTOOLS_TCMALLOC_AND_PROFILER
+  NAMES tcmalloc_and_profiler
+  HINTS ${Gperftools_ROOT_DIR}/lib)
+
+find_path(GPERFTOOLS_INCLUDE_DIR
+  NAMES gperftools/heap-profiler.h
+  HINTS ${Gperftools_ROOT_DIR}/include)
+
+set(GPERFTOOLS_LIBRARIES ${GPERFTOOLS_TCMALLOC_AND_PROFILER})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+  Gperftools
+  DEFAULT_MSG
+  GPERFTOOLS_LIBRARIES
+  GPERFTOOLS_INCLUDE_DIR)
+
+mark_as_advanced(
+  Gperftools_ROOT_DIR
+  GPERFTOOLS_TCMALLOC
+  GPERFTOOLS_PROFILER
+  GPERFTOOLS_TCMALLOC_AND_PROFILER
+  GPERFTOOLS_LIBRARIES
+  GPERFTOOLS_INCLUDE_DIR)

HEADER

+/*
+ * Copyright (c) 2017, Respective Authors.
+ *
+ * The MIT License
+ *
+ * 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, 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:
+ *
+ * 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.txt

+Copyright (c) 2017, Respective Authors
+
+The MIT License
+
+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, 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:
+
+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.

genesis.json

+{
+  "initial_timestamp": "2017-03-30T12:00:00",
+  "initial_parameters": {
+    "block_interval": 5,
+    "maintenance_interval": 86400,
+    "maintenance_skip_slots": 3,
+    "maximum_transaction_size": 2048,
+    "maximum_block_size": 2048000000,
+    "maximum_time_until_expiration": 86400,
+    "maximum_producer_count": 1001
+  },
+  "immutable_parameters": {
+    "min_producer_count": 11
+  },
+  "initial_accounts": [{
+    "name": "init00",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init01",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init02",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init03",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init04",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init05",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init06",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init07",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init08",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init09",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "name": "init10",
+    "owner_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
+    "active_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  }],
+  "initial_producers": [{
+    "owner_name": "init00",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init01",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init02",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init03",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init04",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init05",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init06",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init07",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init08",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init09",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },{
+    "owner_name": "init10",
+    "block_signing_key": "GPH6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
+  },],
+  "initial_producer_count": 11,
+  "initial_chain_id": "0000000000000000000000000000000000000000000000000000000000000000"
+}

libraries/CMakeLists.txt

+add_subdirectory( fc )
+add_subdirectory( chainbase )
+add_subdirectory( wren )
+add_subdirectory( deterministic_openssl_rand )
+add_subdirectory( chain )
+add_subdirectory( egenesis )
+add_subdirectory( net )
+add_subdirectory( utilities )
+add_subdirectory( app )
+add_subdirectory( plugins )

libraries/app/CMakeLists.txt

+file(GLOB HEADERS "include/eos/app/*.hpp")
+file(GLOB EGENESIS_HEADERS "../egenesis/include/eos/app/*.hpp")
+
+add_library( eos_app 
+             api.cpp
+             application.cpp
+             plugin.cpp
+             ${HEADERS}
+             ${EGENESIS_HEADERS}
+           )
+
+# need to link eos_debug_producer because plugins aren't sufficiently isolated #246
+target_link_libraries( eos_app eos_chain fc eos_net eos_utilities eos_debug_producer )
+target_include_directories( eos_app
+                            PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include"
+                            "${CMAKE_CURRENT_SOURCE_DIR}/../egenesis/include" )
+
+if(MSVC)
+  set_source_files_properties( application.cpp api.cpp database_api.cpp PROPERTIES COMPILE_FLAGS "/bigobj" )
+endif(MSVC)
+
+INSTALL( TARGETS
+   eos_app
+
+   RUNTIME DESTINATION bin
+   LIBRARY DESTINATION lib
+   ARCHIVE DESTINATION lib
+)
+INSTALL( FILES ${HEADERS} DESTINATION "include/eos/app" )

libraries/app/api.cpp

+/*
+ * Copyright (c) 2017, Respective Authors.
+ *
+ * The MIT License
+ *
+ * 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, 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:
+ *
+ * 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.
+ */
+#include <cctype>
+
+#include <eos/app/api.hpp>
+#include <eos/app/api_access.hpp>
+#include <eos/app/application.hpp>
+#include <eos/chain/database.hpp>
+#include <eos/chain/get_config.hpp>
+#include <eos/utilities/key_conversion.hpp>
+#include <eos/chain/transaction_object.hpp>
+
+#include <fc/crypto/hex.hpp>
+#include <fc/smart_ref_impl.hpp>
+
+namespace eos { namespace app {
+
+    login_api::login_api(application& a)
+    :_app(a)
+    {
+    }
+
+    login_api::~login_api()
+    {
+    }
+
+    bool login_api::login(const string& user, const string& password)
+    {
+       optional< api_access_info > acc = _app.get_api_access_info( user );
+       if( !acc.valid() )
+          return false;
+       if( acc->password_hash_b64 != "*" )
+       {
+          std::string password_salt = fc::base64_decode( acc->password_salt_b64 );
+          std::string acc_password_hash = fc::base64_decode( acc->password_hash_b64 );
+
+          fc::sha256 hash_obj = fc::sha256::hash( password + password_salt );
+          if( hash_obj.data_size() != acc_password_hash.length() )
+             return false;
+          if( memcmp( hash_obj.data(), acc_password_hash.c_str(), hash_obj.data_size() ) != 0 )
+             return false;
+       }
+
+       for( const std::string& api_name : acc->allowed_apis )
+          enable_api( api_name );
+       return true;
+    }
+
+    void login_api::enable_api( const std::string& api_name )
+    {
+       if( api_name == "block_api" )
+       {
+          _block_api = std::make_shared< block_api >( std::ref( *_app.chain_database() ) );
+       }
+       else if( api_name == "network_broadcast_api" )
+       {
+          _network_broadcast_api = std::make_shared< network_broadcast_api >( std::ref( _app ) );
+       }
+       else if( api_name == "network_node_api" )
+       {
+          _network_node_api = std::make_shared< network_node_api >( std::ref(_app) );
+       }
+       else if( api_name == "debug_api" )
+       {
+          // can only enable this API if the plugin was loaded
+          if( _app.get_plugin( "debug_producer" ) )
+             _debug_api = std::make_shared< eos::debug_producer::debug_api >( std::ref(_app) );
+       }
+       return;
+    }
+
+    // block_api
+    block_api::block_api(eos::chain::database& db) : _db(db) { }
+    block_api::~block_api() { }
+
+    vector<optional<signed_block>> block_api::get_blocks(uint32_t block_num_from, uint32_t block_num_to)const
+    {
+       FC_ASSERT( block_num_to >= block_num_from );
+       vector<optional<signed_block>> res;
+       for(uint32_t block_num=block_num_from; block_num<=block_num_to; block_num++) {
+          res.push_back(_db.fetch_block_by_number(block_num));
+       }
+       return res;
+    }
+
+    network_broadcast_api::network_broadcast_api(application& a):_app(a)
+    {
+       _applied_block_connection = _app.chain_database()->applied_block.connect([this](const signed_block& b){ on_applied_block(b); });
+    }
+
+    void network_broadcast_api::on_applied_block( const signed_block& b )
+    {
+       if( _callbacks.size() )
+       {
+          /// we need to ensure the database_api is not deleted for the life of the async operation
+          auto capture_this = shared_from_this();
+          for( uint32_t trx_num = 0; trx_num < b.transactions.size(); ++trx_num )
+          {
+             const auto& trx = b.transactions[trx_num];
+             auto id = trx.id();
+             auto itr = _callbacks.find(id);
+             if( itr != _callbacks.end() )
+             {
+                auto block_num = b.block_num();
+                auto& callback = _callbacks.find(id)->second;
+                fc::async( [capture_this,this,id,block_num,trx_num,trx,callback](){ callback( fc::variant(transaction_confirmation{ id, block_num, trx_num, trx}) ); } );
+             }
+          }
+       }
+    }
+
+    void network_broadcast_api::broadcast_transaction(const signed_transaction& trx)
+    {
+       trx.validate();
+       _app.chain_database()->push_transaction(trx);
+       _app.p2p_node()->broadcast_transaction(trx);
+    }
+
+    void network_broadcast_api::broadcast_block( const signed_block& b )
+    {
+       _app.chain_database()->push_block(b);
+       _app.p2p_node()->broadcast( net::block_message( b ));
+    }
+
+    void network_broadcast_api::broadcast_transaction_with_callback(confirmation_callback cb, const signed_transaction& trx)
+    {
+       trx.validate();
+       _callbacks[trx.id()] = cb;
+       _app.chain_database()->push_transaction(trx);
+       _app.p2p_node()->broadcast_transaction(trx);
+    }
+
+    network_node_api::network_node_api( application& a ) : _app( a )
+    {
+    }
+
+    fc::variant_object network_node_api::get_info() const
+    {
+       fc::mutable_variant_object result = _app.p2p_node()->network_get_info();
+       result["connection_count"] = _app.p2p_node()->get_connection_count();
+       return result;
+    }
+
+    void network_node_api::add_node(const fc::ip::endpoint& ep)
+    {
+       _app.p2p_node()->add_node(ep);
+    }
+
+    std::vector<net::peer_status> network_node_api::get_connected_peers() const
+    {
+       return _app.p2p_node()->get_connected_peers();
+    }
+
+    std::vector<net::potential_peer_record> network_node_api::get_potential_peers() const
+    {
+       return _app.p2p_node()->get_potential_peers();
+    }
+
+    fc::variant_object network_node_api::get_advanced_node_parameters() const
+    {
+       return _app.p2p_node()->get_advanced_node_parameters();
+    }
+
+    void network_node_api::set_advanced_node_parameters(const fc::variant_object& params)
+    {
+       return _app.p2p_node()->set_advanced_node_parameters(params);
+    }
+
+    fc::api<network_broadcast_api> login_api::network_broadcast()const
+    {
+       FC_ASSERT(_network_broadcast_api);
+       return *_network_broadcast_api;
+    }
+
+    fc::api<block_api> login_api::block()const
+    {
+       FC_ASSERT(_block_api);
+       return *_block_api;
+    }
+
+    fc::api<network_node_api> login_api::network_node()const
+    {
+       FC_ASSERT(_network_node_api);
+       return *_network_node_api;
+    }
+
+    fc::api<eos::debug_producer::debug_api> login_api::debug() const
+    {
+       FC_ASSERT(_debug_api);
+       return *_debug_api;
+    }
+
+} } // eos::app

libraries/app/include/eos/app/api.hpp

+/*
+ * Copyright (c) 2017, Respective Authors.
+ *
+ * The MIT License
+ *
+ * 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, 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:
+ *
+ * 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.
+ */
+#pragma once
+
+#include <eos/chain/database.hpp>
+#include <eos/chain/protocol/types.hpp>
+
+#include <eos/debug_producer/debug_api.hpp>
+
+#include <eos/net/node.hpp>
+
+#include <fc/api.hpp>
+#include <fc/optional.hpp>
+#include <fc/crypto/elliptic.hpp>
+#include <fc/network/ip.hpp>
+
+#include <boost/container/flat_set.hpp>
+
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace eos { namespace app {
+   using namespace eos::chain;
+   using namespace fc::ecc;
+   using namespace std;
+
+   class application;
+
+   /**
+    * @brief Block api
+    */
+   class block_api
+   {
+   public:
+      block_api(eos::chain::database& db);
+      ~block_api();
+
+      vector<optional<signed_block>> get_blocks(uint32_t block_num_from, uint32_t block_num_to)const;
+
+   private:
+      eos::chain::database& _db;
+   };
+
+   /**
+    * @brief The network_broadcast_api class allows broadcasting of transactions.
+    */
+   class network_broadcast_api : public std::enable_shared_from_this<network_broadcast_api>
+   {
+      public:
+         network_broadcast_api(application& a);
+
+         struct transaction_confirmation
+         {
+            transaction_id_type   id;
+            uint32_t              block_num;
+            uint32_t              trx_num;
+            signed_transaction trx;
+         };
+
+         typedef std::function<void(variant/*transaction_confirmation*/)> confirmation_callback;
+
+         /**
+          * @brief Broadcast a transaction to the network
+          * @param trx The transaction to broadcast
+          *
+          * The transaction will be checked for validity in the local database prior to broadcasting. If it fails to
+          * apply locally, an error will be thrown and the transaction will not be broadcast.
+          */
+         void broadcast_transaction(const signed_transaction& trx);
+
+         /** this version of broadcast transaction registers a callback method that will be called when the transaction is
+          * included into a block.  The callback method includes the transaction id, block number, and transaction number in the
+          * block.
+          */
+         void broadcast_transaction_with_callback( confirmation_callback cb, const signed_transaction& trx);
+
+         void broadcast_block( const signed_block& block );
+
+         /**
+          * @brief Not reflected, thus not accessible to API clients.
+          *
+          * This function is registered to receive the applied_block
+          * signal from the chain database when a block is received.
+          * It then dispatches callbacks to clients who have requested
+          * to be notified when a particular txid is included in a block.
+          */
+         void on_applied_block( const signed_block& b );
+      private:
+         boost::signals2::scoped_connection             _applied_block_connection;
+         map<transaction_id_type,confirmation_callback> _callbacks;
+         application&                                   _app;
+   };
+
+   /**
+    * @brief The network_node_api class allows maintenance of p2p connections.
+    */
+   class network_node_api
+   {
+      public:
+         network_node_api(application& a);
+
+         /**
+          * @brief Return general network information, such as p2p port
+          */
+         fc::variant_object get_info() const;
+
+         /**
+          * @brief add_node Connect to a new peer
+          * @param ep The IP/Port of the peer to connect to
+          */
+         void add_node(const fc::ip::endpoint& ep);
+
+         /**
+          * @brief Get status of all current connections to peers
+          */
+         std::vector<net::peer_status> get_connected_peers() const;
+
+         /**
+          * @brief Get advanced node parameters, such as desired and max
+          *        number of connections
+          */
+         fc::variant_object get_advanced_node_parameters() const;
+
+         /**
+          * @brief Set advanced node parameters, such as desired and max
+          *        number of connections
+          * @param params a JSON object containing the name/value pairs for the parameters to set
+          */
+         void set_advanced_node_parameters(const fc::variant_object& params);
+
+         /**
+          * @brief Return list of potential peers
+          */
+         std::vector<net::potential_peer_record> get_potential_peers() const;
+
+      private:
+         application& _app;
+   };
+   
+   /**
+    * @brief The login_api class implements the bottom layer of the RPC API
+    *
+    * All other APIs must be requested from this API.
+    */
+   class login_api
+   {
+      public:
+         login_api(application& a);
+         ~login_api();
+
+         /**
+          * @brief Authenticate to the RPC server
+          * @param user Username to login with
+          * @param password Password to login with
+          * @return True if logged in successfully; false otherwise
+          *
+          * @note This must be called prior to requesting other APIs. Other APIs may not be accessible until the client
+          * has sucessfully authenticated.
+          */
+         bool login(const string& user, const string& password);
+         /// @brief Retrieve the network block API
+         fc::api<block_api> block()const;
+         /// @brief Retrieve the network broadcast API
+         fc::api<network_broadcast_api> network_broadcast()const;
+         /// @brief Retrieve the network node API
+         fc::api<network_node_api> network_node()const;
+         /// @brief Retrieve the debug API (if available)
+         fc::api<eos::debug_producer::debug_api> debug()const;
+
+         /// @brief Called to enable an API, not reflected.
+         void enable_api( const string& api_name );
+      private:
+
+         application& _app;
+         optional< fc::api<block_api> > _block_api;
+         optional< fc::api<network_broadcast_api> > _network_broadcast_api;
+         optional< fc::api<network_node_api> > _network_node_api;
+         optional< fc::api<eos::debug_producer::debug_api> > _debug_api;
+   };
+
+}}  // eos::app
+
+FC_REFLECT( eos::app::network_broadcast_api::transaction_confirmation,
+        (id)(block_num)(trx_num)(trx) )
+
+FC_API(eos::app::block_api,
+       (get_blocks)
+     )
+FC_API(eos::app::network_broadcast_api,
+       (broadcast_transaction)
+       (broadcast_transaction_with_callback)
+       (broadcast_block)
+     )
+FC_API(eos::app::network_node_api,
+       (get_info)
+       (add_node)
+       (get_connected_peers)
+       (get_potential_peers)
+       (get_advanced_node_parameters)
+       (set_advanced_node_parameters)
+     )
+FC_API(eos::app::login_api,
+       (login)
+       (block)
+       (network_broadcast)
+       (network_node)
+       (debug)
+     )

libraries/app/include/eos/app/api_access.hpp

+/*
+ * Copyright (c) 2017, Respective Authors.
+ *
+ * The MIT License
+ *
+ * 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, 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:
+ *
+ * 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.
+ */
+#pragma once
+
+#include <fc/reflect/reflect.hpp>
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace eos { namespace app {
+
+struct api_access_info
+{
+   std::string password_hash_b64;
+   std::string password_salt_b64;
+   std::vector< std::string > allowed_apis;
+};
+
+struct api_access
+{
+   std::map< std::string, api_access_info > permission_map;
+};
+
+} } // eos::app
+
+FC_REFLECT( eos::app::api_access_info,
+    (password_hash_b64)
+    (password_salt_b64)
+    (allowed_apis)
+   )
+
+FC_REFLECT( eos::app::api_access,
+    (permission_map)
+   )

chainbase @ 34d8f632

+Subproject commit 34d8f632857d02cbe412f4bb43bbae3380e8f541

fc @ 1f41494f

+Subproject commit 1f41494f360a1800fc967d647631cf64fdc549ee