Fix DigiDollar chained miner validation and functional regressions

Pass the mempool into BlockAssembler DigiDollar validation so chained DigiDollar transfers built on unconfirmed mempool ancestors are accepted during block assembly, matching mempool admission behavior instead of silently dropping valid descendants from candidate blocks.

Add a focused miner regression that constructs a mint plus two chained DigiDollar transfers entirely from mempool state and asserts the assembled block includes the whole chain.

Replace the old digidollar_transactions functional file with strict end-to-end coverage of real shipped RPC behavior, including mint confirmation, cross-node send accounting, exact-amount redemption, parameter validation, and oracle/collateral sanity checks. Update the oracle and protection assertions to match the current RPC schemas instead of stale placeholder fields.

Also fix the Bug #11/#13 regression runner to call the correct unconfirmed blockheight test method so the suite actually exercises the intended coverage.

Author: JaredTate

src/node/miner.cpp

@@ -195,7 +195,8 @@ bool BlockAssembler::ValidateDDForBlockInclusion(const CTransaction& tx, const C
         chainparams,
         &m_chainstate.CoinsTip(),
         false,
-        txLookup
+        txLookup,
+        m_mempool
     );
 
     TxValidationState tx_state;

src/test/miner_dd_validation_tests.cpp

@@ -144,6 +144,21 @@ struct MinerDDValidationSetup : public TestChain100Setup {
         return MakeTransactionRef(tx);
     }
 
+    CTransactionRef BuildDDTransfer(const COutPoint& prevout, const XOnlyPubKey& recipient, CAmount dd_amount)
+    {
+        CMutableTransaction tx;
+        tx.SetDigiDollarType(DD_TX_TRANSFER);
+        tx.vin.emplace_back(prevout);
+        tx.vout.emplace_back(0, DigiDollar::CreateDigiDollarP2TR(recipient, dd_amount));
+
+        CScript op_return = CScript() << OP_RETURN
+                                      << std::vector<unsigned char>{'D', 'D'}
+                                      << CScriptNum(2)
+                                      << CScriptNum(dd_amount);
+        tx.vout.emplace_back(0, op_return);
+        return MakeTransactionRef(tx);
+    }
+
     bool ValidateMintAtPrice(const CTransaction& tx, int next_height, CAmount oracle_price_micro_usd, std::string* reject_reason = nullptr) const
     {
         DigiDollar::ValidationContext ctx(next_height, oracle_price_micro_usd, 300, Params());
@@ -327,4 +342,48 @@ BOOST_FIXTURE_TEST_CASE(test_block_validity_retry, MinerDDValidationSetup)
     BOOST_CHECK_EQUAL(block_template->block.vtx.size(), 1U);
 }
 
+BOOST_FIXTURE_TEST_CASE(block_includes_chained_dd_transfers_from_mempool, MinerDDValidationSetup)
+{
+    constexpr CAmount kPrice = 50000;
+    constexpr CAmount kDDAmount = 10000;
+    constexpr CAmount kFee = 1000;
+
+    MockOracleManager::GetInstance().SetMockPrice(kPrice);
+
+    const int next_height = NextBlockHeight();
+    const CAmount required = RequiredCollateralAt(kDDAmount, 30, next_height, kPrice);
+    const COutPoint funding = ConfirmOpTrueFunding(required + kFee);
+    const CTransactionRef mint = BuildDDMint(funding, required + kFee, required, kDDAmount, next_height, kFee);
+
+    std::string reject_reason;
+    BOOST_REQUIRE(ValidateMintAtPrice(*mint, next_height, kPrice, &reject_reason));
+
+    CKey transfer1_key;
+    transfer1_key.MakeNewKey(true);
+    const XOnlyPubKey transfer1_xonly(transfer1_key.GetPubKey());
+
+    CKey transfer2_key;
+    transfer2_key.MakeNewKey(true);
+    const XOnlyPubKey transfer2_xonly(transfer2_key.GetPubKey());
+
+    const COutPoint mint_dd_out(mint->GetHash(), 1);
+    const CTransactionRef transfer1 = BuildDDTransfer(mint_dd_out, transfer1_xonly, kDDAmount);
+    const COutPoint transfer1_dd_out(transfer1->GetHash(), 0);
+    const CTransactionRef transfer2 = BuildDDTransfer(transfer1_dd_out, transfer2_xonly, kDDAmount);
+
+    AddToMempool(mint, kFee);
+    AddToMempool(transfer1, kFee);
+    AddToMempool(transfer2, kFee);
+
+    BlockAssembler::Options options;
+    options.blockMinFeeRate = CFeeRate(0);
+    options.test_block_validity = false;
+
+    auto block_template = BuildTemplate(options);
+    BOOST_REQUIRE(block_template);
+    BOOST_CHECK(BlockHasTx(block_template->block, mint->GetHash()));
+    BOOST_CHECK(BlockHasTx(block_template->block, transfer1->GetHash()));
+    BOOST_CHECK(BlockHasTx(block_template->block, transfer2->GetHash()));
+}
+
 BOOST_AUTO_TEST_SUITE_END()

test/functional/digidollar_bug11_bug13_regression.py

@@ -320,7 +320,7 @@ def run_test(self):
         self.log.info("BUG #13: DD transaction blockheight tests")
         self.log.info("=" * 60)
         self.test_bug13_confirmed_tx_has_blockheight()
-        self.test_bug13_unconfirmed_tx_has_blockheight()
+        self.test_bug13_unconfirmed_tx_has_negative_blockheight()
         self.test_bug13_blockheight_matches_actual_block()
         self.test_bug13_multiple_confirmations()