diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index c3ffa3f..7855e25 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -73,12 +73,9 @@ public:
         consensus.BIP66Height = 29000;
         consensus.CSVHeight = 29000;
         consensus.SegwitHeight = 29000;
+
         consensus.MinBIP9WarningHeight = 29540; // segwit activation height + miner confirmation window
 
-
-
-        consensus.nAuxpowStartHeight = 310000;
-
         consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 
         consensus.nPowTargetTimespan = 24 * 60 * 60;    // 86400 seconds
@@ -202,9 +199,8 @@ public:
         consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
         consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
         consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.nAuxpowStartHeight = 1;
-        consensus.nPowTargetTimespan = 24 * 60 * 60; // two weeks
-        consensus.nPowTargetSpacing = 2 * 60;
+        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+        consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
         consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
diff --git a/src/consensus/params.h b/src/consensus/params.h
index aed7438..7cc7890 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -1,22 +1,16 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2019 The Palladium Core developers // Jahr angepasst
+// Copyright (c) 2009-2019 The Palladium Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef PALLADIUM_CONSENSUS_PARAMS_H // Guard angepasst
+#ifndef PALLADIUM_CONSENSUS_PARAMS_H
 #define PALLADIUM_CONSENSUS_PARAMS_H
 
 #include <uint256.h>
 #include <limits>
-#include <map>
-#include <string>
 
 namespace Consensus {
 
-// --- Maximale Blockhöhe für Fork-Planung ---
-static constexpr int MAX_BLOCK_HEIGHT = std::numeric_limits<int>::max();
-
-
 enum DeploymentPos
 {
     DEPLOYMENT_TESTDUMMY,
@@ -30,16 +24,18 @@ enum DeploymentPos
 struct BIP9Deployment {
     /** Bit position to select the particular bit in nVersion. */
     int bit;
-    /** Start MedianTime for version bits signalling. */
+    /** Start MedianTime for version bits miner confirmation. Can be a date in the past */
     int64_t nStartTime;
-    /** Timeout MedianTime for version bits signalling. */
+    /** Timeout/expiry MedianTime for the deployment attempt. */
     int64_t nTimeout;
 
     /** Constant for nTimeout very far in the future. */
     static constexpr int64_t NO_TIMEOUT = std::numeric_limits<int64_t>::max();
 
     /** Special value for nStartTime indicating that the deployment is always active.
-     * This is useful for testing, regression testing and informational deployments. */
+     *  This is useful for testing, as it means tests don't need to deal with the activation
+     *  process (which takes at least 3 BIP9 intervals). Only tests that specifically test the
+     *  behaviour during activation cannot use this. */
     static constexpr int64_t ALWAYS_ACTIVE = -1;
 };
 
@@ -49,71 +45,44 @@ struct BIP9Deployment {
 struct Params {
     uint256 hashGenesisBlock;
     int nSubsidyHalvingInterval;
-    /** Block height and hash at which BIP16 becomes active */
-    // int BIP16Height; // Oft 0 in neueren Chains, P2SH immer aktiv? Prüfen!
-    uint256 BIP16Exception; // Genesis hash if BIP16 active from start
-    /** Block height at which BIP34 becomes active */
+    /* Block hash that is excepted from BIP16 enforcement */
+    uint256 BIP16Exception;
+    /** Block height and hash at which BIP34 becomes active */
     int BIP34Height;
-    uint256 BIP34Hash; // Not needed if height-based
+    uint256 BIP34Hash;
     /** Block height at which BIP65 becomes active */
     int BIP65Height;
     /** Block height at which BIP66 becomes active */
     int BIP66Height;
     /** Block height at which CSV (BIP68, BIP112 and BIP113) becomes active */
     int CSVHeight;
-    /** Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active. */
+    /** Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active.
+     * Note that segwit v0 script rules are enforced on all blocks except the
+     * BIP 16 exception blocks. */
     int SegwitHeight;
-    /** Don't warn about unknown BIP 9 activations below this height. */
+    /** Don't warn about unknown BIP 9 activations below this height.
+     * This prevents us from warning about the CSV and segwit activations. */
     int MinBIP9WarningHeight;
-    /** BIP9 deployment parameters */
+    /**
+     * Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,
+     * (nPowTargetTimespan / nPowTargetSpacing) which is also used for BIP9 deployments.
+     * Examples: 1916 for 95%, 1512 for testchains.
+     */
     uint32_t nRuleChangeActivationThreshold;
     uint32_t nMinerConfirmationWindow;
     BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS];
     /** Proof of work parameters */
     uint256 powLimit;
+
     bool fPowAllowMinDifficultyBlocks;
     bool fPowNoRetargeting;
     int64_t nPowTargetSpacing;
-    int64_t nPowTargetSpacingV2; // Für LWMA / neue Blockzeit
+    int64_t nPowTargetSpacingV2;
     int64_t nPowTargetTimespan;
-    // DifficultyAdjustmentInterval angepasst, um korrekten Wert nach LWMA-Aktivierung zu liefern
-    int DifficultyAdjustmentInterval(int nHeight) const {
-        // Prüfe, ob LWMA aktiv ist (Block >= 29000). Wenn ja, ist das klassische Intervall irrelevant.
-        // Falls wir das Fenster für BIP9 brauchen, muss es anders berechnet werden.
-        // Nehmen wir an, nMinerConfirmationWindow ist jetzt der relevante Wert für BIP9.
-        // Die alte Berechnung ist nur für den alten Algo (< 29000) relevant.
-        if (nHeight < 29000) { // Beispiel: Blockhöhe anpassen, falls LWMA anders aktiviert wurde
-             return nPowTargetTimespan / nPowTargetSpacing;
-        } else {
-             // Für BIP9 wird nMinerConfirmationWindow verwendet.
-             // Gib hier einen sinnvollen Wert zurück oder passe die Verwendung an.
-             // Bitcoin Core verwendet hier oft einen festen Wert (z.B. 2016)
-             // oder leitet ihn aus Timespan/Spacing ab.
-             // Da LWMA das Timespan ignoriert, ist es sauberer, nMinerConfirmationWindow direkt zu verwenden.
-             // return nMinerConfirmationWindow; // Oder die alte Berechnung, wenn sie noch irgendwo gebraucht wird
-             return nPowTargetTimespan / nPowTargetSpacingV2; // Behalte Timespan/Spacing Logik bei
-        }
-    }
+    int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
-
-    // --- AuxPoW Start ---
-    /** Block height at which Auxiliary Proof of Work (AuxPoW) becomes active */
-    int nAuxpowStartHeight;
-    // --- AuxPoW Ende ---
-
-    // Constructor to initialize members - WICHTIG: Alle neuen Member hier initialisieren!
-    Params() : hashGenesisBlock(), nSubsidyHalvingInterval(0), /*BIP16Height(0),*/ BIP16Exception(),
-               BIP34Height(0), BIP34Hash(), BIP65Height(0), BIP66Height(0), CSVHeight(0), SegwitHeight(0),
-               MinBIP9WarningHeight(0), nRuleChangeActivationThreshold(0), nMinerConfirmationWindow(0),
-               vDeployments{}, powLimit(), fPowAllowMinDifficultyBlocks(false), fPowNoRetargeting(false),
-               nPowTargetSpacing(0), nPowTargetSpacingV2(0), nPowTargetTimespan(0),
-               nMinimumChainWork(), defaultAssumeValid()
-               // --- AuxPoW Start ---
-               , nAuxpowStartHeight(MAX_BLOCK_HEIGHT) // Standardmäßig deaktiviert
-               // --- AuxPoW Ende ---
-    {}
 };
 } // namespace Consensus
 
-#endif // PALLADIUM_CONSENSUS_PARAMS_H
\ No newline at end of file
+#endif // PALLADIUM_CONSENSUS_PARAMS_H
diff --git a/src/miner.cpp b/src/miner.cpp
index b0e6ea5..35554d1 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -24,10 +24,6 @@
 #include <algorithm>
 #include <utility>
 
-
-#include <chainparams.h>
-
-
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
 {
     int64_t nOldTime = pblock->nTime;
@@ -428,107 +424,6 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
     }
 }
 
-
-// Method to compute block version
-// Currently just returns BASE_VERSION, needs update for BIP9 signaling if used
-// static int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
-// {
-     // Implement BIP9 version bit signaling logic here if needed
-     // ...
-//     return CBlockHeader::BASE_VERSION; // Return base version for now
-// }
-
-std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
-{
-    int64_t nTimeStart = GetTimeMicros();
-
-    ResetBlock();
-
-    pblocktemplate = std::make_unique<CBlockTemplate>();
-    pblock = &pblocktemplate->block; // pointer for convenience
-
-    // Add dummy coinbase tx as first transaction
-    pblock->vtx.emplace_back();
-    pblocktemplate->vTxFees.push_back(-1); // updated at end
-    pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
-
-    LOCK2(cs_main, m_mempool.cs);
-    CBlockIndex* pindexPrev = ::ChainActive().Tip();
-    assert(pindexPrev != nullptr);
-    nHeight = pindexPrev->nHeight + 1;
-
-    // --- AuxPoW Start ---
-    // Set base version first
-    pblock->nVersion = CBlockHeader::BASE_VERSION; // ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
-    // Add AuxPoW version bit if fork is active
-    const Consensus::Params& consensusParams = chainparams.GetConsensus();
-    if (nHeight >= consensusParams.nAuxpowStartHeight) {
-        pblock->nVersion |= CBlockHeader::AUXPOW_VERSION_BIT;
-         LogPrintf("CreateNewBlock: Setting AuxPoW version bit for block height %d\n", nHeight);
-    }
-    // --- AuxPoW Ende ---
-
-    // -regtest only: allow overriding block.nVersion with
-    // -blockversion=N to test forking scenarios
-    if (chainparams.MineBlocksOnDemand())
-        pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
-
-    pblock->nTime = GetAdjustedTime();
-    const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
-
-    nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
-                       ? nMedianTimePast
-                       : pblock->GetBlockTime();
-
-    // Decide whether to include witness transactions
-    // Typically based on Segwit activation height
-    bool fIncludeWitness = IsWitnessEnabled(pindexPrev, consensusParams);
-
-    int nPackagesSelected = 0;
-    int nDescendantsUpdated = 0;
-    addPackageTxs(nPackagesSelected, nDescendantsUpdated);
-
-    int64_t nTime1 = GetTimeMicros();
-
-    m_last_block_num_txs = nBlockTx;
-    m_last_block_weight = nBlockWeight;
-
-    // Create coinbase transaction.
-    CMutableTransaction coinbaseTx;
-    coinbaseTx.vin.resize(1);
-    coinbaseTx.vin[0].prevout.SetNull();
-    coinbaseTx.vout.resize(1);
-    coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
-    coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, consensusParams);
-    coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0; // OP_0 statt nExtraNonce? Prüfe Coinbase-Regeln
-    // nExtraNonce logic seems missing or different in this base code? Add if needed.
-    // If nExtraNonce is used, it should be part of scriptSig generation.
-
-    pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
-    pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, consensusParams);
-    pblocktemplate->vTxFees[0] = -nFees;
-
-    LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops_cost: %d\n",
-        GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);
-
-    // Fill in header
-    pblock->hashPrevBlock = pindexPrev->GetBlockHash();
-    UpdateTime(pblock, consensusParams, pindexPrev);
-    pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
-    pblock->nNonce = 0; // Nonce wird vom Miner gesetzt
-    pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
-
-    CValidationState state;
-    if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
-        throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString()));
-    }
-    int64_t nTime2 = GetTimeMicros();
-
-    LogPrint(BCLog::BENCH, "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n", 0.001 * (nTime1 - nTimeStart), nPackagesSelected, nDescendantsUpdated, 0.001 * (nTime2 - nTime1), 0.001 * (nTime2 - nTimeStart));
-
-    return std::move(pblocktemplate);
-}
-
 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
 {
     // Update nExtraNonce
diff --git a/src/pow.cpp b/src/pow.cpp
index 802aa80..29dfb97 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -9,68 +9,34 @@
 #include <chain.h>
 #include <primitives/block.h>
 #include <uint256.h>
-#include <util/system.h> // Für error()
-
-// --- AuxPoW Start ---
-#include <util/strencodings.h> // Für ParseHex
-#include <script/script.h>     // Für CScript
-#include <logging.h>          // Für LogPrintf
-#include <set>                // Für Duplicate Check
-#include <sync.h>             // Für cs_main Lock (Duplicate Check)
-#include <algorithm>          // Für std::search, std::reverse
-// --- AuxPoW Ende ---
-
-
-// --- AuxPoW Start ---
-// Globales Set zur Verfolgung verwendeter Parent Block Hashes (Needs cs_main lock for access)
-// Dies ist eine einfache Implementierung. Eine robustere könnte LRU-Caching o.ä. verwenden.
-std::set<uint256> setAuxPowScannedParentHashes GUARDED_BY(cs_main);
-// --- AuxPoW Ende ---
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
     assert(pindexLast != nullptr);
     unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
 
-    // --- AuxPoW Start ---
-    // Nach dem AuxPoW Fork wird die Difficulty immer noch angepasst, aber CheckProofOfWork wird anders aufgerufen.
-    // Die Logik hier bleibt also dieselbe, um das nBits für den *nächsten* Block zu bestimmen.
-    // --- AuxPoW Ende ---
-
-    // reset difficulty for new diff algorithm's average + Segwit/CSV activation (Block 29000 ist LWMA Start)
-    if ((pindexLast->nHeight >= 28930) && (pindexLast->nHeight <= 28999)) {
-        LogPrintf("Difficulty reset to limit for LWMA activation window at height %d\n", pindexLast->nHeight + 1);
+    // reset difficulty for new diff algorithm's average + Segwit/CSV activation
+    if ((pindexLast->nHeight >= 28930) && (pindexLast->nHeight <= 28999))
         return nProofOfWorkLimit;
-    }
 
-    // Ab Block 29000 wird LWMA verwendet
-    // Hole die aktuelle Höhe + 1 für die Entscheidung, welcher DifficultyAlgo genutzt wird
-    int nHeight = pindexLast->nHeight + 1;
-    if (nHeight >= 29000) { // Nutze die korrekte Höhe für die Entscheidung
-        // LogPrintf("Using LWMA for difficulty calculation at height %d\n", nHeight);
+    if (pindexLast->nHeight >= 29000)
         return LwmaCalculateNextWorkRequired(pindexLast, params);
-    }
 
-
-    // Alter Bitcoin Difficulty Adjustment Algo (vor Block 29000)
     // Only change once per difficulty adjustment interval
-    // Verwende die korrekte Höhe für die Intervallprüfung
-    if (nHeight % params.DifficultyAdjustmentInterval(nHeight) != 0)
+    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
     {
         if (params.fPowAllowMinDifficultyBlocks)
         {
-            // Special difficulty rule for testnet/regtest:
-            // If the new block's timestamp is more than 2* target spacing
+            // Special difficulty rule for testnet:
+            // If the new block's timestamp is more than 2* 10 minutes
             // then allow mining of a min-difficulty block.
-            // WICHTIG: Verwende nPowTargetSpacing hier, da dieser Code nur < Block 29000 läuft.
             if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
                 return nProofOfWorkLimit;
             else
             {
                 // Return the last non-special-min-difficulty-rules-block
                 const CBlockIndex* pindex = pindexLast;
-                // Passe die Intervallprüfung an die Höhe des jeweiligen pindex an
-                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval(pindex->nHeight) != 0 && pindex->nBits == nProofOfWorkLimit)
+                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
                     pindex = pindex->pprev;
                 return pindex->nBits;
             }
@@ -78,102 +44,66 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
         return pindexLast->nBits;
     }
 
-    // Go back by what we want to be nPowTargetTimespan worth of blocks
-    // Verwende die korrekte Höhe für die Intervallberechnung
-    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval(nHeight)-1);
+    // Go back by what we want to be 14 days worth of blocks
+    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
     assert(nHeightFirst >= 0);
     const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
     assert(pindexFirst);
 
-    LogPrintf("Using CalculateNextWorkRequired (old algo) at height %d\n", nHeight);
     return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
 }
 
-// LwmaCalculateNextWorkRequired bleibt unverändert (verwendet T = params.nPowTargetSpacingV2 korrekt)
 unsigned int LwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params)
 {
-    const int64_t T = params.nPowTargetSpacingV2; // Korrekt: Verwendet V2 (120 Sek)
-    const int64_t N = 240; // LWMA Fenstergröße (Anzahl Blöcke)
-    // Original LWMA k calculation: T * N * (N + 1) / 2
-    // Hier ist k = N * (N + 1) * T / 2; Das ist mathematisch dasselbe.
-    const int64_t k = N * (N + 1) * T / 2;
+    const int64_t T = params.nPowTargetSpacingV2;
+    const int64_t N = 240;
+    const int64_t k = N * (N + 1) * T / 2; // For T=120, 240, 600 use approx N=100, 75, 50
     const int64_t height = pindexLast->nHeight;
     const arith_uint256 powLimit = UintToArith256(params.powLimit);
-
-    // Genesis Block Case
-    if (pindexLast == nullptr || height == 0) {
-        //LogPrintf("LWMA: Genesis block or pindexLast is null, returning powLimit\n");
-        return powLimit.GetCompact();
-    }
-    // Handle initial blocks where N previous blocks are not available
-    if (height < N) {
-        //LogPrintf("LWMA: Height %d < N (%d), returning powLimit\n", height, N);
-        return powLimit.GetCompact();
-    }
+    
+    if (height < N) { return powLimit.GetCompact(); }
 
     arith_uint256 sumTarget, nextTarget;
     int64_t thisTimestamp, previousTimestamp;
     int64_t t = 0, j = 0;
 
-    // Finde den Startblock für das LWMA Fenster
-    const CBlockIndex* blockStart = pindexLast->GetAncestor(height - N);
-    if (!blockStart) {
-         // Sollte nicht passieren, wenn height >= N
-         LogPrintf("ERROR: LWMA: Could not find ancestor at height %d\n", height - N);
-         return powLimit.GetCompact();
-    }
-    previousTimestamp = blockStart->GetBlockTime();
+    // Uncomment next 2 lines to use LWMA-3 jump rule.
+    //arith_uint256 previousTarget = 0;
+    //int64_t sumLast3Solvetimes = 0; 
 
+    const CBlockIndex* blockPreviousTimestamp = pindexLast->GetAncestor(height - N);
+    previousTimestamp = blockPreviousTimestamp->GetBlockTime();
 
-    // Loop through N most recent blocks (von height - N + 1 bis height).
-    const CBlockIndex* blockCurrent = blockStart;
+    // Loop through N most recent blocks. 
     for (int64_t i = height - N + 1; i <= height; i++) {
-        // Navigiere zum nächsten Block im Hauptzweig. GetAncestor kann teuer sein in Schleife.
-        // Es ist effizienter, von pindexLast rückwärts zu gehen oder von blockStart vorwärts.
-        blockCurrent = pindexLast->GetAncestor(i); // Nutze GetAncestor für Korrektheit bei Reorgs
-        if (!blockCurrent) {
-             LogPrintf("ERROR: LWMA: Could not find block at height %d using GetAncestor\n", i);
-             return powLimit.GetCompact(); // Oder einen anderen Fehler-Fallback
-        }
-
-        thisTimestamp = blockCurrent->GetBlockTime();
-
-        // Ensure timestamps are monotonic within the calculation window for sanity
-        if(thisTimestamp < previousTimestamp) {
-            //LogPrintf("LWMA Warning: Non-monotonic timestamp detected at height %d (%ld < %ld)\n", i, thisTimestamp, previousTimestamp);
-            thisTimestamp = previousTimestamp; // Treat as 0 solvetime if non-monotonic, LWMA does prev+1
-        }
-
-        // Clamp solvetime: min 1, max 6*T
-        int64_t solvetime = std::max((int64_t)1, thisTimestamp - previousTimestamp); // Min solvetime is 1
-        solvetime = std::min(6 * T, solvetime);
+        const CBlockIndex* block = pindexLast->GetAncestor(i);
+        thisTimestamp = (block->GetBlockTime() > previousTimestamp) ? 
+                            block->GetBlockTime() : previousTimestamp + 1;
 
+        int64_t solvetime = std::min(6 * T, thisTimestamp - previousTimestamp);
         previousTimestamp = thisTimestamp;
 
         j++;
         t += solvetime * j; // Weighted solvetime sum.
         arith_uint256 target;
-        target.SetCompact(blockCurrent->nBits);
-        sumTarget += target; // Summe der Targets (NICHT geteilt!)
+        target.SetCompact(block->nBits);
+        sumTarget += target / (k * N);
+ 
+      // Uncomment next 2 lines to use LWMA-3.
+      //  if (i > height - 3) { sumLast3Solvetimes  += solvetime; }  
+      //  if (i == height) { previousTarget = target.SetCompact(block->nBits); }
     }
+    nextTarget = t * sumTarget;
 
-    // Berechne das nächste Target mit korrekter LWMA-Formel
-    if (N == 0 || T == 0 || k == 0) { // Division durch Null verhindern
-         LogPrintf("ERROR: LWMA: N, T or k is zero (N=%ld, T=%ld, k=%ld)\n", N, T, k);
-         return powLimit.GetCompact();
-    }
-    arith_uint256 avgTarget = sumTarget / N; // Durchschnittliches Target über N Blöcke
-    nextTarget = avgTarget * t / (k * T); // KORREKTE LWMA Formel
+   // Uncomment the following to use LWMA-3.
+   // This is a "memory-less" jump in difficulty approximately 2x normal
+   // if (sumLast3Solvetimes < (8 * T) / 10) { nextTarget = (previousTarget*100)/(100+(N*26)/200); } 
 
-    if (nextTarget > powLimit) {
-        //LogPrintf("LWMA: Calculated target > powLimit, clamping to powLimit\n");
-        nextTarget = powLimit;
-    }
+    if (nextTarget > powLimit) { nextTarget = powLimit; }
 
     return nextTarget.GetCompact();
 }
 
-// CalculateNextWorkRequired bleibt unverändert (nur für < Block 29000 relevant)
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
 {
     if (params.fPowNoRetargeting)
@@ -181,13 +111,10 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
 
     // Limit adjustment step
     int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
-    LogPrintf("CalculateNextWorkRequired: nActualTimespan = %d before bounds\n", nActualTimespan);
     if (nActualTimespan < params.nPowTargetTimespan/4)
         nActualTimespan = params.nPowTargetTimespan/4;
     if (nActualTimespan > params.nPowTargetTimespan*4)
         nActualTimespan = params.nPowTargetTimespan*4;
-    LogPrintf("CalculateNextWorkRequired: nActualTimespan = %d after bounds (Target: %d)\n", nActualTimespan, params.nPowTargetTimespan);
-
 
     // Retarget
     const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
@@ -199,123 +126,9 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
     if (bnNew > bnPowLimit)
         bnNew = bnPowLimit;
 
-    LogPrintf("Difficulty Retarget - Old: %08x %s\n", pindexLast->nBits, arith_uint256().SetCompact(pindexLast->nBits).ToString());
-    LogPrintf("Difficulty Retarget - New: %08x %s\n", bnNew.GetCompact(), bnNew.ToString());
-
-
     return bnNew.GetCompact();
 }
 
-// --- AuxPoW Start ---
-// *** NEUE EINZIGARTIGE MAGIC BYTES *** (Hex für "plm" + 0x01)
-const unsigned char pchAuxPowHeader[] = {0x70, 0x6c, 0x6d, 0x01};
-
-/** Check whether the auxiliary proof-of-work satisfies the difficulty specified by nBits */
-bool CheckAuxPowProofOfWork(const CBlock& block, const Consensus::Params& params)
-{
-    // Check if block has AuxPoW data and the version bit is set
-    if (!block.IsAuxpow()) {
-        // This case should ideally be caught by CheckBlock/ContextualCheckBlockHeader
-        return error("%s: Block does not have AuxPoW version bit set", __func__);
-    }
-    if (!block.m_auxpow) {
-        return error("%s: No AuxPoW data present in AuxPoW block", __func__);
-    }
-    LogPrintf("CheckAuxPowProofOfWork: AuxPoW data found for block %s\n", block.GetHash().ToString());
-
-    // Check if the parent block hash satisfies the target difficulty
-    if (!CheckProofOfWork(block.m_auxpow->GetParentBlockHash(), block.nBits, params)) {
-        // Log more details for debugging
-        arith_uint256 bnTarget;
-        bnTarget.SetCompact(block.nBits);
-        LogPrintf("CheckAuxPowProofOfWork failed: Parent Block Hash %s does not meet target %s (nBits %08x)\n",
-                  block.m_auxpow->GetParentBlockHash().ToString(), bnTarget.ToString(), block.nBits);
-        return error("%s: Bitcoin parent block PoW does not meet target", __func__);
-    }
-     LogPrintf("CheckAuxPowProofOfWork: Parent block hash %s meets target %08x\n", block.m_auxpow->GetParentBlockHash().ToString(), block.nBits);
-
-
-    // Check if the Coinbase transaction is correctly linked to the parent block's Merkle root
-    uint256 hashCoinbase = block.m_auxpow->coinbaseTx->GetHash();
-    uint256 calculatedMerkleRoot = block.m_auxpow->CheckMerkleBranch(hashCoinbase, block.m_auxpow->vMerkleBranch, block.m_auxpow->nIndex);
-    if (block.m_auxpow->parentBlock.hashMerkleRoot != calculatedMerkleRoot) {
-         LogPrintf("CheckAuxPowProofOfWork failed: Merkle branch for Coinbase Tx verification failed.\n");
-         LogPrintf("  Coinbase Hash: %s\n", hashCoinbase.ToString());
-         LogPrintf("  Parent Merkle Root: %s\n", block.m_auxpow->parentBlock.hashMerkleRoot.ToString());
-         LogPrintf("  Calculated Merkle Root: %s\n", calculatedMerkleRoot.ToString());
-         LogPrintf("  Index: %d\n", block.m_auxpow->nIndex);
-         LogPrintf("  Branch size: %d\n", block.m_auxpow->vMerkleBranch.size());
-        return error("%s: Merkle branch for Coinbase Tx verification failed", __func__);
-    }
-     LogPrintf("CheckAuxPowProofOfWork: Coinbase Merkle branch verified.\n");
-
-
-    // Find the AuxPoW commitment in the Coinbase transaction's scriptSig
-    // It should be after the magic bytes pchAuxPowHeader
-    const CScript& scriptSig = block.m_auxpow->coinbaseTx->vin[0].scriptSig;
-    CScript::const_iterator pc = std::search(scriptSig.begin(), scriptSig.end(), pchAuxPowHeader, pchAuxPowHeader + sizeof(pchAuxPowHeader));
-
-    if (pc == scriptSig.end()) {
-        LogPrintf("CheckAuxPowProofOfWork failed: AuxPoW magic bytes not found in Coinbase scriptSig.\n");
-        LogPrintf("  ScriptSig: %s\n", HexStr(scriptSig));
-        return error("%s: AuxPoW magic bytes (%s) not found in Coinbase scriptSig", __func__, HexStr(pchAuxPowHeader, pchAuxPowHeader + sizeof(pchAuxPowHeader)));
-    }
-    LogPrintf("CheckAuxPowProofOfWork: Magic bytes found in scriptSig.\n");
-
-
-    // Commitment structure: [Magic Bytes] [Palladium Block Hash (reversed)] [Merkle Tree Size] [Merkle Nonce]
-    // Extract the Palladium block hash (committed hash) - it's typically stored reversed in the scriptSig
-    std::vector<unsigned char> vchCommitment(pc + sizeof(pchAuxPowHeader), scriptSig.end());
-    if (vchCommitment.size() < sizeof(uint256)) { // Ensure there's enough data for the hash
-         LogPrintf("CheckAuxPowProofOfWork failed: Commitment data too short (%d bytes) in Coinbase scriptSig.\n", vchCommitment.size());
-         return error("%s: Commitment data too short in Coinbase scriptSig", __func__);
-    }
-    uint256 hashAuxBlockCommit = uint256(std::vector<unsigned char>(vchCommitment.begin(), vchCommitment.begin() + sizeof(uint256)));
-    // Reverse the hash bytes (standard AuxPoW practice)
-    std::reverse(hashAuxBlockCommit.begin(), hashAuxBlockCommit.end());
-     LogPrintf("CheckAuxPowProofOfWork: Found commitment hash: %s\n", hashAuxBlockCommit.ToString());
-
-
-    // Calculate the expected Palladium block hash (without AuxPoW data)
-    // We need the hash of the block *as if* it wasn't an AuxPoW block.
-    // This typically means hashing the header *without* the AuxPoW version bit.
-    CBlockHeader headerNoAux = block.GetBlockHeader();
-    headerNoAux.nVersion &= ~CBlockHeader::AUXPOW_VERSION_BIT; // Remove AuxPoW flag for hashing
-    uint256 hashAuxBlockExpected = headerNoAux.GetHash();
-     LogPrintf("CheckAuxPowProofOfWork: Expected block hash: %s\n", hashAuxBlockExpected.ToString());
-
-
-    // Verify the commitment
-    if (hashAuxBlockCommit != hashAuxBlockExpected) {
-        LogPrintf("CheckAuxPowProofOfWork failed: AuxPoW commitment mismatch.\n");
-        LogPrintf("  Hash in scriptSig (reversed): %s\n", hashAuxBlockCommit.ToString());
-        LogPrintf("  Expected block hash (version bit removed): %s\n", hashAuxBlockExpected.ToString());
-        return error("%s: AuxPoW commitment mismatch: scriptSig %s vs expected %s", __func__,
-                     hashAuxBlockCommit.ToString(), hashAuxBlockExpected.ToString());
-    }
-    LogPrintf("CheckAuxPowProofOfWork: Commitment hash verified.\n");
-
-
-    // Optional: If using vChainMerkleBranch, verify it here.
-
-    // Check against reusing the same parent block PoW for multiple aux blocks.
-    {
-        LOCK(cs_main); // Lock cs_main to access the global set
-        if (setAuxPowScannedParentHashes.count(block.m_auxpow->GetParentBlockHash())) {
-            LogPrintf("CheckAuxPowProofOfWork failed: Duplicate AuxPoW parent block hash %s\n", block.m_auxpow->GetParentBlockHash().ToString());
-            return error("%s: duplicate proof-of-work parent block hash", __func__);
-        }
-        // Add hash to the set in validation.cpp ConnectBlock/ActivateBestChain
-    }
-     LogPrintf("CheckAuxPowProofOfWork: Parent block hash %s is not a duplicate (as far as checked here).\n", block.m_auxpow->GetParentBlockHash().ToString());
-
-
-    LogPrintf("CheckAuxPowProofOfWork: Block %s PASSED\n", block.GetHash().ToString());
-    return true;
-}
-// --- AuxPoW Ende ---
-
-// Behalte die originale CheckProofOfWork für Blöcke vor dem Hard Fork und für die AuxPoW-Parent-Block-Prüfung
 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
 {
     bool fNegative;
@@ -326,11 +139,11 @@ bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&
 
     // Check range
     if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
-        return error("CheckProofOfWork(): nBits (%08x) below minimum work (%s) or invalid", nBits, UintToArith256(params.powLimit).ToString());
+        return false;
 
     // Check proof of work matches claimed amount
     if (UintToArith256(hash) > bnTarget)
-        return error("CheckProofOfWork(): hash %s doesn't match nBits target %s", hash.ToString(), bnTarget.ToString());
+        return false;
 
     return true;
-}
\ No newline at end of file
+}
diff --git a/src/pow.h b/src/pow.h
index 5cab21d..72015fc 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -7,31 +7,18 @@
 #define PALLADIUM_POW_H
 
 #include <consensus/params.h>
+
 #include <stdint.h>
-#include <vector> // Hinzugefügt für std::vector
 
 class CBlockHeader;
 class CBlockIndex;
 class uint256;
-// --- AuxPoW Start ---
-class CBlock; // Forward declaration für CheckAuxPowProofOfWork
-// --- AuxPoW Ende ---
-
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
+unsigned int LwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params&);
 
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
 
-// --- AuxPoW Start ---
-/** Check whether the auxiliary proof-of-work satisfies the difficulty specified by nBits */
-bool CheckAuxPowProofOfWork(const CBlock& block, const Consensus::Params& params);
-
-// Deklaration für LwmaCalculateNextWorkRequired (bereits in deiner pow.cpp vorhanden)
-unsigned int LwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params&);
-// Deklaration für ComputeMerkleRootFromBranch (in block.cpp hinzugefügt)
-uint256 ComputeMerkleRootFromBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex);
-// --- AuxPoW Ende ---
-
-#endif // PALLADIUM_POW_H
\ No newline at end of file
+#endif // PALLADIUM_POW_H
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index 5dab267..cfdf723 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -7,69 +7,17 @@
 
 #include <hash.h>
 #include <tinyformat.h>
-// --- AuxPoW Start ---
-#include <consensus/merkle.h> // Für ComputeMerkleRootFromBranch
-#include <util/strencodings.h> // Für HexStr (in CAuxPow::ToString)
-#include <crypto/common.h> // Für BEGIN/END Makros (in ComputeMerkleRootFromBranch)
-// --- AuxPoW Ende ---
-
-
-// --- AuxPoW Start ---
-// Stolen from Bitcoin documentation - Calculate the Merkle root for a branch.
-// Note: This implementation assumes the branch is provided correctly for the Bitcoin Merkle tree structure.
-uint256 ComputeMerkleRootFromBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
-{
-    uint256 currentHash = hash;
-    for (const uint256& step : vMerkleBranch) {
-        if (nIndex & 1) { // If index is odd, the step is the left sibling
-            currentHash = Hash(BEGIN(step), END(step), BEGIN(currentHash), END(currentHash));
-        } else { // If index is even, the step is the right sibling
-            currentHash = Hash(BEGIN(currentHash), END(currentHash), BEGIN(step), END(step));
-        }
-        nIndex >>= 1; // Move up to the next level in the tree
-    }
-    return currentHash;
-}
-
-
-/* Calculates the Merkle root of the aux chain commitment branch.
-   Note: This assumes the commitment hash is placed correctly in the tree.
-   It might need adjustments based on how the commitment is structured. */
-uint256 CAuxPow::CheckChainMerkleBranch (uint256 hash, int nIndex) const
-{
-    // This implementation might be identical to CheckMerkleBranch if the structure is the same.
-    // If vChainMerkleBranch is typically empty because the commitment is within the coinbase tx's
-    // scriptSig, this function might not even be strictly necessary or could return a pre-calculated value.
-    // For now, let's assume it works like the main branch check.
-    if (vChainMerkleBranch.empty()) {
-         // If commitment is in coinbase, the root of this branch should be the same as the coinbase branch root
-         // Return the parent block's merkle root directly? Or maybe the hash itself if index is 0 and branch is empty?
-         // This needs careful verification against the exact commitment method. Let's return 0 for now.
-         return uint256(); // Indicate an issue or that this check isn't applicable
-    }
-    return ComputeMerkleRootFromBranch(hash, vChainMerkleBranch, nIndex);
-}
-
-// Implement ToString for CAuxPow for debugging
-std::string CAuxPow::ToString() const
-{
-    return strprintf("CAuxPow(parentblock=%s)", GetParentBlockHash().ToString());
-}
-// --- AuxPoW Ende ---
-
 
 uint256 CBlockHeader::GetHash() const
 {
-    // Header hash is always calculated the same way, regardless of AuxPoW.
     return SerializeHash(*this);
 }
 
 std::string CBlock::ToString() const
 {
     std::stringstream s;
-    s << strprintf("CBlock(hash=%s, powhash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
+    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
         GetHash().ToString(),
-        GetPoWHash().ToString(), // Zeige den PoW-relevanten Hash an
         nVersion,
         hashPrevBlock.ToString(),
         hashMerkleRoot.ToString(),
@@ -78,10 +26,5 @@ std::string CBlock::ToString() const
     for (const auto& tx : vtx) {
         s << "  " << tx->ToString() << "\n";
     }
-    // --- AuxPoW Start ---
-    if (IsAuxpow() && m_auxpow) {
-         s << "  " << m_auxpow->ToString() << "\n"; // Füge AuxPow Infos hinzu
-    }
-    // --- AuxPoW Ende ---
     return s.str();
-}
\ No newline at end of file
+}
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 82945f7..ca822d6 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -9,93 +9,11 @@
 #include <primitives/transaction.h>
 #include <serialize.h>
 #include <uint256.h>
-#include <memory> // Für std::shared_ptr
-#include <string> // Für std::string in ToString
-#include <sstream> // Für std::stringstream in ToString
-#include <vector> // Für std::vector
-
-// --- AuxPoW Start ---
-// Forward declaration
-class CBlock;
-class CBlockHeader; // Forward declaration hinzugefügt
-
-// Hilfsfunktion zur Berechnung des Merkle Roots aus einem Branch (Deklaration)
-uint256 ComputeMerkleRootFromBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex);
-
-/** Header for merge-mining data.
- */
-class CAuxPow
-{
-public:
-    CTransactionRef coinbaseTx; // Bitcoin Coinbase Transaction
-    uint256 hashBlock;          // Bitcoin Block Hash (Parent Block Hash) - Wird beim Serialisieren gesetzt/gelesen
-    std::vector<uint256> vMerkleBranch; // Merkle branch connecting coinbaseTx to Merkle root
-    int nIndex;                 // Index of coinbaseTx in parent block's Merkle tree
-
-    // Merkle branch connecting aux block hash commitment to Merkle root.
-    // This is used ONLY if the commitment is not in the coinbaseTx itself.
-    // Often empty if commitment is in coinbaseTx's scriptSig.
-    std::vector<uint256> vChainMerkleBranch;
-    int nChainIndex;
-
-    CBlockHeader parentBlock; // Bitcoin Block Header (Parent Block)
-
-    CAuxPow()
-    {
-        SetNull();
-    }
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(coinbaseTx);
-        READWRITE(hashBlock); // Hash of Coinbase Tx needed for CheckMerkleBranch
-        READWRITE(vMerkleBranch);
-        READWRITE(nIndex);
-        READWRITE(vChainMerkleBranch);
-        READWRITE(nChainIndex);
-        READWRITE(parentBlock);
-        if (ser_action.ForRead()) {
-             // Nach dem Lesen den korrekten Hash des Parent Blocks setzen
-             // hashBlock in der serialisierten Form ist oft der Coinbase Hash, nicht der Block Hash
-             // Wir verlassen uns auf GetParentBlockHash() für den korrekten PoW Hash
-        }
-    }
-
-    void SetNull()
-    {
-        coinbaseTx.reset();
-        hashBlock.SetNull(); // Dies sollte eher der Coinbase Tx Hash sein
-        vMerkleBranch.clear();
-        nIndex = 0;
-        vChainMerkleBranch.clear();
-        nChainIndex = 0;
-        parentBlock.SetNull();
-    }
-
-    // Prüft den Merkle Branch für die Coinbase Tx zum Parent Block Merkle Root
-    uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex) const
-    {
-        // Die Implementierung befindet sich jetzt in block.cpp
-        return ComputeMerkleRootFromBranch(hash, vMerkleBranch, nIndex);
-    }
-
-    // Get the hash of the corresponding Bitcoin block. Auxiliary PoW uses this hash as the proof of work.
-    uint256 GetParentBlockHash() const { return parentBlock.GetHash(); }
-
-    // Calculate the Merkle root of the aux chain commitment branch.
-    uint256 CheckChainMerkleBranch(uint256 hash, int nIndex) const;
-
-    std::string ToString() const; // Deklaration hinzugefügt
-};
-// --- AuxPoW Ende ---
-
 
 /** Nodes collect new transactions into a block, hash them into a hash tree,
  * and scan through nonce values to make the block's hash satisfy proof-of-work
- * requirements. When they solve the proof-of-work, they broadcast the block
- * to everyone and the block is added to the block chain. The first transaction
+ * requirements.  When they solve the proof-of-work, they broadcast the block
+ * to everyone and the block is added to the block chain.  The first transaction
  * in the block is a special one that creates a new coin owned by the creator
  * of the block.
  */
@@ -103,13 +21,6 @@ class CBlockHeader
 {
 public:
     // header
-    // --- AuxPoW Start ---
-    // Increment base version if other non-AuxPoW changes require it
-    static const int32_t BASE_VERSION=7;
-    // Define AuxPoW block version bit (Bit 8 = 256)
-    static const int32_t AUXPOW_VERSION_BIT = (1 << 8);
-    // --- AuxPoW Ende ---
-
     int32_t nVersion;
     uint256 hashPrevBlock;
     uint256 hashMerkleRoot;
@@ -136,7 +47,7 @@ public:
 
     void SetNull()
     {
-        nVersion = CBlockHeader::BASE_VERSION; // Standardversion setzen (ohne AuxPoW Bit)
+        nVersion = 0;
         hashPrevBlock.SetNull();
         hashMerkleRoot.SetNull();
         nTime = 0;
@@ -155,15 +66,6 @@ public:
     {
         return (int64_t)nTime;
     }
-
-    // --- AuxPoW Start ---
-    // Check if the block version indicates AuxPoW.
-    bool IsAuxpow() const
-    {
-        return nVersion & AUXPOW_VERSION_BIT;
-    }
-    // --- AuxPoW Ende ---
-
 };
 
 
@@ -173,11 +75,6 @@ public:
     // network and disk
     std::vector<CTransactionRef> vtx;
 
-    // --- AuxPoW Start ---
-    // memory only - Optional pointer to AuxPoW data
-    std::shared_ptr<CAuxPow> m_auxpow;
-    // --- AuxPoW Ende ---
-
     // memory only
     mutable bool fChecked;
 
@@ -189,7 +86,7 @@ public:
     CBlock(const CBlockHeader &header)
     {
         SetNull();
-        *((CBlockHeader*)this) = header;
+        *(static_cast<CBlockHeader*>(this)) = header;
     }
 
     ADD_SERIALIZE_METHODS;
@@ -197,46 +94,6 @@ public:
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
         READWRITEAS(CBlockHeader, *this);
-        // --- AuxPoW Start ---
-        // Serialize AuxPoW data only if the version bit is set
-        bool auxpowActive = IsAuxpow(); // Lese Version zuerst
-        if (auxpowActive) {
-            if (ser_action.ForRead()) {
-                // Erstelle das Objekt nur, wenn gelesen wird und es noch nicht existiert
-                if (!m_auxpow) {
-                    m_auxpow = std::make_shared<CAuxPow>();
-                }
-            } else {
-                 // Beim Schreiben: Stelle sicher, dass m_auxpow existiert, wenn das Bit gesetzt ist
-                 // (Sollte durch die Erstellungslogik sichergestellt sein, aber zur Sicherheit)
-                 if (!m_auxpow) {
-                      // Dies sollte nicht passieren, wenn der Block korrekt erstellt wurde
-                      // throw std::ios_base::failure("AuxPow flag set but AuxPow data missing for serialization");
-                      // Alternativ: Erstelle ein leeres Objekt (führt aber zu ungültigen Daten)
-                      m_auxpow = std::make_shared<CAuxPow>(); // Vorsicht hiermit
-                 }
-            }
-            // Serialisiere das Objekt (nur wenn Bit gesetzt)
-            READWRITE(*m_auxpow);
-
-            if (ser_action.ForRead()) {
-                 // Nach dem Lesen: Prüfe, ob das gelesene AuxPow-Objekt gültig ist
-                 // (z.B. ob der Parent Block Hash nicht Null ist)
-                 // Wenn nicht, setze m_auxpow zurück oder werfe Fehler
-                 if (m_auxpow->GetParentBlockHash().IsNull()) {
-                      // Potenziell ungültige AuxPow-Daten gelesen
-                      // throw std::ios_base::failure("Invalid AuxPow data read");
-                      m_auxpow.reset(); // Oder setze zurück
-                 }
-            }
-        } else {
-             // Wenn das AuxPow-Bit NICHT gesetzt ist
-             if (ser_action.ForRead()) {
-                 m_auxpow.reset(); // Stelle sicher, dass keine AuxPow-Daten gespeichert werden
-             }
-             // Beim Schreiben muss m_auxpow == nullptr sein (oder ignoriert werden)
-        }
-        // --- AuxPoW Ende ---
         READWRITE(vtx);
     }
 
@@ -244,9 +101,6 @@ public:
     {
         CBlockHeader::SetNull();
         vtx.clear();
-        // --- AuxPoW Start ---
-        m_auxpow.reset();
-        // --- AuxPoW Ende ---
         fChecked = false;
     }
 
@@ -262,21 +116,6 @@ public:
         return block;
     }
 
-    // --- AuxPoW Start ---
-    // Return the Block Hash used for Proof of Work verification.
-    // For normal blocks, it's the block's own hash.
-    // For AuxPoW blocks, it's the hash of the parent Bitcoin block.
-    uint256 GetPoWHash() const
-    {
-        if (IsAuxpow() && m_auxpow) {
-            // Stelle sicher, dass m_auxpow initialisiert ist
-            return m_auxpow->GetParentBlockHash();
-        } else {
-            return GetHash();
-        }
-    }
-    // --- AuxPoW Ende ---
-
     std::string ToString() const;
 };
 
@@ -313,4 +152,4 @@ struct CBlockLocator
     }
 };
 
-#endif // PALLADIUM_PRIMITIVES_BLOCK_H
\ No newline at end of file
+#endif // PALLADIUM_PRIMITIVES_BLOCK_H
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 8f15bd1..90114af 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -29,7 +29,7 @@
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
-#include <validation.h> // Für ::ChainActive(), cs_main, mapBlockIndex
+#include <validation.h>
 #include <validationinterface.h>
 #include <versionbitsinfo.h>
 #include <warnings.h>
@@ -37,28 +37,12 @@
 #include <memory>
 #include <stdint.h>
 
-#include <sync.h>        // Für cs_main Lock
-// --- AuxPoW Start ---
-// #include <pow.h> // Ist bereits oben inkludiert
-#include <primitives/block.h> // Für CBlockHeader::AUXPOW_VERSION_BIT und CBlock
-// --- AuxPoW Ende ---
-
-
-// --- AuxPoW Start ---
-// Magic Bytes for AuxPoW block hash commitment (aus pow.cpp)
-// Deklariere als extern, da in pow.cpp definiert
-extern const unsigned char pchAuxPowHeader[];
-// *** NEUE EINZIGARTIGE CHAIN ID *** (Hex für "plm" + 0x01 als Integer)
-const int32_t PALLADIUM_AUXPOW_CHAIN_ID = 0x706C6D01;
-// --- AuxPoW Ende ---
-
-namespace { // Begin anon namespace
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
  * or from the last difficulty change if 'lookup' is nonpositive.
  * If 'height' is nonnegative, compute the estimate at the time when a given block was found.
  */
-UniValue GetNetworkHashPS(int lookup, int height) {
+static UniValue GetNetworkHashPS(int lookup, int height) {
     CBlockIndex *pb = ::ChainActive().Tip();
 
     if (height >= 0 && height < ::ChainActive().Height())
@@ -68,9 +52,8 @@ UniValue GetNetworkHashPS(int lookup, int height) {
         return 0;
 
     // If lookup is -1, then use blocks since last difficulty change.
-    // Pass current height to DifficultyAdjustmentInterval
     if (lookup <= 0)
-        lookup = pb->nHeight % Params().GetConsensus().DifficultyAdjustmentInterval(pb->nHeight + 1) + 1;
+        lookup = pb->nHeight % Params().GetConsensus().DifficultyAdjustmentInterval() + 1;
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight)
@@ -95,7 +78,6 @@ UniValue GetNetworkHashPS(int lookup, int height) {
 
     return workDiff.getdouble() / timeDiff;
 }
-} // End anon namespace
 
 static UniValue getnetworkhashps(const JSONRPCRequest& request)
 {
@@ -104,7 +86,7 @@ static UniValue getnetworkhashps(const JSONRPCRequest& request)
                 "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
                 "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
                 {
-                    {"nblocks", RPCArg::Type::NUM, /* default */ "48", "The number of blocks, or -1 for blocks since last difficulty change."}, // Default geändert von 120 auf 48 (24h * 60min / 2min * 2 ?) -> Check logic
+                    {"nblocks", RPCArg::Type::NUM, /* default */ "48", "The number of blocks, or -1 for blocks since last difficulty change."},
                     {"height", RPCArg::Type::NUM, /* default */ "-1", "To estimate at the time of the given height."},
                 },
                 RPCResult{
@@ -116,13 +98,9 @@ static UniValue getnetworkhashps(const JSONRPCRequest& request)
             }.Check(request);
 
     LOCK(cs_main);
-    // Passe Default-Wert hier an, falls nötig (z.B. auf 720 für 24 Stunden bei 2 Min Blöcken)
-    return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 720, !request.params[1].isNull() ? request.params[1].get_int() : -1);
+    return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 48, !request.params[1].isNull() ? request.params[1].get_int() : -1);
 }
 
-// Internal function called by generatetoaddress and generatetodescriptor
-// WARNING: THIS FUNCTION MINES VIA CPU - DO NOT USE ON MAINNET UNLESS REGTEST/TESTNET
-//          IT IS EXTREMELY INEFFICIENT AND CANNOT GENERATE AUXPOW BLOCKS!
 static UniValue generateBlocks(const CTxMemPool& mempool, const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
 {
     int nHeightEnd = 0;
@@ -135,30 +113,9 @@ static UniValue generateBlocks(const CTxMemPool& mempool, const CScript& coinbas
     }
     unsigned int nExtraNonce = 0;
     UniValue blockHashes(UniValue::VARR);
-    const CChainParams& chainparams = Params();
-    const Consensus::Params& consensusParams = chainparams.GetConsensus();
-
     while (nHeight < nHeightEnd && !ShutdownRequested())
     {
-        // --- AuxPoW Check ---
-        bool fAuxPowActive = false;
-        {
-             LOCK(cs_main);
-             fAuxPowActive = (::ChainActive().Height() + 1 >= consensusParams.nAuxpowStartHeight);
-        }
-        if (fAuxPowActive && chainparams.NetworkIDString() != CBaseChainParams::REGTEST) {
-             // Verhindere CPU-Mining mit generate* RPCs, wenn AuxPoW aktiv ist (außer Regtest)
-             throw JSONRPCError(RPC_MISC_ERROR, "Cannot generate blocks via RPC when AuxPoW is active on this network. Use an external miner.");
-        }
-        // --- AuxPoW Check Ende ---
-
-        std::unique_ptr<CBlockTemplate> pblocktemplate;
-        try {
-            pblocktemplate = BlockAssembler(mempool, chainparams).CreateNewBlock(coinbase_script);
-        } catch (const std::exception& e) {
-             LogPrintf("GenerateBlocks: Error creating block template: %s\n", e.what());
-             throw JSONRPCError(RPC_INTERNAL_ERROR, "Could not create block template");
-        }
+        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(mempool, Params()).CreateNewBlock(coinbase_script));
         if (!pblocktemplate.get())
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         CBlock *pblock = &pblocktemplate->block;
@@ -166,44 +123,30 @@ static UniValue generateBlocks(const CTxMemPool& mempool, const CScript& coinbas
             LOCK(cs_main);
             IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);
         }
-
-        // Standard PoW Loop (nur relevant wenn AuxPoW nicht aktiv ist)
-        while (nMaxTries > 0 && pblock->nNonce < std::numeric_limits<uint32_t>::max() && !ShutdownRequested()) {
-            if (CheckProofOfWork(pblock->GetHash(), pblock->nBits, consensusParams)) {
-                 break; // Found a solution
-            }
+        while (nMaxTries > 0 && pblock->nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus()) && !ShutdownRequested()) {
             ++pblock->nNonce;
             --nMaxTries;
         }
-
         if (nMaxTries == 0 || ShutdownRequested()) {
             break;
         }
         if (pblock->nNonce == std::numeric_limits<uint32_t>::max()) {
-            // Update time and try again if nonce wrapped around
-             UpdateTime(pblock, consensusParams, ::ChainActive().Tip());
             continue;
         }
-
         std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
-        bool new_block = false; // Wird von ProcessNewBlock gesetzt
-        if (!ProcessNewBlock(chainparams, shared_pblock, true, &new_block)) {
-             LogPrintf("GenerateBlocks: ProcessNewBlock failed for block %s\n", pblock->GetHash().ToString());
+        if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr))
             throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
-        }
         ++nHeight;
         blockHashes.push_back(pblock->GetHash().GetHex());
     }
     return blockHashes;
 }
 
-
 static UniValue generatetodescriptor(const JSONRPCRequest& request)
 {
     RPCHelpMan{
         "generatetodescriptor",
-        "\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n"
-        "Note: This command can only be used on regtest networks. Use an external miner for mainnet/testnet.\n", // Warnung hinzugefügt
+        "\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n",
         {
             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated palladium to."},
@@ -220,14 +163,8 @@ static UniValue generatetodescriptor(const JSONRPCRequest& request)
     }
         .Check(request);
 
-    // --- AuxPoW Check ---
-    if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
-        throw JSONRPCError(RPC_MISC_ERROR, "generatetodescriptor can only be used on regtest.");
-    }
-    // --- AuxPoW Check Ende ---
-
     const int num_blocks{request.params[0].get_int()};
-    const uint64_t max_tries{request.params[2].isNull() ? 1000000 : request.params[2].get_int64()}; // Verwende get_int64
+    const int64_t max_tries{request.params[2].isNull() ? 1000000 : request.params[2].get_int()};
 
     FlatSigningProvider key_provider;
     std::string error;
@@ -239,34 +176,23 @@ static UniValue generatetodescriptor(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptor not accepted. Maybe pass through deriveaddresses first?");
     }
 
-    // This Wallet context part might need adaptation depending on how wallet access is handled
-    // Assuming GetScriptPubKeyManFromDescriptor is available or adapt accordingly.
-    /*
-    ScriptPubKeyMan* spk_man = GetScriptPubKeyManFromDescriptor(*desc, key_provider, false); // internal = false
-    if (!spk_man) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Descriptor %s does not have keys", desc->ToString()));
-    }
-    const CScript script = spk_man->GetScript(); // Simplified: GetScript might need more context
-    */
-    // Alternative: Directly expand the descriptor to get scripts
     FlatSigningProvider provider;
-    std::vector<CScript> coinbase_scripts;
-    if (!desc->Expand(0, key_provider, coinbase_scripts, provider)) {
-       throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Cannot derive script without private keys for descriptor"));
+    std::vector<CScript> coinbase_script;
+    if (!desc->Expand(0, key_provider, coinbase_script, provider)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Cannot derive script without private keys"));
     }
-    CHECK_NONFATAL(coinbase_scripts.size() == 1); // Ensure only one script is derived
-    const CScript& script = coinbase_scripts[0];
 
-    const CTxMemPool& mempool = EnsureMemPool(); // Use EnsureMemPool to get reference
+    const CTxMemPool& mempool = EnsureMemPool();
 
-    return generateBlocks(mempool, script, num_blocks, max_tries);
+    CHECK_NONFATAL(coinbase_script.size() == 1);
+
+    return generateBlocks(mempool, coinbase_script.at(0), num_blocks, max_tries);
 }
 
 static UniValue generatetoaddress(const JSONRPCRequest& request)
 {
             RPCHelpMan{"generatetoaddress",
-                "\nMine blocks immediately to a specified address (before the RPC call returns)\n"
-                 "Note: This command can only be used on regtest networks. Use an external miner for mainnet/testnet.\n", // Warnung hinzugefügt
+                "\nMine blocks immediately to a specified address (before the RPC call returns)\n",
                 {
                     {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated palladium to."},
@@ -285,17 +211,10 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
                 },
             }.Check(request);
 
-    // --- AuxPoW Check ---
-    if (Params().NetworkIDString() != CBaseChainParams::REGTEST) {
-        throw JSONRPCError(RPC_MISC_ERROR, "generatetoaddress can only be used on regtest.");
-    }
-    // --- AuxPoW Check Ende ---
-
-
     int nGenerate = request.params[0].get_int();
     uint64_t nMaxTries = 1000000;
     if (!request.params[2].isNull()) {
-        nMaxTries = request.params[2].get_int64(); // Verwende get_int64
+        nMaxTries = request.params[2].get_int();
     }
 
     CTxDestination destination = DecodeDestination(request.params[1].get_str());
@@ -303,7 +222,7 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
     }
 
-    const CTxMemPool& mempool = EnsureMemPool(); // Use EnsureMemPool
+    const CTxMemPool& mempool = EnsureMemPool();
 
     CScript coinbase_script = GetScriptForDestination(destination);
 
@@ -333,33 +252,60 @@ static UniValue getmininginfo(const JSONRPCRequest& request)
                 },
             }.Check(request);
 
-
     LOCK(cs_main);
-    const CTxMemPool& mempool = EnsureMemPool(); // Use EnsureMemPool
-    const CChainParams& chainparams = Params();
+    const CTxMemPool& mempool = EnsureMemPool();
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("blocks",           (int)::ChainActive().Height());
-    // Referenziere die statischen Member korrekt (abhängig von deiner BlockAssembler Implementierung)
     if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
     if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
     obj.pushKV("difficulty",       (double)GetDifficulty(::ChainActive().Tip()));
-    // Pass a copy of the request to getnetworkhashps if needed, or adjust getnetworkhashps to not need it.
-    // Making a dummy request for getnetworkhashps call.
-    JSONRPCRequest netHashRequest = request; // Copy request for sub-call context if needed
-    netHashRequest.params = UniValue(UniValue::VARR); // Clear params for default behavior
-    netHashRequest.params.append(720); // Default blocks (e.g., 24h)
-    netHashRequest.params.append(-1);  // Default height
-    obj.pushKV("networkhashps",    getnetworkhashps(netHashRequest)); // Use modified request
+    obj.pushKV("networkhashps",    getnetworkhashps(request));
     obj.pushKV("pooledtx",         (uint64_t)mempool.size());
-    obj.pushKV("chain",            chainparams.NetworkIDString());
-    obj.pushKV("warnings",         GetWarnings(false).original); // Assuming GetWarnings exists and returns struct/object with .original
+    obj.pushKV("chain",            Params().NetworkIDString());
+    obj.pushKV("warnings",         GetWarnings(false));
     return obj;
 }
 
 
+// NOTE: Unlike wallet RPC (which use PLM values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
+static UniValue prioritisetransaction(const JSONRPCRequest& request)
+{
+            RPCHelpMan{"prioritisetransaction",
+                "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
+                {
+                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
+                    {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "API-Compatibility for previous API. Must be zero or null.\n"
+            "                  DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
+                    {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
+            "                  Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
+            "                  The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
+            "                  considers the transaction as it would have paid a higher (or lower) fee."},
+                },
+                RPCResult{
+                    RPCResult::Type::BOOL, "", "Returns true"},
+                RPCExamples{
+                    HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
+            + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
+                },
+            }.Check(request);
+
+    LOCK(cs_main);
+
+    uint256 hash(ParseHashV(request.params[0], "txid"));
+    CAmount nAmount = request.params[2].get_int64();
+
+    if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
+    }
+
+    EnsureMemPool().PrioritiseTransaction(hash, nAmount);
+    return true;
+}
+
+
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be handled by caller
-static UniValue BIP22ValidationResult(const BlockValidationState& state) // Verwende BlockValidationState
+static UniValue BIP22ValidationResult(const BlockValidationState& state)
 {
     if (state.IsValid())
         return NullUniValue;
@@ -370,188 +316,22 @@ static UniValue BIP22ValidationResult(const BlockValidationState& state) // Verw
     {
         std::string strRejectReason = state.GetRejectReason();
         if (strRejectReason.empty())
-            return "rejected"; // Default rejection string
-        // Map specific results to BIP22 strings
-        if (state.GetResult() == BlockValidationResult::BLOCK_HEADER_DUPLICATE || state.GetResult() == BlockValidationResult::BLOCK_INVALID_HEADER) {
-            // Check reason string for specifics
-            if (strRejectReason == "duplicate") return "duplicate";
-            if (strRejectReason == "duplicate-invalid") return "duplicate-invalid";
-        }
-        if (state.GetResult() == BlockValidationResult::BLOCK_INVALID_PREV) return "inconclusive-not-best-prevblk"; // Example
-        // Add more mappings if needed based on BlockValidationResult enums and reason strings
-
-        // Fallback to reason string or general 'rejected'
-        return strRejectReason; // Return reason string if available
+            return "rejected";
+        return strRejectReason;
     }
-    // Should be impossible?
-    return "valid?"; // Should not happen
+    // Should be impossible
+    return "valid?";
 }
 
-/* RBFStatus Logic adapted from Bitcoin Core - adjust based on your mempool implementation */
-// Assuming RBFTransactionState enum and IsRBFOptIn are defined elsewhere (e.g., policy/rbf.h/cpp or util/rbf.h/cpp)
-// RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
-
-static UniValue prioritisetransaction(const JSONRPCRequest& request)
-{
-            RPCHelpMan{"prioritisetransaction",
-                "\nAccepts the transaction into mined blocks at a higher (or lower) priority\n",
-                {
-                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
-                    {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "API-Compatibility for previous API. Must be zero or null.\n"
-             "                  DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
-                    {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
-             "                  Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
-             "                  The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
-             "                  considers the transaction as it would have paid a higher (or lower) fee."},
-                },
-                RPCResult{
-                    RPCResult::Type::BOOL, "", "Returns true"},
-                RPCExamples{
-                    HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
-            + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
-                },
-            }.Check(request);
-
-    // LOCK(cs_main); // Lock cs_main first if mempool requires it
-    LOCK(EnsureMemPool().cs); // Lock mempool directly
-
-    uint256 hash(ParseHashV(request.params[0], "txid"));
-    CAmount nAmount = request.params[2].get_int64();
-
-    if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
+static std::string gbt_vb_name(const Consensus::DeploymentPos pos) {
+    const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
+    std::string s = vbinfo.name;
+    if (!vbinfo.gbt_force) {
+        s.insert(s.begin(), '!');
     }
-
-    EnsureMemPool().PrioritiseTransaction(hash, nAmount); // Use EnsureMemPool()
-    return true;
+    return s;
 }
 
-
-// Helper functions for getblocktemplate proposal mode
-// Adaptations from Bitcoin Core - ensure types/methods match your codebase
-namespace { // Begin anon namespace
-struct GBTValidity {
-    std::shared_ptr<CBlock> pblock;
-    CBlockIndex* pindexPrev = nullptr; // Initialize to nullptr
-    BlockValidationState state; // Use BlockValidationState
-};
-
-// Simple handler for proposals (does basic checks)
-GBTValidity CheckBlockTemplateProposal(const UniValue& data, const CChainParams& chainparams) {
-    GBTValidity ret;
-    ret.pblock = std::make_shared<CBlock>();
-    CBlock& block = *ret.pblock;
-
-    if (!DecodeHexBlk(block, data.get_str())) {
-        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
-    }
-
-    uint256 hash = block.GetHash();
-    LOCK(cs_main);
-    // Use LookupBlockIndex directly
-    const CBlockIndex* pindex = LookupBlockIndex(hash);
-    if (pindex) {
-        if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
-             ret.state.Invalid(BlockValidationResult::BLOCK_HEADER_DUPLICATE, "duplicate", "duplicate");
-             return ret;
-        }
-        if (pindex->nStatus & BLOCK_FAILED_MASK) {
-             ret.state.Invalid(BlockValidationResult::BLOCK_HEADER_DUPLICATE, "duplicate-invalid", "duplicate-invalid");
-             return ret;
-        }
-    }
-
-    ret.pindexPrev = ::ChainActive().Tip();
-    // Only do basic validation package checks (context-free)
-    // Pass non-const pindexPrev
-    CBlockIndex* pindexPrevMut = ::ChainActive().Tip(); // Get mutable pointer if needed
-    if (!TestBlockValidity(ret.state, chainparams, block, pindexPrevMut, /*fCheckPOW=*/false, /*fCheckMerkleRoot=*/true)) {
-         LogPrintf("CheckBlockTemplateProposal: TestBlockValidity failed: %s\n", ret.state.ToString());
-         return ret;
-    }
-
-    return ret;
-}
-
-// Helper functions copied from rpc/blockchain.cpp for GBT response generation
-// Ensure these functions exist or adapt them.
-
-// Simplified TransactionsToJson - adapt based on actual fields needed by GBT
-UniValue TransactionsToJson(const std::vector<CAmount>& vTxFees, const std::vector<int64_t>& vTxSigOpsCost, const CBlock& block) {
-    UniValue transactions(UniValue::VARR);
-    std::map<uint256, int64_t> setTxIndex;
-    int i = 0;
-    for (const auto& tx : block.vtx) {
-         uint256 txHash = tx->GetHash();
-         setTxIndex[txHash] = i++;
-
-         if (tx->IsCoinBase()) continue;
-
-         UniValue entry(UniValue::VOBJ);
-         entry.pushKV("data", EncodeHexTx(*tx));
-         entry.pushKV("txid", txHash.GetHex());
-         entry.pushKV("hash", tx->GetWitnessHash().GetHex()); // Assuming GetWitnessHash exists
-
-         UniValue deps(UniValue::VARR);
-         for (const CTxIn &in : tx->vin) {
-             if (setTxIndex.count(in.prevout.hash))
-                 deps.push_back(setTxIndex[in.prevout.hash]);
-         }
-         entry.pushKV("depends", deps);
-
-         int index_in_template = i - 1;
-         if (index_in_template >= 0 && index_in_template < vTxFees.size()) {
-             entry.pushKV("fee", vTxFees[index_in_template]);
-         }
-         if (index_in_template >= 0 && index_in_template < vTxSigOpsCost.size()) {
-             entry.pushKV("sigops", vTxSigOpsCost[index_in_template]); // SigOpsCost might need scaling
-         }
-         entry.pushKV("weight", GetTransactionWeight(*tx)); // Assuming GetTransactionWeight exists
-
-         transactions.push_back(entry);
-    }
-    return transactions;
-}
-
-// Simplified CoinbaseAuxToJson - adapt based on actual fields
-UniValue CoinbaseAuxToJson(const std::vector<unsigned char>& vchCoinbaseCommitment) {
-    UniValue aux(UniValue::VOBJ);
-    // Example: Assuming commitment is just flags
-    // if (!vchCoinbaseCommitment.empty()) aux.pushKV("flags", HexStr(vchCoinbaseCommitment));
-    // Adapt based on what vchCoinbaseCommitment actually contains
-    return aux;
-}
-
-// Assuming BIP22Capabilities, BIP9RulesArray, GetMutableList exist
-UniValue BIP22Capabilities() {
-     UniValue capabilities(UniValue::VARR);
-     capabilities.push_back("proposal");
-     // Add other capabilities like "coinbasetxn", "coinbasevalue", "longpoll", etc.
-     return capabilities;
-}
-
-// Simplified BIP9RulesArray - adapt based on actual BIP9 logic
-UniValue BIP9RulesArray(const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams) {
-     UniValue rules(UniValue::VARR);
-     // Add currently active BIP9 rules based on pindexPrev height/state
-     rules.push_back("csv"); // Example
-     if (IsWitnessEnabled(pindexPrev, consensusParams)) {
-          rules.push_back("segwit"); // Example
-     }
-     return rules;
-}
-
-// Simplified GetMutableList - adapt based on actual mutable fields
-UniValue GetMutableList() {
-     UniValue mutables(UniValue::VARR);
-     mutables.push_back("time");
-     mutables.push_back("transactions");
-     mutables.push_back("prevblock");
-     return mutables;
-}
-
-} // End anon namespace
-
 static UniValue getblocktemplate(const JSONRPCRequest& request)
 {
             RPCHelpMan{"getblocktemplate",
@@ -563,91 +343,130 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
                 "    https://github.com/palladium/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
                 "    https://github.com/palladium/bips/blob/master/bip-0145.mediawiki\n",
                 {
-                    {"template_request", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "Format of the template",
+                    {"template_request", RPCArg::Type::OBJ, "{}", "Format of the template",
                         {
                             {"mode", RPCArg::Type::STR, /* treat as named arg */ RPCArg::Optional::OMITTED_NAMED_ARG, "This must be set to \"template\", \"proposal\" (see BIP 23), or omitted"},
                             {"capabilities", RPCArg::Type::ARR, /* treat as named arg */ RPCArg::Optional::OMITTED_NAMED_ARG, "A list of strings",
                                 {
                                     {"support", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported feature, 'longpoll', 'coinbasetxn', 'coinbasevalue', 'proposal', 'serverlist', 'workid'"},
                                 },
-                            },
-                            {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings", // Made mandatory by later check
+                                },
+                            {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings",
                                 {
                                     {"support", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported softfork deployment"},
                                 },
-                             },
+                                },
                         },
                         "\"template_request\""},
                 },
-                 RPCResult{
-                     RPCResult::Type::OBJ, "", "",
-                     {
-                         {RPCResult::Type::NUM, "version", "The preferred block version"},
-                         {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced", { {RPCResult::Type::STR, "", "rulename"}, }},
-                         {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments", { {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"}, }},
-                         {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
-                         {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
-                         {RPCResult::Type::ARR, "transactions", "contents of non-coinbase transactions that should be included in the next block", { {RPCResult::Type::OBJ, "", "", { /* ... transaction fields ... */ } } }},
-                         {RPCResult::Type::OBJ, "coinbaseaux", "data that should be included in the coinbase's scriptSig content", { {RPCResult::Type::ELISION, "", ""}, }},
-                         {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
-                         {RPCResult::Type::STR, "longpollid", "an ID to be used with the longpoll protocol"},
-                         {RPCResult::Type::STR, "target", "The hash target"},
-                         {RPCResult::Type::NUM_TIME, "mintime", "The minimum timestamp appropriate for the next block time, expressed in " + UNIX_EPOCH_TIME},
-                         {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed", { {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"}, }},
-                         {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
-                         {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
-                         {RPCResult::Type::NUM, "sizelimit", /* optional */ true, "limit of block size (deprecated)"},
-                         {RPCResult::Type::NUM, "weightlimit", /* optional */ true, "limit of block weight"},
-                         {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME},
-                         {RPCResult::Type::STR, "bits", "compressed target of next block"},
-                         {RPCResult::Type::NUM, "height", "The height of the next block"},
-                         // --- AuxPoW Start ---
-                         {RPCResult::Type::OBJ, "aux", /* optional */ true, "AuxPoW specific data (present if AuxPoW is active)", {
-                            {RPCResult::Type::STR_HEX, "flags", "Magic bytes identifying the AuxPoW commitment format"},
-                            {RPCResult::Type::NUM, "chainid", "Unique identifier for this chain"},
-                          }},
-                         {RPCResult::Type::BOOL, "submitold", /* optional */ true, "If false, submitblock expects AuxPoW data"},
-                         // --- AuxPoW Ende ---
-                         {RPCResult::Type::STR_HEX, "default_witness_commitment", /* optional */ true, "a valid witness commitment for the unmodified block template"},
-                     }},
+                RPCResult{
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::NUM, "version", "The preferred block version"},
+                        {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced",
+                            {
+                                {RPCResult::Type::STR, "", "rulename"},
+                            }},
+                        {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments",
+                            {
+                                {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
+                            }},
+                        {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
+                        {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
+                        {RPCResult::Type::ARR, "", "contents of non-coinbase transactions that should be included in the next block",
+                            {
+                                {RPCResult::Type::OBJ, "", "",
+                                    {
+                                        {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
+                                        {RPCResult::Type::STR_HEX, "txid", "transaction id encoded in little-endian hexadecimal"},
+                                        {RPCResult::Type::STR_HEX, "hash", "hash encoded in little-endian hexadecimal (including witness data)"},
+                                        {RPCResult::Type::ARR, "depends", "array of numbers",
+                                            {
+                                                {RPCResult::Type::NUM, "", "transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is"},
+                                            }},
+                                        {RPCResult::Type::NUM, "fee", "difference in value between transaction inputs and outputs (in satoshis); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one"},
+                                        {RPCResult::Type::NUM, "sigops", "total SigOps cost, as counted for purposes of block limits; if key is not present, sigop cost is unknown and clients MUST NOT assume it is zero"},
+                                        {RPCResult::Type::NUM, "weight", "total transaction weight, as counted for purposes of block limits"},
+                                    }},
+                            }},
+                        {RPCResult::Type::OBJ, "coinbaseaux", "data that should be included in the coinbase's scriptSig content",
+                        {
+                            {RPCResult::Type::ELISION, "", ""},
+                        }},
+                        {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
+                        {RPCResult::Type::OBJ, "coinbasetxn", "information for coinbase transaction",
+                        {
+                            {RPCResult::Type::ELISION, "", ""},
+                        }},
+                        {RPCResult::Type::STR, "target", "The hash target"},
+                        {RPCResult::Type::NUM_TIME, "mintime", "The minimum timestamp appropriate for the next block time, expressed in " + UNIX_EPOCH_TIME},
+                        {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed",
+                            {
+                                {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
+                            }},
+                        {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
+                        {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
+                        {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
+                        {RPCResult::Type::NUM, "weightlimit", "limit of block weight"},
+                        {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME},
+                        {RPCResult::Type::STR, "bits", "compressed target of next block"},
+                        {RPCResult::Type::NUM, "height", "The height of the next block"},
+                    }},
                 RPCExamples{
                     HelpExampleCli("getblocktemplate", "'{\"rules\": [\"segwit\"]}'")
             + HelpExampleRpc("getblocktemplate", "{\"rules\": [\"segwit\"]}")
                 },
             }.Check(request);
 
-    // NodeContext& node = EnsureNodeContext(request.context); // NodeContext nicht verfügbar?
-    // ChainstateManager& chainman = EnsureChainman(node);
-
     LOCK(cs_main);
 
     std::string strMode = "template";
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
-    int64_t nMaxVersionPreVB = -1; // Not relevant for newer versions?
+    int64_t nMaxVersionPreVB = -1;
     if (!request.params[0].isNull())
     {
         const UniValue& oparam = request.params[0].get_obj();
         const UniValue& modeval = find_value(oparam, "mode");
         if (modeval.isStr())
             strMode = modeval.get_str();
-        else if (modeval.isNull()) { /* Do nothing */ }
+        else if (modeval.isNull())
+        {
+            /* Do nothing */
+        }
         else
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
         lpval = find_value(oparam, "longpollid");
 
-        // Handle proposal mode
         if (strMode == "proposal")
         {
             const UniValue& dataval = find_value(oparam, "data");
             if (!dataval.isStr())
                 throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
 
-            GBTValidity validity = CheckBlockTemplateProposal(dataval, Params());
-            return BIP22ValidationResult(validity.state); // Return validation result
+            CBlock block;
+            if (!DecodeHexBlk(block, dataval.get_str()))
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
+
+            uint256 hash = block.GetHash();
+            const CBlockIndex* pindex = LookupBlockIndex(hash);
+            if (pindex) {
+                if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
+                    return "duplicate";
+                if (pindex->nStatus & BLOCK_FAILED_MASK)
+                    return "duplicate-invalid";
+                return "duplicate-inconclusive";
+            }
+
+            CBlockIndex* const pindexPrev = ::ChainActive().Tip();
+            // TestBlockValidity only supports blocks built on the current Tip
+            if (block.hashPrevBlock != pindexPrev->GetBlockHash())
+                return "inconclusive-not-best-prevblk";
+            BlockValidationState state;
+            TestBlockValidity(state, Params(), block, pindexPrev, false, true);
+            return BIP22ValidationResult(state);
         }
 
-        // Parse rules and capabilities for template mode
         const UniValue& aClientRules = find_value(oparam, "rules");
         if (aClientRules.isArray()) {
             for (unsigned int i = 0; i < aClientRules.size(); ++i) {
@@ -655,41 +474,29 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
                 setClientRules.insert(v.get_str());
             }
         } else {
-             // Fallback for older clients/no rules specified? BIP requires rules.
-             // throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing rules array");
+            // NOTE: It is important that this NOT be read if versionbits is supported
+            const UniValue& uvMaxVersion = find_value(oparam, "maxversion");
+            if (uvMaxVersion.isNum()) {
+                nMaxVersionPreVB = uvMaxVersion.get_int64();
+            }
         }
-
-        // Parse capabilities (optional)
-        const UniValue& capabilities = find_value(oparam, "capabilities");
-        if (capabilities.isArray()) {
-             // Process capabilities if needed, e.g., longpoll support
-        }
-        // maxversion (legacy, pre-BIP9)
-        const UniValue& uvMaxVersion = find_value(oparam, "maxversion");
-        if (uvMaxVersion.isNum()) {
-             nMaxVersionPreVB = uvMaxVersion.get_int64();
-        }
-
-    } // End parsing request.params[0]
-
-    if (strMode != "template")
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode"); // Should not happen
-
-    // Check P2P status
-    if (!g_connman)
-        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
-    if (g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0 && !Params().MineBlocksOnDemand())
-        throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Palladium is not connected!");
-    if (::ChainstateActive().IsInitialBlockDownload())
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Palladium is downloading blocks...");
-
-    // Check for segwit rule
-    if (setClientRules.count("segwit") == 0) {
-         throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the \"segwit\" rule set.");
     }
 
-    // Handle Long Poll
-    static unsigned int nTransactionsUpdatedLast; // Static variable for tracking mempool updates
+    if (strMode != "template")
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
+
+    if(!g_rpc_node->connman)
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+
+    if (g_rpc_node->connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+        throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
+
+    if (::ChainstateActive().IsInitialBlockDownload())
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
+
+    static unsigned int nTransactionsUpdatedLast;
+    const CTxMemPool& mempool = EnsureMemPool();
+
     if (!lpval.isNull())
     {
         // Wait to respond until either the best block changes, OR a minute has passed and there are more transactions
@@ -701,21 +508,13 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         {
             // Format: <hashBestChain><nTransactionsUpdatedLast>
             std::string lpstr = lpval.get_str();
-            if (lpstr.length() != 64 + std::to_string(nTransactionsUpdatedLast).length()) { // Basic format check
-                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid longpollid format");
-            }
 
             hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
-            // Use std::stoul for safer conversion
-            try {
-                nTransactionsUpdatedLastLP = std::stoul(lpstr.substr(64));
-            } catch (const std::exception& e) {
-                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid longpollid format (transaction count)");
-            }
+            nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
         }
         else
         {
-            // Use current state if longpollid is not a string (testing?)
+            // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
             hashWatchedChain = ::ChainActive().Tip()->GetBlockHash();
             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
         }
@@ -725,15 +524,16 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         {
             checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);
 
-            WAIT_LOCK(g_best_block_mutex, lock); // Assuming g_best_block_mutex/cv exist
-            while (g_best_block == hashWatchedChain && IsRPCRunning()) // Assuming g_best_block exists
+            WAIT_LOCK(g_best_block_mutex, lock);
+            while (g_best_block == hashWatchedChain && IsRPCRunning())
             {
                 if (g_best_block_cv.wait_until(lock, checktxtime) == std::cv_status::timeout)
                 {
                     // Timeout: Check transactions for update
-                    if (EnsureMemPool().GetTransactionsUpdated() != nTransactionsUpdatedLastLP)
+                    // without holding the mempool lock to avoid deadlocks
+                    if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP)
                         break;
-                    checktxtime += std::chrono::seconds(10); // Wait another 10 seconds
+                    checktxtime += std::chrono::seconds(10);
                 }
             }
         }
@@ -741,146 +541,188 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
 
         if (!IsRPCRunning())
             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
-        // Recheck initial conditions after wait
-        if (::ChainstateActive().IsInitialBlockDownload())
-             throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Palladium is downloading blocks...");
-        if (g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0 && !Params().MineBlocksOnDemand())
-             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Palladium is not connected!");
+        // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
+    }
 
-    } // End Long Poll Handling
+    // GBT must be called with 'segwit' set in the rules
+    if (setClientRules.count("segwit") != 1) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
+    }
 
-    const CChainParams& chainparams = Params();
-    const CTxMemPool& mempool = EnsureMemPool(); // Use EnsureMemPool
-
-    // Update block template if necessary
-    static CBlockIndex* pindexPrev = nullptr; // Static pindexPrev for caching template
-    static int64_t nStart = 0;
-    static std::unique_ptr<CBlockTemplate> pblocktemplate; // Static template
-
-    // Check if tip changed or mempool updated significantly
+    // Update block
+    static CBlockIndex* pindexPrev;
+    static int64_t nStart;
+    static std::unique_ptr<CBlockTemplate> pblocktemplate;
     if (pindexPrev != ::ChainActive().Tip() ||
         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5))
     {
-        // Clear previous template data
+        // Clear pindexPrev so future calls make a new block, despite any failures from here on
         pindexPrev = nullptr;
 
-        // Store current state
+        // Store the pindexBest used before CreateNewBlock, to avoid races
         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
         CBlockIndex* pindexPrevNew = ::ChainActive().Tip();
         nStart = GetTime();
 
-        // Create new block template
+        // Create new block
         CScript scriptDummy = CScript() << OP_TRUE;
-        try {
-            pblocktemplate = BlockAssembler(mempool, chainparams).CreateNewBlock(scriptDummy);
-        } catch (const std::runtime_error& e) {
-             throw JSONRPCError(RPC_INTERNAL_ERROR, e.what());
-        } catch (...) {
-             throw JSONRPCError(RPC_INTERNAL_ERROR, "Block template creation failed");
-        }
+        pblocktemplate = BlockAssembler(mempool, Params()).CreateNewBlock(scriptDummy);
         if (!pblocktemplate)
-            throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory"); // Or internal error
+            throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
 
-        // Update pindexPrev cache only on success
+        // Need to update only after we know CreateNewBlock succeeded
         pindexPrev = pindexPrevNew;
     }
-    CHECK_NONFATAL(pindexPrev); // Should be set if we got here
-    CBlock* pblock = &pblocktemplate->block; // Pointer for convenience
-    const Consensus::Params& consensusParams = chainparams.GetConsensus(); // Get consensus params
-    int nHeight = pindexPrev->nHeight + 1; // Correct height
+    CHECK_NONFATAL(pindexPrev);
+    CBlock* pblock = &pblocktemplate->block; // pointer for convenience
+    const Consensus::Params& consensusParams = Params().GetConsensus();
 
-    // Update nTime for the template (miners can adjust this)
+    // Update nTime
     UpdateTime(pblock, consensusParams, pindexPrev);
-    pblock->nNonce = 0; // Miner sets nonce
+    pblock->nNonce = 0;
+
+    // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
+    const bool fPreSegWit = (pindexPrev->nHeight + 1 < consensusParams.SegwitHeight);
+
+    UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
+
+    UniValue transactions(UniValue::VARR);
+    std::map<uint256, int64_t> setTxIndex;
+    int i = 0;
+    for (const auto& it : pblock->vtx) {
+        const CTransaction& tx = *it;
+        uint256 txHash = tx.GetHash();
+        setTxIndex[txHash] = i++;
+
+        if (tx.IsCoinBase())
+            continue;
+
+        UniValue entry(UniValue::VOBJ);
+
+        entry.pushKV("data", EncodeHexTx(tx));
+        entry.pushKV("txid", txHash.GetHex());
+        entry.pushKV("hash", tx.GetWitnessHash().GetHex());
+
+        UniValue deps(UniValue::VARR);
+        for (const CTxIn &in : tx.vin)
+        {
+            if (setTxIndex.count(in.prevout.hash))
+                deps.push_back(setTxIndex[in.prevout.hash]);
+        }
+        entry.pushKV("depends", deps);
+
+        int index_in_template = i - 1;
+        entry.pushKV("fee", pblocktemplate->vTxFees[index_in_template]);
+        int64_t nTxSigOps = pblocktemplate->vTxSigOpsCost[index_in_template];
+        if (fPreSegWit) {
+            CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
+            nTxSigOps /= WITNESS_SCALE_FACTOR;
+        }
+        entry.pushKV("sigops", nTxSigOps);
+        entry.pushKV("weight", GetTransactionWeight(tx));
+
+        transactions.push_back(entry);
+    }
+
+    UniValue aux(UniValue::VOBJ);
+
+    arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
+
+    UniValue aMutable(UniValue::VARR);
+    aMutable.push_back("time");
+    aMutable.push_back("transactions");
+    aMutable.push_back("prevblock");
 
-    // Populate reply
     UniValue result(UniValue::VOBJ);
-    result.pushKV("capabilities", BIP22Capabilities());
-    result.pushKV("rules", BIP9RulesArray(pindexPrev, consensusParams));
+    result.pushKV("capabilities", aCaps);
 
-    // Version bits info - Adapt based on your VersionBitsDeploymentInfo and caching logic
-    VersionBitsCache versionbitscache; // Local cache for this call
+    UniValue aRules(UniValue::VARR);
+    aRules.push_back("csv");
+    if (!fPreSegWit) aRules.push_back("!segwit");
     UniValue vbavailable(UniValue::VOBJ);
-    int32_t nVBMask = 0; // Required mask
     for (int j = 0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
         Consensus::DeploymentPos pos = Consensus::DeploymentPos(j);
         ThresholdState state = VersionBitsState(pindexPrev, consensusParams, pos, versionbitscache);
         switch (state) {
             case ThresholdState::DEFINED:
             case ThresholdState::FAILED:
+                // Not exposed to GBT at all
                 break;
             case ThresholdState::LOCKED_IN:
-                 // Set bit in required mask
-                 nVBMask |= VersionBitsMask(consensusParams, pos);
-                 // Fallthrough
+                // Ensure bit is set in block version
+                pblock->nVersion |= VersionBitsMask(consensusParams, pos);
+                // FALL THROUGH to get vbavailable set...
             case ThresholdState::STARTED:
-                 vbavailable.pushKV(VersionBitsDeploymentInfo[pos].name, consensusParams.vDeployments[pos].bit);
-                 break;
+            {
+                const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
+                vbavailable.pushKV(gbt_vb_name(pos), consensusParams.vDeployments[pos].bit);
+                if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
+                    if (!vbinfo.gbt_force) {
+                        // If the client doesn't support this, don't indicate it in the [default] version
+                        pblock->nVersion &= ~VersionBitsMask(consensusParams, pos);
+                    }
+                }
+                break;
+            }
             case ThresholdState::ACTIVE:
-                 // Already included in rules array
-                 break;
+            {
+                // Add to rules only
+                const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
+                aRules.push_back(gbt_vb_name(pos));
+                if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
+                    // Not supported by the client; make sure it's safe to proceed
+                    if (!vbinfo.gbt_force) {
+                        // If we do anything other than throw an exception here, be sure version/force isn't sent to old clients
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", vbinfo.name));
+                    }
+                }
+                break;
+            }
         }
     }
+    result.pushKV("version", pblock->nVersion);
+    result.pushKV("rules", aRules);
     result.pushKV("vbavailable", vbavailable);
-    result.pushKV("vbrequired", nVBMask);
+    result.pushKV("vbrequired", int(0));
 
+    if (nMaxVersionPreVB >= 2) {
+        // If VB is supported by the client, nMaxVersionPreVB is -1, so we won't get here
+        // Because BIP 34 changed how the generation transaction is serialized, we can only use version/force back to v2 blocks
+        // This is safe to do [otherwise-]unconditionally only because we are throwing an exception above if a non-force deployment gets activated
+        // Note that this can probably also be removed entirely after the first BIP9 non-force deployment (ie, probably segwit) gets activated
+        aMutable.push_back("version/force");
+    }
 
     result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
-    result.pushKV("transactions", TransactionsToJson(pblocktemplate->vTxFees, pblocktemplate->vTxSigOpsCost, *pblock));
-    result.pushKV("coinbaseaux", CoinbaseAuxToJson(pblocktemplate->vchCoinbaseCommitment));
+    result.pushKV("transactions", transactions);
+    result.pushKV("coinbaseaux", aux);
     result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
-    result.pushKV("longpollid", pindexPrev->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast)); // Use ToString
-    result.pushKV("target", ArithToUint256(arith_uint256().SetCompact(pblock->nBits)).GetHex());
+    result.pushKV("longpollid", ::ChainActive().Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast));
+    result.pushKV("target", hashTarget.GetHex());
     result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
-    result.pushKV("mutable", GetMutableList());
+    result.pushKV("mutable", aMutable);
     result.pushKV("noncerange", "00000000ffffffff");
-
-    // Limits based on Segwit status
     int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
-    int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE; // Might be MAX_BLOCK_BASE_SIZE in newer code
-    bool fUsingWitness = IsWitnessEnabled(pindexPrev, consensusParams);
-    if (fUsingWitness) {
-        result.pushKV("sigoplimit", nSigOpLimit);
-        result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
-    } else {
-        // Legacy limits calculation might differ based on version
-        // Using MAX_BLOCK_SIGOPS_COST / WITNESS_SCALE_FACTOR as an approximation
-        result.pushKV("sigoplimit", nSigOpLimit / WITNESS_SCALE_FACTOR);
-        result.pushKV("sizelimit", nSizeLimit); // Pre-segwit uses size limit
+    int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
+    if (fPreSegWit) {
+        CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
+        nSigOpLimit /= WITNESS_SCALE_FACTOR;
+        CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
+        nSizeLimit /= WITNESS_SCALE_FACTOR;
+    }
+    result.pushKV("sigoplimit", nSigOpLimit);
+    result.pushKV("sizelimit", nSizeLimit);
+    if (!fPreSegWit) {
+        result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
     }
-
     result.pushKV("curtime", pblock->GetBlockTime());
     result.pushKV("bits", strprintf("%08x", pblock->nBits));
-    result.pushKV("height", nHeight);
+    result.pushKV("height", (int64_t)(pindexPrev->nHeight+1));
 
-    // Add default witness commitment if segwit is active
-    if (fUsingWitness && !pblocktemplate->vchCoinbaseCommitment.empty()) {
-        result.pushKV("default_witness_commitment", HexStr(pblocktemplate->vchCoinbaseCommitment));
+    if (!pblocktemplate->vchCoinbaseCommitment.empty()) {
+        result.pushKV("default_witness_commitment", HexStr(pblocktemplate->vchCoinbaseCommitment.begin(), pblocktemplate->vchCoinbaseCommitment.end()));
     }
 
-
-    // --- AuxPoW Start ---
-    bool fAuxPowActive = (nHeight >= consensusParams.nAuxpowStartHeight);
-    if (fAuxPowActive) {
-        // Füge AuxPoW-spezifische Felder zum GBT hinzu
-        UniValue aux(UniValue::VOBJ);
-        // Flags sind die Magic Bytes
-        aux.pushKV("flags", HexStr(pchAuxPowHeader, pchAuxPowHeader + sizeof(pchAuxPowHeader)));
-        // Chain ID zur Unterscheidung
-        aux.pushKV("chainid", PALLADIUM_AUXPOW_CHAIN_ID); // Verwende die Konstante
-        result.pushKV("aux", aux);
-
-        // Signalisiere, dass AuxPoW benötigt wird
-        result.pushKV("submitold", false);
-
-         LogPrintf("getblocktemplate: AuxPoW active for height %d, adding aux fields.\n", nHeight);
-    } else {
-         LogPrintf("getblocktemplate: AuxPoW NOT active for height %d.\n", nHeight);
-    }
-    // Stelle sicher, dass die Version im Template das AuxPoW-Bit korrekt hat
-    result.pushKV("version", (int64_t)pblock->nVersion); // Setze die Version hier (überschreibt ggf. BIP9-Bits, was ok sein sollte)
-    // --- AuxPoW Ende ---
-
     return result;
 }
 
@@ -889,12 +731,12 @@ class submitblock_StateCatcher final : public CValidationInterface
 public:
     uint256 hash;
     bool found;
-    BlockValidationState state; // Verwende BlockValidationState
+    BlockValidationState state;
 
     explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), found(false), state() {}
 
 protected:
-    void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override { // Verwende BlockValidationState
+    void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override {
         if (block.GetHash() != hash)
             return;
         found = true;
@@ -907,7 +749,7 @@ static UniValue submitblock(const JSONRPCRequest& request)
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
             RPCHelpMan{"submitblock",
                 "\nAttempts to submit new block to network.\n"
-                "See https://en.palladium.it/wiki/BIP_0022 for full specification.\n", // Link angepasst
+                "See https://en.palladium.it/wiki/BIP_0022 for full specification.\n",
                 {
                     {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
                     {"dummy", RPCArg::Type::STR, /* default */ "ignored", "dummy value, for compatibility with BIP22. This value is ignored."},
@@ -925,54 +767,11 @@ static UniValue submitblock(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
     }
 
-    // --- AuxPoW Start ---
-    bool fBlockHasAuxPow = block.IsAuxpow();
-    bool fShouldHaveAuxPow = false;
-    int nHeight = 0;
-    const Consensus::Params& consensusParams = Params().GetConsensus();
-    {
-        LOCK(cs_main);
-        const CBlockIndex* pindexPrev = LookupBlockIndex(block.hashPrevBlock); // Verwende LookupBlockIndex
-        if (pindexPrev) {
-             nHeight = pindexPrev->nHeight + 1;
-             fShouldHaveAuxPow = (nHeight >= consensusParams.nAuxpowStartHeight);
-        } else if (block.GetHash() == consensusParams.hashGenesisBlock) {
-             nHeight = 0;
-             fShouldHaveAuxPow = (nHeight >= consensusParams.nAuxpowStartHeight); // Check height 0 case
-        } else {
-             LogPrintf("submitblock: Preceding block %s not found\n", block.hashPrevBlock.ToString());
-             // BIP22 expects specific strings on failure
-             // return "inconclusive - not-best-prevblk"; // This might be more appropriate than throwing
-             throw JSONRPCError(RPC_VERIFY_ERROR, "Block rejected: previous block not known");
-        }
-    }
-
-     LogPrintf("submitblock: Received block %s (height %d). ShouldHaveAuxPow=%d, HasAuxPow=%d\n",
-               block.GetHash().ToString(), nHeight, fShouldHaveAuxPow, fBlockHasAuxPow);
-
-    // Prüfe Konsistenz der AuxPoW-Version mit der Höhe
-    if (fShouldHaveAuxPow && !fBlockHasAuxPow) {
-         return "rejected: bad-auxpow-version-missing";
-    }
-    if (!fShouldHaveAuxPow && fBlockHasAuxPow) {
-         return "rejected: bad-auxpow-unexpected";
-    }
-    // Wenn AuxPoW erwartet wird, prüfe ob die Daten vorhanden sind (Deserialisierung sollte das getan haben)
-    if (fShouldHaveAuxPow && !block.m_auxpow) {
-         LogPrintf("submitblock: AuxPoW expected but m_auxpow is null for block %s\n", block.GetHash().ToString());
-         return "rejected: bad-auxpow-data-missing";
-    }
-    // --- AuxPoW Ende ---
-
-    // Check block basics before submitting (e.g., coinbase existence)
     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
-        // throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block does not start with a coinbase");
-        return "rejected: bad-cb-missing"; // BIP22 konformer
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block does not start with a coinbase");
     }
 
-
     uint256 hash = block.GetHash();
-    // Check if block already exists
     {
         LOCK(cs_main);
         const CBlockIndex* pindex = LookupBlockIndex(hash);
@@ -983,65 +782,41 @@ static UniValue submitblock(const JSONRPCRequest& request)
             if (pindex->nStatus & BLOCK_FAILED_MASK) {
                 return "duplicate-invalid";
             }
-            // Block already known but not fully validated/failed
-            // ProcessNewBlock will handle this case
         }
     }
 
-    // Check prev block again to update structures if needed
     {
         LOCK(cs_main);
         const CBlockIndex* pindex = LookupBlockIndex(block.hashPrevBlock);
         if (pindex) {
-             // UpdateUncommittedBlockStructures might be needed depending on codebase version
-             // If ProcessNewBlock handles this, it might not be needed here.
-             // UpdateUncommittedBlockStructures(block, pindex, consensusParams);
-        } else {
-             // Should have been caught earlier, but double-check
-             return "inconclusive - not-best-prevblk";
+            UpdateUncommittedBlockStructures(block, pindex, Params().GetConsensus());
         }
     }
 
-
-    bool new_block = false;
-    // Register ValidationInterface to catch the result state
+    bool new_block;
     auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
     RegisterSharedValidationInterface(sc);
-    // Call ProcessNewBlock
     bool accepted = ProcessNewBlock(Params(), blockptr, /* fForceProcessing */ true, /* fNewBlock */ &new_block);
     UnregisterSharedValidationInterface(sc);
-
-    // Check the result state captured by the interface
-    if (sc->found) {
-         // Block was processed, return the BIP22 result
-         return BIP22ValidationResult(sc->state);
-    }
-
-    // If BlockChecked was somehow not called (shouldn't happen if ProcessNewBlock was attempted)
-    // Fallback based on ProcessNewBlock return value
-    if (!accepted) {
-        // Generic rejection if state catcher failed but acceptance failed
-        return "rejected";
-    }
-    if (!new_block) {
-        // Block was accepted but not new (already known)
+    if (!new_block && accepted) {
         return "duplicate";
     }
-
-    // Should not be reached if state catcher worked
-    return NullUniValue; // Success
+    if (!sc->found) {
+        return "inconclusive";
+    }
+    return BIP22ValidationResult(sc->state);
 }
 
 static UniValue submitheader(const JSONRPCRequest& request)
 {
             RPCHelpMan{"submitheader",
-                "\nDecode header and submit it as a candidate chain tip if valid.\n"
-                "Throws when the header is invalid.\n"
-                 "WARNING: Incompatible with AuxPoW after the fork height.\n", // Warnung hinzugefügt
+                "\nDecode the given hexdata as a header and submit it as a candidate chain tip if valid."
+                "\nThrows when the header is invalid.\n",
                 {
                     {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
                 },
-                RPCResult{RPCResult::Type::NONE, "", "None"},
+                RPCResult{
+                    RPCResult::Type::NONE, "", "None"},
                 RPCExamples{
                     HelpExampleCli("submitheader", "\"aabbcc\"") +
                     HelpExampleRpc("submitheader", "\"aabbcc\"")
@@ -1052,42 +827,20 @@ static UniValue submitheader(const JSONRPCRequest& request)
     if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
     }
-
-    // --- AuxPoW Start ---
-    // Check if AuxPoW is active for the potential height of this header
-    const Consensus::Params& consensusParams = Params().GetConsensus();
-    int nHeight = 0; // Height this header *would* have
     {
-         LOCK(cs_main);
-         const CBlockIndex* pindexPrev = LookupBlockIndex(h.hashPrevBlock);
-         if (pindexPrev) {
-             nHeight = pindexPrev->nHeight + 1;
-         } else if (h.GetHash() == consensusParams.hashGenesisBlock) {
-             nHeight = 0;
-         } else {
-              throw JSONRPCError(RPC_VERIFY_ERROR, "Submitheader rejected: previous block not known");
-         }
-    }
-    if (nHeight >= consensusParams.nAuxpowStartHeight) {
-         throw JSONRPCError(RPC_INVALID_REQUEST, "Submitheader is incompatible with active AuxPoW");
-    }
-    // --- AuxPoW Ende ---
-
-    // NodeContext& node = EnsureNodeContext(request.context); // Nicht verfügbar?
-    // ChainstateManager& chainman = EnsureChainman(node);
-    BlockValidationState state; // Verwende BlockValidationState
-    // Direkter Aufruf von ProcessNewBlockHeaders
-    if (!ProcessNewBlockHeaders({h}, state, Params())) {
-        if (state.IsInvalid()) {
-             // Throw specific error based on state
-             throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
+        LOCK(cs_main);
+        if (!LookupBlockIndex(h.hashPrevBlock)) {
+            throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
         }
-        // Header was valid but didn't connect or wasn't better
-        // Silently return NullUniValue? Or indicate non-acceptance?
-        // Let's return Null for now as per original logic if not invalid/error
     }
 
-    return NullUniValue;
+    BlockValidationState state;
+    ProcessNewBlockHeaders({h}, state, Params());
+    if (state.IsValid()) return NullUniValue;
+    if (state.IsError()) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
+    }
+    throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
 }
 
 static UniValue estimatesmartfee(const JSONRPCRequest& request)
@@ -1100,28 +853,28 @@ static UniValue estimatesmartfee(const JSONRPCRequest& request)
                 {
                     {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
                     {"estimate_mode", RPCArg::Type::STR, /* default */ "CONSERVATIVE", "The fee estimate mode.\n"
-             "                  Whether to return a more conservative estimate which also satisfies\n"
-             "                  a longer history. A conservative estimate potentially returns a\n"
-             "                  higher feerate and is more likely to be sufficient for the desired\n"
-             "                  target, but is not as responsive to short term drops in the\n"
-             "                  prevailing fee market.  Must be one of:\n"
-             "      \"UNSET\"\n"
-             "      \"ECONOMICAL\"\n"
-             "      \"CONSERVATIVE\""},
+            "                   Whether to return a more conservative estimate which also satisfies\n"
+            "                   a longer history. A conservative estimate potentially returns a\n"
+            "                   higher feerate and is more likely to be sufficient for the desired\n"
+            "                   target, but is not as responsive to short term drops in the\n"
+            "                   prevailing fee market.  Must be one of:\n"
+            "       \"UNSET\"\n"
+            "       \"ECONOMICAL\"\n"
+            "       \"CONSERVATIVE\""},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
                     {
-                        {RPCResult::Type::NUM, "feerate", /* optional */ true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB (only present if no errors were encountered)"}, // kvB statt kB
-                        {RPCResult::Type::ARR, "errors", /* optional */ true, "Errors encountered during processing", // Optional gemacht
+                        {RPCResult::Type::NUM, "feerate", /* optional */ true, "estimate fee rate in " + CURRENCY_UNIT + "/kB (only present if no errors were encountered)"},
+                        {RPCResult::Type::ARR, "errors", "Errors encountered during processing",
                             {
                                 {RPCResult::Type::STR, "", "error"},
                             }},
                         {RPCResult::Type::NUM, "blocks", "block number where estimate was found\n"
-             "The request target will be clamped between 2 and the highest target\n"
-             "fee estimation is able to return based on how long it has been running.\n"
-             "An error is returned if not enough transactions and blocks\n"
-             "have been observed to make an estimate for any number of blocks."},
+            "The request target will be clamped between 2 and the highest target\n"
+            "fee estimation is able to return based on how long it has been running.\n"
+            "An error is returned if not enough transactions and blocks\n"
+            "have been observed to make an estimate for any number of blocks."},
                     }},
                 RPCExamples{
                     HelpExampleCli("estimatesmartfee", "6")
@@ -1130,12 +883,12 @@ static UniValue estimatesmartfee(const JSONRPCRequest& request)
 
     RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VSTR});
     RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
-    unsigned int max_target = ::feeEstimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE); // Assuming ::feeEstimator exists
-    unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target); // Assuming ParseConfirmTarget exists
+    unsigned int max_target = ::feeEstimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
+    unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
     bool conservative = true;
     if (!request.params[1].isNull()) {
         FeeEstimateMode fee_mode;
-        if (!FeeModeFromString(request.params[1].get_str(), fee_mode)) { // Assuming FeeModeFromString exists
+        if (!FeeModeFromString(request.params[1].get_str(), fee_mode)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid estimate_mode parameter");
         }
         if (fee_mode == FeeEstimateMode::ECONOMICAL) conservative = false;
@@ -1146,7 +899,7 @@ static UniValue estimatesmartfee(const JSONRPCRequest& request)
     FeeCalculation feeCalc;
     CFeeRate feeRate = ::feeEstimator.estimateSmartFee(conf_target, &feeCalc, conservative);
     if (feeRate != CFeeRate(0)) {
-        result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK())); // PerK or PerKVB?
+        result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
     } else {
         errors.push_back("Insufficient data or no feerate found");
         result.pushKV("errors", errors);
@@ -1160,23 +913,51 @@ static UniValue estimaterawfee(const JSONRPCRequest& request)
             RPCHelpMan{"estimaterawfee",
                 "\nWARNING: This interface is unstable and may disappear or change!\n"
                 "\nWARNING: This is an advanced API call that is tightly coupled to the specific\n"
-                "        implementation of fee estimation. The parameters it can be called with\n"
-                "        and the results it returns will change if the internal implementation changes.\n"
+                "         implementation of fee estimation. The parameters it can be called with\n"
+                "         and the results it returns will change if the internal implementation changes.\n"
                 "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
                 "confirmation within conf_target blocks if possible. Uses virtual transaction size as\n"
                 "defined in BIP 141 (witness data is discounted).\n",
                 {
                     {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
                     {"threshold", RPCArg::Type::NUM, /* default */ "0.95", "The proportion of transactions in a given feerate range that must have been\n"
-             "                  confirmed within conf_target in order to consider those feerates as high enough and proceed to check\n"
-             "                  lower buckets."},
+            "               confirmed within conf_target in order to consider those feerates as high enough and proceed to check\n"
+            "               lower buckets."},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "Results are returned for any horizon which tracks blocks up to the confirmation target",
                     {
-                        {RPCResult::Type::OBJ, "short", /* optional */ true, "estimate for short time horizon", { /* ... short fields ... */ }},
-                        {RPCResult::Type::OBJ, "medium", /* optional */ true, "estimate for medium time horizon", { /* ... medium fields ... */ }},
-                        {RPCResult::Type::OBJ, "long", /* optional */ true, "estimate for long time horizon", { /* ... long fields ... */ }},
+                        {RPCResult::Type::OBJ, "short", /* optional */ true, "estimate for short time horizon",
+                            {
+                                {RPCResult::Type::NUM, "feerate", /* optional */ true, "estimate fee rate in " + CURRENCY_UNIT + "/kB"},
+                                {RPCResult::Type::NUM, "decay", "exponential decay (per block) for historical moving average of confirmation data"},
+                                {RPCResult::Type::NUM, "scale", "The resolution of confirmation targets at this time horizon"},
+                                {RPCResult::Type::OBJ, "pass", /* optional */ true, "information about the lowest range of feerates to succeed in meeting the threshold",
+                                {
+                                        {RPCResult::Type::NUM, "startrange", "start of feerate range"},
+                                        {RPCResult::Type::NUM, "endrange", "end of feerate range"},
+                                        {RPCResult::Type::NUM, "withintarget", "number of txs over history horizon in the feerate range that were confirmed within target"},
+                                        {RPCResult::Type::NUM, "totalconfirmed", "number of txs over history horizon in the feerate range that were confirmed at any point"},
+                                        {RPCResult::Type::NUM, "inmempool", "current number of txs in mempool in the feerate range unconfirmed for at least target blocks"},
+                                        {RPCResult::Type::NUM, "leftmempool", "number of txs over history horizon in the feerate range that left mempool unconfirmed after target"},
+                                }},
+                                {RPCResult::Type::OBJ, "fail", /* optional */ true, "information about the highest range of feerates to fail to meet the threshold",
+                                {
+                                    {RPCResult::Type::ELISION, "", ""},
+                                }},
+                                {RPCResult::Type::ARR, "errors", /* optional */ true, "Errors encountered during processing",
+                                {
+                                    {RPCResult::Type::STR, "error", ""},
+                                }},
+                        }},
+                        {RPCResult::Type::OBJ, "medium", /* optional */ true, "estimate for medium time horizon",
+                        {
+                            {RPCResult::Type::ELISION, "", ""},
+                        }},
+                        {RPCResult::Type::OBJ, "long", /* optional */ true, "estimate for long time horizon",
+                        {
+                            {RPCResult::Type::ELISION, "", ""},
+                        }},
                     }},
                 RPCExamples{
                     HelpExampleCli("estimaterawfee", "6 0.9")
@@ -1197,18 +978,6 @@ static UniValue estimaterawfee(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VOBJ);
 
-    // Helper lambda to format bucket info
-    auto BucketToJson = [](const EstimationResult::EstimationBucket& bucket) {
-        UniValue bucket_obj(UniValue::VOBJ);
-        if (bucket.start >= 0) bucket_obj.pushKV("startrange", round(bucket.start)); // Use fee rate values
-        if (bucket.end >= 0) bucket_obj.pushKV("endrange", round(bucket.end));
-        bucket_obj.pushKV("withintarget", round(bucket.withinTarget * 100.0) / 100.0);
-        bucket_obj.pushKV("totalconfirmed", round(bucket.totalConfirmed * 100.0) / 100.0);
-        bucket_obj.pushKV("inmempool", round(bucket.inMempool * 100.0) / 100.0);
-        bucket_obj.pushKV("leftmempool", round(bucket.leftMempool * 100.0) / 100.0);
-        return bucket_obj;
-    };
-
     for (const FeeEstimateHorizon horizon : {FeeEstimateHorizon::SHORT_HALFLIFE, FeeEstimateHorizon::MED_HALFLIFE, FeeEstimateHorizon::LONG_HALFLIFE}) {
         CFeeRate feeRate;
         EstimationResult buckets;
@@ -1219,24 +988,38 @@ static UniValue estimaterawfee(const JSONRPCRequest& request)
         feeRate = ::feeEstimator.estimateRawFee(conf_target, threshold, horizon, &buckets);
         UniValue horizon_result(UniValue::VOBJ);
         UniValue errors(UniValue::VARR);
+        UniValue passbucket(UniValue::VOBJ);
+        passbucket.pushKV("startrange", round(buckets.pass.start));
+        passbucket.pushKV("endrange", round(buckets.pass.end));
+        passbucket.pushKV("withintarget", round(buckets.pass.withinTarget * 100.0) / 100.0);
+        passbucket.pushKV("totalconfirmed", round(buckets.pass.totalConfirmed * 100.0) / 100.0);
+        passbucket.pushKV("inmempool", round(buckets.pass.inMempool * 100.0) / 100.0);
+        passbucket.pushKV("leftmempool", round(buckets.pass.leftMempool * 100.0) / 100.0);
+        UniValue failbucket(UniValue::VOBJ);
+        failbucket.pushKV("startrange", round(buckets.fail.start));
+        failbucket.pushKV("endrange", round(buckets.fail.end));
+        failbucket.pushKV("withintarget", round(buckets.fail.withinTarget * 100.0) / 100.0);
+        failbucket.pushKV("totalconfirmed", round(buckets.fail.totalConfirmed * 100.0) / 100.0);
+        failbucket.pushKV("inmempool", round(buckets.fail.inMempool * 100.0) / 100.0);
+        failbucket.pushKV("leftmempool", round(buckets.fail.leftMempool * 100.0) / 100.0);
 
         // CFeeRate(0) is used to indicate error as a return value from estimateRawFee
         if (feeRate != CFeeRate(0)) {
-            horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK())); // PerK or PerKVB?
+            horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
             horizon_result.pushKV("decay", buckets.decay);
             horizon_result.pushKV("scale", (int)buckets.scale);
-             if (buckets.pass.start >= 0) horizon_result.pushKV("pass", BucketToJson(buckets.pass));
-             if (buckets.fail.start >= 0) horizon_result.pushKV("fail", BucketToJson(buckets.fail));
+            horizon_result.pushKV("pass", passbucket);
+            // buckets.fail.start == -1 indicates that all buckets passed, there is no fail bucket to output
+            if (buckets.fail.start != -1) horizon_result.pushKV("fail", failbucket);
         } else {
             // Output only information that is still meaningful in the event of error
             horizon_result.pushKV("decay", buckets.decay);
             horizon_result.pushKV("scale", (int)buckets.scale);
-            // Only output fail bucket if relevant data exists
-            if (buckets.fail.start >= 0) horizon_result.pushKV("fail", BucketToJson(buckets.fail));
+            horizon_result.pushKV("fail", failbucket);
             errors.push_back("Insufficient data or no feerate found which meets threshold");
             horizon_result.pushKV("errors",errors);
         }
-        result.pushKV(StringForFeeEstimateHorizon(horizon), horizon_result); // Assuming StringForFeeEstimateHorizon exists
+        result.pushKV(StringForFeeEstimateHorizon(horizon), horizon_result);
     }
     return result;
 }
@@ -1252,7 +1035,7 @@ static const CRPCCommand commands[] =
     { "mining",             "prioritisetransaction",  &prioritisetransaction,  {"txid","dummy","fee_delta"} },
     { "mining",             "getblocktemplate",       &getblocktemplate,       {"template_request"} },
     { "mining",             "submitblock",            &submitblock,            {"hexdata","dummy"} },
-//{ "mining",             "submitheader",           &submitheader,           {"hexdata"} }, // Keep commented out
+    { "mining",             "submitheader",           &submitheader,           {"hexdata"} },
 
 
     { "generating",         "generatetoaddress",      &generatetoaddress,      {"nblocks","address","maxtries"} },
@@ -1264,6 +1047,6 @@ static const CRPCCommand commands[] =
 };
 // clang-format on
 
-    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) // Verwende ARRAYLEN statt range-based for
+    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
-}
\ No newline at end of file
+}
diff --git a/src/validation.cpp b/src/validation.cpp
index c7a5b7d..56d296a 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -52,16 +52,6 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/thread.hpp>
 
-#include <map> // Für mapBlockIndex Zugriff
-
-// --- AuxPoW Start ---
-// Include block.h to access AuxPoW members
-#include <primitives/block.h>
-// Make setAuxPowScannedParentHashes accessible (defined in pow.cpp)
-extern std::set<uint256> setAuxPowScannedParentHashes GUARDED_BY(cs_main);
-// --- AuxPoW Ende ---
-
-
 #if defined(NDEBUG)
 # error "Palladium cannot be compiled without assertions."
 #endif
@@ -2200,19 +2190,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     int64_t nTime6 = GetTimeMicros(); nTimeCallbacks += nTime6 - nTime5;
     LogPrint(BCLog::BENCH, "    - Callbacks: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime6 - nTime5), nTimeCallbacks * MICRO, nTimeCallbacks * MILLI / nBlocksTotal);
 
-
-    // --- AuxPoW Start ---
-    // Mark parent block hash as used to prevent reuse
-    // const CBlock* pblock = pindex->GetBlock(); // Hol den Block vom Index
-    // In CChainState::ConnectBlock ist der Block als 'block' Parameter verfügbar
-    if (block.IsAuxpow() && block.m_auxpow) { // Prüfe den 'block' Parameter
-        AssertLockHeld(cs_main); // Sicherstellen, dass der Lock gehalten wird
-        setAuxPowScannedParentHashes.insert(block.m_auxpow->GetParentBlockHash());
-        LogPrintf("ConnectBlock: Added AuxPoW parent hash %s to used set for block %s (height %d)\n",
-                  block.m_auxpow->GetParentBlockHash().ToString(), block.GetHash().ToString(), pindex->nHeight);
-    }
-    // --- AuxPoW Ende ---
-
     return true;
 }
 
@@ -3292,38 +3269,11 @@ static bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos
 
 static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
 {
-// Alt:
-// Check proof of work matches claimed amount
-// if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
-//     return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
-//
-// return true;
+    // Check proof of work matches claimed amount
+    if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
 
-// Neu:
-if (fCheckPOW) {
-    // --- AuxPoW Integration Start ---
-    // Basic PoW check is now just a format check of nBits,
-    // because the actual hash requirement depends on AuxPoW status (height).
-    // The full check is done in CheckBlock where height context is available.
-    arith_uint256 bnTarget;
-    bool fNegative, fOverflow;
-    bnTarget.SetCompact(block.nBits, &fNegative, &fOverflow);
-
-    // Check range (Verwendet BlockValidationResult und neuere state.Invalid Syntax)
-    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(consensusParams.powLimit)) {
-         LogPrintf("CheckBlockHeader failed: nBits %08x invalid or out of range\n", block.nBits);
-         // Verwende die neuere state.Invalid Syntax mit BlockValidationResult
-         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "bits CBlockHeader check failed");
-    }
-    // --- AuxPoW Integration Ende ---
-}
-
-// Check timestamp (Diese Prüfung existiert bereits in deinem Code um Zeile 1104)
-// if (block.GetBlockTime() > GetAdjustedTime() + MAX_FUTURE_BLOCK_TIME)
-//    return state.Invalid(BlockValidationResult::BLOCK_TIMESTAMP_TOO_FAR_IN_FUTURE, "time-too-new", "block timestamp too far in the future");
-
-
-return true; // Behalte das return true am Ende der Funktion
+    return true;
 }
 
 bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
@@ -3335,64 +3285,7 @@ bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensu
 
     // Check that the header is valid (particularly PoW).  This is mostly
     // redundant with the call in AcceptBlockHeader.
-    if (!CheckBlockHeader(block, state, consensusParams,fCheckPOW))
-
-
-        // --- AuxPoW Proof of Work Check ---
-    if (fCheckPOW) { // Füge die Prüfung hinzu, ob fCheckPOW überhaupt true ist
-    const CBlockIndex* pindexPrev = nullptr;
-    int nHeight = 0; // Höhe des *aktuellen* Blocks
-    {
-        LOCK(cs_main);
-        BlockMap::const_iterator mi = mapBlockIndex.find(block.hashPrevBlock);
-        if (mi != mapBlockIndex.end()) {
-            pindexPrev = mi->second;
-            nHeight = pindexPrev->nHeight + 1;
-        } else if (block.GetHash() == consensusParams.hashGenesisBlock) {
-             // Genesis block has no previous block
-             nHeight = 0;
-        } else {
-             LogPrintf("CheckBlock failed: Previous block %s not found in mapBlockIndex for block %s\n", block.hashPrevBlock.ToString(), block.GetHash().ToString());
-             // Verwende die neuere state.Invalid Syntax mit BlockValidationResult
-             return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "prev-blk-not-found", "Previous block not found");
-        }
-    }
-
-    bool fIsAuxpow = block.IsAuxpow();
-    bool fShouldBeAuxpow = (nHeight >= consensusParams.nAuxpowStartHeight);
-
-    LogPrintf("CheckBlock PoW Check: Block height %d, AuxPoW Start Height %d. ShouldBeAuxpow=%d, IsAuxpow=%d\n",
-              nHeight, consensusParams.nAuxpowStartHeight, fShouldBeAuxpow, fIsAuxpow);
-
-    if (fShouldBeAuxpow) {
-        // After the fork height, AuxPoW MUST be signaled and valid
-        if (!fIsAuxpow) {
-            LogPrintf("CheckBlock failed: AuxPoW flag missing after fork height %d for block %s (height %d)\n", consensusParams.nAuxpowStartHeight, block.GetHash().ToString(), nHeight);
-            return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-auxpow-version-missing", "AuxPoW flag missing in block version after fork height");
-        }
-         LogPrintf("CheckBlock: Checking AuxPoW for block %s (height %d)\n", block.GetHash().ToString(), nHeight);
-        if (!CheckAuxPowProofOfWork(block, consensusParams)) {
-             // Error already logged in CheckAuxPowProofOfWork
-             // Verwende die neuere state.Invalid Syntax
-             return state.Invalid(BlockValidationResult::BLOCK_POW_INVALID, "bad-auxpow", "Auxiliary proof of work check failed");
-        }
-    } else {
-        // Before the fork height, AuxPoW MUST NOT be signaled, and standard PoW must be valid
-        if (fIsAuxpow) {
-             LogPrintf("CheckBlock failed: AuxPoW flag set before fork height %d for block %s (height %d)\n", consensusParams.nAuxpowStartHeight, block.GetHash().ToString(), nHeight);
-             return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-auxpow-unexpected", "AuxPoW flag set in block version before fork height");
-        }
-         LogPrintf("CheckBlock: Checking standard PoW for block %s (height %d)\n", block.GetHash().ToString(), nHeight);
-        if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) {
-            // Error already logged in CheckProofOfWork
-            // state.Invalid() wird in CheckProofOfWork in neueren Versionen nicht gesetzt,
-            // daher hier explizit setzen.
-            return state.Invalid(BlockValidationResult::BLOCK_POW_INVALID, "high-hash", "proof of work failed");
-        }
-    }
-} // End fCheckPOW
-// --- AuxPoW Ende ---
-
+    if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
         return false;
 
     // Check the merkle root.
@@ -3575,34 +3468,6 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
             return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
                                  strprintf("rejected nVersion=0x%08x block", block.nVersion));
 
-    // --- AuxPoW Start ---
-// Check version consistency with AuxPoW fork height
-// const Consensus::Params& consensusParams = params.GetConsensus(); // Hol dir Consensus::Params hier, falls nicht schon vorhanden
-bool fShouldBeAuxpow = (nHeight >= consensusParams.nAuxpowStartHeight); // nHeight sollte hier verfügbar sein
-bool fIsAuxpow = block.nVersion & CBlockHeader::AUXPOW_VERSION_BIT;
-
-if (fShouldBeAuxpow && !fIsAuxpow) {
-    LogPrintf("ContextualCheckBlockHeader failed: AuxPoW flag missing after fork height %d for block %s (height %d)\n", consensusParams.nAuxpowStartHeight, block.GetHash().ToString(), nHeight);
-    // Verwende die passende state.Invalid Syntax (BlockValidationResult oder ValidationInvalidReason)
-    return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-auxpow-version-missing-ctx", "AuxPoW flag missing in block version after fork height");
-}
-if (!fShouldBeAuxpow && fIsAuxpow) {
-     LogPrintf("ContextualCheckBlockHeader failed: AuxPoW flag set before fork height %d for block %s (height %d)\n", consensusParams.nAuxpowStartHeight, block.GetHash().ToString(), nHeight);
-     return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-auxpow-unexpected-ctx", "AuxPoW flag set in block version before fork height");
-}
-// Check base version bits if needed (e.g., BIP9) using VersionBitsState
-int32_t nBaseVersion = block.nVersion & ~CBlockHeader::AUXPOW_VERSION_BIT; // Check base version
-
-// Check against BIP 91/BIP 141/BIP 149 block version rules if applicable (Segwit related)
-// !!! ACHTUNG: Stelle sicher, dass `versionbitscache` hier verfügbar ist.
-// Wenn nicht, musst du es deklarieren oder die Funktion ohne Cache verwenden. !!!
-// VersionBitsCache versionbitscache; // Beispiel-Deklaration
-// if (!VersionBitsState(pindexPrev, consensusParams, Consensus::DEPLOYMENT_SEGWIT, versionbitscache).IsConsensusRequired(nBaseVersion)) {
-//     LogPrintf("ContextualCheckBlockHeader failed: Block version 0x%08x rejected by Segwit rules (height %d)\n", block.nVersion, nHeight);
-//     return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-version-segwit", "rejected by segwit activation");
-// }
-// --- AuxPoW Ende ---
-
     return true;
 }