Remove direct bitcoin calls from qt/addresstablemodel.cpp

ryanofsky · jnewbery · commit 3ec2ebcd9b4b · 2018-04-04T16:52:40.000-04:00
diff --git a/src/interface/wallet.cpp b/src/interface/wallet.cpp
@@ -85,6 +85,10 @@ class WalletImpl : public Wallet
     }
     bool backupWallet(const std::string& filename) override { return m_wallet.BackupWallet(filename); }
     std::string getWalletName() override { return m_wallet.GetName(); }
+    bool getKeyFromPool(bool internal, CPubKey& pub_key) override
+    {
+        return m_wallet.GetKeyFromPool(pub_key, internal);
+    }
     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; }
@@ -93,6 +97,10 @@ class WalletImpl : public Wallet
     {
         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);
@@ -108,6 +116,16 @@ class WalletImpl : public Wallet
         }
         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);
diff --git a/src/interface/wallet.h b/src/interface/wallet.h
@@ -6,6 +6,7 @@
 #define BITCOIN_INTERFACE_WALLET_H
 
 #include <amount.h>                    // For CAmount
+#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
@@ -30,6 +31,7 @@ namespace interface {
 
 class Handler;
 class PendingWalletTx;
+struct WalletAddress;
 struct WalletBalances;
 struct WalletTxOut;
 
@@ -67,6 +69,9 @@ class Wallet
     //! Get wallet name.
     virtual std::string getWalletName() = 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;
 
@@ -82,11 +87,21 @@ class Wallet
     //! 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;
 
@@ -216,6 +231,20 @@ class PendingWalletTx
         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 dest, isminetype is_mine, std::string name, std::string purpose)
+        : dest(std::move(dest)), is_mine(is_mine), name(std::move(name)), purpose(std::move(purpose))
+    {
+    }
+};
+
 //! Collection of wallet balances.
 struct WalletBalances
 {
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
@@ -7,6 +7,7 @@
 #include <qt/guiutil.h>
 #include <qt/walletmodel.h>
 
+#include <interface/node.h>
 #include <key_io.h>
 #include <wallet/wallet.h>
 
@@ -67,28 +68,23 @@ static AddressTableEntry::Type translateTransactionType(const QString &strPurpos
 class AddressTablePriv
 {
 public:
-    CWallet *wallet;
     QList<AddressTableEntry> cachedAddressTable;
     AddressTableModel *parent;
 
-    AddressTablePriv(CWallet *_wallet, AddressTableModel *_parent):
-        wallet(_wallet), parent(_parent) {}
+    AddressTablePriv(AddressTableModel *_parent):
+        parent(_parent) {}
 
-    void refreshAddressTable()
+    void refreshAddressTable(interface::Wallet& wallet)
     {
         cachedAddressTable.clear();
         {
-            LOCK(wallet->cs_wallet);
-            for (const std::pair<CTxDestination, CAddressBookData>& item : wallet->mapAddressBook)
+            for (const auto& address : wallet.getAddresses())
             {
-                const CTxDestination& address = item.first;
-                bool fMine = IsMine(*wallet, address);
                 AddressTableEntry::Type addressType = translateTransactionType(
-                        QString::fromStdString(item.second.purpose), fMine);
-                const std::string& strName = item.second.name;
+                        QString::fromStdString(address.purpose), address.is_mine);
                 cachedAddressTable.append(AddressTableEntry(addressType,
-                                  QString::fromStdString(strName),
-                                  QString::fromStdString(EncodeDestination(address))));
+                                  QString::fromStdString(address.name),
+                                  QString::fromStdString(EncodeDestination(address.dest))));
             }
         }
         // qLowerBound() and qUpperBound() require our cachedAddressTable list to be sorted in asc order
@@ -162,12 +158,12 @@ class AddressTablePriv
     }
 };
 
-AddressTableModel::AddressTableModel(CWallet *_wallet, WalletModel *parent) :
-    QAbstractTableModel(parent),walletModel(parent),wallet(_wallet),priv(0)
+AddressTableModel::AddressTableModel(WalletModel *parent) :
+    QAbstractTableModel(parent),walletModel(parent),priv(0)
 {
     columns << tr("Label") << tr("Address");
-    priv = new AddressTablePriv(wallet, this);
-    priv->refreshAddressTable();
+    priv = new AddressTablePriv(this);
+    priv->refreshAddressTable(parent->wallet());
 }
 
 AddressTableModel::~AddressTableModel()
@@ -244,7 +240,6 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
 
     if(role == Qt::EditRole)
     {
-        LOCK(wallet->cs_wallet); /* For SetAddressBook / DelAddressBook */
         CTxDestination curAddress = DecodeDestination(rec->address.toStdString());
         if(index.column() == Label)
         {
@@ -254,7 +249,7 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
                 editStatus = NO_CHANGES;
                 return false;
             }
-            wallet->SetAddressBook(curAddress, value.toString().toStdString(), strPurpose);
+            walletModel->wallet().setAddressBook(curAddress, value.toString().toStdString(), strPurpose);
         } else if(index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(value.toString().toStdString());
             // Refuse to set invalid address, set error status and return false
@@ -271,7 +266,7 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
             }
             // 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)
-            else if(wallet->mapAddressBook.count(newAddress))
+            if (walletModel->wallet().getAddress(newAddress))
             {
                 editStatus = DUPLICATE_ADDRESS;
                 return false;
@@ -280,9 +275,9 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
             else if(rec->type == AddressTableEntry::Sending)
             {
                 // Remove old entry
-                wallet->DelAddressBook(curAddress);
+                walletModel->wallet().delAddressBook(curAddress);
                 // Add new entry with new address
-                wallet->SetAddressBook(newAddress, rec->label.toStdString(), strPurpose);
+                walletModel->wallet().setAddressBook(newAddress, value.toString().toStdString(), strPurpose);
             }
         }
         return true;
@@ -356,8 +351,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
         }
         // Check for duplicate addresses
         {
-            LOCK(wallet->cs_wallet);
-            if(wallet->mapAddressBook.count(DecodeDestination(strAddress)))
+            if(walletModel->wallet().getAddress(DecodeDestination(strAddress)))
             {
                 editStatus = DUPLICATE_ADDRESS;
                 return QString();
@@ -368,7 +362,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
     {
         // Generate a new address to associate with given label
         CPubKey newKey;
-        if(!wallet->GetKeyFromPool(newKey))
+        if(!walletModel->wallet().getKeyFromPool(false /* internal */, newKey))
         {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if(!ctx.isValid())
@@ -377,13 +371,13 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
-            if(!wallet->GetKeyFromPool(newKey))
+            if(!walletModel->wallet().getKeyFromPool(false /* internal */, newKey))
             {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
-        wallet->LearnRelatedScripts(newKey, address_type);
+        walletModel->wallet().learnRelatedScripts(newKey, address_type);
         strAddress = EncodeDestination(GetDestinationForKey(newKey, address_type));
     }
     else
@@ -392,7 +386,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
     }
 
     // Add entry
-    wallet->SetAddressBook(DecodeDestination(strAddress), strLabel,
+    walletModel->wallet().setAddressBook(DecodeDestination(strAddress), strLabel,
                            (type == Send ? "send" : "receive"));
     return QString::fromStdString(strAddress);
 }
@@ -407,7 +401,7 @@ bool AddressTableModel::removeRows(int row, int count, const QModelIndex &parent
         // Also refuse to remove receiving addresses.
         return false;
     }
-    wallet->DelAddressBook(DecodeDestination(rec->address.toStdString()));
+    walletModel->wallet().delAddressBook(DecodeDestination(rec->address.toStdString()));
     return true;
 }
 
@@ -416,12 +410,11 @@ bool AddressTableModel::removeRows(int row, int count, const QModelIndex &parent
 QString AddressTableModel::labelForAddress(const QString &address) const
 {
     {
-        LOCK(wallet->cs_wallet);
         CTxDestination destination = DecodeDestination(address.toStdString());
-        std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(destination);
-        if (mi != wallet->mapAddressBook.end())
+        std::string name;
+        if (walletModel->wallet().getAddress(destination, &name))
         {
-            return QString::fromStdString(mi->second.name);
+            return QString::fromStdString(name);
         }
     }
     return QString();
@@ -441,7 +434,7 @@ int AddressTableModel::lookupAddress(const QString &address) const
     }
 }
 
-OutputType AddressTableModel::GetDefaultAddressType() const { return wallet->m_default_address_type; };
+OutputType AddressTableModel::GetDefaultAddressType() const { return walletModel->wallet().getDefaultAddressType(); };
 
 void AddressTableModel::emitDataChanged(int idx)
 {
diff --git a/src/qt/addresstablemodel.h b/src/qt/addresstablemodel.h
@@ -13,7 +13,9 @@ enum class OutputType;
 class AddressTablePriv;
 class WalletModel;
 
-class CWallet;
+namespace interface {
+class Wallet;
+}
 
 /**
    Qt model of the address book in the core. This allows views to access and modify the address book.
@@ -23,7 +25,7 @@ class AddressTableModel : public QAbstractTableModel
     Q_OBJECT
 
 public:
-    explicit AddressTableModel(CWallet *wallet, WalletModel *parent = 0);
+    explicit AddressTableModel(WalletModel *parent = 0);
     ~AddressTableModel();
 
     enum ColumnIndex {
@@ -80,7 +82,6 @@ class AddressTableModel : public QAbstractTableModel
 
 private:
     WalletModel *walletModel;
-    CWallet *wallet;
     AddressTablePriv *priv;
     QStringList columns;
     EditStatus editStatus;
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
@@ -49,7 +49,7 @@ WalletModel::WalletModel(std::unique_ptr<interface::Wallet> wallet, interface::N
     fHaveWatchOnly = m_wallet->haveWatchOnly();
     fForceCheckBalanceChanged = false;
 
-    addressTableModel = new AddressTableModel(cwallet, this);
+    addressTableModel = new AddressTableModel(this);
     transactionTableModel = new TransactionTableModel(platformStyle, cwallet, this);
     recentRequestsTableModel = new RecentRequestsTableModel(cwallet, this);
 

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,10 @@ class WalletImpl : public Wallet`
`85`	`85`	`}`
`86`	`86`	`bool backupWallet(const std::string& filename) override { return m_wallet.BackupWallet(filename); }`
`87`	`87`	`std::string getWalletName() override { return m_wallet.GetName(); }`
	`88`	`+ bool getKeyFromPool(bool internal, CPubKey& pub_key) override`
	`89`	`+ {`
	`90`	`+ return m_wallet.GetKeyFromPool(pub_key, internal);`
	`91`	`+ }`
`88`	`92`	`bool getPubKey(const CKeyID& address, CPubKey& pub_key) override { return m_wallet.GetPubKey(address, pub_key); }`
`89`	`93`	`bool getPrivKey(const CKeyID& address, CKey& key) override { return m_wallet.GetKey(address, key); }`
`90`	`94`	`bool isSpendable(const CTxDestination& dest) override { return IsMine(m_wallet, dest) & ISMINE_SPENDABLE; }`
`@@ -93,6 +97,10 @@ class WalletImpl : public Wallet`
`93`	`97`	`{`
`94`	`98`	`return m_wallet.SetAddressBook(dest, name, purpose);`
`95`	`99`	`}`
	`100`	`+ bool delAddressBook(const CTxDestination& dest) override`
	`101`	`+ {`
	`102`	`+ return m_wallet.DelAddressBook(dest);`
	`103`	`+ }`
`96`	`104`	`bool getAddress(const CTxDestination& dest, std::string* name, isminetype* is_mine) override`
`97`	`105`	`{`
`98`	`106`	`LOCK(m_wallet.cs_wallet);`
`@@ -108,6 +116,16 @@ class WalletImpl : public Wallet`
`108`	`116`	`}`
`109`	`117`	`return true;`
`110`	`118`	`}`
	`119`	`+ std::vector<WalletAddress> getAddresses() override`
	`120`	`+ {`
	`121`	`+ LOCK(m_wallet.cs_wallet);`
	`122`	`+ std::vector<WalletAddress> result;`
	`123`	`+ for (const auto& item : m_wallet.mapAddressBook) {`
	`124`	`+ result.emplace_back(item.first, IsMine(m_wallet, item.first), item.second.name, item.second.purpose);`
	`125`	`+ }`
	`126`	`+ return result;`
	`127`	`+ }`
	`128`	`+ void learnRelatedScripts(const CPubKey& key, OutputType type) override { m_wallet.LearnRelatedScripts(key, type); }`
`111`	`129`	`bool addDestData(const CTxDestination& dest, const std::string& key, const std::string& value) override`
`112`	`130`	`{`
`113`	`131`	`LOCK(m_wallet.cs_wallet);`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`#include <qt/guiutil.h>`
`8`	`8`	`#include <qt/walletmodel.h>`
`9`	`9`
	`10`	`+#include <interface/node.h>`
`10`	`11`	`#include <key_io.h>`
`11`	`12`	`#include <wallet/wallet.h>`
`12`	`13`
`@@ -67,28 +68,23 @@ static AddressTableEntry::Type translateTransactionType(const QString &strPurpos`
`67`	`68`	`class AddressTablePriv`
`68`	`69`	`{`
`69`	`70`	`public:`
`70`		`- CWallet *wallet;`
`71`	`71`	`QList<AddressTableEntry> cachedAddressTable;`
`72`	`72`	`AddressTableModel *parent;`
`73`	`73`
`74`		`- AddressTablePriv(CWallet _wallet, AddressTableModel _parent):`
`75`		`- wallet(_wallet), parent(_parent) {}`
	`74`	`+ AddressTablePriv(AddressTableModel *_parent):`
	`75`	`+ parent(_parent) {}`
`76`	`76`
`77`		`- void refreshAddressTable()`
	`77`	`+ void refreshAddressTable(interface::Wallet& wallet)`
`78`	`78`	`{`
`79`	`79`	`cachedAddressTable.clear();`
`80`	`80`	`{`
`81`		`- LOCK(wallet->cs_wallet);`
`82`		`- for (const std::pair<CTxDestination, CAddressBookData>& item : wallet->mapAddressBook)`
	`81`	`+ for (const auto& address : wallet.getAddresses())`
`83`	`82`	`{`
`84`		`- const CTxDestination& address = item.first;`
`85`		`- bool fMine = IsMine(*wallet, address);`
`86`	`83`	`AddressTableEntry::Type addressType = translateTransactionType(`
`87`		`- QString::fromStdString(item.second.purpose), fMine);`
`88`		`- const std::string& strName = item.second.name;`
	`84`	`+ QString::fromStdString(address.purpose), address.is_mine);`
`89`	`85`	`cachedAddressTable.append(AddressTableEntry(addressType,`
`90`		`- QString::fromStdString(strName),`
`91`		`- QString::fromStdString(EncodeDestination(address))));`
	`86`	`+ QString::fromStdString(address.name),`
	`87`	`+ QString::fromStdString(EncodeDestination(address.dest))));`
`92`	`88`	`}`
`93`	`89`	`}`
`94`	`90`	`// qLowerBound() and qUpperBound() require our cachedAddressTable list to be sorted in asc order`
`@@ -162,12 +158,12 @@ class AddressTablePriv`
`162`	`158`	`}`
`163`	`159`	`};`
`164`	`160`
`165`		`-AddressTableModel::AddressTableModel(CWallet _wallet, WalletModel parent) :`
`166`		`- QAbstractTableModel(parent),walletModel(parent),wallet(_wallet),priv(0)`
	`161`	`+AddressTableModel::AddressTableModel(WalletModel *parent) :`
	`162`	`+ QAbstractTableModel(parent),walletModel(parent),priv(0)`
`167`	`163`	`{`
`168`	`164`	`columns << tr("Label") << tr("Address");`
`169`		`- priv = new AddressTablePriv(wallet, this);`
`170`		`- priv->refreshAddressTable();`
	`165`	`+ priv = new AddressTablePriv(this);`
	`166`	`+ priv->refreshAddressTable(parent->wallet());`
`171`	`167`	`}`
`172`	`168`
`173`	`169`	`AddressTableModel::~AddressTableModel()`
`@@ -244,7 +240,6 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,`
`244`	`240`
`245`	`241`	`if(role == Qt::EditRole)`
`246`	`242`	`{`
`247`		`- LOCK(wallet->cs_wallet); /* For SetAddressBook / DelAddressBook */`
`248`	`243`	`CTxDestination curAddress = DecodeDestination(rec->address.toStdString());`
`249`	`244`	`if(index.column() == Label)`
`250`	`245`	`{`
`@@ -254,7 +249,7 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,`
`254`	`249`	`editStatus = NO_CHANGES;`
`255`	`250`	`return false;`
`256`	`251`	`}`
`257`		`- wallet->SetAddressBook(curAddress, value.toString().toStdString(), strPurpose);`
	`252`	`+ walletModel->wallet().setAddressBook(curAddress, value.toString().toStdString(), strPurpose);`
`258`	`253`	`} else if(index.column() == Address) {`
`259`	`254`	`CTxDestination newAddress = DecodeDestination(value.toString().toStdString());`
`260`	`255`	`// Refuse to set invalid address, set error status and return false`
`@@ -271,7 +266,7 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,`
`271`	`266`	`}`
`272`	`267`	`// Check for duplicate addresses to prevent accidental deletion of addresses, if you try`
`273`	`268`	`// to paste an existing address over another address (with a different label)`
`274`		`- else if(wallet->mapAddressBook.count(newAddress))`
	`269`	`+ if (walletModel->wallet().getAddress(newAddress))`
`275`	`270`	`{`
`276`	`271`	`editStatus = DUPLICATE_ADDRESS;`
`277`	`272`	`return false;`
`@@ -280,9 +275,9 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,`
`280`	`275`	`else if(rec->type == AddressTableEntry::Sending)`
`281`	`276`	`{`
`282`	`277`	`// Remove old entry`
`283`		`- wallet->DelAddressBook(curAddress);`
	`278`	`+ walletModel->wallet().delAddressBook(curAddress);`
`284`	`279`	`// Add new entry with new address`
`285`		`- wallet->SetAddressBook(newAddress, rec->label.toStdString(), strPurpose);`
	`280`	`+ walletModel->wallet().setAddressBook(newAddress, value.toString().toStdString(), strPurpose);`
`286`	`281`	`}`
`287`	`282`	`}`
`288`	`283`	`return true;`
`@@ -356,8 +351,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con`
`356`	`351`	`}`
`357`	`352`	`// Check for duplicate addresses`
`358`	`353`	`{`
`359`		`- LOCK(wallet->cs_wallet);`
`360`		`- if(wallet->mapAddressBook.count(DecodeDestination(strAddress)))`
	`354`	`+ if(walletModel->wallet().getAddress(DecodeDestination(strAddress)))`
`361`	`355`	`{`
`362`	`356`	`editStatus = DUPLICATE_ADDRESS;`
`363`	`357`	`return QString();`
`@@ -368,7 +362,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con`
`368`	`362`	`{`
`369`	`363`	`// Generate a new address to associate with given label`
`370`	`364`	`CPubKey newKey;`
`371`		`- if(!wallet->GetKeyFromPool(newKey))`
	`365`	`+ if(!walletModel->wallet().getKeyFromPool(false /* internal */, newKey))`
`372`	`366`	`{`
`373`	`367`	`WalletModel::UnlockContext ctx(walletModel->requestUnlock());`
`374`	`368`	`if(!ctx.isValid())`
`@@ -377,13 +371,13 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con`
`377`	`371`	`editStatus = WALLET_UNLOCK_FAILURE;`
`378`	`372`	`return QString();`
`379`	`373`	`}`
`380`		`- if(!wallet->GetKeyFromPool(newKey))`
	`374`	`+ if(!walletModel->wallet().getKeyFromPool(false /* internal */, newKey))`
`381`	`375`	`{`
`382`	`376`	`editStatus = KEY_GENERATION_FAILURE;`
`383`	`377`	`return QString();`
`384`	`378`	`}`
`385`	`379`	`}`
`386`		`- wallet->LearnRelatedScripts(newKey, address_type);`
	`380`	`+ walletModel->wallet().learnRelatedScripts(newKey, address_type);`
`387`	`381`	`strAddress = EncodeDestination(GetDestinationForKey(newKey, address_type));`
`388`	`382`	`}`
`389`	`383`	`else`
`@@ -392,7 +386,7 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con`
`392`	`386`	`}`
`393`	`387`
`394`	`388`	`// Add entry`
`395`		`- wallet->SetAddressBook(DecodeDestination(strAddress), strLabel,`
	`389`	`+ walletModel->wallet().setAddressBook(DecodeDestination(strAddress), strLabel,`
`396`	`390`	`(type == Send ? "send" : "receive"));`
`397`	`391`	`return QString::fromStdString(strAddress);`
`398`	`392`	`}`
`@@ -407,7 +401,7 @@ bool AddressTableModel::removeRows(int row, int count, const QModelIndex &parent`
`407`	`401`	`// Also refuse to remove receiving addresses.`
`408`	`402`	`return false;`
`409`	`403`	`}`
`410`		`- wallet->DelAddressBook(DecodeDestination(rec->address.toStdString()));`
	`404`	`+ walletModel->wallet().delAddressBook(DecodeDestination(rec->address.toStdString()));`
`411`	`405`	`return true;`
`412`	`406`	`}`
`413`	`407`
`@@ -416,12 +410,11 @@ bool AddressTableModel::removeRows(int row, int count, const QModelIndex &parent`
`416`	`410`	`QString AddressTableModel::labelForAddress(const QString &address) const`
`417`	`411`	`{`
`418`	`412`	`{`
`419`		`- LOCK(wallet->cs_wallet);`
`420`	`413`	`CTxDestination destination = DecodeDestination(address.toStdString());`
`421`		`- std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(destination);`
`422`		`- if (mi != wallet->mapAddressBook.end())`
	`414`	`+ std::string name;`
	`415`	`+ if (walletModel->wallet().getAddress(destination, &name))`
`423`	`416`	`{`
`424`		`- return QString::fromStdString(mi->second.name);`
	`417`	`+ return QString::fromStdString(name);`
`425`	`418`	`}`
`426`	`419`	`}`
`427`	`420`	`return QString();`
`@@ -441,7 +434,7 @@ int AddressTableModel::lookupAddress(const QString &address) const`
`441`	`434`	`}`
`442`	`435`	`}`
`443`	`436`
`444`		`-OutputType AddressTableModel::GetDefaultAddressType() const { return wallet->m_default_address_type; };`
	`437`	`+OutputType AddressTableModel::GetDefaultAddressType() const { return walletModel->wallet().getDefaultAddressType(); };`
`445`	`438`
`446`	`439`	`void AddressTableModel::emitDataChanged(int idx)`
`447`	`440`	`{`