cachedEncryptionStatus(Unencrypted),
cachedNumBlocks(0)
{
+ fHaveWatchOnly = wallet->HaveWatchOnly();
+
addressTableModel = new AddressTableModel(wallet, this);
mintingTableModel = new MintingTableModel(wallet, this);
transactionTableModel = new TransactionTableModel(wallet, this);
unsubscribeFromCoreSignals();
}
+bool WalletModel::haveWatchOnly() const
+{
+ return fHaveWatchOnly;
+}
+
qint64 WalletModel::getBalance() const
{
return wallet->GetBalance();
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;
- scriptPubKey.SetDestination(CBitcoinAddress(rcp.address.toStdString()).Get());
+ scriptPubKey.SetAddress(CBitcoinAddress(rcp.address.toStdString()));
vecSend.push_back(make_pair(scriptPubKey, rcp.amount));
}
CWalletTx wtx;
CReserveKey keyChange(wallet);
- int64 nFeeRequired = 0;
+ int64_t nFeeRequired = 0;
bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, coinControl);
if(!fCreated)
foreach(const SendCoinsRecipient &rcp, recipients)
{
std::string strAddress = rcp.address.toStdString();
- CTxDestination dest = CBitcoinAddress(strAddress).Get();
+ CBitcoinAddress addr(strAddress);
std::string strLabel = rcp.label.toStdString();
{
LOCK(wallet->cs_wallet);
- std::map<CTxDestination, std::string>::iterator mi = wallet->mapAddressBook.find(dest);
+ std::map<CBitcoinAddress, std::string>::iterator mi = wallet->mapAddressBook.find(addr);
// Check if we have a new address or an updated label
if (mi == wallet->mapAddressBook.end() || mi->second != strLabel)
{
- wallet->SetAddressBookName(dest, strLabel);
+ wallet->SetAddressBookName(addr, strLabel);
}
}
}
}
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);
}
QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
}
-static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *wallet, const CTxDestination &address, const std::string &label, bool isMine, ChangeType status)
+static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *wallet, const CBitcoinAddress &address, const std::string &label, bool isMine, ChangeType status)
{
- OutputDebugStringF("NotifyAddressBookChanged %s %s isMine=%i status=%i\n", CBitcoinAddress(address).ToString().c_str(), label.c_str(), isMine, status);
+ OutputDebugStringF("NotifyAddressBookChanged %s %s isMine=%i status=%i\n", address.ToString().c_str(), label.c_str(), isMine, status);
QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
- Q_ARG(QString, QString::fromStdString(CBitcoinAddress(address).ToString())),
+ Q_ARG(QString, QString::fromStdString(address.ToString())),
Q_ARG(QString, QString::fromStdString(label)),
Q_ARG(bool, isMine),
Q_ARG(int, status));
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)
cout = COutput(&wallet->mapWallet[cout.tx->vin[0].prevout.hash], cout.tx->vin[0].prevout.n, 0, true);
}
- CTxDestination address;
- if(!out.fSpendable || !ExtractDestination(cout.tx->vout[cout.i].scriptPubKey, address))
+ CBitcoinAddress addressRet;
+ if(!out.fSpendable || !ExtractAddress(*wallet, cout.tx->vout[cout.i].scriptPubKey, addressRet))
continue;
- mapCoins[CBitcoinAddress(address).ToString().c_str()].push_back(out);
+
+ mapCoins[addressRet.ToString().c_str()].push_back(out);
}
}
{
return;
}
+
+void WalletModel::clearOrphans()
+{
+ wallet->ClearOrphans();
+}
+
+CWallet* WalletModel::getWallet()
+{
+ return wallet;
+}