diff --git a/src/Makefile.am b/src/Makefile.am
index 7a8e53cc34..c84454e189 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -206,6 +206,7 @@ BITCOIN_CORE_H = \
   noui.h \
   outputtype.h \
   pegins.h \
+  policy/discount.h \
   policy/feerate.h \
   policy/fees.h \
   policy/packages.h \
diff --git a/src/bench/rpc_blockchain.cpp b/src/bench/rpc_blockchain.cpp
index 2143bcf950..4c6a0bf6ea 100644
--- a/src/bench/rpc_blockchain.cpp
+++ b/src/bench/rpc_blockchain.cpp
@@ -15,7 +15,7 @@
 namespace {
 
 struct TestBlockAndIndex {
-    const std::unique_ptr<const TestingSetup> testing_setup{MakeNoLogFileContext<const TestingSetup>(CBaseChainParams::MAIN)};
+    std::unique_ptr<TestingSetup> testing_setup{MakeNoLogFileContext<TestingSetup>(CBaseChainParams::MAIN)};
     CBlock block{};
     uint256 blockHash{};
     CBlockIndex blockindex{};
@@ -28,6 +28,7 @@ struct TestBlockAndIndex {
 
         stream >> block;
 
+        CBlockIndex::SetNodeContext(&(testing_setup->m_node));
         blockHash = block.GetHash();
         blockindex.phashBlock = &blockHash;
         blockindex.nBits = 403014710;
diff --git a/src/chain.cpp b/src/chain.cpp
index dd5510bfec..113bc1d3cd 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -5,6 +5,11 @@
 
 #include <chain.h>
 #include <util/time.h>
+#include <validation.h>
+#include <node/context.h>
+
+
+node::NodeContext *CBlockIndex::m_pcontext;
 
 std::string CBlockFileInfo::ToString() const
 {
@@ -51,6 +56,27 @@ CBlockLocator CChain::GetLocator(const CBlockIndex *pindex) const {
     return CBlockLocator(vHave);
 }
 
+void CBlockIndex::untrim() EXCLUSIVE_LOCKS_REQUIRED(::cs_main){
+    AssertLockHeld(::cs_main);
+    if (!trimmed())
+        return;
+    CBlockIndex tmp;
+    const CBlockIndex *pindexfull = untrim_to(&tmp);
+    assert(pindexfull!=this);
+    m_trimmed = false;
+    set_stored();
+    proof = pindexfull->proof;
+    m_dynafed_params = pindexfull->m_dynafed_params;
+    m_signblock_witness = pindexfull->m_signblock_witness;
+    m_pcontext->chainman->m_blockman.m_dirty_blockindex.insert(this);
+}
+
+const CBlockIndex *CBlockIndex::untrim_to(CBlockIndex *pindexNew) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+{
+    AssertLockHeld(::cs_main);
+    return m_pcontext->chainman->m_blockman.m_block_tree_db->RegenerateFullIndex(this, pindexNew);
+}
+
 const CBlockIndex *CChain::FindFork(const CBlockIndex *pindex) const {
     if (pindex == nullptr) {
         return nullptr;
diff --git a/src/chain.h b/src/chain.h
index 76ba3b1880..119b3683a3 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -16,6 +16,9 @@
 
 #include <vector>
 
+namespace node {
+struct NodeContext;
+}
 /**
  * Maximum amount of time that a block timestamp is allowed to exceed the
  * current network-adjusted time before the block will be accepted.
@@ -215,26 +218,41 @@ class CBlockIndex
 
     bool m_trimmed{false};
     bool m_trimmed_dynafed_block{false};
+    bool m_stored_lvl{false};
 
     friend class CBlockTreeDB;
 
+    static node::NodeContext *m_pcontext;
+
 public:
+    static void SetNodeContext(node::NodeContext *context) {m_pcontext = context;};
 
     // Irrevocably remove blocksigning and dynafed-related stuff from this
     // in-memory copy of the block header.
-    void trim() {
+    bool trim() {
         assert_untrimmed();
+        if (!m_stored_lvl) {
+            // We can't trim in-memory data if it's not on disk yet, but we can if it's already been recovered once
+            return false;
+        }
         m_trimmed = true;
         m_trimmed_dynafed_block = !m_dynafed_params.value().IsNull();
         proof = std::nullopt;
         m_dynafed_params = std::nullopt;
         m_signblock_witness = std::nullopt;
+        return true;
     }
 
+    void untrim();
+    const CBlockIndex * untrim_to(CBlockIndex *pindexNew) const;
+
     inline bool trimmed() const {
         return m_trimmed;
     }
 
+    inline void set_stored() {
+        m_stored_lvl = true;
+    }
     inline void assert_untrimmed() const {
         assert(!m_trimmed);
     }
@@ -501,6 +519,9 @@ class CDiskBlockIndex : public CBlockIndex
 
         // For compatibility with elements 0.14 based chains
         if (g_signed_blocks) {
+            if (!ser_action.ForRead()) {
+                obj.assert_untrimmed();
+            }
             if (is_dyna) {
                 READWRITE(obj.m_dynafed_params.value());
                 READWRITE(obj.m_signblock_witness.value().stack);
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index a3ad97661c..e3f0114e76 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -223,6 +223,8 @@ class CMainParams : public CChainParams {
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
+        accept_discount_ct = false;
+        create_discount_ct = false;
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -361,6 +363,8 @@ class CTestNetParams : public CChainParams {
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
+        accept_discount_ct = false;
+        create_discount_ct = false;
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -517,6 +521,8 @@ class SigNetParams : public CChainParams {
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
+        accept_discount_ct = false;
+        create_discount_ct = false;
         consensus.has_parent_chain = false;
         g_signed_blocks = false; // lol
         g_con_elementsmode = false;
@@ -610,6 +616,8 @@ class CRegTestParams : public CChainParams {
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
+        accept_discount_ct = false;
+        create_discount_ct = false;
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -887,6 +895,8 @@ class CCustomParams : public CRegTestParams {
         const CScript default_script(CScript() << OP_TRUE);
         consensus.fedpegScript = StrHexToScriptWithDefault(args.GetArg("-fedpegscript", ""), default_script);
         consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
+        create_discount_ct = args.GetBoolArg("-creatediscountct", false);
+        accept_discount_ct = args.GetBoolArg("-acceptdiscountct", create_discount_ct);
 
         // Calculate pegged Bitcoin asset
         std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
@@ -1023,7 +1033,7 @@ class CLiquidTestNetParams : public CCustomParams {
  */
 class CLiquidV1Params : public CChainParams {
 public:
-    CLiquidV1Params()
+    explicit CLiquidV1Params(const ArgsManager& args)
     {
 
         strNetworkID = "liquidv1";
@@ -1118,6 +1128,8 @@ class CLiquidV1Params : public CChainParams {
         enforce_pak = true;
 
         multi_data_permitted = true;
+        create_discount_ct = args.GetBoolArg("-creatediscountct", false);
+        accept_discount_ct = args.GetBoolArg("-acceptdiscountct", false);
 
         parentGenesisBlockHash = uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
         const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
@@ -1261,7 +1273,7 @@ class CLiquidV1Params : public CChainParams {
  */
 class CLiquidV1TestParams : public CLiquidV1Params {
 public:
-    explicit CLiquidV1TestParams(const ArgsManager& args)
+    explicit CLiquidV1TestParams(const ArgsManager& args) : CLiquidV1Params(args)
     {
         // Our goal here is to override ONLY the things from liquidv1 that make no sense for a test chain / which are pointless and burdensome to require people to override manually.
 
@@ -1466,6 +1478,8 @@ class CLiquidV1TestParams : public CLiquidV1Params {
         enforce_pak = args.GetBoolArg("-enforce_pak", enforce_pak);
 
         multi_data_permitted = args.GetBoolArg("-multi_data_permitted", multi_data_permitted);
+        create_discount_ct = args.GetBoolArg("-creatediscountct", create_discount_ct);
+        accept_discount_ct = args.GetBoolArg("-acceptdiscountct", accept_discount_ct || create_discount_ct);
 
         if (args.IsArgSet("-parentgenesisblockhash")) {
             parentGenesisBlockHash = uint256S(args.GetArg("-parentgenesisblockhash", ""));
@@ -1557,7 +1571,7 @@ std::unique_ptr<const CChainParams> CreateChainParams(const ArgsManager& args, c
     } else if (chain == CBaseChainParams::REGTEST) {
         return std::unique_ptr<CChainParams>(new CRegTestParams(args));
     } else if (chain == CBaseChainParams::LIQUID1) {
-        return std::unique_ptr<CChainParams>(new CLiquidV1Params());
+        return std::unique_ptr<CChainParams>(new CLiquidV1Params(args));
     } else if (chain == CBaseChainParams::LIQUID1TEST) {
         return std::unique_ptr<CChainParams>(new CLiquidV1TestParams(args));
     } else if (chain == CBaseChainParams::LIQUIDTESTNET) {
diff --git a/src/chainparams.h b/src/chainparams.h
index c4a7e99eab..a80807a8eb 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -135,6 +135,8 @@ class CChainParams
     const std::string& ParentBlech32HRP() const { return parent_blech32_hrp; }
     bool GetEnforcePak() const { return enforce_pak; }
     bool GetMultiDataPermitted() const { return multi_data_permitted; }
+    bool GetAcceptDiscountCT() const { return accept_discount_ct; }
+    bool GetCreateDiscountCT() const { return create_discount_ct; }
 
 protected:
     CChainParams() {}
@@ -167,6 +169,8 @@ class CChainParams
     std::string parent_blech32_hrp;
     bool enforce_pak;
     bool multi_data_permitted;
+    bool accept_discount_ct;
+    bool create_discount_ct;
 };
 
 /**
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 1771ebe0de..d9fc2a7a59 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -9,6 +9,7 @@
 #include <consensus/validation.h>
 #include <issuance.h>
 #include <key_io.h>
+#include <policy/discount.h> // ELEMENTS
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sign.h>
@@ -236,6 +237,10 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
     entry.pushKV("version", static_cast<int64_t>(static_cast<uint32_t>(tx.nVersion)));
     entry.pushKV("size", (int)::GetSerializeSize(tx, PROTOCOL_VERSION));
     entry.pushKV("vsize", (GetTransactionWeight(tx) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR);
+    // ELEMENTS: add discountvsize
+    if (Params().GetAcceptDiscountCT()) {
+        entry.pushKV("discountvsize", GetDiscountVirtualTransactionSize(tx));
+    }
     entry.pushKV("weight", GetTransactionWeight(tx));
     entry.pushKV("locktime", (int64_t)tx.nLockTime);
 
diff --git a/src/dynafed.cpp b/src/dynafed.cpp
index 8ef680e296..d719795149 100644
--- a/src/dynafed.cpp
+++ b/src/dynafed.cpp
@@ -1,6 +1,8 @@
 
 #include <dynafed.h>
 #include <hash.h>
+#include <validation.h>
+#include <node/context.h>
 
 bool NextBlockIsParameterTransition(const CBlockIndex* pindexPrev, const Consensus::Params& consensus, DynaFedParamEntry& winning_entry)
 {
@@ -15,6 +17,10 @@ bool NextBlockIsParameterTransition(const CBlockIndex* pindexPrev, const Consens
     for (int32_t height = next_height - 1; height >= (int32_t)(next_height - consensus.dynamic_epoch_length); --height) {
         const CBlockIndex* p_epoch_walk = pindexPrev->GetAncestor(height);
         assert(p_epoch_walk);
+        if (node::fTrimHeaders) {
+            LOCK(cs_main);
+            ForceUntrimHeader(p_epoch_walk);
+        }
         const DynaFedParamEntry& proposal = p_epoch_walk->dynafed_params().m_proposed;
         const uint256 proposal_root = proposal.CalculateRoot();
         vote_tally[proposal_root]++;
@@ -60,6 +66,10 @@ DynaFedParamEntry ComputeNextBlockFullCurrentParameters(const CBlockIndex* pinde
     // may be pre-dynafed params
     const CBlockIndex* p_epoch_start = pindexPrev->GetAncestor(epoch_start_height);
     assert(p_epoch_start);
+    if (node::fTrimHeaders) {
+        LOCK(cs_main);
+        ForceUntrimHeader(p_epoch_start);
+    }
     if (p_epoch_start->dynafed_params().IsNull()) {
         // We need to construct the "full" current parameters of pre-dynafed
         // consensus
@@ -93,6 +103,10 @@ DynaFedParamEntry ComputeNextBlockCurrentParameters(const CBlockIndex* pindexPre
 {
     assert(pindexPrev);
 
+    if (node::fTrimHeaders) {
+        LOCK(cs_main);
+        ForceUntrimHeader(pindexPrev);
+    }
     DynaFedParamEntry entry = ComputeNextBlockFullCurrentParameters(pindexPrev, consensus);
 
     uint32_t next_height = pindexPrev->nHeight+1;
diff --git a/src/init.cpp b/src/init.cpp
index 2890ea4a67..f3098e7f4b 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -640,6 +640,8 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-initialreissuancetokens=<n>", "The amount of reissuance tokens created in the genesis block. (default: 0)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-ct_bits", strprintf("The default number of hiding bits in a rangeproof. Will be exceeded to cover amounts exceeding the maximum hiding value. (default: %d)", 52), ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-ct_exponent", strprintf("The hiding exponent. (default: %s)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-acceptdiscountct", "Accept discounted fees for Confidential Transactions (default: true for liquidv1, false for other chains)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-creatediscountct", "Create Confidential Transactions with discounted fees (default: false). Setting this to true will also set 'acceptdiscountct' to true.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
 
 #if defined(USE_SYSCALL_SANDBOX)
     argsman.AddArg("-sandbox=<mode>", "Use the experimental syscall sandbox in the specified mode (-sandbox=log-and-abort or -sandbox=abort). Allow only expected syscalls to be used by bitcoind. Note that this is an experimental new feature that may cause bitcoind to exit or crash unexpectedly: use with caution. In the \"log-and-abort\" mode the invocation of an unexpected syscall results in a debug handler being invoked which will log the incident and terminate the program (without executing the unexpected syscall). In the \"abort\" mode the invocation of an unexpected syscall results in the entire process being killed immediately by the kernel without executing the unexpected syscall.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
@@ -1009,13 +1011,13 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     }
 
     if (args.GetBoolArg("-trim_headers", false)) {
-        LogPrintf("Configured for header-trimming mode. This will reduce memory usage substantially, but we will be unable to serve as a full P2P peer, and certain header fields may be missing from JSON RPC output.\n");
+        LogPrintf("Configured for header-trimming mode. This will reduce memory usage substantially, but will increase IO usage when the headers need to be temporarily untrimmed.\n");
         node::fTrimHeaders = true;
         // This calculation is driven by GetValidFedpegScripts in pegins.cpp, which walks the chain
         //   back to current epoch start, and then an additional total_valid_epochs on top of that.
         //   We add one epoch here for the current partial epoch, and then another one for good luck.
 
-        node::nMustKeepFullHeaders = (chainparams.GetConsensus().total_valid_epochs + 2) * epoch_length;
+        node::nMustKeepFullHeaders = chainparams.GetConsensus().total_valid_epochs * epoch_length;
         // This is the number of headers we can have in flight downloading at a time, beyond the
         //   set of blocks we've already validated. Capping this is necessary to keep memory usage
         //   bounded during IBD.
@@ -1241,6 +1243,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     const ArgsManager& args = *Assert(node.args);
     const CChainParams& chainparams = Params();
 
+    CBlockIndex::SetNodeContext(&node);
     auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
     if (!opt_max_upload) {
         return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
@@ -1710,7 +1713,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // if pruning, unset the service bit and perform the initial blockstore prune
     // after any wallet rescanning has taken place.
-    if (fPruneMode || node::fTrimHeaders) {
+    if (fPruneMode) {
         LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
         nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
         if (!fReindex) {
@@ -1722,11 +1725,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }
 
-    if (node::fTrimHeaders) {
-        LogPrintf("Unsetting NODE_NETWORK_LIMITED on header trim mode\n");
-        nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK_LIMITED);
-    }
-
     // ********************************************************* Step 11: import blocks
 
     if (!CheckDiskSpace(gArgs.GetDataDirNet())) {
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index b7dc6da0fb..8ab454d3e0 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3305,12 +3305,13 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         for (; pindex; pindex = m_chainman.ActiveChain().Next(pindex))
         {
             if (pindex->trimmed()) {
-                // For simplicity, if any of the headers they're asking for are trimmed,
-                //   just drop the request.
-                LogPrint(BCLog::NET, "%s: ignoring getheaders from peer=%i which would return at least one trimmed header\n", __func__, pfrom.GetId());
-                return;
+                // Header is trimmed, reload from disk before sending
+                CBlockIndex tmpBlockIndexFull;
+                const CBlockIndex* pindexfull = pindex->untrim_to(&tmpBlockIndexFull);
+                vHeaders.push_back(pindexfull->GetBlockHeader());
+            } else {
+                vHeaders.push_back(pindex->GetBlockHeader());
             }
-            vHeaders.push_back(pindex->GetBlockHeader());
             if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
                 break;
         }
@@ -4964,7 +4965,9 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         auto txid = txinfo.tx->GetHash();
                         auto wtxid = txinfo.tx->GetWitnessHash();
                         // Peer told you to not send transactions at that feerate? Don't bother sending it.
-                        if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
+                        // ELEMENTS: use the discounted vsize here so that discounted CTs are relayed.
+                        // discountvsize only differs from vsize if accept_discount_ct is true.
+                        if (txinfo.fee < filterrate.GetFee(txinfo.discountvsize)) {
                             continue;
                         }
                         if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 63ed09fc40..fe96436012 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -223,15 +223,7 @@ bool BlockManager::LoadBlockIndex(
 {
     int trim_below_height = 0;
     if (fTrimHeaders) {
-        int max_height = 0;
-        if (!m_block_tree_db->WalkBlockIndexGutsForMaxHeight(&max_height)) {
-            LogPrintf("LoadBlockIndex: Failed to WalkBlockIndexGutsForMaxHeight.\n");
-            return false;
-        }
-
-        int must_keep_headers = (consensus_params.total_valid_epochs + 2) * consensus_params.dynamic_epoch_length;
-        int extra_headers_buffer = consensus_params.dynamic_epoch_length * 2; // XXX arbitrary
-        trim_below_height = max_height - must_keep_headers - extra_headers_buffer;
+        trim_below_height = std::numeric_limits<int>::max();
     }
     if (!m_block_tree_db->LoadBlockIndexGuts(consensus_params, [this](const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return this->InsertBlockIndex(hash); }, trim_below_height)) {
         return false;
@@ -337,6 +329,9 @@ bool BlockManager::LoadBlockIndex(
         }
     }
 
+    if (pindexBestHeader) {
+        ForceUntrimHeader(pindexBestHeader);
+    }
     return true;
 }
 
@@ -803,23 +798,6 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus
     return true;
 }
 
-bool ReadBlockHeaderFromDisk(CBlockHeader& header, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
-{
-    // Not very efficient: read a block and throw away all but the header.
-    CBlock tmp;
-    if (!ReadBlockFromDisk(tmp, pindex, consensusParams)) {
-        return false;
-    }
-    const FlatFilePos block_pos{WITH_LOCK(cs_main, return pindex->GetBlockPos())};
-
-    header = tmp.GetBlockHeader();
-    if (tmp.GetHash() != pindex->GetBlockHash()) {
-        return error("ReadBlockheaderFromDisk(CBlockHeader&, CBlockIndex*): GetHash() doesn't match index for %s at %s",
-                     pindex->ToString(), block_pos.ToString());
-    }
-    return true;
-}
-
 bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos, const CMessageHeader::MessageStartChars& message_start)
 {
     FlatFilePos hpos = pos;
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index c6621cde78..aceb775848 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -76,6 +76,7 @@ class BlockManager
 {
     friend CChainState;
     friend ChainstateManager;
+    friend CBlockIndex;
 
 private:
     void FlushBlockFile(bool fFinalize = false, bool finalize_undo = false);
@@ -193,7 +194,6 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
 bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos, const CMessageHeader::MessageStartChars& message_start);
 // ELEMENTS:
-bool ReadBlockHeaderFromDisk(class CBlockHeader& header, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
 
 bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex);
 
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index b8072bea29..4325f0a29f 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -320,6 +320,7 @@ int BlockAssembler::UpdatePackagesForAdded(const CTxMemPool::setEntries& already
             if (mit == mapModifiedTx.end()) {
                 CTxMemPoolModifiedEntry modEntry(desc);
                 modEntry.nSizeWithAncestors -= it->GetTxSize();
+                modEntry.discountSizeWithAncestors -= it->GetDiscountTxSize();
                 modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
                 modEntry.nSigOpCostWithAncestors -= it->GetSigOpCost();
                 mapModifiedTx.insert(modEntry);
@@ -383,7 +384,8 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
     // and modifying them for their already included ancestors
     UpdatePackagesForAdded(inBlock, mapModifiedTx);
 
-    CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = m_mempool.mapTx.get<ancestor_score>().begin();
+    // ELEMENTS: we use confidential_score instead of ancestor_score
+    CTxMemPool::indexed_transaction_set::index<confidential_score>::type::iterator mi = m_mempool.mapTx.get<confidential_score>().begin();
     CTxMemPool::txiter iter;
 
     // Limit the number of attempts to add transactions to the block when it is
@@ -392,9 +394,9 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
     const int64_t MAX_CONSECUTIVE_FAILURES = 1000;
     int64_t nConsecutiveFailed = 0;
 
-    while (mi != m_mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty()) {
+    while (mi != m_mempool.mapTx.get<confidential_score>().end() || !mapModifiedTx.empty()) {
         // First try to find a new transaction in mapTx to evaluate.
-        if (mi != m_mempool.mapTx.get<ancestor_score>().end() &&
+        if (mi != m_mempool.mapTx.get<confidential_score>().end() &&
             SkipMapTxEntry(m_mempool.mapTx.project<0>(mi), mapModifiedTx, failedTx)) {
             ++mi;
             continue;
@@ -404,16 +406,16 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
         // the next entry from mapTx, or the best from mapModifiedTx?
         bool fUsingModified = false;
 
-        modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
-        if (mi == m_mempool.mapTx.get<ancestor_score>().end()) {
+        modconftxscoreiter modit = mapModifiedTx.get<confidential_score>().begin();
+        if (mi == m_mempool.mapTx.get<confidential_score>().end()) {
             // We're out of entries in mapTx; use the entry from mapModifiedTx
             iter = modit->iter;
             fUsingModified = true;
         } else {
             // Try to compare the mapTx entry to the mapModifiedTx entry
             iter = m_mempool.mapTx.project<0>(mi);
-            if (modit != mapModifiedTx.get<ancestor_score>().end() &&
-                    CompareTxMemPoolEntryByAncestorFee()(*modit, CTxMemPoolModifiedEntry(iter))) {
+            if (modit != mapModifiedTx.get<confidential_score>().end() &&
+                    CompareTxMemPoolEntryByConfidentialFee()(*modit, CTxMemPoolModifiedEntry(iter))) {
                 // The best entry in mapModifiedTx has higher score
                 // than the one from mapTx.
                 // Switch which transaction (package) to consider
@@ -455,7 +457,7 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
                 // Since we always look at the best entry in mapModifiedTx,
                 // we must erase failed entries so that we can consider the
                 // next best entry on the next loop iteration
-                mapModifiedTx.get<ancestor_score>().erase(modit);
+                mapModifiedTx.get<confidential_score>().erase(modit);
                 failedTx.insert(iter);
             }
 
@@ -480,7 +482,7 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
         // Test if all tx's are Final
         if (!TestPackageTransactions(ancestors)) {
             if (fUsingModified) {
-                mapModifiedTx.get<ancestor_score>().erase(modit);
+                mapModifiedTx.get<confidential_score>().erase(modit);
                 failedTx.insert(iter);
             }
             continue;
diff --git a/src/node/miner.h b/src/node/miner.h
index e3ae1aca8b..45a9494e06 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -41,18 +41,22 @@ struct CTxMemPoolModifiedEntry {
     {
         iter = entry;
         nSizeWithAncestors = entry->GetSizeWithAncestors();
+        discountSizeWithAncestors = entry->GetDiscountSizeWithAncestors();
         nModFeesWithAncestors = entry->GetModFeesWithAncestors();
         nSigOpCostWithAncestors = entry->GetSigOpCostWithAncestors();
     }
 
     int64_t GetModifiedFee() const { return iter->GetModifiedFee(); }
     uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
+    uint64_t GetDiscountSizeWithAncestors() const { return discountSizeWithAncestors; }
     CAmount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
     size_t GetTxSize() const { return iter->GetTxSize(); }
+    size_t GetDiscountTxSize() const { return iter->GetDiscountTxSize(); }
     const CTransaction& GetTx() const { return iter->GetTx(); }
 
     CTxMemPool::txiter iter;
     uint64_t nSizeWithAncestors;
+    uint64_t discountSizeWithAncestors;
     CAmount nModFeesWithAncestors;
     int64_t nSigOpCostWithAncestors;
 };
@@ -103,12 +107,19 @@ typedef boost::multi_index_container<
             boost::multi_index::tag<ancestor_score>,
             boost::multi_index::identity<CTxMemPoolModifiedEntry>,
             CompareTxMemPoolEntryByAncestorFee
+        >,
+        // ELEMENTS
+        boost::multi_index::ordered_non_unique<
+            boost::multi_index::tag<confidential_score>,
+            boost::multi_index::identity<CTxMemPoolModifiedEntry>,
+            CompareTxMemPoolEntryByConfidentialFee
         >
     >
 > indexed_modified_transaction_set;
 
 typedef indexed_modified_transaction_set::nth_index<0>::type::iterator modtxiter;
 typedef indexed_modified_transaction_set::index<ancestor_score>::type::iterator modtxscoreiter;
+typedef indexed_modified_transaction_set::index<confidential_score>::type::iterator modconftxscoreiter; // ELEMENTS
 
 struct update_for_parent_inclusion
 {
diff --git a/src/pegins.cpp b/src/pegins.cpp
index 370ffcb83b..72551d2c3b 100644
--- a/src/pegins.cpp
+++ b/src/pegins.cpp
@@ -26,6 +26,8 @@
 // ELEMENTS
 //
 
+#include <validation.h>
+
 namespace {
 static secp256k1_context* secp256k1_ctx_validation;
 
@@ -487,6 +489,10 @@ std::vector<std::pair<CScript, CScript>> GetValidFedpegScripts(const CBlockIndex
             break;
         }
 
+        if (node::fTrimHeaders) {
+            LOCK(cs_main);
+            ForceUntrimHeader(p_epoch_start);
+        }
         if (!p_epoch_start->dynafed_params().IsNull()) {
             fedpegscripts.push_back(std::make_pair(p_epoch_start->dynafed_params().m_current.m_fedpeg_program, p_epoch_start->dynafed_params().m_current.m_fedpegscript));
         } else {
diff --git a/src/policy/discount.h b/src/policy/discount.h
new file mode 100644
index 0000000000..e8c3ece6e0
--- /dev/null
+++ b/src/policy/discount.h
@@ -0,0 +1,50 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2021 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POLICY_DISCOUNT_H
+#define BITCOIN_POLICY_DISCOUNT_H
+
+#include <consensus/consensus.h>
+#include <cstdint>
+#include <primitives/transaction.h>
+#include <version.h>
+
+/**
+ * Calculate a smaller virtual size for discounted Confidential Transactions.
+ */
+static inline int64_t GetDiscountVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost = 0, unsigned int bytes_per_sig_op = 0)
+{
+    int64_t size_bytes = ::GetSerializeSize(tx, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(tx, PROTOCOL_VERSION);
+    int64_t sigop_bytes = nSigOpCost * bytes_per_sig_op;
+
+    int64_t weight = std::max(size_bytes, sigop_bytes);
+
+    // for each confidential output
+    for (size_t i = 0; i < tx.vout.size(); ++i) {
+        const CTxOut& output = tx.vout[i];
+        if (i < tx.witness.vtxoutwit.size()) {
+            // subtract the weight of the output witness, except the 2 bytes used to serialize the empty proofs
+            size_t witness_size = ::GetSerializeSize(tx.witness.vtxoutwit[i], PROTOCOL_VERSION);
+            assert(witness_size >= 2);
+            weight -= (witness_size - 2);
+        }
+        if (output.nValue.IsCommitment()) {
+            // subtract the weight difference of amount commitment (33) vs explicit amount (9)
+            weight -= (33 - 9);
+        }
+        if (output.nNonce.IsCommitment()) {
+            // subtract the weight difference of nonce commitment (33) vs no nonce (1)
+            weight -= 32;
+        }
+    }
+    assert(weight > 0);
+
+    size_t discountvsize = (weight + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
+
+    assert(discountvsize > 0);
+    return discountvsize;
+}
+
+#endif // BITCOIN_POLICY_DISCOUNT_H
diff --git a/src/policy/policy.h b/src/policy/policy.h
index f7e34546ed..f62f9a8640 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -7,6 +7,7 @@
 #define BITCOIN_POLICY_POLICY_H
 
 #include <consensus/consensus.h>
+#include <policy/discount.h>
 #include <policy/feerate.h>
 #include <script/interpreter.h>
 #include <script/standard.h>
diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
index 028e52e964..7c128ba0ce 100644
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -48,6 +48,7 @@ void RPCNestedTests::rpcNestedTests()
 
     TestingSetup test;
     m_node.setContext(&test.m_node);
+    CBlockIndex::SetNodeContext(&test.m_node);
 
     if (RPCIsInWarmup(nullptr)) SetRPCWarmupFinished();
 
diff --git a/src/rest.cpp b/src/rest.cpp
index 754b55c2f8..f7376e814d 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -232,13 +232,10 @@ static bool rest_headers(const std::any& context,
     case RetFormat::BINARY: {
         CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
         for (const CBlockIndex *pindex : headers) {
-            if (pindex->trimmed()) {
-                CBlockHeader tmp;
-                node::ReadBlockHeaderFromDisk(tmp, pindex, Params().GetConsensus());
-                ssHeader << tmp;
-            } else {
-                ssHeader << pindex->GetBlockHeader();
-            }
+            LOCK(cs_main);
+            CBlockIndex tmpBlockIndexFull;
+            const CBlockIndex* pindexfull=pindex->untrim_to(&tmpBlockIndexFull);
+            ssHeader << pindexfull->GetBlockHeader();
         }
 
         std::string binaryHeader = ssHeader.str();
@@ -250,14 +247,10 @@ static bool rest_headers(const std::any& context,
     case RetFormat::HEX: {
         CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
         for (const CBlockIndex *pindex : headers) {
-            if (pindex->trimmed()) {
-                CBlockHeader tmp;
-                node::ReadBlockHeaderFromDisk(tmp, pindex, Params().GetConsensus());
-                ssHeader << tmp;
-
-            } else {
-                ssHeader << pindex->GetBlockHeader();
-            }
+            LOCK(cs_main);
+            CBlockIndex tmpBlockIndexFull;
+            const CBlockIndex* pindexfull=pindex->untrim_to(&tmpBlockIndexFull);
+            ssHeader << pindexfull->GetBlockHeader();
         }
 
         std::string strHex = HexStr(ssHeader) + "\n";
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 4f702b6bd5..03b6e44939 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -193,15 +193,22 @@ CBlockIndex* ParseHashOrHeight(const UniValue& param, ChainstateManager& chainma
     }
 }
 
-UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex)
+UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex_)
 {
     // Serialize passed information without accessing chain state of the active chain!
     AssertLockNotHeld(cs_main); // For performance reasons
 
+    CBlockIndex tmpBlockIndexFull;
+    const CBlockIndex* blockindex;
+    {
+        LOCK(cs_main);
+        blockindex = blockindex_->untrim_to(&tmpBlockIndexFull);
+    }
+
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex* pnext;
-    int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
+    int confirmations = ComputeNextBlockAndDepth(tip, blockindex_, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", blockindex->nVersion);
@@ -238,7 +245,7 @@ UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex
         }
     }
     result.pushKV("nTx", (uint64_t)blockindex->nTx);
-    if (blockindex->pprev)
+    if (blockindex_->pprev)
         result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());
     if (pnext)
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
@@ -1002,7 +1009,7 @@ static RPCHelpMan getblockheader()
     if (!request.params[1].isNull())
         fVerbose = request.params[1].get_bool();
 
-    const CBlockIndex* pblockindex;
+    CBlockIndex* pblockindex;
     const CBlockIndex* tip;
     {
         ChainstateManager& chainman = EnsureAnyChainman(request.context);
@@ -1017,14 +1024,11 @@ static RPCHelpMan getblockheader()
 
     if (!fVerbose)
     {
+        LOCK(cs_main);
         CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
-        if (pblockindex->trimmed()) {
-            CBlockHeader tmp;
-            node::ReadBlockHeaderFromDisk(tmp, pblockindex, Params().GetConsensus());
-            ssBlock << tmp;
-        } else {
-            ssBlock << pblockindex->GetBlockHeader();
-        }
+        CBlockIndex tmpBlockIndexFull;
+        const CBlockIndex* pblockindexfull=pblockindex->untrim_to(&tmpBlockIndexFull);
+        ssBlock << pblockindexfull->GetBlockHeader();
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
@@ -1737,6 +1741,7 @@ RPCHelpMan getblockchaininfo()
     }
     obj.pushKV("size_on_disk", chainman.m_blockman.CalculateCurrentUsage());
     obj.pushKV("pruned",                node::fPruneMode);
+    obj.pushKV("trim_headers",          node::fTrimHeaders); // ELEMENTS
     if (g_signed_blocks) {
         if (!DeploymentActiveAfter(tip, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DYNA_FED)) {
             CScript sign_block_script = chainparams.GetConsensus().signblockscript;
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 4ebd1c4f08..d1fe0394cb 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -19,6 +19,7 @@
 
 // ELEMENTS
 #include <block_proof.h> // CheckProof
+#include <chainparams.h> // Params()
 
 static constexpr uint8_t DB_COIN{'C'};
 static constexpr uint8_t DB_COINS{'c'};
@@ -330,39 +331,48 @@ bool CBlockTreeDB::WritePAKList(const std::vector<std::vector<unsigned char> >&
         return Write(std::make_pair(DB_PAK, uint256S("1")), offline_list) && Write(std::make_pair(DB_PAK, uint256S("2")), online_list) && Write(std::make_pair(DB_PAK, uint256S("3")), reject);
 }
 
-/** Note that we only get a conservative (lower) estimate of the max header height here,
- * obtained by sampling the first 10,000 headers on disk (which are in random order) and
- * taking the highest block we see. */
-bool CBlockTreeDB::WalkBlockIndexGutsForMaxHeight(int* nHeight) {
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-    *nHeight = 0;
-    int i = 0;
-    pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
-    while (pcursor->Valid()) {
-        if (ShutdownRequested()) return false;
-        std::pair<uint8_t, uint256> key;
-        if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
-            i++;
-            if (i > 10'000) {
-                // Under the (accurate) assumption that the headers on disk are effectively in random height order,
-                //   we have a good-enough (conservative) estimate of the max height very quickly, and don't need to
-                //   waste more time. Shortcutting like this will cause us to keep a few extra headers, which is fine.
-                break;
-            }
-            CDiskBlockIndex diskindex;
-            if (pcursor->GetValue(diskindex)) {
-                if (diskindex.nHeight > *nHeight) {
-                    *nHeight = diskindex.nHeight;
-                }
-                pcursor->Next();
-            } else {
-                return error("%s: failed to read value", __func__);
-            }
-        } else {
-            break;
-        }
+const CBlockIndex *CBlockTreeDB::RegenerateFullIndex(const CBlockIndex *pindexTrimmed, CBlockIndex *pindexNew) const
+{
+    LOCK(cs_main);
+
+    if(!pindexTrimmed->trimmed()) {
+        return pindexTrimmed;
     }
-    return true;
+    CBlockHeader tmp;
+    bool BlockRead = false;
+    {
+        // In unpruned nodes, same data could be read from blocks using ReadBlockFromDisk, but that turned out to
+        // be about 6x slower than reading from the index
+        std::pair<uint8_t, uint256> key(DB_BLOCK_INDEX, pindexTrimmed->GetBlockHash());
+        CDiskBlockIndex diskindex;
+        BlockRead = this->Read(key, diskindex);
+        tmp = diskindex.GetBlockHeader();
+    }
+    assert(BlockRead);
+    // Clone the needed data from the original trimmed block
+    pindexNew->pprev          = pindexTrimmed->pprev;
+    pindexNew->phashBlock     = pindexTrimmed->phashBlock;
+    // Construct block index object
+    pindexNew->nHeight        = pindexTrimmed->nHeight;
+    pindexNew->nFile          = pindexTrimmed->nFile;
+    pindexNew->nDataPos       = pindexTrimmed->nDataPos;
+    pindexNew->nUndoPos       = pindexTrimmed->nUndoPos;
+    pindexNew->nVersion       = pindexTrimmed->nVersion;
+    pindexNew->hashMerkleRoot = pindexTrimmed->hashMerkleRoot;
+    pindexNew->nTime          = pindexTrimmed->nTime;
+    pindexNew->nBits          = pindexTrimmed->nBits;
+    pindexNew->nNonce         = pindexTrimmed->nNonce;
+    pindexNew->nStatus        = pindexTrimmed->nStatus;
+    pindexNew->nTx            = pindexTrimmed->nTx;
+
+    pindexNew->proof               = tmp.proof;
+    pindexNew->m_dynafed_params    = tmp.m_dynafed_params;
+    pindexNew->m_signblock_witness = tmp.m_signblock_witness;
+
+    if (pindexTrimmed->nHeight && pindexTrimmed->nHeight % 1000 == 0) {
+        assert(CheckProof(pindexNew->GetBlockHeader(), Params().GetConsensus()));
+    }
+    return pindexNew;
 }
 
 bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, int trimBelowHeight)
@@ -396,23 +406,26 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
                 pindexNew->nStatus        = diskindex.nStatus;
                 pindexNew->nTx            = diskindex.nTx;
 
+                pindexNew->proof               = diskindex.proof;
+                pindexNew->m_dynafed_params    = diskindex.m_dynafed_params;
+                pindexNew->m_signblock_witness = diskindex.m_signblock_witness;
+
+                assert(!(g_signed_blocks && diskindex.m_dynafed_params.value().IsNull() && diskindex.proof.value().IsNull()));
+
+                pindexNew->set_stored();
                 n_total++;
+
+                const uint256 block_hash = pindexNew->GetBlockHash();
+                // Only validate one of every 1000 block header for sanity check
+                if (pindexNew->nHeight % 1000 == 0 &&
+                        block_hash != consensusParams.hashGenesisBlock &&
+                        !CheckProof(pindexNew->GetBlockHeader(), consensusParams)) {
+                    return error("%s: CheckProof: %s, %s", __func__, block_hash.ToString(), pindexNew->ToString());
+                }
                 if (diskindex.nHeight >= trimBelowHeight) {
                     n_untrimmed++;
-                    pindexNew->proof               = diskindex.proof;
-                    pindexNew->m_dynafed_params    = diskindex.m_dynafed_params;
-                    pindexNew->m_signblock_witness = diskindex.m_signblock_witness;
-
-                    const uint256 block_hash = pindexNew->GetBlockHash();
-                    // Only validate one of every 1000 block header for sanity check
-                    if (pindexNew->nHeight % 1000 == 0 &&
-                            block_hash != consensusParams.hashGenesisBlock &&
-                            !CheckProof(pindexNew->GetBlockHeader(), consensusParams)) {
-                        return error("%s: CheckProof: %s, %s", __func__, block_hash.ToString(), pindexNew->ToString());
-                    }
                 } else {
-                    pindexNew->m_trimmed = true;
-                    pindexNew->m_trimmed_dynafed_block = !diskindex.m_dynafed_params.value().IsNull();
+                    pindexNew->trim();
                 }
 
                 pcursor->Next();
diff --git a/src/txdb.h b/src/txdb.h
index aa28a0061e..1f3fab44dc 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -91,7 +91,7 @@ class CBlockTreeDB : public CDBWrapper
     bool LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, int trimBelowHeight)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
     // ELEMENTS:
-    bool WalkBlockIndexGutsForMaxHeight(int* nHeight);
+    const CBlockIndex *RegenerateFullIndex(const CBlockIndex *pindexTrimmed, CBlockIndex *pindexNew) const;
     bool ReadPAKList(std::vector<std::vector<unsigned char> >& offline_list, std::vector<std::vector<unsigned char> >& online_list, bool& reject);
     bool WritePAKList(const std::vector<std::vector<unsigned char> >& offline_list, const std::vector<std::vector<unsigned char> >& online_list, bool reject);
 };
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index c46b685b08..f84ffe4d23 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -13,6 +13,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <pegins.h>
+#include <policy/discount.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -43,18 +44,20 @@ struct update_descendant_state
 
 struct update_ancestor_state
 {
-    update_ancestor_state(int64_t _modifySize, CAmount _modifyFee, int64_t _modifyCount, int64_t _modifySigOpsCost) :
-        modifySize(_modifySize), modifyFee(_modifyFee), modifyCount(_modifyCount), modifySigOpsCost(_modifySigOpsCost)
+    update_ancestor_state(int64_t _modifySize, CAmount _modifyFee, int64_t _modifyCount, int64_t _modifySigOpsCost, int64_t _discountSize) :
+        modifySize(_modifySize), modifyFee(_modifyFee), modifyCount(_modifyCount), modifySigOpsCost(_modifySigOpsCost),
+        discountSize(_discountSize)
     {}
 
     void operator() (CTxMemPoolEntry &e)
-        { e.UpdateAncestorState(modifySize, modifyFee, modifyCount, modifySigOpsCost); }
+        { e.UpdateAncestorState(modifySize, modifyFee, modifyCount, modifySigOpsCost, discountSize); }
 
     private:
         int64_t modifySize;
         CAmount modifyFee;
         int64_t modifyCount;
         int64_t modifySigOpsCost;
+        int64_t discountSize;
 };
 
 struct update_fee_delta
@@ -102,6 +105,7 @@ CTxMemPoolEntry::CTxMemPoolEntry(const CTransactionRef& tx, CAmount fee,
       nSizeWithAncestors{GetTxSize()},
       nModFeesWithAncestors{nFee},
       nSigOpCostWithAncestors{sigOpCost},
+      discountSizeWithAncestors{GetDiscountTxSize()},
       setPeginsSpent(_setPeginsSpent) {}
 
 void CTxMemPoolEntry::UpdateFeeDelta(int64_t newFeeDelta)
@@ -121,6 +125,16 @@ size_t CTxMemPoolEntry::GetTxSize() const
     return GetVirtualTransactionSize(nTxWeight, sigOpCost);
 }
 
+size_t CTxMemPoolEntry::GetDiscountTxSize() const
+{
+    // discountvsize only differs from vsize if we accept discounted CTs
+    if (Params().GetAcceptDiscountCT()) {
+        return GetDiscountVirtualTransactionSize(*tx, sigOpCost, ::nBytesPerSigOp);
+    } else {
+        return GetVirtualTransactionSize(nTxWeight, sigOpCost);
+    }
+}
+
 void CTxMemPool::UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
                                       const std::set<uint256>& setExclude, std::set<uint256>& descendants_to_remove,
                                       uint64_t ancestor_size_limit, uint64_t ancestor_count_limit)
@@ -159,7 +173,7 @@ void CTxMemPool::UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendan
             modifyCount++;
             cachedDescendants[updateIt].insert(mapTx.iterator_to(descendant));
             // Update ancestor state for each descendant
-            mapTx.modify(mapTx.iterator_to(descendant), update_ancestor_state(updateIt->GetTxSize(), updateIt->GetModifiedFee(), 1, updateIt->GetSigOpCost()));
+            mapTx.modify(mapTx.iterator_to(descendant), update_ancestor_state(updateIt->GetTxSize(), updateIt->GetModifiedFee(), 1, updateIt->GetSigOpCost(), updateIt->GetDiscountTxSize()));
             // Don't directly remove the transaction here -- doing so would
             // invalidate iterators in cachedDescendants. Mark it for removal
             // by inserting into descendants_to_remove.
@@ -370,12 +384,14 @@ void CTxMemPool::UpdateEntryForAncestors(txiter it, const setEntries &setAncesto
     int64_t updateSize = 0;
     CAmount updateFee = 0;
     int64_t updateSigOpsCost = 0;
+    int64_t discountSize = 0;
     for (txiter ancestorIt : setAncestors) {
         updateSize += ancestorIt->GetTxSize();
         updateFee += ancestorIt->GetModifiedFee();
         updateSigOpsCost += ancestorIt->GetSigOpCost();
+        discountSize += ancestorIt->GetDiscountTxSize();
     }
-    mapTx.modify(it, update_ancestor_state(updateSize, updateFee, updateCount, updateSigOpsCost));
+    mapTx.modify(it, update_ancestor_state(updateSize, updateFee, updateCount, updateSigOpsCost, discountSize));
 }
 
 void CTxMemPool::UpdateChildrenForRemoval(txiter it)
@@ -405,8 +421,9 @@ void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove, b
             int64_t modifySize = -((int64_t)removeIt->GetTxSize());
             CAmount modifyFee = -removeIt->GetModifiedFee();
             int modifySigOps = -removeIt->GetSigOpCost();
+            int64_t discountSize = -((int64_t)removeIt->GetDiscountTxSize());
             for (txiter dit : setDescendants) {
-                mapTx.modify(dit, update_ancestor_state(modifySize, modifyFee, -1, modifySigOps));
+                mapTx.modify(dit, update_ancestor_state(modifySize, modifyFee, -1, modifySigOps, discountSize));
             }
         }
     }
@@ -455,7 +472,7 @@ void CTxMemPoolEntry::UpdateDescendantState(int64_t modifySize, CAmount modifyFe
     assert(int64_t(nCountWithDescendants) > 0);
 }
 
-void CTxMemPoolEntry::UpdateAncestorState(int64_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps)
+void CTxMemPoolEntry::UpdateAncestorState(int64_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps, int64_t discountSize)
 {
     nSizeWithAncestors += modifySize;
     assert(int64_t(nSizeWithAncestors) > 0);
@@ -464,6 +481,8 @@ void CTxMemPoolEntry::UpdateAncestorState(int64_t modifySize, CAmount modifyFee,
     assert(int64_t(nCountWithAncestors) > 0);
     nSigOpCostWithAncestors += modifySigOps;
     assert(int(nSigOpCostWithAncestors) >= 0);
+    discountSizeWithAncestors += discountSize;
+    assert(int64_t(discountSizeWithAncestors) > 0);
 }
 
 CTxMemPool::CTxMemPool(CBlockPolicyEstimator* estimator, int check_ratio)
@@ -965,7 +984,7 @@ void CTxMemPool::queryHashes(std::vector<uint256>& vtxid) const
 }
 
 static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it) {
-    return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(), it->GetTxSize(), it->GetModifiedFee() - it->GetFee()};
+    return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(), it->GetTxSize(), it->GetModifiedFee() - it->GetFee(), it->GetDiscountTxSize()};
 }
 
 std::vector<TxMempoolInfo> CTxMemPool::infoAll() const
@@ -1022,7 +1041,7 @@ void CTxMemPool::PrioritiseTransaction(const uint256& hash, const CAmount& nFeeD
             CalculateDescendants(it, setDescendants);
             setDescendants.erase(it);
             for (txiter descendantIt : setDescendants) {
-                mapTx.modify(descendantIt, update_ancestor_state(0, nFeeDelta, 0, 0));
+                mapTx.modify(descendantIt, update_ancestor_state(0, nFeeDelta, 0, 0, 0));
             }
             ++nTransactionsUpdated;
         }
diff --git a/src/txmempool.h b/src/txmempool.h
index 8b5e442a14..edfe7be1ad 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -117,6 +117,7 @@ class CTxMemPoolEntry
     uint64_t nSizeWithAncestors;
     CAmount nModFeesWithAncestors;
     int64_t nSigOpCostWithAncestors;
+    uint64_t discountSizeWithAncestors; // ELEMENTS
 
 public:
     CTxMemPoolEntry(const CTransactionRef& tx, CAmount fee,
@@ -129,6 +130,7 @@ class CTxMemPoolEntry
     CTransactionRef GetSharedTx() const { return this->tx; }
     const CAmount& GetFee() const { return nFee; }
     size_t GetTxSize() const;
+    size_t GetDiscountTxSize() const;
     size_t GetTxWeight() const { return nTxWeight; }
     std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
     unsigned int GetHeight() const { return entryHeight; }
@@ -140,7 +142,7 @@ class CTxMemPoolEntry
     // Adjusts the descendant state.
     void UpdateDescendantState(int64_t modifySize, CAmount modifyFee, int64_t modifyCount);
     // Adjusts the ancestor state
-    void UpdateAncestorState(int64_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps);
+    void UpdateAncestorState(int64_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps, int64_t discountSize);
     // Updates the fee delta used for mining priority score, and the
     // modified fees with descendants.
     void UpdateFeeDelta(int64_t feeDelta);
@@ -155,6 +157,7 @@ class CTxMemPoolEntry
 
     uint64_t GetCountWithAncestors() const { return nCountWithAncestors; }
     uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
+    uint64_t GetDiscountSizeWithAncestors() const { return discountSizeWithAncestors; }
     CAmount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
     int64_t GetSigOpCostWithAncestors() const { return nSigOpCostWithAncestors; }
 
@@ -318,11 +321,56 @@ class CompareTxMemPoolEntryByAncestorFee
     }
 };
 
+/** \class CompareTxMemPoolEntryByConfidentialFee
+ *
+ *  Sort an entry by min(score/discountvsize of entry's tx, score/discountvsize with all ancestors).
+ */
+class CompareTxMemPoolEntryByConfidentialFee
+{
+public:
+    template <typename T>
+    bool operator()(const T& a, const T& b) const
+    {
+        double a_mod_fee, a_size, b_mod_fee, b_size;
+
+        GetModFeeAndSize(a, a_mod_fee, a_size);
+        GetModFeeAndSize(b, b_mod_fee, b_size);
+
+        // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
+        double f1 = a_mod_fee * b_size;
+        double f2 = a_size * b_mod_fee;
+
+        if (f1 == f2) {
+            return a.GetTx().GetHash() < b.GetTx().GetHash();
+        }
+        return f1 > f2;
+    }
+
+    // Return the fee/size we're using for sorting this entry.
+    template <typename T>
+    void GetModFeeAndSize(const T& a, double& mod_fee, double& size) const
+    {
+        // Compare feerate with ancestors to feerate of the transaction, and
+        // return the fee/size for the min.
+        double f1 = (double)a.GetModifiedFee() * a.GetDiscountSizeWithAncestors();
+        double f2 = (double)a.GetModFeesWithAncestors() * a.GetDiscountTxSize();
+
+        if (f1 > f2) {
+            mod_fee = a.GetModFeesWithAncestors();
+            size = a.GetDiscountSizeWithAncestors();
+        } else {
+            mod_fee = a.GetModifiedFee();
+            size = a.GetDiscountTxSize();
+        }
+    }
+};
+
 // Multi_index tag names
 struct descendant_score {};
 struct entry_time {};
 struct ancestor_score {};
 struct index_by_wtxid {};
+struct confidential_score {}; // ELEMENTS
 
 class CBlockPolicyEstimator;
 
@@ -345,6 +393,9 @@ struct TxMempoolInfo
 
     /** The fee delta. */
     int64_t nFeeDelta;
+
+    /** ELEMENTS: Discounted CT size. */
+    size_t discountvsize;
 };
 
 /** Reason why a transaction was removed from the mempool,
@@ -380,6 +431,7 @@ enum class MemPoolRemovalReason {
  * - descendant feerate [we use max(feerate of tx, feerate of tx with all descendants)]
  * - time in mempool
  * - ancestor feerate [we use min(feerate of tx, feerate of tx with all unconfirmed ancestors)]
+ * - ancestor feerate by discount vsize // ELEMENTS: "confidential_score"
  *
  * Note: the term "descendant" refers to in-mempool transactions that depend on
  * this one, while "ancestor" refers to in-mempool transactions that a given
@@ -489,6 +541,12 @@ class CTxMemPool
                 boost::multi_index::tag<ancestor_score>,
                 boost::multi_index::identity<CTxMemPoolEntry>,
                 CompareTxMemPoolEntryByAncestorFee
+            >,
+            // ELEMENTS: sorted by confidential first fee rate with ancestors
+            boost::multi_index::ordered_non_unique<
+                boost::multi_index::tag<confidential_score>,
+                boost::multi_index::identity<CTxMemPoolEntry>,
+                CompareTxMemPoolEntryByConfidentialFee
             >
         >
     > indexed_transaction_set;
diff --git a/src/validation.cpp b/src/validation.cpp
index 1bd2e18ba3..b6fc6d4fd7 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -914,7 +914,9 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
 
     // No transactions are allowed below minRelayTxFee except from disconnected
     // blocks
-    if (!bypass_limits && !CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state)) return false;
+    // ELEMENTS: accept discounted fees for Confidential Transactions only, if enabled.
+    int64_t package_size = Params().GetAcceptDiscountCT() ? GetDiscountVirtualTransactionSize(tx) : ws.m_vsize;
+    if (!bypass_limits && !CheckFeeRate(package_size, ws.m_modified_fees, state)) return false;
 
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
     // Calculate in-mempool ancestors, up to a limit.
@@ -2566,38 +2568,53 @@ bool CChainState::FlushStateToDisk(
                 m_blockman.FlushBlockFile();
             }
 
+            std::set<CBlockIndex*> setTrimmableBlockIndex(m_blockman.m_dirty_blockindex);
             // Then update all block file information (which may refer to block and undo files).
             {
                 LOG_TIME_MILLIS_WITH_CATEGORY("write block index to disk", BCLog::BENCH);
 
+                if (node::fTrimHeaders) {
+                    for (std::set<CBlockIndex*>::iterator it = setTrimmableBlockIndex.begin(); it != setTrimmableBlockIndex.end(); it++) {
+                        (*it)->untrim();
+                    }
+                }
                 if (!m_blockman.WriteBlockIndexDB()) {
                     return AbortNode(state, "Failed to write to block index database");
                 }
 
-                if (node::fTrimHeaders) {
-                    std::set<CBlockIndex*> setTrimmableBlockIndex(m_blockman.m_dirty_blockindex);
+                // This should be done inside WriteBatchSync, but CBlockIndex is const there
+                for (std::set<CBlockIndex*>::iterator it = setTrimmableBlockIndex.begin(); it != setTrimmableBlockIndex.end(); it++) {
+                    (*it)->set_stored();
+                }
+
+                int trim_height = 0;
+                if (pindexBestHeader && (uint64_t)pindexBestHeader->nHeight > node::nMustKeepFullHeaders) { // check first, to prevent underflow
+                    trim_height = pindexBestHeader->nHeight - node::nMustKeepFullHeaders;
+                }
+                if (node::fTrimHeaders && trim_height > 0 && !ShutdownRequested()) {
+                    static int nMinTrimHeight{0};
                     LogPrintf("Flushing block index, trimming headers, setTrimmableBlockIndex.size(): %d\n", setTrimmableBlockIndex.size());
-                    int trim_height = m_chain.Height() - node::nMustKeepFullHeaders;
-                    int min_height = std::numeric_limits<int>::max();
-                    CBlockIndex* min_index = nullptr;
                     for (std::set<CBlockIndex*>::iterator it = setTrimmableBlockIndex.begin(); it != setTrimmableBlockIndex.end(); it++) {
                         (*it)->assert_untrimmed();
                         if ((*it)->nHeight < trim_height) {
                             (*it)->trim();
-                            if ((*it)->nHeight < min_height) {
-                                min_height = (*it)->nHeight;
-                                min_index = *it;
-                            }
                         }
                     }
-
+                    CBlockIndex* min_index = pindexBestHeader->GetAncestor(trim_height-1);
                     // Handle any remaining untrimmed blocks that were too recent for trimming last time we flushed.
                     if (min_index) {
-                        min_index = min_index->pprev;
-                        while (min_index && !min_index->trimmed()) {
-                            min_index->trim();
+                        int nMaxTrimHeightRound = std::max(nMinTrimHeight, min_index->nHeight + 1);
+                        while (min_index && min_index->nHeight >= nMinTrimHeight) {
+                            if (!min_index->trimmed()) {
+                                // there may be gaps due to untrimmed blocks, we need to check them all
+                                if (!min_index->trim()) {
+                                    // Header could not be trimmed, we'll need to try again next round
+                                    nMaxTrimHeightRound = min_index->nHeight;
+                                }
+                            }
                             min_index = min_index->pprev;
                         }
+                        nMinTrimHeight = nMaxTrimHeightRound;
                     }
                 }
             }
@@ -2700,6 +2717,18 @@ static void UpdateTipLog(
         !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : "");
 }
 
+void ForceUntrimHeader(const CBlockIndex *pindex_) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+{
+    AssertLockHeld(cs_main);
+
+    assert(pindex_);
+    if (!pindex_->trimmed()) {
+        return;
+    }
+    CBlockIndex *pindex=const_cast<CBlockIndex*>(pindex_);
+    pindex->untrim();
+}
+
 void CChainState::UpdateTip(const CBlockIndex* pindexNew)
 {
     AssertLockHeld(::cs_main);
@@ -2745,11 +2774,13 @@ void CChainState::UpdateTip(const CBlockIndex* pindexNew)
     }
     UpdateTipLog(coins_tip, pindexNew, m_params, __func__, "", warning_messages.original);
 
+    ForceUntrimHeader(pindexNew);
     // Do some logging if dynafed parameters changed.
     if (pindexNew->pprev && !pindexNew->dynafed_params().IsNull()) {
         int height = pindexNew->nHeight;
         uint256 hash = pindexNew->GetBlockHash();
         uint256 root = pindexNew->dynafed_params().m_current.CalculateRoot();
+        ForceUntrimHeader(pindexNew->pprev);
         if (pindexNew->pprev->dynafed_params().IsNull()) {
             LogPrintf("Dynafed activated in block %d:%s: %s\n", height, hash.GetHex(), root.GetHex());
         } else if (root != pindexNew->pprev->dynafed_params().m_current.CalculateRoot()) {
diff --git a/src/validation.h b/src/validation.h
index a27f927fea..78fa8bea6a 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1023,4 +1023,5 @@ bool LoadMempool(CTxMemPool& pool, CChainState& active_chainstate, FopenFn mocka
  */
 const AssumeutxoData* ExpectedAssumeutxo(const int height, const CChainParams& params);
 
+void ForceUntrimHeader(const CBlockIndex *pindex_);
 #endif // BITCOIN_VALIDATION_H
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 65a7a6f228..f7bd721cef 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -174,6 +174,11 @@ TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *walle
     CTransaction ctx(txNew);
     int64_t vsize = GetVirtualTransactionSize(ctx);
     int64_t weight = GetTransactionWeight(ctx);
+    // ELEMENTS: use discounted vsize for CTs if enabled
+    if (Params().GetCreateDiscountCT()) {
+        vsize = GetDiscountVirtualTransactionSize(ctx);
+    }
+
     return TxSize{vsize, weight};
 }
 
diff --git a/test/functional/feature_discount_ct.py b/test/functional/feature_discount_ct.py
new file mode 100755
index 0000000000..b4c2fb9a4d
--- /dev/null
+++ b/test/functional/feature_discount_ct.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from decimal import Decimal
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+)
+
+class CTTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        args = [
+            "-anyonecanspendaremine=1",
+            "-con_blocksubsidy=0",
+            "-con_connect_genesis_outputs=1",
+            "-initialfreecoins=2100000000000000",
+            "-txindex=1",
+        ]
+        self.extra_args = [
+            # node 0 does not accept nor create discounted CTs
+            args + ["-acceptdiscountct=0", "-creatediscountct=0"],
+            # node 1 accepts but does not create discounted CTs
+            args + ["-acceptdiscountct=1", "-creatediscountct=0"],
+            # node 2 both accepts and creates discounted CTs
+            args + ["-acceptdiscountct=1", "-creatediscountct=1"],
+        ]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        feerate = 1.0
+
+        node0 = self.nodes[0]
+        node1 = self.nodes[1]
+        node2 = self.nodes[2]
+
+        self.generate(node0, 101)
+        balance = node0.getbalance()
+        assert_equal(balance['bitcoin'], 21000000)
+
+        self.log.info("Create UTXOs")
+        many = {}
+        num = 25
+        for i in range(num):
+            addr = node0.getnewaddress()
+            info = node0.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+        for i in range(10):
+            addr = node1.getnewaddress()
+            info = node1.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+        for i in range(10):
+            addr = node2.getnewaddress()
+            info = node2.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+
+        txid = node0.sendmany("", many)
+        self.generate(node0, 1)
+
+        self.log.info("Send explicit tx to node 0")
+        addr = node0.getnewaddress()
+        info = node0.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000326'))
+        assert_equal(decoded['vsize'], 326)
+        self.generate(node0, 1)
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 326)
+
+        self.log.info("Send confidential tx to node 0")
+        addr = node0.getnewaddress()
+        info = node0.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00002575'))
+        assert_equal(decoded['vsize'], 2575)
+        self.generate(node0, 1)
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 410) # node1 has discountvsize
+
+        self.log.info("Send explicit tx to node 1")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000326'))
+        assert_equal(decoded['vsize'], 326)
+        self.generate(node0, 1)
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 326)
+
+        self.log.info("Send confidential (undiscounted) tx to node 1")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00002575'))
+        assert_equal(decoded['vsize'], 2575)
+        self.generate(node0, 1)
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 410) # node1 has discountvsize
+
+        self.log.info("Send confidential (discounted) tx to node 1")
+        bitcoin = 'b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23'
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node2.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        # node0 won't accept or relay the tx
+        self.sync_mempools([node1, node2])
+        assert_equal(node0.getrawmempool(), [])
+        self.generate(node2, 1, sync_fun=self.sync_blocks)
+        for node in [node2, node1]:
+            tx = node.gettransaction(txid, True, True)
+            decoded = tx['decoded']
+            vin = decoded['vin']
+            vout = decoded['vout']
+            assert_equal(len(vin), 2)
+            assert_equal(len(vout), 3)
+            if 'bitcoin' in decoded['fee']:
+                assert_equal(decoded['fee']['bitcoin'], Decimal('-0.00000410'))
+            else:
+                assert_equal(decoded['fee'][bitcoin], Decimal('0.00000410'))
+            assert_equal(decoded['vsize'], 2575)
+            assert_equal(decoded['discountvsize'], 410)
+
+        # node0 only has vsize
+        tx = node0.getrawtransaction(txid, True)
+        assert_equal(tx['vsize'], 2575)
+
+
+if __name__ == '__main__':
+    CTTest().main()
diff --git a/test/functional/feature_discount_ct_ordering.py b/test/functional/feature_discount_ct_ordering.py
new file mode 100755
index 0000000000..7cca1ee880
--- /dev/null
+++ b/test/functional/feature_discount_ct_ordering.py
@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from decimal import Decimal
+from io import BytesIO
+from test_framework.messages import CBlock
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+)
+
+class CTTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        self.args = [
+            "-anyonecanspendaremine=1",
+            "-con_blocksubsidy=0",
+            "-con_connect_genesis_outputs=1",
+            "-initialfreecoins=2100000000000000",
+            "-txindex=1",
+        ]
+        self.extra_args = [
+            # node 0 does not accept nor create discounted CTs
+            self.args + ["-acceptdiscountct=0", "-creatediscountct=0"],
+            # node 1 accepts but does not create discounted CTs
+            self.args + ["-acceptdiscountct=1", "-creatediscountct=0"],
+            # node 2 both accepts and creates discounted CTs
+            self.args + ["-acceptdiscountct=1", "-creatediscountct=1"],
+        ]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+
+        node0 = self.nodes[0]
+        node1 = self.nodes[1]
+        node2 = self.nodes[2]
+
+        self.generate(node0, 101)
+        balance = node0.getbalance()
+        assert_equal(balance['bitcoin'], 21000000)
+
+        self.log.info("Create UTXOs")
+        many = {}
+        num = 25
+        for i in range(num):
+            addr = node0.getnewaddress()
+            info = node0.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+        for i in range(10):
+            addr = node1.getnewaddress()
+            info = node1.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+        for i in range(10):
+            addr = node2.getnewaddress()
+            info = node2.getaddressinfo(addr)
+            many[info['unconfidential']] = 1
+
+        txid = node0.sendmany("", many)
+        self.generate(node0, 1)
+
+        feerate = 1.0
+        self.log.info(f"Send explicit tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000326'))
+        assert_equal(decoded['vsize'], 326)
+        self.sync_mempools([node0, node1])
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 326)
+
+        feerate = 2.0
+        self.log.info(f"Send explicit tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000652'))
+        assert_equal(decoded['vsize'], 326)
+        self.sync_mempools([node0, node1])
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 326)
+
+        feerate = 1.0
+        self.log.info(f"Send confidential (undiscounted) tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        self.sync_mempools()
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00002575'))
+        assert_equal(decoded['vsize'], 2575)
+        self.sync_mempools([node0, node1])
+        tx = node1.getrawtransaction(txid, True)
+        assert_equal(tx['discountvsize'], 410)
+
+        feerate = 1.0
+        self.log.info(f"Send confidential (discounted) tx to node 1 at {feerate} sat/vb")
+        bitcoin = 'b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23'
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node2.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        # node0 won't accept or relay the tx
+        self.sync_mempools([node1, node2])
+        for node in [node2, node1]:
+            tx = node.gettransaction(txid, True, True)
+            decoded = tx['decoded']
+            vin = decoded['vin']
+            vout = decoded['vout']
+            assert_equal(len(vin), 2)
+            assert_equal(len(vout), 3)
+            if 'bitcoin' in decoded['fee']:
+                assert_equal(decoded['fee']['bitcoin'], Decimal('-0.00000410'))
+            else:
+                assert_equal(decoded['fee'][bitcoin], Decimal('0.00000410'))
+            assert_equal(decoded['vsize'], 2575)
+            assert_equal(decoded['discountvsize'], 410)
+
+        feerate = 2.0
+        self.log.info(f"Send confidential (discounted) tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node2.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        self.sync_mempools([node1, node2])
+        tx = node1.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        assert_equal(decoded['fee'][bitcoin], Decimal('0.00000820'))
+
+        # check that txs in the block template are in decreasing feerate according to their discount size
+        self.log.info("Check tx ordering in block template")
+        h = node1.getnewblockhex()
+        b = bytes.fromhex(h)
+        block = CBlock()
+        block.deserialize(BytesIO(b))
+        last_feerate = None
+        i = 0
+        for tx in block.vtx:
+            tx.calc_sha256()
+            fees = list(filter(lambda o: o.is_fee(), tx.vout))
+            # print(f"fees: {fees}")
+
+            if len(fees) > 0:
+                print("---")
+                txid = tx.hash
+                print(f"txid: {txid}")
+                t = node1.gettransaction(txid, True, True)
+                discountvsize = t['decoded']['discountvsize']
+                vsize = tx.get_vsize()
+                fee = fees[0].nValue.getAmount()
+                print(f"fee: {fee}")
+                print(f"vsize: {vsize}")
+                print(f"discountvsize: {discountvsize}")
+                print(f"actual feerate at vsize : {fee / vsize}")
+                feerate = fee / discountvsize
+                print(f"feerate at discountvsize: {feerate}")
+                # if last_feerate is not None:
+                #     assert feerate <= last_feerate
+                last_feerate = feerate
+                i = i + 1
+        print("---")
+
+        # discounted txs are dropped from the mempool on restart if we no longer accept them
+        self.log.info("Restart node1 with acceptdiscount=0")
+        self.restart_node(1, extra_args = self.args + ["-acceptdiscountct=0", "-creatediscountct=0"])
+        self.connect_nodes(0, 1)
+        self.sync_mempools([node0, node1])
+
+        # send a few more txs
+        feerate = 1.0
+        self.log.info(f"Send explicit tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000326'))
+        assert_equal(decoded['vsize'], 326)
+
+        feerate = 2.0
+        self.log.info(f"Send explicit tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000652'))
+        assert_equal(decoded['vsize'], 326)
+
+        feerate = 3.0
+        self.log.info(f"Send explicit tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['unconfidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00000978'))
+        assert_equal(decoded['vsize'], 326)
+
+        feerate = 3.0
+        self.log.info(f"Send confidential (undiscounted) tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00007725'))
+        assert_equal(decoded['vsize'], 2575)
+
+        feerate = 2.0
+        self.log.info(f"Send confidential (undiscounted) tx to node 1 at {feerate} sat/vb")
+        addr = node1.getnewaddress()
+        info = node1.getaddressinfo(addr)
+        txid = node0.sendtoaddress(info['confidential'], 1.0, "", "", False, None, None, None, None, None, None, feerate)
+        tx = node0.gettransaction(txid, True, True)
+        decoded = tx['decoded']
+        vin = decoded['vin']
+        vout = decoded['vout']
+        assert_equal(len(vin), 2)
+        assert_equal(len(vout), 3)
+        assert_equal(tx['fee']['bitcoin'], Decimal('-0.00005150'))
+        assert_equal(decoded['vsize'], 2575)
+
+        self.sync_mempools([node0, node1])
+
+        # check that txs in the block template are in decreasing feerate
+        self.log.info("Check tx ordering in block template with acceptdiscountct=0")
+        h = node0.getnewblockhex()
+        b = bytes.fromhex(h)
+        block = CBlock()
+        block.deserialize(BytesIO(b))
+        last_feerate = None
+        i = 0
+        for tx in block.vtx:
+            tx.calc_sha256()
+            fees = list(filter(lambda o: o.is_fee(), tx.vout))
+            # print(f"fees: {fees}")
+
+            if len(fees) > 0:
+                print("---")
+                txid = tx.hash
+                print(f"txid: {txid}")
+                t = node1.gettransaction(txid, True, True)
+                vsize = tx.get_vsize()
+                fee = fees[0].nValue.getAmount()
+                print(f"fee: {fee}")
+                print(f"vsize: {vsize}")
+                print(f"actual feerate at vsize : {fee / vsize}")
+                if last_feerate is not None:
+                    assert feerate <= last_feerate
+                last_feerate = feerate
+                i = i + 1
+        print("---")
+
+if __name__ == '__main__':
+    CTTest().main()
diff --git a/test/functional/feature_trim_headers.py b/test/functional/feature_trim_headers.py
new file mode 100755
index 0000000000..8d44ee92a9
--- /dev/null
+++ b/test/functional/feature_trim_headers.py
@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+
+import codecs
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+from test_framework import (
+    address,
+    key,
+)
+from test_framework.messages import (
+    CBlock,
+    from_hex,
+)
+from test_framework.script import (
+    OP_NOP,
+    OP_RETURN,
+    CScript
+)
+
+# Generate wallet import format from private key.
+def wif(pk):
+    # Base58Check version for regtest WIF keys is 0xef = 239
+    pk_compressed = pk + bytes([0x1])
+    return address.byte_to_base58(pk_compressed, 239)
+
+# The signblockscript is a Bitcoin Script k-of-n multisig script.
+def make_signblockscript(num_nodes, required_signers, keys):
+    assert num_nodes >= required_signers
+    script = "{}".format(50 + required_signers)
+    for i in range(num_nodes):
+        k = keys[i]
+        script += "21"
+        script += codecs.encode(k.get_pubkey().get_bytes(), 'hex_codec').decode("utf-8")
+    script += "{}".format(50 + num_nodes)  # num keys
+    script += "ae"  # OP_CHECKMULTISIG
+    return script
+
+class TrimHeadersTest(BitcoinTestFramework):
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    # Dynamically generate N keys to be used for block signing.
+    def init_keys(self, num_keys):
+        self.keys = []
+        self.wifs = []
+        for i in range(num_keys):
+            k = key.ECKey()
+            k.generate()
+            w = wif(k.get_bytes())
+            self.keys.append(k)
+            self.wifs.append(w)
+
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.num_keys = 1
+        self.required_signers = 1
+        self.setup_clean_chain = True
+        self.init_keys(self.num_keys)
+        signblockscript = make_signblockscript(self.num_keys, self.required_signers, self.keys)
+        self.witnessScript = signblockscript  # post-dynafed this becomes witnessScript
+        args = [
+            "-signblockscript={}".format(signblockscript),
+            "-con_max_block_sig_size={}".format(self.required_signers * 74 + self.num_nodes * 33),
+            "-anyonecanspendaremine=1",
+            "-evbparams=dynafed:0:::",
+            "-con_dyna_deploy_signal=1",
+        ]
+        self.trim_args = args + ["-trim_headers=1"]
+        self.prune_args = self.trim_args + ["-prune=1"]
+        self.extra_args = [
+            args,
+            self.trim_args,
+            self.prune_args,
+        ]
+
+    def setup_network(self):
+        self.setup_nodes()
+        self.connect_nodes(0, 1)
+        self.connect_nodes(0, 2)
+
+    def check_height(self, expected_height, all=False, verbose=True):
+        if verbose:
+            self.log.info(f"Check height {expected_height}")
+        if all:
+            for n in self.nodes:
+                assert_equal(n.getblockcount(), expected_height)
+        else:
+            assert_equal(self.nodes[0].getblockcount(), expected_height)
+
+    def mine_block(self, make_transactions):
+        # alternate mining between the signing nodes
+        mineridx = self.nodes[0].getblockcount() % self.required_signers  # assuming in sync
+        mineridx_next = (self.nodes[0].getblockcount() + 1) % self.required_signers
+        miner = self.nodes[mineridx]
+        miner_next = self.nodes[mineridx_next]
+
+        # If dynafed is enabled, this means signblockscript has been WSH-wrapped
+        blockchain_info = self.nodes[0].getblockchaininfo()
+        deployment_info = self.nodes[0].getdeploymentinfo()
+        dynafed_active = deployment_info['deployments']['dynafed']['bip9']['status'] == "active"
+        if dynafed_active:
+            wsh_wrap = self.nodes[0].decodescript(self.witnessScript)['segwit']['hex']
+            assert_equal(wsh_wrap, blockchain_info['current_signblock_hex'])
+
+        # Make a few transactions to make non-empty blocks for compact transmission
+        if make_transactions:
+            for i in range(10):
+                miner.sendtoaddress(miner_next.getnewaddress(), 1, "", "", True)
+        # miner makes a block
+        block = miner.getnewblockhex()
+        block_struct = from_hex(CBlock(), block)
+
+        # make another block with the commitment field filled out
+        dummy_block = miner.getnewblockhex(commit_data="deadbeef")
+        dummy_struct = from_hex(CBlock(), dummy_block)
+        assert_equal(len(dummy_struct.vtx[0].vout), len(block_struct.vtx[0].vout) + 1)
+        # OP_RETURN deadbeef
+        assert_equal(CScript(dummy_struct.vtx[0].vout[0].scriptPubKey).hex(), '6a04deadbeef')
+
+        # All nodes get compact blocks, first node may get complete
+        # block in 0.5 RTT even with transactions thanks to p2p connection
+        # with non-signing node being miner
+        for i in range(self.num_keys):
+            sketch = miner.getcompactsketch(block)
+            compact_response = self.nodes[i].consumecompactsketch(sketch)
+            if "block_tx_req" in compact_response:
+                block_txn = self.nodes[i].consumegetblocktxn(block, compact_response["block_tx_req"])
+                final_block = self.nodes[i].finalizecompactblock(sketch, block_txn, compact_response["found_transactions"])
+            else:
+                # If there's only coinbase, it should succeed immediately
+                final_block = compact_response["blockhex"]
+            # Block should be complete, sans signatures
+            self.nodes[i].testproposedblock(final_block)
+
+        # collect num_keys signatures from signers, reduce to required_signers sigs during combine
+        sigs = []
+        for i in range(self.num_keys):
+            result = miner.combineblocksigs(block, sigs, self.witnessScript)
+            sigs = sigs + self.nodes[i].signblock(block, self.witnessScript)
+            assert_equal(result["complete"], i >= self.required_signers)
+            # submitting should have no effect pre-threshhold
+            if i < self.required_signers:
+                miner.submitblock(result["hex"])
+
+        result = miner.combineblocksigs(block, sigs, self.witnessScript)
+        assert_equal(result["complete"], True)
+
+        self.nodes[0].submitblock(result["hex"])
+
+    def mine_blocks(self, num_blocks, transactions):
+        for _ in range(num_blocks):
+            self.mine_block(transactions)
+
+    def mine_large_blocks(self, n):
+        big_script = CScript([OP_RETURN] + [OP_NOP] * 950000)
+        node = self.nodes[0]
+
+        for _ in range(n):
+            hex = node.getnewblockhex()
+            block = from_hex(CBlock(), hex)
+            tx = block.vtx[0]
+            tx.vout[0].scriptPubKey = big_script
+            tx.rehash()
+            block.vtx[0] = tx
+            block.hashMerkleRoot = block.calc_merkle_root()
+            block.solve()
+            h = block.serialize().hex()
+
+            sigs = node.signblock(h, self.witnessScript)
+
+            result = node.combineblocksigs(h, sigs, self.witnessScript)
+            assert_equal(result["complete"], True)
+
+            node.submitblock(result["hex"])
+
+
+    def run_test(self):
+        for i in range(self.num_keys):
+            self.nodes[i].importprivkey(self.wifs[i])
+
+        expected_height = 0
+        self.check_height(expected_height, all=True)
+
+        self.log.info("Mining and signing 101 blocks to unlock funds")
+        expected_height += 101
+        self.mine_blocks(101, False)
+        self.sync_all()
+        self.check_height(expected_height, all=True)
+        # check the new field in getblockchaininfo
+        assert not self.nodes[0].getblockchaininfo()["trim_headers"]
+        assert self.nodes[1].getblockchaininfo()["trim_headers"]
+        assert self.nodes[2].getblockchaininfo()["trim_headers"]
+
+        self.log.info("Shut down trimmed nodes")
+        self.stop_node(1)
+        self.stop_node(2)
+
+        self.log.info("Mining and signing non-empty blocks")
+        expected_height += 10
+        self.mine_blocks(10, True)
+        self.check_height(expected_height)
+
+        # signblock rpc field stuff
+        tip = self.nodes[0].getblockhash(self.nodes[0].getblockcount())
+        header = self.nodes[0].getblockheader(tip)
+        block = self.nodes[0].getblock(tip)
+
+        assert 'signblock_witness_asm' in header
+        assert 'signblock_witness_hex' in header
+        assert 'signblock_witness_asm' in block
+        assert 'signblock_witness_hex' in block
+
+        assert_equal(self.nodes[0].getdeploymentinfo()['deployments']['dynafed']['bip9']['status'], "defined")
+
+        # activate dynafed
+        blocks_til_dynafed = 431 - self.nodes[0].getblockcount()
+        self.log.info("Activating dynafed")
+        self.mine_blocks(blocks_til_dynafed, False)
+        expected_height += blocks_til_dynafed
+        self.check_height(expected_height)
+
+        assert_equal(self.nodes[0].getdeploymentinfo()['deployments']['dynafed']['bip9']['status'], "locked_in")
+
+        num = 3000
+        self.log.info(f"Mine {num} dynamic federation blocks without txns")
+        self.mine_blocks(num, False)
+        expected_height += num
+        self.check_height(expected_height)
+
+        num = 10
+        self.log.info(f"Mine {num} dynamic federation blocks with txns")
+        self.mine_blocks(num, True)
+        expected_height += num
+        self.check_height(expected_height)
+
+        num = 777
+        self.log.info(f"Mine {num} large blocks")
+        expected_height += num
+        self.mine_large_blocks(num)
+
+        self.log.info("Restart the trimmed nodes")
+        self.start_node(1, extra_args=self.trim_args)
+        self.start_node(2, extra_args=self.prune_args)
+        self.connect_nodes(0, 1)
+        self.connect_nodes(0, 2)
+
+        self.sync_all()
+        self.check_height(expected_height, all=True)
+
+        self.log.info("Prune the pruned node")
+        self.nodes[2].pruneblockchain(4000)
+
+        hash = self.nodes[0].getblockhash(expected_height)
+        block = self.nodes[0].getblock(hash)
+        for i in range(1, self.num_nodes):
+            assert_equal(hash, self.nodes[i].getblockhash(expected_height))
+            assert_equal(block, self.nodes[i].getblock(hash))
+
+        self.log.info(f"All nodes at height {expected_height} with block hash {hash}")
+
+
+if __name__ == '__main__':
+    TrimHeadersTest().main()
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index 949d7e6fbf..6e54ddca1f 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -123,6 +123,7 @@ def _test_getblockchaininfo(self):
             'pruned',
             'size_on_disk',
             'time',
+            'trim_headers',
             'verificationprogress',
             'warnings',
         ]
diff --git a/test/functional/rpc_tweakfedpeg.py b/test/functional/rpc_tweakfedpeg.py
index 18ce19df0e..b2611a8982 100755
--- a/test/functional/rpc_tweakfedpeg.py
+++ b/test/functional/rpc_tweakfedpeg.py
@@ -38,12 +38,14 @@ def skip_test_if_missing_module(self):
     def run_test(self):
         # Test that OP_TRUE mainchain_addr/claim_script never changes
         assert_equal(self.nodes[0].getsidechaininfo()["fedpegscript"], OP_TRUE_SCRIPT)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op) # just to get node out of ibd
         pegin_addr = self.nodes[0].getpeginaddress()
         for _ in range(5):
             assert_equal(pegin_addr["mainchain_address"], self.nodes[0].getpeginaddress()["mainchain_address"])
             assert_equal(self.nodes[0].tweakfedpegscript(pegin_addr["claim_script"])["script"], OP_TRUE_SCRIPT)
 
         # Test that OP_CMS has all keys change and matches elements-0.14 example
+        self.generate(self.nodes[1], 1, sync_fun=self.no_op)
         pegin_addr = self.nodes[1].getpeginaddress()
         assert_equal(self.nodes[1].getsidechaininfo()["fedpegscript"], OP_CMS_SCRIPT)
         nontweak_decoded = self.nodes[1].decodescript(OP_CMS_SCRIPT)["asm"]
@@ -61,6 +63,7 @@ def run_test(self):
                 "522102f5bc6bc407187d06854005c366b84b411534757f4503587cf335645a620f896a2102fd90164e4e7d53417e4eacfa3f86fd39fe40594791758739e8af31eeea4e79c552ae")
 
         # Test Liquid-style fedpegscript with CSV emergency keys(which don't get tweaked!)
+        self.generate(self.nodes[2], 1, sync_fun=self.no_op)
         pegin_addr = self.nodes[2].getpeginaddress()
         assert_equal(self.nodes[2].getsidechaininfo()["fedpegscript"], LIQUID_SCRIPT)
         nontweak_decoded = self.nodes[2].decodescript(LIQUID_SCRIPT)["asm"]
@@ -86,7 +89,7 @@ def run_test(self):
         # Advance to dynamic federations activation, which has pubkeys
         # after OP_ELSE get tweaked except the exact liquidv1 template to
         # maintain compatibility
-        self.generate(self.nodes[2], 433, sync_fun=self.no_op)
+        self.generate(self.nodes[2], 432, sync_fun=self.no_op)
         assert_equal(self.nodes[2].getdeploymentinfo()['deployments']['dynafed']['bip9']['status'], 'active')
         assert_equal(self.nodes[2].tweakfedpegscript(claim_script)["script"], liquid_tweaked)
 
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 8cde0b32f4..fc3c1034cc 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -112,6 +112,7 @@
     'rpc_getnewblockhex.py',
     'wallet_elements_regression_1172.py --legacy-wallet',
     'wallet_elements_regression_1259.py --legacy-wallet',
+    'feature_trim_headers.py',
     # Longest test should go first, to favor running tests in parallel
     'wallet_hd.py --legacy-wallet',
     'wallet_hd.py --descriptors',
@@ -185,6 +186,9 @@
     'wallet_avoidreuse.py --descriptors',
     'mempool_reorg.py',
     'mempool_persist.py',
+    # ELEMENTS: discounted Confidential Transactions
+    'feature_discount_ct.py',
+    'feature_discount_ct_ordering.py',
     'wallet_multiwallet.py --legacy-wallet',
     'wallet_multiwallet.py --descriptors',
     'wallet_multiwallet.py --usecli',
diff --git a/test/functional/wallet_elements_regression_1263.py b/test/functional/wallet_elements_regression_1263.py
index 6e64a9b4bc..c4f713c8e3 100755
--- a/test/functional/wallet_elements_regression_1263.py
+++ b/test/functional/wallet_elements_regression_1263.py
@@ -24,6 +24,7 @@ def run_test(self):
         self.log.info("Start in Bitcoin regtest mode")
         self.nodes[0].createwallet("pegin")
         rpc = self.nodes[0].get_wallet_rpc("pegin")
+        self.generatetoaddress(self.nodes[0], 1, rpc.getnewaddress())
 
         self.log.info("Call getpeginaddress")
         assert_raises_rpc_error(-32603, "No valid fedpegscripts. Not running in Elements mode, check your 'chain' param.", rpc.getpeginaddress)
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index e587b1c225..2753b8cd94 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -22,6 +22,29 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "wallet/fees -> wallet/wallet -> wallet/fees"
     "wallet/wallet -> wallet/walletdb -> wallet/wallet"
     "node/coinstats -> validation -> node/coinstats"
+    # ELEMENTs: introduced by https://github.com/ElementsProject/elements/pull/1270
+    "chain -> validation -> chain"
+    "chain -> validation -> consensus/tx_verify -> chain"
+    "dynafed -> validation -> dynafed"
+    "pegins -> validation -> pegins"
+    "chain -> node/context -> txmempool -> chain"
+    "chain -> validation -> deploymentstatus -> chain"
+    "chain -> validation -> index/blockfilterindex -> chain"
+    "chain -> validation -> primitives/pak -> chain"
+    "chain -> validation -> txdb -> chain"
+    "chain -> validation -> validationinterface -> chain"
+    "chain -> validation -> txdb -> pow -> chain"
+    "chain -> validation -> deploymentstatus -> versionbits -> chain"
+    "confidential_validation -> pegins -> validation -> confidential_validation"
+    "consensus/tx_verify -> pegins -> validation -> consensus/tx_verify"
+    "dynafed -> validation -> primitives/pak -> dynafed"
+    "pegins -> validation -> txmempool -> pegins"
+    "block_proof -> chain -> validation -> block_proof"
+    "block_proof -> chain -> validation -> txdb -> block_proof"
+    "chain -> node/context -> net_processing -> node/blockstorage -> chain"
+    "consensus/tx_verify -> pegins -> validation -> txmempool -> consensus/tx_verify"
+    "block_proof -> chain -> node/context -> net_processing -> node/blockstorage -> block_proof"
+    "core_io -> script/sign -> pegins -> validation -> signet -> core_io"
     # ELEMENTS: will be fixed by blinding cleanup
     "blindpsbt -> psbt -> blindpsbt"
     # ELEMENTS: not so easy to fix, caused by us doing asset ID lookups in the