src/wallet/wallet.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_WALLET_WALLET_H
   7 #define BITCOIN_WALLET_WALLET_H
   8
   9 #include "amount.h"
  10 #include "coins.h"
  11 #include "consensus/consensus.h"
  12 #include "key.h"
  13 #include "keystore.h"
  14 #include "primitives/block.h"
  15 #include "primitives/transaction.h"
  16 #include "tinyformat.h"
  17 #include "ui_interface.h"
  18 #include "utilstrencodings.h"
  19 #include "validationinterface.h"
  20 #include "wallet/crypter.h"
  21 #include "wallet/wallet_ismine.h"
  22 #include "wallet/walletdb.h"
  23 #include "zcash/Address.hpp"
  24 #include "base58.h"
  25
  26 #include <algorithm>
  27 #include <map>
  28 #include <set>
  29 #include <stdexcept>
  30 #include <stdint.h>
  31 #include <string>
  32 #include <utility>
  33 #include <vector>
  34
  35 /**
  36  * Settings
  37  */
  38 extern CFeeRate payTxFee;
  39 extern CAmount maxTxFee;
  40 extern unsigned int nTxConfirmTarget;
  41 extern bool bSpendZeroConfChange;
  42 extern bool fSendFreeTransactions;
  43 extern bool fPayAtLeastCustomFee;
  44
  45 //! -paytxfee default
  46 static const CAmount DEFAULT_TRANSACTION_FEE = 0;
  47 //! -paytxfee will warn if called with a higher fee than this amount (in satoshis) per KB
  48 static const CAmount nHighTransactionFeeWarning = 0.01 * COIN;
  49 //! -maxtxfee default
  50 static const CAmount DEFAULT_TRANSACTION_MAXFEE = 0.1 * COIN;
  51 //! -txconfirmtarget default
  52 static const unsigned int DEFAULT_TX_CONFIRM_TARGET = 2;
  53 //! -maxtxfee will warn if called with a higher fee than this amount (in satoshis)
  54 static const CAmount nHighTransactionMaxFeeWarning = 100 * nHighTransactionFeeWarning;
  55 //! Largest (in bytes) free transaction we're willing to create
  56 static const unsigned int MAX_FREE_TRANSACTION_CREATE_SIZE = 1000;
  57 //! Size of witness cache
  58 //  Should be large enough that we can expect not to reorg beyond our cache
  59 //  unless there is some exceptional network disruption.
  60 static const unsigned int WITNESS_CACHE_SIZE = COINBASE_MATURITY;
  61
  62 class CAccountingEntry;
  63 class CBlockIndex;
  64 class CCoinControl;
  65 class COutput;
  66 class CReserveKey;
  67 class CScript;
  68 class CTxMemPool;
  69 class CWalletTx;
  70
  71 /** (client) version numbers for particular wallet features */
  72 enum WalletFeature
  73 {
  74     FEATURE_BASE = 10500, // the earliest version new wallets supports (only useful for getinfo's clientversion output)
  75
  76     FEATURE_WALLETCRYPT = 40000, // wallet encryption
  77     FEATURE_COMPRPUBKEY = 60000, // compressed public keys
  78
  79     FEATURE_LATEST = 60000
  80 };
  81
  82
  83 /** A key pool entry */
  84 class CKeyPool
  85 {
  86 public:
  87     int64_t nTime;
  88     CPubKey vchPubKey;
  89
  90     CKeyPool();
  91     CKeyPool(const CPubKey& vchPubKeyIn);
  92
  93     ADD_SERIALIZE_METHODS;
  94
  95     template <typename Stream, typename Operation>
  96     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
  97         if (!(nType & SER_GETHASH))
  98             READWRITE(nVersion);
  99         READWRITE(nTime);
 100         READWRITE(vchPubKey);
 101     }
 102 };
 103
 104 /** Address book data */
 105 class CAddressBookData
 106 {
 107 public:
 108     std::string name;
 109     std::string purpose;
 110
 111     CAddressBookData()
 112     {
 113         purpose = "unknown";
 114     }
 115
 116     typedef std::map<std::string, std::string> StringMap;
 117     StringMap destdata;
 118 };
 119
 120 struct CRecipient
 121 {
 122     CScript scriptPubKey;
 123     CAmount nAmount;
 124     bool fSubtractFeeFromAmount;
 125 };
 126
 127 typedef std::map<std::string, std::string> mapValue_t;
 128
 129
 130 static void ReadOrderPos(int64_t& nOrderPos, mapValue_t& mapValue)
 131 {
 132     if (!mapValue.count("n"))
 133     {
 134         nOrderPos = -1; // TODO: calculate elsewhere
 135         return;
 136     }
 137     nOrderPos = atoi64(mapValue["n"].c_str());
 138 }
 139
 140
 141 static void WriteOrderPos(const int64_t& nOrderPos, mapValue_t& mapValue)
 142 {
 143     if (nOrderPos == -1)
 144         return;
 145     mapValue["n"] = i64tostr(nOrderPos);
 146 }
 147
 148 struct COutputEntry
 149 {
 150     CTxDestination destination;
 151     CAmount amount;
 152     int vout;
 153 };
 154
 155 /** An note outpoint */
 156 class JSOutPoint
 157 {
 158 public:
 159     // Transaction hash
 160     uint256 hash;
 161     // Index into CTransaction.vjoinsplit
 162     size_t js;
 163     // Index into JSDescription fields of length ZC_NUM_JS_OUTPUTS
 164     uint8_t n;
 165
 166     JSOutPoint() { SetNull(); }
 167     JSOutPoint(uint256 h, size_t js, uint8_t n) : hash {h}, js {js}, n {n} { }
 168
 169     ADD_SERIALIZE_METHODS;
 170
 171     template <typename Stream, typename Operation>
 172     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 173         READWRITE(hash);
 174         READWRITE(js);
 175         READWRITE(n);
 176     }
 177
 178     void SetNull() { hash.SetNull(); }
 179     bool IsNull() const { return hash.IsNull(); }
 180
 181     friend bool operator<(const JSOutPoint& a, const JSOutPoint& b) {
 182         return (a.hash < b.hash ||
 183                 (a.hash == b.hash && a.js < b.js) ||
 184                 (a.hash == b.hash && a.js == b.js && a.n < b.n));
 185     }
 186
 187     friend bool operator==(const JSOutPoint& a, const JSOutPoint& b) {
 188         return (a.hash == b.hash && a.js == b.js && a.n == b.n);
 189     }
 190
 191     friend bool operator!=(const JSOutPoint& a, const JSOutPoint& b) {
 192         return !(a == b);
 193     }
 194
 195     std::string ToString() const;
 196 };
 197
 198 class CNoteData
 199 {
 200 public:
 201     libzcash::PaymentAddress address;
 202
 203     // It's okay to cache the nullifier in the wallet, because we are storing
 204     // the spending key there too, which could be used to derive this.
 205     // If PR #1210 is merged, we need to revisit the threat model and decide
 206     // whether it is okay to store this unencrypted while the spending key is
 207     // encrypted.
 208     uint256 nullifier;
 209
 210     /**
 211      * Cached incremental witnesses for spendable Notes.
 212      * Beginning of the list is the most recent witness.
 213      */
 214     std::list<ZCIncrementalWitness> witnesses;
 215
 216     CNoteData() : address(), nullifier() { }
 217     CNoteData(libzcash::PaymentAddress a, uint256 n) : address {a}, nullifier {n} { }
 218
 219     ADD_SERIALIZE_METHODS;
 220
 221     template <typename Stream, typename Operation>
 222     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 223         READWRITE(address);
 224         READWRITE(nullifier);
 225         READWRITE(witnesses);
 226     }
 227
 228     friend bool operator<(const CNoteData& a, const CNoteData& b) {
 229         return (a.address < b.address ||
 230                 (a.address == b.address && a.nullifier < b.nullifier));
 231     }
 232
 233     friend bool operator==(const CNoteData& a, const CNoteData& b) {
 234         return (a.address == b.address && a.nullifier == b.nullifier);
 235     }
 236
 237     friend bool operator!=(const CNoteData& a, const CNoteData& b) {
 238         return !(a == b);
 239     }
 240 };
 241
 242 typedef std::map<JSOutPoint, CNoteData> mapNoteData_t;
 243
 244
 245 struct CNotePlaintextEntry
 246 {
 247     JSOutPoint jsop;
 248     libzcash::NotePlaintext plaintext;
 249 };
 250
 251
 252
 253 /** A transaction with a merkle branch linking it to the block chain. */
 254 class CMerkleTx : public CTransaction
 255 {
 256 private:
 257     int GetDepthInMainChainINTERNAL(const CBlockIndex* &pindexRet) const;
 258
 259 public:
 260     uint256 hashBlock;
 261     std::vector<uint256> vMerkleBranch;
 262     int nIndex;
 263
 264     // memory only
 265     mutable bool fMerkleVerified;
 266
 267
 268     CMerkleTx()
 269     {
 270         Init();
 271     }
 272
 273     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 274     {
 275         Init();
 276     }
 277
 278     void Init()
 279     {
 280         hashBlock = uint256();
 281         nIndex = -1;
 282         fMerkleVerified = false;
 283     }
 284
 285     ADD_SERIALIZE_METHODS;
 286
 287     template <typename Stream, typename Operation>
 288     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 289         READWRITE(*(CTransaction*)this);
 290         nVersion = this->nVersion;
 291         READWRITE(hashBlock);
 292         READWRITE(vMerkleBranch);
 293         READWRITE(nIndex);
 294     }
 295
 296     int SetMerkleBranch(const CBlock& block);
 297
 298
 299     /**
 300      * Return depth of transaction in blockchain:
 301      * -1  : not in blockchain, and not in memory pool (conflicted transaction)
 302      *  0  : in memory pool, waiting to be included in a block
 303      * >=1 : this many blocks deep in the main chain
 304      */
 305     int GetDepthInMainChain(const CBlockIndex* &pindexRet) const;
 306     int GetDepthInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 307     bool IsInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChainINTERNAL(pindexRet) > 0; }
 308     int GetBlocksToMaturity() const;
 309     bool AcceptToMemoryPool(bool fLimitFree=true, bool fRejectAbsurdFee=true);
 310 };
 311
 312 /**
 313  * A transaction with a bunch of additional info that only the owner cares about.
 314  * It includes any unrecorded transactions needed to link it back to the block chain.
 315  */
 316 class CWalletTx : public CMerkleTx
 317 {
 318 private:
 319     const CWallet* pwallet;
 320
 321 public:
 322     mapValue_t mapValue;
 323     mapNoteData_t mapNoteData;
 324     std::vector<std::pair<std::string, std::string> > vOrderForm;
 325     unsigned int fTimeReceivedIsTxTime;
 326     unsigned int nTimeReceived; //! time received by this node
 327     unsigned int nTimeSmart;
 328     char fFromMe;
 329     std::string strFromAccount;
 330     int64_t nOrderPos; //! position in ordered transaction list
 331
 332     // memory only
 333     mutable bool fDebitCached;
 334     mutable bool fCreditCached;
 335     mutable bool fImmatureCreditCached;
 336     mutable bool fAvailableCreditCached;
 337     mutable bool fWatchDebitCached;
 338     mutable bool fWatchCreditCached;
 339     mutable bool fImmatureWatchCreditCached;
 340     mutable bool fAvailableWatchCreditCached;
 341     mutable bool fChangeCached;
 342     mutable CAmount nDebitCached;
 343     mutable CAmount nCreditCached;
 344     mutable CAmount nImmatureCreditCached;
 345     mutable CAmount nAvailableCreditCached;
 346     mutable CAmount nWatchDebitCached;
 347     mutable CAmount nWatchCreditCached;
 348     mutable CAmount nImmatureWatchCreditCached;
 349     mutable CAmount nAvailableWatchCreditCached;
 350     mutable CAmount nChangeCached;
 351
 352     CWalletTx()
 353     {
 354         Init(NULL);
 355     }
 356
 357     CWalletTx(const CWallet* pwalletIn)
 358     {
 359         Init(pwalletIn);
 360     }
 361
 362     CWalletTx(const CWallet* pwalletIn, const CMerkleTx& txIn) : CMerkleTx(txIn)
 363     {
 364         Init(pwalletIn);
 365     }
 366
 367     CWalletTx(const CWallet* pwalletIn, const CTransaction& txIn) : CMerkleTx(txIn)
 368     {
 369         Init(pwalletIn);
 370     }
 371
 372     void Init(const CWallet* pwalletIn)
 373     {
 374         pwallet = pwalletIn;
 375         mapValue.clear();
 376         mapNoteData.clear();
 377         vOrderForm.clear();
 378         fTimeReceivedIsTxTime = false;
 379         nTimeReceived = 0;
 380         nTimeSmart = 0;
 381         fFromMe = false;
 382         strFromAccount.clear();
 383         fDebitCached = false;
 384         fCreditCached = false;
 385         fImmatureCreditCached = false;
 386         fAvailableCreditCached = false;
 387         fWatchDebitCached = false;
 388         fWatchCreditCached = false;
 389         fImmatureWatchCreditCached = false;
 390         fAvailableWatchCreditCached = false;
 391         fChangeCached = false;
 392         nDebitCached = 0;
 393         nCreditCached = 0;
 394         nImmatureCreditCached = 0;
 395         nAvailableCreditCached = 0;
 396         nWatchDebitCached = 0;
 397         nWatchCreditCached = 0;
 398         nAvailableWatchCreditCached = 0;
 399         nImmatureWatchCreditCached = 0;
 400         nChangeCached = 0;
 401         nOrderPos = -1;
 402     }
 403
 404     ADD_SERIALIZE_METHODS;
 405
 406     template <typename Stream, typename Operation>
 407     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 408         if (ser_action.ForRead())
 409             Init(NULL);
 410         char fSpent = false;
 411
 412         if (!ser_action.ForRead())
 413         {
 414             mapValue["fromaccount"] = strFromAccount;
 415
 416             WriteOrderPos(nOrderPos, mapValue);
 417
 418             if (nTimeSmart)
 419                 mapValue["timesmart"] = strprintf("%u", nTimeSmart);
 420         }
 421
 422         READWRITE(*(CMerkleTx*)this);
 423         std::vector<CMerkleTx> vUnused; //! Used to be vtxPrev
 424         READWRITE(vUnused);
 425         READWRITE(mapValue);
 426         READWRITE(mapNoteData);
 427         READWRITE(vOrderForm);
 428         READWRITE(fTimeReceivedIsTxTime);
 429         READWRITE(nTimeReceived);
 430         READWRITE(fFromMe);
 431         READWRITE(fSpent);
 432
 433         if (ser_action.ForRead())
 434         {
 435             strFromAccount = mapValue["fromaccount"];
 436
 437             ReadOrderPos(nOrderPos, mapValue);
 438
 439             nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(mapValue["timesmart"]) : 0;
 440         }
 441
 442         mapValue.erase("fromaccount");
 443         mapValue.erase("version");
 444         mapValue.erase("spent");
 445         mapValue.erase("n");
 446         mapValue.erase("timesmart");
 447     }
 448
 449     //! make sure balances are recalculated
 450     void MarkDirty()
 451     {
 452         fCreditCached = false;
 453         fAvailableCreditCached = false;
 454         fWatchDebitCached = false;
 455         fWatchCreditCached = false;
 456         fAvailableWatchCreditCached = false;
 457         fImmatureWatchCreditCached = false;
 458         fDebitCached = false;
 459         fChangeCached = false;
 460     }
 461
 462     void BindWallet(CWallet *pwalletIn)
 463     {
 464         pwallet = pwalletIn;
 465         MarkDirty();
 466     }
 467
 468     void SetNoteData(mapNoteData_t &noteData);
 469
 470     //! filter decides which addresses will count towards the debit
 471     CAmount GetDebit(const isminefilter& filter) const;
 472     CAmount GetCredit(const isminefilter& filter) const;
 473     CAmount GetImmatureCredit(bool fUseCache=true) const;
 474     CAmount GetAvailableCredit(bool fUseCache=true) const;
 475     CAmount GetImmatureWatchOnlyCredit(const bool& fUseCache=true) const;
 476     CAmount GetAvailableWatchOnlyCredit(const bool& fUseCache=true) const;
 477     CAmount GetChange() const;
 478
 479     void GetAmounts(std::list<COutputEntry>& listReceived,
 480                     std::list<COutputEntry>& listSent, CAmount& nFee, std::string& strSentAccount, const isminefilter& filter) const;
 481
 482     void GetAccountAmounts(const std::string& strAccount, CAmount& nReceived,
 483                            CAmount& nSent, CAmount& nFee, const isminefilter& filter) const;
 484
 485     bool IsFromMe(const isminefilter& filter) const
 486     {
 487         return (GetDebit(filter) > 0);
 488     }
 489
 490     bool IsTrusted() const;
 491
 492     bool WriteToDisk(CWalletDB *pwalletdb);
 493
 494     int64_t GetTxTime() const;
 495     int GetRequestCount() const;
 496
 497     bool RelayWalletTransaction();
 498
 499     std::set<uint256> GetConflicts() const;
 500 };
 501
 502
 503
 504
 505 class COutput
 506 {
 507 public:
 508     const CWalletTx *tx;
 509     int i;
 510     int nDepth;
 511     bool fSpendable;
 512
 513     COutput(const CWalletTx *txIn, int iIn, int nDepthIn, bool fSpendableIn)
 514     {
 515         tx = txIn; i = iIn; nDepth = nDepthIn; fSpendable = fSpendableIn;
 516     }
 517
 518     std::string ToString() const;
 519 };
 520
 521
 522
 523
 524 /** Private key that includes an expiration date in case it never gets used. */
 525 class CWalletKey
 526 {
 527 public:
 528     CPrivKey vchPrivKey;
 529     int64_t nTimeCreated;
 530     int64_t nTimeExpires;
 531     std::string strComment;
 532     //! todo: add something to note what created it (user, getnewaddress, change)
 533     //!   maybe should have a map<string, string> property map
 534
 535     CWalletKey(int64_t nExpires=0);
 536
 537     ADD_SERIALIZE_METHODS;
 538
 539     template <typename Stream, typename Operation>
 540     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 541         if (!(nType & SER_GETHASH))
 542             READWRITE(nVersion);
 543         READWRITE(vchPrivKey);
 544         READWRITE(nTimeCreated);
 545         READWRITE(nTimeExpires);
 546         READWRITE(LIMITED_STRING(strComment, 65536));
 547     }
 548 };
 549
 550
 551
 552 /**
 553  * A CWallet is an extension of a keystore, which also maintains a set of transactions and balances,
 554  * and provides the ability to create new transactions.
 555  */
 556 class CWallet : public CCryptoKeyStore, public CValidationInterface
 557 {
 558 private:
 559     bool SelectCoins(const CAmount& nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl *coinControl = NULL) const;
 560
 561     CWalletDB *pwalletdbEncryption;
 562
 563     //! the current wallet version: clients below this version are not able to load the wallet
 564     int nWalletVersion;
 565
 566     //! the maximum wallet format version: memory-only variable that specifies to what version this wallet may be upgraded
 567     int nWalletMaxVersion;
 568
 569     int64_t nNextResend;
 570     int64_t nLastResend;
 571     bool fBroadcastTransactions;
 572
 573     template <class T>
 574     using TxSpendMap = std::multimap<T, uint256>;
 575     /**
 576      * Used to keep track of spent outpoints, and
 577      * detect and report conflicts (double-spends or
 578      * mutated transactions where the mutant gets mined).
 579      */
 580     typedef TxSpendMap<COutPoint> TxSpends;
 581     TxSpends mapTxSpends;
 582     /**
 583      * Used to keep track of spent Notes, and
 584      * detect and report conflicts (double-spends).
 585      */
 586     typedef TxSpendMap<uint256> TxNullifiers;
 587     TxNullifiers mapTxNullifiers;
 588
 589     void AddToSpends(const COutPoint& outpoint, const uint256& wtxid);
 590     void AddToSpends(const uint256& nullifier, const uint256& wtxid);
 591     void AddToSpends(const uint256& wtxid);
 592
 593 public:
 594     /*
 595      * Size of the incremental witness cache for the notes in our wallet.
 596      * This will always be greater than or equal to the size of the largest
 597      * incremental witness cache in any transaction in mapWallet.
 598      */
 599     int64_t nWitnessCacheSize;
 600
 601     void ClearNoteWitnessCache();
 602
 603 protected:
 604     void IncrementNoteWitnesses(const CBlockIndex* pindex,
 605                                 const CBlock* pblock,
 606                                 ZCIncrementalMerkleTree tree);
 607     void DecrementNoteWitnesses();
 608     void WriteWitnessCache();
 609
 610 private:
 611     template <class T>
 612     void SyncMetaData(std::pair<typename TxSpendMap<T>::iterator, typename TxSpendMap<T>::iterator>);
 613
 614 protected:
 615     bool UpdatedNoteData(const CWalletTx& wtxIn, CWalletTx& wtx);
 616     void MarkAffectedTransactionsDirty(const CTransaction& tx);
 617
 618 public:
 619     /*
 620      * Main wallet lock.
 621      * This lock protects all the fields added by CWallet
 622      *   except for:
 623      *      fFileBacked (immutable after instantiation)
 624      *      strWalletFile (immutable after instantiation)
 625      */
 626     mutable CCriticalSection cs_wallet;
 627
 628     bool fFileBacked;
 629     std::string strWalletFile;
 630
 631     std::set<int64_t> setKeyPool;
 632     std::map<CKeyID, CKeyMetadata> mapKeyMetadata;
 633     std::map<libzcash::PaymentAddress, CKeyMetadata> mapZKeyMetadata;
 634
 635     typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
 636     MasterKeyMap mapMasterKeys;
 637     unsigned int nMasterKeyMaxID;
 638
 639     CWallet()
 640     {
 641         SetNull();
 642     }
 643
 644     CWallet(std::string strWalletFileIn)
 645     {
 646         SetNull();
 647
 648         strWalletFile = strWalletFileIn;
 649         fFileBacked = true;
 650     }
 651
 652     ~CWallet()
 653     {
 654         delete pwalletdbEncryption;
 655         pwalletdbEncryption = NULL;
 656     }
 657
 658     void SetNull()
 659     {
 660         nWalletVersion = FEATURE_BASE;
 661         nWalletMaxVersion = FEATURE_BASE;
 662         fFileBacked = false;
 663         nMasterKeyMaxID = 0;
 664         pwalletdbEncryption = NULL;
 665         nOrderPosNext = 0;
 666         nNextResend = 0;
 667         nLastResend = 0;
 668         nTimeFirstKey = 0;
 669         fBroadcastTransactions = false;
 670         nWitnessCacheSize = 0;
 671     }
 672
 673     std::map<uint256, JSOutPoint> mapNullifiersToNotes;
 674     std::map<uint256, CWalletTx> mapWallet;
 675
 676     int64_t nOrderPosNext;
 677     std::map<uint256, int> mapRequestCount;
 678
 679     std::map<CTxDestination, CAddressBookData> mapAddressBook;
 680
 681     CPubKey vchDefaultKey;
 682
 683     std::set<COutPoint> setLockedCoins;
 684
 685     int64_t nTimeFirstKey;
 686
 687     const CWalletTx* GetWalletTx(const uint256& hash) const;
 688
 689     //! check whether we are allowed to upgrade (or already support) to the named feature
 690     bool CanSupportFeature(enum WalletFeature wf) { AssertLockHeld(cs_wallet); return nWalletMaxVersion >= wf; }
 691
 692     void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl = NULL, bool fIncludeZeroValue=false) const;
 693     bool SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet) const;
 694
 695     bool IsSpent(const uint256& hash, unsigned int n) const;
 696     bool IsSpent(const uint256& nullifier) const;
 697
 698     bool IsLockedCoin(uint256 hash, unsigned int n) const;
 699     void LockCoin(COutPoint& output);
 700     void UnlockCoin(COutPoint& output);
 701     void UnlockAllCoins();
 702     void ListLockedCoins(std::vector<COutPoint>& vOutpts);
 703
 704     /**
 705      * keystore implementation
 706      * Generate a new key
 707      */
 708     CPubKey GenerateNewKey();
 709     //! Adds a key to the store, and saves it to disk.
 710     bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);
 711     //! Adds a key to the store, without saving it to disk (used by LoadWallet)
 712     bool LoadKey(const CKey& key, const CPubKey &pubkey) { return CCryptoKeyStore::AddKeyPubKey(key, pubkey); }
 713     //! Load metadata (used by LoadWallet)
 714     bool LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &metadata);
 715
 716     bool LoadMinVersion(int nVersion) { AssertLockHeld(cs_wallet); nWalletVersion = nVersion; nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion); return true; }
 717
 718     //! Adds an encrypted key to the store, and saves it to disk.
 719     bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
 720     //! Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
 721     bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
 722     bool AddCScript(const CScript& redeemScript);
 723     bool LoadCScript(const CScript& redeemScript);
 724
 725     //! Adds a destination data tuple to the store, and saves it to disk
 726     bool AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value);
 727     //! Erases a destination data tuple in the store and on disk
 728     bool EraseDestData(const CTxDestination &dest, const std::string &key);
 729     //! Adds a destination data tuple to the store, without saving it to disk
 730     bool LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value);
 731     //! Look up a destination data tuple in the store, return true if found false otherwise
 732     bool GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const;
 733
 734     //! Adds a watch-only address to the store, and saves it to disk.
 735     bool AddWatchOnly(const CScript &dest);
 736     bool RemoveWatchOnly(const CScript &dest);
 737     //! Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
 738     bool LoadWatchOnly(const CScript &dest);
 739
 740     bool Unlock(const SecureString& strWalletPassphrase);
 741     bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
 742     bool EncryptWallet(const SecureString& strWalletPassphrase);
 743
 744     void GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const;
 745
 746     /**
 747       * ZKeys
 748       */
 749     //! Generates a new zaddr
 750     CZCPaymentAddress GenerateNewZKey();
 751     //! Adds spending key to the store, and saves it to disk
 752     bool AddZKey(const libzcash::SpendingKey &key);
 753     //! Adds spending key to the store, without saving it to disk (used by LoadWallet)
 754     bool LoadZKey(const libzcash::SpendingKey &key);
 755     //! Load spending key metadata (used by LoadWallet)
 756     bool LoadZKeyMetadata(const libzcash::PaymentAddress &addr, const CKeyMetadata &meta);
 757     //! Adds an encrypted spending key to the store, without saving it to disk (used by LoadWallet)
 758     bool LoadCryptedZKey(const libzcash::PaymentAddress &addr, const libzcash::ViewingKey &vk, const std::vector<unsigned char> &vchCryptedSecret);
 759     //! Adds an encrypted spending key to the store, and saves it to disk (virtual method, declared in crypter.h)
 760     bool AddCryptedSpendingKey(const libzcash::PaymentAddress &address, const libzcash::ViewingKey &vk, const std::vector<unsigned char> &vchCryptedSecret);
 761
 762     /**
 763      * Increment the next transaction order id
 764      * @return next transaction order id
 765      */
 766     int64_t IncOrderPosNext(CWalletDB *pwalletdb = NULL);
 767
 768     typedef std::pair<CWalletTx*, CAccountingEntry*> TxPair;
 769     typedef std::multimap<int64_t, TxPair > TxItems;
 770
 771     /**
 772      * Get the wallet's activity log
 773      * @return multimap of ordered transactions and accounting entries
 774      * @warning Returned pointers are *only* valid within the scope of passed acentries
 775      */
 776     TxItems OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount = "");
 777
 778     void MarkDirty();
 779     void UpdateNullifierNoteMap(const CWalletTx& wtx);
 780     bool AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet, CWalletDB* pwalletdb);
 781     void SyncTransaction(const CTransaction& tx, const CBlock* pblock);
 782     bool AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate);
 783     void EraseFromWallet(const uint256 &hash);
 784     void WitnessNoteCommitment(
 785          std::vector<uint256> commitments,
 786          std::vector<boost::optional<ZCIncrementalWitness>>& witnesses,
 787          uint256 &final_anchor);
 788     int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
 789     void ReacceptWalletTransactions();
 790     void ResendWalletTransactions(int64_t nBestBlockTime);
 791     std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime);
 792     CAmount GetBalance() const;
 793     CAmount GetUnconfirmedBalance() const;
 794     CAmount GetImmatureBalance() const;
 795     CAmount GetWatchOnlyBalance() const;
 796     CAmount GetUnconfirmedWatchOnlyBalance() const;
 797     CAmount GetImmatureWatchOnlyBalance() const;
 798     bool CreateTransaction(const std::vector<CRecipient>& vecSend,
 799                            CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRet, int& nChangePosRet, std::string& strFailReason, const CCoinControl *coinControl = NULL);
 800     bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey);
 801
 802     static CFeeRate minTxFee;
 803     static CAmount GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool& pool);
 804
 805     bool NewKeyPool();
 806     bool TopUpKeyPool(unsigned int kpSize = 0);
 807     void ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool);
 808     void KeepKey(int64_t nIndex);
 809     void ReturnKey(int64_t nIndex);
 810     bool GetKeyFromPool(CPubKey &key);
 811     int64_t GetOldestKeyPoolTime();
 812     void GetAllReserveKeys(std::set<CKeyID>& setAddress) const;
 813
 814     std::set< std::set<CTxDestination> > GetAddressGroupings();
 815     std::map<CTxDestination, CAmount> GetAddressBalances();
 816
 817     std::set<CTxDestination> GetAccountAddresses(std::string strAccount) const;
 818
 819     mapNoteData_t FindMyNotes(const CTransaction& tx) const;
 820     bool IsFromMe(const uint256& nullifier) const;
 821     void GetNoteWitnesses(
 822          std::vector<JSOutPoint> notes,
 823          std::vector<boost::optional<ZCIncrementalWitness>>& witnesses,
 824          uint256 &final_anchor);
 825
 826     isminetype IsMine(const CTxIn& txin) const;
 827     CAmount GetDebit(const CTxIn& txin, const isminefilter& filter) const;
 828     isminetype IsMine(const CTxOut& txout) const;
 829     CAmount GetCredit(const CTxOut& txout, const isminefilter& filter) const;
 830     bool IsChange(const CTxOut& txout) const;
 831     CAmount GetChange(const CTxOut& txout) const;
 832     bool IsMine(const CTransaction& tx) const;
 833     /** should probably be renamed to IsRelevantToMe */
 834     bool IsFromMe(const CTransaction& tx) const;
 835     CAmount GetDebit(const CTransaction& tx, const isminefilter& filter) const;
 836     CAmount GetCredit(const CTransaction& tx, const isminefilter& filter) const;
 837     CAmount GetChange(const CTransaction& tx) const;
 838     void ChainTip(const CBlockIndex *pindex, const CBlock *pblock, ZCIncrementalMerkleTree tree, bool added);
 839     void SetBestChain(const CBlockLocator& loc);
 840
 841     DBErrors LoadWallet(bool& fFirstRunRet);
 842     DBErrors ZapWalletTx(std::vector<CWalletTx>& vWtx);
 843
 844     bool SetAddressBook(const CTxDestination& address, const std::string& strName, const std::string& purpose);
 845
 846     bool DelAddressBook(const CTxDestination& address);
 847
 848     void UpdatedTransaction(const uint256 &hashTx);
 849
 850     void Inventory(const uint256 &hash)
 851     {
 852         {
 853             LOCK(cs_wallet);
 854             std::map<uint256, int>::iterator mi = mapRequestCount.find(hash);
 855             if (mi != mapRequestCount.end())
 856                 (*mi).second++;
 857         }
 858     }
 859
 860     unsigned int GetKeyPoolSize()
 861     {
 862         AssertLockHeld(cs_wallet); // setKeyPool
 863         return setKeyPool.size();
 864     }
 865
 866     bool SetDefaultKey(const CPubKey &vchPubKey);
 867
 868     //! signify that a particular wallet feature is now used. this may change nWalletVersion and nWalletMaxVersion if those are lower
 869     bool SetMinVersion(enum WalletFeature, CWalletDB* pwalletdbIn = NULL, bool fExplicit = false);
 870
 871     //! change which version we're allowed to upgrade to (note that this does not immediately imply upgrading to that format)
 872     bool SetMaxVersion(int nVersion);
 873
 874     //! get the current wallet format (the oldest client version guaranteed to understand this wallet)
 875     int GetVersion() { LOCK(cs_wallet); return nWalletVersion; }
 876
 877     //! Get wallet transactions that conflict with given transaction (spend same outputs)
 878     std::set<uint256> GetConflicts(const uint256& txid) const;
 879
 880     //! Flush wallet (bitdb flush)
 881     void Flush(bool shutdown=false);
 882
 883     //! Verify the wallet database and perform salvage if required
 884     static bool Verify(const std::string& walletFile, std::string& warningString, std::string& errorString);
 885
 886     /**
 887      * Address book entry changed.
 888      * @note called with lock cs_wallet held.
 889      */
 890     boost::signals2::signal<void (CWallet *wallet, const CTxDestination
 891             &address, const std::string &label, bool isMine,
 892             const std::string &purpose,
 893             ChangeType status)> NotifyAddressBookChanged;
 894
 895     /**
 896      * Wallet transaction added, removed or updated.
 897      * @note called with lock cs_wallet held.
 898      */
 899     boost::signals2::signal<void (CWallet *wallet, const uint256 &hashTx,
 900             ChangeType status)> NotifyTransactionChanged;
 901
 902     /** Show progress e.g. for rescan */
 903     boost::signals2::signal<void (const std::string &title, int nProgress)> ShowProgress;
 904
 905     /** Watch-only address added */
 906     boost::signals2::signal<void (bool fHaveWatchOnly)> NotifyWatchonlyChanged;
 907
 908     /** Inquire whether this wallet broadcasts transactions. */
 909     bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
 910     /** Set whether this wallet broadcasts transactions. */
 911     void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions = broadcast; }
 912
 913     /* Find notes filtered by payment address, min depth, ability to spend */
 914     bool GetFilteredNotes(std::vector<CNotePlaintextEntry> & outEntries, std::string address, int minDepth=1, bool ignoreSpent=true);
 915
 916 };
 917
 918 /** A key allocated from the key pool. */
 919 class CReserveKey
 920 {
 921 protected:
 922     CWallet* pwallet;
 923     int64_t nIndex;
 924     CPubKey vchPubKey;
 925 public:
 926     CReserveKey(CWallet* pwalletIn)
 927     {
 928         nIndex = -1;
 929         pwallet = pwalletIn;
 930     }
 931
 932     ~CReserveKey()
 933     {
 934         ReturnKey();
 935     }
 936
 937     void ReturnKey();
 938     bool GetReservedKey(CPubKey &pubkey);
 939     void KeepKey();
 940 };
 941
 942
 943 /**
 944  * Account information.
 945  * Stored in wallet with key "acc"+string account name.
 946  */
 947 class CAccount
 948 {
 949 public:
 950     CPubKey vchPubKey;
 951
 952     CAccount()
 953     {
 954         SetNull();
 955     }
 956
 957     void SetNull()
 958     {
 959         vchPubKey = CPubKey();
 960     }
 961
 962     ADD_SERIALIZE_METHODS;
 963
 964     template <typename Stream, typename Operation>
 965     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 966         if (!(nType & SER_GETHASH))
 967             READWRITE(nVersion);
 968         READWRITE(vchPubKey);
 969     }
 970 };
 971
 972
 973
 974 /**
 975  * Internal transfers.
 976  * Database key is acentry<account><counter>.
 977  */
 978 class CAccountingEntry
 979 {
 980 public:
 981     std::string strAccount;
 982     CAmount nCreditDebit;
 983     int64_t nTime;
 984     std::string strOtherAccount;
 985     std::string strComment;
 986     mapValue_t mapValue;
 987     int64_t nOrderPos;  //! position in ordered transaction list
 988     uint64_t nEntryNo;
 989
 990     CAccountingEntry()
 991     {
 992         SetNull();
 993     }
 994
 995     void SetNull()
 996     {
 997         nCreditDebit = 0;
 998         nTime = 0;
 999         strAccount.clear();
1000         strOtherAccount.clear();
1001         strComment.clear();
1002         nOrderPos = -1;
1003         nEntryNo = 0;
1004     }
1005
1006     ADD_SERIALIZE_METHODS;
1007
1008     template <typename Stream, typename Operation>
1009     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
1010         if (!(nType & SER_GETHASH))
1011             READWRITE(nVersion);
1012         //! Note: strAccount is serialized as part of the key, not here.
1013         READWRITE(nCreditDebit);
1014         READWRITE(nTime);
1015         READWRITE(LIMITED_STRING(strOtherAccount, 65536));
1016
1017         if (!ser_action.ForRead())
1018         {
1019             WriteOrderPos(nOrderPos, mapValue);
1020
1021             if (!(mapValue.empty() && _ssExtra.empty()))
1022             {
1023                 CDataStream ss(nType, nVersion);
1024                 ss.insert(ss.begin(), '\0');
1025                 ss << mapValue;
1026                 ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end());
1027                 strComment.append(ss.str());
1028             }
1029         }
1030
1031         READWRITE(LIMITED_STRING(strComment, 65536));
1032
1033         size_t nSepPos = strComment.find("\0", 0, 1);
1034         if (ser_action.ForRead())
1035         {
1036             mapValue.clear();
1037             if (std::string::npos != nSepPos)
1038             {
1039                 CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion);
1040                 ss >> mapValue;
1041                 _ssExtra = std::vector<char>(ss.begin(), ss.end());
1042             }
1043             ReadOrderPos(nOrderPos, mapValue);
1044         }
1045         if (std::string::npos != nSepPos)
1046             strComment.erase(nSepPos);
1047
1048         mapValue.erase("n");
1049     }
1050
1051 private:
1052     std::vector<char> _ssExtra;
1053 };
1054
1055 #endif // BITCOIN_WALLET_WALLET_H