#include "guiconstants.h"
#include "optionsmodel.h"
#include "addresstablemodel.h"
+#include "mintingtablemodel.h"
#include "transactiontablemodel.h"
#include "ui_interface.h"
cachedEncryptionStatus(Unencrypted),
cachedNumBlocks(0)
{
+ fHaveWatchOnly = wallet->HaveWatchOnly();
+
addressTableModel = new AddressTableModel(wallet, this);
+ mintingTableModel = new MintingTableModel(wallet, this);
transactionTableModel = new TransactionTableModel(wallet, this);
// This timer will be fired repeatedly to update the balance
unsubscribeFromCoreSignals();
}
+bool WalletModel::haveWatchOnly() const
+{
+ return fHaveWatchOnly;
+}
+
qint64 WalletModel::getBalance() const
{
return wallet->GetBalance();
qint64 WalletModel::getBalanceWatchOnly() const
{
- return wallet->GetBalanceWatchOnly();
+ return wallet->GetWatchOnlyBalance();
}
qint64 WalletModel::getUnconfirmedBalance() const
int numTransactions = 0;
{
LOCK(wallet->cs_wallet);
- numTransactions = wallet->mapWallet.size();
+ numTransactions = (int)(wallet->mapWallet.size());
}
return numTransactions;
}
addressTableModel->updateEntry(address, label, isMine, status);
}
+void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly)
+{
+ fHaveWatchOnly = fHaveWatchonly;
+ emit notifyWatchonlyChanged(fHaveWatchonly);
+}
+
bool WalletModel::validateAddress(const QString &address)
{
CBitcoinAddress addressParsed(address.toStdString());
return DuplicateAddress;
}
- int64 nBalance = 0;
+ int64_t nBalance = 0;
std::vector<COutput> vCoins;
wallet->AvailableCoins(vCoins, true, coinControl);
LOCK2(cs_main, wallet->cs_wallet);
// Sendmany
- std::vector<std::pair<CScript, int64> > vecSend;
+ std::vector<std::pair<CScript, int64_t> > vecSend;
foreach(const SendCoinsRecipient &rcp, recipients)
{
CScript scriptPubKey;
CWalletTx wtx;
CReserveKey keyChange(wallet);
- int64 nFeeRequired = 0;
+ int64_t nFeeRequired = 0;
bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, coinControl);
if(!fCreated)
return addressTableModel;
}
+MintingTableModel *WalletModel::getMintingTableModel()
+{
+ return mintingTableModel;
+}
+
TransactionTableModel *WalletModel::getTransactionTableModel()
{
return transactionTableModel;
}
else
{
- // Decrypt -- TODO; not supported yet
- return false;
+ // Decrypt
+ return wallet->DecryptWallet(passphrase);
}
}
return retval;
}
-void WalletModel::getStakeWeight(uint64& nMinWeight, uint64& nMaxWeight, uint64& nWeight)
-{
- wallet->GetStakeWeight(*wallet, nMinWeight, nMaxWeight, nWeight);
-}
-
-void WalletModel::getStakeWeightFromValue(const int64& nTime, const int64& nValue, uint64& nWeight)
+void WalletModel::getStakeWeightFromValue(const int64_t& nTime, const int64_t& nValue, uint64_t& nWeight)
{
wallet->GetStakeWeightFromValue(nTime, nValue, nWeight);
}
Q_ARG(int, status));
}
+static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
+{
+ QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
+ Q_ARG(bool, fHaveWatchonly));
+}
+
void WalletModel::subscribeToCoreSignals()
{
// Connect signals to wallet
wallet->NotifyStatusChanged.connect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
wallet->NotifyAddressBookChanged.connect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5));
wallet->NotifyTransactionChanged.connect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
+ wallet->NotifyWatchonlyChanged.connect(boost::bind(NotifyWatchonlyChanged, this, _1));
}
void WalletModel::unsubscribeFromCoreSignals()
wallet->NotifyStatusChanged.disconnect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
wallet->NotifyAddressBookChanged.disconnect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5));
wallet->NotifyTransactionChanged.disconnect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
+ wallet->NotifyWatchonlyChanged.disconnect(boost::bind(NotifyWatchonlyChanged, this, _1));
}
// WalletModel::UnlockContext implementation
WalletModel::UnlockContext WalletModel::requestUnlock()
{
bool was_locked = getEncryptionStatus() == Locked;
-
+ bool mintflag = fWalletUnlockMintOnly;
+
if ((!was_locked) && fWalletUnlockMintOnly)
{
- setWalletLocked(true);
- was_locked = getEncryptionStatus() == Locked;
-
+ setWalletLocked(true);
+ was_locked = getEncryptionStatus() == Locked;
}
if(was_locked)
{
// If wallet is still locked, unlock was failed or cancelled, mark context as invalid
bool valid = getEncryptionStatus() != Locked;
- return UnlockContext(this, valid, was_locked && !fWalletUnlockMintOnly);
+ return UnlockContext(this, valid, was_locked, mintflag);
}
-WalletModel::UnlockContext::UnlockContext(WalletModel *wallet, bool valid, bool relock):
+WalletModel::UnlockContext::UnlockContext(WalletModel *wallet, bool valid, bool relock, bool mintflag):
wallet(wallet),
valid(valid),
- relock(relock)
+ relock(relock),
+ mintflag(mintflag)
{
}
{
if(valid && relock)
{
+ if (mintflag)
+ {
+ // Restore unlock minting flag
+ fWalletUnlockMintOnly = mintflag;
+ return;
+ }
wallet->setWalletLocked(true);
+
}
}
bool WalletModel::getPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
{
- return wallet->GetPubKey(address, vchPubKeyOut);
+ return wallet->GetPubKey(address, vchPubKeyOut);
}
// returns a list of COutputs from COutPoints
{
if (!wallet->mapWallet.count(outpoint.hash)) continue;
COutput out(&wallet->mapWallet[outpoint.hash], outpoint.n, wallet->mapWallet[outpoint.hash].GetDepthInMainChain(), true);
- vCoins.push_back(out);
+ if (outpoint.n < out.tx->vout.size() && wallet->IsMine(out.tx->vout[outpoint.n]) == MINE_SPENDABLE)
+ vCoins.push_back(out);
}
BOOST_FOREACH(const COutput& out, vCoins)
{
return;
}
+
+void WalletModel::clearOrphans()
+{
+ wallet->ClearOrphans();
+}
+
+CWallet* WalletModel::getWallet()
+{
+ return wallet;
+}
\ No newline at end of file