The wallet state and lifecycle

751    for (auto it = begin; it != end; ++it) {
752        auto entry = mapWallet.find(it->second);
753        if (!Assume(entry != mapWallet.end())) continue; // sanity-check: mapTxSpends has txs that are in mapWallet
754        const bool is_self = &entry->second == &wtx;
755        found_self |= is_self;
756        if (is_self || wtx.IsMalleation(entry->second)) {
757            Assume(txs.insert(&entry->second).second);
758        }
759    }
760    // wtx should always be found as this function is always called after AddToSpends
761    Assert(found_self);
762    return txs;
763}
764
765void CWallet::SyncMalleatedTxMetadata(WalletBatch& batch, const CWalletTx& wtx)
766{
767    const auto txs = GetMalleatedVariants(wtx);
768    if (txs.size() <= 1) return; // no variants, nothing to do
769
770    // First tx is the oldest one (smallest nOrderPos)
771    const CWalletTx* copyFrom = *txs.begin();
772
773    // The metadata that is kept in sync between malleated variants.
774    // nTimeReceived, nOrderPos and cached members are not copied on purpose.
775    const auto metadata = [](auto& tx) {
776        return std::tie(tx.m_from, tx.m_message, tx.m_comment, tx.m_comment_to,
777                        tx.m_replaces_txid, tx.m_replaced_by_txid,
778                        tx.m_messages, tx.m_payment_requests, tx.nTimeSmart);
779    };
780
781    // Now copy data from copyFrom to rest:
782    for (CWalletTx* copyTo : txs) {
783        if (copyTo == copyFrom) continue;
784        metadata(*copyTo) = metadata(*copyFrom);
785        (void)batch.WriteTxMetadata(*copyTo);
786    }
787}
788
789/**
790 * Outpoint is spent if any non-conflicted transaction
791 * spends it:
792 */
793bool CWallet::IsSpent(const COutPoint& outpoint) const
794{
795    std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
796    range = mapTxSpends.equal_range(outpoint);
797
798    for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
799        const Txid& txid = it->second;
800        const auto mit = mapWallet.find(txid);
801        if (mit != mapWallet.end()) {
802            const auto& wtx = mit->second;
803            if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted())
804                return true; // Spent
805        }
806    }
807    return false;
808}
809
810CWallet::SpendType CWallet::HowSpent(const COutPoint& outpoint) const
811{
812    SpendType st{SpendType::UNSPENT};
813
814    std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
815    range = mapTxSpends.equal_range(outpoint);
816
817    for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
818        const Txid& txid = it->second;
819        const auto mit = mapWallet.find(txid);
820        if (mit != mapWallet.end()) {
821            const auto& wtx = mit->second;
822            if (wtx.isConfirmed()) return SpendType::CONFIRMED;
823            if (wtx.InMempool()) {
824                st = SpendType::MEMPOOL;
825            } else if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted()) {
826                if (st == SpendType::UNSPENT) st = SpendType::NONMEMPOOL;
827            }
828        }
829    }
830    return st;
831}
832
833void CWallet::AddToSpends(const COutPoint& outpoint, const Txid& txid)
834{
835    mapTxSpends.insert(std::make_pair(outpoint, txid));
836
837    UnlockCoin(outpoint);
838}
839
840
841void CWallet::AddToSpends(const CWalletTx& wtx)
842{
843    if (wtx.IsCoinBase()) // Coinbases don't spend anything!
844        return;
845
846    for (const CTxIn& txin : wtx.GetTx()->vin)
847        AddToSpends(txin.prevout, wtx.GetHash());
848}
849
850bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
851{
852    // Only descriptor wallets can be encrypted
853    Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
854
855    if (HasEncryptionKeys())
856        return false;
857
858    CKeyingMaterial plain_master_key;
859
860    plain_master_key.resize(WALLET_CRYPTO_KEY_SIZE);
861    GetStrongRandBytes(plain_master_key);
862
863    CMasterKey master_key;
864
865    master_key.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
866    GetStrongRandBytes(master_key.vchSalt);
867
868    if (!EncryptMasterKey(strWalletPassphrase, plain_master_key, master_key)) {
869        return false;
870    }
871    WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", master_key.nDeriveIterations);
872
873    {
874        LOCK2(m_relock_mutex, cs_wallet);
875        mapMasterKeys[++nMasterKeyMaxID] = master_key;
876        WalletBatch* encrypted_batch = new WalletBatch(GetDatabase());
877        if (!encrypted_batch->TxnBegin()) {
878            delete encrypted_batch;
879            encrypted_batch = nullptr;
880            return false;
881        }
882        encrypted_batch->WriteMasterKey(nMasterKeyMaxID, master_key);
883
884        for (const auto& spk_man_pair : m_spk_managers) {
885            auto spk_man = spk_man_pair.second.get();
886            if (!spk_man->Encrypt(plain_master_key, encrypted_batch)) {
887                encrypted_batch->TxnAbort();
888                delete encrypted_batch;
889                encrypted_batch = nullptr;
890                // We now probably have half of our keys encrypted in memory, and half not...
891                // die and let the user reload the unencrypted wallet.
892                assert(false);
893            }
894        }
895
896        if (!encrypted_batch->TxnCommit()) {
897            delete encrypted_batch;
898            encrypted_batch = nullptr;
899            // We now have keys encrypted in memory, but not on disk...
900            // die to avoid confusion and let the user reload the unencrypted wallet.
901            assert(false);
902        }
903
904        delete encrypted_batch;
905        encrypted_batch = nullptr;
906
907        Lock();
908        if (!Unlock(strWalletPassphrase)) {
909            return false;
910        }
911
912        SetupWalletGeneration();
913
914        Lock();
915
916        // Need to completely rewrite the wallet file; if we don't, the database might keep
917        // bits of the unencrypted private key in slack space in the database file.
918        GetDatabase().Rewrite();
919    }
920    NotifyStatusChanged(this);
921
922    return true;
923}
924
925DBErrors CWallet::ReorderTransactions()
926{
927    LOCK(cs_wallet);
928    WalletBatch batch(GetDatabase());
929
930    // Old wallets didn't have any defined order for transactions
931    // Probably a bad idea to change the output of this
932
933    // First: get all CWalletTx into a sorted-by-time multimap.
934    typedef std::multimap<int64_t, CWalletTx*> TxItems;
935    TxItems txByTime;
936
937    for (auto& entry : mapWallet)
938    {
939        CWalletTx* wtx = &entry.second;
940        txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
941    }
942
943    nOrderPosNext = 0;
944    std::vector<int64_t> nOrderPosOffsets;
945    for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
946    {
947        CWalletTx *const pwtx = (*it).second;
948        int64_t& nOrderPos = pwtx->nOrderPos;
949
950        if (nOrderPos == -1)
951        {
952            nOrderPos = nOrderPosNext++;
953            nOrderPosOffsets.push_back(nOrderPos);
954
955            if (!batch.WriteTxMetadata(*pwtx))
956                return DBErrors::LOAD_FAIL;
957        }
958        else
959        {
960            int64_t nOrderPosOff = 0;
961            for (const int64_t& nOffsetStart : nOrderPosOffsets)
962            {
963                if (nOrderPos >= nOffsetStart)
964                    ++nOrderPosOff;
965            }
966            nOrderPos += nOrderPosOff;
967            nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
968
969            if (!nOrderPosOff)
970                continue;
971
972            // Since we're changing the order, write it back
973            if (!batch.WriteTxMetadata(*pwtx))
974                return DBErrors::LOAD_FAIL;
975        }
976    }
977    batch.WriteOrderPosNext(nOrderPosNext);
978
979    return DBErrors::LOAD_OK;
980}
981
982int64_t CWallet::IncOrderPosNext(WalletBatch* batch)
983{
984    AssertLockHeld(cs_wallet);
985    int64_t nRet = nOrderPosNext++;
986    if (batch) {
987        batch->WriteOrderPosNext(nOrderPosNext);
988    } else {
989        WalletBatch(GetDatabase()).WriteOrderPosNext(nOrderPosNext);
990    }
991    return nRet;
992}
993
994void CWallet::MarkDirty()
995{
996    {
997        LOCK(cs_wallet);
998        for (auto& [_, wtx] : mapWallet)
999            wtx.MarkDirty();
1000    }