From 2eeeaf0e6491ef9111541441ab4fb9950038abf5 Mon Sep 17 00:00:00 2001
From: JohnnyLawDGB <johnnylaw2021@protonmail.com>
Date: Sun, 12 Apr 2026 07:03:37 -0500
Subject: [PATCH] fix: resolve DD amounts from mempool for chained transfers
 (Bug #35)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The DD conservation validator could not determine input DD amounts when
the creating transaction was still in the mempool (unconfirmed). All
three existing lookup strategies fail for mempool txs:
  1. txindex — only indexes confirmed blocks
  2. block-db — tx not in any block yet
  3. scriptPubKey metadata — P2TR scripts don't encode DD amounts

This caused back-to-back DD transfers to fail with
"transfer-dd-conservation-violation" because the second transfer's
input (the first transfer's change output) had its DD amount silently
dropped from the conservation sum.

Add mempool transaction lookup as strategy 0 (before txindex). Mempool
txs have already passed full validation so their OP_RETURN is
trustworthy. Pass the mempool pointer via ValidationContext from
MemPoolAccept::PreChecks, where it is naturally available.

Applied to both the transfer conservation check and the redemption DD
input extraction paths.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/digidollar/validation.cpp | 36 +++++++++++++++++++++++++++++++++++
 src/digidollar/validation.h   |  7 +++++--
 src/validation.cpp            |  3 ++-
 3 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/src/digidollar/validation.cpp b/src/digidollar/validation.cpp
index 2c7f6ebd49..85bac7f956 100644
--- a/src/digidollar/validation.cpp
+++ b/src/digidollar/validation.cpp
@@ -15,6 +15,7 @@ using DigiDollar::GetScriptMetadata;
 #include <consensus/dca.h>
 #include <consensus/err.h>
 #include <index/txindex.h>  // For decentralized DD amount lookup via g_txindex
+#include <txmempool.h>      // For mempool DD amount lookup (Bug #35)
 #include <script/standard.h>
 #include <script/solver.h>
 #include <script/interpreter.h>
@@ -329,6 +330,30 @@ static bool ExtractDDAmountFromTxRef(const CTransactionRef& prev_tx, const COutP
     return false;
 }
 
+/**
+ * Extract DD amount from a transaction in the mempool (Bug #35).
+ * Mempool txs have already passed full validation, so their OP_RETURN is trustworthy.
+ * This enables chaining DD transfers without waiting for block confirmation.
+ */
+bool ExtractDDAmountFromMempool(const COutPoint& prevout, const CTxMemPool* mempool, CAmount& amount) {
+    amount = 0;
+    if (!mempool) return false;
+
+    CTransactionRef prev_tx = mempool->get(prevout.hash);
+    if (!prev_tx) {
+        LogPrint(BCLog::DIGIDOLLAR, "DigiDollar: ExtractDDAmountFromMempool - tx %s not in mempool\n",
+                 prevout.hash.ToString());
+        return false;
+    }
+
+    bool ok = ExtractDDAmountFromTxRef(prev_tx, prevout, amount);
+    if (ok) {
+        LogPrint(BCLog::DIGIDOLLAR, "DigiDollar: ExtractDDAmountFromMempool - tx %s vout %d = %lld cents\n",
+                 prevout.hash.ToString(), prevout.n, (long long)amount);
+    }
+    return ok;
+}
+
 bool ExtractDDAmountFromPrevTx(const COutPoint& prevout, CAmount& amount) {
     amount = 0;
 
@@ -1255,6 +1280,13 @@ bool ValidateTransferTransaction(const CTransaction& tx,
             CAmount ddAmt = 0;
             bool found = false;
 
+            // 0. Try mempool lookup (for spending unconfirmed DD outputs — Bug #35)
+            if (!found && ctx.mempool) {
+                if (ExtractDDAmountFromMempool(txin.prevout, ctx.mempool, ddAmt) && ddAmt > 0) {
+                    found = true;
+                }
+            }
+
             // 1. Try txindex (authoritative — reads creating tx's OP_RETURN)
             if (!found && ExtractDDAmountFromPrevTx(txin.prevout, ddAmt) && ddAmt > 0) {
                 found = true;
@@ -1389,6 +1421,10 @@ bool ValidateRedemptionTransaction(const CTransaction& tx,
                             totalDDInputs += ddAmount;
                             LogPrint(BCLog::DIGIDOLLAR, "DigiDollar: DD input %d - amount: %lld cents (from registry)\n",
                                      i, (long long)ddAmount);
+                        } else if (ctx.mempool && ExtractDDAmountFromMempool(input.prevout, ctx.mempool, ddAmount) && ddAmount > 0) {
+                            totalDDInputs += ddAmount;
+                            LogPrint(BCLog::DIGIDOLLAR, "DigiDollar: DD input %d - amount: %lld cents (from mempool)\n",
+                                     i, (long long)ddAmount);
                         } else if (ExtractDDAmountFromPrevTx(input.prevout, ddAmount) && ddAmount > 0) {
                             totalDDInputs += ddAmount;
                             LogPrint(BCLog::DIGIDOLLAR, "DigiDollar: DD input %d - amount: %lld cents (from txindex)\n",
diff --git a/src/digidollar/validation.h b/src/digidollar/validation.h
index 43a7126800..969738cba1 100644
--- a/src/digidollar/validation.h
+++ b/src/digidollar/validation.h
@@ -16,6 +16,8 @@
 #include <chainparams.h>
 #include <coins.h>
 
+class CTxMemPool;
+
 #include <cstdint>
 #include <functional>
 #include <vector>
@@ -68,13 +70,14 @@ struct ValidationContext {
     const CCoinsViewCache* coins;    // Coins view for UTXO lookups (nullptr if not available)
     bool skipOracleValidation;       // Skip oracle-dependent validation (for historical blocks)
     TxLookupFn txLookup;             // Look up tx from block database (for DD amount extraction)
+    const CTxMemPool* mempool;       // Mempool for resolving DD amounts from unconfirmed parent txs
 
     ValidationContext(int height, CAmount price_micro_usd, int collateral, const CChainParams& chainParams,
                       const CCoinsViewCache* coins_view = nullptr, bool skip_oracle = false,
-                      TxLookupFn tx_lookup = nullptr)
+                      TxLookupFn tx_lookup = nullptr, const CTxMemPool* pool = nullptr)
         : nHeight(height), oraclePriceMicroUSD(price_micro_usd), systemCollateral(collateral),
           params(chainParams), coins(coins_view), skipOracleValidation(skip_oracle),
-          txLookup(std::move(tx_lookup)) {}
+          txLookup(std::move(tx_lookup)), mempool(pool) {}
 };
 
 // ============================================================================
diff --git a/src/validation.cpp b/src/validation.cpp
index 7fa590af1a..23ab50cdfb 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -804,7 +804,8 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
             args.m_chainparams,                          // Chain parameters
             &m_active_chainstate.CoinsTip(),             // Coins view for UTXO lookup
             false,                                       // Don't skip oracle validation in mempool
-            txLookup                                     // Block-db tx lookup for DD amounts
+            txLookup,                                    // Block-db tx lookup for DD amounts
+            &m_pool                                      // Mempool for unconfirmed DD input lookup
         );
 
         if (!DigiDollar::ValidateDigiDollarTransaction(tx, ddContext, state)) {