Merge remote-tracking branch 'upstream/master'

28 files changed, 432 insertions, 205 deletions

diff --git a/src/crypto/oaes_lib.c b/src/crypto/oaes_lib.c
index 96f038600..f3f2aac8c 100644
--- a/src/crypto/oaes_lib.c
+++ b/src/crypto/oaes_lib.c
@@ -64,7 +64,6 @@ static const char _NR[] = {
 # define min(a,b) (((a)<(b)) ? (a) : (b))
 #endif /* min */
 
-
 // "OAES<8-bit header version><8-bit type><16-bit options><8-bit flags><56-bit reserved>"
 static uint8_t oaes_header[OAES_BLOCK_SIZE] = {
 	// 		0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    a,    b,    c,    d,    e,    f,
diff --git a/src/crypto/oaes_lib.h b/src/crypto/oaes_lib.h
index 16b914c7a..fd1942822 100644
--- a/src/crypto/oaes_lib.h
+++ b/src/crypto/oaes_lib.h
@@ -32,6 +32,7 @@
 #define _OAES_LIB_H
 
 #include <stdint.h>
+#include <stdlib.h>
 
 #ifdef __cplusplus 
 extern "C" {
@@ -101,15 +102,14 @@ typedef int ( * oaes_step_cb ) (
 
 typedef uint16_t OAES_OPTION;
 
-
 typedef struct _oaes_key
 {
-	size_t data_len;
-	uint8_t *data;
-	size_t exp_data_len;
-	uint8_t *exp_data;
-	size_t num_keys;
-	size_t key_base;
+  size_t data_len;
+  uint8_t *data;
+  size_t exp_data_len;
+  uint8_t *exp_data;
+  size_t num_keys;
+  size_t key_base;
 } oaes_key;
 
 typedef struct _oaes_ctx
@@ -119,14 +119,13 @@ typedef struct _oaes_ctx
 #endif // OAES_HAVE_ISAAC
 
 #ifdef OAES_DEBUG
-	oaes_step_cb step_cb;
+  oaes_step_cb step_cb;
 #endif // OAES_DEBUG
 
-	oaes_key * key;
-	OAES_OPTION options;
-	uint8_t iv[OAES_BLOCK_SIZE];
+  oaes_key * key;
+  OAES_OPTION options;
+  uint8_t iv[OAES_BLOCK_SIZE];
 } oaes_ctx;
-
 /*
  * // usage:
  * 
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index 34d053aa8..a992a9db0 100644
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -8,7 +8,7 @@
 #define CRYPTONOTE_MAX_BLOCK_SIZE                       500000000  // block header blob limit, never used!
 #define CRYPTONOTE_MAX_TX_SIZE                          1000000000
 #define CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER          0
-#define CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX         18 // addresses start with "2"
+#define CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX         18 // addresses start with "4"
 #define CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW            60
 #define CURRENT_TRANSACTION_VERSION                     1
 #define CURRENT_BLOCK_MAJOR_VERSION                     1
@@ -26,8 +26,8 @@
 #define CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE          600
 #define CRYPTONOTE_DISPLAY_DECIMAL_POINT                12
 // COIN - number of smallest units in one coin
-#define COIN                                            ((uint64_t)100000000) // pow(10, 8)
-#define DEFAULT_FEE                                     ((uint64_t)1000000) // pow(10, 6)
+#define COIN                                            ((uint64_t)1000000000000) // pow(10, 12)
+#define DEFAULT_FEE                                     ((uint64_t)5000000000) // 5 * pow(10, 9)
 
 
 #define ORPHANED_BLOCKS_MAX_COUNT                       100
diff --git a/src/cryptonote_core/blockchain_storage.cpp b/src/cryptonote_core/blockchain_storage.cpp
index 0e20b454b..9e9c77e85 100644
--- a/src/cryptonote_core/blockchain_storage.cpp
+++ b/src/cryptonote_core/blockchain_storage.cpp
@@ -372,7 +372,7 @@ bool blockchain_storage::rollback_blockchain_switching(std::list<block>& origina
   return true;
 }
 //------------------------------------------------------------------
-bool blockchain_storage::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::iterator>& alt_chain)
+bool blockchain_storage::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::iterator>& alt_chain, bool discard_disconnected_chain)
 {
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
   CHECK_AND_ASSERT_MES(alt_chain.size(), false, "switch_to_alternative_blockchain: empty chain passed");
@@ -414,16 +414,19 @@ bool blockchain_storage::switch_to_alternative_blockchain(std::list<blocks_ext_b
     }
   }
 
-  //pushing old chain as alternative chain
-  BOOST_FOREACH(auto& old_ch_ent, disconnected_chain)
+  if(!discard_disconnected_chain)
   {
-    block_verification_context bvc = boost::value_initialized<block_verification_context>();
-    bool r = handle_alternative_block(old_ch_ent, get_block_hash(old_ch_ent), bvc);
-    if(!r)
+    //pushing old chain as alternative chain
+    BOOST_FOREACH(auto& old_ch_ent, disconnected_chain)
     {
-      LOG_ERROR("Failed to push ex-main chain blocks to alternative chain ");
-      rollback_blockchain_switching(disconnected_chain, split_height);
-      return false;
+      block_verification_context bvc = boost::value_initialized<block_verification_context>();
+      bool r = handle_alternative_block(old_ch_ent, get_block_hash(old_ch_ent), bvc);
+      if(!r)
+      {
+        LOG_ERROR("Failed to push ex-main chain blocks to alternative chain ");
+        rollback_blockchain_switching(disconnected_chain, split_height);
+        return false;
+      }
     }
   }
 
@@ -701,6 +704,22 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
 {
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
 
+  uint64_t block_height = get_block_height(b);
+  if(0 == block_height)
+  {
+    LOG_ERROR("Block with id: " << string_tools::pod_to_hex(id) << " (as alternative) have wrong miner transaction");
+    bvc.m_verifivation_failed = true;
+    return false;
+  }
+  if (!m_checkpoints.is_alternative_block_allowed(get_current_blockchain_height(), block_height))
+  {
+    LOG_PRINT_RED_L0("Block with id: " << id
+      << ENDL << " can't be accepted for alternative chain, block height: " << block_height
+      << ENDL << " blockchain height: " << get_current_blockchain_height());
+    bvc.m_verifivation_failed = true;
+    return false;
+  }
+
   //block is not related with head of main chain
   //first of all - look in alternative chains container
   auto it_main_prev = m_blocks_index.find(b.prev_id);
@@ -746,31 +765,28 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
     block_extended_info bei = boost::value_initialized<block_extended_info>();
     bei.bl = b;
     bei.height = alt_chain.size() ? it_prev->second.height + 1 : it_main_prev->second + 1;
+
+    bool is_a_checkpoint;
+    if(!m_checkpoints.check_block(bei.height, id, is_a_checkpoint))
+    {
+      LOG_ERROR("CHECKPOINT VALIDATION FAILED");
+      bvc.m_verifivation_failed = true;
+      return false;
+    }
+
+    // Always check PoW for alternative blocks
+    m_is_in_checkpoint_zone = false;
     difficulty_type current_diff = get_next_difficulty_for_alternative_chain(alt_chain, bei);
     CHECK_AND_ASSERT_MES(current_diff, false, "!!!!!!! DIFFICULTY OVERHEAD !!!!!!!");
     crypto::hash proof_of_work = null_hash;
-    if(!m_checkpoints.is_in_checkpoint_zone(bei.height))
+    get_block_longhash(bei.bl, proof_of_work, bei.height);
+    if(!check_hash(proof_of_work, current_diff))
     {
-      m_is_in_checkpoint_zone = false;
-      get_block_longhash(bei.bl, proof_of_work, bei.height);
-
-      if(!check_hash(proof_of_work, current_diff))
-      {
-        LOG_PRINT_RED_L0("Block with id: " << id
-          << ENDL << " for alternative chain, have not enough proof of work: " << proof_of_work
-          << ENDL << " expected difficulty: " << current_diff);
-        bvc.m_verifivation_failed = true;
-        return false;
-      }
-    }else
-    {
-      m_is_in_checkpoint_zone = true;
-      if(!m_checkpoints.check_block(bei.height, id))
-      {
-        LOG_ERROR("CHECKPOINT VALIDATION FAILED");
-        bvc.m_verifivation_failed = true;
-        return false;
-      }
+      LOG_PRINT_RED_L0("Block with id: " << id
+        << ENDL << " for alternative chain, have not enough proof of work: " << proof_of_work
+        << ENDL << " expected difficulty: " << current_diff);
+      bvc.m_verifivation_failed = true;
+      return false;
     }
 
     if(!prevalidate_miner_transaction(b, bei.height))
@@ -792,22 +808,33 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
     auto i_res = m_alternative_chains.insert(blocks_ext_by_hash::value_type(id, bei));
     CHECK_AND_ASSERT_MES(i_res.second, false, "insertion of new alternative block returned as it already exist");
     alt_chain.push_back(i_res.first);
-    //check if difficulty bigger then in main chain
-    if(m_blocks.back().cumulative_difficulty < bei.cumulative_difficulty)
+
+    if(is_a_checkpoint)
     {
       //do reorganize!
-      LOG_PRINT_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_blocks.size() -1  << " with cum_difficulty " << m_blocks.back().cumulative_difficulty
+      LOG_PRINT_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_blocks.size() - 1 <<
+        ", checkpoint is found in alternative chain on height " << bei.height, LOG_LEVEL_0);
+      bool r = switch_to_alternative_blockchain(alt_chain, true);
+      if(r) bvc.m_added_to_main_chain = true;
+      else bvc.m_verifivation_failed = true;
+      return r;
+    }else if(m_blocks.back().cumulative_difficulty < bei.cumulative_difficulty) //check if difficulty bigger then in main chain
+    {
+      //do reorganize!
+      LOG_PRINT_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_blocks.size() - 1 << " with cum_difficulty " << m_blocks.back().cumulative_difficulty
         << ENDL << " alternative blockchain size: " << alt_chain.size() << " with cum_difficulty " << bei.cumulative_difficulty, LOG_LEVEL_0);
-      bool r = switch_to_alternative_blockchain(alt_chain);
+      bool r = switch_to_alternative_blockchain(alt_chain, false);
       if(r) bvc.m_added_to_main_chain = true;
       else bvc.m_verifivation_failed = true;
       return r;
+    }else
+    {
+      LOG_PRINT_BLUE("----- BLOCK ADDED AS ALTERNATIVE ON HEIGHT " << bei.height
+        << ENDL << "id:\t" << id
+        << ENDL << "PoW:\t" << proof_of_work
+        << ENDL << "difficulty:\t" << current_diff, LOG_LEVEL_0);
+      return true;
     }
-    LOG_PRINT_BLUE("----- BLOCK ADDED AS ALTERNATIVE ON HEIGHT " << bei.height
-      << ENDL << "id:\t" << id
-      << ENDL << "PoW:\t" << proof_of_work
-      << ENDL << "difficulty:\t" << current_diff, LOG_LEVEL_0);
-    return true;
   }else
   {
     //block orphaned
@@ -815,7 +842,6 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
     LOG_PRINT_RED_L0("Block recognized as orphaned and rejected, id = " << id);
   }
 
-
   return true;
 }
 //------------------------------------------------------------------
@@ -1480,19 +1506,27 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
   TIME_MEASURE_FINISH(target_calculating_time);
   TIME_MEASURE_START(longhash_calculating_time);
   crypto::hash proof_of_work = null_hash;
-  if(!m_checkpoints.is_in_checkpoint_zone(get_current_blockchain_height()))
+
+  // Formerly the code below contained an if loop with the following condition
+  // !m_checkpoints.is_in_checkpoint_zone(get_current_blockchain_height())
+  // however, this caused the daemon to not bother checking PoW for blocks
+  // before checkpoints, which is very dangerous behaviour. We moved the PoW
+  // validation out of the next chunk of code to make sure that we correctly
+  // check PoW now.
+  proof_of_work = get_block_longhash(bl, m_blocks.size());
+
+  if(!check_hash(proof_of_work, current_diffic))
   {
-    proof_of_work = get_block_longhash(bl, m_blocks.size());
+    LOG_PRINT_L0("Block with id: " << id << ENDL
+      << "have not enough proof of work: " << proof_of_work << ENDL
+      << "nexpected difficulty: " << current_diffic );
+    bvc.m_verifivation_failed = true;
+    return false;
+  }
 
-    if(!check_hash(proof_of_work, current_diffic))
-    {
-      LOG_PRINT_L0("Block with id: " << id << ENDL
-        << "have not enough proof of work: " << proof_of_work << ENDL
-        << "nexpected difficulty: " << current_diffic );
-      bvc.m_verifivation_failed = true;
-      return false;
-    }
-  }else
+  // If we're at a checkpoint, ensure that our hardcoded checkpoint hash
+  // is correct.
+  if(m_checkpoints.is_in_checkpoint_zone(get_current_blockchain_height()))
   {
     if(!m_checkpoints.check_block(get_current_blockchain_height(), id))
     {
@@ -1501,6 +1535,7 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
       return false;
     }
   }
+
   TIME_MEASURE_FINISH(longhash_calculating_time);
 
   if(!prevalidate_miner_transaction(bl, m_blocks.size()))
@@ -1648,4 +1683,4 @@ bool blockchain_storage::add_new_block(const block& bl_, block_verification_cont
   }
 
   return handle_block_to_main_chain(bl, id, bvc);
-}
\ No newline at end of file
+}
diff --git a/src/cryptonote_core/blockchain_storage.h b/src/cryptonote_core/blockchain_storage.h
index 1ea5e29ea..b1fb5df41 100644
--- a/src/cryptonote_core/blockchain_storage.h
+++ b/src/cryptonote_core/blockchain_storage.h
@@ -13,6 +13,8 @@
 #include <boost/foreach.hpp>
 #include <atomic>
 
+#include "syncobj.h"
+#include "string_tools.h"
 #include "tx_pool.h"
 #include "cryptonote_basic.h"
 #include "common/util.h"
@@ -50,7 +52,7 @@ namespace cryptonote
       uint64_t already_generated_coins;
     };
 
-    blockchain_storage(tx_memory_pool& tx_pool):m_tx_pool(tx_pool), m_current_block_cumul_sz_limit(0), m_is_in_checkpoint_zone(false)
+    blockchain_storage(tx_memory_pool& tx_pool):m_tx_pool(tx_pool), m_current_block_cumul_sz_limit(0), m_is_in_checkpoint_zone(false), m_is_blockchain_storing(false)
     {};
 
     bool init() { return init(tools::get_default_data_dir()); }
@@ -119,7 +121,7 @@ namespace cryptonote
           missed_bs.push_back(bl_id);
         else
         {
-          CHECK_AND_ASSERT_MES(it->second < m_blocks.size(), false, "Internal error: bl_id=" << string_tools::pod_to_hex(bl_id)
+          CHECK_AND_ASSERT_MES(it->second < m_blocks.size(), false, "Internal error: bl_id=" << epee::string_tools::pod_to_hex(bl_id)
             << " have index record with offset="<<it->second<< ", bigger then m_blocks.size()=" << m_blocks.size());
             blocks.push_back(m_blocks[it->second].bl);
         }
@@ -163,7 +165,7 @@ namespace cryptonote
     typedef std::map<uint64_t, std::vector<std::pair<crypto::hash, size_t>>> outputs_container; //crypto::hash - tx hash, size_t - index of out in transaction
 
     tx_memory_pool& m_tx_pool;
-    critical_section m_blockchain_lock; // TODO: add here reader/writer lock
+    epee::critical_section m_blockchain_lock; // TODO: add here reader/writer lock
 
     // main chain
     blocks_container m_blocks;               // height  -> block_extended_info
@@ -186,7 +188,7 @@ namespace cryptonote
     std::atomic<bool> m_is_in_checkpoint_zone;
     std::atomic<bool> m_is_blockchain_storing;
 
-    bool switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::iterator>& alt_chain);
+    bool switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::iterator>& alt_chain, bool discard_disconnected_chain);
     bool pop_block_from_blockchain();
     bool purge_block_data_from_blockchain(const block& b, size_t processed_tx_count);
     bool purge_transaction_from_blockchain(const crypto::hash& tx_id);
@@ -301,7 +303,7 @@ namespace cryptonote
         return false;
       }
       transactions_container::iterator tx_it = m_transactions.find(amount_outs_vec[i].first);
-      CHECK_AND_ASSERT_MES(tx_it != m_transactions.end(), false, "Wrong transaction id in output indexes: " <<string_tools::pod_to_hex(amount_outs_vec[i].first));
+      CHECK_AND_ASSERT_MES(tx_it != m_transactions.end(), false, "Wrong transaction id in output indexes: " << epee::string_tools::pod_to_hex(amount_outs_vec[i].first));
       CHECK_AND_ASSERT_MES(amount_outs_vec[i].second < tx_it->second.tx.vout.size(), false,
         "Wrong index in transaction outputs: " << amount_outs_vec[i].second << ", expected less then " << tx_it->second.tx.vout.size());
       if(!vis.handle_output(tx_it->second.tx, tx_it->second.tx.vout[amount_outs_vec[i].second]))
diff --git a/src/cryptonote_core/checkpoints.cpp b/src/cryptonote_core/checkpoints.cpp
index 54c2f3a6d..33a2d2986 100644
--- a/src/cryptonote_core/checkpoints.cpp
+++ b/src/cryptonote_core/checkpoints.cpp
@@ -29,10 +29,11 @@ namespace cryptonote
     return !m_points.empty() && (height <= (--m_points.end())->first);
   }
   //---------------------------------------------------------------------------
-  bool checkpoints::check_block(uint64_t height, const crypto::hash& h) const
+  bool checkpoints::check_block(uint64_t height, const crypto::hash& h, bool& is_a_checkpoint) const
   {
     auto it = m_points.find(height);
-    if(it == m_points.end())
+    is_a_checkpoint = it != m_points.end();
+    if(!is_a_checkpoint)
       return true;
 
     if(it->second == h)
@@ -45,4 +46,25 @@ namespace cryptonote
       return false;
     }
   }
+  //---------------------------------------------------------------------------
+  bool checkpoints::check_block(uint64_t height, const crypto::hash& h) const
+  {
+    bool ignored;
+    return check_block(height, h, ignored);
+  }
+  //---------------------------------------------------------------------------
+  bool checkpoints::is_alternative_block_allowed(uint64_t blockchain_height, uint64_t block_height) const
+  {
+    if (0 == block_height)
+      return false;
+
+    auto it = m_points.upper_bound(blockchain_height);
+    // Is blockchain_height before the first checkpoint?
+    if (it == m_points.begin())
+      return true;
+
+    --it;
+    uint64_t checkpoint_height = it->first;
+    return checkpoint_height < block_height;
+  }
 }
diff --git a/src/cryptonote_core/checkpoints.h b/src/cryptonote_core/checkpoints.h
index 20014b1c8..1bc055d91 100644
--- a/src/cryptonote_core/checkpoints.h
+++ b/src/cryptonote_core/checkpoints.h
@@ -16,6 +16,9 @@ namespace cryptonote
     bool add_checkpoint(uint64_t height, const std::string& hash_str);
     bool is_in_checkpoint_zone(uint64_t height) const;
     bool check_block(uint64_t height, const crypto::hash& h) const;
+    bool check_block(uint64_t height, const crypto::hash& h, bool& is_a_checkpoint) const;
+    bool is_alternative_block_allowed(uint64_t blockchain_height, uint64_t block_height) const;
+
   private:
     std::map<uint64_t, crypto::hash> m_points;
   };
diff --git a/src/cryptonote_core/checkpoints_create.h b/src/cryptonote_core/checkpoints_create.h
index 32d15831f..3ecbbf0b6 100644
--- a/src/cryptonote_core/checkpoints_create.h
+++ b/src/cryptonote_core/checkpoints_create.h
@@ -12,12 +12,9 @@
 namespace cryptonote {
   inline bool create_checkpoints(cryptonote::checkpoints& checkpoints)
   {      
-    // Checkpointing disabled until we can make the client not fast-sync
-    // without checking PoW at some point. Otherwise we may be exposed
-    // to blockchain corruption attacks. Need to investigate this further.
-    // 8-5-14
-    // ADD_CHECKPOINT(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25");
-    // ADD_CHECKPOINT(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6");
+    ADD_CHECKPOINT(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25");
+    ADD_CHECKPOINT(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6");
+    ADD_CHECKPOINT(50000, "0fe8758ab06a8b9cb35b7328fd4f757af530a5d37759f9d3e421023231f7b31c");
     return true;
   }
 }
diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index a09f25d31..b6bfa09c8 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -502,7 +502,7 @@ namespace cryptonote
       LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL 
         << "The daemon will start synchronizing with the network. It may take up to several hours." << ENDL 
         << ENDL
-        << "You can set the level of process detailization by using command \"set_log <level>\", where <level> is either 0 (no details), 1 (current block height synchronized), or 2 (all details)." << ENDL
+        << "You can set the level of process detailization* through \"set_log <level>\" command*, where <level> is between 0 (no details) and 4 (very verbose)." << ENDL
         << ENDL
         << "Use \"help\" command to see the list of available commands." << ENDL
         << ENDL
diff --git a/src/cryptonote_core/cryptonote_core.h b/src/cryptonote_core/cryptonote_core.h
index c298451e8..cde52d5a2 100644
--- a/src/cryptonote_core/cryptonote_core.h
+++ b/src/cryptonote_core/cryptonote_core.h
@@ -115,13 +115,13 @@ namespace cryptonote
      tx_memory_pool m_mempool;
      blockchain_storage m_blockchain_storage;
      i_cryptonote_protocol* m_pprotocol;
-     critical_section m_incoming_tx_lock;
+     epee::critical_section m_incoming_tx_lock;
      //m_miner and m_miner_addres are probably temporary here
      miner m_miner;
      account_public_address m_miner_address;
      std::string m_config_folder;
      cryptonote_protocol_stub m_protocol_stub;
-     math_helper::once_a_time_seconds<60*60*12, false> m_store_blockchain_interval;
+     epee::math_helper::once_a_time_seconds<60*60*12, false> m_store_blockchain_interval;
      friend class tx_validate_inputs;
      std::atomic<bool> m_starter_message_showed;
    };
diff --git a/src/cryptonote_core/cryptonote_format_utils.cpp b/src/cryptonote_core/cryptonote_format_utils.cpp
index 2b38d001f..7b7f18844 100644
--- a/src/cryptonote_core/cryptonote_format_utils.cpp
+++ b/src/cryptonote_core/cryptonote_format_utils.cpp
@@ -239,8 +239,7 @@ namespace cryptonote
   crypto::public_key get_tx_pub_key_from_extra(const std::vector<uint8_t>& tx_extra)
   {
     std::vector<tx_extra_field> tx_extra_fields;
-    if (!parse_tx_extra(tx_extra, tx_extra_fields))
-      return null_pkey;
+    parse_tx_extra(tx_extra, tx_extra_fields);
 
     tx_extra_pub_key pub_key_field;
     if(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field))
diff --git a/src/cryptonote_core/miner.h b/src/cryptonote_core/miner.h
index da4578b06..61c063ddf 100644
--- a/src/cryptonote_core/miner.h
+++ b/src/cryptonote_core/miner.h
@@ -4,7 +4,6 @@
 
 #pragma once 
 
-#include <boost/atomic.hpp>
 #include <boost/program_options.hpp>
 #include <atomic>
 #include "cryptonote_basic.h"
@@ -64,7 +63,7 @@ namespace cryptonote
 
 
     volatile uint32_t m_stop;
-    ::critical_section m_template_lock;
+    epee::critical_section m_template_lock;
     block m_template;
     std::atomic<uint32_t> m_template_no;
     std::atomic<uint32_t> m_starter_nonce;
@@ -73,21 +72,21 @@ namespace cryptonote
     volatile uint32_t m_thread_index; 
     volatile uint32_t m_threads_total;
     std::atomic<int32_t> m_pausers_count;
-    ::critical_section m_miners_count_lock;
+    epee::critical_section m_miners_count_lock;
 
     std::list<boost::thread> m_threads;
-    ::critical_section m_threads_lock;
+    epee::critical_section m_threads_lock;
     i_miner_handler* m_phandler;
     account_public_address m_mine_address;
-    math_helper::once_a_time_seconds<5> m_update_block_template_interval;
-    math_helper::once_a_time_seconds<2> m_update_merge_hr_interval;
+    epee::math_helper::once_a_time_seconds<5> m_update_block_template_interval;
+    epee::math_helper::once_a_time_seconds<2> m_update_merge_hr_interval;
     std::vector<blobdata> m_extra_messages;
     miner_config m_config;
     std::string m_config_folder_path;    
     std::atomic<uint64_t> m_last_hr_merge_time;
     std::atomic<uint64_t> m_hashes;
     std::atomic<uint64_t> m_current_hash_rate;
-    critical_section m_last_hash_rates_lock;
+    epee::critical_section m_last_hash_rates_lock;
     std::list<uint64_t> m_last_hash_rates;
     bool m_do_print_hashrate;
     bool m_do_mining;
diff --git a/src/cryptonote_core/tx_extra.h b/src/cryptonote_core/tx_extra.h
index 254a6a2ff..37a04a41e 100644
--- a/src/cryptonote_core/tx_extra.h
+++ b/src/cryptonote_core/tx_extra.h
@@ -135,7 +135,6 @@ namespace cryptonote
   //   varint tag;
   //   varint size;
   //   varint data[];
-  //typedef boost::variant<tx_extra_padding, tx_extra_pub_key, tx_extra_nonce> tx_extra_field;
   typedef boost::variant<tx_extra_padding, tx_extra_pub_key, tx_extra_nonce, tx_extra_merge_mining_tag> tx_extra_field;
 }
 
diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 24e5752ad..4c4c6aea1 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -350,18 +350,69 @@ namespace cryptonote
   //---------------------------------------------------------------------------------
   bool tx_memory_pool::fill_block_template(block &bl, size_t median_size, uint64_t already_generated_coins, size_t &total_size, uint64_t &fee)
   {
+    // Warning: This function takes already_generated_
+    // coins as an argument and appears to do nothing
+    // with it.
+
     CRITICAL_REGION_LOCAL(m_transactions_lock);
 
     total_size = 0;
     fee = 0;
 
-    size_t max_total_size = 2 * median_size - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
+    size_t max_total_size = 2 * median_size - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE; // Max block size
     std::unordered_set<crypto::key_image> k_images;
+
+    // Tx size limit as in wallet2.h
+    // tx_pool.cpp uses size_t for tx sizes, whereas
+    // wallet2.h uses uint64_t; just use size_t here 
+    // for now
+    size_t upper_transaction_size_limit = ((CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE * 125) / 100) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
+
+    // Calculate size limit based on median too; useful
+    // for when we actually fix wallet2.h's maximum
+    // allowable tx size
+    //
+    // Can be removed when wallet2.h calculates max
+    // tx size based on the median too; just use
+    // upper_transaction_size_limit_median in all cases
+    size_t upper_transaction_size_limit_median = ((median_size * 125) / 100) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
+    if (upper_transaction_size_limit_median > upper_transaction_size_limit)
+      upper_transaction_size_limit = upper_transaction_size_limit_median;
+
     BOOST_FOREACH(transactions_container::value_type& tx, m_transactions)
     {
+      // Can not exceed maximum block size
       if (max_total_size < total_size + tx.second.blob_size)
         continue;
 
+      // Check to see if the minimum fee is included;
+      // exclude tx missing minimum fee
+      if (tx.second.fee < DEFAULT_FEE)
+        continue;
+
+      // Skip transactions that are too large
+      // TODO: Correct upper_transactions_size_limit
+      // such that it is based on median block size;
+      // We need to make a similar patch for
+      // wallet2.h
+      if (tx.second.blob_size > upper_transaction_size_limit)
+        continue;
+
+      // If adding this tx will make the block size
+      // greater than 130% of the median, reject the
+      // tx; this will keep down largely punitive tx
+      // from being included
+      if ( (total_size + tx.second.blob_size) > ((130 * median_size) / 100) )
+        continue;
+
+      // If we've exceeded the penalty free size,
+      // stop including more tx
+      if (total_size > median_size)
+        break;      
+
+      // Skip transactions that are not ready to be
+      // included into the blockchain or that are
+      // missing key images
       if (!is_transaction_ready_to_go(tx.second) || have_key_images(k_images, tx.second.tx))
         continue;
 
diff --git a/src/cryptonote_core/tx_pool.h b/src/cryptonote_core/tx_pool.h
index 3978dfb96..26d273aa7 100644
--- a/src/cryptonote_core/tx_pool.h
+++ b/src/cryptonote_core/tx_pool.h
@@ -4,8 +4,6 @@
 
 #pragma once
 #include "include_base_utils.h"
-using namespace epee;
-
 
 #include <set>
 #include <unordered_map>
diff --git a/src/cryptonote_protocol/cryptonote_protocol_handler.h b/src/cryptonote_protocol/cryptonote_protocol_handler.h
index 178ec2eb1..80538677c 100644
--- a/src/cryptonote_protocol/cryptonote_protocol_handler.h
+++ b/src/cryptonote_protocol/cryptonote_protocol_handler.h
@@ -81,7 +81,7 @@ namespace cryptonote
     template<class t_parametr>
       bool post_notify(typename t_parametr::request& arg, cryptonote_connection_context& context)
       {
-        LOG_PRINT_L2("[" << net_utils::print_connection_context_short(context) << "] post " << typeid(t_parametr).name() << " -->");
+        LOG_PRINT_L2("[" << epee::net_utils::print_connection_context_short(context) << "] post " << typeid(t_parametr).name() << " -->");
         std::string blob;
         epee::serialization::store_t_to_binary(arg, blob);
         return m_p2p->invoke_notify_to_peer(t_parametr::ID, blob, context);
@@ -90,7 +90,7 @@ namespace cryptonote
       template<class t_parametr>
       bool relay_post_notify(typename t_parametr::request& arg, cryptonote_connection_context& exlude_context)
       {
-        LOG_PRINT_L2("[" << net_utils::print_connection_context_short(exlude_context) << "] post relay " << typeid(t_parametr).name() << " -->");
+        LOG_PRINT_L2("[" << epee::net_utils::print_connection_context_short(exlude_context) << "] post relay " << typeid(t_parametr).name() << " -->");
         std::string arg_buff;
         epee::serialization::store_t_to_binary(arg, arg_buff);
         return m_p2p->relay_notify_to_all(t_parametr::ID, arg_buff, exlude_context);
diff --git a/src/cryptonote_protocol/cryptonote_protocol_handler.inl b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
index a0838e690..2584f1097 100644
--- a/src/cryptonote_protocol/cryptonote_protocol_handler.inl
+++ b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
@@ -81,7 +81,7 @@ namespace cryptonote
     m_p2p->for_each_connection([&](const connection_context& cntxt, nodetool::peerid_type peer_id)
     {
       ss << std::setw(25) << std::left << std::string(cntxt.m_is_income ? " [INC]":"[OUT]") + 
-        string_tools::get_ip_string_from_int32(cntxt.m_remote_ip) + ":" + std::to_string(cntxt.m_remote_port) 
+        epee::string_tools::get_ip_string_from_int32(cntxt.m_remote_ip) + ":" + std::to_string(cntxt.m_remote_port) 
         << std::setw(20) << std::hex << peer_id
         << std::setw(25) << std::to_string(cntxt.m_recv_cnt)+ "(" + std::to_string(time(NULL) - cntxt.m_last_recv) + ")" + "/" + std::to_string(cntxt.m_send_cnt) + "(" + std::to_string(time(NULL) - cntxt.m_last_send) + ")"
         << std::setw(25) << get_protocol_state_string(cntxt.m_state)
@@ -108,9 +108,12 @@ namespace cryptonote
       return true;
     }
 
-    LOG_PRINT_CCONTEXT_YELLOW("Sync data returned unknown top block: " << m_core.get_current_blockchain_height() << "->" << hshd.current_height 
-      << "[" << static_cast<int64_t>(hshd.current_height - m_core.get_current_blockchain_height()) << " blocks(" << (hshd.current_height - m_core.get_current_blockchain_height()) /1440 << " days) behind] " << ENDL 
-      << "remote top: "  << hshd.top_id << "[" << hshd.current_height << "]" << ", set SYNCHRONIZATION mode", (is_inital ? LOG_LEVEL_0:LOG_LEVEL_1));
+    int64_t diff = static_cast<int64_t>(hshd.current_height) - static_cast<int64_t>(m_core.get_current_blockchain_height());
+    LOG_PRINT_CCONTEXT_YELLOW("Sync data returned unknown top block: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height
+      << " [" << std::abs(diff) << " blocks (" << diff / (24 * 60 * 60 / DIFFICULTY_TARGET) << " days) "
+      << (0 <= diff ? std::string("behind") : std::string("ahead"))
+      << "] " << ENDL << "SYNCHRONIZATION started", (is_inital ? LOG_LEVEL_0:LOG_LEVEL_1));
+    LOG_PRINT_L1("Remote top block height: " << hshd.current_height << ", id: " << hshd.top_id);
     context.m_state = cryptonote_connection_context::state_synchronizing;
     context.m_remote_blockchain_height = hshd.current_height;
     //let the socket to send response to handshake, but request callback, to let send request data after response
@@ -254,7 +257,7 @@ namespace cryptonote
       if(!parse_and_validate_block_from_blob(block_entry.block, b))
       {
         LOG_ERROR_CCONTEXT("sent wrong block: failed to parse and validate block: \r\n" 
-          << string_tools::buff_to_hex_nodelimer(block_entry.block) << "\r\n dropping connection");
+          << epee::string_tools::buff_to_hex_nodelimer(block_entry.block) << "\r\n dropping connection");
         m_p2p->drop_connection(context);
         return 1;
       }      
@@ -274,14 +277,14 @@ namespace cryptonote
       auto req_it = context.m_requested_objects.find(get_block_hash(b));
       if(req_it == context.m_requested_objects.end())
       {
-        LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << string_tools::pod_to_hex(get_blob_hash(block_entry.block)) 
+        LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block)) 
           << " wasn't requested, dropping connection");
         m_p2p->drop_connection(context);
         return 1;
       }
       if(b.tx_hashes.size() != block_entry.txs.size()) 
       {
-        LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << string_tools::pod_to_hex(get_blob_hash(block_entry.block)) 
+        LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block)) 
           << ", tx_hashes.size()=" << b.tx_hashes.size() << " mismatch with block_complete_entry.m_txs.size()=" << block_entry.txs.size() << ", dropping connection");
         m_p2p->drop_connection(context);
         return 1;
@@ -300,7 +303,7 @@ namespace cryptonote
 
     {
       m_core.pause_mine();
-      misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
+      epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler(
         boost::bind(&t_core::resume_mine, &m_core));
 
       BOOST_FOREACH(const block_complete_entry& block_entry, arg.blocks)
@@ -314,7 +317,7 @@ namespace cryptonote
           if(tvc.m_verifivation_failed)
           {
             LOG_ERROR_CCONTEXT("transaction verification failed on NOTIFY_RESPONSE_GET_OBJECTS, \r\ntx_id = " 
-              << string_tools::pod_to_hex(get_blob_hash(tx_blob)) << ", dropping connection");
+              << epee::string_tools::pod_to_hex(get_blob_hash(tx_blob)) << ", dropping connection");
             m_p2p->drop_connection(context);
             return 1;
           }
@@ -408,7 +411,7 @@ namespace cryptonote
                            << "\r\nm_remote_blockchain_height=" << context.m_remote_blockchain_height
                            << "\r\nm_needed_objects.size()=" << context.m_needed_objects.size()
                            << "\r\nm_requested_objects.size()=" << context.m_requested_objects.size()
-                           << "\r\non connection [" << net_utils::print_connection_context_short(context)<< "]");
+                           << "\r\non connection [" << epee::net_utils::print_connection_context_short(context)<< "]");
       
       context.m_state = cryptonote_connection_context::state_normal;
       LOG_PRINT_CCONTEXT_GREEN(" SYNCHRONIZED OK", LOG_LEVEL_0);
@@ -464,7 +467,7 @@ namespace cryptonote
     if(!m_core.have_block(arg.m_block_ids.front()))
     {
       LOG_ERROR_CCONTEXT("sent m_block_ids starting from unknown id: "
-                                              << string_tools::pod_to_hex(arg.m_block_ids.front()) << " , dropping connection");
+                                              << epee::string_tools::pod_to_hex(arg.m_block_ids.front()) << " , dropping connection");
       m_p2p->drop_connection(context);
       return 1;
     }
diff --git a/src/daemon/daemon_commands_handler.h b/src/daemon/daemon_commands_handler.h
index 74b671e2a..135ec68f8 100644
--- a/src/daemon/daemon_commands_handler.h
+++ b/src/daemon/daemon_commands_handler.h
@@ -11,6 +11,7 @@
 #include "cryptonote_protocol/cryptonote_protocol_handler.h"
 #include "common/util.h"
 #include "crypto/hash.h"
+#include "version.h"
 
 
 class daemon_cmmands_handler
@@ -34,6 +35,7 @@ public:
     m_cmd_binder.set_handler("show_hr", boost::bind(&daemon_cmmands_handler::show_hr, this, _1), "Start showing hash rate");
     m_cmd_binder.set_handler("hide_hr", boost::bind(&daemon_cmmands_handler::hide_hr, this, _1), "Stop showing hash rate");
     m_cmd_binder.set_handler("save", boost::bind(&daemon_cmmands_handler::save, this, _1), "Save blockchain");
+    m_cmd_binder.set_handler("set_log", boost::bind(&daemon_cmmands_handler::set_log, this, _1), "set_log <level> - Change current log detalization level, <level> is a number 0-4");
     m_cmd_binder.set_handler("diff", boost::bind(&daemon_cmmands_handler::diff, this, _1), "Show difficulty");
   }
 
@@ -55,6 +57,7 @@ private:
   std::string get_commands_str()
   {
     std::stringstream ss;
+    ss << CRYPTONOTE_NAME << " v" << PROJECT_VERSION_LONG << ENDL;
     ss << "Commands: " << ENDL;
     std::string usage = m_cmd_binder.get_usage();
     boost::replace_all(usage, "\n", "\n  ");
@@ -135,19 +138,34 @@ private:
       return false;
     }
     uint64_t start_index = 0;
+    uint64_t end_index = 0;
     uint64_t end_block_parametr = m_srv.get_payload_object().get_core().get_current_blockchain_height();
     if(!string_tools::get_xtype_from_string(start_index, args[0]))
     {
       std::cout << "wrong starter block index parameter" << ENDL;
       return false;
     }
-    if(args.size() >1 && !string_tools::get_xtype_from_string(end_block_parametr, args[1]))
+    if(args.size() >1 && !string_tools::get_xtype_from_string(end_index, args[1]))
     {
       std::cout << "wrong end block index parameter" << ENDL;
       return false;
     }
+    if (end_index == 0)
+    {
+      end_index = end_block_parametr;
+    }
+    if (end_index > end_block_parametr)
+    {
+      std::cout << "end block index parameter shouldn't be greater than " << end_block_parametr << ENDL;
+      return false;
+    }
+    if (end_index <= start_index)
+    {
+      std::cout << "end block index should be greater than starter block index" << ENDL;
+      return false;
+    }
 
-    m_srv.get_payload_object().get_core().print_blockchain(start_index, end_block_parametr);
+    m_srv.get_payload_object().get_core().print_blockchain(start_index, end_index);
     return true;
   }
   //--------------------------------------------------------------------------------
@@ -156,6 +174,33 @@ private:
     m_srv.get_payload_object().get_core().print_blockchain_index();
     return true;
   }
+
+  bool set_log(const std::vector<std::string>& args)
+  {
+    if(args.size() != 1)
+    {
+      std::cout << "use: set_log <log_level_number_0-4>" << ENDL;
+      return true;
+    }
+
+    uint16_t l = 0;
+    if(!string_tools::get_xtype_from_string(l, args[0]))
+    {
+      std::cout << "wrong number format, use: set_log <log_level_number_0-4>" << ENDL;
+      return true;
+    }
+
+    if(LOG_LEVEL_4 < l)
+    {
+      std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << ENDL;
+      return true;
+    }
+
+    log_space::log_singletone::get_set_log_detalisation_level(true, l);
+
+    return true;
+  }
+
   //--------------------------------------------------------------------------------
   template <typename T>
   static bool print_as_json(T& obj)
diff --git a/src/p2p/net_node.h b/src/p2p/net_node.h
index 794b97429..5a03b049f 100644
--- a/src/p2p/net_node.h
+++ b/src/p2p/net_node.h
@@ -24,8 +24,7 @@
 #include "p2p_networks.h"
 #include "math_helper.h"
 #include "net_node_common.h"
-
-using namespace epee;
+#include "common/command_line.h"
 
 PUSH_WARNINGS
 DISABLE_VS_WARNINGS(4355)
@@ -39,7 +38,7 @@ namespace nodetool
   };
 
   template<class t_payload_net_handler>
-  class node_server: public levin::levin_commands_handler<p2p_connection_context_t<typename t_payload_net_handler::connection_context> >,
+  class node_server: public epee::levin::levin_commands_handler<p2p_connection_context_t<typename t_payload_net_handler::connection_context> >,
                      public i_p2p_endpoint<typename t_payload_net_handler::connection_context>
   {
     struct by_conn_id{};
@@ -126,7 +125,7 @@ namespace nodetool
     bool parse_peer_from_string(nodetool::net_address& pe, const std::string& node_addr);
     bool handle_command_line(const boost::program_options::variables_map& vm);
     bool idle_worker();
-    bool handle_remote_peerlist(const std::list<peerlist_entry>& peerlist, time_t local_time, const net_utils::connection_context_base& context);
+    bool handle_remote_peerlist(const std::list<peerlist_entry>& peerlist, time_t local_time, const epee::net_utils::connection_context_base& context);
     bool get_local_node_data(basic_node_data& node_data);
     //bool get_local_handshake_data(handshake_data& hshd);
 
@@ -136,7 +135,7 @@ namespace nodetool
     bool connections_maker();
     bool peer_sync_idle_maker();
     bool do_handshake_with_peer(peerid_type& pi, p2p_connection_context& context, bool just_take_peerlist = false);
-    bool do_peer_timed_sync(const net_utils::connection_context_base& context, peerid_type peer_id);
+    bool do_peer_timed_sync(const epee::net_utils::connection_context_base& context, peerid_type peer_id);
 
     bool make_new_connection_from_peerlist(bool use_white_list);
     bool try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist = false, uint64_t last_seen_stamp = 0, bool white = true);
@@ -146,12 +145,19 @@ namespace nodetool
     template<class t_callback>
     bool try_ping(basic_node_data& node_data, p2p_connection_context& context, t_callback cb);
     bool make_expected_connections_count(bool white_list, size_t expected_connections);
+    bool is_priority_node(const net_address& na);
+
+    template <class Container>
+    bool connect_to_peerlist(const Container& peers);
+
+    template <class Container>
+    bool parse_peers_and_add_to_container(const boost::program_options::variables_map& vm, const command_line::arg_descriptor<std::vector<std::string> > & arg, Container& container);
 
     //debug functions
     std::string print_connections_container();
 
 
-    typedef net_utils::boosted_tcp_server<levin::async_protocol_handler<p2p_connection_context> > net_server;
+    typedef epee::net_utils::boosted_tcp_server<epee::levin::async_protocol_handler<p2p_connection_context> > net_server;
 
     struct config
     {
@@ -181,9 +187,9 @@ namespace nodetool
     t_payload_net_handler& m_payload_handler;
     peerlist_manager m_peerlist;
 
-    math_helper::once_a_time_seconds<P2P_DEFAULT_HANDSHAKE_INTERVAL> m_peer_handshake_idle_maker_interval;
-    math_helper::once_a_time_seconds<1> m_connections_maker_interval;
-    math_helper::once_a_time_seconds<60*30, false> m_peerlist_store_interval;
+    epee::math_helper::once_a_time_seconds<P2P_DEFAULT_HANDSHAKE_INTERVAL> m_peer_handshake_idle_maker_interval;
+    epee::math_helper::once_a_time_seconds<1> m_connections_maker_interval;
+    epee::math_helper::once_a_time_seconds<60*30, false> m_peerlist_store_interval;
 
     std::string m_bind_ip;
     std::string m_port;
@@ -191,6 +197,7 @@ namespace nodetool
     uint64_t m_last_stat_request_time;
 #endif
     std::list<net_address>   m_priority_peers;
+    std::vector<net_address> m_exclusive_peers;
     std::vector<net_address> m_seed_nodes;
     std::list<nodetool::peerlist_entry> m_command_line_peers;
     uint64_t m_peer_livetime;
diff --git a/src/p2p/net_node.inl b/src/p2p/net_node.inl
index 31d3e6597..e45e51b77 100644
--- a/src/p2p/net_node.inl
+++ b/src/p2p/net_node.inl
@@ -4,9 +4,10 @@
 
 #pragma once
 
+#include <algorithm>
+
 #include "version.h"
 #include "string_tools.h"
-#include "common/command_line.h"
 #include "common/util.h"
 #include "net/net_helper.h"
 #include "math_helper.h"
@@ -31,8 +32,11 @@ namespace nodetool
     const command_line::arg_descriptor<bool>        arg_p2p_allow_local_ip = {"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"};
     const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_add_peer   = {"add-peer", "Manually add peer to local peerlist"};
     const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_add_priority_node   = {"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"};
+    const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_add_exclusive_node   = {"add-exclusive-node", "Specify list of peers to connect to only."
+                                                                                                  " If this option is given the options add-priority-node and seed-node are ignored"};
     const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_seed_node   = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"};
-    const command_line::arg_descriptor<bool> arg_p2p_hide_my_port   =    {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};  }
+    const command_line::arg_descriptor<bool> arg_p2p_hide_my_port   =    {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};
+  }
 
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
@@ -44,6 +48,7 @@ namespace nodetool
     command_line::add_arg(desc, arg_p2p_allow_local_ip);
     command_line::add_arg(desc, arg_p2p_add_peer);
     command_line::add_arg(desc, arg_p2p_add_priority_node);
+    command_line::add_arg(desc, arg_p2p_add_exclusive_node);
     command_line::add_arg(desc, arg_p2p_seed_node);    
     command_line::add_arg(desc, arg_p2p_hide_my_port);   }
   //-----------------------------------------------------------------------------------
@@ -96,7 +101,7 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::parse_peer_from_string(nodetool::net_address& pe, const std::string& node_addr)
   {
-    return string_tools::parse_peer_from_string(pe.ip, pe.port, node_addr);
+    return epee::string_tools::parse_peer_from_string(pe.ip, pe.port, node_addr);
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
@@ -120,30 +125,26 @@ namespace nodetool
       }
     }
 
-    if (command_line::has_arg(vm, arg_p2p_add_priority_node))
-    {       
-      std::vector<std::string> perrs = command_line::get_arg(vm, arg_p2p_add_priority_node);
-      for(const std::string& pr_str: perrs)
-      {
-        nodetool::net_address na = AUTO_VAL_INIT(na);
-        bool r = parse_peer_from_string(na, pr_str);
-        CHECK_AND_ASSERT_MES(r, false, "Failed to parse address from string: " << pr_str);
-        m_priority_peers.push_back(na);
-      }
+    if (command_line::has_arg(vm,arg_p2p_add_exclusive_node))
+    {
+      if (!parse_peers_and_add_to_container(vm, arg_p2p_add_exclusive_node, m_exclusive_peers))
+        return false;
+    }
+    else if (command_line::has_arg(vm, arg_p2p_add_priority_node))
+    {
+      if (!parse_peers_and_add_to_container(vm, arg_p2p_add_priority_node, m_priority_peers))
+        return false;
     }
     if (command_line::has_arg(vm, arg_p2p_seed_node))
     {
-      std::vector<std::string> seed_perrs = command_line::get_arg(vm, arg_p2p_seed_node);
-      for(const std::string& pr_str: seed_perrs)
-      {
-        nodetool::net_address na = AUTO_VAL_INIT(na);
-        bool r = parse_peer_from_string(na, pr_str);
-        CHECK_AND_ASSERT_MES(r, false, "Failed to parse seed address from string: " << pr_str);
-        m_seed_nodes.push_back(na);
-      }
+      if (!parse_peers_and_add_to_container(vm, arg_p2p_seed_node, m_seed_nodes))
+        return false;
     }
+
     if(command_line::has_arg(vm, arg_p2p_hide_my_port))
-      m_hide_my_port = true;    return true;
+      m_hide_my_port = true;
+
+    return true;
   }
   //-----------------------------------------------------------------------------------
   namespace
@@ -353,23 +354,23 @@ namespace nodetool
     get_local_node_data(arg.node_data);
     m_payload_handler.get_payload_sync_data(arg.payload_data);
     
-    simple_event ev;
+    epee::simple_event ev;
     std::atomic<bool> hsh_result(false);
     
-    bool r = net_utils::async_invoke_remote_command2<typename COMMAND_HANDSHAKE::response>(context_.m_connection_id, COMMAND_HANDSHAKE::ID, arg, m_net_server.get_config_object(), 
+    bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_HANDSHAKE::response>(context_.m_connection_id, COMMAND_HANDSHAKE::ID, arg, m_net_server.get_config_object(), 
       [this, &pi, &ev, &hsh_result, &just_take_peerlist](int code, const typename COMMAND_HANDSHAKE::response& rsp, p2p_connection_context& context)
     {
-      misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler([&](){ev.raise();});
+      epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ev.raise();});
 
       if(code < 0)
       {
-        LOG_PRINT_CC_RED(context, "COMMAND_HANDSHAKE invoke failed. (" << code <<  ", " << levin::get_err_descr(code) << ")", LOG_LEVEL_1);
+        LOG_PRINT_CC_RED(context, "COMMAND_HANDSHAKE invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
         return;
       }
 
       if(rsp.node_data.network_id != BYTECOIN_NETWORK)
       {
-        LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE Failed, wrong network!  (" << string_tools::get_str_from_guid_a(rsp.node_data.network_id) << "), closing connection.");
+        LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE Failed, wrong network!  (" << epee::string_tools::get_str_from_guid_a(rsp.node_data.network_id) << "), closing connection.");
         return;
       }
 
@@ -397,10 +398,10 @@ namespace nodetool
           hsh_result = false;
           return;
         }
-        LOG_PRINT_CCONTEXT_L0(" COMMAND_HANDSHAKE INVOKED OK");
+        LOG_PRINT_CCONTEXT_L1(" COMMAND_HANDSHAKE INVOKED OK");
       }else
       {
-        LOG_PRINT_CCONTEXT_L0(" COMMAND_HANDSHAKE(AND CLOSE) INVOKED OK");
+        LOG_PRINT_CCONTEXT_L1(" COMMAND_HANDSHAKE(AND CLOSE) INVOKED OK");
       }
     }, P2P_DEFAULT_HANDSHAKE_INVOKE_TIMEOUT);
 
@@ -411,7 +412,7 @@ namespace nodetool
 
     if(!hsh_result)
     {
-      LOG_PRINT_CC_L0(context_, "COMMAND_HANDSHAKE Failed");
+      LOG_PRINT_CC_L1(context_, "COMMAND_HANDSHAKE Failed");
       m_net_server.get_config_object().close(context_.m_connection_id);
     }
 
@@ -419,17 +420,17 @@ namespace nodetool
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
-  bool node_server<t_payload_net_handler>::do_peer_timed_sync(const net_utils::connection_context_base& context_, peerid_type peer_id)
+  bool node_server<t_payload_net_handler>::do_peer_timed_sync(const epee::net_utils::connection_context_base& context_, peerid_type peer_id)
   {
     typename COMMAND_TIMED_SYNC::request arg = AUTO_VAL_INIT(arg);
     m_payload_handler.get_payload_sync_data(arg.payload_data);
 
-    bool r = net_utils::async_invoke_remote_command2<typename COMMAND_TIMED_SYNC::response>(context_.m_connection_id, COMMAND_TIMED_SYNC::ID, arg, m_net_server.get_config_object(), 
+    bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_TIMED_SYNC::response>(context_.m_connection_id, COMMAND_TIMED_SYNC::ID, arg, m_net_server.get_config_object(), 
       [this](int code, const typename COMMAND_TIMED_SYNC::response& rsp, p2p_connection_context& context)
     {
       if(code < 0)
       {
-        LOG_PRINT_CC_RED(context, "COMMAND_TIMED_SYNC invoke failed. (" << code <<  ", " << levin::get_err_descr(code) << ")", LOG_LEVEL_1);
+        LOG_PRINT_CC_RED(context, "COMMAND_TIMED_SYNC invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
         return;
       }
 
@@ -502,36 +503,53 @@ namespace nodetool
     return connected;
   }
 
-  //-----------------------------------------------------------------------------------
+#define LOG_PRINT_CC_PRIORITY_NODE(priority, con, msg) \
+  do { \
+    if (priority) {\
+      LOG_PRINT_CC_L0(con, msg); \
+    } else {\
+      LOG_PRINT_CC_L1(con, msg); \
+    } \
+  } while(0)
+
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist, uint64_t last_seen_stamp, bool white)
   {
-    LOG_PRINT_L0("Connecting to " << string_tools::get_ip_string_from_int32(na.ip)  << ":" << string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: " << (last_seen_stamp?misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never" ) << ")...");
+    LOG_PRINT_L1("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip)  << ":"
+        << epee::string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: "
+        << (last_seen_stamp ? epee::misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never")
+        << ")...");
 
     typename net_server::t_connection_context con = AUTO_VAL_INIT(con);
-    bool res = m_net_server.connect(string_tools::get_ip_string_from_int32(na.ip),
-      string_tools::num_to_string_fast(na.port),
+    bool res = m_net_server.connect(epee::string_tools::get_ip_string_from_int32(na.ip),
+      epee::string_tools::num_to_string_fast(na.port),
       m_config.m_net_config.connection_timeout,
       con);
+
     if(!res)
     {
-      LOG_PRINT_L0("Connect failed to "
-        << string_tools::get_ip_string_from_int32(na.ip)
-        << ":" << string_tools::num_to_string_fast(na.port)
+      bool is_priority = is_priority_node(na);
+      LOG_PRINT_CC_PRIORITY_NODE(is_priority, con, "Connect failed to "
+        << epee::string_tools::get_ip_string_from_int32(na.ip)
+        << ":" << epee::string_tools::num_to_string_fast(na.port)
         /*<< ", try " << try_count*/);
       //m_peerlist.set_peer_unreachable(pe);
       return false;
     }
+
     peerid_type pi = AUTO_VAL_INIT(pi);
     res = do_handshake_with_peer(pi, con, just_take_peerlist);
+
     if(!res)
     {
-      LOG_PRINT_CC_L0(con, "Failed to HANDSHAKE with peer "
-        << string_tools::get_ip_string_from_int32(na.ip)
-        << ":" << string_tools::num_to_string_fast(na.port)
+      bool is_priority = is_priority_node(na);
+      LOG_PRINT_CC_PRIORITY_NODE(is_priority, con, "Failed to HANDSHAKE with peer "
+        << epee::string_tools::get_ip_string_from_int32(na.ip)
+        << ":" << epee::string_tools::num_to_string_fast(na.port)
         /*<< ", try " << try_count*/);
       return false;
     }
+
     if(just_take_peerlist)
     {
       m_net_server.get_config_object().close(con.m_connection_id);
@@ -549,6 +567,9 @@ namespace nodetool
     LOG_PRINT_CC_GREEN(con, "CONNECTION HANDSHAKED OK.", LOG_LEVEL_2);
     return true;
   }
+
+#undef LOG_PRINT_CC_PRIORITY_NODE
+
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::make_new_connection_from_peerlist(bool use_white_list)
@@ -582,7 +603,10 @@ namespace nodetool
       if(is_peer_used(pe))
         continue;
 
-      LOG_PRINT_L1("Selected peer: " << pe.id << " " << string_tools::get_ip_string_from_int32(pe.adr.ip) << ":" << boost::lexical_cast<std::string>(pe.adr.port) << "[white=" << use_white_list << "] last_seen: " << (pe.last_seen ? misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
+      LOG_PRINT_L1("Selected peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip)
+                    << ":" << boost::lexical_cast<std::string>(pe.adr.port)
+                    << "[white=" << use_white_list
+                    << "] last_seen: " << (pe.last_seen ? epee::misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
       
       if(!try_to_connect_and_handshake_with_new_peer(pe.adr, false, pe.last_seen, use_white_list))
         continue;
@@ -595,6 +619,10 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::connections_maker()
   {
+    if (!connect_to_peerlist(m_exclusive_peers)) return false;
+
+    if (!m_exclusive_peers.empty()) return true;
+
     if(!m_peerlist.get_white_peers_count() && m_seed_nodes.size())
     {
       size_t try_count = 0;
@@ -616,15 +644,7 @@ namespace nodetool
       }
     }
 
-    for(const net_address& na: m_priority_peers)
-    {
-      if(m_net_server.is_stop_signal_sent())
-        return false;
-
-      if(is_addr_connected(na))
-        continue;
-      try_to_connect_and_handshake_with_new_peer(na);
-    }
+    if (!connect_to_peerlist(m_priority_peers)) return false;
 
     size_t expected_white_connections = (m_config.m_net_config.connections_count*P2P_DEFAULT_WHITELIST_CONNECTIONS_PERCENT)/100;
 
@@ -698,7 +718,7 @@ namespace nodetool
   bool node_server<t_payload_net_handler>::peer_sync_idle_maker()
   {
     LOG_PRINT_L2("STARTED PEERLIST IDLE HANDSHAKE");
-    typedef std::list<std::pair<net_utils::connection_context_base, peerid_type> > local_connects_type;
+    typedef std::list<std::pair<epee::net_utils::connection_context_base, peerid_type> > local_connects_type;
     local_connects_type cncts;
     m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
     {
@@ -725,7 +745,7 @@ namespace nodetool
     {
       if(be.last_seen > local_time)
       {
-        LOG_PRINT_RED_L0("FOUND FUTURE peerlist for entry " << string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time);
+        LOG_PRINT_RED_L0("FOUND FUTURE peerlist for entry " << epee::string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time);
         return false;
       }
       be.last_seen += delta;
@@ -734,7 +754,7 @@ namespace nodetool
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
-  bool node_server<t_payload_net_handler>::handle_remote_peerlist(const std::list<peerlist_entry>& peerlist, time_t local_time, const net_utils::connection_context_base& context)
+  bool node_server<t_payload_net_handler>::handle_remote_peerlist(const std::list<peerlist_entry>& peerlist, time_t local_time, const epee::net_utils::connection_context_base& context)
   {
     int64_t delta = 0;
     std::list<peerlist_entry> peerlist_ = peerlist;
@@ -782,7 +802,7 @@ namespace nodetool
       return false;
     }
     crypto::public_key pk = AUTO_VAL_INIT(pk);
-    string_tools::hex_to_pod(P2P_STAT_TRUSTED_PUB_KEY, pk);
+    epee::string_tools::hex_to_pod(P2P_STAT_TRUSTED_PUB_KEY, pk);
     crypto::hash h = tools::get_proof_of_trust_hash(tr);
     if(!crypto::check_signature(h, pk, tr.sign))
     {
@@ -903,8 +923,8 @@ namespace nodetool
     uint32_t actual_ip =  context.m_remote_ip;
     if(!m_peerlist.is_ip_allowed(actual_ip))
       return false;
-    std::string ip = string_tools::get_ip_string_from_int32(actual_ip);
-    std::string port = string_tools::num_to_string_fast(node_data.my_port);
+    std::string ip = epee::string_tools::get_ip_string_from_int32(actual_ip);
+    std::string port = epee::string_tools::num_to_string_fast(node_data.my_port);
     peerid_type pr = node_data.peer_id;
     bool r = m_net_server.connect_async(ip, port, m_config.m_net_config.ping_connection_timeout, [cb, /*context,*/ ip, port, pr, this](
       const typename net_server::t_connection_context& ping_context,
@@ -922,12 +942,12 @@ namespace nodetool
       std::string port_=port;
       peerid_type pr_ = pr;
       auto cb_ = cb;*/
-      bool inv_call_res = net_utils::async_invoke_remote_command2<COMMAND_PING::response>(ping_context.m_connection_id, COMMAND_PING::ID, req, m_net_server.get_config_object(),
+      bool inv_call_res = epee::net_utils::async_invoke_remote_command2<COMMAND_PING::response>(ping_context.m_connection_id, COMMAND_PING::ID, req, m_net_server.get_config_object(),
         [=](int code, const COMMAND_PING::response& rsp, p2p_connection_context& context)
       {
         if(code <= 0)
         {
-          LOG_PRINT_CC_L2(ping_context, "Failed to invoke COMMAND_PING to " << ip << ":" << port << "(" << code <<  ", " << levin::get_err_descr(code) << ")");
+          LOG_PRINT_CC_L2(ping_context, "Failed to invoke COMMAND_PING to " << ip << ":" << port << "(" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
           return;
         }
 
@@ -979,7 +999,7 @@ namespace nodetool
     if(arg.node_data.network_id != BYTECOIN_NETWORK)
     {
 
-      LOG_PRINT_CCONTEXT_L0("WRONG NETWORK AGENT CONNECTED! id=" << string_tools::get_str_from_guid_a(arg.node_data.network_id));
+      LOG_PRINT_CCONTEXT_L0("WRONG NETWORK AGENT CONNECTED! id=" << epee::string_tools::get_str_from_guid_a(arg.node_data.network_id));
       drop_connection(context);
       return 1;
     }
@@ -1021,7 +1041,7 @@ namespace nodetool
         time(&pe.last_seen);
         pe.id = peer_id_l;
         this->m_peerlist.append_with_peer_white(pe);
-        LOG_PRINT_CCONTEXT_L2("PING SUCCESS " << string_tools::get_ip_string_from_int32(context.m_remote_ip) << ":" << port_l);
+        LOG_PRINT_CCONTEXT_L2("PING SUCCESS " << epee::string_tools::get_ip_string_from_int32(context.m_remote_ip) << ":" << port_l);
       });
     }
 
@@ -1066,9 +1086,9 @@ namespace nodetool
     std::stringstream ss;
     m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
     {
-      ss << string_tools::get_ip_string_from_int32(cntxt.m_remote_ip) << ":" << cntxt.m_remote_port
+      ss << epee::string_tools::get_ip_string_from_int32(cntxt.m_remote_ip) << ":" << cntxt.m_remote_port
         << " \t\tpeer_id " << cntxt.peer_id
-        << " \t\tconn_id " << string_tools::get_str_from_guid_a(cntxt.m_connection_id) << (cntxt.m_is_income ? " INC":" OUT")
+        << " \t\tconn_id " << epee::string_tools::get_str_from_guid_a(cntxt.m_connection_id) << (cntxt.m_is_income ? " INC":" OUT")
         << std::endl;
       return true;
     });
@@ -1079,13 +1099,51 @@ namespace nodetool
   template<class t_payload_net_handler>
   void node_server<t_payload_net_handler>::on_connection_new(p2p_connection_context& context)
   {
-    LOG_PRINT_L2("["<< net_utils::print_connection_context(context) << "] NEW CONNECTION");
+    LOG_PRINT_L2("["<< epee::net_utils::print_connection_context(context) << "] NEW CONNECTION");
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
   void node_server<t_payload_net_handler>::on_connection_close(p2p_connection_context& context)
   {
-    LOG_PRINT_L2("["<< net_utils::print_connection_context(context) << "] CLOSE CONNECTION");
+    LOG_PRINT_L2("["<< epee::net_utils::print_connection_context(context) << "] CLOSE CONNECTION");
+  }
+
+  template<class t_payload_net_handler>
+  bool node_server<t_payload_net_handler>::is_priority_node(const net_address& na)
+  {
+    return (std::find(m_priority_peers.begin(), m_priority_peers.end(), na) != m_priority_peers.end()) || (std::find(m_exclusive_peers.begin(), m_exclusive_peers.end(), na) != m_exclusive_peers.end());
+  }
+
+  template<class t_payload_net_handler> template <class Container>
+  bool node_server<t_payload_net_handler>::connect_to_peerlist(const Container& peers)
+  {
+    for(const net_address& na: peers)
+    {
+      if(m_net_server.is_stop_signal_sent())
+        return false;
+
+      if(is_addr_connected(na))
+        continue;
+
+      try_to_connect_and_handshake_with_new_peer(na);
+    }
+
+    return true;
+  }
+
+  template<class t_payload_net_handler> template <class Container>
+  bool node_server<t_payload_net_handler>::parse_peers_and_add_to_container(const boost::program_options::variables_map& vm, const command_line::arg_descriptor<std::vector<std::string> > & arg, Container& container)
+  {
+    std::vector<std::string> perrs = command_line::get_arg(vm, arg);
+
+    for(const std::string& pr_str: perrs)
+    {
+      nodetool::net_address na = AUTO_VAL_INIT(na);
+      bool r = parse_peer_from_string(na, pr_str);
+      CHECK_AND_ASSERT_MES(r, false, "Failed to parse address from string: " << pr_str);
+      container.push_back(na);
+    }
+
+    return true;
   }
-  //-----------------------------------------------------------------------------------
 }
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 2c4e82085..8779f73d8 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -395,7 +395,7 @@ namespace cryptonote
       return false;
     }
     res.blocktemplate_blob = string_tools::buff_to_hex_nodelimer(block_blob);
-
+    res.status = CORE_RPC_STATUS_OK;
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
@@ -423,7 +423,7 @@ namespace cryptonote
       error_resp.message = "Block not accepted";
       return false;
     }
-    res.status = "OK";
+    res.status = CORE_RPC_STATUS_OK;
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
diff --git a/src/serialization/crypto.h b/src/serialization/crypto.h
index 89d3c9885..b7763ffeb 100644
--- a/src/serialization/crypto.h
+++ b/src/serialization/crypto.h
@@ -2,6 +2,8 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <vector>
+
 #include "serialization.h"
 #include "debug_archive.h"
 #include "crypto/chacha8.h"
diff --git a/src/serialization/serialization.h b/src/serialization/serialization.h
index 2e69ea0a3..7024fdc03 100644
--- a/src/serialization/serialization.h
+++ b/src/serialization/serialization.h
@@ -10,6 +10,7 @@
 #include <vector>
 #include <string>
 #include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 
 template <class T>
 struct is_blob_type { typedef boost::false_type type; };
@@ -79,8 +80,10 @@ inline bool do_serialize(Archive &ar, T &v)
     if (!r || !ar.stream().good()) return false; \
   } while(0);
 #define FIELDS(f) \
+  do { \
     bool r = ::do_serialize(ar, f); \
-    if (!r || !ar.stream().good()) return false;
+    if (!r || !ar.stream().good()) return false; \
+  } while(0);
 #define FIELD(f) \
   do { \
     ar.tag(#f); \
@@ -99,6 +102,7 @@ inline bool do_serialize(Archive &ar, T &v)
     ar.serialize_varint(f); \
     if (!ar.stream().good()) return false; \
   } while(0);
+
 namespace serialization {
   namespace detail
   {
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index cc10de5cd..9053dde1f 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -202,7 +202,7 @@ bool simple_wallet::set_log(const std::vector<std::string> &args)
     return true;
   }
   uint16_t l = 0;
-  if(!string_tools::get_xtype_from_string(l, args[0]))
+  if(!epee::string_tools::get_xtype_from_string(l, args[0]))
   {
     fail_msg_writer() << "wrong number format, use: set_log <log_level_number_0-4>";
     return true;
@@ -229,8 +229,8 @@ bool simple_wallet::ask_wallet_create_if_needed()
   wallet_path = string_tools::trim(wallet_path);
 
   bool keys_file_exists;
-  bool wallet_file_exitst;
-  tools::wallet2::wallet_exists(wallet_path, keys_file_exists, wallet_file_exitst);
+  bool wallet_file_exists;
+  tools::wallet2::wallet_exists(wallet_path, keys_file_exists, wallet_file_exists);
 
   bool r;
   if(keys_file_exists)
@@ -239,7 +239,7 @@ bool simple_wallet::ask_wallet_create_if_needed()
     r = true;
   }else
   {
-    if(!wallet_file_exitst)
+    if(!wallet_file_exists)
     {
       std::cout << "The wallet doesn't exist, generating new one" << std::endl;
       m_generate_new = wallet_path;
@@ -749,7 +749,7 @@ bool simple_wallet::transfer(const std::vector<std::string> &args_)
   }
 
   size_t fake_outs_count;
-  if(!string_tools::get_xtype_from_string(fake_outs_count, local_args[0]))
+  if(!epee::string_tools::get_xtype_from_string(fake_outs_count, local_args[0]))
   {
     fail_msg_writer() << "mixin_count should be non-negative integer, got " << local_args[0];
     return true;
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 3aa0789ae..3dcaaeaa0 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -132,7 +132,7 @@ namespace cryptonote
     epee::console_handlers_binder m_cmd_binder;
 
     std::unique_ptr<tools::wallet2> m_wallet;
-    net_utils::http::http_simple_client m_http_client;
+    epee::net_utils::http::http_simple_client m_http_client;
     refresh_progress_reporter_t m_refresh_progress_reporter;
   };
 }
diff --git a/src/version.h.in b/src/version.h.in
index 01d2994f8..f171a8e6b 100644
--- a/src/version.h.in
+++ b/src/version.h.in
@@ -1,4 +1,4 @@
 #define BUILD_COMMIT_ID "@VERSION@"
-#define PROJECT_VERSION "0.8.8.2"
+#define PROJECT_VERSION "0.8.8"
 #define PROJECT_VERSION_BUILD_NO "1"
 #define PROJECT_VERSION_LONG PROJECT_VERSION "." PROJECT_VERSION_BUILD_NO "(" BUILD_COMMIT_ID ")"
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index e8d67eec2..111b76117 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -455,14 +455,14 @@ void wallet2::generate(const std::string& wallet_, const std::string& password)
   store();
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exitst)
+void wallet2::wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exists)
 {
   std::string keys_file, wallet_file;
   do_prepare_file_names(file_path, keys_file, wallet_file);
 
   boost::system::error_code ignore;
   keys_file_exists = boost::filesystem::exists(keys_file, ignore);
-  wallet_file_exitst = boost::filesystem::exists(wallet_file, ignore);
+  wallet_file_exists = boost::filesystem::exists(wallet_file, ignore);
 }
 //----------------------------------------------------------------------------------------------------
 bool wallet2::prepare_file_names(const std::string& file_path)
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index edbf31f2d..f90fc4fac 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -102,7 +102,12 @@ namespace tools
     void store();
     cryptonote::account_base& get_account(){return m_account;}
 
-    void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE*2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
+    // upper_transaction_size_limit as defined below is set to 
+    // approximately 125% of the fixed minimum allowable penalty
+    // free block size. TODO: fix this so that it actually takes
+    // into account the current median block size rather than
+    // the minimum block size.
+    void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = ((CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE * 125) / 100) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
     bool deinit();
 
     void stop() { m_run.store(false, std::memory_order_relaxed); }
@@ -144,7 +149,7 @@ namespace tools
       a & m_payments;
     }
 
-    static void wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exitst);
+    static void wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exists);
 
   private:
     bool store_keys(const std::string& keys_file_name, const std::string& password);
@@ -326,7 +331,7 @@ namespace tools
         req.amounts.push_back(it->amount());
       }
 
-      bool r = net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/getrandom_outs.bin", req, daemon_resp, m_http_client, 200000);
+      bool r = epee::net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/getrandom_outs.bin", req, daemon_resp, m_http_client, 200000);
       THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "getrandom_outs.bin");
       THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getrandom_outs.bin");
       THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::get_random_outs_error, daemon_resp.status);
@@ -421,7 +426,7 @@ namespace tools
     COMMAND_RPC_SEND_RAW_TX::request req;
     req.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx));
     COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
-    r = net_utils::invoke_http_json_remote_command2(m_daemon_address + "/sendrawtransaction", req, daemon_send_resp, m_http_client, 200000);
+    r = epee::net_utils::invoke_http_json_remote_command2(m_daemon_address + "/sendrawtransaction", req, daemon_send_resp, m_http_client, 200000);
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "sendrawtransaction");
     THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "sendrawtransaction");
     THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status != CORE_RPC_STATUS_OK, error::tx_rejected, tx, daemon_send_resp.status);