Wallet transaction states and stored metadata

251        const Txid& canonical_txid = GetHash();
252        for (const auto& [wtxid, tx] : variants) {
253            if (tx->GetHash() != canonical_txid) throw std::runtime_error("variant txid does not match wallet txid");
254        }
255        // Merge witness variants
256        m_txs.insert(variants.begin(), variants.end());
257        Assert(m_txs.contains(GetWitnessHash()));
258    }
259
260    TxState m_state;
261
262    // Set of mempool transactions that conflict
263    // directly with the transaction, or that conflict
264    // with an ancestor transaction. This set will be
265    // empty if state is InMempool or Confirmed, but
266    // can be nonempty if state is Inactive or
267    // BlockConflicted.
268    std::set<Txid> mempool_conflicts;
269
270    // Track v3 mempool tx that spends from this tx
271    // so that we don't try to create another unconfirmed child
272    std::optional<Txid> truc_child_in_mempool;
273
274    template<typename Stream>
275    void Serialize(Stream& s) const
276    {
277        std::map<std::string, std::string> string_values;
278        if (m_from) string_values["from"] = *m_from;
279        if (m_message) string_values["message"] = *m_message;
280        if (m_comment) string_values["comment"] = *m_comment;
281        if (m_comment_to) string_values["to"] = *m_comment_to;
282        if (m_replaces_txid) string_values["replaces_txid"] = m_replaces_txid->ToString();
283        if (m_replaced_by_txid) string_values["replaced_by_txid"] = m_replaced_by_txid->ToString();
284        string_values["fromaccount"] = "";
285        if (nOrderPos != -1) string_values["n"] = util::ToString(nOrderPos);
286        if (nTimeSmart) string_values["timesmart"] = strprintf("%u", nTimeSmart);
287
288        std::vector<std::pair<std::string, std::string>> msgs_reqs;
289        msgs_reqs.reserve(m_messages.size() + m_payment_requests.size());
290        for (const std::string& msg : m_messages) {
291            msgs_reqs.emplace_back("Message", msg);
292        }
293        for (const std::string& req : m_payment_requests) {
294            msgs_reqs.emplace_back("PaymentRequest", req);
295        }
296
297        std::vector<uint8_t> dummy_vector1; // Used to be vMerkleBranch
298        std::vector<uint8_t> dummy_vector2; // Used to be vtxPrev
299        bool dummy_bool = false; // Used to be fFromMe, and fSpent
300        uint32_t dummy_int = 0; // Used to be fTimeReceivedIsTxTime
301        uint256 serializedHash = TxStateSerializedBlockHash(m_state);
302        int serializedIndex = TxStateSerializedIndex(m_state);
303        s << TX_WITH_WITNESS(GetTx()) << serializedHash << dummy_vector1 << serializedIndex << dummy_vector2 << string_values << msgs_reqs << dummy_int << nTimeReceived << dummy_bool << dummy_bool;
304    }
305
306    template<typename Stream>
307    void Unserialize(Stream& s)
308    {
309        Init();
310
311        std::vector<uint256> dummy_vector1; // Used to be vMerkleBranch
312        std::vector<CMerkleTx> dummy_vector2; // Used to be vtxPrev
313        bool dummy_bool; // Used to be fFromMe, and fSpent
314        uint32_t dummy_int; // Used to be fTimeReceivedIsTxTime
315        uint256 serialized_block_hash;
316        int serializedIndex;
317        std::map<std::string, std::string> string_values;
318        std::vector<std::pair<std::string, std::string>> msgs_reqs;
319        CTransactionRef canonical_tx;
320        s >> TX_WITH_WITNESS(canonical_tx) >> serialized_block_hash >> dummy_vector1 >> serializedIndex >> dummy_vector2 >> string_values >> msgs_reqs >> dummy_int >> nTimeReceived >> dummy_bool >> dummy_bool;
321        m_canonical_wtxid = canonical_tx->GetWitnessHash();
322        m_txs.emplace(m_canonical_wtxid, std::move(canonical_tx));
323
324        m_state = TxStateInterpretSerialized({serialized_block_hash, serializedIndex});
325
326        string_values.erase("fromaccount");
327        string_values.erase("spent");
328        for (const auto& [key, value] : string_values) {
329            if (key == "n") nOrderPos = LocaleIndependentAtoi<int64_t>(value);
330            else if (key == "timesmart") nTimeSmart = LocaleIndependentAtoi<int64_t>(value);
331            else if (key == "from") m_from = value;
332            else if (key == "message") m_message = value;
333            else if (key == "comment") m_comment = value;
334            else if (key == "to") m_comment_to = value;
335            else if (key == "replaces_txid") m_replaces_txid = Txid::FromHex(value);
336            else if (key == "replaced_by_txid") m_replaced_by_txid = Txid::FromHex(value);
337            else {
338                throw std::runtime_error("Unexpected value in CWalletTx strings value map");
339            }
340        }
341
342        for (const auto& [type, data] : msgs_reqs) {
343            if (type == "Message") m_messages.emplace_back(data);
344            else if (type == "PaymentRequest") m_payment_requests.emplace_back(data);
345            else {
346                throw std::runtime_error("Unknown type in CWalletTx messages and requests vector");
347            }
348        }
349    }
350
351    CTransactionRef GetTx() const { return m_txs.at(m_canonical_wtxid); }
352
353    // Update the state of this wallet transaction along with a transaction that may have a different wtxid.
354    // If the given transaction has a different wtxid, the transaction is stored if it has not been seen before.
355    // The canonical wtxid is also updated. The tx that is confirmed becomes canonical. For unconfirmed txs,
356    // those with witnesses are preferred, followed by least weight.
357    bool Update(CTransactionRef tx, const TxState& new_state, WalletBatch& batch, bool metadata_changed);
358
359    //! make sure balances are recalculated
360    void MarkDirty()
361    {
362        m_amounts[DEBIT].Reset();
363        m_amounts[CREDIT].Reset();
364        fChangeCached = false;
365        m_is_cache_empty = true;
366        m_cached_from_me = std::nullopt;
367    }
368
369    /** True if tx is a malleation of this, i.e. it has the exact same version, locktime,
370     * input order, input outpoints, input sequences, and outputs. Input scriptSigs and input scriptWitnesses may differ. */
371    bool IsMalleation(const CWalletTx& tx) const;
372
373    bool InMempool() const;
374
375    int64_t GetTxTime() const;
376
377    template<typename T> const T* state() const { return std::get_if<T>(&m_state); }
378    template<typename T> T* state() { return std::get_if<T>(&m_state); }
379
380    //! Update transaction state when attaching to a chain, filling in heights
381    //! of conflicted and confirmed blocks
382    void updateState(interfaces::Chain& chain);
383
384    bool isAbandoned() const { return state<TxStateInactive>() && state<TxStateInactive>()->abandoned; }
385    bool isMempoolConflicted() const { return !mempool_conflicts.empty(); }
386    bool isBlockConflicted() const { return state<TxStateBlockConflicted>(); }
387    bool isInactive() const { return state<TxStateInactive>(); }
388    bool isUnconfirmed() const { return !isAbandoned() && !isBlockConflicted() && !isMempoolConflicted() && !isConfirmed(); }
389    bool isConfirmed() const { return state<TxStateConfirmed>(); }
390    const Txid& GetHash() const LIFETIMEBOUND { return GetTx()->GetHash(); }
391    const Wtxid& GetWitnessHash() const LIFETIMEBOUND { return GetTx()->GetWitnessHash(); }
392    bool IsCoinBase() const { return GetTx()->IsCoinBase(); }
393
394    const std::map<Wtxid, CTransactionRef>& GetTxs() const { return m_txs; }
395
396    // Disable copying of CWalletTx objects to prevent bugs where instances get
397    // copied in and out of the mapWallet map, and fields are updated in the
398    // wrong copy.
399    CWalletTx(const CWalletTx&) = delete;
400    CWalletTx& operator=(const CWalletTx&) = delete;
401
402    // Enable the default move constructor
403    CWalletTx(CWalletTx&&) = default;
404
405private:
406    void SetDefaults()
407    {
408        nTimeReceived = 0;
409        nTimeSmart = 0;
410        fChangeCached = false;
411        nChangeCached = 0;
412        nOrderPos = -1;
413    }
414
415    void Init()
416    {
417        m_txs.clear();
418        m_canonical_wtxid = Wtxid{};
419        SetDefaults();
420    }
421
422    Wtxid m_canonical_wtxid;
423    std::map<Wtxid, CTransactionRef> m_txs;
424
425    //! Set m_canonical_wtxid to the best variant under the unconfirmed rule
426    //! (witnessed preferred, then least weight). Ignores state.
427    void RecomputeCanonical();
428};
429
430struct WalletTxOrderComparator {
431    bool operator()(const CWalletTx* a, const CWalletTx* b) const
432    {
433        return a->nOrderPos < b->nOrderPos;
434    }
435};
436
437class WalletTXO
438{
439private:
440    const CWalletTx& m_wtx;
441    const CTxOut& m_output;
442
443public:
444    WalletTXO(const CWalletTx& wtx, const CTxOut& output)
445    : m_wtx(wtx),
446    m_output(output)
447    {
448        Assume(std::ranges::find(wtx.GetTx()->vout, output) != wtx.GetTx()->vout.end());
449    }
450
451    const CWalletTx& GetWalletTx() const { return m_wtx; }
452
453    const CTxOut& GetTxOut() const { return m_output; }
454};
455} // namespace wallet
456
457#endif // BITCOIN_WALLET_TRANSACTION_H
458