23 files changed, 2019 insertions, 460 deletions
diff --git a/src/common/stack_trace.cpp b/src/common/stack_trace.cpp
index 2805e7604..0d2ccb39d 100644
--- a/src/common/stack_trace.cpp
+++ b/src/common/stack_trace.cpp
@@ -33,7 +33,9 @@
 #include <libunwind.h>
 #endif
 #include <cxxabi.h>
+#ifndef STATICLIB
 #include <dlfcn.h>
+#endif
 
 // from http://stackoverflow.com/questions/11665829/how-can-i-print-stack-trace-for-caught-exceptions-in-c-code-injection-in-c
 #ifdef STATICLIB
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 6ea934acd..4a7a70b8c 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -485,6 +485,68 @@ bool simple_wallet::set_default_mixin(const std::vector<std::string> &args/* = s
   }
 }
 
+bool simple_wallet::set_default_fee_multiplier(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
+{
+  bool success = false;
+  int fee_multiplier = 0;
+  if (m_wallet->watch_only())
+  {
+    fail_msg_writer() << tr("wallet is watch-only and cannot transfer");
+    return true;
+  }
+  try
+  {
+    if (strchr(args[1].c_str(), '-'))
+    {
+      fail_msg_writer() << tr("fee multiplier must be 0, 1, 2, or 3 ");
+      return true;
+    }
+    if (args[1] == "0")
+    {
+      fee_multiplier = 0;
+    }
+    else
+    {
+      fee_multiplier = boost::lexical_cast<int>(args[1]);
+      if (fee_multiplier != 1 && fee_multiplier != 2 && fee_multiplier != 3)
+      {
+        fail_msg_writer() << tr("fee multiplier must be 0, 1, 2, or 3");
+        return true;
+      }
+    }
+
+    tools::password_container pwd_container;
+    success = pwd_container.read_password();
+    if (!success)
+    {
+      fail_msg_writer() << tr("failed to read wallet password");
+      return true;
+    }
+
+    /* verify password before using so user doesn't accidentally set a new password for rewritten wallet */
+    success = m_wallet->verify_password(pwd_container.password());
+    if (!success)
+    {
+      fail_msg_writer() << tr("invalid password");
+      return true;
+    }
+
+    m_wallet->set_default_fee_multiplier(fee_multiplier);
+    m_wallet->rewrite(m_wallet_file, pwd_container.password());
+    return true;
+  }
+  catch(const boost::bad_lexical_cast &)
+  {
+    fail_msg_writer() << tr("fee multiplier must be 0, 1, 2 or 3");
+    return true;
+  }
+  catch(...)
+  {
+    fail_msg_writer() << tr("could not change default fee multiplier");
+    return true;
+  }
+}
+
 bool simple_wallet::set_auto_refresh(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
   bool success = false;
@@ -587,7 +649,7 @@ simple_wallet::simple_wallet()
   m_cmd_binder.set_handler("viewkey", boost::bind(&simple_wallet::viewkey, this, _1), tr("Display private view key"));
   m_cmd_binder.set_handler("spendkey", boost::bind(&simple_wallet::spendkey, this, _1), tr("Display private spend key"));
   m_cmd_binder.set_handler("seed", boost::bind(&simple_wallet::seed, this, _1), tr("Display Electrum-style mnemonic seed"));
-  m_cmd_binder.set_handler("set", boost::bind(&simple_wallet::set_variable, this, _1), tr("Available options: seed language - set wallet seed language; always-confirm-transfers <1|0> - whether to confirm unsplit txes; store-tx-info <1|0> - whether to store outgoing tx info (destination address, payment ID, tx secret key) for future reference; default-mixin <n> - set default mixin (default default is 4); auto-refresh <1|0> - whether to automatically sync new blocks from the daemon; refresh-type <full|optimize-coinbase|no-coinbase|default> - set wallet refresh behaviour"));
+  m_cmd_binder.set_handler("set", boost::bind(&simple_wallet::set_variable, this, _1), tr("Available options: seed language - set wallet seed language; always-confirm-transfers <1|0> - whether to confirm unsplit txes; store-tx-info <1|0> - whether to store outgoing tx info (destination address, payment ID, tx secret key) for future reference; default-mixin <n> - set default mixin (default default is 4); auto-refresh <1|0> - whether to automatically sync new blocks from the daemon; refresh-type <full|optimize-coinbase|no-coinbase|default> - set wallet refresh behaviour; fee-multiplier [1|2|3] - normal/elevated/priority fee"));
   m_cmd_binder.set_handler("rescan_spent", boost::bind(&simple_wallet::rescan_spent, this, _1), tr("Rescan blockchain for spent outputs"));
   m_cmd_binder.set_handler("get_tx_key", boost::bind(&simple_wallet::get_tx_key, this, _1), tr("Get transaction key (r) for a given <txid>"));
   m_cmd_binder.set_handler("check_tx_key", boost::bind(&simple_wallet::check_tx_key, this, _1), tr("Check amount going to <address> in <txid>"));
@@ -609,6 +671,7 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
     success_msg_writer() << "default-mixin = " << m_wallet->default_mixin();
     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() << "fee-multiplier = " << m_wallet->get_default_fee_multiplier();
     return true;
   }
   else
@@ -704,6 +767,21 @@ bool simple_wallet::set_variable(const std::vector<std::string> &args)
         return true;
       }
     }
+    else if (args[0] == "fee-multiplier")
+    {
+      if (args.size() <= 1)
+      {
+        fail_msg_writer() << tr("set fee-multiplier: needs an argument: 0, 1, 2, or 3");
+        return true;
+      }
+      else
+      {
+        std::vector<std::string> local_args = args;
+        local_args.erase(local_args.begin(), local_args.begin()+2);
+        set_default_fee_multiplier(local_args);
+        return true;
+      }
+    }
   }
   fail_msg_writer() << tr("set: unrecognized argument(s)");
   return true;
@@ -2999,7 +3077,7 @@ bool simple_wallet::show_transfers(const std::vector<std::string> &args_)
   }
 
   LOCK_REFRESH_THREAD_SCOPE();
-
+  
   // optional in/out selector
   if (local_args.size() > 0) {
     if (local_args[0] == "in" || local_args[0] == "incoming") {
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 66f74b456..e0478eb6e 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -142,6 +142,7 @@ namespace cryptonote
     bool set_tx_note(const std::vector<std::string> &args);
     bool get_tx_note(const std::vector<std::string> &args);
     bool status(const std::vector<std::string> &args);
+    bool set_default_fee_multiplier(const std::vector<std::string> &args);
 
     uint64_t get_daemon_blockchain_height(std::string& err);
     bool try_connect_to_daemon();
diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt
index a6fc37dec..0b8fe4cb1 100644
--- a/src/wallet/CMakeLists.txt
+++ b/src/wallet/CMakeLists.txt
@@ -26,15 +26,24 @@
 # 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.
 
+# include (${PROJECT_SOURCE_DIR}/cmake/libutils.cmake)
+include (${PROJECT_SOURCE_DIR}/cmake/MergeStaticLibs.cmake)
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
 set(wallet_sources
   wallet2.cpp
   wallet_rpc_server.cpp
-  wallet2_api.cpp)
+  api/wallet.cpp
+  api/wallet_manager.cpp
+  api/transaction_info.cpp
+  api/transaction_history.cpp
+  api/pending_transaction.cpp
+  api/utils.cpp)
 
-set(wallet_headers)
+set(wallet_api_headers
+    wallet2_api.h)
+    
 
 set(wallet_private_headers
   wallet2.h
@@ -42,13 +51,18 @@ set(wallet_private_headers
   wallet_rpc_server.h
   wallet_rpc_server_commands_defs.h
   wallet_rpc_server_error_codes.h
-  wallet2_api.h)
+  api/wallet.h
+  api/wallet_manager.h
+  api/transaction_info.h
+  api/transaction_history.h
+  api/pending_transaction.h
+  api/common_defines.h)
 
 bitmonero_private_headers(wallet
   ${wallet_private_headers})
 bitmonero_add_library(wallet
   ${wallet_sources}
-  ${wallet_headers}
+  ${wallet_api_headers}
   ${wallet_private_headers})
 target_link_libraries(wallet
   LINK_PUBLIC
@@ -61,3 +75,15 @@ target_link_libraries(wallet
     ${Boost_REGEX_LIBRARY}
     ${EXTRA_LIBRARIES})
 
+
+set(libs_to_merge wallet cryptonote_core mnemonics common crypto)
+#MERGE_STATIC_LIBS(wallet_merged wallet_merged "${libs_to_merge}")
+merge_static_libs(wallet_merged "${libs_to_merge}")
+
+install(TARGETS wallet_merged
+    ARCHIVE DESTINATION lib)
+
+install(FILES ${wallet_api_headers}
+    DESTINATION include/wallet)
+
+
diff --git a/src/wallet/api/common_defines.h b/src/wallet/api/common_defines.h
new file mode 100644
index 000000000..60a40a45a
--- /dev/null
+++ b/src/wallet/api/common_defines.h
@@ -0,0 +1,7 @@
+#ifndef WALLET_API_COMMON_DEFINES_H__
+#define WALLET_API_COMMON_DEFINES_H__
+
+#define tr(x) (x)
+
+#endif
+
diff --git a/src/wallet/api/pending_transaction.cpp b/src/wallet/api/pending_transaction.cpp
new file mode 100644
index 000000000..c4a770f87
--- /dev/null
+++ b/src/wallet/api/pending_transaction.cpp
@@ -0,0 +1,138 @@
+// Copyright (c) 2014-2016, 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 "pending_transaction.h"
+#include "wallet.h"
+#include "common_defines.h"
+
+#include "cryptonote_core/cryptonote_format_utils.h"
+#include "cryptonote_core/cryptonote_basic_impl.h"
+#include "cryptonote_core/cryptonote_format_utils.h"
+
+#include <memory>
+#include <vector>
+#include <sstream>
+#include <boost/format.hpp>
+
+using namespace std;
+
+namespace Bitmonero {
+
+PendingTransaction::~PendingTransaction() {}
+
+
+PendingTransactionImpl::PendingTransactionImpl(WalletImpl &wallet)
+    : m_wallet(wallet)
+{
+
+}
+
+PendingTransactionImpl::~PendingTransactionImpl()
+{
+
+}
+
+int PendingTransactionImpl::status() const
+{
+    return m_status;
+}
+
+string PendingTransactionImpl::errorString() const
+{
+    return m_errorString;
+}
+
+bool PendingTransactionImpl::commit()
+{
+
+    LOG_PRINT_L0("m_pending_tx size: " << m_pending_tx.size());
+    assert(m_pending_tx.size() == 1);
+    try {
+        while (!m_pending_tx.empty()) {
+            auto & ptx = m_pending_tx.back();
+            m_wallet.m_wallet->commit_tx(ptx);
+            // success_msg_writer(true) << tr("Money successfully sent, transaction ") << get_transaction_hash(ptx.tx);
+            // if no exception, remove element from vector
+            m_pending_tx.pop_back();
+        } // TODO: extract method;
+    } catch (const tools::error::daemon_busy&) {
+        // TODO: make it translatable with "tr"?
+        m_errorString = tr("daemon is busy. Please try again later.");
+        m_status = Status_Error;
+    } catch (const tools::error::no_connection_to_daemon&) {
+        m_errorString = tr("no connection to daemon. Please make sure daemon is running.");
+        m_status = Status_Error;
+    } catch (const tools::error::tx_rejected& e) {
+        std::ostringstream writer(m_errorString);
+        writer << (boost::format(tr("transaction %s was rejected by daemon with status: ")) % get_transaction_hash(e.tx())) <<  e.status();
+        m_status = Status_Error;
+    } catch (std::exception &e) {
+        m_errorString = string(tr("Unknown exception: ")) + e.what();
+        m_status = Status_Error;
+    } catch (...) {
+        m_errorString = tr("Unhandled exception");
+        LOG_ERROR(m_errorString);
+        m_status = Status_Error;
+    }
+
+    return m_status == Status_Ok;
+}
+
+uint64_t PendingTransactionImpl::amount() const
+{
+    uint64_t result = 0;
+    for (const auto &ptx : m_pending_tx)   {
+        for (const auto &dest : ptx.dests) {
+            result += dest.amount;
+        }
+    }
+    return result;
+}
+
+uint64_t PendingTransactionImpl::dust() const
+{
+    uint32_t result = 0;
+    for (const auto & ptx : m_pending_tx) {
+        result += ptx.dust;
+    }
+    return result;
+}
+
+uint64_t PendingTransactionImpl::fee() const
+{
+    uint32_t result = 0;
+    for (const auto ptx : m_pending_tx) {
+        result += ptx.fee;
+    }
+    return result;
+}
+
+}
+
diff --git a/src/wallet/api/pending_transaction.h b/src/wallet/api/pending_transaction.h
new file mode 100644
index 000000000..8e09bec91
--- /dev/null
+++ b/src/wallet/api/pending_transaction.h
@@ -0,0 +1,64 @@
+// Copyright (c) 2014-2016, 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 "wallet/wallet2_api.h"
+#include "wallet/wallet2.h"
+
+#include <string>
+#include <vector>
+
+
+namespace Bitmonero {
+
+class WalletImpl;
+class PendingTransactionImpl : public PendingTransaction
+{
+public:
+    PendingTransactionImpl(WalletImpl &wallet);
+    ~PendingTransactionImpl();
+    int status() const;
+    std::string errorString() const;
+    bool commit();
+    uint64_t amount() const;
+    uint64_t dust() const;
+    uint64_t fee() const;
+    // TODO: continue with interface;
+
+private:
+    friend class WalletImpl;
+    WalletImpl &m_wallet;
+
+    int  m_status;
+    std::string m_errorString;
+    std::vector<tools::wallet2::pending_tx> m_pending_tx;
+};
+
+
+}
diff --git a/src/wallet/api/transaction_history.cpp b/src/wallet/api/transaction_history.cpp
new file mode 100644
index 000000000..db42e2141
--- /dev/null
+++ b/src/wallet/api/transaction_history.cpp
@@ -0,0 +1,194 @@
+// Copyright (c) 2014-2016, 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 "transaction_history.h"
+#include "transaction_info.h"
+#include "wallet.h"
+
+#include "crypto/hash.h"
+#include "wallet/wallet2.h"
+
+
+#include <string>
+#include <list>
+
+using namespace epee;
+
+namespace Bitmonero {
+
+TransactionHistory::~TransactionHistory() {}
+
+
+TransactionHistoryImpl::TransactionHistoryImpl(WalletImpl *wallet)
+    : m_wallet(wallet)
+{
+
+}
+
+TransactionHistoryImpl::~TransactionHistoryImpl()
+{
+
+}
+
+int TransactionHistoryImpl::count() const
+{
+    return m_history.size();
+}
+
+TransactionInfo *TransactionHistoryImpl::transaction(const std::string &id) const
+{
+    return nullptr;
+}
+
+std::vector<TransactionInfo *> TransactionHistoryImpl::getAll() const
+{
+    return m_history;
+}
+
+void TransactionHistoryImpl::refresh()
+{
+    // TODO: configurable values;
+    uint64_t min_height = 0;
+    uint64_t max_height = (uint64_t)-1;
+
+    // delete old transactions;
+    for (auto t : m_history)
+        delete t;
+    m_history.clear();
+
+
+
+    // transactions are stored in wallet2:
+    // - confirmed_transfer_details   - out transfers
+    // - unconfirmed_transfer_details - pending out transfers
+    // - payment_details              - input transfers
+
+    // payments are "input transactions";
+    // one input transaction contains only one transfer. e.g. <transaction_id> - <100XMR>
+
+    std::list<std::pair<crypto::hash, tools::wallet2::payment_details>> in_payments;
+    m_wallet->m_wallet->get_payments(in_payments, min_height, max_height);
+    for (std::list<std::pair<crypto::hash, tools::wallet2::payment_details>>::const_iterator i = in_payments.begin(); i != in_payments.end(); ++i) {
+        const tools::wallet2::payment_details &pd = i->second;
+        std::string payment_id = string_tools::pod_to_hex(i->first);
+        if (payment_id.substr(16).find_first_not_of('0') == std::string::npos)
+            payment_id = payment_id.substr(0,16);
+        // TODO
+        TransactionInfoImpl * ti = new TransactionInfoImpl();
+        ti->m_paymentid = payment_id;
+        ti->m_amount    = pd.m_amount;
+        ti->m_direction = TransactionInfo::Direction_In;
+        ti->m_hash      = string_tools::pod_to_hex(pd.m_tx_hash);
+        ti->m_blockheight = pd.m_block_height;
+        // TODO:
+        // ti->m_timestamp = pd.m_timestamp;
+        m_history.push_back(ti);
+
+        /* output.insert(std::make_pair(pd.m_block_height, std::make_pair(true, (boost::format("%20.20s %s %s %s")
+                                                                                 % print_money(pd.m_amount)
+                                                                                 % string_tools::pod_to_hex(pd.m_tx_hash)
+                                                                                 % payment_id % "-").str()))); */
+    }
+
+    // confirmed output transactions
+    // one output transaction may contain more than one money transfer, e.g.
+    // <transaction_id>:
+    //    transfer1: 100XMR to <address_1>
+    //    transfer2: 50XMR  to <address_2>
+    //    fee: fee charged per transaction
+    //
+
+    std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> out_payments;
+    m_wallet->m_wallet->get_payments_out(out_payments, min_height, max_height);
+
+    for (std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>>::const_iterator i = out_payments.begin();
+         i != out_payments.end(); ++i) {
+        
+        const crypto::hash &hash = i->first;
+        const tools::wallet2::confirmed_transfer_details &pd = i->second;
+        
+        uint64_t fee = pd.m_amount_in - pd.m_amount_out;
+        uint64_t change = pd.m_change == (uint64_t)-1 ? 0 : pd.m_change; // change may not be known
+        
+
+        std::string payment_id = string_tools::pod_to_hex(i->second.m_payment_id);
+        if (payment_id.substr(16).find_first_not_of('0') == std::string::npos)
+            payment_id = payment_id.substr(0,16);
+
+
+        TransactionInfoImpl * ti = new TransactionInfoImpl();
+        ti->m_paymentid = payment_id;
+        ti->m_amount = pd.m_amount_in - change - fee;
+        ti->m_fee    = fee;
+        ti->m_direction = TransactionInfo::Direction_Out;
+        ti->m_hash = string_tools::pod_to_hex(hash);
+        ti->m_blockheight = pd.m_block_height;
+
+        // single output transaction might contain multiple transfers
+        for (const auto &d: pd.m_dests) {
+            ti->m_transfers.push_back({d.amount, get_account_address_as_str(m_wallet->m_wallet->testnet(), d.addr)});
+        }
+        m_history.push_back(ti);
+    }
+
+    // unconfirmed output transactions
+    std::list<std::pair<crypto::hash, tools::wallet2::unconfirmed_transfer_details>> upayments;
+    m_wallet->m_wallet->get_unconfirmed_payments_out(upayments);
+    for (std::list<std::pair<crypto::hash, tools::wallet2::unconfirmed_transfer_details>>::const_iterator i = upayments.begin(); i != upayments.end(); ++i) {
+        const tools::wallet2::unconfirmed_transfer_details &pd = i->second;
+        const crypto::hash &hash = i->first;
+        uint64_t amount = 0;
+        cryptonote::get_inputs_money_amount(pd.m_tx, amount);
+        uint64_t fee = amount - get_outs_money_amount(pd.m_tx);
+        std::string payment_id = string_tools::pod_to_hex(i->second.m_payment_id);
+        if (payment_id.substr(16).find_first_not_of('0') == std::string::npos)
+            payment_id = payment_id.substr(0,16);
+        bool is_failed = pd.m_state == tools::wallet2::unconfirmed_transfer_details::failed;
+
+        TransactionInfoImpl * ti = new TransactionInfoImpl();
+        ti->m_paymentid = payment_id;
+        ti->m_amount = amount - pd.m_change;
+        ti->m_fee    = fee;
+        ti->m_direction = TransactionInfo::Direction_Out;
+        ti->m_failed = is_failed;
+        ti->m_pending = true;
+        ti->m_hash = string_tools::pod_to_hex(hash);
+        m_history.push_back(ti);
+    }
+
+}
+
+TransactionInfo *TransactionHistoryImpl::transaction(int index) const
+{
+    return nullptr;
+}
+
+}
diff --git a/src/wallet/api/transaction_history.h b/src/wallet/api/transaction_history.h
new file mode 100644
index 000000000..171fd2210
--- /dev/null
+++ b/src/wallet/api/transaction_history.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2014-2016, 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 "wallet/wallet2_api.h"
+
+namespace Bitmonero {
+
+class TransactionInfo;
+class WalletImpl;
+
+class TransactionHistoryImpl : public TransactionHistory
+{
+public:
+    TransactionHistoryImpl(WalletImpl * wallet);
+    ~TransactionHistoryImpl();
+    virtual int count() const;
+    virtual TransactionInfo * transaction(int index)  const;
+    virtual TransactionInfo * transaction(const std::string &id) const;
+    virtual std::vector<TransactionInfo*> getAll() const;
+    virtual void refresh();
+
+private:
+
+    // TransactionHistory is responsible of memory management
+    std::vector<TransactionInfo*> m_history;
+    WalletImpl *m_wallet;
+};
+
+}
+
diff --git a/src/wallet/api/transaction_info.cpp b/src/wallet/api/transaction_info.cpp
new file mode 100644
index 000000000..f25c53a90
--- /dev/null
+++ b/src/wallet/api/transaction_info.cpp
@@ -0,0 +1,112 @@
+// Copyright (c) 2014-2016, 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 "transaction_info.h"
+
+
+using namespace std;
+
+namespace Bitmonero {
+
+TransactionInfo::~TransactionInfo() {}
+
+TransactionInfo::Transfer::Transfer(uint64_t _amount, const string &_address)
+    : amount(_amount), address(_address) {}
+
+
+TransactionInfoImpl::TransactionInfoImpl()
+    : m_direction(Direction_Out)
+      , m_pending(false)
+      , m_failed(false)
+      , m_amount(0)
+      , m_fee(0)
+      , m_blockheight(0)
+      , m_timestamp(0)
+{
+
+}
+
+TransactionInfoImpl::~TransactionInfoImpl()
+{
+
+}
+
+int TransactionInfoImpl::direction() const
+{
+    return m_direction;
+}
+
+
+bool TransactionInfoImpl::isPending() const
+{
+    return m_pending;
+}
+
+bool TransactionInfoImpl::isFailed() const
+{
+    return m_failed;
+}
+
+uint64_t TransactionInfoImpl::amount() const
+{
+    return m_amount;
+}
+
+uint64_t TransactionInfoImpl::fee() const
+{
+    return m_fee;
+}
+
+uint64_t TransactionInfoImpl::blockHeight() const
+{
+    return m_blockheight;
+}
+
+string TransactionInfoImpl::hash() const
+{
+    return m_hash;
+}
+
+std::time_t TransactionInfoImpl::timestamp() const
+{
+    return m_timestamp;
+}
+
+string TransactionInfoImpl::paymentId() const
+{
+    return m_paymentid;
+}
+
+const std::vector<TransactionInfo::Transfer> &TransactionInfoImpl::transfers() const
+{
+    return m_transfers;
+}
+
+} // namespace
diff --git a/src/wallet/api/transaction_info.h b/src/wallet/api/transaction_info.h
new file mode 100644
index 000000000..82ab2cc6b
--- /dev/null
+++ b/src/wallet/api/transaction_info.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2014-2016, 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 "wallet/wallet2_api.h"
+#include <string>
+#include <ctime>
+
+namespace Bitmonero {
+
+class TransactionHistoryImpl;
+
+class TransactionInfoImpl : public TransactionInfo
+{
+public:
+    TransactionInfoImpl();
+    ~TransactionInfoImpl();
+    //! in/out
+    virtual int direction() const;
+    //! true if hold
+    virtual bool isPending() const;
+    virtual bool isFailed() const;
+    virtual uint64_t amount() const;
+    //! always 0 for incoming txes
+    virtual uint64_t fee() const;
+    virtual uint64_t blockHeight() const;
+
+    virtual std::string hash() const;
+    virtual std::time_t timestamp() const;
+    virtual std::string paymentId() const;
+    virtual const std::vector<Transfer> &transfers() const;
+
+private:
+    int         m_direction;
+    bool        m_pending;
+    bool        m_failed;
+    uint64_t    m_amount;
+    uint64_t    m_fee;
+    uint64_t    m_blockheight;
+    std::string m_hash;
+    std::time_t m_timestamp;
+    std::string m_paymentid;
+    std::vector<Transfer> m_transfers;
+
+    friend class TransactionHistoryImpl;
+
+};
+
+} // namespace
diff --git a/src/wallet/api/utils.cpp b/src/wallet/api/utils.cpp
new file mode 100644
index 000000000..aa85323f0
--- /dev/null
+++ b/src/wallet/api/utils.cpp
@@ -0,0 +1,79 @@
+// Copyright (c) 2014-2016, 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 "include_base_utils.h"                     // LOG_PRINT_x
+#include "net/http_client.h"                        // epee::net_utils::...
+#include <boost/asio.hpp>
+
+using namespace std;
+
+namespace Bitmonero {
+namespace Utils {
+
+
+// copy-pasted from simplewallet.
+
+bool isAddressLocal(const std::string &address)
+{
+    // extract host
+    epee::net_utils::http::url_content u_c;
+    if (!epee::net_utils::parse_url(address, u_c))
+    {
+        LOG_PRINT_L1("Failed to determine whether daemon is local, assuming not");
+        return false;
+    }
+    if (u_c.host.empty())
+    {
+        LOG_PRINT_L1("Failed to determine whether daemon is local, assuming not");
+        return false;
+    }
+
+    // resolve to IP
+    boost::asio::io_service io_service;
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(u_c.host, "");
+    boost::asio::ip::tcp::resolver::iterator i = resolver.resolve(query);
+    while (i != boost::asio::ip::tcp::resolver::iterator())
+    {
+        const boost::asio::ip::tcp::endpoint &ep = *i;
+        if (ep.address().is_loopback())
+            return true;
+        ++i;
+    }
+
+    return false;
+}
+
+}
+
+
+} // namespace
diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp
new file mode 100644
index 000000000..be379cb99
--- /dev/null
+++ b/src/wallet/api/wallet.cpp
@@ -0,0 +1,588 @@
+// Copyright (c) 2014-2016, 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 "wallet.h"
+#include "pending_transaction.h"
+#include "transaction_history.h"
+#include "common_defines.h"
+
+#include "mnemonics/electrum-words.h"
+#include <boost/format.hpp>
+#include <sstream>
+
+using namespace std;
+using namespace cryptonote;
+
+namespace Bitmonero {
+
+namespace {
+    // copy-pasted from simplewallet
+    static const size_t DEFAULT_MIXIN = 4;
+}
+
+struct Wallet2CallbackImpl : public tools::i_wallet2_callback
+{
+
+    Wallet2CallbackImpl()
+     : m_listener(nullptr)
+    {
+
+    }
+
+    ~Wallet2CallbackImpl()
+    {
+
+    }
+
+    void setListener(WalletListener * listener)
+    {
+        m_listener = listener;
+    }
+
+    WalletListener * getListener() const
+    {
+        return m_listener;
+    }
+
+    virtual void on_new_block(uint64_t height, const cryptonote::block& block)
+    {
+        // TODO;
+        LOG_PRINT_L3(__FUNCTION__ << ": new block. height: " << height);
+    }
+
+    virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, size_t out_index)
+    {
+
+        std::string tx_hash =  epee::string_tools::pod_to_hex(get_transaction_hash(tx));
+        uint64_t amount     = tx.vout[out_index].amount;
+
+        LOG_PRINT_L3(__FUNCTION__ << ": money received. height:  " << height
+                     << ", tx: " << tx_hash
+                     << ", amount: " << print_money(amount));
+        if (m_listener) {
+            m_listener->moneyReceived(tx_hash, amount);
+        }
+    }
+
+    virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, size_t out_index,
+                                const cryptonote::transaction& spend_tx)
+    {
+        // TODO;
+        std::string tx_hash = epee::string_tools::pod_to_hex(get_transaction_hash(spend_tx));
+        uint64_t amount = in_tx.vout[out_index].amount;
+        LOG_PRINT_L3(__FUNCTION__ << ": money spent. height:  " << height
+                     << ", tx: " << tx_hash
+                     << ", amount: " << print_money(amount));
+        if (m_listener) {
+            m_listener->moneySpent(tx_hash, amount);
+        }
+    }
+
+    virtual void on_skip_transaction(uint64_t height, const cryptonote::transaction& tx)
+    {
+        // TODO;
+    }
+
+    WalletListener * m_listener;
+};
+
+Wallet::~Wallet() {}
+
+WalletListener::~WalletListener() {}
+
+string Wallet::displayAmount(uint64_t amount)
+{
+    return cryptonote::print_money(amount);
+}
+
+uint64_t Wallet::amountFromString(const string &amount)
+{
+    uint64_t result;
+    cryptonote::parse_amount(result, amount);
+    return result;
+}
+
+uint64_t Wallet::amountFromDouble(double amount)
+{
+    std::stringstream ss;
+    ss << std::fixed << std::setprecision(CRYPTONOTE_DISPLAY_DECIMAL_POINT) << amount;
+    return amountFromString(ss.str());
+}
+
+std::string Wallet::genPaymentId()
+{
+    crypto::hash8 payment_id = crypto::rand<crypto::hash8>();
+    return epee::string_tools::pod_to_hex(payment_id);
+
+}
+
+
+///////////////////////// WalletImpl implementation ////////////////////////
+WalletImpl::WalletImpl(bool testnet)
+    :m_wallet(nullptr), m_status(Wallet::Status_Ok), m_trustedDaemon(false),
+      m_wallet2Callback(nullptr)
+{
+    m_wallet = new tools::wallet2(testnet);
+    m_history = new TransactionHistoryImpl(this);
+    m_wallet2Callback = new Wallet2CallbackImpl;
+}
+
+WalletImpl::~WalletImpl()
+{
+    delete m_wallet2Callback;
+    delete m_history;
+    delete m_wallet;
+}
+
+bool WalletImpl::create(const std::string &path, const std::string &password, const std::string &language)
+{
+
+    clearStatus();
+
+    bool keys_file_exists;
+    bool wallet_file_exists;
+    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
+    // TODO: figure out how to setup logger;
+    LOG_PRINT_L3("wallet_path: " << path << "");
+    LOG_PRINT_L3("keys_file_exists: " << std::boolalpha << keys_file_exists << std::noboolalpha
+                 << "  wallet_file_exists: " << std::boolalpha << wallet_file_exists << std::noboolalpha);
+
+
+    // add logic to error out if new wallet requested but named wallet file exists
+    if (keys_file_exists || wallet_file_exists) {
+        m_errorString = "attempting to generate or restore wallet, but specified file(s) exist.  Exiting to not risk overwriting.";
+        LOG_ERROR(m_errorString);
+        m_status = Status_Error;
+        return false;
+    }
+    // TODO: validate language
+    m_wallet->set_seed_language(language);
+    crypto::secret_key recovery_val, secret_key;
+    try {
+        recovery_val = m_wallet->generate(path, password, secret_key, false, false);
+        m_password = password;
+        m_status = Status_Ok;
+    } catch (const std::exception &e) {
+        LOG_ERROR("Error creating wallet: " << e.what());
+        m_status = Status_Error;
+        m_errorString = e.what();
+        return false;
+    }
+
+    return true;
+}
+
+bool WalletImpl::open(const std::string &path, const std::string &password)
+{
+    clearStatus();
+    try {
+        // TODO: handle "deprecated"
+        m_wallet->load(path, password);
+
+        m_password = password;
+    } catch (const std::exception &e) {
+        LOG_ERROR("Error opening wallet: " << e.what());
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+    return m_status == Status_Ok;
+}
+
+bool WalletImpl::recover(const std::string &path, const std::string &seed)
+{
+    clearStatus();
+    m_errorString.clear();
+    if (seed.empty()) {
+        m_errorString = "Electrum seed is empty";
+        LOG_ERROR(m_errorString);
+        m_status = Status_Error;
+        return false;
+    }
+
+    crypto::secret_key recovery_key;
+    std::string old_language;
+    if (!crypto::ElectrumWords::words_to_bytes(seed, recovery_key, old_language)) {
+        m_errorString = "Electrum-style word list failed verification";
+        m_status = Status_Error;
+        return false;
+    }
+
+    try {
+        m_wallet->set_seed_language(old_language);
+        m_wallet->generate(path, "", recovery_key, true, false);
+        // TODO: wallet->init(daemon_address);
+    } catch (const std::exception &e) {
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+    return m_status == Status_Ok;
+}
+
+bool WalletImpl::close()
+{
+    clearStatus();
+    bool result = false;
+    try {
+        m_wallet->store();
+        m_wallet->stop();
+        result = true;
+    } catch (const std::exception &e) {
+        m_status = Status_Error;
+        m_errorString = e.what();
+        LOG_ERROR("Error closing wallet: " << e.what());
+    }
+    return result;
+}
+
+std::string WalletImpl::seed() const
+{
+    std::string seed;
+    if (m_wallet)
+        m_wallet->get_seed(seed);
+    return seed;
+}
+
+std::string WalletImpl::getSeedLanguage() const
+{
+    return m_wallet->get_seed_language();
+}
+
+void WalletImpl::setSeedLanguage(const std::string &arg)
+{
+    m_wallet->set_seed_language(arg);
+}
+
+int WalletImpl::status() const
+{
+    return m_status;
+}
+
+std::string WalletImpl::errorString() const
+{
+    return m_errorString;
+}
+
+bool WalletImpl::setPassword(const std::string &password)
+{
+    clearStatus();
+    try {
+        m_wallet->rewrite(m_wallet->get_wallet_file(), password);
+        m_password = password;
+    } catch (const std::exception &e) {
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+    return m_status == Status_Ok;
+}
+
+std::string WalletImpl::address() const
+{
+    return m_wallet->get_account().get_public_address_str(m_wallet->testnet());
+}
+
+std::string WalletImpl::integratedAddress(const std::string &payment_id) const
+{
+    crypto::hash8 pid;
+    if (!tools::wallet2::parse_short_payment_id(payment_id, pid)) {
+        pid = crypto::rand<crypto::hash8>();
+    }
+    return m_wallet->get_account().get_public_integrated_address_str(pid, m_wallet->testnet());
+}
+
+bool WalletImpl::store(const std::string &path)
+{
+    clearStatus();
+    try {
+        if (path.empty()) {
+            m_wallet->store();
+        } else {
+            m_wallet->store_to(path, m_password);
+        }
+    } catch (const std::exception &e) {
+        LOG_ERROR("Error storing wallet: " << e.what());
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+
+    return m_status == Status_Ok;
+}
+
+string WalletImpl::filename() const
+{
+    return m_wallet->get_wallet_file();
+}
+
+string WalletImpl::keysFilename() const
+{
+    return m_wallet->get_keys_file();
+}
+
+bool WalletImpl::init(const std::string &daemon_address, uint64_t upper_transaction_size_limit)
+{
+    clearStatus();
+    try {
+        m_wallet->init(daemon_address, upper_transaction_size_limit);
+        if (Utils::isAddressLocal(daemon_address)) {
+            this->setTrustedDaemon(true);
+        }
+
+    } catch (const std::exception &e) {
+        LOG_ERROR("Error initializing wallet: " << e.what());
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+
+    return m_status == Status_Ok;
+}
+
+uint64_t WalletImpl::balance() const
+{
+    return m_wallet->balance();
+}
+
+uint64_t WalletImpl::unlockedBalance() const
+{
+    return m_wallet->unlocked_balance();
+}
+
+
+bool WalletImpl::refresh()
+{
+    clearStatus();
+    try {
+        m_wallet->refresh();
+    } catch (const std::exception &e) {
+        m_status = Status_Error;
+        m_errorString = e.what();
+    }
+    return m_status == Status_Ok;
+}
+
+// TODO:
+// 1 - properly handle payment id (add another menthod with explicit 'payment_id' param)
+// 2 - check / design how "Transaction" can be single interface
+// (instead of few different data structures within wallet2 implementation:
+//    - pending_tx;
+//    - transfer_details;
+//    - payment_details;
+//    - unconfirmed_transfer_details;
+//    - confirmed_transfer_details)
+
+PendingTransaction *WalletImpl::createTransaction(const string &dst_addr, const string &payment_id, uint64_t amount, uint32_t mixin_count)
+{
+    clearStatus();
+    vector<cryptonote::tx_destination_entry> dsts;
+    cryptonote::tx_destination_entry de;
+
+    // indicates if dst_addr is integrated address (address + payment_id)
+    bool has_payment_id;
+    crypto::hash8 payment_id_short;
+    // TODO:  (https://bitcointalk.org/index.php?topic=753252.msg9985441#msg9985441)
+    size_t fake_outs_count = mixin_count > 0 ? mixin_count : m_wallet->default_mixin();
+    if (fake_outs_count == 0)
+        fake_outs_count = DEFAULT_MIXIN;
+
+    PendingTransactionImpl * transaction = new PendingTransactionImpl(*this);
+
+    do {
+        if(!cryptonote::get_account_integrated_address_from_str(de.addr, has_payment_id, payment_id_short, m_wallet->testnet(), dst_addr)) {
+            // TODO: copy-paste 'if treating as an address fails, try as url' from simplewallet.cpp:1982
+            m_status = Status_Error;
+            m_errorString = "Invalid destination address";
+            break;
+        }
+
+
+        std::vector<uint8_t> extra;
+        // if dst_addr is not an integrated address, parse payment_id
+        if (!has_payment_id && !payment_id.empty()) {
+            // copy-pasted from simplewallet.cpp:2212
+            crypto::hash payment_id_long;
+            bool r = tools::wallet2::parse_long_payment_id(payment_id, payment_id_long);
+            if (r) {
+                std::string extra_nonce;
+                cryptonote::set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id_long);
+                r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
+            } else {
+                r = tools::wallet2::parse_short_payment_id(payment_id, payment_id_short);
+                if (r) {
+                    std::string extra_nonce;
+                    set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id_short);
+                    r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
+                }
+            }
+
+            if (!r) {
+                m_status = Status_Error;
+                m_errorString = tr("payment id has invalid format, expected 16 or 64 character hex string: ") + payment_id;
+                break;
+            }
+        }
+
+        de.amount = amount;
+        if (de.amount <= 0) {
+            m_status = Status_Error;
+            m_errorString = "Invalid amount";
+            break;
+        }
+
+        dsts.push_back(de);
+        //std::vector<tools::wallet2::pending_tx> ptx_vector;
+
+        try {
+            transaction->m_pending_tx = m_wallet->create_transactions_2(dsts, fake_outs_count, 0 /* unlock_time */,
+                                                                      0 /* unused fee arg*/, extra, m_trustedDaemon);
+
+        } catch (const tools::error::daemon_busy&) {
+            // TODO: make it translatable with "tr"?
+            m_errorString = tr("daemon is busy. Please try again later.");
+            m_status = Status_Error;
+        } catch (const tools::error::no_connection_to_daemon&) {
+            m_errorString = tr("no connection to daemon. Please make sure daemon is running.");
+            m_status = Status_Error;
+        } catch (const tools::error::wallet_rpc_error& e) {
+            m_errorString = tr("RPC error: ") +  e.to_string();
+            m_status = Status_Error;
+        } catch (const tools::error::get_random_outs_error&) {
+            m_errorString = tr("failed to get random outputs to mix");
+            m_status = Status_Error;
+
+        } catch (const tools::error::not_enough_money& e) {
+            m_status = Status_Error;
+            std::ostringstream writer;
+
+            writer << boost::format(tr("not enough money to transfer, available only %s, transaction amount %s = %s + %s (fee)")) %
+                      print_money(e.available()) %
+                      print_money(e.tx_amount() + e.fee())  %
+                      print_money(e.tx_amount()) %
+                      print_money(e.fee());
+            m_errorString = writer.str();
+
+        } catch (const tools::error::not_enough_outs_to_mix& e) {
+            std::ostringstream writer;
+            writer << tr("not enough outputs for specified mixin_count") << " = " << e.mixin_count() << ":";
+            for (const cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& outs_for_amount : e.scanty_outs()) {
+                writer << "\n" << tr("output amount") << " = " << print_money(outs_for_amount.amount) << ", " << tr("found outputs to mix") << " = " << outs_for_amount.outs.size();
+            }
+            m_errorString = writer.str();
+            m_status = Status_Error;
+        } catch (const tools::error::tx_not_constructed&) {
+            m_errorString = tr("transaction was not constructed");
+            m_status = Status_Error;
+        } catch (const tools::error::tx_rejected& e) {
+            std::ostringstream writer;
+            writer << (boost::format(tr("transaction %s was rejected by daemon with status: ")) % get_transaction_hash(e.tx())) <<  e.status();
+            m_errorString = writer.str();
+            m_status = Status_Error;
+        } catch (const tools::error::tx_sum_overflow& e) {
+            m_errorString = e.what();
+            m_status = Status_Error;
+        } catch (const tools::error::zero_destination&) {
+            m_errorString =  tr("one of destinations is zero");
+            m_status = Status_Error;
+        } catch (const tools::error::tx_too_big& e) {
+            m_errorString =  tr("failed to find a suitable way to split transactions");
+            m_status = Status_Error;
+        } catch (const tools::error::transfer_error& e) {
+            m_errorString = string(tr("unknown transfer error: ")) + e.what();
+            m_status = Status_Error;
+        } catch (const tools::error::wallet_internal_error& e) {
+            m_errorString =  string(tr("internal error: ")) + e.what();
+            m_status = Status_Error;
+        } catch (const std::exception& e) {
+            m_errorString =  string(tr("unexpected error: ")) + e.what();
+            m_status = Status_Error;
+        } catch (...) {
+            m_errorString = tr("unknown error");
+            m_status = Status_Error;
+        }
+    } while (false);
+
+    transaction->m_status = m_status;
+    transaction->m_errorString = m_errorString;
+    return transaction;
+}
+
+void WalletImpl::disposeTransaction(PendingTransaction *t)
+{
+    delete t;
+}
+
+TransactionHistory *WalletImpl::history() const
+{
+    return m_history;
+}
+
+void WalletImpl::setListener(WalletListener *l)
+{
+    // TODO thread synchronization;
+    m_wallet2Callback->setListener(l);
+}
+
+uint32_t WalletImpl::defaultMixin() const
+{
+    return m_wallet->default_mixin();
+}
+
+void WalletImpl::setDefaultMixin(uint32_t arg)
+{
+    m_wallet->default_mixin(arg);
+}
+
+
+bool WalletImpl::connectToDaemon()
+{
+    bool result = m_wallet->check_connection();
+    m_status = result ? Status_Ok : Status_Error;
+    if (!result) {
+        m_errorString = "Error connecting to daemon at " + m_wallet->get_daemon_address();
+    }
+    return result;
+}
+
+void WalletImpl::setTrustedDaemon(bool arg)
+{
+    m_trustedDaemon = arg;
+}
+
+bool WalletImpl::trustedDaemon() const
+{
+    return m_trustedDaemon;
+}
+
+void WalletImpl::clearStatus()
+{
+    m_status = Status_Ok;
+    m_errorString.clear();
+}
+
+
+} // namespace
diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h
new file mode 100644
index 000000000..164aede1a
--- /dev/null
+++ b/src/wallet/api/wallet.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2014-2016, 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
+
+#ifndef WALLET_IMPL_H
+#define WALLET_IMPL_H
+
+#include "wallet/wallet2_api.h"
+#include "wallet/wallet2.h"
+
+#include <string>
+
+
+namespace Bitmonero {
+class TransactionHistoryImpl;
+class PendingTransactionImpl;
+struct Wallet2CallbackImpl;
+
+class WalletImpl : public Wallet
+{
+public:
+    WalletImpl(bool testnet = false);
+    ~WalletImpl();
+    bool create(const std::string &path, const std::string &password,
+                const std::string &language);
+    bool open(const std::string &path, const std::string &password);
+    bool recover(const std::string &path, const std::string &seed);
+    bool close();
+    std::string seed() const;
+    std::string getSeedLanguage() const;
+    void setSeedLanguage(const std::string &arg);
+    // void setListener(Listener *) {}
+    int status() const;
+    std::string errorString() const;
+    bool setPassword(const std::string &password);
+    std::string address() const;
+    std::string integratedAddress(const std::string &payment_id) const;
+    bool store(const std::string &path);
+    std::string filename() const;
+    std::string keysFilename() const;
+    bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit);
+    bool connectToDaemon();
+    void setTrustedDaemon(bool arg);
+    bool trustedDaemon() const;
+    uint64_t balance() const;
+    uint64_t unlockedBalance() const;
+    bool refresh();
+    PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id,
+                                           uint64_t amount, uint32_t mixin_count);
+    virtual void disposeTransaction(PendingTransaction * t);
+    virtual TransactionHistory * history() const;
+    virtual void setListener(WalletListener * l);
+    virtual uint32_t defaultMixin() const;
+    virtual void setDefaultMixin(uint32_t arg);
+
+private:
+    void clearStatus();
+
+private:
+    friend class PendingTransactionImpl;
+    friend class TransactionHistoryImpl;
+
+    tools::wallet2 * m_wallet;
+    int  m_status;
+    std::string m_errorString;
+    std::string m_password;
+    TransactionHistoryImpl * m_history;
+    bool        m_trustedDaemon;
+    WalletListener * m_walletListener;
+    Wallet2CallbackImpl * m_wallet2Callback;
+};
+
+
+} // namespace
+
+#endif
+
diff --git a/src/wallet/api/wallet_manager.cpp b/src/wallet/api/wallet_manager.cpp
new file mode 100644
index 000000000..4ed6e09fb
--- /dev/null
+++ b/src/wallet/api/wallet_manager.cpp
@@ -0,0 +1,142 @@
+// Copyright (c) 2014-2016, 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 "wallet_manager.h"
+#include "wallet.h"
+
+#include <boost/filesystem.hpp>
+#include <boost/regex.hpp>
+
+
+namespace epee {
+    unsigned int g_test_dbg_lock_sleep = 0;
+}
+
+namespace Bitmonero {
+
+Wallet *WalletManagerImpl::createWallet(const std::string &path, const std::string &password,
+                                    const std::string &language, bool testnet)
+{
+    WalletImpl * wallet = new WalletImpl(testnet);
+    wallet->create(path, password, language);
+    return wallet;
+}
+
+Wallet *WalletManagerImpl::openWallet(const std::string &path, const std::string &password, bool testnet)
+{
+    WalletImpl * wallet = new WalletImpl(testnet);
+    wallet->open(path, password);
+    return wallet;
+}
+
+Wallet *WalletManagerImpl::recoveryWallet(const std::string &path, const std::string &memo, bool testnet)
+{
+    WalletImpl * wallet = new WalletImpl(testnet);
+    wallet->recover(path, memo);
+    return wallet;
+}
+
+bool WalletManagerImpl::closeWallet(Wallet *wallet)
+{
+    WalletImpl * wallet_ = dynamic_cast<WalletImpl*>(wallet);
+    bool result = wallet_->close();
+    if (!result) {
+        m_errorString = wallet_->errorString();
+    } else {
+        delete wallet_;
+    }
+    return result;
+}
+
+bool WalletManagerImpl::walletExists(const std::string &path)
+{
+    return false;
+}
+
+
+std::vector<std::string> WalletManagerImpl::findWallets(const std::string &path)
+{
+    std::vector<std::string> result;
+    const boost::regex wallet_rx("(.*)\\.(keys)$"); // searching for <wallet_name>.keys files
+    boost::filesystem::recursive_directory_iterator end_itr; // Default ctor yields past-the-end
+    boost::filesystem::path work_dir(path);
+
+    for (boost::filesystem::recursive_directory_iterator itr(path); itr != end_itr; ++itr) {
+        // Skip if not a file
+        if (!boost::filesystem::is_regular_file(itr->status()))
+            continue;
+        boost::smatch what;
+        std::string filename = itr->path().filename().string();
+
+        LOG_PRINT_L3("Checking filename: " << filename);
+
+        bool matched = boost::regex_match(filename, what, wallet_rx);
+        if (matched) {
+            // if keys file found, checking if there's wallet file itself
+            std::string wallet_file = (itr->path().parent_path() /= what[1]).string();
+            if (boost::filesystem::exists(wallet_file)) {
+                LOG_PRINT_L3("Found wallet: " << wallet_file);
+                result.push_back(wallet_file);
+            }
+        }
+    }
+    return result;
+}
+
+std::string WalletManagerImpl::errorString() const
+{
+    return m_errorString;
+}
+
+void WalletManagerImpl::setDaemonHost(const std::string &hostname)
+{
+
+}
+
+
+
+///////////////////// WalletManagerFactory implementation //////////////////////
+WalletManager *WalletManagerFactory::getWalletManager()
+{
+
+    static WalletManagerImpl * g_walletManager = nullptr;
+
+    if  (!g_walletManager) {
+        epee::log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_MAX);
+        g_walletManager = new WalletManagerImpl();
+    }
+
+    return g_walletManager;
+}
+
+
+
+}
diff --git a/src/wallet/api/wallet_manager.h b/src/wallet/api/wallet_manager.h
new file mode 100644
index 000000000..7585c1af7
--- /dev/null
+++ b/src/wallet/api/wallet_manager.h
@@ -0,0 +1,56 @@
+// Copyright (c) 2014-2016, 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 "wallet/wallet2_api.h"
+#include <string>
+
+namespace Bitmonero {
+
+class WalletManagerImpl : public WalletManager
+{
+public:
+    Wallet * createWallet(const std::string &path, const std::string &password,
+                          const std::string &language, bool testnet);
+    Wallet * openWallet(const std::string &path, const std::string &password, bool testnet);
+    virtual Wallet * recoveryWallet(const std::string &path, const std::string &memo, bool testnet);
+    virtual bool closeWallet(Wallet *wallet);
+    bool walletExists(const std::string &path);
+    std::vector<std::string> findWallets(const std::string &path);
+    std::string errorString() const;
+    void setDaemonHost(const std::string &hostname);
+
+private:
+    WalletManagerImpl() {}
+    friend struct WalletManagerFactory;
+    std::string m_errorString;
+};
+
+} // namespace
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index b6c10c0e5..a153967ce 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -94,11 +94,12 @@ void do_prepare_file_names(const std::string& file_path, std::string& keys_file,
   }
 }
 
-uint64_t calculate_fee(const cryptonote::blobdata &blob)
+uint64_t calculate_fee(const cryptonote::blobdata &blob, uint64_t fee_multiplier)
 {
+  THROW_WALLET_EXCEPTION_IF(fee_multiplier <= 0 || fee_multiplier > 3, tools::error::invalid_fee_multiplier);
   uint64_t bytes = blob.size();
   uint64_t kB = (bytes + 1023) / 1024;
-  return kB * FEE_PER_KB;
+  return kB * FEE_PER_KB * fee_multiplier;
 }
 
 } //namespace
@@ -1054,6 +1055,9 @@ bool wallet2::store_keys(const std::string& keys_file_name, const std::string& p
   value2.SetUint(m_default_mixin);
   json.AddMember("default_mixin", value2, json.GetAllocator());
 
+  value2.SetUint(m_default_fee_multiplier);
+  json.AddMember("default_fee_multiplier", value2, json.GetAllocator());
+
   value2.SetInt(m_auto_refresh ? 1 :0);
   json.AddMember("auto_refresh", value2, json.GetAllocator());
 
@@ -1125,6 +1129,7 @@ bool wallet2::load_keys(const std::string& keys_file_name, const std::string& pa
     m_watch_only = false;
     m_always_confirm_transfers = false;
     m_default_mixin = 0;
+    m_default_fee_multiplier = 0;
     m_auto_refresh = true;
     m_refresh_type = RefreshType::RefreshDefault;
   }
@@ -1158,6 +1163,8 @@ bool wallet2::load_keys(const std::string& keys_file_name, const std::string& pa
                    || (field_store_tx_info_found && (field_store_tx_info != 0));
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_mixin, unsigned int, Uint, false);
     m_default_mixin = field_default_mixin_found ? field_default_mixin : 0;
+    GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_fee_multiplier, unsigned int, Uint, false);
+    m_default_fee_multiplier = field_default_fee_multiplier_found ? field_default_fee_multiplier : 0;
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, auto_refresh, int, Int, false);
     m_auto_refresh = !field_auto_refresh_found || (field_auto_refresh != 0);
     GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, refresh_type, int, Int, false);
@@ -1545,6 +1552,42 @@ void wallet2::check_genesis(const crypto::hash& genesis_hash) const {
 //----------------------------------------------------------------------------------------------------
 void wallet2::store()
 {
+  store_to("", "");
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::store_to(const std::string &path, const std::string &password)
+{
+  // if file is the same, we do:
+  // 1. save wallet to the *.new file
+  // 2. remove old wallet file
+  // 3. rename *.new to wallet_name
+
+  // handle if we want just store wallet state to current files (ex store() replacement);
+  bool same_file = true;
+  if (!path.empty())
+  {
+    std::string canonical_path = boost::filesystem::canonical(m_wallet_file).string();
+    size_t pos = canonical_path.find(path);
+    same_file = pos != std::string::npos;
+  }
+
+
+  if (!same_file)
+  {
+    // check if we want to store to directory which doesn't exists yet
+    boost::filesystem::path parent_path = boost::filesystem::path(path).parent_path();
+
+    // if path is not exists, try to create it
+    if (!parent_path.empty() &&  !boost::filesystem::exists(parent_path))
+    {
+      boost::system::error_code ec;
+      if (!boost::filesystem::create_directories(parent_path, ec))
+      {
+        throw std::logic_error(ec.message());
+      }
+    }
+  }
+  // preparing wallet data
   std::stringstream oss;
   boost::archive::binary_oarchive ar(oss);
   ar << *this;
@@ -1559,10 +1602,10 @@ void wallet2::store()
   crypto::chacha8(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cipher[0]);
   cache_file_data.cache_data = cipher;
 
-  // save to new file, rename main to old, rename new to main
-  // at all times, there should be a valid file on disk
-  const std::string new_file = m_wallet_file + ".new";
-  const std::string old_file = m_wallet_file + ".old";
+  const std::string new_file = same_file ? m_wallet_file + ".new" : path;
+  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";
 
   // save to new file
   std::ofstream ostr;
@@ -1572,87 +1615,35 @@ void wallet2::store()
   ostr.close();
   THROW_WALLET_EXCEPTION_IF(!success || !ostr.good(), error::file_save_error, new_file);
 
-  // rename
-  boost::filesystem::remove(old_file); // probably does not exist
-  if (boost::filesystem::exists(m_wallet_file)) {
-    std::error_code e = tools::replace_file(m_wallet_file, old_file);
-    THROW_WALLET_EXCEPTION_IF(e, error::file_save_error, m_wallet_file, e);
-  }
-  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);
-  boost::filesystem::remove(old_file);
-}
-
-void wallet2::store_to(const std::string &path, const std::string &password)
-{
-    // TODO: merge it with wallet2::store() function
-
-    // check if we want to store to directory which doesn't exists yet
-    boost::filesystem::path parent_path = boost::filesystem::path(path).parent_path();
-
-    // if path is not exists, try to create it
-    if  (!parent_path.empty() &&  !boost::filesystem::exists(parent_path)) {
-        boost::system::error_code ec;
-        if (!boost::filesystem::create_directories(parent_path, ec)) {
-            throw std::logic_error(ec.message());
-        }
-    }
-
-
-    std::stringstream oss;
-    boost::archive::binary_oarchive ar(oss);
-    ar << *this;
-
-    wallet2::cache_file_data cache_file_data = boost::value_initialized<wallet2::cache_file_data>();
-    cache_file_data.cache_data = oss.str();
-    crypto::chacha8_key key;
-    generate_chacha8_key_from_secret_keys(key);
-    std::string cipher;
-    cipher.resize(cache_file_data.cache_data.size());
-    cache_file_data.iv = crypto::rand<crypto::chacha8_iv>();
-    crypto::chacha8(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cipher[0]);
-    cache_file_data.cache_data = cipher;
-
-
-    const std::string new_file = path;
-    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";
-
-    // save to new file
-    std::ofstream ostr;
-    ostr.open(new_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
-    binary_archive<true> oar(ostr);
-    bool success = ::serialization::serialize(oar, cache_file_data);
-    ostr.close();
-    THROW_WALLET_EXCEPTION_IF(!success || !ostr.good(), error::file_save_error, new_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
+  // save keys to the new file
+  // if we here, main wallet file is saved and we only need to save keys and address files
+  if (!same_file) {
     prepare_file_names(path);
     store_keys(m_keys_file, password, false);
-
     // save address to the new file
     const std::string address_file = m_wallet_file + ".address.txt";
     bool r = file_io_utils::save_string_to_file(address_file, m_account.get_public_address_str(m_testnet));
     THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_wallet_file);
-
-
     // remove old wallet file
     r = boost::filesystem::remove(old_file);
     if (!r) {
-        LOG_ERROR("error removing file: " << old_file);
+      LOG_ERROR("error removing file: " << old_file);
     }
     // remove old keys file
     r = boost::filesystem::remove(old_keys_file);
     if (!r) {
-        LOG_ERROR("error removing file: " << old_keys_file);
+      LOG_ERROR("error removing file: " << old_keys_file);
     }
     // remove old address file
     r = boost::filesystem::remove(old_address_file);
     if (!r) {
-        LOG_ERROR("error removing file: " << old_address_file);
+      LOG_ERROR("error removing file: " << old_address_file);
     }
+  } else {
+    // here we have "*.new" file, we need to rename it to be without ".new"
+    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);
+  }
 }
 //----------------------------------------------------------------------------------------------------
 uint64_t wallet2::unlocked_balance() const
@@ -2081,15 +2072,29 @@ void wallet2::commit_tx(std::vector<pending_tx>& ptx_vector)
   }
 }
 
+uint64_t wallet2::sanitize_fee_multiplier(uint64_t fee_multiplier) const
+{
+  // 0, default value used for previous fee argument, defaults to normal fee
+  if (fee_multiplier == 0)
+    return m_default_fee_multiplier > 0 ? m_default_fee_multiplier : 1;
+  // 1 to 3 are allowed as multipliers
+  if (fee_multiplier >= 1 && fee_multiplier <= 3)
+    return fee_multiplier;
+  THROW_WALLET_EXCEPTION_IF (false, error::invalid_fee_multiplier);
+  return 1;
+}
+
 //----------------------------------------------------------------------------------------------------
 // separated the call(s) to wallet2::transfer into their own function
 //
 // this function will make multiple calls to wallet2::transfer if multiple
 // transactions will be required
-std::vector<wallet2::pending_tx> wallet2::create_transactions(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon)
+std::vector<wallet2::pending_tx> wallet2::create_transactions(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon)
 {
   const std::vector<size_t> unused_transfers_indices = select_available_outputs_from_histogram(fake_outs_count + 1, true, trusted_daemon);
 
+  fee_multiplier = sanitize_fee_multiplier(fee_multiplier);
+
   // failsafe split attempt counter
   size_t attempt_count = 0;
 
@@ -2120,7 +2125,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions(std::vector<crypto
 	{
 	  transfer(dst_vector, fake_outs_count, unused_transfers_indices, unlock_time, needed_fee, extra, tx, ptx, trusted_daemon);
 	  auto txBlob = t_serializable_object_to_blob(ptx.tx);
-          needed_fee = calculate_fee(txBlob);
+          needed_fee = calculate_fee(txBlob, fee_multiplier);
 	} while (ptx.fee < needed_fee);
 
         ptx_vector.push_back(ptx);
@@ -2358,7 +2363,7 @@ void wallet2::transfer_selected(const std::vector<cryptonote::tx_destination_ent
 // This system allows for sending (almost) the entire balance, since it does
 // not generate spurious change in all txes, thus decreasing the instantaneous
 // usable balance.
-std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon)
+std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon)
 {
   std::vector<size_t> unused_transfers_indices;
   std::vector<size_t> unused_dust_indices;
@@ -2388,6 +2393,8 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
   // throw if attempting a transaction with no destinations
   THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
 
+  fee_multiplier = sanitize_fee_multiplier (fee_multiplier);
+
   // calculate total amount being sent to all destinations
   // throw if total amount overflows uint64_t
   needed_money = 0;
@@ -2499,7 +2506,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
       transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, unlock_time, needed_fee, extra,
         detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
       auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
-      needed_fee = calculate_fee(txBlob);
+      needed_fee = calculate_fee(txBlob, fee_multiplier);
       available_for_fee = test_ptx.fee + test_ptx.change_dts.amount + (!test_ptx.dust_added_to_fee ? test_ptx.dust : 0);
       LOG_PRINT_L2("Made a " << txBlob.size() << " kB tx, with " << print_money(available_for_fee) << " available for fee (" <<
         print_money(needed_fee) << " needed)");
@@ -2582,7 +2589,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
   return ptx_vector;
 }
 
-std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon)
+std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon)
 {
   std::vector<size_t> unused_transfers_indices;
   std::vector<size_t> unused_dust_indices;
@@ -2598,6 +2605,8 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptono
   uint64_t needed_fee, available_for_fee = 0;
   uint64_t upper_transaction_size_limit = get_upper_tranaction_size_limit();
 
+  fee_multiplier = sanitize_fee_multiplier(fee_multiplier);
+
   // gather all our dust and non dust outputs
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
@@ -2626,7 +2635,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptono
     // get a random unspent output and use it to pay next chunk. We try to alternate
     // dust and non dust to ensure we never get with only dust, from which we might
     // get a tx that can't pay for itself
-    size_t idx = unused_transfers_indices.empty() ? pop_random_value(unused_dust_indices) : unused_dust_indices.empty() ? pop_random_value(unused_transfers_indices) : ((tx.selected_transfers.size() & 1) || accumulated_outputs > FEE_PER_KB * (upper_transaction_size_limit + 1023) / 1024) ? pop_random_value(unused_dust_indices) : pop_random_value(unused_transfers_indices);
+    size_t idx = unused_transfers_indices.empty() ? pop_random_value(unused_dust_indices) : unused_dust_indices.empty() ? pop_random_value(unused_transfers_indices) : ((tx.selected_transfers.size() & 1) || accumulated_outputs > FEE_PER_KB * fee_multiplier * (upper_transaction_size_limit + 1023) / 1024) ? pop_random_value(unused_dust_indices) : pop_random_value(unused_transfers_indices);
 
     const transfer_details &td = m_transfers[idx];
     LOG_PRINT_L2("Picking output " << idx << ", amount " << print_money(td.amount()));
@@ -2654,7 +2663,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptono
       transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, unlock_time, needed_fee, extra,
         detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
       auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
-      needed_fee = calculate_fee(txBlob);
+      needed_fee = calculate_fee(txBlob, fee_multiplier);
       available_for_fee = test_ptx.fee + test_ptx.dests[0].amount + test_ptx.change_dts.amount;
       LOG_PRINT_L2("Made a " << txBlob.size() << " kB tx, with " << print_money(available_for_fee) << " available for fee (" <<
         print_money(needed_fee) << " needed)");
@@ -2667,7 +2676,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_all(const cryptono
         transfer_selected(tx.dsts, tx.selected_transfers, fake_outs_count, unlock_time, needed_fee, extra,
           detail::digit_split_strategy, tx_dust_policy(::config::DEFAULT_DUST_THRESHOLD), test_tx, test_ptx);
         txBlob = t_serializable_object_to_blob(test_ptx.tx);
-        needed_fee = calculate_fee(txBlob);
+        needed_fee = calculate_fee(txBlob, fee_multiplier);
         LOG_PRINT_L2("Made an attempt at a final " << ((txBlob.size() + 1023)/1024) << " kB tx, with " << print_money(test_ptx.fee) <<
           " fee  and " << print_money(test_ptx.change_dts.amount) << " change");
       } while (needed_fee > test_ptx.fee);
@@ -2994,13 +3003,13 @@ std::vector<wallet2::pending_tx> wallet2::create_unmixable_sweep_transactions(bo
 	{
 	  transfer_from(unmixable_outputs, num_outputs_per_tx, (uint64_t)0 /* unlock_time */, 0, detail::digit_split_strategy, dust_policy, extra, tx, ptx);
 	  auto txBlob = t_serializable_object_to_blob(ptx.tx);
-          needed_fee = calculate_fee(txBlob);
+          needed_fee = calculate_fee(txBlob, 1);
 
           // reroll the tx with the actual amount minus the fee
           // if there's not enough for the fee, it'll throw
 	  transfer_from(unmixable_outputs, num_outputs_per_tx, (uint64_t)0 /* unlock_time */, needed_fee, detail::digit_split_strategy, dust_policy, extra, tx, ptx);
 	  txBlob = t_serializable_object_to_blob(ptx.tx);
-          needed_fee = calculate_fee(txBlob);
+          needed_fee = calculate_fee(txBlob, 1);
 	} while (ptx.fee < needed_fee);
 
         ptx_vector.push_back(ptx);
@@ -3072,12 +3081,17 @@ bool wallet2::get_tx_key(const crypto::hash &txid, crypto::secret_key &tx_key) c
 
 std::string wallet2::get_wallet_file() const
 {
-    return m_wallet_file;
+  return m_wallet_file;
 }
 
 std::string wallet2::get_keys_file() const
 {
-    return m_keys_file;
+  return m_keys_file;
+}
+
+std::string wallet2::get_daemon_address() const
+{
+  return m_daemon_address;
 }
 
 void wallet2::set_tx_note(const crypto::hash &txid, const std::string &note)
@@ -3092,7 +3106,6 @@ std::string wallet2::get_tx_note(const crypto::hash &txid) const
     return std::string();
   return i->second;
 }
-
 //----------------------------------------------------------------------------------------------------
 void wallet2::generate_genesis(cryptonote::block& b) {
   if (m_testnet)
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index c2d387acd..c5149a10c 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -61,6 +61,7 @@ namespace tools
     virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, size_t out_index) {}
     virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, size_t out_index, const cryptonote::transaction& spend_tx) {}
     virtual void on_skip_transaction(uint64_t height, const cryptonote::transaction& tx) {}
+    virtual ~i_wallet2_callback() {}
   };
 
   struct tx_dust_policy
@@ -88,10 +89,10 @@ namespace tools
     };
 
   private:
-    wallet2(const wallet2&) : m_run(true), m_callback(0), m_testnet(false), m_always_confirm_transfers (false), m_store_tx_info(true), m_default_mixin(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
+    wallet2(const wallet2&) : m_run(true), m_callback(0), m_testnet(false), m_always_confirm_transfers (false), m_store_tx_info(true), m_default_mixin(0), m_default_fee_multiplier(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
 
   public:
-    wallet2(bool testnet = false, bool restricted = false) : m_run(true), m_callback(0), m_testnet(testnet), m_restricted(restricted), is_old_file_format(false), m_store_tx_info(true), m_default_mixin(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
+    wallet2(bool testnet = false, bool restricted = false) : m_run(true), m_callback(0), m_testnet(testnet), m_restricted(restricted), is_old_file_format(false), m_store_tx_info(true), m_default_mixin(0), m_default_fee_multiplier(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
     struct transfer_details
     {
       uint64_t m_block_height;
@@ -291,9 +292,9 @@ namespace tools
 
     void commit_tx(pending_tx& ptx_vector);
     void commit_tx(std::vector<pending_tx>& ptx_vector);
-    std::vector<pending_tx> create_transactions(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee, const std::vector<uint8_t> extra, bool trusted_daemon);
-    std::vector<wallet2::pending_tx> create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon);
-    std::vector<wallet2::pending_tx> create_transactions_all(const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon);
+    std::vector<pending_tx> create_transactions(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon);
+    std::vector<wallet2::pending_tx> create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon);
+    std::vector<wallet2::pending_tx> create_transactions_all(const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, uint64_t fee_multiplier, const std::vector<uint8_t> extra, bool trusted_daemon);
     std::vector<pending_tx> create_unmixable_sweep_transactions(bool trusted_daemon);
     bool check_connection();
     void get_transfers(wallet2::transfer_container& incoming_transfers) const;
@@ -363,6 +364,8 @@ namespace tools
     void store_tx_info(bool store) { m_store_tx_info = store; }
     uint32_t default_mixin() const { return m_default_mixin; }
     void default_mixin(uint32_t m) { m_default_mixin = m; }
+    uint32_t get_default_fee_multiplier() const { return m_default_fee_multiplier; }
+    void set_default_fee_multiplier(uint32_t m) { m_default_fee_multiplier = m; }
     bool auto_refresh() const { return m_auto_refresh; }
     void auto_refresh(bool r) { m_auto_refresh = r; }
 
@@ -373,6 +376,7 @@ namespace tools
 
     std::string get_wallet_file() const;
     std::string get_keys_file() const;
+    std::string get_daemon_address() const;
 
     std::vector<size_t> select_available_outputs_from_histogram(uint64_t count, bool atleast, bool trusted_daemon);
     std::vector<size_t> select_available_outputs(const std::function<bool(const transfer_details &td)> &f);
@@ -423,6 +427,7 @@ namespace tools
     uint64_t get_upper_tranaction_size_limit();
     void check_pending_txes();
     std::vector<uint64_t> get_unspent_amounts_vector();
+    uint64_t sanitize_fee_multiplier(uint64_t fee_multiplier) const;
 
     cryptonote::account_base m_account;
     std::string m_daemon_address;
@@ -455,6 +460,7 @@ namespace tools
     bool m_always_confirm_transfers;
     bool m_store_tx_info; /*!< request txkey to be returned in RPC, and store in the wallet cache file */
     uint32_t m_default_mixin;
+    uint32_t m_default_fee_multiplier;
     RefreshType m_refresh_type;
     bool m_auto_refresh;
     uint64_t m_refresh_from_block_height;
diff --git a/src/wallet/wallet2_api.cpp b/src/wallet/wallet2_api.cpp
deleted file mode 100644
index 0644e3690..000000000
--- a/src/wallet/wallet2_api.cpp
+++ /dev/null
@@ -1,346 +0,0 @@
-// Copyright (c) 2014-2016, 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 "wallet2_api.h"
-#include "wallet2.h"
-#include "mnemonics/electrum-words.h"
-#include <memory>
-
-namespace epee {
-    unsigned int g_test_dbg_lock_sleep = 0;
-}
-
-namespace Bitmonero {
-
-struct WalletManagerImpl;
-
-namespace {
-    static WalletManagerImpl * g_walletManager = nullptr;
-
-
-
-}
-
-Wallet::~Wallet() {}
-
-///////////////////////// Wallet implementation ////////////////////////////////
-class WalletImpl : public Wallet
-{
-public:
-    WalletImpl();
-    ~WalletImpl();
-    bool create(const std::string &path, const std::string &password,
-                const std::string &language);
-    bool open(const std::string &path, const std::string &password);
-    bool recover(const std::string &path, const std::string &seed);
-    bool close();
-    std::string seed() const;
-    std::string getSeedLanguage() const;
-    void setSeedLanguage(const std::string &arg);
-    void setListener(Listener *) {}
-    int status() const;
-    std::string errorString() const;
-    bool setPassword(const std::string &password);
-    std::string address() const;
-    bool store(const std::string &path);
-
-private:
-    void clearStatus();
-
-private:
-    //std::unique_ptr<tools::wallet2> m_wallet;
-    tools::wallet2 * m_wallet;
-    int  m_status;
-    std::string m_errorString;
-    std::string m_password;
-};
-
-WalletImpl::WalletImpl()
-    :m_wallet(nullptr), m_status(Wallet::Status_Ok)
-{
-    m_wallet = new tools::wallet2();
-}
-
-WalletImpl::~WalletImpl()
-{
-    delete m_wallet;
-}
-
-bool WalletImpl::create(const std::string &path, const std::string &password, const std::string &language)
-{
-
-    clearStatus();
-
-    bool keys_file_exists;
-    bool wallet_file_exists;
-    tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
-    // TODO: figure out how to setup logger;
-    LOG_PRINT_L3("wallet_path: " << path << "");
-    LOG_PRINT_L3("keys_file_exists: " << std::boolalpha << keys_file_exists << std::noboolalpha
-                 << "  wallet_file_exists: " << std::boolalpha << wallet_file_exists << std::noboolalpha);
-
-
-    // add logic to error out if new wallet requested but named wallet file exists
-    if (keys_file_exists || wallet_file_exists) {
-        m_errorString = "attempting to generate or restore wallet, but specified file(s) exist.  Exiting to not risk overwriting.";
-        LOG_ERROR(m_errorString);
-        m_status = Status_Error;
-        return false;
-    }
-    // TODO: validate language
-    m_wallet->set_seed_language(language);
-    crypto::secret_key recovery_val, secret_key;
-    try {
-        recovery_val = m_wallet->generate(path, password, secret_key, false, false);
-        m_password = password;
-        m_status = Status_Ok;
-    } catch (const std::exception &e) {
-        LOG_ERROR("Error creating wallet: " << e.what());
-        m_status = Status_Error;
-        m_errorString = e.what();
-        return false;
-    }
-
-    return true;
-}
-
-bool WalletImpl::open(const std::string &path, const std::string &password)
-{
-    clearStatus();
-    try {
-        // TODO: handle "deprecated"
-        m_wallet->load(path, password);
-
-        m_password = password;
-    } catch (const std::exception &e) {
-        LOG_ERROR("Error opening wallet: " << e.what());
-        m_status = Status_Error;
-        m_errorString = e.what();
-    }
-    return m_status == Status_Ok;
-}
-
-bool WalletImpl::recover(const std::string &path, const std::string &seed)
-{
-    clearStatus();
-    m_errorString.clear();
-    if (seed.empty()) {
-        m_errorString = "Electrum seed is empty";
-        LOG_ERROR(m_errorString);
-        m_status = Status_Error;
-        return false;
-    }
-
-    crypto::secret_key recovery_key;
-    std::string old_language;
-    if (!crypto::ElectrumWords::words_to_bytes(seed, recovery_key, old_language)) {
-        m_errorString = "Electrum-style word list failed verification";
-        m_status = Status_Error;
-        return false;
-    }
-
-    try {
-        m_wallet->set_seed_language(old_language);
-        m_wallet->generate(path, "", recovery_key, true, false);
-        // TODO: wallet->init(daemon_address);
-    } catch (const std::exception &e) {
-        m_status = Status_Error;
-        m_errorString = e.what();
-    }
-    return m_status == Status_Ok;
-}
-
-bool WalletImpl::close()
-{
-    clearStatus();
-    bool result = false;
-    try {
-        m_wallet->store();
-        m_wallet->stop();
-        result = true;
-    } catch (const std::exception &e) {
-        m_status = Status_Error;
-        m_errorString = e.what();
-        LOG_ERROR("Error closing wallet: " << e.what());
-    }
-    return result;
-}
-
-std::string WalletImpl::seed() const
-{
-    std::string seed;
-    if (m_wallet)
-        m_wallet->get_seed(seed);
-    return seed;
-}
-
-std::string WalletImpl::getSeedLanguage() const
-{
-    return m_wallet->get_seed_language();
-}
-
-void WalletImpl::setSeedLanguage(const std::string &arg)
-{
-    m_wallet->set_seed_language(arg);
-}
-
-int WalletImpl::status() const
-{
-    return m_status;
-}
-
-std::string WalletImpl::errorString() const
-{
-    return m_errorString;
-}
-
-bool WalletImpl::setPassword(const std::string &password)
-{
-    clearStatus();
-    try {
-        m_wallet->rewrite(m_wallet->get_wallet_file(), password);
-        m_password = password;
-    } catch (const std::exception &e) {
-        m_status = Status_Error;
-        m_errorString = e.what();
-    }
-    return m_status == Status_Ok;
-}
-
-std::string WalletImpl::address() const
-{
-    return m_wallet->get_account().get_public_address_str(m_wallet->testnet());
-}
-
-bool WalletImpl::store(const std::string &path)
-{
-    clearStatus();
-    try {
-        if (path.empty()) {
-            m_wallet->store();
-        } else {
-            m_wallet->store_to(path, m_password);
-        }
-    } catch (const std::exception &e) {
-        LOG_ERROR("Error storing wallet: " << e.what());
-        m_status = Status_Error;
-        m_errorString = e.what();
-    }
-
-    return m_status == Status_Ok;
-}
-
-void WalletImpl::clearStatus()
-{
-    m_status = Status_Ok;
-    m_errorString.clear();
-}
-
-
-
-///////////////////////// WalletManager implementation /////////////////////////
-class WalletManagerImpl : public WalletManager
-{
-public:
-    Wallet * createWallet(const std::string &path, const std::string &password,
-                          const std::string &language);
-    Wallet * openWallet(const std::string &path, const std::string &password);
-    virtual Wallet * recoveryWallet(const std::string &path, const std::string &memo);
-    virtual bool closeWallet(Wallet *wallet);
-    bool walletExists(const std::string &path);
-    std::string errorString() const;
-
-
-private:
-    WalletManagerImpl() {}
-    friend struct WalletManagerFactory;
-
-    std::string m_errorString;
-};
-
-Wallet *WalletManagerImpl::createWallet(const std::string &path, const std::string &password,
-                                    const std::string &language)
-{
-    WalletImpl * wallet = new WalletImpl();
-    wallet->create(path, password, language);
-    return wallet;
-}
-
-Wallet *WalletManagerImpl::openWallet(const std::string &path, const std::string &password)
-{
-    WalletImpl * wallet = new WalletImpl();
-    wallet->open(path, password);
-    return wallet;
-}
-
-Wallet *WalletManagerImpl::recoveryWallet(const std::string &path, const std::string &memo)
-{
-    WalletImpl * wallet = new WalletImpl();
-    wallet->recover(path, memo);
-    return wallet;
-}
-
-bool WalletManagerImpl::closeWallet(Wallet *wallet)
-{
-    WalletImpl * wallet_ = dynamic_cast<WalletImpl*>(wallet);
-    bool result = wallet_->close();
-    if (!result) {
-        m_errorString = wallet_->errorString();
-    } else {
-        delete wallet_;
-    }
-    return result;
-}
-
-bool WalletManagerImpl::walletExists(const std::string &path)
-{
-    return false;
-}
-
-std::string WalletManagerImpl::errorString() const
-{
-    return m_errorString;
-}
-
-
-
-///////////////////// WalletManagerFactory implementation //////////////////////
-WalletManager *WalletManagerFactory::getWalletManager()
-{
-
-    if  (!g_walletManager) {
-        epee::log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_0);
-        g_walletManager = new WalletManagerImpl();
-    }
-
-    return g_walletManager;
-}
-
-}
diff --git a/src/wallet/wallet2_api.h b/src/wallet/wallet2_api.h
index c7e7c536c..66987e4c5 100644
--- a/src/wallet/wallet2_api.h
+++ b/src/wallet/wallet2_api.h
@@ -32,10 +32,85 @@
 
 
 #include <string>
+#include <vector>
+#include <ctime>
 
 //  Public interface for libwallet library
 namespace Bitmonero {
 
+    namespace Utils {
+        bool isAddressLocal(const std::string &hostaddr);
+    }
+/**
+ * @brief Transaction-like interface for sending money
+ */
+struct PendingTransaction
+{
+    enum Status {
+        Status_Ok,
+        Status_Error
+    };
+    virtual ~PendingTransaction() = 0;
+    virtual int status() const = 0;
+    virtual std::string errorString() const = 0;
+    virtual bool commit() = 0;
+    virtual uint64_t amount() const = 0;
+    virtual uint64_t dust() const = 0;
+    virtual uint64_t fee() const = 0;
+};
+
+/**
+ * @brief The TransactionInfo - interface for displaying transaction information
+ */
+struct TransactionInfo
+{
+    enum Direction {
+        Direction_In,
+        Direction_Out
+    };
+
+    struct Transfer {
+        Transfer(uint64_t _amount, const std::string &address);
+        const uint64_t amount;
+        const std::string address;
+    };
+
+    virtual ~TransactionInfo() = 0;
+    virtual int  direction() const = 0;
+    virtual bool isPending() const = 0;
+    virtual bool isFailed() const = 0;
+    virtual uint64_t amount() const = 0;
+    virtual uint64_t fee() const = 0;
+    virtual uint64_t blockHeight() const = 0;
+    //! transaction_id
+    virtual std::string hash() const = 0;
+    virtual std::time_t timestamp() const = 0;
+    virtual std::string paymentId() const = 0;
+    //! only applicable for output transactions
+    virtual const std::vector<Transfer> & transfers() const = 0;
+};
+/**
+ * @brief The TransactionHistory - interface for displaying transaction history
+ */
+struct TransactionHistory
+{
+    virtual ~TransactionHistory() = 0;
+    virtual int count() const = 0;
+    virtual TransactionInfo * transaction(int index)  const = 0;
+    virtual TransactionInfo * transaction(const std::string &id) const = 0;
+    virtual std::vector<TransactionInfo*> getAll() const = 0;
+    virtual void refresh() = 0;
+};
+
+
+struct WalletListener
+{
+    virtual ~WalletListener() = 0;
+    virtual void moneySpent(const std::string &txId, uint64_t amount) = 0;
+    virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0;
+    // TODO: on_skip_transaction;
+};
+
 
 /**
  * @brief Interface for wallet operations.
@@ -43,30 +118,93 @@ namespace Bitmonero {
  */
 struct Wallet
 {
-   // TODO define wallet interface (decide what needed from wallet2)
 
     enum Status {
         Status_Ok,
         Status_Error
     };
 
-    struct Listener
-    {
-        // TODO
-    };
-
     virtual ~Wallet() = 0;
     virtual std::string seed() const = 0;
     virtual std::string getSeedLanguage() const = 0;
     virtual void setSeedLanguage(const std::string &arg) = 0;
-    virtual void setListener(Listener * listener) = 0;
     //! returns wallet status (Status_Ok | Status_Error)
     virtual int status() const = 0;
     //! in case error status, returns error string
     virtual std::string errorString() const = 0;
     virtual bool setPassword(const std::string &password) = 0;
     virtual std::string address() 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 store - stores wallet to file.
+     * \param path - main filename to store wallet to. additionally stores address file and keys file.
+     *               to store to the same file - just pass empty string;
+     * \return
+     */
     virtual bool store(const std::string &path) = 0;
+    /*!
+     * \brief filename - returns wallet filename
+     * \return
+     */
+    virtual std::string filename() const = 0;
+    /*!
+     * \brief keysFilename - returns keys filename. usually this formed as "wallet_filename".keys
+     * \return
+     */
+    virtual std::string keysFilename() const = 0;
+
+    virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit) = 0;
+    virtual bool connectToDaemon() = 0;
+    virtual void setTrustedDaemon(bool arg) = 0;
+    virtual bool trustedDaemon() const = 0;
+    virtual uint64_t balance() const = 0;
+    virtual uint64_t unlockedBalance() const = 0;
+
+    static std::string displayAmount(uint64_t amount);
+    static uint64_t amountFromString(const std::string &amount);
+    static uint64_t amountFromDouble(double amount);
+    static std::string genPaymentId();
+
+    // TODO?
+    // virtual uint64_t unlockedDustBalance() const = 0;
+    virtual bool refresh() = 0;
+    /*!
+     * \brief createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored
+     * \param dst_addr          destination address as string
+     * \param payment_id        optional payment_id, can be empty string
+     * \param amount            amount
+     * \param mixin_count       mixin count. if 0 passed, wallet will use default value
+     * \return                  PendingTransaction object. caller is responsible to check PendingTransaction::status()
+     *                          after object returned
+     */
+
+    virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id,
+                                                   uint64_t amount, uint32_t mixin_count) = 0;
+
+    virtual void disposeTransaction(PendingTransaction * t) = 0;
+    virtual TransactionHistory * history() const = 0;
+    virtual void setListener(WalletListener *) = 0;
+    /*!
+     * \brief defaultMixin - returns number of mixins used in transactions
+     * \return
+     */
+    virtual uint32_t defaultMixin() const = 0;
+    /*!
+     * \brief setDefaultMixin - setum number of mixins to be used for new transactions
+     * \param arg
+     */
+    virtual void setDefaultMixin(uint32_t arg) = 0;
 };
 
 /**
@@ -82,7 +220,7 @@ struct WalletManager
      * \param  language       Language to be used to generate electrum seed memo
      * \return                Wallet instance (Wallet::status() needs to be called to check if created successfully)
      */
-    virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language) = 0;
+    virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) = 0;
 
     /*!
      * \brief  Opens existing wallet
@@ -90,7 +228,7 @@ struct WalletManager
      * \param  password       Password of wallet file
      * \return                Wallet instance (Wallet::status() needs to be called to check if opened successfully)
      */
-    virtual Wallet * openWallet(const std::string &path, const std::string &password) = 0;
+    virtual Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) = 0;
 
     /*!
      * \brief  recovers existing wallet using memo (electrum seed)
@@ -98,7 +236,7 @@ struct WalletManager
      * \param  memo           memo (25 words electrum seed)
      * \return                Wallet instance (Wallet::status() needs to be called to check if recovered successfully)
      */
-    virtual Wallet * recoveryWallet(const std::string &path, const std::string &memo) = 0;
+    virtual Wallet * recoveryWallet(const std::string &path, const std::string &memo, bool testnet = false) = 0;
 
     /*!
      * \brief Closes wallet. In case operation succeded, wallet object deleted. in case operation failed, wallet object not deleted
@@ -107,9 +245,25 @@ struct WalletManager
      */
     virtual bool closeWallet(Wallet *wallet) = 0;
 
-    //! checks if wallet with the given name already exists
+    /*
+     * ! checks if wallet with the given name already exists
+     */
+
+    /*!
+     * @brief TODO: delme walletExists - check if the given filename is the wallet
+     * @param path - filename
+     * @return
+     */
     virtual bool walletExists(const std::string &path) = 0;
 
+    /*!
+     * \brief findWallets - searches for the wallet files by given path name recursively
+     * \param path - starting point to search
+     * \return - list of strings with found wallets (absolute paths);
+     */
+    virtual std::vector<std::string> findWallets(const std::string &path) = 0;
+
+    //! returns verbose error string regarding last error;
     virtual std::string errorString() const = 0;
 
 };
diff --git a/src/wallet/wallet_errors.h b/src/wallet/wallet_errors.h
index 184d8a2a1..ea0b6a1f5 100644
--- a/src/wallet/wallet_errors.h
+++ b/src/wallet/wallet_errors.h
@@ -56,6 +56,7 @@ namespace tools
     //       file_read_error
     //       file_save_error
     //       invalid_password
+    //       invalid_fee_multiplier
     //       refresh_error *
     //         acc_outs_lookup_error
     //         block_parse_error
@@ -226,6 +227,15 @@ namespace tools
 
       std::string to_string() const { return wallet_logic_error::to_string(); }
     };
+    struct invalid_fee_multiplier : public wallet_logic_error
+    {
+      explicit invalid_fee_multiplier(std::string&& loc)
+        : wallet_logic_error(std::move(loc), "invalid fee multiplier")
+      {
+      }
+
+      std::string to_string() const { return wallet_logic_error::to_string(); }
+    };
 
     //----------------------------------------------------------------------------------------------------
     struct invalid_pregenerated_random : public wallet_logic_error
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
index 5be9ae5b0..01ae00fe5 100644
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -232,7 +232,7 @@ namespace tools
         LOG_PRINT_L1("Requested mixin " << req.mixin << " too low for hard fork 2, using 2");
         mixin = 2;
       }
-      std::vector<wallet2::pending_tx> ptx_vector = m_wallet.create_transactions(dsts, mixin, req.unlock_time, req.fee, extra, req.trusted_daemon);
+      std::vector<wallet2::pending_tx> ptx_vector = m_wallet.create_transactions(dsts, mixin, req.unlock_time, req.fee_multiplier, extra, req.trusted_daemon);
 
       // reject proposed transactions if there are more than one.  see on_transfer_split below.
       if (ptx_vector.size() != 1)
@@ -299,9 +299,9 @@ namespace tools
       }
       std::vector<wallet2::pending_tx> ptx_vector;
       if (req.new_algorithm)
-        ptx_vector = m_wallet.create_transactions_2(dsts, mixin, req.unlock_time, req.fee, extra, req.trusted_daemon);
+        ptx_vector = m_wallet.create_transactions_2(dsts, mixin, req.unlock_time, req.fee_multiplier, extra, req.trusted_daemon);
       else
-        ptx_vector = m_wallet.create_transactions(dsts, mixin, req.unlock_time, req.fee, extra, req.trusted_daemon);
+        ptx_vector = m_wallet.create_transactions(dsts, mixin, req.unlock_time, req.fee_multiplier, extra, req.trusted_daemon);
 
       m_wallet.commit_tx(ptx_vector);
 
@@ -406,7 +406,7 @@ namespace tools
 
     try
     {
-      std::vector<wallet2::pending_tx> ptx_vector = m_wallet.create_transactions_all(dsts[0].addr, req.mixin, req.unlock_time, req.fee, extra, req.trusted_daemon);
+      std::vector<wallet2::pending_tx> ptx_vector = m_wallet.create_transactions_all(dsts[0].addr, req.mixin, req.unlock_time, req.fee_multiplier, extra, req.trusted_daemon);
 
       m_wallet.commit_tx(ptx_vector);
 
diff --git a/src/wallet/wallet_rpc_server_commands_defs.h b/src/wallet/wallet_rpc_server_commands_defs.h
index f8c04c007..3908476d6 100644
--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@@ -110,7 +110,7 @@ namespace wallet_rpc
     struct request
     {
       std::list<transfer_destination> destinations;
-      uint64_t fee;
+      uint64_t fee_multiplier;
       uint64_t mixin;
       uint64_t unlock_time;
       std::string payment_id;
@@ -119,7 +119,7 @@ namespace wallet_rpc
 
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(destinations)
-        KV_SERIALIZE(fee)
+        KV_SERIALIZE(fee_multiplier)
         KV_SERIALIZE(mixin)
         KV_SERIALIZE(unlock_time)
         KV_SERIALIZE(payment_id)
@@ -145,7 +145,7 @@ namespace wallet_rpc
     struct request
     {
       std::list<transfer_destination> destinations;
-      uint64_t fee;
+      uint64_t fee_multiplier;
       uint64_t mixin;
       uint64_t unlock_time;
       std::string payment_id;
@@ -155,7 +155,7 @@ namespace wallet_rpc
 
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(destinations)
-        KV_SERIALIZE(fee)
+        KV_SERIALIZE(fee_multiplier)
         KV_SERIALIZE(mixin)
         KV_SERIALIZE(unlock_time)
         KV_SERIALIZE(payment_id)
@@ -207,7 +207,7 @@ namespace wallet_rpc
     struct request
     {
       std::string address;
-      uint64_t fee;
+      uint64_t fee_multiplier;
       uint64_t mixin;
       uint64_t unlock_time;
       std::string payment_id;
@@ -216,7 +216,7 @@ namespace wallet_rpc
 
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(address)
-        KV_SERIALIZE(fee)
+        KV_SERIALIZE(fee_multiplier)
         KV_SERIALIZE(mixin)
         KV_SERIALIZE(unlock_time)
         KV_SERIALIZE(payment_id)