add ability to upgrade pre-rebase wallet files to post-rebase format

src/CMakeLists.txt

@@ -101,6 +101,7 @@ add_subdirectory(crypto)
 add_subdirectory(ringct)
 add_subdirectory(cryptonote_basic)
 add_subdirectory(cryptonote_core)
+add_subdirectory(legacy)
 if(NOT IOS)
   add_subdirectory(blockchain_db)
 endif()

src/legacy/BinaryInputStreamSerializer.cpp

@@ -0,0 +1,134 @@
+// Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
+//
+// This file is part of Bytecoin.
+//
+// Bytecoin is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Bytecoin is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Bytecoin.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BinaryInputStreamSerializer.h"
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include "StreamTools.h"
+#include "SerializationOverloads.h"
+
+using namespace Common;
+
+namespace CryptoNote {
+
+namespace {
+
+template<typename StorageType, typename T>
+void readVarintAs(IInputStream& s, T &i) {
+  i = static_cast<T>(readVarint<StorageType>(s));
+}
+
+}
+
+ISerializer::SerializerType BinaryInputStreamSerializer::type() const {
+  return ISerializer::INPUT;
+}
+
+bool BinaryInputStreamSerializer::beginObject(Common::StringView name) {
+  return true;
+}
+
+void BinaryInputStreamSerializer::endObject() {
+}
+
+bool BinaryInputStreamSerializer::beginArray(size_t& size, Common::StringView name) {
+  readVarintAs<uint64_t>(stream, size);
+  return true;
+}
+
+void BinaryInputStreamSerializer::endArray() {
+}
+
+bool BinaryInputStreamSerializer::operator()(uint8_t& value, Common::StringView name) {
+  readVarint(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(uint16_t& value, Common::StringView name) {
+  readVarint(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(int16_t& value, Common::StringView name) {
+  readVarintAs<uint16_t>(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(uint32_t& value, Common::StringView name) {
+  readVarint(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(int32_t& value, Common::StringView name) {
+  readVarintAs<uint32_t>(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(int64_t& value, Common::StringView name) {
+  readVarintAs<uint64_t>(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(uint64_t& value, Common::StringView name) {
+  readVarint(stream, value);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(bool& value, Common::StringView name) {
+  value = read<uint8_t>(stream) != 0;
+  return true;
+}
+
+bool BinaryInputStreamSerializer::operator()(std::string& value, Common::StringView name) {
+  uint64_t size;
+  readVarint(stream, size);
+
+  if (size > 0) {
+    std::vector<char> temp;
+    temp.resize(size);
+    checkedRead(&temp[0], size);
+    value.reserve(size);
+    value.assign(&temp[0], size);
+  } else {
+    value.clear();
+  }
+
+  return true;
+}
+
+bool BinaryInputStreamSerializer::binary(void* value, size_t size, Common::StringView name) {
+  checkedRead(static_cast<char*>(value), size);
+  return true;
+}
+
+bool BinaryInputStreamSerializer::binary(std::string& value, Common::StringView name) {
+  return (*this)(value, name);
+}
+
+bool BinaryInputStreamSerializer::operator()(double& value, Common::StringView name) {
+  assert(false); //the method is not supported for this type of serialization
+  throw std::runtime_error("double serialization is not supported in BinaryInputStreamSerializer");
+  return false;
+}
+
+void BinaryInputStreamSerializer::checkedRead(char* buf, size_t size) {
+  read(stream, buf, size);
+}
+
+}

src/legacy/BinaryInputStreamSerializer.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
+//
+// This file is part of Bytecoin.
+//
+// Bytecoin is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Bytecoin is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Bytecoin.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "IInputStream.h"
+#include "ISerializer.h"
+#include "SerializationOverloads.h"
+
+namespace CryptoNote {
+
+	class BinaryInputStreamSerializer : public ISerializer {
+	public:
+		BinaryInputStreamSerializer(Common::IInputStream& strm) : stream(strm) {}
+		virtual ~BinaryInputStreamSerializer() {}
+
+		virtual ISerializer::SerializerType type() const override;
+
+		virtual bool beginObject(Common::StringView name) override;
+		virtual void endObject() override;
+
+		virtual bool beginArray(size_t& size, Common::StringView name) override;
+		virtual void endArray() override;
+
+		virtual bool operator()(uint8_t& value, Common::StringView name) override;
+		virtual bool operator()(int16_t& value, Common::StringView name) override;
+		virtual bool operator()(uint16_t& value, Common::StringView name) override;
+		virtual bool operator()(int32_t& value, Common::StringView name) override;
+		virtual bool operator()(uint32_t& value, Common::StringView name) override;
+		virtual bool operator()(int64_t& value, Common::StringView name) override;
+		virtual bool operator()(uint64_t& value, Common::StringView name) override;
+		virtual bool operator()(double& value, Common::StringView name) override;
+		virtual bool operator()(bool& value, Common::StringView name) override;
+		virtual bool operator()(std::string& value, Common::StringView name) override;
+		virtual bool binary(void* value, size_t size, Common::StringView name) override;
+		virtual bool binary(std::string& value, Common::StringView name) override;
+
+		template<typename T>
+		bool operator()(T& value, Common::StringView name) {
+			return ISerializer::operator()(value, name);
+		}
+
+	private:
+
+		void checkedRead(char* buf, size_t size);
+		Common::IInputStream& stream;
+	};
+
+}

src/legacy/BinaryOutputStreamSerializer.cpp

@@ -0,0 +1,114 @@
+// Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
+//
+// This file is part of Bytecoin.
+//
+// Bytecoin is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Bytecoin is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Bytecoin.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BinaryOutputStreamSerializer.h"
+
+#include <cassert>
+#include <stdexcept>
+#include "StreamTools.h"
+
+using namespace Common;
+
+namespace CryptoNote {
+
+ISerializer::SerializerType BinaryOutputStreamSerializer::type() const {
+  return ISerializer::OUTPUT;
+}
+
+bool BinaryOutputStreamSerializer::beginObject(Common::StringView name) {
+  return true;
+}
+
+void BinaryOutputStreamSerializer::endObject() {
+}
+
+bool BinaryOutputStreamSerializer::beginArray(size_t& size, Common::StringView name) {
+  writeVarint(stream, size);
+  return true;
+}
+
+void BinaryOutputStreamSerializer::endArray() {
+}
+
+bool BinaryOutputStreamSerializer::operator()(uint8_t& value, Common::StringView name) {
+  writeVarint(stream, value);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(uint16_t& value, Common::StringView name) {
+  writeVarint(stream, value);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(int16_t& value, Common::StringView name) {
+  writeVarint(stream, static_cast<uint16_t>(value));
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(uint32_t& value, Common::StringView name) {
+  writeVarint(stream, value);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(int32_t& value, Common::StringView name) {
+  writeVarint(stream, static_cast<uint32_t>(value));
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(int64_t& value, Common::StringView name) {
+  writeVarint(stream, static_cast<uint64_t>(value));
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(uint64_t& value, Common::StringView name) {
+  writeVarint(stream, value);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(bool& value, Common::StringView name) {
+  char boolVal = value;
+  checkedWrite(&boolVal, 1);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::operator()(std::string& value, Common::StringView name) {
+  writeVarint(stream, value.size());
+  checkedWrite(value.data(), value.size());
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::binary(void* value, size_t size, Common::StringView name) {
+  checkedWrite(static_cast<const char*>(value), size);
+  return true;
+}
+
+bool BinaryOutputStreamSerializer::binary(std::string& value, Common::StringView name) {
+  // write as string (with size prefix)
+  return (*this)(value, name);
+}
+
+bool BinaryOutputStreamSerializer::operator()(double& value, Common::StringView name) {
+  assert(false); //the method is not supported for this type of serialization
+  throw std::runtime_error("double serialization is not supported in BinaryOutputStreamSerializer");
+  return false;
+}
+
+void BinaryOutputStreamSerializer::checkedWrite(const char* buf, size_t size) {
+  write(stream, buf, size);
+}
+
+}

src/legacy/BinaryOutputStreamSerializer.h

@@ -0,0 +1,62 @@
+// Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
+//
+// This file is part of Bytecoin.
+//
+// Bytecoin is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Bytecoin is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Bytecoin.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "IOutputStream.h"
+#include "ISerializer.h"
+#include "SerializationOverloads.h"
+
+namespace CryptoNote {
+
+class BinaryOutputStreamSerializer : public ISerializer {
+public:
+  BinaryOutputStreamSerializer(Common::IOutputStream& strm) : stream(strm) {}
+  virtual ~BinaryOutputStreamSerializer() {}
+
+  virtual ISerializer::SerializerType type() const override;
+
+  virtual bool beginObject(Common::StringView name) override;
+  virtual void endObject() override;
+
+  virtual bool beginArray(size_t& size, Common::StringView name) override;
+  virtual void endArray() override;
+
+  virtual bool operator()(uint8_t& value, Common::StringView name) override;
+  virtual bool operator()(int16_t& value, Common::StringView name) override;
+  virtual bool operator()(uint16_t& value, Common::StringView name) override;
+  virtual bool operator()(int32_t& value, Common::StringView name) override;
+  virtual bool operator()(uint32_t& value, Common::StringView name) override;
+  virtual bool operator()(int64_t& value, Common::StringView name) override;
+  virtual bool operator()(uint64_t& value, Common::StringView name) override;
+  virtual bool operator()(double& value, Common::StringView name) override;
+  virtual bool operator()(bool& value, Common::StringView name) override;
+  virtual bool operator()(std::string& value, Common::StringView name) override;
+  virtual bool binary(void* value, size_t size, Common::StringView name) override;
+  virtual bool binary(std::string& value, Common::StringView name) override;
+
+  template<typename T>
+  bool operator()(T& value, Common::StringView name) {
+    return ISerializer::operator()(value, name);
+  }
+
+private:
+  void checkedWrite(const char* buf, size_t size);
+  Common::IOutputStream& stream;
+};
+
+}