From a5253e2fb4ca06e02209dc41c3bd9528d20bab57 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Tue, 9 Oct 2018 15:30:06 +0300
Subject: [PATCH 01/54] update checkpoints

---
 src/blocks/checkpoints.dat         | Bin 6340 -> 6820 bytes
 src/checkpoints/checkpoints.cpp    |   5 ++++-
 src/cryptonote_core/blockchain.cpp |   2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index 200a572dd78864b44abc3c3422edea4f120a47ed..fce6c1d4d2ad26993cf781f68309b521643ee9b3 100644
GIT binary patch
delta 494
zcmV<K0TKShF{CvC)v*D?7=Lq4CC#vsvw-E;Ck%uST*>z*AeFZ?t-47>0Uo=V-+{01
zc9ySUie76^6Q=Ft{H5m$^)u@htT!@bFE#f}?3x1V^ujZH9TTrqRtOsqx<*nn&1C(Y
zCX{hT-gYDfV1R{tLjBj><cFvp9&<m~JGe3d-)a7v<<yaC*2g?E@qdK!v_v96m-g-2
z3+A<I+qT_09;t+BK3_a(66`o+BUotafKh81g5A#z{a8cm_R_T0u%8Y=Vi+ub*{swr
zcdA;@uKr)oL9V(WzrwtOd;PGTu-e$|FkPY2QTcGHnmkK7@czkGA>Qp5t%kUVa3JTO
z9(hXhy+k|jD`m1<5`Uef4b}JI-r~KC@NzXL-KB>s{|^&QQENeZWPE?gw^DU<oq=<X
zjtRs*e<ZO9DJ5(bn;O4_nzqhTzczJLZ`pw4ucXxebOFD{5fQ|Rn$rj8PL;NIkmQ89
zDd(WcC=ugX@p$OSeP&OSRyT^9vJV)>_peqxsFC#6;^U2#RAbow3qj*qeyW*Dcb(FQ
zCooy=>??<|M1r{1AxD{r|AlB1^jQeWz}{&oGdZ4|=O-6=cU`!fdm=2@Y9y6im93(v
kWh5FxKqgMz7mEpwI&L72je;Vw6*|YYHD{ECDN4yvW-ovGRR910

delta 10
RcmZ2tdc=_N*ha>~5&#$v1S0?d

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 16fa39384..1fb98f0a3 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -185,7 +185,10 @@ namespace cryptonote
       ADD_CHECKPOINT(20000,  "52cc7edcb49eb02f28a653b824089a726f4050eb210263ee6f4180d388a1e5cc");
       ADD_CHECKPOINT(30000,  "d22fde5dd240ade16d3250eb0aa5d1c16dc7cb51c20484e05eb274911032b3fa");
       ADD_CHECKPOINT(40000,  "aee0d642322542ba069cb1c58ab2acd3560f108d4682c3dc3cb15a54d442d91f");
-      ADD_CHECKPOINT(50000,  "5286ac2a0f39b3aefcba363cd71f2760bd1e0d763cbc81026ebdc3f80a86541f");      
+      ADD_CHECKPOINT(50000,  "5286ac2a0f39b3aefcba363cd71f2760bd1e0d763cbc81026ebdc3f80a86541f");
+      ADD_CHECKPOINT(53666,  "3f43f56f66ef0c43cf2fd14d0d28fa2aae0ef8f40716773511345750770f1255"); //Hard fork to v9
+      ADD_CHECKPOINT(54500,  "8ed3078b389c2b44add007803d741b58d3fbed2e1ba4139bda702152d8773c9b");
+
       return true;
   }
 
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 08255d394..d762d3dfb 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4441,7 +4441,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "16cb7e839284c1910925f8d9f8a752f38ad908ae9deec7afdfbbc4a777f5ef2e";
+static const char expected_block_hashes_hash[] = "e8255f4188ddb613df2953d8ae2ed509223e432290368b0eef062f8c12da9f70";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;

From cbf07f01ba19baf783886baa23e671da1468557c Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 17 Oct 2018 01:14:39 +0300
Subject: [PATCH 02/54] encourage use of subaddresses

---
 src/simplewallet/simplewallet.cpp            | 98 +++++---------------
 src/simplewallet/simplewallet.h              |  3 +-
 src/wallet/api/wallet.cpp                    |  8 --
 src/wallet/api/wallet.h                      |  1 -
 src/wallet/api/wallet2_api.h                 | 10 --
 src/wallet/wallet2.cpp                       | 17 ++--
 src/wallet/wallet2.h                         |  7 +-
 src/wallet/wallet_rpc_server.cpp             | 63 -------------
 src/wallet/wallet_rpc_server.h               |  4 -
 src/wallet/wallet_rpc_server_commands_defs.h | 47 ----------
 10 files changed, 35 insertions(+), 223 deletions(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index bf76f3ffa..413277b11 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -1688,13 +1688,13 @@ bool simple_wallet::set_refresh_type(const std::vector<std::string> &args/* = st
   return true;
 }
 
-bool simple_wallet::set_confirm_missing_payment_id(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
+bool simple_wallet::set_confirm_subaddress(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
   const auto pwd_container = get_and_verify_password();
   if (pwd_container)
   {
     parse_bool_and_use(args[1], [&](bool r) {
-      m_wallet->confirm_missing_payment_id(r);
+      m_wallet->confirm_subaddress(r);
       m_wallet->rewrite(m_wallet_file, pwd_container->password());
     });
   }
@@ -1931,10 +1931,10 @@ bool simple_wallet::help(const std::vector<std::string> &args/* = std::vector<st
   "Commands:\n" <<
   tr("  \"balance\" - Show balance.\n") <<
   tr("  \"address\" - Show wallet's address.\n") <<
-  tr("  \"integrated_address\" - Show receiving address with an integrated payment ID.\n") <<
-  tr("  \"transfer [address|integrated_address] [amount]\" - Send WOW to an address.\n") <<
+  tr("  \"address new [optional note]\" - Create new sub-address with optional note, spaces are allowed.\n") <<
+  tr("  \"address all\" - Show all sub-addresses.\n") <<
+  tr("  \"transfer [address] [amount]\" - Send WOW to an address.\n") <<
   tr("  \"show_transfers [in|out|pending|failed|pool]\" - Show transactions.\n") <<
-  tr("  \"payments [payment ID]\" - Show transaction of a given payment ID.\n") <<
   tr("  \"sweep_all [address]\" - Send whole balance to another wallet.\n") <<
   tr("  \"seed\" - Show secret 25 words that can be used to recover this wallet.\n") <<
   tr("  \"refresh\" - Synchronize wallet with the Wownero network.\n") <<
@@ -2064,13 +2064,9 @@ simple_wallet::simple_wallet()
                            boost::bind(&simple_wallet::print_address, this, _1),
                            tr("address [ new <label text with white spaces allowed> | all | <index_min> [<index_max>] | label <index> <label text with white spaces allowed>]"),
                            tr("If no arguments are specified or <index> is specified, the wallet shows the default or specified address. If \"all\" is specified, the wallet shows all the existing addresses in the currently selected account. If \"new \" is specified, the wallet creates a new address with the provided label text (which can be empty). If \"label\" is specified, the wallet sets the label of the address specified by <index> to the provided label text."));
-  m_cmd_binder.set_handler("integrated_address",
-                           boost::bind(&simple_wallet::print_integrated_address, this, _1),
-                           tr("integrated_address [<payment_id> | <address>]"),
-                           tr("Encode a payment ID into an integrated address for the current wallet public address (no argument uses a random payment ID), or decode an integrated address to standard address and payment ID"));
   m_cmd_binder.set_handler("address_book",
                            boost::bind(&simple_wallet::address_book, this, _1),
-                           tr("address_book [(add ((<address> [pid <id>])|<integrated address>) [<description possibly with whitespaces>])|(delete <index>)]"),
+                           tr("address_book [(add ((<address> [pid <id>])) [<description possibly with whitespaces>])|(delete <index>)]"),
                            tr("Print all entries in the address book, optionally adding/deleting an entry to/from it."));
   m_cmd_binder.set_handler("save",
                            boost::bind(&simple_wallet::save, this, _1),
@@ -2319,7 +2315,7 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
     success_msg_writer() << "auto-refresh = " << m_wallet->auto_refresh();
     success_msg_writer() << "refresh-type = " << get_refresh_type_name(m_wallet->get_refresh_type());
     success_msg_writer() << "priority = " << m_wallet->get_default_priority();
-    success_msg_writer() << "confirm-missing-payment-id = " << m_wallet->confirm_missing_payment_id();
+    success_msg_writer() << "confirm-subaddress = " << m_wallet->confirm_subaddress();
     success_msg_writer() << "ask-password = " << m_wallet->ask_password();
     success_msg_writer() << "unit = " << cryptonote::get_unit(cryptonote::get_default_decimal_point());
     success_msg_writer() << "min-outputs-count = " << m_wallet->get_min_output_count();
@@ -2373,7 +2369,7 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
     CHECK_SIMPLE_VARIABLE("auto-refresh", set_auto_refresh, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("refresh-type", set_refresh_type, tr("full (slowest, no assumptions); optimize-coinbase (fast, assumes the whole coinbase is paid to a single address); no-coinbase (fastest, assumes we receive no coinbase transaction), default (same as optimize-coinbase)"));
     CHECK_SIMPLE_VARIABLE("priority", set_default_priority, tr("0, 1, 2, 3, or 4"));
-    CHECK_SIMPLE_VARIABLE("confirm-missing-payment-id", set_confirm_missing_payment_id, tr("0 or 1"));
+    CHECK_SIMPLE_VARIABLE("confirm-subaddress", set_confirm_subaddress, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("ask-password", set_ask_password, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("unit", set_unit, tr("wownero, millinero, micronero, nanonero, piconero"));
     CHECK_SIMPLE_VARIABLE("min-outputs-count", set_min_output_count, tr("unsigned integer"));
@@ -3470,6 +3466,8 @@ bool simple_wallet::open_wallet(const boost::program_options::variables_map& vm)
       prefix = tr("Opened wallet");
     message_writer(console_color_white, true) <<
       prefix << ": " << m_wallet->get_account().get_public_address_str(m_wallet->nettype());
+    message_writer(console_color_yellow, true) << "\n" << tr("When receiving WOW, "
+          "create a new sub-address for each transaction with the command “address new”. \nUse “address all” to see all sub-addresses.\n");
     if (m_wallet->get_account().get_device()) {
        message_writer(console_color_white, true) << "Wallet is on device: " << m_wallet->get_account().get_device().get_name();
     }
@@ -4346,7 +4344,7 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
       std::string extra_nonce;
       set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
       r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
-      success_msg_writer() << tr("WARNING: Payment id is unencrypted, which might potentially compromise your privacy. An integrated address is recommended instead.\n");
+      success_msg_writer() << tr("\nWARNING: Payment IDs will be deprecated soon. Sub-addresses are recommended instead.\n");
     }
     else
     {
@@ -4357,6 +4355,7 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
         std::string extra_nonce;
         set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id8);
         r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
+        success_msg_writer() << tr("\nWARNING: Payment IDs will be deprecated soon. Sub-addresses are recommended instead.\n");
       }
     }
 
@@ -4433,10 +4432,10 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
     dsts.push_back(de);
   }
 
-  // prompt is there is no payment id and confirmation is required
-  if (!payment_id_seen && m_wallet->confirm_missing_payment_id() && dsts.size() > num_subaddresses)
+  // prompt if regular address
+  if (!payment_id_seen && m_wallet->confirm_subaddress() && dsts.size() > num_subaddresses)
   {
-     std::string accepted = input_line(tr("No payment id is included with this transaction. Is this okay?  (Y/Yes/N/No): "));
+     std::string accepted = input_line(tr("\nSending to a regular address may degrade privacy. Ask recipient for a sub-address instead. Continue anyway? (Y/Yes/N/No): "));
      if (std::cin.eof())
        return true;
      if (!command_line::is_yes(accepted))
@@ -4833,6 +4832,7 @@ bool simple_wallet::sweep_main(uint64_t below, const std::vector<std::string> &a
       set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
       r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
       payment_id_seen = true;
+      success_msg_writer() << tr("\nWARNING: Payment IDs will be deprecated soon. Sub-addresses are recommended instead.\n");
     }
     else
     {
@@ -4844,6 +4844,7 @@ bool simple_wallet::sweep_main(uint64_t below, const std::vector<std::string> &a
         set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id8);
         r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
         payment_id_seen = true;
+        success_msg_writer() << tr("\nWARNING: Payment IDs will be deprecated soon. Sub-addresses are recommended instead.\n");
       }
     }
 
@@ -4882,10 +4883,10 @@ bool simple_wallet::sweep_main(uint64_t below, const std::vector<std::string> &a
     payment_id_seen = true;
   }
 
-  // prompt is there is no payment id and confirmation is required
-  if (!payment_id_seen && m_wallet->confirm_missing_payment_id() && !info.is_subaddress)
+  // prompt if regular address
+  if (!payment_id_seen && m_wallet->confirm_subaddress() && !info.is_subaddress)
   {
-     std::string accepted = input_line(tr("No payment id is included with this transaction. Is this okay?  (Y/Yes/N/No): "));
+     std::string accepted = input_line(tr("\nSending to a regular address may degrade privacy. Ask recipient for a sub-address instead. Continue anyway? (Y/Yes/N/No): "));
      if (std::cin.eof())
        return true;
      if (!command_line::is_yes(accepted))
@@ -5081,10 +5082,10 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
     payment_id_seen = true;
   }
 
-  // prompt if there is no payment id and confirmation is required
-  if (!payment_id_seen && m_wallet->confirm_missing_payment_id() && !info.is_subaddress)
+  // prompt if regular address
+  if (!payment_id_seen && m_wallet->confirm_subaddress() && !info.is_subaddress)
   {
-     std::string accepted = input_line(tr("No payment id is included with this transaction. Is this okay?  (Y/Yes/N/No): "));
+     std::string accepted = input_line(tr("\nSending to a regular address may degrade privacy. Ask recipient for a sub-address instead. Continue anyway? (Y/Yes/N/No): "));
      if (std::cin.eof())
        return true;
      if (!command_line::is_yes(accepted))
@@ -6675,56 +6676,7 @@ bool simple_wallet::print_address(const std::vector<std::string> &args/* = std::
   return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::print_integrated_address(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
-{
-  crypto::hash8 payment_id;
-  if (args.size() > 1)
-  {
-    fail_msg_writer() << tr("usage: integrated_address [payment ID]");
-    return true;
-  }
-  if (args.size() == 0)
-  {
-    if (m_current_subaddress_account != 0)
-    {
-      fail_msg_writer() << tr("Integrated addresses can only be created for account 0");
-      return true;
-    }
-    payment_id = crypto::rand<crypto::hash8>();
-    success_msg_writer() << tr("Random payment ID: ") << payment_id;
-    success_msg_writer() << tr("Matching integrated address: ") << m_wallet->get_account().get_public_integrated_address_str(payment_id, m_wallet->nettype());
-    return true;
-  }
-  if(tools::wallet2::parse_short_payment_id(args.back(), payment_id))
-  {
-    if (m_current_subaddress_account != 0)
-    {
-      fail_msg_writer() << tr("Integrated addresses can only be created for account 0");
-      return true;
-    }
-    success_msg_writer() << m_wallet->get_account().get_public_integrated_address_str(payment_id, m_wallet->nettype());
-    return true;
-  }
-  else {
-    address_parse_info info;
-    if(get_account_address_from_str(info, m_wallet->nettype(), args.back()))
-    {
-      if (info.has_payment_id)
-      {
-        success_msg_writer() << boost::format(tr("Integrated address: %s, payment ID: %s")) %
-          get_account_address_as_str(m_wallet->nettype(), false, info.address) % epee::string_tools::pod_to_hex(info.payment_id);
-      }
-      else
-      {
-        success_msg_writer() << (info.is_subaddress ? tr("Subaddress: ") : tr("Standard address: ")) << get_account_address_as_str(m_wallet->nettype(), info.is_subaddress, info.address);
-      }
-      return true;
-    }
-  }
-  fail_msg_writer() << tr("failed to parse payment ID or address");
-  return true;
-}
-//----------------------------------------------------------------------------------------------------
+
 bool simple_wallet::address_book(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
   if (args.size() == 0)
@@ -6732,7 +6684,7 @@ bool simple_wallet::address_book(const std::vector<std::string> &args/* = std::v
   }
   else if (args.size() == 1 || (args[0] != "add" && args[0] != "delete"))
   {
-    fail_msg_writer() << tr("usage: address_book [(add (<address> [pid <long or short payment id>])|<integrated address> [<description possibly with whitespaces>])|(delete <index>)]");
+    fail_msg_writer() << tr("usage: address_book [(add (<address> [pid <long or short payment id>]) [<description possibly with whitespaces>])|(delete <index>)]");
     return true;
   }
   else if (args[0] == "add")
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 125e849d5..c52c50909 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -121,7 +121,7 @@ namespace cryptonote
     bool set_store_tx_info(const std::vector<std::string> &args = std::vector<std::string>());
     bool set_auto_refresh(const std::vector<std::string> &args = std::vector<std::string>());
     bool set_refresh_type(const std::vector<std::string> &args = std::vector<std::string>());
-    bool set_confirm_missing_payment_id(const std::vector<std::string> &args = std::vector<std::string>());
+    bool set_confirm_subaddress(const std::vector<std::string> &args = std::vector<std::string>());
     bool set_ask_password(const std::vector<std::string> &args = std::vector<std::string>());
     bool set_unit(const std::vector<std::string> &args = std::vector<std::string>());
     bool set_min_output_count(const std::vector<std::string> &args = std::vector<std::string>());
@@ -167,7 +167,6 @@ namespace cryptonote
     void print_accounts();
     void print_accounts(const std::string& tag);
     bool print_address(const std::vector<std::string> &args = std::vector<std::string>());
-    bool print_integrated_address(const std::vector<std::string> &args = std::vector<std::string>());
     bool address_book(const std::vector<std::string> &args = std::vector<std::string>());
     bool save(const std::vector<std::string> &args);
     bool save_watch_only(const std::vector<std::string> &args);
diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp
index 2dae2c42f..66976d162 100644
--- a/src/wallet/api/wallet.cpp
+++ b/src/wallet/api/wallet.cpp
@@ -744,14 +744,6 @@ std::string WalletImpl::address(uint32_t accountIndex, uint32_t addressIndex) co
     return m_wallet->get_subaddress_as_str({accountIndex, addressIndex});
 }
 
-std::string WalletImpl::integratedAddress(const std::string &payment_id) const
-{
-    crypto::hash8 pid;
-    if (!tools::wallet2::parse_short_payment_id(payment_id, pid)) {
-        return "";
-    }
-    return m_wallet->get_integrated_address_as_str(pid);
-}
 
 std::string WalletImpl::secretViewKey() const
 {
diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h
index f9ebc3c7b..a19d2381c 100644
--- a/src/wallet/api/wallet.h
+++ b/src/wallet/api/wallet.h
@@ -88,7 +88,6 @@ public:
     std::string errorString() const;
     bool setPassword(const std::string &password);
     std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const;
-    std::string integratedAddress(const std::string &payment_id) const;
     std::string secretViewKey() const;
     std::string publicViewKey() const;
     std::string secretSpendKey() const;
diff --git a/src/wallet/api/wallet2_api.h b/src/wallet/api/wallet2_api.h
index 516a1d692..56ce24708 100644
--- a/src/wallet/api/wallet2_api.h
+++ b/src/wallet/api/wallet2_api.h
@@ -373,16 +373,6 @@ struct Wallet
     virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0;
     //! check if hard fork rules should be used
     virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0;  
-    /*!
-     * \brief integratedAddress - returns integrated address for current wallet address and given payment_id.
-     *                            if passed "payment_id" param is an empty string or not-valid payment id string
-     *                            (16 characters hexadecimal string) - random payment_id will be generated
-     *
-     * \param payment_id        - 16 characters hexadecimal string or empty string if new random payment id needs to be
-     *                            generated
-     * \return                  - 106 characters string representing integrated address
-     */
-    virtual std::string integratedAddress(const std::string &payment_id) const = 0;
     
    /*!
     * \brief secretViewKey     - returns secret view key
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index a6f81322e..2cdb2e9d5 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -651,7 +651,7 @@ wallet2::wallet2(network_type nettype, bool restricted):
   m_auto_refresh(true),
   m_refresh_from_block_height(0),
   m_explicit_refresh_from_block_height(true),
-  m_confirm_missing_payment_id(true),
+  m_confirm_subaddress(true),
   m_confirm_non_default_ring_size(true),
   m_ask_password(true),
   m_min_output_count(0),
@@ -899,11 +899,6 @@ std::string wallet2::get_subaddress_as_str(const cryptonote::subaddress_index& i
   return cryptonote::get_account_address_as_str(m_nettype, !index.is_zero(), address);
 }
 //----------------------------------------------------------------------------------------------------
-std::string wallet2::get_integrated_address_as_str(const crypto::hash8& payment_id) const
-{
-  return cryptonote::get_account_integrated_address_as_str(m_nettype, get_address(), payment_id);
-}
-//----------------------------------------------------------------------------------------------------
 void wallet2::add_subaddress_account(const std::string& label)
 {
   uint32_t index_major = (uint32_t)get_num_subaddress_accounts();
@@ -2623,8 +2618,8 @@ bool wallet2::store_keys(const std::string& keys_file_name, const epee::wipeable
   value2.SetUint64(m_refresh_from_block_height);
   json.AddMember("refresh_height", value2, json.GetAllocator());
 
-  value2.SetInt(m_confirm_missing_payment_id ? 1 :0);
-  json.AddMember("confirm_missing_payment_id", value2, json.GetAllocator());
+  value2.SetInt(m_confirm_subaddress ? 1 :0);
+  json.AddMember("confirm_subaddress", value2, json.GetAllocator());
 
   value2.SetInt(m_confirm_non_default_ring_size ? 1 :0);
   json.AddMember("confirm_non_default_ring_size", value2, json.GetAllocator());
@@ -2734,7 +2729,7 @@ bool wallet2::load_keys(const std::string& keys_file_name, const epee::wipeable_
     m_default_priority = 0;
     m_auto_refresh = true;
     m_refresh_type = RefreshType::RefreshDefault;
-    m_confirm_missing_payment_id = true;
+    m_confirm_subaddress = true;
     m_confirm_non_default_ring_size = true;
     m_ask_password = true;
     m_min_output_count = 0;
@@ -2837,8 +2832,8 @@ bool wallet2::load_keys(const std::string& keys_file_name, const epee::wipeable_
     }
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, refresh_height, uint64_t, Uint64, false, 0);
     m_refresh_from_block_height = field_refresh_height;
-    GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_missing_payment_id, int, Int, false, true);
-    m_confirm_missing_payment_id = field_confirm_missing_payment_id;
+    GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_subaddress, int, Int, false, true);
+    m_confirm_subaddress = field_confirm_subaddress;
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_non_default_ring_size, int, Int, false, true);
     m_confirm_non_default_ring_size = field_confirm_non_default_ring_size;
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, ask_password, int, Int, false, true);
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 4488dbb2a..8c141be7e 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -628,7 +628,6 @@ namespace tools
     std::vector<crypto::public_key> get_subaddress_spend_public_keys(uint32_t account, uint32_t begin, uint32_t end) const;
     std::string get_subaddress_as_str(const cryptonote::subaddress_index& index) const;
     std::string get_address_as_str() const { return get_subaddress_as_str({0, 0}); }
-    std::string get_integrated_address_as_str(const crypto::hash8& payment_id) const;
     void add_subaddress_account(const std::string& label);
     size_t get_num_subaddress_accounts() const { return m_subaddress_labels.size(); }
     size_t get_num_subaddresses(uint32_t index_major) const { return index_major < m_subaddress_labels.size() ? m_subaddress_labels[index_major].size() : 0; }
@@ -851,8 +850,8 @@ namespace tools
     void set_default_priority(uint32_t p) { m_default_priority = p; }
     bool auto_refresh() const { return m_auto_refresh; }
     void auto_refresh(bool r) { m_auto_refresh = r; }
-    bool confirm_missing_payment_id() const { return m_confirm_missing_payment_id; }
-    void confirm_missing_payment_id(bool always) { m_confirm_missing_payment_id = always; }
+    bool confirm_subaddress() const { return m_confirm_subaddress; }
+    void confirm_subaddress(bool always) { m_confirm_subaddress = always; }
     bool ask_password() const { return m_ask_password; }
     void ask_password(bool always) { m_ask_password = always; }
     void set_min_output_count(uint32_t count) { m_min_output_count = count; }
@@ -1196,7 +1195,7 @@ namespace tools
     // If m_refresh_from_block_height is explicitly set to zero we need this to differentiate it from the case that
     // m_refresh_from_block_height was defaulted to zero.*/
     bool m_explicit_refresh_from_block_height;
-    bool m_confirm_missing_payment_id;
+    bool m_confirm_subaddress;
     bool m_confirm_non_default_ring_size;
     bool m_ask_password;
     uint32_t m_min_output_count;
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 21916d0ae..75dcd75d4 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1072,69 +1072,6 @@ namespace tools
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_make_integrated_address(const wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er)
-  {
-    if (!m_wallet) return not_open(er);
-    try
-    {
-      crypto::hash8 payment_id;
-      if (req.payment_id.empty())
-      {
-        payment_id = crypto::rand<crypto::hash8>();
-      }
-      else
-      {
-        if (!tools::wallet2::parse_short_payment_id(req.payment_id,payment_id))
-        {
-          er.code = WALLET_RPC_ERROR_CODE_WRONG_PAYMENT_ID;
-          er.message = "Invalid payment ID";
-          return false;
-        }
-      }
-
-      res.integrated_address = m_wallet->get_integrated_address_as_str(payment_id);
-      res.payment_id = epee::string_tools::pod_to_hex(payment_id);
-      return true;
-    }
-    catch (const std::exception& e)
-    {
-      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR);
-      return false;
-    }
-    return true;
-  }
-  //------------------------------------------------------------------------------------------------------------------------------
-  bool wallet_rpc_server::on_split_integrated_address(const wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er)
-  {
-    if (!m_wallet) return not_open(er);
-    try
-    {
-      cryptonote::address_parse_info info;
-
-      if(!get_account_address_from_str(info, m_wallet->nettype(), req.integrated_address))
-      {
-        er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
-        er.message = "Invalid address";
-        return false;
-      }
-      if(!info.has_payment_id)
-      {
-        er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
-        er.message = "Address is not an integrated address";
-        return false;
-      }
-      res.standard_address = get_account_address_as_str(m_wallet->nettype(), info.is_subaddress, info.address);
-      res.payment_id = epee::string_tools::pod_to_hex(info.payment_id);
-      return true;
-    }
-    catch (const std::exception& e)
-    {
-      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR);
-      return false;
-    }
-    return true;
-  }
-  //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er)
   {
     if (!m_wallet) return not_open(er);
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index 2ec53cc80..97275758b 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -94,8 +94,6 @@ namespace tools
         MAP_JON_RPC_WE("get_bulk_payments",  on_get_bulk_payments,  wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS)
         MAP_JON_RPC_WE("incoming_transfers", on_incoming_transfers, wallet_rpc::COMMAND_RPC_INCOMING_TRANSFERS)
         MAP_JON_RPC_WE("query_key",         on_query_key,         wallet_rpc::COMMAND_RPC_QUERY_KEY)
-        MAP_JON_RPC_WE("make_integrated_address", on_make_integrated_address, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS)
-        MAP_JON_RPC_WE("split_integrated_address", on_split_integrated_address, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS)
         MAP_JON_RPC_WE("stop_wallet",        on_stop_wallet,        wallet_rpc::COMMAND_RPC_STOP_WALLET)
         MAP_JON_RPC_WE("rescan_blockchain",  on_rescan_blockchain,  wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN)
         MAP_JON_RPC_WE("set_tx_notes",       on_set_tx_notes,       wallet_rpc::COMMAND_RPC_SET_TX_NOTES)
@@ -158,8 +156,6 @@ namespace tools
       bool on_sweep_all(const wallet_rpc::COMMAND_RPC_SWEEP_ALL::request& req, wallet_rpc::COMMAND_RPC_SWEEP_ALL::response& res, epee::json_rpc::error& er);
       bool on_sweep_single(const wallet_rpc::COMMAND_RPC_SWEEP_SINGLE::request& req, wallet_rpc::COMMAND_RPC_SWEEP_SINGLE::response& res, epee::json_rpc::error& er);
       bool on_relay_tx(const wallet_rpc::COMMAND_RPC_RELAY_TX::request& req, wallet_rpc::COMMAND_RPC_RELAY_TX::response& res, epee::json_rpc::error& er);
-      bool on_make_integrated_address(const wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er);
-      bool on_split_integrated_address(const wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er);
       bool on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er);
       bool on_get_payments(const wallet_rpc::COMMAND_RPC_GET_PAYMENTS::request& req, wallet_rpc::COMMAND_RPC_GET_PAYMENTS::response& res, epee::json_rpc::error& er);
       bool on_get_bulk_payments(const wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::request& req, wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::response& res, epee::json_rpc::error& er);
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index a0f43c9b9..f92ddd25f 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -841,53 +841,6 @@ namespace wallet_rpc
     };
   };
 
-  struct COMMAND_RPC_MAKE_INTEGRATED_ADDRESS
-  {
-    struct request
-    {
-      std::string payment_id;
-
-      BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(payment_id)
-      END_KV_SERIALIZE_MAP()
-    };
-
-    struct response
-    {
-      std::string integrated_address;
-      std::string payment_id;
-
-      BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(integrated_address)
-        KV_SERIALIZE(payment_id)
-      END_KV_SERIALIZE_MAP()
-    };
-  };
-
-  struct COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS
-  {
-    struct request
-    {
-      std::string integrated_address;
-
-      BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(integrated_address)
-      END_KV_SERIALIZE_MAP()
-    };
-
-    struct response
-    {
-      std::string standard_address;
-      std::string payment_id;
-      bool is_subaddress;
-
-      BEGIN_KV_SERIALIZE_MAP()
-        KV_SERIALIZE(standard_address)
-        KV_SERIALIZE(payment_id)
-        KV_SERIALIZE(is_subaddress)
-      END_KV_SERIALIZE_MAP()
-    };
-  };
 
   struct COMMAND_RPC_STOP_WALLET
   {

From d1176c5ef5b1b71d567f7e5c01ce7c265b851e17 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Thu, 18 Oct 2018 12:39:44 +0300
Subject: [PATCH 03/54] rpc: added subaddresses warning

---
 src/wallet/wallet_rpc_server.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 75dcd75d4..0c0802048 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -2944,6 +2944,7 @@ just_dir:
     wrpc.send_stop_signal();
   });
   LOG_PRINT_L0(tools::wallet_rpc_server::tr("Starting wallet RPC server"));
+  LOG_PRINT_L0(tools::wallet_rpc_server::tr("WARNING: Payment IDs/integrated addresses will be deprecated soon. Use sub-addresses."));
   try
   {
     wrpc.run();

From 00bf0b5ef061887f1e41e65b6ca60cfb52335147 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Mon, 1 Oct 2018 14:46:32 +0000
Subject: [PATCH 04/54] wallet_rpc_server: include all transfer records for a
 txid

Since subaddresses were added, a tx can now create more than
one payment
---
 src/wallet/wallet_rpc_server.cpp             | 22 +++++++++++++-------
 src/wallet/wallet_rpc_server_commands_defs.h | 13 ++++++++++++
 2 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 21916d0ae..64cb9da61 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1938,8 +1938,8 @@ namespace tools
     for (std::list<std::pair<crypto::hash, tools::wallet2::payment_details>>::const_iterator i = payments.begin(); i != payments.end(); ++i) {
       if (i->second.m_tx_hash == txid)
       {
-        fill_transfer_entry(res.transfer, i->second.m_tx_hash, i->first, i->second);
-        return true;
+        res.transfers.resize(res.transfers.size() + 1);
+        fill_transfer_entry(res.transfers.back(), i->second.m_tx_hash, i->first, i->second);
       }
     }
 
@@ -1948,8 +1948,8 @@ namespace tools
     for (std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>>::const_iterator i = payments_out.begin(); i != payments_out.end(); ++i) {
       if (i->first == txid)
       {
-        fill_transfer_entry(res.transfer, i->first, i->second);
-        return true;
+        res.transfers.resize(res.transfers.size() + 1);
+        fill_transfer_entry(res.transfers.back(), i->first, i->second);
       }
     }
 
@@ -1958,8 +1958,8 @@ namespace tools
     for (std::list<std::pair<crypto::hash, tools::wallet2::unconfirmed_transfer_details>>::const_iterator i = upayments.begin(); i != upayments.end(); ++i) {
       if (i->first == txid)
       {
-        fill_transfer_entry(res.transfer, i->first, i->second);
-        return true;
+        res.transfers.resize(res.transfers.size() + 1);
+        fill_transfer_entry(res.transfers.back(), i->first, i->second);
       }
     }
 
@@ -1970,11 +1970,17 @@ namespace tools
     for (std::list<std::pair<crypto::hash, tools::wallet2::pool_payment_details>>::const_iterator i = pool_payments.begin(); i != pool_payments.end(); ++i) {
       if (i->second.m_pd.m_tx_hash == txid)
       {
-        fill_transfer_entry(res.transfer, i->first, i->second);
-        return true;
+        res.transfers.resize(res.transfers.size() + 1);
+        fill_transfer_entry(res.transfers.back(), i->first, i->second);
       }
     }
 
+    if (!res.transfers.empty())
+    {
+      res.transfer = res.transfers.front(); // backward compat
+      return true;
+    }
+
     er.code = WALLET_RPC_ERROR_CODE_WRONG_TXID;
     er.message = "Transaction not found.";
     return false;
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index a0f43c9b9..e12a5f415 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -39,6 +39,17 @@
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "wallet.rpc"
 
+// When making *any* change here, bump minor
+// If the change is incompatible, then bump major and set minor to 0
+// This ensures WALLET_RPC_VERSION always increases, that every change
+// has its own version, and that clients can just test major to see
+// whether they can talk to a given wallet without having to know in
+// advance which version they will stop working with
+// Don't go over 32767 for any of these
+#define WALLET_RPC_VERSION_MAJOR 1
+#define WALLET_RPC_VERSION_MINOR 4
+#define MAKE_WALLET_RPC_VERSION(major,minor) (((major)<<16)|(minor))
+#define WALLET_RPC_VERSION MAKE_WALLET_RPC_VERSION(WALLET_RPC_VERSION_MAJOR, WALLET_RPC_VERSION_MINOR)
 namespace tools
 {
 namespace wallet_rpc
@@ -1311,9 +1322,11 @@ namespace wallet_rpc
     struct response
     {
       transfer_entry transfer;
+      std::list<transfer_entry> transfers;
 
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(transfer);
+        KV_SERIALIZE(transfers);
       END_KV_SERIALIZE_MAP()
     };
   };

From 44e0f9eebff4154e7fbcc1337b51e04653d5484d Mon Sep 17 00:00:00 2001
From: doy-lee <doylet@protonmail.com>
Date: Wed, 26 Sep 2018 12:38:39 +0000
Subject: [PATCH 05/54] wallet2: clear found out for every tx key

Avoids triggering the sanity check
---
 src/wallet/wallet2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index a6f81322e..ae22917e8 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -1105,7 +1105,6 @@ void wallet2::process_new_transaction(const crypto::hash &txid, const cryptonote
   // (that is, the prunable stuff may or may not be included)
   if (!miner_tx && !pool)
     process_unconfirmed(txid, tx, height);
-  std::vector<size_t> outs;
   std::unordered_map<cryptonote::subaddress_index, uint64_t> tx_money_got_in_outs;  // per receiving subaddress index
   crypto::public_key tx_pub_key = null_pkey;
 
@@ -1123,6 +1122,7 @@ void wallet2::process_new_transaction(const crypto::hash &txid, const cryptonote
   uint64_t total_received_1 = 0;
   while (!tx.vout.empty())
   {
+    std::vector<size_t> outs;
     // if tx.vout is not empty, we loop through all tx pubkeys
 
     tx_extra_pub_key pub_key_field;

From 2998b929d58e879462ead297bd285a0b3c89f70d Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Mon, 15 Oct 2018 11:57:02 +0900
Subject: [PATCH 06/54] tx_pool: store hex string instead of raw binary to
 tx_blob of get_transaction_pool RPC

Inspired by https://github.com/masari-project/masari/issues/93
---
 src/cryptonote_core/tx_pool.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 684a6b363..036cb7d33 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -746,7 +746,7 @@ namespace cryptonote
     m_blockchain.for_all_txpool_txes([&tx_infos, key_image_infos, include_sensitive_data](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
       tx_info txi;
       txi.id_hash = epee::string_tools::pod_to_hex(txid);
-      txi.tx_blob = *bd;
+      txi.tx_blob = epee::string_tools::buff_to_hex_nodelimer(*bd);
       transaction tx;
       if (!parse_and_validate_tx_from_blob(*bd, tx))
       {

From a09d5ea211253e9bf8e1b9f3ef9321881e7ed4eb Mon Sep 17 00:00:00 2001
From: Jorropo <jorropo.pgm@gmail.com>
Date: Wed, 25 Jul 2018 10:16:01 +0200
Subject: [PATCH 07/54] [monerod] Added blocks remaining count during
 syncronisation. And percent if usefull (% < 99)

---
 .../cryptonote_protocol_handler.inl               | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/cryptonote_protocol/cryptonote_protocol_handler.inl b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
index 6e7240b57..e970afcde 100644
--- a/src/cryptonote_protocol/cryptonote_protocol_handler.inl
+++ b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
@@ -1167,8 +1167,20 @@ skip:
                 + " blocks/sec), " + std::to_string(m_block_queue.get_data_size() / 1048576.f) + " MB queued";
             if (ELPP->vRegistry()->allowed(el::Level::Debug, "sync-info"))
               timing_message += std::string(": ") + m_block_queue.get_overview();
-            MGINFO_YELLOW(context << " Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height()
+            if(m_core.get_target_blockchain_height() == 0){
+              MGINFO_YELLOW(context << " Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height()
                 << timing_message);
+            } else {
+              const int completition_percent = (m_core.get_current_blockchain_height() * 100 / m_core.get_target_blockchain_height());
+              if(completition_percent < 99) {//printing completion percent only if % is < of 99 cause for 99 >= this is useless
+                MGINFO_YELLOW(context << " Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height()
+                  << " (" << completition_percent << "% " << (m_core.get_target_blockchain_height() - m_core.get_current_blockchain_height())
+                  << " blocks remaining)" << timing_message);
+              } else {
+                MGINFO_YELLOW(context << " Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height()
+                  << timing_message);
+              }
+            }
           }
         }
       }
@@ -1752,3 +1764,4 @@ skip:
     m_core.stop();
   }
 } // namespace
+

From 83e5d6a82959befa0ca74f70ca3a8a929d520799 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Mon, 23 Jul 2018 23:45:11 +0900
Subject: [PATCH 08/54] wallet-rpc: add get_address_index command

---
 src/wallet/wallet2.cpp                       |  8 ++++++++
 src/wallet/wallet2.h                         |  1 +
 src/wallet/wallet_rpc_server.cpp             | 21 ++++++++++++++++++++
 src/wallet/wallet_rpc_server.h               |  2 ++
 src/wallet/wallet_rpc_server_commands_defs.h | 19 ++++++++++++++++++
 5 files changed, 51 insertions(+)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index ae22917e8..35bbde9d5 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -887,6 +887,14 @@ cryptonote::account_public_address wallet2::get_subaddress(const cryptonote::sub
   return hwdev.get_subaddress(m_account.get_keys(), index);
 }
 //----------------------------------------------------------------------------------------------------
+boost::optional<cryptonote::subaddress_index> wallet2::get_subaddress_index(const cryptonote::account_public_address& address) const
+{
+  auto index = m_subaddresses.find(address.m_spend_public_key);
+  if (index == m_subaddresses.end())
+    return boost::none;
+  return index->second;
+}
+//----------------------------------------------------------------------------------------------------
 crypto::public_key wallet2::get_subaddress_spend_public_key(const cryptonote::subaddress_index& index) const
 {
   hw::device &hwdev = m_account.get_device();
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 4488dbb2a..af4c9ad8e 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -624,6 +624,7 @@ namespace tools
     // Subaddress scheme
     cryptonote::account_public_address get_subaddress(const cryptonote::subaddress_index& index) const;
     cryptonote::account_public_address get_address() const { return get_subaddress({0,0}); }
+    boost::optional<cryptonote::subaddress_index> get_subaddress_index(const cryptonote::account_public_address& address) const;
     crypto::public_key get_subaddress_spend_public_key(const cryptonote::subaddress_index& index) const;
     std::vector<crypto::public_key> get_subaddress_spend_public_keys(uint32_t account, uint32_t begin, uint32_t end) const;
     std::string get_subaddress_as_str(const cryptonote::subaddress_index& index) const;
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 64cb9da61..6ee6dc279 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -397,6 +397,27 @@ namespace tools
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_getaddress_index(const wallet_rpc::COMMAND_RPC_GET_ADDRESS_INDEX::request& req, wallet_rpc::COMMAND_RPC_GET_ADDRESS_INDEX::response& res, epee::json_rpc::error& er)
+  {
+    if (!m_wallet) return not_open(er);
+    cryptonote::address_parse_info info;
+    if(!get_account_address_from_str(info, m_wallet->nettype(), req.address))
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
+      er.message = "Invalid address";
+      return false;
+    }
+    auto index = m_wallet->get_subaddress_index(info.address);
+    if (!index)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
+      er.message = "Address doesn't belong to the wallet";
+      return false;
+    }
+    res.index = *index;
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_create_address(const wallet_rpc::COMMAND_RPC_CREATE_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_CREATE_ADDRESS::response& res, epee::json_rpc::error& er)
   {
     if (!m_wallet) return not_open(er);
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index 2ec53cc80..a68e12d97 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -69,6 +69,7 @@ namespace tools
       BEGIN_JSON_RPC_MAP("/json_rpc")
         MAP_JON_RPC_WE("get_balance",        on_getbalance,         wallet_rpc::COMMAND_RPC_GET_BALANCE)
         MAP_JON_RPC_WE("get_address",        on_getaddress,         wallet_rpc::COMMAND_RPC_GET_ADDRESS)
+        MAP_JON_RPC_WE("get_address_index",  on_getaddress_index,   wallet_rpc::COMMAND_RPC_GET_ADDRESS_INDEX)
         MAP_JON_RPC_WE("getbalance",         on_getbalance,         wallet_rpc::COMMAND_RPC_GET_BALANCE)
         MAP_JON_RPC_WE("getaddress",         on_getaddress,         wallet_rpc::COMMAND_RPC_GET_ADDRESS)
         MAP_JON_RPC_WE("create_address",     on_create_address,     wallet_rpc::COMMAND_RPC_CREATE_ADDRESS)
@@ -141,6 +142,7 @@ namespace tools
       //json_rpc
       bool on_getbalance(const wallet_rpc::COMMAND_RPC_GET_BALANCE::request& req, wallet_rpc::COMMAND_RPC_GET_BALANCE::response& res, epee::json_rpc::error& er);
       bool on_getaddress(const wallet_rpc::COMMAND_RPC_GET_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_GET_ADDRESS::response& res, epee::json_rpc::error& er);
+      bool on_getaddress_index(const wallet_rpc::COMMAND_RPC_GET_ADDRESS_INDEX::request& req, wallet_rpc::COMMAND_RPC_GET_ADDRESS_INDEX::response& res, epee::json_rpc::error& er);
       bool on_create_address(const wallet_rpc::COMMAND_RPC_CREATE_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_CREATE_ADDRESS::response& res, epee::json_rpc::error& er);
       bool on_label_address(const wallet_rpc::COMMAND_RPC_LABEL_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_LABEL_ADDRESS::response& res, epee::json_rpc::error& er);
       bool on_get_accounts(const wallet_rpc::COMMAND_RPC_GET_ACCOUNTS::request& req, wallet_rpc::COMMAND_RPC_GET_ACCOUNTS::response& res, epee::json_rpc::error& er);
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index e12a5f415..c61645826 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -141,6 +141,25 @@ namespace wallet_rpc
     };
   };
 
+  struct COMMAND_RPC_GET_ADDRESS_INDEX
+  {
+    struct request
+    {
+      std::string address;
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(address)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      cryptonote::subaddress_index index;
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(index)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
   struct COMMAND_RPC_CREATE_ADDRESS
   {
     struct request

From 7ba6d691965e9a5c675c008aafca9b21b9a57337 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Mon, 23 Jul 2018 23:58:31 +0900
Subject: [PATCH 09/54] wallet-rpc: filter getbalance response by address index

---
 src/wallet/wallet_rpc_server.cpp             | 14 ++++++++++----
 src/wallet/wallet_rpc_server_commands_defs.h |  2 ++
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 6ee6dc279..1b3bdf84d 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -336,14 +336,20 @@ namespace tools
       std::map<uint32_t, uint64_t> unlocked_balance_per_subaddress = m_wallet->unlocked_balance_per_subaddress(req.account_index);
       std::vector<tools::wallet2::transfer_details> transfers;
       m_wallet->get_transfers(transfers);
-      for (const auto& i : balance_per_subaddress)
+      std::set<uint32_t> address_indices = req.address_indices;
+      if (address_indices.empty())
+      {
+        for (const auto& i : balance_per_subaddress)
+          address_indices.insert(i.first);
+      }
+      for (uint32_t i : address_indices)
       {
         wallet_rpc::COMMAND_RPC_GET_BALANCE::per_subaddress_info info;
-        info.address_index = i.first;
+        info.address_index = i;
         cryptonote::subaddress_index index = {req.account_index, info.address_index};
         info.address = m_wallet->get_subaddress_as_str(index);
-        info.balance = i.second;
-        info.unlocked_balance = unlocked_balance_per_subaddress[i.first];
+        info.balance = balance_per_subaddress[i];
+        info.unlocked_balance = unlocked_balance_per_subaddress[i];
         info.label = m_wallet->get_subaddress_label(index);
         info.num_unspent_outputs = std::count_if(transfers.begin(), transfers.end(), [&](const tools::wallet2::transfer_details& td) { return !td.m_spent && td.m_subaddr_index == index; });
         res.per_subaddress.push_back(info);
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index c61645826..f264829ad 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -62,8 +62,10 @@ namespace wallet_rpc
     struct request
     {
       uint32_t account_index;
+      std::set<uint32_t> address_indices;
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(account_index)
+        KV_SERIALIZE(address_indices)
       END_KV_SERIALIZE_MAP()
     };
 

From ee45ef2c9ec19f0179a5e14b135e5cb569436824 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Tue, 24 Jul 2018 13:32:58 +0900
Subject: [PATCH 10/54] simplewallet.unspent_outputs: fix wrong logic for
 parsing

---
 src/simplewallet/simplewallet.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index bf76f3ffa..b7800d9b5 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -6167,7 +6167,7 @@ bool simple_wallet::unspent_outputs(const std::vector<std::string> &args_)
   auto local_args = args_;
 
   std::set<uint32_t> subaddr_indices;
-  if (local_args.size() > 0 && local_args[0].substr(0, 6) != "index=")
+  if (local_args.size() > 0 && local_args[0].substr(0, 6) == "index=")
   {
     if (!parse_subaddress_indices(local_args[0], subaddr_indices))
       return true;

From 583eaf3ccb3d1107a518c1dfd93e0ce99bee51e2 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Tue, 24 Jul 2018 14:33:33 +0100
Subject: [PATCH 11/54] wallet2: fix O(n^2) behaviour in import_key_images

That takes a lot of time for even not so large wallets
---
 src/wallet/wallet2.cpp | 36 +++++++++++++++---------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 35bbde9d5..5c4170900 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -9580,6 +9580,17 @@ uint64_t wallet2::import_key_images(const std::vector<std::pair<crypto::key_imag
   std::unordered_set<crypto::hash> spent_txids;   // For each spent key image, search for a tx in m_transfers that uses it as input.
   std::vector<size_t> swept_transfers;            // If such a spending tx wasn't found in m_transfers, this means the spending tx 
                                                   // was created by sweep_all, so we can't know the spent height and other detailed info.
+  std::unordered_map<crypto::key_image, crypto::hash> spent_key_images;
+
+  for (const transfer_details &td: m_transfers)
+  {
+    for (const cryptonote::txin_v& in : td.m_tx.vin)
+    {
+      if (in.type() == typeid(cryptonote::txin_to_key))
+        spent_key_images.insert(std::make_pair(boost::get<cryptonote::txin_to_key>(in).k_image, td.m_txid));
+    }
+  }
+
   for(size_t i = 0; i < signed_key_images.size(); ++i)
   {
     transfer_details &td = m_transfers[i];
@@ -9593,28 +9604,11 @@ uint64_t wallet2::import_key_images(const std::vector<std::pair<crypto::key_imag
 
     if (i < daemon_resp.spent_status.size() && daemon_resp.spent_status[i] == COMMAND_RPC_IS_KEY_IMAGE_SPENT::SPENT_IN_BLOCKCHAIN)
     {
-      bool is_spent_tx_found = false;
-      for (auto it = m_transfers.rbegin(); &(*it) != &td; ++it)
-      {
-        bool is_spent_tx = false;
-        for(const cryptonote::txin_v& in : it->m_tx.vin)
-        {
-          if(in.type() == typeid(cryptonote::txin_to_key) && td.m_key_image == boost::get<cryptonote::txin_to_key>(in).k_image)
-          {
-            is_spent_tx = true;
-            break;
-          }
-        }
-        if (is_spent_tx)
-        {
-          is_spent_tx_found = true;
-          spent_txids.insert(it->m_txid);
-          break;
-        }
-      }
-
-      if (!is_spent_tx_found)
+      const std::unordered_map<crypto::key_image, crypto::hash>::const_iterator skii = spent_key_images.find(td.m_key_image);
+      if (skii == spent_key_images.end())
         swept_transfers.push_back(i);
+      else
+        spent_txids.insert(skii->second);
     }
   }
   MDEBUG("Total: " << print_money(spent) << " spent, " << print_money(unspent) << " unspent");

From 0da1f14aafbc1e6a09af4147104a6f000919eab8 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Mon, 30 Jul 2018 13:15:41 +0100
Subject: [PATCH 12/54] wallet2: guard against bad outputs in import_outputs

also some minor speedup
---
 src/wallet/wallet2.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 5c4170900..67a4f7aad 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -9830,18 +9830,20 @@ size_t wallet2::import_outputs(const std::vector<tools::wallet2::transfer_detail
     crypto::public_key tx_pub_key = get_tx_pub_key_from_received_outs(td);
     const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
 
+    THROW_WALLET_EXCEPTION_IF(td.m_tx.vout[td.m_internal_output_index].target.type() != typeid(cryptonote::txout_to_key),
+        error::wallet_internal_error, "Unsupported output type");
     const crypto::public_key& out_key = boost::get<cryptonote::txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key;
     bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, out_key, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, td.m_key_image, m_account.get_device());
     THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
     expand_subaddresses(td.m_subaddr_index);
     td.m_key_image_known = true;
     td.m_key_image_partial = false;
-    THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != boost::get<cryptonote::txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key,
+    THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != out_key,
         error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key at index " + boost::lexical_cast<std::string>(i));
 
     m_key_images[td.m_key_image] = m_transfers.size();
     m_pub_keys[td.get_public_key()] = m_transfers.size();
-    m_transfers.push_back(td);
+    m_transfers.push_back(std::move(td));
   }
 
   return m_transfers.size();

From d904ea08a1bd2a738394675063c61956d0793640 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Mon, 30 Jul 2018 13:33:02 +0100
Subject: [PATCH 13/54] wallet2: avoid using arbitrary random values when
 unknown

---
 src/wallet/wallet2.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 67a4f7aad..aa6c6eb1f 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -9731,11 +9731,10 @@ uint64_t wallet2::import_key_images(const std::vector<std::pair<crypto::key_imag
     {
       const transfer_details& td = m_transfers[n];
       confirmed_transfer_details pd;
-      pd.m_change = (uint64_t)-1;                             // cahnge is unknown
+      pd.m_change = (uint64_t)-1;                             // change is unknown
       pd.m_amount_in = pd.m_amount_out = td.amount();         // fee is unknown
-      std::string err;
-      pd.m_block_height = get_daemon_blockchain_height(err);  // spent block height is unknown, so hypothetically set to the highest
-      crypto::hash spent_txid = crypto::rand<crypto::hash>(); // spent txid is unknown, so hypothetically set to random
+      pd.m_block_height = 0;  // spent block height is unknown
+      const crypto::hash &spent_txid = crypto::null_hash; // spent txid is unknown
       m_confirmed_txs.insert(std::make_pair(spent_txid, pd));
     }
   }

From 7cf07e9319ec6f81ecee7ff0a1847c2f9873bb01 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Mon, 30 Jul 2018 20:39:05 +0900
Subject: [PATCH 14/54] simplewallet: make sure wallet config is stored right
 after creation

---
 src/simplewallet/simplewallet.cpp | 60 ++++++++++++++++++-------------
 src/simplewallet/simplewallet.h   |  8 ++---
 2 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index b7800d9b5..22901d030 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -2631,6 +2631,7 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
           m_recovery_key = cryptonote::decrypt_key(m_recovery_key, seed_pass);
       }
     }
+    epee::wipeable_string password;
     if (!m_generate_from_view_key.empty())
     {
       m_wallet_file = m_generate_from_view_key;
@@ -2683,8 +2684,9 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
         return false;
       }
 
-      bool r = new_wallet(vm, info.address, boost::none, viewkey);
+      auto r = new_wallet(vm, info.address, boost::none, viewkey);
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
     }
     else if (!m_generate_from_spend_key.empty())
     {
@@ -2702,8 +2704,9 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
         fail_msg_writer() << tr("failed to parse spend key secret key");
         return false;
       }
-      bool r = new_wallet(vm, m_recovery_key, true, false, "");
+      auto r = new_wallet(vm, m_recovery_key, true, false, "");
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
     }
     else if (!m_generate_from_keys.empty())
     {
@@ -2780,8 +2783,9 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
         fail_msg_writer() << tr("view key does not match standard address");
         return false;
       }
-      bool r = new_wallet(vm, info.address, spendkey, viewkey);
+      auto r = new_wallet(vm, info.address, spendkey, viewkey);
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
     }
     
     // Asks user for all the data required to merge secret keys from multisig wallets into one master wallet, which then gets full control of the multisig wallet. The resulting wallet will be the same as any other regular wallet.
@@ -2914,8 +2918,9 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
       }
       
       // create wallet
-      bool r = new_wallet(vm, info.address, spendkey, viewkey);
+      auto r = new_wallet(vm, info.address, spendkey, viewkey);
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
     }
     
     else if (!m_generate_from_json.empty())
@@ -2937,8 +2942,9 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
     {
       m_wallet_file = m_generate_from_device;
       // create wallet
-      bool r = new_wallet(vm, "Ledger");
+      auto r = new_wallet(vm, "Ledger");
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
       // if no block_height is specified, assume its a new account and start it "now"
       if(m_wallet->get_refresh_from_block_height() == 0) {
         {
@@ -2963,12 +2969,13 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
         return false;
       }
       m_wallet_file = m_generate_new;
-      bool r;
+      boost::optional<epee::wipeable_string> r;
       if (m_restore_multisig_wallet)
         r = new_wallet(vm, multisig_keys, old_language);
       else
         r = new_wallet(vm, m_recovery_key, m_restore_deterministic_wallet, m_non_deterministic, old_language);
       CHECK_AND_ASSERT_MES(r, false, tr("account creation failed"));
+      password = *r;
     }
 
     if (m_restoring && m_generate_from_json.empty() && m_generate_from_device.empty())
@@ -3050,6 +3057,7 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
       }
       m_wallet->set_refresh_from_block_height(m_restore_height);
     }
+    m_wallet->rewrite(m_wallet_file, password);
   }
   else
   {
@@ -3217,15 +3225,16 @@ boost::optional<tools::password_container> simple_wallet::get_and_verify_passwor
   return pwd_container;
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
+boost::optional<epee::wipeable_string> simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   const crypto::secret_key& recovery_key, bool recover, bool two_random, const std::string &old_language)
 {
   auto rc = tools::wallet2::make_new(vm, password_prompter);
   m_wallet = std::move(rc.first);
   if (!m_wallet)
   {
-    return false;
+    return {};
   }
+  epee::wipeable_string password = rc.second.password();
 
   if (!m_subaddress_lookahead.empty())
   {
@@ -3261,7 +3270,7 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
     }
     mnemonic_language = get_mnemonic_language();
     if (mnemonic_language.empty())
-      return false;
+      return {};
   }
 
   m_wallet->set_seed_language(mnemonic_language);
@@ -3279,7 +3288,7 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   catch (const std::exception& e)
   {
     fail_msg_writer() << tr("failed to generate new wallet: ") << e.what();
-    return false;
+    return {};
   }
 
   // convert rng value to electrum-style word list
@@ -3305,10 +3314,10 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   }
   success_msg_writer() << "**********************************************************************";
 
-  return true;
+  return std::move(password);
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
+boost::optional<epee::wipeable_string> simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   const cryptonote::account_public_address& address, const boost::optional<crypto::secret_key>& spendkey,
   const crypto::secret_key& viewkey)
 {
@@ -3316,8 +3325,9 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   m_wallet = std::move(rc.first);
   if (!m_wallet)
   {
-    return false;
+    return {};
   }
+  epee::wipeable_string password = rc.second.password();
 
   if (!m_subaddress_lookahead.empty())
   {
@@ -3347,22 +3357,23 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   catch (const std::exception& e)
   {
     fail_msg_writer() << tr("failed to generate new wallet: ") << e.what();
-    return false;
+    return {};
   }
 
 
-  return true;
+  return std::move(password);
 }
 
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
+boost::optional<epee::wipeable_string> simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
                                const std::string &device_name) {
   auto rc = tools::wallet2::make_new(vm, password_prompter);
   m_wallet = std::move(rc.first);
   if (!m_wallet)
   {
-    return false;
+    return {};
   }
+  epee::wipeable_string password = rc.second.password();
 
   if (!m_subaddress_lookahead.empty())
   {
@@ -3383,21 +3394,22 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   catch (const std::exception& e)
   {
     fail_msg_writer() << tr("failed to generate new wallet: ") << e.what();
-    return false;
+    return {};
   }
 
-  return true;
+  return std::move(password);
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
+boost::optional<epee::wipeable_string> simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
     const std::string &multisig_keys, const std::string &old_language)
 {
   auto rc = tools::wallet2::make_new(vm, password_prompter);
   m_wallet = std::move(rc.first);
   if (!m_wallet)
   {
-    return false;
+    return {};
   }
+  epee::wipeable_string password = rc.second.password();
 
   if (!m_subaddress_lookahead.empty())
   {
@@ -3427,7 +3439,7 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
     if (!m_wallet->multisig(&ready, &threshold, &total) || !ready)
     {
       fail_msg_writer() << tr("failed to generate new mutlisig wallet");
-      return false;
+      return {};
     }
     message_writer(console_color_white, true) << boost::format(tr("Generated new %u/%u multisig wallet: ")) % threshold % total
       << m_wallet->get_account().get_public_address_str(m_wallet->nettype());
@@ -3435,10 +3447,10 @@ bool simple_wallet::new_wallet(const boost::program_options::variables_map& vm,
   catch (const std::exception& e)
   {
     fail_msg_writer() << tr("failed to generate new wallet: ") << e.what();
-    return false;
+    return {};
   }
 
-  return true;
+  return std::move(password);
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::open_wallet(const boost::program_options::variables_map& vm)
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 125e849d5..e1d60bbd4 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -91,13 +91,13 @@ namespace cryptonote
     //! \return Prompts user for password and verifies against local file. Logs on error and returns `none`
     boost::optional<tools::password_container> get_and_verify_password() const;
 
-    bool new_wallet(const boost::program_options::variables_map& vm, const crypto::secret_key& recovery_key,
+    boost::optional<epee::wipeable_string> new_wallet(const boost::program_options::variables_map& vm, const crypto::secret_key& recovery_key,
         bool recover, bool two_random, const std::string &old_language);
-    bool new_wallet(const boost::program_options::variables_map& vm, const cryptonote::account_public_address& address,
+    boost::optional<epee::wipeable_string> new_wallet(const boost::program_options::variables_map& vm, const cryptonote::account_public_address& address,
         const boost::optional<crypto::secret_key>& spendkey, const crypto::secret_key& viewkey);
-    bool new_wallet(const boost::program_options::variables_map& vm,
+    boost::optional<epee::wipeable_string> new_wallet(const boost::program_options::variables_map& vm,
         const std::string &multisig_keys, const std::string &old_language);
-    bool new_wallet(const boost::program_options::variables_map& vm, const std::string& device_name);
+    boost::optional<epee::wipeable_string> new_wallet(const boost::program_options::variables_map& vm, const std::string& device_name);
     bool open_wallet(const boost::program_options::variables_map& vm);
     bool close_wallet();
 

From ae255e3857bb5142b19a4220d1c906428b40d56c Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Fri, 24 Aug 2018 09:50:34 +0000
Subject: [PATCH 15/54] cryptonote_format_utils: do not early out on invalid tx
 pubkeys

Another such pubkey might be valid
---
 src/cryptonote_basic/cryptonote_format_utils.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/cryptonote_basic/cryptonote_format_utils.cpp b/src/cryptonote_basic/cryptonote_format_utils.cpp
index ca7254bf5..fce729634 100644
--- a/src/cryptonote_basic/cryptonote_format_utils.cpp
+++ b/src/cryptonote_basic/cryptonote_format_utils.cpp
@@ -201,15 +201,25 @@ namespace cryptonote
   {
     crypto::key_derivation recv_derivation = AUTO_VAL_INIT(recv_derivation);
     bool r = hwdev.generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
-    CHECK_AND_ASSERT_MES(r, false, "key image helper: failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
+    if (!r)
+    {
+      MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
+      memcpy(&recv_derivation, rct::identity().bytes, sizeof(recv_derivation));
+    }
 
     std::vector<crypto::key_derivation> additional_recv_derivations;
     for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
     {
       crypto::key_derivation additional_recv_derivation = AUTO_VAL_INIT(additional_recv_derivation);
       r = hwdev.generate_key_derivation(additional_tx_public_keys[i], ack.m_view_secret_key, additional_recv_derivation);
-      CHECK_AND_ASSERT_MES(r, false, "key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", " << ack.m_view_secret_key << ")");
-      additional_recv_derivations.push_back(additional_recv_derivation);
+      if (!r)
+      {
+        MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", " << ack.m_view_secret_key << ")");
+      }
+      else
+      {
+        additional_recv_derivations.push_back(additional_recv_derivation);
+      }
     }
 
     boost::optional<subaddress_receive_info> subaddr_recv_info = is_out_to_acc_precomp(subaddresses, out_key, recv_derivation, additional_recv_derivations, real_output_index,hwdev);

From 332ac6a03af3bae34bcba55aa40ca6582fec527b Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Sun, 9 Sep 2018 15:26:50 +0000
Subject: [PATCH 16/54] rpc: return "already mining" in start_mining if already
 mining

---
 src/rpc/core_rpc_server.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 3ec67e7e0..8617c7e28 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -863,7 +863,13 @@ namespace cryptonote
     boost::thread::attributes attrs;
     attrs.set_stack_size(THREAD_STACK_SIZE);
 
-    if(!m_core.get_miner().start(info.address, static_cast<size_t>(req.threads_count), attrs, req.do_background_mining, req.ignore_battery))
+    cryptonote::miner &miner= m_core.get_miner();
+    if (miner.is_mining())
+    {
+      res.status = "Already mining";
+      return true;
+    }
+    if(!miner.start(info.address, static_cast<size_t>(req.threads_count), attrs, req.do_background_mining, req.ignore_battery))
     {
       res.status = "Failed, mining not started";
       LOG_PRINT_L0(res.status);

From dc1e56d815321bea210c630f00c6eedbd15f8d40 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Mon, 1 Oct 2018 21:25:56 +0000
Subject: [PATCH 17/54] daemon: do not display uptime when not known

---
 src/daemon/rpc_command_executor.cpp | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/daemon/rpc_command_executor.cpp b/src/daemon/rpc_command_executor.cpp
index c73d98a84..f7b77233f 100644
--- a/src/daemon/rpc_command_executor.cpp
+++ b/src/daemon/rpc_command_executor.cpp
@@ -438,7 +438,8 @@ bool t_rpc_command_executor::show_status() {
     }
   }
 
-  tools::success_msg_writer() << boost::format("Height: %llu/%llu (%.1f%%) on %s%s, %s, net hash %s, v%u%s, %s, %u(out)+%u(in) connections, uptime %ud %uh %um %us")
+  std::stringstream str;
+  str << boost::format("Height: %llu/%llu (%.1f%%) on %s%s, %s, net hash %s, v%u%s, %s, %u(out)+%u(in) connections")
     % (unsigned long long)ires.height
     % (unsigned long long)net_height
     % get_sync_percentage(ires)
@@ -451,12 +452,21 @@ bool t_rpc_command_executor::show_status() {
     % (hfres.state == cryptonote::HardFork::Ready ? "up to date" : hfres.state == cryptonote::HardFork::UpdateNeeded ? "update needed" : "out of date, likely forked")
     % (unsigned)ires.outgoing_connections_count
     % (unsigned)ires.incoming_connections_count
-    % (unsigned int)floor(uptime / 60.0 / 60.0 / 24.0)
-    % (unsigned int)floor(fmod((uptime / 60.0 / 60.0), 24.0))
-    % (unsigned int)floor(fmod((uptime / 60.0), 60.0))
-    % (unsigned int)fmod(uptime, 60.0)
   ;
 
+  // restricted RPC does not disclose start time
+  if (ires.start_time)
+  {
+    str << boost::format(", uptime %ud %uh %um %us")
+      % (unsigned int)floor(uptime / 60.0 / 60.0 / 24.0)
+      % (unsigned int)floor(fmod((uptime / 60.0 / 60.0), 24.0))
+      % (unsigned int)floor(fmod((uptime / 60.0), 60.0))
+      % (unsigned int)fmod(uptime, 60.0)
+    ;
+  }
+
+  tools::success_msg_writer() << str.str();
+
   return true;
 }
 

From 1bbfeb325c5d160450f988feeacc2951e18fe17b Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Tue, 25 Sep 2018 09:57:24 +0000
Subject: [PATCH 18/54] tx_pool: fix tx removal at startup keeping references

---
 src/cryptonote_core/tx_pool.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 036cb7d33..9694a2a8c 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -1284,6 +1284,7 @@ namespace cryptonote
         {
           MWARNING("Failed to parse tx from txpool, removing");
           remove.push_back(txid);
+          return true;
         }
         if (!insert_key_images(tx, meta.kept_by_block))
         {

From d4f07b40de62cb1bbdbb5ddfc342a75953d51852 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Tue, 4 Sep 2018 13:00:38 +0900
Subject: [PATCH 19/54] wallet2.get_reserve_proof: throw when specified amount
 is zero

---
 src/wallet/wallet2.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index aa6c6eb1f..6b17803f8 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -8915,6 +8915,7 @@ std::string wallet2::get_reserve_proof(const boost::optional<std::pair<uint32_t,
 
   if (account_minreserve)
   {
+    THROW_WALLET_EXCEPTION_IF(account_minreserve->second == 0, error::wallet_internal_error, "Proved amount must be greater than 0");
     // minimize the number of outputs included in the proof, by only picking the N largest outputs that can cover the requested min reserve amount
     std::sort(selected_transfers.begin(), selected_transfers.end(), [&](const size_t a, const size_t b)
       { return m_transfers[a].amount() > m_transfers[b].amount(); });

From 7e6b4601c30e02c24c41b4e26b3df4ae732c9c2d Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Fri, 17 Aug 2018 17:24:24 +0000
Subject: [PATCH 20/54] tx_pool: fix infinite loop when failing to find a meta
 record

---
 src/cryptonote_core/tx_pool.cpp | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 9694a2a8c..044a66953 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -1095,7 +1095,7 @@ namespace cryptonote
     LockedTXN lock(m_blockchain);
 
     auto sorted_it = m_txs_by_fee_and_receive_time.begin();
-    while (sorted_it != m_txs_by_fee_and_receive_time.end())
+    for (; sorted_it != m_txs_by_fee_and_receive_time.end(); ++sorted_it)
     {
       txpool_tx_meta_t meta;
       if (!m_blockchain.get_txpool_tx_meta(sorted_it->second, meta))
@@ -1109,7 +1109,6 @@ namespace cryptonote
       if (max_total_size < total_size + meta.blob_size)
       {
         LOG_PRINT_L2("  would exceed maximum block size");
-        sorted_it++;
         continue;
       }
 
@@ -1122,14 +1121,12 @@ namespace cryptonote
         if(!get_block_reward(median_size, total_size + meta.blob_size, already_generated_coins, block_reward, version))
         {
           LOG_PRINT_L2("  would exceed maximum block size");
-          sorted_it++;
           continue;
         }
         coinbase = block_reward + fee + meta.fee;
         if (coinbase < template_accept_threshold(best_coinbase))
         {
           LOG_PRINT_L2("  would decrease coinbase to " << print_money(coinbase));
-          sorted_it++;
           continue;
         }
       }
@@ -1173,13 +1170,11 @@ namespace cryptonote
       if (!ready)
       {
         LOG_PRINT_L2("  not ready to go");
-        sorted_it++;
         continue;
       }
       if (have_key_images(k_images, tx))
       {
         LOG_PRINT_L2("  key images already seen");
-        sorted_it++;
         continue;
       }
 
@@ -1188,7 +1183,6 @@ namespace cryptonote
       fee += meta.fee;
       best_coinbase = coinbase;
       append_key_images(k_images, tx);
-      sorted_it++;
       LOG_PRINT_L2("  added, new block size " << total_size << "/" << max_total_size << ", coinbase " << print_money(best_coinbase));
     }
 

From c4bdd5699cf5dc086a56e379d086c29e1964d737 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Thu, 16 Aug 2018 18:15:47 +0000
Subject: [PATCH 21/54] epee: some speedup in parsing

---
 contrib/epee/include/storages/parserse_base_utils.h | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/contrib/epee/include/storages/parserse_base_utils.h b/contrib/epee/include/storages/parserse_base_utils.h
index c809392f4..8c6c1a64d 100644
--- a/contrib/epee/include/storages/parserse_base_utils.h
+++ b/contrib/epee/include/storages/parserse_base_utils.h
@@ -28,6 +28,8 @@
 
 #pragma once 
 
+#include <algorithm>
+
 namespace epee 
 {
 namespace misc_utils
@@ -36,8 +38,12 @@ namespace misc_utils
   {
     inline std::string transform_to_escape_sequence(const std::string& src)
     {
-      //std::stringstream res;
+      static const char escaped[] = "\b\f\n\r\t\v\"\\/";
+      if (std::find_first_of(src.begin(), src.end(), escaped, escaped + sizeof(escaped)) == src.end())
+        return src;
+
       std::string res;
+      res.reserve(2 * src.size());
       for(std::string::const_iterator it = src.begin(); it!=src.end(); ++it)
       {
         switch(*it)
@@ -84,6 +90,7 @@ namespace misc_utils
       inline void match_string2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
       {
         val.clear();
+        val.reserve(std::distance(star_end_string, buf_end));
         bool escape_mode = false;
         std::string::const_iterator it = star_end_string;
         ++it;

From 47f7cf68aeaf51838cc794297e4693fc94a80275 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Thu, 16 Aug 2018 18:15:07 +0000
Subject: [PATCH 22/54] epee: resize vectors where possible in serialization

to avoid unnecessary repeated reallocation
---
 .../serialization/keyvalue_serialization_overloads.h        | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
index 7087136cc..db4b1af5e 100644
--- a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
+++ b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
@@ -35,6 +35,11 @@
 
 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
   {
 
@@ -158,6 +163,7 @@ namespace epee
           false, 
           "size in blob " << loaded_size << " not have not zero modulo for sizeof(value_type) = " << sizeof(typename stl_container::value_type));
         size_t count = (loaded_size/sizeof(typename stl_container::value_type));
+        hint_resize(container, count);
         for(size_t i = 0; i < count; i++)
           container.insert(container.end(), *(pelem++));
       }

From 00c6056e9879183f3ad41161f0228c98534dac76 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Wed, 15 Aug 2018 12:15:39 +0000
Subject: [PATCH 23/54] simplewallet: allow named priority levels for
 default-priority

to match those used by the various transfer functions
---
 src/simplewallet/simplewallet.cpp | 46 +++++++++++++++++++++++++------
 1 file changed, 37 insertions(+), 9 deletions(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 22901d030..455e1fda6 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -525,6 +525,18 @@ bool parse_priority(const std::string& arg, uint32_t& priority)
   return false;
 }
 
+std::string join_priority_strings(const char *delimiter)
+{
+  std::string s;
+  for (size_t n = 0; n < allowed_priority_strings.size(); ++n)
+  {
+    if (!s.empty())
+      s += delimiter;
+    s += allowed_priority_strings[n];
+  }
+  return s;
+}
+
 std::string simple_wallet::get_commands_str()
 {
   std::stringstream ss;
@@ -1611,12 +1623,12 @@ bool simple_wallet::set_store_tx_info(const std::vector<std::string> &args/* = s
 
 bool simple_wallet::set_default_priority(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
-  int priority = 0;
+  uint32_t priority = 0;
   try
   {
     if (strchr(args[1].c_str(), '-'))
     {
-      fail_msg_writer() << tr("priority must be 0, 1, 2, 3, or 4 ");
+      fail_msg_writer() << tr("priority must be either 0, 1, 2, 3, or 4, or one of: ") << join_priority_strings(", ");
       return true;
     }
     if (args[1] == "0")
@@ -1625,11 +1637,23 @@ bool simple_wallet::set_default_priority(const std::vector<std::string> &args/*
     }
     else
     {
-      priority = boost::lexical_cast<int>(args[1]);
-      if (priority < 1 || priority > 4)
+      bool found = false;
+      for (size_t n = 0; n < allowed_priority_strings.size(); ++n)
       {
-        fail_msg_writer() << tr("priority must be 0, 1, 2, 3, or 4");
-        return true;
+        if (allowed_priority_strings[n] == args[1])
+        {
+          found = true;
+          priority = n;
+        }
+      }
+      if (!found)
+      {
+        priority = boost::lexical_cast<int>(args[1]);
+        if (priority < 1 || priority > 4)
+        {
+          fail_msg_writer() << tr("priority must be either 0, 1, 2, 3, or 4, or one of: ") << join_priority_strings(", ");
+          return true;
+        }
       }
     }
  
@@ -1643,7 +1667,7 @@ bool simple_wallet::set_default_priority(const std::vector<std::string> &args/*
   }
   catch(const boost::bad_lexical_cast &)
   {
-    fail_msg_writer() << tr("priority must be 0, 1, 2, 3, or 4");
+    fail_msg_writer() << tr("priority must be either 0, 1, 2, 3, or 4, or one of: ") << join_priority_strings(", ");
     return true;
   }
   catch(...)
@@ -2312,13 +2336,17 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
     std::string seed_language = m_wallet->get_seed_language();
     if (m_use_english_language_names)
       seed_language = crypto::ElectrumWords::get_english_name_for(seed_language);
+    std::string priority_string = "invalid";
+    uint32_t priority = m_wallet->get_default_priority();
+    if (priority < allowed_priority_strings.size())
+      priority_string = allowed_priority_strings[priority];
     success_msg_writer() << "seed = " << seed_language;
     success_msg_writer() << "always-confirm-transfers = " << m_wallet->always_confirm_transfers();
     success_msg_writer() << "print-ring-members = " << m_wallet->print_ring_members();
     success_msg_writer() << "store-tx-info = " << m_wallet->store_tx_info();
     success_msg_writer() << "auto-refresh = " << m_wallet->auto_refresh();
     success_msg_writer() << "refresh-type = " << get_refresh_type_name(m_wallet->get_refresh_type());
-    success_msg_writer() << "priority = " << m_wallet->get_default_priority();
+    success_msg_writer() << "priority = " << priority<< " (" << priority_string << ")";
     success_msg_writer() << "confirm-missing-payment-id = " << m_wallet->confirm_missing_payment_id();
     success_msg_writer() << "ask-password = " << m_wallet->ask_password();
     success_msg_writer() << "unit = " << cryptonote::get_unit(cryptonote::get_default_decimal_point());
@@ -2372,7 +2400,7 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
     CHECK_SIMPLE_VARIABLE("store-tx-info", set_store_tx_info, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("auto-refresh", set_auto_refresh, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("refresh-type", set_refresh_type, tr("full (slowest, no assumptions); optimize-coinbase (fast, assumes the whole coinbase is paid to a single address); no-coinbase (fastest, assumes we receive no coinbase transaction), default (same as optimize-coinbase)"));
-    CHECK_SIMPLE_VARIABLE("priority", set_default_priority, tr("0, 1, 2, 3, or 4"));
+    CHECK_SIMPLE_VARIABLE("priority", set_default_priority, tr("0, 1, 2, 3, or 4, or one of ") << join_priority_strings(", "));
     CHECK_SIMPLE_VARIABLE("confirm-missing-payment-id", set_confirm_missing_payment_id, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("ask-password", set_ask_password, tr("0 or 1"));
     CHECK_SIMPLE_VARIABLE("unit", set_unit, tr("wownero, millinero, micronero, nanonero, piconero"));

From bbd251c48fd74c01ec130d5b35737a12c2840575 Mon Sep 17 00:00:00 2001
From: rbrunner7 <rbrunner@dreamshare.ch>
Date: Sun, 12 Aug 2018 14:49:32 +0200
Subject: [PATCH 24/54] simplewallet: Simplify LOCK_IDLE_SCOPE macro

---
 src/simplewallet/simplewallet.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 455e1fda6..36f1278df 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -93,13 +93,8 @@ typedef cryptonote::simple_wallet sw;
   m_auto_refresh_enabled.store(false, std::memory_order_relaxed); \
   /* stop any background refresh, and take over */ \
   m_wallet->stop(); \
-  m_idle_mutex.lock(); \
-  while (m_auto_refresh_refreshing) \
-    m_idle_cond.notify_one(); \
-  m_idle_mutex.unlock(); \
-/*  if (auto_refresh_run)*/ \
-    /*m_auto_refresh_thread.join();*/ \
   boost::unique_lock<boost::mutex> lock(m_idle_mutex); \
+  m_idle_cond.notify_all(); \
   epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ \
     m_auto_refresh_enabled.store(auto_refresh_enabled, std::memory_order_relaxed); \
   })

From 9021fe99b188a6eb7ad6c0d7cc8bb1843c08e68d Mon Sep 17 00:00:00 2001
From: fireice-uk <fireice-uk@users.noreply.github.com>
Date: Fri, 10 Aug 2018 16:49:18 +0200
Subject: [PATCH 25/54] node_rpc_proxy: fix fork earliest height caching [RYO
 backport]

xref https://github.com/ryo-currency/ryo-currency/pull/86
---
 src/wallet/node_rpc_proxy.cpp | 2 +-
 src/wallet/wallet2.cpp        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/wallet/node_rpc_proxy.cpp b/src/wallet/node_rpc_proxy.cpp
index c5d869354..3ac7d4406 100644
--- a/src/wallet/node_rpc_proxy.cpp
+++ b/src/wallet/node_rpc_proxy.cpp
@@ -146,7 +146,7 @@ boost::optional<std::string> NodeRPCProxy::get_earliest_height(uint8_t version,
     CHECK_AND_ASSERT_MES(r, std::string(), "Failed to connect to daemon");
     CHECK_AND_ASSERT_MES(resp_t.status != CORE_RPC_STATUS_BUSY, resp_t.status, "Failed to connect to daemon");
     CHECK_AND_ASSERT_MES(resp_t.status == CORE_RPC_STATUS_OK, resp_t.status, "Failed to get hard fork status");
-    m_earliest_height[version] = resp_t.enabled ? resp_t.earliest_height : std::numeric_limits<uint64_t>::max();
+    m_earliest_height[version] = resp_t.earliest_height;
   }
 
   earliest_height = m_earliest_height[version];
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 6b17803f8..38f78582a 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -8132,7 +8132,7 @@ bool wallet2::use_fork_rules(uint8_t version, int64_t early_blocks) const
   result = m_node_rpc_proxy.get_earliest_height(version, earliest_height);
   throw_on_rpc_response_error(result, "get_hard_fork_info");
 
-  bool close_enough = height >=  earliest_height - early_blocks && earliest_height != std::numeric_limits<uint64_t>::max(); // start using the rules that many blocks beforehand
+  bool close_enough = height >=  earliest_height - early_blocks; // start using the rules that many blocks beforehand
   if (close_enough)
     LOG_PRINT_L2("Using v" << (unsigned)version << " rules");
   else

From 835caf37222355b8e5c215b083291d5b02f12254 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Tue, 7 Aug 2018 12:48:04 +0000
Subject: [PATCH 26/54] simplewallet: add a warning and prompt on
 rescan_blockchain

Many people are using this as a "let's see what this does" command
when something doesn't work as they thought it should, and thus
destroying info that they might still need.
---
 src/simplewallet/simplewallet.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 36f1278df..3bf86a4e4 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -2201,7 +2201,7 @@ simple_wallet::simple_wallet()
                            tr("Show the unspent outputs of a specified address within an optional amount range."));
   m_cmd_binder.set_handler("rescan_bc",
                            boost::bind(&simple_wallet::rescan_blockchain, this, _1),
-                           tr("Rescan the blockchain from scratch."));
+                           tr("Rescan the blockchain from scratch, losing any information which can not be recovered from the blockchain itself."));
   m_cmd_binder.set_handler("set_tx_note",
                            boost::bind(&simple_wallet::set_tx_note, this, _1),
                            tr("set_tx_note <txid> [free text note]"),
@@ -6332,6 +6332,14 @@ bool simple_wallet::unspent_outputs(const std::vector<std::string> &args_)
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::rescan_blockchain(const std::vector<std::string> &args_)
 {
+  message_writer() << tr("Warning: this will lose any information which can not be recovered from the blockchain.");
+  message_writer() << tr("This includes destination addresses, tx secret keys, tx notes, etc");
+  std::string confirm = input_line(tr("Rescan anyway ? (Y/Yes/N/No): "));
+  if(!std::cin.eof())
+  {
+    if (!command_line::is_yes(confirm))
+      return true;
+  }
   return refresh_main(0, true);
 }
 //----------------------------------------------------------------------------------------------------

From bb0ac27a4a624f59deb7b083f4291c263df5d219 Mon Sep 17 00:00:00 2001
From: rbrunner7 <rbrunner@dreamshare.ch>
Date: Sun, 5 Aug 2018 09:58:33 +0200
Subject: [PATCH 27/54] simplewallet: correct number of human-readable months

---
 src/simplewallet/simplewallet.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 3bf86a4e4..2679c2bfe 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -6006,7 +6006,7 @@ static std::string get_human_readable_timespan(std::chrono::seconds seconds)
   if (ts < 3600 * 24 * 30.5)
     return std::to_string((uint64_t)(ts / (3600 * 24))) + tr(" days");
   if (ts < 3600 * 24 * 365.25)
-    return std::to_string((uint64_t)(ts / (3600 * 24 * 365.25))) + tr(" months");
+    return std::to_string((uint64_t)(ts / (3600 * 24 * 30.5))) + tr(" months");
   return tr("a long time");
 }
 //----------------------------------------------------------------------------------------------------

From b491ff61c5801d78737b1ae069175c3749309481 Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Wed, 25 Jul 2018 23:00:19 +0100
Subject: [PATCH 28/54] epee: set jsonrpc to "2.0" in parse error return data

---
 contrib/epee/include/net/http_server_handlers_map2.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/epee/include/net/http_server_handlers_map2.h b/contrib/epee/include/net/http_server_handlers_map2.h
index 429e3e1af..00a867d3e 100644
--- a/contrib/epee/include/net/http_server_handlers_map2.h
+++ b/contrib/epee/include/net/http_server_handlers_map2.h
@@ -122,6 +122,7 @@
     if(!ps.load_from_json(query_info.m_body)) \
     { \
        boost::value_initialized<epee::json_rpc::error_response> rsp; \
+       static_cast<epee::json_rpc::error_response&>(rsp).jsonrpc = "2.0"; \
        static_cast<epee::json_rpc::error_response&>(rsp).error.code = -32700; \
        static_cast<epee::json_rpc::error_response&>(rsp).error.message = "Parse error"; \
        epee::serialization::store_t_to_json(static_cast<epee::json_rpc::error_response&>(rsp), response_info.m_body); \

From 308a8f69adf8bcbb2e550261fd53105d418c7534 Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Tue, 24 Jul 2018 16:17:49 +0900
Subject: [PATCH 29/54] daemon.print_bc: don't print difficulty twice

---
 src/daemon/rpc_command_executor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/daemon/rpc_command_executor.cpp b/src/daemon/rpc_command_executor.cpp
index f7b77233f..8af512208 100644
--- a/src/daemon/rpc_command_executor.cpp
+++ b/src/daemon/rpc_command_executor.cpp
@@ -564,7 +564,7 @@ bool t_rpc_command_executor::print_blockchain_info(uint64_t start_block_index, u
     if (!first)
       std::cout << std::endl;
     std::cout
-      << "height: " << header.height << ", timestamp: " << header.timestamp << ", difficulty: " << header.difficulty
+      << "height: " << header.height << ", timestamp: " << header.timestamp
       << ", size: " << header.block_size << ", transactions: " << header.num_txes << std::endl
       << "major version: " << (unsigned)header.major_version << ", minor version: " << (unsigned)header.minor_version << std::endl
       << "block id: " << header.hash << ", previous block id: " << header.prev_hash << std::endl

From b40a81c6946a2961542922310d3828d04531063e Mon Sep 17 00:00:00 2001
From: moneromooo-monero <moneromooo-monero@users.noreply.github.com>
Date: Fri, 23 Mar 2018 15:43:38 +0000
Subject: [PATCH 30/54] wallet2: use a gamma distribution to pick fake outs

as per "An Empirical Analysis of Linkability in the Monero
Blockchain", by Miller et al.
---
 src/wallet/wallet2.cpp | 143 ++++++++++++++++++++++++++++++++---------
 src/wallet/wallet2.h   |   2 +-
 2 files changed, 115 insertions(+), 30 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 38f78582a..f9ea304d2 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -2398,7 +2398,7 @@ bool wallet2::refresh(uint64_t & blocks_fetched, bool& received_money, bool& ok)
   return ok;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_output_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution)
+bool wallet2::get_rct_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution)
 {
   uint32_t rpc_version;
   boost::optional<std::string> result = m_node_rpc_proxy.get_rpc_version(rpc_version);
@@ -5922,22 +5922,42 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     bool is_shortly_after_segregation_fork = height >= segregation_fork_height && height < segregation_fork_height + SEGREGATION_FORK_VICINITY;
     bool is_after_segregation_fork = height >= segregation_fork_height;
 
+    // if we have at least one rct out, get the distribution, or fall back to the previous system
+    uint64_t rct_start_height;
+    std::vector<uint64_t> rct_offsets;
+    bool has_rct = false;
+    for (size_t idx: selected_transfers)
+      if (m_transfers[idx].is_rct())
+        { has_rct = true; break; }
+    const bool has_rct_distribution = has_rct && get_rct_distribution(rct_start_height, rct_offsets);
+    if (has_rct_distribution)
+    {
+      // check we're clear enough of rct start, to avoid corner cases below
+      THROW_WALLET_EXCEPTION_IF(rct_offsets.size() <= CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE,
+          error::get_output_distribution, "Not enough rct outputs");
+    }
+
     // get histogram for the amounts we need
     cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t = AUTO_VAL_INIT(req_t);
     cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t = AUTO_VAL_INIT(resp_t);
-    m_daemon_rpc_mutex.lock();
+    // request histogram for all outputs, except 0 if we have the rct distribution
     for(size_t idx: selected_transfers)
-      req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
-    std::sort(req_t.amounts.begin(), req_t.amounts.end());
-    auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
-    req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
-    req_t.unlocked = true;
-    req_t.recent_cutoff = time(NULL) - RECENT_OUTPUT_ZONE;
-    bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, m_http_client, rpc_timeout);
-    m_daemon_rpc_mutex.unlock();
-    THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
-    THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
-    THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
+      if (!m_transfers[idx].is_rct() || !has_rct_distribution)
+        req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
+    if (!req_t.amounts.empty())
+    {
+      std::sort(req_t.amounts.begin(), req_t.amounts.end());
+      auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
+      req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
+      req_t.unlocked = true;
+      req_t.recent_cutoff = time(NULL) - RECENT_OUTPUT_ZONE;
+      m_daemon_rpc_mutex.lock();
+      bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, m_http_client, rpc_timeout);
+      m_daemon_rpc_mutex.unlock();
+      THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
+      THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
+      THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
+    }
 
     // if we want to segregate fake outs pre or post fork, get distribution
     std::unordered_map<uint64_t, std::pair<uint64_t, uint64_t>> segregation_limit;
@@ -5993,6 +6013,36 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     COMMAND_RPC_GET_OUTPUTS_BIN::request req = AUTO_VAL_INIT(req);
     COMMAND_RPC_GET_OUTPUTS_BIN::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
 
+    struct gamma_engine
+    {
+      typedef uint64_t result_type;
+      static constexpr result_type min() { return 0; }
+      static constexpr result_type max() { return std::numeric_limits<result_type>::max(); }
+      result_type operator()() { return crypto::rand<result_type>(); }
+    } engine;
+    static const double shape = 19.28/*16.94*/;
+    //static const double shape = m_testnet ? 17.02 : 17.28;
+    static const double scale = 1/1.61;
+    std::gamma_distribution<double> gamma(shape, scale);
+    auto pick_gamma = [&]()
+    {
+      double x = gamma(engine);
+      x = exp(x);
+      uint64_t block_offset = x / DIFFICULTY_TARGET_V2; // this assumes constant target over the whole rct range
+      if (block_offset >= rct_offsets.size() - 1)
+        return std::numeric_limits<uint64_t>::max(); // bad pick
+      block_offset = rct_offsets.size() - 2 - block_offset;
+      THROW_WALLET_EXCEPTION_IF(block_offset >= rct_offsets.size() - 1, error::wallet_internal_error, "Bad offset calculation");
+      THROW_WALLET_EXCEPTION_IF(rct_offsets[block_offset + 1] < rct_offsets[block_offset],
+          error::get_output_distribution, "Decreasing offsets in rct distribution: " +
+          std::to_string(block_offset) + ": " + std::to_string(rct_offsets[block_offset]) + ", " +
+          std::to_string(block_offset + 1) + ": " + std::to_string(rct_offsets[block_offset + 1]));
+      uint64_t n_rct = rct_offsets[block_offset + 1] - rct_offsets[block_offset];
+      if (n_rct == 0)
+        return rct_offsets[block_offset] ? rct_offsets[block_offset] - 1 : 0;
+      return rct_offsets[block_offset] + crypto::rand<uint64_t>() % n_rct;
+    };
+
     size_t num_selected_transfers = 0;
     for(size_t idx: selected_transfers)
     {
@@ -6003,6 +6053,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
       // request more for rct in base recent (locked) coinbases are picked, since they're locked for longer
       size_t requested_outputs_count = base_requested_outputs_count + (td.is_rct() ? CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE : 0);
       size_t start = req.outputs.size();
+      bool use_histogram = amount != 0 || !has_rct_distribution;
 
       const bool output_is_pre_fork = td.m_block_height < segregation_fork_height;
       uint64_t num_outs = 0, num_recent_outs = 0;
@@ -6058,26 +6109,41 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
         num_post_fork_outs = num_outs - segregation_limit[amount].first;
       }
 
-      LOG_PRINT_L1("" << num_outs << " unlocked outputs of size " << print_money(amount));
-      THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
-          "histogram reports no unlocked outputs for " + boost::lexical_cast<std::string>(amount) + ", not even ours");
-      THROW_WALLET_EXCEPTION_IF(num_recent_outs > num_outs, error::wallet_internal_error,
-          "histogram reports more recent outs than outs for " + boost::lexical_cast<std::string>(amount));
+      if (use_histogram)
+      {
+        LOG_PRINT_L1("" << num_outs << " unlocked outputs of size " << print_money(amount));
+        THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
+            "histogram reports no unlocked outputs for " + boost::lexical_cast<std::string>(amount) + ", not even ours");
+        THROW_WALLET_EXCEPTION_IF(num_recent_outs > num_outs, error::wallet_internal_error,
+            "histogram reports more recent outs than outs for " + boost::lexical_cast<std::string>(amount));
+      }
+      else
+      {
+        // the base offset of the first rct output in the first unlocked block (or the one to be if there's none)
+        num_outs = rct_offsets[rct_offsets.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE];
+        LOG_PRINT_L1("" << num_outs << " unlocked rct outputs");
+        THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
+            "histogram reports no unlocked rct outputs, not even ours");
+      }
 
-      // how many fake outs to draw on a pre-fork triangular distribution
+      // how many fake outs to draw on a pre-fork distribution
       size_t pre_fork_outputs_count = requested_outputs_count * pre_fork_num_out_ratio;
       size_t post_fork_outputs_count = requested_outputs_count * post_fork_num_out_ratio;
       // how many fake outs to draw otherwise
       size_t normal_output_count = requested_outputs_count - pre_fork_outputs_count - post_fork_outputs_count;
 
-      // X% of those outs are to be taken from recent outputs
-      size_t recent_outputs_count = normal_output_count * RECENT_OUTPUT_RATIO;
-      if (recent_outputs_count == 0)
-        recent_outputs_count = 1; // ensure we have at least one, if possible
-      if (recent_outputs_count > num_recent_outs)
-        recent_outputs_count = num_recent_outs;
-      if (td.m_global_output_index >= num_outs - num_recent_outs && recent_outputs_count > 0)
-        --recent_outputs_count; // if the real out is recent, pick one less recent fake out
+      size_t recent_outputs_count = 0;
+      if (use_histogram)
+      {
+        // X% of those outs are to be taken from recent outputs
+        recent_outputs_count = normal_output_count * RECENT_OUTPUT_RATIO;
+        if (recent_outputs_count == 0)
+          recent_outputs_count = 1; // ensure we have at least one, if possible
+        if (recent_outputs_count > num_recent_outs)
+          recent_outputs_count = num_recent_outs;
+        if (td.m_global_output_index >= num_outs - num_recent_outs && recent_outputs_count > 0)
+          --recent_outputs_count; // if the real out is recent, pick one less recent fake out
+      }
       LOG_PRINT_L1("Fake output makeup: " << requested_outputs_count << " requested: " << recent_outputs_count << " recent, " <<
           pre_fork_outputs_count << " pre-fork, " << post_fork_outputs_count << " post-fork, " <<
           (requested_outputs_count - recent_outputs_count - pre_fork_outputs_count - post_fork_outputs_count) << " full-chain");
@@ -6157,7 +6223,26 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
 
           uint64_t i;
           const char *type = "";
-          if (num_found - 1 < recent_outputs_count) // -1 to account for the real one we seeded with
+          if (amount == 0 && has_rct_distribution)
+          {
+            // gamma distribution
+            if (num_found -1 < recent_outputs_count + pre_fork_outputs_count)
+            {
+              do i = pick_gamma(); while (i >= segregation_limit[amount].first);
+              type = "pre-fork gamma";
+            }
+            else if (num_found -1 < recent_outputs_count + pre_fork_outputs_count + post_fork_outputs_count)
+            {
+              do i = pick_gamma(); while (i < segregation_limit[amount].first || i >= num_outs);
+              type = "post-fork gamma";
+            }
+            else
+            {
+              do i = pick_gamma(); while (i >= num_outs);
+              type = "gamma";
+            }
+          }
+          else if (num_found - 1 < recent_outputs_count) // -1 to account for the real one we seeded with
           {
             // triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
             uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
@@ -6222,7 +6307,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
 
     // get the keys for those
     m_daemon_rpc_mutex.lock();
-    r = epee::net_utils::invoke_http_bin("/get_outs.bin", req, daemon_resp, m_http_client, rpc_timeout);
+    bool r = epee::net_utils::invoke_http_bin("/get_outs.bin", req, daemon_resp, m_http_client, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index af4c9ad8e..c6ae2e29f 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -1139,7 +1139,7 @@ namespace tools
     bool remove_rings(const cryptonote::transaction_prefix &tx);
     bool get_ring(const crypto::chacha_key &key, const crypto::key_image &key_image, std::vector<uint64_t> &outs);
 
-    bool get_output_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution);
+    bool get_rct_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution);
 
     uint64_t get_segregation_fork_height() const;
 

From 5c3195dac9c2f2c173e97a41e186ebbf409eb8c3 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Mon, 22 Oct 2018 23:30:04 +0300
Subject: [PATCH 31/54] up version to 0.3.1

---
 README.md          | 2 +-
 src/version.cpp.in | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8048a9710..385246d89 100644
--- a/README.md
+++ b/README.md
@@ -95,7 +95,7 @@ Dates are provided in the format YYYY-MM-DD.
 | ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
 | 1                              | 2018-04-01 | v7                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 6969                           | 2018-04-24 | v8                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
-| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.0.1                  | Cryptonight variant 2, LWMA v2, ringsize = 22, XXX
+| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.0                  | Cryptonight variant 2, LWMA v2, ringsize = 22, XXX
 
 X's indicate that these details have not been determined as of commit date.
 
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 406c08dcf..e316851c6 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.0.1-master"
+#define DEF_MONERO_VERSION "0.3.1.0"
 #define DEF_MONERO_RELEASE_NAME "Cool Cage"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 

From 88fd5fb494f77c6313bbb94cadb58632d60e5c31 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Mon, 22 Oct 2018 23:40:29 +0300
Subject: [PATCH 32/54] increase minimum difficulty to 25 million

---
 src/cryptonote_config.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index 40f637d18..82408aab3 100755
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -83,7 +83,7 @@
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG
 #define DIFFICULTY_HEIGHT                               53666 // v9 fork height
 #define DIFFICULTY_GUESS                                40000000 // difficulty at fork 40m
-#define DIFFICULTY_MINIMUM                              10000000 // minimum difficulty set to 10m
+#define DIFFICULTY_MINIMUM                              25000000 // minimum difficulty set to 25m
 #define DIFFICULTY_TESTNET_HEIGHT                       100
 #define DIFFICULTY_TESTNET_GUESS                        5069
 #define DIFFICULTY_TESTNET_MINIMUM                      4069

From 17cd68f86505987e3f27a59fe67728e7042b869f Mon Sep 17 00:00:00 2001
From: stoffu <stoffu@protonmail.ch>
Date: Thu, 18 Oct 2018 08:01:56 +0900
Subject: [PATCH 33/54] tx_pool: revert #4592 and move bin2hex conversion to
 on_get_transaction_pool

---
 src/cryptonote_core/tx_pool.cpp | 2 +-
 src/rpc/core_rpc_server.cpp     | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/cryptonote_core/tx_pool.cpp b/src/cryptonote_core/tx_pool.cpp
index 044a66953..3be08b327 100644
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@@ -746,7 +746,7 @@ namespace cryptonote
     m_blockchain.for_all_txpool_txes([&tx_infos, key_image_infos, include_sensitive_data](const crypto::hash &txid, const txpool_tx_meta_t &meta, const cryptonote::blobdata *bd){
       tx_info txi;
       txi.id_hash = epee::string_tools::pod_to_hex(txid);
-      txi.tx_blob = epee::string_tools::buff_to_hex_nodelimer(*bd);
+      txi.tx_blob = *bd;
       transaction tx;
       if (!parse_and_validate_tx_from_blob(*bd, tx))
       {
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 8617c7e28..635caeb16 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -998,6 +998,8 @@ namespace cryptonote
       return r;
 
     m_core.get_pool_transactions_and_spent_keys_info(res.transactions, res.spent_key_images, !request_has_rpc_origin || !m_restricted);
+    for (tx_info& txi : res.transactions)
+      txi.tx_blob = epee::string_tools::buff_to_hex_nodelimer(txi.tx_blob);
     res.status = CORE_RPC_STATUS_OK;
     return true;
   }

From d2554341b1e834974bf99283dd00ebe6d0b72980 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 24 Oct 2018 13:03:02 +0300
Subject: [PATCH 34/54] difficulty: remove testnet variables

---
 src/cryptonote_basic/difficulty.cpp | 11 ++---------
 src/cryptonote_config.h             |  3 ---
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index 5ec281d35..796bd5a7f 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -256,14 +256,10 @@ namespace cryptonote {
 
     assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= static_cast<uint64_t>(N+1) );
 
-    if ( cryptonote::MAINNET && height <= DIFFICULTY_HEIGHT ){ 
+    if ( height <= DIFFICULTY_HEIGHT ){ 
       return static_cast<uint64_t>(DIFFICULTY_GUESS); 
     }
 
-    if ( cryptonote::TESTNET && height <= DIFFICULTY_TESTNET_HEIGHT ){ 
-      return static_cast<uint64_t>(DIFFICULTY_TESTNET_GUESS);
-    }
-
     for ( int64_t i = 1; i <= N; i++ ) {  
       ST = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i-1]);
       ST = std::max(-4*T, std::min(ST, 6*T));
@@ -281,12 +277,9 @@ namespace cryptonote {
       next_D = std::max(next_D,(prev_D*108)/100); 
     }
 
-    if ( cryptonote::MAINNET && next_D < DIFFICULTY_MINIMUM ) { 
+    if ( next_D < DIFFICULTY_MINIMUM ) { 
       return static_cast<uint64_t>(DIFFICULTY_MINIMUM); 
     }
-    else if ( cryptonote::TESTNET && next_D < DIFFICULTY_TESTNET_MINIMUM ) { 
-      return static_cast<uint64_t>(DIFFICULTY_TESTNET_MINIMUM); 
-    }
     else { 
       return static_cast<uint64_t>(next_D); 
     }
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index 82408aab3..9d611b43d 100755
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -84,9 +84,6 @@
 #define DIFFICULTY_HEIGHT                               53666 // v9 fork height
 #define DIFFICULTY_GUESS                                40000000 // difficulty at fork 40m
 #define DIFFICULTY_MINIMUM                              25000000 // minimum difficulty set to 25m
-#define DIFFICULTY_TESTNET_HEIGHT                       100
-#define DIFFICULTY_TESTNET_GUESS                        5069
-#define DIFFICULTY_TESTNET_MINIMUM                      4069
 
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V1   DIFFICULTY_TARGET_V1 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V2   DIFFICULTY_TARGET_V2 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS

From f165101429620bfb70f95af011ed0810691f26c4 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 24 Oct 2018 14:37:54 +0300
Subject: [PATCH 35/54] rpc wallet: revert integrated address generation

---
 src/wallet/wallet2.cpp                       |  6 ++
 src/wallet/wallet2.h                         |  1 +
 src/wallet/wallet_rpc_server.cpp             | 63 ++++++++++++++++++++
 src/wallet/wallet_rpc_server.h               |  4 ++
 src/wallet/wallet_rpc_server_commands_defs.h | 47 +++++++++++++++
 5 files changed, 121 insertions(+)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 2c741c2e5..635f1bb41 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -906,6 +906,12 @@ std::string wallet2::get_subaddress_as_str(const cryptonote::subaddress_index& i
   cryptonote::account_public_address address = get_subaddress(index);
   return cryptonote::get_account_address_as_str(m_nettype, !index.is_zero(), address);
 }
+
+//----------------------------------------------------------------------------------------------------
+std::string wallet2::get_integrated_address_as_str(const crypto::hash8& payment_id) const
+{
+  return cryptonote::get_account_integrated_address_as_str(m_nettype, get_address(), payment_id);
+}
 //----------------------------------------------------------------------------------------------------
 void wallet2::add_subaddress_account(const std::string& label)
 {
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 8e79779a2..ed02d7a28 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -629,6 +629,7 @@ namespace tools
     std::vector<crypto::public_key> get_subaddress_spend_public_keys(uint32_t account, uint32_t begin, uint32_t end) const;
     std::string get_subaddress_as_str(const cryptonote::subaddress_index& index) const;
     std::string get_address_as_str() const { return get_subaddress_as_str({0, 0}); }
+    std::string get_integrated_address_as_str(const crypto::hash8& payment_id) const;
     void add_subaddress_account(const std::string& label);
     size_t get_num_subaddress_accounts() const { return m_subaddress_labels.size(); }
     size_t get_num_subaddresses(uint32_t index_major) const { return index_major < m_subaddress_labels.size() ? m_subaddress_labels[index_major].size() : 0; }
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 8c75031a7..d3491baae 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -1099,6 +1099,69 @@ namespace tools
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_make_integrated_address(const wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er)
+  {
+    if (!m_wallet) return not_open(er);
+    try
+    {
+      crypto::hash8 payment_id;
+      if (req.payment_id.empty())
+      {
+        payment_id = crypto::rand<crypto::hash8>();
+      }
+      else
+      {
+        if (!tools::wallet2::parse_short_payment_id(req.payment_id,payment_id))
+        {
+          er.code = WALLET_RPC_ERROR_CODE_WRONG_PAYMENT_ID;
+          er.message = "Invalid payment ID";
+          return false;
+        }
+      }
+
+      res.integrated_address = m_wallet->get_integrated_address_as_str(payment_id);
+      res.payment_id = epee::string_tools::pod_to_hex(payment_id);
+      return true;
+    }
+    catch (const std::exception& e)
+    {
+      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR);
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_split_integrated_address(const wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er)
+  {
+    if (!m_wallet) return not_open(er);
+    try
+    {
+      cryptonote::address_parse_info info;
+
+      if(!get_account_address_from_str(info, m_wallet->nettype(), req.integrated_address))
+      {
+        er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
+        er.message = "Invalid address";
+        return false;
+      }
+      if(!info.has_payment_id)
+      {
+        er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
+        er.message = "Address is not an integrated address";
+        return false;
+      }
+      res.standard_address = get_account_address_as_str(m_wallet->nettype(), info.is_subaddress, info.address);
+      res.payment_id = epee::string_tools::pod_to_hex(info.payment_id);
+      return true;
+    }
+    catch (const std::exception& e)
+    {
+      handle_rpc_exception(std::current_exception(), er, WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR);
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er)
   {
     if (!m_wallet) return not_open(er);
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
index 04e57db11..a68e12d97 100644
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@@ -95,6 +95,8 @@ namespace tools
         MAP_JON_RPC_WE("get_bulk_payments",  on_get_bulk_payments,  wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS)
         MAP_JON_RPC_WE("incoming_transfers", on_incoming_transfers, wallet_rpc::COMMAND_RPC_INCOMING_TRANSFERS)
         MAP_JON_RPC_WE("query_key",         on_query_key,         wallet_rpc::COMMAND_RPC_QUERY_KEY)
+        MAP_JON_RPC_WE("make_integrated_address", on_make_integrated_address, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS)
+        MAP_JON_RPC_WE("split_integrated_address", on_split_integrated_address, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS)
         MAP_JON_RPC_WE("stop_wallet",        on_stop_wallet,        wallet_rpc::COMMAND_RPC_STOP_WALLET)
         MAP_JON_RPC_WE("rescan_blockchain",  on_rescan_blockchain,  wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN)
         MAP_JON_RPC_WE("set_tx_notes",       on_set_tx_notes,       wallet_rpc::COMMAND_RPC_SET_TX_NOTES)
@@ -158,6 +160,8 @@ namespace tools
       bool on_sweep_all(const wallet_rpc::COMMAND_RPC_SWEEP_ALL::request& req, wallet_rpc::COMMAND_RPC_SWEEP_ALL::response& res, epee::json_rpc::error& er);
       bool on_sweep_single(const wallet_rpc::COMMAND_RPC_SWEEP_SINGLE::request& req, wallet_rpc::COMMAND_RPC_SWEEP_SINGLE::response& res, epee::json_rpc::error& er);
       bool on_relay_tx(const wallet_rpc::COMMAND_RPC_RELAY_TX::request& req, wallet_rpc::COMMAND_RPC_RELAY_TX::response& res, epee::json_rpc::error& er);
+      bool on_make_integrated_address(const wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er);
+      bool on_split_integrated_address(const wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::request& req, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS::response& res, epee::json_rpc::error& er);
       bool on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er);
       bool on_get_payments(const wallet_rpc::COMMAND_RPC_GET_PAYMENTS::request& req, wallet_rpc::COMMAND_RPC_GET_PAYMENTS::response& res, epee::json_rpc::error& er);
       bool on_get_bulk_payments(const wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::request& req, wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::response& res, epee::json_rpc::error& er);
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index e64f4a189..f264829ad 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -873,6 +873,53 @@ namespace wallet_rpc
     };
   };
 
+  struct COMMAND_RPC_MAKE_INTEGRATED_ADDRESS
+  {
+    struct request
+    {
+      std::string payment_id;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(payment_id)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string integrated_address;
+      std::string payment_id;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(integrated_address)
+        KV_SERIALIZE(payment_id)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS
+  {
+    struct request
+    {
+      std::string integrated_address;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(integrated_address)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string standard_address;
+      std::string payment_id;
+      bool is_subaddress;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(standard_address)
+        KV_SERIALIZE(payment_id)
+        KV_SERIALIZE(is_subaddress)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
 
   struct COMMAND_RPC_STOP_WALLET
   {

From f3ee225f29849b91bd09af3da9af406b9a10bf4f Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 24 Oct 2018 20:10:33 +0300
Subject: [PATCH 36/54] add lwma3

---
 src/cryptonote_basic/difficulty.cpp | 39 +++++++++++++++++++++++++++++
 src/cryptonote_basic/difficulty.h   |  1 +
 src/cryptonote_config.h             |  2 ++
 src/cryptonote_core/blockchain.cpp  | 29 ++++++++++++++-------
 4 files changed, 62 insertions(+), 9 deletions(-)

diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index 5ec281d35..eb7c65f79 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -291,4 +291,43 @@ namespace cryptonote {
       return static_cast<uint64_t>(next_D); 
     }
   }
+
+  // LWMA-3 difficulty algorithm 
+  // Copyright (c) 2017-2018 Zawy, MIT License
+  difficulty_type next_difficulty_v4(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t height) {
+
+    uint64_t  T = DIFFICULTY_TARGET_V2;
+    uint64_t  N = DIFFICULTY_WINDOW_V2;
+    uint64_t  L(0), ST, sum_3_ST(0), next_D, prev_D, this_timestamp, previous_timestamp;
+
+    assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
+
+    if ( height == DIFFICULTY_HEIGHT_V2 ){
+      return static_cast<uint64_t>(DIFFICULTY_GUESS);
+    }
+
+    previous_timestamp = timestamps[0];
+    for ( uint64_t i = 1; i <= N; i++) {
+      if ( timestamps[i] > previous_timestamp ) {
+        this_timestamp = timestamps[i];
+      } else { this_timestamp = previous_timestamp+1; }
+      ST = std::min(6*T ,this_timestamp - previous_timestamp);
+      previous_timestamp = this_timestamp;
+      L +=  ST * i ;
+      if ( i > N-3 ) { sum_3_ST += ST; }
+    }
+
+    next_D = ((cumulative_difficulties[N] - cumulative_difficulties[0])*T*(N+1)*99)/(100*2*L);
+    prev_D = cumulative_difficulties[N] - cumulative_difficulties[N-1];
+    next_D = std::max((prev_D*67)/100, std::min(next_D, (prev_D*150)/100));
+
+    if ( sum_3_ST < (8*T)/10) {  next_D = std::max(next_D,(prev_D*108)/100); }
+
+    if ( next_D < DIFFICULTY_MINIMUM ) { 
+      return static_cast<uint64_t>(DIFFICULTY_MINIMUM); 
+    }
+    else {
+      return static_cast<uint64_t>(next_D);
+    }
+  }
 }
diff --git a/src/cryptonote_basic/difficulty.h b/src/cryptonote_basic/difficulty.h
index 247896e10..550b4c164 100644
--- a/src/cryptonote_basic/difficulty.h
+++ b/src/cryptonote_basic/difficulty.h
@@ -55,4 +55,5 @@ namespace cryptonote
     difficulty_type next_difficulty(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
     difficulty_type next_difficulty_v2(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
     difficulty_type next_difficulty_v3(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t height);
+    difficulty_type next_difficulty_v4(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t height);
 }
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index 82408aab3..e9425605f 100755
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -48,6 +48,7 @@
 #define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT              60*60*2
 #define CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE             4
 
+#define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2            11
 #define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW               60
 
 // MONEY_SUPPLY - total number coins to be generated
@@ -82,6 +83,7 @@
 #define DIFFICULTY_BLOCKS_COUNT_V2                      DIFFICULTY_WINDOW_V2 + 1 // added +1 to make N=N
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG
 #define DIFFICULTY_HEIGHT                               53666 // v9 fork height
+#define DIFFICULTY_HEIGHT_V2                            777777 // v10 fork height
 #define DIFFICULTY_GUESS                                40000000 // difficulty at fork 40m
 #define DIFFICULTY_MINIMUM                              25000000 // minimum difficulty set to 25m
 #define DIFFICULTY_TESTNET_HEIGHT                       100
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index d762d3dfb..f5c68c64c 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -838,8 +838,11 @@ difficulty_type Blockchain::get_difficulty_for_next_block()
   else if (version == 8) {
     return next_difficulty_v2(timestamps, difficulties, target);
     }
-  else {
+  else if (version == 9) {
     return next_difficulty_v3(timestamps, difficulties, height);
+    }
+  else {
+    return next_difficulty_v4(timestamps, difficulties, height);
   }
 }
 //------------------------------------------------------------------
@@ -1056,9 +1059,12 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
   } 
   else if (version == 8) {
     return next_difficulty_v2(timestamps, cumulative_difficulties, target);
-  }  
+  }
+  else if (version == 9) {
+    return next_difficulty_v2(timestamps, cumulative_difficulties, height);
+  }    
   else {
-    return next_difficulty_v3(timestamps, cumulative_difficulties, height);
+    return next_difficulty_v4(timestamps, cumulative_difficulties, height);
   }
 }
 
@@ -1350,12 +1356,13 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
 bool Blockchain::complete_timestamps_vector(uint64_t start_top_height, std::vector<uint64_t>& timestamps)
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
-
-  if(timestamps.size() >= BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW)
+  const uint8_t hf_version = m_hardfork->get_current_version();
+  size_t blockchain_timestamp_check_window = hf_version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  if(timestamps.size() >= blockchain_timestamp_check_window)
     return true;
 
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
-  size_t need_elements = BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW - timestamps.size();
+  size_t need_elements = blockchain_timestamp_check_window - timestamps.size();
   CHECK_AND_ASSERT_MES(start_top_height < m_db->height(), false, "internal error: passed start_height not < " << " m_db->height() -- " << start_top_height << " >= " << m_db->height());
   size_t stop_offset = start_top_height > need_elements ? start_top_height - need_elements : 0;
   while (start_top_height != stop_offset)
@@ -3203,10 +3210,12 @@ bool Blockchain::check_block_timestamp(std::vector<uint64_t>& timestamps, const
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
   median_ts = epee::misc_utils::median(timestamps);
+  const uint8_t hf_version = m_hardfork->get_current_version();
+  size_t blockchain_timestamp_check_window = hf_version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
 
   if(b.timestamp < median_ts)
   {
-    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts);
+    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << blockchain_timestamp_check_window << " blocks, " << median_ts);
     return false;
   }
 
@@ -3224,6 +3233,8 @@ bool Blockchain::check_block_timestamp(const block& b, uint64_t& median_ts) cons
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
   uint64_t cryptonote_block_future_time_limit = get_current_hard_fork_version() >= 8 ? CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V2 : CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT;
+  const uint8_t hf_version = m_hardfork->get_current_version();
+  size_t blockchain_timestamp_check_window = hf_version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
   if(b.timestamp > get_adjusted_time() + cryptonote_block_future_time_limit)
   {
     MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than adjusted time + 10 minutes");
@@ -3231,7 +3242,7 @@ bool Blockchain::check_block_timestamp(const block& b, uint64_t& median_ts) cons
   }
 
   // if not enough blocks, no proper median yet, return true
-  if(m_db->height() < BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW)
+  if(m_db->height() < blockchain_timestamp_check_window)
   {
     return true;
   }
@@ -3240,7 +3251,7 @@ bool Blockchain::check_block_timestamp(const block& b, uint64_t& median_ts) cons
   auto h = m_db->height();
 
   // need most recent 60 blocks, get index of first of those
-  size_t offset = h - BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  size_t offset = h - blockchain_timestamp_check_window;
   for(;offset < h; ++offset)
   {
     timestamps.push_back(m_db->get_block_timestamp(offset));

From a8790e240c69f51ef63cc2ad8a152aee4510d3ee Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Thu, 25 Oct 2018 19:14:26 +0300
Subject: [PATCH 37/54] update checkpoints

---
 src/blocks/checkpoints.dat         | Bin 6820 -> 7364 bytes
 src/checkpoints/checkpoints.cpp    |   3 +++
 src/cryptonote_core/blockchain.cpp |   2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index fce6c1d4d2ad26993cf781f68309b521643ee9b3..ae16639799f48f9f6caf1d0715352dbab25a8560 100644
GIT binary patch
delta 559
zcmV+~0?_@WHN-gq=CJ{z8h<Id@BT9;At+|vM7L|igh&o7Z;gjPGh%9T!-aQG6Kyd)
zv<d6OK2_j|m>WhpV{Ef)uc{Dh3-(ZjS|s-wL+fW3Y0t9Iv-JuROzF1Eselx)<np)<
zuSBXBCc4MA6`El8V?jaM{Lcf@U^(2#NPtX`&zi8>+O<;}pOojy(|=NsRf?FX&ONbm
z7*wZ?<C+xp3VfWsOpkk{f;gfNBlP*Q#0Ab8sVmATN=b%x5})W(<AHB6YiIu?Difu3
zH946>Rb(L!FTLOSiN<7TvfZr>6D+YOY-Q!(26^%kU7hqb*u^3+si+`6$xATBH9IU(
zPcQ=#xU$0POUkxs4}W2bolhR(e*$vwe+I=XA+f3vlEJuLWX5!;^=UCTLFEU~M^}3L
zuh7qp7{7X3yNxxomS1~9D|%#WvHRjtrx1IU{AoMkk<ZjE_*@eJ$I`FU43W1z@l)hc
z*sU&U>R=X?7$2=hbBkQ<83YwelppdHzw7h?=q(=99w#=TEPr2ex3h!88fWXb&N$Fb
zPSOOhb3P{XvI*{?$aait|F%V5W>iLq4SaE0#|Q$kjvNRI0fjV4`hrXRV8>5&dAEQw
zA+c$hHCT4a0HB`e5^{l)@bxxaKb+vGqi?)kuH!e)H28~suJN!eFyEF@QI!Ww25|NI
x^|UrASkIWM=p=P%Ouo0VEj2eQdilydZGfc&ZuY5K2-hDtVBkXVOVY^*G-7Bd4sHMd

delta 10
RcmX?Nxx|$5>PE)JQUDm71RMYW

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 1fb98f0a3..70a90f785 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -188,6 +188,9 @@ namespace cryptonote
       ADD_CHECKPOINT(50000,  "5286ac2a0f39b3aefcba363cd71f2760bd1e0d763cbc81026ebdc3f80a86541f");
       ADD_CHECKPOINT(53666,  "3f43f56f66ef0c43cf2fd14d0d28fa2aae0ef8f40716773511345750770f1255"); //Hard fork to v9
       ADD_CHECKPOINT(54500,  "8ed3078b389c2b44add007803d741b58d3fbed2e1ba4139bda702152d8773c9b");
+      ADD_CHECKPOINT(55000,  "4b662ceccefc3247edb4d654dd610b8fb496e85b88a5de43cc2bdd28171b15ff");
+      ADD_CHECKPOINT(57000,  "08a79f09f12bb5d230b63963356a760d51618e526cfc636047a6f3798217c177");
+      ADD_CHECKPOINT(59000,  "180b51ee2c5fbcd4362eb7a29df9422481310dd77d10bccdf8930724c31e007e");
 
       return true;
   }
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index d762d3dfb..2181f8348 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4441,7 +4441,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "e8255f4188ddb613df2953d8ae2ed509223e432290368b0eef062f8c12da9f70";
+static const char expected_block_hashes_hash[] = "897d3ae0f3aef8ef8362b0bb3535925738414fa78d9146f8a04c60555fa5a95f";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;

From 0a97b3784dad6355cf21042b37bd55744936922e Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Fri, 26 Oct 2018 21:39:50 +0300
Subject: [PATCH 38/54] revert wallet2: use a gamma distribution to pick fake
 outs

---
 src/wallet/wallet2.cpp | 141 +++++++++--------------------------------
 src/wallet/wallet2.h   |   2 +-
 2 files changed, 30 insertions(+), 113 deletions(-)

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 635f1bb41..4c4ee8bf3 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -2399,7 +2399,7 @@ bool wallet2::refresh(uint64_t & blocks_fetched, bool& received_money, bool& ok)
   return ok;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_rct_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution)
+bool wallet2::get_output_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution)
 {
   uint32_t rpc_version;
   boost::optional<std::string> result = m_node_rpc_proxy.get_rpc_version(rpc_version);
@@ -5923,42 +5923,23 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     bool is_shortly_after_segregation_fork = height >= segregation_fork_height && height < segregation_fork_height + SEGREGATION_FORK_VICINITY;
     bool is_after_segregation_fork = height >= segregation_fork_height;
 
-    // if we have at least one rct out, get the distribution, or fall back to the previous system
-    uint64_t rct_start_height;
-    std::vector<uint64_t> rct_offsets;
-    bool has_rct = false;
-    for (size_t idx: selected_transfers)
-      if (m_transfers[idx].is_rct())
-        { has_rct = true; break; }
-    const bool has_rct_distribution = has_rct && get_rct_distribution(rct_start_height, rct_offsets);
-    if (has_rct_distribution)
-    {
-      // check we're clear enough of rct start, to avoid corner cases below
-      THROW_WALLET_EXCEPTION_IF(rct_offsets.size() <= CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE,
-          error::get_output_distribution, "Not enough rct outputs");
-    }
 
     // get histogram for the amounts we need
     cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t = AUTO_VAL_INIT(req_t);
     cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t = AUTO_VAL_INIT(resp_t);
-    // request histogram for all outputs, except 0 if we have the rct distribution
+    m_daemon_rpc_mutex.lock();
     for(size_t idx: selected_transfers)
-      if (!m_transfers[idx].is_rct() || !has_rct_distribution)
-        req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
-    if (!req_t.amounts.empty())
-    {
-      std::sort(req_t.amounts.begin(), req_t.amounts.end());
-      auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
-      req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
-      req_t.unlocked = true;
-      req_t.recent_cutoff = time(NULL) - RECENT_OUTPUT_ZONE;
-      m_daemon_rpc_mutex.lock();
-      bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, m_http_client, rpc_timeout);
-      m_daemon_rpc_mutex.unlock();
-      THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
-      THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
-      THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
-    }
+      req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
+    std::sort(req_t.amounts.begin(), req_t.amounts.end());
+    auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
+    req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
+    req_t.unlocked = true;
+    req_t.recent_cutoff = time(NULL) - RECENT_OUTPUT_ZONE;
+    bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, m_http_client, rpc_timeout);
+    m_daemon_rpc_mutex.unlock();
+    THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
+    THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
+    THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
 
     // if we want to segregate fake outs pre or post fork, get distribution
     std::unordered_map<uint64_t, std::pair<uint64_t, uint64_t>> segregation_limit;
@@ -6014,35 +5995,6 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
     COMMAND_RPC_GET_OUTPUTS_BIN::request req = AUTO_VAL_INIT(req);
     COMMAND_RPC_GET_OUTPUTS_BIN::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
 
-    struct gamma_engine
-    {
-      typedef uint64_t result_type;
-      static constexpr result_type min() { return 0; }
-      static constexpr result_type max() { return std::numeric_limits<result_type>::max(); }
-      result_type operator()() { return crypto::rand<result_type>(); }
-    } engine;
-    static const double shape = 19.28/*16.94*/;
-    //static const double shape = m_testnet ? 17.02 : 17.28;
-    static const double scale = 1/1.61;
-    std::gamma_distribution<double> gamma(shape, scale);
-    auto pick_gamma = [&]()
-    {
-      double x = gamma(engine);
-      x = exp(x);
-      uint64_t block_offset = x / DIFFICULTY_TARGET_V2; // this assumes constant target over the whole rct range
-      if (block_offset >= rct_offsets.size() - 1)
-        return std::numeric_limits<uint64_t>::max(); // bad pick
-      block_offset = rct_offsets.size() - 2 - block_offset;
-      THROW_WALLET_EXCEPTION_IF(block_offset >= rct_offsets.size() - 1, error::wallet_internal_error, "Bad offset calculation");
-      THROW_WALLET_EXCEPTION_IF(rct_offsets[block_offset + 1] < rct_offsets[block_offset],
-          error::get_output_distribution, "Decreasing offsets in rct distribution: " +
-          std::to_string(block_offset) + ": " + std::to_string(rct_offsets[block_offset]) + ", " +
-          std::to_string(block_offset + 1) + ": " + std::to_string(rct_offsets[block_offset + 1]));
-      uint64_t n_rct = rct_offsets[block_offset + 1] - rct_offsets[block_offset];
-      if (n_rct == 0)
-        return rct_offsets[block_offset] ? rct_offsets[block_offset] - 1 : 0;
-      return rct_offsets[block_offset] + crypto::rand<uint64_t>() % n_rct;
-    };
 
     size_t num_selected_transfers = 0;
     for(size_t idx: selected_transfers)
@@ -6054,7 +6006,6 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
       // request more for rct in base recent (locked) coinbases are picked, since they're locked for longer
       size_t requested_outputs_count = base_requested_outputs_count + (td.is_rct() ? CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE : 0);
       size_t start = req.outputs.size();
-      bool use_histogram = amount != 0 || !has_rct_distribution;
 
       const bool output_is_pre_fork = td.m_block_height < segregation_fork_height;
       uint64_t num_outs = 0, num_recent_outs = 0;
@@ -6110,41 +6061,26 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
         num_post_fork_outs = num_outs - segregation_limit[amount].first;
       }
 
-      if (use_histogram)
-      {
-        LOG_PRINT_L1("" << num_outs << " unlocked outputs of size " << print_money(amount));
-        THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
-            "histogram reports no unlocked outputs for " + boost::lexical_cast<std::string>(amount) + ", not even ours");
-        THROW_WALLET_EXCEPTION_IF(num_recent_outs > num_outs, error::wallet_internal_error,
-            "histogram reports more recent outs than outs for " + boost::lexical_cast<std::string>(amount));
-      }
-      else
-      {
-        // the base offset of the first rct output in the first unlocked block (or the one to be if there's none)
-        num_outs = rct_offsets[rct_offsets.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE];
-        LOG_PRINT_L1("" << num_outs << " unlocked rct outputs");
-        THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
-            "histogram reports no unlocked rct outputs, not even ours");
-      }
+      LOG_PRINT_L1("" << num_outs << " unlocked outputs of size " << print_money(amount));
+      THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
+          "histogram reports no unlocked outputs for " + boost::lexical_cast<std::string>(amount) + ", not even ours");
+      THROW_WALLET_EXCEPTION_IF(num_recent_outs > num_outs, error::wallet_internal_error,
+          "histogram reports more recent outs than outs for " + boost::lexical_cast<std::string>(amount));
 
-      // how many fake outs to draw on a pre-fork distribution
+      // how many fake outs to draw on a pre-fork triangular distribution
       size_t pre_fork_outputs_count = requested_outputs_count * pre_fork_num_out_ratio;
       size_t post_fork_outputs_count = requested_outputs_count * post_fork_num_out_ratio;
       // how many fake outs to draw otherwise
       size_t normal_output_count = requested_outputs_count - pre_fork_outputs_count - post_fork_outputs_count;
 
-      size_t recent_outputs_count = 0;
-      if (use_histogram)
-      {
-        // X% of those outs are to be taken from recent outputs
-        recent_outputs_count = normal_output_count * RECENT_OUTPUT_RATIO;
-        if (recent_outputs_count == 0)
-          recent_outputs_count = 1; // ensure we have at least one, if possible
-        if (recent_outputs_count > num_recent_outs)
-          recent_outputs_count = num_recent_outs;
-        if (td.m_global_output_index >= num_outs - num_recent_outs && recent_outputs_count > 0)
-          --recent_outputs_count; // if the real out is recent, pick one less recent fake out
-      }
+      // X% of those outs are to be taken from recent outputs
+      size_t recent_outputs_count = normal_output_count * RECENT_OUTPUT_RATIO;
+      if (recent_outputs_count == 0)
+        recent_outputs_count = 1; // ensure we have at least one, if possible
+      if (recent_outputs_count > num_recent_outs)
+        recent_outputs_count = num_recent_outs;
+      if (td.m_global_output_index >= num_outs - num_recent_outs && recent_outputs_count > 0)
+        --recent_outputs_count; // if the real out is recent, pick one less recent fake out
       LOG_PRINT_L1("Fake output makeup: " << requested_outputs_count << " requested: " << recent_outputs_count << " recent, " <<
           pre_fork_outputs_count << " pre-fork, " << post_fork_outputs_count << " post-fork, " <<
           (requested_outputs_count - recent_outputs_count - pre_fork_outputs_count - post_fork_outputs_count) << " full-chain");
@@ -6224,26 +6160,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
 
           uint64_t i;
           const char *type = "";
-          if (amount == 0 && has_rct_distribution)
-          {
-            // gamma distribution
-            if (num_found -1 < recent_outputs_count + pre_fork_outputs_count)
-            {
-              do i = pick_gamma(); while (i >= segregation_limit[amount].first);
-              type = "pre-fork gamma";
-            }
-            else if (num_found -1 < recent_outputs_count + pre_fork_outputs_count + post_fork_outputs_count)
-            {
-              do i = pick_gamma(); while (i < segregation_limit[amount].first || i >= num_outs);
-              type = "post-fork gamma";
-            }
-            else
-            {
-              do i = pick_gamma(); while (i >= num_outs);
-              type = "gamma";
-            }
-          }
-          else if (num_found - 1 < recent_outputs_count) // -1 to account for the real one we seeded with
+          if (num_found - 1 < recent_outputs_count) // -1 to account for the real one we seeded with
           {
             // triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
             uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
@@ -6308,7 +6225,7 @@ void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>>
 
     // get the keys for those
     m_daemon_rpc_mutex.lock();
-    bool r = epee::net_utils::invoke_http_bin("/get_outs.bin", req, daemon_resp, m_http_client, rpc_timeout);
+    r = epee::net_utils::invoke_http_bin("/get_outs.bin", req, daemon_resp, m_http_client, rpc_timeout);
     m_daemon_rpc_mutex.unlock();
     THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
     THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index ed02d7a28..f2e861f18 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -1139,7 +1139,7 @@ namespace tools
     bool remove_rings(const cryptonote::transaction_prefix &tx);
     bool get_ring(const crypto::chacha_key &key, const crypto::key_image &key_image, std::vector<uint64_t> &outs);
 
-    bool get_rct_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution);
+    bool get_output_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution);
 
     uint64_t get_segregation_fork_height() const;
 

From b1e005b3c88332975fd5209669ae74c0bd53972b Mon Sep 17 00:00:00 2001
From: rbrunner7 <rbrunner@dreamshare.ch>
Date: Sun, 28 Oct 2018 14:46:58 +0100
Subject: [PATCH 39/54] MMS: Initial version for Wownero, merged in from Monero

Wownero-specific changes still missing, see following second commit
---
 src/simplewallet/simplewallet.cpp  | 1055 +++++++++++++++++++++++++++-
 src/simplewallet/simplewallet.h    |   34 +
 src/wallet/CMakeLists.txt          |   10 +-
 src/wallet/message_store.cpp       | 1003 ++++++++++++++++++++++++++
 src/wallet/message_store.h         |  357 ++++++++++
 src/wallet/message_transporter.cpp |  287 ++++++++
 src/wallet/message_transporter.h   |  113 +++
 src/wallet/wallet2.cpp             |  129 +++-
 src/wallet/wallet2.h               |   14 +-
 src/wallet/wallet_errors.h         |   25 +
 10 files changed, 2995 insertions(+), 32 deletions(-)
 create mode 100644 src/wallet/message_store.cpp
 create mode 100644 src/wallet/message_store.h
 create mode 100644 src/wallet/message_transporter.cpp
 create mode 100644 src/wallet/message_transporter.h

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 137d84b6e..8519265b9 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -64,6 +64,7 @@
 #include "wallet/wallet_args.h"
 #include "version.h"
 #include <stdexcept>
+#include "wallet/message_store.h"
 
 #ifdef WIN32
 #include <boost/locale.hpp>
@@ -787,6 +788,8 @@ bool simple_wallet::print_fee_info(const std::vector<std::string> &args/* = std:
 
 bool simple_wallet::prepare_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   if (m_wallet->key_on_device())
   {
     fail_msg_writer() << tr("command not supported by HW wallet");
@@ -820,11 +823,20 @@ bool simple_wallet::prepare_multisig(const std::vector<std::string> &args)
   success_msg_writer() << multisig_info;
   success_msg_writer() << tr("Send this multisig info to all other participants, then use make_multisig <threshold> <info1> [<info2>...] with others' multisig info");
   success_msg_writer() << tr("This includes the PRIVATE view key, so needs to be disclosed only to that multisig wallet's participants ");
+
+  if (by_mms)
+  {
+    get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::key_set, multisig_info);
+  }
+
+  m_command_successful = true;
   return true;
 }
 
 bool simple_wallet::make_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   if (m_wallet->key_on_device())
   {
     fail_msg_writer() << tr("command not supported by HW wallet");
@@ -880,6 +892,11 @@ bool simple_wallet::make_multisig(const std::vector<std::string> &args)
       success_msg_writer() << tr("Another step is needed");
       success_msg_writer() << multisig_extra_info;
       success_msg_writer() << tr("Send this multisig info to all other participants, then use finalize_multisig <info1> [<info2>...] with others' multisig info");
+      if (by_mms)
+      {
+        get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::finalizing_key_set, multisig_extra_info);
+      }
+      m_command_successful = true;
       return true;
     }
   }
@@ -898,11 +915,14 @@ bool simple_wallet::make_multisig(const std::vector<std::string> &args)
   success_msg_writer() << std::to_string(threshold) << "/" << total << tr(" multisig address: ")
       << m_wallet->get_account().get_public_address_str(m_wallet->nettype());
 
+  m_command_successful = true;
   return true;
 }
 
 bool simple_wallet::finalize_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   bool ready;
   if (m_wallet->key_on_device())
   {
@@ -947,11 +967,14 @@ bool simple_wallet::finalize_multisig(const std::vector<std::string> &args)
     return true;
   }
 
+  m_command_successful = true;
   return true;
 }
 
 bool simple_wallet::export_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   bool ready;
   if (m_wallet->key_on_device())
   {
@@ -977,17 +1000,24 @@ bool simple_wallet::export_multisig(const std::vector<std::string> &args)
     return true;
 
   const std::string filename = args[0];
-  if (m_wallet->confirm_export_overwrite() && !check_file_overwrite(filename))
+  if (!by_mms && m_wallet->confirm_export_overwrite() && !check_file_overwrite(filename))
     return true;
   try
   {
     cryptonote::blobdata ciphertext = m_wallet->export_multisig();
 
-    bool r = epee::file_io_utils::save_string_to_file(filename, ciphertext);
-    if (!r)
+    if (by_mms)
     {
-      fail_msg_writer() << tr("failed to save file ") << filename;
-      return true;
+      get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::multisig_sync_data, ciphertext);
+    }
+    else
+    {
+      bool r = epee::file_io_utils::save_string_to_file(filename, ciphertext);
+      if (!r)
+      {
+	fail_msg_writer() << tr("failed to save file ") << filename;
+	return true;
+      }
     }
   }
   catch (const std::exception &e)
@@ -998,11 +1028,14 @@ bool simple_wallet::export_multisig(const std::vector<std::string> &args)
   }
 
   success_msg_writer() << tr("Multisig info exported to ") << filename;
+  m_command_successful = true;
   return true;
 }
 
 bool simple_wallet::import_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   bool ready;
   uint32_t threshold, total;
   if (m_wallet->key_on_device())
@@ -1031,15 +1064,22 @@ bool simple_wallet::import_multisig(const std::vector<std::string> &args)
   std::vector<cryptonote::blobdata> info;
   for (size_t n = 0; n < args.size(); ++n)
   {
-    const std::string filename = args[n];
-    std::string data;
-    bool r = epee::file_io_utils::load_file_to_string(filename, data);
-    if (!r)
+    if (by_mms)
     {
-      fail_msg_writer() << tr("failed to read file ") << filename;
-      return true;
+      info.push_back(args[n]);
+    }
+    else
+    {
+      const std::string &filename = args[n];
+      std::string data;
+      bool r = epee::file_io_utils::load_file_to_string(filename, data);
+      if (!r)
+      {
+	fail_msg_writer() << tr("failed to read file ") << filename;
+	return true;
+      }
+      info.push_back(std::move(data));
     }
-    info.push_back(std::move(data));
   }
 
   LOCK_IDLE_SCOPE();
@@ -1051,6 +1091,7 @@ bool simple_wallet::import_multisig(const std::vector<std::string> &args)
     // Clear line "Height xxx of xxx"
     std::cout << "\r                                                                \r";
     success_msg_writer() << tr("Multisig info imported");
+    m_command_successful = true;
   }
   catch (const std::exception &e)
   {
@@ -1083,6 +1124,8 @@ bool simple_wallet::accept_loaded_tx(const tools::wallet2::multisig_tx_set &txs)
 
 bool simple_wallet::sign_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   bool ready;
   if (m_wallet->key_on_device())
   {
@@ -1111,11 +1154,48 @@ bool simple_wallet::sign_multisig(const std::vector<std::string> &args)
   uint32_t signers = 0;
   try
   {
-    bool r = m_wallet->sign_multisig_tx_from_file(filename, txids, [&](const tools::wallet2::multisig_tx_set &tx){ signers = tx.m_signers.size(); return accept_loaded_tx(tx); });
-    if (!r)
+    if (by_mms)
     {
-      fail_msg_writer() << tr("Failed to sign multisig transaction");
-      return true;
+      tools::wallet2::multisig_tx_set exported_txs;
+      std::string ciphertext;
+      bool r = m_wallet->load_multisig_tx(args[0], exported_txs, [&](const tools::wallet2::multisig_tx_set &tx){ signers = tx.m_signers.size(); return accept_loaded_tx(tx); });
+      if (r)
+      {
+	r = m_wallet->sign_multisig_tx(exported_txs, txids);
+      }
+      if (r)
+      {
+	ciphertext = m_wallet->save_multisig_tx(exported_txs);
+        if (ciphertext.empty())
+	{
+	  r = false;
+	}
+      }
+      if (r)
+      {
+	mms::message_type message_type = mms::message_type::fully_signed_tx;
+	if (txids.empty())
+	{
+	  message_type = mms::message_type::partially_signed_tx;
+	}
+        get_message_store().process_wallet_created_data(get_multisig_wallet_state(), message_type, ciphertext);
+	filename = "MMS";   // for the messages below
+	m_command_successful = true;
+      }
+      else
+      {
+	fail_msg_writer() << tr("Failed to sign multisig transaction");
+	return true;
+      }
+    }
+    else
+    {
+      bool r = m_wallet->sign_multisig_tx_from_file(filename, txids, [&](const tools::wallet2::multisig_tx_set &tx){ signers = tx.m_signers.size(); return accept_loaded_tx(tx); });
+      if (!r)
+      {
+	fail_msg_writer() << tr("Failed to sign multisig transaction");
+	return true;
+      }
     }
   }
   catch (const tools::error::multisig_export_needed& e)
@@ -1155,6 +1235,8 @@ bool simple_wallet::sign_multisig(const std::vector<std::string> &args)
 
 bool simple_wallet::submit_multisig(const std::vector<std::string> &args)
 {
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   bool ready;
   uint32_t threshold;
   if (m_wallet->key_on_device())
@@ -1186,11 +1268,23 @@ bool simple_wallet::submit_multisig(const std::vector<std::string> &args)
   try
   {
     tools::wallet2::multisig_tx_set txs;
-    bool r = m_wallet->load_multisig_tx_from_file(filename, txs, [&](const tools::wallet2::multisig_tx_set &tx){ return accept_loaded_tx(tx); });
-    if (!r)
+    if (by_mms)
     {
-      fail_msg_writer() << tr("Failed to load multisig transaction from file");
-      return true;
+      bool r = m_wallet->load_multisig_tx(args[0], txs, [&](const tools::wallet2::multisig_tx_set &tx){ return accept_loaded_tx(tx); });
+      if (!r)
+      {
+        fail_msg_writer() << tr("Failed to load multisig transaction from MMS");
+	return true;
+      }
+    }
+    else
+    {
+      bool r = m_wallet->load_multisig_tx_from_file(filename, txs, [&](const tools::wallet2::multisig_tx_set &tx){ return accept_loaded_tx(tx); });
+      if (!r)
+      {
+	fail_msg_writer() << tr("Failed to load multisig transaction from file");
+	return true;
+      }
     }
     if (txs.m_signers.size() < threshold)
     {
@@ -1206,6 +1300,7 @@ bool simple_wallet::submit_multisig(const std::vector<std::string> &args)
       success_msg_writer(true) << tr("Transaction successfully submitted, transaction ") << get_transaction_hash(ptx.tx) << ENDL
           << tr("You can check its status by using the `show_transfers` command.");
     }
+    m_command_successful = true;
   }
   catch (const std::exception &e)
   {
@@ -1296,6 +1391,816 @@ bool simple_wallet::export_raw_multisig(const std::vector<std::string> &args)
   return true;
 }
 
+// MMS ---------------------------------------------------------------------------------------------------
+
+// Access to the message store, or more exactly to the list of the messages that can be changed
+// by the idle thread, is guarded by the same mutex-based mechanism as access to the wallet
+// as a whole and thus e.g. uses the "LOCK_IDLE_SCOPE" macro. This is a little over-cautious, but
+// simple and safe. Care has to be taken however where MMS methods call other simplewallet methods
+// that use "LOCK_IDLE_SCOPE" as this cannot be nested!
+
+// Methods for commands like "export_multisig_info" usually read data from file(s) or write data
+// to files. The MMS calls now those methods as well, to produce data for messages and to process data
+// from messages. As it would be quite inconvenient for the MMS to write data for such methods to files
+// first or get data out of result files after the call, those methods detect a call from the MMS and
+// expect data as arguments instead of files and give back data by calling 'process_wallet_created_data'.
+bool simple_wallet::called_by_mms()
+{
+  bool by_mms = m_called_by_mms;
+  m_called_by_mms = false;
+  return by_mms;
+}
+
+bool simple_wallet::user_confirms(const std::string &question)
+{
+   std::string answer = input_line(question + tr(" (Y/Yes/N/No): "));
+   return !std::cin.eof() && command_line::is_yes(answer);
+}
+
+bool simple_wallet::get_number_from_arg(const std::string &arg, uint32_t &number, const uint32_t lower_bound, const uint32_t upper_bound)
+{
+  bool valid = false;
+  try
+  {
+    number = boost::lexical_cast<uint32_t>(arg);
+    valid = (number >= lower_bound) && (number <= upper_bound);
+  }
+  catch(const boost::bad_lexical_cast &)
+  {
+  }
+  return valid;
+}
+
+bool simple_wallet::choose_mms_processing(const std::vector<mms::processing_data> &data_list, uint32_t &choice)
+{
+  uint32_t choices = data_list.size();
+  if (choices == 1)
+  {
+    choice = 0;
+    return true;
+  }
+  mms::message_store& ms = m_wallet->get_message_store();
+  success_msg_writer() << tr("Choose processing:");
+  std::string text;
+  for (size_t i = 0; i < choices; ++i)
+  {
+    const mms::processing_data &data = data_list[i];
+    text = std::to_string(i+1) + ": ";
+    switch (data.processing)
+    {
+    case mms::message_processing::sign_tx:
+      text += tr("Sign tx");
+      break;
+    case mms::message_processing::send_tx:
+    {
+      mms::message m;
+      ms.get_message_by_id(data.message_ids[0], m);
+      if (m.type == mms::message_type::fully_signed_tx)
+      {
+        text += tr("Send the tx for submission to ");
+      }
+      else
+      {
+        text += tr("Send the tx for signing to ");
+      }
+      mms::coalition_member member = ms.get_member(data.receiving_member_index);
+      text += ms.member_to_string(member, 50);
+      break;
+    }
+    case mms::message_processing::submit_tx:
+      text += tr("Submit tx");
+      break;
+    default:
+      text += tr("unknown");
+      break;
+    }
+    success_msg_writer() << text;
+  }
+
+  std::string line = input_line(tr("Choice: "));
+  if (std::cin.eof() || line.empty())
+  {
+    return false;
+  }
+  bool choice_ok = get_number_from_arg(line, choice, 1, choices);
+  if (choice_ok)
+  {
+    choice--;
+  }
+  else
+  {
+    fail_msg_writer() << tr("Wrong choice");
+  }
+  return choice_ok;
+}
+
+static std::string get_human_readable_timestamp(uint64_t ts);
+static std::string get_human_readable_timespan(std::chrono::seconds seconds);
+
+void simple_wallet::list_mms_messages(const std::vector<mms::message> &messages)
+{
+  success_msg_writer() << boost::format("%4s %-4s %-30s %-21s %7s %-15s %-40s") % tr("Id") % tr("I/O") % tr("Coalition Member")
+	  % tr("Message Type") % tr("Height") % tr("Message State") % tr("Since");
+  mms::message_store& ms = m_wallet->get_message_store();
+  uint64_t now = time(NULL);
+  for (size_t i = 0; i < messages.size(); ++i)
+  {
+    const mms::message &m = messages[i];
+    const mms::coalition_member &member = ms.get_member(m.member_index);
+    bool highlight = (m.state == mms::message_state::ready_to_send) || (m.state == mms::message_state::waiting);
+    message_writer(m.direction == mms::message_direction::out ? console_color_green : console_color_magenta, highlight) <<
+	    boost::format("%4s %-4s %-30s %-21s %7s %-15s %-40s") %
+	    m.id %
+	    ms.message_direction_to_string(m.direction) %
+	    ms.member_to_string(member, 30) %
+	    ms.message_type_to_string(m.type) %
+	    m.wallet_height %
+	    ms.message_state_to_string(m.state) %
+	    (get_human_readable_timestamp(m.modified) + ", " + get_human_readable_timespan(std::chrono::seconds(now - m.modified)) + tr(" ago"));
+  }
+}
+
+void simple_wallet::show_message(const mms::message &m)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  const mms::coalition_member &member = ms.get_member(m.member_index);
+  bool display_content;
+  switch (m.type)
+  {
+  case mms::message_type::key_set:
+  case mms::message_type::finalizing_key_set:
+  case mms::message_type::note:
+    display_content = true;
+    break;
+  default:
+    display_content = false;
+  }
+  uint64_t now = time(NULL);
+  success_msg_writer() << "";
+  success_msg_writer() << tr("Message ") << m.id;
+  success_msg_writer() << tr("In/out: ") << ms.message_direction_to_string(m.direction);
+  success_msg_writer() << tr("Type: ") << ms.message_type_to_string(m.type);
+  success_msg_writer() << tr("State: ") << boost::format(tr("%s since %s, %s ago")) %
+	  ms.message_state_to_string(m.state) % get_human_readable_timestamp(m.modified) % get_human_readable_timespan(std::chrono::seconds(now - m.modified));
+  if (m.sent == 0)
+  {
+    success_msg_writer() << tr("Sent: Never");
+  }
+  else
+  {
+    success_msg_writer() << boost::format(tr("Sent: %s, %s ago")) %
+	    get_human_readable_timestamp(m.sent) % get_human_readable_timespan(std::chrono::seconds(now - m.sent));
+  }
+  success_msg_writer() << tr("Member: ") << ms.member_to_string(member, 100);
+  success_msg_writer() << tr("Content size: ") << m.content.length() << tr(" bytes");
+  success_msg_writer() << tr("Content: ") << (display_content ? m.content : tr("(binary data)"));
+
+  if (m.type == mms::message_type::note)
+  {
+    // Showing a note and read its text is "processing" it: Set the state accordingly
+    // which will also delete it from Bitmessage as a side effect
+    // (Without this little "twist" it would never change the state, and never get deleted)
+    ms.set_message_processed_or_sent(m.id);
+  }
+}
+
+void simple_wallet::ask_send_all_ready_messages()
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  std::vector<mms::message> ready_messages;
+  const std::vector<mms::message> &messages = ms.get_all_messages();
+  for (size_t i = 0; i < messages.size(); ++i)
+  {
+    const mms::message &m = messages[i];
+    if (m.state == mms::message_state::ready_to_send)
+    {
+      ready_messages.push_back(m);
+    }
+  }
+  if (ready_messages.size() != 0)
+  {
+    list_mms_messages(ready_messages);
+    bool send = ms.get_auto_send();
+    if (!send)
+    {
+      send = user_confirms(tr("Send these messages now?"));
+    }
+    if (send)
+    {
+      mms::multisig_wallet_state state = get_multisig_wallet_state();
+      for (size_t i = 0; i < ready_messages.size(); ++i)
+      {
+	ms.send_message(state, ready_messages[i].id);
+	ms.set_message_processed_or_sent(ready_messages[i].id);
+      }
+      success_msg_writer() << tr("Sent.");
+    }
+  }
+}
+
+bool simple_wallet::get_message_from_arg(const std::string &arg, mms::message &m)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  bool valid_id = false;
+  uint32_t id;
+  try
+  {
+    id = (uint32_t)boost::lexical_cast<uint32_t>(arg);
+    valid_id = ms.get_message_by_id(id, m);
+  }
+  catch (const boost::bad_lexical_cast &)
+  {
+  }
+  if (!valid_id)
+  {
+    fail_msg_writer() << tr("Invalid message id");
+  }
+  return valid_id;
+}
+
+void simple_wallet::mms_init(const std::vector<std::string> &args)
+{
+  // mms init <threshold>/<coalition_size> <own_label> <own_transport_address>
+  // Example: mms init 2/3 rbrunner BM-2cUVEbbb3H6ojddYQziK3RafJ5GPcFQv7e
+  // For now, assume we still have the original Monero address available, before "make_multisig"
+  if (args.size() != 4)
+  {
+    fail_msg_writer() << tr("usage: mms init <threshold>/<coalition_size> <own_label> <own_transport_address>");
+    return;
+  }
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (ms.get_active())
+  {
+    if (!user_confirms(tr("The MMS is already initialized. Re-initialize by deleting all member info and messages?")))
+    {
+      return;
+    }
+  }
+  uint32_t threshold;
+  uint32_t coalition_size;
+  const std::string &mn = args[1];
+  std::vector<std::string> numbers;
+  boost::split(numbers, mn, boost::is_any_of("/"));
+  bool mn_ok = (numbers.size() == 2)
+               && get_number_from_arg(numbers[0], threshold, 1, 100)
+               && get_number_from_arg(numbers[1], coalition_size, 2, 100);
+  if (mn_ok)
+  {
+    mn_ok = (threshold == coalition_size) || (threshold == (coalition_size -1));
+    // Fully general cases like 3/5 not yet supported
+  }
+  if (!mn_ok)
+  {
+    fail_msg_writer() << tr("Error in threshold and/or coalition size");
+    return;
+  }
+  ms.init(get_multisig_wallet_state(), args[2], args[3], coalition_size, threshold);
+}
+
+void simple_wallet::mms_info(const std::vector<std::string> &args)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  success_msg_writer() << boost::format("The MMS is active for %s/%s multisig.")
+	  % ms.get_threshold() % ms.get_coalition_size();
+}
+
+void simple_wallet::mms_member(const std::vector<std::string> &args)
+// mms 0:member [1:<number> <2:label> [3:<transport_address> [4:<monero_address>]]]
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  const std::vector<mms::coalition_member> &members = ms.get_all_members();
+  if (args.size() == 1)
+  {
+    // Without further parameters list all defined members
+    success_msg_writer() << boost::format("%2s %-20s %-s") % tr("#") % tr("Label") % tr("Transport Address");
+    success_msg_writer() << boost::format("%2s %-20s %-s") % "" % "" % tr("Monero Address");
+    for (size_t i = 0; i < members.size(); ++i)
+    {
+      const mms::coalition_member &member = members[i];
+      std::string label = member.label.empty() ? tr("<not set>") : member.label;
+      std::string monero_address;
+      if (member.monero_address_known)
+      {
+	monero_address = get_account_address_as_str(m_wallet->nettype(), false, member.monero_address);
+      }
+      else
+      {
+	monero_address = tr("<not set>");
+      }
+      std::string transport_address = member.transport_address.empty() ? tr("<not set>") : member.transport_address;
+      success_msg_writer() << boost::format("%2s %-20s %-s") % (i + 1) % label % transport_address;
+      success_msg_writer() << boost::format("%2s %-20s %-s") % "" % "" % monero_address;
+      success_msg_writer() << "";
+    }
+    return;
+  }
+
+  uint32_t index;
+  bool index_valid = get_number_from_arg(args[1], index, 1, ms.get_coalition_size());
+  if (index_valid)
+  {
+    index--;
+  }
+  else
+  {
+    fail_msg_writer() << tr("Invalid coalition member number ") + args[1];
+    return;
+  }
+  if (args.size() < 3)
+  {
+    fail_msg_writer() << tr("mms member [<number> <label> [<transport_address> [<monero_address>]]]");
+    return;
+  }
+
+  boost::optional<string> label = args[2];
+  boost::optional<string> transport_address;
+  if (args.size() >= 4)
+  {
+    transport_address = args[3];
+  }
+  boost::optional<cryptonote::account_public_address> monero_address;
+  mms::multisig_wallet_state state = get_multisig_wallet_state();
+  if (args.size() >= 5)
+  {
+    cryptonote::address_parse_info info;
+    bool ok = cryptonote::get_account_address_from_str_or_url(info, m_wallet->nettype(), args[4], oa_prompter);
+    if (!ok)
+    {
+      fail_msg_writer() << tr("Invalid Monero address");
+      return;
+    }
+    monero_address = info.address;
+    const std::vector<mms::message> &messages = ms.get_all_messages();
+    if ((messages.size() > 0) || state.multisig)
+    {
+      fail_msg_writer() << tr("Wallet state does not allow changing Monero addresses anymore");
+      return;
+    }
+  }
+  ms.set_member(state, index, label, transport_address, monero_address);
+}
+
+void simple_wallet::mms_list(const std::vector<std::string> &args)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (args.size() != 1)
+  {
+    fail_msg_writer() << tr("Usage: mms list");
+    return;
+  }
+  LOCK_IDLE_SCOPE();
+  const std::vector<mms::message> &messages = ms.get_all_messages();
+  list_mms_messages(messages);
+}
+
+void simple_wallet::mms_next(const std::vector<std::string> &args)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  if ((args.size() > 2) || ((args.size() == 2) && (args[1] != "sync")))
+  {
+    fail_msg_writer() << tr("Usage: mms next [sync]");
+    return;
+  }
+  if (!ms.member_info_complete())
+  {
+    fail_msg_writer() << tr("Member info is not yet complete");
+    return;
+  }
+  bool avail = false;
+  std::vector<mms::processing_data> data_list;
+  bool force_sync = false;
+  uint32_t choice = 0;
+  {
+    LOCK_IDLE_SCOPE();
+    if ((args.size() > 1) && (args[1] == "sync"))
+    {
+      // Force the MMS to process any waiting sync info although on its own it would just ignore
+      // those messages because no need to process them can be seen
+      force_sync = true;
+    }
+    string wait_reason;
+    {
+      avail = ms.get_processable_messages(get_multisig_wallet_state(), force_sync, data_list, wait_reason);
+    }
+    if (avail)
+    {
+      avail = choose_mms_processing(data_list, choice);
+    }
+    else if (!wait_reason.empty())
+    {
+      success_msg_writer() << tr("No next step: ") << wait_reason;
+    }
+  }
+  if (avail)
+  {
+    mms::processing_data data = data_list[choice];
+    m_command_successful = false;
+    switch(data.processing)
+    {
+    case mms::message_processing::prepare_multisig:
+      success_msg_writer() << tr("prepare_multisig");
+      m_called_by_mms = true;
+      prepare_multisig(std::vector<std::string>());
+      break;
+
+    case mms::message_processing::make_multisig:
+    {
+      success_msg_writer() << tr("make_multisig");
+      uint32_t number_of_key_sets = data.message_ids.size();
+      std::vector<std::string> sig_args(number_of_key_sets + 1);
+      sig_args[0] = std::to_string(ms.get_threshold());
+      for (size_t i = 0; i < number_of_key_sets; ++i)
+      {
+	mms::message m = ms.get_message_by_id(data.message_ids[i]);
+	sig_args[i+1] = m.content;
+      }
+      m_called_by_mms = true;
+      make_multisig(sig_args);
+      break;
+    }
+
+    case mms::message_processing::finalize_multisig:
+    {
+      success_msg_writer() << tr("finalize_multisig");
+      uint32_t number_of_key_sets = data.message_ids.size();
+      // Other than "make_multisig" only the key sets as parameters, no threshold
+      std::vector<std::string> sig_args(number_of_key_sets);
+      for (size_t i = 0; i < number_of_key_sets; ++i)
+      {
+	mms::message m = ms.get_message_by_id(data.message_ids[i]);
+	sig_args[i] = m.content;
+      }
+      m_called_by_mms = true;
+      finalize_multisig(sig_args);
+      break;
+    }
+
+    case mms::message_processing::create_sync_data:
+    {
+      success_msg_writer() << tr("export_multisig_info");
+      std::vector<std::string> export_args;
+      export_args.push_back("MMS");  // dummy filename
+      m_called_by_mms = true;
+      export_multisig(export_args);
+      break;
+    }
+
+    case mms::message_processing::process_sync_data:
+    {
+      success_msg_writer() << tr("import_multisig_info");
+      std::vector<std::string> import_args;
+      for (size_t i = 0; i < data.message_ids.size(); ++i)
+      {
+	mms::message m = ms.get_message_by_id(data.message_ids[i]);
+	import_args.push_back(m.content);
+      }
+      m_called_by_mms = true;
+      import_multisig(import_args);
+      break;
+    }
+
+    case mms::message_processing::sign_tx:
+    {
+      success_msg_writer() << tr("sign_multisig");
+      std::vector<std::string> sign_args;
+      mms::message m = ms.get_message_by_id(data.message_ids[0]);
+      sign_args.push_back(m.content);
+      m_called_by_mms = true;
+      sign_multisig(sign_args);
+      break;
+    }
+
+    case mms::message_processing::submit_tx:
+    {
+      success_msg_writer() << tr("submit_multisig");
+      std::vector<std::string> submit_args;
+      mms::message m = ms.get_message_by_id(data.message_ids[0]);
+      submit_args.push_back(m.content);
+      m_called_by_mms = true;
+      submit_multisig(submit_args);
+      break;
+    }
+
+    case mms::message_processing::send_tx:
+    {
+      success_msg_writer() << tr("send tx");
+      mms::message m = ms.get_message_by_id(data.message_ids[0]);
+      ms.add_message(get_multisig_wallet_state(), data.receiving_member_index, m.type, mms::message_direction::out,
+		     m.content);
+      m_command_successful = true;
+      break;
+    }
+
+    default:
+      message_writer() << tr("Nothing ready to process");
+      break;
+    }
+
+    if (m_command_successful) {
+      {
+        LOCK_IDLE_SCOPE();
+        ms.set_messages_processed(data);
+        ask_send_all_ready_messages();
+      }
+    }
+  }
+}
+
+void simple_wallet::mms_sync(const std::vector<std::string> &args)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (args.size() != 1)
+  {
+    fail_msg_writer() << tr("Usage: mms sync");
+    return;
+  }
+  // Force the start of a new sync round, for exceptional cases where something went wrong
+  // Can e.g. solve the problem "This signature was made with stale data" after trying to
+  // create 2 transactions in a row somehow
+  // Code is identical to the code for 'message_processing::create_sync_data'
+  success_msg_writer() << tr("export_multisig_info");
+  std::vector<std::string> export_args;
+  export_args.push_back("MMS");  // dummy filename
+  m_called_by_mms = true;
+  export_multisig(export_args);
+  ask_send_all_ready_messages();
+}
+
+void simple_wallet::mms_transfer(const std::vector<std::string> &args)
+{
+  // It's too complicated to check any arguments here, just let 'transfer' do the whole job
+  std::vector<std::string> transfer_args = args;
+  transfer_args.erase(transfer_args.begin());
+  m_called_by_mms = true;
+  transfer_new(transfer_args);
+}
+
+void simple_wallet::mms_delete(const std::vector<std::string> &args)
+{
+  if (args.size() != 2)
+  {
+    fail_msg_writer() << tr("Usage: mms delete <message_id> | all");
+    return;
+  }
+  LOCK_IDLE_SCOPE();
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (args[1] == "all")
+  {
+    if (user_confirms(tr("Delete all messages?")))
+    {
+      ms.delete_all_messages();
+    }
+  }
+  else
+  {
+    mms::message m;
+    bool valid_id = get_message_from_arg(args[1], m);
+    if (valid_id)
+    {
+      // For the moment, just delete, even if unsent / unprocessed: This is CLI, assume people know what they do
+      ms.delete_message(m.id);
+    }
+  }
+}
+
+void simple_wallet::mms_send(const std::vector<std::string> &args)
+{
+  if (args.size() == 1)
+  {
+    ask_send_all_ready_messages();
+    return;
+  }
+  else if (args.size() != 2)
+  {
+    fail_msg_writer() << tr("Usage: mms send [<message_id>]");
+    return;
+  }
+  LOCK_IDLE_SCOPE();
+  mms::message_store& ms = m_wallet->get_message_store();
+  mms::message m;
+  bool valid_id = get_message_from_arg(args[1], m);
+  if (valid_id)
+  {
+    ms.send_message(get_multisig_wallet_state(), m.id);
+  }
+}
+
+void simple_wallet::mms_receive(const std::vector<std::string> &args)
+{
+  std::vector<mms::message> new_messages;
+  LOCK_IDLE_SCOPE();
+  mms::message_store& ms = m_wallet->get_message_store();
+  bool avail = ms.check_for_messages(get_multisig_wallet_state(), new_messages);
+  if (avail)
+  {
+    list_mms_messages(new_messages);
+  }
+}
+
+void simple_wallet::mms_note(const std::vector<std::string> &args)
+{
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (args.size() == 1)
+  {
+    LOCK_IDLE_SCOPE();
+    const std::vector<mms::message> &messages = ms.get_all_messages();
+    for (size_t i = 0; i < messages.size(); ++i)
+    {
+      const mms::message &m = messages[i];
+      if ((m.type == mms::message_type::note) && (m.state == mms::message_state::waiting))
+      {
+	show_message(m);
+      }
+    }
+    return;
+  }
+  if (args.size() < 3)
+  {
+    fail_msg_writer() << tr("Usage: mms note [<label> <text>]");
+    return;
+  }
+  uint32_t member_index;
+  bool found = ms.get_member_index_by_label(args[1], member_index);
+  if (!found)
+  {
+    fail_msg_writer() << tr("No coalition member found with label ") << args[1];
+    return;
+  }
+  std::string note = "";
+  for (size_t n = 2; n < args.size(); ++n)
+  {
+    if (n > 2)
+    {
+      note += " ";
+    }
+    note += args[n];
+  }
+  LOCK_IDLE_SCOPE();
+  ms.add_message(get_multisig_wallet_state(), member_index, mms::message_type::note,
+		 mms::message_direction::out, note);
+  ask_send_all_ready_messages();
+}
+
+void simple_wallet::mms_show(const std::vector<std::string> &args)
+{
+  if (args.size() != 2)
+  {
+    fail_msg_writer() << tr("Usage: mms show <message_id>");
+    return;
+  }
+  LOCK_IDLE_SCOPE();
+  mms::message_store& ms = m_wallet->get_message_store();
+  mms::message m;
+  bool valid_id = get_message_from_arg(args[1], m);
+  if (valid_id)
+  {
+    show_message(m);
+  }
+}
+
+void simple_wallet::mms_set(const std::vector<std::string> &args)
+{
+  bool set = args.size() == 3;
+  bool query = args.size() == 2;
+  if (!set && !query)
+  {
+    fail_msg_writer() << tr("Usage: mms set <option_name> [<option_value>]");
+    return;
+  }
+  mms::message_store& ms = m_wallet->get_message_store();
+  if (args[1] == "auto-send")
+  {
+    if (set)
+    {
+      bool result;
+      bool ok = parse_bool(args[2], result);
+      if (ok)
+      {
+	ms.set_auto_send(result);
+      }
+      else
+      {
+	fail_msg_writer() << tr("Wrong option value");
+      }
+    }
+    else
+    {
+      success_msg_writer() << (ms.get_auto_send() ? tr("Auto-send is on") : tr("Auto-send is off"));
+    }
+  }
+  else
+  {
+    fail_msg_writer() << tr("Unknown option");
+  }
+}
+
+void simple_wallet::mms_help(const std::vector<std::string> &args)
+{
+  if (args.size() != 2)
+  {
+    fail_msg_writer() << tr("Usage: mms help <subcommand>");
+    return;
+  }
+  std::vector<std::string> help_args;
+  help_args.push_back("mms");
+  help_args.push_back(args[1]);
+  help(help_args);
+}
+
+bool simple_wallet::mms(const std::vector<std::string> &args)
+{
+  try
+  {
+    mms::message_store& ms = m_wallet->get_message_store();
+    if (args.size() == 0)
+    {
+      if (ms.get_active())
+      {
+	mms_info(args);
+      }
+      else
+      {
+	success_msg_writer() << tr("The MMS is not active.");
+      }
+    }
+    else if (args[0] == "init")
+    {
+      mms_init(args);
+    }
+    else if (!ms.get_active())
+    {
+      fail_msg_writer() << tr("The MMS is not active. Activate using the \"mms init\" command");
+    }
+    else if (args[0] == "info")
+    {
+      mms_info(args);
+    }
+    else if (args[0] == "member")
+    {
+      mms_member(args);
+    }
+    else if (args[0] == "list")
+    {
+      mms_list(args);
+    }
+    else if (args[0] == "next")
+    {
+      mms_next(args);
+    }
+    else if (args[0] == "sync")
+    {
+      mms_sync(args);
+    }
+    else if (args[0] == "transfer")
+    {
+      mms_transfer(args);
+    }
+    else if (args[0] == "delete")
+    {
+      mms_delete(args);
+    }
+    else if (args[0] == "send")
+    {
+      mms_send(args);
+    }
+    else if (args[0] == "receive")
+    {
+      mms_receive(args);
+    }
+    else if (args[0] == "note")
+    {
+      mms_note(args);
+    }
+    else if (args[0] == "show")
+    {
+      mms_show(args);
+    }
+    else if (args[0] == "set")
+    {
+      mms_set(args);
+    }
+    else if (args[0] == "help")
+    {
+      mms_help(args);
+    }
+    else
+    {
+      fail_msg_writer() << tr("Invalid MMS subcommand");
+    }
+  }
+  catch (const tools::error::no_connection_to_daemon &e)
+  {
+    fail_msg_writer() << tr("Error in MMS command: ") << e.what() << " " << e.request();
+  }
+  catch (const std::exception &e)
+  {
+    fail_msg_writer() << tr("Error in MMS command: ") << e.what();
+    return true;
+  }
+  return true;
+}
+// End MMS ------------------------------------------------------------------------------------------------
+
 bool simple_wallet::print_ring(const std::vector<std::string> &args)
 {
   crypto::key_image key_image;
@@ -1973,6 +2878,12 @@ bool simple_wallet::help_advanced(const std::vector<std::string> &args/* = std::
   {
     success_msg_writer() << get_commands_str();
   }
+  else if ((args.size() == 2) && (args.front() == "mms"))
+  {
+    // Little hack to be able to do "help mms <subcommand>"
+    std::vector<std::string> mms_args(1, args.front() + " " + args.back());
+    success_msg_writer() << get_command_usage(mms_args);
+  }
   else
   {
     success_msg_writer() << get_command_usage(args);
@@ -2282,6 +3193,67 @@ simple_wallet::simple_wallet()
                            boost::bind(&simple_wallet::export_raw_multisig, this, _1),
                            tr("export_raw_multisig_tx <filename>"),
                            tr("Export a signed multisig transaction to a file"));
+  m_cmd_binder.set_handler("mms",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms [<subcommand> [<subcommand_parameters>]]"),
+                           tr("Interface with the MMS (Monero Messaging System)\n"
+			      "subcommand is one of: init, info, member, list, next, sync, transfer, delete, send, receive, note, show, set, help\n"
+			      "Get help about a subcommand with: help mms <subcommand>"));
+  m_cmd_binder.set_handler("mms init",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms init <threshold>/<coalition_size> <own_label> <own_transport_address>"),
+                           tr("Initialize and configure the MMS"));
+  m_cmd_binder.set_handler("mms info",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms info"),
+                           tr("Display current MMS configuration"));
+  m_cmd_binder.set_handler("mms member",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms member [<number> <label> [<transport_address> [<monero_address>]]]"),
+                           tr("Set or modify coalition member info (single-word label, transport address, Monero address), or list all members"));
+  m_cmd_binder.set_handler("mms list",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms list"),
+                           tr("List all messages"));
+  m_cmd_binder.set_handler("mms next",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms next [sync]"),
+                           tr("Evaluate the next possible multisig-related action(s) according to wallet state, and execute or offer for choice\n"
+			      "By using 'sync' processing of waiting messages with multisig sync info can be forced regardless of wallet state"));
+  m_cmd_binder.set_handler("mms sync",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms sync"),
+                           tr("Force generation of multisig sync info regardless of wallet state, to recover from special situations like \"stale data\" errors"));
+  m_cmd_binder.set_handler("mms transfer",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms transfer <transfer_command_arguments>"),
+                           tr("Initiate transfer with MMS support; arguments identical to normal 'transfer' command arguments, for info see there"));
+  m_cmd_binder.set_handler("mms delete",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms delete <message id> | all"),
+                           tr("Delete a single message by giving its id, or delete all messages by using 'all'"));
+  m_cmd_binder.set_handler("mms send",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms send [<message id>]"),
+                           tr("Send a single message by giving its id, or send all waiting messages"));
+  m_cmd_binder.set_handler("mms receive",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms receive"),
+                           tr("Check right away for new messages to receive"));
+  m_cmd_binder.set_handler("mms note",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms note [<label> <text>]"),
+                           tr("Send a one-line message to a coalition member, identified by its label, or show any waiting unread notes"));
+  m_cmd_binder.set_handler("mms show",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms show <message_id>"),
+                           tr("Show detailed info about a single message"));
+  m_cmd_binder.set_handler("mms set",
+                           boost::bind(&simple_wallet::mms, this, _1),
+                           tr("mms set <option_name> [<option_value>]"),
+                           tr("Available options:\n "
+                                  "auto-send <1|0>\n "
+                                  "  Whether to automatically send newly generated messages right away.\n "));
   m_cmd_binder.set_handler("print_ring",
                            boost::bind(&simple_wallet::print_ring, this, _1),
                            tr("print_ring <key_image> | <txid>"),
@@ -4326,6 +5298,8 @@ bool simple_wallet::print_ring_members(const std::vector<tools::wallet2::pending
 bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::string> &args_)
 {
 //  "transfer [index=<N1>[,<N2>,...]] [<priority>] <address> <amount> [<payment_id>]"
+  m_command_successful = false;
+  bool by_mms = called_by_mms();
   if (m_wallet->ask_password() && !get_and_verify_password()) { return true; }
   if (!try_connect_to_daemon())
     return true;
@@ -4651,12 +5625,22 @@ bool simple_wallet::transfer_main(int transfer_type, const std::vector<std::stri
     }
 
     // actually commit the transactions
-    if (m_wallet->multisig())
+    if (m_wallet->multisig() && by_mms)
+    {
+      std::string ciphertext = m_wallet->save_multisig_tx(ptx_vector);
+      if (!ciphertext.empty())
+      {
+	get_message_store().process_wallet_created_data(get_multisig_wallet_state(), mms::message_type::partially_signed_tx, ciphertext);
+	success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to MMS");
+	m_command_successful = true;
+      }
+    }
+    else if (m_wallet->multisig())
     {
       bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_wownero_tx");
       if (!r)
       {
-        fail_msg_writer() << tr("Failed to write transaction(s) to file");
+	fail_msg_writer() << tr("Failed to write transaction(s) to file");
       }
       else
       {
@@ -6027,9 +7011,9 @@ bool simple_wallet::show_transfers(const std::vector<std::string> &args_)
     fail_msg_writer() << tr("usage: show_transfers [in|out|all|pending|failed] [index=<N1>[,<N2>,...]] [<min_height> [<max_height>]]");
     return true;
   }
-
-  LOCK_IDLE_SCOPE();
   
+  LOCK_IDLE_SCOPE();
+
   // optional in/out selector
   if (local_args.size() > 0) {
     if (local_args[0] == "in" || local_args[0] == "incoming") {
@@ -6344,6 +7328,21 @@ bool simple_wallet::rescan_blockchain(const std::vector<std::string> &args_)
   return refresh_main(0, true);
 }
 //----------------------------------------------------------------------------------------------------
+void simple_wallet::check_for_messages()
+{
+  try {
+    std::vector<mms::message> new_messages;
+    bool new_message = get_message_store().check_for_messages(get_multisig_wallet_state(), new_messages);
+    if (new_message)
+    {
+      message_writer(console_color_magenta, true) << tr("MMS received new message");
+      list_mms_messages(new_messages);
+      m_cmd_binder.print_prompt();
+    }
+  }
+  catch(...) {}
+}
+//----------------------------------------------------------------------------------------------------
 void simple_wallet::wallet_idle_thread()
 {
   while (true)
@@ -6366,6 +7365,14 @@ void simple_wallet::wallet_idle_thread()
       m_auto_refresh_refreshing = false;
     }
 
+    // Check for new MMS messages;
+    // For simplicity auto message check is ALSO controlled by "m_auto_refresh_enabled" and has no
+    // separate thread either; thread syncing is tricky enough with only this one idle thread here
+    if (m_auto_refresh_enabled && get_message_store().get_active())
+    {
+      check_for_messages();
+    }
+
     if (!m_idle_run.load(std::memory_order_relaxed))
       break;
     m_idle_cond.wait_for(lock, boost::chrono::seconds(90));
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 8157ce9a2..138b3455b 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -210,6 +210,7 @@ namespace cryptonote
     bool sign_multisig(const std::vector<std::string>& args);
     bool submit_multisig(const std::vector<std::string>& args);
     bool export_raw_multisig(const std::vector<std::string>& args);
+    bool mms(const std::vector<std::string>& args);
     bool print_ring(const std::vector<std::string>& args);
     bool set_ring(const std::vector<std::string>& args);
     bool save_known_rings(const std::vector<std::string>& args);
@@ -351,5 +352,38 @@ namespace cryptonote
     bool m_auto_refresh_refreshing;
     std::atomic<bool> m_in_manual_refresh;
     uint32_t m_current_subaddress_account;
+
+    // MMS
+    mms::message_store& get_message_store() const { return m_wallet->get_message_store(); };
+    mms::multisig_wallet_state get_multisig_wallet_state() const { return m_wallet->get_multisig_wallet_state(); };
+    bool mms_active() const { return get_message_store().get_active(); };
+    bool choose_mms_processing(const std::vector<mms::processing_data> &data_list, uint32_t &choice);
+    void list_mms_messages(const std::vector<mms::message> &messages);
+    void show_message(const mms::message &m);
+    void ask_send_all_ready_messages();
+    void check_for_messages();
+    bool user_confirms(const std::string &question);
+    bool get_message_from_arg(const std::string &arg, mms::message &m);
+    bool get_number_from_arg(const std::string &arg, uint32_t &number, const uint32_t lower_bound, const uint32_t upper_bound);
+
+    void mms_init(const std::vector<std::string> &args);
+    void mms_info(const std::vector<std::string> &args);
+    void mms_member(const std::vector<std::string> &args);
+    void mms_list(const std::vector<std::string> &args);
+    void mms_next(const std::vector<std::string> &args);
+    void mms_sync(const std::vector<std::string> &args);
+    void mms_transfer(const std::vector<std::string> &args);
+    void mms_delete(const std::vector<std::string> &args);
+    void mms_send(const std::vector<std::string> &args);
+    void mms_receive(const std::vector<std::string> &args);
+    void mms_note(const std::vector<std::string> &args);
+    void mms_show(const std::vector<std::string> &args);
+    void mms_set(const std::vector<std::string> &args);
+    void mms_help(const std::vector<std::string> &args);
+    void mms_debug(const std::vector<std::string> &args);
+
+    bool m_called_by_mms = false;
+    bool called_by_mms();
+    bool m_command_successful;
   };
 }
diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt
index 258f7bed9..d8f582459 100644
--- a/src/wallet/CMakeLists.txt
+++ b/src/wallet/CMakeLists.txt
@@ -34,7 +34,10 @@ set(wallet_sources
   wallet2.cpp
   wallet_args.cpp
   ringdb.cpp
-  node_rpc_proxy.cpp)
+  node_rpc_proxy.cpp
+  message_store.cpp
+  message_transporter.cpp
+)
 
 set(wallet_private_headers
   wallet2.h
@@ -44,7 +47,9 @@ set(wallet_private_headers
   wallet_rpc_server_commands_defs.h
   wallet_rpc_server_error_codes.h
   ringdb.h
-  node_rpc_proxy.h)
+  node_rpc_proxy.h
+  message_store.h
+  message_transporter.h)
 
 monero_private_headers(wallet
   ${wallet_private_headers})
@@ -102,7 +107,6 @@ set_property(TARGET wallet_rpc_server
     OUTPUT_NAME "wownero-wallet-rpc")
 install(TARGETS wallet_rpc_server DESTINATION bin)
 
-
 # build and install libwallet_merged only if we building for GUI
 if (BUILD_GUI_DEPS)
     set(libs_to_merge
diff --git a/src/wallet/message_store.cpp b/src/wallet/message_store.cpp
new file mode 100644
index 000000000..1c0cb2c1c
--- /dev/null
+++ b/src/wallet/message_store.cpp
@@ -0,0 +1,1003 @@
+// Copyright (c) 2014-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.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#include "message_store.h"
+#include <boost/archive/portable_binary_oarchive.hpp>
+#include <boost/archive/portable_binary_iarchive.hpp>
+#include <boost/format.hpp>
+#include <fstream>
+#include <sstream>
+#include "file_io_utils.h"
+#include "storages/http_abstract_invoke.h"
+#include "wallet_errors.h"
+#include "serialization/binary_utils.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "wallet.mms"
+
+namespace mms
+{
+static std::string get_human_readable_timestamp(uint64_t ts)
+{
+  char buffer[64];
+  time_t tt = ts;
+  struct tm tm;
+#ifdef WIN32
+  gmtime_s(&tm, &tt);
+#else
+  gmtime_r(&tt, &tm);
+#endif
+  strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
+  return std::string(buffer);
+}
+
+message_store::message_store() {
+  m_active = false;
+  m_auto_send = false;
+  m_next_message_id = 1;
+  m_coalition_size = 0;
+  m_threshold = 0;
+  m_nettype = cryptonote::network_type::UNDEFINED;
+  m_run = true;
+}
+
+namespace
+{
+  // MMS options handling mirrors what "wallet2" is doing for its options, on-demand init and all
+  // It's not very clean to initialize Bitmessage-specific options here, but going one level further
+  // down still into "message_transporter" for that is a little bit too much
+  struct options {
+    const command_line::arg_descriptor<std::string> bitmessage_address = {"bitmessage-address", mms::message_store::tr("Use PyBitmessage instance at URL <arg>"), "http://localhost:8442/"};
+    const command_line::arg_descriptor<std::string> bitmessage_login = {"bitmessage-login", mms::message_store::tr("Specify <arg> as username:password for PyBitmessage API"), "username:password"};
+  };
+}
+
+void message_store::init_options(boost::program_options::options_description& desc_params)
+{
+  const options opts{};
+  command_line::add_arg(desc_params, opts.bitmessage_address);
+  command_line::add_arg(desc_params, opts.bitmessage_login);
+}
+
+void message_store::init(const multisig_wallet_state &state, const std::string &own_label,
+			 const std::string &own_transport_address, uint32_t coalition_size, uint32_t threshold)
+{
+  m_coalition_size = coalition_size;
+  m_threshold = threshold;
+  m_members.clear();
+  m_messages.clear();
+  m_next_message_id = 1;
+
+  coalition_member member;
+  member.label.clear();
+  member.transport_address.clear();
+  member.monero_address_known = false;
+  memset(&member.monero_address, 0, sizeof(cryptonote::account_public_address));
+  member.index = 0;
+
+  for (size_t i = 0; i < m_coalition_size; ++i) {
+    member.me = member.index == 0;    // Simple convention/automatism for now: The very first member is fixed as / must be "me"
+    m_members.push_back(member);
+    member.index++;
+  }
+
+  set_member(state, 0, own_label, own_transport_address, state.address);
+
+  m_nettype = state.nettype;
+  set_active(true);
+  m_filename = state.mms_file;
+  save(state);
+}
+
+void message_store::set_options(const boost::program_options::variables_map& vm)
+{
+  const options opts{};
+  auto bitmessage_address = command_line::get_arg(vm, opts.bitmessage_address);
+  auto bitmessage_login = command_line::get_arg(vm, opts.bitmessage_login);
+  set_options(bitmessage_address, bitmessage_login);
+}
+
+void message_store::set_options(const std::string &bitmessage_address, const std::string &bitmessage_login)
+{
+  m_transporter.set_options(bitmessage_address, bitmessage_login);
+}
+
+void message_store::set_member(const multisig_wallet_state &state,
+			       uint32_t index,
+                               const boost::optional<std::string> &label,
+                               const boost::optional<std::string> &transport_address,
+                               const boost::optional<cryptonote::account_public_address> monero_address)
+{
+  THROW_WALLET_EXCEPTION_IF(index >= m_coalition_size, tools::error::wallet_internal_error, "Invalid member index " + index);
+  coalition_member &m = m_members[index];
+  if (label)
+  {
+    m.label = label.get();
+  }
+  if (transport_address)
+  {
+    m.transport_address = transport_address.get();
+  }
+  if (monero_address)
+  {
+    m.monero_address_known = true;
+    m.monero_address = monero_address.get();
+  }
+  // Save to minimize the chance to loose that info (at least while in beta)
+  save(state);
+}
+
+const coalition_member &message_store::get_member(uint32_t index) const
+{
+  return m_members[index];
+}
+
+bool message_store::member_info_complete() const
+{
+  for (size_t i = 0; i < m_members.size(); ++i) {
+    const coalition_member &m = m_members[i];
+    if (m.label.empty() || m.transport_address.empty() || !m.monero_address_known) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool message_store::get_member_index_by_monero_address(const cryptonote::account_public_address &monero_address, uint32_t &index) const
+{
+  for (size_t i = 0; i < m_members.size(); ++i) {
+    const coalition_member &m = m_members[i];
+    if (m.monero_address == monero_address) {
+      index = m.index;
+      return true;
+    }
+  }
+  MWARNING("No coalition member with Monero address " << account_address_to_string(monero_address));
+  return false;
+}
+
+bool message_store::get_member_index_by_label(const std::string label, uint32_t &index) const
+{
+  for (size_t i = 0; i < m_members.size(); ++i) {
+    const coalition_member &m = m_members[i];
+    if (m.label == label) {
+      index = m.index;
+      return true;
+    }
+  }
+  MWARNING("No coalition member with label " << label);
+  return false;
+}
+
+void message_store::process_wallet_created_data(const multisig_wallet_state &state, message_type type, const std::string &content) {
+  switch(type)
+  {
+  case message_type::key_set:
+    // Result of a "prepare_multisig" command in the wallet
+    // Send the key set to all other members
+  case message_type::finalizing_key_set:
+    // Result of a "make_multisig" command in the wallet in case of N-1/N multisig
+    // Send the finalizing key set to all other members
+  case message_type::multisig_sync_data:
+    // Result of a "export_multisig_info" command in the wallet
+    // Send the sync data to all other members
+    for (size_t i = 1; i < m_members.size(); ++i) {
+      add_message(state, i, type, message_direction::out, content);
+    }
+    break;
+
+  case message_type::partially_signed_tx:
+    // Result of a "transfer" command in the wallet, or a "sign_multisig" command
+    // that did not yet result in the minimum number of signatures required
+    // Create a message "from me to me" as a container for the tx data
+    if (m_threshold == 1)
+    {
+      // Probably rare, but possible: The 1 signature is already enough, correct the type
+      // Easier to correct here than asking all callers to detect this rare special case
+      type = message_type::fully_signed_tx;
+    }
+    add_message(state, 0, type, message_direction::in, content);
+    break;
+
+  case message_type::fully_signed_tx:
+    add_message(state, 0, type, message_direction::in, content);
+    break;
+
+  default:
+    THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, "Illegal message type " + (uint32_t)type);
+    break;
+  }
+}
+
+uint32_t message_store::add_message(const multisig_wallet_state &state,
+                                    uint32_t member_index, message_type type, message_direction direction,
+				    const std::string &content)
+{
+  message m;
+  m.id = m_next_message_id++;
+  m.type = type;
+  m.direction = direction;
+  m.content = content;
+  m.created = time(NULL);
+  m.modified = m.created;
+  m.sent = 0;
+  m.member_index = member_index;
+  if (direction == message_direction::out)
+  {
+    m.state = message_state::ready_to_send;
+  }
+  else {
+    m.state = message_state::waiting;
+  };
+  m.wallet_height = state.num_transfer_details;
+  m.round = 0;  // Future expansion for fully generalized M/N multisig
+  m.signature_count = 0;  // Future expansion for signature counting when signing txs
+  m.hash = crypto::null_hash;
+  m_messages.push_back(m);
+
+  // Save for every new message right away (at least while in beta)
+  save(state);
+
+  uint32_t id = m_messages.size() - 1;
+  MINFO(boost::format("Added %s message %s for member %s of type %s")
+	  % message_direction_to_string(direction) % id % member_index % message_type_to_string(type));
+  return id;
+}
+
+// Get the index of the message with id "id", return false if not found
+bool message_store::get_message_index_by_id(uint32_t id, uint32_t &index) const
+{
+  for (size_t i = 0; i < m_messages.size(); ++i)
+  {
+    if (m_messages[i].id == id)
+    {
+      index = i;
+      return true;
+    }
+  }
+  MWARNING("No message found with an id of " << id);
+  return false;
+}
+
+// Get the message with id "id" that must exist
+uint32_t message_store::get_message_index_by_id(uint32_t id) const
+{
+  uint32_t index;
+  bool found = get_message_index_by_id(id, index);
+  THROW_WALLET_EXCEPTION_IF(!found, tools::error::wallet_internal_error, "Invalid message id " + id);
+  return index;
+}
+
+// Get the message with id "id", return false if not found
+// This version of the method allows to check whether id is valid without triggering an error
+bool message_store::get_message_by_id(uint32_t id, message &m) const
+{
+  uint32_t index;
+  bool found = get_message_index_by_id(id, index);
+  if (found)
+  {
+    m = m_messages[index];
+  }
+  return found;
+}
+
+// Get the message with id "id" that must exist
+message message_store::get_message_by_id(uint32_t id) const
+{
+  message m;
+  bool found = get_message_by_id(id, m);
+  THROW_WALLET_EXCEPTION_IF(!found, tools::error::wallet_internal_error, "Invalid message id " + id);
+  return m;
+}
+
+bool message_store::any_message_of_type(message_type type, message_direction direction) const
+{
+  for (size_t i = 0; i < m_messages.size(); ++i)
+  {
+    if ((m_messages[i].type == type) && (m_messages[i].direction == direction))
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool message_store::any_message_with_hash(const crypto::hash &hash) const
+{
+  for (size_t i = 0; i < m_messages.size(); ++i)
+  {
+    if (m_messages[i].hash == hash)
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Is in every element of vector 'ids' (except at index 0) a message id i.e. not 0?
+// Mostly used to check whether we have a message for each coalition member except me,
+// with the member index used as index into 'ids'; the element at index 0, for me,
+// is ignored, to make constant subtractions of 1 for indices when filling the
+// vector unnecessary
+bool message_store::message_ids_complete(const std::vector<uint32_t> ids) const
+{
+  for (size_t i = 1 /* and not 0 */; i < ids.size(); ++i)
+  {
+    if (ids[i] == 0)
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+void message_store::delete_message(uint32_t id)
+{
+  delete_transport_message(id);
+  uint32_t index = get_message_index_by_id(id);
+  m_messages.erase(m_messages.begin() + index);
+}
+
+void message_store::delete_all_messages()
+{
+  for (size_t i = 0; i < m_messages.size(); ++i)
+  {
+    delete_transport_message(m_messages[i].id);
+  }
+  m_messages.clear();
+}
+
+void message_store::write_to_file(const multisig_wallet_state &state, const std::string &filename) {
+  std::stringstream oss;
+  boost::archive::portable_binary_oarchive ar(oss);
+  try
+  {
+    ar << *this;
+  }
+  catch (...)
+  {
+    THROW_WALLET_EXCEPTION_IF(true, tools::error::file_save_error, filename);
+  }
+  std::string buf = oss.str();
+
+  crypto::chacha_key key;
+  crypto::generate_chacha_key(&state.view_secret_key, sizeof(crypto::secret_key), key);
+
+  file_data write_file_data = boost::value_initialized<file_data>();
+  write_file_data.magic_string = "MMS";
+  write_file_data.file_version = 0;
+  write_file_data.iv = crypto::rand<crypto::chacha_iv>();
+  std::string encrypted_data;
+  encrypted_data.resize(buf.size());
+  crypto::chacha20(buf.data(), buf.size(), key, write_file_data.iv, &encrypted_data[0]);
+  write_file_data.encrypted_data = encrypted_data;
+
+  std::stringstream file_oss;
+  boost::archive::portable_binary_oarchive file_ar(file_oss);
+  try
+  {
+    file_ar << write_file_data;
+  }
+  catch (...)
+  {
+    THROW_WALLET_EXCEPTION_IF(true, tools::error::file_save_error, filename);
+  }
+
+  bool success = epee::file_io_utils::save_string_to_file(filename, file_oss.str());
+  THROW_WALLET_EXCEPTION_IF(!success, tools::error::file_save_error, filename);
+}
+
+void message_store::read_from_file(const multisig_wallet_state &state, const std::string &filename)
+{
+  boost::system::error_code ignored_ec;
+  bool file_exists = boost::filesystem::exists(filename, ignored_ec);
+  if (!file_exists) {
+    // Simply do nothing if the file is not there; allows e.g. easy recovery
+    // from problems with the MMS by deleting the file
+    MERROR("No message store file found: " << filename);
+    return;
+  }
+
+  std::string buf;
+  bool success = epee::file_io_utils::load_file_to_string(filename, buf);
+  THROW_WALLET_EXCEPTION_IF(!success, tools::error::file_read_error, filename);
+
+  file_data read_file_data;
+  try
+  {
+    std::stringstream iss;
+    iss << buf;
+    boost::archive::portable_binary_iarchive ar(iss);
+    ar >> read_file_data;
+  }
+  catch (const std::exception &e)
+  {
+    MERROR("MMS file " << filename << " has bad structure <iv,encrypted_data>: " << e.what());
+    THROW_WALLET_EXCEPTION_IF(true, tools::error::file_read_error, filename);
+  }
+
+  crypto::chacha_key key;
+  crypto::generate_chacha_key(&state.view_secret_key, sizeof(crypto::secret_key), key);
+  std::string decrypted_data;
+  decrypted_data.resize(read_file_data.encrypted_data.size());
+  crypto::chacha20(read_file_data.encrypted_data.data(), read_file_data.encrypted_data.size(), key, read_file_data.iv, &decrypted_data[0]);
+
+  try
+  {
+    std::stringstream iss;
+    iss << decrypted_data;
+    boost::archive::portable_binary_iarchive ar(iss);
+    ar >> *this;
+  }
+  catch (const std::exception &e)
+  {
+    MERROR("MMS file " << filename << " has bad structure: " << e.what());
+    THROW_WALLET_EXCEPTION_IF(true, tools::error::file_read_error, filename);
+  }
+
+  m_filename = filename;
+}
+
+// Save to the same file this message store was loaded from
+// Called after changes deemed "important", to make it less probable to loose messages in case of
+// a crash; a better and long-term solution would of course be to use LMDB ...
+void message_store::save(const multisig_wallet_state &state)
+{
+  if (!m_filename.empty())
+  {
+    write_to_file(state, m_filename);
+  }
+}
+
+bool message_store::get_processable_messages(const multisig_wallet_state &state,
+                                             bool force_sync, std::vector<processing_data> &data_list, std::string &wait_reason)
+{
+  uint32_t wallet_height = state.num_transfer_details;
+  data_list.clear();
+  wait_reason.clear();
+  if (m_members.size() < m_coalition_size)
+  {
+    // Unless ALL members are known we can't do anything
+    wait_reason = tr("The list of coalition members is not complete.");
+    return false;
+  }
+
+  if (!state.multisig)
+  {
+    if (!any_message_of_type(message_type::key_set, message_direction::out))
+    {
+      // With the own key set not yet ready we must do "prepare_multisig" first;
+      // Key sets from other members may be here already, but if we process them now
+      // the wallet will go multisig too early: we can't produce our own key set any more!
+      processing_data data;
+      data.processing = message_processing::prepare_multisig;
+      data_list.push_back(data);
+      return true;
+    }
+
+    // Ids of key set messages per member index, to check completeness
+    // Naturally, does not care about the order of the messages and is trivial to secure against
+    // key sets that were received more than once
+    std::vector<uint32_t> key_set_messages(m_coalition_size, 0);
+
+    for (size_t i = 0; i < m_messages.size(); ++i)
+    {
+      message &m = m_messages[i];
+      if ((m.type == message_type::key_set) && (m.state == message_state::waiting))
+      {
+	if (key_set_messages[m.member_index] == 0)
+	{
+	  key_set_messages[m.member_index] = m.id;
+	}
+	// else duplicate key set, ignore
+      }
+    }
+
+    bool key_sets_complete = message_ids_complete(key_set_messages);
+    if (key_sets_complete)
+    {
+      // Nothing else can be ready to process earlier than this, ignore everything else and give back
+      processing_data data;
+      data.processing = message_processing::make_multisig;
+      data.message_ids = key_set_messages;
+      data.message_ids.erase(data.message_ids.begin());
+      data_list.push_back(data);
+      return true;
+    }
+    else
+    {
+      wait_reason = tr("Wallet can't go multisig because key sets from other members missing or not complete.");
+      return false;
+    }
+  }
+
+  if (state.multisig && !state.multisig_is_ready)
+  {
+    // In the case of N-1/N multisig the call 'wallet2::multisig' returns already true
+    // after "make_multisig" but before "finalize_multisig", but returns the parameter
+    // 'ready' as false to document this particular state
+
+    // Same story for finalizing key sets: If all are here we process them
+    // It looks like the "finalize_multisig" command would also process less than all key sets,
+    // and maybe also correctly so, but the MMS does not support that case and insists on completeness
+    std::vector<uint32_t> finalizing_key_set_messages(m_coalition_size, 0);
+
+    for (size_t i = 0; i < m_messages.size(); ++i)
+    {
+      message &m = m_messages[i];
+      if ((m.type == message_type::finalizing_key_set) && (m.state == message_state::waiting))
+      {
+	if (finalizing_key_set_messages[m.member_index] == 0)
+	{
+	  finalizing_key_set_messages[m.member_index] = m.id;
+	}
+	// else duplicate key set, ignore
+      }
+    }
+
+    bool key_sets_complete = message_ids_complete(finalizing_key_set_messages);
+    if (key_sets_complete)
+    {
+      processing_data data;
+      data.processing = message_processing::finalize_multisig;
+      data.message_ids = finalizing_key_set_messages;
+      data.message_ids.erase(data.message_ids.begin());
+      data_list.push_back(data);
+      return true;
+    }
+    else
+    {
+      wait_reason = tr("Wallet can't finalize multisig because key sets from other members missing or not complete.");
+      return false;
+    }
+  }
+
+  // Properly exchanging multisig sync data is easiest and most transparent
+  // for the user if a wallet sends its own data first and processes any received
+  // sync data afterwards so that's the order that the MMS enforces here.
+  // (Technically, it seems to work also the other way round.)
+  //
+  // To check whether a NEW round of syncing is necessary the MMS works with a
+  // "wallet state": new state means new syncing needed.
+  //
+  // The MMS monitors the "wallet state" by recording "wallet heights" as
+  // numbers of transfers present in a wallet at the time of message creation. While
+  // not watertight, this quite simple scheme should already suffice to trigger
+  // and orchestrate a sensible exchange of sync data.
+  if (state.has_multisig_partial_key_images || force_sync)
+  {
+    // Sync is necessary and not yet completed: Processing of transactions
+    // will only be possible again once properly synced
+    // Check first whether we generated already OUR sync info; take note of
+    // any processable sync info from other members on the way in case we need it
+    bool own_sync_data_created = false;
+    std::vector<uint32_t> sync_messages(m_coalition_size, 0);
+    for (size_t i = 0; i < m_messages.size(); ++i)
+    {
+      message &m = m_messages[i];
+      if ((m.type == message_type::multisig_sync_data) && (force_sync || (m.wallet_height == wallet_height)))
+      // It's data for the same "round" of syncing, on the same "wallet height", therefore relevant
+      {
+	if (m.direction == message_direction::out)
+	{
+	  own_sync_data_created = true;
+	  // Ignore whether sent already or not, and assume as complete if several other members there
+	}
+	else if ((m.direction == message_direction::in) && (m.state == message_state::waiting))
+	{
+	  if (sync_messages[m.member_index] == 0)
+	  {
+	    sync_messages[m.member_index] = m.id;
+	  }
+	  // else duplicate sync message, ignore
+	}
+      }
+    }
+    if (!own_sync_data_created) {
+      // As explained above, creating sync data BEFORE processing such data from
+      // other members reliably works, so insist on that here
+      processing_data data;
+      data.processing = message_processing::create_sync_data;
+      data_list.push_back(data);
+      return true;
+    }
+    else if (message_ids_complete(sync_messages))
+    {
+      processing_data data;
+      data.processing = message_processing::process_sync_data;
+      data.message_ids = sync_messages;
+      data.message_ids.erase(data.message_ids.begin());
+      data_list.push_back(data);
+      return true;
+    }
+    else
+    {
+      // We can't proceed to any transactions until we have synced
+      wait_reason = tr("Syncing not possible because multisig sync data from other members missing or not complete.");
+      return false;
+    }
+  }
+
+  bool waiting_found = false;
+  for (size_t i = 0; i < m_messages.size(); ++i)
+  {
+    message &m = m_messages[i];
+    if (m.state == message_state::waiting)
+    {
+      waiting_found = true;
+      if (m.type == message_type::fully_signed_tx)
+      {
+	// We can either submit it ourselves, or send it to any other member for submission
+	processing_data data;
+	data.processing = message_processing::submit_tx;
+	data.message_ids.push_back(m.id);
+	data_list.push_back(data);
+
+	data.processing = message_processing::send_tx;
+	for (size_t j = 1; j < m_members.size(); ++j)
+	{
+	  data.receiving_member_index = j;
+	  data_list.push_back(data);
+	}
+	return true;
+      }
+      else if (m.type == message_type::partially_signed_tx)
+      {
+	if (m.member_index == 0)
+	{
+	  // We started this ourselves, or signed it but with still signatures missing:
+	  // We can send it to any other member for signing / further signing
+	  // In principle it does not make sense to send it back to somebody who
+	  // already signed, but the MMS does not / not yet keep track of that,
+	  // because that would be somewhat complicated.
+	  processing_data data;
+	  data.processing = message_processing::send_tx;
+	  data.message_ids.push_back(m.id);
+	  for (size_t j = 1; j < m_members.size(); ++j)
+	  {
+	    data.receiving_member_index = j;
+	    data_list.push_back(data);
+	  }
+	  return true;
+	}
+	else
+	{
+	  // Somebody else sent this to us: We can sign it
+	  // It would be possible to just pass it on, but that's not directly supported here
+	  processing_data data;
+	  data.processing = message_processing::sign_tx;
+	  data.message_ids.push_back(m.id);
+	  data_list.push_back(data);
+	  return true;
+	}
+      }
+    }
+  }
+  if (waiting_found)
+  {
+    wait_reason = tr("Waiting message is not a tx and thus not processable now.");
+  }
+  else
+  {
+    wait_reason = tr("There is no message waiting to be processed.");
+  }
+
+  return false;
+}
+
+void message_store::set_messages_processed(const processing_data &data)
+{
+  for (size_t i = 0; i < data.message_ids.size(); ++i)
+  {
+    set_message_processed_or_sent(data.message_ids[i]);
+  }
+}
+
+void message_store::set_message_processed_or_sent(uint32_t id)
+{
+  uint32_t index = get_message_index_by_id(id);
+  message &m = m_messages[index];
+  if (m.state == message_state::waiting)
+  {
+    // So far a fairly cautious and conservative strategy: Only delete from Bitmessage
+    // when fully processed (and e.g. not already after reception and writing into
+    // the message store file)
+    delete_transport_message(id);
+    m.state = message_state::processed;
+  }
+  else if (m.state == message_state::ready_to_send)
+  {
+    m.state = message_state::sent;
+  }
+  m.modified = time(NULL);
+}
+
+void message_store::encrypt(uint32_t member_index, const std::string &plaintext,
+			    std::string &ciphertext, crypto::public_key &encryption_public_key, crypto::chacha_iv &iv)
+{
+  crypto::secret_key encryption_secret_key;
+  crypto::generate_keys(encryption_public_key, encryption_secret_key);
+
+  crypto::key_derivation derivation;
+  crypto::public_key dest_view_public_key = m_members[member_index].monero_address.m_view_public_key;
+  bool success = crypto::generate_key_derivation(dest_view_public_key, encryption_secret_key, derivation);
+  THROW_WALLET_EXCEPTION_IF(!success, tools::error::wallet_internal_error, "Failed to generate key derivation for message encryption");
+
+  crypto::chacha_key chacha_key;
+  crypto::generate_chacha_key(&derivation, sizeof(derivation), chacha_key);
+  iv = crypto::rand<crypto::chacha_iv>();
+  ciphertext.resize(plaintext.size());
+  crypto::chacha20(plaintext.data(), plaintext.size(), chacha_key, iv, &ciphertext[0]);
+}
+
+void message_store::decrypt(const std::string &ciphertext, const crypto::public_key &encryption_public_key, const crypto::chacha_iv &iv,
+			    const crypto::secret_key &view_secret_key, std::string &plaintext)
+{
+  crypto::key_derivation derivation;
+  bool success = crypto::generate_key_derivation(encryption_public_key, view_secret_key, derivation);
+  THROW_WALLET_EXCEPTION_IF(!success, tools::error::wallet_internal_error, "Failed to generate key derivation for message decryption");
+  crypto::chacha_key chacha_key;
+  crypto::generate_chacha_key(&derivation, sizeof(derivation), chacha_key);
+  plaintext.resize(ciphertext.size());
+  crypto::chacha20(ciphertext.data(), ciphertext.size(), chacha_key, iv, &plaintext[0]);
+}
+
+void message_store::send_message(const multisig_wallet_state &state, uint32_t id)
+{
+  uint32_t index = get_message_index_by_id(id);
+  message m = m_messages[index];
+  file_transport_message dm;
+  dm.sender_address = m_members[0].monero_address;
+  dm.internal_message = m;
+  encrypt(m.member_index, m.content, dm.internal_message.content, dm.encryption_public_key, dm.iv);
+  std::string transport_address = m_members[m.member_index].transport_address;
+  if (transport_address.find("BM-") == 0)
+  {
+    // Take the transport address of the member as Bitmessage address and use the message transporter
+    transport_message rm;
+    rm.source_monero_address = dm.sender_address;
+    rm.source_transport_address = m_members[0].transport_address;
+    rm.destination_monero_address = m_members[m.member_index].monero_address;
+    rm.destination_transport_address = transport_address;
+    rm.iv = dm.iv;
+    rm.encryption_public_key = dm.encryption_public_key;
+    rm.timestamp = time(NULL);
+    rm.type = (uint32_t)dm.internal_message.type;
+    rm.subject = "MMS V0 " + get_human_readable_timestamp(rm.timestamp);
+    rm.content = dm.internal_message.content;
+    rm.hash = crypto::cn_fast_hash(rm.content.data(), rm.content.size());
+
+    crypto::generate_signature(rm.hash, m_members[0].monero_address.m_view_public_key, state.view_secret_key, rm.signature);
+
+    bool success = m_transporter.send_message(rm);
+  }
+  else
+  {
+    // Take the transport address of the member as a subdirectory and write the message as
+    // file "debug_message" there
+    std::string filename = transport_address + "/debug_message";
+
+    std::stringstream oss;
+    boost::archive::portable_binary_oarchive ar(oss);
+    ar << dm;
+    std::string buf = oss.str();
+    bool r = epee::file_io_utils::save_string_to_file(filename, buf);
+  }
+
+  m_messages[index].state=message_state::sent;
+  m_messages[index].sent= time(NULL);
+}
+
+bool message_store::check_for_messages(const multisig_wallet_state &state, std::vector<message> &messages)
+{
+  m_run.store(true, std::memory_order_relaxed);
+  std::string transport_address = m_members[0].transport_address;
+  if (transport_address.find("BM-") == 0)
+  {
+      // Take the transport address of "me" as Bitmessage address and use the messaging daemon
+    std::vector<transport_message> transport_messages;
+    bool r = m_transporter.receive_messages(m_members[0].monero_address, transport_address, transport_messages);
+    if (!m_run.load(std::memory_order_relaxed))
+    {
+      // Stop was called, don't waste time processing the messages
+      // (but once started processing them, don't react to stop request anymore, avoid receiving them "partially)"
+      return false;
+    }
+
+    bool new_messages = false;
+    for (size_t i = 0; i < transport_messages.size(); ++i)
+    {
+      transport_message rm = transport_messages[i];
+      if (any_message_with_hash(rm.hash))
+      {
+	// Already seen, do not take again
+      }
+      else
+      {
+        uint32_t sender_index;
+	bool found = get_member_index_by_monero_address(rm.source_monero_address, sender_index);
+	if (!found)
+	{
+	  // From an address that is not a member here: Ignore
+	}
+	else
+	{
+	  crypto::hash actual_hash = crypto::cn_fast_hash(rm.content.data(), rm.content.size());
+          THROW_WALLET_EXCEPTION_IF(actual_hash != rm.hash, tools::error::wallet_internal_error, "Message hash mismatch");
+
+	  bool signature_valid = crypto::check_signature(actual_hash, rm.source_monero_address.m_view_public_key, rm.signature);
+          THROW_WALLET_EXCEPTION_IF(!signature_valid, tools::error::wallet_internal_error, "Message signature not valid");
+
+	  std::string plaintext;
+	  decrypt(rm.content, rm.encryption_public_key, rm.iv, state.view_secret_key, plaintext);
+	  uint32_t index = add_message(state, sender_index, (message_type)rm.type, message_direction::in, plaintext);
+	  message &m = m_messages[index];
+	  m.hash = rm.hash;
+	  m.transport_id = rm.transport_id;
+	  m.sent = rm.timestamp;
+	  m.round = rm.round;
+	  m.signature_count = rm.signature_count;
+	  messages.push_back(m);
+	  new_messages = true;
+	}
+      }
+    }
+    return new_messages;
+  }
+  else
+  {
+    // Take the transport address of "me" as a subdirectory and read a single new
+    // message from a file "debug_message" there, assumed to come from member 1
+    std::string filename = m_members[0].transport_address + "/debug_message";
+    boost::system::error_code ignored_ec;
+    bool file_exists = boost::filesystem::exists(filename, ignored_ec);
+    if (!file_exists) {
+      return false;
+    }
+
+    file_transport_message dm;
+    std::string buf;
+    bool r = epee::file_io_utils::load_file_to_string(filename, buf);
+    std::stringstream iss;
+    iss << buf;
+    boost::archive::portable_binary_iarchive ar(iss);
+    ar >> dm;
+
+    uint32_t sender_index;
+    get_member_index_by_monero_address(dm.sender_address, sender_index);
+    std::string plaintext;
+    decrypt(dm.internal_message.content, dm.encryption_public_key, dm.iv, state.view_secret_key, plaintext);
+    add_message(state, sender_index, dm.internal_message.type, message_direction::in, plaintext);
+    boost::filesystem::remove(filename);
+    return true;
+  }
+  return false;
+}
+
+void message_store::delete_transport_message(uint32_t id)
+{
+  uint32_t index = get_message_index_by_id(id);
+  message m = m_messages[index];
+  if (!m.transport_id.empty())
+  {
+    m_transporter.delete_message(m.transport_id);
+  }
+}
+
+std::string message_store::account_address_to_string(const cryptonote::account_public_address &account_address) const
+{
+  return get_account_address_as_str(m_nettype, false, account_address);
+}
+
+const char* message_store::message_type_to_string(message_type type) {
+  switch (type)
+  {
+  case message_type::key_set:
+    return tr("key set");
+  case message_type::finalizing_key_set:
+    return tr("finalizing key set");
+  case message_type::multisig_sync_data:
+    return tr("multisig sync data");
+  case message_type::partially_signed_tx:
+    return tr("partially signed tx");
+  case message_type::fully_signed_tx:
+    return tr("fully signed tx");
+  case message_type::note:
+    return tr("note");
+  default:
+    return tr("unknown message type");
+  }
+}
+
+const char* message_store::message_direction_to_string(message_direction direction) {
+  switch (direction)
+  {
+  case message_direction::in:
+    return tr("in");
+  case message_direction::out:
+    return tr("out");
+  default:
+    return tr("unknown message direction");
+  }
+}
+
+const char* message_store::message_state_to_string(message_state state) {
+  switch (state)
+  {
+  case message_state::ready_to_send:
+    return tr("ready to send");
+  case message_state::sent:
+    return tr("sent");
+  case message_state::waiting:
+    return tr("waiting");
+  case message_state::processed:
+    return tr("processed");
+  case message_state::cancelled:
+    return tr("cancelled");
+  default:
+    return tr("unknown message state");
+  }
+}
+
+// Convert a member to string suitable for a column in a list, with 'max_width'
+// Format: label: transport_address
+std::string message_store::member_to_string(const coalition_member &member, uint32_t max_width) {
+  std::string s = "";
+  s.reserve(max_width);
+  uint32_t avail = max_width;
+  uint32_t label_len = member.label.length();
+  if (label_len > avail)
+  {
+    s.append(member.label.substr(0, avail - 2));
+    s.append("..");
+    return s;
+  }
+  s.append(member.label);
+  avail -= label_len;
+  uint32_t transport_addr_len = member.transport_address.length();
+  if ((transport_addr_len > 0) && (avail > 10))
+  {
+    s.append(": ");
+    avail -= 2;
+    if (transport_addr_len <= avail)
+    {
+      s.append(member.transport_address);
+    }
+    else
+    {
+      s.append(member.transport_address.substr(0, avail-2));
+      s.append("..");
+    }
+  }
+  return s;
+}
+
+
+}
diff --git a/src/wallet/message_store.h b/src/wallet/message_store.h
new file mode 100644
index 000000000..f12bd7d2a
--- /dev/null
+++ b/src/wallet/message_store.h
@@ -0,0 +1,357 @@
+// Copyright (c) 2014-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.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include "crypto/hash.h"
+#include <boost/serialization/vector.hpp>
+#include "serialization/serialization.h"
+#include "cryptonote_basic/cryptonote_boost_serialization.h"
+#include "cryptonote_basic/account_boost_serialization.h"
+#include "cryptonote_basic/cryptonote_basic.h"
+#include "common/i18n.h"
+#include "message_transporter.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "wallet.mms"
+
+namespace mms
+{
+  enum class message_type
+  {
+    key_set,
+    finalizing_key_set,
+    multisig_sync_data,
+    partially_signed_tx,
+    fully_signed_tx,
+    note
+  };
+
+  enum class message_direction
+  {
+    in,
+    out
+  };
+
+  enum class message_state
+  {
+    ready_to_send,
+    sent,
+
+    waiting,
+    processed,
+
+    cancelled
+  };
+
+  enum class message_processing
+  {
+    prepare_multisig,
+    make_multisig,
+    finalize_multisig,
+    create_sync_data,
+    process_sync_data,
+    sign_tx,
+    send_tx,
+    submit_tx
+  };
+
+  struct message
+  {
+    uint32_t id;
+    message_type type;
+    message_direction direction;
+    std::string content;
+    uint64_t created;
+    uint64_t modified;
+    uint64_t sent;
+    uint32_t member_index;
+    crypto::hash hash;
+    message_state state;
+    uint32_t wallet_height;
+    uint32_t round;
+    uint32_t signature_count;
+    std::string transport_id;
+  };
+  // "wallet_height" (for lack of a short name that would describe what it is about)
+  // is the number of transfers present in the wallet at the time of message
+  // construction; used to coordinate generation of sync info (which depends
+  // on the content of the wallet at time of generation)
+
+  struct coalition_member
+  {
+    std::string label;
+    std::string transport_address;
+    bool monero_address_known;
+    cryptonote::account_public_address monero_address;
+    bool me;
+    uint32_t index;
+  };
+
+  struct processing_data
+  {
+    message_processing processing;
+    std::vector<uint32_t> message_ids;
+    uint32_t receiving_member_index = 0;
+  };
+
+  struct file_transport_message
+  {
+    cryptonote::account_public_address sender_address;
+    crypto::chacha_iv iv;
+    crypto::public_key encryption_public_key;
+    message internal_message;
+  };
+
+  // Overal .mms file structure, with the "message_store" object serialized to and
+  // encrypted in "encrypted_data"
+  struct file_data
+  {
+    std::string magic_string;
+    uint32_t file_version;
+    crypto::chacha_iv iv;
+    std::string encrypted_data;
+  };
+
+    // The following struct provides info about the current state of a "wallet2" object
+  // at the time of a "message_store" method call that those methods need. See on the
+  // one hand a first parameter of this type for several of those methods, and on the
+  // other hand the method "wallet2::get_multisig_wallet_state" which clients like the
+  // CLI wallet can use to get that info.
+  //
+  // Note that in the case of a wallet that is already multisig "address" is NOT the
+  // multisig address, but the "original" wallet address at creation time. Likewise
+  // "view_secret_key" is the original view secret key then.
+  //
+  // This struct definition is here and not in "wallet2.h" to avoid circular imports.
+  struct multisig_wallet_state
+  {
+    cryptonote::account_public_address address;
+    cryptonote::network_type nettype;
+    crypto::secret_key view_secret_key;
+    bool multisig;
+    bool multisig_is_ready;
+    bool has_multisig_partial_key_images;
+    size_t num_transfer_details;
+    std::string mms_file;
+
+    ~multisig_wallet_state()
+    {
+      view_secret_key = crypto::null_skey;
+    }
+  };
+
+  class message_store
+  {
+  public:
+    message_store();
+    // Initialize and start to use the MMS, set the first member, this wallet itself
+    // Filename, if not null and not empty, is used to create the ".mms" file
+    // reset it if already used, with deletion of all members and messages
+    void init(const multisig_wallet_state &state, const std::string &own_label,
+              const std::string &own_transport_address, uint32_t coalition_size, uint32_t threshold);
+    void set_active(bool active) { m_active = active; };
+    void set_auto_send(bool auto_send) { m_auto_send = auto_send; };
+    void set_options(const boost::program_options::variables_map& vm);
+    void set_options(const std::string &bitmessage_address, const std::string &bitmessage_login);
+    bool get_active() const { return m_active; };
+    bool get_auto_send() const { return m_auto_send; };
+    uint32_t get_threshold() const { return m_threshold; };
+    uint32_t get_coalition_size() const { return m_coalition_size; };
+
+    void set_member(const multisig_wallet_state &state,
+                    uint32_t index,
+                    const boost::optional<std::string> &label,
+                    const boost::optional<std::string> &transport_address,
+                    const boost::optional<cryptonote::account_public_address> monero_address);
+
+    const coalition_member &get_member(uint32_t index) const;
+    bool get_member_index_by_monero_address(const cryptonote::account_public_address &monero_address, uint32_t &index) const;
+    bool get_member_index_by_label(const std::string label, uint32_t &index) const;
+    const std::vector<coalition_member> &get_all_members() const { return m_members; };
+    bool member_info_complete() const;
+
+    // Process data just created by "me" i.e. the own local wallet, e.g. as the result of a "prepare_multisig" command
+    // Creates the resulting messages to the right members
+    void process_wallet_created_data(const multisig_wallet_state &state, message_type type, const std::string &content);
+
+    // Go through all the messages, look at the "ready to process" ones, and check whether any single one
+    // or any group of them can be processed, because they are processable as single messages (like a tx
+    // that is fully signed and thus ready for submit to the net) or because they form a complete group
+    // (e.g. key sets from all coalition members to make the wallet multisig). If there are multiple
+    // candidates, e.g. in 2/3 multisig sending to one OR the other member to sign, there will be more
+    // than 1 element in 'data' for the user to choose. If nothing is ready "false" is returned.
+    // The method mostly ignores the order in which the messages were received because messages may be delayed
+    // (e.g. sync data from a member arrives AFTER a transaction to submit) or because message time stamps
+    // may be wrong so it's not possible to order them reliably.
+    // Messages also may be ready by themselves but the wallet not yet ready for them (e.g. sync data already
+    // arriving when the wallet is not yet multisig because key sets were delayed or were lost altogether.)
+    // If nothing is ready 'wait_reason' may contain further info about the reason why.
+    bool get_processable_messages(const multisig_wallet_state &state,
+                                  bool force_sync,
+                                  std::vector<processing_data> &data_list,
+                                  std::string &wait_reason);
+    void set_messages_processed(const processing_data &data);
+
+    uint32_t add_message(const multisig_wallet_state &state,
+                         uint32_t member_index, message_type type, message_direction direction,
+                         const std::string &content);
+    const std::vector<message> &get_all_messages() const { return m_messages; };
+    bool get_message_by_id(uint32_t id, message &m) const;
+    message get_message_by_id(uint32_t id) const;
+    void set_message_processed_or_sent(uint32_t id);
+    void delete_message(uint32_t id);
+    void delete_all_messages();
+
+    void send_message(const multisig_wallet_state &state, uint32_t id);
+    bool check_for_messages(const multisig_wallet_state &state, std::vector<message> &messages);
+    void stop() { m_run.store(false, std::memory_order_relaxed); m_transporter.stop(); }
+
+    void write_to_file(const multisig_wallet_state &state, const std::string &filename);
+    void read_from_file(const multisig_wallet_state &state, const std::string &filename);
+
+    template <class t_archive>
+    inline void serialize(t_archive &a, const unsigned int ver)
+    {
+      a & m_active;
+      a & m_coalition_size;
+      a & m_nettype;
+      a & m_threshold;
+      a & m_members;
+      a & m_messages;
+      a & m_next_message_id;
+      a & m_auto_send;
+    }
+
+    const char* message_type_to_string(message_type type);
+    const char* message_direction_to_string(message_direction direction);
+    const char* message_state_to_string(message_state state);
+    std::string member_to_string(const coalition_member &member, uint32_t max_width);
+
+    static const char *tr(const char *str) { return i18n_translate(str, "tools::mms"); }
+    static void init_options(boost::program_options::options_description& desc_params);
+
+  private:
+    bool m_active;
+    uint32_t m_coalition_size;
+    uint32_t m_threshold;
+    bool m_auto_send;
+    cryptonote::network_type m_nettype;
+    std::vector<coalition_member> m_members;
+    std::vector<message> m_messages;
+    uint32_t m_next_message_id;
+    std::string m_filename;
+    message_transporter m_transporter;
+    std::atomic<bool> m_run;
+
+    bool get_message_index_by_id(uint32_t id, uint32_t &index) const;
+    uint32_t get_message_index_by_id(uint32_t id) const;
+    bool any_message_of_type(message_type type, message_direction direction) const;
+    bool any_message_with_hash(const crypto::hash &hash) const;
+    bool message_ids_complete(const std::vector<uint32_t> ids) const;
+    void encrypt(uint32_t member_index, const std::string &plaintext,
+                 std::string &ciphertext, crypto::public_key &encryption_public_key, crypto::chacha_iv &iv);
+    void decrypt(const std::string &ciphertext, const crypto::public_key &encryption_public_key, const crypto::chacha_iv &iv,
+                 const crypto::secret_key &view_secret_key, std::string &plaintext);
+    void delete_transport_message(uint32_t id);
+    std::string account_address_to_string(const cryptonote::account_public_address &account_address) const;
+    void save(const multisig_wallet_state &state);
+  };
+}
+
+BOOST_CLASS_VERSION(mms::file_data, 0)
+BOOST_CLASS_VERSION(mms::message_store, 0)
+BOOST_CLASS_VERSION(mms::message, 0)
+BOOST_CLASS_VERSION(mms::file_transport_message, 0)
+BOOST_CLASS_VERSION(mms::coalition_member, 0)
+
+namespace boost
+{
+  namespace serialization
+  {
+    template <class Archive>
+    inline void serialize(Archive &a, mms::file_data &x, const boost::serialization::version_type ver)
+    {
+      a & x.magic_string;
+      a & x.file_version;
+      a & x.iv;
+      a & x.encrypted_data;
+    }
+
+    template <class Archive>
+    inline void serialize(Archive &a, mms::message &x, const boost::serialization::version_type ver)
+    {
+      a & x.id;
+      a & x.type;
+      a & x.direction;
+      a & x.content;
+      a & x.created;
+      a & x.modified;
+      a & x.sent;
+      a & x.member_index;
+      a & x.hash;
+      a & x.state;
+      a & x.wallet_height;
+      a & x.round;
+      a & x.signature_count;
+      a & x.transport_id;
+    }
+
+    template <class Archive>
+    inline void serialize(Archive &a, mms::coalition_member &x, const boost::serialization::version_type ver)
+    {
+      a & x.label;
+      a & x.transport_address;
+      a & x.monero_address_known;
+      a & x.monero_address;
+      a & x.me;
+      a & x.index;
+    }
+
+    template <class Archive>
+    inline void serialize(Archive &a, mms::file_transport_message &x, const boost::serialization::version_type ver)
+    {
+      a & x.sender_address;
+      a & x.iv;
+      a & x.encryption_public_key;
+      a & x.internal_message;
+    }
+
+    template <class Archive>
+    inline void serialize(Archive &a, crypto::chacha_iv &x, const boost::serialization::version_type ver)
+    {
+      a & x.data;
+    }
+
+  }
+}
\ No newline at end of file
diff --git a/src/wallet/message_transporter.cpp b/src/wallet/message_transporter.cpp
new file mode 100644
index 000000000..6394ffcfc
--- /dev/null
+++ b/src/wallet/message_transporter.cpp
@@ -0,0 +1,287 @@
+// Copyright (c) 2014-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.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#include "message_transporter.h"
+#include "string_coding.h"
+#include <boost/format.hpp>
+#include "wallet_errors.h"
+#include "net/http_client.h"
+#include "net/net_parse_helpers.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "wallet.mms"
+#define PYBITMESSAGE_DEFAULT_API_PORT 8442
+
+namespace mms
+{
+
+namespace bitmessage_rpc
+{
+
+  struct message_info
+  {
+    uint32_t encodingType;
+    std::string toAddress;
+    uint32_t read;
+    std::string msgid;
+    std::string message;
+    std::string fromAddress;
+    std::string receivedTime;
+    std::string subject;
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(encodingType)
+      KV_SERIALIZE(toAddress)
+      KV_SERIALIZE(read)
+      KV_SERIALIZE(msgid)
+      KV_SERIALIZE(message);
+      KV_SERIALIZE(fromAddress)
+      KV_SERIALIZE(receivedTime)
+      KV_SERIALIZE(subject)
+    END_KV_SERIALIZE_MAP()
+  };
+
+  struct inbox_messages_response
+  {
+    std::vector<message_info> inboxMessages;
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(inboxMessages)
+    END_KV_SERIALIZE_MAP()
+  };
+
+}
+
+message_transporter::message_transporter()
+{
+  m_run = true;
+}
+
+void message_transporter::set_options(const std::string &bitmessage_address, const std::string &bitmessage_login) {
+  m_bitmessage_url = bitmessage_address;
+  epee::net_utils::http::url_content address_parts{};
+  epee::net_utils::parse_url(m_bitmessage_url, address_parts);
+  if (address_parts.port == 0)
+  {
+    address_parts.port = PYBITMESSAGE_DEFAULT_API_PORT;
+  }
+
+  auto pos = bitmessage_login.find(":");
+  if (pos == std::string::npos)
+  {
+    m_bitmessage_user = bitmessage_login;
+    m_bitmessage_password.clear();
+  }
+  else
+  {
+    m_bitmessage_user = bitmessage_login.substr(0, pos);
+    m_bitmessage_password = bitmessage_login.substr(pos + 1);
+  }
+
+  boost::optional<epee::net_utils::http::login> login{};
+  login.emplace(m_bitmessage_user, m_bitmessage_password);
+  m_http_client.set_server(address_parts.host, std::to_string(address_parts.port), login);
+}
+
+bool message_transporter::receive_messages(const cryptonote::account_public_address &destination_monero_address,
+                                           const std::string &destination_transport_address,
+                                           std::vector<transport_message> &messages)
+{
+  // The message body of the Bitmessage message is basically the transport message, as JSON (and nothing more).
+  // Weeding out other, non-MMS messages is done in a simple way: If it deserializes without error, it's an MMS message
+  // That JSON is Base64-encoded by the MMS because the Monero epee JSON serializer does not escape anything and happily
+  // includes even 0 (NUL) in strings, which might confuse Bitmessage or at least display confusingly in the client.
+  // There is yet another Base64-encoding of course as part of the Bitmessage API for the message body parameter
+  // The Bitmessage API call "getAllInboxMessages" gives back a JSON array with all the messages (despite using
+  // XML-RPC for the calls, and not JSON-RPC ...)
+  m_run.store(true, std::memory_order_relaxed);
+  std::string request;
+  start_xml_rpc_cmd(request, "getAllInboxMessages");
+  end_xml_rpc_cmd(request);
+  std::string answer;
+  post_request(request, answer);
+
+  std::string json = get_str_between_tags(answer, "<string>", "</string>");
+  bitmessage_rpc::inbox_messages_response bitmessage_res;
+  epee::serialization::load_t_from_json(bitmessage_res, json);
+  size_t size = bitmessage_res.inboxMessages.size();
+  messages.clear();
+
+  for (size_t i = 0; i < size; ++i)
+  {
+    if (!m_run.load(std::memory_order_relaxed))
+    {
+      // Stop was called, don't waste time processing any more messages
+      return false;
+    }
+    bitmessage_rpc::message_info message_info = bitmessage_res.inboxMessages[i];
+    transport_message message;
+    bool is_mms_message = false;
+    try
+    {
+      // First Base64-decoding: The message body is Base64 in the Bitmessage API
+      std::string message_body = epee::string_encoding::base64_decode(message_info.message);
+      // Second Base64-decoding: The MMS uses Base64 to hide non-textual data in its JSON from Bitmessage
+      json = epee::string_encoding::base64_decode(message_body);
+      epee::serialization::load_t_from_json(message, json);
+      is_mms_message = true;
+    }
+    catch(const std::exception& e)
+    {
+    }
+    if (is_mms_message)
+    {
+      if (message.destination_monero_address == destination_monero_address)
+      {
+	message.transport_id = message_info.msgid;
+	messages.push_back(message);
+      }
+    }
+  }
+
+  return true;
+}
+
+bool message_transporter::send_message(const transport_message &message)
+{
+  // <toAddress> <fromAddress> <subject> <message> [encodingType [TTL]]
+  std::string request;
+  start_xml_rpc_cmd(request, "sendMessage");
+  add_xml_rpc_string_param(request, message.destination_transport_address);
+  add_xml_rpc_string_param(request, message.source_transport_address);
+  add_xml_rpc_base64_param(request, message.subject);
+  std::string json = epee::serialization::store_t_to_json(message);
+  std::string message_body = epee::string_encoding::base64_encode(json);  // See comment in "receive_message" about reason for (double-)Base64 encoding
+  add_xml_rpc_base64_param(request, message_body);
+  add_xml_rpc_integer_param(request, 2);
+  end_xml_rpc_cmd(request);
+  std::string answer;
+  post_request(request, answer);
+  return true;
+}
+
+bool message_transporter::delete_message(const std::string &transport_id)
+{
+  std::string request;
+  start_xml_rpc_cmd(request, "trashMessage");
+  add_xml_rpc_string_param(request, transport_id);
+  end_xml_rpc_cmd(request);
+  std::string answer;
+  post_request(request, answer);
+  return true;
+}
+
+bool message_transporter::post_request(const std::string &request, std::string &answer)
+{
+  // Somehow things do not work out if one tries to connect "m_http_client" to Bitmessage
+  // and keep it connected over the course of several calls. But with a new connection per
+  // call and disconnecting after the call there is no problem (despite perhaps a small
+  // slowdown)
+  epee::net_utils::http::fields_list additional_params;
+
+  // Basic access authentication according to RFC 7617 (which the epee HTTP classes do not seem to support?)
+  std::string user_password(m_bitmessage_user + ":" + m_bitmessage_password);
+  std::string auth_string = epee::string_encoding::base64_encode(user_password);
+  auth_string.insert(0, "Basic ");
+  additional_params.push_back(std::make_pair("Authorization", auth_string));
+
+  additional_params.push_back(std::make_pair("Content-Type", "application/xml; charset=utf-8"));
+  const epee::net_utils::http::http_response_info* response = NULL;
+  std::chrono::milliseconds timeout = std::chrono::seconds(15);
+  bool r = m_http_client.invoke("/", "POST", request, timeout, std::addressof(response), std::move(additional_params));
+  if (r)
+  {
+    answer = response->m_body;
+  }
+  else
+  {
+    LOG_ERROR("POST request to Bitmessage failed: " << request.substr(0, 300));
+    THROW_WALLET_EXCEPTION(tools::error::no_connection_to_bitmessage, m_bitmessage_url);
+  }
+  m_http_client.disconnect();  // see comment above
+  std::string string_value = get_str_between_tags(answer, "<string>", "</string>");
+  if ((string_value.find("API Error") == 0) || (string_value.find("RPC ") == 0))
+  {
+    THROW_WALLET_EXCEPTION(tools::error::bitmessage_api_error, string_value);
+  }
+
+  return r;
+}
+
+// Pick some string between two delimiters
+// When parsing the XML returned by PyBitmessage, don't bother to fully parse it but as a little hack rely on the
+// fact that e.g. a single string returned will be, however deeply nested in "<params><param><value>...", delivered
+// between the very first "<string>" and "</string>" tags to be found in the XML
+std::string message_transporter::get_str_between_tags(const std::string &s, const std::string &start_delim, const std::string &stop_delim)
+{
+  size_t first_delim_pos = s.find(start_delim);
+  if (first_delim_pos != std::string::npos)
+  {
+    size_t end_pos_of_first_delim = first_delim_pos + start_delim.length();
+    size_t last_delim_pos = s.find(stop_delim);
+    if (last_delim_pos != std::string::npos)
+    {
+      return s.substr(end_pos_of_first_delim, last_delim_pos - end_pos_of_first_delim);
+    }
+  }
+  return std::string();
+}
+
+void message_transporter::start_xml_rpc_cmd(std::string &xml, const std::string &method_name)
+{
+  xml = (boost::format("<?xml version=\"1.0\"?><methodCall><methodName>%s</methodName><params>") % method_name).str();
+}
+
+void message_transporter::add_xml_rpc_string_param(std::string &xml, const std::string &param)
+{
+  xml += (boost::format("<param><value><string>%s</string></value></param>") % param).str();
+}
+
+void message_transporter::add_xml_rpc_base64_param(std::string &xml, const std::string &param)
+{
+  // Bitmessage expects some arguments Base64-encoded, but it wants them as parameters of type "string", not "base64" that is also part of XML-RPC
+  std::string encoded_param = epee::string_encoding::base64_encode(param);
+  xml += (boost::format("<param><value><string>%s</string></value></param>") % encoded_param).str();
+}
+
+void message_transporter::add_xml_rpc_integer_param(std::string &xml, const int32_t &param)
+{
+  xml += (boost::format("<param><value><int>%i</int></value></param>") % param).str();
+}
+
+void message_transporter::end_xml_rpc_cmd(std::string &xml)
+{
+  xml += "</params></methodCall>";
+}
+
+
+
+}
+
diff --git a/src/wallet/message_transporter.h b/src/wallet/message_transporter.h
new file mode 100644
index 000000000..0de2bbd78
--- /dev/null
+++ b/src/wallet/message_transporter.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2014-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.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+#include "serialization/keyvalue_serialization.h"
+#include "cryptonote_basic/cryptonote_basic.h"
+#include "cryptonote_basic/cryptonote_boost_serialization.h"
+#include "cryptonote_basic/account_boost_serialization.h"
+#include "cryptonote_basic/cryptonote_basic.h"
+#include "net/http_server_impl_base.h"
+#include "net/http_client.h"
+#include "common/util.h"
+#include "serialization/keyvalue_serialization.h"
+
+#define PYBITMESSAGE_API_PORT 8442
+
+namespace mms
+{
+
+struct transport_message
+{
+  cryptonote::account_public_address source_monero_address;
+  std::string source_transport_address;
+  cryptonote::account_public_address destination_monero_address;
+  std::string destination_transport_address;
+  crypto::chacha_iv iv;
+  crypto::public_key encryption_public_key;
+  uint64_t timestamp;
+  uint32_t type;
+  std::string subject;
+  std::string content;
+  crypto::hash hash;
+  crypto::signature signature;
+  uint32_t round;
+  uint32_t signature_count;
+  std::string transport_id;
+
+  BEGIN_KV_SERIALIZE_MAP()
+    KV_SERIALIZE(source_monero_address)
+    KV_SERIALIZE(source_transport_address)
+    KV_SERIALIZE(destination_monero_address)
+    KV_SERIALIZE(destination_transport_address)
+    KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(iv)
+    KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(encryption_public_key)
+    KV_SERIALIZE(timestamp)
+    KV_SERIALIZE(type)
+    KV_SERIALIZE(subject)
+    KV_SERIALIZE(content)
+    KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(hash)
+    KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(signature)
+    KV_SERIALIZE(round)
+    KV_SERIALIZE(signature_count)
+    KV_SERIALIZE(transport_id)
+  END_KV_SERIALIZE_MAP()
+};
+
+class message_transporter {
+public:
+  message_transporter();
+  void set_options(const std::string &bitmessage_address, const std::string &bitmessage_login);
+  bool send_message(const transport_message &message);
+  bool receive_messages(const cryptonote::account_public_address &destination_monero_address,
+                        const std::string &destination_transport_address,
+                        std::vector<transport_message> &messages);
+  bool delete_message(const std::string &transport_id);
+  void stop() { m_run.store(false, std::memory_order_relaxed); }
+
+private:
+  epee::net_utils::http::http_simple_client m_http_client;
+  std::string m_bitmessage_url;
+  std::string m_bitmessage_user;
+  std::string m_bitmessage_password;
+  std::atomic<bool> m_run;
+
+  bool post_request(const std::string &request, std::string &answer);
+  std::string get_str_between_tags(const std::string &s, const std::string &start_delim, const std::string &stop_delim);
+
+  void start_xml_rpc_cmd(std::string &xml, const std::string &method_name);
+  void add_xml_rpc_string_param(std::string &xml, const std::string &param);
+  void add_xml_rpc_base64_param(std::string &xml, const std::string &param);
+  void add_xml_rpc_integer_param(std::string &xml, const int32_t &param);
+  void end_xml_rpc_cmd(std::string &xml);
+
+};
+
+}
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 4c4ee8bf3..1bb9f52bc 100755
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -153,7 +153,7 @@ struct options {
   };
 };
 
-void do_prepare_file_names(const std::string& file_path, std::string& keys_file, std::string& wallet_file)
+void do_prepare_file_names(const std::string& file_path, std::string& keys_file, std::string& wallet_file, std::string &mms_file)
 {
   keys_file = file_path;
   wallet_file = file_path;
@@ -165,6 +165,7 @@ void do_prepare_file_names(const std::string& file_path, std::string& keys_file,
   {//provided wallet file name
     keys_file += ".keys";
   }
+  mms_file = file_path + ".mms";
 }
 
 uint64_t calculate_fee(uint64_t fee_per_kb, size_t bytes, uint64_t fee_multiplier)
@@ -230,6 +231,7 @@ std::unique_ptr<tools::wallet2> make_basic(const boost::program_options::variabl
   wallet->init(std::move(daemon_address), std::move(login));
   boost::filesystem::path ringdb_path = command_line::get_arg(vm, opts.shared_ringdb_dir);
   wallet->set_ring_database(ringdb_path.string());
+  wallet->get_message_store().set_options(vm);
   return wallet;
 }
 
@@ -676,6 +678,8 @@ wallet2::wallet2(network_type nettype, bool restricted):
   m_light_wallet_connected(false),
   m_light_wallet_balance(0),
   m_light_wallet_unlocked_balance(0),
+  m_original_keys_available(false),
+  m_message_store(),
   m_key_on_device(false),
   m_ring_history_saved(false),
   m_ringdb()
@@ -709,6 +713,7 @@ void wallet2::init_options(boost::program_options::options_description& desc_par
   command_line::add_arg(desc_params, opts.stagenet);
   command_line::add_arg(desc_params, opts.restricted);
   command_line::add_arg(desc_params, opts.shared_ringdb_dir);
+  mms::message_store::init_options(desc_params);
 }
 
 std::unique_ptr<wallet2> wallet2::make_from_json(const boost::program_options::variables_map& vm, const std::string& json_file, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
@@ -2581,6 +2586,7 @@ bool wallet2::store_keys(const std::string& keys_file_name, const epee::wipeable
   rapidjson::Document json;
   json.SetObject();
   rapidjson::Value value(rapidjson::kStringType);
+
   value.SetString(account_data.c_str(), account_data.length());
   json.AddMember("key_data", value, json.GetAllocator());
   if (!seed_language.empty())
@@ -2683,6 +2689,22 @@ bool wallet2::store_keys(const std::string& keys_file_name, const epee::wipeable
   value2.SetUint(m_subaddress_lookahead_minor);
   json.AddMember("subaddress_lookahead_minor", value2, json.GetAllocator());
 
+  value2.SetInt(m_original_keys_available ? 1 : 0);
+  json.AddMember("original_keys_available", value2, json.GetAllocator());
+
+  std::string original_address;
+  std::string original_view_secret_key;
+  if (m_original_keys_available)
+  {
+    original_address = get_account_address_as_str(m_nettype, false, m_original_address);
+    value.SetString(original_address.c_str(), original_address.length());
+    json.AddMember("original_address", value, json.GetAllocator());
+
+    original_view_secret_key = epee::string_tools::pod_to_hex(m_original_view_secret_key);
+    value.SetString(original_view_secret_key.c_str(), original_view_secret_key.length());
+    json.AddMember("original_view_secret_key", value, json.GetAllocator());
+  }
+
   // Serialize the JSON object
   rapidjson::StringBuffer buffer;
   rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
@@ -2758,6 +2780,7 @@ bool wallet2::load_keys(const std::string& keys_file_name, const epee::wipeable_
     m_segregation_height = 0;
     m_subaddress_lookahead_major = SUBADDRESS_LOOKAHEAD_MAJOR;
     m_subaddress_lookahead_minor = SUBADDRESS_LOOKAHEAD_MINOR;
+    m_original_keys_available = false;
     m_key_on_device = false;
   }
   else if(json.IsObject())
@@ -2884,6 +2907,44 @@ bool wallet2::load_keys(const std::string& keys_file_name, const epee::wipeable_
     m_subaddress_lookahead_major = field_subaddress_lookahead_major;
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, subaddress_lookahead_minor, uint32_t, Uint, false, SUBADDRESS_LOOKAHEAD_MINOR);
     m_subaddress_lookahead_minor = field_subaddress_lookahead_minor;
+
+    if (json.HasMember("original_keys_available"))
+    {
+      GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_keys_available, int, Int, false, false);
+      m_original_keys_available = field_original_keys_available;
+      if (m_original_keys_available)
+      {
+	GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_address, std::string, String, false, std::string());
+	if (!field_original_address_found)
+	{
+	  LOG_ERROR("Field original_address not found in JSON");
+	  return false;
+	}
+	address_parse_info info;
+	bool ok = get_account_address_from_str(info, m_nettype, field_original_address);
+        if (!ok)
+	{
+	  LOG_ERROR("Failed to parse original_address from JSON");
+	  return false;
+	}
+	m_original_address = info.address;
+	GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_view_secret_key, std::string, String, false, std::string());
+	if (!field_original_view_secret_key_found)
+	{
+	  LOG_ERROR("Field original_view_secret_key not found in JSON");
+	  return false;
+	}
+	ok = epee::string_tools::hex_to_pod(field_original_view_secret_key, m_original_view_secret_key);
+	if (!ok)
+	{
+	  LOG_ERROR("Failed to parse original_view_secret_key from JSON");
+	}
+      }
+    }
+    else
+    {
+      m_original_keys_available = false;
+    }
   }
   else
   {
@@ -3051,6 +3112,10 @@ void wallet2::generate(const std::string& wallet_, const epee::wipeable_string&
   m_multisig_signers = multisig_signers;
   m_key_on_device = false;
 
+  // Not possible to restore a multisig wallet that is able to activate the MMS
+  // (because the original keys are not (yet) part of the restore info)
+  m_original_keys_available = false;
+
   if (!wallet_.empty())
   {
     bool r = store_keys(m_keys_file, password, false);
@@ -3101,6 +3166,7 @@ crypto::secret_key wallet2::generate(const std::string& wallet_, const epee::wip
   m_multisig = false;
   m_multisig_threshold = 0;
   m_multisig_signers.clear();
+  m_original_keys_available = false;
   m_key_on_device = false;
 
   // calculate a starting refresh height
@@ -3199,6 +3265,7 @@ void wallet2::generate(const std::string& wallet_, const epee::wipeable_string&
   m_multisig = false;
   m_multisig_threshold = 0;
   m_multisig_signers.clear();
+  m_original_keys_available = false;
   m_key_on_device = false;
 
   if (!wallet_.empty())
@@ -3249,6 +3316,7 @@ void wallet2::generate(const std::string& wallet_, const epee::wipeable_string&
   m_multisig = false;
   m_multisig_threshold = 0;
   m_multisig_signers.clear();
+  m_original_keys_available = false;
   m_key_on_device = false;
 
   if (!wallet_.empty())
@@ -3295,6 +3363,7 @@ void wallet2::restore(const std::string& wallet_, const epee::wipeable_string& p
   m_multisig = false;
   m_multisig_threshold = 0;
   m_multisig_signers.clear();
+  m_original_keys_available = false;
 
   if (!wallet_.empty()) {
     bool r = store_keys(m_keys_file, password, false);
@@ -3369,6 +3438,15 @@ std::string wallet2::make_multisig(const epee::wipeable_string &password,
     CHECK_AND_ASSERT_THROW_MES(false, "Unsupported threshold case");
   }
 
+  if (!m_original_keys_available)
+  {
+    // Save the original i.e. non-multisig keys so the MMS can continue to use them to encrypt and decrypt messages
+    // (making a wallet multisig overwrites those keys, see account_base::make_multisig)
+    m_original_address = m_account.get_keys().m_account_address;
+    m_original_view_secret_key = m_account.get_keys().m_view_secret_key;
+    m_original_keys_available = true;
+  }
+
   // the multisig view key is shared by all, make one all can derive
   MINFO("Creating view key...");
   crypto::secret_key view_skey = cryptonote::generate_multisig_view_secret_key(get_account().get_keys().m_view_secret_key, view_keys);
@@ -3696,8 +3774,8 @@ void wallet2::write_watch_only_wallet(const std::string& wallet_name, const epee
 //----------------------------------------------------------------------------------------------------
 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);
+  std::string keys_file, wallet_file, mms_file;
+  do_prepare_file_names(file_path, keys_file, wallet_file, mms_file);
 
   boost::system::error_code ignore;
   keys_file_exists = boost::filesystem::exists(keys_file, ignore);
@@ -3751,7 +3829,7 @@ bool wallet2::parse_payment_id(const std::string& payment_id_str, crypto::hash&
 //----------------------------------------------------------------------------------------------------
 bool wallet2::prepare_file_names(const std::string& file_path)
 {
-  do_prepare_file_names(file_path, m_keys_file, m_wallet_file);
+  do_prepare_file_names(file_path, m_keys_file, m_wallet_file, m_mms_file);
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -3922,6 +4000,8 @@ void wallet2::load(const std::string& wallet_, const epee::wipeable_string& pass
   {
     MERROR("Failed to save rings, will try again next time");
   }
+
+  m_message_store.read_from_file(get_multisig_wallet_state(), m_mms_file);
 }
 //----------------------------------------------------------------------------------------------------
 void wallet2::trim_hashchain()
@@ -4029,6 +4109,7 @@ void wallet2::store_to(const std::string &path, const epee::wipeable_string &pas
   const std::string old_file = m_wallet_file;
   const std::string old_keys_file = m_keys_file;
   const std::string old_address_file = m_wallet_file + ".address.txt";
+  const std::string old_mms_file = m_mms_file;
 
   // save keys to the new file
   // if we here, main wallet file is saved and we only need to save keys and address files
@@ -4058,6 +4139,14 @@ void wallet2::store_to(const std::string &path, const epee::wipeable_string &pas
     if (!r) {
       LOG_ERROR("error removing file: " << old_address_file);
     }
+    // remove old message store file
+    if (boost::filesystem::exists(old_mms_file))
+      {
+      r = boost::filesystem::remove(old_mms_file);
+      if (!r) {
+	LOG_ERROR("error removing file: " << old_mms_file);
+      }
+    }
   } else {
     // save to new file
 #ifdef WIN32
@@ -4083,6 +4172,14 @@ void wallet2::store_to(const std::string &path, const epee::wipeable_string &pas
     std::error_code e = tools::replace_file(new_file, m_wallet_file);
     THROW_WALLET_EXCEPTION_IF(e, error::file_save_error, m_wallet_file, e);
   }
+
+  if (m_message_store.get_active())
+  {
+    // While the "m_message_store" object of course always exist, a file for the message
+    // store should only exist if the MMS is really active
+    m_message_store.write_to_file(get_multisig_wallet_state(), m_mms_file);
+  }
+
 }
 //----------------------------------------------------------------------------------------------------
 uint64_t wallet2::balance(uint32_t index_major) const
@@ -10561,4 +10658,28 @@ void wallet2::generate_genesis(cryptonote::block& b) const {
     cryptonote::generate_genesis_block(b, config::GENESIS_TX, config::GENESIS_NONCE);
   }
 }
+//----------------------------------------------------------------------------------------------------
+mms::multisig_wallet_state wallet2::get_multisig_wallet_state()
+{
+  mms::multisig_wallet_state state;
+  state.nettype = m_nettype;
+  state.multisig = multisig(&state.multisig_is_ready);
+  state.has_multisig_partial_key_images = has_multisig_partial_key_images();
+  state.num_transfer_details = m_transfers.size();
+  if (state.multisig)
+  {
+    THROW_WALLET_EXCEPTION_IF(!m_original_keys_available, error::wallet_internal_error, "MMS use not possible because own original Monero address not available");
+    state.address = m_original_address;
+    state.view_secret_key = m_original_view_secret_key;
+  }
+  else
+  {
+    state.address = m_account.get_keys().m_account_address;
+    state.view_secret_key = m_account.get_keys().m_view_secret_key;
+  }
+  state.mms_file=m_mms_file;
+  return state;
+}
+
+
 }
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index f2e861f18..1d7a2b155 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -58,6 +58,7 @@
 #include "wallet_errors.h"
 #include "common/password.h"
 #include "node_rpc_proxy.h"
+#include "message_store.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "wallet.wallet2"
@@ -454,6 +455,7 @@ namespace tools
 
     typedef std::tuple<uint64_t, crypto::public_key, rct::key> get_outs_entry;
 
+
     /*!
      * \brief  Generates a wallet or restores one.
      * \param  wallet_              Name of wallet file
@@ -593,7 +595,7 @@ namespace tools
     bool init(std::string daemon_address = "http://localhost:8080",
       boost::optional<epee::net_utils::http::login> daemon_login = boost::none, uint64_t upper_transaction_size_limit = 0, bool ssl = false);
 
-    void stop() { m_run.store(false, std::memory_order_relaxed); }
+    void stop() { m_run.store(false, std::memory_order_relaxed); m_message_store.stop(); }
 
     i_wallet2_callback* callback() const { return m_callback; }
     void callback(i_wallet2_callback* callback) { m_callback = callback; }
@@ -1077,6 +1079,10 @@ namespace tools
     bool unblackball_output(const crypto::public_key &output);
     bool is_output_blackballed(const crypto::public_key &output) const;
 
+    // MMS -------------------------------------------------------------------------------------------------
+    mms::message_store& get_message_store() { return m_message_store; };
+    mms::multisig_wallet_state get_multisig_wallet_state();
+
   private:
     /*!
      * \brief  Stores wallet information to wallet file.
@@ -1148,6 +1154,7 @@ namespace tools
     std::string m_daemon_address;
     std::string m_wallet_file;
     std::string m_keys_file;
+    std::string m_mms_file;
     epee::net_utils::http::http_simple_client m_http_client;
     hashchain m_blockchain;
     std::atomic<uint64_t> m_local_bc_height; //temporary workaround
@@ -1232,6 +1239,11 @@ namespace tools
     std::string m_ring_database;
     bool m_ring_history_saved;
     std::unique_ptr<ringdb> m_ringdb;
+
+    mms::message_store m_message_store;
+    bool m_original_keys_available;
+    cryptonote::account_public_address m_original_address;
+    crypto::secret_key m_original_view_secret_key;
   };
 }
 BOOST_CLASS_VERSION(tools::wallet2, 24)
diff --git a/src/wallet/wallet_errors.h b/src/wallet/wallet_errors.h
index 214d51cde..46dcc1ddd 100644
--- a/src/wallet/wallet_errors.h
+++ b/src/wallet/wallet_errors.h
@@ -784,6 +784,31 @@ namespace tools
       std::string m_wallet_file;
     };
     //----------------------------------------------------------------------------------------------------
+    struct mms_error : public wallet_logic_error
+    {
+    protected:
+      explicit mms_error(std::string&& loc, const std::string& message)
+        : wallet_logic_error(std::move(loc), message)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct no_connection_to_bitmessage : public mms_error
+    {
+      explicit no_connection_to_bitmessage(std::string&& loc, const std::string& address)
+        : mms_error(std::move(loc), "no connection to PyBitmessage at address " + address)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct bitmessage_api_error : public mms_error
+    {
+      explicit bitmessage_api_error(std::string&& loc, const std::string& error_string)
+        : mms_error(std::move(loc), "PyBitmessage returned " + error_string)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
 
 #if !defined(_MSC_VER)
 

From fc915d3e0fbd8046a18a22d8f17eec9aaa4a8d08 Mon Sep 17 00:00:00 2001
From: rbrunner7 <rbrunner@dreamshare.ch>
Date: Sun, 28 Oct 2018 20:00:33 +0100
Subject: [PATCH 40/54] MMS: Some Wownero-specific changes in
 'simplewallet.cpp'

---
 src/simplewallet/simplewallet.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 8519265b9..d2acf5182 100755
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -1665,7 +1665,7 @@ void simple_wallet::mms_info(const std::vector<std::string> &args)
 }
 
 void simple_wallet::mms_member(const std::vector<std::string> &args)
-// mms 0:member [1:<number> <2:label> [3:<transport_address> [4:<monero_address>]]]
+// mms 0:member [1:<number> <2:label> [3:<transport_address> [4:<wownero_address>]]]
 {
   mms::message_store& ms = m_wallet->get_message_store();
   const std::vector<mms::coalition_member> &members = ms.get_all_members();
@@ -1673,7 +1673,7 @@ void simple_wallet::mms_member(const std::vector<std::string> &args)
   {
     // Without further parameters list all defined members
     success_msg_writer() << boost::format("%2s %-20s %-s") % tr("#") % tr("Label") % tr("Transport Address");
-    success_msg_writer() << boost::format("%2s %-20s %-s") % "" % "" % tr("Monero Address");
+    success_msg_writer() << boost::format("%2s %-20s %-s") % "" % "" % tr("Wownero Address");
     for (size_t i = 0; i < members.size(); ++i)
     {
       const mms::coalition_member &member = members[i];
@@ -1708,7 +1708,7 @@ void simple_wallet::mms_member(const std::vector<std::string> &args)
   }
   if (args.size() < 3)
   {
-    fail_msg_writer() << tr("mms member [<number> <label> [<transport_address> [<monero_address>]]]");
+    fail_msg_writer() << tr("mms member [<number> <label> [<transport_address> [<wownero_address>]]]");
     return;
   }
 
@@ -1726,14 +1726,14 @@ void simple_wallet::mms_member(const std::vector<std::string> &args)
     bool ok = cryptonote::get_account_address_from_str_or_url(info, m_wallet->nettype(), args[4], oa_prompter);
     if (!ok)
     {
-      fail_msg_writer() << tr("Invalid Monero address");
+      fail_msg_writer() << tr("Invalid Wownero address");
       return;
     }
     monero_address = info.address;
     const std::vector<mms::message> &messages = ms.get_all_messages();
     if ((messages.size() > 0) || state.multisig)
     {
-      fail_msg_writer() << tr("Wallet state does not allow changing Monero addresses anymore");
+      fail_msg_writer() << tr("Wallet state does not allow changing Wownero addresses anymore");
       return;
     }
   }
@@ -2104,7 +2104,7 @@ void simple_wallet::mms_help(const std::vector<std::string> &args)
   std::vector<std::string> help_args;
   help_args.push_back("mms");
   help_args.push_back(args[1]);
-  help(help_args);
+  help_advanced(help_args);
 }
 
 bool simple_wallet::mms(const std::vector<std::string> &args)
@@ -3196,9 +3196,9 @@ simple_wallet::simple_wallet()
   m_cmd_binder.set_handler("mms",
                            boost::bind(&simple_wallet::mms, this, _1),
                            tr("mms [<subcommand> [<subcommand_parameters>]]"),
-                           tr("Interface with the MMS (Monero Messaging System)\n"
+                           tr("Interface with the MMS (Multisig Messaging System)\n"
 			      "subcommand is one of: init, info, member, list, next, sync, transfer, delete, send, receive, note, show, set, help\n"
-			      "Get help about a subcommand with: help mms <subcommand>"));
+			      "Get help about a subcommand with: help_advanced mms <subcommand>, or: mms help <subcommand>"));
   m_cmd_binder.set_handler("mms init",
                            boost::bind(&simple_wallet::mms, this, _1),
                            tr("mms init <threshold>/<coalition_size> <own_label> <own_transport_address>"),
@@ -3209,8 +3209,8 @@ simple_wallet::simple_wallet()
                            tr("Display current MMS configuration"));
   m_cmd_binder.set_handler("mms member",
                            boost::bind(&simple_wallet::mms, this, _1),
-                           tr("mms member [<number> <label> [<transport_address> [<monero_address>]]]"),
-                           tr("Set or modify coalition member info (single-word label, transport address, Monero address), or list all members"));
+                           tr("mms member [<number> <label> [<transport_address> [<wownero_address>]]]"),
+                           tr("Set or modify coalition member info (single-word label, transport address, Wownero address), or list all members"));
   m_cmd_binder.set_handler("mms list",
                            boost::bind(&simple_wallet::mms, this, _1),
                            tr("mms list"),

From 398a21019c4ea0e24b9c1b2d729557585ab941bf Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Mon, 29 Oct 2018 01:05:00 +0300
Subject: [PATCH 41/54] up version

---
 README.md          | 2 +-
 src/version.cpp.in | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 385246d89..89a4b196b 100644
--- a/README.md
+++ b/README.md
@@ -95,7 +95,7 @@ Dates are provided in the format YYYY-MM-DD.
 | ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
 | 1                              | 2018-04-01 | v7                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 6969                           | 2018-04-24 | v8                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
-| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.0                  | Cryptonight variant 2, LWMA v2, ringsize = 22, XXX
+| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.1                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
 
 X's indicate that these details have not been determined as of commit date.
 
diff --git a/src/version.cpp.in b/src/version.cpp.in
index e316851c6..3908a9c39 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.1.0"
+#define DEF_MONERO_VERSION "0.3.1.1"
 #define DEF_MONERO_RELEASE_NAME "Cool Cage"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 

From 47b543b591cd10e5165f2cf015d50874735b5a61 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Mon, 29 Oct 2018 01:20:17 +0300
Subject: [PATCH 42/54] update checkpoints

---
 src/blocks/checkpoints.dat         | Bin 7364 -> 7460 bytes
 src/checkpoints/checkpoints.cpp    |   1 +
 src/cryptonote_core/blockchain.cpp |   2 +-
 3 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index ae16639799f48f9f6caf1d0715352dbab25a8560..13137708071f644741ac3efce2c1c1076c7c8e74 100644
GIT binary patch
delta 107
zcmV-x0F?j4IixxP>9GOB9AE~D%~dVYOTH$C2hdE7H3lQGfboz#VK+SNhTwNiyFQ_8
znz+6=<DDHxA$*yZ-+b-Ite%%66(nB?e<X3hwe}o*IUz5=b#!OR^dC~dxugeAw5vXG
Nzx$JP;PjPeF(P4bGWP%g

delta 10
RcmZ2tb;OeK*+$00G5{GE1XKV3

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 70a90f785..300993018 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -191,6 +191,7 @@ namespace cryptonote
       ADD_CHECKPOINT(55000,  "4b662ceccefc3247edb4d654dd610b8fb496e85b88a5de43cc2bdd28171b15ff");
       ADD_CHECKPOINT(57000,  "08a79f09f12bb5d230b63963356a760d51618e526cfc636047a6f3798217c177");
       ADD_CHECKPOINT(59000,  "180b51ee2c5fbcd4362eb7a29df9422481310dd77d10bccdf8930724c31e007e");
+      ADD_CHECKPOINT(59900,  "18cc0653ef39cb304c68045dba5eb6b885f936281cd939dea04d0e6c9cd4ae2e");
 
       return true;
   }
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 4e9dfe44f..3ee53a464 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4452,7 +4452,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "897d3ae0f3aef8ef8362b0bb3535925738414fa78d9146f8a04c60555fa5a95f";
+static const char expected_block_hashes_hash[] = "876bea21d9b941a3b4d281c39cda1f549fa91c3a6b0695b01f81f929f7d6159d";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;

From d1623175b267df596becd30b998c4ea4dd8298f6 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Tue, 6 Nov 2018 21:19:09 +0300
Subject: [PATCH 43/54] update checkpoints

---
 README.md                          |   2 +-
 src/blocks/checkpoints.dat         | Bin 7460 -> 7780 bytes
 src/checkpoints/checkpoints.cpp    |   6 ++++++
 src/cryptonote_core/blockchain.cpp |   2 +-
 src/version.cpp.in                 |   2 +-
 5 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 89a4b196b..04b75a925 100644
--- a/README.md
+++ b/README.md
@@ -95,7 +95,7 @@ Dates are provided in the format YYYY-MM-DD.
 | ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
 | 1                              | 2018-04-01 | v7                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 6969                           | 2018-04-24 | v8                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
-| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.1                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
+| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.2                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
 
 X's indicate that these details have not been determined as of commit date.
 
diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index 13137708071f644741ac3efce2c1c1076c7c8e74..59fc46785a52c43cc99445ca9128e2cd3a7ec362 100644
GIT binary patch
delta 333
zcmV-T0kZz2I^;Y7^RWRV9e+<D=6SC^s3K9<uhba(Q!<C8#TOjgkUAaK&Xku@ehOjN
zz5ktnBu@cgOTsXz7CZS&a#h4!=_;Ft8)=t3P=YHIk5|i^e3oeG+qMDerYJrt$HVgM
zC5f?Cm;{3=`)f{p0zv@r2c;|QXg~>ahUpmifFLeDQ=rGdd9iv-B!3@q_e#kMNu-?8
zIe~OyA`z?z3Es>2Y%9?qLaH^<jQ$;9#u|f2+2~<p=Dce6f|S{6j<l7}EC7IO)>&;G
zgn7s1szYXT%<C^-<)n7##7>-&Abj0VOAL9{GG0=t`SdhVkRWYJ>WUy(ymjwtg;H|)
zb+;W~1!O`lL*OYhWkL>X=uW>4+I?iJZ+_bE31{U`S979dMFARZ{t!bw{5rXNg>}<R
fQCW>KKrTp)lkcw@97{9!m<BeAn)~M5ln2@`qe`8_

delta 10
RcmaE2v&4$=<wizjSpXS<1KR)q

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 300993018..2f830ef38 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -192,6 +192,12 @@ namespace cryptonote
       ADD_CHECKPOINT(57000,  "08a79f09f12bb5d230b63963356a760d51618e526cfc636047a6f3798217c177");
       ADD_CHECKPOINT(59000,  "180b51ee2c5fbcd4362eb7a29df9422481310dd77d10bccdf8930724c31e007e");
       ADD_CHECKPOINT(59900,  "18cc0653ef39cb304c68045dba5eb6b885f936281cd939dea04d0e6c9cd4ae2e");
+      ADD_CHECKPOINT(60000,  "0f02aa57a63f79f63dafed9063abe228a37cb19f00430dc3168b8a8f4ae8016c");
+      ADD_CHECKPOINT(61000,  "509aca8c54eb5fe44623768757b6e890ae39d512478c75f614cbff3d91809350");
+      ADD_CHECKPOINT(62000,  "7fe91ad256c08dbd961e04738968be22fb481093fbfa7959bde7796ccceba0e2");
+      ADD_CHECKPOINT(62150,  "1a7c75f8ebeda0e20eb5877181eafd7db0fc887e3fed43e0b27ab2e7bccafd10");
+      ADD_CHECKPOINT(62269,  "4969555d60742afb93925fd96d83ac28f45e6e3c0e583c9fb3c92d9b2100d38f");
+
 
       return true;
   }
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 3ee53a464..a0e3580e4 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4452,7 +4452,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "876bea21d9b941a3b4d281c39cda1f549fa91c3a6b0695b01f81f929f7d6159d";
+static const char expected_block_hashes_hash[] = "4dcb4285e8c51d1672ac96f9408b04a4949f7c50900afb78841d0af890b99e83";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 3908a9c39..94fc3c35e 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.1.1"
+#define DEF_MONERO_VERSION "0.3.1.2"
 #define DEF_MONERO_RELEASE_NAME "Cool Cage"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 

From 8b56a44adcd7f4b57d94231b707b19f1c6e97b6a Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 7 Nov 2018 19:19:07 +0300
Subject: [PATCH 44/54] counter attack

---
 src/checkpoints/checkpoints.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 2f830ef38..fbeb17bd2 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -197,6 +197,9 @@ namespace cryptonote
       ADD_CHECKPOINT(62000,  "7fe91ad256c08dbd961e04738968be22fb481093fbfa7959bde7796ccceba0e2");
       ADD_CHECKPOINT(62150,  "1a7c75f8ebeda0e20eb5877181eafd7db0fc887e3fed43e0b27ab2e7bccafd10");
       ADD_CHECKPOINT(62269,  "4969555d60742afb93925fd96d83ac28f45e6e3c0e583c9fb3c92d9b2100d38f");
+      ADD_CHECKPOINT(62419,  "bd8bf5ac4c4fb07ab4d0d492bd1699def5c095ab6943ad3b63a89d1d8b1ce748");
+      ADD_CHECKPOINT(62425,  "41a922dba6f3906871b2ccaf31ec9c91033470c503959093dae796deda8940ea");
+
 
 
       return true;

From caae62e2cefa52e090a6483b9361fac6fd5147cc Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 7 Nov 2018 20:28:05 +0300
Subject: [PATCH 45/54] update checkpoints

---
 README.md                       | 2 +-
 src/checkpoints/checkpoints.cpp | 2 +-
 src/version.cpp.in              | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 04b75a925..66de4e32c 100644
--- a/README.md
+++ b/README.md
@@ -95,7 +95,7 @@ Dates are provided in the format YYYY-MM-DD.
 | ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
 | 1                              | 2018-04-01 | v7                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 6969                           | 2018-04-24 | v8                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
-| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.2                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
+| 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.3                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
 
 X's indicate that these details have not been determined as of commit date.
 
diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index fbeb17bd2..589fb376a 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -199,7 +199,7 @@ namespace cryptonote
       ADD_CHECKPOINT(62269,  "4969555d60742afb93925fd96d83ac28f45e6e3c0e583c9fb3c92d9b2100d38f");
       ADD_CHECKPOINT(62419,  "bd8bf5ac4c4fb07ab4d0d492bd1699def5c095ab6943ad3b63a89d1d8b1ce748");
       ADD_CHECKPOINT(62425,  "41a922dba6f3906871b2ccaf31ec9c91033470c503959093dae796deda8940ea");
-
+      ADD_CHECKPOINT(62479,  "a2e8ff4205ba2980eb70921b0b21b5fc656ee273664ea94b860c68ca069b60dd");
 
 
       return true;
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 94fc3c35e..8ff3212b8 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.1.2"
+#define DEF_MONERO_VERSION "0.3.1.3"
 #define DEF_MONERO_RELEASE_NAME "Cool Cage"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 

From 6cf896f8ab9ab578371c3a4a82f4e77fbd9923bc Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 7 Nov 2018 20:49:04 +0300
Subject: [PATCH 46/54] update checkpoints

---
 src/blocks/checkpoints.dat         | Bin 7780 -> 7812 bytes
 src/checkpoints/checkpoints.cpp    |   2 +-
 src/cryptonote_core/blockchain.cpp |   2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index 59fc46785a52c43cc99445ca9128e2cd3a7ec362..626b0c1b83b9e802cf52ff34113cf694c363b60d 100644
GIT binary patch
delta 43
zcmV+`0M!5FJcK;~^sxbB9w6+&kFk%#zGg(atJ3Pr&@BDJVc2JfZ3U}S0E$-GUH|ez
B7bE}x

delta 10
RcmZp%ePYA-c_U-88~_-L1PK5D

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 589fb376a..ac5f57c35 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -197,11 +197,11 @@ namespace cryptonote
       ADD_CHECKPOINT(62000,  "7fe91ad256c08dbd961e04738968be22fb481093fbfa7959bde7796ccceba0e2");
       ADD_CHECKPOINT(62150,  "1a7c75f8ebeda0e20eb5877181eafd7db0fc887e3fed43e0b27ab2e7bccafd10");
       ADD_CHECKPOINT(62269,  "4969555d60742afb93925fd96d83ac28f45e6e3c0e583c9fb3c92d9b2100d38f");
+      ADD_CHECKPOINT(62405,  "4d0ae890cf9f875f231c7069508ad28dc429d14814b52db114dfab7519a27584");
       ADD_CHECKPOINT(62419,  "bd8bf5ac4c4fb07ab4d0d492bd1699def5c095ab6943ad3b63a89d1d8b1ce748");
       ADD_CHECKPOINT(62425,  "41a922dba6f3906871b2ccaf31ec9c91033470c503959093dae796deda8940ea");
       ADD_CHECKPOINT(62479,  "a2e8ff4205ba2980eb70921b0b21b5fc656ee273664ea94b860c68ca069b60dd");
 
-
       return true;
   }
 
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index a0e3580e4..8c73819f1 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4452,7 +4452,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "4dcb4285e8c51d1672ac96f9408b04a4949f7c50900afb78841d0af890b99e83";
+static const char expected_block_hashes_hash[] = "991bae8e227c5ba51767522aaea4fc7c1e54be8528793fe9301aff8f3031b7d7";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;

From 3263067b971b308946e9d5ff6a350f5e38b23e89 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Wed, 7 Nov 2018 22:04:23 +0300
Subject: [PATCH 47/54] update checkpoint

---
 src/checkpoints/checkpoints.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index ac5f57c35..0f3dc64db 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -201,6 +201,7 @@ namespace cryptonote
       ADD_CHECKPOINT(62419,  "bd8bf5ac4c4fb07ab4d0d492bd1699def5c095ab6943ad3b63a89d1d8b1ce748");
       ADD_CHECKPOINT(62425,  "41a922dba6f3906871b2ccaf31ec9c91033470c503959093dae796deda8940ea");
       ADD_CHECKPOINT(62479,  "a2e8ff4205ba2980eb70921b0b21b5fc656ee273664ea94b860c68ca069b60dd");
+      ADD_CHECKPOINT(62503,  "25fa115962988b4b8f8cfd22744a3e653b22ead8c8468e64caf334fc75a97d08");
 
       return true;
   }

From 8adea0a0346f836426209dccc70df8602fc55dac Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Thu, 8 Nov 2018 17:52:47 +0300
Subject: [PATCH 48/54] update checkpoints

---
 src/checkpoints/checkpoints.cpp | 2 ++
 src/version.cpp.in              | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index 0f3dc64db..fa242c8c2 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -202,6 +202,8 @@ namespace cryptonote
       ADD_CHECKPOINT(62425,  "41a922dba6f3906871b2ccaf31ec9c91033470c503959093dae796deda8940ea");
       ADD_CHECKPOINT(62479,  "a2e8ff4205ba2980eb70921b0b21b5fc656ee273664ea94b860c68ca069b60dd");
       ADD_CHECKPOINT(62503,  "25fa115962988b4b8f8cfd22744a3e653b22ead8c8468e64caf334fc75a97d08");
+      ADD_CHECKPOINT(62550,  "bde522a8a81c392c98c979434aa1dd9d20b4ca52230ba6ae0362872757808a48");
+      ADD_CHECKPOINT(62629,  "8368e1ce1d421f1fc969364558433e2b2363d0ffcb5f2d946633095e3e6734f5");
 
       return true;
   }
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 8ff3212b8..15db5ab41 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,5 +1,5 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.1.3"
+#define DEF_MONERO_VERSION "0.3.1.4"
 #define DEF_MONERO_RELEASE_NAME "Cool Cage"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 

From 7bc2142590602da6a5e4bfb1a41436ba94b274dc Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Thu, 8 Nov 2018 18:21:52 +0300
Subject: [PATCH 49/54] correct cumulative difficulty count

---
 src/cryptonote_basic/difficulty.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index fbd97df30..530fe81a6 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -256,9 +256,9 @@ namespace cryptonote {
 
     assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= static_cast<uint64_t>(N+1) );
 
-    if ( height <= DIFFICULTY_HEIGHT ){ 
+    /*if ( height <= DIFFICULTY_HEIGHT ){ 
       return static_cast<uint64_t>(DIFFICULTY_GUESS); 
-    }
+    }*/
 
     for ( int64_t i = 1; i <= N; i++ ) {  
       ST = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i-1]);

From 47bd60ba50a59cfa75d2f94df1ce720cf7fa2c1a Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Thu, 8 Nov 2018 21:15:49 +0300
Subject: [PATCH 50/54] Replace LWMA-3 with LWMA-4, add v10 fork height

---
 README.md                           |  1 +
 src/cryptonote_basic/difficulty.cpp | 89 ++++++++++++++++++-----------
 src/cryptonote_config.h             |  3 +-
 src/cryptonote_core/blockchain.cpp  |  3 +-
 4 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/README.md b/README.md
index 66de4e32c..96ab39e2c 100644
--- a/README.md
+++ b/README.md
@@ -96,6 +96,7 @@ Dates are provided in the format YYYY-MM-DD.
 | 1                              | 2018-04-01 | v7                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 6969                           | 2018-04-24 | v8                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
 | 53666                          | 2018-10-06 | v9                | v0.3.0.0               | v0.3.1.3                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
+| 63469                          | 2018-11-11 | v10               | v0.4.0.0               | v0.4.0.0                  | LWMA v4
 
 X's indicate that these details have not been determined as of commit date.
 
diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index 530fe81a6..927e1baf7 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -285,42 +285,65 @@ namespace cryptonote {
     }
   }
 
-  // LWMA-3 difficulty algorithm 
+  // LWMA-4 difficulty algorithm 
   // Copyright (c) 2017-2018 Zawy, MIT License
+  // https://github.com/zawy12/difficulty-algorithms/issues/3
   difficulty_type next_difficulty_v4(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t height) {
 
-    uint64_t  T = DIFFICULTY_TARGET_V2;
-    uint64_t  N = DIFFICULTY_WINDOW_V2;
-    uint64_t  L(0), ST, sum_3_ST(0), next_D, prev_D, this_timestamp, previous_timestamp;
-
+   uint64_t  T = DIFFICULTY_TARGET_V2;
+   uint64_t  N = DIFFICULTY_WINDOW_V2; // N=45, 60, and 90 for T=600, 120, 60.
+   uint64_t  L(0), ST(0), next_D, prev_D, avg_D, i;
+        
     assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
-
-    if ( height == DIFFICULTY_HEIGHT_V2 ){
-      return static_cast<uint64_t>(DIFFICULTY_GUESS);
-    }
-
-    previous_timestamp = timestamps[0];
-    for ( uint64_t i = 1; i <= N; i++) {
-      if ( timestamps[i] > previous_timestamp ) {
-        this_timestamp = timestamps[i];
-      } else { this_timestamp = previous_timestamp+1; }
-      ST = std::min(6*T ,this_timestamp - previous_timestamp);
-      previous_timestamp = this_timestamp;
-      L +=  ST * i ;
-      if ( i > N-3 ) { sum_3_ST += ST; }
-    }
-
-    next_D = ((cumulative_difficulties[N] - cumulative_difficulties[0])*T*(N+1)*99)/(100*2*L);
-    prev_D = cumulative_difficulties[N] - cumulative_difficulties[N-1];
-    next_D = std::max((prev_D*67)/100, std::min(next_D, (prev_D*150)/100));
-
-    if ( sum_3_ST < (8*T)/10) {  next_D = std::max(next_D,(prev_D*108)/100); }
-
-    if ( next_D < DIFFICULTY_MINIMUM ) { 
-      return static_cast<uint64_t>(DIFFICULTY_MINIMUM); 
-    }
-    else {
-      return static_cast<uint64_t>(next_D);
-    }
+   
+   if ( height <= DIFFICULTY_HEIGHT + 1 + N ) { return DIFFICULTY_GUESS;  }
+ 
+   // Safely convert out-of-sequence timestamps into > 0 solvetimes.
+   std::vector<uint64_t>TS(N+1);
+   TS[0] = timestamps[0];
+   for ( i = 1; i <= N; i++) {        
+      if ( timestamps[i]  > TS[i-1]  ) {   TS[i] = timestamps[i];  } 
+      else {  TS[i] = TS[i-1];   }
+   }
+
+   for ( i = 1; i <= N; i++) {  
+      // Ignore long solvetimes if they were preceeded by 3 or 6 fast solves.
+      if ( i > 4 && TS[i]-TS[i-1] > 4*T  && TS[i-1] - TS[i-4] < (16*T)/10 ) {   ST = 2*T; }
+      else if ( i > 7 && TS[i]-TS[i-1] > 4*T  && TS[i-1] - TS[i-7] < 4*T ) {   ST = 2*T; }
+      else { // Assume normal conditions, so get ST.
+         // LWMA drops too much from long ST, so limit drops with a 5*T limit 
+         ST = std::min(5*T ,TS[i] - TS[i-1]);
+      }
+      L +=  ST * i ; 
+   } 
+   if (L < N*N*T/20 ) { L =  N*N*T/20; } 
+   avg_D = ( cumulative_difficulties[N] - cumulative_difficulties[0] )/ N;
+   
+   // Prevent round off error for small D and overflow for large D.
+   if (avg_D > 2000000*N*N*T) { 
+       next_D = (avg_D/(200*L))*(N*(N+1)*T*97);   
+   }   
+   else {    next_D = (avg_D*N*(N+1)*T*97)/(200*L);    }
+
+   prev_D =  cumulative_difficulties[N] - cumulative_difficulties[N-1] ; 
+
+   // Apply 10% jump rule.
+   if (  ( TS[N] - TS[N-1] < (2*T)/10 ) || 
+         ( TS[N] - TS[N-2] < (5*T)/10 ) ||  
+         ( TS[N] - TS[N-3] < (8*T)/10 )    )
+   {  
+       next_D = std::max( next_D, std::min( (prev_D*110)/100, (105*avg_D)/100 ) ); 
+   }
+   // Make all insignificant digits zero for easy reading.
+   i = 1000000000;
+   while (i > 1) { 
+     if ( next_D > i*100 ) { next_D = ((next_D+i/2)/i)*i; break; }
+     else { i /= 10; }
+   }
+   // Make least 3 digits equal avg of past 10 solvetimes.
+   if ( next_D > 100000 ) { 
+    next_D = ((next_D+500)/1000)*1000 + std::min(static_cast<uint64_t>(999), (TS[N]-TS[N-10])/10); 
+   }
+   return  next_D;
   }
 }
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index bf446a81f..17b0aaa10 100755
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -82,8 +82,7 @@
 #define DIFFICULTY_CUT                                  60  // timestamps to cut after sorting
 #define DIFFICULTY_BLOCKS_COUNT_V2                      DIFFICULTY_WINDOW_V2 + 1 // added +1 to make N=N
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG
-#define DIFFICULTY_HEIGHT                               53666 // v9 fork height
-#define DIFFICULTY_HEIGHT_V2                            777777 // v10 fork height
+#define DIFFICULTY_HEIGHT                               63469 // v10 fork height
 #define DIFFICULTY_GUESS                                40000000 // difficulty at fork 40m
 #define DIFFICULTY_MINIMUM                              25000000 // minimum difficulty set to 25m
 
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 8c73819f1..396235772 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -93,6 +93,7 @@ static const struct {
  { 7, 1, 0, 1519605000 },
  { 8, 6969, 0, 1524214739 },
  { 9, 53666, 0, 1538689773 },
+ { 10, 63469, 0, 1541700352 },
 };
 
 static const uint64_t mainnet_hard_fork_version_1_till = ((uint64_t)(0));
@@ -1061,7 +1062,7 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
     return next_difficulty_v2(timestamps, cumulative_difficulties, target);
   }
   else if (version == 9) {
-    return next_difficulty_v2(timestamps, cumulative_difficulties, height);
+    return next_difficulty_v3(timestamps, cumulative_difficulties, height);
   }    
   else {
     return next_difficulty_v4(timestamps, cumulative_difficulties, height);

From 003f0b3af3ffe37d4a329c6bcdd4ddb3b003e3f7 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Fri, 9 Nov 2018 12:49:51 +0300
Subject: [PATCH 51/54] v0.4 ASCII art

---
 src/cryptonote_core/cryptonote_core.cpp | 26 ++++++++++++++++---------
 src/version.cpp.in                      |  4 ++--
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index da79b5598..19a5678e3 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -1344,16 +1344,24 @@ namespace cryptonote
         main_message = "The daemon is running offline and will not attempt to sync to the Monero network.";
       else
         main_message = "The daemon will start synchronizing with the network. This may take a long time to complete.";
-      MGINFO_BLUE(ENDL <<
+      MGINFO_GREEN(ENDL <<
       "\n \n"
-      "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░▄█▄░░░░████▄░████▄░█░░░░░░░░▄█▄░░░░██░░░░▄▀░░▄███▄░░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░█▀ ▀▄░░█░░░█░█░░░█░█░░░░░░░░█▀ ▀▄░░█ █░░▄▀░░░█▀░░░▀░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░█░░░░░░█░░░█░█░░░█░█░░░░░░░░█░░░░░░█▄▄█ █░▀▄░██▄▄░░░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░█▄░░▄▀ ▀████░▀████░███▄░░░░░█▄░░▄▀ █░░█ █░░░█░█▄░░░▄▀░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░▀███▀░░░░░░░░░░░░░░░░░░▀░░░░▀███▀░░░░░█░░███░░▀███▀░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░░░░░░░░░░░\n" 
-      "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▀░░░░░░░░░░░░░░░░░░░░░░░░░" << ENDL);
+      "                                \n"
+      "      | __/|                     \n"
+      "      | @ @   WoW!              \n"
+      "      |   <>              _     \n"
+      "      |  _/|------____ ((| |))  \n"
+      "      |               `--' |    \n"
+      "  ____|_       ___|   |___.'    \n"
+      " /_/_____/____/_______|         \n"
+      "########################################################\n"
+      "### ____ ############ _ #### ____ ######################\n" 
+      "###|  _ |  __ _ _ __ | | __ |  _ |  ___   __ _  ___  ###\n"
+      "###| | | |/ _` | '_ || |/ / | | | |/ _ | / _` |/ _ | ###\n"
+      "###| |_| | (_| | | | |   <  | |_| | (_) | (_| |  __/ ###\n"
+      "###|____/ |__,_|_| |_|_||_| |____/ |___/  __, ||___| ###\n"
+      "#########################################|___/##########\n"
+      "########################################################"<< ENDL);
       MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
         << main_message << ENDL
         << ENDL
diff --git a/src/version.cpp.in b/src/version.cpp.in
index 15db5ab41..a28dcd8dc 100755
--- a/src/version.cpp.in
+++ b/src/version.cpp.in
@@ -1,6 +1,6 @@
 #define DEF_MONERO_VERSION_TAG "@VERSIONTAG@"
-#define DEF_MONERO_VERSION "0.3.1.4"
-#define DEF_MONERO_RELEASE_NAME "Cool Cage"
+#define DEF_MONERO_VERSION "0.4.0.0"
+#define DEF_MONERO_RELEASE_NAME "Dank Doge"
 #define DEF_MONERO_VERSION_FULL DEF_MONERO_VERSION "-" DEF_MONERO_VERSION_TAG
 
 #include "version.h"

From 7f28f73bd6d0578b7501f77b8c20c848659eb9a3 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Fri, 9 Nov 2018 13:02:08 +0300
Subject: [PATCH 52/54] Difficulty: temper long solvetime

---
 src/cryptonote_basic/difficulty.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index 927e1baf7..688164424 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -295,7 +295,7 @@ namespace cryptonote {
    uint64_t  L(0), ST(0), next_D, prev_D, avg_D, i;
         
     assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
-   
+
    if ( height <= DIFFICULTY_HEIGHT + 1 + N ) { return DIFFICULTY_GUESS;  }
  
    // Safely convert out-of-sequence timestamps into > 0 solvetimes.
@@ -307,9 +307,9 @@ namespace cryptonote {
    }
 
    for ( i = 1; i <= N; i++) {  
-      // Ignore long solvetimes if they were preceeded by 3 or 6 fast solves.
-      if ( i > 4 && TS[i]-TS[i-1] > 4*T  && TS[i-1] - TS[i-4] < (16*T)/10 ) {   ST = 2*T; }
-      else if ( i > 7 && TS[i]-TS[i-1] > 4*T  && TS[i-1] - TS[i-7] < 4*T ) {   ST = 2*T; }
+      // Temper long solvetime drops if they were preceded by 3 or 6 fast solves.
+      if ( i > 4 && TS[i]-TS[i-1] > 5*T  && TS[i-1] - TS[i-4] < (14*T)/10 ) {   ST = 2*T; }
+      else if ( i > 7 && TS[i]-TS[i-1] > 5*T  && TS[i-1] - TS[i-7] < 4*T ) {   ST = 2*T; }
       else { // Assume normal conditions, so get ST.
          // LWMA drops too much from long ST, so limit drops with a 5*T limit 
          ST = std::min(5*T ,TS[i] - TS[i-1]);

From 698d041e64e46d89947a58e68ec1a263251afaa0 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Fri, 9 Nov 2018 18:34:07 +0300
Subject: [PATCH 53/54] update checkpoints

---
 src/blocks/checkpoints.dat         | Bin 7812 -> 7844 bytes
 src/checkpoints/checkpoints.cpp    |   3 +++
 src/cryptonote_core/blockchain.cpp |   2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/blocks/checkpoints.dat b/src/blocks/checkpoints.dat
index 626b0c1b83b9e802cf52ff34113cf694c363b60d..5bcd092781cac8e24cd7728be8de0b590bba23bd 100644
GIT binary patch
delta 43
zcmZp%U1H1lbt7Z5oWjFYwt_Bezbk^8Z;Uj!ZP|r_H+ggQ<j=8oeL464gXgjUV<8c0

delta 10
RcmZ2t+hWW3Wg}y=8~_&=1M2_)

diff --git a/src/checkpoints/checkpoints.cpp b/src/checkpoints/checkpoints.cpp
index fa242c8c2..8cf237adb 100755
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@@ -204,6 +204,9 @@ namespace cryptonote
       ADD_CHECKPOINT(62503,  "25fa115962988b4b8f8cfd22744a3e653b22ead8c8468e64caf334fc75a97d08");
       ADD_CHECKPOINT(62550,  "bde522a8a81c392c98c979434aa1dd9d20b4ca52230ba6ae0362872757808a48");
       ADD_CHECKPOINT(62629,  "8368e1ce1d421f1fc969364558433e2b2363d0ffcb5f2d946633095e3e6734f5");
+      ADD_CHECKPOINT(62720,  "f871cddd75951e2fe24c282d2bd28396fc922ea519b354ace992a0162cb333ff");
+      ADD_CHECKPOINT(62733,  "8331dbeeaf23173d2235a062373a437befadb6492cceb7640127bf18653a9e61");
+      ADD_CHECKPOINT(62877,  "62d44adc05d7d4fd9d15239c5575612207beab0bcf2da49158bf89e365441ca1");
 
       return true;
   }
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 396235772..4c1078efd 100755
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -4453,7 +4453,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "991bae8e227c5ba51767522aaea4fc7c1e54be8528793fe9301aff8f3031b7d7";
+static const char expected_block_hashes_hash[] = "e06ddfd59a891d5e63e80795d8e0494a7c1e3b01a1faa4ed91b015ecfc38c003";
 void Blockchain::load_compiled_in_block_hashes()
 {
   const bool testnet = m_nettype == TESTNET;

From fc9d0deb387e17ad820ce44a5633bb9b6505c965 Mon Sep 17 00:00:00 2001
From: wowario <wowario@protonmail.com>
Date: Fri, 9 Nov 2018 19:09:29 +0300
Subject: [PATCH 54/54] update difficulty minimum and guess

---
 src/cryptonote_basic/difficulty.cpp | 10 ++++++++--
 src/cryptonote_config.h             |  4 ++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/cryptonote_basic/difficulty.cpp b/src/cryptonote_basic/difficulty.cpp
index 688164424..c84fff7a5 100644
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@@ -296,7 +296,7 @@ namespace cryptonote {
         
     assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
 
-   if ( height <= DIFFICULTY_HEIGHT + 1 + N ) { return DIFFICULTY_GUESS;  }
+   if ( height <= DIFFICULTY_HEIGHT + 1 ) { return DIFFICULTY_GUESS;  }
  
    // Safely convert out-of-sequence timestamps into > 0 solvetimes.
    std::vector<uint64_t>TS(N+1);
@@ -344,6 +344,12 @@ namespace cryptonote {
    if ( next_D > 100000 ) { 
     next_D = ((next_D+500)/1000)*1000 + std::min(static_cast<uint64_t>(999), (TS[N]-TS[N-10])/10); 
    }
-   return  next_D;
+
+   if ( next_D < DIFFICULTY_MINIMUM ) {
+    return static_cast<uint64_t>(DIFFICULTY_MINIMUM);
+   } 
+   else { 
+    return static_cast<uint64_t>(next_D); 
+   }
   }
 }
diff --git a/src/cryptonote_config.h b/src/cryptonote_config.h
index 17b0aaa10..ebf8a020f 100755
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@@ -83,8 +83,8 @@
 #define DIFFICULTY_BLOCKS_COUNT_V2                      DIFFICULTY_WINDOW_V2 + 1 // added +1 to make N=N
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG
 #define DIFFICULTY_HEIGHT                               63469 // v10 fork height
-#define DIFFICULTY_GUESS                                40000000 // difficulty at fork 40m
-#define DIFFICULTY_MINIMUM                              25000000 // minimum difficulty set to 25m
+#define DIFFICULTY_GUESS                                100000069 // difficulty at fork 100m
+#define DIFFICULTY_MINIMUM                              40000069 // minimum difficulty set to 40m
 
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V1   DIFFICULTY_TARGET_V1 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V2   DIFFICULTY_TARGET_V2 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS