From 967443acc6a73e9d0537ae1ccc877d8de7adfb67 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 29 Sep 2022 19:25:05 +0700
Subject: [PATCH 01/37] feat: add implementation of DIP 0027 Credit Asset Locks

This commit includes:
  - Asset Lock transaction
  - Asset Unlock transaction (withdrawal)
  - Unit tests for Asset Lock/Unlock tx
  - Credit Pool in coinbase and its serialization in evo db when it required
  - New functional test `feature_asset_locks.py`
  - RPC for Credit Pool (currently locked amount)
  - check validity of asset-locked amount in coin base tx for new block

Asset unlock transaction requires a lot of validation that implemented:
  - Asset unlock limits are equals to: min(max(100, min(.10 * assetlockpool, 1000)), assetlockpool)
  - Asset unlock transaction are restricted to be accepted during only 48 blocks
  - Removing expired asset-unlock transaction from mempool
  - An index validation for asset-unlock txes
  - Indexes also validated before beeing added to txmempool
  - Unlock transactions are validated twice: when accepting to block chain and in miner

All of these checks have functional tests for that, and also:
  - Rollback of block with tx Asset Lock
  - Rollback of block with tx Asset Unlock
  - Duplicate 'asset unlock' tx for new block
  - Asset unlock rollback and reconsider
  - Reconsider/invalidate blocks
  - Manually created block with invalid transaction
---
 src/Makefile.am                              |   4 +
 src/Makefile.test.include                    |   1 +
 src/bloom.cpp                                |   4 +
 src/chainparams.cpp                          |   4 +
 src/consensus/params.h                       |   1 +
 src/consensus/tx_check.cpp                   |  13 +-
 src/consensus/tx_verify.cpp                  |  15 +
 src/core_write.cpp                           |  15 +
 src/evo/assetlocktx.cpp                      | 237 +++++++++
 src/evo/assetlocktx.h                        | 144 ++++++
 src/evo/cbtx.cpp                             |  13 +-
 src/evo/cbtx.h                               |   7 +
 src/evo/creditpool.cpp                       | 335 ++++++++++++
 src/evo/creditpool.h                         | 175 +++++++
 src/evo/specialtxman.cpp                     |  45 +-
 src/evo/specialtxman.h                       |  10 +-
 src/init.cpp                                 |   3 +
 src/merkleblock.cpp                          |   2 +
 src/miner.cpp                                |  39 +-
 src/miner.h                                  |   3 +-
 src/node/context.cpp                         |   1 +
 src/node/context.h                           |   2 +
 src/primitives/transaction.h                 |   2 +
 src/rpc/evo.cpp                              |   5 +-
 src/test/evo_assetlocks_tests.cpp            | 360 +++++++++++++
 src/test/util/setup_common.cpp               |   5 +
 src/txmempool.cpp                            |  27 +
 src/txmempool.h                              |   2 +
 src/validation.cpp                           |  14 +-
 test/functional/feature_asset_locks.py       | 505 +++++++++++++++++++
 test/functional/feature_nulldummy.py         |   5 +-
 test/functional/test_framework/blocktools.py |   5 +-
 test/functional/test_framework/messages.py   |  91 +++-
 test/functional/test_runner.py               |   1 +
 test/lint/lint-circular-dependencies.sh      |   5 +
 35 files changed, 2066 insertions(+), 34 deletions(-)
 create mode 100644 src/evo/assetlocktx.cpp
 create mode 100644 src/evo/assetlocktx.h
 create mode 100644 src/evo/creditpool.cpp
 create mode 100644 src/evo/creditpool.h
 create mode 100644 src/test/evo_assetlocks_tests.cpp
 create mode 100755 test/functional/feature_asset_locks.py

diff --git a/src/Makefile.am b/src/Makefile.am
index edbf2936b0f38..2bb600f89ef90 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -169,8 +169,10 @@ BITCOIN_CORE_H = \
   cuckoocache.h \
   ctpl_stl.h \
   cxxtimer.hpp \
+  evo/assetlocktx.h \
   evo/dmn_types.h \
   evo/cbtx.h \
+  evo/creditpool.h \
   evo/deterministicmns.h \
   evo/dmnstate.h \
   evo/evodb.h \
@@ -384,7 +386,9 @@ libbitcoin_server_a_SOURCES = \
   consensus/tx_verify.cpp \
   dbwrapper.cpp \
   dsnotificationinterface.cpp \
+  evo/assetlocktx.cpp \
   evo/cbtx.cpp \
+  evo/creditpool.cpp \
   evo/deterministicmns.cpp \
   evo/dmnstate.cpp \
   evo/evodb.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 7152329f7acc3..c48eacf1c057c 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -95,6 +95,7 @@ BITCOIN_TESTS =\
   test/dip0020opcodes_tests.cpp \
   test/descriptor_tests.cpp \
   test/dynamic_activation_thresholds_tests.cpp \
+  test/evo_assetlocks_tests.cpp \
   test/evo_deterministicmns_tests.cpp \
   test/evo_instantsend_tests.cpp \
   test/evo_simplifiedmns_tests.cpp \
diff --git a/src/bloom.cpp b/src/bloom.cpp
index d8c2e6dac50cb..2c30ce4aaee1c 100644
--- a/src/bloom.cpp
+++ b/src/bloom.cpp
@@ -194,6 +194,10 @@ bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &t
     case(TRANSACTION_MNHF_SIGNAL):
         // No additional checks for this transaction types
         return false;
+    case(TRANSACTION_ASSET_LOCK):
+    case(TRANSACTION_ASSET_UNLOCK):
+        // TODO asset lock/unlock bloom?
+        return false;
     }
 
     LogPrintf("Unknown special transaction type in Bloom filter check.\n");
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 7e4e42e610bcd..aba5d97ed992a 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -258,6 +258,7 @@ class CMainParams : public CChainParams {
         consensus.llmqTypeDIP0024InstantSend = Consensus::LLMQType::LLMQ_60_75;
         consensus.llmqTypePlatform = Consensus::LLMQType::LLMQ_100_67;
         consensus.llmqTypeMnhf = Consensus::LLMQType::LLMQ_400_85;
+        consensus.llmqTypeAssetLocks = Consensus::LLMQType::LLMQ_400_85;
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = true;
@@ -447,6 +448,7 @@ class CTestNetParams : public CChainParams {
         consensus.llmqTypeDIP0024InstantSend = Consensus::LLMQType::LLMQ_60_75;
         consensus.llmqTypePlatform = Consensus::LLMQType::LLMQ_25_67;
         consensus.llmqTypeMnhf = Consensus::LLMQType::LLMQ_50_60;
+        consensus.llmqTypeAssetLocks = Consensus::LLMQType::LLMQ_50_60;
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = false;
@@ -619,6 +621,7 @@ class CDevNetParams : public CChainParams {
         consensus.llmqTypeDIP0024InstantSend = Consensus::LLMQType::LLMQ_60_75;
         consensus.llmqTypePlatform = Consensus::LLMQType::LLMQ_100_67;
         consensus.llmqTypeMnhf = Consensus::LLMQType::LLMQ_50_60;
+        consensus.llmqTypeAssetLocks = Consensus::LLMQType::LLMQ_50_60;
 
         UpdateDevnetLLMQChainLocksFromArgs(args);
         UpdateDevnetLLMQInstantSendFromArgs(args);
@@ -891,6 +894,7 @@ class CRegTestParams : public CChainParams {
         consensus.llmqTypeDIP0024InstantSend = Consensus::LLMQType::LLMQ_TEST_DIP0024;
         consensus.llmqTypePlatform = Consensus::LLMQType::LLMQ_TEST_PLATFORM;
         consensus.llmqTypeMnhf = Consensus::LLMQType::LLMQ_TEST;
+        consensus.llmqTypeAssetLocks = Consensus::LLMQType::LLMQ_TEST;
 
         UpdateLLMQTestParametersFromArgs(args, Consensus::LLMQType::LLMQ_TEST);
         UpdateLLMQTestParametersFromArgs(args, Consensus::LLMQType::LLMQ_TEST_INSTANTSEND);
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 7072e441c4828..0c9083086d2c0 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -125,6 +125,7 @@ struct Params {
     LLMQType llmqTypeDIP0024InstantSend{LLMQType::LLMQ_NONE};
     LLMQType llmqTypePlatform{LLMQType::LLMQ_NONE};
     LLMQType llmqTypeMnhf{LLMQType::LLMQ_NONE};
+    LLMQType llmqTypeAssetLocks{LLMQType::LLMQ_NONE};
 };
 } // namespace Consensus
 
diff --git a/src/consensus/tx_check.cpp b/src/consensus/tx_check.cpp
index dff067b685a4c..5c54c4e4242a9 100644
--- a/src/consensus/tx_check.cpp
+++ b/src/consensus/tx_check.cpp
@@ -12,15 +12,20 @@
 
 bool CheckTransaction(const CTransaction& tx, TxValidationState& state)
 {
-    bool allowEmptyTxInOut = false;
+    bool allowEmptyTxIn = false;
+    bool allowEmptyTxOut = false;
     if (tx.nType == TRANSACTION_QUORUM_COMMITMENT) {
-        allowEmptyTxInOut = true;
+        allowEmptyTxIn = true;
+        allowEmptyTxOut = true;
+    }
+    if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
+        allowEmptyTxIn = true;
     }
 
     // Basic checks that don't depend on any context
-    if (!allowEmptyTxInOut && tx.vin.empty())
+    if (!allowEmptyTxIn && tx.vin.empty())
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vin-empty");
-    if (!allowEmptyTxInOut && tx.vout.empty())
+    if (!allowEmptyTxOut && tx.vout.empty())
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-empty");
     // Size limits
     if (::GetSerializeSize(tx, PROTOCOL_VERSION) > MAX_LEGACY_BLOCK_SIZE)
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 58f1b2fc0bd3f..01c8a400e51e4 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -8,6 +8,7 @@
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <consensus/validation.h>
+#include <evo/assetlocktx.h>
 
 // TODO remove the following dependencies
 #include <chain.h>
@@ -160,6 +161,20 @@ unsigned int GetTransactionSigOpCount(const CTransaction& tx, const CCoinsViewCa
 
 bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
 {
+
+    if (bool isAssetUnlockTx = (tx.nVersion == 3 && tx.nType ==  TRANSACTION_ASSET_UNLOCK); isAssetUnlockTx) {
+        CAssetUnlockPayload assetUnlockTx;
+        if (!GetTxPayload(tx, assetUnlockTx)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
+        }
+        CAmount txfee_aux = assetUnlockTx.getFee();
+        if (!MoneyRange(txfee_aux)) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-assetunlock-fee-outofrange");
+        }
+        txfee = txfee_aux;
+        return true;
+    }
+
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
         return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 046b735f09776..10c82e2149a37 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -16,6 +16,7 @@
 
 #include <spentindex.h>
 
+#include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/mnhftx.h>
 #include <evo/providertx.h>
@@ -310,6 +311,20 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
             mnhfTx.ToJson(obj);
             entry.pushKV("mnhfTx", obj);
         }
+    } else if (tx.nType == TRANSACTION_ASSET_LOCK) {
+        CAssetLockPayload assetLockTx;
+        if (!GetTxPayload(tx, assetLockTx)) {
+            UniValue obj;
+            assetLockTx.ToJson(obj);
+            entry.pushKV("assetLockTx", obj);
+        }
+    } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
+        CAssetUnlockPayload assetUnlockTx;
+        if (!GetTxPayload(tx, assetUnlockTx)) {
+            UniValue obj;
+            assetUnlockTx.ToJson(obj);
+            entry.pushKV("assetUnlockTx", obj);
+        }
     }
 
     if (!hashBlock.IsNull())
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
new file mode 100644
index 0000000000000..8b229f650894a
--- /dev/null
+++ b/src/evo/assetlocktx.cpp
@@ -0,0 +1,237 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <evo/assetlocktx.h>
+#include <evo/specialtx.h>
+#include <evo/creditpool.h>
+
+#include <consensus/params.h>
+
+#include <chainparams.h>
+#include <validation.h>
+
+#include <llmq/commitment.h>
+#include <llmq/signing.h>
+#include <llmq/utils.h>
+#include <llmq/quorums.h>
+
+#include <algorithm>
+
+/*
+   Common code for Asset Lock and Asset Unlock
+    */
+bool CheckAssetLockUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state)
+{
+    switch (tx.nType) {
+    case TRANSACTION_ASSET_LOCK:
+        return CheckAssetLockTx(tx, state);
+    case TRANSACTION_ASSET_UNLOCK:
+        return CheckAssetUnlockTx(tx, pindexPrev, creditPool, state);
+    default:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-not-asset-locks-at-all");
+    }
+}
+
+/*
+   Asset Lock Transaction
+   */
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
+{
+    if (tx.nType != TRANSACTION_ASSET_LOCK) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-type");
+    }
+
+    CAmount returnAmount{0};
+    for (const CTxOut& txout : tx.vout) {
+        const CScript& script = txout.scriptPubKey;
+        if (script.empty() || script[0] != OP_RETURN) continue;
+
+        if (script.size() != 2 || script[1] != 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-non-empty-return");
+
+        if (txout.nValue <= 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-zeroout-return");
+
+        // Should be only one OP_RETURN
+        if (returnAmount) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-multiple-return");
+        returnAmount = txout.nValue;
+    }
+
+    if (returnAmount == 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-no-return");
+
+    CAssetLockPayload assetLockTx;
+    if (!GetTxPayload(tx, assetLockTx)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-payload");
+    }
+
+    if (assetLockTx.getVersion() == 0 || assetLockTx.getVersion() > CAssetLockPayload::CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version");
+    }
+
+    if (assetLockTx.getType() != 0) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-locktype");
+    }
+
+    if (assetLockTx.getCreditOutputs().empty()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-emptycreditoutputs");
+    }
+
+    CAmount creditOutputsAmount = 0;
+    for (const CTxOut& out : assetLockTx.getCreditOutputs()) {
+        creditOutputsAmount += out.nValue;
+        if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
+        }
+    }
+    if (creditOutputsAmount != returnAmount) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-creditamount");
+    }
+
+    return true;
+}
+
+std::string CAssetLockPayload::ToString() const
+{
+    std::string outputs{"["};
+    for (const CTxOut& tx: creditOutputs) {
+        outputs.append(tx.ToString());
+        outputs.append(",");
+    }
+    outputs.back() = ']';
+    return strprintf("CAssetLockPayload(nVersion=%d,nType=%d,creditOutputs=%s)", nVersion, nType, outputs.c_str());
+}
+
+uint16_t CAssetLockPayload::getVersion() const {
+    return nVersion;
+}
+
+uint16_t CAssetLockPayload::getType() const {
+    return nType;
+}
+
+const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const {
+    return creditOutputs;
+}
+
+/*
+   Asset Unlock Transaction (withdrawals)
+   */
+bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* pindexTip, TxValidationState& state) const
+{
+    // That quourm hash must be active at `requestHeight`,
+    // and at the quorumHash must be active in either the current or previous quorum cycle
+    // and the sig must validate against that specific quorumHash.
+
+    Consensus::LLMQType llmqType = Params().GetConsensus().llmqTypeAssetLocks;
+
+    const auto& llmq_params_opt = llmq::GetLLMQParams(llmqType);
+    if (!llmq_params_opt) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-llmq-type");
+    }
+
+    // We check at most 2 quorums, so, count is equal to 2
+    const int count = 2;
+    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, count > -1 ? count : llmq_params_opt->signingActiveQuorumCount);
+    bool isActive = std::any_of(quorums.begin(), quorums.end(), [&](const auto &q) { return q->qc->quorumHash == quorumHash; });
+
+    if (!isActive) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-not-active-quorum");
+    }
+
+    if (pindexTip->nHeight < requestedHeight || pindexTip->nHeight >= getHeightToExpiry()) {
+        LogPrintf("Asset unlock tx %d with requested height %d could not be accepted on height: %d\n",
+                index, requestedHeight, pindexTip->nHeight);
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-too-late");
+    }
+
+    const auto quorum = llmq::quorumManager->GetQuorum(llmqType, quorumHash);
+    assert(quorum);
+
+    const std::string id(strprintf("plwdtx%lld", index));
+
+    std::vector<uint8_t> vchHash(32);
+    CSHA256().Write(reinterpret_cast<const uint8_t*>(id.data()), id.size()).Finalize(vchHash.data());
+    uint256 requestId(vchHash);
+
+    uint256 signHash = llmq::utils::BuildSignHash(llmqType, quorum->qc->quorumHash, requestId, msgHash);
+    if (quorumSig.VerifyInsecure(quorum->qc->quorumPublicKey, signHash)) {
+        return true;
+    }
+
+    return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-not-verified");
+}
+
+bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state)
+{
+    if (tx.nType != TRANSACTION_ASSET_UNLOCK) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-type");
+    }
+
+    if (!tx.vin.empty()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-have-input");
+    }
+
+    if (tx.vout.size() > CAssetUnlockPayload::MAXIMUM_WITHDRAWALS) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-too-many-outs");
+    }
+
+    CAssetUnlockPayload assetUnlockTx;
+    if (!GetTxPayload(tx, assetUnlockTx)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
+    }
+
+    if (assetUnlockTx.getVersion() == 0 || assetUnlockTx.getVersion() > CAssetUnlockPayload::CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version");
+    }
+
+    if (creditPool.indexes.contains(assetUnlockTx.getIndex())) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-duplicated-index");
+    }
+
+    const CBlockIndex* pindexQuorum = WITH_LOCK(cs_main, return g_chainman.m_blockman.LookupBlockIndex(assetUnlockTx.getQuorumHash()));
+    if (!pindexQuorum) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-quorum-hash");
+    }
+
+    // Copy transaction except `quorumSig` field to calculate hash
+    CMutableTransaction tx_copy(tx);
+    auto payload_copy = CAssetUnlockPayload(assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature());
+    SetTxPayload(tx_copy, payload_copy);
+
+    uint256 msgHash = tx_copy.GetHash();
+    return assetUnlockTx.VerifySig(msgHash, pindexPrev, state);
+}
+
+std::string CAssetUnlockPayload::ToString() const
+{
+    return strprintf("CAssetUnlockPayload(nVersion=%d,index=%d,fee=%d.%08d,requestedHeight=%d,quorumHash=%d,quorumSig=%s",
+            nVersion, index, fee / COIN, fee % COIN, requestedHeight, quorumHash.GetHex(), quorumSig.ToString().c_str());
+}
+
+uint16_t CAssetUnlockPayload::getVersion() const {
+    return nVersion;
+}
+
+uint64_t CAssetUnlockPayload::getIndex() const {
+    return index;
+}
+
+uint32_t CAssetUnlockPayload::getFee() const {
+    return fee;
+}
+
+uint32_t CAssetUnlockPayload::getRequestedHeight() const {
+    return requestedHeight;
+}
+
+const uint256& CAssetUnlockPayload::getQuorumHash() const {
+    return quorumHash;
+}
+
+const CBLSSignature& CAssetUnlockPayload::getQuorumSig() const {
+    return quorumSig;
+}
+
+int CAssetUnlockPayload::getHeightToExpiry() const {
+    int expiryHeight = 48;
+    return requestedHeight + expiryHeight;
+}
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
new file mode 100644
index 0000000000000..a8e9b3a9f8b03
--- /dev/null
+++ b/src/evo/assetlocktx.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_EVO_ASSETLOCKTX_H
+#define BITCOIN_EVO_ASSETLOCKTX_H
+
+#include <bls/bls_ies.h>
+#include <evo/specialtx.h>
+#include <primitives/transaction.h>
+
+#include <key_io.h>
+#include <serialize.h>
+#include <tinyformat.h>
+#include <univalue.h>
+
+class CBlockIndex;
+struct CCreditPool;
+
+class CAssetLockPayload
+{
+public:
+    static constexpr uint16_t CURRENT_VERSION = 1;
+    static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_LOCK;
+
+private:
+    uint16_t nVersion{CURRENT_VERSION};
+    uint16_t nType{0};
+    std::vector<CTxOut> creditOutputs;
+
+public:
+    CAssetLockPayload(uint16_t nType, const std::vector<CTxOut>& creditOutputs) :
+        nType(nType),
+        creditOutputs(creditOutputs)
+    {}
+
+    CAssetLockPayload() = default;
+
+    SERIALIZE_METHODS(CAssetLockPayload, obj)
+    {
+        READWRITE(
+            obj.nVersion,
+            obj.nType,
+            obj.creditOutputs
+        );
+    }
+
+    std::string ToString() const;
+
+    void ToJson(UniValue& obj) const
+    {
+        obj.clear();
+        obj.setObject();
+        obj.pushKV("version", int(nVersion));
+        obj.pushKV("type", int(nType));
+        UniValue outputs;
+        outputs.setArray();
+        for (const CTxOut& out : creditOutputs) {
+            outputs.push_back(out.ToString());
+        }
+        obj.pushKV("creditOutputs", outputs);
+    }
+
+    // getters
+    uint16_t getVersion() const;
+    uint16_t getType() const;
+    const std::vector<CTxOut>& getCreditOutputs() const;
+};
+
+class CAssetUnlockPayload
+{
+public:
+    static constexpr uint16_t CURRENT_VERSION = 1;
+    static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_UNLOCK;
+
+    static constexpr size_t MAXIMUM_WITHDRAWALS = 32;
+
+private:
+    uint16_t nVersion{CURRENT_VERSION};
+    uint64_t index{0};
+    uint32_t fee{0};
+    uint32_t requestedHeight{0};
+    uint256 quorumHash{0};
+    CBLSSignature quorumSig{};
+
+public:
+    CAssetUnlockPayload(uint16_t nVersion, uint64_t index, uint32_t fee, uint32_t requestedHeight,
+            uint256 quorumHash, CBLSSignature quorumSig) :
+        nVersion(nVersion),
+        index(index),
+        fee(fee),
+        requestedHeight(requestedHeight),
+        quorumHash(quorumHash),
+        quorumSig(quorumSig)
+    {}
+
+    CAssetUnlockPayload() = default;
+
+    SERIALIZE_METHODS(CAssetUnlockPayload, obj)
+    {
+        READWRITE(
+            obj.nVersion,
+            obj.index,
+            obj.fee,
+            obj.requestedHeight,
+            obj.quorumHash,
+            obj.quorumSig
+        );
+    }
+
+    std::string ToString() const;
+
+    void ToJson(UniValue& obj) const
+    {
+        obj.clear();
+        obj.setObject();
+        obj.pushKV("version", int(nVersion));
+        obj.pushKV("index", int(index));
+        obj.pushKV("fee", int(fee));
+        obj.pushKV("requestedHeight", int(requestedHeight));
+        obj.pushKV("quorumHash", quorumHash.ToString());
+        obj.pushKV("quorumSig", quorumSig.ToString());
+    }
+
+    bool VerifySig(const uint256& msgHash, const CBlockIndex* pindexTip, TxValidationState& state) const;
+
+    // getters
+    uint16_t getVersion() const;
+    uint16_t getType() const;
+    uint64_t getIndex() const;
+    uint32_t getFee() const;
+    uint32_t getRequestedHeight() const;
+    const uint256& getQuorumHash() const;
+    const CBLSSignature& getQuorumSig() const;
+
+    // used by mempool to know when possible to drop a transaction as expired
+    int getHeightToExpiry() const;
+};
+
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);
+bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state);
+bool CheckAssetLockUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state);
+
+#endif // BITCOIN_EVO_ASSETLOCKTX_H
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index 4135ba7627b00..34797da3331c7 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -36,11 +36,11 @@ bool CheckCbTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidati
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
     }
 
-    if (pindexPrev && pindexPrev->nHeight + 1 != cbTx.nHeight) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-height");
-    }
-
     if (pindexPrev) {
+        if (pindexPrev->nHeight + 1 != cbTx.nHeight) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-height");
+        }
+
         bool fDIP0008Active = pindexPrev->nHeight >= Params().GetConsensus().DIP0008Height;
         if (fDIP0008Active && cbTx.nVersion < CCbTx::CB_V19_VERSION) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
@@ -431,8 +431,9 @@ bool CalcCbTxBestChainlock(const llmq::CChainLocksHandler& chainlock_handler, co
 
 std::string CCbTx::ToString() const
 {
-    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s)",
-        nVersion, nHeight, merkleRootMNList.ToString(), merkleRootQuorums.ToString(), bestCLHeightDiff, bestCLSignature.ToString());
+    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s, assetLockedAmount=%d.%08d)",
+        nVersion, nHeight, merkleRootMNList.ToString(), merkleRootQuorums.ToString(), bestCLHeightDiff, bestCLSignature.ToString(),
+        assetLockedAmount / COIN, assetLockedAmount % COIN);
 }
 
 std::optional<CCbTx> GetCoinbaseTx(const CBlockIndex* pindex)
diff --git a/src/evo/cbtx.h b/src/evo/cbtx.h
index f3141464f5fcd..c97d74595050f 100644
--- a/src/evo/cbtx.h
+++ b/src/evo/cbtx.h
@@ -20,6 +20,9 @@ class CQuorumBlockProcessor;
 class CChainLocksHandler;
 }// namespace llmq
 
+// Forward declaration from core_io to get rid of circular dependency
+UniValue ValueFromAmount(const CAmount& amount);
+
 // coinbase transaction
 class CCbTx
 {
@@ -34,6 +37,7 @@ class CCbTx
     uint256 merkleRootQuorums;
     uint32_t bestCLHeightDiff;
     CBLSSignature bestCLSignature;
+    CAmount assetLockedAmount{0};
 
     SERIALIZE_METHODS(CCbTx, obj)
     {
@@ -44,8 +48,10 @@ class CCbTx
             if (obj.nVersion >= CB_V20_VERSION) {
                 READWRITE(COMPACTSIZE(obj.bestCLHeightDiff));
                 READWRITE(obj.bestCLSignature);
+                READWRITE(obj.assetLockedAmount);
             }
         }
+
     }
 
     std::string ToString() const;
@@ -62,6 +68,7 @@ class CCbTx
             if (nVersion >= CB_V20_VERSION) {
                 obj.pushKV("bestCLHeightDiff", static_cast<int>(bestCLHeightDiff));
                 obj.pushKV("bestCLSignature", bestCLSignature.ToString());
+                obj.pushKV("assetLockedAmount", ValueFromAmount(assetLockedAmount));
             }
         }
     }
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
new file mode 100644
index 0000000000000..55f51ee03f0f2
--- /dev/null
+++ b/src/evo/creditpool.cpp
@@ -0,0 +1,335 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <evo/creditpool.h>
+
+#include <evo/assetlocktx.h>
+#include <evo/cbtx.h>
+
+#include <llmq/utils.h>
+
+#include <chain.h>
+#include <logging.h>
+#include <util/validation.h>
+#include <validation.h>
+
+#include <algorithm>
+#include <exception>
+#include <memory>
+#include <stack>
+
+static const std::string DB_CREDITPOOL_SNAPSHOT = "cpm_S";
+
+std::unique_ptr<CCreditPoolManager> creditPoolManager;
+
+static bool getDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint64_t& index, TxValidationState& state) {
+    CAssetUnlockPayload assetUnlockTx;
+    if (!GetTxPayload(tx, assetUnlockTx)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-payload");
+    }
+
+    index = assetUnlockTx.getIndex();
+    toUnlock = assetUnlockTx.getFee();
+    for (const CTxOut& txout : tx.vout) {
+        if (txout.nValue < 0) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-negative-amount");
+        }
+        toUnlock += txout.nValue;
+    }
+    return true;
+}
+
+namespace {
+    struct UnlockDataPerBlock  {
+        CAmount unlocked{0};
+        std::unordered_set<uint64_t> indexes;
+    };
+} // anonymous namespace
+
+// it throws exception if anything went wrong
+static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRef>& vtx) {
+    UnlockDataPerBlock blockData;
+
+    for (CTransactionRef tx : vtx) {
+        if (tx->nVersion != 3 || tx->nType != TRANSACTION_ASSET_UNLOCK) continue;
+
+        CAmount unlocked{0};
+        TxValidationState tx_state;
+        uint64_t index{0};
+        if (!getDataFromUnlockTx(*tx, unlocked, index, tx_state)) {
+            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getCreditPool failed: %s", __func__, FormatStateMessage(tx_state)));
+        }
+        blockData.unlocked += unlocked;
+        blockData.indexes.insert(index);
+    }
+    return blockData;
+}
+
+bool CSkipSet::add(uint64_t value) {
+    assert(!contains(value));
+
+    if (auto it = skipped.find(value); it != skipped.end()) {
+        skipped.erase(it);
+        return true;
+    }
+
+    assert(current_max <= value);
+    if (capacity() + value - current_max > capacity_limit) {
+        LogPrintf("CSkipSet::add failed due to capacity exceeded: requested %lld to %lld while limit is %lld\n",
+                value - current_max, capacity(), capacity_limit);
+        return false;
+    }
+    for (uint64_t index = current_max; index < value; ++index) {
+        bool insert_ret = skipped.insert(index).second;
+        assert(insert_ret);
+    }
+    current_max = value + 1;
+    return true;
+}
+
+bool CSkipSet::canBeAdded(uint64_t value) const {
+    if (contains(value)) return false;
+
+    if (skipped.find(value) != skipped.end()) return true;
+
+    if (capacity() + value - current_max > capacity_limit) {
+        return false;
+    }
+
+    return true;
+}
+
+bool CSkipSet::contains(uint64_t value) const {
+    if (current_max <= value) return false;
+    return skipped.find(value) == skipped.end();
+}
+
+std::string CCreditPool::ToString() const {
+    return strprintf("CCreditPool(locked=%lld,currentLimit=%lld,nIndexes=%lld)",
+            locked, currentLimit, indexes.size());
+}
+
+std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* const block_index) {
+    if (!llmq::utils::IsV20Active(block_index)) return CCreditPool{};
+
+    uint256 block_hash = block_index->GetBlockHash();
+    CCreditPool pool;
+    {
+        LOCK(cs_cache);
+        if (creditPoolCache.get(block_hash, pool)) {
+            return pool;
+        }
+    }
+    if (block_index->nHeight % DISK_SNAPSHOT_PERIOD == 0) {
+        if (evoDb.Read(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool)) {
+            LOCK(cs_cache);
+            creditPoolCache.insert(block_hash, pool);
+            return pool;
+        }
+    }
+    return std::nullopt;
+}
+
+void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const CCreditPool &pool) {
+    {
+        LOCK(cs_cache);
+        creditPoolCache.insert(block_hash, pool);
+    }
+    if (height % DISK_SNAPSHOT_PERIOD == 0) {
+        evoDb.Write(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool);
+    }
+}
+
+static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex *block_index, const Consensus::Params& consensusParams) {
+    CBlock block;
+    if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
+        throw std::runtime_error("failed-getcbforblock-read");
+    }
+    // Should not fail if V20 (DIP0027) are active but it happens for Unit Tests
+    if (block.vtx[0]->nVersion != 3) return std::nullopt;
+
+    assert(!block.vtx.empty());
+    assert(block.vtx[0]->nVersion == 3);
+    assert(!block.vtx[0]->vExtraPayload.empty());
+
+    return block;
+}
+
+CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams)
+{
+    std::optional<CBlock> block = getBlockForCreditPool(block_index, consensusParams);
+    if (!block) {
+        // If reading of previous block is not read successfully, but
+        // prev contains credit pool related data, something strange happened
+        assert(prev.locked == 0);
+        assert(prev.indexes.size() == 0);
+
+        CCreditPool emptyPool;
+        addToCache(block_index->GetBlockHash(), block_index->nHeight, emptyPool);
+        return emptyPool;
+    }
+    CAmount locked{0};
+    {
+        CCbTx cbTx;
+        if (!GetTxPayload(block->vtx[0]->vExtraPayload, cbTx)) {
+            throw std::runtime_error(strprintf("%s: failed-getcreditpool-cbtx-payload", __func__));
+        }
+        locked = cbTx.assetLockedAmount;
+    }
+
+    // We use here sliding window with LimitBlocksToTrace to determine
+    // current limits for asset unlock transactions.
+    // Indexes should not be duplicated since genesis block, but the Unlock Amount
+    // of withdrawal transaction is limited only by this window
+    UnlockDataPerBlock blockData = getDataFromUnlockTxes(block->vtx);
+    CSkipSet indexes{std::move(prev.indexes)};
+    if (std::any_of(blockData.indexes.begin(), blockData.indexes.end(), [&](const uint64_t index) { return !indexes.add(index); })) {
+        throw std::runtime_error(strprintf("%s: failed-getcreditpool-index-exceed", __func__));
+    }
+
+    const CBlockIndex* distant_block_index = block_index;
+    for (size_t i = 0; i < CCreditPoolManager::LimitBlocksToTrace; ++i) {
+        distant_block_index = distant_block_index->pprev;
+        if (distant_block_index == nullptr) break;
+    }
+    CAmount distantUnlocked{0};
+    if (distant_block_index) {
+        if (std::optional<CBlock> distant_block = getBlockForCreditPool(distant_block_index, consensusParams); distant_block) {
+            distantUnlocked = getDataFromUnlockTxes(distant_block->vtx).unlocked;
+        }
+    }
+
+    // Unlock limits are # max(100, min(.10 * assetlockpool, 1000)) inside window
+    CAmount currentLimit = locked;
+    CAmount latelyUnlocked = prev.latelyUnlocked + blockData.unlocked - distantUnlocked;
+    if (currentLimit + latelyUnlocked > LimitAmountLow) {
+        currentLimit = std::max(LimitAmountLow, locked / 10) - latelyUnlocked;
+        if (currentLimit < 0) currentLimit = 0;
+    }
+    currentLimit = std::min(currentLimit, LimitAmountHigh - latelyUnlocked);
+
+    assert(currentLimit >= 0);
+
+    if (currentLimit || latelyUnlocked || locked) {
+        LogPrintf("CCreditPoolManager: asset unlock limits on height: %d locked: %d.%08d limit: %d.%08d previous: %d.%08d\n", block_index->nHeight, locked / COIN, locked % COIN,
+               currentLimit / COIN, currentLimit % COIN,
+               latelyUnlocked / COIN, latelyUnlocked % COIN);
+    }
+
+    CCreditPool pool{locked, currentLimit, latelyUnlocked, indexes};
+    addToCache(block_index->GetBlockHash(), block_index->nHeight, pool);
+    return pool;
+
+}
+
+CCreditPool CCreditPoolManager::getCreditPool(const CBlockIndex* block_index, const Consensus::Params& consensusParams)
+{
+    std::stack<const CBlockIndex *> to_calculate;
+
+    std::optional<CCreditPool> poolTmp;
+    while (!(poolTmp = getFromCache(block_index)).has_value()) {
+        to_calculate.push(block_index);
+        block_index = block_index->pprev;
+    }
+    while (!to_calculate.empty()) {
+        poolTmp = constructCreditPool(to_calculate.top(), *poolTmp, consensusParams);
+        to_calculate.pop();
+    }
+    return *poolTmp;
+}
+
+CCreditPoolManager::CCreditPoolManager(CEvoDB& _evoDb)
+: evoDb(_evoDb)
+{
+}
+
+CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex, const Consensus::Params& consensusParams) :
+    pool(std::move(starter)),
+    pindex(pindex)
+{
+    assert(pindex);
+}
+
+bool CCreditPoolDiff::setTarget(const CTransaction& tx, TxValidationState& state)
+{
+    CCbTx cbTx;
+    if (!GetTxPayload(tx, cbTx)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-payload");
+    }
+
+    if (cbTx.nVersion == 3) {
+        targetLocked = cbTx.assetLockedAmount;
+    }
+    return true;
+}
+
+bool CCreditPoolDiff::lock(const CTransaction& tx, TxValidationState& state)
+{
+    CAssetLockPayload assetLockTx;
+    if (!GetTxPayload(tx, assetLockTx)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-lock-payload");
+    }
+
+    for (const CTxOut& txout : tx.vout) {
+        const CScript& script = txout.scriptPubKey;
+        if (script.empty() || script[0] != OP_RETURN) continue;
+
+        sessionLocked += txout.nValue;
+        return true;
+    }
+
+    return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-lock-invalid");
+}
+
+bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
+{
+    uint64_t index{0};
+    CAmount toUnlock{0};
+    if (!getDataFromUnlockTx(tx, toUnlock, index, state)) {
+        // state is set up inside getDataFromUnlockTx
+        return false;
+    }
+
+    if (sessionUnlocked + toUnlock > pool.currentLimit) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-too-much");
+    }
+
+    if (pool.indexes.contains(index) || newIndexes.count(index)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-duplicated-index");
+    }
+
+    if (!pool.indexes.canBeAdded(index)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-getcbforblock-index-exceed");
+    }
+
+    newIndexes.insert(index);
+    sessionUnlocked += toUnlock;
+    return true;
+}
+
+bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationState& state) {
+    if (tx.nVersion != 3) return true;
+    if (tx.nType == TRANSACTION_COINBASE) return setTarget(tx, state);
+
+    if (tx.nType != TRANSACTION_ASSET_LOCK && tx.nType != TRANSACTION_ASSET_UNLOCK) return true;
+
+    if (!CheckAssetLockUnlockTx(tx, pindex, this->pool, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    try {
+        switch (tx.nType) {
+        case TRANSACTION_ASSET_LOCK:
+            return lock(tx, state);
+        case TRANSACTION_ASSET_UNLOCK:
+            return unlock(tx, state);
+        default:
+            return true;
+        }
+    } catch (const std::exception& e) {
+        LogPrintf("%s -- failed: %s\n", __func__, e.what());
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-procassetlocksinblock");
+    }
+}
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
new file mode 100644
index 0000000000000..fc2522c93c290
--- /dev/null
+++ b/src/evo/creditpool.h
@@ -0,0 +1,175 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_EVO_CREDITPOOL_H
+#define BITCOIN_EVO_CREDITPOOL_H
+
+#include <coins.h>
+
+#include <evo/assetlocktx.h>
+#include <evo/evodb.h>
+
+#include <sync.h>
+#include <threadsafety.h>
+
+#include <optional>
+#include <unordered_set>
+
+#include <saltedhasher.h>
+#include <unordered_lru_cache.h>
+
+class CBlockIndex;
+class TxValidationState;
+
+namespace Consensus
+{
+    struct Params;
+}
+
+// This datastructure keeps efficiently all indexes and have a strict limit for used memory
+// So far as CCreditPool is built only in direction from parent block to child
+// there's no need to remove elements from CSkipSet ever, only add them
+class CSkipSet {
+private:
+    std::unordered_set<uint64_t> skipped;
+    uint64_t current_max{0};
+    size_t capacity_limit;
+public:
+    explicit CSkipSet(size_t capacity_limit = 10'000) :
+        capacity_limit(capacity_limit)
+    {}
+
+    /**
+     * adding value that already exist in CKipSet will cause `assert`.
+     *
+     */
+    [[nodiscard]] bool add(uint64_t value);
+
+    bool canBeAdded(uint64_t value) const;
+
+    bool contains(uint64_t value) const;
+
+    size_t size() const {
+        return current_max - skipped.size();
+    }
+    size_t capacity() const {
+        return skipped.size();
+    }
+
+    SERIALIZE_METHODS(CSkipSet, obj)
+    {
+        READWRITE(obj.current_max);
+        READWRITE(obj.skipped);
+    }
+};
+
+struct CCreditPool {
+    CAmount locked{0};
+
+    // needs for logic of limits of unlocks
+    CAmount currentLimit{0};
+    CAmount latelyUnlocked{0};
+    CSkipSet indexes{};
+
+    std::string ToString() const;
+
+    SERIALIZE_METHODS(CCreditPool, obj)
+    {
+        READWRITE(
+            obj.locked,
+            obj.currentLimit,
+            obj.latelyUnlocked,
+            obj.indexes
+        );
+    }
+};
+
+/**
+ * The class CCreditPoolDiff has 2 purposes:
+ *  - it helps to determine which transaction can be included in new mined block
+ *  within current limits for Asset Unlock transactions and filter duplicated indexes
+ *  - to validate Asset Unlock transaction in mined block. The standalone checks of tx
+ *  such as CheckSpecialTx is not able to do so because at that moment there is no full
+ *  information about Credit Pool limits.
+ *
+ * CCreditPoolDiff temporary stores new values `lockedAmount` and `indexes` while
+ * limits should stay same and depends only on the previous block.
+ */
+class CCreditPoolDiff {
+private:
+    const CCreditPool pool;
+    std::unordered_set<uint64_t> newIndexes;
+
+    CAmount sessionLocked{0};
+    CAmount sessionUnlocked{0};
+
+    // target value is used to validate CbTx. If values mismatched, block is invalid
+    std::optional<CAmount> targetLocked;
+
+    const CBlockIndex *pindex{nullptr};
+public:
+    explicit CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex, const Consensus::Params& consensusParams);
+
+    /**
+     * This function should be called for each Asset Lock/Unlock tx
+     * to change amount of credit pool
+     * @return true if transaction can be included in this block
+     */
+    bool processTransaction(const CTransaction& tx, TxValidationState& state);
+
+    CAmount getTotalLocked() const {
+        return pool.locked + sessionLocked - sessionUnlocked;
+    }
+
+    const std::optional<CAmount>& getTargetLocked() const {
+        return targetLocked;
+    }
+
+    std::string ToString() const {
+        return strprintf("CCreditPoolDiff(target=%lld,sessionLocked=%lld,sessionUnlocked=%lld,newIndexes=%lld,pool=%s", getTargetLocked() ? *getTargetLocked() : -1, sessionLocked, sessionUnlocked, newIndexes.size(), pool.ToString());
+    }
+
+private:
+    bool setTarget(const CTransaction& tx, TxValidationState& state);
+    bool lock(const CTransaction& tx, TxValidationState& state);
+    bool unlock(const CTransaction& tx, TxValidationState& state);
+};
+
+class CCreditPoolManager
+{
+private:
+    static constexpr size_t CreditPoolCacheSize = 1000;
+    CCriticalSection cs_cache;
+    unordered_lru_cache<uint256, CCreditPool, StaticSaltedHasher> creditPoolCache GUARDED_BY(cs_cache) {CreditPoolCacheSize};
+
+    CEvoDB& evoDb;
+
+    static constexpr int DISK_SNAPSHOT_PERIOD = 576; // once per day
+
+public:
+    static constexpr int LimitBlocksToTrace = 576;
+    static constexpr CAmount LimitAmountLow = 100 * COIN;
+    static constexpr CAmount LimitAmountHigh = 1000 * COIN;
+
+    explicit CCreditPoolManager(CEvoDB& _evoDb);
+
+    ~CCreditPoolManager() = default;
+
+    /**
+      * @return CCreditPool with data or with empty depends on activation V19 at that block
+      * In case if block is invalid the function getCreditPool throws an exception
+      * it can happen if there limits of withdrawal (unlock) exceed
+      */
+    CCreditPool getCreditPool(const CBlockIndex* block, const Consensus::Params& consensusParams);
+
+private:
+    std::optional<CCreditPool> getFromCache(const CBlockIndex* const block_index);
+    void addToCache(const uint256& block_hash, int height, const CCreditPool& pool);
+
+    CCreditPool constructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams);
+};
+
+extern std::unique_ptr<CCreditPoolManager> creditPoolManager;
+
+#endif
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index dba0a94cff873..936da8ae8f6ed 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -7,9 +7,11 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <evo/cbtx.h>
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/mnhftx.h>
 #include <evo/providertx.h>
+#include <evo/assetlocktx.h>
 #include <hash.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
@@ -17,7 +19,7 @@
 #include <primitives/block.h>
 #include <validation.h>
 
-bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state, const CCoinsViewCache& view, bool check_sigs)
+bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, const CCreditPool& creditPool, bool check_sigs, TxValidationState& state)
 {
     AssertLockHeld(cs_main);
 
@@ -44,6 +46,12 @@ bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxVal
             return llmq::CheckLLMQCommitment(tx, pindexPrev, state);
         case TRANSACTION_MNHF_SIGNAL:
             return pindexPrev->nHeight + 1 >= Params().GetConsensus().DIP0024Height && CheckMNHFTx(tx, pindexPrev, state);
+        case TRANSACTION_ASSET_LOCK:
+        case TRANSACTION_ASSET_UNLOCK:
+            if (!llmq::utils::IsV20Active(pindexPrev)) {
+                return state.Invalid(TxValidationResult::TX_CONSENSUS, "v20-not-active");
+            }
+            return CheckAssetLockUnlockTx(tx, pindexPrev, creditPool, state);
         }
     } catch (const std::exception& e) {
         LogPrintf("%s -- failed: %s\n", __func__, e.what());
@@ -60,6 +68,9 @@ bool ProcessSpecialTx(const CTransaction& tx, const CBlockIndex* pindex, TxValid
     }
 
     switch (tx.nType) {
+    case TRANSACTION_ASSET_LOCK:
+    case TRANSACTION_ASSET_UNLOCK:
+        return true; // handled per block (during cb)
     case TRANSACTION_PROVIDER_REGISTER:
     case TRANSACTION_PROVIDER_UPDATE_SERVICE:
     case TRANSACTION_PROVIDER_UPDATE_REGISTRAR:
@@ -83,6 +94,9 @@ bool UndoSpecialTx(const CTransaction& tx, const CBlockIndex* pindex)
     }
 
     switch (tx.nType) {
+    case TRANSACTION_ASSET_LOCK:
+    case TRANSACTION_ASSET_UNLOCK:
+        return true; // handled per block (during cb)
     case TRANSACTION_PROVIDER_REGISTER:
     case TRANSACTION_PROVIDER_UPDATE_SERVICE:
     case TRANSACTION_PROVIDER_UPDATE_REGISTRAR:
@@ -100,7 +114,8 @@ bool UndoSpecialTx(const CTransaction& tx, const CBlockIndex* pindex)
 }
 
 bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, llmq::CQuorumBlockProcessor& quorum_block_processor, const llmq::CChainLocksHandler& chainlock_handler,
-                              BlockValidationState& state, const CCoinsViewCache& view, bool fJustCheck, bool fCheckCbTxMerleRoots)
+                              const Consensus::Params& consensusParams, const CCoinsViewCache& view, bool fJustCheck, bool fCheckCbTxMerleRoots,
+                              BlockValidationState& state)
 {
     AssertLockHeld(cs_main);
 
@@ -113,11 +128,18 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
 
         int64_t nTime1 = GetTimeMicros();
 
+        const CCreditPool creditPool = creditPoolManager->getCreditPool(pindex->pprev, consensusParams);
+        std::optional<CCreditPoolDiff> creditPoolDiff;
+        if (bool fV20Active_context = llmq::utils::IsV20Active(pindex->pprev); fV20Active_context) {
+            LogPrintf("%s: CCreditPool is %s\n", __func__, creditPool.ToString());
+            creditPoolDiff.emplace(creditPool, pindex->pprev, consensusParams);
+        }
+
         for (const auto& ptr_tx : block.vtx) {
             TxValidationState tx_state;
             // At this moment CheckSpecialTx() and ProcessSpecialTx() may fail by 2 possible ways:
             // consensus failures and "TX_BAD_SPECIAL"
-            if (!CheckSpecialTx(*ptr_tx, pindex->pprev, tx_state, view, fCheckCbTxMerleRoots)) {
+            if (!CheckSpecialTx(*ptr_tx, pindex->pprev, view, creditPool, fCheckCbTxMerleRoots, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Special Transaction check failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -127,6 +149,23 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
             }
+            if (creditPoolDiff && !creditPoolDiff->processTransaction(*ptr_tx, tx_state)) {
+                assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
+                                 strprintf("Process Special Transaction failed at Credit Pool (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
+
+                return false;
+            }
+        }
+        if (creditPoolDiff) {
+            CAmount locked_proposed{0};
+            if(creditPoolDiff->getTargetLocked()) locked_proposed = *creditPoolDiff->getTargetLocked();
+
+            CAmount locked_calculated = creditPoolDiff->getTotalLocked();
+            if (locked_proposed != locked_calculated) {
+                LogPrintf("%s: mismatched locked amount in CbTx: %lld against re-calculated: %lld\n", __func__, locked_proposed, locked_calculated);
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cbtx-assetlocked-amount");
+            }
         }
 
         int64_t nTime2 = GetTimeMicros();
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index 3db330730a041..89d74c7d2e9d8 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -12,18 +12,24 @@
 class BlockValidationState;
 class CBlock;
 class CBlockIndex;
+struct CCreditPool;
 class CCoinsViewCache;
 class TxValidationState;
 namespace llmq {
 class CQuorumBlockProcessor;
 class CChainLocksHandler;
 } // namespace llmq
+namespace Consensus {
+class Params;
+} // namespace Consensus
 
 extern RecursiveMutex cs_main;
 
-bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state, const CCoinsViewCache& view, bool check_sigs) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, const CCreditPool& pool, bool check_sigs,
+                    TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, llmq::CQuorumBlockProcessor& quorum_block_processor, const llmq::CChainLocksHandler& chainlock_handler,
-                              BlockValidationState& state, const CCoinsViewCache& view, bool fJustCheck, bool fCheckCbTxMerleRoots) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+                            const Consensus::Params& consensusParams, const CCoinsViewCache& view, bool fJustCheck, bool fCheckCbTxMerleRoots,
+                            BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 bool UndoSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, llmq::CQuorumBlockProcessor& quorum_block_processor) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 #endif // BITCOIN_EVO_SPECIALTXMAN_H
diff --git a/src/init.cpp b/src/init.cpp
index d43986b1b3bf0..0f8063c0adfec 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -82,6 +82,7 @@
 #include <spork.h>
 #include <walletinitinterface.h>
 
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/chainlocks.h>
@@ -352,6 +353,7 @@ void PrepareShutdown(NodeContext& node)
         }
         llmq::quorumSnapshotManager.reset();
         deterministicMNManager.reset();
+        creditPoolManager.reset();
         node.evodb.reset();
     }
     for (const auto& client : node.chain_clients) {
@@ -2031,6 +2033,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                 // Same logic as above with pblocktree
                 deterministicMNManager.reset();
                 deterministicMNManager.reset(new CDeterministicMNManager(*node.evodb, *node.connman));
+                creditPoolManager.reset(new CCreditPoolManager(*node.evodb));
                 llmq::quorumSnapshotManager.reset();
                 llmq::quorumSnapshotManager.reset(new llmq::CQuorumSnapshotManager(*node.evodb));
                 node.llmq_ctx.reset();
diff --git a/src/merkleblock.cpp b/src/merkleblock.cpp
index bd73dc4157cec..c55fab4773502 100644
--- a/src/merkleblock.cpp
+++ b/src/merkleblock.cpp
@@ -44,6 +44,8 @@ CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std:
             TRANSACTION_PROVIDER_UPDATE_REGISTRAR,
             TRANSACTION_PROVIDER_UPDATE_REVOKE,
             TRANSACTION_COINBASE,
+            TRANSACTION_ASSET_LOCK,
+            TRANSACTION_ASSET_UNLOCK,
     };
 
     for (unsigned int i = 0; i < block.vtx.size(); i++)
diff --git a/src/miner.cpp b/src/miner.cpp
index 6c3dc40f7c7c2..a54baa899069d 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -23,6 +23,7 @@
 
 #include <evo/specialtx.h>
 #include <evo/cbtx.h>
+#include <evo/creditpool.h>
 #include <evo/simplifiedmns.h>
 #include <governance/governance.h>
 #include <llmq/blockprocessor.h>
@@ -133,6 +134,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     bool fDIP0003Active_context = nHeight >= chainparams.GetConsensus().DIP0003Height;
     bool fDIP0008Active_context = nHeight >= chainparams.GetConsensus().DIP0008Height;
+    bool fV20Active_context = llmq::utils::IsV20Active(pindexPrev);
 
     pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // Non-mainnet only: allow overriding block.nVersion with
@@ -166,7 +168,14 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     int nPackagesSelected = 0;
     int nDescendantsUpdated = 0;
-    addPackageTxs(nPackagesSelected, nDescendantsUpdated);
+
+    std::optional<CCreditPoolDiff> creditPoolDiff;
+    if (fV20Active_context) {
+        CCreditPool creditPool = creditPoolManager->getCreditPool(pindexPrev, chainparams.GetConsensus());
+        LogPrintf("%s: CCreditPool is %s\n", __func__, creditPool.ToString());
+        creditPoolDiff.emplace(std::move(creditPool), pindexPrev, chainparams.GetConsensus());
+    }
+    addPackageTxs(nPackagesSelected, nDescendantsUpdated, creditPoolDiff);
 
     int64_t nTime1 = GetTimeMicros();
 
@@ -197,7 +206,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
         CCbTx cbTx;
 
-        if (llmq::utils::IsV20Active(pindexPrev)) {
+        if (fV20Active_context) {
             cbTx.nVersion = CCbTx::CB_V20_VERSION;
         } else if (fDIP0008Active_context) {
             cbTx.nVersion = CCbTx::CB_V19_VERSION;
@@ -215,14 +224,15 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
             if (!CalcCbTxMerkleRootQuorums(*pblock, pindexPrev, quorum_block_processor, cbTx.merkleRootQuorums, state)) {
                 throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootQuorums failed: %s", __func__, state.ToString()));
             }
-            if (llmq::utils::IsV20Active(pindexPrev)) {
+            if (fV20Active_context) {
                 if (CalcCbTxBestChainlock(m_clhandler, pindexPrev, cbTx.bestCLHeightDiff, cbTx.bestCLSignature)) {
                     LogPrintf("CreateNewBlock() h[%d] CbTx bestCLHeightDiff[%d] CLSig[%s]\n", nHeight, cbTx.bestCLHeightDiff, cbTx.bestCLSignature.ToString());
-                }
-                else {
+                } else {
                     // not an error
                     LogPrintf("CreateNewBlock() h[%d] CbTx failed to find best CL. Inserting null CL\n", nHeight);
                 }
+                assert(creditPoolDiff);
+                cbTx.assetLockedAmount = creditPoolDiff->getTotalLocked();
             }
         }
 
@@ -383,7 +393,7 @@ void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::ve
 // Each time through the loop, we compare the best transaction in
 // mapModifiedTxs with the next transaction in the mempool to decide what
 // transaction package to work on next.
-void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated)
+void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated, std::optional<CCreditPoolDiff>& creditPoolDiff)
 {
     AssertLockHeld(m_mempool.cs);
 
@@ -440,6 +450,23 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
             }
         }
 
+        if (creditPoolDiff) {
+            // If one transaction is skipped due to limits, it is not a reason to interrupt
+            // whole process of adding transactions.
+            // `state` is local here because used to log info about this specific tx
+            TxValidationState state;
+
+            if (!creditPoolDiff->processTransaction(iter->GetTx(), state)) {
+                if (fUsingModified) {
+                    mapModifiedTx.get<ancestor_score>().erase(modit);
+                    failedTx.insert(iter);
+                }
+                LogPrintf("%s: asset locks tx skipped due %s txid %s\n",
+                          __func__, FormatStateMessage(state), iter->GetTx().GetHash().ToString());
+                continue;
+            }
+        }
+
         // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
         // contain anything that is inBlock.
         assert(!inBlock.count(iter));
diff --git a/src/miner.h b/src/miner.h
index e067cdbdf4df7..adde0884e607d 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -20,6 +20,7 @@
 class CBlockIndex;
 class CChainParams;
 class CConnman;
+class CCreditPoolDiff;
 class CGovernanceManager;
 class CScript;
 class CSporkManager;
@@ -194,7 +195,7 @@ class BlockAssembler
     /** Add transactions based on feerate including unconfirmed ancestors
       * Increments nPackagesSelected / nDescendantsUpdated with corresponding
       * statistics from the package selection (for logging statistics). */
-    void addPackageTxs(int& nPackagesSelected, int& nDescendantsUpdated) EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs);
+    void addPackageTxs(int& nPackagesSelected, int& nDescendantsUpdated, std::optional<CCreditPoolDiff>& creditPoolDiff) EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs);
 
     // helper functions for addPackageTxs()
     /** Remove confirmed (inBlock) entries from given set */
diff --git a/src/node/context.cpp b/src/node/context.cpp
index 2fed2df7a4075..9abe0cd3927f7 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -6,6 +6,7 @@
 
 #include <addrman.h>
 #include <banman.h>
+#include <evo/creditpool.h>
 #include <interfaces/chain.h>
 #include <llmq/context.h>
 #include <evo/evodb.h>
diff --git a/src/node/context.h b/src/node/context.h
index dcdee0f96a681..ac8038b269ac3 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -15,6 +15,7 @@ class BanMan;
 class CAddrMan;
 class CBlockPolicyEstimator;
 class CConnman;
+class CCreditPoolManager;
 class CScheduler;
 class CTxMemPool;
 class ChainstateManager;
@@ -56,6 +57,7 @@ struct NodeContext {
     std::function<void()> rpc_interruption_point = [] {};
     //! Dash
     std::unique_ptr<LLMQContext> llmq_ctx;
+    std::unique_ptr<CCreditPoolManager> creditPoolManager;
 
     std::unique_ptr<CEvoDB> evodb;
 
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 3e0fe28cd4af5..3a8feddcb59c1 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -22,6 +22,8 @@ enum {
     TRANSACTION_COINBASE = 5,
     TRANSACTION_QUORUM_COMMITMENT = 6,
     TRANSACTION_MNHF_SIGNAL = 7,
+    TRANSACTION_ASSET_LOCK = 8,
+    TRANSACTION_ASSET_UNLOCK = 9,
 };
 
 /** An outpoint - a combination of a transaction hash and an index n into its vout */
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 0417765f7599e..34f65f8b5296b 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -7,6 +7,7 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/providertx.h>
@@ -328,8 +329,10 @@ static std::string SignAndSendSpecialTx(const JSONRPCRequest& request, const CMu
     {
     LOCK(cs_main);
 
+    CCreditPool creditPool = creditPoolManager->getCreditPool(::ChainActive().Tip(), Params().GetConsensus());
+
     TxValidationState state;
-    if (!CheckSpecialTx(CTransaction(tx), ::ChainActive().Tip(), state, ::ChainstateActive().CoinsTip(), true)) {
+    if (!CheckSpecialTx(CTransaction(tx), ::ChainActive().Tip(), ::ChainstateActive().CoinsTip(), creditPool, true, state)) {
         throw std::runtime_error(state.ToString());
     }
     } // cs_main
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
new file mode 100644
index 0000000000000..6b13bb33b0417
--- /dev/null
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -0,0 +1,360 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/setup_common.h>
+
+#include <evo/assetlocktx.h>
+#include <policy/settings.h>
+#include <script/signingprovider.h>
+#include <consensus/tx_check.h>
+#include <script/script.h>
+
+#include <validation.h> // for ::ChainActive()
+
+#include <boost/test/unit_test.hpp>
+
+
+//
+// Helper: create two dummy transactions, each with
+// two outputs.  The first has 11 and 50 CENT outputs
+// paid to a TX_PUBKEY, the second 21 and 22 CENT outputs
+// paid to a TX_PUBKEYHASH.
+//
+static std::vector<CMutableTransaction>
+SetupDummyInputs(FillableSigningProvider& keystoreRet, CCoinsViewCache& coinsRet)
+{
+    std::vector<CMutableTransaction> dummyTransactions;
+    dummyTransactions.resize(2);
+
+    // Add some keys to the keystore:
+    std::array<CKey, 4> key;
+    {
+        bool flip = true;
+        for (auto& k : key) {
+            k.MakeNewKey(flip);
+            keystoreRet.AddKey(k);
+            flip = !flip;
+        }
+    }
+
+    // Create some dummy input transactions
+    dummyTransactions[0].vout.resize(2);
+    dummyTransactions[0].vout[0].nValue = 11*CENT;
+    dummyTransactions[0].vout[0].scriptPubKey << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
+    dummyTransactions[0].vout[1].nValue = 50*CENT;
+    dummyTransactions[0].vout[1].scriptPubKey << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
+    AddCoins(coinsRet, CTransaction(dummyTransactions[0]), 0);
+
+    dummyTransactions[1].vout.resize(2);
+    dummyTransactions[1].vout[0].nValue = 21*CENT;
+    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[2].GetPubKey()));
+    dummyTransactions[1].vout[1].nValue = 22*CENT;
+    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(PKHash(key[3].GetPubKey()));
+    AddCoins(coinsRet, CTransaction(dummyTransactions[1]), 0);
+
+    return dummyTransactions;
+}
+
+static CMutableTransaction CreateAssetLockTx(FillableSigningProvider& keystore, CCoinsViewCache& coins, CKey& key)
+{
+    std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
+
+    std::vector<CTxOut> creditOutputs(2);
+    creditOutputs[0].nValue = 17 * CENT;
+    creditOutputs[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+    creditOutputs[1].nValue = 13 * CENT;
+    creditOutputs[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+    CAssetLockPayload assetLockTx(0, creditOutputs);
+
+    CMutableTransaction tx;
+    tx.nVersion = 2;
+    tx.nType = TRANSACTION_ASSET_LOCK;
+    SetTxPayload(tx, assetLockTx);
+
+    tx.vin.resize(1);
+    tx.vin[0].prevout.hash = dummyTransactions[0].GetHash();
+    tx.vin[0].prevout.n = 1;
+    tx.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
+
+    tx.vout.resize(2);
+    tx.vout[0].nValue = 30 * CENT;
+    tx.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
+
+    tx.vout[1].nValue = 20 * CENT;
+    tx.vout[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+    return tx;
+}
+
+static CMutableTransaction CreateAssetUnlockTx(FillableSigningProvider& keystore, CKey& key)
+{
+    int nVersion = 1;
+    // just a big number bigger than uint32_t
+    uint64_t index = 0x001122334455667788L;
+    // big enough to overflow int32_t
+    uint32_t fee = 2000'000'000u;
+    // just big enough to overflow uint16_t
+    uint32_t requestedHeight = 1000'000;
+    uint256 quorumHash;
+    CBLSSignature quorumSig;
+    CAssetUnlockPayload assetUnlockTx(nVersion, index, fee, requestedHeight, quorumHash, quorumSig);
+
+    CMutableTransaction tx;
+    tx.nVersion = 2;
+    tx.nType = TRANSACTION_ASSET_UNLOCK;
+    SetTxPayload(tx, assetUnlockTx);
+
+    tx.vin.resize(0);
+
+    tx.vout.resize(2);
+    tx.vout[0].nValue = 10 * CENT;
+    tx.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+    tx.vout[1].nValue = 20 * CENT;
+    tx.vout[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+    return tx;
+}
+
+BOOST_FIXTURE_TEST_SUITE(evo_assetlocks_tests, TestChain100Setup)
+
+BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
+{
+
+    LOCK(cs_main);
+    FillableSigningProvider keystore;
+    CCoinsView coinsDummy;
+    CCoinsViewCache coins(&coinsDummy);
+
+    CKey key;
+    key.MakeNewKey(true);
+
+    const CMutableTransaction tx = CreateAssetLockTx(keystore, coins, key);
+    std::string reason;
+    BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
+
+    TxValidationState tx_state;
+    std::string strTest;
+    BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), tx_state), strTest);
+    BOOST_CHECK(tx_state.IsValid());
+
+    BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state));
+
+    BOOST_CHECK(AreInputsStandard(CTransaction(tx), coins));
+
+    // Check version
+    {
+        BOOST_CHECK(tx.nVersion == 2);
+
+        CAssetLockPayload lockPayload;
+        GetTxPayload(tx, lockPayload);
+
+        BOOST_CHECK(lockPayload.getVersion() == 1);
+    }
+
+    {
+        // Wrong type "Asset Unlock TX" instead "Asset Lock TX"
+        CMutableTransaction txWrongType = tx;
+        txWrongType.nType = TRANSACTION_ASSET_UNLOCK;
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txWrongType), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-type");
+    }
+
+    {
+        CAmount inSum = 0;
+        for (const auto& vin : tx.vin) {
+            inSum += coins.AccessCoin(vin.prevout).out.nValue;
+        }
+
+        auto outSum = CTransaction(tx).GetValueOut();
+        BOOST_CHECK(inSum == outSum);
+
+        // Outputs should not be bigger than inputs
+        CMutableTransaction txBigOutput = tx;
+        txBigOutput.vout[0].nValue += 1;
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBigOutput), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
+
+        // Smaller outputs are allown
+        CMutableTransaction txSmallOutput = tx;
+        txSmallOutput.vout[1].nValue -= 1;
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txSmallOutput), tx_state));
+    }
+
+    const CAssetLockPayload assetLockPayload = [tx]() -> CAssetLockPayload {
+        CAssetLockPayload payload;
+        GetTxPayload(tx, payload);
+        return payload;
+    }();
+    const std::vector<CTxOut> creditOutputs = assetLockPayload.getCreditOutputs();
+
+    {
+        BOOST_CHECK(assetLockPayload.getType() == 0);
+
+        // Type of payload is not `0`
+        CMutableTransaction txPayloadWrongType = tx;
+
+        CAssetLockPayload assetLockWrongType(1, creditOutputs);
+        SetTxPayload(txPayloadWrongType, assetLockWrongType);
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txPayloadWrongType), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-locktype");
+    }
+
+    {
+        // Sum of credit output greater than OP_RETURN
+        std::vector<CTxOut> wrongOutput = creditOutputs;
+        wrongOutput[0].nValue += CENT;
+        CAssetLockPayload greaterCreditsPayload(0, wrongOutput);
+
+        CMutableTransaction txGreaterCredits = tx;
+        SetTxPayload(txGreaterCredits, greaterCreditsPayload);
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txGreaterCredits), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
+
+        // Sum of credit output less than OP_RETURN
+        wrongOutput[1].nValue -= 2 * CENT;
+        CAssetLockPayload lessCreditsPayload(0, wrongOutput);
+
+        CMutableTransaction txLessCredits = tx;
+        SetTxPayload(txLessCredits, lessCreditsPayload);
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txLessCredits), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
+    }
+
+    {
+        // One credit output keys is not pub key
+        std::vector<CTxOut> creditOutputsNotPubkey = creditOutputs;
+        creditOutputsNotPubkey[0].scriptPubKey = CScript() << OP_1;
+        CAssetLockPayload notPubkeyPayload(0, creditOutputsNotPubkey);
+
+        CMutableTransaction txNotPubkey = tx;
+        SetTxPayload(txNotPubkey, notPubkeyPayload);
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNotPubkey), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+
+    }
+
+    {
+        // OP_RETURN must be only one, not more
+        CMutableTransaction txMultipleReturn = tx;
+        txMultipleReturn.vout[1].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-multiple-return");
+
+    }
+
+    {
+        // OP_RETURN is missing
+        CMutableTransaction txNoReturn = tx;
+        txNoReturn.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNoReturn), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-no-return");
+    }
+
+    {
+        // OP_RETURN should not have any data
+        CMutableTransaction txMultipleReturn = tx;
+        txMultipleReturn.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("abc");
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-non-empty-return");
+    }
+}
+
+BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
+{
+    LOCK(cs_main);
+    FillableSigningProvider keystore;
+
+    CKey key;
+    key.MakeNewKey(true);
+
+    const CMutableTransaction tx = CreateAssetUnlockTx(keystore, key);
+    std::string reason;
+    BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
+
+    TxValidationState tx_state;
+    std::string strTest;
+    BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), tx_state), strTest);
+    BOOST_CHECK(tx_state.IsValid());
+
+    const CBlockIndex *block_index = ::ChainActive().Tip();
+    CCreditPool pool;
+    BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(tx), block_index, pool, tx_state));
+    BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
+
+    {
+        // Any input should be a reason to fail CheckAssetUnlockTx()
+        CCoinsView coinsDummy;
+        CCoinsViewCache coins(&coinsDummy);
+        std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
+
+        CMutableTransaction txNonemptyInput = tx;
+        txNonemptyInput.vin.resize(1);
+        txNonemptyInput.vin[0].prevout.hash = dummyTransactions[0].GetHash();
+        txNonemptyInput.vin[0].prevout.n = 1;
+        txNonemptyInput.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
+
+        std::string reason;
+        BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
+
+        BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txNonemptyInput), block_index, pool, tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-have-input");
+    }
+
+    // Check version
+    BOOST_CHECK(tx.nVersion == 2);
+    {
+        CAssetUnlockPayload unlockPayload;
+        GetTxPayload(tx, unlockPayload);
+        BOOST_CHECK(unlockPayload.getVersion() == 1);
+        BOOST_CHECK(unlockPayload.getRequestedHeight() == 1000'000);
+        BOOST_CHECK(unlockPayload.getFee() == 2000'000'000u);
+        BOOST_CHECK(unlockPayload.getIndex() == 0x001122334455667788L);
+
+        // Wrong type "Asset Lock TX" instead "Asset Unlock TX"
+        CMutableTransaction txWrongType = tx;
+        txWrongType.nType = TRANSACTION_ASSET_LOCK;
+        BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txWrongType), block_index, pool, tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-type");
+    }
+
+    {
+        BOOST_CHECK(tx.nVersion == 2);
+
+        // Version of payload is not `1`
+        CMutableTransaction txWrongVersion = tx;
+    }
+
+    {
+        // Exactly 32 withdrawal is fine
+        CMutableTransaction txManyOutputs = tx;
+        int outputsLimit = 32;
+        txManyOutputs.vout.resize(outputsLimit);
+        for (auto& out : txManyOutputs.vout) {
+            out.nValue = CENT;
+            out.scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+        }
+
+        BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txManyOutputs), block_index, pool, tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
+
+        // Should not be more than 32 withdrawal in one transaction
+        txManyOutputs.vout.resize(outputsLimit + 1);
+        txManyOutputs.vout.back().nValue = CENT;
+        txManyOutputs.vout.back().scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
+        BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txManyOutputs), block_index, pool, tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-too-many-outs");
+    }
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index d10689c3ee31e..d6096caf519a1 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -56,6 +56,7 @@
 #include <coinjoin/coinjoin.h>
 #include <coinjoin/server.h>
 #include <evo/cbtx.h>
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
@@ -139,6 +140,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     connman = std::make_unique<CConnman>(0x1337, 0x1337, *m_node.addrman);
     deterministicMNManager.reset(new CDeterministicMNManager(*m_node.evodb, *connman));
     llmq::quorumSnapshotManager.reset(new llmq::CQuorumSnapshotManager(*m_node.evodb));
+    creditPoolManager = std::make_unique<CCreditPoolManager>(*m_node.evodb);
     static bool noui_connected = false;
     if (!noui_connected) {
         noui_connect();
@@ -152,6 +154,7 @@ BasicTestingSetup::~BasicTestingSetup()
     connman.reset();
     llmq::quorumSnapshotManager.reset();
     deterministicMNManager.reset();
+    creditPoolManager.reset();
     m_node.evodb.reset();
 
     LogInstance().DisconnectTestLogger();
@@ -188,6 +191,7 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
 
     deterministicMNManager.reset(new CDeterministicMNManager(*m_node.evodb, *m_node.connman));
     m_node.llmq_ctx = std::make_unique<LLMQContext>(*m_node.evodb, *m_node.mempool, *m_node.connman, *sporkManager, m_node.peerman, true, false);
+    m_node.creditPoolManager = std::make_unique<CCreditPoolManager>(*m_node.evodb);
 
     // Start script-checking threads. Set g_parallel_script_checks to true so they are used.
     constexpr int script_check_threads = 2;
@@ -201,6 +205,7 @@ ChainTestingSetup::~ChainTestingSetup()
     deterministicMNManager.reset();
     m_node.llmq_ctx->Interrupt();
     m_node.llmq_ctx->Stop();
+    m_node.creditPoolManager.reset();
     StopScriptCheckWorkerThreads();
     GetMainSignals().FlushBackgroundCallbacks();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 1f09267774719..2e58aef800066 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -20,6 +20,7 @@
 #include <validationinterface.h>
 
 #include <evo/specialtx.h>
+#include <evo/assetlocktx.h>
 #include <evo/providertx.h>
 #include <evo/deterministicmns.h>
 #include <llmq/instantsend.h>
@@ -451,6 +452,11 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces
         if (dmn->pdmnState->pubKeyOperator.Get() != CBLSPublicKey()) {
             newit->isKeyChangeProTx = true;
         }
+    } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
+        CAssetUnlockPayload assetUnlockTx;
+        bool ok = GetTxPayload(tx, assetUnlockTx);
+        assert(ok);
+        mapAssetUnlockExpiry.insert({tx.GetHash(), assetUnlockTx.getHeightToExpiry()});
     }
 }
 
@@ -679,6 +685,8 @@ void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason)
             assert(false);
         }
         eraseProTxRef(proTx.proTxHash, it->GetTx().GetHash());
+    } else if (it->GetTx().nType == TRANSACTION_ASSET_UNLOCK) {
+        mapAssetUnlockExpiry.erase(it->GetTx().GetHash());
     }
 
     totalTxSize -= it->GetTxSize();
@@ -999,6 +1007,25 @@ void CTxMemPool::removeForBlock(const std::vector<CTransactionRef>& vtx, unsigne
     blockSinceLastRollingFeeBump = true;
 }
 
+/**
+  * Called when a lenght of chain is increased. Removes from mempool expired asset-unlock transactions
+  */
+void CTxMemPool::removeExpiredAssetUnlock(unsigned int nBlockHeight)
+{
+    AssertLockHeld(cs);
+    // items to removed should be firstly collected to independed list,
+    // because removing items by `removeRecursive` changes the mapAssetUnlockExpiry
+    std::vector<CTransactionRef> entries;
+    for (const auto& item: mapAssetUnlockExpiry) {
+        if (item.second < nBlockHeight) {
+            entries.push_back(get(item.first));
+        }
+    }
+    for (const auto& tx : entries) {
+        removeRecursive(*tx, MemPoolRemovalReason::EXPIRY);
+    }
+}
+
 void CTxMemPool::_clear()
 {
     mapLinks.clear();
diff --git a/src/txmempool.h b/src/txmempool.h
index 0d37a188cba78..cde068bdcf803 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -574,6 +574,7 @@ class CTxMemPool
     std::map<CKeyID, uint256> mapProTxPubKeyIDs;
     std::map<uint256, uint256> mapProTxBlsPubKeyHashes;
     std::map<COutPoint, uint256> mapProTxCollaterals;
+    std::map<uint256, int /* expiry height */> mapAssetUnlockExpiry; // tx hash -> height
 
     void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
@@ -634,6 +635,7 @@ class CTxMemPool
     void removeProTxKeyChangedConflicts(const CTransaction &tx, const uint256& proTxHash, const uint256& newKeyHash) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeProTxConflicts(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void removeExpiredAssetUnlock(unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     void clear();
     void _clear() EXCLUSIVE_LOCKS_REQUIRED(cs); //lock free
diff --git a/src/validation.cpp b/src/validation.cpp
index 5b28ff746c150..43a40008f689f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -50,6 +50,7 @@
 #include <masternode/payments.h>
 #include <masternode/sync.h>
 
+#include <evo/creditpool.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
@@ -384,7 +385,9 @@ static bool ContextualCheckTransaction(const CTransaction& tx, TxValidationState
                 tx.nType != TRANSACTION_PROVIDER_UPDATE_REVOKE &&
                 tx.nType != TRANSACTION_COINBASE &&
                 tx.nType != TRANSACTION_QUORUM_COMMITMENT &&
-                tx.nType != TRANSACTION_MNHF_SIGNAL) {
+                tx.nType != TRANSACTION_MNHF_SIGNAL &&
+                tx.nType != TRANSACTION_ASSET_LOCK &&
+                tx.nType != TRANSACTION_ASSET_UNLOCK) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-type");
             }
             if (tx.IsCoinBase() && tx.nType != TRANSACTION_COINBASE)
@@ -707,7 +710,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
             }
         }
     }
-
+    CCreditPool creditPool = creditPoolManager->getCreditPool(::ChainActive().Tip(), chainparams.GetConsensus());
     LockPoints lp;
     m_view.SetBackend(m_viewmempool);
 
@@ -822,7 +825,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     // DoS scoring a node for non-critical errors, e.g. duplicate keys because a TX is received that was already
     // mined
     // NOTE: we use UTXO here and do NOT allow mempool txes as masternode collaterals
-    if (!CheckSpecialTx(tx, m_active_chainstate.m_chain.Tip(), state, m_active_chainstate.CoinsTip(), true))
+    if (!CheckSpecialTx(tx, m_active_chainstate.m_chain.Tip(), m_active_chainstate.CoinsTip(), creditPool, true, state))
         return false;
 
     if (m_pool.existsProviderTxConflict(tx)) {
@@ -2257,7 +2260,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     bool fDIP0001Active_context = pindex->nHeight >= Params().GetConsensus().DIP0001Height;
 
     // MUST process special txes before updating UTXO to ensure consistency between mempool and block processing
-    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, state, view, fJustCheck, fScriptChecks)) {
+    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, chainparams.GetConsensus(), view, fJustCheck, fScriptChecks, state)) {
         return error("ConnectBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s",
                      pindex->GetBlockHash().ToString(), state.ToString());
     }
@@ -2961,6 +2964,7 @@ bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew
     // Remove conflicting transactions from the mempool.;
     if (m_mempool) {
         m_mempool->removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
+        m_mempool->removeExpiredAssetUnlock(pindexNew->nHeight);
         disconnectpool.removeForBlock(blockConnecting.vtx);
     }
     // Update m_chain & related variables.
@@ -4906,7 +4910,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
 
     // MUST process special txes before updating UTXO to ensure consistency between mempool and block processing
     BlockValidationState state;
-    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, state, inputs, false /*fJustCheck*/, false /*fScriptChecks*/)) {
+    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, params.GetConsensus(), inputs, false /*fJustCheck*/, false /*fScriptChecks*/, state)) {
         return error("RollforwardBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s",
             pindex->GetBlockHash().ToString(), state.ToString());
     }
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
new file mode 100755
index 0000000000000..e5785fb2c8fbc
--- /dev/null
+++ b/test/functional/feature_asset_locks.py
@@ -0,0 +1,505 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2022 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import hashlib
+import copy
+from decimal import Decimal
+from io import BytesIO
+
+from test_framework.blocktools import (
+    create_block,
+    create_coinbase,
+)
+from test_framework.authproxy import JSONRPCException
+from test_framework.key import ECKey
+from test_framework.messages import (
+    FromHex,
+    CAssetLockTx,
+    CAssetUnlockTx,
+    COutPoint,
+    CTxOut,
+    CTxIn,
+    COIN,
+    CTransaction,
+)
+from test_framework.script import (
+    hash160,
+    CScript,
+    OP_HASH160,
+    OP_RETURN,
+    OP_CHECKSIG,
+    OP_DUP,
+    OP_EQUALVERIFY,
+)
+from test_framework.test_framework import DashTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_greater_than_or_equal,
+    wait_until,
+)
+
+llmq_type_test = 100
+tiny_amount = int(Decimal("0.0007") * COIN)
+blocks_in_one_day = 576
+
+class AssetLocksTest(DashTestFramework):
+    def set_test_params(self):
+        self.set_dash_test_params(4, 3)
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def create_assetlock(self, amount, pubkey):
+        node = self.nodes[0]
+
+        coins = node.listunspent()
+        coin = None
+        while coin is None or COIN * coin['amount'] < amount:
+            coin = coins.pop()
+
+        inputs = [CTxIn(COutPoint(int(coin["txid"], 16), coin["vout"]))]
+
+        credit_outputs = CTxOut(amount, CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG]))
+
+        lockTx_payload = CAssetLockTx(1, 0, [credit_outputs])
+
+        remaining = int(COIN * coin['amount']) - tiny_amount - credit_outputs.nValue
+
+        tx_output_ret = CTxOut(credit_outputs.nValue, CScript([OP_RETURN, b""]))
+        tx_output = CTxOut(remaining, CScript([pubkey, OP_CHECKSIG]))
+
+        lock_tx = CTransaction()
+        lock_tx.vin = inputs
+        lock_tx.vout = [tx_output, tx_output_ret] if remaining > 0 else [tx_output_ret]
+        lock_tx.nVersion = 3
+        lock_tx.nType = 8 # asset lock type
+        lock_tx.vExtraPayload = lockTx_payload.serialize()
+
+        lock_tx = node.signrawtransactionwithwallet(lock_tx.serialize().hex())
+        return FromHex(CTransaction(), lock_tx["hex"])
+
+
+    def create_assetunlock(self, mninfo, index, withdrawal, pubkey=None):
+
+        def check_sigs(mninfo, id, msgHash):
+            for mn in mninfo:
+                if not mn.node.quorum("hasrecsig", llmq_type_test, id, msgHash):
+                    return False
+            return True
+
+        def wait_for_sigs(mninfo, id, msgHash, timeout):
+            wait_until(lambda: check_sigs(mninfo, id, msgHash), timeout = timeout)
+
+        node = self.nodes[0]
+        tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
+
+        # request ID = sha256("plwdtx", index)
+        sha256 = hashlib.sha256()
+        sha256.update(("plwdtx" + str(index)).encode())
+        id = sha256.digest()[::-1].hex()
+
+        height = node.getblockcount()
+        quorumHash = mninfo[0].node.quorum("selectquorum", llmq_type_test, id)["quorumHash"]
+        unlockTx_payload = CAssetUnlockTx(
+            version = 1,
+            index = index,
+            fee = tiny_amount,
+            requestedHeight = height,
+            quorumHash = int(quorumHash, 16),
+            quorumSig = b'\00' * 96)
+
+        unlock_tx = CTransaction()
+        unlock_tx.vin = []
+        unlock_tx.vout = [tx_output]
+        unlock_tx.nVersion = 3
+        unlock_tx.nType = 9 # asset unlock type
+        unlock_tx.vExtraPayload = unlockTx_payload.serialize()
+
+        unlock_tx.calc_sha256()
+        msgHash = format(unlock_tx.sha256, '064x')
+
+        for mn in mninfo:
+            mn.node.quorum("sign", llmq_type_test, id, msgHash, quorumHash)
+
+        wait_for_sigs(mninfo, id, msgHash, 5)
+
+        recsig = mninfo[0].node.quorum("getrecsig", llmq_type_test, id, msgHash)
+
+        unlockTx_payload.quorumSig = bytearray.fromhex(recsig["sig"])
+        unlock_tx.vExtraPayload = unlockTx_payload.serialize()
+        return unlock_tx
+
+    def get_credit_pool_amount(self, node=None, block_hash = None):
+        if node is None: node = self.nodes[0]
+
+        if block_hash is None:
+            block_hash = node.getbestblockhash()
+        block = node.getblock(block_hash)
+        return int(COIN * block['cbTx']['assetLockedAmount'])
+
+    def check_mempool_size(self):
+        assert_equal(self.nodes[0].getmempoolinfo()['size'], self.mempool_size)  # Must not change mempool state
+
+    def check_mempool_result(self, result_expected, tx):
+        """Wrapper to check result of testmempoolaccept on node_0's mempool"""
+        result_expected['txid'] = tx.rehash()
+
+        result_test = self.nodes[0].testmempoolaccept([tx.serialize().hex()])
+
+        assert_equal([result_expected], result_test)
+        self.check_mempool_size()
+
+    def create_and_check_block(self, txes, expected_error = None):
+        node = self.nodes[0]
+        best_block_hash = node.getbestblockhash()
+        best_block = node.getblock(best_block_hash)
+        tip = int(best_block_hash, 16)
+        height = best_block["height"] + 1
+        block_time = best_block["time"] + 1
+
+        cbb = create_coinbase(height, dip4_activated=True, v20_activated=True)
+        cbb.calc_sha256()
+        block = create_block(tip, cbb, block_time, version=3)
+        for tx in txes:
+            block.vtx.append(tx)
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.solve()
+        result = node.submitblock(block.serialize().hex())
+        if result != expected_error:
+            raise AssertionError('mining the block should have failed with error %s, but submitblock returned %s' % (expected_error, result))
+
+    def set_sporks(self):
+        spork_enabled = 0
+        spork_disabled = 4070908800
+
+        self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", spork_enabled)
+        self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", spork_disabled)
+        self.nodes[0].sporkupdate("SPORK_3_INSTANTSEND_BLOCK_FILTERING", spork_disabled)
+        self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", spork_disabled)
+        self.wait_for_sporks_same()
+
+    def ensure_tx_is_not_mined(self, tx_id):
+        try:
+            self.nodes[0].gettransaction(tx_id)
+            raise AssertionError("Transaction should not be mined")
+        except JSONRPCException as e:
+            assert "Invalid or non-wallet transaction id" in e.error['message']
+
+    def send_tx(self, tx, expected_error = None, reason = None):
+        try:
+            tx = self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
+            if expected_error is None:
+                return tx
+
+            # failure didn't happen, but expected:
+            message = "Transaction should not be accepted"
+            if reason is not None:
+                message += ": " + reason
+
+            raise AssertionError(message)
+        except JSONRPCException as e:
+            assert expected_error in e.error['message']
+
+    def slowly_generate_batch(self, amount):
+        while amount > 0:
+            self.log.info(f"Generating batch of blocks {amount} left")
+            next = min(10, amount)
+            amount -= next
+            self.bump_mocktime(next)
+            self.nodes[0].generate(next)
+            self.sync_all()
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        self.set_sporks()
+        self.activate_v20()
+
+        self.mempool_size = 0
+        assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
+
+        key = ECKey()
+        key.generate()
+        pubkey = key.get_pubkey().get_bytes()
+
+        self.log.info("Testing asset lock...")
+        locked_1 = 10 * COIN + 141421
+        locked_2 = 10 * COIN + 314159
+        asset_lock_tx = self.create_assetlock(locked_1, pubkey)
+
+        self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True})
+        assert_equal(self.get_credit_pool_amount(), 0)
+        txid_in_block = self.send_tx(asset_lock_tx)
+
+        self.sync_mempools()
+        assert_equal(self.get_credit_pool_amount(), 0)
+
+        node.generate(1)
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        # Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock
+        node.generate(12)
+        self.sync_all()
+
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        assert_equal(self.get_credit_pool_amount(node=self.nodes[1]), locked_1)
+
+        # tx is mined, let's get blockhash
+        self.log.info("Invalidate block with asset lock tx...")
+        block_hash_1 = node.gettransaction(txid_in_block)['blockhash']
+        for inode in self.nodes:
+            inode.invalidateblock(block_hash_1)
+            assert_equal(self.get_credit_pool_amount(node=inode), 0)
+        node.generate(3)
+        self.sync_all()
+        assert_equal(self.get_credit_pool_amount(), 0)
+        self.log.info("Resubmit asset lock tx to new chain...")
+        # NEW tx appears
+        asset_lock_tx_2 = self.create_assetlock(locked_2, pubkey)
+        txid_in_block = self.send_tx(asset_lock_tx_2)
+        node.generate(1)
+        self.sync_all()
+
+        assert_equal(self.get_credit_pool_amount(), locked_2)
+
+        node.generate(3)
+        self.sync_all()
+        assert_equal(self.get_credit_pool_amount(), locked_2)
+        self.log.info("Reconsider old blocks...")
+        for inode in self.nodes:
+            inode.reconsiderblock(block_hash_1)
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.sync_all()
+
+        self.log.info('Mine block with incorrect credit-poool value...')
+        extra_lock_tx = self.create_assetlock(COIN, pubkey)
+        self.create_and_check_block([extra_lock_tx], expected_error = 'bad-cbtx-assetlocked-amount')
+
+        self.log.info("Mine a quorum...")
+        self.mine_quorum()
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+
+        self.log.info("Testing asset unlock...")
+        # tx asset_unlock_tx_index_too_far should not be mined at first
+        asset_unlock_tx_index_too_far = self.create_assetunlock(self.mninfo, 10001, COIN, pubkey)
+        tx_too_far_index = self.send_tx(asset_unlock_tx_index_too_far)
+        node.generate(1)
+        self.sync_all()
+        self.mempool_size += 1
+        assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
+        self.ensure_tx_is_not_mined(tx_too_far_index)
+
+        # These txs should all have been generated by the same quorum
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        asset_unlock_tx = self.create_assetunlock(self.mninfo, 101, COIN, pubkey)
+        asset_unlock_tx_late = self.create_assetunlock(self.mninfo, 102, COIN, pubkey)
+        asset_unlock_tx_too_late = self.create_assetunlock(self.mninfo, 103, COIN, pubkey)
+        asset_unlock_tx_duplicate_index = copy.deepcopy(asset_unlock_tx)
+        asset_unlock_tx_duplicate_index.vout[0].nValue += COIN
+        too_late_height = node.getblock(node.getbestblockhash())["height"] + 48
+
+        self.check_mempool_result(tx=asset_unlock_tx, result_expected={'allowed': True})
+        self.check_mempool_result(tx=asset_unlock_tx_duplicate_index,
+                result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-verified'})
+
+        # validate that we calculate payload hash correctly: ask quorum forcely by message hash
+        asset_unlock_tx_payload = CAssetUnlockTx()
+        asset_unlock_tx_payload.deserialize(BytesIO(asset_unlock_tx.vExtraPayload))
+
+        assert_equal(asset_unlock_tx_payload.quorumHash, int(self.mninfo[0].node.quorum("selectquorum", llmq_type_test, 'e6c7a809d79f78ea85b72d5df7e9bd592aecf151e679d6e976b74f053a7f9056')["quorumHash"], 16))
+
+        self.send_tx(asset_unlock_tx)
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        # need to mine exactly 2 blocks to be sure that SkipSet lets far transaction appears in block
+        node.generate(1)
+        self.sync_all()
+        self.check_mempool_size()
+        node.generate(1)
+        self.sync_all()
+        self.mempool_size -= 1
+        self.check_mempool_size()
+        block_asset_unlock = node.getrawtransaction(asset_unlock_tx.rehash(), 1)['blockhash']
+
+        self.send_tx(asset_unlock_tx,
+            expected_error = "Transaction already in block chain",
+            reason = "double copy")
+
+        self.check_mempool_result(tx=asset_unlock_tx_duplicate_index,
+                result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-duplicated-index'})
+        self.send_tx(asset_unlock_tx_duplicate_index,
+            expected_error = "bad-assetunlock-duplicated-index",
+            reason = "double index")
+
+        # transaction with too far index should be mined too, because it is not too far anymore
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.nodes[0].getrawtransaction(tx_too_far_index, 1)['blockhash']
+
+        # mine next quorum, tx 'asset_unlock_tx_late' should be still accepted
+        self.mine_quorum()
+        # should stay same
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.check_mempool_result(tx=asset_unlock_tx_late, result_expected={'allowed': True})
+        # should still stay same
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.send_tx(asset_unlock_tx_late)
+        node.generate(1)
+        self.sync_all()
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
+
+        # generate many blocks to make quorum far behind (even still active)
+        self.slowly_generate_batch(too_late_height - node.getblock(node.getbestblockhash())["height"] - 1)
+        self.check_mempool_result(tx=asset_unlock_tx_too_late, result_expected={'allowed': True})
+        node.generate(1)
+        self.sync_all()
+        self.check_mempool_result(tx=asset_unlock_tx_too_late,
+                result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-too-late'})
+
+        # two quorums later is too late because quorum is not active, reason should not be same
+        self.mine_quorum()
+        self.check_mempool_result(tx=asset_unlock_tx_too_late,
+                result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-active-quorum'})
+
+        block_to_reconsider = node.getbestblockhash()
+        self.log.info("Test block invalidation with asset unlock tx...")
+        for inode in self.nodes:
+            inode.invalidateblock(block_asset_unlock)
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        # generate some new blocks
+        self.slowly_generate_batch(50)
+        assert_equal(self.get_credit_pool_amount(), locked_1)
+        for inode in self.nodes:
+            inode.reconsiderblock(block_to_reconsider)
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
+
+        # Forcibly mine asset_unlock_tx_too_late and ensure block is invalid
+        self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum")
+
+        node.generate(1)
+        self.sync_all()
+
+        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
+        assert_equal(self.get_credit_pool_amount(block_hash=block_hash_1), locked_1)
+
+        # too big withdrawal should not be mined
+        asset_unlock_tx_full = self.create_assetunlock(self.mninfo, 201, 1 + self.get_credit_pool_amount(), pubkey)
+
+        # Mempool doesn't know about the size of the credit pool, so the transaction will be accepted to mempool,
+        # but won't be mined
+        self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True })
+
+        txid_in_block = self.send_tx(asset_unlock_tx_full)
+        node.generate(1)
+        self.sync_all()
+
+        self.ensure_tx_is_not_mined(txid_in_block)
+
+        # Forcibly mine asset_unlock_tx_full and ensure block is invalid
+        self.create_and_check_block([asset_unlock_tx_full], expected_error = "failed-creditpool-unlock-too-much")
+
+        self.mempool_size += 1
+        asset_unlock_tx_full = self.create_assetunlock(self.mninfo, 301, self.get_credit_pool_amount(), pubkey)
+        self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True })
+
+        txid_in_block = self.send_tx(asset_unlock_tx_full)
+        node.generate(1)
+        self.sync_all()
+        # check txid_in_block was mined
+        block = node.getblock(node.getbestblockhash())
+        assert txid_in_block in block['tx']
+        assert_equal(self.get_credit_pool_amount(), 0)
+
+        # after many blocks duplicated tx still should not be mined
+        self.send_tx(asset_unlock_tx_duplicate_index,
+                expected_error = "bad-assetunlock-duplicated-index",
+                reason = "double index")
+
+        # Forcibly mine asset_unlock_tx_full and ensure block is invalid
+        self.create_and_check_block([asset_unlock_tx_duplicate_index], expected_error = "bad-assetunlock-duplicated-index")
+
+        self.log.info("Fast forward to the next day to reset all current unlock limits...")
+        self.slowly_generate_batch(blocks_in_one_day  + 1)
+        self.mine_quorum()
+
+        total = self.get_credit_pool_amount()
+        while total <= 10_900 * COIN:
+            coin = node.listunspent().pop()
+            to_lock = int(coin['amount'] * COIN) - tiny_amount
+            if to_lock > 50 * COIN:
+                to_lock = 50 * COIN
+            total += to_lock
+            tx = self.create_assetlock(to_lock, pubkey)
+            self.send_tx(tx)
+        node.generate(1)
+        self.sync_all()
+        credit_pool_amount_1 = self.get_credit_pool_amount()
+        assert_greater_than(credit_pool_amount_1, 10_900 * COIN)
+        limit_amount_1 = 1000 * COIN
+        # take most of limit by one big tx for faster testing and
+        # create several tiny withdrawal with exactly 1 *invalid* / causes spend above limit tx
+        withdrawals = [600 * COIN, 131 * COIN, 131 * COIN, 131 * COIN, 131 * COIN]
+        amount_to_withdraw_1 = sum(withdrawals)
+        index = 400
+        for next_amount in withdrawals:
+            index += 1
+            asset_unlock_tx = self.create_assetunlock(self.mninfo, index, next_amount, pubkey)
+            self.send_tx(asset_unlock_tx)
+            if index == 401:
+                node.generate(1)
+
+        node.generate(1)
+        self.sync_all()
+
+        new_total = self.get_credit_pool_amount()
+        amount_actually_withdrawn = total - new_total
+        block = node.getblock(node.getbestblockhash())
+        # Since we tried to withdraw more than we could
+        assert_greater_than(amount_to_withdraw_1, amount_actually_withdrawn)
+        # Check we tried to withdraw more than the limit
+        assert_greater_than(amount_to_withdraw_1, limit_amount_1)
+        # Check we didn't actually withdraw more than allowed by the limit
+        assert_greater_than_or_equal(limit_amount_1, amount_actually_withdrawn)
+        assert_equal(amount_actually_withdrawn, 993 * COIN)
+        node.generate(1)
+        self.sync_all()
+        # one tx should stay in mempool for awhile until is not invalidated by height
+        assert_equal(node.getmempoolinfo()['size'], 1)
+
+        assert_equal(new_total, self.get_credit_pool_amount())
+        self.log.info("Fast forward to next day again...")
+        self.slowly_generate_batch(blocks_in_one_day - 2)
+        # but should disappear later
+        assert_equal(node.getmempoolinfo()['size'], 0)
+
+        # new tx should be mined not this block, but next one
+        # size of this transaction should be more than
+        credit_pool_amount_2 = self.get_credit_pool_amount()
+        limit_amount_2 = credit_pool_amount_2 // 10
+        index += 1
+        asset_unlock_tx = self.create_assetunlock(self.mninfo, index, limit_amount_2, pubkey)
+        self.send_tx(asset_unlock_tx)
+        node.generate(1)
+        self.sync_all()
+        assert_equal(new_total, self.get_credit_pool_amount())
+        node.generate(1)
+        self.sync_all()
+        new_total -= limit_amount_2
+        assert_equal(new_total, self.get_credit_pool_amount())
+        # trying to withdraw more: should fail
+        index += 1
+        asset_unlock_tx = self.create_assetunlock(self.mninfo, index, COIN * 100, pubkey)
+        self.send_tx(asset_unlock_tx)
+        node.generate(1)
+        self.sync_all()
+
+        # all tx should be dropped from mempool because too far
+        # but amount in credit pool should be still same after many blocks
+        self.log.info("generate many blocks to be sure that mempool is empty afterwards...")
+        self.slowly_generate_batch(60)
+        assert_equal(new_total, self.get_credit_pool_amount())
+        assert_equal(node.getmempoolinfo()['size'], 0)
+
+if __name__ == '__main__':
+    AssetLocksTest().main()
diff --git a/test/functional/feature_nulldummy.py b/test/functional/feature_nulldummy.py
index 653a21f070710..e191008512893 100755
--- a/test/functional/feature_nulldummy.py
+++ b/test/functional/feature_nulldummy.py
@@ -17,7 +17,7 @@
 from test_framework.messages import CTransaction
 from test_framework.script import CScript
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.util import assert_equal, assert_raises_rpc_error, get_bip9_status
 
 
 NULLDUMMY_ERROR = "non-mandatory-script-verify-flag (Dummy CHECKMULTISIG argument must be zero)"
@@ -88,7 +88,8 @@ def run_test(self):
 
     def block_submit(self, node, txs, accept = False):
         dip4_activated = self.lastblockheight + 1 >= 432
-        block = create_block(self.tip, create_coinbase(self.lastblockheight + 1, dip4_activated=dip4_activated), self.lastblocktime + 1)
+        v20_activated = get_bip9_status(self.nodes[0], 'v20')['status'] == 'active'
+        block = create_block(self.tip, create_coinbase(self.lastblockheight + 1, dip4_activated=dip4_activated, v20_activated=v20_activated), self.lastblocktime + 1)
         block.nVersion = 4
         for tx in txs:
             tx.rehash()
diff --git a/test/functional/test_framework/blocktools.py b/test/functional/test_framework/blocktools.py
index e98b0a16a8684..e3252a9573960 100644
--- a/test/functional/test_framework/blocktools.py
+++ b/test/functional/test_framework/blocktools.py
@@ -48,7 +48,7 @@ def script_BIP34_coinbase_height(height):
     return CScript([CScriptNum(height)])
 
 
-def create_coinbase(height, pubkey=None, dip4_activated=False):
+def create_coinbase(height, pubkey=None, dip4_activated=False, v20_activated=False):
     """Create a coinbase transaction, assuming no miner fees.
 
     If pubkey is passed in, the coinbase output will be a P2PK output;
@@ -67,7 +67,8 @@ def create_coinbase(height, pubkey=None, dip4_activated=False):
     if dip4_activated:
         coinbase.nVersion = 3
         coinbase.nType = 5
-        cbtx_payload = CCbTx(2, height, 0, 0)
+        cbtx_version = 3 if v20_activated else 2
+        cbtx_payload = CCbTx(cbtx_version, height, 0, 0, 0)
         coinbase.vExtraPayload = cbtx_payload.serialize()
     coinbase.calc_sha256()
     return coinbase
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 4f21d1a64ba52..60d83e588f3a7 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1046,9 +1046,9 @@ def __repr__(self):
 
 
 class CCbTx:
-    __slots__ = ("version", "height", "merkleRootMNList", "merkleRootQuorums", "bestCLHeightDiff", "bestCLSignature")
+    __slots__ = ("version", "height", "merkleRootMNList", "merkleRootQuorums", "bestCLHeightDiff", "bestCLSignature", "lockedAmount")
 
-    def __init__(self, version=None, height=None, merkleRootMNList=None, merkleRootQuorums=None, bestCLHeightDiff=None, bestCLSignature=None):
+    def __init__(self, version=None, height=None, merkleRootMNList=None, merkleRootQuorums=None, bestCLHeightDiff=None, bestCLSignature=None, lockedAmount=None):
         self.set_null()
         if version is not None:
             self.version = version
@@ -1062,6 +1062,8 @@ def __init__(self, version=None, height=None, merkleRootMNList=None, merkleRootQ
             self.bestCLHeightDiff = bestCLHeightDiff
         if bestCLSignature is not None:
             self.bestCLSignature = bestCLSignature
+        if lockedAmount is not None:
+            self.lockedAmount = lockedAmount
 
     def set_null(self):
         self.version = 0
@@ -1069,6 +1071,7 @@ def set_null(self):
         self.merkleRootMNList = None
         self.bestCLHeightDiff = 0
         self.bestCLSignature = b'\x00' * 96
+        self.lockedAmount = 0
 
     def deserialize(self, f):
         self.version = struct.unpack("<H", f.read(2))[0]
@@ -1079,6 +1082,7 @@ def deserialize(self, f):
             if self.version >= 3:
                 self.bestCLHeightDiff = deser_compact_size(f)
                 self.bestCLSignature = f.read(96)
+                self.lockedAmount = struct.unpack("<q", f.read(8))[0]
 
 
     def serialize(self):
@@ -1091,9 +1095,92 @@ def serialize(self):
             if self.version >= 3:
                 r += ser_compact_size(self.bestCLHeightDiff)
                 r += self.bestCLSignature
+                r += struct.pack("<q", self.lockedAmount)
         return r
 
 
+class CAssetLockTx:
+    __slots__ = ("version", "nType", "creditOutputs")
+
+    def __init__(self, version=None, nType=None, creditOutputs=None):
+        self.set_null()
+        if version is not None:
+            self.version = version
+        if nType is not None:
+            self.nType = nType
+        self.creditOutputs = creditOutputs if creditOutputs is not None else []
+
+    def set_null(self):
+        self.version = 0
+        self.nType = 0
+        self.creditOutputs = None
+
+    def deserialize(self, f):
+        self.version = struct.unpack("<H", f.read(2))[0]
+        self.nType = struct.unpack("<H", f.read(2))[0]
+        self.creditOutputs = deser_vector(f, CTxOut)
+
+    def serialize(self):
+        r = b""
+        r += struct.pack("<H", self.version)
+        r += struct.pack("<H", self.nType)
+        r += ser_vector(self.creditOutputs)
+        return r
+
+    def __repr__(self):
+        return "CAssetLockTx(version={} nType={} creditOutputs={}" \
+            .format(self.version, self.nType, repr(self.creditOutputs))
+
+
+class CAssetUnlockTx:
+    __slots__ = ("version", "index", "fee", "requestedHeight", "quorumHash", "quorumSig")
+
+    def __init__(self, version=None, index=None, fee=None, requestedHeight=None, quorumHash = 0, quorumSig = None):
+        self.set_null()
+        if version is not None:
+            self.version = version
+        if index is not None:
+            self.index = index
+        if fee is not None:
+            self.fee = fee
+        if requestedHeight is not None:
+            self.requestedHeight = requestedHeight
+        if quorumHash is not None:
+            self.quorumHash = quorumHash
+        if quorumSig is not None:
+            self.quorumSig = quorumSig
+
+    def set_null(self):
+        self.version = 0
+        self.index = 0
+        self.fee = None
+        self.requestedHeight = 0
+        self.quorumHash = 0
+        self.quorumSig = b'\x00' * 96
+
+    def deserialize(self, f):
+        self.version = struct.unpack("<H", f.read(2))[0]
+        self.index = struct.unpack("<Q", f.read(8))[0]
+        self.fee = struct.unpack("<I", f.read(4))[0]
+        self.requestedHeight = struct.unpack("<I", f.read(4))[0]
+        self.quorumHash = deser_uint256(f)
+        self.quorumSig = f.read(96)
+
+    def serialize(self):
+        r = b""
+        r += struct.pack("<H", self.version)
+        r += struct.pack("<Q", self.index)
+        r += struct.pack("<I", self.fee)
+        r += struct.pack("<I", self.requestedHeight)
+        r += ser_uint256(self.quorumHash)
+        r += self.quorumSig
+        return r
+
+    def __repr__(self):
+        return "CAssetUnlockTx(version={} index={} fee={} requestedHeight={} quorumHash={:x} quorumSig={}" \
+            .format(self.version, self.index, self.fee, self.requestedHeight, self.quorumHash, self.quorumSig.hex())
+
+
 class CSimplifiedMNListEntry:
     __slots__ = ("proRegTxHash", "confirmedHash", "service", "pubKeyOperator", "keyIDVoting", "isValid", "nVersion", "type", "platformHTTPPort", "platformNodeID")
 
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 11fbfcb4032da..3b4a086e92247 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -120,6 +120,7 @@
     'feature_llmq_is_retroactive.py', # NOTE: needs dash_hash to pass
     'feature_llmq_dkgerrors.py', # NOTE: needs dash_hash to pass
     'feature_dip4_coinbasemerkleroots.py', # NOTE: needs dash_hash to pass
+    'feature_asset_locks.py', # NOTE: needs dash_hash to pass
     # vv Tests less than 60s vv
     'p2p_sendheaders.py', # NOTE: needs dash_hash to pass
     'p2p_sendheaders_compressed.py', # NOTE: needs dash_hash to pass
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 0db633c60a5a4..de882d3f98aed 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -71,6 +71,11 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "evo/deterministicmns -> llmq/utils -> net -> evo/deterministicmns"
     "policy/policy -> policy/settings -> policy/policy"
     "evo/specialtxman -> validation -> evo/specialtxman"
+    "evo/creditpool -> validation -> evo/creditpool"
+    "consensus/tx_verify -> evo/assetlocktx -> validation -> consensus/tx_verify"
+    "consensus/tx_verify -> evo/assetlocktx -> llmq/quorums -> net_processing -> txmempool -> consensus/tx_verify"
+    "evo/assetlocktx -> evo/creditpool -> evo/assetlocktx"
+    "evo/assetlocktx -> llmq/quorums -> net_processing -> txmempool -> evo/assetlocktx"
 
     "evo/simplifiedmns -> llmq/blockprocessor -> net_processing -> llmq/snapshot -> evo/simplifiedmns"
     "llmq/blockprocessor -> net_processing -> llmq/context -> llmq/blockprocessor"

From ae631b5a9f25c41d5a4aa5f639577236485d27dc Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 29 Nov 2022 16:24:39 +0700
Subject: [PATCH 02/37] feat: add unittests for SkipSet structure

---
 src/test/evo_assetlocks_tests.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index 6b13bb33b0417..56dc9ae5ab1b4 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/util/setup_common.h>
 
 #include <evo/assetlocktx.h>
+#include <evo/creditpool.h> // to test CSkipSet
 #include <policy/settings.h>
 #include <script/signingprovider.h>
 #include <consensus/tx_check.h>
@@ -14,6 +15,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <random>
+#include <unordered_set>
 
 //
 // Helper: create two dummy transactions, each with
@@ -357,4 +360,30 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 
 }
 
+BOOST_FIXTURE_TEST_CASE(evo_skipset, TestChain100Setup)
+{
+    std::mt19937 gen;
+    for (size_t test = 0; test < 17; ++test) {
+        std::uniform_int_distribution<uint64_t> dist_value(0, (1 << test));
+        size_t skip_size = test ? (1 << (test - 1)) : 1;
+        CSkipSet set_1{skip_size};
+        std::unordered_set<uint64_t> set_2;
+        for (size_t iter = 0; iter < (1 << test) * 2; ++iter) {
+            uint64_t value = dist_value(gen);
+            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
+            if (!set_1.contains(value) && set_1.canBeAdded(value)) {
+                BOOST_CHECK(!set_1.contains(value));
+                BOOST_CHECK(set_1.add(value));
+                set_2.insert(value);
+            }
+            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
+            BOOST_CHECK(set_1.size() == set_2.size());
+        }
+        if (test > 4) {
+            BOOST_CHECK(set_1.size() > ((1 << test) / 4));
+        }
+    }
+}
+
+
 BOOST_AUTO_TEST_SUITE_END()

From a16fe167ff306bcb0420a70a20da21336ed1f115 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 10 May 2023 02:33:24 +0700
Subject: [PATCH 03/37] cleanup mninfo

---
 test/functional/feature_asset_locks.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index e5785fb2c8fbc..3b544b17f27b5 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -83,7 +83,7 @@ def create_assetlock(self, amount, pubkey):
         return FromHex(CTransaction(), lock_tx["hex"])
 
 
-    def create_assetunlock(self, mninfo, index, withdrawal, pubkey=None):
+    def create_assetunlock(self, index, withdrawal, pubkey=None):
 
         def check_sigs(mninfo, id, msgHash):
             for mn in mninfo:
@@ -95,6 +95,7 @@ def wait_for_sigs(mninfo, id, msgHash, timeout):
             wait_until(lambda: check_sigs(mninfo, id, msgHash), timeout = timeout)
 
         node = self.nodes[0]
+        mninfo = self.mninfo
         tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
 
         # request ID = sha256("plwdtx", index)
@@ -284,7 +285,7 @@ def run_test(self):
 
         self.log.info("Testing asset unlock...")
         # tx asset_unlock_tx_index_too_far should not be mined at first
-        asset_unlock_tx_index_too_far = self.create_assetunlock(self.mninfo, 10001, COIN, pubkey)
+        asset_unlock_tx_index_too_far = self.create_assetunlock(10001, COIN, pubkey)
         tx_too_far_index = self.send_tx(asset_unlock_tx_index_too_far)
         node.generate(1)
         self.sync_all()
@@ -294,9 +295,9 @@ def run_test(self):
 
         # These txs should all have been generated by the same quorum
         assert_equal(self.get_credit_pool_amount(), locked_1)
-        asset_unlock_tx = self.create_assetunlock(self.mninfo, 101, COIN, pubkey)
-        asset_unlock_tx_late = self.create_assetunlock(self.mninfo, 102, COIN, pubkey)
-        asset_unlock_tx_too_late = self.create_assetunlock(self.mninfo, 103, COIN, pubkey)
+        asset_unlock_tx = self.create_assetunlock(101, COIN, pubkey)
+        asset_unlock_tx_late = self.create_assetunlock(102, COIN, pubkey)
+        asset_unlock_tx_too_late = self.create_assetunlock(103, COIN, pubkey)
         asset_unlock_tx_duplicate_index = copy.deepcopy(asset_unlock_tx)
         asset_unlock_tx_duplicate_index.vout[0].nValue += COIN
         too_late_height = node.getblock(node.getbestblockhash())["height"] + 48
@@ -384,7 +385,7 @@ def run_test(self):
         assert_equal(self.get_credit_pool_amount(block_hash=block_hash_1), locked_1)
 
         # too big withdrawal should not be mined
-        asset_unlock_tx_full = self.create_assetunlock(self.mninfo, 201, 1 + self.get_credit_pool_amount(), pubkey)
+        asset_unlock_tx_full = self.create_assetunlock(201, 1 + self.get_credit_pool_amount(), pubkey)
 
         # Mempool doesn't know about the size of the credit pool, so the transaction will be accepted to mempool,
         # but won't be mined
@@ -400,7 +401,7 @@ def run_test(self):
         self.create_and_check_block([asset_unlock_tx_full], expected_error = "failed-creditpool-unlock-too-much")
 
         self.mempool_size += 1
-        asset_unlock_tx_full = self.create_assetunlock(self.mninfo, 301, self.get_credit_pool_amount(), pubkey)
+        asset_unlock_tx_full = self.create_assetunlock(301, self.get_credit_pool_amount(), pubkey)
         self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True })
 
         txid_in_block = self.send_tx(asset_unlock_tx_full)
@@ -444,7 +445,7 @@ def run_test(self):
         index = 400
         for next_amount in withdrawals:
             index += 1
-            asset_unlock_tx = self.create_assetunlock(self.mninfo, index, next_amount, pubkey)
+            asset_unlock_tx = self.create_assetunlock(index, next_amount, pubkey)
             self.send_tx(asset_unlock_tx)
             if index == 401:
                 node.generate(1)
@@ -478,7 +479,7 @@ def run_test(self):
         credit_pool_amount_2 = self.get_credit_pool_amount()
         limit_amount_2 = credit_pool_amount_2 // 10
         index += 1
-        asset_unlock_tx = self.create_assetunlock(self.mninfo, index, limit_amount_2, pubkey)
+        asset_unlock_tx = self.create_assetunlock(index, limit_amount_2, pubkey)
         self.send_tx(asset_unlock_tx)
         node.generate(1)
         self.sync_all()
@@ -489,7 +490,7 @@ def run_test(self):
         assert_equal(new_total, self.get_credit_pool_amount())
         # trying to withdraw more: should fail
         index += 1
-        asset_unlock_tx = self.create_assetunlock(self.mninfo, index, COIN * 100, pubkey)
+        asset_unlock_tx = self.create_assetunlock(index, COIN * 100, pubkey)
         self.send_tx(asset_unlock_tx)
         node.generate(1)
         self.sync_all()

From c763d97c9e23420f7255ba7dfdd881ba911f8c2a Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 11 May 2023 17:59:57 +0700
Subject: [PATCH 04/37] fixups for coin

---
 test/functional/feature_asset_locks.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 3b544b17f27b5..efd57ab8e2291 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -53,13 +53,9 @@ def set_test_params(self):
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def create_assetlock(self, amount, pubkey):
+    def create_assetlock(self, coin, amount, pubkey):
         node = self.nodes[0]
 
-        coins = node.listunspent()
-        coin = None
-        while coin is None or COIN * coin['amount'] < amount:
-            coin = coins.pop()
 
         inputs = [CTxIn(COutPoint(int(coin["txid"], 16), coin["vout"]))]
 
@@ -164,7 +160,7 @@ def create_and_check_block(self, txes, expected_error = None):
 
         cbb = create_coinbase(height, dip4_activated=True, v20_activated=True)
         cbb.calc_sha256()
-        block = create_block(tip, cbb, block_time, version=3)
+        block = create_block(tip, cbb, block_time, version=4)
         for tx in txes:
             block.vtx.append(tx)
         block.hashMerkleRoot = block.calc_merkle_root()
@@ -230,7 +226,12 @@ def run_test(self):
         self.log.info("Testing asset lock...")
         locked_1 = 10 * COIN + 141421
         locked_2 = 10 * COIN + 314159
-        asset_lock_tx = self.create_assetlock(locked_1, pubkey)
+
+        coins = node.listunspent()
+        coin = None
+        while coin is None or COIN * coin['amount'] < locked_2:
+            coin = coins.pop()
+        asset_lock_tx = self.create_assetlock(coin, locked_1, pubkey)
 
         self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True})
         assert_equal(self.get_credit_pool_amount(), 0)
@@ -259,7 +260,7 @@ def run_test(self):
         assert_equal(self.get_credit_pool_amount(), 0)
         self.log.info("Resubmit asset lock tx to new chain...")
         # NEW tx appears
-        asset_lock_tx_2 = self.create_assetlock(locked_2, pubkey)
+        asset_lock_tx_2 = self.create_assetlock(coin, locked_2, pubkey)
         txid_in_block = self.send_tx(asset_lock_tx_2)
         node.generate(1)
         self.sync_all()
@@ -276,7 +277,7 @@ def run_test(self):
         self.sync_all()
 
         self.log.info('Mine block with incorrect credit-poool value...')
-        extra_lock_tx = self.create_assetlock(COIN, pubkey)
+        extra_lock_tx = self.create_assetlock(coin, COIN, pubkey)
         self.create_and_check_block([extra_lock_tx], expected_error = 'bad-cbtx-assetlocked-amount')
 
         self.log.info("Mine a quorum...")
@@ -431,7 +432,7 @@ def run_test(self):
             if to_lock > 50 * COIN:
                 to_lock = 50 * COIN
             total += to_lock
-            tx = self.create_assetlock(to_lock, pubkey)
+            tx = self.create_assetlock(coin, to_lock, pubkey)
             self.send_tx(tx)
         node.generate(1)
         self.sync_all()

From 2db5c05244b57cd64aad847d2ff4fed451ae006d Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 11 May 2023 18:16:33 +0700
Subject: [PATCH 05/37] refactor: clean up duplicated code - using
 get_recovered_sigs from framework

---
 test/functional/feature_asset_locks.py | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index efd57ab8e2291..3dfd8d57dfa8d 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -39,7 +39,6 @@
     assert_equal,
     assert_greater_than,
     assert_greater_than_or_equal,
-    wait_until,
 )
 
 llmq_type_test = 100
@@ -80,16 +79,6 @@ def create_assetlock(self, coin, amount, pubkey):
 
 
     def create_assetunlock(self, index, withdrawal, pubkey=None):
-
-        def check_sigs(mninfo, id, msgHash):
-            for mn in mninfo:
-                if not mn.node.quorum("hasrecsig", llmq_type_test, id, msgHash):
-                    return False
-            return True
-
-        def wait_for_sigs(mninfo, id, msgHash, timeout):
-            wait_until(lambda: check_sigs(mninfo, id, msgHash), timeout = timeout)
-
         node = self.nodes[0]
         mninfo = self.mninfo
         tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
@@ -119,12 +108,7 @@ def wait_for_sigs(mninfo, id, msgHash, timeout):
         unlock_tx.calc_sha256()
         msgHash = format(unlock_tx.sha256, '064x')
 
-        for mn in mninfo:
-            mn.node.quorum("sign", llmq_type_test, id, msgHash, quorumHash)
-
-        wait_for_sigs(mninfo, id, msgHash, 5)
-
-        recsig = mninfo[0].node.quorum("getrecsig", llmq_type_test, id, msgHash)
+        recsig = self.get_recovered_sig(id, msgHash, llmq_type=llmq_type_test)
 
         unlockTx_payload.quorumSig = bytearray.fromhex(recsig["sig"])
         unlock_tx.vExtraPayload = unlockTx_payload.serialize()

From 3ffdcdd134e6253fd2b95d911bad1eab418a14b2 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 25 Apr 2023 15:13:58 +0700
Subject: [PATCH 06/37] fixup after assetlocks

---
 src/evo/specialtxman.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index 89d74c7d2e9d8..5f4151662bc9d 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -20,7 +20,7 @@ class CQuorumBlockProcessor;
 class CChainLocksHandler;
 } // namespace llmq
 namespace Consensus {
-class Params;
+struct Params;
 } // namespace Consensus
 
 extern RecursiveMutex cs_main;

From d07abef588ef5d17b2bb0bdf1121e481586e718d Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 11 May 2023 18:36:35 +0700
Subject: [PATCH 07/37] using check_mempool_size() instead direct call of RPC

---
 test/functional/feature_asset_locks.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 3dfd8d57dfa8d..63b83d8efd780 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -201,7 +201,6 @@ def run_test(self):
         self.activate_v20()
 
         self.mempool_size = 0
-        assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
 
         key = ECKey()
         key.generate()
@@ -275,7 +274,7 @@ def run_test(self):
         node.generate(1)
         self.sync_all()
         self.mempool_size += 1
-        assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
+        self.check_mempool_size()
         self.ensure_tx_is_not_mined(tx_too_far_index)
 
         # These txs should all have been generated by the same quorum
@@ -451,13 +450,15 @@ def run_test(self):
         node.generate(1)
         self.sync_all()
         # one tx should stay in mempool for awhile until is not invalidated by height
-        assert_equal(node.getmempoolinfo()['size'], 1)
+        self.mempool_size = 1
+        self.check_mempool_size()
 
         assert_equal(new_total, self.get_credit_pool_amount())
         self.log.info("Fast forward to next day again...")
         self.slowly_generate_batch(blocks_in_one_day - 2)
         # but should disappear later
-        assert_equal(node.getmempoolinfo()['size'], 0)
+        self.mempool_size = 0
+        self.check_mempool_size()
 
         # new tx should be mined not this block, but next one
         # size of this transaction should be more than
@@ -485,7 +486,7 @@ def run_test(self):
         self.log.info("generate many blocks to be sure that mempool is empty afterwards...")
         self.slowly_generate_batch(60)
         assert_equal(new_total, self.get_credit_pool_amount())
-        assert_equal(node.getmempoolinfo()['size'], 0)
+        self.check_mempool_size()
 
 if __name__ == '__main__':
     AssetLocksTest().main()

From 4fa8f1c214184506e8f62a6f665a9f009c94f668 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 11 May 2023 19:19:05 +0700
Subject: [PATCH 08/37] fixup codestyle

---
 test/functional/feature_asset_locks.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 63b83d8efd780..a333bc4b0e427 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -115,7 +115,8 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         return unlock_tx
 
     def get_credit_pool_amount(self, node=None, block_hash = None):
-        if node is None: node = self.nodes[0]
+        if node is None:
+            node = self.nodes[0]
 
         if block_hash is None:
             block_hash = node.getbestblockhash()

From fc8e7d28783ae21e6c7247fcbf6ea1ba6b23a16b Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 11 May 2023 19:31:39 +0700
Subject: [PATCH 09/37] fixup feature_nulldummy

---
 test/functional/feature_nulldummy.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/functional/feature_nulldummy.py b/test/functional/feature_nulldummy.py
index e191008512893..653a21f070710 100755
--- a/test/functional/feature_nulldummy.py
+++ b/test/functional/feature_nulldummy.py
@@ -17,7 +17,7 @@
 from test_framework.messages import CTransaction
 from test_framework.script import CScript
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, get_bip9_status
+from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 NULLDUMMY_ERROR = "non-mandatory-script-verify-flag (Dummy CHECKMULTISIG argument must be zero)"
@@ -88,8 +88,7 @@ def run_test(self):
 
     def block_submit(self, node, txs, accept = False):
         dip4_activated = self.lastblockheight + 1 >= 432
-        v20_activated = get_bip9_status(self.nodes[0], 'v20')['status'] == 'active'
-        block = create_block(self.tip, create_coinbase(self.lastblockheight + 1, dip4_activated=dip4_activated, v20_activated=v20_activated), self.lastblocktime + 1)
+        block = create_block(self.tip, create_coinbase(self.lastblockheight + 1, dip4_activated=dip4_activated), self.lastblocktime + 1)
         block.nVersion = 4
         for tx in txs:
             tx.rehash()

From a1a0ce18df3b17866c45deb5589f9b329c6f1aeb Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 16 May 2023 18:45:22 +0700
Subject: [PATCH 10/37] feat: instead comments in functional test use logs for
 more clear progress tracking

---
 test/functional/feature_asset_locks.py | 65 +++++++++++++-------------
 1 file changed, 33 insertions(+), 32 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index a333bc4b0e427..8a39a89cf5069 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -173,9 +173,10 @@ def ensure_tx_is_not_mined(self, tx_id):
 
     def send_tx(self, tx, expected_error = None, reason = None):
         try:
-            tx = self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
+            self.log.info(f"Send tx with expected_error:'{expected_error}'...")
+            tx_res = self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
             if expected_error is None:
-                return tx
+                return tx_res
 
             # failure didn't happen, but expected:
             message = "Transaction should not be accepted"
@@ -187,6 +188,7 @@ def send_tx(self, tx, expected_error = None, reason = None):
             assert expected_error in e.error['message']
 
     def slowly_generate_batch(self, amount):
+        self.log.info(f"Slowly generate {amount} blocks")
         while amount > 0:
             self.log.info(f"Generating batch of blocks {amount} left")
             next = min(10, amount)
@@ -226,7 +228,7 @@ def run_test(self):
 
         node.generate(1)
         assert_equal(self.get_credit_pool_amount(), locked_1)
-        # Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock
+        self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock")
         node.generate(12)
         self.sync_all()
 
@@ -269,16 +271,16 @@ def run_test(self):
         assert_equal(self.get_credit_pool_amount(), locked_1)
 
         self.log.info("Testing asset unlock...")
-        # tx asset_unlock_tx_index_too_far should not be mined at first
         asset_unlock_tx_index_too_far = self.create_assetunlock(10001, COIN, pubkey)
         tx_too_far_index = self.send_tx(asset_unlock_tx_index_too_far)
         node.generate(1)
         self.sync_all()
         self.mempool_size += 1
         self.check_mempool_size()
+        self.log.info("Checking that `asset_unlock_tx_index_too_far` not mined yet...")
         self.ensure_tx_is_not_mined(tx_too_far_index)
 
-        # These txs should all have been generated by the same quorum
+        self.log.info("Generating several txes by same quorum....")
         assert_equal(self.get_credit_pool_amount(), locked_1)
         asset_unlock_tx = self.create_assetunlock(101, COIN, pubkey)
         asset_unlock_tx_late = self.create_assetunlock(102, COIN, pubkey)
@@ -291,7 +293,7 @@ def run_test(self):
         self.check_mempool_result(tx=asset_unlock_tx_duplicate_index,
                 result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-verified'})
 
-        # validate that we calculate payload hash correctly: ask quorum forcely by message hash
+        self.log.info("Validating that we calculate payload hash correctly: ask quorum forcely by message hash...")
         asset_unlock_tx_payload = CAssetUnlockTx()
         asset_unlock_tx_payload.deserialize(BytesIO(asset_unlock_tx.vExtraPayload))
 
@@ -299,7 +301,7 @@ def run_test(self):
 
         self.send_tx(asset_unlock_tx)
         assert_equal(self.get_credit_pool_amount(), locked_1)
-        # need to mine exactly 2 blocks to be sure that SkipSet lets far transaction appears in block
+        self.log.info("Mining exactly 2 blocks to be sure that SkipSet lets far transaction appears in block")
         node.generate(1)
         self.sync_all()
         self.check_mempool_size()
@@ -319,23 +321,23 @@ def run_test(self):
             expected_error = "bad-assetunlock-duplicated-index",
             reason = "double index")
 
-        # transaction with too far index should be mined too, because it is not too far anymore
+        self.log.info("Checking tx with too far index is mined too - it is not too far anymore...")
         assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
         self.nodes[0].getrawtransaction(tx_too_far_index, 1)['blockhash']
 
-        # mine next quorum, tx 'asset_unlock_tx_late' should be still accepted
+        self.log.info("Mining next quorum to check tx 'asset_unlock_tx_late' is still valid...")
         self.mine_quorum()
-        # should stay same
+        self.log.info("Checking credit pool amount is same...")
         assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
         self.check_mempool_result(tx=asset_unlock_tx_late, result_expected={'allowed': True})
-        # should still stay same
+        self.log.info("Checking credit pool amount still is same...")
         assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
         self.send_tx(asset_unlock_tx_late)
         node.generate(1)
         self.sync_all()
         assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
 
-        # generate many blocks to make quorum far behind (even still active)
+        self.log.info("Generating many blocks to make quorum far behind (even still active)...")
         self.slowly_generate_batch(too_late_height - node.getblock(node.getbestblockhash())["height"] - 1)
         self.check_mempool_result(tx=asset_unlock_tx_too_late, result_expected={'allowed': True})
         node.generate(1)
@@ -343,8 +345,9 @@ def run_test(self):
         self.check_mempool_result(tx=asset_unlock_tx_too_late,
                 result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-too-late'})
 
-        # two quorums later is too late because quorum is not active, reason should not be same
+        self.log.info("Checking that two quorums later it is too late because quorum is not active...")
         self.mine_quorum()
+        self.log.info("Expecting new reject-reason...")
         self.check_mempool_result(tx=asset_unlock_tx_too_late,
                 result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-active-quorum'})
 
@@ -353,14 +356,13 @@ def run_test(self):
         for inode in self.nodes:
             inode.invalidateblock(block_asset_unlock)
         assert_equal(self.get_credit_pool_amount(), locked_1)
-        # generate some new blocks
         self.slowly_generate_batch(50)
         assert_equal(self.get_credit_pool_amount(), locked_1)
         for inode in self.nodes:
             inode.reconsiderblock(block_to_reconsider)
         assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
 
-        # Forcibly mine asset_unlock_tx_too_late and ensure block is invalid
+        self.log.info("Forcibly mining asset_unlock_tx_too_late and ensure block is invalid...")
         self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum")
 
         node.generate(1)
@@ -369,11 +371,11 @@ def run_test(self):
         assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
         assert_equal(self.get_credit_pool_amount(block_hash=block_hash_1), locked_1)
 
-        # too big withdrawal should not be mined
+        self.log.info("Checking too big withdrawal... expected to not be mined")
         asset_unlock_tx_full = self.create_assetunlock(201, 1 + self.get_credit_pool_amount(), pubkey)
 
-        # Mempool doesn't know about the size of the credit pool, so the transaction will be accepted to mempool,
-        # but won't be mined
+        self.log.info("Checking that transaction with exceeding amount accepted by mempool...")
+        # Mempool doesn't know about the size of the credit pool
         self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True })
 
         txid_in_block = self.send_tx(asset_unlock_tx_full)
@@ -382,7 +384,7 @@ def run_test(self):
 
         self.ensure_tx_is_not_mined(txid_in_block)
 
-        # Forcibly mine asset_unlock_tx_full and ensure block is invalid
+        self.log.info("Forcibly mine asset_unlock_tx_full and ensure block is invalid...")
         self.create_and_check_block([asset_unlock_tx_full], expected_error = "failed-creditpool-unlock-too-much")
 
         self.mempool_size += 1
@@ -392,17 +394,17 @@ def run_test(self):
         txid_in_block = self.send_tx(asset_unlock_tx_full)
         node.generate(1)
         self.sync_all()
-        # check txid_in_block was mined
+        self.log.info("Check txid_in_block was mined...")
         block = node.getblock(node.getbestblockhash())
         assert txid_in_block in block['tx']
         assert_equal(self.get_credit_pool_amount(), 0)
 
-        # after many blocks duplicated tx still should not be mined
+        self.log.info("After many blocks duplicated tx still should not be mined")
         self.send_tx(asset_unlock_tx_duplicate_index,
                 expected_error = "bad-assetunlock-duplicated-index",
                 reason = "double index")
 
-        # Forcibly mine asset_unlock_tx_full and ensure block is invalid
+        self.log.info("Forcibly mine asset_unlock_tx_full and ensure block is invalid...")
         self.create_and_check_block([asset_unlock_tx_duplicate_index], expected_error = "bad-assetunlock-duplicated-index")
 
         self.log.info("Fast forward to the next day to reset all current unlock limits...")
@@ -411,6 +413,7 @@ def run_test(self):
 
         total = self.get_credit_pool_amount()
         while total <= 10_900 * COIN:
+            self.log.info(f"Collecting coins in pool... Collected {total}/{10_900 * COIN}")
             coin = node.listunspent().pop()
             to_lock = int(coin['amount'] * COIN) - tiny_amount
             if to_lock > 50 * COIN:
@@ -441,28 +444,27 @@ def run_test(self):
         new_total = self.get_credit_pool_amount()
         amount_actually_withdrawn = total - new_total
         block = node.getblock(node.getbestblockhash())
-        # Since we tried to withdraw more than we could
+        self.log.info("Testing that we tried to withdraw more than we could...")
         assert_greater_than(amount_to_withdraw_1, amount_actually_withdrawn)
-        # Check we tried to withdraw more than the limit
+        self.log.info("Checking that we tried to withdraw more than the limit...")
         assert_greater_than(amount_to_withdraw_1, limit_amount_1)
-        # Check we didn't actually withdraw more than allowed by the limit
+        self.log.info("Checking we didn't actually withdraw more than allowed by the limit...")
         assert_greater_than_or_equal(limit_amount_1, amount_actually_withdrawn)
         assert_equal(amount_actually_withdrawn, 993 * COIN)
         node.generate(1)
         self.sync_all()
-        # one tx should stay in mempool for awhile until is not invalidated by height
+        self.log.info("Checking that exactly 1 tx stayed in mempool...")
         self.mempool_size = 1
         self.check_mempool_size()
 
         assert_equal(new_total, self.get_credit_pool_amount())
         self.log.info("Fast forward to next day again...")
         self.slowly_generate_batch(blocks_in_one_day - 2)
-        # but should disappear later
+        self.log.info("Checking mempool is empty now...")
         self.mempool_size = 0
         self.check_mempool_size()
 
-        # new tx should be mined not this block, but next one
-        # size of this transaction should be more than
+        self.log.info("Creating new asset-unlock tx. It should be mined exactly 1 block after")
         credit_pool_amount_2 = self.get_credit_pool_amount()
         limit_amount_2 = credit_pool_amount_2 // 10
         index += 1
@@ -475,17 +477,16 @@ def run_test(self):
         self.sync_all()
         new_total -= limit_amount_2
         assert_equal(new_total, self.get_credit_pool_amount())
-        # trying to withdraw more: should fail
+        self.log.info("Trying to withdraw more... expecting to fail")
         index += 1
         asset_unlock_tx = self.create_assetunlock(index, COIN * 100, pubkey)
         self.send_tx(asset_unlock_tx)
         node.generate(1)
         self.sync_all()
 
-        # all tx should be dropped from mempool because too far
-        # but amount in credit pool should be still same after many blocks
         self.log.info("generate many blocks to be sure that mempool is empty afterwards...")
         self.slowly_generate_batch(60)
+        self.log.info("Checking that credit pool is not changed...")
         assert_equal(new_total, self.get_credit_pool_amount())
         self.check_mempool_size()
 

From 51d095a888bda2e712a9a179d033066e190be701 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 16 May 2023 18:49:11 +0700
Subject: [PATCH 11/37] improved performance of functional test
 feature_asset_locks significantly

no need to call `listunspend` every time, better to re-use it.
---
 test/functional/feature_asset_locks.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 8a39a89cf5069..f03aba800fa71 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -414,7 +414,7 @@ def run_test(self):
         total = self.get_credit_pool_amount()
         while total <= 10_900 * COIN:
             self.log.info(f"Collecting coins in pool... Collected {total}/{10_900 * COIN}")
-            coin = node.listunspent().pop()
+            coin = coins.pop()
             to_lock = int(coin['amount'] * COIN) - tiny_amount
             if to_lock > 50 * COIN:
                 to_lock = 50 * COIN

From 157a282fc608f8488d1c68960ac41a6ce6821af4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 1 Jun 2023 15:53:27 +0700
Subject: [PATCH 12/37] resolve conflicts after refactoring util/validation.h
 follow-up bitcoin#17399

---
 src/evo/creditpool.cpp | 9 ++++-----
 src/evo/creditpool.h   | 4 ++--
 src/miner.cpp          | 4 ++--
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 55f51ee03f0f2..f0168dd814667 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -11,7 +11,6 @@
 
 #include <chain.h>
 #include <logging.h>
-#include <util/validation.h>
 #include <validation.h>
 
 #include <algorithm>
@@ -58,7 +57,7 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
         TxValidationState tx_state;
         uint64_t index{0};
         if (!getDataFromUnlockTx(*tx, unlocked, index, tx_state)) {
-            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getCreditPool failed: %s", __func__, FormatStateMessage(tx_state)));
+            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getCreditPool failed: %s", __func__, tx_state.ToString()));
         }
         blockData.unlocked += unlocked;
         blockData.indexes.insert(index);
@@ -116,14 +115,14 @@ std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* c
     uint256 block_hash = block_index->GetBlockHash();
     CCreditPool pool;
     {
-        LOCK(cs_cache);
+        LOCK(cache_mutex);
         if (creditPoolCache.get(block_hash, pool)) {
             return pool;
         }
     }
     if (block_index->nHeight % DISK_SNAPSHOT_PERIOD == 0) {
         if (evoDb.Read(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool)) {
-            LOCK(cs_cache);
+            LOCK(cache_mutex);
             creditPoolCache.insert(block_hash, pool);
             return pool;
         }
@@ -133,7 +132,7 @@ std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* c
 
 void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const CCreditPool &pool) {
     {
-        LOCK(cs_cache);
+        LOCK(cache_mutex);
         creditPoolCache.insert(block_hash, pool);
     }
     if (height % DISK_SNAPSHOT_PERIOD == 0) {
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index fc2522c93c290..3cd11518b29dd 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -140,8 +140,8 @@ class CCreditPoolManager
 {
 private:
     static constexpr size_t CreditPoolCacheSize = 1000;
-    CCriticalSection cs_cache;
-    unordered_lru_cache<uint256, CCreditPool, StaticSaltedHasher> creditPoolCache GUARDED_BY(cs_cache) {CreditPoolCacheSize};
+    RecursiveMutex cache_mutex;
+    unordered_lru_cache<uint256, CCreditPool, StaticSaltedHasher> creditPoolCache GUARDED_BY(cache_mutex) {CreditPoolCacheSize};
 
     CEvoDB& evoDb;
 
diff --git a/src/miner.cpp b/src/miner.cpp
index a54baa899069d..a20e2e20827fa 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -461,8 +461,8 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
                     mapModifiedTx.get<ancestor_score>().erase(modit);
                     failedTx.insert(iter);
                 }
-                LogPrintf("%s: asset locks tx skipped due %s txid %s\n",
-                          __func__, FormatStateMessage(state), iter->GetTx().GetHash().ToString());
+                LogPrintf("%s: asset-locks tx %s skipped due %s\n",
+                          __func__, iter->GetTx().GetHash().ToString(), state.ToString());
                 continue;
             }
         }

From e5469cf1e1c003cadcf516b91dbec7a78e0e3117 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 9 Jun 2023 03:22:53 +0700
Subject: [PATCH 13/37] resolve conflicts

---
 src/validation.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/validation.cpp b/src/validation.cpp
index 43a40008f689f..8af54d6698899 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2260,7 +2260,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     bool fDIP0001Active_context = pindex->nHeight >= Params().GetConsensus().DIP0001Height;
 
     // MUST process special txes before updating UTXO to ensure consistency between mempool and block processing
-    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, chainparams.GetConsensus(), view, fJustCheck, fScriptChecks, state)) {
+    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, m_params.GetConsensus(), view, fJustCheck, fScriptChecks, state)) {
         return error("ConnectBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s",
                      pindex->GetBlockHash().ToString(), state.ToString());
     }
@@ -4910,7 +4910,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
 
     // MUST process special txes before updating UTXO to ensure consistency between mempool and block processing
     BlockValidationState state;
-    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, params.GetConsensus(), inputs, false /*fJustCheck*/, false /*fScriptChecks*/, state)) {
+    if (!ProcessSpecialTxsInBlock(block, pindex, *m_quorum_block_processor, *m_clhandler, m_params.GetConsensus(), inputs, false /*fJustCheck*/, false /*fScriptChecks*/, state)) {
         return error("RollforwardBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s",
             pindex->GetBlockHash().ToString(), state.ToString());
     }

From 6836e9d17cddf4caa686f919dfc5ad830b071904 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 16 Jun 2023 15:45:33 +0700
Subject: [PATCH 14/37] fix: removed nType from AssetLock tx accordingly DIP

---
 src/evo/assetlocktx.cpp                    | 10 +------
 src/evo/assetlocktx.h                      |  7 +----
 src/test/evo_assetlocks_tests.cpp          | 31 +++++++---------------
 test/functional/feature_asset_locks.py     |  2 +-
 test/functional/test_framework/messages.py | 13 +++------
 5 files changed, 16 insertions(+), 47 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 8b229f650894a..3db9c8fe5fb32 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -67,10 +67,6 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version");
     }
 
-    if (assetLockTx.getType() != 0) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-locktype");
-    }
-
     if (assetLockTx.getCreditOutputs().empty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-emptycreditoutputs");
     }
@@ -97,17 +93,13 @@ std::string CAssetLockPayload::ToString() const
         outputs.append(",");
     }
     outputs.back() = ']';
-    return strprintf("CAssetLockPayload(nVersion=%d,nType=%d,creditOutputs=%s)", nVersion, nType, outputs.c_str());
+    return strprintf("CAssetLockPayload(nVersion=%d,creditOutputs=%s)", nVersion, outputs.c_str());
 }
 
 uint16_t CAssetLockPayload::getVersion() const {
     return nVersion;
 }
 
-uint16_t CAssetLockPayload::getType() const {
-    return nType;
-}
-
 const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const {
     return creditOutputs;
 }
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index a8e9b3a9f8b03..7f7b635e91a9d 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -25,12 +25,10 @@ class CAssetLockPayload
 
 private:
     uint16_t nVersion{CURRENT_VERSION};
-    uint16_t nType{0};
     std::vector<CTxOut> creditOutputs;
 
 public:
-    CAssetLockPayload(uint16_t nType, const std::vector<CTxOut>& creditOutputs) :
-        nType(nType),
+    CAssetLockPayload(const std::vector<CTxOut>& creditOutputs) :
         creditOutputs(creditOutputs)
     {}
 
@@ -40,7 +38,6 @@ class CAssetLockPayload
     {
         READWRITE(
             obj.nVersion,
-            obj.nType,
             obj.creditOutputs
         );
     }
@@ -52,7 +49,6 @@ class CAssetLockPayload
         obj.clear();
         obj.setObject();
         obj.pushKV("version", int(nVersion));
-        obj.pushKV("type", int(nType));
         UniValue outputs;
         outputs.setArray();
         for (const CTxOut& out : creditOutputs) {
@@ -63,7 +59,6 @@ class CAssetLockPayload
 
     // getters
     uint16_t getVersion() const;
-    uint16_t getType() const;
     const std::vector<CTxOut>& getCreditOutputs() const;
 };
 
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index 56dc9ae5ab1b4..ed446307ef7cd 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -69,10 +69,10 @@ static CMutableTransaction CreateAssetLockTx(FillableSigningProvider& keystore,
     creditOutputs[1].nValue = 13 * CENT;
     creditOutputs[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
-    CAssetLockPayload assetLockTx(0, creditOutputs);
+    CAssetLockPayload assetLockTx(creditOutputs);
 
     CMutableTransaction tx;
-    tx.nVersion = 2;
+    tx.nVersion = 3;
     tx.nType = TRANSACTION_ASSET_LOCK;
     SetTxPayload(tx, assetLockTx);
 
@@ -105,7 +105,7 @@ static CMutableTransaction CreateAssetUnlockTx(FillableSigningProvider& keystore
     CAssetUnlockPayload assetUnlockTx(nVersion, index, fee, requestedHeight, quorumHash, quorumSig);
 
     CMutableTransaction tx;
-    tx.nVersion = 2;
+    tx.nVersion = 3;
     tx.nType = TRANSACTION_ASSET_UNLOCK;
     SetTxPayload(tx, assetUnlockTx);
 
@@ -149,7 +149,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
 
     // Check version
     {
-        BOOST_CHECK(tx.nVersion == 2);
+        BOOST_CHECK(tx.nVersion == 3);
 
         CAssetLockPayload lockPayload;
         GetTxPayload(tx, lockPayload);
@@ -193,24 +193,11 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
     }();
     const std::vector<CTxOut> creditOutputs = assetLockPayload.getCreditOutputs();
 
-    {
-        BOOST_CHECK(assetLockPayload.getType() == 0);
-
-        // Type of payload is not `0`
-        CMutableTransaction txPayloadWrongType = tx;
-
-        CAssetLockPayload assetLockWrongType(1, creditOutputs);
-        SetTxPayload(txPayloadWrongType, assetLockWrongType);
-
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txPayloadWrongType), tx_state));
-        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-locktype");
-    }
-
     {
         // Sum of credit output greater than OP_RETURN
         std::vector<CTxOut> wrongOutput = creditOutputs;
         wrongOutput[0].nValue += CENT;
-        CAssetLockPayload greaterCreditsPayload(0, wrongOutput);
+        CAssetLockPayload greaterCreditsPayload(wrongOutput);
 
         CMutableTransaction txGreaterCredits = tx;
         SetTxPayload(txGreaterCredits, greaterCreditsPayload);
@@ -220,7 +207,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
 
         // Sum of credit output less than OP_RETURN
         wrongOutput[1].nValue -= 2 * CENT;
-        CAssetLockPayload lessCreditsPayload(0, wrongOutput);
+        CAssetLockPayload lessCreditsPayload(wrongOutput);
 
         CMutableTransaction txLessCredits = tx;
         SetTxPayload(txLessCredits, lessCreditsPayload);
@@ -233,7 +220,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         // One credit output keys is not pub key
         std::vector<CTxOut> creditOutputsNotPubkey = creditOutputs;
         creditOutputsNotPubkey[0].scriptPubKey = CScript() << OP_1;
-        CAssetLockPayload notPubkeyPayload(0, creditOutputsNotPubkey);
+        CAssetLockPayload notPubkeyPayload(creditOutputsNotPubkey);
 
         CMutableTransaction txNotPubkey = tx;
         SetTxPayload(txNotPubkey, notPubkeyPayload);
@@ -314,7 +301,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
     }
 
     // Check version
-    BOOST_CHECK(tx.nVersion == 2);
+    BOOST_CHECK(tx.nVersion == 3);
     {
         CAssetUnlockPayload unlockPayload;
         GetTxPayload(tx, unlockPayload);
@@ -331,7 +318,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
     }
 
     {
-        BOOST_CHECK(tx.nVersion == 2);
+        BOOST_CHECK(tx.nVersion == 3);
 
         // Version of payload is not `1`
         CMutableTransaction txWrongVersion = tx;
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index f03aba800fa71..32b41e00a6ff9 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -60,7 +60,7 @@ def create_assetlock(self, coin, amount, pubkey):
 
         credit_outputs = CTxOut(amount, CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG]))
 
-        lockTx_payload = CAssetLockTx(1, 0, [credit_outputs])
+        lockTx_payload = CAssetLockTx(1, [credit_outputs])
 
         remaining = int(COIN * coin['amount']) - tiny_amount - credit_outputs.nValue
 
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 60d83e588f3a7..a71b7d8c2baee 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1100,36 +1100,31 @@ def serialize(self):
 
 
 class CAssetLockTx:
-    __slots__ = ("version", "nType", "creditOutputs")
+    __slots__ = ("version", "creditOutputs")
 
-    def __init__(self, version=None, nType=None, creditOutputs=None):
+    def __init__(self, version=None, creditOutputs=None):
         self.set_null()
         if version is not None:
             self.version = version
-        if nType is not None:
-            self.nType = nType
         self.creditOutputs = creditOutputs if creditOutputs is not None else []
 
     def set_null(self):
         self.version = 0
-        self.nType = 0
         self.creditOutputs = None
 
     def deserialize(self, f):
         self.version = struct.unpack("<H", f.read(2))[0]
-        self.nType = struct.unpack("<H", f.read(2))[0]
         self.creditOutputs = deser_vector(f, CTxOut)
 
     def serialize(self):
         r = b""
         r += struct.pack("<H", self.version)
-        r += struct.pack("<H", self.nType)
         r += ser_vector(self.creditOutputs)
         return r
 
     def __repr__(self):
-        return "CAssetLockTx(version={} nType={} creditOutputs={}" \
-            .format(self.version, self.nType, repr(self.creditOutputs))
+        return "CAssetLockTx(version={} creditOutputs={}" \
+            .format(self.version, repr(self.creditOutputs))
 
 
 class CAssetUnlockTx:

From cd22d3adc4ed5a9908bceb3d764f163e1cbc31b4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 16 Jun 2023 16:12:00 +0700
Subject: [PATCH 15/37] fix: nVersion in Asset Lock/Unlock transaction's
 payload is 8bits not 16

---
 src/evo/assetlocktx.cpp                    |  4 ++--
 src/evo/assetlocktx.h                      | 15 ++++++-------
 src/test/evo_assetlocks_tests.cpp          | 25 ++++++++++++++++------
 test/functional/test_framework/messages.py |  8 +++----
 4 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 3db9c8fe5fb32..f1c7c2acd3551 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -96,7 +96,7 @@ std::string CAssetLockPayload::ToString() const
     return strprintf("CAssetLockPayload(nVersion=%d,creditOutputs=%s)", nVersion, outputs.c_str());
 }
 
-uint16_t CAssetLockPayload::getVersion() const {
+uint8_t CAssetLockPayload::getVersion() const {
     return nVersion;
 }
 
@@ -199,7 +199,7 @@ std::string CAssetUnlockPayload::ToString() const
             nVersion, index, fee / COIN, fee % COIN, requestedHeight, quorumHash.GetHex(), quorumSig.ToString().c_str());
 }
 
-uint16_t CAssetUnlockPayload::getVersion() const {
+uint8_t CAssetUnlockPayload::getVersion() const {
     return nVersion;
 }
 
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 7f7b635e91a9d..cad231816611e 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -20,11 +20,11 @@ struct CCreditPool;
 class CAssetLockPayload
 {
 public:
-    static constexpr uint16_t CURRENT_VERSION = 1;
+    static constexpr uint8_t CURRENT_VERSION = 1;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_LOCK;
 
 private:
-    uint16_t nVersion{CURRENT_VERSION};
+    uint8_t nVersion{CURRENT_VERSION};
     std::vector<CTxOut> creditOutputs;
 
 public:
@@ -58,20 +58,20 @@ class CAssetLockPayload
     }
 
     // getters
-    uint16_t getVersion() const;
+    uint8_t getVersion() const;
     const std::vector<CTxOut>& getCreditOutputs() const;
 };
 
 class CAssetUnlockPayload
 {
 public:
-    static constexpr uint16_t CURRENT_VERSION = 1;
+    static constexpr uint8_t CURRENT_VERSION = 1;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_UNLOCK;
 
     static constexpr size_t MAXIMUM_WITHDRAWALS = 32;
 
 private:
-    uint16_t nVersion{CURRENT_VERSION};
+    uint8_t nVersion{CURRENT_VERSION};
     uint64_t index{0};
     uint32_t fee{0};
     uint32_t requestedHeight{0};
@@ -79,7 +79,7 @@ class CAssetUnlockPayload
     CBLSSignature quorumSig{};
 
 public:
-    CAssetUnlockPayload(uint16_t nVersion, uint64_t index, uint32_t fee, uint32_t requestedHeight,
+    CAssetUnlockPayload(uint8_t nVersion, uint64_t index, uint32_t fee, uint32_t requestedHeight,
             uint256 quorumHash, CBLSSignature quorumSig) :
         nVersion(nVersion),
         index(index),
@@ -120,8 +120,7 @@ class CAssetUnlockPayload
     bool VerifySig(const uint256& msgHash, const CBlockIndex* pindexTip, TxValidationState& state) const;
 
     // getters
-    uint16_t getVersion() const;
-    uint16_t getType() const;
+    uint8_t getVersion() const;
     uint64_t getIndex() const;
     uint32_t getFee() const;
     uint32_t getRequestedHeight() const;
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index ed446307ef7cd..e8de62bfe1bf0 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -300,8 +300,6 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-have-input");
     }
 
-    // Check version
-    BOOST_CHECK(tx.nVersion == 3);
     {
         CAssetUnlockPayload unlockPayload;
         GetTxPayload(tx, unlockPayload);
@@ -315,13 +313,26 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         txWrongType.nType = TRANSACTION_ASSET_LOCK;
         BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txWrongType), block_index, pool, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-type");
-    }
 
-    {
+        // Check version of tx and payload
         BOOST_CHECK(tx.nVersion == 3);
-
-        // Version of payload is not `1`
-        CMutableTransaction txWrongVersion = tx;
+        for (uint8_t payload_version : {0, 1, 2, 255}) {
+            CAssetUnlockPayload unlockPayload_tmp{payload_version,
+                unlockPayload.getIndex(),
+                unlockPayload.getFee(),
+                unlockPayload.getRequestedHeight(),
+                unlockPayload.getQuorumHash(),
+                unlockPayload.getQuorumSig()};
+            CMutableTransaction txWrongVersion = tx;
+            SetTxPayload(txWrongVersion, unlockPayload_tmp);
+            if (payload_version != 1) {
+                BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txWrongVersion), block_index, pool, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-version");
+            } else {
+                BOOST_CHECK(!CheckAssetUnlockTx(CTransaction(txWrongVersion), block_index, pool, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
+            }
+        }
     }
 
     {
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index a71b7d8c2baee..425826b865f09 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1113,12 +1113,12 @@ def set_null(self):
         self.creditOutputs = None
 
     def deserialize(self, f):
-        self.version = struct.unpack("<H", f.read(2))[0]
+        self.version = struct.unpack("<B", f.read(1))[0]
         self.creditOutputs = deser_vector(f, CTxOut)
 
     def serialize(self):
         r = b""
-        r += struct.pack("<H", self.version)
+        r += struct.pack("<B", self.version)
         r += ser_vector(self.creditOutputs)
         return r
 
@@ -1154,7 +1154,7 @@ def set_null(self):
         self.quorumSig = b'\x00' * 96
 
     def deserialize(self, f):
-        self.version = struct.unpack("<H", f.read(2))[0]
+        self.version = struct.unpack("<B", f.read(1))[0]
         self.index = struct.unpack("<Q", f.read(8))[0]
         self.fee = struct.unpack("<I", f.read(4))[0]
         self.requestedHeight = struct.unpack("<I", f.read(4))[0]
@@ -1163,7 +1163,7 @@ def deserialize(self, f):
 
     def serialize(self):
         r = b""
-        r += struct.pack("<H", self.version)
+        r += struct.pack("<B", self.version)
         r += struct.pack("<Q", self.index)
         r += struct.pack("<I", self.fee)
         r += struct.pack("<I", self.requestedHeight)

From 341655313f2bed6776fd610f3bba29a8387cd36d Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Sun, 18 Jun 2023 00:20:21 +0700
Subject: [PATCH 16/37] fixup missing explicit

---
 src/evo/assetlocktx.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index cad231816611e..edb2a4f82185b 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -28,7 +28,7 @@ class CAssetLockPayload
     std::vector<CTxOut> creditOutputs;
 
 public:
-    CAssetLockPayload(const std::vector<CTxOut>& creditOutputs) :
+    explicit CAssetLockPayload(const std::vector<CTxOut>& creditOutputs) :
         creditOutputs(creditOutputs)
     {}
 

From 1b2944d86133795dae558a7ca6e2fa4007b7bcca Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 01:28:00 +0700
Subject: [PATCH 17/37] fixes accordingly to codereview

---
 src/consensus/tx_verify.cpp |  2 +-
 src/evo/assetlocktx.cpp     | 16 +++++-----------
 src/evo/assetlocktx.h       |  7 +++++--
 src/evo/creditpool.cpp      | 31 ++++++++++++++++++++-----------
 src/evo/specialtxman.cpp    |  4 ++--
 src/miner.cpp               |  4 ++--
 6 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 01c8a400e51e4..01503e15aaa49 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -168,7 +168,7 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
         }
         CAmount txfee_aux = assetUnlockTx.getFee();
-        if (!MoneyRange(txfee_aux)) {
+        if (txfee_aux == 0 || !MoneyRange(txfee_aux)) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-assetunlock-fee-outofrange");
         }
         txfee = txfee_aux;
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index f1c7c2acd3551..dd3da98fabca8 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -52,7 +52,7 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
         if (txout.nValue <= 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-zeroout-return");
 
         // Should be only one OP_RETURN
-        if (returnAmount) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-multiple-return");
+        if (returnAmount > 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-multiple-return");
         returnAmount = txout.nValue;
     }
 
@@ -115,14 +115,9 @@ bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* p
 
     Consensus::LLMQType llmqType = Params().GetConsensus().llmqTypeAssetLocks;
 
-    const auto& llmq_params_opt = llmq::GetLLMQParams(llmqType);
-    if (!llmq_params_opt) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-llmq-type");
-    }
-
-    // We check at most 2 quorums, so, count is equal to 2
-    const int count = 2;
-    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, count > -1 ? count : llmq_params_opt->signingActiveQuorumCount);
+    // We check at most 2 quorums, so, quorum_count is equal to 2
+    const int quorum_count = 2;
+    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, quorum_count);
     bool isActive = std::any_of(quorums.begin(), quorums.end(), [&](const auto &q) { return q->qc->quorumHash == quorumHash; });
 
     if (!isActive) {
@@ -224,6 +219,5 @@ const CBLSSignature& CAssetUnlockPayload::getQuorumSig() const {
 }
 
 int CAssetUnlockPayload::getHeightToExpiry() const {
-    int expiryHeight = 48;
-    return requestedHeight + expiryHeight;
+    return requestedHeight + HEIGHT_DIFF_EXPIRING;
 }
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index edb2a4f82185b..3bc33ae5186f9 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -98,9 +98,11 @@ class CAssetUnlockPayload
             obj.index,
             obj.fee,
             obj.requestedHeight,
-            obj.quorumHash,
-            obj.quorumSig
+            obj.quorumHash
         );
+        if (!(s.GetType() & SER_GETHASH)) {
+            READWRITE(obj.quorumSig);
+        }
     }
 
     std::string ToString() const;
@@ -129,6 +131,7 @@ class CAssetUnlockPayload
 
     // used by mempool to know when possible to drop a transaction as expired
     int getHeightToExpiry() const;
+    static constexpr int HEIGHT_DIFF_EXPIRING = 48;
 };
 
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index f0168dd814667..0f1bd181f5cfe 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -22,7 +22,8 @@ static const std::string DB_CREDITPOOL_SNAPSHOT = "cpm_S";
 
 std::unique_ptr<CCreditPoolManager> creditPoolManager;
 
-static bool getDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint64_t& index, TxValidationState& state) {
+static bool getDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint64_t& index, TxValidationState& state)
+{
     CAssetUnlockPayload assetUnlockTx;
     if (!GetTxPayload(tx, assetUnlockTx)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-payload");
@@ -31,8 +32,8 @@ static bool getDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint6
     index = assetUnlockTx.getIndex();
     toUnlock = assetUnlockTx.getFee();
     for (const CTxOut& txout : tx.vout) {
-        if (txout.nValue < 0) {
-            return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-negative-amount");
+        if (!MoneyRange(txout.nValue)) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-txout-outofrange");
         }
         toUnlock += txout.nValue;
     }
@@ -47,7 +48,8 @@ namespace {
 } // anonymous namespace
 
 // it throws exception if anything went wrong
-static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRef>& vtx) {
+static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRef>& vtx)
+{
     UnlockDataPerBlock blockData;
 
     for (CTransactionRef tx : vtx) {
@@ -65,7 +67,8 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
     return blockData;
 }
 
-bool CSkipSet::add(uint64_t value) {
+bool CSkipSet::add(uint64_t value)
+{
     assert(!contains(value));
 
     if (auto it = skipped.find(value); it != skipped.end()) {
@@ -87,7 +90,8 @@ bool CSkipSet::add(uint64_t value) {
     return true;
 }
 
-bool CSkipSet::canBeAdded(uint64_t value) const {
+bool CSkipSet::canBeAdded(uint64_t value) const
+{
     if (contains(value)) return false;
 
     if (skipped.find(value) != skipped.end()) return true;
@@ -99,17 +103,20 @@ bool CSkipSet::canBeAdded(uint64_t value) const {
     return true;
 }
 
-bool CSkipSet::contains(uint64_t value) const {
+bool CSkipSet::contains(uint64_t value) const
+{
     if (current_max <= value) return false;
     return skipped.find(value) == skipped.end();
 }
 
-std::string CCreditPool::ToString() const {
+std::string CCreditPool::ToString() const
+{
     return strprintf("CCreditPool(locked=%lld,currentLimit=%lld,nIndexes=%lld)",
             locked, currentLimit, indexes.size());
 }
 
-std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* const block_index) {
+std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* const block_index)
+{
     if (!llmq::utils::IsV20Active(block_index)) return CCreditPool{};
 
     uint256 block_hash = block_index->GetBlockHash();
@@ -130,7 +137,8 @@ std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* c
     return std::nullopt;
 }
 
-void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const CCreditPool &pool) {
+void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const CCreditPool &pool)
+{
     {
         LOCK(cache_mutex);
         creditPoolCache.insert(block_hash, pool);
@@ -140,7 +148,8 @@ void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const
     }
 }
 
-static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex *block_index, const Consensus::Params& consensusParams) {
+static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex *block_index, const Consensus::Params& consensusParams)
+{
     CBlock block;
     if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
         throw std::runtime_error("failed-getcbforblock-read");
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 936da8ae8f6ed..5d6fb06624dfe 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -149,7 +149,7 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
             }
-            if (creditPoolDiff && !creditPoolDiff->processTransaction(*ptr_tx, tx_state)) {
+            if (creditPoolDiff != std::nullopt && !creditPoolDiff->processTransaction(*ptr_tx, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed at Credit Pool (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -157,7 +157,7 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
                 return false;
             }
         }
-        if (creditPoolDiff) {
+        if (creditPoolDiff != std::nullopt) {
             CAmount locked_proposed{0};
             if(creditPoolDiff->getTargetLocked()) locked_proposed = *creditPoolDiff->getTargetLocked();
 
diff --git a/src/miner.cpp b/src/miner.cpp
index a20e2e20827fa..854d000d1d4c5 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -231,7 +231,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                     // not an error
                     LogPrintf("CreateNewBlock() h[%d] CbTx failed to find best CL. Inserting null CL\n", nHeight);
                 }
-                assert(creditPoolDiff);
+                assert(creditPoolDiff != std::nullopt);
                 cbTx.assetLockedAmount = creditPoolDiff->getTotalLocked();
             }
         }
@@ -450,7 +450,7 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
             }
         }
 
-        if (creditPoolDiff) {
+        if (creditPoolDiff != std::nullopt) {
             // If one transaction is skipped due to limits, it is not a reason to interrupt
             // whole process of adding transactions.
             // `state` is local here because used to log info about this specific tx

From 9a7645c7cf64ed87c8fa7a69110d4dc899a8a2a3 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 01:32:55 +0700
Subject: [PATCH 18/37] codestyle: { at new line

---
 src/evo/assetlocktx.cpp | 21 ++++++++++++++-------
 src/evo/creditpool.cpp  |  3 ++-
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index dd3da98fabca8..c36c96a247e18 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -194,30 +194,37 @@ std::string CAssetUnlockPayload::ToString() const
             nVersion, index, fee / COIN, fee % COIN, requestedHeight, quorumHash.GetHex(), quorumSig.ToString().c_str());
 }
 
-uint8_t CAssetUnlockPayload::getVersion() const {
+uint8_t CAssetUnlockPayload::getVersion() const
+{
     return nVersion;
 }
 
-uint64_t CAssetUnlockPayload::getIndex() const {
+uint64_t CAssetUnlockPayload::getIndex() const
+{
     return index;
 }
 
-uint32_t CAssetUnlockPayload::getFee() const {
+uint32_t CAssetUnlockPayload::getFee() const
+{
     return fee;
 }
 
-uint32_t CAssetUnlockPayload::getRequestedHeight() const {
+uint32_t CAssetUnlockPayload::getRequestedHeight() const
+{
     return requestedHeight;
 }
 
-const uint256& CAssetUnlockPayload::getQuorumHash() const {
+const uint256& CAssetUnlockPayload::getQuorumHash() const
+{
     return quorumHash;
 }
 
-const CBLSSignature& CAssetUnlockPayload::getQuorumSig() const {
+const CBLSSignature& CAssetUnlockPayload::getQuorumSig() const
+{
     return quorumSig;
 }
 
-int CAssetUnlockPayload::getHeightToExpiry() const {
+int CAssetUnlockPayload::getHeightToExpiry() const
+{
     return requestedHeight + HEIGHT_DIFF_EXPIRING;
 }
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 0f1bd181f5cfe..5b30a24b0503a 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -316,7 +316,8 @@ bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
     return true;
 }
 
-bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationState& state) {
+bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationState& state)
+{
     if (tx.nVersion != 3) return true;
     if (tx.nType == TRANSACTION_COINBASE) return setTarget(tx, state);
 

From 46c6c6d8e329b320b54c40ab47d4462187097001 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 01:44:11 +0700
Subject: [PATCH 19/37] fix for SkipList unit tests accordingly code review

---
 src/test/evo_assetlocks_tests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index e8de62bfe1bf0..4218b108f6db4 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -358,7 +358,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 
 }
 
-BOOST_FIXTURE_TEST_CASE(evo_skipset, TestChain100Setup)
+BOOST_FIXTURE_TEST_CASE(evo_skipset, BasicTestingSetup)
 {
     std::mt19937 gen;
     for (size_t test = 0; test < 17; ++test) {

From 1e02bcfda98199fb085c18c9eeebccfc33f223f2 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 02:02:29 +0700
Subject: [PATCH 20/37] more fixes accodringly to review

---
 src/evo/assetlocktx.cpp           |  2 +-
 src/test/evo_assetlocks_tests.cpp | 27 +++++++++++++++++++++------
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index c36c96a247e18..cc37d78acf81c 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -49,7 +49,7 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
 
         if (script.size() != 2 || script[1] != 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-non-empty-return");
 
-        if (txout.nValue <= 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-zeroout-return");
+        if (txout.nValue == 0 || !MoneyRange(txout.nValue)) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-opreturn-outofrange");
 
         // Should be only one OP_RETURN
         if (returnAmount > 0) return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-multiple-return");
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index 4218b108f6db4..c7498dd869973 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -4,13 +4,13 @@
 
 #include <test/util/setup_common.h>
 
+#include <amount.h>
+#include <consensus/tx_check.h>
 #include <evo/assetlocktx.h>
 #include <evo/creditpool.h> // to test CSkipSet
 #include <policy/settings.h>
-#include <script/signingprovider.h>
-#include <consensus/tx_check.h>
 #include <script/script.h>
-
+#include <script/signingprovider.h>
 #include <validation.h> // for ::ChainActive()
 
 #include <boost/test/unit_test.hpp>
@@ -240,6 +240,21 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
 
     }
 
+    {
+        // zero/negative OP_RETURN
+        CMutableTransaction txReturnOutOfRange = tx;
+        txReturnOutOfRange.vout[0].nValue = 0;
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
+
+        txReturnOutOfRange.vout[0].nValue = MAX_MONEY + 1;
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
+    }
+
+
     {
         // OP_RETURN is missing
         CMutableTransaction txNoReturn = tx;
@@ -251,10 +266,10 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
 
     {
         // OP_RETURN should not have any data
-        CMutableTransaction txMultipleReturn = tx;
-        txMultipleReturn.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("abc");
+        CMutableTransaction txReturnData = tx;
+        txReturnData.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("abc");
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnData), tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-non-empty-return");
     }
 }

From 4ebfcc49c9c5ff1ece8789d73cf2b1e3bcebc0f0 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 02:20:35 +0700
Subject: [PATCH 21/37] fix inflation bug for credit outputs in assetlock tx

---
 src/evo/assetlocktx.cpp           |  4 ++++
 src/test/evo_assetlocks_tests.cpp | 25 +++++++++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index cc37d78acf81c..1f63c73f770da 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -73,6 +73,10 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
 
     CAmount creditOutputsAmount = 0;
     for (const CTxOut& out : assetLockTx.getCreditOutputs()) {
+        if (out.nValue == 0 || !MoneyRange(out.nValue) || !MoneyRange(creditOutputsAmount + out.nValue)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-credit-outofrange");
+        }
+
         creditOutputsAmount += out.nValue;
         if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index c7498dd869973..b2c11df9f0bc5 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -216,6 +216,31 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
     }
 
+    {
+        // Credit output is out-of-range
+        std::vector<CTxOut> creditOutputsOutOfRange = creditOutputs;
+        creditOutputsOutOfRange[0].nValue = 0;
+        CAssetLockPayload invalidOutputsPayload(creditOutputsOutOfRange);
+
+        CMutableTransaction txInvalidOutputs = tx;
+        SetTxPayload(txInvalidOutputs, invalidOutputsPayload);
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
+
+        // one of output is out of range
+        creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1;
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
+
+        // sum of some of output is out of range
+        creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1 - creditOutputsOutOfRange[1].nValue;
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
+
+    }
     {
         // One credit output keys is not pub key
         std::vector<CTxOut> creditOutputsNotPubkey = creditOutputs;

From 4ff8e759a112dcc3790c0d37db0b85bce9018c88 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 02:22:51 +0700
Subject: [PATCH 22/37] improved hash calculation

---
 src/evo/assetlocktx.cpp                | 19 ++++++------------
 test/functional/feature_asset_locks.py | 27 +++++++++++++-------------
 2 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 1f63c73f770da..8c1125818a7c6 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -111,6 +111,9 @@ const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const {
 /*
    Asset Unlock Transaction (withdrawals)
    */
+
+const std::string ASSETUNLOCK_REQUESTID_PREFIX = "plwdtx";
+
 bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* pindexTip, TxValidationState& state) const
 {
     // That quourm hash must be active at `requestHeight`,
@@ -137,13 +140,9 @@ bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* p
     const auto quorum = llmq::quorumManager->GetQuorum(llmqType, quorumHash);
     assert(quorum);
 
-    const std::string id(strprintf("plwdtx%lld", index));
+    const uint256 requestId = ::SerializeHash(std::make_pair(ASSETUNLOCK_REQUESTID_PREFIX, index));
 
-    std::vector<uint8_t> vchHash(32);
-    CSHA256().Write(reinterpret_cast<const uint8_t*>(id.data()), id.size()).Finalize(vchHash.data());
-    uint256 requestId(vchHash);
-
-    uint256 signHash = llmq::utils::BuildSignHash(llmqType, quorum->qc->quorumHash, requestId, msgHash);
+    const uint256 signHash = llmq::utils::BuildSignHash(llmqType, quorum->qc->quorumHash, requestId, msgHash);
     if (quorumSig.VerifyInsecure(quorum->qc->quorumPublicKey, signHash)) {
         return true;
     }
@@ -183,13 +182,7 @@ bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-quorum-hash");
     }
 
-    // Copy transaction except `quorumSig` field to calculate hash
-    CMutableTransaction tx_copy(tx);
-    auto payload_copy = CAssetUnlockPayload(assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature());
-    SetTxPayload(tx_copy, payload_copy);
-
-    uint256 msgHash = tx_copy.GetHash();
-    return assetUnlockTx.VerifySig(msgHash, pindexPrev, state);
+    return assetUnlockTx.VerifySig(tx.GetHash(), pindexPrev, state);
 }
 
 std::string CAssetUnlockPayload::ToString() const
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 32b41e00a6ff9..540945ba59c5d 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -4,8 +4,8 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-import hashlib
 import copy
+import struct
 from decimal import Decimal
 from io import BytesIO
 
@@ -16,23 +16,25 @@
 from test_framework.authproxy import JSONRPCException
 from test_framework.key import ECKey
 from test_framework.messages import (
-    FromHex,
     CAssetLockTx,
     CAssetUnlockTx,
-    COutPoint,
-    CTxOut,
-    CTxIn,
     COIN,
+    COutPoint,
     CTransaction,
+    CTxIn,
+    CTxOut,
+    FromHex,
+    hash256,
+    ser_string,
 )
 from test_framework.script import (
-    hash160,
     CScript,
-    OP_HASH160,
-    OP_RETURN,
     OP_CHECKSIG,
     OP_DUP,
     OP_EQUALVERIFY,
+    OP_HASH160,
+    OP_RETURN,
+    hash160,
 )
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import (
@@ -84,12 +86,11 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
 
         # request ID = sha256("plwdtx", index)
-        sha256 = hashlib.sha256()
-        sha256.update(("plwdtx" + str(index)).encode())
-        id = sha256.digest()[::-1].hex()
+        request_id_buf = ser_string(b"plwdtx") + struct.pack("<Q", index)
+        request_id = hash256(request_id_buf)[::-1].hex()
 
         height = node.getblockcount()
-        quorumHash = mninfo[0].node.quorum("selectquorum", llmq_type_test, id)["quorumHash"]
+        quorumHash = mninfo[0].node.quorum("selectquorum", llmq_type_test, request_id)["quorumHash"]
         unlockTx_payload = CAssetUnlockTx(
             version = 1,
             index = index,
@@ -108,7 +109,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         unlock_tx.calc_sha256()
         msgHash = format(unlock_tx.sha256, '064x')
 
-        recsig = self.get_recovered_sig(id, msgHash, llmq_type=llmq_type_test)
+        recsig = self.get_recovered_sig(request_id, msgHash, llmq_type=llmq_type_test)
 
         unlockTx_payload.quorumSig = bytearray.fromhex(recsig["sig"])
         unlock_tx.vExtraPayload = unlockTx_payload.serialize()

From 4f60fb2db6994a72cc457a93908490cdea95476f Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 03:23:53 +0700
Subject: [PATCH 23/37] hidden implementation of asset locks from tx_verify

---
 src/consensus/tx_verify.cpp | 11 +----------
 src/evo/assetlocktx.cpp     | 14 ++++++++++++++
 src/evo/assetlocktx.h       |  1 +
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 01503e15aaa49..e7fcc762d44c7 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -163,16 +163,7 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
 {
 
     if (bool isAssetUnlockTx = (tx.nVersion == 3 && tx.nType ==  TRANSACTION_ASSET_UNLOCK); isAssetUnlockTx) {
-        CAssetUnlockPayload assetUnlockTx;
-        if (!GetTxPayload(tx, assetUnlockTx)) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
-        }
-        CAmount txfee_aux = assetUnlockTx.getFee();
-        if (txfee_aux == 0 || !MoneyRange(txfee_aux)) {
-            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-assetunlock-fee-outofrange");
-        }
-        txfee = txfee_aux;
-        return true;
+        return GetAssetUnlockFee(tx, txfee, state);
     }
 
     // are the actual inputs available?
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 8c1125818a7c6..12f1b8bb3c539 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -185,6 +185,20 @@ bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, c
     return assetUnlockTx.VerifySig(tx.GetHash(), pindexPrev, state);
 }
 
+bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state)
+{
+    CAssetUnlockPayload assetUnlockTx;
+    if (!GetTxPayload(tx, assetUnlockTx)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
+    }
+    CAmount txfee_aux = assetUnlockTx.getFee();
+    if (txfee_aux == 0 || !MoneyRange(txfee_aux)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-assetunlock-fee-outofrange");
+    }
+    txfee = txfee_aux;
+    return true;
+}
+
 std::string CAssetUnlockPayload::ToString() const
 {
     return strprintf("CAssetUnlockPayload(nVersion=%d,index=%d,fee=%d.%08d,requestedHeight=%d,quorumHash=%d,quorumSig=%s",
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 3bc33ae5186f9..b5810d84fe94a 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -137,5 +137,6 @@ class CAssetUnlockPayload
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);
 bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state);
 bool CheckAssetLockUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state);
+bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state);
 
 #endif // BITCOIN_EVO_ASSETLOCKTX_H

From 4e6e9631ae65d6982f6d5d0efcbba80d9ab1c325 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 04:01:02 +0700
Subject: [PATCH 24/37] cleanup `quorum_count`

---
 src/evo/assetlocktx.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 12f1b8bb3c539..bb92dbf578c65 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -122,9 +122,8 @@ bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* p
 
     Consensus::LLMQType llmqType = Params().GetConsensus().llmqTypeAssetLocks;
 
-    // We check at most 2 quorums, so, quorum_count is equal to 2
-    const int quorum_count = 2;
-    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, quorum_count);
+    // We check at most 2 quorums
+    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, 2);
     bool isActive = std::any_of(quorums.begin(), quorums.end(), [&](const auto &q) { return q->qc->quorumHash == quorumHash; });
 
     if (!isActive) {

From f2c2df244a11ca3be6b9e168e73519a812c7c335 Mon Sep 17 00:00:00 2001
From: UdjinM6 <UdjinM6@users.noreply.github.com>
Date: Wed, 21 Jun 2023 02:05:55 +0300
Subject: [PATCH 25/37] fix: revert hash calculation of AssetUnlock transaction

`tx.GetHash()` exclude hash from serialization at all, while previous implementation assumes zeroes on sig's place
---
 src/evo/assetlocktx.cpp | 9 ++++++++-
 src/evo/assetlocktx.h   | 6 ++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index bb92dbf578c65..5b7300c83aacc 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -181,7 +181,14 @@ bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-quorum-hash");
     }
 
-    return assetUnlockTx.VerifySig(tx.GetHash(), pindexPrev, state);
+    // Copy transaction except `quorumSig` field to calculate hash
+    CMutableTransaction tx_copy(tx);
+    auto payload_copy = CAssetUnlockPayload(assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature());
+    SetTxPayload(tx_copy, payload_copy);
+
+    uint256 msgHash = tx_copy.GetHash();
+
+    return assetUnlockTx.VerifySig(msgHash, pindexPrev, state);
 }
 
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state)
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index b5810d84fe94a..939f6d9960939 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -98,11 +98,9 @@ class CAssetUnlockPayload
             obj.index,
             obj.fee,
             obj.requestedHeight,
-            obj.quorumHash
+            obj.quorumHash,
+            obj.quorumSig
         );
-        if (!(s.GetType() & SER_GETHASH)) {
-            READWRITE(obj.quorumSig);
-        }
     }
 
     std::string ToString() const;

From 55dff947a0d0fe5042f2a788ac2fc0c283cd5dee Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 21 Jun 2023 13:59:10 +0700
Subject: [PATCH 26/37] refactor: add more const for local variables that is
 not supposed to be changed

---
 src/evo/assetlocktx.cpp | 12 +++++++-----
 src/evo/creditpool.cpp  |  8 ++++----
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 5b7300c83aacc..09025f59f0d37 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -100,11 +100,13 @@ std::string CAssetLockPayload::ToString() const
     return strprintf("CAssetLockPayload(nVersion=%d,creditOutputs=%s)", nVersion, outputs.c_str());
 }
 
-uint8_t CAssetLockPayload::getVersion() const {
+uint8_t CAssetLockPayload::getVersion() const
+{
     return nVersion;
 }
 
-const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const {
+const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const
+{
     return creditOutputs;
 }
 
@@ -123,7 +125,7 @@ bool CAssetUnlockPayload::VerifySig(const uint256& msgHash, const CBlockIndex* p
     Consensus::LLMQType llmqType = Params().GetConsensus().llmqTypeAssetLocks;
 
     // We check at most 2 quorums
-    auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, 2);
+    const auto quorums = llmq::quorumManager->ScanQuorums(llmqType, pindexTip, 2);
     bool isActive = std::any_of(quorums.begin(), quorums.end(), [&](const auto &q) { return q->qc->quorumHash == quorumHash; });
 
     if (!isActive) {
@@ -183,7 +185,7 @@ bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, c
 
     // Copy transaction except `quorumSig` field to calculate hash
     CMutableTransaction tx_copy(tx);
-    auto payload_copy = CAssetUnlockPayload(assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature());
+    const CAssetUnlockPayload payload_copy{assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature{}};
     SetTxPayload(tx_copy, payload_copy);
 
     uint256 msgHash = tx_copy.GetHash();
@@ -197,7 +199,7 @@ bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState
     if (!GetTxPayload(tx, assetUnlockTx)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
     }
-    CAmount txfee_aux = assetUnlockTx.getFee();
+    const CAmount txfee_aux = assetUnlockTx.getFee();
     if (txfee_aux == 0 || !MoneyRange(txfee_aux)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-assetunlock-fee-outofrange");
     }
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 5b30a24b0503a..5810de9be7876 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -119,7 +119,7 @@ std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* c
 {
     if (!llmq::utils::IsV20Active(block_index)) return CCreditPool{};
 
-    uint256 block_hash = block_index->GetBlockHash();
+    const uint256 block_hash = block_index->GetBlockHash();
     CCreditPool pool;
     {
         LOCK(cache_mutex);
@@ -148,7 +148,7 @@ void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const
     }
 }
 
-static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex *block_index, const Consensus::Params& consensusParams)
+static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex* const block_index, const Consensus::Params& consensusParams)
 {
     CBlock block;
     if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
@@ -164,7 +164,7 @@ static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex *block_inde
     return block;
 }
 
-CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams)
+CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const block_index, CCreditPool prev, const Consensus::Params& consensusParams)
 {
     std::optional<CBlock> block = getBlockForCreditPool(block_index, consensusParams);
     if (!block) {
@@ -210,7 +210,7 @@ CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* block_ind
 
     // Unlock limits are # max(100, min(.10 * assetlockpool, 1000)) inside window
     CAmount currentLimit = locked;
-    CAmount latelyUnlocked = prev.latelyUnlocked + blockData.unlocked - distantUnlocked;
+    const CAmount latelyUnlocked = prev.latelyUnlocked + blockData.unlocked - distantUnlocked;
     if (currentLimit + latelyUnlocked > LimitAmountLow) {
         currentLimit = std::max(LimitAmountLow, locked / 10) - latelyUnlocked;
         if (currentLimit < 0) currentLimit = 0;

From 3908739b7fcdb8cc3e29483849460726943e467f Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 30 Jun 2023 16:25:36 +0700
Subject: [PATCH 27/37] fix: apply suggestions from code review

Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com>
---
 src/evo/creditpool.cpp | 10 +++++-----
 src/evo/creditpool.h   |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 5810de9be7876..353f746f56263 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -59,7 +59,7 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
         TxValidationState tx_state;
         uint64_t index{0};
         if (!getDataFromUnlockTx(*tx, unlocked, index, tx_state)) {
-            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getCreditPool failed: %s", __func__, tx_state.ToString()));
+            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getDataFromUnlockTx failed: %s", __func__, tx_state.ToString()));
         }
         blockData.unlocked += unlocked;
         blockData.indexes.insert(index);
@@ -111,7 +111,7 @@ bool CSkipSet::contains(uint64_t value) const
 
 std::string CCreditPool::ToString() const
 {
-    return strprintf("CCreditPool(locked=%lld,currentLimit=%lld,nIndexes=%lld)",
+    return strprintf("CCreditPool(locked=%lld, currentLimit=%lld, nIndexes=%lld)",
             locked, currentLimit, indexes.size());
 }
 
@@ -219,7 +219,7 @@ CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const blo
 
     assert(currentLimit >= 0);
 
-    if (currentLimit || latelyUnlocked || locked) {
+    if (currentLimit > 0 || latelyUnlocked > 0 || locked > 0) {
         LogPrintf("CCreditPoolManager: asset unlock limits on height: %d locked: %d.%08d limit: %d.%08d previous: %d.%08d\n", block_index->nHeight, locked / COIN, locked % COIN,
                currentLimit / COIN, currentLimit % COIN,
                latelyUnlocked / COIN, latelyUnlocked % COIN);
@@ -304,11 +304,11 @@ bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
     }
 
     if (pool.indexes.contains(index) || newIndexes.count(index)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-duplicated-index");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-duplicated-index");
     }
 
     if (!pool.indexes.canBeAdded(index)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-getcbforblock-index-exceed");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-cant-add");
     }
 
     newIndexes.insert(index);
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index 3cd11518b29dd..5edae81b8c94d 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -127,7 +127,7 @@ class CCreditPoolDiff {
     }
 
     std::string ToString() const {
-        return strprintf("CCreditPoolDiff(target=%lld,sessionLocked=%lld,sessionUnlocked=%lld,newIndexes=%lld,pool=%s", getTargetLocked() ? *getTargetLocked() : -1, sessionLocked, sessionUnlocked, newIndexes.size(), pool.ToString());
+        return strprintf("CCreditPoolDiff(target=%lld, sessionLocked=%lld, sessionUnlocked=%lld, newIndexes=%lld, pool=%s)", getTargetLocked() ? *getTargetLocked() : -1, sessionLocked, sessionUnlocked, newIndexes.size(), pool.ToString());
     }
 
 private:

From 128ef194799f87b9e18e47aef099db41b46498b8 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Sun, 9 Jul 2023 17:07:31 +0700
Subject: [PATCH 28/37] refactor: move trivial getters of
 CAsset{Lock,Unlock}Payload to header

---
 src/evo/assetlocktx.cpp | 45 ------------------------------------
 src/evo/assetlocktx.h   | 51 +++++++++++++++++++++++++++++++++--------
 2 files changed, 42 insertions(+), 54 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 09025f59f0d37..79cc1c7e0fd6d 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -100,16 +100,6 @@ std::string CAssetLockPayload::ToString() const
     return strprintf("CAssetLockPayload(nVersion=%d,creditOutputs=%s)", nVersion, outputs.c_str());
 }
 
-uint8_t CAssetLockPayload::getVersion() const
-{
-    return nVersion;
-}
-
-const std::vector<CTxOut>& CAssetLockPayload::getCreditOutputs() const
-{
-    return creditOutputs;
-}
-
 /*
    Asset Unlock Transaction (withdrawals)
    */
@@ -212,38 +202,3 @@ std::string CAssetUnlockPayload::ToString() const
     return strprintf("CAssetUnlockPayload(nVersion=%d,index=%d,fee=%d.%08d,requestedHeight=%d,quorumHash=%d,quorumSig=%s",
             nVersion, index, fee / COIN, fee % COIN, requestedHeight, quorumHash.GetHex(), quorumSig.ToString().c_str());
 }
-
-uint8_t CAssetUnlockPayload::getVersion() const
-{
-    return nVersion;
-}
-
-uint64_t CAssetUnlockPayload::getIndex() const
-{
-    return index;
-}
-
-uint32_t CAssetUnlockPayload::getFee() const
-{
-    return fee;
-}
-
-uint32_t CAssetUnlockPayload::getRequestedHeight() const
-{
-    return requestedHeight;
-}
-
-const uint256& CAssetUnlockPayload::getQuorumHash() const
-{
-    return quorumHash;
-}
-
-const CBLSSignature& CAssetUnlockPayload::getQuorumSig() const
-{
-    return quorumSig;
-}
-
-int CAssetUnlockPayload::getHeightToExpiry() const
-{
-    return requestedHeight + HEIGHT_DIFF_EXPIRING;
-}
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 939f6d9960939..34e409daa2d1d 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -58,8 +58,15 @@ class CAssetLockPayload
     }
 
     // getters
-    uint8_t getVersion() const;
-    const std::vector<CTxOut>& getCreditOutputs() const;
+    uint8_t getVersion() const
+    {
+        return nVersion;
+    }
+
+    const std::vector<CTxOut>& getCreditOutputs() const
+    {
+        return creditOutputs;
+    }
 };
 
 class CAssetUnlockPayload
@@ -120,16 +127,42 @@ class CAssetUnlockPayload
     bool VerifySig(const uint256& msgHash, const CBlockIndex* pindexTip, TxValidationState& state) const;
 
     // getters
-    uint8_t getVersion() const;
-    uint64_t getIndex() const;
-    uint32_t getFee() const;
-    uint32_t getRequestedHeight() const;
-    const uint256& getQuorumHash() const;
-    const CBLSSignature& getQuorumSig() const;
+    uint8_t getVersion() const
+    {
+        return nVersion;
+    }
+
+    uint64_t getIndex() const
+    {
+        return index;
+    }
+
+    uint32_t getFee() const
+    {
+        return fee;
+    }
+
+    uint32_t getRequestedHeight() const
+    {
+        return requestedHeight;
+    }
+
+    const uint256& getQuorumHash() const
+    {
+        return quorumHash;
+    }
+
+    const CBLSSignature& getQuorumSig() const
+    {
+        return quorumSig;
+    }
 
     // used by mempool to know when possible to drop a transaction as expired
-    int getHeightToExpiry() const;
     static constexpr int HEIGHT_DIFF_EXPIRING = 48;
+    int getHeightToExpiry() const
+    {
+        return requestedHeight + HEIGHT_DIFF_EXPIRING;
+    }
 };
 
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);

From 23fc477d66a99a8a5ea540bd4dbed1a504d46840 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 14 Jul 2023 00:49:59 +0700
Subject: [PATCH 29/37] refactor: moved CSkipSet from CreditPool.h to separate
 file

---
 src/Makefile.am                   |  2 ++
 src/evo/assetlocktx.cpp           |  1 +
 src/evo/creditpool.cpp            | 42 --------------------------
 src/evo/creditpool.h              | 44 +++------------------------
 src/test/evo_assetlocks_tests.cpp | 31 +------------------
 src/test/util_tests.cpp           | 28 +++++++++++++++++
 src/util/skip_set.cpp             | 50 +++++++++++++++++++++++++++++++
 src/util/skip_set.h               | 44 +++++++++++++++++++++++++++
 8 files changed, 130 insertions(+), 112 deletions(-)
 create mode 100644 src/util/skip_set.cpp
 create mode 100644 src/util/skip_set.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 2bb600f89ef90..ee32ddc5ed64c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -322,6 +322,7 @@ BITCOIN_CORE_H = \
   util/underlying.h \
   util/serfloat.h \
   util/settings.h \
+  util/skip_set.h \
   util/sock.h \
   util/string.h \
   util/time.h \
@@ -735,6 +736,7 @@ libbitcoin_util_a_SOURCES = \
   util/message.cpp \
   util/moneystr.cpp \
   util/settings.cpp \
+  util/skip_set.cpp \
   util/spanparsing.cpp \
   util/strencodings.cpp \
   util/time.cpp \
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 79cc1c7e0fd6d..0727628d7ef43 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -9,6 +9,7 @@
 #include <consensus/params.h>
 
 #include <chainparams.h>
+#include <logging.h>
 #include <validation.h>
 
 #include <llmq/commitment.h>
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 353f746f56263..6bafd07d7e33c 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -67,48 +67,6 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
     return blockData;
 }
 
-bool CSkipSet::add(uint64_t value)
-{
-    assert(!contains(value));
-
-    if (auto it = skipped.find(value); it != skipped.end()) {
-        skipped.erase(it);
-        return true;
-    }
-
-    assert(current_max <= value);
-    if (capacity() + value - current_max > capacity_limit) {
-        LogPrintf("CSkipSet::add failed due to capacity exceeded: requested %lld to %lld while limit is %lld\n",
-                value - current_max, capacity(), capacity_limit);
-        return false;
-    }
-    for (uint64_t index = current_max; index < value; ++index) {
-        bool insert_ret = skipped.insert(index).second;
-        assert(insert_ret);
-    }
-    current_max = value + 1;
-    return true;
-}
-
-bool CSkipSet::canBeAdded(uint64_t value) const
-{
-    if (contains(value)) return false;
-
-    if (skipped.find(value) != skipped.end()) return true;
-
-    if (capacity() + value - current_max > capacity_limit) {
-        return false;
-    }
-
-    return true;
-}
-
-bool CSkipSet::contains(uint64_t value) const
-{
-    if (current_max <= value) return false;
-    return skipped.find(value) == skipped.end();
-}
-
 std::string CCreditPool::ToString() const
 {
     return strprintf("CCreditPool(locked=%lld, currentLimit=%lld, nIndexes=%lld)",
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index 5edae81b8c94d..28185e55755a3 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -10,15 +10,16 @@
 #include <evo/assetlocktx.h>
 #include <evo/evodb.h>
 
+#include <saltedhasher.h>
+#include <serialize.h>
 #include <sync.h>
 #include <threadsafety.h>
+#include <unordered_lru_cache.h>
+#include <util/skip_set.h>
 
 #include <optional>
 #include <unordered_set>
 
-#include <saltedhasher.h>
-#include <unordered_lru_cache.h>
-
 class CBlockIndex;
 class TxValidationState;
 
@@ -27,43 +28,6 @@ namespace Consensus
     struct Params;
 }
 
-// This datastructure keeps efficiently all indexes and have a strict limit for used memory
-// So far as CCreditPool is built only in direction from parent block to child
-// there's no need to remove elements from CSkipSet ever, only add them
-class CSkipSet {
-private:
-    std::unordered_set<uint64_t> skipped;
-    uint64_t current_max{0};
-    size_t capacity_limit;
-public:
-    explicit CSkipSet(size_t capacity_limit = 10'000) :
-        capacity_limit(capacity_limit)
-    {}
-
-    /**
-     * adding value that already exist in CKipSet will cause `assert`.
-     *
-     */
-    [[nodiscard]] bool add(uint64_t value);
-
-    bool canBeAdded(uint64_t value) const;
-
-    bool contains(uint64_t value) const;
-
-    size_t size() const {
-        return current_max - skipped.size();
-    }
-    size_t capacity() const {
-        return skipped.size();
-    }
-
-    SERIALIZE_METHODS(CSkipSet, obj)
-    {
-        READWRITE(obj.current_max);
-        READWRITE(obj.skipped);
-    }
-};
-
 struct CCreditPool {
     CAmount locked{0};
 
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index b2c11df9f0bc5..555e275891d48 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -7,7 +7,7 @@
 #include <amount.h>
 #include <consensus/tx_check.h>
 #include <evo/assetlocktx.h>
-#include <evo/creditpool.h> // to test CSkipSet
+#include <evo/creditpool.h>
 #include <policy/settings.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
@@ -15,9 +15,6 @@
 
 #include <boost/test/unit_test.hpp>
 
-#include <random>
-#include <unordered_set>
-
 //
 // Helper: create two dummy transactions, each with
 // two outputs.  The first has 11 and 50 CENT outputs
@@ -398,30 +395,4 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 
 }
 
-BOOST_FIXTURE_TEST_CASE(evo_skipset, BasicTestingSetup)
-{
-    std::mt19937 gen;
-    for (size_t test = 0; test < 17; ++test) {
-        std::uniform_int_distribution<uint64_t> dist_value(0, (1 << test));
-        size_t skip_size = test ? (1 << (test - 1)) : 1;
-        CSkipSet set_1{skip_size};
-        std::unordered_set<uint64_t> set_2;
-        for (size_t iter = 0; iter < (1 << test) * 2; ++iter) {
-            uint64_t value = dist_value(gen);
-            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
-            if (!set_1.contains(value) && set_1.canBeAdded(value)) {
-                BOOST_CHECK(!set_1.contains(value));
-                BOOST_CHECK(set_1.add(value));
-                set_2.insert(value);
-            }
-            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
-            BOOST_CHECK(set_1.size() == set_2.size());
-        }
-        if (test > 4) {
-            BOOST_CHECK(set_1.size() > ((1 << test) / 4));
-        }
-    }
-}
-
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 24c2db2e71b2e..617d077272f08 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -15,6 +15,7 @@
 #include <util/getuniquepath.h>
 #include <util/message.h> // For MessageSign(), MessageVerify(), MESSAGE_MAGIC
 #include <util/moneystr.h>
+#include <util/skip_set.h>
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/string.h>
@@ -23,10 +24,12 @@
 
 #include <array>
 #include <optional>
+#include <random>
 #include <stdint.h>
 #include <string.h>
 #include <thread>
 #include <univalue.h>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 #ifndef WIN32
@@ -2160,6 +2163,31 @@ BOOST_AUTO_TEST_CASE(test_Capitalize)
     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
+BOOST_AUTO_TEST_CASE(test_SkipSet)
+{
+    std::mt19937 gen;
+    for (size_t test = 0; test < 17; ++test) {
+        std::uniform_int_distribution<uint64_t> dist_value(0, (1 << test));
+        size_t skip_size = test ? (1 << (test - 1)) : 1;
+        CSkipSet set_1{skip_size};
+        std::unordered_set<uint64_t> set_2;
+        for (size_t iter = 0; iter < (1 << test) * 2; ++iter) {
+            uint64_t value = dist_value(gen);
+            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
+            if (!set_1.contains(value) && set_1.canBeAdded(value)) {
+                BOOST_CHECK(!set_1.contains(value));
+                BOOST_CHECK(set_1.add(value));
+                set_2.insert(value);
+            }
+            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
+            BOOST_CHECK(set_1.size() == set_2.size());
+        }
+        if (test > 4) {
+            BOOST_CHECK(set_1.size() > ((1 << test) / 4));
+        }
+    }
+}
+
 static std::string SpanToStr(const Span<const char>& span)
 {
     return std::string(span.begin(), span.end());
diff --git a/src/util/skip_set.cpp b/src/util/skip_set.cpp
new file mode 100644
index 0000000000000..b666d449c7153
--- /dev/null
+++ b/src/util/skip_set.cpp
@@ -0,0 +1,50 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util/skip_set.h>
+
+#include <logging.h>
+
+bool CSkipSet::add(uint64_t value)
+{
+    assert(!contains(value));
+
+    if (auto it = skipped.find(value); it != skipped.end()) {
+        skipped.erase(it);
+        return true;
+    }
+
+    assert(current_max <= value);
+    if (capacity() + value - current_max > capacity_limit) {
+        LogPrintf("CSkipSet::add failed due to capacity exceeded: requested %lld to %lld while limit is %lld\n",
+                value - current_max, capacity(), capacity_limit);
+        return false;
+    }
+    for (uint64_t index = current_max; index < value; ++index) {
+        bool insert_ret = skipped.insert(index).second;
+        assert(insert_ret);
+    }
+    current_max = value + 1;
+    return true;
+}
+
+bool CSkipSet::canBeAdded(uint64_t value) const
+{
+    if (contains(value)) return false;
+
+    if (skipped.find(value) != skipped.end()) return true;
+
+    if (capacity() + value - current_max > capacity_limit) {
+        return false;
+    }
+
+    return true;
+}
+
+bool CSkipSet::contains(uint64_t value) const
+{
+    if (current_max <= value) return false;
+    return skipped.find(value) == skipped.end();
+}
+
diff --git a/src/util/skip_set.h b/src/util/skip_set.h
new file mode 100644
index 0000000000000..1c03f98bbb249
--- /dev/null
+++ b/src/util/skip_set.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <serialize.h>
+#include <unordered_set>
+
+// This datastructure keeps efficiently all indexes and have a strict limit for used memory
+// So far as CCreditPool is built only in direction from parent block to child
+// there's no need to remove elements from CSkipSet ever, only add them
+class CSkipSet {
+private:
+    std::unordered_set<uint64_t> skipped;
+    uint64_t current_max{0};
+    size_t capacity_limit;
+public:
+    explicit CSkipSet(size_t capacity_limit = 10'000) :
+        capacity_limit(capacity_limit)
+    {}
+
+    /**
+     * adding value that already exist in CKipSet will cause `assert`.
+     *
+     */
+    [[nodiscard]] bool add(uint64_t value);
+
+    bool canBeAdded(uint64_t value) const;
+
+    bool contains(uint64_t value) const;
+
+    size_t size() const {
+        return current_max - skipped.size();
+    }
+    size_t capacity() const {
+        return skipped.size();
+    }
+
+    SERIALIZE_METHODS(CSkipSet, obj)
+    {
+        READWRITE(obj.current_max);
+        READWRITE(obj.skipped);
+    }
+};
+

From 95b8d196c47af85ea38b4d97a01e4296a08c3658 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 13 Jul 2023 22:02:19 +0700
Subject: [PATCH 30/37] fix: code-style adjusting for methods naming in credit
 pool and related classes

---
 src/evo/assetlocktx.cpp  |  2 +-
 src/evo/creditpool.cpp   | 62 ++++++++++++++++++++--------------------
 src/evo/creditpool.h     | 24 ++++++++--------
 src/evo/specialtxman.cpp |  8 +++---
 src/miner.cpp            |  6 ++--
 src/rpc/evo.cpp          |  2 +-
 src/test/util_tests.cpp  | 14 ++++-----
 src/util/skip_set.cpp    | 18 ++++++------
 src/util/skip_set.h      | 10 +++----
 src/validation.cpp       |  2 +-
 10 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 0727628d7ef43..1dc3e17bffa0e 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -165,7 +165,7 @@ bool CheckAssetUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, c
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version");
     }
 
-    if (creditPool.indexes.contains(assetUnlockTx.getIndex())) {
+    if (creditPool.indexes.Contains(assetUnlockTx.getIndex())) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-duplicated-index");
     }
 
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 6bafd07d7e33c..5d8efa63202f8 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -22,7 +22,7 @@ static const std::string DB_CREDITPOOL_SNAPSHOT = "cpm_S";
 
 std::unique_ptr<CCreditPoolManager> creditPoolManager;
 
-static bool getDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint64_t& index, TxValidationState& state)
+static bool GetDataFromUnlockTx(const CTransaction& tx, CAmount& toUnlock, uint64_t& index, TxValidationState& state)
 {
     CAssetUnlockPayload assetUnlockTx;
     if (!GetTxPayload(tx, assetUnlockTx)) {
@@ -48,7 +48,7 @@ namespace {
 } // anonymous namespace
 
 // it throws exception if anything went wrong
-static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRef>& vtx)
+static UnlockDataPerBlock GetDataFromUnlockTxes(const std::vector<CTransactionRef>& vtx)
 {
     UnlockDataPerBlock blockData;
 
@@ -58,8 +58,8 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
         CAmount unlocked{0};
         TxValidationState tx_state;
         uint64_t index{0};
-        if (!getDataFromUnlockTx(*tx, unlocked, index, tx_state)) {
-            throw std::runtime_error(strprintf("%s: CCreditPoolManager::getDataFromUnlockTx failed: %s", __func__, tx_state.ToString()));
+        if (!GetDataFromUnlockTx(*tx, unlocked, index, tx_state)) {
+            throw std::runtime_error(strprintf("%s: CCreditPoolManager::GetDataFromUnlockTxes failed: %s", __func__, tx_state.ToString()));
         }
         blockData.unlocked += unlocked;
         blockData.indexes.insert(index);
@@ -70,10 +70,10 @@ static UnlockDataPerBlock getDataFromUnlockTxes(const std::vector<CTransactionRe
 std::string CCreditPool::ToString() const
 {
     return strprintf("CCreditPool(locked=%lld, currentLimit=%lld, nIndexes=%lld)",
-            locked, currentLimit, indexes.size());
+            locked, currentLimit, indexes.Size());
 }
 
-std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* const block_index)
+std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex* const block_index)
 {
     if (!llmq::utils::IsV20Active(block_index)) return CCreditPool{};
 
@@ -95,7 +95,7 @@ std::optional<CCreditPool> CCreditPoolManager::getFromCache(const CBlockIndex* c
     return std::nullopt;
 }
 
-void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const CCreditPool &pool)
+void CCreditPoolManager::AddToCache(const uint256& block_hash, int height, const CCreditPool &pool)
 {
     {
         LOCK(cache_mutex);
@@ -106,7 +106,7 @@ void CCreditPoolManager::addToCache(const uint256& block_hash, int height, const
     }
 }
 
-static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex* const block_index, const Consensus::Params& consensusParams)
+static std::optional<CBlock> GetBlockForCreditPool(const CBlockIndex* const block_index, const Consensus::Params& consensusParams)
 {
     CBlock block;
     if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
@@ -122,17 +122,17 @@ static std::optional<CBlock> getBlockForCreditPool(const CBlockIndex* const bloc
     return block;
 }
 
-CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const block_index, CCreditPool prev, const Consensus::Params& consensusParams)
+CCreditPool CCreditPoolManager::ConstructCreditPool(const CBlockIndex* const block_index, CCreditPool prev, const Consensus::Params& consensusParams)
 {
-    std::optional<CBlock> block = getBlockForCreditPool(block_index, consensusParams);
+    std::optional<CBlock> block = GetBlockForCreditPool(block_index, consensusParams);
     if (!block) {
         // If reading of previous block is not read successfully, but
         // prev contains credit pool related data, something strange happened
         assert(prev.locked == 0);
-        assert(prev.indexes.size() == 0);
+        assert(prev.indexes.Size() == 0);
 
         CCreditPool emptyPool;
-        addToCache(block_index->GetBlockHash(), block_index->nHeight, emptyPool);
+        AddToCache(block_index->GetBlockHash(), block_index->nHeight, emptyPool);
         return emptyPool;
     }
     CAmount locked{0};
@@ -148,9 +148,9 @@ CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const blo
     // current limits for asset unlock transactions.
     // Indexes should not be duplicated since genesis block, but the Unlock Amount
     // of withdrawal transaction is limited only by this window
-    UnlockDataPerBlock blockData = getDataFromUnlockTxes(block->vtx);
+    UnlockDataPerBlock blockData = GetDataFromUnlockTxes(block->vtx);
     CSkipSet indexes{std::move(prev.indexes)};
-    if (std::any_of(blockData.indexes.begin(), blockData.indexes.end(), [&](const uint64_t index) { return !indexes.add(index); })) {
+    if (std::any_of(blockData.indexes.begin(), blockData.indexes.end(), [&](const uint64_t index) { return !indexes.Add(index); })) {
         throw std::runtime_error(strprintf("%s: failed-getcreditpool-index-exceed", __func__));
     }
 
@@ -161,8 +161,8 @@ CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const blo
     }
     CAmount distantUnlocked{0};
     if (distant_block_index) {
-        if (std::optional<CBlock> distant_block = getBlockForCreditPool(distant_block_index, consensusParams); distant_block) {
-            distantUnlocked = getDataFromUnlockTxes(distant_block->vtx).unlocked;
+        if (std::optional<CBlock> distant_block = GetBlockForCreditPool(distant_block_index, consensusParams); distant_block) {
+            distantUnlocked = GetDataFromUnlockTxes(distant_block->vtx).unlocked;
         }
     }
 
@@ -184,22 +184,22 @@ CCreditPool CCreditPoolManager::constructCreditPool(const CBlockIndex* const blo
     }
 
     CCreditPool pool{locked, currentLimit, latelyUnlocked, indexes};
-    addToCache(block_index->GetBlockHash(), block_index->nHeight, pool);
+    AddToCache(block_index->GetBlockHash(), block_index->nHeight, pool);
     return pool;
 
 }
 
-CCreditPool CCreditPoolManager::getCreditPool(const CBlockIndex* block_index, const Consensus::Params& consensusParams)
+CCreditPool CCreditPoolManager::GetCreditPool(const CBlockIndex* block_index, const Consensus::Params& consensusParams)
 {
     std::stack<const CBlockIndex *> to_calculate;
 
     std::optional<CCreditPool> poolTmp;
-    while (!(poolTmp = getFromCache(block_index)).has_value()) {
+    while (!(poolTmp = GetFromCache(block_index)).has_value()) {
         to_calculate.push(block_index);
         block_index = block_index->pprev;
     }
     while (!to_calculate.empty()) {
-        poolTmp = constructCreditPool(to_calculate.top(), *poolTmp, consensusParams);
+        poolTmp = ConstructCreditPool(to_calculate.top(), *poolTmp, consensusParams);
         to_calculate.pop();
     }
     return *poolTmp;
@@ -217,7 +217,7 @@ CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex,
     assert(pindex);
 }
 
-bool CCreditPoolDiff::setTarget(const CTransaction& tx, TxValidationState& state)
+bool CCreditPoolDiff::SetTarget(const CTransaction& tx, TxValidationState& state)
 {
     CCbTx cbTx;
     if (!GetTxPayload(tx, cbTx)) {
@@ -230,7 +230,7 @@ bool CCreditPoolDiff::setTarget(const CTransaction& tx, TxValidationState& state
     return true;
 }
 
-bool CCreditPoolDiff::lock(const CTransaction& tx, TxValidationState& state)
+bool CCreditPoolDiff::Lock(const CTransaction& tx, TxValidationState& state)
 {
     CAssetLockPayload assetLockTx;
     if (!GetTxPayload(tx, assetLockTx)) {
@@ -248,12 +248,12 @@ bool CCreditPoolDiff::lock(const CTransaction& tx, TxValidationState& state)
     return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-lock-invalid");
 }
 
-bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
+bool CCreditPoolDiff::Unlock(const CTransaction& tx, TxValidationState& state)
 {
     uint64_t index{0};
     CAmount toUnlock{0};
-    if (!getDataFromUnlockTx(tx, toUnlock, index, state)) {
-        // state is set up inside getDataFromUnlockTx
+    if (!GetDataFromUnlockTx(tx, toUnlock, index, state)) {
+        // state is set up inside GetDataFromUnlockTx
         return false;
     }
 
@@ -261,11 +261,11 @@ bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-too-much");
     }
 
-    if (pool.indexes.contains(index) || newIndexes.count(index)) {
+    if (pool.indexes.Contains(index) || newIndexes.count(index)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-duplicated-index");
     }
 
-    if (!pool.indexes.canBeAdded(index)) {
+    if (!pool.indexes.CanBeAdded(index)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-creditpool-unlock-cant-add");
     }
 
@@ -274,10 +274,10 @@ bool CCreditPoolDiff::unlock(const CTransaction& tx, TxValidationState& state)
     return true;
 }
 
-bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationState& state)
+bool CCreditPoolDiff::ProcessTransaction(const CTransaction& tx, TxValidationState& state)
 {
     if (tx.nVersion != 3) return true;
-    if (tx.nType == TRANSACTION_COINBASE) return setTarget(tx, state);
+    if (tx.nType == TRANSACTION_COINBASE) return SetTarget(tx, state);
 
     if (tx.nType != TRANSACTION_ASSET_LOCK && tx.nType != TRANSACTION_ASSET_UNLOCK) return true;
 
@@ -289,9 +289,9 @@ bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationSta
     try {
         switch (tx.nType) {
         case TRANSACTION_ASSET_LOCK:
-            return lock(tx, state);
+            return Lock(tx, state);
         case TRANSACTION_ASSET_UNLOCK:
-            return unlock(tx, state);
+            return Unlock(tx, state);
         default:
             return true;
         }
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index 28185e55755a3..80015668e2d8a 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -80,24 +80,24 @@ class CCreditPoolDiff {
      * to change amount of credit pool
      * @return true if transaction can be included in this block
      */
-    bool processTransaction(const CTransaction& tx, TxValidationState& state);
+    bool ProcessTransaction(const CTransaction& tx, TxValidationState& state);
 
-    CAmount getTotalLocked() const {
+    CAmount GetTotalLocked() const {
         return pool.locked + sessionLocked - sessionUnlocked;
     }
 
-    const std::optional<CAmount>& getTargetLocked() const {
+    const std::optional<CAmount>& GetTargetLocked() const {
         return targetLocked;
     }
 
     std::string ToString() const {
-        return strprintf("CCreditPoolDiff(target=%lld, sessionLocked=%lld, sessionUnlocked=%lld, newIndexes=%lld, pool=%s)", getTargetLocked() ? *getTargetLocked() : -1, sessionLocked, sessionUnlocked, newIndexes.size(), pool.ToString());
+        return strprintf("CCreditPoolDiff(target=%lld, sessionLocked=%lld, sessionUnlocked=%lld, newIndexes=%lld, pool=%s)", GetTargetLocked() ? *GetTargetLocked() : -1, sessionLocked, sessionUnlocked, newIndexes.size(), pool.ToString());
     }
 
 private:
-    bool setTarget(const CTransaction& tx, TxValidationState& state);
-    bool lock(const CTransaction& tx, TxValidationState& state);
-    bool unlock(const CTransaction& tx, TxValidationState& state);
+    bool SetTarget(const CTransaction& tx, TxValidationState& state);
+    bool Lock(const CTransaction& tx, TxValidationState& state);
+    bool Unlock(const CTransaction& tx, TxValidationState& state);
 };
 
 class CCreditPoolManager
@@ -122,16 +122,16 @@ class CCreditPoolManager
 
     /**
       * @return CCreditPool with data or with empty depends on activation V19 at that block
-      * In case if block is invalid the function getCreditPool throws an exception
+      * In case if block is invalid the function GetCreditPool throws an exception
       * it can happen if there limits of withdrawal (unlock) exceed
       */
-    CCreditPool getCreditPool(const CBlockIndex* block, const Consensus::Params& consensusParams);
+    CCreditPool GetCreditPool(const CBlockIndex* block, const Consensus::Params& consensusParams);
 
 private:
-    std::optional<CCreditPool> getFromCache(const CBlockIndex* const block_index);
-    void addToCache(const uint256& block_hash, int height, const CCreditPool& pool);
+    std::optional<CCreditPool> GetFromCache(const CBlockIndex* const block_index);
+    void AddToCache(const uint256& block_hash, int height, const CCreditPool& pool);
 
-    CCreditPool constructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams);
+    CCreditPool ConstructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams);
 };
 
 extern std::unique_ptr<CCreditPoolManager> creditPoolManager;
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 5d6fb06624dfe..c06dd38d01a18 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -128,7 +128,7 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
 
         int64_t nTime1 = GetTimeMicros();
 
-        const CCreditPool creditPool = creditPoolManager->getCreditPool(pindex->pprev, consensusParams);
+        const CCreditPool creditPool = creditPoolManager->GetCreditPool(pindex->pprev, consensusParams);
         std::optional<CCreditPoolDiff> creditPoolDiff;
         if (bool fV20Active_context = llmq::utils::IsV20Active(pindex->pprev); fV20Active_context) {
             LogPrintf("%s: CCreditPool is %s\n", __func__, creditPool.ToString());
@@ -149,7 +149,7 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
             }
-            if (creditPoolDiff != std::nullopt && !creditPoolDiff->processTransaction(*ptr_tx, tx_state)) {
+            if (creditPoolDiff != std::nullopt && !creditPoolDiff->ProcessTransaction(*ptr_tx, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed at Credit Pool (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -159,9 +159,9 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
         }
         if (creditPoolDiff != std::nullopt) {
             CAmount locked_proposed{0};
-            if(creditPoolDiff->getTargetLocked()) locked_proposed = *creditPoolDiff->getTargetLocked();
+            if(creditPoolDiff->GetTargetLocked()) locked_proposed = *creditPoolDiff->GetTargetLocked();
 
-            CAmount locked_calculated = creditPoolDiff->getTotalLocked();
+            CAmount locked_calculated = creditPoolDiff->GetTotalLocked();
             if (locked_proposed != locked_calculated) {
                 LogPrintf("%s: mismatched locked amount in CbTx: %lld against re-calculated: %lld\n", __func__, locked_proposed, locked_calculated);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cbtx-assetlocked-amount");
diff --git a/src/miner.cpp b/src/miner.cpp
index 854d000d1d4c5..633238bfa91c5 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -171,7 +171,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     std::optional<CCreditPoolDiff> creditPoolDiff;
     if (fV20Active_context) {
-        CCreditPool creditPool = creditPoolManager->getCreditPool(pindexPrev, chainparams.GetConsensus());
+        CCreditPool creditPool = creditPoolManager->GetCreditPool(pindexPrev, chainparams.GetConsensus());
         LogPrintf("%s: CCreditPool is %s\n", __func__, creditPool.ToString());
         creditPoolDiff.emplace(std::move(creditPool), pindexPrev, chainparams.GetConsensus());
     }
@@ -232,7 +232,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                     LogPrintf("CreateNewBlock() h[%d] CbTx failed to find best CL. Inserting null CL\n", nHeight);
                 }
                 assert(creditPoolDiff != std::nullopt);
-                cbTx.assetLockedAmount = creditPoolDiff->getTotalLocked();
+                cbTx.assetLockedAmount = creditPoolDiff->GetTotalLocked();
             }
         }
 
@@ -456,7 +456,7 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
             // `state` is local here because used to log info about this specific tx
             TxValidationState state;
 
-            if (!creditPoolDiff->processTransaction(iter->GetTx(), state)) {
+            if (!creditPoolDiff->ProcessTransaction(iter->GetTx(), state)) {
                 if (fUsingModified) {
                     mapModifiedTx.get<ancestor_score>().erase(modit);
                     failedTx.insert(iter);
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 34f65f8b5296b..5eb6aa30eae2e 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -329,7 +329,7 @@ static std::string SignAndSendSpecialTx(const JSONRPCRequest& request, const CMu
     {
     LOCK(cs_main);
 
-    CCreditPool creditPool = creditPoolManager->getCreditPool(::ChainActive().Tip(), Params().GetConsensus());
+    CCreditPool creditPool = creditPoolManager->GetCreditPool(::ChainActive().Tip(), Params().GetConsensus());
 
     TxValidationState state;
     if (!CheckSpecialTx(CTransaction(tx), ::ChainActive().Tip(), ::ChainstateActive().CoinsTip(), creditPool, true, state)) {
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 617d077272f08..2b9cb2f97646b 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -2173,17 +2173,17 @@ BOOST_AUTO_TEST_CASE(test_SkipSet)
         std::unordered_set<uint64_t> set_2;
         for (size_t iter = 0; iter < (1 << test) * 2; ++iter) {
             uint64_t value = dist_value(gen);
-            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
-            if (!set_1.contains(value) && set_1.canBeAdded(value)) {
-                BOOST_CHECK(!set_1.contains(value));
-                BOOST_CHECK(set_1.add(value));
+            BOOST_CHECK(set_1.Contains(value) == !!set_2.count(value));
+            if (!set_1.Contains(value) && set_1.CanBeAdded(value)) {
+                BOOST_CHECK(!set_1.Contains(value));
+                BOOST_CHECK(set_1.Add(value));
                 set_2.insert(value);
             }
-            BOOST_CHECK(set_1.contains(value) == !!set_2.count(value));
-            BOOST_CHECK(set_1.size() == set_2.size());
+            BOOST_CHECK(set_1.Contains(value) == !!set_2.count(value));
+            BOOST_CHECK(set_1.Size() == set_2.size());
         }
         if (test > 4) {
-            BOOST_CHECK(set_1.size() > ((1 << test) / 4));
+            BOOST_CHECK(set_1.Size() > ((1 << test) / 4));
         }
     }
 }
diff --git a/src/util/skip_set.cpp b/src/util/skip_set.cpp
index b666d449c7153..e77cec7576e11 100644
--- a/src/util/skip_set.cpp
+++ b/src/util/skip_set.cpp
@@ -6,9 +6,9 @@
 
 #include <logging.h>
 
-bool CSkipSet::add(uint64_t value)
+bool CSkipSet::Add(uint64_t value)
 {
-    assert(!contains(value));
+    assert(!Contains(value));
 
     if (auto it = skipped.find(value); it != skipped.end()) {
         skipped.erase(it);
@@ -16,9 +16,9 @@ bool CSkipSet::add(uint64_t value)
     }
 
     assert(current_max <= value);
-    if (capacity() + value - current_max > capacity_limit) {
-        LogPrintf("CSkipSet::add failed due to capacity exceeded: requested %lld to %lld while limit is %lld\n",
-                value - current_max, capacity(), capacity_limit);
+    if (Capacity() + value - current_max > capacity_limit) {
+        LogPrintf("CSkipSet::Add failed due to capacity exceeded: requested %lld to %lld while limit is %lld\n",
+                value - current_max, Capacity(), capacity_limit);
         return false;
     }
     for (uint64_t index = current_max; index < value; ++index) {
@@ -29,20 +29,20 @@ bool CSkipSet::add(uint64_t value)
     return true;
 }
 
-bool CSkipSet::canBeAdded(uint64_t value) const
+bool CSkipSet::CanBeAdded(uint64_t value) const
 {
-    if (contains(value)) return false;
+    if (Contains(value)) return false;
 
     if (skipped.find(value) != skipped.end()) return true;
 
-    if (capacity() + value - current_max > capacity_limit) {
+    if (Capacity() + value - current_max > capacity_limit) {
         return false;
     }
 
     return true;
 }
 
-bool CSkipSet::contains(uint64_t value) const
+bool CSkipSet::Contains(uint64_t value) const
 {
     if (current_max <= value) return false;
     return skipped.find(value) == skipped.end();
diff --git a/src/util/skip_set.h b/src/util/skip_set.h
index 1c03f98bbb249..8f2d29ee45c4f 100644
--- a/src/util/skip_set.h
+++ b/src/util/skip_set.h
@@ -22,16 +22,16 @@ class CSkipSet {
      * adding value that already exist in CKipSet will cause `assert`.
      *
      */
-    [[nodiscard]] bool add(uint64_t value);
+    [[nodiscard]] bool Add(uint64_t value);
 
-    bool canBeAdded(uint64_t value) const;
+    bool CanBeAdded(uint64_t value) const;
 
-    bool contains(uint64_t value) const;
+    bool Contains(uint64_t value) const;
 
-    size_t size() const {
+    size_t Size() const {
         return current_max - skipped.size();
     }
-    size_t capacity() const {
+    size_t Capacity() const {
         return skipped.size();
     }
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 8af54d6698899..dc8d914ff8500 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -710,7 +710,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
             }
         }
     }
-    CCreditPool creditPool = creditPoolManager->getCreditPool(::ChainActive().Tip(), chainparams.GetConsensus());
+    CCreditPool creditPool = creditPoolManager->GetCreditPool(::ChainActive().Tip(), chainparams.GetConsensus());
     LockPoints lp;
     m_view.SetBackend(m_viewmempool);
 

From 5d29b06271e9adca904ceb980ae689caa6c2b489 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 14 Jul 2023 23:48:33 +0700
Subject: [PATCH 31/37] fix: fixing typos and improving comments. Fixing error
 message for v20 non-active

---
 src/evo/assetlocktx.cpp  | 18 +++++++++---------
 src/evo/creditpool.cpp   |  4 ++--
 src/evo/specialtxman.cpp |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 1dc3e17bffa0e..de43590e60f3c 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -19,9 +19,9 @@
 
 #include <algorithm>
 
-/*
-   Common code for Asset Lock and Asset Unlock
-    */
+/**
+ *  Common code for Asset Lock and Asset Unlock
+ */
 bool CheckAssetLockUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCreditPool& creditPool, TxValidationState& state)
 {
     switch (tx.nType) {
@@ -34,9 +34,9 @@ bool CheckAssetLockUnlockTx(const CTransaction& tx, const CBlockIndex* pindexPre
     }
 }
 
-/*
-   Asset Lock Transaction
-   */
+/**
+ * Asset Lock Transaction
+ */
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
 {
     if (tx.nType != TRANSACTION_ASSET_LOCK) {
@@ -101,9 +101,9 @@ std::string CAssetLockPayload::ToString() const
     return strprintf("CAssetLockPayload(nVersion=%d,creditOutputs=%s)", nVersion, outputs.c_str());
 }
 
-/*
-   Asset Unlock Transaction (withdrawals)
-   */
+/**
+ * Asset Unlock Transaction (withdrawals)
+ */
 
 const std::string ASSETUNLOCK_REQUESTID_PREFIX = "plwdtx";
 
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 5d8efa63202f8..dda04ad8f112b 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -112,7 +112,7 @@ static std::optional<CBlock> GetBlockForCreditPool(const CBlockIndex* const bloc
     if (!ReadBlockFromDisk(block, block_index, consensusParams)) {
         throw std::runtime_error("failed-getcbforblock-read");
     }
-    // Should not fail if V20 (DIP0027) are active but it happens for Unit Tests
+    // Should not fail if V20 (DIP0027) is active but it happens for RegChain (unit tests)
     if (block.vtx[0]->nVersion != 3) return std::nullopt;
 
     assert(!block.vtx.empty());
@@ -126,7 +126,7 @@ CCreditPool CCreditPoolManager::ConstructCreditPool(const CBlockIndex* const blo
 {
     std::optional<CBlock> block = GetBlockForCreditPool(block_index, consensusParams);
     if (!block) {
-        // If reading of previous block is not read successfully, but
+        // If reading of previous block is not successfully, but
         // prev contains credit pool related data, something strange happened
         assert(prev.locked == 0);
         assert(prev.indexes.Size() == 0);
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index c06dd38d01a18..ca54b71749c3e 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -49,7 +49,7 @@ bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const
         case TRANSACTION_ASSET_LOCK:
         case TRANSACTION_ASSET_UNLOCK:
             if (!llmq::utils::IsV20Active(pindexPrev)) {
-                return state.Invalid(TxValidationResult::TX_CONSENSUS, "v20-not-active");
+                return state.Invalid(TxValidationResult::TX_CONSENSUS, "assetlocks-before-v20");
             }
             return CheckAssetLockUnlockTx(tx, pindexPrev, creditPool, state);
         }

From 2ea4251f0a6a776c808b651dc64320a6abf566f5 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Fri, 14 Jul 2023 23:49:34 +0700
Subject: [PATCH 32/37] fix: replaced an assert to an exception in CSkipSet
 inside Add

assert can be triggered if Add() is called without validation of SkipSet conditions
---
 src/util/skip_set.cpp | 5 ++++-
 src/util/skip_set.h   | 8 ++++++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/util/skip_set.cpp b/src/util/skip_set.cpp
index e77cec7576e11..8eb2ec2d7945c 100644
--- a/src/util/skip_set.cpp
+++ b/src/util/skip_set.cpp
@@ -5,10 +5,13 @@
 #include <util/skip_set.h>
 
 #include <logging.h>
+#include <stdexcept>
 
 bool CSkipSet::Add(uint64_t value)
 {
-    assert(!Contains(value));
+    if (Contains(value)) {
+        throw std::runtime_error(strprintf("%s: trying to add an element that can't be added", __func__));
+    }
 
     if (auto it = skipped.find(value); it != skipped.end()) {
         skipped.erase(it);
diff --git a/src/util/skip_set.h b/src/util/skip_set.h
index 8f2d29ee45c4f..f5b6b16dd2fa7 100644
--- a/src/util/skip_set.h
+++ b/src/util/skip_set.h
@@ -5,7 +5,7 @@
 #include <serialize.h>
 #include <unordered_set>
 
-// This datastructure keeps efficiently all indexes and have a strict limit for used memory
+// This data structure keeps efficiently all indexes and have a strict limit for used memory
 // So far as CCreditPool is built only in direction from parent block to child
 // there's no need to remove elements from CSkipSet ever, only add them
 class CSkipSet {
@@ -19,8 +19,12 @@ class CSkipSet {
     {}
 
     /**
-     * adding value that already exist in CKipSet will cause `assert`.
+     * `Add` returns true if element has been added correctly and false if
+     * capacity is depleted.
      *
+     * `Add` should not be called if the element has been already added.
+     * Use `Contains` to check if the element is here
+     * Adding existing value will cause an exception
      */
     [[nodiscard]] bool Add(uint64_t value);
 

From 54ae92d7b8c077b2da1a78ed326cfb9c933178d4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Sat, 15 Jul 2023 02:13:39 +0700
Subject: [PATCH 33/37] fix: add missing #define guards for skip_set

---
 src/util/skip_set.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/util/skip_set.h b/src/util/skip_set.h
index f5b6b16dd2fa7..56b935be6b537 100644
--- a/src/util/skip_set.h
+++ b/src/util/skip_set.h
@@ -2,6 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#ifndef BITCOIN_UTIL_SKIP_SET_H
+#define BITCOIN_UTIL_SKIP_SET_H
+
 #include <serialize.h>
 #include <unordered_set>
 
@@ -46,3 +49,4 @@ class CSkipSet {
     }
 };
 
+#endif // BITCOIN_UTIL_SKIP_SET_H

From 0e793c609584c70860e052a7514d8cce8193d65e Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 18 Jul 2023 13:44:26 +0700
Subject: [PATCH 34/37] fix: removed duplicated `return false` from
 src/evo/specialtxman.cpp

Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com>
---
 src/evo/specialtxman.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index ca54b71749c3e..0f361b19efd18 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -153,8 +153,6 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, ll
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Special Transaction failed at Credit Pool (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
-
-                return false;
             }
         }
         if (creditPoolDiff != std::nullopt) {

From 5534f645ac6bfcad0ddca5a44707a96d60ec26d5 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 19 Jul 2023 16:16:08 +0700
Subject: [PATCH 35/37] feat: check credit pool amount against all nodes in
 functional test

---
 test/functional/feature_asset_locks.py | 52 +++++++++++++++-----------
 1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 540945ba59c5d..a14b65f98e642 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -124,6 +124,15 @@ def get_credit_pool_amount(self, node=None, block_hash = None):
         block = node.getblock(block_hash)
         return int(COIN * block['cbTx']['assetLockedAmount'])
 
+    def validate_credit_pool_amount(self, block_hash = None, expected = None):
+        for node in self.nodes:
+            locked = self.get_credit_pool_amount(node, block_hash)
+            if expected is None:
+                expected = locked
+            else:
+                assert_equal(expected, locked)
+        return expected
+
     def check_mempool_size(self):
         assert_equal(self.nodes[0].getmempoolinfo()['size'], self.mempool_size)  # Must not change mempool state
 
@@ -221,20 +230,19 @@ def run_test(self):
         asset_lock_tx = self.create_assetlock(coin, locked_1, pubkey)
 
         self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True})
-        assert_equal(self.get_credit_pool_amount(), 0)
+        self.validate_credit_pool_amount(0)
         txid_in_block = self.send_tx(asset_lock_tx)
 
         self.sync_mempools()
-        assert_equal(self.get_credit_pool_amount(), 0)
+        self.validate_credit_pool_amount(0)
 
         node.generate(1)
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock")
         node.generate(12)
         self.sync_all()
 
-        assert_equal(self.get_credit_pool_amount(), locked_1)
-        assert_equal(self.get_credit_pool_amount(node=self.nodes[1]), locked_1)
+        self.validate_credit_pool_amount(locked_1)
 
         # tx is mined, let's get blockhash
         self.log.info("Invalidate block with asset lock tx...")
@@ -244,7 +252,7 @@ def run_test(self):
             assert_equal(self.get_credit_pool_amount(node=inode), 0)
         node.generate(3)
         self.sync_all()
-        assert_equal(self.get_credit_pool_amount(), 0)
+        self.validate_credit_pool_amount(0)
         self.log.info("Resubmit asset lock tx to new chain...")
         # NEW tx appears
         asset_lock_tx_2 = self.create_assetlock(coin, locked_2, pubkey)
@@ -252,15 +260,15 @@ def run_test(self):
         node.generate(1)
         self.sync_all()
 
-        assert_equal(self.get_credit_pool_amount(), locked_2)
+        self.validate_credit_pool_amount(locked_2)
 
         node.generate(3)
         self.sync_all()
-        assert_equal(self.get_credit_pool_amount(), locked_2)
+        self.validate_credit_pool_amount(locked_2)
         self.log.info("Reconsider old blocks...")
         for inode in self.nodes:
             inode.reconsiderblock(block_hash_1)
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         self.sync_all()
 
         self.log.info('Mine block with incorrect credit-poool value...')
@@ -269,7 +277,7 @@ def run_test(self):
 
         self.log.info("Mine a quorum...")
         self.mine_quorum()
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
 
         self.log.info("Testing asset unlock...")
         asset_unlock_tx_index_too_far = self.create_assetunlock(10001, COIN, pubkey)
@@ -282,7 +290,7 @@ def run_test(self):
         self.ensure_tx_is_not_mined(tx_too_far_index)
 
         self.log.info("Generating several txes by same quorum....")
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         asset_unlock_tx = self.create_assetunlock(101, COIN, pubkey)
         asset_unlock_tx_late = self.create_assetunlock(102, COIN, pubkey)
         asset_unlock_tx_too_late = self.create_assetunlock(103, COIN, pubkey)
@@ -301,7 +309,7 @@ def run_test(self):
         assert_equal(asset_unlock_tx_payload.quorumHash, int(self.mninfo[0].node.quorum("selectquorum", llmq_type_test, 'e6c7a809d79f78ea85b72d5df7e9bd592aecf151e679d6e976b74f053a7f9056')["quorumHash"], 16))
 
         self.send_tx(asset_unlock_tx)
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         self.log.info("Mining exactly 2 blocks to be sure that SkipSet lets far transaction appears in block")
         node.generate(1)
         self.sync_all()
@@ -323,20 +331,20 @@ def run_test(self):
             reason = "double index")
 
         self.log.info("Checking tx with too far index is mined too - it is not too far anymore...")
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.validate_credit_pool_amount(locked_1 - 2 * COIN)
         self.nodes[0].getrawtransaction(tx_too_far_index, 1)['blockhash']
 
         self.log.info("Mining next quorum to check tx 'asset_unlock_tx_late' is still valid...")
         self.mine_quorum()
         self.log.info("Checking credit pool amount is same...")
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.validate_credit_pool_amount(locked_1 - 2 * COIN)
         self.check_mempool_result(tx=asset_unlock_tx_late, result_expected={'allowed': True})
         self.log.info("Checking credit pool amount still is same...")
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 2 * COIN)
+        self.validate_credit_pool_amount(locked_1 - 2 * COIN)
         self.send_tx(asset_unlock_tx_late)
         node.generate(1)
         self.sync_all()
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
+        self.validate_credit_pool_amount(locked_1 - 3 * COIN)
 
         self.log.info("Generating many blocks to make quorum far behind (even still active)...")
         self.slowly_generate_batch(too_late_height - node.getblock(node.getbestblockhash())["height"] - 1)
@@ -356,12 +364,12 @@ def run_test(self):
         self.log.info("Test block invalidation with asset unlock tx...")
         for inode in self.nodes:
             inode.invalidateblock(block_asset_unlock)
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         self.slowly_generate_batch(50)
-        assert_equal(self.get_credit_pool_amount(), locked_1)
+        self.validate_credit_pool_amount(locked_1)
         for inode in self.nodes:
             inode.reconsiderblock(block_to_reconsider)
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
+        self.validate_credit_pool_amount(locked_1 - 3 * COIN)
 
         self.log.info("Forcibly mining asset_unlock_tx_too_late and ensure block is invalid...")
         self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum")
@@ -369,8 +377,8 @@ def run_test(self):
         node.generate(1)
         self.sync_all()
 
-        assert_equal(self.get_credit_pool_amount(), locked_1 - 3 * COIN)
-        assert_equal(self.get_credit_pool_amount(block_hash=block_hash_1), locked_1)
+        self.validate_credit_pool_amount(locked_1 - 3 * COIN)
+        self.validate_credit_pool_amount(block_hash=block_hash_1, expected=locked_1)
 
         self.log.info("Checking too big withdrawal... expected to not be mined")
         asset_unlock_tx_full = self.create_assetunlock(201, 1 + self.get_credit_pool_amount(), pubkey)
@@ -398,7 +406,7 @@ def run_test(self):
         self.log.info("Check txid_in_block was mined...")
         block = node.getblock(node.getbestblockhash())
         assert txid_in_block in block['tx']
-        assert_equal(self.get_credit_pool_amount(), 0)
+        self.validate_credit_pool_amount(0)
 
         self.log.info("After many blocks duplicated tx still should not be mined")
         self.send_tx(asset_unlock_tx_duplicate_index,

From dcd92622e7cd1ccd8aae45afd07e72da147768f9 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Wed, 19 Jul 2023 16:17:23 +0700
Subject: [PATCH 36/37] feat: add an extra node with wallet for asset locks
 function test

Now blocks mined and transaction are created by different nodes to be sure that transaction are relayed
---
 test/functional/feature_asset_locks.py | 73 +++++++++++++++-----------
 1 file changed, 42 insertions(+), 31 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index a14b65f98e642..8a8fb805a7be7 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -49,13 +49,13 @@
 
 class AssetLocksTest(DashTestFramework):
     def set_test_params(self):
-        self.set_dash_test_params(4, 3)
+        self.set_dash_test_params(5, 3)
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def create_assetlock(self, coin, amount, pubkey):
-        node = self.nodes[0]
+        node_wallet = self.nodes[0]
 
 
         inputs = [CTxIn(COutPoint(int(coin["txid"], 16), coin["vout"]))]
@@ -76,12 +76,13 @@ def create_assetlock(self, coin, amount, pubkey):
         lock_tx.nType = 8 # asset lock type
         lock_tx.vExtraPayload = lockTx_payload.serialize()
 
-        lock_tx = node.signrawtransactionwithwallet(lock_tx.serialize().hex())
+        lock_tx = node_wallet.signrawtransactionwithwallet(lock_tx.serialize().hex())
+        self.log.info(f"next tx: {lock_tx} payload: {lockTx_payload}")
         return FromHex(CTransaction(), lock_tx["hex"])
 
 
     def create_assetunlock(self, index, withdrawal, pubkey=None):
-        node = self.nodes[0]
+        node_wallet = self.nodes[0]
         mninfo = self.mninfo
         tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
 
@@ -89,7 +90,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         request_id_buf = ser_string(b"plwdtx") + struct.pack("<Q", index)
         request_id = hash256(request_id_buf)[::-1].hex()
 
-        height = node.getblockcount()
+        height = node_wallet.getblockcount()
         quorumHash = mninfo[0].node.quorum("selectquorum", llmq_type_test, request_id)["quorumHash"]
         unlockTx_payload = CAssetUnlockTx(
             version = 1,
@@ -115,7 +116,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         unlock_tx.vExtraPayload = unlockTx_payload.serialize()
         return unlock_tx
 
-    def get_credit_pool_amount(self, node=None, block_hash = None):
+    def get_credit_pool_amount(self, node = None, block_hash = None):
         if node is None:
             node = self.nodes[0]
 
@@ -124,9 +125,10 @@ def get_credit_pool_amount(self, node=None, block_hash = None):
         block = node.getblock(block_hash)
         return int(COIN * block['cbTx']['assetLockedAmount'])
 
-    def validate_credit_pool_amount(self, block_hash = None, expected = None):
+    def validate_credit_pool_amount(self, expected = None, block_hash = None):
         for node in self.nodes:
-            locked = self.get_credit_pool_amount(node, block_hash)
+            locked = self.get_credit_pool_amount(node=node, block_hash=block_hash)
+            self.log.info(f"validate: {locked}")
             if expected is None:
                 expected = locked
             else:
@@ -134,7 +136,9 @@ def validate_credit_pool_amount(self, block_hash = None, expected = None):
         return expected
 
     def check_mempool_size(self):
-        assert_equal(self.nodes[0].getmempoolinfo()['size'], self.mempool_size)  # Must not change mempool state
+        self.sync_mempools()
+        for node in self.nodes:
+            assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
 
     def check_mempool_result(self, result_expected, tx):
         """Wrapper to check result of testmempoolaccept on node_0's mempool"""
@@ -146,9 +150,9 @@ def check_mempool_result(self, result_expected, tx):
         self.check_mempool_size()
 
     def create_and_check_block(self, txes, expected_error = None):
-        node = self.nodes[0]
-        best_block_hash = node.getbestblockhash()
-        best_block = node.getblock(best_block_hash)
+        node_wallet = self.nodes[0]
+        best_block_hash = node_wallet.getbestblockhash()
+        best_block = node_wallet.getblock(best_block_hash)
         tip = int(best_block_hash, 16)
         height = best_block["height"] + 1
         block_time = best_block["time"] + 1
@@ -160,7 +164,7 @@ def create_and_check_block(self, txes, expected_error = None):
             block.vtx.append(tx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
-        result = node.submitblock(block.serialize().hex())
+        result = node_wallet.submitblock(block.serialize().hex())
         if result != expected_error:
             raise AssertionError('mining the block should have failed with error %s, but submitblock returned %s' % (expected_error, result))
 
@@ -176,16 +180,21 @@ def set_sporks(self):
 
     def ensure_tx_is_not_mined(self, tx_id):
         try:
-            self.nodes[0].gettransaction(tx_id)
+            for node in self.nodes:
+                node.gettransaction(tx_id)
             raise AssertionError("Transaction should not be mined")
         except JSONRPCException as e:
             assert "Invalid or non-wallet transaction id" in e.error['message']
 
+    def send_tx_simple(self, tx):
+        return self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
+
     def send_tx(self, tx, expected_error = None, reason = None):
         try:
             self.log.info(f"Send tx with expected_error:'{expected_error}'...")
-            tx_res = self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
+            tx_res = self.send_tx_simple(tx)
             if expected_error is None:
+                self.sync_mempools()
                 return tx_res
 
             # failure didn't happen, but expected:
@@ -204,11 +213,12 @@ def slowly_generate_batch(self, amount):
             next = min(10, amount)
             amount -= next
             self.bump_mocktime(next)
-            self.nodes[0].generate(next)
+            self.nodes[1].generate(next)
             self.sync_all()
 
     def run_test(self):
-        node = self.nodes[0]
+        node_wallet = self.nodes[0]
+        node = self.nodes[1]
 
         self.set_sporks()
         self.activate_v20()
@@ -223,7 +233,7 @@ def run_test(self):
         locked_1 = 10 * COIN + 141421
         locked_2 = 10 * COIN + 314159
 
-        coins = node.listunspent()
+        coins = node_wallet.listunspent()
         coin = None
         while coin is None or COIN * coin['amount'] < locked_2:
             coin = coins.pop()
@@ -232,12 +242,10 @@ def run_test(self):
         self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True})
         self.validate_credit_pool_amount(0)
         txid_in_block = self.send_tx(asset_lock_tx)
-
-        self.sync_mempools()
         self.validate_credit_pool_amount(0)
-
         node.generate(1)
-        self.validate_credit_pool_amount(locked_1)
+        assert_equal(self.get_credit_pool_amount(node=node_wallet), 0)
+        assert_equal(self.get_credit_pool_amount(node=node), locked_1)
         self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock")
         node.generate(12)
         self.sync_all()
@@ -246,7 +254,7 @@ def run_test(self):
 
         # tx is mined, let's get blockhash
         self.log.info("Invalidate block with asset lock tx...")
-        block_hash_1 = node.gettransaction(txid_in_block)['blockhash']
+        block_hash_1 = node_wallet.gettransaction(txid_in_block)['blockhash']
         for inode in self.nodes:
             inode.invalidateblock(block_hash_1)
             assert_equal(self.get_credit_pool_amount(node=inode), 0)
@@ -259,11 +267,6 @@ def run_test(self):
         txid_in_block = self.send_tx(asset_lock_tx_2)
         node.generate(1)
         self.sync_all()
-
-        self.validate_credit_pool_amount(locked_2)
-
-        node.generate(3)
-        self.sync_all()
         self.validate_credit_pool_amount(locked_2)
         self.log.info("Reconsider old blocks...")
         for inode in self.nodes:
@@ -309,11 +312,16 @@ def run_test(self):
         assert_equal(asset_unlock_tx_payload.quorumHash, int(self.mninfo[0].node.quorum("selectquorum", llmq_type_test, 'e6c7a809d79f78ea85b72d5df7e9bd592aecf151e679d6e976b74f053a7f9056')["quorumHash"], 16))
 
         self.send_tx(asset_unlock_tx)
+        self.mempool_size += 1
+        self.check_mempool_size()
         self.validate_credit_pool_amount(locked_1)
-        self.log.info("Mining exactly 2 blocks to be sure that SkipSet lets far transaction appears in block")
+        self.log.info("Mining one block - index '10001' can't be included in this block")
         node.generate(1)
         self.sync_all()
+        self.validate_credit_pool_amount(locked_1 - COIN)
+        self.mempool_size -= 1
         self.check_mempool_size()
+        self.log.info("Tx should not be mined yet... mine one more block")
         node.generate(1)
         self.sync_all()
         self.mempool_size -= 1
@@ -429,7 +437,8 @@ def run_test(self):
                 to_lock = 50 * COIN
             total += to_lock
             tx = self.create_assetlock(coin, to_lock, pubkey)
-            self.send_tx(tx)
+            self.send_tx_simple(tx)
+        self.sync_mempools()
         node.generate(1)
         self.sync_all()
         credit_pool_amount_1 = self.get_credit_pool_amount()
@@ -443,10 +452,12 @@ def run_test(self):
         for next_amount in withdrawals:
             index += 1
             asset_unlock_tx = self.create_assetunlock(index, next_amount, pubkey)
-            self.send_tx(asset_unlock_tx)
+            self.send_tx_simple(asset_unlock_tx)
             if index == 401:
+                self.sync_mempools()
                 node.generate(1)
 
+        self.sync_mempools()
         node.generate(1)
         self.sync_all()
 

From 2c6aa491604a291af3a3592f3c982a41cd0da6e7 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Thu, 20 Jul 2023 23:17:43 +0700
Subject: [PATCH 37/37] feat: new tests with asset-unlock tx absurdly high fee
 and zero fee

---
 test/functional/feature_asset_locks.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 8a8fb805a7be7..725d290f6e16e 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -81,10 +81,11 @@ def create_assetlock(self, coin, amount, pubkey):
         return FromHex(CTransaction(), lock_tx["hex"])
 
 
-    def create_assetunlock(self, index, withdrawal, pubkey=None):
+    def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
         node_wallet = self.nodes[0]
         mninfo = self.mninfo
-        tx_output = CTxOut(int(withdrawal) - tiny_amount, CScript([pubkey, OP_CHECKSIG]))
+        assert_greater_than(int(withdrawal), fee)
+        tx_output = CTxOut(int(withdrawal) - fee, CScript([pubkey, OP_CHECKSIG]))
 
         # request ID = sha256("plwdtx", index)
         request_id_buf = ser_string(b"plwdtx") + struct.pack("<Q", index)
@@ -95,7 +96,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None):
         unlockTx_payload = CAssetUnlockTx(
             version = 1,
             index = index,
-            fee = tiny_amount,
+            fee = fee,
             requestedHeight = height,
             quorumHash = int(quorumHash, 16),
             quorumSig = b'\00' * 96)
@@ -128,11 +129,11 @@ def get_credit_pool_amount(self, node = None, block_hash = None):
     def validate_credit_pool_amount(self, expected = None, block_hash = None):
         for node in self.nodes:
             locked = self.get_credit_pool_amount(node=node, block_hash=block_hash)
-            self.log.info(f"validate: {locked}")
             if expected is None:
                 expected = locked
             else:
                 assert_equal(expected, locked)
+        self.log.info(f"Credit pool amount matched with '{expected}'")
         return expected
 
     def check_mempool_size(self):
@@ -274,7 +275,7 @@ def run_test(self):
         self.validate_credit_pool_amount(locked_1)
         self.sync_all()
 
-        self.log.info('Mine block with incorrect credit-poool value...')
+        self.log.info('Mine block with incorrect credit-pool value...')
         extra_lock_tx = self.create_assetlock(coin, COIN, pubkey)
         self.create_and_check_block([extra_lock_tx], expected_error = 'bad-cbtx-assetlocked-amount')
 
@@ -297,11 +298,18 @@ def run_test(self):
         asset_unlock_tx = self.create_assetunlock(101, COIN, pubkey)
         asset_unlock_tx_late = self.create_assetunlock(102, COIN, pubkey)
         asset_unlock_tx_too_late = self.create_assetunlock(103, COIN, pubkey)
+        asset_unlock_tx_too_big_fee = self.create_assetunlock(104, COIN, pubkey, fee=int(Decimal("0.1") * COIN))
+        asset_unlock_tx_zero_fee = self.create_assetunlock(105, COIN, pubkey, fee=0)
         asset_unlock_tx_duplicate_index = copy.deepcopy(asset_unlock_tx)
         asset_unlock_tx_duplicate_index.vout[0].nValue += COIN
         too_late_height = node.getblock(node.getbestblockhash())["height"] + 48
 
         self.check_mempool_result(tx=asset_unlock_tx, result_expected={'allowed': True})
+        self.check_mempool_result(tx=asset_unlock_tx_too_big_fee,
+                result_expected={'allowed': False, 'reject-reason' : 'absurdly-high-fee'})
+        self.check_mempool_result(tx=asset_unlock_tx_zero_fee,
+                result_expected={'allowed': False, 'reject-reason' : 'bad-txns-assetunlock-fee-outofrange'})
+        # not-verified is a correct faiure from mempool. Mempool knows nothing about CreditPool indexes and he just report that signature is not validated
         self.check_mempool_result(tx=asset_unlock_tx_duplicate_index,
                 result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-verified'})