diff --git a/build_msvc/VeriBlockIntegrationTest/VeriBlockIntegrationTest.vcxproj b/build_msvc/VeriBlockIntegrationTest/VeriBlockIntegrationTest.vcxproj
index a560a576df542..2bf7db3fa627f 100644
--- a/build_msvc/VeriBlockIntegrationTest/VeriBlockIntegrationTest.vcxproj
+++ b/build_msvc/VeriBlockIntegrationTest/VeriBlockIntegrationTest.vcxproj
@@ -151,8 +151,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\test\setup_common.cpp" />
-    <ClCompile Include="..\..\src\vbk\test\integration\dummy.cpp" />
+    <ClCompile Include="..\..\src\test\util\setup_common.cpp" />
     <ClCompile Include="..\..\src\vbk\test\integration\main.cpp" />
     <ClCompile Include="..\..\src\vbk\test\integration\utils.cpp" />
     <ClCompile Include="..\..\src\vbk\test\integration\grpc_integration_service.cpp" />
diff --git a/src/Makefile.am b/src/Makefile.am
index 29dcabaa4a44f..5085a58946d50 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -116,7 +116,8 @@ VBK_H = \
   vbk/pop_service/pop_service_exception.hpp \
   vbk/merkle.hpp \
   vbk/genesis.hpp \
-  vbk/entity/publications.hpp \
+  vbk/entity/pop.hpp \
+  vbk/interpreter.hpp \
   vbk/util.hpp
 
 VBK_GRPC_OUT_ABS = $(srcdir)/vbk/pop_service
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 52e8131edab2e..0cf99149d9359 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -123,7 +123,9 @@ VBK_TESTS = \
   vbk/test/unit/updated_mempool_tests.cpp \
   vbk/test/unit/pop_reward_tests.cpp \
   vbk/test/unit/vbk_merkle_tests.cpp \
-  vbk/test/unit/vbk_net_processing_tests.cpp
+  vbk/test/unit/vbk_net_processing_tests.cpp \
+  vbk/test/unit/pop_interpreter_tests.cpp \
+  vbk/test/unit/block_validation_tests.cpp
   
 ### VeriBlock section end
 
diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index 3f817f00701a4..61857ff8a10ab 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -44,6 +44,7 @@ enum class TxValidationResult {
      */
     TX_CONFLICT,
     TX_MEMPOOL_POLICY,        //!< violated mempool's fee/size/descendant/RBF/etc limits
+    TX_BAD_POP_DATA           //!< data that is stored inside pop tx is invalid
 };
 
 /** A "reason" why a block was invalid, suitable for determining whether the
diff --git a/src/miner.cpp b/src/miner.cpp
index 6624ac9d07740..8bc80e563bb33 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -157,7 +157,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
-    VeriBlock::getService<VeriBlock::UtilService>().addPopPayoutsIntoCoinbaseTx(coinbaseTx, *pindexPrev);
+    VeriBlock::getService<VeriBlock::UtilService>().addPopPayoutsIntoCoinbaseTx(coinbaseTx, *pindexPrev, chainparams.GetConsensus());
 
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
     pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index e89c5b78ff14a..0576ac9b7b068 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1060,6 +1060,9 @@ static bool MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& s
  */
 static bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state, const std::string& message = "") {
     switch (state.GetResult()) {
+    case TxValidationResult::TX_BAD_POP_DATA:
+        LogPrint(BCLog::NET, "pop tx is invalid: %s\n", message);
+        break;
     case TxValidationResult::TX_RESULT_UNSET:
         break;
     // The node is providing invalid data:
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 7f02f60a3e371..257efc4b3cf76 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -725,7 +725,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
     result.pushKV("pop_witness_commitment", HexStr(popCoinbaseCommitment.scriptPubKey.begin(), popCoinbaseCommitment.scriptPubKey.end()));
 
     UniValue popRewardsArray(UniValue::VARR);
-    VeriBlock::PoPRewards popRewards = VeriBlock::getService<VeriBlock::UtilService>().getPopRewards(*pindexPrev);
+    VeriBlock::PoPRewards popRewards = VeriBlock::getService<VeriBlock::UtilService>().getPopRewards(*pindexPrev, Params().GetConsensus());
     for (const auto& itr : popRewards) {
         UniValue popRewardValue(UniValue::VOBJ);
         popRewardValue.pushKV("payout_info", HexStr(itr.first.begin(), itr.first.end()));
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 5c1cb19edffcd..56b65511c091b 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -303,7 +303,7 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
 
     if (flags & SCRIPT_VERIFY_POP) {
         auto& util = VeriBlock::getService<VeriBlock::UtilService>();
-        return util.EvalScript(script, stack, serror, nullptr);
+        return util.EvalScript(script, stack, serror, nullptr, nullptr, nullptr, true);
     }
 
     if (script.size() > MAX_SCRIPT_SIZE) {
diff --git a/src/script/script.cpp b/src/script/script.cpp
index 2a8df2e0b52f4..793ea2c5dcbdb 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -140,6 +140,8 @@ const char* GetOpName(opcodetype opcode)
     case OP_CHECKATV               : return "OP_CHECKATV";
     case OP_CHECKVTB               : return "OP_CHECKVTB";
     case OP_CHECKPOP               : return "OP_CHECKPOP";
+    case OP_POPBTCHEADER           : return "OP_POPBTCHEADER";
+    case OP_POPVBKHEADER           : return "OP_POPVBKHEADER";
 
     case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
 
diff --git a/src/script/script.h b/src/script/script.h
index 6491093d82be5..ef0ecdabe2bef 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -189,12 +189,14 @@ enum opcodetype
     OP_CHECKATV = 0xba,
     OP_CHECKVTB = 0xbb,
     OP_CHECKPOP = 0xbc,
+    OP_POPBTCHEADER = 0xbd,
+    OP_POPVBKHEADER = 0xbe,
 
     OP_INVALIDOPCODE = 0xff,
 };
 
 // Maximum value that an opcode can be
-static const unsigned int MAX_OPCODE = OP_CHECKPOP;
+static const unsigned int MAX_OPCODE = OP_POPVBKHEADER;
 
 const char* GetOpName(opcodetype opcode);
 
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
index 431ac61ab7fe5..aa35dd996722e 100644
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -252,10 +252,7 @@
 ["0", "IF NOP10 ENDIF 1", "P2SH,STRICTENC,DISCOURAGE_UPGRADABLE_NOPS", "OK",
  "Discouraged NOPs are allowed if not executed"],
 
-["0", "IF 0xbc ELSE 1 ENDIF", "P2SH,STRICTENC", "OK", "opcodes above MAX_OPCODE invalid if executed"],
-["0", "IF 0xbd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
-["0", "IF 0xbe ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
-["0", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
+["0", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK", "opcodes above MAX_OPCODE invalid if executed"],
 ["0", "IF 0xc0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
diff --git a/src/validation.cpp b/src/validation.cpp
index d3a72a1cc3564..064b160ace251 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2179,14 +2179,14 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     auto& utilService = VeriBlock::getService<VeriBlock::UtilService>();
     CAmount PoPrewards = 0;
-    for (const auto& it : utilService.getPopRewards(*pindex->pprev)) {
+    for (const auto& it : utilService.getPopRewards(*pindex->pprev, chainparams.GetConsensus())) {
         PoPrewards += it.second;
     }
     assert(PoPrewards >= 0);
 
     CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus()) + PoPrewards;
     assert(pindex->pprev && "previous block ptr is nullptr");
-    if (!VeriBlock::getService<VeriBlock::UtilService>().checkCoinbaseTxWithPopRewards(*block.vtx[0], blockReward, *pindex->pprev, state)) {
+    if (!VeriBlock::getService<VeriBlock::UtilService>().checkCoinbaseTxWithPopRewards(*block.vtx[0], blockReward, *pindex->pprev, chainparams.GetConsensus(), state)) {
         return false;
     }
 
@@ -3511,7 +3511,8 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
         // state is already set with error message
         return false;
     }
-    // VeriBlock: statefull block validation
+
+    // VeriBlock: stateful block validation
     if (!VeriBlock::getService<VeriBlock::PopService>().blockPopValidation(block, *pindexPrev, consensusParams, state)) {
         return false;
     }
diff --git a/src/vbk/alt-integration-proto b/src/vbk/alt-integration-proto
index df2746302e944..61f46aeade550 160000
--- a/src/vbk/alt-integration-proto
+++ b/src/vbk/alt-integration-proto
@@ -1 +1 @@
-Subproject commit df2746302e9447a2291bb952167e3e00c357b272
+Subproject commit 61f46aeade5507a79f5792ce2b2668ef2ef49dba
diff --git a/src/vbk/config.hpp b/src/vbk/config.hpp
index ce99106424758..e8c08d339435f 100644
--- a/src/vbk/config.hpp
+++ b/src/vbk/config.hpp
@@ -3,6 +3,7 @@
 
 #include <cstdint>
 #include <string>
+#include <vector>
 
 #include "vbk/typed_wrapper.hpp"
 #include <array>
@@ -25,11 +26,13 @@ struct Config {
     // unique index to this chain; network id across chains
     AltchainId index = AltchainId(0x3ae6ca);
 
+    uint32_t btc_header_size = 80;
+    uint32_t vbk_header_size = 64;
     uint32_t max_pop_script_size = 150000; // TODO: figure out number
-    uint32_t max_vtb_size = 100000; // TODO: figure out number
-    uint32_t min_vtb_size = 1; // TODO: figure out number
-    uint32_t max_atv_size = 100000; // TODO: figure out numer
-    uint32_t min_atv_size = 1; // TODO: figure out number
+    uint32_t max_vtb_size = 100000;        // TODO: figure out number
+    uint32_t min_vtb_size = 1;             // TODO: figure out number
+    uint32_t max_atv_size = 100000;        // TODO: figure out numer
+    uint32_t min_atv_size = 1;             // TODO: figure out number
 
     uint32_t max_future_block_time = 10 * 60; // 10 minutes
 
@@ -40,19 +43,67 @@ struct Config {
     /// The maximum allowed weight for the PoP transaction
     uint32_t max_pop_tx_weight = 150000;
 
-    /// The maximun allowed number of PoP transaction in a block
+    /// The maximum allowed number of PoP transaction in a block
     uint32_t max_pop_tx_amount = 50;
+    /// The maximum allowed number of "UpdateContext" transactions in a block
+    uint32_t max_update_context_tx_amount = 1;
+
 
     /////// Pop Rewards section start
     uint32_t POP_REWARD_PERCENTAGE = 40;
     int32_t POP_REWARD_SETTLEMENT_INTERVAL = 400;
     int32_t POP_REWARD_PAYMENT_DELAY = 500;
     int32_t POP_DIFFICULTY_AVERAGING_INTERVAL = 50;
+    
+    // how many payout rounds we have
+    uint32_t payoutRounds = 4;
+
+    // keystone is on 4th round (numeration starts from 0)
+    uint32_t keystoneRound = 3;
+
+    // we gradually increase the reward for every consecutive payout round
+    std::vector<std::string> roundRatios = { "0.97", "1.03", "1.07", "3.00" };
+
+    // the score when the rewards starts decreasing
+    std::string startOfDecreasingLine = "100.0";
+
+    // this is the length of the decreasing part of the reward curve
+    std::string widthOfDecreasingLineNormal = "100.0";
+
+    // this is the length of the decreasing part of the reward curve for keystone block
+    std::string widthOfDecreasingLineKeystone = "200.0";
+
+    // we decrease each score point to 80% of initial value when difficulty is above 1.0
+    std::string aboveIntendedPayoutMultiplierNormal = "0.8000";
+
+    // we decrease each keystone score point to 57% of initial value when difficulty is above 1.0
+    std::string aboveIntendedPayoutMultiplierKeystone = "0.5735";
+
+    // we limit the maximum rewards to 200% for normal PoP
+    std::string maxRewardThresholdNormal = "200.0";
+
+    // we limit the maximum rewards to 300% for keystone PoP
+    std::string maxRewardThresholdKeystone = "300.0";
+
+    // we score each VeriBlock and lower the reward for late blocks
+    std::vector<std::string> relativeScoreLookupTable = {"1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "1.0", "0.48296816", "0.31551694", "0.23325824", "0.18453616", "0.15238463", "0.12961255", "0.11265630", "0.09955094", "0.08912509", "0.08063761", "0.07359692", "0.06766428", "0.06259873", "0.05822428", "0.05440941", "0.05105386", "0.04807993", "0.04542644", "0.04304458", "0.04089495", "0.03894540", "0.03716941", "0.03554497", "0.03405359", "0.03267969", "0.03141000", "0.03023319", "0.02913950", "0.02812047", "0.02716878", "0.02627801", "0.02544253", "0.02465739", "0.02391820", "0.02322107", "0.02256255", "0.02193952", "0.02134922"};
+
+    // use flat score on 3rd round
+    int32_t flatScoreRound = 2;
+    bool flatScoreRoundUse = true;
+
+
     /////// Pop Rewards section end
 
     // GRPC config
     std::string service_port = "19012";
     std::string service_ip = "127.0.0.1";
+
+    //Alt service bootstrap blocks
+    //Veriblock blocks
+    std::vector<std::string> bootstrap_veriblock_blocks = {"000212B90002500640D2DCFDD047AF3F197C2BB743C05C2619919657462191847838E067A540836ABBE2C5AB1AA8DA98602D68C05DFB5C010405F5E1584D4024", "000212BA0002539544FC18F77FD997B080D52BB743C05C2619919657462191847838E067FF19E383F41F4B8A586142E47DB3B6225DFB5C080405F5E15876C544", "000212BB0002304FB9683DAFC9396A7F36492BB743C05C2619919657462191847838E067A87CF5F304B4E102B104320C5CBA33B85DFB5C500405F5E15A2670DE", "000212BC00025870BF9AD09BF0137D74551A2BB743C05C2619919657462191847838E06718A87B5E2923426270A6554112B0A7945DFB5C930405F5E1265B82D7", "000212BD000221C1F97385FB4F50D012571E2BB743C05C2619919657462191847838E067AAE01CA8E166338760880FC2C68466645DFB5CE60405F5E15DA9ACE9", "000212BE00025DB805D6B59D588982F60CF92BB743C05C2619919657462191847838E06703925057C5DC7A36080403CD446EF1B95DFB5E2F0405F5E1656929E3", "000212BF00024B0D40593576A382CD58DA5E2BB743C05C2619919657462191847838E0673C67D352F821E84195F9393C70A37BA15DFB5E7F0405F5E13425A20A", "000212C000022E28E85F3B565A9CE3A6D36F2BB743C05C2619919657462191847838E067B9321B6449970FB663B56210261D2AE75DFB5E800405F5E16742DE63", "000212C100022EABFB8FAF228721BA705F282BB743C05C2619919657462191847838E067C1D55AED879E3C2A39AD3DA4C72AA32C5DFB5EA10405F5E1351804AE", "000212C20002D918744D237CB620F05C04CB2BB743C05C2619919657462191847838E0673EFCD8817DD5C7DC3F71BCC71C992C1D5DFB5F0F0405F5E1382F2CCB", "000212C30002083EB27D9F62BE9FC7E178472BB743C05C2619919657462191847838E067AC554CC2C3E2942460A742093FA20F8D5DFB5F100405F5E138362725", "000212C4000282B9C1AF739155679954D27D2BB743C05C2619919657462191847838E067CEC2574589471F8635D3C85BC56803245DFB5F120405F5E13843B8A3", "000212C500028BD2113E1525CF7B7176DF782BB743C05C2619919657462191847838E0671B597D4BAE12B2A71CF670D6910608DF5DFB5F3C0405F5E139720FCD", "000212C600022E6EB382CD9D47641B43314C2BB743C05C2619919657462191847838E067073821D2D8891A8610B8C18897ED065A5DFB5F570405F5E16A8BEC2E", "000212C70002C1B622B7A4AB48CA23EAB9242BB743C05C2619919657462191847838E06731D8269A8DF296193B158E7059DA3E3C5DFB5FBF0405F5E16EC2628B", "000212C80002129B6280D651E9FC3D46799D2BB743C05C2619919657462191847838E067718CC361844278EAB1BD9E1FB387D0F45DFB5FC70405F5E16DAF3C66"};
+    std::vector<std::string> bootstrap_bitcoin_blocks = {"000000204E2FE8861AF5135B650512F2197DA6F57EA4AE495959E2A3E5850000000000005C1C10A2A023B0375ABF924E0F04D36F1F645E5B906DEBCD59D1E9AAADA9029A0E56FB5DFFFF001B75696A5B", "000000208A55C72B18AF0884EBE94F035E3EF3F581C9BF2915F54EDBB3530000000000005BEF944BBC852CA367D9B771DC7060DBE373E78095758C03E0822B9EC0257579C056FB5DFFFF001B9E787E4A", "00000020615F9BFDF41FADEEC01BB69ED6A3B4751A1E6A3B3901554356E800000000000004E28DC3633A798A42113304FB3E23F2C34FB64BF16F85C96387D4336D1524A5FE57FB5DFFFF001BB06B5D3D", "00000020313C38FDA19B2DC29CD0B0C3A5D402B29DD99019573F7D03E049000000000000A27BB8E349594A307997AE3E27BB4B767E4FB61D5E6053DDDD12F41E67DA39E46058FB5DFFFF001BA234951F", "00000020AB142C1020A85F5F94A64FAF1073E10631BBA606F6895568C179000000000000B6DDC3FF20EF1AFD4070521270CCD9E9606CCCE4A21C1F4189F18A55A2496DB59258FB5DFFFF001B5114DFFD", "00000020F74C38CBF19627902641C66BEB42934DB826EEDDBE538D2B0AAF00000000000070551E97C33CE1B1E357984683606F0FBAAE1E79D350CFFA489A34CF0C8FA1DAF658FB5DFFFF001BD5A959BC", "00000020FDF387285B7C1444B37F5F4C68AEAE3C50D1B4E5989C123F2B2E000000000000026EBDB6D235AAC2E31EC757FFBF5A1B99CB7FFE9B8334EA618AA0BDA74806E43759FB5DFFFF001BACF5113C", "00000020862AA943B501E24F122BA508D444FDA9E6ED720D01C9C5FC254900000000000090BDE5548BEB2AAA1809A4CF667F72E6A1F82A221E58C7BF6E463E338BC64C74A959FB5DFFFF001B0957D25B", "000000207CE1E81B69DC90653C8652D7E897F66D7CF49C7D17AAF087A21E00000000000016D70855883C41BA77CA41BE3A30D3EC902132E317C29F2BFB298531DD54C09D6C5AFB5DFFFF001B36E17BC4", "0000002076FBC13AFFEABF306C9F00B7F046B3FC3257F6F4D9D96BE45E5600000000000011B793687891A9E218046C5A9DC5552F2DE86B4B6CFA6E70CC5F4F15F66FEEC6B25AFB5DFFFF001B1825B521", "00000020AA5B1689B9B745A265EF864C18E74E0615FD0ED4F919D2725A8E000000000000C5F543263E5D3A794FE3D4BE20CE131B134B32336FC2FBABDBE7E62F02A3F5A17A5BFB5DFFFF001BEDC8CF53", "000000200AD01BDE5BD4221A3CEF8A5DECB199B4B999D5157A48F20E9F1D000000000000E73841C91619662B365D690BD054F8A005C8DB2E22063872F91F3FD5E305AF05EB5BFB5DFFFF001B6BAA1754", "00000020BFA07C30A017FCEB97F0B738E4CCFB937809AFC370CDB93EECDC000000000000C0C55F28309FDB0F0EF745F9BA3118462529DFAE84B280578EBBF9F31E40DBC0C15EFB5DFFFF001BC597988F", "000000208791BB6E32BD11121C3BF13EBEF976C555CDC1D20C5CD60DCE56000000000000A4A861D7B9813C8BACB6C0C79BD6568C81DB4FEA90460375127BDDF2C425722BCD5EFB5DFFFF001B91F6168A", "000000206AB5E7E62B060B31171533EDFC60D473B2C4381768BAA5AD1D97000000000000EB6CCCE2E6FB36E7E75E0A0941691BF36053BD676A510C35CFFFB2A16A8621B56F5FFB5DFFFF001BB14CAEAD", "00000020E2EEC323DA41F7F3387E8E4F1BF313EDFD2247788CBA378900040000000000002878DE94F86A20B384C0B0FC6BAAD61EBB0DCDC7126684072CCAD3EE624905060F60FB5DFFFF001B2CBAA52B"};
+    uint32_t bitcoin_first_block_height = 1628985;
 };
 
 } // namespace VeriBlock
diff --git a/src/vbk/entity/pop.hpp b/src/vbk/entity/pop.hpp
new file mode 100644
index 0000000000000..681207c508236
--- /dev/null
+++ b/src/vbk/entity/pop.hpp
@@ -0,0 +1,34 @@
+#ifndef INTEGRATION_REFERENCE_BTC_POP_HPP
+#define INTEGRATION_REFERENCE_BTC_POP_HPP
+
+#include <cstdint>
+#include <vector>
+
+namespace VeriBlock {
+
+using ByteArray = std::vector<uint8_t>;
+
+struct Publications {
+    ByteArray atv;
+    std::vector<ByteArray> vtbs;
+};
+
+struct Context {
+    std::vector<ByteArray> btc;
+    std::vector<ByteArray> vbk;
+
+    bool operator==(const Context& other) const
+    {
+        return btc == other.btc && vbk == other.vbk;
+    }
+};
+
+enum class PopTxType {
+    UNKNOWN = 0,
+    PUBLICATIONS = 1,
+    CONTEXT = 2
+};
+
+} // namespace VeriBlock
+
+#endif //INTEGRATION_REFERENCE_BTC_POP_HPP
diff --git a/src/vbk/entity/publications.hpp b/src/vbk/entity/publications.hpp
index 54860042ba192..e69de29bb2d1d 100644
--- a/src/vbk/entity/publications.hpp
+++ b/src/vbk/entity/publications.hpp
@@ -1,17 +0,0 @@
-#ifndef INTEGRATION_REFERENCE_BTC_PUBLICATIONS_HPP
-#define INTEGRATION_REFERENCE_BTC_PUBLICATIONS_HPP
-
-#include <vector>
-
-namespace VeriBlock {
-
-using ByteArray = std::vector<uint8_t>;
-
-struct Publications {
-    ByteArray atv;
-    std::vector<ByteArray> vtbs;
-};
-
-} // namespace VeriBlock
-
-#endif //INTEGRATION_REFERENCE_BTC_PUBLICATIONS_HPP
diff --git a/src/vbk/interpreter.hpp b/src/vbk/interpreter.hpp
new file mode 100644
index 0000000000000..6b8d4ce6a5d2f
--- /dev/null
+++ b/src/vbk/interpreter.hpp
@@ -0,0 +1,212 @@
+#ifndef INTEGRATION_REFERENCE_BTC_INTERPRETER_HPP
+#define INTEGRATION_REFERENCE_BTC_INTERPRETER_HPP
+
+
+#include <script/script.h>
+#include <script/script_error.h>
+#include <vbk/entity/pop.hpp>
+#include <vbk/pop_service.hpp>
+#include <vbk/service_locator.hpp>
+
+namespace VeriBlock {
+
+namespace {
+inline bool set_error(ScriptError* ret, const ScriptError serror)
+{
+    if (ret)
+        *ret = serror;
+    return false;
+}
+typedef std::vector<unsigned char> valtype;
+
+#define stacktop(i) (stack.at(stack.size() + (i)))
+inline void popstack(std::vector<valtype>& stack)
+{
+    if (stack.empty())
+        throw std::runtime_error("popstack(): stack empty");
+    stack.pop_back();
+}
+
+} // namespace
+
+inline bool EvalScriptImpl(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, VeriBlock::Publications* publications, VeriBlock::Context* context, PopTxType* type, bool with_checks)
+{
+    CScript::const_iterator pc = script.begin();
+    CScript::const_iterator pend = script.end();
+    static const valtype vchFalse(0);
+    static const valtype vchTrue(1, 1);
+    opcodetype opcode;
+    std::vector<unsigned char> vchPushValue;
+    auto& config = getService<Config>();
+    auto& pop = getService<PopService>();
+    Publications pub;
+    Context ctx;
+
+    bool isPublicationsTx = false;
+    bool isContextTx = false;
+
+    if (script.size() > config.max_pop_script_size) {
+        return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
+    }
+
+    try {
+        while (pc < pend) {
+            if (!script.GetOp(pc, opcode, vchPushValue)) {
+                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+            }
+
+            if (!vchPushValue.empty()) {
+                stack.push_back(vchPushValue);
+                continue;
+            }
+
+            switch (opcode) {
+            case OP_POPBTCHEADER: {
+                // we do not allow single pop tx simultaneously contain publications and context
+                isContextTx = true;
+                if (isPublicationsTx) {
+                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+                }
+
+                const auto& el = stacktop(-1);
+                if (el.size() != config.btc_header_size) {
+                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+                }
+
+                ctx.btc.push_back(el);
+                popstack(stack);
+
+                break;
+            }
+            case OP_POPVBKHEADER: {
+                // we do not allow single pop tx simultaneously contain publications and context
+                isContextTx = true;
+                if (isPublicationsTx) {
+                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+                }
+
+                const auto& el = stacktop(-1);
+                if (el.size() != config.vbk_header_size) {
+                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+                }
+
+                ctx.vbk.push_back(el);
+                popstack(stack);
+
+                break;
+            }
+            case OP_CHECKATV: {
+                // we do not allow single pop tx simultaneously contain publications and context
+                isPublicationsTx = true;
+                if (isContextTx) {
+                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+                }
+
+                // tx has one ATV
+                if (!pub.atv.empty()) {
+                    return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
+                }
+
+                // validate ATV size
+                const auto& el = stacktop(-1);
+                if (el.size() > config.max_atv_size || el.size() < config.min_atv_size) {
+                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+                }
+
+                // validate ATV content
+                if (with_checks && !pop.checkATVinternally(el)) {
+                    return set_error(serror, SCRIPT_ERR_VBK_ATVFAIL);
+                }
+
+                pub.atv = el;
+                popstack(stack);
+                break;
+            }
+            case OP_CHECKVTB: {
+                // we do not allow single pop tx simultaneously contain publications and context
+                isPublicationsTx = true;
+                if (isContextTx) {
+                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+                }
+
+                // validate VTB size
+                const auto& el = stacktop(-1);
+                if (el.size() > config.max_vtb_size || el.size() < config.min_vtb_size) {
+                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+                }
+
+                // validate VTB content
+                if (with_checks && !pop.checkVTBinternally(el)) {
+                    return set_error(serror, SCRIPT_ERR_VBK_VTBFAIL);
+                }
+
+                // tx has many VTBs
+                pub.vtbs.push_back(el);
+                popstack(stack);
+                break;
+            }
+            case OP_CHECKPOP: {
+                // OP_CHECKPOP should be last opcode
+                if (script.GetOp(pc, opcode, vchPushValue)) {
+                    // we could read next opcode. extra opcodes is an error
+                    return set_error(serror, SCRIPT_ERR_VBK_EXTRA_OPCODE);
+                }
+
+                // stack should be empty at this point
+                if (!stack.empty()) {
+                    return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
+                }
+
+                // we did all checks, put true on stack to signal successful execution
+                stack.push_back(vchTrue);
+                break;
+            }
+            default:
+                // forbid any other opcodes in pop transactions
+                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+            }
+        }
+    } catch (...) {
+        return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
+    }
+
+    if (isPublicationsTx && pub.atv.empty()) {
+        // must contain non-empty ATV
+        return set_error(serror, SCRIPT_ERR_VBK_ATVFAIL);
+    }
+
+    // set return value of publications
+    if (publications != nullptr) {
+        *publications = pub;
+    }
+
+    // set return value of context
+    if (context != nullptr) {
+        *context = ctx;
+    }
+
+    // set return value of tx type
+    if (type != nullptr) {
+        // can not be simultaneously context and publication tx
+        if (isContextTx && isPublicationsTx) {
+            return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
+        }
+
+        if (isContextTx) {
+            *type = PopTxType::CONTEXT;
+        } else if (isPublicationsTx) {
+            *type = PopTxType::PUBLICATIONS;
+        } else {
+            *type = PopTxType::UNKNOWN;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+} // namespace VeriBlock
+
+#undef stacktop
+
+#endif //INTEGRATION_REFERENCE_BTC_INTERPRETER_HPP
diff --git a/src/vbk/pop_service.hpp b/src/vbk/pop_service.hpp
index 27c04f4473979..695067aef089f 100644
--- a/src/vbk/pop_service.hpp
+++ b/src/vbk/pop_service.hpp
@@ -7,6 +7,7 @@
 #include <consensus/validation.h>
 #include <script/interpreter.h>
 #include <vbk/entity/context_info_container.hpp>
+#include <vbk/entity/pop.hpp>
 
 class CBlock;
 class CTransaction;
@@ -38,11 +39,19 @@ struct PopService {
 
     virtual int compareTwoBranches(const CBlockIndex* commonKeystone, const CBlockIndex* leftForkTip, const CBlockIndex* rightForkTip) = 0;
 
-    virtual void rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex& difficulty_start_interval, const CBlockIndex& difficulty_end_interval, std::map<CScript, int64_t>& outputs) = 0;
+    virtual void rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) = 0;
 
     virtual bool blockPopValidation(const CBlock& block, const CBlockIndex& pindexPrev, const Consensus::Params& params, BlockValidationState& state) = 0;
 
     virtual void updateContext(const std::vector<std::vector<uint8_t>>& veriBlockBlocks, const std::vector<std::vector<uint8_t>>& bitcoinBlocks) = 0;
+
+    virtual bool parsePopTx(const CTransactionRef& tx, Publications* publications, Context* ctx, PopTxType* type) = 0;
+
+    virtual bool determineATVPlausibilityWithBTCRules(AltchainId altChainIdentifier, const CBlockHeader& popEndorsementHeader, const Consensus::Params& params) = 0;
+
+    virtual void addPayloads(const CBlock& block, const int& nHeight, const Publications& publications) = 0;
+    virtual void removePayloads(const CBlock&, const int&) = 0;
+    virtual void setConfig() = 0;
 };
 } // namespace VeriBlock
 
diff --git a/src/vbk/pop_service/pop_service_impl.cpp b/src/vbk/pop_service/pop_service_impl.cpp
index 29fcc601d98d1..b0f1482877150 100644
--- a/src/vbk/pop_service/pop_service_impl.cpp
+++ b/src/vbk/pop_service/pop_service_impl.cpp
@@ -15,6 +15,7 @@
 #include <shutdown.h>
 #include <streams.h>
 #include <validation.h>
+#include <util/strencodings.h>
 
 #include <vbk/merkle.hpp>
 #include <vbk/service_locator.hpp>
@@ -27,24 +28,6 @@ using grpc::Status;
 
 namespace {
 
-template <class T>
-using DeserializeMemberFunction = Status (VeriBlock::GrpcPopService::Stub::*)(::grpc::ClientContext* context, const ::VeriBlock::BytesArrayRequest& request, T* response);
-
-template <class T>
-void grpc_deserialize(const std::shared_ptr<VeriBlock::GrpcPopService::Stub>& grpcPopService, const std::vector<unsigned char>& bytes, T& reply, DeserializeMemberFunction<T> func)
-{
-    VeriBlock::BytesArrayRequest request;
-    ClientContext context;
-
-    request.set_data(bytes.data(), bytes.size());
-
-    Status status = (*grpcPopService.*func)(&context, request, &reply);
-    if (!status.ok()) {
-        throw VeriBlock::PopServiceException(status);
-    }
-}
-
-
 void BlockToProtoAltChainBlock(const CBlockIndex& blockIndex, VeriBlock::AltChainBlock& protoBlock)
 {
     auto* blockIndex1 = new VeriBlock::BlockIndex();
@@ -89,6 +72,9 @@ PopServiceImpl::PopServiceImpl()
         LogPrintf("-------------------------------------------------------------------------------------------------\n");
         StartShutdown();
     }
+    else {
+        setConfig();
+    }
 }
 
 void PopServiceImpl::addPayloads(const CBlock& block, const int& nHeight, const Publications& publications)
@@ -151,8 +137,15 @@ void PopServiceImpl::savePopTxToDatabase(const CBlock& block, const int& nHeight
 
         PopTxData* popTxData = request.add_popdata();
 
+
         Publications publications;
-        getPublicationsData(tx, publications);
+        PopTxType type;
+        assert(parsePopTx(tx, &publications, nullptr, &type) && "scriptSig of pop tx is invalid in savePopTxToDatabase");
+
+        // skip all non-publications txes
+        if(type != PopTxType::PUBLICATIONS) {
+            continue;
+        }
 
         // Fill the proto objects with pop data
         popTxData->set_poptxhash(tx->GetHash().ToString());
@@ -325,7 +318,7 @@ int PopServiceImpl::compareTwoBranches(const CBlockIndex* commonKeystone, const
 }
 
 // Pop rewards
-void PopServiceImpl::rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex& difficulty_start_interval, const CBlockIndex& difficulty_end_interval, std::map<CScript, int64_t>& outputs)
+void PopServiceImpl::rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs)
 {
     RewardsCalculateRequest request;
     RewardsCalculateReply reply;
@@ -339,9 +332,11 @@ void PopServiceImpl::rewardsCalculateOutputs(const int& blockHeight, const CBloc
         workingBlock = workingBlock->pprev;
     }
 
-    workingBlock = &difficulty_end_interval;
+    workingBlock = difficulty_end_interval;
+
+    CBlockIndex* pprev_difficulty_start_interval = difficulty_start_interval != nullptr ? difficulty_start_interval->pprev : nullptr;
 
-    while (workingBlock != difficulty_start_interval.pprev) // including the start_interval block
+    while (workingBlock != pprev_difficulty_start_interval) // including the start_interval block
     {
         AltChainBlock* b = request.add_difficultyblocks();
         ::BlockToProtoAltChainBlock(*workingBlock, *b);
@@ -379,31 +374,20 @@ void PopServiceImpl::rewardsCalculateOutputs(const int& blockHeight, const CBloc
     }
 }
 
-// Deserialization
-void PopServiceImpl::parseAltPublication(const std::vector<unsigned char>& bytes, VeriBlock::AltPublication& publication)
-{
-    ::grpc_deserialize(grpcPopService, bytes, publication, &GrpcPopService::Stub::ParseAltPublication);
-}
-
-void PopServiceImpl::parseVeriBlockPublication(const std::vector<unsigned char>& bytes, VeriBlock::VeriBlockPublication& publication)
-{
-    ::grpc_deserialize(grpcPopService, bytes, publication, &GrpcPopService::Stub::ParseVeriBlockPublication);
-}
-
-void PopServiceImpl::getPublicationsData(const CTransactionRef& tx, Publications& publications)
+bool PopServiceImpl::parsePopTx(const CTransactionRef& tx, Publications* pub, Context* ctx, PopTxType* type)
 {
     std::vector<std::vector<uint8_t>> stack;
-    getService<UtilService>().EvalScript(tx->vin[0].scriptSig, stack, nullptr, &publications, false);
+    return getService<UtilService>().EvalScript(tx->vin[0].scriptSig, stack, nullptr, pub, ctx, type, false);
 }
 
-void PopServiceImpl::getPublicationsData(const Publications& data, PublicationData& publciationData)
+void PopServiceImpl::getPublicationsData(const Publications& data, PublicationData& pub)
 {
     ClientContext context;
     BytesArrayRequest request;
 
     request.set_data(data.atv.data(), data.atv.size());
 
-    Status status = grpcPopService->GetPublicationDataFromAltPublication(&context, request, &publciationData);
+    Status status = grpcPopService->GetPublicationDataFromAltPublication(&context, request, &pub);
 
     if (!status.ok()) {
         throw PopServiceException(status);
@@ -425,6 +409,92 @@ bool PopServiceImpl::determineATVPlausibilityWithBTCRules(AltchainId altChainIde
     return CheckProofOfWork(popEndorsementHeader.GetHash(), popEndorsementHeader.nBits, params);
 }
 
+void PopServiceImpl::setConfig()
+{
+    auto& config = getService<Config>();
+
+    ClientContext context;
+    SetConfigRequest request;
+    EmptyReply reply;
+
+    //AltChainConfig
+    AltChainConfigRequest* altChainConfig = new AltChainConfigRequest();
+    altChainConfig->set_keystoneinterval(config.keystone_interval);
+
+    // CalculatorConfig
+    CalculatorConfig* calculatorConfig = new CalculatorConfig();
+    calculatorConfig->set_basicreward(std::to_string(COIN));
+    calculatorConfig->set_payoutrounds(config.payoutRounds);
+    calculatorConfig->set_keystoneround(config.keystoneRound);
+    
+    RoundRatioConfig* roundRatioConfig = new RoundRatioConfig();
+    for (size_t i = 0; i < config.roundRatios.size(); ++i) {
+        std::string* round = roundRatioConfig->add_roundratio();
+        *round = config.roundRatios[i];
+    }
+    calculatorConfig->set_allocated_roundratios(roundRatioConfig);
+    
+    RewardCurveConfig* rewardCurveConfig = new RewardCurveConfig();
+    rewardCurveConfig->set_startofdecreasingline(config.startOfDecreasingLine);
+    rewardCurveConfig->set_widthofdecreasinglinenormal(config.widthOfDecreasingLineNormal);
+    rewardCurveConfig->set_widthofdecreasinglinekeystone(config.widthOfDecreasingLineKeystone);
+    rewardCurveConfig->set_aboveintendedpayoutmultipliernormal(config.aboveIntendedPayoutMultiplierNormal);
+    rewardCurveConfig->set_aboveintendedpayoutmultiplierkeystone(config.aboveIntendedPayoutMultiplierKeystone);
+    calculatorConfig->set_allocated_rewardcurve(rewardCurveConfig);
+
+    calculatorConfig->set_maxrewardthresholdnormal(config.maxRewardThresholdNormal);
+    calculatorConfig->set_maxrewardthresholdkeystone(config.maxRewardThresholdKeystone);
+
+    RelativeScoreConfig* relativeScoreConfig = new RelativeScoreConfig();
+    for (size_t i = 0; i < config.relativeScoreLookupTable.size(); ++i) {
+        std::string* score = relativeScoreConfig->add_score();
+        *score = config.relativeScoreLookupTable[i];
+    }
+    calculatorConfig->set_allocated_relativescorelookuptable(relativeScoreConfig);
+
+    FlatScoreRoundConfig* flatScoreRoundConfig = new FlatScoreRoundConfig();
+    flatScoreRoundConfig->set_round(config.flatScoreRound);
+    flatScoreRoundConfig->set_active(config.flatScoreRoundUse);
+    calculatorConfig->set_allocated_flatscoreround(flatScoreRoundConfig);
+
+    calculatorConfig->set_popdifficultyaveraginginterval(config.POP_DIFFICULTY_AVERAGING_INTERVAL);
+    calculatorConfig->set_poprewardsettlementinterval(config.POP_REWARD_SETTLEMENT_INTERVAL);
+    
+    //ForkresolutionConfig
+    ForkresolutionConfigRequest* forkresolutionConfig = new ForkresolutionConfigRequest();
+    forkresolutionConfig->set_keystonefinalitydelay(config.keystone_finality_delay);
+    forkresolutionConfig->set_amnestyperiod(config.amnesty_period);
+
+    //VeriBlockBootstrapConfig
+    VeriBlockBootstrapConfig* veriBlockBootstrapBlocks = new VeriBlockBootstrapConfig();
+    for (size_t i = 0; i < config.bootstrap_veriblock_blocks.size(); ++i) {
+        std::string* block = veriBlockBootstrapBlocks->add_blocks();
+        std::vector<uint8_t> bytes = ParseHex(config.bootstrap_veriblock_blocks[i]);
+        *block = std::string(bytes.begin(), bytes.end());
+    }
+
+    //BitcoinBootstrapConfig
+    BitcoinBootstrapConfig* bitcoinBootstrapBlocks = new BitcoinBootstrapConfig();
+    for (size_t i = 0; i < config.bootstrap_bitcoin_blocks.size(); ++i) {
+        std::string* block = bitcoinBootstrapBlocks->add_blocks();
+        std::vector<uint8_t> bytes = ParseHex(config.bootstrap_bitcoin_blocks[i]);
+        *block = std::string(bytes.begin(), bytes.end());
+    }
+    bitcoinBootstrapBlocks->set_firstblockheight(config.bitcoin_first_block_height);
+
+    request.set_allocated_altchainconfig(altChainConfig);
+    request.set_allocated_calculatorconfig(calculatorConfig);
+    request.set_allocated_forkresolutionconfig(forkresolutionConfig);
+    request.set_allocated_veriblockbootstrapconfig(veriBlockBootstrapBlocks);
+    request.set_allocated_bitcoinbootstrapconfig(bitcoinBootstrapBlocks);
+
+    Status status = grpcPopService->SetConfig(&context, request, &reply);
+
+    if (!status.ok()) {
+        throw PopServiceException(status);
+    }
+}
+
 bool blockPopValidationImpl(PopServiceImpl& pop, const CBlock& block, const CBlockIndex& pindexPrev, const Consensus::Params& params, BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     bool isValid = true;
@@ -441,64 +511,93 @@ bool blockPopValidationImpl(PopServiceImpl& pop, const CBlock& block, const CBlo
         }
 
         Publications publications;
-        pop.getPublicationsData(tx, publications);
-
-        PublicationData popEndorsement;
-        pop.getPublicationsData(publications, popEndorsement);
-
-        CDataStream stream(std::vector<unsigned char>(popEndorsement.header().begin(), popEndorsement.header().end()), SER_NETWORK, PROTOCOL_VERSION);
-        CBlockHeader popEndorsementHeader;
-
-        try {
-            stream >> popEndorsementHeader;
-        } catch (const std::exception&) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid endorsed block header \n";
+        Context context;
+        PopTxType type = PopTxType::UNKNOWN;
+        if (!pop.parsePopTx(tx, &publications, &context, &type)) {
+            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : can not parse pop tx data \n";
             isValid = false;
             mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
             continue;
         }
 
-        if (!pop.determineATVPlausibilityWithBTCRules(AltchainId(popEndorsement.identifier()), popEndorsementHeader, params)) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid alt-chain index or bad PoW of endorsed block header \n";
-            isValid = false;
-            mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
-            continue;
+        switch (type) {
+        case PopTxType::CONTEXT: {
+            try {
+                pop.updateContext(context.vbk, context.btc);
+            } catch (const PopServiceException& e) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : updateContext failed, " + e.what() + "\n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+            break;
         }
 
-        const CBlockIndex* popEndorsementIdnex = LookupBlockIndex(popEndorsementHeader.GetHash());
-        if (popEndorsementIdnex == nullptr || pindexPrev.GetAncestor(popEndorsementIdnex->nHeight) == nullptr) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : endorsed block not from this chain \n";
-            isValid = false;
-            mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
-            continue;
-        }
+        case PopTxType::PUBLICATIONS: {
+            PublicationData popEndorsement;
+            pop.getPublicationsData(publications, popEndorsement);
 
-        CBlock popEndorsementBlock;
-        if (!ReadBlockFromDisk(popEndorsementBlock, popEndorsementIdnex, params)) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : cant read endorsed block from disk \n";
-            isValid = false;
-            mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
-            continue;
-        }
+            CDataStream stream(std::vector<unsigned char>(popEndorsement.header().begin(), popEndorsement.header().end()), SER_NETWORK, PROTOCOL_VERSION);
+            CBlockHeader popEndorsementHeader;
 
-        if (!VeriBlock::VerifyTopLevelMerkleRoot(popEndorsementBlock, state, popEndorsementIdnex->pprev)) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid top merkle root of the endorsed block \n";
-            isValid = false;
-            mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
-            continue;
-        }
+            try {
+                stream >> popEndorsementHeader;
+            } catch (const std::exception&) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid endorsed block header \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
 
-        if (pindexPrev.nHeight + 1 - popEndorsementIdnex->nHeight > config.POP_REWARD_SETTLEMENT_INTERVAL) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : endorsed block is too old for this chain \n";
-            isValid = false;
-            mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
-            continue;
-        }
+            if (!pop.determineATVPlausibilityWithBTCRules(AltchainId(popEndorsement.identifier()), popEndorsementHeader, params)) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid alt-chain index or bad PoW of endorsed block header \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
 
-        try {
-            pop.addPayloads(block, pindexPrev.nHeight + 1, publications);
-        } catch (const PopServiceException& e) {
-            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : addPayloads failed, " + e.what() + "\n";
+            const CBlockIndex* popEndorsementIdnex = LookupBlockIndex(popEndorsementHeader.GetHash());
+            if (popEndorsementIdnex == nullptr || pindexPrev.GetAncestor(popEndorsementIdnex->nHeight) == nullptr) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : endorsed block not from this chain \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+
+            CBlock popEndorsementBlock;
+            if (!ReadBlockFromDisk(popEndorsementBlock, popEndorsementIdnex, params)) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : cant read endorsed block from disk \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+
+            if (!VeriBlock::VerifyTopLevelMerkleRoot(popEndorsementBlock, state, popEndorsementIdnex->pprev)) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : invalid top merkle root of the endorsed block \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+
+            if (pindexPrev.nHeight + 1 - popEndorsementIdnex->nHeight > config.POP_REWARD_SETTLEMENT_INTERVAL) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : endorsed block is too old for this chain \n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+
+            try {
+                pop.addPayloads(block, pindexPrev.nHeight + 1, publications);
+            } catch (const PopServiceException& e) {
+                error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : addPayloads failed, " + e.what() + "\n";
+                isValid = false;
+                mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
+                continue;
+            }
+            break;
+        }
+        default:
+            error_message += " tx hash: (" + tx->GetHash().GetHex() + ") reason : pop tx type is unknown \n";
             isValid = false;
             mempool.removeRecursive(*tx, MemPoolRemovalReason::BLOCK);
             continue;
diff --git a/src/vbk/pop_service/pop_service_impl.hpp b/src/vbk/pop_service/pop_service_impl.hpp
index 936f11494aa31..fe7fdd832aefb 100644
--- a/src/vbk/pop_service/pop_service_impl.hpp
+++ b/src/vbk/pop_service/pop_service_impl.hpp
@@ -1,9 +1,9 @@
 #ifndef BITCOIN_SRC_VBK_POP_SERVICE_POP_SERVICE_IMPL_HPP
 #define BITCOIN_SRC_VBK_POP_SERVICE_POP_SERVICE_IMPL_HPP
 
+#include <vbk/entity/pop.hpp>
 #include <vbk/pop_service.hpp>
 #include <vbk/pop_service/pop_service_exception.hpp>
-#include <vbk/entity/publications.hpp>
 
 #include <memory>
 #include <vector>
@@ -36,22 +36,24 @@ class PopServiceImpl : public PopService
 
     int compareTwoBranches(const CBlockIndex* commonKeystone, const CBlockIndex* leftForkTip, const CBlockIndex* rightForkTip) override;
 
-    void rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex& difficulty_start_interval, const CBlockIndex& difficulty_end_interval, std::map<CScript, int64_t>& outputs) override;
+    void rewardsCalculateOutputs(const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) override;
 
     bool blockPopValidation(const CBlock& block, const CBlockIndex& pindexPrev, const Consensus::Params& params, BlockValidationState& state) override;
 
     void updateContext(const std::vector<std::vector<uint8_t>>& veriBlockBlocks, const std::vector<std::vector<uint8_t>>& bitcoinBlocks) override;
 
-public:
-    virtual void parseAltPublication(const std::vector<uint8_t>&, VeriBlock::AltPublication&);
-    virtual void parseVeriBlockPublication(const std::vector<uint8_t>&, VeriBlock::VeriBlockPublication&);
-    virtual void getPublicationsData(const CTransactionRef& tx, Publications& publications);
-    virtual void getPublicationsData(const Publications& tx, PublicationData& publicationData);
+     bool parsePopTx(const CTransactionRef& tx, Publications* publications, Context* ctx, PopTxType* type) override;
+
+    bool determineATVPlausibilityWithBTCRules(AltchainId altChainIdentifier, const CBlockHeader& popEndorsementHeader, const Consensus::Params& params) override;
+
+    void addPayloads(const CBlock& block, const int& nHeight, const Publications& publications) override;
 
-    virtual bool determineATVPlausibilityWithBTCRules(AltchainId altChainIdentifier, const CBlockHeader& popEndorsementHeader, const Consensus::Params& params);
+    void removePayloads(const CBlock&, const int&) override;
 
-    virtual void addPayloads(const CBlock& block, const int& nHeight, const Publications& publications);
-    virtual void removePayloads(const CBlock&, const int&);
+    void setConfig() override;
+
+public:
+    virtual void getPublicationsData(const Publications& tx, PublicationData& publicationData);
 };
 
 bool blockPopValidationImpl(PopServiceImpl& pop, const CBlock& block, const CBlockIndex& pindexPrev, const Consensus::Params& params, BlockValidationState& state);
diff --git a/src/vbk/rpc_service/rpc_service_impl.cpp b/src/vbk/rpc_service/rpc_service_impl.cpp
index 0a0dde9711751..ae5fafc9c81a2 100644
--- a/src/vbk/rpc_service/rpc_service_impl.cpp
+++ b/src/vbk/rpc_service/rpc_service_impl.cpp
@@ -65,18 +65,18 @@ UniValue RpcServiceImpl::submitpop(const JSONRPCRequest& request)
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR});
 
+    Publications pub;
     LogPrintf("submitpop executed with: \n");
     const UniValue& vtb_array = request.params[1].get_array();
-    std::vector<std::vector<uint8_t>> vtbs;
     for (uint32_t idx = 0u, size = vtb_array.size(); idx < size; ++idx) {
         LogPrintf(" - VTB: %s\n", vtb_array[idx].get_str());
-        vtbs.emplace_back(ParseHexV(vtb_array[idx], "vtb[" + std::to_string(idx) + "]"));
+        pub.vtbs.emplace_back(ParseHexV(vtb_array[idx], "vtb[" + std::to_string(idx) + "]"));
     }
 
     LogPrintf(" - ATV: %s\n", request.params[0].get_str());
-    auto atv = ParseHexV(request.params[0], "atv");
+    pub.atv = ParseHexV(request.params[0], "atv");
 
-    return doSubmitPop(atv, vtbs);
+    return doSubmitPop(pub);
 }
 
 UniValue RpcServiceImpl::getpopdata(const JSONRPCRequest& request)
@@ -171,28 +171,43 @@ UniValue RpcServiceImpl::doGetPopData(int height, const std::shared_ptr<CWallet>
     return result;
 }
 
-UniValue RpcServiceImpl::doSubmitPop(const std::vector<uint8_t>& atv,
-    const std::vector<std::vector<uint8_t>>& vtbs)
+UniValue RpcServiceImpl::updatecontext(const JSONRPCRequest& request)
 {
-    LOCK(cs_main);
-
-    CMutableTransaction tx;
+    if (request.fHelp || request.params.size() != 2)
+        throw std::runtime_error(
+            "updatecontext bitcoin_blocks veriblock_blocks\n"
+            "\nAdds into the alt-integration service database bitcoin and veriblock blocks.\n"
+            "\nArguments:\n"
+            "1. bitcoin_blocks       (array, required) Array of hex-encoded Bitcoin records.\n"
+            "2. veriblock_blocks      (array, required) Array of hex-encoded VeriBlock records.\n"
+            "\nResult:\n"
+            "             (string) \"Transaction hash\"\n"
+            "\nExamples:\n" +
+            HelpExampleCli("updatecontext", "[BitcoinBlock_1 BitcoinBlock_2] [VeriBlock_1 VeriBlock_2]") + HelpExampleRpc("updatecontext", "[BitcoinBlock_1, BitcoinBlock_2 ...], [VeriBlock_1, VeriBlock_2 ...]"));
 
-    tx.vout.resize(1);
-    tx.vout[0].nValue = 0;
-    tx.vout[0].scriptPubKey << OP_RETURN;
+    RPCTypeCheck(request.params, {UniValue::VARR, UniValue::VARR});
 
-    tx.vin.resize(1);
-    VeriBlock::setVBKNoInput(tx.vin[0].prevout);
+    Context ctx;
+    const UniValue& bitcoin_array = request.params[0].get_array();
+    std::vector<std::vector<uint8_t>> bitcoin_blocks;
+    for (uint32_t idx = 0u, size = bitcoin_array.size(); idx < size; ++idx) {
+        ctx.btc.emplace_back(ParseHexV(bitcoin_array[idx], "btc[" + std::to_string(idx) + "]"));
+    }
 
-    tx.vin[0].scriptSig << atv << OP_CHECKATV;
-    for (const auto& vtb : vtbs) {
-        tx.vin[0].scriptSig << vtb << OP_CHECKVTB;
+    const UniValue& veriblock_array = request.params[1].get_array();
+    std::vector<std::vector<uint8_t>> veriblock_blocks;
+    for (uint32_t idx = 0u, size = veriblock_array.size(); idx < size; ++idx) {
+        ctx.vbk.emplace_back(ParseHexV(veriblock_array[idx], "vbk[" + std::to_string(idx) + "]"));
     }
 
-    tx.vin[0].scriptSig << OP_CHECKPOP;
+    return doUpdateContext(ctx);
+}
+
+UniValue RpcServiceImpl::createPopTx(const CScript& scriptSig)
+{
+    LOCK(cs_main);
 
-    assert(VeriBlock::isPopTx(CTransaction(tx)));
+    auto tx = VeriBlock::MakePopTx(scriptSig);
 
     const uint256& hashTx = tx.GetHash();
     if (!::mempool.exists(hashTx)) {
@@ -216,38 +231,31 @@ UniValue RpcServiceImpl::doSubmitPop(const std::vector<uint8_t>& atv,
     return hashTx.GetHex();
 }
 
-UniValue RpcServiceImpl::updatecontext(const JSONRPCRequest& request)
+UniValue RpcServiceImpl::doUpdateContext(const Context& ctx)
 {
-    if (request.fHelp || request.params.size() != 2)
-        throw std::runtime_error(
-            "updatecontext ( bitcoin_blocks veriblock_blocks )\n"
-            "\nAdds into the alt-integration service database bitcoin and veriblock blocks.\n"
-            "\nArguments:\n"
-            "1. bitcoin_blocks       (array, required) Array of hex-encoded Bitcoin records.\n"
-            "2. veriblock_blocks      (array, required) Array of hex-encoded VeriBlock records.\n"
-            "\nResult:\n"
-            "             (string) \"Bitcoin and VeriBlock bloks were added\"\n"
-            "\nExamples:\n" +
-            HelpExampleCli("updatecontext", "[BitcoinBlock_1 BitcoinBlock_2] [VeriBlock_1 VeriBlock_2]") + HelpExampleRpc("submitpop", "[BitcoinBlock_1, BitcoinBlock_2 ...], [VeriBlock_1, VeriBlock_2 ...]"));
-
-    RPCTypeCheck(request.params, {UniValue::VARR, UniValue::VARR});
-
-    const UniValue& bitcoin_array = request.params[0].get_array();
-    std::vector<std::vector<uint8_t>> bitcoin_blocks;
-    for (uint32_t idx = 0u, size = bitcoin_array.size(); idx < size; ++idx) {
-        bitcoin_blocks.emplace_back(ParseHexV(bitcoin_array[idx], "vtb[" + std::to_string(idx) + "]"));
+    CScript script;
+    for (const auto& btc : ctx.btc) {
+        script << btc << OP_POPBTCHEADER;
     }
 
-    const UniValue& veriblock_array = request.params[1].get_array();
-    std::vector<std::vector<uint8_t>> veriblock_blocks;
-    for (uint32_t idx = 0u, size = veriblock_array.size(); idx < size; ++idx) {
-        veriblock_blocks.emplace_back(ParseHexV(veriblock_array[idx], "vtb[" + std::to_string(idx) + "]"));
+    for (const auto& vbk : ctx.vbk) {
+        script << vbk << OP_POPVBKHEADER;
     }
 
-    auto& service = getService<PopService>();
-    service.updateContext(veriblock_blocks, bitcoin_blocks);
+    script << OP_CHECKPOP;
+
+    return createPopTx(script);
+}
 
-    return "Bitcoin and VeriBlock bloks were added";
+UniValue RpcServiceImpl::doSubmitPop(const Publications& pub)
+{
+    CScript script;
+    script << pub.atv << OP_CHECKATV;
+    for (const auto& vtb : pub.vtbs) {
+        script << vtb << OP_CHECKVTB;
+    }
+    script << OP_CHECKPOP;
+    return createPopTx(script);
 }
 
 RpcServiceImpl::RpcServiceImpl(CConnman* connman)
diff --git a/src/vbk/rpc_service/rpc_service_impl.hpp b/src/vbk/rpc_service/rpc_service_impl.hpp
index 9b7a63662eca1..9ae9a110bdef8 100644
--- a/src/vbk/rpc_service/rpc_service_impl.hpp
+++ b/src/vbk/rpc_service/rpc_service_impl.hpp
@@ -31,6 +31,10 @@ class RpcServiceImpl : public RpcService
     UniValue doSubmitPop(const std::vector<uint8_t>& atv,
         const std::vector<std::vector<uint8_t>>& vtbs);
 
+    UniValue createPopTx(const CScript& scriptSig);
+    UniValue doUpdateContext(const Context& ctx);
+    UniValue doSubmitPop(const Publications& pub);
+
     CConnman* connman;
 };
 
diff --git a/src/vbk/test/integration/grpc_integration_service.hpp b/src/vbk/test/integration/grpc_integration_service.hpp
index 5d497c478f377..10d923f22148e 100644
--- a/src/vbk/test/integration/grpc_integration_service.hpp
+++ b/src/vbk/test/integration/grpc_integration_service.hpp
@@ -31,4 +31,4 @@ class GrpcIntegrationService
     std::vector<uint8_t> serializePublicationData(const VeriBlock::PublicationData& publicationData);
 };
 } // namespace VeriBlock
-#endif
+#endif // VERIBLOCK_INTEGRATION_TEST_VALIDATION_SERVICE_H
diff --git a/src/vbk/test/integration/rpc_tests.cpp b/src/vbk/test/integration/rpc_tests.cpp
index 5ca24b0d7f794..d8a0bf659cb05 100644
--- a/src/vbk/test/integration/rpc_tests.cpp
+++ b/src/vbk/test/integration/rpc_tests.cpp
@@ -16,6 +16,11 @@ struct IntegrationTextFixture : public TestChain100Setup {
 
     IntegrationTextFixture() : TestChain100Setup()
     {
+        VeriBlock::Config& config = VeriBlock::getService<VeriBlock::Config>();
+        config.bootstrap_bitcoin_blocks = {"000212B90002500640D2DCFDD047AF3F197C2BB743C05C2619919657462191847838E067A540836ABBE2C5AB1AA8DA98602D68C05DFB5C010405F5E1584D4024", "000212BA0002539544FC18F77FD997B080D52BB743C05C2619919657462191847838E067FF19E383F41F4B8A586142E47DB3B6225DFB5C080405F5E15876C544", "000212BB0002304FB9683DAFC9396A7F36492BB743C05C2619919657462191847838E067A87CF5F304B4E102B104320C5CBA33B85DFB5C500405F5E15A2670DE", "000212BC00025870BF9AD09BF0137D74551A2BB743C05C2619919657462191847838E06718A87B5E2923426270A6554112B0A7945DFB5C930405F5E1265B82D7", "000212BD000221C1F97385FB4F50D012571E2BB743C05C2619919657462191847838E067AAE01CA8E166338760880FC2C68466645DFB5CE60405F5E15DA9ACE9", "000212BE00025DB805D6B59D588982F60CF92BB743C05C2619919657462191847838E06703925057C5DC7A36080403CD446EF1B95DFB5E2F0405F5E1656929E3", "000212BF00024B0D40593576A382CD58DA5E2BB743C05C2619919657462191847838E0673C67D352F821E84195F9393C70A37BA15DFB5E7F0405F5E13425A20A", "000212C000022E28E85F3B565A9CE3A6D36F2BB743C05C2619919657462191847838E067B9321B6449970FB663B56210261D2AE75DFB5E800405F5E16742DE63", "000212C100022EABFB8FAF228721BA705F282BB743C05C2619919657462191847838E067C1D55AED879E3C2A39AD3DA4C72AA32C5DFB5EA10405F5E1351804AE", "000212C20002D918744D237CB620F05C04CB2BB743C05C2619919657462191847838E0673EFCD8817DD5C7DC3F71BCC71C992C1D5DFB5F0F0405F5E1382F2CCB", "000212C30002083EB27D9F62BE9FC7E178472BB743C05C2619919657462191847838E067AC554CC2C3E2942460A742093FA20F8D5DFB5F100405F5E138362725", "000212C4000282B9C1AF739155679954D27D2BB743C05C2619919657462191847838E067CEC2574589471F8635D3C85BC56803245DFB5F120405F5E13843B8A3", "000212C500028BD2113E1525CF7B7176DF782BB743C05C2619919657462191847838E0671B597D4BAE12B2A71CF670D6910608DF5DFB5F3C0405F5E139720FCD", "000212C600022E6EB382CD9D47641B43314C2BB743C05C2619919657462191847838E067073821D2D8891A8610B8C18897ED065A5DFB5F570405F5E16A8BEC2E", "000212C70002C1B622B7A4AB48CA23EAB9242BB743C05C2619919657462191847838E06731D8269A8DF296193B158E7059DA3E3C5DFB5FBF0405F5E16EC2628B"};
+        config.bitcoin_first_block_height = 1610826;
+        config.bootstrap_veriblock_blocks = {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};
+
         VeriBlock::InitPopService();
     }
 };
@@ -128,10 +133,10 @@ BOOST_AUTO_TEST_CASE(updatecontext_test)
 
     // These values was taken from the alt-integration service default properties file and also was removed from that file
     UniValue veriblock_blocks(UniValue::VARR);
-    veriblock_blocks.push_back("00019C9A00026713D7DDB273B344AADD06BF9AFD32E075F6BEC5BADF97549B10936A8468C8CF8CE7253035B52DDE7A1B1CEDD3BC5DE540480405F5E10E87A0F1");
+    veriblock_blocks.push_back("000212C80002129B6280D651E9FC3D46799D2BB743C05C2619919657462191847838E067718CC361844278EAB1BD9E1FB387D0F45DFB5FC70405F5E16DAF3C66");
 
     UniValue bitcoin_blocks(UniValue::VARR);
-    bitcoin_blocks.push_back("00000020b15d70ede23ca82d38a9418914d836cf75251b8027b9a9d53c02000000000000d455849c387207d5b3ca9577796874dcdf22e5a31e6bdc8b15a6aaaf44e7de1f7a3ee55dffff001d31f589dc");
+    bitcoin_blocks.push_back("00000020E2EEC323DA41F7F3387E8E4F1BF313EDFD2247788CBA378900040000000000002878DE94F86A20B384C0B0FC6BAAD61EBB0DCDC7126684072CCAD3EE624905060F60FB5DFFFF001B2CBAA52B");
 
     request.params.push_back(bitcoin_blocks);
     request.params.push_back(veriblock_blocks);
diff --git a/src/vbk/test/integration/test_setup.cpp b/src/vbk/test/integration/test_setup.cpp
index c21f40eb03c5a..a4cfc1f6cf3e7 100644
--- a/src/vbk/test/integration/test_setup.cpp
+++ b/src/vbk/test/integration/test_setup.cpp
@@ -1,133 +1,12 @@
 #include <vbk/test/integration/test_setup.hpp>
 
+#include <chain.h>
+#include <vbk/entity/pop.hpp>
 #include <vbk/init.hpp>
+#include <vbk/interpreter.hpp>
 
 using namespace fakeit;
 
-namespace {
-#define stacktop(i) (stack.at(stack.size() + (i)))
-
-inline bool set_error(ScriptError* ret, const ScriptError serror)
-{
-    if (ret)
-        *ret = serror;
-    return false;
-}
-
-inline void popstack(std::vector<std::vector<uint8_t>>& stack)
-{
-    if (stack.empty())
-        throw std::runtime_error("popstack(): stack empty");
-    stack.pop_back();
-}
-
-static bool TestEvalScript(const CScript& script, std::vector<std::vector<uint8_t>>& stack, ScriptError* serror, VeriBlock::Publications* ret, bool with_checks)
-{
-    CScript::const_iterator pc = script.begin();
-    CScript::const_iterator pend = script.end();
-    static const std::vector<uint8_t> vchFalse(0);
-    static const std::vector<uint8_t> vchTrue(1, 1);
-    opcodetype opcode;
-    std::vector<unsigned char> vchPushValue;
-    auto& config = VeriBlock::getService<VeriBlock::Config>();
-    auto& pop = VeriBlock::getService<VeriBlock::PopService>();
-    VeriBlock::Publications pub;
-
-    if (script.size() > config.max_pop_script_size) {
-        return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
-    }
-
-    size_t maxPushSize = std::max(config.max_atv_size, config.max_vtb_size);
-    size_t minPushSize = std::min(config.min_atv_size, config.min_vtb_size);
-    try {
-        while (pc < pend) {
-            if (!script.GetOp(pc, opcode, vchPushValue)) {
-                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-            }
-
-            if (!vchPushValue.empty()) {
-                // we don't know if it is ATV or VTB yet, so do sanity check here
-                if (vchPushValue.size() > maxPushSize || vchPushValue.size() < minPushSize) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-                stack.push_back(vchPushValue);
-                continue;
-            }
-
-            // at this point, opcode is always one of these 3
-            switch (opcode) {
-            case OP_CHECKATV: {
-                // tx has one ATV
-                if (!pub.atv.empty()) {
-                    return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-                }
-
-                // validate ATV size
-                const auto& el = stacktop(-1);
-                if (el.size() > config.max_atv_size || el.size() < config.min_atv_size) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-
-                // validate ATV content
-                if (with_checks && !pop.checkATVinternally(el)) {
-                    return set_error(serror, SCRIPT_ERR_VBK_ATVFAIL);
-                }
-
-                pub.atv = el;
-                popstack(stack);
-                break;
-            }
-            case OP_CHECKVTB: {
-                // validate VTB size
-                const auto& el = stacktop(-1);
-                if (el.size() > config.max_vtb_size || el.size() < config.min_vtb_size) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-
-                // validate VTB content
-                if (with_checks && !pop.checkVTBinternally(el)) {
-                    return set_error(serror, SCRIPT_ERR_VBK_VTBFAIL);
-                }
-
-                // tx has many VTBs
-                pub.vtbs.push_back(el);
-                popstack(stack);
-                break;
-            }
-            case OP_CHECKPOP: {
-                // OP_CHECKPOP should be last opcode
-                if (script.GetOp(pc, opcode, vchPushValue)) {
-                    // we could read next opcode. extra opcodes is an error
-                    return set_error(serror, SCRIPT_ERR_VBK_EXTRA_OPCODE);
-                }
-
-                // stack should be empty at this point
-                if (!stack.empty()) {
-                    return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
-                }
-
-                // we did all checks, put true on stack to signal successful execution
-                stack.push_back(vchTrue);
-                break;
-            }
-            default:
-                // forbid any other opcodes in pop transactions
-                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-            }
-        }
-    } catch (...) {
-        return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
-    }
-
-    // set return value
-    if (ret != nullptr) {
-        *ret = pub;
-    }
-
-    return true;
-}
-} // namespace
-
 namespace VeriBlockTest {
 
 IntegrationTestFixture::IntegrationTestFixture() : TestChain100Setup()
@@ -136,16 +15,16 @@ IntegrationTestFixture::IntegrationTestFixture() : TestChain100Setup()
         return util_service_impl.compareForks(left, right);
     });
     When(Method(util_service_mock, CheckPopInputs)).AlwaysReturn(true);
-    When(Method(util_service_mock, EvalScript)).AlwaysDo([&](const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, VeriBlock::Publications* pub, bool with_checks) -> bool {
-        return ::TestEvalScript(script, stack, serror, pub, with_checks);
+    When(Method(util_service_mock, EvalScript)).AlwaysDo([&](const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, VeriBlock::Publications* pub, VeriBlock::Context* ctx, VeriBlock::PopTxType* type, bool with_checks) -> bool {
+        return VeriBlock::EvalScriptImpl(script, stack, serror, pub, ctx, type, with_checks);
     });
     When(Method(util_service_mock, validatePopTx)).AlwaysReturn(true);
     When(Method(util_service_mock, checkCoinbaseTxWithPopRewards)).AlwaysReturn(true);
-    When(Method(util_service_mock, getPopRewards)).AlwaysDo([&](const CBlockIndex& pindexPrev) -> VeriBlock::PoPRewards {
-        return util_service_impl.getPopRewards(pindexPrev);
+    When(Method(util_service_mock, getPopRewards)).AlwaysDo([&](const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) -> VeriBlock::PoPRewards {
+        return util_service_impl.getPopRewards(pindexPrev, consensusParams);
     });
-    When(Method(util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) -> void {
-        return util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev);
+    When(Method(util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) -> void {
+        return util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev, consensusParams);
     });
 
     When(Method(util_service_mock, makeTopLevelRoot)).AlwaysDo([&](int height, const VeriBlock::KeystoneArray& keystones, const uint256& txRoot) -> uint256 {
@@ -158,9 +37,14 @@ IntegrationTestFixture::IntegrationTestFixture() : TestChain100Setup()
 
     VeriBlockTest::setServiceMock<VeriBlock::UtilService>(util_service_mock);
 
-    VeriBlock::GrpcIntegrationService* validationService = new VeriBlock::GrpcIntegrationService();
+    auto* validationService = new VeriBlock::GrpcIntegrationService();
     VeriBlock::setService<VeriBlock::GrpcIntegrationService>(validationService);
 
+    VeriBlock::Config& config = VeriBlock::getService<VeriBlock::Config>();
+    config.bootstrap_bitcoin_blocks = {"010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010270000FFFF7F2000000000"};
+    config.bitcoin_first_block_height = 1610826;
+    config.bootstrap_veriblock_blocks = {"00000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000027100101000000000000"};
+
     VeriBlock::InitPopService();
 
     VeriBlockTest::setUpGenesisBlocks();
diff --git a/src/vbk/test/integration/utils.hpp b/src/vbk/test/integration/utils.hpp
index 9028f260f0091..cb4d84500fb37 100644
--- a/src/vbk/test/integration/utils.hpp
+++ b/src/vbk/test/integration/utils.hpp
@@ -16,4 +16,5 @@ void setUpGenesisBlocks();
 
 VeriBlock::AltPublication generateSignedAltPublication(const CBlock& endorsedBlock, const uint32_t& identifier, const CScript& payoutInfo);
 } // namespace VeriBlockTest
+
 #endif
diff --git a/src/vbk/test/unit/block_validation_tests.cpp b/src/vbk/test/unit/block_validation_tests.cpp
new file mode 100644
index 0000000000000..af150b69580d8
--- /dev/null
+++ b/src/vbk/test/unit/block_validation_tests.cpp
@@ -0,0 +1,95 @@
+#include <boost/test/unit_test.hpp>
+#include <chainparams.h>
+#include <consensus/validation.h>
+#include <test/util/setup_common.h>
+#include <validation.h>
+
+#include <vbk/config.hpp>
+#include <vbk/init.hpp>
+#include <vbk/pop_service.hpp>
+#include <vbk/service_locator.hpp>
+#include <vbk/test/util/tx.hpp>
+#include <vbk/util_service.hpp>
+
+#include <string>
+
+#include <fakeit.hpp>
+using namespace fakeit;
+
+inline std::vector<uint8_t> operator""_v(const char* s, size_t size)
+{
+    return std::vector<uint8_t>{s, s + size};
+}
+
+struct BlockValidationFixture : public TestChain100Setup {
+    fakeit::Mock<VeriBlock::PopServiceImpl> pop_impl_mock;
+
+    CScript cbKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+
+    std::vector<uint8_t> btc_header = std::vector<uint8_t>(80, 1);
+    std::vector<uint8_t> vbk_header = std::vector<uint8_t>(64, 2);
+
+    CScript ctxscript = (CScript() << vbk_header << OP_POPVBKHEADER << btc_header << OP_POPBTCHEADER << OP_CHECKPOP);
+    CScript pubscript = (CScript() << "ATV"_v << OP_CHECKATV << "VTB"_v << OP_CHECKVTB << OP_CHECKPOP);
+
+    BlockValidationFixture()
+    {
+        VeriBlock::InitConfig();
+        VeriBlock::InitUtilService();
+
+        CBlockIndex* endorsedBlockIndex = ChainActive().Tip()->pprev;
+        CBlock endorsedBlock;
+        BOOST_CHECK(ReadBlockFromDisk(endorsedBlock, endorsedBlockIndex, Params().GetConsensus()));
+
+        stream = std::make_shared<CDataStream>(SER_NETWORK, PROTOCOL_VERSION);
+        *stream << endorsedBlock.GetBlockHeader();
+    };
+
+    std::shared_ptr<CDataStream> stream;
+};
+
+BOOST_AUTO_TEST_SUITE(block_validation_tests)
+
+
+BOOST_FIXTURE_TEST_CASE(BlockWithBothPopTxes, BlockValidationFixture)
+{
+    auto& config = VeriBlock::getService<VeriBlock::Config>();
+
+    When(OverloadedMethod(pop_impl_mock, getPublicationsData, void(const VeriBlock::Publications&, VeriBlock::PublicationData&)))
+        .Do([&](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
+            publicationData.set_identifier(config.index.unwrap());
+            publicationData.set_header(stream->data(), stream->size());
+        });
+    When(Method(pop_impl_mock, parsePopTx)).AlwaysDo([](const CTransactionRef& tx, VeriBlock::Publications* pub, VeriBlock::Context* ctx, VeriBlock::PopTxType* type) -> bool {
+        std::vector<std::vector<uint8_t>> stack;
+        return VeriBlock::EvalScriptImpl(tx->vin[0].scriptSig, stack, nullptr, pub, ctx, type, false);
+    });
+    When(Method(pop_impl_mock, determineATVPlausibilityWithBTCRules)).AlwaysReturn(true);
+    Fake(Method(pop_impl_mock, addPayloads));
+    Fake(Method(pop_impl_mock, updateContext));
+
+    When(Method(pop_service_mock, checkVTBinternally)).AlwaysReturn(true);
+    When(Method(pop_service_mock, checkATVinternally)).AlwaysReturn(true);
+    When(Method(pop_service_mock, blockPopValidation)).AlwaysDo([&](const CBlock& block, const CBlockIndex& pindexPrev, const Consensus::Params& params, BlockValidationState& state) -> bool {
+        return VeriBlock::blockPopValidationImpl(pop_impl_mock.get(), block, pindexPrev, params, state);
+    });
+
+    VeriBlock::Context ctx;
+    ctx.btc.push_back(btc_header);
+    ctx.vbk.push_back(vbk_header);
+
+    CMutableTransaction ctxtx = VeriBlock::MakePopTx(ctxscript);
+    CMutableTransaction pubtx = VeriBlock::MakePopTx(pubscript);
+
+    auto block = CreateAndProcessBlock({ctxtx, pubtx}, cbKey);
+
+    BOOST_CHECK(block.vtx.size() == 3);
+    BOOST_CHECK(block.vtx[0]->IsCoinBase());
+    BOOST_CHECK(*block.vtx[1] == CTransaction(ctxtx));
+    BOOST_CHECK(*block.vtx[2] == CTransaction(pubtx));
+
+    Verify_Method(Method(pop_service_mock, checkATVinternally) + Method(pop_service_mock, checkVTBinternally)).Exactly(1);
+    Verify_Method(Method(pop_impl_mock, updateContext)).Exactly(1);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/src/vbk/test/unit/pop_interpreter_tests.cpp b/src/vbk/test/unit/pop_interpreter_tests.cpp
new file mode 100644
index 0000000000000..0809874a053fa
--- /dev/null
+++ b/src/vbk/test/unit/pop_interpreter_tests.cpp
@@ -0,0 +1,212 @@
+#include <boost/test/unit_test.hpp>
+#include <consensus/validation.h>
+#include <script/interpreter.h>
+#include <string>
+#include <test/util/setup_common.h>
+#include <validation.h>
+#include <vbk/config.hpp>
+#include <vbk/init.hpp>
+#include <vbk/pop_service.hpp>
+#include <vbk/service_locator.hpp>
+#include <vbk/test/util/mock.hpp>
+#include <vbk/test/util/tx.hpp>
+#include <vbk/util.hpp>
+#include <vbk/util_service/util_service_impl.hpp>
+
+#include <fakeit.hpp>
+
+using namespace fakeit;
+
+BOOST_AUTO_TEST_SUITE(pop_interpreter_tests)
+
+template <typename Stream>
+Stream& operator<<(Stream&& s, std::string data)
+{
+    return s << std::vector<uint8_t>{data.begin(), data.end()};
+}
+
+inline std::vector<uint8_t> operator""_v(const char* c, size_t s)
+{
+    return std::vector<uint8_t>{c, c + s};
+}
+
+struct EvalScriptFixture {
+    static std::string str(const std::vector<uint8_t>& v)
+    {
+        return std::string{v.begin(), v.end()};
+    }
+
+    static bool CastToBool(const std::vector<uint8_t>& vch)
+    {
+        for (unsigned int i = 0; i < vch.size(); i++) {
+            if (vch[i] != 0) {
+                // Can be negative zero
+                if (i == vch.size() - 1 && vch[i] == 0x80)
+                    return false;
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    EvalScriptFixture()
+    {
+        VeriBlockTest::setServiceMock<VeriBlock::PopService>(pop);
+
+        config.min_atv_size = 1;
+        config.max_atv_size = 10;
+        config.min_vtb_size = 1;
+        config.max_vtb_size = 10;
+        config.max_pop_script_size = 1000;
+        config.btc_header_size = 3;
+        config.vbk_header_size = 4;
+
+        When(Method(pop, checkATVinternally)).AlwaysReturn(true);
+        When(Method(pop, checkVTBinternally)).AlwaysReturn(true);
+    }
+
+    Mock<VeriBlock::PopService> pop;
+    VeriBlock::UtilService& util{VeriBlock::InitUtilService()};
+    VeriBlock::Config& config{VeriBlock::InitConfig()};
+
+    std::vector<std::vector<uint8_t>> stack{};
+    VeriBlock::Publications pub{};
+    VeriBlock::Context ctx{};
+    VeriBlock::PopTxType type{};
+    ScriptError serror{};
+    CScript script = CScript()
+        << "ATV" << OP_CHECKATV
+        << "VTB1" << OP_CHECKVTB
+        << "VTB2" << OP_CHECKVTB
+        << "VTB3" << OP_CHECKVTB
+        << OP_CHECKPOP;
+};
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_valid, EvalScriptFixture)
+{
+    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub, &ctx, &type, true));
+    BOOST_REQUIRE(!stack.empty());
+    BOOST_CHECK(type == VeriBlock::PopTxType::PUBLICATIONS);
+    BOOST_CHECK(CastToBool(stack.back()));
+    BOOST_CHECK(pub.atv == "ATV"_v);
+    BOOST_CHECK(pub.vtbs.size() == 3);
+    BOOST_CHECK(pub.vtbs[0] == "VTB1"_v);
+    BOOST_CHECK(pub.vtbs[1] == "VTB2"_v);
+    BOOST_CHECK(pub.vtbs[2] == "VTB3"_v);
+    Verify_Method(Method(pop, checkATVinternally)).Once();
+    Verify_Method(Method(pop, checkVTBinternally)).Exactly(3);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_atv_size_invalid, EvalScriptFixture)
+{
+    config.min_atv_size = 10; // more than 3
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+    config.min_atv_size = 0;
+    config.max_atv_size = 1; // less than 3
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_vtb_size_invalid, EvalScriptFixture)
+{
+    config.min_vtb_size = 10; // more than 4
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+    config.min_vtb_size = 0;
+    config.max_vtb_size = 2; // less than 4
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_only_atv, EvalScriptFixture)
+{
+    script = CScript() << "ATV" << OP_CHECKATV << OP_CHECKPOP;
+    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub, &ctx, &type, true));
+    BOOST_REQUIRE(!stack.empty());
+    BOOST_CHECK(type == VeriBlock::PopTxType::PUBLICATIONS);
+    BOOST_CHECK(CastToBool(stack.back()));
+    BOOST_CHECK(pub.vtbs.empty());
+    BOOST_CHECK(pub.atv == "ATV"_v);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_only_vtbs, EvalScriptFixture)
+{
+    script = CScript() << "VTB1" << OP_CHECKVTB << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_VBK_ATVFAIL);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_out_of_order, EvalScriptFixture)
+{
+    script = CScript() << "VTB1" << OP_CHECKVTB << "ATV" << OP_CHECKATV << "VTB2" << OP_CHECKVTB << OP_CHECKPOP;
+    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub, &ctx, &type, true));
+    BOOST_REQUIRE(!stack.empty());
+    BOOST_CHECK(CastToBool(stack.back()));
+    BOOST_CHECK(pub.atv == "ATV"_v);
+    BOOST_CHECK(pub.vtbs.size() == 2);
+    BOOST_CHECK(pub.vtbs[0] == "VTB1"_v);
+    BOOST_CHECK(pub.vtbs[1] == "VTB2"_v);
+    BOOST_CHECK(type == VeriBlock::PopTxType::PUBLICATIONS);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_too_big, EvalScriptFixture)
+{
+    config.max_pop_script_size = 10;
+    script = CScript() << "this is too long, I can not handle script this long" << OP_CHECKVTB << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_SCRIPT_SIZE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_checkpop_is_not_last, EvalScriptFixture)
+{
+    script = CScript() << "ATV" << OP_CHECKATV << "VTB" << OP_CHECKVTB << OP_CHECKPOP << "VTB2";
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_VBK_EXTRA_OPCODE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_checkpop_stack_is_not_empty, EvalScriptFixture)
+{
+    // missing OP_CHECKATV
+    script = CScript() << "ATV"
+                       << "VTB" << OP_CHECKVTB << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, true));
+    BOOST_CHECK(serror == SCRIPT_ERR_EVAL_FALSE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_only_context_valid, EvalScriptFixture)
+{
+    script = CScript() << "btc" << "vbk1" << OP_POPVBKHEADER << "vbk2" << OP_POPVBKHEADER << OP_POPBTCHEADER << OP_CHECKPOP;
+    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub, &ctx, &type, false));
+    BOOST_CHECK(type == VeriBlock::PopTxType::CONTEXT);
+    BOOST_CHECK(ctx.btc.size() == 1);
+    BOOST_CHECK(ctx.btc[0] == "btc"_v);
+    BOOST_CHECK(ctx.vbk.size() == 2);
+    BOOST_CHECK(ctx.vbk[0] == "vbk1"_v);
+    BOOST_CHECK(ctx.vbk[1] == "vbk2"_v);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_mixed_pub_and_context, EvalScriptFixture)
+{
+    script = CScript() << "ATV" << OP_CHECKATV << "VTB" << OP_CHECKVTB << "btc" << "vbk1" << OP_POPVBKHEADER << "vbk2" << OP_POPVBKHEADER << OP_POPBTCHEADER << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, false));
+    BOOST_CHECK(serror == SCRIPT_ERR_BAD_OPCODE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_ctx_invalid_size_vbk, EvalScriptFixture)
+{
+    script = CScript() << "btc" << "veriblock header that is not equalto expected size" << OP_POPVBKHEADER << "vbk2" << OP_POPVBKHEADER << OP_POPBTCHEADER << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, false));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+}
+
+BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_ctx_invalid_size_btc, EvalScriptFixture)
+{
+    script = CScript() << "bitcoin header that is not equal to expected size" << OP_POPBTCHEADER << "vbk2" << OP_POPVBKHEADER << OP_CHECKPOP;
+    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr, nullptr, nullptr, false));
+    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/vbk/test/unit/pop_reward_tests.cpp b/src/vbk/test/unit/pop_reward_tests.cpp
index 6531433aeedec..72e44c456d142 100644
--- a/src/vbk/test/unit/pop_reward_tests.cpp
+++ b/src/vbk/test/unit/pop_reward_tests.cpp
@@ -6,12 +6,33 @@
 #include <validation.h>
 #include <wallet/wallet.h>
 
+#include <vbk/config.hpp>
+#include <vbk/pop_service/pop_service_impl.hpp>
 #include <vbk/service_locator.hpp>
 #include <vbk/test/util/mock.hpp>
 
 #include <fakeit.hpp>
 using namespace fakeit;
 
+struct PopRewardsTestFixture : public TestChain100Setup, VeriBlockTest::ServicesFixture {
+    //VeriBlockTest::ServicesFixture  service_fixture;
+
+    PopRewardsTestFixture()
+    {
+        When(Method(util_service_mock, getPopRewards)).AlwaysDo([&](const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) {
+            return util_service_impl.getPopRewards(pindexPrev, consensusParams);
+        });
+
+        When(Method(util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) {
+            util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev, consensusParams);
+        });
+
+        When(Method(util_service_mock, checkCoinbaseTxWithPopRewards)).AlwaysDo([&](const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams, BlockValidationState& state) -> bool {
+            return util_service_impl.checkCoinbaseTxWithPopRewards(tx, PoWBlockReward, pindexPrev, consensusParams, state);
+        });
+    }
+};
+
 BOOST_AUTO_TEST_SUITE(pop_reward_tests)
 
 static VeriBlock::PoPRewards getRewards()
@@ -30,80 +51,94 @@ static VeriBlock::PoPRewards getRewards()
     return rewards;
 }
 
-
-BOOST_FIXTURE_TEST_CASE(addPopPayoutsIntoCoinbaseTx_test, TestChain100Setup)
+BOOST_FIXTURE_TEST_CASE(addPopPayoutsIntoCoinbaseTx_test, PopRewardsTestFixture)
 {
-    VeriBlockTest::ServicesFixture serviceFixture;
-
-    VeriBlock::PoPRewards rewards = getRewards();
+    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
 
-    When(Method(serviceFixture.util_service_mock, getPopRewards)).AlwaysDo([&rewards](const CBlockIndex& pindexPrev) -> VeriBlock::PoPRewards {
-        return rewards;
-    });
+    while (ChainActive().Height() < VeriBlock::getService<VeriBlock::Config>().POP_REWARD_PAYMENT_DELAY) {
+        CreateAndProcessBlock({}, scriptPubKey);
+    }
 
-    When(Method(serviceFixture.util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&serviceFixture](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) {
-        serviceFixture.util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev);
+    VeriBlock::PoPRewards rewards = getRewards();
+    When(Method(pop_service_mock, rewardsCalculateOutputs)).AlwaysDo([&rewards](const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) {
+        outputs = rewards;
     });
 
-    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CBlock block = CreateAndProcessBlock({}, scriptPubKey);
 
-    CAmount PoWReward = GetBlockSubsidy(ChainActive().Height(), Params().GetConsensus());
-
-    BOOST_CHECK((PoWReward + 105) == block.vtx[0]->GetValueOut());
-
-    for (auto i = 0u; i < rewards.size(); ++i) {
-        CScript payoutInfo = block.vtx[0]->vout[i + 1].scriptPubKey;
-        BOOST_CHECK(block.vtx[0]->vout[i + 1].nValue == rewards[payoutInfo]);
+    int n = 0;
+    for (const auto& out : block.vtx[0]->vout) {
+        if (rewards.find(out.scriptPubKey) != rewards.end()) {
+            n++;
+        }
     }
+    // have found 4 pop rewards
+    BOOST_CHECK(n == 4);
 }
 
-BOOST_FIXTURE_TEST_CASE(checkCoinbaseTxWithPopRewards, TestChain100Setup)
+BOOST_FIXTURE_TEST_CASE(checkCoinbaseTxWithPopRewards, PopRewardsTestFixture)
 {
-    VeriBlockTest::ServicesFixture serviceFixture;
-
-    VeriBlock::PoPRewards rewards = getRewards();
-
-    When(Method(serviceFixture.util_service_mock, getPopRewards)).AlwaysDo([rewards](const CBlockIndex& pindexPrev) -> VeriBlock::PoPRewards {
-        return rewards;
-    });
+    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
 
-    When(Method(serviceFixture.util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&serviceFixture](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) {
-        serviceFixture.util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev);
-    });
+    while (ChainActive().Height() < VeriBlock::getService<VeriBlock::Config>().POP_REWARD_PAYMENT_DELAY) {
+        CreateAndProcessBlock({}, scriptPubKey);
+    }
 
-    When(Method(serviceFixture.util_service_mock, checkCoinbaseTxWithPopRewards)).AlwaysDo([&serviceFixture](const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, BlockValidationState& state) -> bool {
-        return serviceFixture.util_service_impl.checkCoinbaseTxWithPopRewards(tx, PoWBlockReward, pindexPrev, state);
+    VeriBlock::PoPRewards rewards = getRewards();
+    When(Method(pop_service_mock, rewardsCalculateOutputs)).AlwaysDo([&rewards](const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) {
+        outputs = rewards;
     });
 
-    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CBlock block = CreateAndProcessBlock({}, scriptPubKey);
 
     BOOST_CHECK(block.GetHash() == ChainActive().Tip()->GetBlockHash()); // means that pop rewards are valid
-    Verify_Method(Method(serviceFixture.util_service_mock, checkCoinbaseTxWithPopRewards)).AtLeastOnce();
+    Verify_Method(Method(util_service_mock, checkCoinbaseTxWithPopRewards)).AtLeastOnce();
 
-    When(Method(serviceFixture.util_service_mock, checkCoinbaseTxWithPopRewards)).AlwaysReturn(false);
+    When(Method(util_service_mock, checkCoinbaseTxWithPopRewards)).AlwaysReturn(false);
 
     BOOST_CHECK_THROW(CreateAndProcessBlock({}, scriptPubKey), std::runtime_error);
 
-    Verify_Method(Method(serviceFixture.util_service_mock, checkCoinbaseTxWithPopRewards)).AtLeastOnce();
+    Verify_Method(Method(util_service_mock, checkCoinbaseTxWithPopRewards)).AtLeastOnce();
 }
 
-BOOST_FIXTURE_TEST_CASE(check_wallet_balance_with_pop_reward, TestChain100Setup)
+BOOST_FIXTURE_TEST_CASE(pop_reward_halving_test, PopRewardsTestFixture)
 {
-    VeriBlockTest::ServicesFixture serviceFixture;
-
-    CAmount PoPReward = 56;
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+
+    while (ChainActive().Height() < Params().GetConsensus().nSubsidyHalvingInterval || ChainActive().Height() < VeriBlock::getService<VeriBlock::Config>().POP_REWARD_PAYMENT_DELAY) {
+        CreateAndProcessBlock({}, scriptPubKey);
+    }
+
     VeriBlock::PoPRewards rewards;
-    rewards[scriptPubKey] = PoPReward;
+    CScript pop_payout = CScript() << std::vector<uint8_t>(5, 1);
+    rewards[pop_payout] = 50;
 
-    When(Method(serviceFixture.util_service_mock, getPopRewards)).AlwaysDo([rewards](const CBlockIndex& pindexPrev) -> VeriBlock::PoPRewards {
-        return rewards;
+    When(Method(pop_service_mock, rewardsCalculateOutputs)).AlwaysDo([&rewards](const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) {
+        outputs = rewards;
     });
 
-    When(Method(serviceFixture.util_service_mock, addPopPayoutsIntoCoinbaseTx)).AlwaysDo([&serviceFixture](CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) {
-        serviceFixture.util_service_impl.addPopPayoutsIntoCoinbaseTx(coinbaseTx, pindexPrev);
+    CBlock block = CreateAndProcessBlock({}, scriptPubKey);
+
+    for (const auto& out : block.vtx[0]->vout) {
+        if (out.scriptPubKey == pop_payout) {
+            // 3 times halving (50 / 8)
+            BOOST_CHECK(6 == out.nValue);
+        }
+    }
+}
+
+BOOST_FIXTURE_TEST_CASE(check_wallet_balance_with_pop_reward, PopRewardsTestFixture)
+{
+    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+    VeriBlock::PoPRewards rewards;
+    rewards[scriptPubKey] = 56;
+
+    while (ChainActive().Height() < VeriBlock::getService<VeriBlock::Config>().POP_REWARD_PAYMENT_DELAY) {
+        CreateAndProcessBlock({}, scriptPubKey);
+    }
+
+    When(Method(pop_service_mock, rewardsCalculateOutputs)).AlwaysDo([&rewards](const int& blockHeight, const CBlockIndex& endorsedBlock, const CBlockIndex& contaningBlocksTip, const CBlockIndex* difficulty_start_interval, const CBlockIndex* difficulty_end_interval, std::map<CScript, int64_t>& outputs) {
+        outputs = rewards;
     });
 
     auto block = CreateAndProcessBlock({}, scriptPubKey);
@@ -135,8 +170,8 @@ BOOST_FIXTURE_TEST_CASE(check_wallet_balance_with_pop_reward, TestChain100Setup)
         BOOST_CHECK(result.last_failed_block.IsNull());
         BOOST_CHECK_EQUAL(result.last_scanned_block, tip->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height, tip->nHeight);
-        BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, PoWReward + PoPReward);
+        // 3 times halving (56 / 8)
+        BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, PoWReward + 7);
     }
 }
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/vbk/test/unit/pop_service_tests.cpp b/src/vbk/test/unit/pop_service_tests.cpp
index 48b4eb4a1a89d..f735ac015b5f0 100644
--- a/src/vbk/test/unit/pop_service_tests.cpp
+++ b/src/vbk/test/unit/pop_service_tests.cpp
@@ -36,7 +36,7 @@ struct PopServiceFixture : public TestChain100Setup {
         VeriBlock::InitConfig();
         Fake(Method(pop_service_impl_mock, addPayloads));
         Fake(Method(pop_service_impl_mock, removePayloads));
-        Fake(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const CTransactionRef&, VeriBlock::Publications&)));
+        When(OverloadedMethod(pop_service_impl_mock, parsePopTx, bool(const CTransactionRef&, VeriBlock::Publications*, VeriBlock::Context*, VeriBlock::PopTxType*))).AlwaysReturn(true);
         When(Method(pop_service_impl_mock, determineATVPlausibilityWithBTCRules)).AlwaysReturn(true);
     }
 };
@@ -57,8 +57,17 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test, PopServiceFixture)
 
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications&, VeriBlock::PublicationData&)))
         .Do([stream, config](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, config.index.unwrap());
-    });
+            setPublicationData(publicationData, stream, config.index.unwrap());
+        });
+
+    When(OverloadedMethod(pop_service_impl_mock, parsePopTx, bool(const CTransactionRef&, VeriBlock::Publications*, VeriBlock::Context*, VeriBlock::PopTxType*)))
+        .Do([](const CTransactionRef&, VeriBlock::Publications*, VeriBlock::Context*, VeriBlock::PopTxType* type) -> bool {
+            if (type != nullptr) {
+                *type = VeriBlock::PopTxType::PUBLICATIONS;
+            }
+            return true;
+        });
+
 
     BlockValidationState state;
     {
@@ -81,8 +90,8 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test_wrong_index, PopServiceFixture)
     // make another index
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications&, VeriBlock::PublicationData&)))
         .Do([stream](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, -1);
-    });
+            setPublicationData(publicationData, stream, -1);
+        });
 
     When(Method(pop_service_impl_mock, determineATVPlausibilityWithBTCRules)).Return(false);
 
@@ -121,8 +130,8 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test_wrong_ancestor, PopServiceFixtur
 
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData)))
         .Do([stream, config](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, config.index.unwrap());
-    });
+            setPublicationData(publicationData, stream, config.index.unwrap());
+        });
 
     {
         LOCK(cs_main);
@@ -146,8 +155,8 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test_wrong_merkleroot, PopServiceFixt
 
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData)))
         .Do([stream, config](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, config.index.unwrap());
-    });
+            setPublicationData(publicationData, stream, config.index.unwrap());
+        });
 
     When(Method(pop_service_impl_mock, determineATVPlausibilityWithBTCRules)).AlwaysReturn(true);
 
@@ -173,8 +182,8 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test_wrong_settlement_interval, PopSe
 
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData)))
         .Do([stream, config](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, config.index.unwrap());
-    });
+            setPublicationData(publicationData, stream, config.index.unwrap());
+        });
 
     config.POP_REWARD_SETTLEMENT_INTERVAL = 0;
     VeriBlock::setService<VeriBlock::Config>(new VeriBlock::Config(config));
@@ -201,11 +210,11 @@ BOOST_FIXTURE_TEST_CASE(blockPopValidation_test_wrong_addPayloads, PopServiceFix
 
     When(OverloadedMethod(pop_service_impl_mock, getPublicationsData, void(const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData)))
         .Do([stream, config](const VeriBlock::Publications& pub, VeriBlock::PublicationData& publicationData) {
-        setPublicationData(publicationData, stream, config.index.unwrap());
-    });
+            setPublicationData(publicationData, stream, config.index.unwrap());
+        });
 
     When(Method(pop_service_impl_mock, addPayloads)).AlwaysDo([](const CBlock& block, const int& nHeight, const VeriBlock::Publications& publications) -> void {
-        throw  VeriBlock::PopServiceException("fail");
+        throw VeriBlock::PopServiceException("fail");
     });
 
     BlockValidationState state;
diff --git a/src/vbk/test/unit/util_service_tests.cpp b/src/vbk/test/unit/util_service_tests.cpp
index c3c2c452b4506..53d9ad43b5047 100644
--- a/src/vbk/test/unit/util_service_tests.cpp
+++ b/src/vbk/test/unit/util_service_tests.cpp
@@ -154,149 +154,4 @@ BOOST_AUTO_TEST_CASE(RegularTxesTotalSize_test)
     BOOST_CHECK(VeriBlock::RegularTxesTotalSize(vtx) == 2);
 }
 
-template <typename Stream>
-Stream& operator<<(Stream&& s, std::string data)
-{
-    return s << std::vector<uint8_t>{data.begin(), data.end()};
-}
-
-inline std::vector<uint8_t> operator""_v(const char* c, size_t s)
-{
-    return std::vector<uint8_t>{c, c + s};
-}
-
-struct EvalScriptFixture {
-    static std::string str(const std::vector<uint8_t>& v)
-    {
-        return std::string{v.begin(), v.end()};
-    }
-
-    static bool CastToBool(const std::vector<uint8_t>& vch)
-    {
-        for (unsigned int i = 0; i < vch.size(); i++) {
-            if (vch[i] != 0) {
-                // Can be negative zero
-                if (i == vch.size() - 1 && vch[i] == 0x80)
-                    return false;
-                return true;
-            }
-        }
-        return false;
-    }
-
-
-    EvalScriptFixture()
-    {
-        VeriBlockTest::setServiceMock<VeriBlock::PopService>(pop);
-
-        config.min_atv_size = 1;
-        config.max_atv_size = 10;
-        config.min_vtb_size = 1;
-        config.max_vtb_size = 10;
-        config.max_pop_script_size = 1000;
-
-        When(Method(pop, checkATVinternally)).AlwaysReturn(true);
-        When(Method(pop, checkVTBinternally)).AlwaysReturn(true);
-    }
-
-    Mock<VeriBlock::PopService> pop;
-    VeriBlock::UtilService& util{VeriBlock::InitUtilService()};
-    VeriBlock::Config& config{VeriBlock::InitConfig()};
-
-    std::vector<std::vector<uint8_t>> stack{};
-    VeriBlock::Publications pub{};
-    ScriptError serror{};
-    CScript script = CScript()
-                     << "ATV" << OP_CHECKATV
-                     << "VTB1" << OP_CHECKVTB
-                     << "VTB2" << OP_CHECKVTB
-                     << "VTB3" << OP_CHECKVTB
-                     << OP_CHECKPOP;
-};
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_valid, EvalScriptFixture)
-{
-    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub));
-    BOOST_REQUIRE(!stack.empty());
-    BOOST_CHECK(CastToBool(stack.back()));
-    BOOST_CHECK(pub.atv == "ATV"_v);
-    BOOST_CHECK(pub.vtbs.size() == 3);
-    BOOST_CHECK(pub.vtbs[0] == "VTB1"_v);
-    BOOST_CHECK(pub.vtbs[1] == "VTB2"_v);
-    BOOST_CHECK(pub.vtbs[2] == "VTB3"_v);
-    Verify_Method(Method(pop, checkATVinternally)).Once();
-    Verify_Method(Method(pop, checkVTBinternally)).Exactly(3);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_atv_size_invalid, EvalScriptFixture)
-{
-    config.min_atv_size = 10; // more than 3
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr));
-    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
-    config.min_atv_size = 0;
-    config.max_atv_size = 1; // less than 3
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr));
-    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_vtb_size_invalid, EvalScriptFixture)
-{
-    config.min_vtb_size = 10; // more than 4
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
-    config.min_vtb_size = 0;
-    config.max_vtb_size = 2; // less than 4
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_PUSH_SIZE);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_only_atv, EvalScriptFixture)
-{
-    script = CScript() << "ATV" << OP_CHECKATV << OP_CHECKPOP;
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_VBK_VTBFAIL);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_only_vtbs, EvalScriptFixture)
-{
-    script = CScript() << "VTB1" << OP_CHECKVTB << OP_CHECKPOP;
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, nullptr));
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_out_of_order, EvalScriptFixture)
-{
-    script = CScript() << "VTB1" << OP_CHECKVTB << "ATV" << OP_CHECKATV << "VTB2" << OP_CHECKVTB << OP_CHECKPOP;
-    BOOST_CHECK(util.EvalScript(script, stack, &serror, &pub));
-    BOOST_REQUIRE(!stack.empty());
-    BOOST_CHECK(CastToBool(stack.back()));
-    BOOST_CHECK(pub.atv == "ATV"_v);
-    BOOST_CHECK(pub.vtbs.size() == 2);
-    BOOST_CHECK(pub.vtbs[0] == "VTB1"_v);
-    BOOST_CHECK(pub.vtbs[1] == "VTB2"_v);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_too_big, EvalScriptFixture)
-{
-    config.max_pop_script_size = 10;
-    script = CScript() << "this is too long, I can not handle script this long" << OP_CHECKVTB << OP_CHECKPOP;
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_SCRIPT_SIZE);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_checkpop_is_not_last, EvalScriptFixture)
-{
-    script = CScript() << "ATV" << OP_CHECKATV << "VTB" << OP_CHECKVTB << OP_CHECKPOP << "VTB2";
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_VBK_EXTRA_OPCODE);
-}
-
-BOOST_FIXTURE_TEST_CASE(eval_pop_tx_scriptSig_checkpop_stack_is_not_empty, EvalScriptFixture)
-{
-    // missing OP_CHECKATV
-    script = CScript() << "ATV"
-                       << "VTB" << OP_CHECKVTB << OP_CHECKPOP;
-    BOOST_CHECK(!util.EvalScript(script, stack, &serror, &pub));
-    BOOST_CHECK(serror == SCRIPT_ERR_EVAL_FALSE);
-}
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/vbk/util.hpp b/src/vbk/util.hpp
index 8ac60871c1674..28afea03069f2 100644
--- a/src/vbk/util.hpp
+++ b/src/vbk/util.hpp
@@ -86,6 +86,22 @@ inline CAmount getCoinbaseSubsidy(const CAmount& subsidy)
     return subsidy * (100 - VeriBlock::getService<VeriBlock::Config>().POP_REWARD_PERCENTAGE) / 100;
 }
 
+inline CMutableTransaction MakePopTx(const CScript& scriptSig) {
+    CMutableTransaction tx;
+
+    tx.vout.resize(1);
+    tx.vout[0].nValue = 0;
+    tx.vout[0].scriptPubKey << OP_RETURN;
+
+    tx.vin.resize(1);
+    VeriBlock::setVBKNoInput(tx.vin[0].prevout);
+    tx.vin[0].scriptSig = scriptSig;
+
+    assert(VeriBlock::isPopTx(CTransaction(tx)));
+
+    return tx;
+}
+
 template <typename DefaultComparatorTag>
 struct poptx_priority {
 };
diff --git a/src/vbk/util_service.hpp b/src/vbk/util_service.hpp
index 31e71c8e1857d..a1c522a6e9b5a 100644
--- a/src/vbk/util_service.hpp
+++ b/src/vbk/util_service.hpp
@@ -3,11 +3,13 @@
 
 #include <array>
 
-#include "vbk/entity/context_info_container.hpp"
-#include "vbk/entity/publications.hpp"
+#include "interpreter.hpp"
+#include <vbk/entity/context_info_container.hpp>
+#include <vbk/entity/pop.hpp>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/script_error.h>
+#include <consensus/params.h>
 
 class CBlockIndex;
 class TxValidationState;
@@ -31,22 +33,24 @@ struct UtilService {
 
     virtual int compareForks(const CBlockIndex& left, const CBlockIndex& right) = 0;
 
-    // Pop rewards methods
-    virtual PoPRewards getPopRewards(const CBlockIndex& pindexPrev) = 0;
-    virtual void addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) = 0;
-    virtual bool checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, BlockValidationState& state) = 0;
+    virtual PoPRewards getPopRewards(const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) = 0;
+    virtual void addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) = 0;
+    virtual bool checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams, BlockValidationState& state) = 0;
 
     virtual bool validatePopTx(const CTransaction& tx, TxValidationState& state) = 0;
 
     /**
-     * Executes script of POP transaction.
-     * @param script bitcoin script
-     * @param stack bitcoin stack
-     * @param serror if set (not nullptr), will be equal to error code on errorneous script
-     * @param pub if set (non nullptr), will be equal to parsed ATV & VTBs
-     * @return true if script is valid, false otherwise
+     * Evaluate scriptSig of POP TX.
+     * @param script[in] script to evaluate.
+     * @param stack[in] stack
+     * @param serror[out] error will be written here
+     * @param pub[out] publication data (if any) will be written here
+     * @param ctx[out] context data (if any) will be written here
+     * @param type[out] to distinguish between tx type (publication, context), this argument will contain parsed data type.
+     * @param with_checks[in] if true, atv&vtb checks will be enabled
+     * @return true, if script is valid, false otherwise.
      */
-    virtual bool EvalScript(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, Publications* pub, bool with_checks = true) = 0;
+    virtual bool EvalScript(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, Publications* pub, Context* ctx, PopTxType* type, bool with_checks) = 0;
 };
 
 } // namespace VeriBlock
diff --git a/src/vbk/util_service/util_service_impl.cpp b/src/vbk/util_service/util_service_impl.cpp
index 0594bce5ef01d..71cf1a4d9d9f9 100644
--- a/src/vbk/util_service/util_service_impl.cpp
+++ b/src/vbk/util_service/util_service_impl.cpp
@@ -1,7 +1,6 @@
 #include "util_service_impl.hpp"
 
 #include <chain.h>
-#include <consensus/merkle.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <primitives/block.h>
@@ -12,28 +11,10 @@
 #include <vbk/pop_service.hpp>
 #include <vbk/service_locator.hpp>
 #include <vbk/util.hpp>
+#include <vbk/interpreter.hpp>
 
 namespace VeriBlock {
 
-namespace {
-inline bool set_error(ScriptError* ret, const ScriptError serror)
-{
-    if (ret)
-        *ret = serror;
-    return false;
-}
-typedef std::vector<unsigned char> valtype;
-
-#define stacktop(i) (stack.at(stack.size() + (i)))
-inline void popstack(std::vector<valtype>& stack)
-{
-    if (stack.empty())
-        throw std::runtime_error("popstack(): stack empty");
-    stack.pop_back();
-}
-
-} // namespace
-
 
 bool UtilServiceImpl::CheckPopInputs(const CTransaction& tx, TxValidationState& state, unsigned int flags, bool cacheSigStore, PrecomputedTransactionData& txdata)
 {
@@ -139,9 +120,9 @@ uint256 UtilServiceImpl::makeTopLevelRoot(int height, const KeystoneArray& keyst
     return Hash(txRoot.begin(), txRoot.end(), contextHash.begin(), contextHash.end());
 }
 
-void UtilServiceImpl::addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev)
+void UtilServiceImpl::addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams)
 {
-    PoPRewards rewards = getService<UtilService>().getPopRewards(pindexPrev);
+    PoPRewards rewards = getPopRewards(pindexPrev, consensusParams);
 
     for (const auto& itr : rewards) {
         CTxOut out;
@@ -151,9 +132,9 @@ void UtilServiceImpl::addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseT
     }
 }
 
-bool UtilServiceImpl::checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, BlockValidationState& state)
+bool UtilServiceImpl::checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams, BlockValidationState& state)
 {
-    PoPRewards rewards = getService<UtilService>().getPopRewards(pindexPrev);
+    PoPRewards rewards = getPopRewards(pindexPrev, consensusParams);
 
     if (tx.vout.size() < rewards.size()) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
@@ -162,7 +143,7 @@ bool UtilServiceImpl::checkCoinbaseTxWithPopRewards(const CTransaction& tx, cons
 
     CAmount nTotalPopReward = 0;
     for (const auto& out : tx.vout) {
-        auto it = rewards.find(out.scriptPubKey);
+        const auto& it = rewards.find(out.scriptPubKey);
         if (it != rewards.end() && it->second == out.nValue) {
             nTotalPopReward += it->second; // Pop reward
             rewards.erase(it);
@@ -181,8 +162,10 @@ bool UtilServiceImpl::checkCoinbaseTxWithPopRewards(const CTransaction& tx, cons
     return true;
 }
 
-PoPRewards UtilServiceImpl::getPopRewards(const CBlockIndex& pindexPrev)
+PoPRewards UtilServiceImpl::getPopRewards(const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams)
 {
+    int halvings = (pindexPrev.nHeight + 1) / consensusParams.nSubsidyHalvingInterval;
+
     PoPRewards rewards;
     auto& config = getService<Config>();
     auto& pop_service = VeriBlock::getService<VeriBlock::PopService>();
@@ -195,15 +178,16 @@ PoPRewards UtilServiceImpl::getPopRewards(const CBlockIndex& pindexPrev)
         const CBlockIndex* difficultyBlockStart = pindexPrev.GetAncestor(checkHeight - config.POP_DIFFICULTY_AVERAGING_INTERVAL);
         const CBlockIndex* difficultyBlockEnd = pindexPrev.GetAncestor(checkHeight + config.POP_REWARD_SETTLEMENT_INTERVAL - 1);
 
-        if (!endorsedBlock || !contaningBlocksTip || !difficultyBlockStart || !difficultyBlockEnd) {
+        if (!endorsedBlock) {
             return rewards;
         }
 
-        pop_service.rewardsCalculateOutputs(checkHeight, *endorsedBlock, *contaningBlocksTip, *difficultyBlockStart, *difficultyBlockEnd, rewards);
+        pop_service.rewardsCalculateOutputs(checkHeight, *endorsedBlock, *contaningBlocksTip, difficultyBlockStart, difficultyBlockEnd, rewards);
     }
 
-    // erase rewards, that pay 0 satoshis
+    // erase rewards, that pay 0 satoshis and halve rewards
     for (auto it = rewards.begin(), end = rewards.end(); it != end;) {
+        it->second >>= halvings;
         if (it->second == 0) {
             rewards.erase(it++);
         } else {
@@ -265,119 +249,9 @@ bool UtilServiceImpl::validatePopTxOutput(const CTxOut& out, TxValidationState&
 }
 
 
-bool UtilServiceImpl::EvalScript(const CScript& script, std::vector<std::vector<uint8_t>>& stack, ScriptError* serror, Publications* ret, bool with_checks)
+bool UtilServiceImpl::EvalScript(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, VeriBlock::Publications* publications, VeriBlock::Context* context, PopTxType* type, bool with_checks)
 {
-    CScript::const_iterator pc = script.begin();
-    CScript::const_iterator pend = script.end();
-    static const valtype vchFalse(0);
-    static const valtype vchTrue(1, 1);
-    opcodetype opcode;
-    std::vector<unsigned char> vchPushValue;
-    auto& config = getService<Config>();
-    auto& pop = getService<PopService>();
-    Publications pub;
-
-    if (script.size() > config.max_pop_script_size) {
-        return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
-    }
-
-    size_t maxPushSize = std::max(config.max_atv_size, config.max_vtb_size);
-    size_t minPushSize = std::min(config.min_atv_size, config.min_vtb_size);
-    try {
-        while (pc < pend) {
-            if (!script.GetOp(pc, opcode, vchPushValue)) {
-                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-            }
-
-            if (!vchPushValue.empty()) {
-                // we don't know if it is ATV or VTB yet, so do sanity check here
-                if (vchPushValue.size() > maxPushSize || vchPushValue.size() < minPushSize) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-                stack.push_back(vchPushValue);
-                continue;
-            }
-
-            // at this point, opcode is always one of these 3
-            switch (opcode) {
-            case OP_CHECKATV: {
-                // tx has one ATV
-                if (!pub.atv.empty()) {
-                    return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-                }
-
-                // validate ATV size
-                const auto& el = stacktop(-1);
-                if (el.size() > config.max_atv_size || el.size() < config.min_atv_size) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-
-                // validate ATV content
-                if (with_checks && !pop.checkATVinternally(el)) {
-                    return set_error(serror, SCRIPT_ERR_VBK_ATVFAIL);
-                }
-
-                pub.atv = el;
-                popstack(stack);
-                break;
-            }
-            case OP_CHECKVTB: {
-                // validate VTB size
-                const auto& el = stacktop(-1);
-                if (el.size() > config.max_vtb_size || el.size() < config.min_vtb_size) {
-                    return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-                }
-
-                // validate VTB content
-                if (with_checks && !pop.checkVTBinternally(el)) {
-                    return set_error(serror, SCRIPT_ERR_VBK_VTBFAIL);
-                }
-
-                // tx has many VTBs
-                pub.vtbs.push_back(el);
-                popstack(stack);
-                break;
-            }
-            case OP_CHECKPOP: {
-                // OP_CHECKPOP should be last opcode
-                if (script.GetOp(pc, opcode, vchPushValue)) {
-                    // we could read next opcode. extra opcodes is an error
-                    return set_error(serror, SCRIPT_ERR_VBK_EXTRA_OPCODE);
-                }
-
-                // stack should be empty at this point
-                if (!stack.empty()) {
-                    return set_error(serror, SCRIPT_ERR_EVAL_FALSE);
-                }
-
-                // we did all checks, put true on stack to signal successful execution
-                stack.push_back(vchTrue);
-                break;
-            }
-            default:
-                // forbid any other opcodes in pop transactions
-                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-            }
-        }
-    } catch (...) {
-        return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
-    }
-
-    if (pub.atv.empty()) {
-        // must contain non-empty ATV
-        return set_error(serror, SCRIPT_ERR_VBK_ATVFAIL);
-    }
-
-    if (pub.vtbs.empty()) {
-        // must contain at least one VTB
-        return set_error(serror, SCRIPT_ERR_VBK_VTBFAIL);
-    }
-
-    // set return value
-    if (ret != nullptr) {
-        *ret = pub;
-    }
-
-    return true;
+    return EvalScriptImpl(script, stack, serror, publications, context, type, with_checks);
 }
+
 } // namespace VeriBlock
diff --git a/src/vbk/util_service/util_service_impl.hpp b/src/vbk/util_service/util_service_impl.hpp
index a8cbe7216b34c..77675eaf75700 100644
--- a/src/vbk/util_service/util_service_impl.hpp
+++ b/src/vbk/util_service/util_service_impl.hpp
@@ -5,6 +5,7 @@
 #include "vbk/util_service.hpp"
 
 #include <consensus/validation.h>
+#include <vbk/interpreter.hpp>
 #include <vector>
 
 namespace VeriBlock {
@@ -22,23 +23,19 @@ struct UtilServiceImpl : public UtilService {
 
     uint256 makeTopLevelRoot(int height, const KeystoneArray& keystones, const uint256& txRoot) override;
 
-    /// same as:
-    /// bool CForkResolution::operator()(const CBlockIndex* leftFork, const CBlockIndex* rightFork) const
-
     int compareForks(const CBlockIndex& left, const CBlockIndex& right) override;
 
     // Pop rewards methods
-    PoPRewards getPopRewards(const CBlockIndex& pindexPrev) override;
-    void addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev) override;
-    bool checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, BlockValidationState& state) override;
+    PoPRewards getPopRewards(const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) override;
+    void addPopPayoutsIntoCoinbaseTx(CMutableTransaction& coinbaseTx, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams) override;
+    bool checkCoinbaseTxWithPopRewards(const CTransaction& tx, const CAmount& PoWBlockReward, const CBlockIndex& pindexPrev, const Consensus::Params& consensusParams, BlockValidationState& state) override;
+
+    bool EvalScript(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, Publications* publications, Context* context, PopTxType* type, bool with_checks) override;
 
-    bool EvalScript(const CScript& script, std::vector<std::vector<unsigned char>>& stack, ScriptError* serror, Publications* pub, bool with_checks = true) override;
     bool validatePopTx(const CTransaction& tx, TxValidationState& state) override;
     bool validatePopTxInput(const CTxIn& in, TxValidationState& state);
     bool validatePopTxOutput(const CTxOut& in, TxValidationState& state);
 
-    // statefull VeriBlock validation
-    //bool blockPopValidation(const CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& params, CValidationState& state) override;
 
 protected:
     const CBlockIndex* FindCommonKeystone(const CBlockIndex* leftFork, const CBlockIndex* rightFork);