transaction.cpp

// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2020 The Bitcoin Core developers
// Copyright (c) 2014-2024 The Reddcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <consensus/validation.h>
#include <index/txindex.h>
#include <net.h>
#include <net_processing.h>
#include <node/blockstorage.h>
#include <node/context.h>
#include <txmempool.h>
#include <validation.h>
#include <validationinterface.h>
#include <node/transaction.h>
#include <coins.h>
#include <chainparams.h>
#include <index/disktxpos.h>
#include <logging.h>

#include <future>

static TransactionError HandleATMPError(const TxValidationState& state, std::string& err_string_out)
{
    err_string_out = state.ToString();
    if (state.IsInvalid()) {
        if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
            return TransactionError::MISSING_INPUTS;
        }
        return TransactionError::MEMPOOL_REJECTED;
    } else {
        return TransactionError::MEMPOOL_ERROR;
    }
}

TransactionError BroadcastTransaction(NodeContext& node, const CTransactionRef tx, std::string& err_string, const CAmount& max_tx_fee, bool relay, bool wait_callback)
{
    // BroadcastTransaction can be called by either sendrawtransaction RPC or the wallet.
    // chainman, mempool and peerman are initialized before the RPC server and wallet are started
    // and reset after the RPC sever and wallet are stopped.
    assert(node.chainman);
    assert(node.mempool);
    assert(node.peerman);

    std::promise<void> promise;
    uint256 txid = tx->GetHash();
    uint256 wtxid = tx->GetWitnessHash();
    bool callback_set = false;

    {
        LOCK(cs_main);

        // If the transaction is already confirmed in the chain, don't do anything
        // and return early.
        CCoinsViewCache &view = node.chainman->ActiveChainstate().CoinsTip();
        for (size_t o = 0; o < tx->vout.size(); o++) {
            const Coin& existingCoin = view.AccessCoin(COutPoint(txid, o));
            // IsSpent doesn't mean the coin is spent, it means the output doesn't exist.
            // So if the output does exist, then this transaction exists in the chain.
            if (!existingCoin.IsSpent()) return TransactionError::ALREADY_IN_CHAIN;
        }

        if (auto mempool_tx = node.mempool->get(txid); mempool_tx) {
            // There's already a transaction in the mempool with this txid. Don't
            // try to submit this transaction to the mempool (since it'll be
            // rejected as a TX_CONFLICT), but do attempt to reannounce the mempool
            // transaction if relay=true.
            //
            // The mempool transaction may have the same or different witness (and
            // wtxid) as this transaction. Use the mempool's wtxid for reannouncement.
            wtxid = mempool_tx->GetWitnessHash();
        } else {
            // Transaction is not already in the mempool.
            if (max_tx_fee > 0) {
                // First, call ATMP with test_accept and check the fee. If ATMP
                // fails here, return error immediately.
                const MempoolAcceptResult result = AcceptToMemoryPool(node.chainman->ActiveChainstate(), *node.mempool, tx, false /* bypass_limits */,
                                                                      true /* test_accept */);
                if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
                    return HandleATMPError(result.m_state, err_string);
                } else if (result.m_base_fees.value() > max_tx_fee) {
                    return TransactionError::MAX_FEE_EXCEEDED;
                }
            }
            // Try to submit the transaction to the mempool.
            const MempoolAcceptResult result = AcceptToMemoryPool(node.chainman->ActiveChainstate(), *node.mempool, tx, false /* bypass_limits */,
                                                                  false /* test_accept */);
            if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
                return HandleATMPError(result.m_state, err_string);
            }

            // Transaction was accepted to the mempool.

            if (relay) {
                // the mempool tracks locally submitted transactions to make a
                // best-effort of initial broadcast
                node.mempool->AddUnbroadcastTx(txid);
            }

            if (wait_callback) {
                // For transactions broadcast from outside the wallet, make sure
                // that the wallet has been notified of the transaction before
                // continuing.
                //
                // This prevents a race where a user might call sendrawtransaction
                // with a transaction to/from their wallet, immediately call some
                // wallet RPC, and get a stale result because callbacks have not
                // yet been processed.
                CallFunctionInValidationInterfaceQueue([&promise] {
                    promise.set_value();
                });
                callback_set = true;
            }
        }
    } // cs_main

    if (callback_set) {
        // Wait until Validation Interface clients have been notified of the
        // transaction entering the mempool.
        promise.get_future().wait();
    }

    if (relay) {
        node.peerman->RelayTransaction(txid, wtxid);
    }

    return TransactionError::OK;
}

CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock)
{
    LOCK(cs_main);

    if (mempool && !block_index) {
        CTransactionRef ptx = mempool->get(hash);
        if (ptx) return ptx;
    }
    if (g_txindex) {
        CTransactionRef tx;
        uint256 block_hash;
        if (g_txindex->FindTx(hash, block_hash, tx)) {
            if (!block_index || block_index->GetBlockHash() == block_hash) {
                // Don't return the transaction if the provided block hash doesn't match.
                // The case where a transaction appears in multiple blocks (e.g. reorgs or
                // BIP30) is handled by the block lookup below.
                hashBlock = block_hash;
                return tx;
            }
        }
    }
    if (block_index) {
        CBlock block;
        if (ReadBlockFromDisk(block, block_index, consensusParams)) {
            for (const auto& tx : block.vtx) {
                if (tx->GetHash() == hash) {
                    hashBlock = block_index->GetBlockHash();
                    return tx;
                }
            }
        }
    }
    return nullptr;
}

CTransactionRef GetTransaction(const uint256& txhash, uint256& hashBlock)
{
    if (g_txindex) {
        CTransactionRef tx;
        uint256 block_hash;
        if (g_txindex->FindTx(txhash, block_hash, tx)) {
            hashBlock = block_hash;
            return tx;
        }
    }

    return nullptr;
}

CTransactionRef GetTransaction(const uint256& txhash)
{
    if (g_txindex) {
        CDiskTxPos postx;
        if (g_txindex->FindTxPosition(txhash, postx)) {
            // Read block header
            CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
            CBlockHeader header;
            CTransactionRef tx;
            try {
                file >> header;
                fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
                file >> tx;
                return tx;
            } catch (std::exception& e) {
                return nullptr;
            }
        }
    }

    return nullptr;
}

bool GetTransaction(CChainState* active_chainstate, const COutPoint& prevout,
                    CTransactionRef& txOut, CBlockHeader& blockHeader, unsigned int& nTxOffset)
{
    // During reindex, skip txindex as it may contain stale data
    // Always use UTXO fallback during reindex to ensure correct validation
    const bool fSkipTxIndex = fReindex.load();

    // Try txindex first if available and not reindexing (fast path)
    if (g_txindex && !fSkipTxIndex) {
        CDiskTxPos postx;
        if (g_txindex->FindTxPosition(prevout.hash, postx)) {
            CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
            if (!file.IsNull()) {
                try {
                    file >> blockHeader;
                    fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
                    file >> txOut;
                    nTxOffset = postx.nTxOffset;
                    return true;
                } catch (const std::exception& e) {
                    // Fall through to UTXO lookup
                }
            }
        }
    }

    // Fallback: use UTXO set + block reading (works during reindex without txindex)
    if (!active_chainstate) {
        LogPrint(BCLog::POS, "%s: no active chainstate available\n", __func__);
        return false;
    }

    LOCK(cs_main);

    // Get the coin from UTXO set
    const Coin& coin = active_chainstate->CoinsTip().AccessCoin(prevout);
    if (coin.IsSpent()) {
        LogPrint(BCLog::POS, "%s: prevout %s already spent\n", __func__, prevout.ToString());
        return false;
    }

    // Get the block index at the height where the coin was created
    CBlockIndex* pindex = active_chainstate->m_chain[coin.nHeight];
    if (!pindex) {
        LogPrint(BCLog::POS, "%s: block at height %d not found in chain\n", __func__, coin.nHeight);
        return false;
    }

    // Read block header and transaction directly from disk (same as txindex does)
    // This ensures we get the exact same serialized data that txindex would provide
    CAutoFile file(OpenBlockFile(pindex->GetBlockPos(), true), SER_DISK, CLIENT_VERSION);
    if (file.IsNull()) {
        return error("%s: failed to open block file for %s", __func__, prevout.hash.ToString());
    }

    try {
        file >> blockHeader;  // Read header directly from disk
    } catch (const std::exception& e) {
        return error("%s: failed to read block header: %s", __func__, e.what());
    }

    // Now we need to read the full block to find our transaction and calculate offset
    CBlock block;
    if (!ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
        LogPrint(BCLog::POS, "%s: failed to read block %s from disk\n", __func__, pindex->GetBlockHash().ToString());
        return false;
    }

    // Find the transaction in the block and calculate its offset
    // The offset must match exactly what txindex stores: offset from after block header to the transaction
    // Offset = CompactSize(vtx.size()) + sum of sizes of all transactions before target

    // Start with CompactSize of transaction count
    CDataStream ssSize(SER_DISK, CLIENT_VERSION);
    WriteCompactSize(ssSize, block.vtx.size());
    unsigned int currentOffset = ssSize.size();

    for (size_t i = 0; i < block.vtx.size(); i++) {
        if (block.vtx[i]->GetHash() == prevout.hash) {
            nTxOffset = currentOffset;

            // Read transaction from file using calculated offset (same as txindex does)
            // Seek to the transaction offset from current position (after header)
            if (fseek(file.Get(), nTxOffset, SEEK_CUR) != 0) {
                return error("%s: failed to seek to offset %u for tx %s", __func__, nTxOffset, prevout.hash.ToString());
            }

            try {
                file >> txOut;  // Read transaction directly from file
            } catch (const std::exception& e) {
                return error("%s: failed to read transaction from file: %s", __func__, e.what());
            }

            return true;
        }

        // Add this transaction's size to offset for next iteration
        currentOffset += ::GetSerializeSize(*block.vtx[i], CLIENT_VERSION);
    }

    return error("%s: transaction %s not found in block %s", __func__, prevout.hash.ToString(), pindex->GetBlockHash().ToString());
}