Bug fix

This reverts commit ca654590ea.

README.md

@@ -1,6 +1,12 @@
 Node-CryptoForkNote-Util with Merged Mining support
 ===================================================
 
+Installing locally and testing
+-----
+```
+npm install https://github.com/MoneroOcean/node-cryptoforknote-util
+```
+
 Dependencies
 ------------
 

binding.gyp

@@ -5,6 +5,7 @@
             "sources": [
                 "src/main.cc",
                 "src/cryptonote_core/cryptonote_format_utils.cpp",
+                "src/offshore/pricing_record.cpp",
                 "src/crypto/tree-hash.c",
                 "src/crypto/crypto.cpp",
                 "src/crypto/crypto-ops.c",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cryptoforknote-util",
-  "version": "7.0.2",
+  "version": "8.1.0",
   "main": "cryptoforknote-util",
   "author": {
     "name": "LucasJones",

src/common/base58.cpp

@@ -1,7 +1,32 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
+// Copyright (c) 2014-2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include "base58.h"
 
@@ -11,7 +36,6 @@
 
 #include "crypto/hash.h"
 #include "int-util.h"
-#include "util.h"
 #include "varint.h"
 
 namespace tools
@@ -84,20 +108,8 @@ namespace tools
         assert(1 <= size && size <= sizeof(uint64_t));
 
         uint64_t res = 0;
-        switch (9 - size)
-        {
-        case 1:            res |= *data++;
-        case 2: res <<= 8; res |= *data++;
-        case 3: res <<= 8; res |= *data++;
-        case 4: res <<= 8; res |= *data++;
-        case 5: res <<= 8; res |= *data++;
-        case 6: res <<= 8; res |= *data++;
-        case 7: res <<= 8; res |= *data++;
-        case 8: res <<= 8; res |= *data; break;
-        default: assert(false);
-        }
-
-        return res;
+        memcpy(reinterpret_cast<uint8_t*>(&res) + sizeof(uint64_t) - size, data, size);
+        return SWAP64BE(res);
       }
 
       void uint_64_to_8be(uint64_t num, size_t size, uint8_t* data)
@@ -110,7 +122,7 @@ namespace tools
 
       void encode_block(const char* block, size_t size, char* res)
       {
-        assert(1 <= size && size <= sizeof(full_block_size));
+        assert(1 <= size && size <= full_block_size);
 
         uint64_t num = uint_8be_to_64(reinterpret_cast<const uint8_t*>(block), size);
         int i = static_cast<int>(encoded_block_sizes[size]) - 1;
@@ -222,7 +234,7 @@ namespace tools
       return encode(buf);
     }
 
-    bool decode_addr(std::string addr, uint64_t& tag, std::string& data)
+    bool decode_addr(const std::string &addr, uint64_t& tag, std::string& data)
     {
       std::string addr_data;
       bool r = decode(addr, addr_data);

src/common/base58.h

@@ -1,6 +1,32 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+// Copyright (c) 2014-2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #pragma once
 
@@ -15,6 +41,6 @@ namespace tools
     bool decode(const std::string& enc, std::string& data);
 
     std::string encode_addr(uint64_t tag, const std::string& data);
-    bool decode_addr(std::string addr, uint64_t& tag, std::string& data);
+    bool decode_addr(const std::string &addr, uint64_t& tag, std::string& data);
   }
 }

src/contrib/epee/include/file_io_utils.h

@@ -0,0 +1,235 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+#ifndef _FILE_IO_UTILS_H_
+#define _FILE_IO_UTILS_H_
+
+#include <fstream>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#ifdef WIN32
+#include <windows.h>
+#include "string_tools.h"
+#endif
+
+// On Windows there is a problem with non-ASCII characters in path and file names
+// as far as support by the standard components used is concerned:
+
+// The various file stream classes, e.g. std::ifstream and std::ofstream, are
+// part of the GNU C++ Library / libstdc++. On the most basic level they use the
+// fopen() call as defined / made accessible to programs compiled within MSYS2
+// by the stdio.h header file maintained by the MinGW project.
+
+// The critical point: The implementation of fopen() is part of MSVCRT, the
+// Microsoft Visual C/C++ Runtime Library, and this method does NOT offer any
+// Unicode support.
+
+// Monero code that would want to continue to use the normal file stream classes
+// but WITH Unicode support could therefore not solve this problem on its own,
+// but 2 different projects from 2 different maintaining groups would need changes
+// in this particular direction - something probably difficult to achieve and
+// with a long time to wait until all new versions / releases arrive.
+
+// Implemented solution approach: Circumvent the problem by stopping to use std
+// file stream classes on Windows and directly use Unicode-capable WIN32 API
+// calls. Most of the code doing so is concentrated in this header file here.
+
+namespace epee
+{
+namespace file_io_utils
+{
+	inline 
+		bool is_file_exist(const std::string& path)
+	{
+		boost::filesystem::path p(path);
+		return boost::filesystem::exists(p);
+	}
+
+	inline
+		bool save_string_to_file(const std::string& path_to_file, const std::string& str)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                DWORD bytes_written;
+                DWORD bytes_to_write = (DWORD)str.size();
+                BOOL result = WriteFile(file_handle, str.data(), bytes_to_write, &bytes_written, NULL);
+                CloseHandle(file_handle);
+                if (bytes_written != bytes_to_write)
+                    result = FALSE;
+                return result;
+#else
+		try
+		{
+			std::ofstream fstream;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
+			fstream << str;
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+#endif
+	}
+
+	inline
+	bool get_file_time(const std::string& path_to_file, time_t& ft)
+	{
+		boost::system::error_code ec;
+		ft = boost::filesystem::last_write_time(boost::filesystem::path(path_to_file), ec);
+		if(!ec)
+			return true;
+		else
+			return false;
+	}
+
+	inline
+		bool set_file_time(const std::string& path_to_file, const time_t& ft)
+	{
+		boost::system::error_code ec;
+		boost::filesystem::last_write_time(boost::filesystem::path(path_to_file), ft, ec);
+		if(!ec)
+			return true;
+		else
+			return false;
+	}
+
+
+	inline
+		bool load_file_to_string(const std::string& path_to_file, std::string& target_str, size_t max_size = 1000000000)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                DWORD file_size = GetFileSize(file_handle, NULL);
+                if ((file_size == INVALID_FILE_SIZE) || (uint64_t)file_size > (uint64_t)max_size) {
+                    CloseHandle(file_handle);
+                    return false;
+                }
+                target_str.resize(file_size);
+                DWORD bytes_read;
+                BOOL result = ReadFile(file_handle, &target_str[0], file_size, &bytes_read, NULL);
+                CloseHandle(file_handle);
+                if (bytes_read != file_size)
+                    result = FALSE;
+                return result;
+#else
+		try
+		{
+			std::ifstream fstream;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::in | std::ios::ate);
+
+			std::ifstream::pos_type file_size = fstream.tellg();
+			
+			if((uint64_t)file_size > (uint64_t)max_size) // ensure a large domain for comparison, and negative -> too large
+				return false;//don't go crazy
+			size_t file_size_t = static_cast<size_t>(file_size);
+
+			target_str.resize(file_size_t);
+
+			fstream.seekg (0, std::ios::beg);
+			fstream.read((char*)target_str.data(), target_str.size());
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+#endif
+	}
+
+	inline
+		bool append_string_to_file(const std::string& path_to_file, const std::string& str)
+	{
+                // No special Windows implementation because so far not used in Monero code
+		try
+		{
+			std::ofstream fstream;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file.c_str(), std::ios_base::binary | std::ios_base::out | std::ios_base::app);
+			fstream << str;
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+	}
+
+	inline
+		bool get_file_size(const std::string& path_to_file, uint64_t &size)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                LARGE_INTEGER file_size;
+                BOOL result = GetFileSizeEx(file_handle, &file_size);
+                CloseHandle(file_handle);
+                if (result) {
+                    size = file_size.QuadPart;
+                }
+                return size;
+#else
+		try
+		{
+			std::ifstream fstream;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::in | std::ios::ate);
+			size = fstream.tellg();
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+#endif
+	}
+
+}
+}
+
+#endif //_FILE_IO_UTILS_H_

src/contrib/epee/include/fnv1.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+namespace epee
+{
+
+namespace fnv
+{
+  inline uint64_t FNV1a(const char *ptr, size_t sz)
+  {
+    uint64_t h = 0xcbf29ce484222325;
+    for (size_t i = 0; i < sz; ++i)
+      h = (h ^ *(const uint8_t*)ptr++) * 0x100000001b3;
+    return h;
+  }
+}
+
+}

src/contrib/epee/include/hex.h

@@ -0,0 +1,78 @@
+// Copyright (c) 2017-2019, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+#include <boost/utility/string_ref.hpp>
+
+#include "wipeable_string.h"
+#include "span.h"
+
+namespace epee
+{
+  struct to_hex
+  {
+    //! \return A std::string containing hex of `src`.
+    static std::string string(const span<const std::uint8_t> src);
+    //! \return A epee::wipeable_string containing hex of `src`.
+    static epee::wipeable_string wipeable_string(const span<const std::uint8_t> src);
+    template<typename T> static epee::wipeable_string wipeable_string(const T &pod) { return wipeable_string(span<const uint8_t>((const uint8_t*)&pod, sizeof(pod))); }
+
+    //! \return An array containing hex of `src`.
+    template<std::size_t N>
+    static std::array<char, N * 2> array(const std::array<std::uint8_t, N>& src) noexcept
+    {
+      std::array<char, N * 2> out{{}};
+      static_assert(N <= 128, "keep the stack size down");
+      buffer_unchecked(out.data(), {src.data(), src.size()});
+      return out;
+    }
+
+    //! Append `src` as hex to `out`.
+    static void buffer(std::ostream& out, const span<const std::uint8_t> src);
+
+    //! Append `< + src + >` as hex to `out`.
+    static void formatted(std::ostream& out, const span<const std::uint8_t> src);
+
+  private:
+    template<typename T> T static convert(const span<const std::uint8_t> src);
+
+    //! Write `src` bytes as hex to `out`. `out` must be twice the length
+    static void buffer_unchecked(char* out, const span<const std::uint8_t> src) noexcept;
+  };
+
+  struct from_hex
+  {
+      //! \return An std::vector of unsigned integers from the `src`
+      static std::vector<uint8_t> vector(boost::string_ref src);
+  };
+}

src/contrib/epee/include/int-util.h

@@ -0,0 +1,258 @@
+// Copyright (c) 2014-2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef _MSC_VER
+#include <sys/param.h>
+#endif
+
+#if defined(__ANDROID__)
+#include <byteswap.h>
+#endif
+
+#if defined(__sun) && defined(__SVR4)
+#include <endian.h>
+#endif
+
+#if defined(_MSC_VER)
+#include <stdlib.h>
+
+static inline uint32_t rol32(uint32_t x, int r) {
+  static_assert(sizeof(uint32_t) == sizeof(unsigned int), "this code assumes 32-bit integers");
+  return _rotl(x, r);
+}
+
+static inline uint64_t rol64(uint64_t x, int r) {
+  return _rotl64(x, r);
+}
+
+#else
+
+static inline uint32_t rol32(uint32_t x, int r) {
+  return (x << (r & 31)) | (x >> (-r & 31));
+}
+
+static inline uint64_t rol64(uint64_t x, int r) {
+  return (x << (r & 63)) | (x >> (-r & 63));
+}
+
+#endif
+
+static inline uint64_t hi_dword(uint64_t val) {
+  return val >> 32;
+}
+
+static inline uint64_t lo_dword(uint64_t val) {
+  return val & 0xFFFFFFFF;
+}
+
+static inline uint64_t mul128(uint64_t multiplier, uint64_t multiplicand, uint64_t* product_hi) {
+  // multiplier   = ab = a * 2^32 + b
+  // multiplicand = cd = c * 2^32 + d
+  // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d
+  uint64_t a = hi_dword(multiplier);
+  uint64_t b = lo_dword(multiplier);
+  uint64_t c = hi_dword(multiplicand);
+  uint64_t d = lo_dword(multiplicand);
+
+  uint64_t ac = a * c;
+  uint64_t ad = a * d;
+  uint64_t bc = b * c;
+  uint64_t bd = b * d;
+
+  uint64_t adbc = ad + bc;
+  uint64_t adbc_carry = adbc < ad ? 1 : 0;
+
+  // multiplier * multiplicand = product_hi * 2^64 + product_lo
+  uint64_t product_lo = bd + (adbc << 32);
+  uint64_t product_lo_carry = product_lo < bd ? 1 : 0;
+  *product_hi = ac + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry;
+  assert(ac <= *product_hi);
+
+  return product_lo;
+}
+
+static inline uint64_t div_with_reminder(uint64_t dividend, uint32_t divisor, uint32_t* remainder) {
+  dividend |= ((uint64_t)*remainder) << 32;
+  *remainder = dividend % divisor;
+  return dividend / divisor;
+}
+
+// Long division with 2^32 base
+static inline uint32_t div128_32(uint64_t dividend_hi, uint64_t dividend_lo, uint32_t divisor, uint64_t* quotient_hi, uint64_t* quotient_lo) {
+  uint64_t dividend_dwords[4];
+  uint32_t remainder = 0;
+
+  dividend_dwords[3] = hi_dword(dividend_hi);
+  dividend_dwords[2] = lo_dword(dividend_hi);
+  dividend_dwords[1] = hi_dword(dividend_lo);
+  dividend_dwords[0] = lo_dword(dividend_lo);
+
+  *quotient_hi  = div_with_reminder(dividend_dwords[3], divisor, &remainder) << 32;
+  *quotient_hi |= div_with_reminder(dividend_dwords[2], divisor, &remainder);
+  *quotient_lo  = div_with_reminder(dividend_dwords[1], divisor, &remainder) << 32;
+  *quotient_lo |= div_with_reminder(dividend_dwords[0], divisor, &remainder);
+
+  return remainder;
+}
+
+#define IDENT32(x) ((uint32_t) (x))
+#define IDENT64(x) ((uint64_t) (x))
+
+#define SWAP32(x) ((((uint32_t) (x) & 0x000000ff) << 24) | \
+  (((uint32_t) (x) & 0x0000ff00) <<  8) | \
+  (((uint32_t) (x) & 0x00ff0000) >>  8) | \
+  (((uint32_t) (x) & 0xff000000) >> 24))
+#define SWAP64(x) ((((uint64_t) (x) & 0x00000000000000ff) << 56) | \
+  (((uint64_t) (x) & 0x000000000000ff00) << 40) | \
+  (((uint64_t) (x) & 0x0000000000ff0000) << 24) | \
+  (((uint64_t) (x) & 0x00000000ff000000) <<  8) | \
+  (((uint64_t) (x) & 0x000000ff00000000) >>  8) | \
+  (((uint64_t) (x) & 0x0000ff0000000000) >> 24) | \
+  (((uint64_t) (x) & 0x00ff000000000000) >> 40) | \
+  (((uint64_t) (x) & 0xff00000000000000) >> 56))
+
+static inline uint32_t ident32(uint32_t x) { return x; }
+static inline uint64_t ident64(uint64_t x) { return x; }
+
+#ifndef __OpenBSD__
+#  if defined(__ANDROID__) && defined(__swap32) && !defined(swap32)
+#      define swap32 __swap32
+#  elif !defined(swap32)
+static inline uint32_t swap32(uint32_t x) {
+  x = ((x & 0x00ff00ff) << 8) | ((x & 0xff00ff00) >> 8);
+  return (x << 16) | (x >> 16);
+}
+#  endif
+#  if defined(__ANDROID__) && defined(__swap64) && !defined(swap64)
+#      define swap64 __swap64
+#  elif !defined(swap64)
+static inline uint64_t swap64(uint64_t x) {
+  x = ((x & 0x00ff00ff00ff00ff) <<  8) | ((x & 0xff00ff00ff00ff00) >>  8);
+  x = ((x & 0x0000ffff0000ffff) << 16) | ((x & 0xffff0000ffff0000) >> 16);
+  return (x << 32) | (x >> 32);
+}
+#  endif
+#endif /* __OpenBSD__ */
+
+#if defined(__GNUC__)
+#define UNUSED __attribute__((unused))
+#else
+#define UNUSED
+#endif
+static inline void mem_inplace_ident(void *mem UNUSED, size_t n UNUSED) { }
+#undef UNUSED
+
+static inline void mem_inplace_swap32(void *mem, size_t n) {
+  size_t i;
+  for (i = 0; i < n; i++) {
+    ((uint32_t *) mem)[i] = swap32(((const uint32_t *) mem)[i]);
+  }
+}
+static inline void mem_inplace_swap64(void *mem, size_t n) {
+  size_t i;
+  for (i = 0; i < n; i++) {
+    ((uint64_t *) mem)[i] = swap64(((const uint64_t *) mem)[i]);
+  }
+}
+
+static inline void memcpy_ident32(void *dst, const void *src, size_t n) {
+  memcpy(dst, src, 4 * n);
+}
+static inline void memcpy_ident64(void *dst, const void *src, size_t n) {
+  memcpy(dst, src, 8 * n);
+}
+
+static inline void memcpy_swap32(void *dst, const void *src, size_t n) {
+  size_t i;
+  for (i = 0; i < n; i++) {
+    ((uint32_t *) dst)[i] = swap32(((const uint32_t *) src)[i]);
+  }
+}
+static inline void memcpy_swap64(void *dst, const void *src, size_t n) {
+  size_t i;
+  for (i = 0; i < n; i++) {
+    ((uint64_t *) dst)[i] = swap64(((const uint64_t *) src)[i]);
+  }
+}
+
+#ifdef _MSC_VER
+# define LITTLE_ENDIAN	1234
+# define BIG_ENDIAN	4321
+# define BYTE_ORDER	LITTLE_ENDIAN
+#endif
+
+#if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
+static_assert(false, "BYTE_ORDER is undefined. Perhaps, GNU extensions are not enabled");
+#endif
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define SWAP32LE IDENT32
+#define SWAP32BE SWAP32
+#define swap32le ident32
+#define swap32be swap32
+#define mem_inplace_swap32le mem_inplace_ident
+#define mem_inplace_swap32be mem_inplace_swap32
+#define memcpy_swap32le memcpy_ident32
+#define memcpy_swap32be memcpy_swap32
+#define SWAP64LE IDENT64
+#define SWAP64BE SWAP64
+#define swap64le ident64
+#define swap64be swap64
+#define mem_inplace_swap64le mem_inplace_ident
+#define mem_inplace_swap64be mem_inplace_swap64
+#define memcpy_swap64le memcpy_ident64
+#define memcpy_swap64be memcpy_swap64
+#endif
+
+#if BYTE_ORDER == BIG_ENDIAN
+#define SWAP32BE IDENT32
+#define SWAP32LE SWAP32
+#define swap32be ident32
+#define swap32le swap32
+#define mem_inplace_swap32be mem_inplace_ident
+#define mem_inplace_swap32le mem_inplace_swap32
+#define memcpy_swap32be memcpy_ident32
+#define memcpy_swap32le memcpy_swap32
+#define SWAP64BE IDENT64
+#define SWAP64LE SWAP64
+#define swap64be ident64
+#define swap64le swap64
+#define mem_inplace_swap64be mem_inplace_ident
+#define mem_inplace_swap64le mem_inplace_swap64
+#define memcpy_swap64be memcpy_ident64
+#define memcpy_swap64le memcpy_swap64
+#endif

src/contrib/epee/include/math_helper.h

@@ -32,11 +32,12 @@
 
 #include <list>
 #include <numeric>
-#include <boost/timer.hpp>
+#include <boost/timer/timer.hpp>
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/random_generator.hpp>
 
 #include "misc_os_dependent.h"
+#include "syncobj.h"
 
 namespace epee
 {
@@ -229,44 +230,57 @@ namespace math_helper
 		}
 
 	}
-PRAGMA_WARNING_PUSH
-PRAGMA_GCC("GCC diagnostic ignored \"-Wstrict-aliasing\"")
-  inline
-  uint64_t generated_random_uint64()
-  {
-    boost::uuids::uuid id___ = boost::uuids::random_generator()();
-    return  *reinterpret_cast<uint64_t*>(&id___.data[0]); //(*reinterpret_cast<uint64_t*>(&id___.data[0]) ^ *reinterpret_cast<uint64_t*>(&id___.data[8]));
-  }
-PRAGMA_WARNING_POP
-	template<int default_interval, bool start_immediate = true>
-	class once_a_time_seconds
+	template<uint64_t scale, int default_interval, bool start_immediate = true>
+	class once_a_time
 	{
+    uint64_t get_time() const
+    {
+#ifdef _WIN32
+      FILETIME fileTime;
+      GetSystemTimeAsFileTime(&fileTime);
+      unsigned __int64 present = 0;
+      present |= fileTime.dwHighDateTime;
+      present = present << 32;
+      present |= fileTime.dwLowDateTime;
+      present /= 10;  // mic-sec
+      return present;
+#else
+      struct timeval tv;
+      gettimeofday(&tv, NULL);
+      return tv.tv_sec * 1000000 + tv.tv_usec;
+#endif
+    }
+
 	public:
-		once_a_time_seconds():m_interval(default_interval)
+		once_a_time():m_interval(default_interval * scale)
 		{
 			m_last_worked_time = 0;
       if(!start_immediate)
-        time(&m_last_worked_time);
+        m_last_worked_time = get_time();
 		}
 
 		template<class functor_t>
 		bool do_call(functor_t functr)
 		{
-			time_t current_time = 0;
-			time(&current_time);
+			uint64_t current_time = get_time();
 
       if(current_time - m_last_worked_time > m_interval)
 			{
 				bool res = functr();
-				time(&m_last_worked_time);
+				m_last_worked_time = get_time();
 				return res;
 			}
 			return true;
 		}
 
 	private:
-		time_t m_last_worked_time;
-		time_t m_interval;
+		uint64_t m_last_worked_time;
+		uint64_t m_interval;
 	};
+
+  template<int default_interval, bool start_immediate = true>
+  class once_a_time_seconds: public once_a_time<1000000, default_interval, start_immediate> {};
+  template<int default_interval, bool start_immediate = true>
+  class once_a_time_milliseconds: public once_a_time<1000, default_interval, start_immediate> {};
+}
 }
-}

src/contrib/epee/include/memwipe.h

@@ -0,0 +1,80 @@
+// Copyright (c) 2017-2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#ifdef __cplusplus
+#include <array>
+
+extern "C" {
+#endif
+
+void *memwipe(void *src, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+namespace tools {
+
+  /// Scrubs data in the contained type upon destruction.
+  ///
+  /// Primarily useful for making sure that private keys don't stick around in
+  /// memory after the objects that held them have gone out of scope.
+  template <class T>
+  struct scrubbed : public T {
+    using type = T;
+
+    ~scrubbed() {
+      scrub();
+    }
+
+    /// Destroy the contents of the contained type.
+    void scrub() {
+      static_assert(std::is_pod<T>::value,
+                    "T cannot be auto-scrubbed. T must be POD.");
+      static_assert(std::is_trivially_destructible<T>::value,
+                    "T cannot be auto-scrubbed. T must be trivially destructable.");
+      memwipe(this, sizeof(T));
+    }
+  };
+
+  template<typename T>
+  T& unwrap(scrubbed<T>& src) { return src; }
+
+  template<typename T>
+  const T& unwrap(scrubbed<T> const& src) { return src; }
+
+  template <class T, size_t N>
+  using scrubbed_arr = scrubbed<std::array<T, N>>;
+} // namespace tools
+
+#endif // __cplusplus

src/contrib/epee/include/misc_language.h

@@ -147,7 +147,8 @@ namespace misc_utils
     {}
     ~call_befor_die()
     {
-      m_func();
+      try { m_func(); }
+      catch (...) { /* ignore */ }
     }
   };
 
@@ -158,5 +159,10 @@ namespace misc_utils
     return slc;
   }
 
+  template<typename T> struct struct_init: T
+  {
+    struct_init(): T{} {}
+  };
+
 }
 }

src/contrib/epee/include/misc_os_dependent.h

@@ -23,6 +23,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+
 #ifdef WIN32
   #ifndef WIN32_LEAN_AND_MEAN 
   #define WIN32_LEAN_AND_MEAN
@@ -42,16 +46,27 @@
 #include <mach/mach.h>
 #endif
 
+#include <iostream>
+#include <boost/lexical_cast.hpp>
+
 #pragma once 
 namespace epee
 {
 namespace misc_utils
 {
 
-        inline uint64_t get_tick_count()
+        inline uint64_t get_ns_count()
         {
 #if defined(_MSC_VER)
-                return ::GetTickCount64();
+                return ::GetTickCount64() * 1000000;
+#elif defined(WIN32)
+                static LARGE_INTEGER pcfreq = {0};
+                LARGE_INTEGER ticks;
+                if (!pcfreq.QuadPart)
+                    QueryPerformanceFrequency(&pcfreq);
+                QueryPerformanceCounter(&ticks);
+                ticks.QuadPart *= 1000000000; /* we want nsec */
+                return ticks.QuadPart / pcfreq.QuadPart;
 #elif defined(__MACH__)
                 clock_serv_t cclock;
                 mach_timespec_t mts;
@@ -60,16 +75,21 @@ namespace misc_utils
                 clock_get_time(cclock, &mts);
                 mach_port_deallocate(mach_task_self(), cclock);
 
-                return (mts.tv_sec * 1000) + (mts.tv_nsec/1000000);
+                return ((uint64_t)mts.tv_sec * 1000000000) + (mts.tv_nsec);
 #else
                 struct timespec ts;
                 if(clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
                         return 0;
                 }
-                return (ts.tv_sec * 1000) + (ts.tv_nsec/1000000);
+                return ((uint64_t)ts.tv_sec * 1000000000) + (ts.tv_nsec);
 #endif
         }
 
+        inline uint64_t get_tick_count()
+        {
+                return get_ns_count() / 1000000;
+        }
+
 
         inline int call_sys_cmd(const std::string& cmd)
 	{      
@@ -98,10 +118,19 @@ namespace misc_utils
 
 	inline std::string get_thread_string_id()
 	{
-#if defined(_MSC_VER)
+#if defined(_WIN32)
 		return boost::lexical_cast<std::string>(GetCurrentThreadId());
 #elif defined(__GNUC__)  
 		return boost::lexical_cast<std::string>(pthread_self());
+#endif
+	}
+
+	inline bool get_gmt_time(time_t t, struct tm &tm)
+	{
+#ifdef _WIN32
+		return gmtime_s(&tm, &t);
+#else
+		return gmtime_r(&t, &tm);
 #endif
 	}
 }

src/contrib/epee/include/mlocker.h

@@ -0,0 +1,87 @@
+// Copyright (c) 2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once 
+
+#include <map>
+#include <boost/thread/mutex.hpp>
+
+namespace epee
+{
+  class mlocker
+  {
+  public:
+    mlocker(void *ptr, size_t len);
+    ~mlocker();
+
+    static size_t get_page_size();
+    static size_t get_num_locked_pages();
+    static size_t get_num_locked_objects();
+
+    static void lock(void *ptr, size_t len);
+    static void unlock(void *ptr, size_t len);
+
+  private:
+    static size_t page_size;
+    static size_t num_locked_objects;
+
+    static boost::mutex &mutex();
+    static std::map<size_t, unsigned int> &map();
+    static void lock_page(size_t page);
+    static void unlock_page(size_t page);
+
+    void *ptr;
+    size_t len;
+  };
+
+  /// Locks memory while in scope
+  ///
+  /// Primarily useful for making sure that private keys don't get swapped out
+  //  to disk
+  template <class T>
+  struct mlocked : public T {
+    using type = T;
+
+    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
+    mlocked(const T &t): T(t) { mlocker::lock(this, sizeof(T)); }
+    mlocked(const mlocked<T> &mt): T(mt) { mlocker::lock(this, sizeof(T)); }
+    mlocked(const T &&t): T(t) { mlocker::lock(this, sizeof(T)); }
+    mlocked(const mlocked<T> &&mt): T(mt) { mlocker::lock(this, sizeof(T)); }
+    mlocked<T> &operator=(const mlocked<T> &mt) { T::operator=(mt); return *this; }
+    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }
+  };
+
+  template<typename T>
+  T& unwrap(mlocked<T>& src) { return src; }
+
+  template<typename T>
+  const T& unwrap(mlocked<T> const& src) { return src; }
+
+  template <class T, size_t N>
+  using mlocked_arr = mlocked<std::array<T, N>>;
+}

src/contrib/epee/include/serialization/enableable.h

@@ -50,4 +50,4 @@ namespace epee
     {	// construct from specified values
     }
   };
-}
+}

src/contrib/epee/include/serialization/keyvalue_serialization.h

@@ -31,6 +31,10 @@
 #include "misc_log_ex.h"
 #include "enableable.h"
 #include "keyvalue_serialization_overloads.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
+
 namespace epee
 {
   /************************************************************************/
@@ -41,12 +45,12 @@ public: \
   template<class t_storage> \
   bool store( t_storage& st, typename t_storage::hsection hparent_section = nullptr) const\
   {\
-  return serialize_map<true>(*this, st, hparent_section);\
+    return serialize_map<true>(*this, st, hparent_section);\
   }\
   template<class t_storage> \
   bool _load( t_storage& stg, typename t_storage::hsection hparent_section = nullptr)\
   {\
-  return serialize_map<false>(*this, stg, hparent_section);\
+    return serialize_map<false>(*this, stg, hparent_section);\
   }\
   template<class t_storage> \
   bool load( t_storage& stg, typename t_storage::hsection hparent_section = nullptr)\
@@ -68,6 +72,15 @@ public: \
 #define KV_SERIALIZE_N(varialble, val_name) \
   epee::serialization::selector<is_store>::serialize(this_ref.varialble, stg, hparent_section, val_name);
 
+  template<typename T> inline void serialize_default(const T &t, T v) { }
+  template<typename T> inline void serialize_default(T &t, T v) { t = v; }
+
+#define KV_SERIALIZE_OPT_N(variable, val_name, default_value) \
+  do { \
+    if (!epee::serialization::selector<is_store>::serialize(this_ref.variable, stg, hparent_section, val_name)) \
+      epee::serialize_default(this_ref.variable, default_value); \
+  } while (0);
+
 #define KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name) \
   epee::serialization::selector<is_store>::serialize_t_val_as_blob(this_ref.varialble, stg, hparent_section, val_name); 
 
@@ -75,6 +88,14 @@ public: \
   static_assert(std::is_pod<decltype(this_ref.varialble)>::value, "t_type must be a POD type."); \
   KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name)
 
+#define KV_SERIALIZE_VAL_POD_AS_BLOB_OPT_N(varialble, val_name, default_value) \
+  do { \
+    static_assert(std::is_pod<decltype(this_ref.varialble)>::value, "t_type must be a POD type."); \
+    bool ret = KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name); \
+    if (!ret) \
+      epee::serialize_default(this_ref.varialble, default_value); \
+  } while(0);
+
 #define KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(varialble, val_name) \
   epee::serialization::selector<is_store>::serialize_stl_container_pod_val_as_blob(this_ref.varialble, stg, hparent_section, val_name);
 
@@ -82,8 +103,10 @@ public: \
 
 #define KV_SERIALIZE(varialble)                           KV_SERIALIZE_N(varialble, #varialble)
 #define KV_SERIALIZE_VAL_POD_AS_BLOB(varialble)           KV_SERIALIZE_VAL_POD_AS_BLOB_N(varialble, #varialble)
+#define KV_SERIALIZE_VAL_POD_AS_BLOB_OPT(varialble, def)  KV_SERIALIZE_VAL_POD_AS_BLOB_OPT_N(varialble, #varialble, def)
 #define KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(varialble)     KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, #varialble) //skip is_pod compile time check
 #define KV_SERIALIZE_CONTAINER_POD_AS_BLOB(varialble)     KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(varialble, #varialble)
+#define KV_SERIALIZE_OPT(variable,default_value)          KV_SERIALIZE_OPT_N(variable, #variable, default_value)
 
 }
 

src/contrib/epee/include/serialization/keyvalue_serialization_overloads.h

@@ -26,8 +26,23 @@
 
 #pragma once
 
+#include <set>
+#include <list>
+#include <vector>
+#include <deque>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/contains_fwd.hpp>
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
+
 namespace epee
 {
+  namespace
+  {
+    template<class C> void hint_resize(C &container, size_t size) {}
+    template<class C> void hint_resize(std::vector<C> &container, size_t size) { container.reserve(size); }
+  }
   namespace serialization
   {
 
@@ -73,7 +88,7 @@ namespace epee
     template<class serializible_type, class t_storage>
     static bool unserialize_t_obj(serializible_type& obj, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
     {
-      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, true);
+      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, false);
       if(!hchild_section) return false;
       return obj._load(stg, hchild_section);
     }
@@ -90,7 +105,7 @@ namespace epee
     static bool unserialize_t_obj(enableable<serializible_type>& obj, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
     {
       obj.enabled = false;
-      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, true);
+      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, false);
       if(!hchild_section) return false;
       obj.enabled = true;
       return obj.v._load(stg, hchild_section);
@@ -117,16 +132,15 @@ namespace epee
       typename stl_container::value_type exchange_val;
       typename t_storage::harray hval_array = stg.get_first_value(pname, exchange_val, hparent_section);
       if(!hval_array) return false;
-      container.push_back(std::move(exchange_val));
+      container.insert(container.end(), std::move(exchange_val));
       while(stg.get_next_value(hval_array, exchange_val))
-        container.push_back(std::move(exchange_val));
+        container.insert(container.end(), std::move(exchange_val));
       return true;
     }//--------------------------------------------------------------------------------------------------------------------
     template<class stl_container, class t_storage>
     static bool serialize_stl_container_pod_val_as_blob(const stl_container& container, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
     {
       if(!container.size()) return true;
-      typename stl_container::const_iterator it = container.begin();
       std::string mb;
       mb.resize(sizeof(typename stl_container::value_type)*container.size());
       typename stl_container::value_type* p_elem = (typename stl_container::value_type*)mb.data();
@@ -150,10 +164,11 @@ namespace epee
         typename stl_container::value_type* pelem =  (typename stl_container::value_type*)buff.data();
         CHECK_AND_ASSERT_MES(!(loaded_size%sizeof(typename stl_container::value_type)), 
           false, 
-          "size in blob " << loaded_size << " not have not zero modulo for sizeof(value_type) = " << sizeof(typename stl_container::value_type));
+          "size in blob " << loaded_size << " not have not zero modulo for sizeof(value_type) = " << sizeof(typename stl_container::value_type) << ", type " << typeid(typename stl_container::value_type).name());
         size_t count = (loaded_size/sizeof(typename stl_container::value_type));
+        hint_resize(container, count);
         for(size_t i = 0; i < count; i++)
-          container.push_back(*(pelem++));
+          container.insert(container.end(), *(pelem++));
       }
       return res;
     }
@@ -187,12 +202,12 @@ namespace epee
       typename t_storage::harray hsec_array = stg.get_first_section(pname, hchild_section, hparent_section);
       if(!hsec_array || !hchild_section) return false;
       res = val._load(stg, hchild_section);
-      container.push_back(val);
+      container.insert(container.end(), val);
       while(stg.get_next_section(hsec_array, hchild_section))
       {
         typename stl_container::value_type val_l = typename stl_container::value_type();
         res |= val_l._load(stg, hchild_section);
-        container.push_back(std::move(val_l));
+        container.insert(container.end(), std::move(val_l));
       }
       return res;
     }
@@ -228,6 +243,18 @@ namespace epee
       } 
       //-------------------------------------------------------------------------------------------------------------------
       template<class t_type, class t_storage>
+      static bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_val(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
       static bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
       {
         return serialize_stl_container_t_val(d, stg, hparent_section, pname);
@@ -239,6 +266,18 @@ namespace epee
         return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
       } 
       //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_val(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
     };
     template<>
     struct kv_serialization_overloads_impl_is_base_serializable_types<false>
@@ -269,6 +308,18 @@ namespace epee
       } 
       //-------------------------------------------------------------------------------------------------------------------
       template<class t_type, class t_storage>
+      static bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
       static bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
       {
         return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
@@ -279,6 +330,18 @@ namespace epee
       {
         return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
       } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      } 
     };
     template<class t_storage>
     struct base_serializable_types: public boost::mpl::vector<uint64_t, uint32_t, uint16_t, uint8_t, int64_t, int32_t, int16_t, int8_t, double, bool, std::string, typename t_storage::meta_entry>::type
@@ -354,6 +417,18 @@ namespace epee
     } 
     //-------------------------------------------------------------------------------------------------------------------
     template<class t_type, class t_storage>
+    bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
+    } 
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
     bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
     {
       return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
@@ -364,5 +439,17 @@ namespace epee
     {
       return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
     } 
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
+    } 
   }
 }

src/contrib/epee/include/span.h

@@ -0,0 +1,175 @@
+// Copyright (c) 2017-2019, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace epee
+{
+  /*!
+    \brief Non-owning sequence of data. Does not deep copy
+
+    Inspired by `gsl::span` and/or `boost::iterator_range`. This class is
+    intended to be used as a parameter type for functions that need to take a
+    writable or read-only sequence of data. Most common cases are `span<char>`
+    and `span<std::uint8_t>`. Using as a class member is only recommended if
+    clearly documented as not doing a deep-copy. C-arrays are easily convertible
+    to this type.
+
+    \note Conversion from C string literal to `span<const char>` will include
+      the NULL-terminator.
+    \note Never allows derived-to-base pointer conversion; an array of derived
+      types is not an array of base types.
+   */
+  template<typename T>
+  class span
+  {
+    template<typename U>
+    static constexpr bool safe_conversion() noexcept
+    {
+      // Allow exact matches or `T*` -> `const T*`.
+      using with_const = typename std::add_const<U>::type;
+      return std::is_same<T, U>() ||
+        (std::is_const<T>() && std::is_same<T, with_const>());
+    }
+
+  public:
+    using value_type = T;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+
+    constexpr span() noexcept : ptr(nullptr), len(0) {}
+    constexpr span(std::nullptr_t) noexcept : span() {}
+
+    //! Prevent derived-to-base conversions; invalid in this context.
+    template<typename U, typename = typename std::enable_if<safe_conversion<U>()>::type>
+    constexpr span(U* const src_ptr, const std::size_t count) noexcept
+      : ptr(src_ptr), len(count) {}
+
+    //! Conversion from C-array. Prevents common bugs with sizeof + arrays.
+    template<std::size_t N>
+    constexpr span(T (&src)[N]) noexcept : span(src, N) {}
+
+    constexpr span(const span&) noexcept = default;
+    span& operator=(const span&) noexcept = default;
+
+    /*! Try to remove `amount` elements from beginning of span.
+    \return Number of elements removed. */
+    std::size_t remove_prefix(std::size_t amount) noexcept
+    {
+        amount = std::min(len, amount);
+        ptr += amount;
+        len -= amount;
+        return amount;
+    }
+
+    constexpr iterator begin() const noexcept { return ptr; }
+    constexpr const_iterator cbegin() const noexcept { return ptr; }
+
+    constexpr iterator end() const noexcept { return begin() + size(); }
+    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
+
+    constexpr bool empty() const noexcept { return size() == 0; }
+    constexpr pointer data() const noexcept { return ptr; }
+    constexpr std::size_t size() const noexcept { return len; }
+    constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
+
+    const T &operator[](size_t idx) const { return ptr[idx]; }
+
+  private:
+    T* ptr;
+    std::size_t len;
+  };
+
+  //! \return `span<const T::value_type>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<const typename T::value_type> to_span(const T& src)
+  {
+    // compiler provides diagnostic if size() is not size_t.
+    return {src.data(), src.size()};
+  }
+
+  //! \return `span<T::value_type>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<typename T::value_type> to_mut_span(T& src)
+  {
+    // compiler provides diagnostic if size() is not size_t.
+    return {src.data(), src.size()};
+  }
+
+  template<typename T>
+  constexpr bool has_padding() noexcept
+  {
+    return !std::is_standard_layout<T>() || alignof(T) != 1;
+  }
+
+  //! \return Cast data from `src` as `span<const std::uint8_t>`.
+  template<typename T>
+  span<const std::uint8_t> to_byte_span(const span<const T> src) noexcept
+  {
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
+  }
+
+  //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
+  template<typename T>
+  span<const std::uint8_t> as_byte_span(const T& src) noexcept
+  {
+    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
+  }
+
+  //! \return `span<std::uint8_t>` which represents the bytes at `&src`.
+  template<typename T>
+  span<std::uint8_t> as_mut_byte_span(T& src) noexcept
+  {
+    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
+  }
+
+  //! make a span from a std::string
+  template<typename T>
+  span<const T> strspan(const std::string &s) noexcept
+  {
+    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected type");
+    return {reinterpret_cast<const T*>(s.data()), s.size()};
+  }
+}

src/contrib/epee/include/storages/crypted_storage.h

@@ -0,0 +1,62 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+#ifndef _CRYPTED_STORAGE_H_
+#define _CRYPTED_STORAGE_H_
+
+#include "cryptopp_helper.h"
+
+namespace epee
+{
+template<class t_base_storage, class crypt_provider, class t_key_provider>
+class crypted_storage: public t_base_storage
+{
+public: 
+	size_t	PackToSolidBuffer(std::string& targetObj)
+	{
+		size_t res = t_base_storage::PackToSolidBuffer(targetObj);
+		if(res <= 0)
+			return res;
+		
+		if(!crypt_provider::encrypt(targetObj, t_key_provider::get_storage_default_key()))
+			return 0;
+
+		return targetObj.size();
+	}
+
+	size_t		LoadFromSolidBuffer(const std::string& pTargetObj)
+	{
+		std::string buff_to_decrypt = pTargetObj;
+		if(crypt_provider::decrypt(buff_to_decrypt, t_key_provider::get_storage_default_key()))
+			return t_base_storage::LoadFromSolidBuffer(buff_to_decrypt);
+
+		return 0;
+	}
+};
+}
+
+#endif //_CRYPTED_STORAGE_H_

src/contrib/epee/include/storages/gzipped_inmemstorage.h

@@ -0,0 +1,68 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+#ifndef _GZIPPED_INMEMSTORAGE_H_
+#define _GZIPPED_INMEMSTORAGE_H_
+
+#include "zlib_helper.h"
+namespace epee
+{
+namespace StorageNamed
+{
+
+	template<class t_base_storage>
+	class gziped_storage: public t_base_storage
+	{
+	public: 
+		size_t	PackToSolidBuffer(std::string& targetObj)
+		{
+			size_t res = t_base_storage::PackToSolidBuffer(targetObj);
+			if(res <= 0)
+				return res;
+
+			if(!zlib_helper::pack(targetObj))
+				return 0;
+		
+			return targetObj.size();
+		}
+
+		size_t		LoadFromSolidBuffer(const std::string& pTargetObj)
+		{
+			std::string buff_to_ungzip = pTargetObj;
+			if(zlib_helper::unpack(buff_to_ungzip))
+				return t_base_storage::LoadFromSolidBuffer(buff_to_ungzip);
+
+			return 0;
+		}
+
+	private:
+	};
+
+}
+}
+
+#endif 

src/contrib/epee/include/storages/http_abstract_invoke.h

@@ -0,0 +1,132 @@
+
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#pragma once
+#include <boost/utility/string_ref.hpp>
+#include <chrono>
+#include <string>
+#include "portable_storage_template_helper.h"
+#include "net/http_base.h"
+#include "net/http_server_handlers_map2.h"
+
+namespace epee
+{
+  namespace net_utils
+  {
+    template<class t_request, class t_response, class t_transport>
+    bool invoke_http_json(const boost::string_ref uri, const t_request& out_struct, t_response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref method = "GET")
+    {
+      std::string req_param;
+      if(!serialization::store_t_to_json(out_struct, req_param))
+        return false;
+
+      http::fields_list additional_params;
+      additional_params.push_back(std::make_pair("Content-Type","application/json; charset=utf-8"));
+
+      const http::http_response_info* pri = NULL;
+      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri), std::move(additional_params)))
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
+        return false;
+      }
+
+      if(!pri)
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
+        return false;
+      }
+
+      if(pri->m_response_code != 200)
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code);
+        return false;
+      }
+
+      return serialization::load_t_from_json(result_struct, pri->m_body);
+    }
+
+
+
+    template<class t_request, class t_response, class t_transport>
+    bool invoke_http_bin(const boost::string_ref uri, const t_request& out_struct, t_response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref method = "GET")
+    {
+      std::string req_param;
+      if(!serialization::store_t_to_binary(out_struct, req_param))
+        return false;
+
+      const http::http_response_info* pri = NULL;
+      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri)))
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
+        return false;
+      }
+
+      if(!pri)
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
+        return false;
+      }
+
+      if(pri->m_response_code != 200)
+      {
+        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code);
+        return false;
+      }
+
+      return serialization::load_t_from_binary(result_struct, epee::strspan<uint8_t>(pri->m_body));
+    }
+
+    template<class t_request, class t_response, class t_transport>
+    bool invoke_http_json_rpc(const boost::string_ref uri, std::string method_name, const t_request& out_struct, t_response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref http_method = "GET", const std::string& req_id = "0")
+    {
+      epee::json_rpc::request<t_request> req_t = AUTO_VAL_INIT(req_t);
+      req_t.jsonrpc = "2.0";
+      req_t.id = req_id;
+      req_t.method = std::move(method_name);
+      req_t.params = out_struct;
+      epee::json_rpc::response<t_response, epee::json_rpc::error> resp_t = AUTO_VAL_INIT(resp_t);
+      if(!epee::net_utils::invoke_http_json(uri, req_t, resp_t, transport, timeout, http_method))
+      {
+        return false;
+      }
+      if(resp_t.error.code || resp_t.error.message.size())
+      {
+        LOG_ERROR("RPC call of \"" << req_t.method << "\" returned error: " << resp_t.error.code << ", message: " << resp_t.error.message);
+        return false;
+      }
+      result_struct = resp_t.result;
+      return true;
+    }
+
+    template<class t_command, class t_transport>
+    bool invoke_http_json_rpc(const boost::string_ref uri, typename t_command::request& out_struct, typename t_command::response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref http_method = "GET", const std::string& req_id = "0")
+    {
+      return invoke_http_json_rpc(uri, t_command::methodname(), out_struct, result_struct, transport, timeout, http_method, req_id);
+    }
+
+  }
+}

src/contrib/epee/include/storages/levin_abstract_invoke2.h

@@ -0,0 +1,303 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#pragma once
+
+#include "portable_storage_template_helper.h"
+#include <boost/utility/value_init.hpp>
+#include "span.h"
+#include "net/levin_base.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
+namespace epee
+{
+  namespace net_utils
+  {
+    template<class t_arg, class t_result, class t_transport>
+    bool invoke_remote_command2(int command, const t_arg& out_struct, t_result& result_struct, t_transport& transport)
+    {
+      if(!transport.is_connected())
+        return false;
+
+      serialization::portable_storage stg;
+      out_struct.store(stg);
+      std::string buff_to_send, buff_to_recv;
+      stg.store_to_binary(buff_to_send);
+
+      int res = transport.invoke(command, buff_to_send, buff_to_recv);
+      if( res <=0 )
+      {
+        MERROR("Failed to invoke command " << command << " return code " << res);
+        return false;
+      }
+      serialization::portable_storage stg_ret;
+      if(!stg_ret.load_from_binary(buff_to_recv))
+      {
+        LOG_ERROR("Failed to load_from_binary on command " << command);
+        return false;
+      }
+      return result_struct.load(stg_ret);
+    }
+
+    template<class t_arg, class t_transport>
+    bool notify_remote_command2(int command, const t_arg& out_struct, t_transport& transport)
+    {
+      if(!transport.is_connected())
+        return false;
+
+      serialization::portable_storage stg;
+      out_struct.store(&stg);
+      std::string buff_to_send;
+      stg.store_to_binary(buff_to_send);
+
+      int res = transport.notify(command, buff_to_send);
+      if(res <=0 )
+      {
+        LOG_ERROR("Failed to notify command " << command << " return code " << res);
+        return false;
+      }
+      return true;
+    }
+
+    template<class t_arg, class t_result, class t_transport>
+    bool invoke_remote_command2(boost::uuids::uuid conn_id, int command, const t_arg& out_struct, t_result& result_struct, t_transport& transport)
+    {
+
+      typename serialization::portable_storage stg;
+      out_struct.store(stg);
+      std::string buff_to_send, buff_to_recv;
+      stg.store_to_binary(buff_to_send);
+
+      int res = transport.invoke(command, buff_to_send, buff_to_recv, conn_id);
+      if( res <=0 )
+      {
+        LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
+        return false;
+      }
+      typename serialization::portable_storage stg_ret;
+      if(!stg_ret.load_from_binary(buff_to_recv))
+      {
+        LOG_ERROR("Failed to load_from_binary on command " << command);
+        return false;
+      }
+      return result_struct.load(stg_ret);
+    }
+
+    template<class t_result, class t_arg, class callback_t, class t_transport>
+    bool async_invoke_remote_command2(boost::uuids::uuid conn_id, int command, const t_arg& out_struct, t_transport& transport, const callback_t &cb, size_t inv_timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
+    {
+      typename serialization::portable_storage stg;
+      const_cast<t_arg&>(out_struct).store(stg);//TODO: add true const support to searilzation
+      std::string buff_to_send;
+      stg.store_to_binary(buff_to_send);
+      int res = transport.invoke_async(command, epee::strspan<uint8_t>(buff_to_send), conn_id, [cb, command](int code, const epee::span<const uint8_t> buff, typename t_transport::connection_context& context)->bool 
+      {
+        t_result result_struct = AUTO_VAL_INIT(result_struct);
+        if( code <=0 )
+        {
+          LOG_PRINT_L1("Failed to invoke command " << command << " return code " << code);
+          cb(code, result_struct, context);
+          return false;
+        }
+        serialization::portable_storage stg_ret;
+        if(!stg_ret.load_from_binary(buff))
+        {
+          LOG_ERROR("Failed to load_from_binary on command " << command);
+          cb(LEVIN_ERROR_FORMAT, result_struct, context);
+          return false;
+        }
+        if (!result_struct.load(stg_ret))
+        {
+          LOG_ERROR("Failed to load result struct on command " << command);
+          cb(LEVIN_ERROR_FORMAT, result_struct, context);
+          return false;
+        }
+        cb(code, result_struct, context);
+        return true;
+      }, inv_timeout);
+      if( res <=0 )
+      {
+        LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
+        return false;
+      }
+      return true;
+    }
+
+    template<class t_arg, class t_transport>
+    bool notify_remote_command2(boost::uuids::uuid conn_id, int command, const t_arg& out_struct, t_transport& transport)
+    {
+
+      serialization::portable_storage stg;
+      out_struct.store(stg);
+      std::string buff_to_send;
+      stg.store_to_binary(buff_to_send);
+
+      int res = transport.notify(command, epee::strspan<uint8_t>(buff_to_send), conn_id);
+      if(res <=0 )
+      {
+        MERROR("Failed to notify command " << command << " return code " << res);
+        return false;
+      }
+      return true;
+    }
+    //----------------------------------------------------------------------------------------------------
+    //----------------------------------------------------------------------------------------------------
+    template<class t_owner, class t_in_type, class t_out_type, class t_context, class callback_t>
+    int buff_to_t_adapter(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, callback_t cb, t_context& context )
+    {
+      serialization::portable_storage strg;
+      if(!strg.load_from_binary(in_buff))
+      {
+        LOG_ERROR("Failed to load_from_binary in command " << command);
+        return -1;
+      }
+      boost::value_initialized<t_in_type> in_struct;
+      boost::value_initialized<t_out_type> out_struct;
+
+      if (!static_cast<t_in_type&>(in_struct).load(strg))
+      {
+        LOG_ERROR("Failed to load in_struct in command " << command);
+        return -1;
+      }
+      int res = cb(command, static_cast<t_in_type&>(in_struct), static_cast<t_out_type&>(out_struct), context);
+      serialization::portable_storage strg_out;
+      static_cast<t_out_type&>(out_struct).store(strg_out);
+
+      if(!strg_out.store_to_binary(buff_out))
+      {
+        LOG_ERROR("Failed to store_to_binary in command" << command);
+        return -1;
+      }
+
+      return res;
+    }
+
+    template<class t_owner, class t_in_type, class t_context, class callback_t>
+    int buff_to_t_adapter(t_owner* powner, int command, const epee::span<const uint8_t> in_buff, callback_t cb, t_context& context)
+    {
+      serialization::portable_storage strg;
+      if(!strg.load_from_binary(in_buff))
+      {
+        LOG_ERROR("Failed to load_from_binary in notify " << command);
+        return -1;
+      }
+      boost::value_initialized<t_in_type> in_struct;
+      if (!static_cast<t_in_type&>(in_struct).load(strg))
+      {
+        LOG_ERROR("Failed to load in_struct in notify " << command);
+        return -1;
+      }
+      return cb(command, in_struct, context);
+    }
+
+#define CHAIN_LEVIN_INVOKE_MAP2(context_type) \
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, context_type& context) \
+  { \
+  bool handled = false; \
+  return handle_invoke_map(false, command, in_buff, buff_out, context, handled); \
+  } 
+
+#define CHAIN_LEVIN_NOTIFY_MAP2(context_type) \
+  int notify(int command, const epee::span<const uint8_t> in_buff, context_type& context) \
+  { \
+  bool handled = false; std::string fake_str;\
+  return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
+  } 
+
+
+#define CHAIN_LEVIN_INVOKE_MAP() \
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, epee::net_utils::connection_context_base& context) \
+  { \
+  bool handled = false; \
+  return handle_invoke_map(false, command, in_buff, buff_out, context, handled); \
+  } 
+
+#define CHAIN_LEVIN_NOTIFY_MAP() \
+  int notify(int command, const epee::span<const uint8_t> in_buff, epee::net_utils::connection_context_base& context) \
+  { \
+  bool handled = false; std::string fake_str;\
+  return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
+  } 
+
+#define CHAIN_LEVIN_NOTIFY_STUB() \
+  int notify(int command, const epee::span<const uint8_t> in_buff, epee::net_utils::connection_context_base& context) \
+  { \
+  return -1; \
+  } 
+
+#define BEGIN_INVOKE_MAP2(owner_type) \
+  template <class t_context> int handle_invoke_map(bool is_notify, int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, t_context& context, bool& handled) \
+  { \
+  typedef owner_type internal_owner_type_name;
+
+#define HANDLE_INVOKE2(command_id, func, type_name_in, typename_out) \
+  if(!is_notify && command_id == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, type_name_in, typename_out>(this, command, in_buff, buff_out, boost::bind(func, this, _1, _2, _3, _4), context);}
+
+#define HANDLE_INVOKE_T2(COMMAND, func) \
+  if(!is_notify && COMMAND::ID == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, typename COMMAND::request, typename COMMAND::response>(command, in_buff, buff_out, boost::bind(func, this, _1, _2, _3, _4), context);}
+
+
+#define HANDLE_NOTIFY2(command_id, func, type_name_in) \
+  if(is_notify && command_id == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, type_name_in>(this, command, in_buff, boost::bind(func, this, _1, _2, _3), context);}
+
+#define HANDLE_NOTIFY_T2(NOTIFY, func) \
+  if(is_notify && NOTIFY::ID == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, typename NOTIFY::request>(this, command, in_buff, boost::bind(func, this, _1, _2, _3), context);}
+
+
+#define CHAIN_INVOKE_MAP2(func) \
+  { \
+  int res = func(is_notify, command, in_buff, buff_out, context, handled); \
+  if(handled) \
+  return res; \
+  }
+
+#define CHAIN_INVOKE_MAP_TO_OBJ2(obj) \
+  { \
+  int res = obj.handle_invoke_map(is_notify, command, in_buff, buff_out, context, handled); \
+  if(handled) \
+  return res; \
+  }
+
+#define CHAIN_INVOKE_MAP_TO_OBJ_FORCE_CONTEXT(obj, context_type) \
+  { \
+  int res = obj.handle_invoke_map(is_notify, command, in_buff, buff_out, static_cast<context_type>(context), handled); \
+  if(handled) return res; \
+  }
+
+
+#define END_INVOKE_MAP2() \
+  LOG_ERROR("Unknown command:" << command); \
+  return LEVIN_ERROR_CONNECTION_HANDLER_NOT_DEFINED; \
+  }
+  }
+}
+

src/contrib/epee/include/storages/parserse_base_utils.h

@@ -0,0 +1,318 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include <algorithm>
+#include <boost/utility/string_ref.hpp>
+
+namespace epee 
+{
+namespace misc_utils
+{
+  namespace parse
+  {
+    // 1: digit
+    // 2: .eE (floating point)
+    // 4: alpha
+    // 8: whitespace
+    // 16: allowed in float but doesn't necessarily mean it's a float
+    // 32: \ and " (end of verbatim string)
+    static const constexpr uint8_t lut[256]={
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, // 16
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32
+      8, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 16, 18, 0, // 48
+      17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, 0, // 64
+      0, 4, 4, 4, 4, 22, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 80
+      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 32, 0, 0, 0, // 96
+      0, 4, 4, 4, 4, 22, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 112
+      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, // 128
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    };
+
+    inline bool isspace(char c)
+    {
+      return lut[(uint8_t)c] & 8;
+    }
+
+    inline bool isdigit(char c)
+    {
+      return lut[(uint8_t)c] & 1;
+    }
+
+    inline std::string transform_to_escape_sequence(const std::string& src)
+    {
+      static const char escaped[] = "\b\f\n\r\t\v\"\\/";
+      std::string::const_iterator it = std::find_first_of(src.begin(), src.end(), escaped, escaped + sizeof(escaped));
+      if (it == src.end())
+        return src;
+
+      std::string res;
+      res.reserve(2 * src.size());
+      res.assign(src.begin(), it);
+      for(; it!=src.end(); ++it)
+      {
+        switch(*it)
+        {
+        case '\b':  //Backspace (ascii code 08)
+          res+="\\b"; break;
+        case '\f':  //Form feed (ascii code 0C)
+          res+="\\f"; break;
+        case '\n':  //New line
+          res+="\\n"; break;
+        case '\r':  //Carriage return
+          res+="\\r"; break;
+        case '\t':  //Tab
+          res+="\\t"; break;
+        case '\v':  //Vertical tab
+          res+="\\v"; break;
+        //case '\'':  //Apostrophe or single quote
+        //  res+="\\'"; break;
+        case '"':  //Double quote
+          res+="\\\""; break;
+        case '\\':  //Backslash caracter
+          res+="\\\\"; break;
+        case '/':  //Backslash caracter
+          res+="\\/"; break;
+        default:
+          res.push_back(*it);
+        }
+      }
+      return res;
+    }
+    /*
+      
+      \b  Backspace (ascii code 08)
+      \f  Form feed (ascii code 0C)
+      \n  New line
+      \r  Carriage return
+      \t  Tab
+      \v  Vertical tab
+      \'  Apostrophe or single quote
+      \"  Double quote
+      \\  Backslash character
+
+      */
+      inline void match_string2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
+      {
+        bool escape_mode = false;
+        std::string::const_iterator it = star_end_string;
+        ++it;
+        std::string::const_iterator fi = it;
+        while (fi != buf_end && ((lut[(uint8_t)*fi] & 32)) == 0)
+          ++fi;
+        val.assign(it, fi);
+        val.reserve(std::distance(star_end_string, buf_end));
+        it = fi;
+        for(;it != buf_end;it++)
+        {
+          if(escape_mode/*prev_ch == '\\'*/)
+          {
+            switch(*it)
+            {
+            case 'b':  //Backspace (ascii code 08)
+              val.push_back(0x08);break;
+            case 'f':  //Form feed (ascii code 0C)
+              val.push_back(0x0C);break;
+            case 'n':  //New line
+              val.push_back('\n');break;
+            case 'r':  //Carriage return
+              val.push_back('\r');break;
+            case 't':  //Tab
+              val.push_back('\t');break;
+            case 'v':  //Vertical tab
+              val.push_back('\v');break;
+            case '\'':  //Apostrophe or single quote
+              val.push_back('\'');break;
+            case '"':  //Double quote
+              val.push_back('"');break;
+            case '\\':  //Backslash character
+              val.push_back('\\');break;
+            case '/':  //Slash character
+              val.push_back('/');break;
+            default:
+              val.push_back(*it);
+              LOG_PRINT_L0("Unknown escape sequence :\"\\" << *it << "\"");
+            }
+            escape_mode = false;
+          }else if(*it == '"')
+          {
+            star_end_string = it;
+            return;
+          }else if(*it == '\\')
+          {
+            escape_mode = true;
+          }          
+          else
+          {
+            val.push_back(*it); 
+          }
+        }
+        ASSERT_MES_AND_THROW("Failed to match string in json entry: " << std::string(star_end_string, buf_end));
+      }
+      inline bool match_string(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
+      {
+        try
+        {
+
+          match_string2(star_end_string, buf_end, val);
+          return true;
+        }
+        catch(...)
+        {
+          return false;
+        }
+      }
+      inline void match_number2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val, bool& is_float_val, bool& is_signed_val)
+      {
+        val.clear();
+        uint8_t float_flag = 0;
+        is_signed_val = false;
+        size_t chars = 0;
+        std::string::const_iterator it = star_end_string;
+        if (it != buf_end && *it == '-')
+        {
+          is_signed_val = true;
+          ++chars;
+          ++it;
+        }
+        for(;it != buf_end;it++)
+        {
+          const uint8_t flags = lut[(uint8_t)*it];
+          if (flags & 16)
+          {
+            float_flag |= flags;
+            ++chars;
+          }
+          else
+          {
+            val = boost::string_ref(&*star_end_string, chars);
+            if(val.size())
+            {
+              star_end_string = --it;
+              is_float_val = !!(float_flag & 2);
+              return;
+            }
+            else 
+              ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
+          }
+        }
+        ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
+      }
+      inline bool match_number(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
+      {
+        try
+        {
+          bool is_v_float = false;bool is_signed_val = false;
+          match_number2(star_end_string, buf_end, val, is_v_float, is_signed_val);
+          return !is_v_float;
+        }
+        catch(...)
+        {
+          return false;
+        }
+      }
+      inline void match_word2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
+      {
+        val.clear();
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if (!(lut[(uint8_t)*it] & 4))
+          {
+            val = boost::string_ref(&*star_end_string, std::distance(star_end_string, it));
+            if(val.size())
+            {
+              star_end_string = --it;
+              return;
+            }else 
+              ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
+          }
+        }
+        ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
+      }
+      inline bool match_word(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
+      {
+        try
+        {
+          match_word2(star_end_string, buf_end, val);
+          return true;
+        }
+        catch(...)
+        {
+          return false;
+        }
+      }
+      inline bool match_word_with_extrasymb(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
+      {
+        val.clear();
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if(!isalnum(*it) && *it != '-' && *it != '_')
+          {
+            val.assign(star_end_string, it);
+            if(val.size())
+            {
+              star_end_string = --it;
+              return true;
+            }else 
+              return false;
+          }
+        }
+        return false;
+      }
+      inline bool match_word_til_equal_mark(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string::const_iterator& word_end)
+      {
+        word_end = star_end_string;
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if(isspace(*it))
+          {
+
+            continue;
+          }else if( *it == '=' )
+          {            
+            star_end_string = it;
+            word_end = it;
+            return true;
+          }
+        }
+        return false;
+      }
+  }
+}
+}

src/contrib/epee/include/storages/portable_storage.h

@@ -0,0 +1,482 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include "misc_language.h"
+#include "portable_storage_base.h"
+#include "portable_storage_to_bin.h"
+#include "portable_storage_from_bin.h"
+#include "portable_storage_to_json.h"
+#include "portable_storage_from_json.h"
+#include "portable_storage_val_converters.h"
+#include "span.h"
+#include "int-util.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+    /************************************************************************/
+    /*                                                                      */
+    /************************************************************************/
+    class portable_storage
+    {
+    public:
+      typedef epee::serialization::hsection hsection;
+      typedef epee::serialization::harray  harray;
+      typedef storage_entry meta_entry;
+
+      portable_storage(){}
+      virtual ~portable_storage(){}
+      hsection   open_section(const std::string& section_name,  hsection hparent_section, bool create_if_notexist = false);
+      template<class t_value>
+      bool       get_value(const std::string& value_name, t_value& val, hsection hparent_section);
+      bool       get_value(const std::string& value_name, storage_entry& val, hsection hparent_section);
+      template<class t_value>
+      bool       set_value(const std::string& value_name, const t_value& target, hsection hparent_section);
+
+      //serial access for arrays of values --------------------------------------
+      //values
+      template<class t_value>
+      harray get_first_value(const std::string& value_name, t_value& target, hsection hparent_section);
+      template<class t_value>
+      bool          get_next_value(harray hval_array, t_value& target);
+      template<class t_value>
+      harray insert_first_value(const std::string& value_name, const t_value& target, hsection hparent_section);
+      template<class t_value>
+      bool          insert_next_value(harray hval_array, const t_value& target);
+      //sections
+      harray get_first_section(const std::string& pSectionName, hsection& h_child_section, hsection hparent_section);
+      bool            get_next_section(harray hSecArray, hsection& h_child_section);
+      harray insert_first_section(const std::string& pSectionName, hsection& hinserted_childsection, hsection hparent_section);
+      bool            insert_next_section(harray hSecArray, hsection& hinserted_childsection);
+      //------------------------------------------------------------------------
+      //delete entry (section, value or array)
+      bool        delete_entry(const std::string& pentry_name, hsection hparent_section = nullptr);
+
+      //-------------------------------------------------------------------------------
+      bool		store_to_binary(binarybuffer& target);
+      bool		load_from_binary(const epee::span<const uint8_t> target);
+      bool		load_from_binary(const std::string& target) { return load_from_binary(epee::strspan<uint8_t>(target)); }
+      template<class trace_policy>
+      bool		  dump_as_xml(std::string& targetObj, const std::string& root_name = "");
+      bool		  dump_as_json(std::string& targetObj, size_t indent = 0, bool insert_newlines = true);
+      bool		  load_from_json(const std::string& source);
+
+    private:
+      section m_root;
+      hsection	get_root_section() {return &m_root;}
+      storage_entry* find_storage_entry(const std::string& pentry_name, hsection psection);
+      template<class entry_type>
+      storage_entry* insert_new_entry_get_storage_entry(const std::string& pentry_name, hsection psection, const entry_type& entry);
+
+      hsection    insert_new_section(const std::string& pentry_name, hsection psection);
+
+#pragma pack(push)
+#pragma pack(1)
+      struct storage_block_header
+      {
+        uint32_t m_signature_a;
+        uint32_t m_signature_b;
+        uint8_t  m_ver;
+      };
+#pragma pack(pop)
+    };
+    inline
+    bool portable_storage::dump_as_json(std::string& buff, size_t indent, bool insert_newlines)
+    {
+      TRY_ENTRY();
+      std::stringstream ss;
+      epee::serialization::dump_as_json(ss, m_root, indent, insert_newlines);
+      buff = ss.str();
+      return true;
+      CATCH_ENTRY("portable_storage::dump_as_json", false)
+    }
+    inline
+    bool portable_storage::load_from_json(const std::string& source)
+    {
+      TRY_ENTRY();
+      return json::load_from_json(source, *this);
+      CATCH_ENTRY("portable_storage::load_from_json", false)
+    }
+
+    template<class trace_policy>
+    bool portable_storage::dump_as_xml(std::string& targetObj, const std::string& root_name)
+    {
+      return false;//TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
+    }
+
+    inline
+    bool portable_storage::store_to_binary(binarybuffer& target)
+    {
+      TRY_ENTRY();
+      std::stringstream ss;
+      storage_block_header sbh = AUTO_VAL_INIT(sbh);
+      sbh.m_signature_a = SWAP32LE(PORTABLE_STORAGE_SIGNATUREA);
+      sbh.m_signature_b = SWAP32LE(PORTABLE_STORAGE_SIGNATUREB);
+      sbh.m_ver = PORTABLE_STORAGE_FORMAT_VER;
+      ss.write((const char*)&sbh, sizeof(storage_block_header));
+      pack_entry_to_buff(ss, m_root);
+      target = ss.str();
+      return true;
+      CATCH_ENTRY("portable_storage::store_to_binary", false)
+    }
+    inline
+    bool portable_storage::load_from_binary(const epee::span<const uint8_t> source)
+    {
+      m_root.m_entries.clear();
+      if(source.size() < sizeof(storage_block_header))
+      {
+        LOG_ERROR("portable_storage: wrong binary format, packet size = " << source.size() << " less than expected sizeof(storage_block_header)=" << sizeof(storage_block_header));
+        return false;
+      }
+      storage_block_header* pbuff = (storage_block_header*)source.data();
+      if(pbuff->m_signature_a != SWAP32LE(PORTABLE_STORAGE_SIGNATUREA) ||
+        pbuff->m_signature_b != SWAP32LE(PORTABLE_STORAGE_SIGNATUREB)
+        )
+      {
+        LOG_ERROR("portable_storage: wrong binary format - signature mismatch");
+        return false;
+      }
+      if(pbuff->m_ver != PORTABLE_STORAGE_FORMAT_VER)
+      {
+        LOG_ERROR("portable_storage: wrong binary format - unknown format ver = " << pbuff->m_ver);
+        return false;
+      }
+      TRY_ENTRY();
+      throwable_buffer_reader buf_reader(source.data()+sizeof(storage_block_header), source.size()-sizeof(storage_block_header));
+      buf_reader.read(m_root);
+      return true;//TODO:
+      CATCH_ENTRY("portable_storage::load_from_binary", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    hsection portable_storage::open_section(const std::string& section_name,  hsection hparent_section, bool create_if_notexist)
+    {
+      TRY_ENTRY();
+      hparent_section = hparent_section ? hparent_section:&m_root;
+      storage_entry* pentry = find_storage_entry(section_name, hparent_section);
+      if(!pentry)
+      {
+        if(!create_if_notexist)
+          return nullptr;
+        return insert_new_section(section_name, hparent_section);
+      }
+      CHECK_AND_ASSERT(pentry , nullptr);
+      //check that section_entry we find is real "CSSection"
+      if(pentry->type() != typeid(section))
+      {
+        if(create_if_notexist)
+          *pentry = storage_entry(section());//replace
+        else
+          return nullptr;
+      }
+      return &boost::get<section>(*pentry);
+      CATCH_ENTRY("portable_storage::open_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class to_type>
+    struct get_value_visitor: boost::static_visitor<void>
+    {
+      to_type& m_target;
+      get_value_visitor(to_type& target):m_target(target){}
+      template<class from_type>
+      void operator()(const from_type& v){convert_t(v, m_target);}
+    };
+
+    template<class t_value>
+    bool portable_storage::get_value(const std::string& value_name, t_value& val, hsection hparent_section)
+    {
+      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
+      //TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+        return false;
+
+      get_value_visitor<t_value> gvv(val);
+      boost::apply_visitor(gvv, *pentry);
+      return true;
+      //CATCH_ENTRY("portable_storage::template<>get_value", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::get_value(const std::string& value_name, storage_entry& val, hsection hparent_section)
+    {
+      //TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+        return false;
+
+      val = *pentry;
+      return true;
+      //CATCH_ENTRY("portable_storage::template<>get_value", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class t_value>
+    bool portable_storage::set_value(const std::string& value_name, const t_value& v, hsection hparent_section)        
+    {
+      BOOST_MPL_ASSERT(( boost::mpl::contains<boost::mpl::push_front<storage_entry::types, storage_entry>::type, t_value> )); 
+      TRY_ENTRY();
+      if(!hparent_section)
+        hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+      {
+        pentry = insert_new_entry_get_storage_entry(value_name, hparent_section, v);
+        if(!pentry)
+          return false;
+        return true;
+      }
+      *pentry = storage_entry(v);
+      return true;
+      CATCH_ENTRY("portable_storage::template<>set_value", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    storage_entry* portable_storage::find_storage_entry(const std::string& pentry_name, hsection psection)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(psection, nullptr);
+      auto it = psection->m_entries.find(pentry_name);
+      if(it == psection->m_entries.end())
+        return nullptr;
+
+      return &it->second;
+      CATCH_ENTRY("portable_storage::find_storage_entry", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class entry_type>
+    storage_entry* portable_storage::insert_new_entry_get_storage_entry(const std::string& pentry_name, hsection psection, const entry_type& entry)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(psection, nullptr);
+      auto ins_res = psection->m_entries.insert(std::pair<std::string, storage_entry>(pentry_name, entry));
+      return &ins_res.first->second;
+      CATCH_ENTRY("portable_storage::insert_new_entry_get_storage_entry", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    hsection portable_storage::insert_new_section(const std::string& pentry_name, hsection psection)
+    {
+      TRY_ENTRY();
+      storage_entry* pse = insert_new_entry_get_storage_entry(pentry_name, psection, section());
+      if(!pse) return nullptr;
+      return &boost::get<section>(*pse);
+      CATCH_ENTRY("portable_storage::insert_new_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class to_type>
+    struct get_first_value_visitor: boost::static_visitor<bool>
+    {
+      to_type& m_target;
+      get_first_value_visitor(to_type& target):m_target(target){}
+      template<class from_type>
+      bool operator()(const array_entry_t<from_type>& a)
+      {
+        const from_type* pv = a.get_first_val();
+        if(!pv)
+          return false;
+        convert_t(*pv, m_target);
+        return true;
+      }
+    };
+    //---------------------------------------------------------------------------------------------------------------
+    template<class t_value>
+    harray portable_storage::get_first_value(const std::string& value_name, t_value& target, hsection hparent_section)
+    {
+      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
+      //TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+        return nullptr;
+      if(pentry->type() != typeid(array_entry))
+        return nullptr;
+      array_entry& ar_entry = boost::get<array_entry>(*pentry);
+      
+      get_first_value_visitor<t_value> gfv(target);
+      if(!boost::apply_visitor(gfv, ar_entry))
+        return nullptr;
+      return &ar_entry;
+      //CATCH_ENTRY("portable_storage::get_first_value", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class to_type>
+    struct get_next_value_visitor: boost::static_visitor<bool>
+    {
+      to_type& m_target;
+      get_next_value_visitor(to_type& target):m_target(target){}
+      template<class from_type>
+      bool operator()(const array_entry_t<from_type>& a)
+      {
+        //TODO: optimize code here: work without get_next_val function
+        const from_type* pv = a.get_next_val();
+        if(!pv)
+          return false;
+        convert_t(*pv, m_target);
+        return true;
+      }
+    };
+
+
+    template<class t_value>
+    bool portable_storage::get_next_value(harray hval_array, t_value& target)
+    {
+      BOOST_MPL_ASSERT(( boost::mpl::contains<storage_entry::types, t_value> )); 
+      //TRY_ENTRY();
+      CHECK_AND_ASSERT(hval_array, false);
+      array_entry& ar_entry = *hval_array;
+      get_next_value_visitor<t_value> gnv(target);
+      if(!boost::apply_visitor(gnv, ar_entry))
+        return false;
+      return true;
+      //CATCH_ENTRY("portable_storage::get_next_value", false);
+    } 
+    //---------------------------------------------------------------------------------------------------------------
+    template<class t_value>
+    harray portable_storage::insert_first_value(const std::string& value_name, const t_value& target, hsection hparent_section)
+    {
+      TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+      {
+        pentry = insert_new_entry_get_storage_entry(value_name, hparent_section, array_entry(array_entry_t<t_value>()));
+        if(!pentry)
+          return nullptr;
+      }
+      if(pentry->type() != typeid(array_entry))
+        *pentry = storage_entry(array_entry(array_entry_t<t_value>()));
+
+      array_entry& arr = boost::get<array_entry>(*pentry);
+      if(arr.type() != typeid(array_entry_t<t_value>))
+        arr = array_entry(array_entry_t<t_value>());
+
+      array_entry_t<t_value>& arr_typed = boost::get<array_entry_t<t_value> >(arr);
+      arr_typed.insert_first_val(target);
+      return &arr;
+      CATCH_ENTRY("portable_storage::insert_first_value", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    template<class t_value>
+    bool portable_storage::insert_next_value(harray hval_array, const t_value& target)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(hval_array, false);
+
+      CHECK_AND_ASSERT_MES(hval_array->type() == typeid(array_entry_t<t_value>), 
+        false, "unexpected type in insert_next_value: " << typeid(array_entry_t<t_value>).name());
+
+      array_entry_t<t_value>& arr_typed = boost::get<array_entry_t<t_value> >(*hval_array);
+      arr_typed.insert_next_value(target);
+      return true;
+      CATCH_ENTRY("portable_storage::insert_next_value", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    //sections
+    inline
+    harray portable_storage::get_first_section(const std::string& sec_name, hsection& h_child_section, hsection hparent_section)
+    {
+      TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
+      if(!pentry)
+        return nullptr;
+      if(pentry->type() != typeid(array_entry))
+        return nullptr;
+      array_entry& ar_entry = boost::get<array_entry>(*pentry);
+      if(ar_entry.type() != typeid(array_entry_t<section>))
+        return nullptr;
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
+      section* psec = sec_array.get_first_val();
+      if(!psec)
+        return nullptr;
+      h_child_section = psec;
+      return &ar_entry;
+      CATCH_ENTRY("portable_storage::get_first_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::get_next_section(harray hsec_array, hsection& h_child_section)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(hsec_array, false);
+      if(hsec_array->type() != typeid(array_entry_t<section>))
+        return false;
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
+      h_child_section = sec_array.get_next_val();
+      if(!h_child_section)
+        return false;
+      return true;
+      CATCH_ENTRY("portable_storage::get_next_section", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    harray portable_storage::insert_first_section(const std::string& sec_name, hsection& hinserted_childsection, hsection hparent_section)
+    {
+      TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
+      if(!pentry)
+      {
+        pentry = insert_new_entry_get_storage_entry(sec_name, hparent_section, array_entry(array_entry_t<section>()));
+        if(!pentry)
+          return nullptr;
+      }
+      if(pentry->type() != typeid(array_entry))
+        *pentry = storage_entry(array_entry(array_entry_t<section>()));
+
+      array_entry& ar_entry = boost::get<array_entry>(*pentry);
+      if(ar_entry.type() != typeid(array_entry_t<section>))
+        ar_entry = array_entry(array_entry_t<section>());
+
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
+      hinserted_childsection = &sec_array.insert_first_val(section());
+      return &ar_entry;
+      CATCH_ENTRY("portable_storage::insert_first_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::insert_next_section(harray hsec_array, hsection& hinserted_childsection)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(hsec_array, false);
+      CHECK_AND_ASSERT_MES(hsec_array->type() == typeid(array_entry_t<section>), 
+        false, "unexpected type(not 'section') in insert_next_section, type: " << hsec_array->type().name());
+
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
+      hinserted_childsection = &sec_array.insert_next_value(section());
+      return true;
+      CATCH_ENTRY("portable_storage::insert_next_section", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+  }
+}

src/contrib/epee/include/storages/portable_storage_base.h

@@ -0,0 +1,170 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include <boost/variant.hpp>
+#include <boost/any.hpp>
+#include <string>
+#include <vector>
+#include <deque>
+
+#define PORTABLE_STORAGE_SIGNATUREA 0x01011101
+#define PORTABLE_STORAGE_SIGNATUREB 0x01020101 // bender's nightmare 
+#define PORTABLE_STORAGE_FORMAT_VER 1
+
+#define PORTABLE_RAW_SIZE_MARK_MASK   0x03 
+#define PORTABLE_RAW_SIZE_MARK_BYTE   0
+#define PORTABLE_RAW_SIZE_MARK_WORD   1
+#define PORTABLE_RAW_SIZE_MARK_DWORD  2
+#define PORTABLE_RAW_SIZE_MARK_INT64  3
+
+#ifndef MAX_STRING_LEN_POSSIBLE       
+#define MAX_STRING_LEN_POSSIBLE       2000000000 //do not let string be so big
+#endif
+
+//data types 
+#define SERIALIZE_TYPE_INT64                1
+#define SERIALIZE_TYPE_INT32                2
+#define SERIALIZE_TYPE_INT16                3
+#define SERIALIZE_TYPE_INT8                 4
+#define SERIALIZE_TYPE_UINT64               5
+#define SERIALIZE_TYPE_UINT32               6
+#define SERIALIZE_TYPE_UINT16               7
+#define SERIALIZE_TYPE_UINT8                8
+#define SERIALIZE_TYPE_DUOBLE               9
+#define SERIALIZE_TYPE_STRING               10
+#define SERIALIZE_TYPE_BOOL                 11
+#define SERIALIZE_TYPE_OBJECT               12
+#define SERIALIZE_TYPE_ARRAY                13
+
+#define SERIALIZE_FLAG_ARRAY              0x80
+
+
+namespace epee
+{
+  namespace serialization
+  {
+    struct section;
+
+    template<typename T> struct entry_container { typedef std::vector<T> type; static void reserve(type &t, size_t n) { t.reserve(n); } };
+    template<> struct entry_container<bool> { typedef std::deque<bool> type; static void reserve(type &t, size_t n) {} };
+
+    /************************************************************************/
+    /*                                                                      */
+    /************************************************************************/
+    template<class t_entry_type>
+    struct array_entry_t
+    {
+      array_entry_t():m_it(m_array.end()){}        
+      array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){}
+
+      const t_entry_type* get_first_val() const 
+      {
+        m_it = m_array.begin();
+        return get_next_val();
+      }
+
+      t_entry_type* get_first_val() 
+      {
+        m_it = m_array.begin();
+        return get_next_val();
+      }
+
+
+      const t_entry_type* get_next_val() const 
+      {
+        if(m_it == m_array.end())
+          return nullptr;
+        return &(*(m_it++));
+      }
+
+      t_entry_type* get_next_val() 
+      {
+        if(m_it == m_array.end())
+          return nullptr;
+        return (t_entry_type*)&(*(m_it++));//fuckoff
+      }
+
+      t_entry_type& insert_first_val(const t_entry_type& v)
+      {
+        m_array.clear();
+        m_it = m_array.end();
+        return insert_next_value(v);
+      }
+
+      t_entry_type& insert_next_value(const t_entry_type& v)
+      {
+        m_array.push_back(v);
+        return m_array.back();
+      }
+
+      void reserve(size_t n)
+      {
+        entry_container<t_entry_type>::reserve(m_array, n);
+      }
+
+      typename entry_container<t_entry_type>::type m_array;
+      mutable typename entry_container<t_entry_type>::type::const_iterator m_it;
+    };
+
+
+    typedef  boost::make_recursive_variant<
+      array_entry_t<section>, 
+      array_entry_t<uint64_t>, 
+      array_entry_t<uint32_t>, 
+      array_entry_t<uint16_t>, 
+      array_entry_t<uint8_t>, 
+      array_entry_t<int64_t>, 
+      array_entry_t<int32_t>, 
+      array_entry_t<int16_t>, 
+      array_entry_t<int8_t>, 
+      array_entry_t<double>, 
+      array_entry_t<bool>, 
+      array_entry_t<std::string>,
+      array_entry_t<section>, 
+      array_entry_t<boost::recursive_variant_> 
+    >::type array_entry;
+
+    typedef boost::variant<uint64_t, uint32_t, uint16_t, uint8_t, int64_t, int32_t, int16_t, int8_t, double, bool, std::string, section, array_entry> storage_entry;
+
+    typedef std::string binarybuffer;//it's ok      
+
+    /************************************************************************/
+    /*                                                                      */
+    /************************************************************************/
+    struct section
+    {
+      std::map<std::string, storage_entry> m_entries;
+    };
+
+    //handle-like aliases
+    typedef section*      hsection;  
+    typedef array_entry*  harray;
+  }
+}

src/contrib/epee/include/storages/portable_storage_bin_utils.h

@@ -0,0 +1,46 @@
+// Copyright (c) 2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once 
+
+#include "int-util.h"
+
+template<typename T> T convert_swapper(T t) { return t; }
+template<> inline uint16_t convert_swapper(uint16_t t) { return SWAP16LE(t); }
+template<> inline int16_t convert_swapper(int16_t t) { return SWAP16LE((uint16_t&)t); }
+template<> inline uint32_t convert_swapper(uint32_t t) { return SWAP32LE(t); }
+template<> inline int32_t convert_swapper(int32_t t) { return SWAP32LE((uint32_t&)t); }
+template<> inline uint64_t convert_swapper(uint64_t t) { return SWAP64LE(t); }
+template<> inline int64_t convert_swapper(int64_t t) { return SWAP64LE((uint64_t&)t); }
+template<> inline double convert_swapper(double t) { union { uint64_t u; double d; } u; u.d = t; u.u = SWAP64LE(u.u); return u.d; }
+
+#if BYTE_ORDER == BIG_ENDIAN
+#define CONVERT_POD(x) convert_swapper(x)
+#else
+#define CONVERT_POD(x) (x)
+#endif

src/contrib/epee/include/storages/portable_storage_from_bin.h

@@ -0,0 +1,291 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include "misc_language.h"
+#include "portable_storage_base.h"
+
+#ifdef EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
+#define EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
+#else 
+#define EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL 100
+#endif
+
+namespace epee
+{
+  namespace serialization
+  {
+    struct throwable_buffer_reader
+    {
+      throwable_buffer_reader(const void* ptr, size_t sz);
+      void read(void* target, size_t count);
+      void read_sec_name(std::string& sce_name);
+      template<class t_pod_type>
+      void read(t_pod_type& pod_val);
+      template<class t_type>
+      t_type read();
+      template<class type_name>
+      storage_entry read_ae();
+      storage_entry load_storage_array_entry(uint8_t type);
+      size_t read_varint();
+      template<class t_type>
+      storage_entry read_se();
+      storage_entry load_storage_entry();
+      void read(section& sec);
+      void read(std::string& str);
+      void read(array_entry &ae);
+    private:
+      struct recursuion_limitation_guard
+      {
+        size_t& m_counter_ref;
+        recursuion_limitation_guard(size_t& counter):m_counter_ref(counter)
+        {
+          ++m_counter_ref;
+          CHECK_AND_ASSERT_THROW_MES(m_counter_ref < EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL, "Wrong blob data in portable storage: recursion limitation (" << EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL << ") exceeded");
+        }
+        ~recursuion_limitation_guard() noexcept(false)
+        {
+          CHECK_AND_ASSERT_THROW_MES(m_counter_ref != 0, "Internal error: m_counter_ref == 0 while ~recursuion_limitation_guard()");
+          --m_counter_ref;
+        }
+      };
+#define RECURSION_LIMITATION()  recursuion_limitation_guard rl(m_recursion_count)
+
+      const uint8_t* m_ptr;
+      size_t m_count;
+      size_t m_recursion_count;
+    };
+
+    inline throwable_buffer_reader::throwable_buffer_reader(const void* ptr, size_t sz)
+    {
+      if(!ptr) 
+        throw std::runtime_error("throwable_buffer_reader: ptr==nullptr");
+      if(!sz)
+        throw std::runtime_error("throwable_buffer_reader: sz==0");
+      m_ptr = (uint8_t*)ptr;
+      m_count = sz;
+      m_recursion_count = 0;
+    }
+    inline 
+    void throwable_buffer_reader::read(void* target, size_t count)
+    {
+      RECURSION_LIMITATION();
+      CHECK_AND_ASSERT_THROW_MES(m_count >= count, " attempt to read " << count << " bytes from buffer with " << m_count << " bytes remained");
+      memcpy(target, m_ptr, count);
+      m_ptr += count;
+      m_count -= count;
+    }
+    inline 
+    void throwable_buffer_reader::read_sec_name(std::string& sce_name)
+    {
+      RECURSION_LIMITATION();
+      uint8_t name_len = 0;
+      read(name_len);
+      sce_name.resize(name_len);
+      read((void*)sce_name.data(), name_len);
+    }
+
+    template<class t_pod_type>
+    void throwable_buffer_reader::read(t_pod_type& pod_val)
+    {
+      RECURSION_LIMITATION();
+      static_assert(std::is_pod<t_pod_type>::value, "POD type expected");
+      read(&pod_val, sizeof(pod_val));
+    }
+    
+    template<class t_type>
+    t_type throwable_buffer_reader::read()
+    {
+      RECURSION_LIMITATION();
+      t_type v;
+      read(v);
+      return v;
+    }
+
+
+    template<class type_name>
+    storage_entry throwable_buffer_reader::read_ae()
+    {
+      RECURSION_LIMITATION();
+      //for pod types
+      array_entry_t<type_name> sa;
+      size_t size = read_varint();
+      CHECK_AND_ASSERT_THROW_MES(size <= m_count, "Size sanity check failed");
+      sa.reserve(size);
+      //TODO: add some optimization here later
+      while(size--)
+        sa.m_array.push_back(read<type_name>());        
+      return storage_entry(array_entry(sa));
+    }
+
+    inline 
+    storage_entry throwable_buffer_reader::load_storage_array_entry(uint8_t type)
+    {
+      RECURSION_LIMITATION();
+      type &= ~SERIALIZE_FLAG_ARRAY;
+      switch(type)
+      {
+      case SERIALIZE_TYPE_INT64:  return read_ae<int64_t>();
+      case SERIALIZE_TYPE_INT32:  return read_ae<int32_t>();
+      case SERIALIZE_TYPE_INT16:  return read_ae<int16_t>();
+      case SERIALIZE_TYPE_INT8:   return read_ae<int8_t>();
+      case SERIALIZE_TYPE_UINT64: return read_ae<uint64_t>();
+      case SERIALIZE_TYPE_UINT32: return read_ae<uint32_t>();
+      case SERIALIZE_TYPE_UINT16: return read_ae<uint16_t>();
+      case SERIALIZE_TYPE_UINT8:  return read_ae<uint8_t>();
+      case SERIALIZE_TYPE_DUOBLE: return read_ae<double>();
+      case SERIALIZE_TYPE_BOOL:   return read_ae<bool>();
+      case SERIALIZE_TYPE_STRING: return read_ae<std::string>();
+      case SERIALIZE_TYPE_OBJECT: return read_ae<section>();
+      case SERIALIZE_TYPE_ARRAY:  return read_ae<array_entry>();
+      default: 
+        CHECK_AND_ASSERT_THROW_MES(false, "unknown entry_type code = " << type);
+      }
+    }
+
+    inline 
+    size_t throwable_buffer_reader::read_varint()
+    {
+      RECURSION_LIMITATION();
+      CHECK_AND_ASSERT_THROW_MES(m_count >= 1, "empty buff, expected place for varint");
+      size_t v = 0;
+      uint8_t size_mask = (*(uint8_t*)m_ptr) &PORTABLE_RAW_SIZE_MARK_MASK;
+      switch (size_mask)
+      {
+      case PORTABLE_RAW_SIZE_MARK_BYTE: v = read<uint8_t>();break;
+      case PORTABLE_RAW_SIZE_MARK_WORD: v = read<uint16_t>();break;
+      case PORTABLE_RAW_SIZE_MARK_DWORD: v = read<uint32_t>();break;
+      case PORTABLE_RAW_SIZE_MARK_INT64: v = read<uint64_t>();break;
+      default:
+        CHECK_AND_ASSERT_THROW_MES(false, "unknown varint size_mask = " << size_mask);
+      }
+      v >>= 2;
+      return v;
+    }
+
+    template<class t_type>
+    storage_entry throwable_buffer_reader::read_se()
+    {
+      RECURSION_LIMITATION();
+      t_type v;
+      read(v);
+      return storage_entry(v);
+    }
+
+    template<>
+    inline storage_entry throwable_buffer_reader::read_se<std::string>()
+    {
+      RECURSION_LIMITATION();
+      return storage_entry(read<std::string>());
+    }
+
+
+    template<>
+    inline storage_entry throwable_buffer_reader::read_se<section>()
+    {
+      RECURSION_LIMITATION();
+      section s;//use extra variable due to vs bug, line "storage_entry se(section()); " can't be compiled in visual studio
+      storage_entry se(s);
+      section& section_entry = boost::get<section>(se);
+      read(section_entry);
+      return se;
+    }
+
+    template<>
+    inline storage_entry throwable_buffer_reader::read_se<array_entry>()
+    {
+      RECURSION_LIMITATION();
+      uint8_t ent_type = 0;
+      read(ent_type);
+      CHECK_AND_ASSERT_THROW_MES(ent_type&SERIALIZE_FLAG_ARRAY, "wrong type sequenses");
+      return load_storage_array_entry(ent_type);
+    }
+
+    inline 
+    storage_entry throwable_buffer_reader::load_storage_entry()
+    {
+      RECURSION_LIMITATION();
+      uint8_t ent_type = 0;
+      read(ent_type);
+      if(ent_type&SERIALIZE_FLAG_ARRAY)
+        return load_storage_array_entry(ent_type);
+
+      switch(ent_type)
+      {
+      case SERIALIZE_TYPE_INT64:  return read_se<int64_t>();
+      case SERIALIZE_TYPE_INT32:  return read_se<int32_t>();
+      case SERIALIZE_TYPE_INT16:  return read_se<int16_t>();
+      case SERIALIZE_TYPE_INT8:   return read_se<int8_t>();
+      case SERIALIZE_TYPE_UINT64: return read_se<uint64_t>();
+      case SERIALIZE_TYPE_UINT32: return read_se<uint32_t>();
+      case SERIALIZE_TYPE_UINT16: return read_se<uint16_t>();
+      case SERIALIZE_TYPE_UINT8:  return read_se<uint8_t>();
+      case SERIALIZE_TYPE_DUOBLE: return read_se<double>();
+      case SERIALIZE_TYPE_BOOL:   return read_se<bool>();
+      case SERIALIZE_TYPE_STRING: return read_se<std::string>();
+      case SERIALIZE_TYPE_OBJECT: return read_se<section>();
+      case SERIALIZE_TYPE_ARRAY:  return read_se<array_entry>();
+      default: 
+        CHECK_AND_ASSERT_THROW_MES(false, "unknown entry_type code = " << ent_type);
+      }
+    }
+    inline 
+    void throwable_buffer_reader::read(section& sec)
+    {
+      RECURSION_LIMITATION();
+      sec.m_entries.clear();
+      size_t count = read_varint();
+      while(count--)
+      {
+        //read section name string
+        std::string sec_name;
+        read_sec_name(sec_name);
+        sec.m_entries.insert(std::make_pair(sec_name, load_storage_entry()));
+      }
+    }
+    inline 
+    void throwable_buffer_reader::read(std::string& str)
+    {
+      RECURSION_LIMITATION();
+      size_t len = read_varint();
+      CHECK_AND_ASSERT_THROW_MES(len < MAX_STRING_LEN_POSSIBLE, "to big string len value in storage: " << len);
+      CHECK_AND_ASSERT_THROW_MES(m_count >= len, "string len count value " << len << " goes out of remain storage len " << m_count);
+      //do this manually to avoid double memory write in huge strings (first time at resize, second at read)
+      str.assign((const char*)m_ptr, len);
+      m_ptr+=len;
+      m_count -= len;
+    }
+    inline
+    void throwable_buffer_reader::read(array_entry &ae)
+    {
+      RECURSION_LIMITATION();
+      CHECK_AND_ASSERT_THROW_MES(false, "Reading array entry is not supported");
+    }
+  }
+}

src/contrib/epee/include/storages/portable_storage_from_json.h

@@ -0,0 +1,414 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#pragma once
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include "parserse_base_utils.h"
+#include "file_io_utils.h"
+
+#define EPEE_JSON_RECURSION_LIMIT_INTERNAL 100
+
+namespace epee
+{
+  using namespace misc_utils::parse;
+  namespace serialization
+  {
+    namespace json
+    {
+#define CHECK_ISSPACE()  if(!epee::misc_utils::parse::isspace(*it)){ ASSERT_MES_AND_THROW("Wrong JSON character at: " << std::string(it, buf_end));}
+
+      /*inline void parse_error()
+      {
+        ASSERT_MES_AND_THROW("json parse error");
+      }*/
+      template<class t_storage>
+      inline void run_handler(typename t_storage::hsection current_section, std::string::const_iterator& sec_buf_begin, std::string::const_iterator buf_end, t_storage& stg, unsigned int recursion)
+      {
+        CHECK_AND_ASSERT_THROW_MES(recursion < EPEE_JSON_RECURSION_LIMIT_INTERNAL, "Wrong JSON data: recursion limitation (" << EPEE_JSON_RECURSION_LIMIT_INTERNAL << ") exceeded");
+
+        std::string::const_iterator sub_element_start;
+        std::string name;        
+        typename t_storage::harray h_array = nullptr;
+        enum match_state
+        {
+          match_state_lookup_for_section_start, 
+          match_state_lookup_for_name, 
+          match_state_waiting_separator, 
+          match_state_wonder_after_separator, 
+          match_state_wonder_after_value, 
+          match_state_wonder_array, 
+          match_state_array_after_value,
+          match_state_array_waiting_value, 
+          match_state_error
+        };
+
+        enum array_mode
+        {
+          array_mode_undifined = 0,
+          array_mode_sections, 
+          array_mode_string, 
+          array_mode_numbers,
+          array_mode_booleans
+        };
+
+        match_state state = match_state_lookup_for_section_start;
+        array_mode array_md = array_mode_undifined;
+        std::string::const_iterator it = sec_buf_begin;
+        for(;it != buf_end;it++)
+        {
+          switch (state)
+          {
+          case match_state_lookup_for_section_start:
+            if(*it == '{')
+              state = match_state_lookup_for_name;
+            else CHECK_ISSPACE();
+            break;
+          case match_state_lookup_for_name:
+            switch(*it)
+            {
+            case '"':
+              match_string2(it, buf_end, name);
+              state = match_state_waiting_separator;
+              break;
+            case '}':
+              //this is it! section ends here.
+              //seems that it is empty section
+              sec_buf_begin = it;
+              return;
+            default:
+              CHECK_ISSPACE();
+            }
+            break;
+          case match_state_waiting_separator:
+            if(*it == ':')
+              state = match_state_wonder_after_separator;
+            else CHECK_ISSPACE();
+            break;
+          case match_state_wonder_after_separator:
+            if(*it == '"')
+            {//just a named string value started
+              std::string val;
+              match_string2(it, buf_end, val);
+              //insert text value 
+              stg.set_value(name, std::move(val), current_section);
+              state = match_state_wonder_after_value;
+            }else if (epee::misc_utils::parse::isdigit(*it) || *it == '-')
+            {//just a named number value started
+              boost::string_ref val;
+              bool is_v_float = false;bool is_signed = false;
+              match_number2(it, buf_end, val, is_v_float, is_signed);
+              if(!is_v_float)
+              {
+                if(is_signed)
+                {
+                  errno = 0;
+                  int64_t nval = strtoll(val.data(), NULL, 10);
+                  if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                  stg.set_value(name, nval, current_section);              
+                }else
+                {
+                  errno = 0;
+                  uint64_t nval = strtoull(val.data(), NULL, 10);
+                  if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                  stg.set_value(name, nval, current_section);              
+                }
+              }else
+              {
+                errno = 0;
+                double nval = strtod(val.data(), NULL);
+                if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                stg.set_value(name, nval, current_section);              
+              }
+              state = match_state_wonder_after_value;
+            }else if(isalpha(*it) )
+            {// could be null, true or false
+              boost::string_ref word;
+              match_word2(it, buf_end, word);
+              if(boost::iequals(word, "null"))
+              {
+                state = match_state_wonder_after_value;
+                //just skip this, 
+              }else if(boost::iequals(word, "true"))
+              {
+                stg.set_value(name, true, current_section);              
+                state = match_state_wonder_after_value;
+              }else if(boost::iequals(word, "false"))
+              {
+                stg.set_value(name, false, current_section);              
+                state = match_state_wonder_after_value;
+              }else ASSERT_MES_AND_THROW("Unknown value keyword " << word);
+            }else if(*it == '{')
+            {
+              //sub section here
+              typename t_storage::hsection new_sec = stg.open_section(name, current_section, true);
+              CHECK_AND_ASSERT_THROW_MES(new_sec, "Failed to insert new section in json: " << std::string(it, buf_end));
+              run_handler(new_sec, it, buf_end, stg, recursion + 1);
+              state = match_state_wonder_after_value;
+            }else if(*it == '[')
+            {//array of something
+              state = match_state_wonder_array;
+            }else CHECK_ISSPACE();
+            break;
+          case match_state_wonder_after_value:
+            if(*it == ',')
+              state = match_state_lookup_for_name;
+            else if(*it == '}')
+            {
+              //this is it! section ends here.
+              sec_buf_begin = it;
+              return;
+            }else CHECK_ISSPACE();
+            break;
+          case match_state_wonder_array:
+            if(*it == '[')
+            {
+              ASSERT_MES_AND_THROW("array of array not suppoerted yet :( sorry"); 
+              //mean array of array
+            }
+            if(*it == '{')
+            {
+              //mean array of sections
+              typename t_storage::hsection new_sec = nullptr;
+              h_array = stg.insert_first_section(name, new_sec, current_section);
+              CHECK_AND_ASSERT_THROW_MES(h_array&&new_sec, "failed to create new section");
+              run_handler(new_sec, it, buf_end, stg, recursion + 1);
+              state = match_state_array_after_value;
+              array_md = array_mode_sections;
+            }else if(*it == '"')
+            {
+              //mean array of strings
+              std::string val;
+              match_string2(it, buf_end, val);
+              h_array = stg.insert_first_value(name, std::move(val), current_section);
+              CHECK_AND_ASSERT_THROW_MES(h_array, " failed to insert values entry");
+              state = match_state_array_after_value;
+              array_md = array_mode_string;
+            }else if (epee::misc_utils::parse::isdigit(*it) || *it == '-')
+            {//array of numbers value started
+              boost::string_ref val;
+              bool is_v_float = false;bool is_signed_val = false;
+              match_number2(it, buf_end, val, is_v_float, is_signed_val);
+              if(!is_v_float)
+              {
+                if (is_signed_val)
+                {
+                  errno = 0;
+                  int64_t nval = strtoll(val.data(), NULL, 10);
+                  if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                  h_array = stg.insert_first_value(name, nval, current_section);
+                }else
+                {
+                  errno = 0;
+                  uint64_t nval = strtoull(val.data(), NULL, 10);
+                  if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                  h_array = stg.insert_first_value(name, nval, current_section);
+                }
+                CHECK_AND_ASSERT_THROW_MES(h_array, " failed to insert values section entry");
+              }else
+              {
+                errno = 0;
+                double nval = strtod(val.data(), NULL);
+                if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                h_array = stg.insert_first_value(name, nval, current_section);
+                CHECK_AND_ASSERT_THROW_MES(h_array, " failed to insert values section entry");
+              }
+
+              state = match_state_array_after_value;
+              array_md = array_mode_numbers;
+            }else if(*it == ']')//empty array
+            {
+              array_md = array_mode_undifined;
+              state = match_state_wonder_after_value;
+            }else if(isalpha(*it) )
+            {// array of booleans
+              boost::string_ref word;
+              match_word2(it, buf_end, word);
+              if(boost::iequals(word, "true"))
+              {
+                h_array = stg.insert_first_value(name, true, current_section);              
+                CHECK_AND_ASSERT_THROW_MES(h_array, " failed to insert values section entry");
+                state = match_state_array_after_value;
+                array_md = array_mode_booleans;
+              }else if(boost::iequals(word, "false"))
+              {
+                h_array = stg.insert_first_value(name, false, current_section);              
+                CHECK_AND_ASSERT_THROW_MES(h_array, " failed to insert values section entry");
+                state = match_state_array_after_value;
+                array_md = array_mode_booleans;
+
+              }else ASSERT_MES_AND_THROW("Unknown value keyword " << word)
+            }else CHECK_ISSPACE();
+            break;
+          case match_state_array_after_value:
+            if(*it == ',')
+              state = match_state_array_waiting_value;
+            else if(*it == ']')
+            {
+              h_array = nullptr;
+              array_md = array_mode_undifined;
+              state = match_state_wonder_after_value;
+            }else CHECK_ISSPACE();
+            break;
+          case match_state_array_waiting_value:
+            switch(array_md)
+            {
+            case array_mode_sections:
+              if(*it == '{')
+              {
+                typename t_storage::hsection new_sec = NULL;
+                bool res = stg.insert_next_section(h_array, new_sec);
+                CHECK_AND_ASSERT_THROW_MES(res&&new_sec, "failed to insert next section");
+                run_handler(new_sec, it, buf_end, stg, recursion + 1);
+                state = match_state_array_after_value;
+              }else CHECK_ISSPACE();
+              break;
+            case array_mode_string:
+              if(*it == '"')
+              {
+                std::string val;
+                match_string2(it, buf_end, val);
+                bool res = stg.insert_next_value(h_array, std::move(val));
+                CHECK_AND_ASSERT_THROW_MES(res, "failed to insert values");
+                state = match_state_array_after_value;
+              }else CHECK_ISSPACE();
+              break;
+            case array_mode_numbers:
+              if (epee::misc_utils::parse::isdigit(*it) || *it == '-')
+              {//array of numbers value started
+                boost::string_ref val;
+                bool is_v_float = false;bool is_signed_val = false;
+                match_number2(it, buf_end, val, is_v_float, is_signed_val);
+                bool insert_res = false;
+                if(!is_v_float)
+                {
+                  if (is_signed_val)
+                  {
+                    errno = 0;
+                    int64_t nval = strtoll(val.data(), NULL, 10);
+                    if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                    insert_res = stg.insert_next_value(h_array, nval);
+                  }else
+                  {
+                    errno = 0;
+                    uint64_t nval = strtoull(val.data(), NULL, 10);
+                    if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                    insert_res = stg.insert_next_value(h_array, nval);
+                  }
+                }else
+                {
+                  errno = 0;
+                  double nval = strtod(val.data(), NULL);
+                  if (errno) throw std::runtime_error("Invalid number: " + std::string(val));
+                  insert_res = stg.insert_next_value(h_array, nval);              
+                }
+                CHECK_AND_ASSERT_THROW_MES(insert_res, "Failed to insert next value");
+                state = match_state_array_after_value;
+                array_md = array_mode_numbers;
+              }else CHECK_ISSPACE();
+              break;
+            case array_mode_booleans:
+              if(isalpha(*it) )
+              {// array of booleans
+                boost::string_ref word;
+                match_word2(it, buf_end, word);
+                if(boost::iequals(word, "true"))
+                {
+                  bool r = stg.insert_next_value(h_array, true);              
+                  CHECK_AND_ASSERT_THROW_MES(r, " failed to insert values section entry");
+                  state = match_state_array_after_value;
+                }else if(boost::iequals(word, "false"))
+                {
+                  bool r = stg.insert_next_value(h_array, false);
+                  CHECK_AND_ASSERT_THROW_MES(r, " failed to insert values section entry");
+                  state = match_state_array_after_value;
+                }
+                else ASSERT_MES_AND_THROW("Unknown value keyword " << word);
+              }else CHECK_ISSPACE();
+              break;
+            case array_mode_undifined:
+            default:
+              ASSERT_MES_AND_THROW("Bad array state");
+            }
+            break;
+          case match_state_error:
+          default:
+            ASSERT_MES_AND_THROW("WRONG JSON STATE");
+          }
+        }
+      }
+/*
+{
+    "firstName": "John",
+    "lastName": "Smith",
+    "age": 25,
+    "address": {
+        "streetAddress": "21 2nd Street",
+        "city": "New York",
+        "state": "NY",
+        "postalCode": -10021, 
+        "have_boobs": true, 
+        "have_balls": false 
+    },
+    "phoneNumber": [
+        {
+            "type": "home",
+            "number": "212 555-1234"
+        },
+        {
+            "type": "fax",
+            "number": "646 555-4567"
+        }
+    ], 
+    "phoneNumbers": [
+    "812 123-1234",
+    "916 123-4567"
+    ]
+}
+*/
+      template<class t_storage>
+      inline bool load_from_json(const std::string& buff_json, t_storage& stg)
+      {
+        std::string::const_iterator sec_buf_begin  = buff_json.begin();
+        try
+        {
+          run_handler(nullptr, sec_buf_begin, buff_json.end(), stg, 0);
+          return true;
+        }
+        catch(const std::exception& ex)
+        {
+          MERROR("Failed to parse json, what: " << ex.what());
+          return false;
+        }
+        catch(...)
+        {
+          MERROR("Failed to parse json");
+          return false;
+        }
+      }
+    }
+  }
+}

src/contrib/epee/include/storages/portable_storage_template_helper.h

@@ -0,0 +1,129 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#pragma once
+
+#include <string>
+
+#include "parserse_base_utils.h"
+#include "portable_storage.h"
+#include "file_io_utils.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool load_t_from_json(t_struct& out, const std::string& json_buff)
+    {
+      portable_storage ps;
+      bool rs = ps.load_from_json(json_buff);
+      if(!rs)
+        return false;
+
+      return out.load(ps);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool load_t_from_json_file(t_struct& out, const std::string& json_file)
+    {
+      std::string f_buff;
+      if(!file_io_utils::load_file_to_string(json_file, f_buff))
+        return false;
+
+      return load_t_from_json(out, f_buff);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool store_t_to_json(t_struct& str_in, std::string& json_buff, size_t indent = 0, bool insert_newlines = true)
+    {
+      portable_storage ps;
+      str_in.store(ps);
+      ps.dump_as_json(json_buff, indent, insert_newlines);
+      return true;
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    std::string store_t_to_json(t_struct& str_in, size_t indent = 0, bool insert_newlines = true)
+    {
+      std::string json_buff;
+      store_t_to_json(str_in, json_buff, indent, insert_newlines);
+      return json_buff;
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool store_t_to_json_file(t_struct& str_in, const std::string& fpath)
+    {
+      std::string json_buff;
+      store_t_to_json(str_in, json_buff);
+      return file_io_utils::save_string_to_file(fpath, json_buff);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool load_t_from_binary(t_struct& out, const epee::span<const uint8_t> binary_buff)
+    {
+      portable_storage ps;
+      bool rs = ps.load_from_binary(binary_buff);
+      if(!rs)
+        return false;
+
+      return out.load(ps);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool load_t_from_binary(t_struct& out, const std::string& binary_buff)
+    {
+      return load_t_from_binary(out, epee::strspan<uint8_t>(binary_buff));
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool load_t_from_binary_file(t_struct& out, const std::string& binary_file)
+    {
+      std::string f_buff;
+      if(!file_io_utils::load_file_to_string(binary_file, f_buff))
+        return false;
+
+      return load_t_from_binary(out, f_buff);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    bool store_t_to_binary(t_struct& str_in, std::string& binary_buff, size_t indent = 0)
+    {
+      portable_storage ps;
+      str_in.store(ps);
+      return ps.store_to_binary(binary_buff);
+    }
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    std::string store_t_to_binary(t_struct& str_in, size_t indent = 0)
+    {
+      std::string binary_buff;
+      store_t_to_binary(str_in, binary_buff, indent);
+      return binary_buff;
+    }
+  }
+}

src/contrib/epee/include/storages/portable_storage_to_bin.h

@@ -0,0 +1,216 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include "pragma_comp_defs.h"
+#include "misc_language.h"
+#include "portable_storage_base.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+
+    template<class pack_value, class t_stream>
+    size_t pack_varint_t(t_stream& strm, uint8_t type_or, size_t& pv)
+    {
+      pack_value v = (*((pack_value*)&pv)) << 2;
+      v |= type_or;
+      strm.write((const char*)&v, sizeof(pack_value));
+      return sizeof(pack_value);
+    }
+
+    PRAGMA_WARNING_PUSH
+      PRAGMA_GCC("GCC diagnostic ignored \"-Wstrict-aliasing\"")
+#ifdef __clang__
+      PRAGMA_GCC("GCC diagnostic ignored \"-Wtautological-constant-out-of-range-compare\"")
+#endif
+      template<class t_stream>
+    size_t pack_varint(t_stream& strm, size_t val)
+    {   //the first two bits always reserved for size information
+
+      if(val <= 63)
+      {//mean enough one byte
+        return pack_varint_t<uint8_t>(strm, PORTABLE_RAW_SIZE_MARK_BYTE, val);
+      }
+      else if(val <= 16383)
+      {//mean need word
+        return pack_varint_t<uint16_t>(strm, PORTABLE_RAW_SIZE_MARK_WORD, val);
+      }else if(val <= 1073741823)
+      {//mean need dword
+        return pack_varint_t<uint32_t>(strm, PORTABLE_RAW_SIZE_MARK_DWORD, val);
+      }else
+      {
+        CHECK_AND_ASSERT_THROW_MES(val <= 4611686018427387903, "failed to pack varint - too big amount = " << val);
+        return pack_varint_t<uint64_t>(strm, PORTABLE_RAW_SIZE_MARK_INT64, val);
+      }
+    }
+    PRAGMA_WARNING_POP
+
+      template<class t_stream>
+    bool put_string(t_stream& strm, const std::string& v)
+    {
+      pack_varint(strm, v.size());
+      if(v.size())
+        strm.write((const char*)v.data(), v.size());        
+      return true;
+    }
+
+    template<class t_stream>
+    struct array_entry_store_visitor: public boost::static_visitor<bool>
+    {
+      t_stream& m_strm;
+
+      template<class t_pod_type>
+      bool pack_pod_array_type(uint8_t contained_type, const array_entry_t<t_pod_type>& arr_pod)
+      {
+        uint8_t type = contained_type|SERIALIZE_FLAG_ARRAY;
+        m_strm.write((const char*)&type, 1);
+        pack_varint(m_strm, arr_pod.m_array.size());
+        for(const t_pod_type& x: arr_pod.m_array)
+          m_strm.write((const char*)&x, sizeof(t_pod_type));
+        return true;
+      }
+
+      array_entry_store_visitor(t_stream& strm):m_strm(strm){}
+      bool operator()(const array_entry_t<uint64_t>& v){ return pack_pod_array_type(SERIALIZE_TYPE_UINT64, v);}
+      bool operator()(const array_entry_t<uint32_t>& v){ return pack_pod_array_type(SERIALIZE_TYPE_UINT32, v);}
+      bool operator()(const array_entry_t<uint16_t>& v){ return pack_pod_array_type(SERIALIZE_TYPE_UINT16, v);}
+      bool operator()(const array_entry_t<uint8_t>& v) { return pack_pod_array_type(SERIALIZE_TYPE_UINT8, v);}
+      bool operator()(const array_entry_t<int64_t>& v) { return pack_pod_array_type(SERIALIZE_TYPE_INT64, v);}
+      bool operator()(const array_entry_t<int32_t>& v) { return pack_pod_array_type(SERIALIZE_TYPE_INT32, v);}
+      bool operator()(const array_entry_t<int16_t>& v) { return pack_pod_array_type(SERIALIZE_TYPE_INT16, v);}
+      bool operator()(const array_entry_t<int8_t>& v)  { return pack_pod_array_type(SERIALIZE_TYPE_INT8, v);}
+      bool operator()(const array_entry_t<double>& v)  { return pack_pod_array_type(SERIALIZE_TYPE_DUOBLE, v);}
+      bool operator()(const array_entry_t<bool>& v)    { return pack_pod_array_type(SERIALIZE_TYPE_BOOL, v);}
+      bool operator()(const array_entry_t<std::string>& arr_str)
+      {
+        uint8_t type = SERIALIZE_TYPE_STRING|SERIALIZE_FLAG_ARRAY;
+        m_strm.write((const char*)&type, 1);
+        pack_varint(m_strm, arr_str.m_array.size());
+        for(const std::string& s: arr_str.m_array)
+          put_string(m_strm, s);
+        return true;
+      }
+      bool operator()(const array_entry_t<section>& arr_sec)    
+      {
+        uint8_t type = SERIALIZE_TYPE_OBJECT|SERIALIZE_FLAG_ARRAY;
+        m_strm.write((const char*)&type, 1);
+        pack_varint(m_strm, arr_sec.m_array.size());
+        for(const section& s: arr_sec.m_array)
+          pack_entry_to_buff(m_strm, s);
+        return true;
+      }
+      bool operator()(const array_entry_t<array_entry>& arra_ar)    
+      {
+        uint8_t type = SERIALIZE_TYPE_ARRAY|SERIALIZE_FLAG_ARRAY;
+        m_strm.write((const char*)&type, 1);
+        pack_varint(m_strm, arra_ar.m_array.size());
+        for(const array_entry& s: arra_ar.m_array)
+          pack_entry_to_buff(m_strm, s);
+        return true;
+      }
+    };
+
+    template<class t_stream>
+    struct storage_entry_store_visitor: public boost::static_visitor<bool>
+    {
+      t_stream& m_strm;
+      storage_entry_store_visitor(t_stream& strm):m_strm(strm){}
+      template<class pod_type>
+      bool pack_pod_type(uint8_t type, const pod_type& v)
+      {
+        m_strm.write((const char*)&type, 1);
+        m_strm.write((const char*)&v, sizeof(pod_type));
+        return true;
+      }
+      //section, array_entry
+      bool operator()(const uint64_t& v){ return pack_pod_type(SERIALIZE_TYPE_UINT64, v);}
+      bool operator()(const uint32_t& v){ return pack_pod_type(SERIALIZE_TYPE_UINT32, v);}
+      bool operator()(const uint16_t& v){ return pack_pod_type(SERIALIZE_TYPE_UINT16, v);}
+      bool operator()(const uint8_t& v) { return pack_pod_type(SERIALIZE_TYPE_UINT8, v);}
+      bool operator()(const int64_t& v) { return pack_pod_type(SERIALIZE_TYPE_INT64, v);}
+      bool operator()(const int32_t& v) { return pack_pod_type(SERIALIZE_TYPE_INT32, v);}
+      bool operator()(const int16_t& v) { return pack_pod_type(SERIALIZE_TYPE_INT16, v);}
+      bool operator()(const int8_t& v)  { return pack_pod_type(SERIALIZE_TYPE_INT8, v);}
+      bool operator()(const double& v)  { return pack_pod_type(SERIALIZE_TYPE_DUOBLE, v);}
+      bool operator()(const bool& v)  { return pack_pod_type(SERIALIZE_TYPE_BOOL, v);}
+      bool operator()(const std::string& v)
+      {
+        uint8_t type = SERIALIZE_TYPE_STRING;
+        m_strm.write((const char*)&type, 1);
+        put_string(m_strm, v);
+        return true;
+      }
+      bool operator()(const section& v)  
+      {
+        uint8_t type = SERIALIZE_TYPE_OBJECT;
+        m_strm.write((const char*)&type, 1);
+        return pack_entry_to_buff(m_strm, v);
+      }
+
+      bool operator()(const array_entry& v)  
+      {
+        //uint8_t type = SERIALIZE_TYPE_ARRAY;
+        //m_strm.write((const char*)&type, 1);
+        return pack_entry_to_buff(m_strm, v);
+      }
+    };
+
+    template<class t_stream>
+    bool pack_entry_to_buff(t_stream& strm, const array_entry& ae)
+    {
+      array_entry_store_visitor<t_stream> aesv(strm);
+      return boost::apply_visitor(aesv, ae);
+    }
+
+    template<class t_stream>
+    bool pack_entry_to_buff(t_stream& strm, const storage_entry& se)
+    {
+      storage_entry_store_visitor<t_stream> sv(strm);
+      return boost::apply_visitor(sv, se);
+    }
+
+    template<class t_stream>
+    bool pack_entry_to_buff(t_stream& strm, const section& sec)
+    {
+      typedef std::map<std::string, storage_entry>::value_type section_pair;
+      pack_varint(strm, sec.m_entries.size());
+      for(const section_pair& se: sec.m_entries)
+      {
+        CHECK_AND_ASSERT_THROW_MES(se.first.size() < std::numeric_limits<uint8_t>::max(), "storage_entry_name is too long: " << se.first.size() << ", val: " << se.first);
+        uint8_t len = static_cast<uint8_t>(se.first.size());
+        strm.write((const char*)&len, sizeof(len));
+        strm.write(se.first.data(), size_t(len));
+        pack_entry_to_buff(strm, se.second);
+      }
+      return true;
+    }
+  }
+}

src/contrib/epee/include/storages/portable_storage_to_json.h

@@ -0,0 +1,181 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once 
+
+#include "misc_language.h"
+#include "portable_storage_base.h"
+#include "parserse_base_utils.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const array_entry& ae, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const storage_entry& se, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const std::string& v, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const int8_t& v, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const uint8_t& v, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const bool& v, size_t indent, bool insert_newlines);
+    template<class t_stream, class t_type>
+    void dump_as_json(t_stream& strm, const t_type& v, size_t indent, bool insert_newlines);
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const section& sec, size_t indent, bool insert_newlines);
+
+
+    inline std::string make_indent(size_t indent)
+    {
+      return std::string(indent*2, ' ');
+    }
+
+    template<class t_stream>
+    struct array_entry_store_to_json_visitor: public boost::static_visitor<void>
+    {
+      t_stream& m_strm;
+      size_t m_indent;
+      bool m_insert_newlines;
+      array_entry_store_to_json_visitor(t_stream& strm, size_t indent,
+                                        bool insert_newlines = true)
+        : m_strm(strm), m_indent(indent), m_insert_newlines(insert_newlines)
+      {}
+
+      template<class t_type>
+      void operator()(const array_entry_t<t_type>& a)
+      {
+        m_strm << "[";
+        if(a.m_array.size())
+        {
+          auto last_it = --a.m_array.end();
+          for(auto it = a.m_array.begin(); it != a.m_array.end(); it++)
+          {
+            dump_as_json(m_strm, *it, m_indent, m_insert_newlines);
+            if(it != last_it)
+              m_strm << ",";
+          }
+        }
+        m_strm << "]";
+      }
+    };
+
+    template<class t_stream>
+    struct storage_entry_store_to_json_visitor: public boost::static_visitor<void>
+    {
+      t_stream& m_strm;
+      size_t m_indent;
+      bool m_insert_newlines;
+      storage_entry_store_to_json_visitor(t_stream& strm, size_t indent,
+                                          bool insert_newlines = true)
+          : m_strm(strm), m_indent(indent), m_insert_newlines(insert_newlines)
+      {}
+      //section, array_entry
+      template<class visited_type>
+      void operator()(const visited_type& v)
+      { 
+        dump_as_json(m_strm, v, m_indent, m_insert_newlines);
+      }
+    };
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const array_entry& ae, size_t indent, bool insert_newlines)
+    {
+      array_entry_store_to_json_visitor<t_stream> aesv(strm, indent, insert_newlines);
+      boost::apply_visitor(aesv, ae);
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const storage_entry& se, size_t indent, bool insert_newlines)
+    {
+      storage_entry_store_to_json_visitor<t_stream> sv(strm, indent, insert_newlines);
+      boost::apply_visitor(sv, se);
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const std::string& v, size_t indent, bool insert_newlines)
+    {
+      strm << "\"" << misc_utils::parse::transform_to_escape_sequence(v) << "\"";
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const int8_t& v, size_t indent, bool insert_newlines)
+    {
+      strm << static_cast<int32_t>(v);
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const uint8_t& v, size_t indent, bool insert_newlines)
+    {
+      strm << static_cast<int32_t>(v);
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const bool& v, size_t indent, bool insert_newlines)
+    {
+      if(v)
+        strm << "true";
+      else
+        strm << "false";
+    }
+
+
+
+    template<class t_stream, class t_type>
+    void dump_as_json(t_stream& strm, const t_type& v, size_t indent, bool insert_newlines)
+    {
+      strm << v;
+    }
+
+    template<class t_stream>
+    void dump_as_json(t_stream& strm, const section& sec, size_t indent, bool insert_newlines)
+    {
+      size_t local_indent = indent + 1;
+      std::string newline = insert_newlines ? "\r\n" : "";
+      strm << "{" << newline;
+      std::string indent_str = make_indent(local_indent);
+      if(sec.m_entries.size())
+      {
+        auto it_last = --sec.m_entries.end();
+        for(auto it = sec.m_entries.begin(); it!= sec.m_entries.end();it++)
+        {
+          strm << indent_str << "\"" << misc_utils::parse::transform_to_escape_sequence(it->first) << "\"" << ": ";
+          dump_as_json(strm, it->second, local_indent, insert_newlines);
+          if(it_last != it)
+            strm << ",";
+          strm << newline;
+        }
+      }
+      strm << make_indent(indent) <<  "}";
+    }
+  }
+}

src/contrib/epee/include/storages/portable_storage_val_converters.h

@@ -0,0 +1,202 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+
+
+#pragma once
+
+#include <time.h>
+#include <boost/regex.hpp>
+
+#include "misc_language.h"
+#include "portable_storage_base.h"
+#include "warnings.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+#define ASSERT_AND_THROW_WRONG_CONVERSION() ASSERT_MES_AND_THROW("WRONG DATA CONVERSION: from type=" << typeid(from).name() << " to type " << typeid(to).name())
+
+    template<typename from_type, typename to_type>
+    void convert_int_to_uint(const from_type& from, to_type& to)
+    {
+PUSH_WARNINGS
+DISABLE_VS_WARNINGS(4018)
+      CHECK_AND_ASSERT_THROW_MES(from >=0, "unexpected int value with signed storage value less than 0, and unsigned receiver value");
+DISABLE_GCC_AND_CLANG_WARNING(sign-compare)
+      CHECK_AND_ASSERT_THROW_MES(from <= std::numeric_limits<to_type>::max(), "int value overhead: try to set value " << from << " to type " << typeid(to_type).name() << " with max possible value = " << std::numeric_limits<to_type>::max());
+      to = static_cast<to_type>(from);
+POP_WARNINGS
+    }
+    template<typename from_type, typename to_type>
+    void convert_int_to_int(const from_type& from, to_type& to)
+    {
+      CHECK_AND_ASSERT_THROW_MES(from >= boost::numeric::bounds<to_type>::lowest(), "int value overhead: try to set value " << from << " to type " << typeid(to_type).name() << " with lowest possible value = " << boost::numeric::bounds<to_type>::lowest());
+PUSH_WARNINGS
+DISABLE_CLANG_WARNING(tautological-constant-out-of-range-compare)
+      CHECK_AND_ASSERT_THROW_MES(from <= std::numeric_limits<to_type>::max(), "int value overhead: try to set value " << from << " to type " << typeid(to_type).name() << " with max possible value = " << std::numeric_limits<to_type>::max());
+POP_WARNINGS
+      to = static_cast<to_type>(from);
+    }
+    template<typename from_type, typename to_type>
+    void convert_uint_to_any_int(const from_type& from, to_type& to)
+    {
+PUSH_WARNINGS
+DISABLE_VS_WARNINGS(4018)
+DISABLE_CLANG_WARNING(tautological-constant-out-of-range-compare)
+        CHECK_AND_ASSERT_THROW_MES(from <= std::numeric_limits<to_type>::max(), "uint value overhead: try to set value " << from << " to type " << typeid(to_type).name() << " with max possible value = " << std::numeric_limits<to_type>::max());
+      to = static_cast<to_type>(from);
+POP_WARNINGS
+    }
+
+    template<typename from_type, typename to_type, bool, bool> //is from signed, is from to signed
+    struct convert_to_signed_unsigned;
+
+    template<typename from_type, typename to_type>
+    struct convert_to_signed_unsigned<from_type, to_type, true, true>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {//from signed to signed
+        convert_int_to_int(from, to);
+      }
+    };
+
+    template<typename from_type, typename to_type>
+    struct convert_to_signed_unsigned<from_type, to_type, true, false>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {//from signed to unsigned
+        convert_int_to_uint(from, to);
+      }
+    };
+
+    template<typename from_type, typename to_type>
+    struct convert_to_signed_unsigned<from_type, to_type, false, true>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {//from unsigned to signed
+        convert_uint_to_any_int(from, to);
+      }
+    };
+
+    template<typename from_type, typename to_type>
+    struct convert_to_signed_unsigned<from_type, to_type, false, false>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {
+        //from unsigned to unsigned
+        convert_uint_to_any_int(from, to);
+      }
+    };
+
+    template<typename from_type, typename to_type, bool>
+    struct convert_to_integral;
+
+    template<typename from_type, typename to_type>
+    struct convert_to_integral<from_type, to_type, true>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {
+        convert_to_signed_unsigned<from_type, to_type, std::is_signed<from_type>::value, std::is_signed<to_type>::value>::convert(from, to);
+      }
+    };
+
+    template<typename from_type, typename to_type>
+    struct convert_to_integral<from_type, to_type, false>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {
+        ASSERT_AND_THROW_WRONG_CONVERSION();
+      }
+    };
+
+    // For MyMonero/OpenMonero backend compatibility
+    // MyMonero backend sends amount, fees and timestamp values as strings.
+    // Until MM backend is updated, this is needed for compatibility between OpenMonero and MyMonero. 
+    template<>
+    struct convert_to_integral<std::string, uint64_t, false>
+    {
+      static void convert(const std::string& from, uint64_t& to)
+      {
+        MTRACE("Converting std::string to uint64_t. Source: " << from);
+        // String only contains digits
+        if(std::all_of(from.begin(), from.end(), epee::misc_utils::parse::isdigit))
+          to = boost::lexical_cast<uint64_t>(from);
+        // MyMonero ISO 8061 timestamp (2017-05-06T16:27:06Z)
+        else if (boost::regex_match (from, boost::regex("\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\dZ")))
+        {
+          // Convert to unix timestamp
+#ifdef HAVE_STRPTIME
+          struct tm tm;
+          if (strptime(from.c_str(), "%Y-%m-%dT%H:%M:%S", &tm))
+#else
+          std::tm tm = {};
+          std::istringstream ss(from);
+          if (ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S"))
+#endif
+            to = std::mktime(&tm);
+        } else
+          ASSERT_AND_THROW_WRONG_CONVERSION();
+      }
+    };
+
+    template<class from_type, class to_type>
+    struct is_convertable: std::integral_constant<bool,
+                            std::is_integral<to_type>::value &&
+                            std::is_integral<from_type>::value &&
+                            !std::is_same<from_type, bool>::value &&
+                            !std::is_same<to_type, bool>::value > {};
+
+    template<typename from_type, typename to_type, bool>
+    struct convert_to_same;
+
+    template<typename from_type, typename to_type>
+    struct convert_to_same<from_type, to_type, true>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {
+        to = from;
+      }
+    };
+
+    template<typename from_type, typename to_type>
+    struct convert_to_same<from_type, to_type, false>
+    {
+      static void convert(const from_type& from, to_type& to)
+      {
+        convert_to_integral<from_type, to_type, is_convertable<from_type, to_type>::value>::convert(from, to);// ASSERT_AND_THROW_WRONG_CONVERSION();
+      }
+    };
+
+
+    template<class from_type, class to_type>
+    void convert_t(const from_type& from, to_type& to)
+    {
+      convert_to_same<from_type, to_type, std::is_same<to_type, from_type>::value>::convert(from, to);
+    }
+  }
+}

src/contrib/epee/include/string_tools.h

@@ -29,16 +29,25 @@
 #ifndef _STRING_TOOLS_H_
 #define _STRING_TOOLS_H_
 
-//#include <objbase.h>
+// Previously pulled in by ASIO, further cleanup still required ...
+#ifdef _WIN32
+# include <winsock2.h>
+# include <windows.h>
+#endif
+
+#include <string.h>
 #include <locale>
 #include <cstdlib>
-//#include <strsafe.h>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_io.hpp>
+#include <string>
+#include <type_traits>
 #include <boost/lexical_cast.hpp>
-#include <boost/asio.hpp>
-#include <boost/algorithm/string/compare.hpp>
-#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include "misc_log_ex.h"
+#include "storages/parserse_base_utils.h"
+#include "hex.h"
+#include "memwipe.h"
+#include "mlocker.h"
+#include "span.h"
 #include "warnings.h"
 
 
@@ -50,135 +59,64 @@
 #pragma comment (lib, "Rpcrt4.lib")
 #endif
 
+static const constexpr unsigned char isx[256] =
+{
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0,    1,    2,    3,    4,    5,    6,    7,    8,    9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff,   10,   11,   12,   13,   14,   15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff,   10,   11,   12,   13,   14,   15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+};
+
 namespace epee
 {
 namespace string_tools
 {
-	inline std::wstring get_str_from_guid(const boost::uuids::uuid& rid)
-	{
-		return boost::lexical_cast<std::wstring>(rid);
-	}
-	//----------------------------------------------------------------------------
-	inline std::string get_str_from_guid_a(const boost::uuids::uuid& rid)
-	{
-		return boost::lexical_cast<std::string>(rid);
-	}
-	//----------------------------------------------------------------------------
-	inline bool get_guid_from_string( boost::uuids::uuid& inetifer, std::wstring str_id)
-	{
-		if(str_id.size() < 36)
-			return false;
-
-		if('{' == *str_id.begin())
-			str_id.erase(0, 1);
-
-		if('}' == *(--str_id.end()))
-			str_id.erase(--str_id.end());
-
-		try
-		{
-			inetifer = boost::lexical_cast<boost::uuids::uuid>(str_id);
-			return true;
-		}
-		catch(...)
-		{
-			return false;
-		}
-	}
-	//----------------------------------------------------------------------------
-	inline bool get_guid_from_string(OUT boost::uuids::uuid& inetifer, const std::string& str_id)
-	{
-		std::string local_str_id = str_id;
-		if(local_str_id.size() < 36)
-			return false;
-
-		if('{' == *local_str_id.begin())
-			local_str_id.erase(0, 1);
-
-		if('}' == *(--local_str_id.end()))
-			local_str_id.erase(--local_str_id.end());
-
-		try
-		{
-			inetifer = boost::lexical_cast<boost::uuids::uuid>(local_str_id);
-			return true;
-		}
-		catch(...)
-		{
-			return false;
-		}
-	}
-	//----------------------------------------------------------------------------
-  template<class CharT>
-  std::basic_string<CharT> buff_to_hex(const std::basic_string<CharT>& s)
+  //----------------------------------------------------------------------------
+  inline std::string buff_to_hex_nodelimer(const std::string& src)
   {
-    using namespace std;
-    basic_stringstream<CharT> hexStream;
-    hexStream << hex << noshowbase << setw(2);
-
-    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
-    {
-      hexStream << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(*it)) << " ";
-    }
-    return hexStream.str();
+    return to_hex::string(to_byte_span(to_span(src)));
   }
   //----------------------------------------------------------------------------
-  template<class CharT>
-  std::basic_string<CharT> buff_to_hex_nodelimer(const std::basic_string<CharT>& s)
+  inline bool parse_hexstr_to_binbuff(const epee::span<const char> s, epee::span<char>& res)
   {
-    using namespace std;
-    basic_stringstream<CharT> hexStream;
-    hexStream << hex << noshowbase;
+      if (s.size() != res.size() * 2)
+        return false;
 
-    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
-    {
-      hexStream << setw(2) << setfill('0') << static_cast<unsigned int>(static_cast<unsigned char>(*it));
-    }
-    return hexStream.str();
-  }
-  //----------------------------------------------------------------------------
-  template<class CharT>
-  bool parse_hexstr_to_binbuff(const std::basic_string<CharT>& s, std::basic_string<CharT>& res)
-  {
-    res.clear();
-    try
-    {
-      long v = 0;
-      for(size_t i = 0; i < (s.size() + 1) / 2; i++)
+      unsigned char *dst = (unsigned char *)&res[0];
+      const unsigned char *src = (const unsigned char *)s.data();
+      for(size_t i = 0; i < s.size(); i += 2)
       {
-        CharT byte_str[3];
-        size_t copied = s.copy(byte_str, 2, 2 * i);
-        byte_str[copied] = CharT(0);
-        CharT* endptr;
-        v = strtoul(byte_str, &endptr, 16);
-        if (v < 0 || 0xFF < v || endptr != byte_str + copied)
-        {
-          return false;
-        }
-        res.push_back(static_cast<unsigned char>(v));
+        int tmp = *src++;
+        tmp = isx[tmp];
+        if (tmp == 0xff) return false;
+        int t2 = *src++;
+        t2 = isx[t2];
+        if (t2 == 0xff) return false;
+        *dst++ = (tmp << 4) | t2;
       }
 
       return true;
-    }catch(...)
-    {
-      return false;
-    }
   }
   //----------------------------------------------------------------------------
-  template<class t_pod_type>
-  bool parse_tpod_from_hex_string(const std::string& str_hash, t_pod_type& t_pod)
+  inline bool parse_hexstr_to_binbuff(const std::string& s, std::string& res)
   {
-    std::string buf;
-    bool res = epee::string_tools::parse_hexstr_to_binbuff(str_hash, buf);
-    if (!res || buf.size() != sizeof(t_pod_type))
-    {
+    if (s.size() & 1)
       return false;
-    }
-    else
-    {
-      buf.copy(reinterpret_cast<char *>(&t_pod), sizeof(t_pod_type));
-      return true;
-    }
+    res.resize(s.size() / 2);
+    epee::span<char> rspan((char*)&res[0], res.size());
+    return parse_hexstr_to_binbuff(epee::to_span(s), rspan);
   }
   //----------------------------------------------------------------------------
 PUSH_WARNINGS
@@ -190,7 +128,7 @@ DISABLE_GCC_WARNING(maybe-uninitialized)
     {
       for (char c : str_id)
       {
-        if (!std::isdigit(c))
+        if (!epee::misc_utils::parse::isdigit(c))
           return false;
       }
     }
@@ -200,7 +138,7 @@ DISABLE_GCC_WARNING(maybe-uninitialized)
       val = boost::lexical_cast<XType>(str_id);
       return true;
     }
-    catch(std::exception& /*e*/)
+    catch(const std::exception& /*e*/)
     {
       //const char* pmsg = e.what();
       return false;
@@ -213,22 +151,6 @@ DISABLE_GCC_WARNING(maybe-uninitialized)
     return true;
   }
 POP_WARNINGS
-	//---------------------------------------------------
-	template<typename int_t>
-	bool get_xnum_from_hex_string(const std::string str, int_t& res )
-	{
-		try
-		{
-			std::stringstream ss;
-			ss << std::hex << str;
-			ss >> res;
-			return true;	
-		}
-		catch(...)
-		{
-			return false;
-		}
-	}
 	//----------------------------------------------------------------------------
 	template<class XType>
 	inline bool xtype_to_string(const  XType& val, std::string& str)
@@ -244,139 +166,39 @@ POP_WARNINGS
 
 		return true;
 	}
-    
-	typedef std::map<std::string, std::string> command_line_params_a;
-	typedef std::map<std::wstring, std::wstring> command_line_params_w;
-
-	template<class t_string>
-	bool parse_commandline(std::map<t_string, t_string>& res, int argc, char** argv)
-	{
-    t_string key;
-    for(int i = 1; i < argc; i++)
-    {
-      if(!argv[i])
-        break;
-      t_string s = argv[i];
-      std::string::size_type p = s.find('=');
-      if(std::string::npos == p)
-      {
-        res[s] = "";
-      }else
-      {
-        std::string ss;
-        t_string nm = s.substr(0, p);
-        t_string vl = s.substr(p+1, s.size());
-        res[nm] = vl;
-      }
-    }
-    return true;
-	}
-
-/*  template<typename t_type>
-  bool get_xparam_from_command_line(const std::map<std::string, std::string>& res, const std::basic_string<typename t_string::value_type> & key, t_type& val)
-  {
-
-  }
-  */
-
-	template<class t_string, typename t_type>
-	bool get_xparam_from_command_line(const std::map<t_string, t_string>& res, const t_string & key, t_type& val)
-	{
-		typename std::map<t_string, t_string>::const_iterator it = res.find(key);
-		if(it == res.end())
-			return false;
-
-		if(it->second.size())
-		{
-			return get_xtype_from_string(val, it->second);
-		}
-
-		return true;
-	}
-
-    template<class t_string, typename t_type>
-    t_type get_xparam_from_command_line(const std::map<t_string, t_string>& res, const t_string & key, const t_type& default_value)
-    {
-        typename std::map<t_string, t_string>::const_iterator it = res.find(key);
-        if(it == res.end())
-            return default_value;
-
-        if(it->second.size())
-        {
-            t_type s;
-            get_xtype_from_string(s, it->second);
-            return s;
-        }
-
-        return default_value;
-    }
-
-  template<class t_string>
-  bool have_in_command_line(const std::map<t_string, t_string>& res, const std::basic_string<typename t_string::value_type>& key)
-  {
-    typename std::map<t_string, t_string>::const_iterator it = res.find(key);
-    if(it == res.end())
-      return false;
-
-    return true;
-  }
-
 	//----------------------------------------------------------------------------
-//#ifdef _WINSOCK2API_
-	inline std::string get_ip_string_from_int32(uint32_t ip)
-	{
-		in_addr adr;
-		adr.s_addr = ip;
-		const char* pbuf = inet_ntoa(adr);
-		if(pbuf)
-			return pbuf;
-		else
-			return "[failed]";
-	}
+	std::string get_ip_string_from_int32(uint32_t ip);
 	//----------------------------------------------------------------------------
-	inline bool get_ip_int32_from_string(uint32_t& ip, const std::string& ip_str)
-	{
-		ip = inet_addr(ip_str.c_str());
-		if(INADDR_NONE == ip)
-			return false;
-
-		return true;
-	}
+	bool get_ip_int32_from_string(uint32_t& ip, const std::string& ip_str);
   //----------------------------------------------------------------------------
-  inline bool parse_peer_from_string(uint32_t& ip, uint32_t& port, const std::string& addres)
+  inline bool parse_peer_from_string(uint32_t& ip, uint16_t& port, const std::string& addres)
   {
     //parse ip and address
     std::string::size_type p = addres.find(':');
+    std::string ip_str, port_str;
     if(p == std::string::npos)
     {
-      return false;
+      port = 0;
+      ip_str = addres;
+    }
+    else
+    {
+      ip_str = addres.substr(0, p);
+      port_str = addres.substr(p+1, addres.size());
     }
-    std::string ip_str = addres.substr(0, p);
-    std::string port_str = addres.substr(p+1, addres.size());
 
     if(!get_ip_int32_from_string(ip, ip_str))
     {
       return false;
     }
 
-    if(!get_xtype_from_string(port, port_str))
+    if(p != std::string::npos && !get_xtype_from_string(port, port_str))
     {
       return false;
     }
     return true;
   }
 
-//#endif
-	//----------------------------------------------------------------------------
-  template<typename t>
-	inline std::string get_t_as_hex_nwidth(const t& v, std::streamsize w = 8)
-  {
-    std::stringstream ss;
-    ss << std::setfill ('0') << std::setw (w) << std::hex << std::noshowbase;
-    ss << v;
-    return ss.str();
-  }
-
 	inline std::string num_to_string_fast(int64_t val)
 	{
 		/*
@@ -386,68 +208,15 @@ POP_WARNINGS
 		return boost::lexical_cast<std::string>(val);
 	}
 	//----------------------------------------------------------------------------
-	inline bool string_to_num_fast(const std::string& buff, int64_t& val)
+	inline std::string to_string_hex(uint32_t val)
 	{
-		//return get_xtype_from_string(val, buff);
-#if (defined _MSC_VER)
-    val = _atoi64(buff.c_str());
-#else
-    val = atoll(buff.c_str());
-#endif
-		/*
-		 * val = atoi64(buff.c_str());
-     */
-		if(buff != "0" && val == 0)
-			return false;
-		return true;
+		std::stringstream ss;
+		ss << std::hex << val;
+		std::string s;
+		ss >> s;
+		return s;
 	}
 	//----------------------------------------------------------------------------
-	inline bool string_to_num_fast(const std::string& buff, int& val)
-	{
-		val = atoi(buff.c_str());
-		if(buff != "0" && val == 0)
-			return false;
-
-		return true;
-	}
-	//----------------------------------------------------------------------------
-#ifdef WINDOWS_PLATFORM
-	inline std::string system_time_to_string(const SYSTEMTIME& st)
-	{
-	
-		/*
-		TIME_ZONE_INFORMATION tzi;
-		GetTimeZoneInformation(&tzi);
-		SystemTimeToTzSpecificLocalTime(&tzi, &stUTC, &stLocal);
-		*/
-
-		char szTime[25], szDate[25];
-		::GetTimeFormatA(
-			LOCALE_USER_DEFAULT,    // locale
-			TIME_FORCE24HOURFORMAT, // options
-			&st,					// time
-			NULL,                   // time format string
-			szTime,                 // formatted string buffer
-			25                      // size of string buffer
-			);
-
-		::GetDateFormatA(
-			LOCALE_USER_DEFAULT,    // locale
-			NULL,                   // options
-			&st,					// date
-			NULL,                   // date format
-			szDate,                 // formatted string buffer
-			25                      // size of buffer
-			);
-		szTime[24] = szDate[24] = 0; //be happy :)
-		
-		std::string res = szDate;
-		(res += " " )+= szTime;
-		return res; 
-
-	}
-#endif
-	//----------------------------------------------------------------------------
 	
 	inline bool compare_no_case(const std::string& str1, const std::string& str2)
 	{
@@ -455,33 +224,6 @@ POP_WARNINGS
 		return !boost::iequals(str1, str2);
 	}
 	//----------------------------------------------------------------------------
-	inline bool compare_no_case(const std::wstring& str1, const std::wstring& str2)
-	{
-		return !boost::iequals(str1, str2);
-	}
-	//----------------------------------------------------------------------------
-	inline bool is_match_prefix(const std::wstring& str1, const std::wstring& prefix)
-	{	
-		if(prefix.size()>str1.size())
-			return false;
-
-		if(!compare_no_case(str1.substr(0, prefix.size()), prefix))
-			return true;
-		else
-			return false;
-	}
-	//----------------------------------------------------------------------------
-	inline bool is_match_prefix(const std::string& str1, const std::string& prefix)
-	{	
-		if(prefix.size()>str1.size())
-			return false;
-
-		if(!compare_no_case(str1.substr(0, prefix.size()), prefix))
-			return true;
-		else
-			return false;
-	}
-	//----------------------------------------------------------------------------
 	inline std::string& get_current_module_name()
 	{
 		static std::string module_name;
@@ -559,29 +301,48 @@ POP_WARNINGS
     return str;
   }
   //----------------------------------------------------------------------------
+  inline std::string pad_string(std::string s, size_t n, char c = ' ', bool prepend = false)
+  {
+    if (s.size() < n)
+    {
+      if (prepend)
+        s = std::string(n - s.size(), c) + s;
+      else
+        s.append(n - s.size(), c);
+    }
+    return s;
+  }
+  //----------------------------------------------------------------------------
   template<class t_pod_type>
   std::string pod_to_hex(const t_pod_type& s)
   {
-    std::string buff;
-    buff.assign(reinterpret_cast<const char*>(&s), sizeof(s));
-    return buff_to_hex_nodelimer(buff);
+    static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
+    return to_hex::string(as_byte_span(s));
   }
   //----------------------------------------------------------------------------
   template<class t_pod_type>
   bool hex_to_pod(const std::string& hex_str, t_pod_type& s)
   {
-    std::string hex_str_tr = trim(hex_str);
+    static_assert(std::is_pod<t_pod_type>::value, "expected pod type");
     if(sizeof(s)*2 != hex_str.size())
       return false;
-    std::string bin_buff;
-    if(!parse_hexstr_to_binbuff(hex_str_tr, bin_buff))
-      return false;
-    if(bin_buff.size()!=sizeof(s))
-      return false;
-
-    s = *(t_pod_type*)bin_buff.data();
-    return true;
+    epee::span<char> rspan((char*)&s, sizeof(s));
+    return parse_hexstr_to_binbuff(epee::to_span(hex_str), rspan);
   }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  bool hex_to_pod(const std::string& hex_str, tools::scrubbed<t_pod_type>& s)
+  {
+    return hex_to_pod(hex_str, unwrap(s));
+  }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  bool hex_to_pod(const std::string& hex_str, epee::mlocked<t_pod_type>& s)
+  {
+    return hex_to_pod(hex_str, unwrap(s));
+  }
+  //----------------------------------------------------------------------------
+  bool validate_hex(uint64_t length, const std::string& str);
   //----------------------------------------------------------------------------
 	inline std::string get_extension(const std::string& str)
 	{
@@ -594,20 +355,6 @@ POP_WARNINGS
 		return res;
 	}
 	//----------------------------------------------------------------------------
-	inline std::string get_filename_from_path(const std::string& str)
-	{
-		std::string res;
-		std::string::size_type pos = str.rfind('\\');
-		if(std::string::npos == pos)
-			return str;
-
-		res = str.substr(pos+1, str.size()-pos);
-		return res;
-	}
-	//----------------------------------------------------------------------------
-
-
-
 	inline std::string cut_off_extension(const std::string& str)
 	{
 		std::string res;
@@ -618,126 +365,40 @@ POP_WARNINGS
 		res = str.substr(0, pos);
 		return res;
 	}
-
-	//----------------------------------------------------------------------------
-#ifdef _WININET_
-	inline std::string get_string_from_systemtime(const SYSTEMTIME& sys_time)
-	{
-		std::string result_string;
-
-		char buff[100] = {0};
-		BOOL res = ::InternetTimeFromSystemTimeA(&sys_time, INTERNET_RFC1123_FORMAT, buff, 99);
-		if(!res)
-		{
-			LOG_ERROR("Failed to load SytemTime to string");
-		}
-
-		result_string = buff;
-		return result_string;
-
-	}
-	//-------------------------------------------------------------------------------------
-	inline SYSTEMTIME get_systemtime_from_string(const std::string& buff)
-	{
-		SYSTEMTIME result_time = {0};
-
-		BOOL res = ::InternetTimeToSystemTimeA(buff.c_str(), &result_time, NULL);
-		if(!res)
-		{
-			LOG_ERROR("Failed to load SytemTime from string " << buff << "interval set to 15 minutes");
-		}
-
-		return result_time;
-	}
-#endif
-
-#ifdef WINDOWS_PLATFORM
-	static const DWORD INFO_BUFFER_SIZE = 10000;
-
-	static const wchar_t* get_pc_name()
-	{
-		static wchar_t	info[INFO_BUFFER_SIZE];
-		static DWORD	bufCharCount = INFO_BUFFER_SIZE;
-		static bool		init = false;
-
-		if (!init) {
-			if (!GetComputerNameW( info, &bufCharCount ))
-				info[0] = 0;
-			else
-				init = true;
-		}
-
-		return info;
-	}
-
-	static const wchar_t* get_user_name()
-	{
-		static wchar_t	info[INFO_BUFFER_SIZE];
-		static DWORD	bufCharCount = INFO_BUFFER_SIZE;
-		static bool		init = false;
-
-		if (!init) {
-			if (!GetUserNameW( info, &bufCharCount ))
-				info[0] = 0;
-			else
-				init = true;
-		}
-
-		return info;
-	}
-#endif
-
-#ifdef _LM_
-	static const wchar_t* get_domain_name()
-	{
-		static wchar_t	info[INFO_BUFFER_SIZE];
-		static DWORD	bufCharCount = 0;
-		static bool		init = false;
-
-		if (!init) {
-			LPWSTR domain( NULL );
-			NETSETUP_JOIN_STATUS status;
-			info[0] = 0;
-
-			if (NET_API_STATUS result = NetGetJoinInformation( NULL, &domain, &status )) 
-			{
-				LOG_ERROR("get_domain_name error: " << log_space::get_win32_err_descr(result));
-			} else
-			{
-				StringCchCopyW( info, sizeof(info)/sizeof( info[0] ), domain );
-				NetApiBufferFree((void*)domain);
-				init = true;
-			}
-		}
-
-		return info;
-	}
-#endif
-#ifdef WINDOWS_PLATFORM
-	inline
-	std::string load_resource_string_a(int id, const char* pmodule_name = NULL)
-	{
-		//slow realization 
-		HMODULE h = ::GetModuleHandleA( pmodule_name );
-		
-		char buff[2000] = {0};
-		
-		::LoadStringA( h, id, buff, sizeof(buff));
-		buff[sizeof(buff)-1] = 0; //be happy :)
-		return buff;
-	}
-	inline
-	std::wstring load_resource_string_w(int id, const char* pmodule_name = NULL)
-	{
-		//slow realization 
-		HMODULE h = ::GetModuleHandleA( pmodule_name );
-		
-		wchar_t buff[2000] = {0};
-		
-		::LoadStringW( h, id, buff, sizeof(buff) / sizeof( buff[0] ) );
-		buff[(sizeof(buff)/sizeof(buff[0]))-1] = 0; //be happy :)
-		return buff;	
-	}
+  //----------------------------------------------------------------------------
+#ifdef _WIN32
+  inline std::wstring utf8_to_utf16(const std::string& str)
+  {
+    if (str.empty())
+      return {};
+    int wstr_size = MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), NULL, 0);
+    if (wstr_size == 0)
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    std::wstring wstr(wstr_size, wchar_t{});
+    if (!MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), &wstr[0], wstr_size))
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    return wstr;
+  }
+  inline std::string utf16_to_utf8(const std::wstring& wstr)
+  {
+    if (wstr.empty())
+      return {};
+    int str_size = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), NULL, 0, NULL, NULL);
+    if (str_size == 0)
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    std::string str(str_size, char{});
+    if (!WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), &str[0], str_size, NULL, NULL))
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    return str;
+  }
 #endif
 }
 }

src/contrib/epee/include/syncobj.h

@@ -30,15 +30,25 @@
 #ifndef __WINH_OBJ_H__
 #define __WINH_OBJ_H__
 
-#include <condition_variable>
-#include <mutex>
+#include <boost/chrono/duration.hpp>
+#include <boost/thread/condition_variable.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/thread.hpp>
 
 namespace epee
 {
 
+  namespace debug
+  {
+    inline unsigned int &g_test_dbg_lock_sleep()
+    {
+      static unsigned int value = 0;
+      return value;
+    }
+  }
+  
   struct simple_event
   {
     simple_event() : m_rised(false)
@@ -47,22 +57,22 @@ namespace epee
 
     void raise()
     {
-      std::unique_lock<std::mutex> lock(m_mx);
+      boost::unique_lock<boost::mutex> lock(m_mx);
       m_rised = true;
       m_cond_var.notify_one();
     }
 
     void wait()
     {
-      std::unique_lock<std::mutex> lock(m_mx);
+      boost::unique_lock<boost::mutex> lock(m_mx);
       while (!m_rised) 
         m_cond_var.wait(lock);
       m_rised = false;
     }
 
   private:
-    std::mutex m_mx;
-    std::condition_variable m_cond_var;
+    boost::mutex m_mx;
+    boost::condition_variable m_cond_var;
     bool m_rised;
   };
 
@@ -215,10 +225,10 @@ namespace epee
 #define  SHARED_CRITICAL_REGION_BEGIN(x) { shared_guard   critical_region_var(x)
 #define  EXCLUSIVE_CRITICAL_REGION_BEGIN(x) { exclusive_guard   critical_region_var(x)
 
-#define  CRITICAL_REGION_LOCAL(x) epee::critical_region_t<decltype(x)>   critical_region_var(x)
-#define  CRITICAL_REGION_BEGIN(x) { epee::critical_region_t<decltype(x)>   critical_region_var(x)
-#define  CRITICAL_REGION_LOCAL1(x) epee::critical_region_t<decltype(x)>   critical_region_var1(x)
-#define  CRITICAL_REGION_BEGIN1(x) { epee::critical_region_t<decltype(x)>   critical_region_var1(x)
+#define  CRITICAL_REGION_LOCAL(x) {boost::this_thread::sleep_for(boost::chrono::milliseconds(epee::debug::g_test_dbg_lock_sleep()));}   epee::critical_region_t<decltype(x)>   critical_region_var(x)
+#define  CRITICAL_REGION_BEGIN(x) { boost::this_thread::sleep_for(boost::chrono::milliseconds(epee::debug::g_test_dbg_lock_sleep())); epee::critical_region_t<decltype(x)>   critical_region_var(x)
+#define  CRITICAL_REGION_LOCAL1(x) {boost::this_thread::sleep_for(boost::chrono::milliseconds(epee::debug::g_test_dbg_lock_sleep()));} epee::critical_region_t<decltype(x)>   critical_region_var1(x)
+#define  CRITICAL_REGION_BEGIN1(x) {  boost::this_thread::sleep_for(boost::chrono::milliseconds(epee::debug::g_test_dbg_lock_sleep())); epee::critical_region_t<decltype(x)>   critical_region_var1(x)
 
 #define  CRITICAL_REGION_END() }
 

src/contrib/epee/include/time_helper.h

@@ -156,4 +156,4 @@ PRAGMA_WARNING_POP
 
 #endif
 }
-}
+}

src/contrib/epee/include/warnings.h

@@ -27,4 +27,4 @@
 
 #define DISABLE_GCC_AND_CLANG_WARNING(w) _Pragma(BOOST_PP_STRINGIZE(GCC diagnostic ignored BOOST_PP_STRINGIZE(-W##w)))
 
-#endif
+#endif

src/contrib/epee/include/wipeable_string.h

@@ -0,0 +1,110 @@
+// Copyright (c) 2017-2019, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <boost/optional/optional.hpp>
+#include <stddef.h>
+#include <vector>
+#include <string>
+#include "memwipe.h"
+#include "fnv1.h"
+
+namespace epee
+{
+  class wipeable_string
+  {
+  public:
+    typedef char value_type;
+
+    wipeable_string() {}
+    wipeable_string(const wipeable_string &other);
+    wipeable_string(wipeable_string &&other);
+    wipeable_string(const std::string &other);
+    wipeable_string(std::string &&other);
+    wipeable_string(const char *s);
+    wipeable_string(const char *s, size_t len);
+    ~wipeable_string();
+    void wipe();
+    void push_back(char c);
+    void operator+=(char c);
+    void operator+=(const std::string &s);
+    void operator+=(const epee::wipeable_string &s);
+    void operator+=(const char *s);
+    void append(const char *ptr, size_t len);
+    char pop_back();
+    const char *data() const noexcept { return buffer.data(); }
+    char *data() noexcept { return buffer.data(); }
+    size_t size() const noexcept { return buffer.size(); }
+    size_t length() const noexcept { return buffer.size(); }
+    bool empty() const noexcept { return buffer.empty(); }
+    void trim();
+    void split(std::vector<wipeable_string> &fields) const;
+    boost::optional<wipeable_string> parse_hexstr() const;
+    template<typename T> inline bool hex_to_pod(T &pod) const;
+    template<typename T> inline bool hex_to_pod(tools::scrubbed<T> &pod) const { return hex_to_pod(unwrap(pod)); }
+    void resize(size_t sz);
+    void reserve(size_t sz);
+    void clear();
+    bool operator==(const wipeable_string &other) const noexcept { return buffer == other.buffer; }
+    bool operator!=(const wipeable_string &other) const noexcept { return buffer != other.buffer; }
+    wipeable_string &operator=(wipeable_string &&other);
+    wipeable_string &operator=(const wipeable_string &other);
+
+  private:
+    void grow(size_t sz, size_t reserved = 0);
+
+  private:
+    std::vector<char> buffer;
+  };
+
+  template<typename T> inline bool wipeable_string::hex_to_pod(T &pod) const
+  {
+    static_assert(std::is_pod<T>::value, "expected pod type");
+    if (size() != sizeof(T) * 2)
+      return false;
+    boost::optional<epee::wipeable_string> blob = parse_hexstr();
+    if (!blob)
+      return false;
+    if (blob->size() != sizeof(T))
+      return false;
+    pod = *(const T*)blob->data();
+    return true;
+  }
+}
+
+namespace std
+{
+  template<> struct hash<epee::wipeable_string>
+  {
+    size_t operator()(const epee::wipeable_string &s) const
+    {
+      return epee::fnv::FNV1a(s.data(), s.size());
+    }
+  };
+}

src/cryptonote_config.h

@@ -1,6 +1,7 @@
 #pragma once
 
-#define CURRENT_TRANSACTION_VERSION 1
+#define CURRENT_TRANSACTION_VERSION  1
+#define OFFSHORE_TRANSACTION_VERSION 3
 
 enum BLOB_TYPE {
   BLOB_TYPE_CRYPTONOTE        = 0,
@@ -13,5 +14,6 @@ enum BLOB_TYPE {
   BLOB_TYPE_AEON              = 7, // Aeon
   BLOB_TYPE_CRYPTONOTE_CUCKOO = 8, // MoneroV / Swap
   BLOB_TYPE_CRYPTONOTE_XTNC   = 9, // XTNC
-  BLOB_TYPE_CRYPTONOTE_TUBE   = 10, // bittube
+  BLOB_TYPE_CRYPTONOTE_TUBE   = 10, // TUBE
+  BLOB_TYPE_CRYPTONOTE_XHV    = 11, // Haven
 };

src/cryptonote_core/cryptonote_basic.h

@@ -17,6 +17,7 @@
 #include "serialization/json_archive.h"
 #include "serialization/debug_archive.h"
 #include "serialization/crypto.h"
+#include "serialization/pricing_record.h"
 #include "serialization/keyvalue_serialization.h" // eepe named serialization
 #include "string_tools.h"
 #include "cryptonote_config.h"
@@ -26,6 +27,7 @@
 #include "tx_extra.h"
 #include "ringct/rctTypes.h"
 #include "cryptonote_protocol/blobdatatype.h"
+#include "offshore/pricing_record.h"
 
 
 namespace cryptonote
@@ -72,6 +74,13 @@ namespace cryptonote
     crypto::public_key key;
   };
 
+  struct txout_offshore
+  {
+    txout_offshore() { }
+    txout_offshore(const crypto::public_key &_key) : key(_key) { }
+    crypto::public_key key;
+  };
+
   /* inputs */
 
   struct txin_gen
@@ -124,10 +133,35 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct txin_offshore
+  {
+    uint64_t amount;
+    std::vector<uint64_t> key_offsets;
+    crypto::key_image k_image;
 
-  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_to_key> txin_v;
+    BEGIN_SERIALIZE_OBJECT()
+    VARINT_FIELD(amount)
+    FIELD(key_offsets)
+    FIELD(k_image)
+    END_SERIALIZE()
+  };
 
-  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key> txout_target_v;
+  struct txin_onshore
+  {
+    uint64_t amount;
+    std::vector<uint64_t> key_offsets;
+    crypto::key_image k_image;
+    
+    BEGIN_SERIALIZE_OBJECT()
+    VARINT_FIELD(amount)
+    FIELD(key_offsets)
+    FIELD(k_image)
+    END_SERIALIZE()
+  };
+
+  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_to_key, txin_offshore, txin_onshore> txin_v;
+
+  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key, txout_offshore> txout_target_v;
 
   //typedef std::pair<uint64_t, txout> out_t;
   struct tx_out
@@ -163,6 +197,12 @@ namespace cryptonote
     std::vector<tx_out> vout;
     //extra
     std::vector<uint8_t> extra;
+    // Block height to use PR from
+    uint64_t pricing_record_height;
+    // Circulating supply information
+    std::vector<uint8_t> offshore_data;
+    uint64_t amount_burnt;
+    uint64_t amount_minted;
 
     //
     // NOTE: Loki specific
@@ -203,6 +243,12 @@ namespace cryptonote
         VARINT_FIELD(type)
         if (static_cast<uint16_t>(type) >= loki_type_count) return false;
       }
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV && version >= OFFSHORE_TRANSACTION_VERSION) {
+        VARINT_FIELD(pricing_record_height)
+        FIELD(offshore_data)
+        VARINT_FIELD(amount_burnt)
+        VARINT_FIELD(amount_minted)
+      }
     END_SERIALIZE()
 
 
@@ -267,8 +313,16 @@ namespace cryptonote
           {
             ar.tag("rctsig_prunable");
             ar.begin_object();
-            r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
-                vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
+            if (blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
+                  vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
+            } else {
+              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
+                  vin.size() > 0 && vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 :
+                  vin.size() > 0 && vin[0].type() == typeid(txin_offshore) ? boost::get<txin_offshore>(vin[0]).key_offsets.size() - 1 :
+                  vin.size() > 0 && vin[0].type() == typeid(txin_onshore) ? boost::get<txin_onshore>(vin[0]).key_offsets.size() - 1 :
+         	  0);
+            }
             if (!r || !ar.stream().good()) return false;
             ar.end_object();
           }
@@ -301,6 +355,10 @@ namespace cryptonote
     vout.clear();
     extra.clear();
     signatures.clear();
+    pricing_record_height = 0;
+    offshore_data.clear();
+    amount_burnt = 0;
+    amount_minted = 0;
   }
 
   inline
@@ -312,6 +370,8 @@ namespace cryptonote
       size_t operator()(const txin_to_script& txin) const{return 0;}
       size_t operator()(const txin_to_scripthash& txin) const{return 0;}
       size_t operator()(const txin_to_key& txin) const {return txin.key_offsets.size();}
+      size_t operator()(const txin_offshore& txin) const {return txin.key_offsets.size();}
+      size_t operator()(const txin_onshore& txin) const {return txin.key_offsets.size();}
     };
 
     return boost::apply_visitor(txin_signature_size_visitor(), tx_in);
@@ -431,6 +491,7 @@ namespace cryptonote
     crypto::hash prev_id;
     uint64_t nonce;
     uint64_t nonce8;
+    offshore::pricing_record pricing_record;
     crypto::cycle cycle;
     crypto::cycle40 cycle40;
 
@@ -452,6 +513,8 @@ namespace cryptonote
       }
       if (blob_type == BLOB_TYPE_CRYPTONOTE_XTNC || blob_type == BLOB_TYPE_CRYPTONOTE_CUCKOO) FIELD(cycle)
       if (blob_type == BLOB_TYPE_CRYPTONOTE_TUBE) FIELD(cycle40)
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV) FIELD(pricing_record)
+
     END_SERIALIZE()
   };
 
@@ -538,15 +601,19 @@ namespace cryptonote
 }
 
 BLOB_SERIALIZER(cryptonote::txout_to_key);
+BLOB_SERIALIZER(cryptonote::txout_offshore);
 BLOB_SERIALIZER(cryptonote::txout_to_scripthash);
 
 VARIANT_TAG(binary_archive, cryptonote::txin_gen, 0xff);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_script, 0x0);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_scripthash, 0x1);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txin_offshore, 0x3);
+VARIANT_TAG(binary_archive, cryptonote::txin_onshore, 0x4);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_script, 0x0);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_scripthash, 0x1);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txout_offshore, 0x3);
 VARIANT_TAG(binary_archive, cryptonote::transaction, 0xcc);
 VARIANT_TAG(binary_archive, cryptonote::block, 0xbb);
 
@@ -554,9 +621,12 @@ VARIANT_TAG(json_archive, cryptonote::txin_gen, "gen");
 VARIANT_TAG(json_archive, cryptonote::txin_to_script, "script");
 VARIANT_TAG(json_archive, cryptonote::txin_to_scripthash, "scripthash");
 VARIANT_TAG(json_archive, cryptonote::txin_to_key, "key");
+VARIANT_TAG(json_archive, cryptonote::txin_offshore, "offshore");
+VARIANT_TAG(json_archive, cryptonote::txin_onshore, "onshore");
 VARIANT_TAG(json_archive, cryptonote::txout_to_script, "script");
 VARIANT_TAG(json_archive, cryptonote::txout_to_scripthash, "scripthash");
 VARIANT_TAG(json_archive, cryptonote::txout_to_key, "key");
+VARIANT_TAG(json_archive, cryptonote::txout_offshore, "offshore");
 VARIANT_TAG(json_archive, cryptonote::transaction, "tx");
 VARIANT_TAG(json_archive, cryptonote::block, "block");
 
@@ -564,8 +634,11 @@ VARIANT_TAG(debug_archive, cryptonote::txin_gen, "gen");
 VARIANT_TAG(debug_archive, cryptonote::txin_to_script, "script");
 VARIANT_TAG(debug_archive, cryptonote::txin_to_scripthash, "scripthash");
 VARIANT_TAG(debug_archive, cryptonote::txin_to_key, "key");
+VARIANT_TAG(debug_archive, cryptonote::txin_offshore, "offshore");
+VARIANT_TAG(debug_archive, cryptonote::txin_onshore, "onshore");
 VARIANT_TAG(debug_archive, cryptonote::txout_to_script, "script");
 VARIANT_TAG(debug_archive, cryptonote::txout_to_scripthash, "scripthash");
 VARIANT_TAG(debug_archive, cryptonote::txout_to_key, "key");
+VARIANT_TAG(debug_archive, cryptonote::txout_offshore, "offshore");
 VARIANT_TAG(debug_archive, cryptonote::transaction, "tx");
 VARIANT_TAG(debug_archive, cryptonote::block, "block");

src/cryptonote_core/cryptonote_format_utils.cpp

@@ -87,8 +87,13 @@ namespace cryptonote
     uint64_t amount_out = 0;
     BOOST_FOREACH(auto& in, tx.vin)
     {
-      CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), 0, "unexpected type id in transaction");
-      amount_in += boost::get<txin_to_key>(in).amount;
+      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+        CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), 0, "unexpected type id in transaction");
+        amount_in += boost::get<txin_to_key>(in).amount;
+      } else {
+        CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key) || in.type() == typeid(txin_offshore) || in.type() == typeid(txin_onshore), 0, "unexpected type id in transaction");
+        amount_in += in.type() == typeid(txin_to_key) ? boost::get<txin_to_key>(in).amount : in.type() == typeid(txin_onshore) ? boost::get<txin_onshore>(in).amount : boost::get<txin_offshore>(in).amount;
+      }
     }
     BOOST_FOREACH(auto& o, tx.vout)
       amount_out += o.amount;
@@ -235,10 +240,15 @@ namespace cryptonote
   {
     BOOST_FOREACH(const auto& in, tx.vin)
     {
-      CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), false, "wrong variant type: "
-        << in.type().name() << ", expected " << typeid(txin_to_key).name()
-        << ", in transaction id=" << get_transaction_hash(tx));
-
+      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+        CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), false, "wrong variant type: "
+          << in.type().name() << ", expected " << typeid(txin_to_key).name()
+          << ", in transaction id=" << get_transaction_hash(tx));
+      } else {
+        CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key) || in.type() == typeid(txin_offshore) || in.type() == typeid(txin_onshore), false, "wrong variant type: "
+          << in.type().name() << ", expected " << typeid(txin_to_key).name() << "or " << typeid(txin_onshore).name()
+          << ", in transaction id=" << get_transaction_hash(tx));
+      }
     }
     return true;
   }
@@ -247,14 +257,29 @@ namespace cryptonote
   {
     BOOST_FOREACH(const tx_out& out, tx.vout)
     {
-      CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key), false, "wrong variant type: "
-        << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
-        << ", in transaction id=" << get_transaction_hash(tx));
+      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+        CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key), false, "wrong variant type: "
+          << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
+          << ", in transaction id=" << get_transaction_hash(tx));
+      } else {
+        CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key) || out.target.type() == typeid(txout_offshore), false, "wrong variant type: "
+          << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
+	  << "or " << typeid(txout_offshore).name()
+	  << ", in transaction id=" << get_transaction_hash(tx));
+      }
 
-      CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount ouput in transaction id=" << get_transaction_hash(tx));
+      if (tx.version == 1)
+      {
+        CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount ouput in transaction id=" << get_transaction_hash(tx));
+      }
 
-      if(!check_key(boost::get<txout_to_key>(out.target).key))
-        return false;
+      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+        if(!check_key(boost::get<txout_to_key>(out.target).key))
+          return false;
+      } else {
+        if(!check_key(out.target.type() == typeid(txout_to_key) ? boost::get<txout_to_key>(out.target).key : boost::get<txout_offshore>(out.target).key))
+          return false;
+      }
     }
     return true;
   }
@@ -269,10 +294,22 @@ namespace cryptonote
     uint64_t money = 0;
     BOOST_FOREACH(const auto& in, tx.vin)
     {
-      CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
-      if(money > tokey_in.amount + money)
-        return false;
-      money += tokey_in.amount;
+      if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.vin[0].type() == typeid(txin_offshore)) {
+        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_offshore, tokey_in, false);
+        if(money > tokey_in.amount + money)
+          return false;
+        money += tokey_in.amount;
+      } else if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.vin[0].type() == typeid(txin_onshore)) {
+        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_onshore, tokey_in, false);
+        if(money > tokey_in.amount + money)
+          return false;
+        money += tokey_in.amount;
+      } else {
+        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
+        if(money > tokey_in.amount + money)
+          return false;
+        money += tokey_in.amount;
+      }
     }
     return true;
   }
@@ -406,7 +443,16 @@ namespace cryptonote
       binary_archive<true> ba(ss);
       const size_t inputs = t.vin.size();
       const size_t outputs = t.vout.size();
-      const size_t mixin = t.vin.empty() ? 0 : t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 : 0;
+      size_t mixin;
+      if (t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
+        mixin = t.vin.empty() ? 0 : t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 : 0;
+      } else {
+        mixin = t.vin.empty() ? 0 :
+	t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 :
+	t.vin[0].type() == typeid(txin_offshore) ? boost::get<txin_offshore>(t.vin[0]).key_offsets.size() - 1 :
+	t.vin[0].type() == typeid(txin_onshore) ? boost::get<txin_onshore>(t.vin[0]).key_offsets.size() - 1 :
+	0;
+      }
       bool r = tt.rct_signatures.p.serialize_rctsig_prunable(ba, t.rct_signatures.type, inputs, outputs, mixin);
       CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures prunable");
       cryptonote::get_blob_hash(ss.str(), hashes[2]);
@@ -491,15 +537,6 @@ namespace cryptonote
     return get_object_hash(blob, res);
   }
   //---------------------------------------------------------------
-  bool get_block_longhash(const block& b, crypto::hash& res, uint64_t height)
-  {
-    blobdata bd;
-    if(!get_block_hashing_blob(b, bd))
-      return false;
-    crypto::cn_slow_hash(bd.data(), bd.size(), res);
-    return true;
-  }
-  //---------------------------------------------------------------
   std::vector<uint64_t> relative_output_offsets_to_absolute(const std::vector<uint64_t>& off)
   {
     std::vector<uint64_t> res = off;
@@ -520,13 +557,6 @@ namespace cryptonote
     return res;
   }
   //---------------------------------------------------------------
-  crypto::hash get_block_longhash(const block& b, uint64_t height)
-  {
-    crypto::hash p = null_hash;
-    get_block_longhash(b, p, height);
-    return p;
-  }
-  //---------------------------------------------------------------
   bool get_bytecoin_block_longhash(const block& b, crypto::hash& res)
   {
     blobdata bd;

src/cryptonote_core/cryptonote_format_utils.h

@@ -82,8 +82,6 @@ namespace cryptonote
   bool get_block_hash(const block& b, crypto::hash& res);
   crypto::hash get_block_hash(const block& b);
   bool get_block_header_hash(const block& b, crypto::hash& res);
-  bool get_block_longhash(const block& b, crypto::hash& res, uint64_t height);
-  crypto::hash get_block_longhash(const block& b, uint64_t height);
   bool get_bytecoin_block_longhash(const block& blk, crypto::hash& res);
   bool parse_and_validate_block_from_blob(const blobdata& b_blob, block& b);
   bool get_inputs_money_amount(const transaction& tx, uint64_t& money);

src/offshore/pricing_record.cpp

@@ -0,0 +1,339 @@
+// Copyright (c) 2019, Haven Protocol
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Portions of this code based upon code Copyright (c) 2019, The Monero Project
+
+#include "pricing_record.h"
+
+#include <cstring>
+
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/ecdsa.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+
+#include "serialization/keyvalue_serialization.h"
+#include "storages/portable_storage.h"
+
+namespace offshore
+{
+
+  namespace
+  {
+    struct pr_serialized
+    {
+      uint64_t xAG;
+      uint64_t xAU;
+      uint64_t xAUD;
+      uint64_t xBTC;
+      uint64_t xCAD;
+      uint64_t xCHF;
+      uint64_t xCNY;
+      uint64_t xEUR;
+      uint64_t xGBP;
+      uint64_t xJPY;
+      uint64_t xNOK;
+      uint64_t xNZD;
+      uint64_t xUSD;
+      uint64_t unused1;
+      uint64_t unused2;
+      uint64_t unused3;
+      std::string signature;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(xAG)
+        KV_SERIALIZE(xAU)
+        KV_SERIALIZE(xAUD)
+        KV_SERIALIZE(xBTC)
+        KV_SERIALIZE(xCAD)
+        KV_SERIALIZE(xCHF)
+        KV_SERIALIZE(xCNY)
+        KV_SERIALIZE(xEUR)
+        KV_SERIALIZE(xGBP)
+        KV_SERIALIZE(xJPY)
+        KV_SERIALIZE(xNOK)
+        KV_SERIALIZE(xNZD)
+        KV_SERIALIZE(xUSD)
+        KV_SERIALIZE(unused1)
+        KV_SERIALIZE(unused2)
+        KV_SERIALIZE(unused3)
+        KV_SERIALIZE(signature)
+      END_KV_SERIALIZE_MAP()
+    };
+  }
+  
+  pricing_record::pricing_record() noexcept
+    : xAG(0)
+    , xAU(0)
+    , xAUD(0)
+    , xBTC(0)
+    , xCAD(0)
+    , xCHF(0)
+    , xCNY(0)
+    , xEUR(0)
+    , xGBP(0)
+    , xJPY(0)
+    , xNOK(0)
+    , xNZD(0)
+    , xUSD(0)
+    , unused1(0)
+    , unused2(0)
+    , unused3(0)
+  {
+    std::memset(signature, 0, sizeof(signature));
+  }
+
+  bool pricing_record::_load(epee::serialization::portable_storage& src, epee::serialization::section* hparent)
+  {
+    pr_serialized in{};
+    if (in._load(src, hparent))
+    {
+      // Copy everything into the local instance
+      xAG = in.xAG;
+      xAU = in.xAU;
+      xAUD = in.xAUD;
+      xBTC = in.xBTC;
+      xCAD = in.xCAD;
+      xCHF = in.xCHF;
+      xCNY = in.xCNY;
+      xEUR = in.xEUR;
+      xGBP = in.xGBP;
+      xJPY = in.xJPY;
+      xNOK = in.xNOK;
+      xNZD = in.xNZD;
+      xUSD = in.xUSD;
+      unused1 = in.unused1;
+      unused2 = in.unused2;
+      unused3 = in.unused3;
+      for (unsigned int i = 0; i < in.signature.length(); i += 2) {
+	std::string byteString = in.signature.substr(i, 2);
+	signature[i>>1] = (char) strtol(byteString.c_str(), NULL, 16);
+      }
+      return true;
+    }
+
+    // Report error here?
+    return false;
+  }
+
+  bool pricing_record::store(epee::serialization::portable_storage& dest, epee::serialization::section* hparent) const
+  {
+    std::string sig_hex;
+    for (unsigned int i=0; i<64; i++) {
+      std::stringstream ss;
+      ss << std::hex << std::setw(2) << std::setfill('0') << (0xff & signature[i]);
+      sig_hex += ss.str();
+    }
+    const pr_serialized out{xAG,xAU,xAUD,xBTC,xCAD,xCHF,xCNY,xEUR,xGBP,xJPY,xNOK,xNZD,xUSD,unused1,unused2,unused3,sig_hex};
+    return out.store(dest, hparent);
+  }
+
+  pricing_record::pricing_record(const pricing_record& orig) noexcept
+    : xAG(orig.xAG)
+    , xAU(orig.xAU)
+    , xAUD(orig.xAUD)
+    , xBTC(orig.xBTC)
+    , xCAD(orig.xCAD)
+    , xCHF(orig.xCHF)
+    , xCNY(orig.xCNY)
+    , xEUR(orig.xEUR)
+    , xGBP(orig.xGBP)
+    , xJPY(orig.xJPY)
+    , xNOK(orig.xNOK)
+    , xNZD(orig.xNZD)
+    , xUSD(orig.xUSD)
+    , unused1(orig.unused1)
+    , unused2(orig.unused2)
+    , unused3(orig.unused3)
+  {
+    std::memcpy(signature, orig.signature, sizeof(signature));
+  }
+
+  pricing_record& pricing_record::operator=(const pricing_record& orig) noexcept
+  {
+    xAG = orig.xAG;
+    xAU = orig.xAU;
+    xAUD = orig.xAUD;
+    xBTC = orig.xBTC;
+    xCAD = orig.xCAD;
+    xCHF = orig.xCHF;
+    xCNY = orig.xCNY;
+    xEUR = orig.xEUR;
+    xGBP = orig.xGBP;
+    xJPY = orig.xJPY;
+    xNOK = orig.xNOK;
+    xNZD = orig.xNZD;
+    xUSD = orig.xUSD;
+    unused1 = orig.unused1;
+    unused2 = orig.unused2;
+    unused3 = orig.unused3;
+    ::memcpy(signature, orig.signature, sizeof(signature));
+    return *this;
+  }
+
+  bool pricing_record::equal(const pricing_record& other) const noexcept
+  {
+    return ((xAG == other.xAG) &&
+	    (xAU == other.xAU) &&
+	    (xAUD == other.xAUD) &&
+	    (xBTC == other.xBTC) &&
+	    (xCAD == other.xCAD) &&
+	    (xCHF == other.xCHF) &&
+	    (xCNY == other.xCNY) &&
+	    (xEUR == other.xEUR) &&
+	    (xGBP == other.xGBP) &&
+	    (xJPY == other.xJPY) &&
+	    (xNOK == other.xNOK) &&
+	    (xNZD == other.xNZD) &&
+	    (xUSD == other.xUSD) &&
+	    (unused1 == other.unused1) &&
+	    (unused2 == other.unused2) &&
+	    (unused3 == other.unused3) &&
+	    !::memcmp(signature, other.signature, sizeof(signature)));
+  }
+
+
+  bool pricing_record::verifySignature() const noexcept
+  {
+    // Sanity check - accept empty pricing records
+    unsigned char test_sig[64];
+    std::memset(test_sig, 0, sizeof(test_sig));
+    if (std::memcmp(test_sig, signature, sizeof(signature)) == 0) {
+      return true;
+    }
+    
+    // Convert our internal 64-byte binary representation into 128-byte hex string
+    std::string sig_hex;
+    for (unsigned int i=0; i<64; i++) {
+      std::stringstream ss;
+      ss << std::hex << std::setw(2) << std::setfill('0') << (0xff & signature[i]);
+      sig_hex += ss.str();
+    }
+    
+    // Rebuild the OpenSSL format of the signature from the r+s values
+    std::string sig_rebuilt = "30";
+    std::string r_rebuilt = (signature[0] == 0) ? sig_hex.substr(2, 62) : sig_hex.substr(0,64);
+    if (signature[(signature[0] == 0) ? 1 : 0] & 0x80)
+      r_rebuilt = "00" + r_rebuilt;
+    std::string s_rebuilt = (signature[(signature[32] == 0) ? 33 : 32] == 0) ? sig_hex.substr(66, 62) : sig_hex.substr(64,64);
+    if (signature[(signature[32] == 0) ? 33 : 32] & 0x80)
+      s_rebuilt = "00" + s_rebuilt;
+    size_t sig_length = (r_rebuilt.length() + s_rebuilt.length() + 8) >> 1;
+    std::stringstream ss;
+    ss << std::hex << sig_length;
+    sig_rebuilt += std::string(2-ss.str().length(), '0') + ss.str();
+    ss.clear();
+    sig_rebuilt += "02";
+    size_t r_length = r_rebuilt.length() >> 1;
+    std::stringstream ss2;
+    ss2 << std::hex << r_length;
+    sig_rebuilt += std::string(2-ss2.str().length(), '0') + ss2.str();
+    ss2.clear();
+    sig_rebuilt += r_rebuilt;
+    sig_rebuilt += "02";
+    size_t s_length = s_rebuilt.length() >> 1;
+    std::stringstream ss3;
+    ss3 << std::hex << s_length;
+    sig_rebuilt += std::string(2-ss3.str().length(), '0') + ss3.str();
+    ss3.clear();
+    sig_rebuilt += s_rebuilt;
+
+    // Build the JSON string, so that we can verify the signature
+    std::ostringstream oss;
+    oss << "{\"xAG\":" << xAG;
+    oss << ",\"xAU\":" << xAU;
+    oss << ",\"xAUD\":" << xAUD;
+    oss << ",\"xBTC\":" << xBTC;
+    oss << ",\"xCAD\":" << xCAD;
+    oss << ",\"xCHF\":" << xCHF;
+    oss << ",\"xCNY\":" << xCNY;
+    oss << ",\"xEUR\":" << xEUR;
+    oss << ",\"xGBP\":" << xGBP;
+    oss << ",\"xJPY\":" << xJPY;
+    oss << ",\"xNOK\":" << xNOK;
+    oss << ",\"xNZD\":" << xNZD;
+    oss << ",\"xUSD\":" << xUSD;
+    oss << ",\"unused1\":" << unused1;
+    oss << ",\"unused2\":" << unused2;
+    oss << ",\"unused3\":" << unused3;
+    oss << "}";
+    std::string message = oss.str();    
+
+    // Convert signature from hex-encoded to binary
+    std::string compact;
+    for (unsigned int i = 0; i < sig_rebuilt.length(); i += 2) {
+      std::string byteString = sig_rebuilt.substr(i, 2);
+      char byte = (char) strtol(byteString.c_str(), NULL, 16);
+      compact += (byte);
+    }
+
+    // HERE BE DRAGONS!!!
+    // NEAC: the public key should be in a file
+    static const char public_key[] = "-----BEGIN PUBLIC KEY-----\n"
+      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5YBxWx1AZCA9jTUk8Pr2uZ9jpfRt\n"
+      "KWv3Vo1/Gny+1vfaxsXhBQiG1KlHkafNGarzoL0WHW4ocqaaqF5iv8i35A==\n"
+      "-----END PUBLIC KEY-----\n";
+    // LAND AHOY!!!
+    
+    // Grab the public key and make it usable
+    BIO* bio = BIO_new_mem_buf(public_key, (int)sizeof(public_key));
+    assert(bio != NULL);
+    EVP_PKEY* pubkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
+    BIO_free(bio);
+    assert(pubkey != NULL);
+
+    // Create a verify digest from the message
+    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
+    int ret = 0;
+    if (ctx) {
+      ret=EVP_DigestVerifyInit(ctx, NULL, EVP_sha256(), NULL, pubkey);
+      if (ret == 1) {
+	ret=EVP_DigestVerifyUpdate(ctx, message.data(), message.length());
+	if (ret == 1) {
+	  ret=EVP_DigestVerifyFinal(ctx, (const unsigned char *)compact.data(), compact.length());
+	}
+      }
+    }
+    // Cleanup the context we created
+    EVP_MD_CTX_destroy(ctx);
+
+    // Cleanup the openssl stuff
+    EVP_PKEY_free(pubkey);
+  
+    if (ret == 1)
+      return true;
+
+    // Get the errors from OpenSSL
+    //ERR_print_errors_fp (stderr);
+  
+    return false;
+  }
+}

src/offshore/pricing_record.h

@@ -0,0 +1,120 @@
+// Copyright (c) 2019, Haven Protocol
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Portions of this code based upon code Copyright (c) 2019, The Monero Project
+
+#pragma once
+#include "common/pod-class.h"
+
+#include <cstdint>
+
+namespace epee
+{
+  namespace serialization
+  {
+    class portable_storage;
+    struct section;
+  }
+}
+
+namespace offshore
+{
+
+#pragma pack(push, 1)
+  POD_CLASS pricing_record_old {
+    double xAG;
+    double xAU;
+    double xAUD;
+    double xBTC;
+    double xCAN;
+    double xCHF;
+    double xCNY;
+    double xEUR;
+    double xGBP;
+    double xJPY;
+    double xNOK;
+    double xNZD;
+    double xUSD;
+    double unused1;
+    double unused2;
+    double unused3;
+    char signature[32];
+  };
+#pragma pack(pop)
+
+  class pricing_record
+  {
+
+  public:
+
+    // Fields 
+    uint64_t xAG;
+    uint64_t xAU;
+    uint64_t xAUD;
+    uint64_t xBTC;
+    uint64_t xCAD;
+    uint64_t xCHF;
+    uint64_t xCNY;
+    uint64_t xEUR;
+    uint64_t xGBP;
+    uint64_t xJPY;
+    uint64_t xNOK;
+    uint64_t xNZD;
+    uint64_t xUSD;
+    uint64_t unused1;
+    uint64_t unused2;
+    uint64_t unused3;
+    unsigned char signature[64];
+
+    // Default c'tor
+    pricing_record() noexcept;
+    
+    //! Load from epee p2p format
+    bool _load(epee::serialization::portable_storage& src, epee::serialization::section* hparent);
+    
+    //! Store in epee p2p format
+    bool store(epee::serialization::portable_storage& dest, epee::serialization::section* hparent) const;
+    pricing_record(const pricing_record& orig) noexcept;
+    ~pricing_record() = default;
+    pricing_record& operator=(const pricing_record& orig) noexcept;
+    
+    bool equal(const pricing_record& other) const noexcept;
+
+    bool verifySignature() const noexcept;
+  };
+
+  inline bool operator==(const pricing_record& a, const pricing_record& b) noexcept
+  {
+   return a.equal(b);
+  }
+  
+  inline bool operator!=(const pricing_record& a, const pricing_record& b) noexcept
+  {
+   return !a.equal(b);
+  }
+
+} // offshore

src/serialization/pricing_record.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2019, Haven Protocol
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#include <vector>
+
+#include "serialization.h"
+#include "debug_archive.h"
+#include "offshore/pricing_record.h"
+
+/*
+// read
+template <template <bool> class Archive>
+bool do_serialize(Archive<false> &ar, offshore::pricing_record &pr)
+{
+  // very basic sanity check
+  if (ar.remaining_bytes() < sizeof(offshore::pricing_record)) {
+    ar.stream().setstate(std::ios::failbit);
+    return false;
+  }
+  ar.serialize_blob(&pr, sizeof(offshore::pricing_record), "");
+  if (!ar.stream().good())
+    return false;
+  return true;
+}
+// write
+template <template <bool> class Archive>
+bool do_serialize(Archive<true> &ar, offshore::pricing_record &pr)
+{
+  ar.begin_string();
+  ar.serialize_blob(&pr, sizeof(offshore::pricing_record), "");
+  if (!ar.stream().good())
+    return false;
+  ar.end_string();
+  return true;
+}
+*/
+
+BLOB_SERIALIZER(offshore::pricing_record);