diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index 82354a4409..03b467b966 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,430 +1,431 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <interfaces/wallet.h>
 
 #include <amount.h>
 #include <chain.h>
 #include <consensus/validation.h>
 #include <interfaces/handler.h>
 #include <net.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/ismine.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <timedata.h>
 #include <ui_interface.h>
 #include <validation.h>
 #include <wallet/fees.h>
 #include <wallet/finaltx.h>
 #include <wallet/wallet.h>
 
 #include <memory>
 
 namespace interfaces {
 namespace {
 
     class PendingWalletTxImpl : public PendingWalletTx {
     public:
         PendingWalletTxImpl(CWallet &wallet)
             : m_wallet(wallet), m_key(&wallet) {}
 
         const CTransaction &get() override { return *m_tx; }
 
         bool commit(WalletValueMap value_map, WalletOrderForm order_form,
                     std::string from_account,
                     std::string &reject_reason) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             CValidationState state;
             if (!m_wallet.CommitTransaction(
                     m_tx, std::move(value_map), std::move(order_form),
                     std::move(from_account), m_key, g_connman.get(), state)) {
                 reject_reason = state.GetRejectReason();
                 return false;
             }
             return true;
         }
 
         CTransactionRef m_tx;
         CWallet &m_wallet;
         CReserveKey m_key;
     };
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(wallet.IsMine(txin));
         }
         result.txout_is_mine.reserve(wtx.tx->vout.size());
         result.txout_address.reserve(wtx.tx->vout.size());
         result.txout_address_is_mine.reserve(wtx.tx->vout.size());
         for (const auto &txout : wtx.tx->vout) {
             result.txout_is_mine.emplace_back(wallet.IsMine(txout));
             result.txout_address.emplace_back();
             result.txout_address_is_mine.emplace_back(
                 ExtractDestination(txout.scriptPubKey,
                                    result.txout_address.back())
                     ? IsMine(wallet, result.txout_address.back())
                     : ISMINE_NO);
         }
         result.credit = wtx.GetCredit(ISMINE_ALL);
         result.debit = wtx.GetDebit(ISMINE_ALL);
         result.change = wtx.GetChange();
         result.time = wtx.GetTxTime();
         result.value_map = wtx.mapValue;
         result.is_coinbase = wtx.IsCoinBase();
         return result;
     }
 
     //! Construct wallet tx status struct.
     WalletTxStatus MakeWalletTxStatus(const CWalletTx &wtx) {
         WalletTxStatus result;
         CBlockIndex *block = LookupBlockIndex(wtx.hashBlock);
         result.block_height =
             (block ? block->nHeight : std::numeric_limits<int>::max()),
         result.blocks_to_maturity = wtx.GetBlocksToMaturity();
         result.depth_in_main_chain = wtx.GetDepthInMainChain();
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         result.is_final = CheckFinalTx(*wtx.tx);
         result.is_trusted = wtx.IsTrusted();
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
         result.is_in_main_chain = wtx.IsInMainChain();
         return result;
     }
 
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
                                 int depth) {
         WalletTxOut result;
         result.txout = wtx.tx->vout[n];
         result.time = wtx.GetTxTime();
         result.depth_in_main_chain = depth;
         result.is_spent = wallet.IsSpent(COutPoint(wtx.GetId(), n));
         return result;
     }
 
     class WalletImpl : public Wallet {
     public:
         WalletImpl(CWallet &wallet) : m_wallet(wallet) {}
 
         bool encryptWallet(const SecureString &wallet_passphrase) override {
             return m_wallet.EncryptWallet(wallet_passphrase);
         }
         bool isCrypted() override { return m_wallet.IsCrypted(); }
         bool lock() override { return m_wallet.Lock(); }
         bool unlock(const SecureString &wallet_passphrase) override {
             return m_wallet.Unlock(wallet_passphrase);
         }
         bool isLocked() override { return m_wallet.IsLocked(); }
         bool changeWalletPassphrase(
             const SecureString &old_wallet_passphrase,
             const SecureString &new_wallet_passphrase) override {
             return m_wallet.ChangeWalletPassphrase(old_wallet_passphrase,
                                                    new_wallet_passphrase);
         }
         bool backupWallet(const std::string &filename) override {
             return m_wallet.BackupWallet(filename);
         }
         std::string getWalletName() override { return m_wallet.GetName(); }
         std::set<CTxDestination>
         getLabelAddresses(const std::string &label) override {
             return m_wallet.GetLabelAddresses(label);
         };
         bool getKeyFromPool(bool internal, CPubKey &pub_key) override {
             return m_wallet.GetKeyFromPool(pub_key, internal);
         }
         const CChainParams &getChainParams() override {
             return m_wallet.chainParams;
         }
         bool getPubKey(const CKeyID &address, CPubKey &pub_key) override {
             return m_wallet.GetPubKey(address, pub_key);
         }
         bool getPrivKey(const CKeyID &address, CKey &key) override {
             return m_wallet.GetKey(address, key);
         }
         bool isSpendable(const CTxDestination &dest) override {
             return IsMine(m_wallet, dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override { return m_wallet.HaveWatchOnly(); };
         bool setAddressBook(const CTxDestination &dest, const std::string &name,
                             const std::string &purpose) override {
             return m_wallet.SetAddressBook(dest, name, purpose);
         }
         bool delAddressBook(const CTxDestination &dest) override {
             return m_wallet.DelAddressBook(dest);
         }
         bool getAddress(const CTxDestination &dest, std::string *name,
                         isminetype *is_mine) override {
             LOCK(m_wallet.cs_wallet);
             auto it = m_wallet.mapAddressBook.find(dest);
             if (it == m_wallet.mapAddressBook.end()) {
                 return false;
             }
             if (name) {
                 *name = it->second.name;
             }
             if (is_mine) {
                 *is_mine = IsMine(m_wallet, dest);
             }
             return true;
         }
         std::vector<WalletAddress> getAddresses() override {
             LOCK(m_wallet.cs_wallet);
             std::vector<WalletAddress> result;
             for (const auto &item : m_wallet.mapAddressBook) {
                 result.emplace_back(item.first, IsMine(m_wallet, item.first),
                                     item.second.name, item.second.purpose);
             }
             return result;
         }
         void learnRelatedScripts(const CPubKey &key, OutputType type) override {
             m_wallet.LearnRelatedScripts(key, type);
         }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet.cs_wallet);
             return m_wallet.AddDestData(dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet.cs_wallet);
             return m_wallet.EraseDestData(dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             return m_wallet.GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.LockCoin(output);
         }
         void unlockCoin(const COutPoint &output) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.UnlockCoin(output);
         }
         bool isLockedCoin(const COutPoint &output) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.IsLockedCoin(output);
         }
         void listLockedCoins(std::vector<COutPoint> &outputs) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.ListLockedCoins(outputs);
         }
         std::unique_ptr<PendingWalletTx>
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           std::string &fail_reason) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             auto pending = std::make_unique<PendingWalletTxImpl>(m_wallet);
             if (!m_wallet.CreateTransaction(recipients, pending->m_tx,
                                             pending->m_key, fee, change_pos,
                                             fail_reason, coin_control, sign)) {
                 return {};
             }
             return std::move(pending);
         }
         bool transactionCanBeAbandoned(const TxId &txid) override {
             return m_wallet.TransactionCanBeAbandoned(txid);
         }
         bool abandonTransaction(const TxId &txid) override {
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.AbandonTransaction(txid);
         }
         CTransactionRef getTx(const TxId &txid) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
                 return mi->second.tx;
             }
             return {};
         }
         WalletTx getWalletTx(const TxId &txid) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
                 return MakeWalletTx(m_wallet, mi->second);
             }
             return {};
         }
         std::vector<WalletTx> getWalletTxs() override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             std::vector<WalletTx> result;
             result.reserve(m_wallet.mapWallet.size());
             for (const auto &entry : m_wallet.mapWallet) {
                 result.emplace_back(MakeWalletTx(m_wallet, entry.second));
             }
             return result;
         }
         bool tryGetTxStatus(const TxId &txid,
                             interfaces::WalletTxStatus &tx_status,
                             int &num_blocks, int64_t &block_time) override {
             TRY_LOCK(::cs_main, locked_chain);
             if (!locked_chain) {
                 return false;
             }
             TRY_LOCK(m_wallet.cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi == m_wallet.mapWallet.end()) {
                 return false;
             }
             num_blocks = ::chainActive.Height();
             block_time = ::chainActive.Tip()->GetBlockTime();
             tx_status = MakeWalletTxStatus(mi->second);
             return true;
         }
         WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
                                     WalletOrderForm &order_form,
                                     bool &in_mempool,
                                     int &num_blocks) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
                 num_blocks = ::chainActive.Height();
                 in_mempool = mi->second.InMempool();
                 order_form = mi->second.vOrderForm;
                 tx_status = MakeWalletTxStatus(mi->second);
                 return MakeWalletTx(m_wallet, mi->second);
             }
             return {};
         }
         WalletBalances getBalances() override {
             WalletBalances result;
             result.balance = m_wallet.GetBalance();
             result.unconfirmed_balance = m_wallet.GetUnconfirmedBalance();
             result.immature_balance = m_wallet.GetImmatureBalance();
             result.have_watch_only = m_wallet.HaveWatchOnly();
             if (result.have_watch_only) {
                 result.watch_only_balance = m_wallet.GetWatchOnlyBalance();
                 result.unconfirmed_watch_only_balance =
                     m_wallet.GetUnconfirmedWatchOnlyBalance();
                 result.immature_watch_only_balance =
                     m_wallet.GetImmatureWatchOnlyBalance();
             }
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
                             int &num_blocks) override {
             TRY_LOCK(cs_main, locked_chain);
             if (!locked_chain) {
                 return false;
             }
             TRY_LOCK(m_wallet.cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             balances = getBalances();
             num_blocks = ::chainActive.Height();
             return true;
         }
         Amount getBalance() override { return m_wallet.GetBalance(); }
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet.GetAvailableBalance(&coin_control);
         }
         isminetype txinIsMine(const CTxIn &txin) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             return m_wallet.IsMine(txin);
         }
         isminetype txoutIsMine(const CTxOut &txout) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             return m_wallet.IsMine(txout);
         }
         Amount getDebit(const CTxIn &txin, isminefilter filter) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             return m_wallet.GetDebit(txin, filter);
         }
         Amount getCredit(const CTxOut &txout, isminefilter filter) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             return m_wallet.GetCredit(txout, filter);
         }
         CoinsList listCoins() override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             CoinsList result;
             for (const auto &entry : m_wallet.ListCoins()) {
                 auto &group = result[entry.first];
                 for (const auto &coin : entry.second) {
                     group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
                                        MakeWalletTxOut(m_wallet, *coin.tx,
                                                        coin.i, coin.nDepth));
                 }
             }
             return result;
         }
         std::vector<WalletTxOut>
         getCoins(const std::vector<COutPoint> &outputs) override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             std::vector<WalletTxOut> result;
             result.reserve(outputs.size());
             for (const auto &output : outputs) {
                 result.emplace_back();
                 auto it = m_wallet.mapWallet.find(output.GetTxId());
                 if (it != m_wallet.mapWallet.end()) {
                     int depth = it->second.GetDepthInMainChain();
                     if (depth >= 0) {
                         result.back() = MakeWalletTxOut(m_wallet, it->second,
                                                         output.GetN(), depth);
                     }
                 }
             }
             return result;
         }
         bool hdEnabled() override { return m_wallet.IsHDEnabled(); }
+        OutputType getDefaultAddressType() override { return g_address_type; }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(m_wallet.ShowProgress.connect(fn));
         }
         std::unique_ptr<Handler>
         handleStatusChanged(StatusChangedFn fn) override {
             return MakeHandler(m_wallet.NotifyStatusChanged.connect(
                 [fn](CCryptoKeyStore *) { fn(); }));
         }
         std::unique_ptr<Handler>
         handleAddressBookChanged(AddressBookChangedFn fn) override {
             return MakeHandler(m_wallet.NotifyAddressBookChanged.connect(
                 [fn](CWallet *, const CTxDestination &address,
                      const std::string &label, bool is_mine,
                      const std::string &purpose, ChangeType status) {
                     fn(address, label, is_mine, purpose, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleTransactionChanged(TransactionChangedFn fn) override {
             return MakeHandler(m_wallet.NotifyTransactionChanged.connect(
                 [fn](CWallet *, const TxId &txid, ChangeType status) {
                     fn(txid, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet.NotifyWatchonlyChanged.connect(fn));
         }
         Amount getRequiredFee(unsigned int tx_bytes) override {
             return GetRequiredFee(m_wallet, tx_bytes);
         }
         Amount getMinimumFee(unsigned int tx_bytes,
                              const CCoinControl &coin_control) override {
             return GetMinimumFee(m_wallet, tx_bytes, coin_control, g_mempool);
         }
 
         CWallet &m_wallet;
     };
 
 } // namespace
 
 std::unique_ptr<Wallet> MakeWallet(CWallet &wallet) {
     return std::make_unique<WalletImpl>(wallet);
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index e628dfd94c..14e9341f09 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -1,344 +1,347 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <amount.h>                 // For Amount
 #include <primitives/transaction.h> // For CTxOut
 #include <pubkey.h>                 // For CTxDestination (CKeyID and CScriptID)
 #include <script/ismine.h>          // For isminefilter, isminetype
 #include <script/standard.h>        // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
 #include <ui_interface.h>              // For ChangeType
 
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 class CChainParams;
 class CCoinControl;
 class CKey;
 class CMutableTransaction;
 class COutPoint;
 class CTransaction;
 class CWallet;
 enum class OutputType;
 struct CRecipient;
 struct TxId;
 
 namespace interfaces {
 
 class Handler;
 class PendingWalletTx;
 struct WalletAddress;
 struct WalletBalances;
 struct WalletTx;
 struct WalletTxOut;
 struct WalletTxStatus;
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
 //! Interface for accessing a wallet.
 class Wallet {
 public:
     virtual ~Wallet() {}
 
     //! Encrypt wallet.
     virtual bool encryptWallet(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is encrypted.
     virtual bool isCrypted() = 0;
 
     //! Lock wallet.
     virtual bool lock() = 0;
 
     //! Unlock wallet.
     virtual bool unlock(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is locked.
     virtual bool isLocked() = 0;
 
     //! Change wallet passphrase.
     virtual bool
     changeWalletPassphrase(const SecureString &old_wallet_passphrase,
                            const SecureString &new_wallet_passphrase) = 0;
 
     //! Back up wallet.
     virtual bool backupWallet(const std::string &filename) = 0;
 
     //! Get wallet name.
     virtual std::string getWalletName() = 0;
 
     //! Get chainparams.
     virtual const CChainParams &getChainParams() = 0;
 
     //! Get set of addresses corresponding to a given label.
     virtual std::set<CTxDestination>
     getLabelAddresses(const std::string &label) = 0;
 
     //! Get key from pool.
     virtual bool getKeyFromPool(bool internal, CPubKey &pub_key) = 0;
 
     //! Get public key.
     virtual bool getPubKey(const CKeyID &address, CPubKey &pub_key) = 0;
 
     //! Get private key.
     virtual bool getPrivKey(const CKeyID &address, CKey &key) = 0;
 
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CTxDestination &dest) = 0;
 
     //! Return whether wallet has watch only keys.
     virtual bool haveWatchOnly() = 0;
 
     //! Add or update address.
     virtual bool setAddressBook(const CTxDestination &dest,
                                 const std::string &name,
                                 const std::string &purpose) = 0;
 
     // Remove address.
     virtual bool delAddressBook(const CTxDestination &dest) = 0;
 
     //! Look up address in wallet, return whether exists.
     virtual bool getAddress(const CTxDestination &dest,
                             std::string *name = nullptr,
                             isminetype *is_mine = nullptr) = 0;
 
     //! Get wallet address list.
     virtual std::vector<WalletAddress> getAddresses() = 0;
 
     //! Add scripts to key store so old so software versions opening the wallet
     //! database can detect payments to newer address types.
     virtual void learnRelatedScripts(const CPubKey &key, OutputType type) = 0;
 
     //! Add dest data.
     virtual bool addDestData(const CTxDestination &dest, const std::string &key,
                              const std::string &value) = 0;
 
     //! Erase dest data.
     virtual bool eraseDestData(const CTxDestination &dest,
                                const std::string &key) = 0;
 
     //! Get dest values with prefix.
     virtual std::vector<std::string>
     getDestValues(const std::string &prefix) = 0;
 
     //! Lock coin.
     virtual void lockCoin(const COutPoint &output) = 0;
 
     //! Unlock coin.
     virtual void unlockCoin(const COutPoint &output) = 0;
 
     //! Return whether coin is locked.
     virtual bool isLockedCoin(const COutPoint &output) = 0;
 
     //! List locked coins.
     virtual void listLockedCoins(std::vector<COutPoint> &outputs) = 0;
 
     //! Create transaction.
     virtual std::unique_ptr<PendingWalletTx>
     createTransaction(const std::vector<CRecipient> &recipients,
                       const CCoinControl &coin_control, bool sign,
                       int &change_pos, Amount &fee,
                       std::string &fail_reason) = 0;
 
     //! Return whether transaction can be abandoned.
     virtual bool transactionCanBeAbandoned(const TxId &txid) = 0;
 
     //! Abandon transaction.
     virtual bool abandonTransaction(const TxId &txid) = 0;
 
     //! Get a transaction.
     virtual CTransactionRef getTx(const TxId &txid) = 0;
 
     //! Get transaction information.
     virtual WalletTx getWalletTx(const TxId &txid) = 0;
 
     //! Get list of all wallet transactions.
     virtual std::vector<WalletTx> getWalletTxs() = 0;
 
     //! Try to get updated status for a particular transaction, if possible
     //! without blocking.
     virtual bool tryGetTxStatus(const TxId &txid, WalletTxStatus &tx_status,
                                 int &num_blocks, int64_t &block_time) = 0;
 
     //! Get transaction details.
     virtual WalletTx getWalletTxDetails(const TxId &txid,
                                         WalletTxStatus &tx_status,
                                         WalletOrderForm &order_form,
                                         bool &in_mempool, int &num_blocks) = 0;
 
     //! Get balances.
     virtual WalletBalances getBalances() = 0;
 
     //! Get balances if possible without blocking.
     virtual bool tryGetBalances(WalletBalances &balances, int &num_blocks) = 0;
 
     //! Get balance.
     virtual Amount getBalance() = 0;
 
     //! Get available balance.
     virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
 
     //! Return whether transaction input belongs to wallet.
     virtual isminetype txinIsMine(const CTxIn &txin) = 0;
 
     //! Return whether transaction output belongs to wallet.
     virtual isminetype txoutIsMine(const CTxOut &txout) = 0;
 
     //! Return debit amount if transaction input belongs to wallet.
     virtual Amount getDebit(const CTxIn &txin, isminefilter filter) = 0;
 
     //! Return credit amount if transaction input belongs to wallet.
     virtual Amount getCredit(const CTxOut &txout, isminefilter filter) = 0;
 
     //! Return AvailableCoins + LockedCoins grouped by wallet address.
     //! (put change in one group with wallet address)
     using CoinsList = std::map<CTxDestination,
                                std::vector<std::tuple<COutPoint, WalletTxOut>>>;
     virtual CoinsList listCoins() = 0;
 
     //! Return wallet transaction output information.
     virtual std::vector<WalletTxOut>
     getCoins(const std::vector<COutPoint> &outputs) = 0;
 
     //! Get required fee.
     virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
 
     //! Get minimum fee.
     virtual Amount getMinimumFee(unsigned int tx_bytes,
                                  const CCoinControl &coin_control) = 0;
 
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
+    // Get default address type.
+    virtual OutputType getDefaultAddressType() = 0;
+
     //! Register handler for show progress messages.
     using ShowProgressFn =
         std::function<void(const std::string &title, int progress)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for status changed messages.
     using StatusChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleStatusChanged(StatusChangedFn fn) = 0;
 
     //! Register handler for address book changed messages.
     using AddressBookChangedFn = std::function<void(
         const CTxDestination &address, const std::string &label, bool is_mine,
         const std::string &purpose, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleAddressBookChanged(AddressBookChangedFn fn) = 0;
 
     //! Register handler for transaction changed messages.
     using TransactionChangedFn =
         std::function<void(const TxId &txid, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleTransactionChanged(TransactionChangedFn fn) = 0;
 
     //! Register handler for watchonly changed messages.
     using WatchOnlyChangedFn = std::function<void(bool have_watch_only)>;
     virtual std::unique_ptr<Handler>
     handleWatchOnlyChanged(WatchOnlyChangedFn fn) = 0;
 };
 
 //! Tracking object returned by CreateTransaction and passed to
 //! CommitTransaction.
 class PendingWalletTx {
 public:
     virtual ~PendingWalletTx() {}
 
     //! Get transaction data.
     virtual const CTransaction &get() = 0;
 
     //! Send pending transaction and commit to wallet.
     virtual bool commit(WalletValueMap value_map, WalletOrderForm order_form,
                         std::string from_account,
                         std::string &reject_reason) = 0;
 };
 
 //! Information about one wallet address.
 struct WalletAddress {
     CTxDestination dest;
     isminetype is_mine;
     std::string name;
     std::string purpose;
 
     WalletAddress(CTxDestination destIn, isminetype isMineIn,
                   std::string nameIn, std::string purposeIn)
         : dest(std::move(destIn)), is_mine(isMineIn), name(std::move(nameIn)),
           purpose(std::move(purposeIn)) {}
 };
 
 //! Collection of wallet balances.
 struct WalletBalances {
     Amount balance = Amount::zero();
     Amount unconfirmed_balance = Amount::zero();
     Amount immature_balance = Amount::zero();
     bool have_watch_only = false;
     Amount watch_only_balance = Amount::zero();
     Amount unconfirmed_watch_only_balance = Amount::zero();
     Amount immature_watch_only_balance = Amount::zero();
 
     bool balanceChanged(const WalletBalances &prev) const {
         return balance != prev.balance ||
                unconfirmed_balance != prev.unconfirmed_balance ||
                immature_balance != prev.immature_balance ||
                watch_only_balance != prev.watch_only_balance ||
                unconfirmed_watch_only_balance !=
                    prev.unconfirmed_watch_only_balance ||
                immature_watch_only_balance != prev.immature_watch_only_balance;
     }
 };
 
 // Wallet transaction information.
 struct WalletTx {
     CTransactionRef tx;
     std::vector<isminetype> txin_is_mine;
     std::vector<isminetype> txout_is_mine;
     std::vector<CTxDestination> txout_address;
     std::vector<isminetype> txout_address_is_mine;
     Amount credit;
     Amount debit;
     Amount change;
     int64_t time;
     std::map<std::string, std::string> value_map;
     bool is_coinbase;
 };
 
 //! Updated transaction status.
 struct WalletTxStatus {
     int block_height;
     int blocks_to_maturity;
     int depth_in_main_chain;
     unsigned int time_received;
     uint32_t lock_time;
     bool is_final;
     bool is_trusted;
     bool is_abandoned;
     bool is_coinbase;
     bool is_in_main_chain;
 };
 
 //! Wallet transaction output.
 struct WalletTxOut {
     CTxOut txout;
     int64_t time;
     int depth_in_main_chain = -1;
     bool is_spent = false;
 };
 
 //! Return implementation of Wallet interface. This function will be undefined
 //! in builds where ENABLE_WALLET is false.
 std::unique_ptr<Wallet> MakeWallet(CWallet &wallet);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_WALLET_H
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
index 6aca594b4e..1a801559d3 100644
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -1,409 +1,409 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/addresstablemodel.h>
 
 #include <cashaddrenc.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <qt/guiutil.h>
 #include <qt/walletmodel.h>
 #include <wallet/wallet.h>
 
 #include <QDebug>
 #include <QFont>
 
 const QString AddressTableModel::Send = "S";
 const QString AddressTableModel::Receive = "R";
 
 struct AddressTableEntry {
     enum Type {
         Sending,
         Receiving,
         /* QSortFilterProxyModel will filter these out */
         Hidden
     };
 
     Type type;
     QString label;
     QString address;
 
     AddressTableEntry() {}
     AddressTableEntry(Type _type, const QString &_label,
                       const QString &_address)
         : type(_type), label(_label), address(_address) {}
 };
 
 struct AddressTableEntryLessThan {
     bool operator()(const AddressTableEntry &a,
                     const AddressTableEntry &b) const {
         return a.address < b.address;
     }
     bool operator()(const AddressTableEntry &a, const QString &b) const {
         return a.address < b;
     }
     bool operator()(const QString &a, const AddressTableEntry &b) const {
         return a < b.address;
     }
 };
 
 /* Determine address type from address purpose */
 static AddressTableEntry::Type
 translateTransactionType(const QString &strPurpose, bool isMine) {
     AddressTableEntry::Type addressType = AddressTableEntry::Hidden;
     // "refund" addresses aren't shown, and change addresses aren't in
     // mapAddressBook at all.
     if (strPurpose == "send") {
         addressType = AddressTableEntry::Sending;
     } else if (strPurpose == "receive") {
         addressType = AddressTableEntry::Receiving;
     } else if (strPurpose == "unknown" || strPurpose == "") {
         // if purpose not set, guess
         addressType = (isMine ? AddressTableEntry::Receiving
                               : AddressTableEntry::Sending);
     }
     return addressType;
 }
 
 // Private implementation
 class AddressTablePriv {
 public:
     QList<AddressTableEntry> cachedAddressTable;
     AddressTableModel *parent;
 
     AddressTablePriv(AddressTableModel *_parent) : parent(_parent) {}
 
     void refreshAddressTable(interfaces::Wallet &wallet) {
         cachedAddressTable.clear();
         for (const auto &address : wallet.getAddresses()) {
             AddressTableEntry::Type addressType = translateTransactionType(
                 QString::fromStdString(address.purpose), address.is_mine);
             cachedAddressTable.append(AddressTableEntry(
                 addressType, QString::fromStdString(address.name),
                 QString::fromStdString(EncodeCashAddr(
                     address.dest, parent->walletModel->getChainParams()))));
         }
         // qLowerBound() and qUpperBound() require our cachedAddressTable list
         // to be sorted in asc order. Even though the map is already sorted this
         // re-sorting step is needed because the originating map is sorted by
         // binary address, not by base58() address.
         qSort(cachedAddressTable.begin(), cachedAddressTable.end(),
               AddressTableEntryLessThan());
     }
 
     void updateEntry(const QString &address, const QString &label, bool isMine,
                      const QString &purpose, int status) {
         // Find address / label in model
         QList<AddressTableEntry>::iterator lower =
             qLowerBound(cachedAddressTable.begin(), cachedAddressTable.end(),
                         address, AddressTableEntryLessThan());
         QList<AddressTableEntry>::iterator upper =
             qUpperBound(cachedAddressTable.begin(), cachedAddressTable.end(),
                         address, AddressTableEntryLessThan());
         int lowerIndex = (lower - cachedAddressTable.begin());
         int upperIndex = (upper - cachedAddressTable.begin());
         bool inModel = (lower != upper);
         AddressTableEntry::Type newEntryType =
             translateTransactionType(purpose, isMine);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_NEW, but entry is already in model";
                     break;
                 }
                 parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
                 cachedAddressTable.insert(
                     lowerIndex,
                     AddressTableEntry(newEntryType, label, address));
                 parent->endInsertRows();
                 break;
             case CT_UPDATED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_UPDATED, but entry is not in model";
                     break;
                 }
                 lower->type = newEntryType;
                 lower->label = label;
                 parent->emitDataChanged(lowerIndex);
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_DELETED, but entry is not in model";
                     break;
                 }
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedAddressTable.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
         }
     }
 
     int size() { return cachedAddressTable.size(); }
 
     AddressTableEntry *index(int idx) {
         if (idx >= 0 && idx < cachedAddressTable.size()) {
             return &cachedAddressTable[idx];
         } else {
             return nullptr;
         }
     }
 };
 
 AddressTableModel::AddressTableModel(WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent), priv(0) {
     columns << tr("Label") << tr("Address");
     priv = new AddressTablePriv(this);
     priv->refreshAddressTable(parent->wallet());
 }
 
 AddressTableModel::~AddressTableModel() {
     delete priv;
 }
 
 int AddressTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int AddressTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant AddressTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         switch (index.column()) {
             case Label:
                 if (rec->label.isEmpty() && role == Qt::DisplayRole) {
                     return tr("(no label)");
                 } else {
                     return rec->label;
                 }
             case Address:
                 return rec->address;
         }
     } else if (role == Qt::FontRole) {
         QFont font;
         if (index.column() == Address) {
             font = GUIUtil::fixedPitchFont();
         }
         return font;
     } else if (role == TypeRole) {
         switch (rec->type) {
             case AddressTableEntry::Sending:
                 return Send;
             case AddressTableEntry::Receiving:
                 return Receive;
             default:
                 break;
         }
     }
     return QVariant();
 }
 
 bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
                                 int role) {
     if (!index.isValid()) {
         return false;
     }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
     std::string strPurpose =
         (rec->type == AddressTableEntry::Sending ? "send" : "receive");
     editStatus = OK;
 
     if (role == Qt::EditRole) {
         CTxDestination curAddress = DecodeDestination(
             rec->address.toStdString(), walletModel->getChainParams());
         if (index.column() == Label) {
             // Do nothing, if old label == new label
             if (rec->label == value.toString()) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             walletModel->wallet().setAddressBook(
                 curAddress, value.toString().toStdString(), strPurpose);
         } else if (index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(
                 value.toString().toStdString(), walletModel->getChainParams());
             // Refuse to set invalid address, set error status and return false
             if (boost::get<CNoDestination>(&newAddress)) {
                 editStatus = INVALID_ADDRESS;
                 return false;
             }
             // Do nothing, if old address == new address
             else if (newAddress == curAddress) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             // Check for duplicate addresses to prevent accidental deletion of
             // addresses, if you try to paste an existing address over another
             // address (with a different label)
             if (walletModel->wallet().getAddress(newAddress)) {
                 editStatus = DUPLICATE_ADDRESS;
                 return false;
             }
             // Double-check that we're not overwriting a receiving address
             else if (rec->type == AddressTableEntry::Sending) {
                 // Remove old entry
                 walletModel->wallet().delAddressBook(curAddress);
                 // Add new entry with new address
                 walletModel->wallet().setAddressBook(
                     newAddress, value.toString().toStdString(), strPurpose);
             }
         }
         return true;
     }
     return false;
 }
 
 QVariant AddressTableModel::headerData(int section, Qt::Orientation orientation,
                                        int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags AddressTableModel::flags(const QModelIndex &index) const {
     if (!index.isValid()) {
         return 0;
     }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     // Can edit address and label for sending addresses, and only label for
     // receiving addresses.
     if (rec->type == AddressTableEntry::Sending ||
         (rec->type == AddressTableEntry::Receiving &&
          index.column() == Label)) {
         retval |= Qt::ItemIsEditable;
     }
     return retval;
 }
 
 QModelIndex AddressTableModel::index(int row, int column,
                                      const QModelIndex &parent) const {
     Q_UNUSED(parent);
     AddressTableEntry *data = priv->index(row);
     if (data) {
         return createIndex(row, column, priv->index(row));
     } else {
         return QModelIndex();
     }
 }
 
 void AddressTableModel::updateEntry(const QString &address,
                                     const QString &label, bool isMine,
                                     const QString &purpose, int status) {
     // Update address book model from Bitcoin core
     priv->updateEntry(address, label, isMine, purpose, status);
 }
 
 QString AddressTableModel::addRow(const QString &type, const QString &label,
-                                  const QString &address) {
+                                  const QString &address,
+                                  const OutputType address_type) {
     std::string strLabel = label.toStdString();
     std::string strAddress = address.toStdString();
 
     editStatus = OK;
 
     if (type == Send) {
         if (!walletModel->validateAddress(address)) {
             editStatus = INVALID_ADDRESS;
             return QString();
         }
         // Check for duplicate addresses
         if (walletModel->wallet().getAddress(
                 DecodeDestination(strAddress, walletModel->getChainParams()))) {
             editStatus = DUPLICATE_ADDRESS;
             return QString();
         }
     } else if (type == Receive) {
         // Generate a new address to associate with given label
         CPubKey newKey;
         if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                   newKey)) {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
             if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                       newKey)) {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
-        walletModel->wallet().learnRelatedScripts(newKey, g_address_type);
-        strAddress =
-            EncodeCashAddr(GetDestinationForKey(newKey, g_address_type),
-                           walletModel->getChainParams());
+        walletModel->wallet().learnRelatedScripts(newKey, address_type);
+        strAddress = EncodeCashAddr(GetDestinationForKey(newKey, address_type),
+                                    walletModel->getChainParams());
     } else {
         return QString();
     }
 
     // Add entry
     walletModel->wallet().setAddressBook(
         DecodeDestination(strAddress, walletModel->getChainParams()), strLabel,
         (type == Send ? "send" : "receive"));
     return QString::fromStdString(strAddress);
 }
 
 bool AddressTableModel::removeRows(int row, int count,
                                    const QModelIndex &parent) {
     Q_UNUSED(parent);
     AddressTableEntry *rec = priv->index(row);
     if (count != 1 || !rec || rec->type == AddressTableEntry::Receiving) {
         // Can only remove one row at a time, and cannot remove rows not in
         // model.
         // Also refuse to remove receiving addresses.
         return false;
     }
     walletModel->wallet().delAddressBook(DecodeDestination(
         rec->address.toStdString(), walletModel->getChainParams()));
     return true;
 }
 
 /* Look up label for address in address book, if not found return empty string.
  */
 QString AddressTableModel::labelForAddress(const QString &address) const {
     CTxDestination destination =
         DecodeDestination(address.toStdString(), walletModel->getChainParams());
     std::string name;
     if (walletModel->wallet().getAddress(destination, &name)) {
         return QString::fromStdString(name);
     }
     return QString();
 }
 
 int AddressTableModel::lookupAddress(const QString &address) const {
     QModelIndexList lst = match(index(0, Address, QModelIndex()), Qt::EditRole,
                                 address, 1, Qt::MatchExactly);
     if (lst.isEmpty()) {
         return -1;
     } else {
         return lst.at(0).row();
     }
 }
 
 void AddressTableModel::emitDataChanged(int idx) {
     Q_EMIT dataChanged(index(idx, 0, QModelIndex()),
                        index(idx, columns.length() - 1, QModelIndex()));
 }
diff --git a/src/qt/addresstablemodel.h b/src/qt/addresstablemodel.h
index ab477c8dd7..0a399fcc0f 100644
--- a/src/qt/addresstablemodel.h
+++ b/src/qt/addresstablemodel.h
@@ -1,114 +1,116 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_ADDRESSTABLEMODEL_H
 #define BITCOIN_QT_ADDRESSTABLEMODEL_H
 
 #include <QAbstractTableModel>
 #include <QStringList>
 
+enum class OutputType;
+
 class AddressTablePriv;
 class WalletModel;
 
 namespace interfaces {
 class Wallet;
 }
 
 /**
  * Qt model of the address book in the core. This allows views to access and
  * modify the address book.
  */
 class AddressTableModel : public QAbstractTableModel {
     Q_OBJECT
 
 public:
     explicit AddressTableModel(WalletModel *parent = 0);
     ~AddressTableModel();
 
     enum ColumnIndex {
         /**< User specified label */
         Label = 0,
         /**< Bitcoin address */
         Address = 1
     };
 
     enum RoleIndex {
         /**< Type of address (#Send or #Receive) */
         TypeRole = Qt::UserRole
     };
 
     /** Return status of edit/insert operation */
     enum EditStatus {
         /**< Everything ok */
         OK,
         /**< No changes were made during edit operation */
         NO_CHANGES,
         /**< Unparseable address */
         INVALID_ADDRESS,
         /**< Address already in address book */
         DUPLICATE_ADDRESS,
         /**< Wallet could not be unlocked to create new receiving address */
         WALLET_UNLOCK_FAILURE,
         /**< Generating a new public key for a receiving address failed */
         KEY_GENERATION_FAILURE
     };
 
     /**< Specifies send address */
     static const QString Send;
     /**< Specifies receive address */
     static const QString Receive;
 
     /** @name Methods overridden from QAbstractTableModel
         @{*/
     int rowCount(const QModelIndex &parent) const override;
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value,
                  int role) override;
     QVariant headerData(int section, Qt::Orientation orientation,
                         int role) const override;
     QModelIndex index(int row, int column,
                       const QModelIndex &parent) const override;
     bool removeRows(int row, int count,
                     const QModelIndex &parent = QModelIndex()) override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
     /*@}*/
 
     /* Add an address to the model.
        Returns the added address on success, and an empty string otherwise.
      */
     QString addRow(const QString &type, const QString &label,
-                   const QString &address);
+                   const QString &address, const OutputType address_type);
 
     /* Look up label for address in address book, if not found return empty
      * string.
      */
     QString labelForAddress(const QString &address) const;
 
     /* Look up row index of an address in the model.
        Return -1 if not found.
      */
     int lookupAddress(const QString &address) const;
 
     EditStatus getEditStatus() const { return editStatus; }
 
 private:
     WalletModel *walletModel;
     AddressTablePriv *priv;
     QStringList columns;
     EditStatus editStatus;
 
     /** Notify listeners that data changed. */
     void emitDataChanged(int index);
 
 public Q_SLOTS:
     /* Update address list from core.
      */
     void updateEntry(const QString &address, const QString &label, bool isMine,
                      const QString &purpose, int status);
 
     friend class AddressTablePriv;
 };
 
 #endif // BITCOIN_QT_ADDRESSTABLEMODEL_H
diff --git a/src/qt/editaddressdialog.cpp b/src/qt/editaddressdialog.cpp
index 8b6c05cb97..d89f3fd48a 100644
--- a/src/qt/editaddressdialog.cpp
+++ b/src/qt/editaddressdialog.cpp
@@ -1,134 +1,136 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/editaddressdialog.h>
 #include <qt/forms/ui_editaddressdialog.h>
 
 #include <qt/addresstablemodel.h>
 #include <qt/guiutil.h>
 
 #include <QDataWidgetMapper>
 #include <QMessageBox>
 
+extern OutputType g_address_type;
+
 EditAddressDialog::EditAddressDialog(Mode _mode, QWidget *parent)
     : QDialog(parent), ui(new Ui::EditAddressDialog), mapper(0), mode(_mode),
       model(0) {
     ui->setupUi(this);
 
     GUIUtil::setupAddressWidget(ui->addressEdit, this);
 
     switch (mode) {
         case NewReceivingAddress:
             setWindowTitle(tr("New receiving address"));
             ui->addressEdit->setEnabled(false);
             break;
         case NewSendingAddress:
             setWindowTitle(tr("New sending address"));
             break;
         case EditReceivingAddress:
             setWindowTitle(tr("Edit receiving address"));
             ui->addressEdit->setEnabled(false);
             break;
         case EditSendingAddress:
             setWindowTitle(tr("Edit sending address"));
             break;
     }
 
     mapper = new QDataWidgetMapper(this);
     mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
 }
 
 EditAddressDialog::~EditAddressDialog() {
     delete ui;
 }
 
 void EditAddressDialog::setModel(AddressTableModel *_model) {
     this->model = _model;
     if (!_model) {
         return;
     }
 
     mapper->setModel(_model);
     mapper->addMapping(ui->labelEdit, AddressTableModel::Label);
     mapper->addMapping(ui->addressEdit, AddressTableModel::Address);
 }
 
 void EditAddressDialog::loadRow(int row) {
     mapper->setCurrentIndex(row);
 }
 
 bool EditAddressDialog::saveCurrentRow() {
     if (!model) {
         return false;
     }
 
     switch (mode) {
         case NewReceivingAddress:
         case NewSendingAddress:
             address = model->addRow(
                 mode == NewSendingAddress ? AddressTableModel::Send
                                           : AddressTableModel::Receive,
-                ui->labelEdit->text(), ui->addressEdit->text());
+                ui->labelEdit->text(), ui->addressEdit->text(), g_address_type);
             break;
         case EditReceivingAddress:
         case EditSendingAddress:
             if (mapper->submit()) {
                 address = ui->addressEdit->text();
             }
             break;
     }
     return !address.isEmpty();
 }
 
 void EditAddressDialog::accept() {
     if (!model) {
         return;
     }
 
     if (!saveCurrentRow()) {
         switch (model->getEditStatus()) {
             case AddressTableModel::OK:
                 // Failed with unknown reason. Just reject.
                 break;
             case AddressTableModel::NO_CHANGES:
                 // No changes were made during edit operation. Just reject.
                 break;
             case AddressTableModel::INVALID_ADDRESS:
                 QMessageBox::warning(this, windowTitle(),
                                      tr("The entered address \"%1\" is not a "
                                         "valid Bitcoin address.")
                                          .arg(ui->addressEdit->text()),
                                      QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::DUPLICATE_ADDRESS:
                 QMessageBox::warning(this, windowTitle(),
                                      tr("The entered address \"%1\" is already "
                                         "in the address book.")
                                          .arg(ui->addressEdit->text()),
                                      QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::WALLET_UNLOCK_FAILURE:
                 QMessageBox::critical(this, windowTitle(),
                                       tr("Could not unlock wallet."),
                                       QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::KEY_GENERATION_FAILURE:
                 QMessageBox::critical(this, windowTitle(),
                                       tr("New key generation failed."),
                                       QMessageBox::Ok, QMessageBox::Ok);
                 break;
         }
         return;
     }
     QDialog::accept();
 }
 
 QString EditAddressDialog::getAddress() const {
     return address;
 }
 
 void EditAddressDialog::setAddress(const QString &_address) {
     this->address = _address;
     ui->addressEdit->setText(_address);
 }
diff --git a/src/qt/receivecoinsdialog.cpp b/src/qt/receivecoinsdialog.cpp
index 2e5532d5ec..5a8fa03263 100644
--- a/src/qt/receivecoinsdialog.cpp
+++ b/src/qt/receivecoinsdialog.cpp
@@ -1,281 +1,284 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <wallet/wallet.h>
+
 #include <qt/forms/ui_receivecoinsdialog.h>
 #include <qt/receivecoinsdialog.h>
 
 #include <qt/addressbookpage.h>
 #include <qt/addresstablemodel.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/receiverequestdialog.h>
 #include <qt/recentrequeststablemodel.h>
 #include <qt/walletmodel.h>
 
 #include <QAction>
 #include <QCursor>
 #include <QItemSelection>
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QTextDocument>
 
 ReceiveCoinsDialog::ReceiveCoinsDialog(const PlatformStyle *_platformStyle,
                                        QWidget *parent)
     : QDialog(parent), ui(new Ui::ReceiveCoinsDialog), columnResizingFixer(0),
       model(0), platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     if (!_platformStyle->getImagesOnButtons()) {
         ui->clearButton->setIcon(QIcon());
         ui->receiveButton->setIcon(QIcon());
         ui->showRequestButton->setIcon(QIcon());
         ui->removeRequestButton->setIcon(QIcon());
     } else {
         ui->clearButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/remove"));
         ui->receiveButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/receiving_addresses"));
         ui->showRequestButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/edit"));
         ui->removeRequestButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/remove"));
     }
 
     // context menu actions
     QAction *copyURIAction = new QAction(tr("Copy URI"), this);
     QAction *copyLabelAction = new QAction(tr("Copy label"), this);
     QAction *copyMessageAction = new QAction(tr("Copy message"), this);
     QAction *copyAmountAction = new QAction(tr("Copy amount"), this);
 
     // context menu
     contextMenu = new QMenu(this);
     contextMenu->addAction(copyURIAction);
     contextMenu->addAction(copyLabelAction);
     contextMenu->addAction(copyMessageAction);
     contextMenu->addAction(copyAmountAction);
 
     // context menu signals
     connect(ui->recentRequestsView, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(showMenu(QPoint)));
     connect(copyURIAction, SIGNAL(triggered()), this, SLOT(copyURI()));
     connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(copyLabel()));
     connect(copyMessageAction, SIGNAL(triggered()), this, SLOT(copyMessage()));
     connect(copyAmountAction, SIGNAL(triggered()), this, SLOT(copyAmount()));
 
     connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
 }
 
 void ReceiveCoinsDialog::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model && _model->getOptionsModel()) {
         _model->getRecentRequestsTableModel()->sort(
             RecentRequestsTableModel::Date, Qt::DescendingOrder);
         connect(_model->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
                 this, SLOT(updateDisplayUnit()));
         updateDisplayUnit();
 
         QTableView *tableView = ui->recentRequestsView;
 
         tableView->verticalHeader()->hide();
         tableView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         tableView->setModel(_model->getRecentRequestsTableModel());
         tableView->setAlternatingRowColors(true);
         tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
         tableView->setSelectionMode(QAbstractItemView::ContiguousSelection);
         tableView->setColumnWidth(RecentRequestsTableModel::Date,
                                   DATE_COLUMN_WIDTH);
         tableView->setColumnWidth(RecentRequestsTableModel::Label,
                                   LABEL_COLUMN_WIDTH);
         tableView->setColumnWidth(RecentRequestsTableModel::Amount,
                                   AMOUNT_MINIMUM_COLUMN_WIDTH);
 
         connect(tableView->selectionModel(),
                 SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this,
                 SLOT(recentRequestsView_selectionChanged(QItemSelection,
                                                          QItemSelection)));
         // Last 2 columns are set by the columnResizingFixer, when the table
         // geometry is ready.
         columnResizingFixer = new GUIUtil::TableViewLastColumnResizingFixer(
             tableView, AMOUNT_MINIMUM_COLUMN_WIDTH, DATE_COLUMN_WIDTH, this);
     }
 }
 
 ReceiveCoinsDialog::~ReceiveCoinsDialog() {
     delete ui;
 }
 
 void ReceiveCoinsDialog::clear() {
     ui->reqAmount->clear();
     ui->reqLabel->setText("");
     ui->reqMessage->setText("");
     updateDisplayUnit();
 }
 
 void ReceiveCoinsDialog::reject() {
     clear();
 }
 
 void ReceiveCoinsDialog::accept() {
     clear();
 }
 
 void ReceiveCoinsDialog::updateDisplayUnit() {
     if (model && model->getOptionsModel()) {
         ui->reqAmount->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
     }
 }
 
 void ReceiveCoinsDialog::on_receiveButton_clicked() {
     if (!model || !model->getOptionsModel() || !model->getAddressTableModel() ||
         !model->getRecentRequestsTableModel())
         return;
 
     QString address;
     QString label = ui->reqLabel->text();
     /* Generate new receiving address */
+    OutputType address_type = model->wallet().getDefaultAddressType();
     address = model->getAddressTableModel()->addRow(AddressTableModel::Receive,
-                                                    label, "");
+                                                    label, "", address_type);
     SendCoinsRecipient info(address, label, ui->reqAmount->value(),
                             ui->reqMessage->text());
     ReceiveRequestDialog *dialog = new ReceiveRequestDialog(this);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     dialog->setModel(model);
     dialog->setInfo(info);
     dialog->show();
     clear();
 
     /* Store request for later reference */
     model->getRecentRequestsTableModel()->addNewRequest(info);
 }
 
 void ReceiveCoinsDialog::on_recentRequestsView_doubleClicked(
     const QModelIndex &index) {
     const RecentRequestsTableModel *submodel =
         model->getRecentRequestsTableModel();
     ReceiveRequestDialog *dialog = new ReceiveRequestDialog(this);
     dialog->setModel(model);
     dialog->setInfo(submodel->entry(index.row()).recipient);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     dialog->show();
 }
 
 void ReceiveCoinsDialog::recentRequestsView_selectionChanged(
     const QItemSelection &selected, const QItemSelection &deselected) {
     // Enable Show/Remove buttons only if anything is selected.
     bool enable =
         !ui->recentRequestsView->selectionModel()->selectedRows().isEmpty();
     ui->showRequestButton->setEnabled(enable);
     ui->removeRequestButton->setEnabled(enable);
 }
 
 void ReceiveCoinsDialog::on_showRequestButton_clicked() {
     if (!model || !model->getRecentRequestsTableModel() ||
         !ui->recentRequestsView->selectionModel())
         return;
     QModelIndexList selection =
         ui->recentRequestsView->selectionModel()->selectedRows();
 
     for (const QModelIndex &index : selection) {
         on_recentRequestsView_doubleClicked(index);
     }
 }
 
 void ReceiveCoinsDialog::on_removeRequestButton_clicked() {
     if (!model || !model->getRecentRequestsTableModel() ||
         !ui->recentRequestsView->selectionModel())
         return;
     QModelIndexList selection =
         ui->recentRequestsView->selectionModel()->selectedRows();
     if (selection.empty()) return;
     // correct for selection mode ContiguousSelection
     QModelIndex firstIndex = selection.at(0);
     model->getRecentRequestsTableModel()->removeRows(
         firstIndex.row(), selection.length(), firstIndex.parent());
 }
 
 // We override the virtual resizeEvent of the QWidget to adjust tables column
 // sizes as the tables width is proportional to the dialogs width.
 void ReceiveCoinsDialog::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
     columnResizingFixer->stretchColumnWidth(RecentRequestsTableModel::Message);
 }
 
 void ReceiveCoinsDialog::keyPressEvent(QKeyEvent *event) {
     if (event->key() == Qt::Key_Return) {
         // press return -> submit form
         if (ui->reqLabel->hasFocus() || ui->reqAmount->hasFocus() ||
             ui->reqMessage->hasFocus()) {
             event->ignore();
             on_receiveButton_clicked();
             return;
         }
     }
 
     this->QDialog::keyPressEvent(event);
 }
 
 QModelIndex ReceiveCoinsDialog::selectedRow() {
     if (!model || !model->getRecentRequestsTableModel() ||
         !ui->recentRequestsView->selectionModel())
         return QModelIndex();
     QModelIndexList selection =
         ui->recentRequestsView->selectionModel()->selectedRows();
     if (selection.empty()) return QModelIndex();
     // correct for selection mode ContiguousSelection
     QModelIndex firstIndex = selection.at(0);
     return firstIndex;
 }
 
 // copy column of selected row to clipboard
 void ReceiveCoinsDialog::copyColumnToClipboard(int column) {
     QModelIndex firstIndex = selectedRow();
     if (!firstIndex.isValid()) {
         return;
     }
     GUIUtil::setClipboard(
         model->getRecentRequestsTableModel()
             ->data(firstIndex.child(firstIndex.row(), column), Qt::EditRole)
             .toString());
 }
 
 // context menu
 void ReceiveCoinsDialog::showMenu(const QPoint &point) {
     if (!selectedRow().isValid()) {
         return;
     }
     contextMenu->exec(QCursor::pos());
 }
 
 // context menu action: copy URI
 void ReceiveCoinsDialog::copyURI() {
     QModelIndex sel = selectedRow();
     if (!sel.isValid()) {
         return;
     }
 
     const RecentRequestsTableModel *const submodel =
         model->getRecentRequestsTableModel();
     const QString uri =
         GUIUtil::formatBitcoinURI(submodel->entry(sel.row()).recipient);
     GUIUtil::setClipboard(uri);
 }
 
 // context menu action: copy label
 void ReceiveCoinsDialog::copyLabel() {
     copyColumnToClipboard(RecentRequestsTableModel::Label);
 }
 
 // context menu action: copy message
 void ReceiveCoinsDialog::copyMessage() {
     copyColumnToClipboard(RecentRequestsTableModel::Message);
 }
 
 // context menu action: copy amount
 void ReceiveCoinsDialog::copyAmount() {
     copyColumnToClipboard(RecentRequestsTableModel::Amount);
 }