diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index f653376d16e..60496c0d00b 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -129,7 +129,8 @@ class CMainParams : public CChainParams {
         consensus.FortCanningMuseumHeight = 1430640;
         consensus.FortCanningParkHeight = 1503143;
         consensus.FortCanningHillHeight = 1604999; // Feb 7, 2022.
-        consensus.FortCanningRoadHeight = 1786000; // April 11, 2022. 
+        consensus.FortCanningRoadHeight = 1786000; // April 11, 2022.
+        consensus.GreatWorldHeight = std::numeric_limits<int>::max();
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 //        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -358,6 +359,7 @@ class CTestNetParams : public CChainParams {
         consensus.FortCanningParkHeight = 828800;
         consensus.FortCanningHillHeight = 828900;
         consensus.FortCanningRoadHeight = 893700;
+        consensus.GreatWorldHeight = std::numeric_limits<int>::max();
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 //        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -547,6 +549,7 @@ class CDevNetParams : public CChainParams {
         consensus.FortCanningParkHeight = std::numeric_limits<int>::max();
         consensus.FortCanningHillHeight = std::numeric_limits<int>::max();
         consensus.FortCanningRoadHeight = std::numeric_limits<int>::max();
+        consensus.GreatWorldHeight = std::numeric_limits<int>::max();
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 5 * 60; // 5 min == 10 blocks
@@ -728,6 +731,7 @@ class CRegTestParams : public CChainParams {
         consensus.FortCanningParkHeight = 10000000;
         consensus.FortCanningHillHeight = 10000000;
         consensus.FortCanningRoadHeight = 10000000;
+        consensus.GreatWorldHeight = 10000000;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -948,6 +952,7 @@ void CRegTestParams::UpdateActivationParametersFromArgs()
     UpdateHeightValidation("Fort Canning Park", "-fortcanningparkheight", consensus.FortCanningParkHeight);
     UpdateHeightValidation("Fort Canning Hill", "-fortcanninghillheight", consensus.FortCanningHillHeight);
     UpdateHeightValidation("Fort Canning Road", "-fortcanningroadheight", consensus.FortCanningRoadHeight);
+    UpdateHeightValidation("Great World", "-greatworldheight", consensus.GreatWorldHeight);
 
     if (gArgs.GetBoolArg("-simulatemainnet", false)) {
         consensus.pos.nTargetTimespan = 5 * 60; // 5 min == 10 blocks
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 2d047d9bcd3..7c919d1bec4 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -95,6 +95,7 @@ struct Params {
     int FortCanningParkHeight;
     int FortCanningHillHeight;
     int FortCanningRoadHeight;
+    int GreatWorldHeight;
 
     /** Foundation share after AMK, normalized to COIN = 100% */
     CAmount foundationShareDFIP1;
diff --git a/src/consensus/tx_check.cpp b/src/consensus/tx_check.cpp
index ee03891b96d..86f566c8e5c 100644
--- a/src/consensus/tx_check.cpp
+++ b/src/consensus/tx_check.cpp
@@ -7,9 +7,10 @@
 #include <primitives/transaction.h>
 #include <consensus/validation.h>
 
-/// @todo refactor it to unify txs!!! (need to restart blockchain)
+const std::vector<unsigned char> DfTxMarker = {'D', 'f', 'T', 'x'};
 const std::vector<unsigned char> DfAnchorFinalizeTxMarker = {'D', 'f', 'A', 'f'};
 const std::vector<unsigned char> DfAnchorFinalizeTxMarkerPlus = {'D', 'f', 'A', 'P'};
+const std::vector<unsigned char> DfTokenSplitMarker = {'D', 'f', 'T', 'S'};
 
 bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fCheckDuplicateInputs)
 {
@@ -49,7 +50,7 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fChe
     if (tx.IsCoinBase())
     {
         std::vector<unsigned char> dummy;
-        if (IsAnchorRewardTx(tx, dummy) || IsAnchorRewardTxPlus(tx, dummy))
+        if (IsAnchorRewardTx(tx, dummy) || IsAnchorRewardTxPlus(tx, dummy) || IsTokenSplitTx(tx, dummy))
             return true;
         if (tx.vin[0].scriptSig.size() < 2 || (tx.vin[0].scriptSig.size() > 100))
             return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-length");
@@ -115,3 +116,19 @@ bool IsAnchorRewardTxPlus(CTransaction const & tx, std::vector<unsigned char> &
     }
     return result;
 }
+
+bool IsTokenSplitTx(CTransaction const & tx, std::vector<unsigned char> & metadata, bool fortCanningGreen)
+{
+    if (!fortCanningGreen) {
+        return false;
+    }
+    if (!tx.IsCoinBase() || tx.vout.size() != 1 || tx.vout[0].nValue != 0) {
+        return false;
+    }
+    bool hasAdditionalOpcodes{false};
+    const auto result = ParseScriptByMarker(tx.vout[0].scriptPubKey, DfTokenSplitMarker, metadata, hasAdditionalOpcodes);
+    if (hasAdditionalOpcodes) {
+        return false;
+    }
+    return result;
+}
diff --git a/src/consensus/tx_check.h b/src/consensus/tx_check.h
index 3a7d334ef2f..5eb7012f73e 100644
--- a/src/consensus/tx_check.h
+++ b/src/consensus/tx_check.h
@@ -14,9 +14,10 @@
 
 #include <vector>
 
-/// moved here (!!) due to strange linker errors under mac/win builds
+extern const std::vector<unsigned char> DfTxMarker;
 extern const std::vector<unsigned char> DfAnchorFinalizeTxMarker;
 extern const std::vector<unsigned char> DfAnchorFinalizeTxMarkerPlus;
+extern const std::vector<unsigned char> DfTokenSplitMarker;
 
 class CScript;
 class CTransaction;
@@ -30,5 +31,6 @@ bool ParseScriptByMarker(CScript const & script,
                          bool& hasAdditionalOpcodes);
 bool IsAnchorRewardTx(CTransaction const & tx, std::vector<unsigned char> & metadata, bool fortCanning = false);
 bool IsAnchorRewardTxPlus(CTransaction const & tx, std::vector<unsigned char> & metadata, bool fortCanning = false);
+bool IsTokenSplitTx(CTransaction const & tx, std::vector<unsigned char> & metadata, bool fortCanningGreen = true);
 
 #endif // DEFI_CONSENSUS_TX_CHECK_H
diff --git a/src/init.cpp b/src/init.cpp
index 102c84818b4..8a2d0370674 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -477,6 +477,7 @@ void SetupServerArgs()
     gArgs.AddArg("-fortcanningparkheight", "Fort Canning Park fork activation height (regtest only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-fortcanninghillheight", "Fort Canning Hill fork activation height (regtest only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-fortcanningroadheight", "Fort Canning Road fork activation height (regtest only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-greatworldheight", "Great World fork activation height (regtest only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-jellyfish_regtest", "Configure the regtest network for jellyfish testing", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-simulatemainnet", "Configure the regtest network to mainnet target timespan and spacing ", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
 #ifdef USE_UPNP
diff --git a/src/masternodes/govvariables/attributes.cpp b/src/masternodes/govvariables/attributes.cpp
index cbf62b89101..01d2ee2dc8d 100644
--- a/src/masternodes/govvariables/attributes.cpp
+++ b/src/masternodes/govvariables/attributes.cpp
@@ -6,6 +6,7 @@
 
 #include <masternodes/accountshistory.h> /// CAccountsHistoryWriter
 #include <masternodes/masternodes.h> /// CCustomCSView
+#include <masternodes/mn_checks.h> /// GetAggregatePrice
 #include <masternodes/mn_checks.h> /// CustomTxType
 
 #include <core_io.h> /// ValueFromAmount
@@ -13,24 +14,22 @@
 
 extern UniValue AmountsToJSON(TAmounts const & diffs);
 
-template<typename T>
-static std::string KeyBuilder(const T& value){
-    std::ostringstream oss;
-    oss << value;
-    return oss.str();
+static inline std::string trim_all_ws(std::string s) {
+    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+        return !std::isspace(ch);
+    }));
+    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
+        return !std::isspace(ch);
+    }).base(), s.end());
+    return s;
 }
 
-template<typename T, typename ... Args >
-static std::string KeyBuilder(const T& value, const Args& ... args){
-    return KeyBuilder(value) + '/' + KeyBuilder(args...);
-}
-
-static std::vector<std::string> KeyBreaker(const std::string& str){
+static std::vector<std::string> KeyBreaker(const std::string& str, const char delim = '/'){
     std::string section;
     std::istringstream stream(str);
     std::vector<std::string> strVec;
 
-    while (std::getline(stream, section, '/')) {
+    while (std::getline(stream, section, delim)) {
         strVec.push_back(section);
     }
     return strVec;
@@ -52,6 +51,8 @@ const std::map<uint8_t, std::string>& ATTRIBUTES::displayVersions() {
 
 const std::map<std::string, uint8_t>& ATTRIBUTES::allowedTypes() {
     static const std::map<std::string, uint8_t> types{
+        {"locks",       AttributeTypes::Locks},
+        {"oracles",     AttributeTypes::Oracles},
         {"params",      AttributeTypes::Param},
         {"poolpairs",   AttributeTypes::Poolpairs},
         {"token",       AttributeTypes::Token},
@@ -62,6 +63,8 @@ const std::map<std::string, uint8_t>& ATTRIBUTES::allowedTypes() {
 const std::map<uint8_t, std::string>& ATTRIBUTES::displayTypes() {
     static const std::map<uint8_t, std::string> types{
         {AttributeTypes::Live,      "live"},
+        {AttributeTypes::Locks,     "locks"},
+        {AttributeTypes::Oracles,   "oracles"},
         {AttributeTypes::Param,     "params"},
         {AttributeTypes::Poolpairs, "poolpairs"},
         {AttributeTypes::Token,     "token"},
@@ -77,26 +80,53 @@ const std::map<std::string, uint8_t>& ATTRIBUTES::allowedParamIDs() {
     return params;
 }
 
+const std::map<std::string, uint8_t>& ATTRIBUTES::allowedLocksIDs() {
+    static const std::map<std::string, uint8_t> params{
+            {"token",       ParamIDs::TokenID},
+    };
+    return params;
+}
+
 const std::map<uint8_t, std::string>& ATTRIBUTES::displayParamsIDs() {
     static const std::map<uint8_t, std::string> params{
         {ParamIDs::DFIP2201,    "dfip2201"},
         {ParamIDs::DFIP2203,    "dfip2203"},
+        {ParamIDs::TokenID,     "token"},
         {ParamIDs::Economy,     "economy"},
     };
     return params;
 }
 
+const std::map<std::string, uint8_t>& ATTRIBUTES::allowedOracleIDs() {
+    static const std::map<std::string, uint8_t> params{
+            {"splits",    OracleIDs::Splits}
+    };
+    return params;
+}
+
+const std::map<uint8_t, std::string>& ATTRIBUTES::displayOracleIDs() {
+    static const std::map<uint8_t, std::string> params{
+            {OracleIDs::Splits,    "splits"},
+    };
+    return params;
+}
+
 const std::map<uint8_t, std::map<std::string, uint8_t>>& ATTRIBUTES::allowedKeys() {
     static const std::map<uint8_t, std::map<std::string, uint8_t>> keys{
         {
             AttributeTypes::Token, {
-                {"payback_dfi",         TokenKeys::PaybackDFI},
-                {"payback_dfi_fee_pct", TokenKeys::PaybackDFIFeePCT},
-                {"loan_payback",        TokenKeys::LoanPayback},
-                {"loan_payback_fee_pct",TokenKeys::LoanPaybackFeePCT},
-                {"dex_in_fee_pct",      TokenKeys::DexInFeePct},
-                {"dex_out_fee_pct",     TokenKeys::DexOutFeePct},
-                {"dfip2203",            TokenKeys::DFIP2203Enabled},
+                {"payback_dfi",             TokenKeys::PaybackDFI},
+                {"payback_dfi_fee_pct",     TokenKeys::PaybackDFIFeePCT},
+                {"loan_payback",            TokenKeys::LoanPayback},
+                {"loan_payback_fee_pct",    TokenKeys::LoanPaybackFeePCT},
+                {"dex_in_fee_pct",          TokenKeys::DexInFeePct},
+                {"dex_out_fee_pct",         TokenKeys::DexOutFeePct},
+                {"dfip2203",                TokenKeys::DFIP2203Enabled},
+                {"fixed_interval_price_id", TokenKeys::FixedIntervalPriceId},
+                {"loan_collateral_enabled", TokenKeys::LoanCollateralEnabled},
+                {"loan_collateral_factor",  TokenKeys::LoanCollateralFactor},
+                {"loan_minting_enabled",    TokenKeys::LoanMintingEnabled},
+                {"loan_minting_interest",   TokenKeys::LoanMintingInterest},
             }
         },
         {
@@ -122,13 +152,21 @@ const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys
     static const std::map<uint8_t, std::map<uint8_t, std::string>> keys{
         {
             AttributeTypes::Token, {
-                {TokenKeys::PaybackDFI,       "payback_dfi"},
-                {TokenKeys::PaybackDFIFeePCT, "payback_dfi_fee_pct"},
-                {TokenKeys::LoanPayback,      "loan_payback"},
-                {TokenKeys::LoanPaybackFeePCT,"loan_payback_fee_pct"},
-                {TokenKeys::DexInFeePct,      "dex_in_fee_pct"},
-                {TokenKeys::DexOutFeePct,     "dex_out_fee_pct"},
-                {TokenKeys::DFIP2203Enabled, "dfip2203"},
+                {TokenKeys::PaybackDFI,            "payback_dfi"},
+                {TokenKeys::PaybackDFIFeePCT,      "payback_dfi_fee_pct"},
+                {TokenKeys::LoanPayback,           "loan_payback"},
+                {TokenKeys::LoanPaybackFeePCT,     "loan_payback_fee_pct"},
+                {TokenKeys::DexInFeePct,           "dex_in_fee_pct"},
+                {TokenKeys::DexOutFeePct,          "dex_out_fee_pct"},
+                {TokenKeys::FixedIntervalPriceId,  "fixed_interval_price_id"},
+                {TokenKeys::LoanCollateralEnabled, "loan_collateral_enabled"},
+                {TokenKeys::LoanCollateralFactor,  "loan_collateral_factor"},
+                {TokenKeys::LoanMintingEnabled,    "loan_minting_enabled"},
+                {TokenKeys::LoanMintingInterest,   "loan_minting_interest"},
+                {TokenKeys::DFIP2203Enabled,       "dfip2203"},
+                {TokenKeys::Ascendant,             "ascendant"},
+                {TokenKeys::Descendant,            "descendant"},
+                {TokenKeys::Epitaph,               "epitaph"},
             }
         },
         {
@@ -159,6 +197,14 @@ const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys
 }
 
 static ResVal<int32_t> VerifyInt32(const std::string& str) {
+    int32_t int32;
+    if (!ParseInt32(str, &int32)) {
+        return Res::Err("Value must be an integer");
+    }
+    return {int32, Res::Ok()};
+}
+
+static ResVal<int32_t> VerifyPositiveInt32(const std::string& str) {
     int32_t int32;
     if (!ParseInt32(str, &int32) || int32 < 0) {
         return Res::Err("Value must be a positive integer");
@@ -200,6 +246,52 @@ static ResVal<CAttributeValue> VerifyBool(const std::string& str) {
     return {str == "true", Res::Ok()};
 }
 
+static ResVal<CAttributeValue> VerifySplit(const std::string& str) {
+    const auto values = KeyBreaker(str, ',');
+    if (values.empty()) {
+        return Res::Err(R"(No valid values supplied, "id/multiplier, ...")");
+    }
+
+    OracleSplits splits;
+    for (const auto& item : values) {
+        const auto pairs = KeyBreaker(item);
+        if (pairs.size() != 2) {
+            return Res::Err("Two int values expected for split in id/mutliplier");
+        }
+        const auto resId = VerifyPositiveInt32(pairs[0]);
+        if (!resId) {
+            return resId;
+        }
+        const auto resMultiplier = VerifyInt32(pairs[1]);
+        if (!resMultiplier) {
+            return resMultiplier;
+        }
+        if (*resMultiplier == 0) {
+            return Res::Err("Mutliplier cannot be zero");
+        }
+        splits[*resId] = *resMultiplier;
+    }
+
+    return {splits, Res::Ok()};
+}
+
+static ResVal<CAttributeValue> VerifyCurrencyPair(const std::string& str) {
+    const auto value = KeyBreaker(str);
+    if (value.size() != 2) {
+        return Res::Err("Exactly two entires expected for currency pair");
+    }
+    auto token = trim_all_ws(value[0]).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+    auto currency = trim_all_ws(value[1]).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+    if (token.empty() || currency.empty()) {
+        return Res::Err("Empty token / currency");
+    }
+    return {CTokenCurrencyPair{token, currency}, Res::Ok()};
+}
+
+static bool VerifyToken(const CCustomCSView& view, const uint32_t id) {
+    return view.GetToken(DCT_ID{id}).has_value();
+}
+
 const std::map<uint8_t, std::map<uint8_t,
     std::function<ResVal<CAttributeValue>(const std::string&)>>>& ATTRIBUTES::parseValue() {
 
@@ -207,13 +299,18 @@ const std::map<uint8_t, std::map<uint8_t,
         std::function<ResVal<CAttributeValue>(const std::string&)>>> parsers{
         {
             AttributeTypes::Token, {
-                {TokenKeys::PaybackDFI,       VerifyBool},
-                {TokenKeys::PaybackDFIFeePCT, VerifyPct},
-                {TokenKeys::LoanPayback,      VerifyBool},
-                {TokenKeys::LoanPaybackFeePCT,VerifyPct},
-                {TokenKeys::DexInFeePct,      VerifyPct},
-                {TokenKeys::DexOutFeePct,     VerifyPct},
-                {TokenKeys::DFIP2203Enabled, VerifyBool},
+                {TokenKeys::PaybackDFI,            VerifyBool},
+                {TokenKeys::PaybackDFIFeePCT,      VerifyPct},
+                {TokenKeys::LoanPayback,           VerifyBool},
+                {TokenKeys::LoanPaybackFeePCT,     VerifyPct},
+                {TokenKeys::DexInFeePct,           VerifyPct},
+                {TokenKeys::DexOutFeePct,          VerifyPct},
+                {TokenKeys::FixedIntervalPriceId,  VerifyCurrencyPair},
+                {TokenKeys::LoanCollateralEnabled, VerifyBool},
+                {TokenKeys::LoanCollateralFactor,  VerifyPct},
+                {TokenKeys::LoanMintingEnabled,    VerifyBool},
+                {TokenKeys::LoanMintingInterest,   VerifyFloat},
+                {TokenKeys::DFIP2203Enabled,       VerifyBool},
             }
         },
         {
@@ -231,6 +328,16 @@ const std::map<uint8_t, std::map<uint8_t,
                 {DFIPKeys::BlockPeriod,  VerifyInt64},
             }
         },
+        {
+            AttributeTypes::Locks, {
+                {ParamIDs::TokenID,          VerifyBool},
+            }
+        },
+        {
+            AttributeTypes::Oracles, {
+                {OracleIDs::Splits,          VerifySplit},
+            }
+        },
     };
     return parsers;
 }
@@ -269,12 +376,12 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value
         return Res::Err("Empty value");
     }
 
-    auto iver = allowedVersions().find(keys[0]);
+    const auto& iver = allowedVersions().find(keys[0]);
     if (iver == allowedVersions().end()) {
         return Res::Err("Unsupported version");
     }
 
-    auto version = iver->second;
+    const auto& version = iver->second;
     if (version != VersionTypes::v0) {
         return Res::Err("Unsupported version");
     }
@@ -288,56 +395,83 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value
         return ::ShowError("type", allowedTypes());
     }
 
-    auto type = itype->second;
+    const auto type = itype->second;
 
     uint32_t typeId{0};
-    if (type != AttributeTypes::Param) {
+    if (type == AttributeTypes::Param) {
+        auto id = allowedParamIDs().find(keys[2]);
+        if (id == allowedParamIDs().end()) {
+            return ::ShowError("params", allowedParamIDs());
+        }
+        typeId = id->second;
+    } else if (type == AttributeTypes::Locks) {
+        auto id = allowedLocksIDs().find(keys[2]);
+        if (id == allowedLocksIDs().end()) {
+            return ::ShowError("locks", allowedLocksIDs());
+        }
+        typeId = id->second;
+    } else if (type == AttributeTypes::Oracles) {
+        auto id = allowedOracleIDs().find(keys[2]);
+        if (id == allowedOracleIDs().end()) {
+            return ::ShowError("oracles", allowedOracleIDs());
+        }
+        typeId = id->second;
+    } else {
         auto id = VerifyInt32(keys[2]);
         if (!id) {
             return std::move(id);
         }
         typeId = *id.val;
-    } else {
-        auto id = allowedParamIDs().find(keys[2]);
-        if (id == allowedParamIDs().end()) {
-            return ::ShowError("param", allowedParamIDs());
-        }
-        typeId = id->second;
     }
 
-    auto ikey = allowedKeys().find(type);
-    if (ikey == allowedKeys().end()) {
-        return Res::Err("Unsupported type {%d}", type);
-    }
+    uint32_t typeKey{0};
+    CDataStructureV0 attrV0{};
 
-    itype = ikey->second.find(keys[3]);
-    if (itype == ikey->second.end()) {
-        return ::ShowError("key", ikey->second);
-    }
+    if (type == AttributeTypes::Locks) {
+        typeKey = ParamIDs::TokenID;
+        if (const auto keyValue = VerifyInt32(keys[3])) {
+            attrV0 = CDataStructureV0{type, typeId, static_cast<uint32_t>(*keyValue)};
+        }
+    } else if (type == AttributeTypes::Oracles) {
+        typeKey = OracleIDs::Splits;
+        if (const auto keyValue = VerifyPositiveInt32(keys[3])) {
+            attrV0 = CDataStructureV0{type, typeId, static_cast<uint32_t>(*keyValue)};
+        }
+    } else {
+        auto ikey = allowedKeys().find(type);
+        if (ikey == allowedKeys().end()) {
+            return Res::Err("Unsupported type {%d}", type);
+        }
+
+        itype = ikey->second.find(keys[3]);
+        if (itype == ikey->second.end()) {
+            return ::ShowError("key", ikey->second);
+        }
 
-    auto typeKey = itype->second;
+        typeKey = itype->second;
 
-    if (type == AttributeTypes::Param) {
-        if (typeId == ParamIDs::DFIP2201) {
-            if (typeKey == DFIPKeys::RewardPct ||
-                typeKey == DFIPKeys::BlockPeriod) {
-                return Res::Err("Unsupported type for DFIP2201 {%d}", typeKey);
-            }
-        } else if (typeId == ParamIDs::DFIP2203) {
-            if (typeKey == DFIPKeys::Premium ||
-                typeKey == DFIPKeys::MinSwap) {
-                return Res::Err("Unsupported type for DFIP2203 {%d}", typeKey);
-            }
+        if (type == AttributeTypes::Param) {
+            if (typeId == ParamIDs::DFIP2201) {
+                if (typeKey == DFIPKeys::RewardPct ||
+                    typeKey == DFIPKeys::BlockPeriod) {
+                    return Res::Err("Unsupported type for DFIP2201 {%d}", typeKey);
+                }
+            } else if (typeId == ParamIDs::DFIP2203) {
+                if (typeKey == DFIPKeys::Premium ||
+                    typeKey == DFIPKeys::MinSwap) {
+                    return Res::Err("Unsupported type for DFIP2203 {%d}", typeKey);
+                }
 
-            if (typeKey == DFIPKeys::BlockPeriod) {
-                futureBlockUpdated = true;
+                if (typeKey == DFIPKeys::BlockPeriod) {
+                    futureBlockUpdated = true;
+                }
+            } else {
+                return Res::Err("Unsupported Param ID");
             }
-        } else {
-            return Res::Err("Unsupported Param ID");
         }
-    }
 
-    CDataStructureV0 attrV0{type, typeId, typeKey};
+        attrV0 = CDataStructureV0{type, typeId, typeKey};
+    }
 
     if (attrV0.IsExtendedSize()) {
         if (keys.size() != 5 || keys[4].empty()) {
@@ -349,8 +483,8 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value
         }
         attrV0.keyId = *id.val;
     } else {
-       if (keys.size() != 4) {
-           return Res::Err("Exact 4 keys are required {%d}", keys.size());
+        if (keys.size() != 4) {
+            return Res::Err("Exact 4 keys are required {%d}", keys.size());
         }
     }
 
@@ -440,12 +574,33 @@ Res ATTRIBUTES::Import(const UniValue & val) {
 
     for (const auto& pair : objMap) {
         auto res = ProcessVariable(
-            pair.first, pair.second.get_str(), [this](const CAttributeType& attribute, const CAttributeValue& value) {
+            pair.first, pair.second.get_str(),
+            [this](const CAttributeType& attribute, const CAttributeValue& value) {
                 if (auto attrV0 = boost::get<const CDataStructureV0>(&attribute)) {
-                    if (attrV0->type == AttributeTypes::Live) {
-                        return Res::Err("Live attribute cannot be set externally");
+                    if (attrV0->type == AttributeTypes::Live ||
+                            (attrV0->type == AttributeTypes::Token &&
+                             (attrV0->key == TokenKeys::Ascendant ||
+                              attrV0->key == TokenKeys::Descendant ||
+                              attrV0->key == TokenKeys::Epitaph))) {
+                        return Res::Err("Attribute cannot be set externally");
+                    } else if (attrV0->type == AttributeTypes::Oracles && attrV0->typeId == OracleIDs::Splits) {
+                        auto splitValue = boost::get<OracleSplits>(&value);
+                        if (!splitValue) {
+                            return Res::Err("Failed to get Oracle split value");
+                        }
+                        for (const auto& [id, multiplier] : *splitValue) {
+                            tokenSplits.insert(id);
+                        }
+                        try {
+                            auto attrMap = boost::get<OracleSplits>(&attributes.at(attribute));
+                            OracleSplits combined{*splitValue};
+                            combined.merge(*attrMap);
+                            attributes[attribute] = combined;
+                            return Res::Ok();
+                        } catch (std::out_of_range &) {}
                     }
-                    // applay DFI via old keys
+
+                    // apply DFI via old keys
                     if (attrV0->IsExtendedSize() && attrV0->keyId == 0) {
                         auto newAttr = *attrV0;
                         if (attrV0->key == TokenKeys::LoanPayback) {
@@ -476,15 +631,21 @@ UniValue ATTRIBUTES::Export() const {
             continue;
         }
         try {
-            const auto id = attrV0->type == AttributeTypes::Param
-                         || attrV0->type == AttributeTypes::Live
-                            ? displayParamsIDs().at(attrV0->typeId)
-                            : KeyBuilder(attrV0->typeId);
+            std::string id;
+            if (attrV0->type == AttributeTypes::Param || attrV0->type == AttributeTypes::Live || attrV0->type == AttributeTypes::Locks) {
+                id = displayParamsIDs().at(attrV0->typeId);
+            } else if (attrV0->type == AttributeTypes::Oracles) {
+                id = displayOracleIDs().at(attrV0->typeId);
+            } else {
+                id = KeyBuilder(attrV0->typeId);
+            }
+
+            auto const v0Key = attrV0->type == AttributeTypes::Oracles || attrV0->type == AttributeTypes::Locks ? KeyBuilder(attrV0->key) : displayKeys().at(attrV0->type).at(attrV0->key);
 
             auto key = KeyBuilder(displayVersions().at(VersionTypes::v0),
                                   displayTypes().at(attrV0->type),
                                   id,
-                                  displayKeys().at(attrV0->type).at(attrV0->key));
+                                  v0Key);
 
             if (attrV0->IsExtendedSize()) {
                 key = KeyBuilder(key, attrV0->keyId);
@@ -506,6 +667,18 @@ UniValue ATTRIBUTES::Export() const {
                 result.pushKV("paybackfees", AmountsToJSON(paybacks->tokensFee.balances));
                 result.pushKV("paybacktokens", AmountsToJSON(paybacks->tokensPayback.balances));
                 ret.pushKV(key, result);
+            } else if (const auto splitValues = boost::get<OracleSplits>(&attribute.second)) {
+                std::string keyValue;
+                for (const auto& [tokenId, multiplier] : *splitValues) {
+                    keyValue += KeyBuilder(tokenId, multiplier) + ',';
+                }
+                ret.pushKV(key, keyValue);
+            } else if (const auto& descendantPair = boost::get<DescendantValue>(&attribute.second)) {
+                ret.pushKV(key, KeyBuilder(descendantPair->first, descendantPair->second));
+            } else if (const auto& ascendantPair = boost::get<AscendantValue>(&attribute.second)) {
+                ret.pushKV(key, KeyBuilder(ascendantPair->first, ascendantPair->second));
+            } else if (auto currencyPair = boost::get<CTokenCurrencyPair>(&attribute.second)) {
+                ret.pushKV(key, currencyPair->first + '/' + currencyPair->second);
             }
         } catch (const std::out_of_range&) {
             // Should not get here, that's mean maps are mismatched
@@ -554,6 +727,31 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                             return Res::Err("No such token (%d)", attrV0->typeId);
                         }
                     break;
+                    case TokenKeys::LoanCollateralEnabled:
+                    case TokenKeys::LoanCollateralFactor:
+                    case TokenKeys::LoanMintingEnabled:
+                    case TokenKeys::LoanMintingInterest: {
+                        if (view.GetLastHeight() < Params().GetConsensus().GreatWorldHeight) {
+                            return Res::Err("Cannot be set before GreatWorld");
+                        }
+                        if (!VerifyToken(view, attrV0->typeId)) {
+                            return Res::Err("No such token (%d)", attrV0->typeId);
+                        }
+                        CDataStructureV0 intervalPriceKey{AttributeTypes::Token, attrV0->typeId,
+                                                          TokenKeys::FixedIntervalPriceId};
+                        if (GetValue(intervalPriceKey, CTokenCurrencyPair{}) == CTokenCurrencyPair{}) {
+                            return Res::Err("Fixed interval price currency pair must be set first");
+                        }
+                        break;
+                    }
+                    case TokenKeys::FixedIntervalPriceId:
+                        if (view.GetLastHeight() < Params().GetConsensus().GreatWorldHeight) {
+                            return Res::Err("Cannot be set before GreatWorld");
+                        }
+                        if (!VerifyToken(view, attrV0->typeId)) {
+                            return Res::Err("No such token (%d)", attrV0->typeId);
+                        }
+                        break;
                     case TokenKeys::DFIP2203Enabled:
                         if (view.GetLastHeight() < Params().GetConsensus().FortCanningRoadHeight) {
                             return Res::Err("Cannot be set before FortCanningRoad");
@@ -562,11 +760,47 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                             return Res::Err("No such loan token (%d)", attrV0->typeId);
                         }
                     break;
+                    case TokenKeys::Ascendant:
+                    case TokenKeys::Descendant:
+                    case TokenKeys::Epitaph:
+                    break;
                     default:
                         return Res::Err("Unsupported key");
                 }
             break;
 
+            case AttributeTypes::Oracles:
+                if (view.GetLastHeight() < Params().GetConsensus().GreatWorldHeight) {
+                    return Res::Err("Cannot be set before GreatWorld");
+                }
+                if (attrV0->typeId == OracleIDs::Splits) {
+                    const auto splitMap = boost::get<OracleSplits>(&attribute.second);
+                    if (!splitMap) {
+                        return Res::Err("Unsupported value");
+                    }
+                    for (const auto& [tokenId, multipler] : *splitMap) {
+                        if (tokenId == 0) {
+                            return Res::Err("Tokenised DFI cannot be split");
+                        }
+                        if (view.HasPoolPair(DCT_ID{tokenId})) {
+                            return Res::Err("Pool tokens cannot be split");
+                        }
+                        const auto token = view.GetToken(DCT_ID{tokenId});
+                        if (!token) {
+                            return Res::Err("Token (%d) does not exist", tokenId);
+                        }
+                        if (!token->IsDAT()) {
+                            return Res::Err("Only DATs can be split");
+                        }
+                        if (!view.GetLoanTokenByID(DCT_ID{tokenId}).has_value()) {
+                            return Res::Err("No loan token with id (%d)", tokenId);
+                        }
+                    }
+                } else {
+                    return Res::Err("Unsupported key");
+                }
+            break;
+
             case AttributeTypes::Poolpairs:
                 if (!boost::get<const CAmount>(&attribute.second)) {
                     return Res::Err("Unsupported value");
@@ -597,6 +831,18 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
             case AttributeTypes::Live:
             break;
 
+            case AttributeTypes::Locks:
+                if (view.GetLastHeight() < Params().GetConsensus().GreatWorldHeight) {
+                    return Res::Err("Cannot be set before GreatWorld");
+                }
+                if (attrV0->typeId != ParamIDs::TokenID) {
+                    return Res::Err("Unrecognised locks id");
+                }
+                if (!view.GetLoanTokenByID(DCT_ID{attrV0->key}).has_value()) {
+                    return Res::Err("No loan token with id (%d)", attrV0->key);
+                }
+            break;
+
             default:
                 return Res::Err("Unrecognised type (%d)", attrV0->type);
         }
@@ -637,6 +883,31 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     return res;
                 }
             }
+            if (attrV0->key == TokenKeys::FixedIntervalPriceId) {
+                if (const auto &currencyPair = boost::get<CTokenCurrencyPair>(&attribute.second)) {
+                    // Already exists, skip.
+                    if (mnview.GetFixedIntervalPrice(*currencyPair)) {
+                        continue;
+                    } else if (!OraclePriceFeed(mnview, *currencyPair)) {
+                        return Res::Err("Price feed %s/%s does not belong to any oracle", currencyPair->first,
+                                        currencyPair->second);
+                    }
+                    CFixedIntervalPrice fixedIntervalPrice;
+                    fixedIntervalPrice.priceFeedId = *currencyPair;
+                    fixedIntervalPrice.timestamp = time;
+                    fixedIntervalPrice.priceRecord[1] = -1;
+                    const auto aggregatePrice = GetAggregatePrice(mnview,
+                                                                  fixedIntervalPrice.priceFeedId.first,
+                                                                  fixedIntervalPrice.priceFeedId.second,
+                                                                  time);
+                    if (aggregatePrice) {
+                        fixedIntervalPrice.priceRecord[1] = aggregatePrice;
+                    }
+                    mnview.SetFixedIntervalPrice(fixedIntervalPrice);
+                } else {
+                    return Res::Err("Unrecognised value for FixedIntervalPriceId");
+                }
+            }
             if (attrV0->key == TokenKeys::DFIP2203Enabled) {
 
                 // Skip on block period change to avoid refunding and erasing entries.
@@ -700,6 +971,52 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     return Res::Err("Cannot set block period while DFIP2203 is active");
                 }
             }
+        } else if (attrV0->type == AttributeTypes::Oracles && attrV0->typeId == OracleIDs::Splits) {
+            const auto value = boost::get<OracleSplits>(&attribute.second);
+            if (!value) {
+                return Res::Err("Unsupported value");
+            }
+            for (const auto split : tokenSplits) {
+                if (auto it{value->find(split)}; it == value->end()) {
+                    continue;
+                }
+                CDataStructureV0 lockKey{AttributeTypes::Locks, ParamIDs::TokenID, split};
+                if (GetValue(lockKey, false)) {
+                    continue;
+                }
+
+                if (!mnview.GetLoanTokenByID(DCT_ID{split}).has_value()) {
+                    return Res::Err("Auto lock. No loan token with id (%d)", split);
+                }
+
+                if (attrV0->key < height) {
+                    return Res::Err("Cannot be set at or below current height");
+                }
+
+                CGovernanceHeightMessage lock;
+                auto var = GovVariable::Create("ATTRIBUTES");
+                if (!var) {
+                    return Res::Err("Failed to create Gov var for lock");
+                }
+                auto govVar = std::dynamic_pointer_cast<ATTRIBUTES>(var);
+                if (!govVar) {
+                    return Res::Err("Failed to cast Gov var to ATTRIBUTES");
+                }
+                govVar->attributes[lockKey] = true;
+                lock.govVar = govVar;
+
+                const auto startHeight = attrV0->key - Params().GetConsensus().blocksPerDay() / 2;
+                if (height > startHeight) {
+                    lock.startHeight = height;
+                } else {
+                    lock.startHeight = startHeight;
+                }
+
+                const auto res = storeGovVars(lock, mnview);
+                if (!res) {
+                    return Res::Err("Cannot be set at or below current height");
+                }
+            }
         }
     }
 
diff --git a/src/masternodes/govvariables/attributes.h b/src/masternodes/govvariables/attributes.h
index 604b3f2dd27..97c784c293d 100644
--- a/src/masternodes/govvariables/attributes.h
+++ b/src/masternodes/govvariables/attributes.h
@@ -8,6 +8,7 @@
 #include <amount.h>
 #include <masternodes/balances.h>
 #include <masternodes/gv.h>
+#include <masternodes/oracles.h>
 
 enum VersionTypes : uint8_t {
     v0 = 0,
@@ -15,17 +16,24 @@ enum VersionTypes : uint8_t {
 
 enum AttributeTypes : uint8_t {
     Live      = 'l',
+    Oracles   = 'o',
     Param     = 'a',
     Token     = 't',
     Poolpairs = 'p',
+    Locks     = 'L',
 };
 
 enum ParamIDs : uint8_t  {
     DFIP2201  = 'a',
     DFIP2203  = 'b',
+    TokenID   = 'c',
     Economy   = 'e',
 };
 
+enum OracleIDs : uint8_t  {
+    Splits    = 'a',
+};
+
 enum EconomyKeys : uint8_t {
     PaybackDFITokens = 'a',
     PaybackTokens    = 'b',
@@ -43,13 +51,21 @@ enum DFIPKeys : uint8_t  {
 };
 
 enum TokenKeys : uint8_t  {
-    PaybackDFI          = 'a',
-    PaybackDFIFeePCT    = 'b',
-    LoanPayback         = 'c',
-    LoanPaybackFeePCT   = 'd',
-    DexInFeePct         = 'e',
-    DexOutFeePct        = 'f',
-    DFIP2203Enabled    = 'g',
+    PaybackDFI            = 'a',
+    PaybackDFIFeePCT      = 'b',
+    LoanPayback           = 'c',
+    LoanPaybackFeePCT     = 'd',
+    DexInFeePct           = 'e',
+    DexOutFeePct          = 'f',
+    DFIP2203Enabled       = 'g',
+    FixedIntervalPriceId  = 'h',
+    LoanCollateralEnabled = 'i',
+    LoanCollateralFactor  = 'j',
+    LoanMintingEnabled    = 'k',
+    LoanMintingInterest   = 'l',
+    Ascendant             = 'm',
+    Descendant            = 'n',
+    Epitaph               = 'o',
 };
 
 enum PoolKeys : uint8_t {
@@ -60,7 +76,7 @@ enum PoolKeys : uint8_t {
 struct CDataStructureV0 {
     uint8_t type;
     uint32_t typeId;
-    uint8_t key;
+    uint32_t key;
     uint32_t keyId;
 
     ADD_SERIALIZE_METHODS;
@@ -69,7 +85,7 @@ struct CDataStructureV0 {
     inline void SerializationOp(Stream& s, Operation ser_action) {
         READWRITE(type);
         READWRITE(typeId);
-        READWRITE(key);
+        READWRITE(VARINT(key));
         if (IsExtendedSize()) {
             READWRITE(keyId);
         } else {
@@ -113,8 +129,11 @@ struct CTokenPayback {
 
 ResVal<CScript> GetFutureSwapContractAddress();
 
+using OracleSplits = std::map<uint32_t, int32_t>;
+using DescendantValue = std::pair<uint32_t, int32_t>;
+using AscendantValue = std::pair<uint32_t, std::string>;
 using CAttributeType = boost::variant<CDataStructureV0, CDataStructureV1>;
-using CAttributeValue = boost::variant<bool, CAmount, CBalances, CTokenPayback>;
+using CAttributeValue = boost::variant<bool, CAmount, CBalances, CTokenPayback, CTokenCurrencyPair, OracleSplits, DescendantValue, AscendantValue>;
 
 class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRIBUTES>
 {
@@ -144,12 +163,44 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         return std::move(value);
     }
 
+    template<typename K, typename T>
+    void SetValue(const K& key, T&& value) {
+        static_assert(std::is_convertible_v<K, CAttributeType>);
+        static_assert(std::is_convertible_v<T, CAttributeValue>);
+        changed.insert(key);
+        attributes[key] = std::forward<T>(value);
+    }
+
+    template<typename K>
+    void EraseKey(const K& key) {
+        static_assert(std::is_convertible_v<K, CAttributeType>);
+        changed.insert(key);
+        attributes.erase(key);
+    }
+
     template<typename K>
     [[nodiscard]] bool CheckKey(const K& key) const {
         static_assert(std::is_convertible_v<K, CAttributeType>);
         return attributes.count(key) > 0;
     }
 
+    template<typename C, typename K>
+    void ForEach(const C& callback, const K& key) const {
+        static_assert(std::is_convertible_v<K, CAttributeType>);
+        static_assert(std::is_invocable_r_v<bool, C, K, CAttributeValue>);
+        for (auto it = attributes.lower_bound(key); it != attributes.end(); ++it) {
+            if (auto attrV0 = boost::get<K>(&it->first)) {
+                if (!std::invoke(callback, *attrV0, it->second)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    [[nodiscard]] const std::map<CAttributeType, CAttributeValue>& GetAttributesMap() const {
+        return attributes;
+    }
+
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
@@ -158,28 +209,37 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         READWRITE(attributes);
     }
 
-    std::map<CAttributeType, CAttributeValue> attributes;
+    uint32_t time{0};
+
+    // For formatting in export
+    static const std::map<uint8_t, std::string>& displayVersions();
+    static const std::map<uint8_t, std::string>& displayTypes();
+    static const std::map<uint8_t, std::string>& displayParamsIDs();
+    static const std::map<uint8_t, std::string>& displayOracleIDs();
+    static const std::map<uint8_t, std::map<uint8_t, std::string>>& displayKeys();
 
 private:
+    friend class CGovView;
     bool futureBlockUpdated{};
+    std::set<CAttributeType> changed;
+    std::map<CAttributeType, CAttributeValue> attributes;
 
     // Defined allowed arguments
     static const std::map<std::string, uint8_t>& allowedVersions();
     static const std::map<std::string, uint8_t>& allowedTypes();
     static const std::map<std::string, uint8_t>& allowedParamIDs();
+    static const std::map<std::string, uint8_t>& allowedLocksIDs();
+    static const std::map<std::string, uint8_t>& allowedOracleIDs();
     static const std::map<uint8_t, std::map<std::string, uint8_t>>& allowedKeys();
     static const std::map<uint8_t, std::map<uint8_t,
             std::function<ResVal<CAttributeValue>(const std::string&)>>>& parseValue();
 
-    // For formatting in export
-    static const std::map<uint8_t, std::string>& displayVersions();
-    static const std::map<uint8_t, std::string>& displayTypes();
-    static const std::map<uint8_t, std::string>& displayParamsIDs();
-    static const std::map<uint8_t, std::map<uint8_t, std::string>>& displayKeys();
-
     Res ProcessVariable(const std::string& key, const std::string& value,
                         std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable);
     Res RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID = std::numeric_limits<uint32_t>::max());
+
+private:
+    std::set<uint32_t> tokenSplits{};
 };
 
 #endif // DEFI_MASTERNODES_GOVVARIABLES_ATTRIBUTES_H
diff --git a/src/masternodes/gv.h b/src/masternodes/gv.h
index cb8507727d4..bc73e292286 100644
--- a/src/masternodes/gv.h
+++ b/src/masternodes/gv.h
@@ -49,6 +49,8 @@ class CGovView : public virtual CStorageView
 
     std::shared_ptr<ATTRIBUTES> GetAttributes() const;
 
+    [[nodiscard]] virtual bool AreTokensLocked(const std::set<uint32_t>& tokenIds) const = 0;
+
     struct ByHeightVars { static constexpr uint8_t prefix() { return 'G'; } };
     struct ByName { static constexpr uint8_t prefix() { return 'g'; } };
 };
diff --git a/src/masternodes/loan.cpp b/src/masternodes/loan.cpp
index 0e57152da4c..b5e79e01d2d 100644
--- a/src/masternodes/loan.cpp
+++ b/src/masternodes/loan.cpp
@@ -1,14 +1,14 @@
 
 #include <chainparams.h>
 #include <masternodes/loan.h>
+#include <masternodes/govvariables/attributes.h>
+#include <masternodes/masternodes.h>
+
 #include <boost/multiprecision/cpp_int.hpp>
 
-std::unique_ptr<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::GetLoanCollateralToken(uint256 const & txid) const
+boost::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::GetLoanCollateralToken(uint256 const & txid) const
 {
-    auto collToken = ReadBy<LoanSetCollateralTokenCreationTx,CLoanSetCollateralTokenImpl>(txid);
-    if (collToken)
-        return MakeUnique<CLoanSetCollateralTokenImpl>(*collToken);
-    return {};
+    return ReadBy<LoanSetCollateralTokenCreationTx,CLoanSetCollateralTokenImpl>(txid);
 }
 
 Res CLoanView::CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collToken)
@@ -29,15 +29,11 @@ Res CLoanView::CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & col
     return Res::Ok();
 }
 
-Res CLoanView::UpdateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collateralToken)
+Res CLoanView::EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl& collToken)
 {
-    if (collateralToken.factor > COIN)
-        return Res::Err("setCollateralToken factor must be lower or equal than %s!", GetDecimaleString(COIN));
-    if (collateralToken.factor < 0)
-        return Res::Err("setCollateralToken factor must not be negative!");
-
-    CollateralTokenKey key{collateralToken.idToken, collateralToken.activateAfterBlock};
-    WriteBy<LoanSetCollateralTokenKey>(key, collateralToken.creationTx);
+    CollateralTokenKey key{collToken.idToken, collToken.activateAfterBlock};
+    EraseBy<LoanSetCollateralTokenKey>(key);
+    EraseBy<LoanSetCollateralTokenCreationTx>(collToken.creationTx);
 
     return Res::Ok();
 }
@@ -47,15 +43,16 @@ void CLoanView::ForEachLoanCollateralToken(std::function<bool (CollateralTokenKe
     ForEach<LoanSetCollateralTokenKey, CollateralTokenKey, uint256>(callback, start);
 }
 
-std::unique_ptr<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::HasLoanCollateralToken(CollateralTokenKey const & key)
+boost::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::HasLoanCollateralToken(CollateralTokenKey const & key)
 {
     auto it = LowerBound<LoanSetCollateralTokenKey>(key);
     if (it.Valid() && it.Key().id == key.id)
         return GetLoanCollateralToken(it.Value());
-    return {};
+
+    return GetCollateralTokenFromAttributes(key.id);
 }
 
-std::unique_ptr<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanToken(uint256 const & txid) const
+boost::optional<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanToken(uint256 const & txid) const
 {
     auto id = ReadBy<LoanSetLoanTokenCreationTx, DCT_ID>(txid);
     if (id)
@@ -63,14 +60,6 @@ std::unique_ptr<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanToken(uint25
     return {};
 }
 
-std::unique_ptr<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanTokenByID(DCT_ID const & id) const
-{
-    auto loanToken = ReadBy<LoanSetLoanTokenKey,CLoanSetLoanTokenImpl>(id);
-    if (loanToken)
-        return MakeUnique<CLoanSetLoanTokenImpl>(*loanToken);
-    return {};
-}
-
 Res CLoanView::SetLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID const & id)
 {
     //this should not happen, but for sure
@@ -96,6 +85,13 @@ Res CLoanView::UpdateLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID c
     return Res::Ok();
 }
 
+Res CLoanView::EraseLoanToken(const DCT_ID& id)
+{
+    EraseBy<LoanSetLoanTokenKey>(id);
+
+    return Res::Ok();
+}
+
 void CLoanView::ForEachLoanToken(std::function<bool (DCT_ID const &, CLoanSetLoanTokenImpl const &)> callback, DCT_ID const & start)
 {
     ForEach<LoanSetLoanTokenKey, DCT_ID, CLoanSetLoanTokenImpl>(callback, start);
@@ -394,6 +390,11 @@ Res CLoanView::DeleteInterest(const CVaultId& vaultId, uint32_t height)
     return Res::Ok();
 }
 
+void CLoanView::EraseInterestDirect(const CVaultId& vaultId, DCT_ID id)
+{
+    EraseBy<LoanInterestV2ByVault>(std::make_pair(vaultId, id));
+}
+
 void CLoanView::RevertInterestRateToV1()
 {
     std::vector<std::pair<CVaultId, DCT_ID>> pairs;
@@ -461,7 +462,7 @@ boost::optional<CBalances> CLoanView::GetLoanTokens(const CVaultId& vaultId)
     return ReadBy<LoanTokenAmount, CBalances>(vaultId);
 }
 
-void CLoanView::ForEachLoanToken(std::function<bool(const CVaultId&, const CBalances&)> callback)
+void CLoanView::ForEachLoanTokenAmount(std::function<bool (const CVaultId&, const CBalances&)> callback)
 {
     ForEach<LoanTokenAmount, CVaultId, CBalances>(callback);
 }
diff --git a/src/masternodes/loan.h b/src/masternodes/loan.h
index 9711d9a549e..422c4b0ab3d 100644
--- a/src/masternodes/loan.h
+++ b/src/masternodes/loan.h
@@ -268,6 +268,8 @@ base_uint<128> TotalInterestCalculation(const CInterestRateV2& rate, uint32_t he
 CAmount CeilInterest(const base_uint<128>& value, uint32_t height);
 boost::optional<std::string> GetInterestPerBlockHighPrecisionString(const base_uint<128>& value);
 
+base_uint<128> InterestPerBlockCalculationV2(CAmount amount, CAmount tokenInterest, CAmount schemeInterest);
+
 class CLoanTakeLoanMessage
 {
 public:
@@ -324,16 +326,17 @@ class CLoanView : public virtual CStorageView {
     using CLoanSetCollateralTokenImpl = CLoanSetCollateralTokenImplementation;
     using CLoanSetLoanTokenImpl = CLoanSetLoanTokenImplementation;
 
-    std::unique_ptr<CLoanSetCollateralTokenImpl> GetLoanCollateralToken(uint256 const & txid) const;
+    boost::optional<CLoanSetCollateralTokenImpl> GetLoanCollateralToken(uint256 const & txid) const;
     Res CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collToken);
-    Res UpdateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collateralToken);
+    Res EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl& collToken);
     void ForEachLoanCollateralToken(std::function<bool (CollateralTokenKey const &, uint256 const &)> callback, CollateralTokenKey const & start = {DCT_ID{0}, UINT_MAX});
-    std::unique_ptr<CLoanSetCollateralTokenImpl> HasLoanCollateralToken(CollateralTokenKey const & key);
+    boost::optional<CLoanSetCollateralTokenImpl> HasLoanCollateralToken(CollateralTokenKey const & key);
 
-    std::unique_ptr<CLoanSetLoanTokenImpl> GetLoanToken(uint256 const & txid) const;
-    std::unique_ptr<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const & id) const;
+    boost::optional<CLoanSetLoanTokenImpl> GetLoanToken(uint256 const & txid) const;
+    [[nodiscard]] virtual boost::optional<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const & id) const = 0;
     Res SetLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID const & id);
     Res UpdateLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID const & id);
+    Res EraseLoanToken(const DCT_ID& id);
     void ForEachLoanToken(std::function<bool (DCT_ID const &, CLoanSetLoanTokenImpl const &)> callback, DCT_ID const & start = {0});
 
     Res StoreLoanScheme(const CLoanSchemeMessage& loanScheme);
@@ -351,6 +354,7 @@ class CLoanView : public virtual CStorageView {
     void ForEachDelayedDestroyScheme(std::function<bool (const std::string&, const uint64_t&)> callback);
 
     Res DeleteInterest(const CVaultId& vaultId, uint32_t height);
+    void EraseInterestDirect(const CVaultId& vaultId, DCT_ID id);
     boost::optional<CInterestRateV2> GetInterestRate(const CVaultId& loanSchemeID, DCT_ID id, uint32_t height);
     void WriteInterestRate(const std::pair<CVaultId, DCT_ID>& pair, const CInterestRateV2& rate, uint32_t height);
     Res StoreInterest(uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, DCT_ID id, CAmount loanIncreased);
@@ -363,11 +367,14 @@ class CLoanView : public virtual CStorageView {
     Res AddLoanToken(const CVaultId& vaultId, CTokenAmount amount);
     Res SubLoanToken(const CVaultId& vaultId, CTokenAmount amount);
     boost::optional<CBalances> GetLoanTokens(const CVaultId& vaultId);
-    void ForEachLoanToken(std::function<bool(const CVaultId&, const CBalances&)> callback);
+    void ForEachLoanTokenAmount(std::function<bool (const CVaultId&,  const CBalances&)> callback);
 
     Res SetLoanLiquidationPenalty(CAmount penalty);
     CAmount GetLoanLiquidationPenalty();
 
+    [[nodiscard]] virtual boost::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(const DCT_ID& id) const = 0;
+    [[nodiscard]] virtual boost::optional<CLoanSetCollateralTokenImpl> GetCollateralTokenFromAttributes(const DCT_ID& id) const = 0;
+
     struct LoanSetCollateralTokenCreationTx { static constexpr uint8_t prefix() { return 0x10; } };
     struct LoanSetCollateralTokenKey        { static constexpr uint8_t prefix() { return 0x11; } };
     struct LoanSetLoanTokenCreationTx       { static constexpr uint8_t prefix() { return 0x12; } };
diff --git a/src/masternodes/masternodes.cpp b/src/masternodes/masternodes.cpp
index 54d3bfe8755..11b182a0d51 100644
--- a/src/masternodes/masternodes.cpp
+++ b/src/masternodes/masternodes.cpp
@@ -4,10 +4,12 @@
 
 #include <masternodes/masternodes.h>
 #include <masternodes/anchors.h>
+#include <masternodes/govvariables/attributes.h>
 #include <masternodes/mn_checks.h>
 
 #include <chainparams.h>
 #include <consensus/merkle.h>
+#include <core_io.h>
 #include <net_processing.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -956,7 +958,7 @@ ResVal<CCollateralLoans> CCustomCSView::GetLoanCollaterals(CVaultId const& vault
     return ResVal<CCollateralLoans>(result, Res::Ok());
 }
 
-ResVal<CAmount> CCustomCSView::GetValidatedIntervalPrice(CTokenCurrencyPair priceFeedId, bool useNextPrice, bool requireLivePrice)
+ResVal<CAmount> CCustomCSView::GetValidatedIntervalPrice(const CTokenCurrencyPair& priceFeedId, bool useNextPrice, bool requireLivePrice)
 {
     auto tokenSymbol = priceFeedId.first;
     auto currency = priceFeedId.second;
@@ -1059,6 +1061,61 @@ uint256 CCustomCSView::MerkleRoot() {
     return ComputeMerkleRoot(std::move(hashes));
 }
 
+bool CCustomCSView::AreTokensLocked(const std::set<uint32_t>& tokenIds) const
+{
+    const auto attributes = GetAttributes();
+    if (!attributes) {
+        return false;
+    }
+
+    for (const auto& tokenId : tokenIds) {
+        CDataStructureV0 lockKey{AttributeTypes::Locks, ParamIDs::TokenID, tokenId};
+        if (attributes->GetValue(lockKey, false)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+boost::optional<CTokensView::CTokenImpl> CCustomCSView::GetTokenGuessId(const std::string & str, DCT_ID & id) const
+{
+    std::string const key = trim_ws(str);
+
+    if (key.empty()) {
+        id = DCT_ID{0};
+        return GetToken(id);
+    }
+    if (ParseUInt32(key, &id.v))
+        return GetToken(id);
+
+    uint256 tx;
+    if (ParseHashStr(key, tx)) {
+        auto pair = GetTokenByCreationTx(tx);
+        if (pair) {
+            id = pair->first;
+            return pair->second;
+        }
+    } else {
+        auto pair = GetToken(key);
+        if (pair && pair->second) {
+            id = pair->first;
+            return pair->second;
+        }
+    }
+    return {};
+}
+
+boost::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenByID(DCT_ID const & id) const
+{
+    auto loanToken = ReadBy<LoanSetLoanTokenKey, CLoanSetLoanTokenImpl>(id);
+    if (loanToken) {
+        return loanToken;
+    }
+
+    return GetLoanTokenFromAttributes(id);
+}
+
 std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team)
 {
     AssertLockHeld(cs_main);
@@ -1089,3 +1146,48 @@ std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team)
 
     return operatorDetails;
 }
+
+boost::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenFromAttributes(const DCT_ID& id) const {
+    if (const auto token = GetToken(id)) {
+        if (const auto attributes = GetAttributes()) {
+            CLoanView::CLoanSetLoanTokenImpl loanToken;
+
+            CDataStructureV0 pairKey{AttributeTypes::Token, id.v, TokenKeys::FixedIntervalPriceId};
+            CDataStructureV0 interestKey{AttributeTypes::Token, id.v, TokenKeys::LoanMintingInterest};
+            CDataStructureV0 mintableKey{AttributeTypes::Token, id.v, TokenKeys::LoanMintingEnabled};
+
+            if (attributes->CheckKey(pairKey) && attributes->CheckKey(interestKey) && attributes->CheckKey(mintableKey)) {
+
+                loanToken.fixedIntervalPriceId = attributes->GetValue(pairKey, CTokenCurrencyPair{});
+                loanToken.interest = attributes->GetValue(interestKey, CAmount{0});
+                loanToken.mintable = attributes->GetValue(mintableKey, false);
+                loanToken.symbol = token->symbol;
+                loanToken.name = token->name;
+
+                return loanToken;
+            }
+        }
+    }
+
+    return {};
+}
+
+boost::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollateralTokenFromAttributes(const DCT_ID& id) const {
+    if (const auto attributes = GetAttributes()) {
+        CLoanSetCollateralTokenImplementation collToken;
+
+        CDataStructureV0 pairKey{AttributeTypes::Token, id.v, TokenKeys::FixedIntervalPriceId};
+        CDataStructureV0 factorKey{AttributeTypes::Token, id.v, TokenKeys::LoanCollateralFactor};
+
+        if (attributes->CheckKey(pairKey) && attributes->CheckKey(factorKey)) {
+
+            collToken.fixedIntervalPriceId = attributes->GetValue(pairKey, CTokenCurrencyPair{});
+            collToken.factor = attributes->GetValue(factorKey, CAmount{0});
+            collToken.idToken = id;
+
+            return collToken;
+        }
+    }
+
+    return {};
+}
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 3ab67523e35..0a80d00f2c6 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -430,7 +430,13 @@ class CCustomCSView
 
     ResVal<CCollateralLoans> GetLoanCollaterals(CVaultId const & vaultId, CBalances const & collaterals, uint32_t height, int64_t blockTime, bool useNextPrice = false, bool requireLivePrice = true);
 
-    ResVal<CAmount> GetValidatedIntervalPrice(CTokenCurrencyPair priceFeedId, bool useNextPrice, bool requireLivePrice);
+    ResVal<CAmount> GetValidatedIntervalPrice(const CTokenCurrencyPair& priceFeedId, bool useNextPrice, bool requireLivePrice);
+
+    [[nodiscard]] bool AreTokensLocked(const std::set<uint32_t>& tokenIds) const override;
+    [[nodiscard]] boost::optional<CTokenImpl> GetTokenGuessId(const std::string & str, DCT_ID & id) const override;
+    [[nodiscard]] boost::optional<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const & id) const override;
+    [[nodiscard]] boost::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(const DCT_ID& id) const override;
+    [[nodiscard]] boost::optional<CLoanSetCollateralTokenImpl> GetCollateralTokenFromAttributes(const DCT_ID& id) const override;
 
     void SetDbVersion(int version);
 
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 28a746a14e6..dc61433305a 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -249,6 +249,13 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
         return Res::Ok();
     }
 
+    Res isPostGreatWorldFork() const {
+        if(static_cast<int>(height) < consensus.GreatWorldHeight) {
+            return Res::Err("called before GreatWorldHeight height");
+        }
+        return Res::Ok();
+    }
+
     template<typename T>
     Res serialize(T& obj) const {
         CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
@@ -513,17 +520,26 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
 
     Res operator()(CLoanSetCollateralTokenMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (!res)
+            return res;
+        res = isPostGreatWorldFork();
+        return res ? Res::Err("called after GreatWorld height") : serialize(obj);
     }
 
     Res operator()(CLoanSetLoanTokenMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (!res)
+            return res;
+        res = isPostGreatWorldFork();
+        return res ? Res::Err("called after GreatWorld height") : serialize(obj);
     }
 
     Res operator()(CLoanUpdateLoanTokenMessage& obj) const {
         auto res = isPostFortCanningFork();
-        return !res ? res : serialize(obj);
+        if (!res)
+            return res;
+        res = isPostGreatWorldFork();
+        return res ? Res::Err("called after GreatWorld height") : serialize(obj);
     }
 
     Res operator()(CLoanSchemeMessage& obj) const {
@@ -865,39 +881,6 @@ class CCustomTxVisitor : public boost::static_visitor<Res>
         tokenCurrency = std::move(trimmed);
         return Res::Ok();
     }
-
-    bool oraclePriceFeed(const CTokenCurrencyPair& priceFeed) const {
-        // Allow hard coded DUSD/USD
-        if (priceFeed.first == "DUSD" && priceFeed.second == "USD") {
-            return true;
-        }
-        bool found = false;
-        mnview.ForEachOracle([&](const COracleId&, COracle oracle) {
-            return !(found = oracle.SupportsPair(priceFeed.first, priceFeed.second));
-        });
-        return found;
-    }
-
-    void storeGovVars(const CGovernanceHeightMessage& obj) const {
-
-        // Retrieve any stored GovVariables at startHeight
-        auto storedGovVars = mnview.GetStoredVariables(obj.startHeight);
-
-        // Remove any pre-existing entry
-        for (auto it = storedGovVars.begin(); it != storedGovVars.end();) {
-            if ((*it)->GetName() == obj.govVar->GetName()) {
-                it = storedGovVars.erase(it);
-            } else {
-                ++it;
-            }
-        }
-
-        // Add GovVariable to set for storage
-        storedGovVars.insert(obj.govVar);
-
-        // Store GovVariable set by height
-        mnview.SetStoredVariables(storedGovVars, obj.startHeight);
-    }
 };
 
 class CCustomTxApplyVisitor : public CCustomTxVisitor
@@ -1048,16 +1031,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!pair) {
             return Res::Err("token with creationTx %s does not exist", obj.tokenTx.ToString());
         }
-        const auto& token = pair->second;
+        auto token = pair->second;
 
         //check foundation auth
         auto res = HasFoundationAuth();
 
         if (token.IsDAT() != obj.isDAT && pair->first >= CTokensView::DCT_ID_START) {
-            CToken newToken = static_cast<CToken>(token); // keeps old and triggers only DAT!
-            newToken.flags ^= (uint8_t)CToken::TokenFlags::DAT;
-
-            return !res ? res : mnview.UpdateToken(token.creationTx, newToken, true);
+            token.flags ^= (uint8_t)CToken::TokenFlags::DAT;
+            return !res ? res : mnview.UpdateToken(token, true);
         }
         return res;
     }
@@ -1071,6 +1052,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("Can't alter DFI token!"); // may be redundant cause DFI is 'finalized'
         }
 
+        if (mnview.AreTokensLocked({pair->first.v})) {
+            return Res::Err("Cannot update token during lock");
+        }
+
         const auto& token = pair->second;
 
         // need to check it exectly here cause lps has no collateral auth (that checked next)
@@ -1097,12 +1082,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             }
         }
 
-        auto updatedToken = obj.token;
+        CTokenImplementation updatedToken{obj.token};
+        updatedToken.creationTx = token.creationTx;
+        updatedToken.destructionTx = token.destructionTx;
+        updatedToken.destructionHeight = token.destructionHeight;
         if (height >= consensus.FortCanningHeight) {
             updatedToken.symbol = trim_ws(updatedToken.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
         }
 
-        return mnview.UpdateToken(token.creationTx, updatedToken, false);
+        return mnview.UpdateToken(updatedToken);
     }
 
     Res operator()(const CMintTokensMessage& obj) const {
@@ -1178,7 +1166,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         token.creationTx = tx.GetHash();
         token.creationHeight = height;
 
-        auto tokenId = mnview.CreateToken(token, false);
+        auto tokenId = mnview.CreateToken(token);
         if (!tokenId) {
             return std::move(tokenId);
         }
@@ -1597,7 +1585,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             balances.Add(obj.source);
         }
 
-        attributes->attributes[liveKey] = balances;
+        attributes->SetValue(liveKey, balances);
 
         mnview.SetVariable(*attributes);
 
@@ -1632,50 +1620,49 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
-        for(const auto& var : obj.govs) {
-            auto res = var->Validate(mnview);
-            if (!res) {
-                return Res::Err("%s: %s", var->GetName(), res.msg);
-            }
+        for(const auto& gov : obj.govs) {
+            Res res{};
 
-            if (var->GetName() == "ORACLE_BLOCK_INTERVAL") {
-                // Make sure ORACLE_BLOCK_INTERVAL only updates at end of interval
-                const auto diff = height % mnview.GetIntervalBlock();
-                if (diff != 0) {
-                    // Store as pending change
-                    storeGovVars({var, height + mnview.GetIntervalBlock() - diff});
-                    continue;
-                }
-            } else if (var->GetName() == "ATTRIBUTES") {
+            auto var = gov;
+
+            if (var->GetName() == "ATTRIBUTES") {
                 // Add to existing ATTRIBUTES instead of overwriting.
-                auto govVar = mnview.GetVariable(var->GetName());
-                res = govVar->Import(var->Export());
-                if (!res) {
-                    return Res::Err("%s: %s", var->GetName(), res.msg);
+                auto govVar = mnview.GetAttributes();
+
+                if (!govVar) {
+                    return Res::Err("%s: %s", var->GetName(), "Failed to get existing ATTRIBUTES");
                 }
 
+                govVar->time = time;
+
                 // Validate as complete set. Check for future conflicts between key pairs.
-                res = govVar->Validate(mnview);
-                if (!res) {
+                if (!(res = govVar->Import(var->Export()))
+                    ||  !(res = govVar->Validate(mnview))
+                    ||  !(res = govVar->Apply(mnview, height)))
                     return Res::Err("%s: %s", var->GetName(), res.msg);
-                }
 
-                res = govVar->Apply(mnview, height);
-                if (!res) {
+                var = govVar;
+            } else {
+                // After GW, some ATTRIBUTES changes require the context of its map to validate,
+                // moving this Validate() call to else statement from before this conditional.
+                res = var->Validate(mnview);
+                if (!res)
                     return Res::Err("%s: %s", var->GetName(), res.msg);
+
+                if (var->GetName() == "ORACLE_BLOCK_INTERVAL") {
+                    // Make sure ORACLE_BLOCK_INTERVAL only updates at end of interval
+                    const auto diff = height % mnview.GetIntervalBlock();
+                    if (diff != 0) {
+                        // Store as pending change
+                        storeGovVars({var, height + mnview.GetIntervalBlock() - diff}, mnview);
+                        continue;
+                    }
                 }
 
-                res = mnview.SetVariable(*govVar);
+                res = var->Apply(mnview, height);
                 if (!res) {
                     return Res::Err("%s: %s", var->GetName(), res.msg);
                 }
-
-                continue;
-            }
-
-            res = var->Apply(mnview, height);
-            if (!res) {
-                return Res::Err("%s: %s", var->GetName(), res.msg);
             }
 
             res = mnview.SetVariable(*var);
@@ -1706,7 +1693,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         // Store pending Gov var change
-        storeGovVars(obj);
+        storeGovVars(obj, mnview);
 
         return Res::Ok();
     }
@@ -2335,7 +2322,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (collToken.activateAfterBlock < height)
             return Res::Err("activateAfterBlock cannot be less than current height!");
 
-        if (!oraclePriceFeed(collToken.fixedIntervalPriceId))
+        if (!OraclePriceFeed(mnview, collToken.fixedIntervalPriceId))
             return Res::Err("Price feed %s/%s does not belong to any oracle", collToken.fixedIntervalPriceId.first, collToken.fixedIntervalPriceId.second);
 
         CFixedIntervalPrice fixedIntervalPrice;
@@ -2386,7 +2373,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasFoundationAuth())
             return Res::Err("tx not from foundation member!");
 
-        if (!oraclePriceFeed(loanToken.fixedIntervalPriceId))
+        if (!OraclePriceFeed(mnview, loanToken.fixedIntervalPriceId))
             return Res::Err("Price feed %s/%s does not belong to any oracle", loanToken.fixedIntervalPriceId.first, loanToken.fixedIntervalPriceId.second);
 
         CTokenImplementation token;
@@ -2398,7 +2385,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         token.creationTx = tx.GetHash();
         token.creationHeight = height;
 
-        auto tokenId = mnview.CreateToken(token, false);
+        auto tokenId = mnview.CreateToken(token);
         if (!tokenId)
             return std::move(tokenId);
 
@@ -2434,7 +2421,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             pair->second.name = trim_ws(obj.name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
 
         if (obj.fixedIntervalPriceId != loanToken->fixedIntervalPriceId) {
-            if (!oraclePriceFeed(obj.fixedIntervalPriceId))
+            if (!OraclePriceFeed(mnview, obj.fixedIntervalPriceId))
                 return Res::Err("Price feed %s/%s does not belong to any oracle", obj.fixedIntervalPriceId.first, obj.fixedIntervalPriceId.second);
 
             loanToken->fixedIntervalPriceId = obj.fixedIntervalPriceId;
@@ -2443,7 +2430,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (obj.mintable != (pair->second.flags & (uint8_t)CToken::TokenFlags::Mintable))
             pair->second.flags ^= (uint8_t)CToken::TokenFlags::Mintable;
 
-        res = mnview.UpdateToken(pair->second.creationTx, static_cast<CToken>(pair->second), false);
+        res = mnview.UpdateToken(pair->second);
         if (!res)
             return res;
 
@@ -2746,6 +2733,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (vault->isUnderLiquidation)
             return Res::Err("Cannot deposit to vault under liquidation");
 
+        // If collateral token exist make sure it is enabled.
+        if (mnview.GetCollateralTokenFromAttributes(obj.amount.nTokenId)) {
+            CDataStructureV0 collateralKey{AttributeTypes::Token, obj.amount.nTokenId.v, TokenKeys::LoanCollateralEnabled};
+            if (const auto attributes = mnview.GetAttributes(); !attributes->GetValue(collateralKey, false)) {
+                return Res::Err("Collateral token (%d) is disabled", obj.amount.nTokenId.v);
+            }
+        }
+
         //check balance
         CalculateOwnerRewards(obj.from);
         res = mnview.SubBalance(obj.from, obj.amount);
@@ -3188,7 +3183,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
                         balances.Add(CTokenAmount{loanTokenId, subAmount});
                         balances.Add(CTokenAmount{paybackTokenId, penalty});
-                        attributes->attributes[liveKey] = balances;
+                        attributes->SetValue(liveKey, balances);
 
                         LogPrint(BCLog::LOAN, "CLoanPaybackLoanMessage(): Burning interest and loan in %s directly - total loan %lld (%lld %s), height - %d\n", paybackToken->symbol, subLoan + subInterest, subInToken, paybackToken->symbol, height);
 
@@ -3201,7 +3196,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
                         balances.tokensPayback.Add(CTokenAmount{loanTokenId, subAmount});
                         balances.tokensFee.Add(CTokenAmount{paybackTokenId, penalty});
-                        attributes->attributes[liveKey] = balances;
+                        attributes->SetValue(liveKey, balances);
 
                         LogPrint(BCLog::LOAN, "CLoanPaybackLoanMessage(): Swapping %s to DFI and burning it - total loan %lld (%lld %s), height - %d\n", paybackToken->symbol, subLoan + subInterest, subInToken, paybackToken->symbol, height);
 
@@ -4114,6 +4109,10 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
             }
         }
 
+        if (view.AreTokensLocked({pool->idTokenA.v, pool->idTokenB.v})) {
+            return Res::Err("Pool currently disabled due to locked token");
+        }
+
         auto dexfeeInPct = view.GetDexFeeInPct(currentID, swapAmount.nTokenId);
 
         // Perform swap
@@ -4249,8 +4248,33 @@ bool IsVaultPriceValid(CCustomCSView& mnview, const CVaultId& vaultId, uint32_t
     if (auto loans = mnview.GetLoanTokens(vaultId))
         for (const auto& loan : loans->balances)
             if (auto loanToken = mnview.GetLoanTokenByID(loan.first))
-                if (auto fixedIntervalPrice = mnview.GetFixedIntervalPrice(loanToken->fixedIntervalPriceId))
+                if (auto fixedIntervalPrice = mnview.GetFixedIntervalPrice(loanToken->fixedIntervalPriceId)) {
                     if (!fixedIntervalPrice.val->isLive(mnview.GetPriceDeviation()))
                         return false;
+                } else {
+                    return false;
+                }
     return true;
 }
+
+
+Res storeGovVars(const CGovernanceHeightMessage& obj, CCustomCSView& view) {
+
+    // Retrieve any stored GovVariables at startHeight
+    auto storedGovVars = view.GetStoredVariables(obj.startHeight);
+
+    // Remove any pre-existing entry
+    for (auto it = storedGovVars.begin(); it != storedGovVars.end();) {
+        if ((*it)->GetName() == obj.govVar->GetName()) {
+            it = storedGovVars.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    // Add GovVariable to set for storage
+    storedGovVars.insert(obj.govVar);
+
+    // Store GovVariable set by height
+    return view.SetStoredVariables(storedGovVars, obj.startHeight);
+}
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index c198134d5a5..0163c56213a 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -25,8 +25,6 @@ class CVaultHistoryView;
 class CHistoryWriters;
 class CHistoryErasers;
 
-static const std::vector<unsigned char> DfTxMarker = {'D', 'f', 'T', 'x'};  // 44665478
-
 enum CustomTxErrCodes : uint32_t {
     NotSpecified = 0,
 //    NotCustomTx  = 1,
@@ -394,6 +392,19 @@ ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransactio
 ResVal<CAmount> GetAggregatePrice(CCustomCSView& view, const std::string& token, const std::string& currency, uint64_t lastBlockTime);
 bool IsVaultPriceValid(CCustomCSView& mnview, const CVaultId& vaultId, uint32_t height);
 Res SwapToDFIOverUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CScript const & from, CScript const & to, uint32_t height);
+Res storeGovVars(const CGovernanceHeightMessage& obj, CCustomCSView& view);
+
+inline bool OraclePriceFeed(CCustomCSView& view, const CTokenCurrencyPair& priceFeed) {
+    // Allow hard coded DUSD/USD
+    if (priceFeed.first == "DUSD" && priceFeed.second == "USD") {
+        return true;
+    }
+    bool found = false;
+    view.ForEachOracle([&](const COracleId&, COracle oracle) {
+        return !(found = oracle.SupportsPair(priceFeed.first, priceFeed.second));
+    });
+    return found;
+}
 
 /*
  * Checks if given tx is probably one of 'CustomTx', returns tx type and serialized metadata in 'data'
diff --git a/src/masternodes/oracles.cpp b/src/masternodes/oracles.cpp
index 44ea551b9d5..f8e2795515d 100644
--- a/src/masternodes/oracles.cpp
+++ b/src/masternodes/oracles.cpp
@@ -159,6 +159,23 @@ ResVal<CFixedIntervalPrice> COracleView::GetFixedIntervalPrice(const CTokenCurre
         return Res::Err("fixedIntervalPrice with id <%s/%s> not found", fixedIntervalPriceId.first, fixedIntervalPriceId.second);
     }
 
+    DCT_ID firstID{}, secondID{};
+    const auto firstToken = GetTokenGuessId(fixedIntervalPriceId.first, firstID);
+    const auto secondToken = GetTokenGuessId(fixedIntervalPriceId.second, secondID);
+
+    std::set<uint32_t> loanTokens;
+    if (firstToken && GetLoanTokenByID(firstID)) {
+        loanTokens.insert(firstID.v);
+    }
+
+    if (secondToken && GetLoanTokenByID(secondID)) {
+        loanTokens.insert(secondID.v);
+    }
+
+    if (AreTokensLocked(loanTokens)) {
+        return Res::Err("Fixed interval price currently disabled due to locked token");
+    }
+
     LogPrint(BCLog::ORACLE, "%s(): %s/%s, active - %lld, next - %lld\n", __func__, fixedIntervalPrice.priceFeedId.first, fixedIntervalPrice.priceFeedId.second, fixedIntervalPrice.priceRecord[0], fixedIntervalPrice.priceRecord[1]);
     return ResVal<CFixedIntervalPrice>(fixedIntervalPrice, Res::Ok());
 }
diff --git a/src/masternodes/oracles.h b/src/masternodes/oracles.h
index acce6e13154..ef2572913a8 100644
--- a/src/masternodes/oracles.h
+++ b/src/masternodes/oracles.h
@@ -16,6 +16,9 @@
 #include <string>
 #include <vector>
 
+class CTokenImplementation;
+class CLoanSetLoanTokenImplementation;
+
 using COracleId = uint256;
 using CPriceTimePair = std::pair<CAmount, int64_t>;
 using CTokenCurrencyPair = std::pair<std::string, std::string>;
@@ -156,6 +159,10 @@ class COracleView : public virtual CStorageView
     Res SetIntervalBlock(const uint32_t blockInterval);
     uint32_t GetIntervalBlock() const;
 
+    [[nodiscard]] virtual bool AreTokensLocked(const std::set<uint32_t>& tokenIds) const = 0;
+    [[nodiscard]] virtual boost::optional<CTokenImplementation> GetTokenGuessId(const std::string & str, DCT_ID & id) const = 0;
+    [[nodiscard]] virtual boost::optional<CLoanSetLoanTokenImplementation> GetLoanTokenByID(DCT_ID const & id) const = 0;
+
     struct ByName { static constexpr uint8_t prefix() { return 'O'; } };
     struct PriceDeviation { static constexpr uint8_t prefix() { return 'Y'; } };
     struct FixedIntervalBlockKey { static constexpr uint8_t prefix() { return 'z'; } };
diff --git a/src/masternodes/poolpairs.cpp b/src/masternodes/poolpairs.cpp
index c09515d802d..917d917262b 100644
--- a/src/masternodes/poolpairs.cpp
+++ b/src/masternodes/poolpairs.cpp
@@ -711,6 +711,10 @@ Res CPoolPairView::SetDexFeePct(DCT_ID poolId, DCT_ID tokenId, CAmount feePct) {
     return Res::Ok();
 }
 
+void CPoolPairView::EraseDexFeePct(DCT_ID poolId, DCT_ID tokenId) {
+    EraseBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId));
+}
+
 CAmount CPoolPairView::GetDexFeeInPct(DCT_ID poolId, DCT_ID tokenId) const {
     uint32_t feePct;
     return ReadBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId), feePct)
diff --git a/src/masternodes/poolpairs.h b/src/masternodes/poolpairs.h
index 9ea293bab4e..e7297436458 100644
--- a/src/masternodes/poolpairs.h
+++ b/src/masternodes/poolpairs.h
@@ -232,6 +232,7 @@ class CPoolPairView : public virtual CStorageView
     bool HasPoolPair(DCT_ID const & poolId) const;
 
     Res SetDexFeePct(DCT_ID poolId, DCT_ID tokenId, CAmount feePct);
+    void EraseDexFeePct(DCT_ID poolId, DCT_ID tokenId);
     CAmount GetDexFeeInPct(DCT_ID poolId, DCT_ID tokenId) const;
     CAmount GetDexFeeOutPct(DCT_ID poolId, DCT_ID tokenId) const;
 
diff --git a/src/masternodes/rpc_loan.cpp b/src/masternodes/rpc_loan.cpp
index ab01455a702..8ddefa9dfde 100644
--- a/src/masternodes/rpc_loan.cpp
+++ b/src/masternodes/rpc_loan.cpp
@@ -1,14 +1,16 @@
 #include <masternodes/mn_rpc.h>
 
-extern UniValue tokenToJSON(DCT_ID const& id, CTokenImplementation const& token, bool verbose);
+#include <masternodes/govvariables/attributes.h>
+
+extern UniValue tokenToJSON(CCustomCSView& view, DCT_ID const& id, CTokenImplementation const& token, bool verbose);
 extern UniValue listauctions(const JSONRPCRequest& request);
 extern std::pair<int, int> GetFixedIntervalPriceBlocks(int currentHeight, const CCustomCSView &mnview);
 
-UniValue setCollateralTokenToJSON(CLoanSetCollateralTokenImplementation const& collToken)
+UniValue setCollateralTokenToJSON(CCustomCSView& view, CLoanSetCollateralTokenImplementation const& collToken)
 {
     UniValue collTokenObj(UniValue::VOBJ);
 
-    auto token = pcustomcsview->GetToken(collToken.idToken);
+    auto token = view.GetToken(collToken.idToken);
     if (!token)
         return (UniValue::VNULL);
     collTokenObj.pushKV("token", token->CreateSymbolKey(collToken.idToken));
@@ -21,20 +23,22 @@ UniValue setCollateralTokenToJSON(CLoanSetCollateralTokenImplementation const& c
     return (collTokenObj);
 }
 
-UniValue setLoanTokenToJSON(CLoanSetLoanTokenImplementation const& loanToken, DCT_ID tokenId)
+UniValue setLoanTokenToJSON(CCustomCSView& view, CLoanSetLoanTokenImplementation const& loanToken, DCT_ID tokenId)
 {
     UniValue loanTokenObj(UniValue::VOBJ);
 
-    auto token = pcustomcsview->GetToken(tokenId);
+    auto token = view.GetToken(tokenId);
     if (!token)
         return (UniValue::VNULL);
 
-    loanTokenObj.pushKV("token", tokenToJSON(tokenId, *token, true));
+    loanTokenObj.pushKV("token", tokenToJSON(view, tokenId, *token, true));
     loanTokenObj.pushKV("fixedIntervalPriceId", loanToken.fixedIntervalPriceId.first + "/" + loanToken.fixedIntervalPriceId.second);
     loanTokenObj.pushKV("interest", ValueFromAmount(loanToken.interest));
+    loanTokenObj.pushKV("mintable", loanToken.mintable);
 
     return (loanTokenObj);
 }
+
 CTokenCurrencyPair DecodePriceFeedString(const std::string& value){
     auto delim = value.find('/');
     if (delim == value.npos || value.find('/', delim + 1) != value.npos)
@@ -209,7 +213,7 @@ UniValue getcollateraltoken(const JSONRPCRequest& request) {
     auto collToken = pcustomcsview->HasLoanCollateralToken(start);
     if (collToken && collToken->factor)
     {
-        ret.pushKVs(setCollateralTokenToJSON(*collToken));
+        ret.pushKVs(setCollateralTokenToJSON(*pcustomcsview, *collToken));
     }
 
     return (ret);
@@ -219,15 +223,7 @@ UniValue getcollateraltoken(const JSONRPCRequest& request) {
 UniValue listcollateraltokens(const JSONRPCRequest& request) {
     RPCHelpMan{"listcollateraltokens",
                 "Return list of all created collateral tokens. If no parameters passed it will return all current valid setcollateraltoken transactions.\n",
-                {
-                    {"by", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                        {
-                            {"height", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Valid at specified height"},
-                            {"all", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Alltime setcollateraltoken transactions"},
-                        },
-                    },
-
-                },
+                {},
                 RPCResult
                 {
                     "{...}     (object) Json object with collateral token information\n"
@@ -238,52 +234,38 @@ UniValue listcollateraltokens(const JSONRPCRequest& request) {
      }.Check(request);
 
     UniValue ret(UniValue::VARR);
-    DCT_ID currentToken = {std::numeric_limits<uint32_t>::max()};
-    uint32_t height = ::ChainActive().Height();
-    bool all = false;
-
-    if (request.params.size() > 0)
-    {
-        UniValue byObj = request.params[0].get_obj();
-        std::string tokenSymbol;
-
-        if (!byObj["height"].isNull())
-            height = (size_t) byObj["height"].get_int64();
-        if (!byObj["all"].isNull())
-            all =  byObj["all"].get_bool();
-    }
+    CCustomCSView view(*pcustomcsview);
 
-    LOCK(cs_main);
-
-    CollateralTokenKey start{DCT_ID{0}, height};
-    if (all)
-    {
-        pcustomcsview->ForEachLoanCollateralToken([&](CollateralTokenKey const & key, uint256 const & collTokenTx)
-        {
-            auto collToken = pcustomcsview->GetLoanCollateralToken(collTokenTx);
-            if (collToken)
-                ret.push_back(setCollateralTokenToJSON(*collToken));
+    view.ForEachLoanCollateralToken([&](CollateralTokenKey const & key, uint256 const & collTokenTx) {
+        auto collToken = view.GetLoanCollateralToken(collTokenTx);
+        if (collToken)
+            ret.push_back(setCollateralTokenToJSON(view, *collToken));
 
-            return true;
-        });
+        return true;
+    });
 
-        return (ret);
+    if (!ret.empty()) {
+        return ret;
     }
 
-    pcustomcsview->ForEachLoanCollateralToken([&](CollateralTokenKey const & key, uint256 const & collTokenTx)
-    {
-        if ((key.height > height || currentToken == key.id)) return true;
+    auto attributes = view.GetAttributes();
+    if (!attributes) {
+        return ret;
+    }
 
-        currentToken = key.id;
-        auto collToken = pcustomcsview->GetLoanCollateralToken(collTokenTx);
-        if (collToken)
-        {
-            ret.push_back(setCollateralTokenToJSON(*collToken));
+    attributes->ForEach([&](const CDataStructureV0& attr, const CAttributeValue&) {
+        if (attr.type != AttributeTypes::Token) {
+            return false;
+        }
+        if (attr.key == TokenKeys::LoanCollateralEnabled) {
+            if (auto collToken = view.GetCollateralTokenFromAttributes({attr.typeId})) {
+                ret.push_back(setCollateralTokenToJSON(view, *collToken));
+            }
         }
         return true;
-    }, start);
+    }, CDataStructureV0{AttributeTypes::Token});
 
-    return (ret);
+    return ret;
 }
 
 UniValue setloantoken(const JSONRPCRequest& request) {
@@ -445,7 +427,7 @@ UniValue updateloantoken(const JSONRPCRequest& request) {
     UniValue metaObj = request.params[1].get_obj();
     UniValue const & txInputs = request.params[2];
 
-    std::unique_ptr<CLoanSetLoanTokenImplementation> loanToken;
+    boost::optional<CLoanSetLoanTokenImplementation> loanToken;
     CTokenImplementation tokenImpl;
 
     int targetHeight;
@@ -532,14 +514,36 @@ UniValue listloantokens(const JSONRPCRequest& request) {
 
     UniValue ret(UniValue::VARR);
 
-    LOCK(cs_main);
+    CCustomCSView view(*pcustomcsview);
 
-    pcustomcsview->ForEachLoanToken([&](DCT_ID const & key, CLoanView::CLoanSetLoanTokenImpl loanToken) {
-        ret.push_back(setLoanTokenToJSON(loanToken,key));
+    view.ForEachLoanToken([&](DCT_ID const & key, CLoanView::CLoanSetLoanTokenImpl loanToken) {
+        ret.push_back(setLoanTokenToJSON(view, loanToken, key));
         return true;
     });
 
-    return (ret);
+    if (!ret.empty()) {
+        return ret;
+    }
+
+    auto attributes = view.GetAttributes();
+    if (!attributes) {
+        return ret;
+    }
+
+    attributes->ForEach([&](const CDataStructureV0& attr, const CAttributeValue&) {
+        if (attr.type != AttributeTypes::Token) {
+            return false;
+        }
+        if (attr.key == TokenKeys::LoanMintingEnabled) {
+            auto tokenId = DCT_ID{attr.typeId};
+            if (auto loanToken = view.GetLoanTokenFromAttributes(tokenId)) {
+                ret.push_back(setLoanTokenToJSON(view, *loanToken, tokenId));
+            }
+        }
+        return true;
+    }, CDataStructureV0{AttributeTypes::Token});
+
+    return ret;
 }
 
 UniValue getloantoken(const JSONRPCRequest& request)
@@ -577,7 +581,7 @@ UniValue getloantoken(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_DATABASE_ERROR, strprintf("<%s> is not a valid loan token!", tokenSymbol.c_str()));
     }
 
-    return setLoanTokenToJSON(*loanToken, idToken);
+    return setLoanTokenToJSON(*pcustomcsview, *loanToken, idToken);
 }
 
 UniValue createloanscheme(const JSONRPCRequest& request) {
diff --git a/src/masternodes/rpc_poolpair.cpp b/src/masternodes/rpc_poolpair.cpp
index 0e5044cd7da..34f76b55cc8 100644
--- a/src/masternodes/rpc_poolpair.cpp
+++ b/src/masternodes/rpc_poolpair.cpp
@@ -1071,6 +1071,11 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
                 throw JSONRPCError(RPC_INVALID_REQUEST, "Input amount should be positive");
 
             CPoolPair pp = poolPair->second;
+
+            if (mnview_dummy.AreTokensLocked({pp.idTokenA.v, pp.idTokenB.v})) {
+                throw JSONRPCError(RPC_INVALID_REQUEST, "Pool currently disabled due to locked token");
+            }
+
             auto dexfeeInPct = mnview_dummy.GetDexFeeInPct(poolPair->first, poolSwapMsg.idTokenFrom);
 
             res = pp.Swap({poolSwapMsg.idTokenFrom, poolSwapMsg.amountFrom}, dexfeeInPct, poolSwapMsg.maxPrice, [&] (const CTokenAmount &, const CTokenAmount &tokenAmount) {
diff --git a/src/masternodes/rpc_tokens.cpp b/src/masternodes/rpc_tokens.cpp
index b72f33b0668..f61e645d0d4 100644
--- a/src/masternodes/rpc_tokens.cpp
+++ b/src/masternodes/rpc_tokens.cpp
@@ -1,4 +1,7 @@
 #include <masternodes/mn_rpc.h>
+
+#include <masternodes/govvariables/attributes.h>
+
 #include <index/txindex.h>
 
 UniValue createtoken(const JSONRPCRequest& request) {
@@ -319,7 +322,7 @@ UniValue updatetoken(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue tokenToJSON(DCT_ID const& id, CTokenImplementation const& token, bool verbose) {
+UniValue tokenToJSON(CCustomCSView& view, DCT_ID const& id, CTokenImplementation const& token, bool verbose) {
     UniValue tokenObj(UniValue::VOBJ);
     tokenObj.pushKV("symbol", token.symbol);
     tokenObj.pushKV("symbolKey", token.CreateSymbolKey(id));
@@ -333,7 +336,15 @@ UniValue tokenToJSON(DCT_ID const& id, CTokenImplementation const& token, bool v
         tokenObj.pushKV("isDAT", token.IsDAT());
         tokenObj.pushKV("isLPS", token.IsPoolShare());
         tokenObj.pushKV("finalized", token.IsFinalized());
-        tokenObj.pushKV("isLoanToken", token.IsLoanToken());
+        auto loanToken{token.IsLoanToken()};
+        if (!loanToken) {
+            if (auto attributes = view.GetAttributes()) {
+                CDataStructureV0 mintingKey{AttributeTypes::Token, id.v, TokenKeys::LoanMintingEnabled};
+                CDataStructureV0 interestKey{AttributeTypes::Token, id.v, TokenKeys::LoanMintingInterest};
+                loanToken = attributes->GetValue(mintingKey, false) && attributes->CheckKey(interestKey);
+            }
+        }
+        tokenObj.pushKV("isLoanToken", loanToken);
 
         tokenObj.pushKV("minted", ValueFromAmount(token.minted));
         tokenObj.pushKV("creationTx", token.creationTx.ToString());
@@ -414,7 +425,7 @@ UniValue listtokens(const JSONRPCRequest& request) {
 
     UniValue ret(UniValue::VOBJ);
     pcustomcsview->ForEachToken([&](DCT_ID const& id, CTokenImplementation token) {
-        ret.pushKVs(tokenToJSON(id, token, verbose));
+        ret.pushKVs(tokenToJSON(*pcustomcsview, id, token, verbose));
 
         limit--;
         return limit != 0;
@@ -444,7 +455,7 @@ UniValue gettoken(const JSONRPCRequest& request) {
     DCT_ID id;
     auto token = pcustomcsview->GetTokenGuessId(request.params[0].getValStr(), id);
     if (token) {
-        return tokenToJSON(id, *token, true);
+        return tokenToJSON(*pcustomcsview, id, *token, true);
     }
     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Token not found");
 }
diff --git a/src/masternodes/tokens.cpp b/src/masternodes/tokens.cpp
index 78ec22798a5..1c1625e12f6 100644
--- a/src/masternodes/tokens.cpp
+++ b/src/masternodes/tokens.cpp
@@ -5,6 +5,7 @@
 #include <masternodes/tokens.h>
 
 #include <amount.h>
+#include <chainparams.h> // Params()
 #include <core_io.h>
 #include <primitives/transaction.h>
 
@@ -51,34 +52,6 @@ boost::optional<std::pair<DCT_ID, CTokensView::CTokenImpl> > CTokensView::GetTok
     return {};
 }
 
-boost::optional<CTokensView::CTokenImpl> CTokensView::GetTokenGuessId(const std::string & str, DCT_ID & id) const
-{
-    std::string const key = trim_ws(str);
-
-    if (key.empty()) {
-        id = DCT_ID{0};
-        return GetToken(id);
-    }
-    if (ParseUInt32(key, &id.v))
-        return GetToken(id);
-
-    uint256 tx;
-    if (ParseHashStr(key, tx)) {
-        auto pair = GetTokenByCreationTx(tx);
-        if (pair) {
-            id = pair->first;
-            return pair->second;
-        }
-    } else {
-        auto pair = GetToken(key);
-        if (pair) {
-            id = pair->first;
-            return pair->second;
-        }
-    }
-    return {};
-}
-
 void CTokensView::ForEachToken(std::function<bool (const DCT_ID &, CLazySerialize<CTokenImpl>)> callback, DCT_ID const & start)
 {
     ForEach<ID, DCT_ID, CTokenImpl>(callback, start);
@@ -162,11 +135,11 @@ Res CTokensView::RevertCreateToken(const uint256 & txid)
     return Res::Ok();
 }
 
-Res CTokensView::UpdateToken(const uint256 &tokenTx, const CToken& newToken, bool isPreBayfront)
+Res CTokensView::UpdateToken(const CTokenImpl& newToken, bool isPreBayfront, const bool skipNameValidation)
 {
-    auto pair = GetTokenByCreationTx(tokenTx);
+    auto pair = GetTokenByCreationTx(newToken.creationTx);
     if (!pair) {
-        return Res::Err("token with creationTx %s does not exist!", tokenTx.ToString());
+        return Res::Err("token with creationTx %s does not exist!", newToken.creationTx.ToString());
     }
     DCT_ID id = pair->first;
     CTokenImpl & oldToken = pair->second;
@@ -179,9 +152,11 @@ Res CTokensView::UpdateToken(const uint256 &tokenTx, const CToken& newToken, boo
     oldToken.name = newToken.name;
 
     // check new symbol correctness
-    auto checkSymbolRes = newToken.IsValidSymbol();
-    if (!checkSymbolRes.ok) {
-        return checkSymbolRes;
+    if (!skipNameValidation) {
+        auto checkSymbolRes = newToken.IsValidSymbol();
+        if (!checkSymbolRes.ok) {
+            return checkSymbolRes;
+        }
     }
 
     // deal with DB symbol indexes before touching symbols/DATs:
@@ -211,6 +186,14 @@ Res CTokensView::UpdateToken(const uint256 &tokenTx, const CToken& newToken, boo
     if (!oldToken.IsFinalized() && newToken.IsFinalized()) // IsFinalized() itself was checked upthere (with Err)
         oldToken.flags |= (uint8_t)CToken::TokenFlags::Finalized;
 
+    if (oldToken.destructionHeight != newToken.destructionHeight) {
+        oldToken.destructionHeight = newToken.destructionHeight;
+    }
+
+    if (oldToken.destructionTx != newToken.destructionTx) {
+        oldToken.destructionTx = newToken.destructionTx;
+    }
+
     WriteBy<ID>(id, oldToken);
     return Res::Ok();
 }
@@ -307,3 +290,17 @@ boost::optional<DCT_ID> CTokensView::ReadLastDctId() const
     }
     return {};
 }
+
+inline Res CTokenImplementation::IsValidSymbol() const
+{
+    if (symbol.size() == 0 || IsDigit(symbol[0])) {
+        return Res::Err("token symbol should be non-empty and starts with a letter");
+    }
+    if (symbol.find('#') != std::string::npos) {
+        return Res::Err("token symbol should not contain '#'");
+    }
+    if (creationHeight >= Params().GetConsensus().GreatWorldHeight && symbol.find('/') != std::string::npos) {
+        return Res::Err("token symbol should not contain '/'");
+    }
+    return Res::Ok();
+}
diff --git a/src/masternodes/tokens.h b/src/masternodes/tokens.h
index 3ec0d41907a..5416b320e6a 100644
--- a/src/masternodes/tokens.h
+++ b/src/masternodes/tokens.h
@@ -76,16 +76,6 @@ class CToken
     {
         return flags & (uint8_t)TokenFlags::LoanToken;
     }
-    inline Res IsValidSymbol() const
-    {
-        if (symbol.size() == 0 || IsDigit(symbol[0])) {
-            return Res::Err("token symbol should be non-empty and starts with a letter");
-        }
-        if (symbol.find('#') != std::string::npos) {
-            return Res::Err("token symbol should not contain '#'");
-        }
-        return Res::Ok();
-    }
     inline std::string CreateSymbolKey(DCT_ID const & id) const {
         return symbol + (IsDAT() ? "" : "#" + std::to_string(id.v));
     }
@@ -120,8 +110,16 @@ class CTokenImplementation : public CToken
         , creationHeight(-1)
         , destructionHeight(-1)
     {}
+    explicit CTokenImplementation(const CToken& token)
+            : CToken(token)
+            , minted(0)
+            , creationHeight(-1)
+            , destructionHeight(-1)
+    {}
     ~CTokenImplementation() override = default;
 
+    [[nodiscard]] inline Res IsValidSymbol() const;
+
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
@@ -146,14 +144,14 @@ class CTokensView : public virtual CStorageView
     boost::optional<std::pair<DCT_ID, boost::optional<CTokensView::CTokenImpl>>> GetToken(std::string const & symbol) const;
     // the only possible type of token (with creationTx) is CTokenImpl
     boost::optional<std::pair<DCT_ID, CTokenImpl>> GetTokenByCreationTx(uint256 const & txid) const;
-    boost::optional<CTokensView::CTokenImpl> GetTokenGuessId(const std::string & str, DCT_ID & id) const;
+    [[nodiscard]] virtual boost::optional<CTokenImpl> GetTokenGuessId(const std::string & str, DCT_ID & id) const = 0;
 
     void ForEachToken(std::function<bool(DCT_ID const &, CLazySerialize<CTokenImpl>)> callback, DCT_ID const & start = DCT_ID{0});
 
     Res CreateDFIToken();
-    ResVal<DCT_ID> CreateToken(CTokenImpl const & token, bool isPreBayfront);
+    ResVal<DCT_ID> CreateToken(CTokenImpl const & token, bool isPreBayfront = false);
     Res RevertCreateToken(uint256 const & txid);
-    Res UpdateToken(uint256 const & tokenTx, CToken const & newToken, bool isPreBayfront);
+    Res UpdateToken(CTokenImpl const & newToken, bool isPreBayfront = false, const bool skipNameValidation = false);
 
     Res BayfrontFlagsCleanup();
     Res AddMintedTokens(DCT_ID const & id, CAmount const & amount);
diff --git a/src/miner.cpp b/src/miner.cpp
index 61c857021b8..296a7cc010d 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -15,6 +15,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <masternodes/anchors.h>
+#include <masternodes/govvariables/attributes.h>
 #include <masternodes/masternodes.h>
 #include <masternodes/mn_checks.h>
 #include <memory.h>
@@ -219,6 +220,41 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     }
     addPackageTxs(nPackagesSelected, nDescendantsUpdated, nHeight, mnview);
 
+    // TXs for the creationTx field in new tokens created via token split
+    if (nHeight >= chainparams.GetConsensus().GreatWorldHeight) {
+        const auto attributes = mnview.GetAttributes();
+        if (attributes) {
+            CDataStructureV0 splitKey{AttributeTypes::Oracles, OracleIDs::Splits, static_cast<uint32_t>(nHeight)};
+            const auto splits = attributes->GetValue(splitKey, OracleSplits{});
+
+            for (const auto& [id, multiplier] : splits) {
+                uint32_t entries{1};
+                mnview.ForEachPoolPair([&, id = id](DCT_ID const & poolId, const CPoolPair& pool){
+                    if (pool.idTokenA.v == id || pool.idTokenB.v == id) {
+                        ++entries;
+                    }
+                    return true;
+                });
+
+                for (uint32_t i{0}; i < entries; ++i) {
+                    CDataStream metadata(DfTokenSplitMarker, SER_NETWORK, PROTOCOL_VERSION);
+                    metadata << i << id << multiplier;
+
+                    CMutableTransaction mTx(txVersion);
+                    mTx.vin.resize(1);
+                    mTx.vin[0].prevout.SetNull();
+                    mTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
+                    mTx.vout.resize(1);
+                    mTx.vout[0].scriptPubKey = CScript() << OP_RETURN << ToByteVector(metadata);
+                    mTx.vout[0].nValue = 0;
+                    pblock->vtx.push_back(MakeTransactionRef(std::move(mTx)));
+                    pblocktemplate->vTxFees.push_back(0);
+                    pblocktemplate->vTxSigOpsCost.push_back(WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx.back()));
+                }
+            }
+        }
+    }
+
     int64_t nTime1 = GetTimeMicros();
 
     m_last_block_num_txs = nBlockTx;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 1b63fb36816..ddc0b58b567 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1336,6 +1336,7 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
     BuriedForkDescPushBack(softforks, "fortcanningpark", consensusParams.FortCanningParkHeight);
     BuriedForkDescPushBack(softforks, "fortcanninghill", consensusParams.FortCanningHillHeight);
     BuriedForkDescPushBack(softforks, "fortcanningroad", consensusParams.FortCanningRoadHeight);
+    BuriedForkDescPushBack(softforks, "greatworld", consensusParams.GreatWorldHeight);
     BIP9SoftForkDescPushBack(softforks, "testdummy", consensusParams, Consensus::DEPLOYMENT_TESTDUMMY);
     obj.pushKV("softforks",             softforks);
 
diff --git a/src/util/strencodings.h b/src/util/strencodings.h
index ae8bcd53dcc..2678df2d87f 100644
--- a/src/util/strencodings.h
+++ b/src/util/strencodings.h
@@ -13,6 +13,7 @@
 
 #include <cstdint>
 #include <iterator>
+#include <sstream>
 #include <string>
 #include <vector>
 
@@ -258,4 +259,16 @@ std::string ToUpper(const std::string& str);
  */
 std::string Capitalize(std::string str);
 
+template<typename T>
+static std::string KeyBuilder(const T& value){
+    std::ostringstream oss;
+    oss << value;
+    return oss.str();
+}
+
+template<typename T, typename ... Args >
+static std::string KeyBuilder(const T& value, const Args& ... args){
+    return KeyBuilder(value) + '/' + KeyBuilder(args...);
+}
+
 #endif // DEFI_UTIL_STRENCODINGS_H
diff --git a/src/validation.cpp b/src/validation.cpp
index b359e405fbf..c099cd17f6f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -14,6 +14,7 @@
 #include <consensus/tx_check.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
+#include <core_io.h> /// ValueFromAmount
 #include <cuckoocache.h>
 #include <flatfile.h>
 #include <hash.h>
@@ -23,6 +24,8 @@
 #include <masternodes/govvariables/attributes.h>
 #include <masternodes/govvariables/loan_daily_reward.h>
 #include <masternodes/govvariables/lp_daily_dfi_reward.h>
+#include <masternodes/govvariables/lp_splits.h>
+#include <masternodes/govvariables/loan_splits.h>
 #include <masternodes/masternodes.h>
 #include <masternodes/mn_checks.h>
 #include <masternodes/vaulthistory.h>
@@ -1641,6 +1644,42 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
 }
 
+static bool GetCreationTransactions(const CBlock& block, const uint32_t id, const int32_t multiplier, uint256& tokenCreationTx, std::vector<uint256>& poolCreationTx) {
+    bool opcodes{false};
+    std::vector<unsigned char> metadata;
+    uint32_t type;
+    uint32_t metaId;
+    int32_t metaMultiplier;
+
+    for (const auto& tx : block.vtx) {
+        if (ParseScriptByMarker(tx->vout[0].scriptPubKey, DfTokenSplitMarker, metadata, opcodes)) {
+            try {
+                CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
+                ss >> type;
+                ss >> metaId;
+                ss >> metaMultiplier;
+
+                if (id == metaId && multiplier == metaMultiplier) {
+                    if (type == 0) {
+                        tokenCreationTx = tx->GetHash();
+                    } else if (type > 0) {
+                        poolCreationTx.push_back(tx->GetHash());
+                    }
+                }
+            } catch (const std::ios_base::failure&) {
+                LogPrintf("Failed to read ID and multiplier from token split coinbase TXs. TX: %s\n", tx->GetHash().ToString());
+            }
+        }
+    }
+
+    if (tokenCreationTx == uint256{}) {
+        LogPrintf("%s: Token split failed. Coinbase TX for new token not found.\n", __func__);
+        return false;
+    }
+
+    return true;
+}
+
 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
  *  When FAILED is returned, view is left in an indeterminate state. */
 DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view, CCustomCSView& mnview, std::vector<CAnchorConfirmMessage> & disconnectedAnchorConfirms)
@@ -1767,7 +1806,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
 
         // restore inputs
         TBytes dummy;
-        if (i > 0 && !IsAnchorRewardTx(tx, dummy) && !IsAnchorRewardTxPlus(tx, dummy)) { // not coinbases
+        if (i > 0 && !IsAnchorRewardTx(tx, dummy) && !IsAnchorRewardTxPlus(tx, dummy) && !IsTokenSplitTx(tx, dummy)) { // not coinbases
             CTxUndo &txundo = blockUndo.vtxundo[i-1];
             if (txundo.vprevout.size() != tx.vin.size()) {
                 error("DisconnectBlock(): transaction and undo data inconsistent");
@@ -2246,6 +2285,25 @@ std::vector<CAuctionBatch> CollectAuctionBatches(const CCollateralLoans& collLoa
     return batches;
 }
 
+bool ApplyGovVars(CCustomCSView& cache, const CBlockIndex& pindex, const std::map<std::string, std::string>& attrs){
+    if (auto govVar = cache.GetVariable("ATTRIBUTES")) {
+        if (auto var = dynamic_cast<ATTRIBUTES*>(govVar.get())) {
+            var->time = pindex.nTime;
+
+            UniValue obj(UniValue::VOBJ);
+            for (const auto& [key, value] : attrs) {
+                obj.pushKV(key, value);
+            }
+
+            if (var->Import(obj) && var->Validate(cache) && var->Apply(cache, pindex.nHeight) && cache.SetVariable(*var)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
@@ -2666,6 +2724,43 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     int64_t nTime4 = GetTimeMicros(); nTimeVerify += nTime4 - nTime2;
     LogPrint(BCLog::BENCH, "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1, MILLI * (nTime4 - nTime2), nInputs <= 1 ? 0 : MILLI * (nTime4 - nTime2) / (nInputs-1), nTimeVerify * MICRO, nTimeVerify * MILLI / nBlocksTotal);
 
+    // Reject block without token split coinbase TX outputs.
+    const auto attributes = accountsView.GetAttributes();
+    assert(attributes);
+
+    CDataStructureV0 splitKey{AttributeTypes::Oracles, OracleIDs::Splits, static_cast<uint32_t>(pindex->nHeight)};
+    const auto splits = attributes->GetValue(splitKey, OracleSplits{});
+
+    CreationTxs creationTxs;
+    for (const auto& [id, multiplier] : splits) {
+        uint256 tokenCreationTx{};
+        std::vector<uint256> poolCreationTx;
+        if (!GetCreationTransactions(block, id, multiplier, tokenCreationTx, poolCreationTx)) {
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, error("%s: coinbase missing split token creation TX", __func__),
+                                 REJECT_INVALID, "bad-cb-token-split");
+        }
+
+        std::vector<DCT_ID> poolsToMigrate;
+        accountsView.ForEachPoolPair([&, id = id](DCT_ID const & poolId, const CPoolPair& pool){
+            if (pool.idTokenA.v == id || pool.idTokenB.v == id) {
+                poolsToMigrate.push_back(poolId);
+            }
+            return true;
+        });
+
+        if (poolsToMigrate.size() != poolCreationTx.size()) {
+            return state.Invalid(ValidationInvalidReason::CONSENSUS, error("%s: coinbase missing split pool creation TX", __func__),
+                                 REJECT_INVALID, "bad-cb-pool-split");
+        }
+
+        std::vector<std::pair<DCT_ID, uint256>> poolPairs;
+        poolPairs.reserve(poolsToMigrate.size());
+        std::transform(poolsToMigrate.begin(), poolsToMigrate.end(), poolCreationTx.begin(), std::back_inserter(poolPairs),
+                       [](DCT_ID a, uint256 b) { return std::make_pair(a, b); });
+
+        creationTxs.emplace(id, std::make_pair(tokenCreationTx, poolPairs));
+    }
+
     if (fJustCheck)
         return accountsView.Flush(); // keeps compatibility
 
@@ -2846,6 +2941,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                     // Add to existing ATTRIBUTES instead of overwriting.
                     if (var->GetName() == "ATTRIBUTES") {
                         auto govVar = mnview.GetAttributes();
+                        govVar->time = pindex->GetBlockTime();
                         if (govVar->Import(var->Export()) && govVar->Validate(govCache) && govVar->Apply(govCache, pindex->nHeight) && govCache.SetVariable(*govVar)) {
                             govCache.Flush();
                         }
@@ -2857,6 +2953,12 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
             cache.EraseStoredVariables(static_cast<uint32_t>(pindex->nHeight));
         }
 
+        // Migrate loan and collateral tokens to Gov vars.
+        ProcessTokenToGovVar(pindex, cache, chainparams);
+
+        // Loan splits
+        ProcessTokenSplits(block, pindex, cache, creationTxs, chainparams);
+
         // construct undo
         auto& flushable = cache.GetStorage();
         auto undo = CUndo::Construct(mnview.GetStorage(), flushable.GetRaw());
@@ -3447,11 +3549,11 @@ void CChainState::ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache
         cache.EraseFuturesUserValues(key);
     }
 
-    attributes->attributes[burnKey] = burned;
-    attributes->attributes[mintedKey] = minted;
+    attributes->SetValue(burnKey, std::move(burned));
+    attributes->SetValue(mintedKey, std::move(minted));
 
     if (!unpaidContracts.empty()) {
-        attributes->attributes[liveKey] = balances;
+        attributes->SetValue(liveKey, std::move(balances));
     }
 
     cache.SetVariable(*attributes);
@@ -3504,6 +3606,625 @@ void CChainState::ProcessOracleEvents(const CBlockIndex* pindex, CCustomCSView&
     });
 }
 
+void CChainState::ProcessTokenToGovVar(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams) {
+
+    // Migrate at +1 height so that GetLastHeight() in Gov var
+    // Validate() has a height equal to the GW fork.
+    if (pindex->nHeight != chainparams.GetConsensus().GreatWorldHeight + 1) {
+        return;
+    }
+
+    std::map<DCT_ID, CLoanSetLoanToken> loanTokens;
+    std::vector<CLoanSetCollateralTokenImplementation> collateralTokens;
+
+    cache.ForEachLoanToken([&](const DCT_ID& key, const CLoanSetLoanToken& loanToken) {
+        loanTokens[key] = loanToken;
+        return true;
+    });
+
+    cache.ForEachLoanCollateralToken([&](const CollateralTokenKey& key, const uint256& collTokenTx) {
+        auto collToken = cache.GetLoanCollateralToken(collTokenTx);
+        if (collToken) {
+            collateralTokens.push_back(*collToken);
+        }
+        return true;
+    });
+
+    // Apply fixed_interval_price_id first
+    std::map<std::string, std::string> attrsFirst;
+    std::map<std::string, std::string> attrsSecond;
+
+    int loanCount = 0, collateralCount = 0;
+
+    try {
+        for (const auto& [id, token] : loanTokens) {
+            std::string prefix = KeyBuilder(ATTRIBUTES::displayVersions().at(VersionTypes::v0), ATTRIBUTES::displayTypes().at(AttributeTypes::Token),id.v);
+            attrsFirst[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::FixedIntervalPriceId))] = token.fixedIntervalPriceId.first + '/' + token.fixedIntervalPriceId.second;
+            attrsSecond[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::LoanMintingEnabled))] = token.mintable ? "true" : "false";
+            attrsSecond[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::LoanMintingInterest))] = KeyBuilder(ValueFromAmount(token.interest).get_real());
+            ++loanCount;
+        }
+
+        for (const auto& token : collateralTokens) {
+            std::string prefix = KeyBuilder(ATTRIBUTES::displayVersions().at(VersionTypes::v0), ATTRIBUTES::displayTypes().at(AttributeTypes::Token), token.idToken.v);
+            attrsFirst[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::FixedIntervalPriceId))] = token.fixedIntervalPriceId.first + '/' + token.fixedIntervalPriceId.second;
+            attrsSecond[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::LoanCollateralEnabled))] = "true";
+            attrsSecond[KeyBuilder(prefix, ATTRIBUTES::displayKeys().at(AttributeTypes::Token).at(TokenKeys::LoanCollateralFactor))] = KeyBuilder(ValueFromAmount(token.factor).get_real());
+            ++collateralCount;
+        }
+
+        CCustomCSView govCache(cache);
+        if (ApplyGovVars(govCache, *pindex, attrsFirst) && ApplyGovVars(govCache, *pindex, attrsSecond)) {
+            govCache.Flush();
+
+            // Erase old tokens afterwards to avoid invalid state during transition
+            for (const auto& item : loanTokens) {
+                cache.EraseLoanToken(item.first);
+            }
+
+            for (const auto& token : collateralTokens) {
+                cache.EraseLoanCollateralToken(token);
+            }
+        }
+    } catch(std::out_of_range&) {
+        LogPrintf("Non-existant map entry referenced in loan/collateral token to Gov var migration\n");
+    }
+}
+
+static Res GetTokenSuffix(const CCustomCSView& view, const ATTRIBUTES& attributes, const uint32_t id, std::string& newSuffix) {
+    CDataStructureV0 ascendantKey{AttributeTypes::Token, id, TokenKeys::Ascendant};
+    if (attributes.CheckKey(ascendantKey)) {
+        const auto& [previousID, str] = attributes.GetValue(ascendantKey, AscendantValue{std::numeric_limits<uint32_t>::max(), ""});
+        auto previousToken = view.GetToken(DCT_ID{previousID});
+        if (!previousToken) {
+            return Res::Err("Previous token %d not found\n", id);
+        }
+        const auto found = previousToken->symbol.find(newSuffix);
+        if (found == std::string::npos) {
+            return Res::Err("Previous token name not valid: %s\n", previousToken->symbol);
+        }
+
+        const auto versionNumber  = previousToken->symbol.substr(found + newSuffix.size());
+        uint32_t previousVersion{};
+        try {
+            previousVersion = std::stoi(versionNumber);
+        } catch (...) {
+            return Res::Err("Previous token name not valid.");
+        }
+
+        newSuffix += std::to_string(++previousVersion);
+    } else {
+        newSuffix += '1';
+    }
+
+    return Res::Ok();
+}
+
+template<typename GovVar>
+static Res UpdateLiquiditySplits(CCustomCSView& view, const DCT_ID oldPoolId, const DCT_ID newPoolId, const uint32_t height) {
+    if (auto var = view.GetVariable(GovVar::TypeName())) {
+        if (auto lpVar = std::dynamic_pointer_cast<GovVar>(var)) {
+            if (lpVar->splits.count(oldPoolId) > 0) {
+                const auto value = lpVar->splits[oldPoolId];
+                lpVar->splits.erase(oldPoolId);
+                lpVar->splits[newPoolId] = value;
+                lpVar->Apply(view, height);
+                view.SetVariable(*lpVar);
+            }
+        }
+    } else {
+        return Res::Err("Failed to get %s", LP_SPLITS::TypeName());
+    }
+
+    return Res::Ok();
+}
+
+template<typename T>
+static inline T CalculateNewAmount(const int multiplier, const T amount) {
+    return multiplier < 0 ? amount / std::abs(multiplier) : amount * multiplier;
+}
+
+static Res PoolSplits(CCustomCSView& view, CAmount& totalBalance, ATTRIBUTES& attributes, const DCT_ID oldTokenId, const DCT_ID newTokenId,
+                      const CBlockIndex* pindex, const CreationTxs& creationTxs, const std::string& newTokenSuffix, const int32_t multiplier) {
+
+    try {
+        assert(creationTxs.count(oldTokenId.v));
+        for (const auto& [oldPoolId, creationTx] : creationTxs.at(oldTokenId.v).second) {
+            auto oldPoolToken = view.GetToken(oldPoolId);
+            if (!oldPoolToken) {
+                throw std::runtime_error(strprintf("Failed to get related pool token: %d", oldPoolId.v));
+            }
+
+            CTokenImplementation newPoolToken{*oldPoolToken};
+            newPoolToken.creationHeight = pindex->nHeight;
+            newPoolToken.creationTx = creationTx;
+            newPoolToken.minted = 0;
+
+            oldPoolToken->symbol += newTokenSuffix;
+            oldPoolToken->flags |= static_cast<uint8_t>(CToken::TokenFlags::Tradeable);
+            oldPoolToken->destructionHeight = pindex->nHeight;
+            oldPoolToken->destructionTx = pindex->GetBlockHash();
+
+            auto res = view.UpdateToken(*oldPoolToken, true, true);
+            if (!res) {
+                throw std::runtime_error(res.msg);
+            }
+
+            auto resVal = view.CreateToken(newPoolToken);
+            if (!resVal) {
+                throw std::runtime_error(resVal.msg);
+            }
+
+            const DCT_ID newPoolId{resVal.val->v};
+
+            auto oldPoolPair = view.GetPoolPair(oldPoolId);
+            if (!oldPoolPair) {
+                throw std::runtime_error(strprintf("Failed to get related pool: %d", oldPoolId.v));
+            }
+
+            CPoolPair newPoolPair{*oldPoolPair};
+            if (oldPoolPair->idTokenA == oldTokenId) {
+                newPoolPair.idTokenA = newTokenId;
+            } else {
+                newPoolPair.idTokenB = newTokenId;
+            }
+            newPoolPair.creationTx = newPoolToken.creationTx;
+            newPoolPair.creationHeight = pindex->nHeight;
+            newPoolPair.reserveA = 0;
+            newPoolPair.reserveB = 0;
+            newPoolPair.totalLiquidity = 0;
+
+            res = view.SetPoolPair(newPoolId, pindex->nHeight, newPoolPair);
+            if (!res) {
+                throw std::runtime_error(strprintf("SetPoolPair on new pool pair: %s", res.msg));
+            }
+
+            std::vector<std::pair<CScript, CAmount>> balancesToMigrate;
+            view.ForEachBalance([&, oldPoolId = oldPoolId](CScript const & owner, CTokenAmount balance) {
+                if (oldPoolId.v == balance.nTokenId.v && balance.nValue > 0) {
+                    balancesToMigrate.emplace_back(owner, balance.nValue);
+                }
+                return true;
+            });
+
+            // Largest first to make sure we are over MINIMUM_LIQUIDITY on first call to AddLiquidity
+            std::sort(balancesToMigrate.begin(), balancesToMigrate.end(), [](const std::pair<CScript, CAmount>&a, const std::pair<CScript, CAmount>& b){
+                return a.second > b.second;
+            });
+
+            for (auto& [owner, amount] : balancesToMigrate) {
+
+                if (oldPoolPair->totalLiquidity < CPoolPair::MINIMUM_LIQUIDITY) {
+                    throw std::runtime_error("totalLiquidity less than minimum.");
+                }
+
+                view.CalculateOwnerRewards(owner, pindex->nHeight);
+
+                res = view.SubBalance(owner, CTokenAmount{oldPoolId, amount});
+                if (!res.ok) {
+                    throw std::runtime_error(strprintf("SubBalance failed: %s", res.msg));
+                }
+
+                if (oldPoolPair->totalLiquidity - amount == CPoolPair::MINIMUM_LIQUIDITY) {
+                    amount += CPoolPair::MINIMUM_LIQUIDITY;
+                }
+
+                CAmount resAmountA = (arith_uint256(amount) * oldPoolPair->reserveA / oldPoolPair->totalLiquidity).GetLow64();
+                CAmount resAmountB = (arith_uint256(amount) * oldPoolPair->reserveB / oldPoolPair->totalLiquidity).GetLow64();
+                oldPoolPair->reserveA -= resAmountA;
+                oldPoolPair->reserveB -= resAmountB;
+                oldPoolPair->totalLiquidity -= amount;
+
+                CAmount amountA{0}, amountB{0};
+                if (oldPoolPair->idTokenA == oldTokenId) {
+                    amountA = CalculateNewAmount(multiplier, resAmountA);
+                    totalBalance += amountA;
+                    amountB = resAmountB;
+                } else {
+                    amountA = resAmountA;
+                    amountB = CalculateNewAmount(multiplier, resAmountB);
+                    totalBalance += amountB;
+                }
+
+                auto refundBalances = [&, owner = owner]() {
+                    view.AddBalance(owner, {newPoolPair.idTokenA, amountA});
+                    view.AddBalance(owner, {newPoolPair.idTokenB, amountB});
+                };
+
+                if (amountA <= 0 || amountB <= 0) {
+                    refundBalances();
+                    continue;
+                }
+
+                CAmount liquidity{0};
+                if (newPoolPair.totalLiquidity == 0) {
+                    liquidity = (arith_uint256(amountA) * amountB).sqrt().GetLow64();
+                    liquidity -= CPoolPair::MINIMUM_LIQUIDITY;
+                    newPoolPair.totalLiquidity = CPoolPair::MINIMUM_LIQUIDITY;
+                } else {
+                    CAmount liqA = (arith_uint256(amountA) * newPoolPair.totalLiquidity / newPoolPair.reserveA).GetLow64();
+                    CAmount liqB = (arith_uint256(amountB) * newPoolPair.totalLiquidity / newPoolPair.reserveB).GetLow64();
+                    liquidity = std::min(liqA, liqB);
+
+                    if (liquidity == 0) {
+                        refundBalances();
+                        continue;
+                    }
+                }
+
+                auto resTotal = SafeAdd(newPoolPair.totalLiquidity, liquidity);
+                if (!resTotal) {
+                    refundBalances();
+                    continue;
+                }
+                newPoolPair.totalLiquidity = resTotal;
+
+                auto resA = SafeAdd(newPoolPair.reserveA, amountA);
+                auto resB = SafeAdd(newPoolPair.reserveB, amountB);
+                if (resA && resB) {
+                    newPoolPair.reserveA = resA;
+                    newPoolPair.reserveB = resB;
+                } else {
+                    refundBalances();
+                    continue;
+                }
+
+                res = view.AddBalance(owner, {newPoolId, liquidity});
+                if (!res) {
+                    refundBalances();
+                    continue;
+                }
+
+                view.SetShare(newPoolId, owner, pindex->nHeight);
+            }
+
+            DCT_ID maxToken{std::numeric_limits<uint32_t>::max()};
+            if (oldPoolPair->idTokenA == oldTokenId) {
+                view.EraseDexFeePct(oldPoolPair->idTokenA, maxToken);
+                view.EraseDexFeePct(maxToken, oldPoolPair->idTokenA);
+            } else {
+                view.EraseDexFeePct(oldPoolPair->idTokenB, maxToken);
+                view.EraseDexFeePct(maxToken, oldPoolPair->idTokenB);
+            }
+
+            view.EraseDexFeePct(oldPoolId, oldPoolPair->idTokenA);
+            view.EraseDexFeePct(oldPoolId, oldPoolPair->idTokenB);
+
+            if (oldPoolPair->totalLiquidity != 0) {
+                throw std::runtime_error(strprintf("totalLiquidity should be zero. Remainder: %d", oldPoolPair->totalLiquidity));
+            }
+
+            res = view.SetPoolPair(newPoolId, pindex->nHeight, newPoolPair);
+            if (!res) {
+                throw std::runtime_error(strprintf("SetPoolPair on new pool pair: %s", res.msg));
+            }
+
+            res = view.SetPoolPair(oldPoolId, pindex->nHeight, *oldPoolPair);
+            if (!res) {
+                throw std::runtime_error(strprintf("SetPoolPair on old pool pair: %s", res.msg));
+            }
+
+            res = view.UpdatePoolPair(oldPoolId, pindex->nHeight, false, -1, CScript{}, CBalances{});
+            if (!res) {
+                throw std::runtime_error(strprintf("UpdatePoolPair on old pool pair: %s", res.msg));
+            }
+
+            std::vector<CDataStructureV0> eraseKeys;
+            for (const auto& [key, value] : attributes.GetAttributesMap()) {
+                if (const auto v0Key = boost::get<CDataStructureV0>(&key); v0Key->type == AttributeTypes::Poolpairs && v0Key->typeId == oldPoolId.v) {
+                    CDataStructureV0 newKey{AttributeTypes::Poolpairs, newPoolId.v, v0Key->key, v0Key->keyId};
+                    attributes.SetValue(newKey, value);
+                    eraseKeys.push_back(*v0Key);
+                }
+            }
+
+            for (const auto& key : eraseKeys) {
+                attributes.EraseKey(key);
+            }
+
+            res = UpdateLiquiditySplits<LP_SPLITS>(view, oldPoolId, newPoolId, pindex->nHeight);
+            if (!res) {
+                throw std::runtime_error(res.msg);
+            }
+
+            res = UpdateLiquiditySplits<LP_LOAN_TOKEN_SPLITS>(view, oldPoolId, newPoolId, pindex->nHeight);
+            if (!res) {
+                throw std::runtime_error(res.msg);
+            }
+
+
+        }
+    } catch (const std::runtime_error& e) {
+        return Res::Err(e.what());
+    }
+
+    return Res::Ok();
+}
+
+static Res VaultSplits(CCustomCSView& view, ATTRIBUTES& attributes, const DCT_ID oldTokenId, const DCT_ID newTokenId, const int height, const int multiplier) {
+
+    std::vector<std::pair<CVaultId, CAmount>> loanTokenAmounts;
+    view.ForEachLoanTokenAmount([&](const CVaultId& vaultId,  const CBalances& balances){
+        for (const auto& [tokenId, amount] : balances.balances) {
+            if (tokenId == oldTokenId) {
+                loanTokenAmounts.emplace_back(vaultId, amount);
+            }
+        }
+        return true;
+    });
+
+    for (auto& [vaultId, amount] : loanTokenAmounts) {
+        const auto res = view.SubLoanToken(vaultId, {oldTokenId, amount});
+        if (!res) {
+            return res;
+        }
+    }
+
+    CVaultId failedVault;
+    std::vector<std::tuple<CVaultId, CInterestRateV2, std::string>> loanInterestRates;
+    view.ForEachVaultInterestV2([&](const CVaultId& vaultId, DCT_ID tokenId, const CInterestRateV2& rate) {
+        if (tokenId == oldTokenId) {
+            const auto vaultData = view.GetVault(vaultId);
+            if (!vaultData) {
+                failedVault = vaultId;
+                return false;
+            }
+            loanInterestRates.emplace_back(vaultId, rate, vaultData->schemeId);
+        }
+        return true;
+    });
+
+    if (failedVault != CVaultId{}) {
+        return Res::Err("Failed to get vault data for: %s", failedVault.ToString());
+    }
+
+    attributes.EraseKey(CDataStructureV0{AttributeTypes::Locks, ParamIDs::TokenID, oldTokenId.v});
+    attributes.SetValue(CDataStructureV0{AttributeTypes::Locks, ParamIDs::TokenID, newTokenId.v}, true);
+
+    auto res = attributes.Apply(view, height);
+    if (!res) {
+        return res;
+    }
+    view.SetVariable(attributes);
+
+    for (auto& [vaultId, amount] : loanTokenAmounts) {
+        amount = CalculateNewAmount(multiplier, amount);
+        res = view.AddLoanToken(vaultId, {newTokenId, amount});
+        if (!res) {
+            return res;
+        }
+    }
+
+    const auto loanToken = view.GetLoanTokenByID(newTokenId);
+    if (!loanToken) {
+        return Res::Err("Failed to get loan token.");
+    }
+
+    // Pre-populate to save repeated calls to get loan scheme
+    std::map<std::string, CAmount> loanSchemes;
+    view.ForEachLoanScheme([&](const std::string& key, const CLoanSchemeData& data) {
+        loanSchemes.emplace(key, data.rate);
+        return true;
+    });
+
+    for (auto& [vaultId, rate, schemeId] : loanInterestRates) {
+        CAmount loanSchemeRate{0};
+        try {
+            loanSchemeRate = loanSchemes.at(schemeId);
+        } catch (const std::out_of_range&) {
+            return Res::Err("Failed to get loan scheme.");
+        }
+
+        view.EraseInterestDirect(vaultId, oldTokenId);
+        rate.interestToHeight = CalculateNewAmount(multiplier, rate.interestToHeight);
+
+        auto amounts = view.GetLoanTokens(vaultId);
+        if (amounts) {
+            rate.interestPerBlock = InterestPerBlockCalculationV2(amounts->balances[newTokenId], loanToken->interest, loanSchemeRate);
+        }
+
+        rate.height = height;
+
+        view.WriteInterestRate(std::make_pair(vaultId, newTokenId), rate, height);
+    }
+
+    return Res::Ok();
+}
+
+void CChainState::ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, CCustomCSView& cache, const CreationTxs& creationTxs, const CChainParams& chainparams) {
+    if (pindex->nHeight < chainparams.GetConsensus().GreatWorldHeight) {
+        return;
+    }
+    const auto attributes = cache.GetAttributes();
+    if (!attributes) {
+        return;
+    }
+
+    CDataStructureV0 splitKey{AttributeTypes::Oracles, OracleIDs::Splits, static_cast<uint32_t>(pindex->nHeight)};
+    const auto splits = attributes->GetValue(splitKey, OracleSplits{});
+
+    if (!splits.empty()) {
+        attributes->EraseKey(splitKey);
+        cache.SetVariable(*attributes);
+    }
+
+    for (const auto& [id, multiplier] : splits) {
+
+        if (!cache.AreTokensLocked({id})) {
+            LogPrintf("%s: Token split failed. Token %d not locked\n", __func__, id);
+            continue;
+        }
+
+        auto view{cache};
+
+        const DCT_ID oldTokenId{id};
+
+        auto token = view.GetToken(oldTokenId);
+        if (!token) {
+            LogPrintf("%s: Token split failed. Token %d not found\n", __func__, oldTokenId.v);
+            continue;
+        }
+
+        std::string newTokenSuffix = "/v";
+        auto res = GetTokenSuffix(cache, *attributes, oldTokenId.v, newTokenSuffix);
+        if (!res) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        CTokenImplementation newToken{*token};
+        newToken.creationHeight = pindex->nHeight;
+        assert(creationTxs.count(id));
+        newToken.creationTx = creationTxs.at(id).first;
+        newToken.minted = 0;
+
+        token->symbol += newTokenSuffix;
+        token->destructionHeight = pindex->nHeight;
+        token->destructionTx = pindex->GetBlockHash();
+        token->flags &= ~static_cast<uint8_t>(CToken::TokenFlags::Default);
+        token->flags |= static_cast<uint8_t>(CToken::TokenFlags::Finalized);
+
+        res = view.SubMintedTokens(oldTokenId, token->minted);
+        if (!res) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        res = view.UpdateToken(*token, false, true);
+        if (!res) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        auto resVal = view.CreateToken(newToken);
+        if (!resVal) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, resVal.msg);
+            continue;
+        }
+
+        const DCT_ID newTokenId{resVal.val->v};
+
+        std::vector<CDataStructureV0> eraseKeys;
+        for (const auto& [key, value] : attributes->GetAttributesMap()) {
+            if (const auto v0Key = boost::get<CDataStructureV0>(&key); v0Key->type == AttributeTypes::Token) {
+                if (v0Key->typeId == oldTokenId.v && v0Key->keyId == oldTokenId.v) {
+                    CDataStructureV0 newKey{AttributeTypes::Token, newTokenId.v, v0Key->key, newTokenId.v};
+                    attributes->SetValue(newKey, value);
+                    eraseKeys.push_back(*v0Key);
+                } else if (v0Key->typeId == oldTokenId.v) {
+                    CDataStructureV0 newKey{AttributeTypes::Token, newTokenId.v, v0Key->key, v0Key->keyId};
+                    attributes->SetValue(newKey, value);
+                    eraseKeys.push_back(*v0Key);
+                } else if (v0Key->keyId == oldTokenId.v) {
+                    CDataStructureV0 newKey{AttributeTypes::Token, v0Key->typeId, v0Key->key, newTokenId.v};
+                    attributes->SetValue(newKey, value);
+                    eraseKeys.push_back(*v0Key);
+                }
+            }
+        }
+
+        for (const auto& key : eraseKeys) {
+            attributes->EraseKey(key);
+        }
+
+        CDataStructureV0 newAscendantKey{AttributeTypes::Token, newTokenId.v, TokenKeys::Ascendant};
+        attributes->SetValue(newAscendantKey, AscendantValue{oldTokenId.v, "split"});
+
+        CDataStructureV0 descendantKey{AttributeTypes::Token, oldTokenId.v, TokenKeys::Descendant};
+        attributes->SetValue(descendantKey, DescendantValue{newTokenId.v, static_cast<int32_t>(pindex->nHeight)});
+
+        CAmount totalBalance{0};
+
+        res = PoolSplits(view, totalBalance, *attributes, oldTokenId, newTokenId, pindex, creationTxs,newTokenSuffix, multiplier);
+        if (!res) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        CAccounts addAccounts;
+        CAccounts subAccounts;
+
+        view.ForEachBalance([&, multiplier = multiplier](CScript const & owner, const CTokenAmount& balance) {
+            if (oldTokenId.v == balance.nTokenId.v) {
+                const auto newBalance = CalculateNewAmount(multiplier, balance.nValue);
+                addAccounts[owner].Add({newTokenId, newBalance});
+                subAccounts[owner].Add(balance);
+                totalBalance += newBalance;
+            }
+            return true;
+        });
+
+        res = view.AddMintedTokens(newTokenId, totalBalance);
+        if (!res) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        try {
+            for (const auto& [owner, balances] : addAccounts) {
+                res = view.AddBalances(owner, balances);
+                if (!res) {
+                    throw std::runtime_error(res.msg);
+                }
+            }
+
+            for (const auto& [owner, balances] : subAccounts) {
+                res = view.SubBalances(owner, balances);
+                if (!res) {
+                    throw std::runtime_error(res.msg);
+                }
+            }
+
+        } catch (const std::runtime_error& e) {
+            LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+            continue;
+        }
+
+        if (view.GetLoanTokenByID(oldTokenId)) {
+            res = VaultSplits(view, *attributes, oldTokenId, newTokenId, pindex->nHeight, multiplier);
+            if (!res) {
+                LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+                continue;
+            }
+        } else {
+            auto res = attributes->Apply(view, pindex->nHeight);
+            if (!res) {
+                LogPrintf("%s: Token split failed. %s\n", __func__, res.msg);
+                continue;
+            }
+        }
+
+        std::vector<std::pair<CDataStructureV0, OracleSplits>> updateAttributesKeys;
+        for (const auto& [key, value] : attributes->GetAttributesMap()) {
+            if (const auto v0Key = boost::get<const CDataStructureV0>(&key);
+                v0Key->type == AttributeTypes::Oracles && v0Key->typeId == OracleIDs::Splits) {
+                if (const auto splitMap = boost::get<OracleSplits>(&value)) {
+                    for (auto [splitMapKey, splitMapValue] : *splitMap) {
+                        if (splitMapKey == oldTokenId.v) {
+                            auto copyMap{*splitMap};
+                            copyMap.erase(splitMapKey);
+                            updateAttributesKeys.emplace_back(*v0Key, copyMap);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        for (const auto& [key, value] : updateAttributesKeys) {
+            if (value.empty()) {
+                attributes->EraseKey(key);
+            } else {
+                attributes->SetValue(key, value);
+            }
+        }
+
+        view.SetVariable(*attributes);
+
+        view.Flush();
+    }
+}
+
 bool CChainState::FlushStateToDisk(
     const CChainParams& chainparams,
     CValidationState &state,
@@ -4779,7 +5500,8 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P
         for (unsigned int i = 1; i < block.vtx.size(); i++) {
             if (block.vtx[i]->IsCoinBase() &&
                 !IsAnchorRewardTx(*block.vtx[i], dummy, height >= consensusParams.FortCanningHeight) &&
-                !IsAnchorRewardTxPlus(*block.vtx[i], dummy, height >= consensusParams.FortCanningHeight))
+                !IsAnchorRewardTxPlus(*block.vtx[i], dummy, height >= consensusParams.FortCanningHeight) &&
+                !IsTokenSplitTx(*block.vtx[i], dummy, height >= consensusParams.GreatWorldHeight))
                 return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-multiple", "more than one coinbase");
         }
     }
diff --git a/src/validation.h b/src/validation.h
index 7d19b34f128..68cc102a9e2 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -55,6 +55,8 @@ struct DisconnectedBlockTransactions;
 struct PrecomputedTransactionData;
 struct LockPoints;
 
+using CreationTxs = std::map<uint32_t, std::pair<uint256, std::vector<std::pair<DCT_ID, uint256>>>>;
+
 /** Default for -minrelaytxfee, minimum relay fee for transactions */
 static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 1000;
 /** Default for -limitancestorcount, max number of in-mempool ancestors */
@@ -759,6 +761,10 @@ class CChainState {
     static void ProcessOracleEvents(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams);
 
     static void ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams);
+
+    static void ProcessTokenToGovVar(const CBlockIndex *pindex, CCustomCSView &cache, const CChainParams &chainparams);
+
+    static void ProcessTokenSplits(const CBlock& block, const CBlockIndex* pindex, CCustomCSView& cache, const CreationTxs& creationTxs, const CChainParams& chainparams);
 };
 
 /** Mark a block as precious and reorganize.
diff --git a/test/functional/feature_loan_payback_dfi.py b/test/functional/feature_loan_payback_dfi.py
index 25570a24817..0bcfa689f69 100755
--- a/test/functional/feature_loan_payback_dfi.py
+++ b/test/functional/feature_loan_payback_dfi.py
@@ -145,7 +145,7 @@ def run_test(self):
             'amounts': "1@DFI"
         })
 
-        assert_raises_rpc_error(-5, 'Unrecognised type argument provided, valid types are: params, poolpairs, token,',
+        assert_raises_rpc_error(-5, 'Unrecognised type argument provided, valid types are: locks, oracles, params, poolpairs, token,',
                                 self.nodes[0].setgov, {"ATTRIBUTES":{'v0/live/economy/dfi_payback_tokens':'1'}})
 
         # Disable loan payback
diff --git a/test/functional/feature_loan_payback_dfi_v2.py b/test/functional/feature_loan_payback_dfi_v2.py
index 2ec37133bd8..0ae23da1332 100755
--- a/test/functional/feature_loan_payback_dfi_v2.py
+++ b/test/functional/feature_loan_payback_dfi_v2.py
@@ -298,7 +298,7 @@ def payback_with_DFI_prior_to_atribute_activation(self):
         assert("Payback of loan via DFI token is not currently active" in errorString)
 
     def setgov_attribute_to_false_and_payback(self):
-        assert_raises_rpc_error(-5, 'Unrecognised type argument provided, valid types are: params, poolpairs, token,',
+        assert_raises_rpc_error(-5, 'Unrecognised type argument provided, valid types are: locks, oracles, params, poolpairs, token,',
                                 self.nodes[0].setgov, {"ATTRIBUTES":{'v0/live/economy/dfi_payback_tokens':'1'}})
 
         # Disable loan payback
diff --git a/test/functional/feature_loan_setcollateraltoken.py b/test/functional/feature_loan_setcollateraltoken.py
index 9eea2b5c965..e24656ab03d 100755
--- a/test/functional/feature_loan_setcollateraltoken.py
+++ b/test/functional/feature_loan_setcollateraltoken.py
@@ -123,7 +123,7 @@ def run_test(self):
 
         self.nodes[0].generate(1)
 
-        collTokens = self.nodes[0].listcollateraltokens({'all': True})
+        collTokens = self.nodes[0].listcollateraltokens()
         assert_equal(len(collTokens), 2)
 
         collToken1 = [token for token in collTokens if token["tokenId"] == collTokenTx1][0]
@@ -138,7 +138,7 @@ def run_test(self):
 
         self.nodes[0].generate(1)
 
-        collTokens = self.nodes[0].listcollateraltokens({'all': True})
+        collTokens = self.nodes[0].listcollateraltokens()
         assert_equal(len(collTokens), 3)
 
         collToken2 = [token for token in collTokens if token["tokenId"] == collTokenTx2][0]
@@ -148,7 +148,7 @@ def run_test(self):
 
         self.nodes[0].generate(1)
 
-        collTokens = self.nodes[0].listcollateraltokens({'all': True})
+        collTokens = self.nodes[0].listcollateraltokens()
         assert_equal(len(collTokens), 3)
 
         collToken3 = [token for token in collTokens if token["tokenId"] == collTokenTx3][0]
@@ -189,8 +189,6 @@ def run_test(self):
         self.nodes[0].generate(1)
 
         collTokens = self.nodes[0].listcollateraltokens()
-        assert_equal(len(collTokens), 2)
-        collTokens = self.nodes[0].listcollateraltokens({'all': True})
         assert_equal(len(collTokens), 4)
 
 if __name__ == '__main__':
diff --git a/test/functional/feature_loan_vault.py b/test/functional/feature_loan_vault.py
index 357506625e9..67b49f36336 100755
--- a/test/functional/feature_loan_vault.py
+++ b/test/functional/feature_loan_vault.py
@@ -18,13 +18,67 @@ def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         self.extra_args = [
-                ['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-bayfrontgardensheight=1', '-eunosheight=1', '-txindex=1', '-fortcanningheight=1', '-fortcanninghillheight=300', '-jellyfish_regtest=1', '-simulatemainnet'],
-                ['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-bayfrontgardensheight=1', '-eunosheight=1', '-txindex=1', '-fortcanningheight=1', '-fortcanninghillheight=300', '-jellyfish_regtest=1', '-simulatemainnet']
+                ['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-bayfrontgardensheight=1', '-eunosheight=1', '-txindex=1', '-fortcanningheight=1', '-fortcanninghillheight=300', '-greatworldheight=1700', '-jellyfish_regtest=1', '-simulatemainnet'],
+                ['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-bayfrontgardensheight=1', '-eunosheight=1', '-txindex=1', '-fortcanningheight=1', '-fortcanninghillheight=300', '-greatworldheight=1700', '-jellyfish_regtest=1', '-simulatemainnet']
             ]
         self.vaults = []
         self.owner_addresses = []
         self.oracles = []
 
+    def move_to_gw_fork(self):
+        result = self.nodes[0].listcollateraltokens()
+        assert_equal(result[0]['token'], 'DFI')
+        assert_equal(result[0]['factor'], Decimal('1.00000000'))
+        assert_equal(result[0]['fixedIntervalPriceId'], 'DFI/USD')
+        assert_equal(result[1]['token'], 'BTC')
+        assert_equal(result[1]['factor'], Decimal('0.80000000'))
+        assert_equal(result[1]['fixedIntervalPriceId'], 'BTC/USD')
+
+        result = self.nodes[0].listloantokens()
+        assert_equal(result[0]['token']['6']['symbol'], 'TSLA')
+        assert_equal(result[0]['token']['6']['isLoanToken'], True)
+        assert_equal(result[0]['fixedIntervalPriceId'], 'TSLA/USD')
+        assert_equal(result[0]['interest'], Decimal('2.00000000'))
+        assert_equal(result[1]['token']['7']['symbol'], 'DUSD')
+        assert_equal(result[1]['token']['7']['isLoanToken'], True)
+        assert_equal(result[1]['fixedIntervalPriceId'], 'DUSD/USD')
+        assert_equal(result[1]['interest'], Decimal('1.00000000'))
+
+        # Move to hard fork
+        self.nodes[0].generate(1701 - self.nodes[0].getblockcount())
+
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result['v0/token/0/fixed_interval_price_id'], 'DFI/USD')
+        assert_equal(result['v0/token/0/loan_collateral_enabled'], 'true')
+        assert_equal(result['v0/token/0/loan_collateral_factor'], '1')
+        assert_equal(result['v0/token/1/fixed_interval_price_id'], 'BTC/USD')
+        assert_equal(result['v0/token/1/loan_collateral_enabled'], 'true')
+        assert_equal(result['v0/token/1/loan_collateral_factor'], '0.8')
+        assert_equal(result['v0/token/6/fixed_interval_price_id'], 'TSLA/USD')
+        assert_equal(result['v0/token/6/loan_minting_enabled'], 'true')
+        assert_equal(result['v0/token/6/loan_minting_interest'], '2')
+        assert_equal(result['v0/token/7/fixed_interval_price_id'], 'DUSD/USD')
+        assert_equal(result['v0/token/7/loan_minting_enabled'], 'true')
+        assert_equal(result['v0/token/7/loan_minting_interest'], '1')
+
+        result = self.nodes[0].listcollateraltokens()
+        assert_equal(result[0]['token'], 'DFI')
+        assert_equal(result[0]['factor'], Decimal('1.00000000'))
+        assert_equal(result[0]['fixedIntervalPriceId'], 'DFI/USD')
+        assert_equal(result[1]['token'], 'BTC')
+        assert_equal(result[1]['factor'], Decimal('0.80000000'))
+        assert_equal(result[1]['fixedIntervalPriceId'], 'BTC/USD')
+
+        result = self.nodes[0].listloantokens()
+        assert_equal(result[0]['token']['6']['symbol'], 'TSLA')
+        assert_equal(result[0]['token']['6']['isLoanToken'], True)
+        assert_equal(result[0]['fixedIntervalPriceId'], 'TSLA/USD')
+        assert_equal(result[0]['interest'], Decimal('2.00000000'))
+        assert_equal(result[1]['token']['7']['symbol'], 'DUSD')
+        assert_equal(result[1]['token']['7']['isLoanToken'], True)
+        assert_equal(result[1]['fixedIntervalPriceId'], 'DUSD/USD')
+        assert_equal(result[1]['interest'], Decimal('1.00000000'))
+
     def setup_loanschemes(self):
         self.nodes[0].createloanscheme(175, 3, 'LOAN0001')
         self.nodes[0].createloanscheme(150, 2.5, 'LOAN000A')
@@ -58,8 +112,15 @@ def setup_accounts_and_tokens(self):
         self.nodes[1].generate(102)
         self.sync_blocks()
 
+        self.symbolDFI = "DFI"
+        self.symbolBTC = "BTC"
+        self.symbolETH = "ETH"
+        self.symbolGOOGL = "GOOGL"
+        self.symbolUSDT = "USDT"
+        self.symbolAAPL = "AAPL"
+
         self.nodes[1].createtoken({
-            "symbol": "BTC",
+            "symbol": self.symbolBTC,
             "name": "BTC token",
             "isDAT": True,
             "collateralAddress": self.nodes[1].get_genesis_keys().ownerAuthAddress
@@ -67,8 +128,38 @@ def setup_accounts_and_tokens(self):
         self.nodes[1].generate(1)
         self.sync_blocks()
 
-        self.symbolDFI = "DFI"
-        self.symbolBTC = "BTC"
+        self.nodes[0].createtoken({
+            "symbol": self.symbolETH,
+            "name": "Ethereum",
+            "isDAT": True,
+            "collateralAddress": self.nodes[0].get_genesis_keys().ownerAuthAddress
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createtoken({
+            "symbol": self.symbolGOOGL,
+            "name": "Google",
+            "isDAT": True,
+            "collateralAddress": self.nodes[0].get_genesis_keys().ownerAuthAddress
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createtoken({
+            "symbol": self.symbolUSDT,
+            "name": "USDT Stable Coin",
+            "isDAT": True,
+            "collateralAddress": self.nodes[0].get_genesis_keys().ownerAuthAddress
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createtoken({
+            "symbol": self.symbolAAPL,
+            "name": "Apple",
+            "isDAT": True,
+            "collateralAddress": self.nodes[0].get_genesis_keys().ownerAuthAddress
+        })
+        self.nodes[0].generate(1)
+        self.sync_blocks()
 
         self.nodes[1].minttokens("10@" + self.symbolBTC)
         self.nodes[1].generate(1)
@@ -76,6 +167,10 @@ def setup_accounts_and_tokens(self):
 
         self.idDFI = list(self.nodes[0].gettoken(self.symbolDFI).keys())[0]
         self.idBTC = list(self.nodes[0].gettoken(self.symbolBTC).keys())[0]
+        self.idETH = list(self.nodes[0].gettoken(self.symbolETH).keys())[0]
+        self.idGOOGL = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+        self.idUSDT = list(self.nodes[0].gettoken(self.symbolUSDT).keys())[0]
+        self.idAAPL = list(self.nodes[0].gettoken(self.symbolAAPL).keys())[0]
         self.accountDFI = self.nodes[0].get_genesis_keys().ownerAuthAddress
         self.accountBTC = self.nodes[1].get_genesis_keys().ownerAuthAddress
 
@@ -113,7 +208,7 @@ def setup_accounts_and_tokens(self):
 
     def setup_oracles(self):
         oracle_address1 = self.nodes[0].getnewaddress("", "legacy")
-        price_feeds1 = [{"currency": "USD", "token": "DFI"}, {"currency": "USD", "token": "BTC"}, {"currency": "USD", "token": "TSLA"}]
+        price_feeds1 = [{"currency": "USD", "token": "DFI"}, {"currency": "USD", "token": "BTC"}, {"currency": "USD", "token": "TSLA"}, {"currency": "USD", "token": "GOOGL"}, {"currency": "USD", "token": "ETH"}]
         oracle_id1 = self.nodes[0].appointoracle(oracle_address1, price_feeds1, 10)
         self.oracles.append(oracle_id1)
         self.nodes[0].generate(1)
@@ -122,7 +217,7 @@ def setup_oracles(self):
         timestamp = calendar.timegm(time.gmtime())
         self.nodes[0].setoracledata(oracle_id1, timestamp, oracle1_prices)
 
-        self.nodes[0].generate(120)
+        self.nodes[0].generate(116)
 
     def create_poolpairs(self):
         poolOwner = self.nodes[0].getnewaddress("", "legacy")
@@ -211,7 +306,7 @@ def listvaults_and_filtering(self):
         assert_equal(len(list_vault), 1)
 
     def test_feeburn(self):
-        assert_equal(self.nodes[0].getburninfo()['feeburn'], Decimal('3'))
+        assert_equal(self.nodes[0].getburninfo()['feeburn'], Decimal('7'))
 
     def getvault_wrong_vault_address(self):
         try:
@@ -262,19 +357,10 @@ def actions_on_vault_with_scheme_to_be_destroyed(self):
         self.nodes[0].generate(1)
 
         # create
-        try:
-            self.nodes[0].createvault(self.owner_addresses[0], 'LOAN0002') # default loan scheme
-        except JSONRPCException as e:
-            error_str = e.error['message']
-        assert("Cannot set LOAN0002 as loan scheme, set to be destroyed on block 626" in error_str)
+        assert_raises_rpc_error(-32600, 'Cannot set LOAN0002 as loan scheme, set to be destroyed on block 626', self.nodes[0].createvault, self.owner_addresses[0], 'LOAN0002')
 
         # update
-        try:
-            params = {'loanSchemeId':'LOAN0002'}
-            self.nodes[0].updatevault(self.vaults[1], params) # default loan scheme
-        except JSONRPCException as e:
-            error_str = e.error['message']
-        assert("Cannot set LOAN0002 as loan scheme, set to be destroyed on block 626" in error_str)
+        assert_raises_rpc_error(-32600, 'Cannot set LOAN0002 as loan scheme, set to be destroyed on block 626', self.nodes[0].updatevault, self.vaults[1], {'loanSchemeId':'LOAN0002'})
 
     def update_vault_scheme(self):
         new_address = self.nodes[0].getnewaddress('', 'legacy')
@@ -522,7 +608,7 @@ def estimatevault_with_invalid_params(self):
             self.nodes[0].estimatevault('3.00000000@TSLA', '3.00000000@TSLA')
         except JSONRPCException as e:
             error_str = e.error['message']
-        assert("Token with id (2) is not a valid collateral!" in error_str)
+        assert("Token with id (6) is not a valid collateral!" in error_str)
         # Token not set as loan token
         try:
             self.nodes[0].estimatevault('3.00000000@DFI', '3.00000000@DFI')
@@ -633,7 +719,7 @@ def overflowed_collateral_value(self):
         })
         self.nodes[0].generate(1)
 
-        oracle1_prices = [{"currency": "USD", "tokenAmount": "9999999999@DFI"}, {"currency": "USD", "tokenAmount": "1@TSLA"}, {"currency": "USD", "tokenAmount": "1@BTC"}]
+        oracle1_prices = [{"currency": "USD", "tokenAmount": "9999999999@DFI"}, {"currency": "USD", "tokenAmount": "1@TSLA"}, {"currency": "USD", "tokenAmount": "1@BTC"}, {"currency": "USD", "tokenAmount": "1@ETH"}, {"currency": "USD", "tokenAmount": "2@GOOGL"}]
         timestamp = calendar.timegm(time.gmtime())
         self.nodes[0].setoracledata(self.oracles[0], timestamp, oracle1_prices)
         self.nodes[0].generate(240)
@@ -652,6 +738,242 @@ def overflowed_collateral_value(self):
         self.nodes[0].closevault(vault_id, address)
         self.nodes[0].generate(1)
 
+    def loan_and_collateral_token_to_govvar(self):
+        # Move to hard fork
+        self.move_to_gw_fork()
+
+        # Invalidate fork block
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        assert_equal(len(self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']), 0)
+
+        # Move to hard fork again
+        self.move_to_gw_fork()
+
+        # Try and call disabled RPC calls
+        assert_raises_rpc_error(-32600, 'called after GreatWorld height', self.nodes[0].setloantoken, {
+            'symbol': "DUSD",
+            'name': "DUSD stable token",
+            'fixedIntervalPriceId': "DUSD/USD",
+            'mintable': True,
+            'interest': 1})
+        assert_raises_rpc_error(-32600, 'called after GreatWorld height', self.nodes[0].updateloantoken, "DUSD", {
+            'symbol': "DUSD",
+            'name': "DUSD stable token",
+            'fixedIntervalPriceId': "DUSD/USD",
+            'mintable': True,
+            'interest': 1})
+        assert_raises_rpc_error(-32600, 'called after GreatWorld height', self.nodes[0].setcollateraltoken, {
+            'token': self.idDFI,
+            'factor': 1,
+            'fixedIntervalPriceId': "DFI/USD"})
+
+        # Test setting collateral token partially
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/fixed_interval_price_id':'ETH/USD', f'v0/token/{self.idETH}/loan_collateral_enabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Should not show up as collateral token
+        assert_equal(len(self.nodes[0].listcollateraltokens()), 2)
+
+        # Revert
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        self.nodes[0].clearmempool()
+
+        # Test setting collateral token partially
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/fixed_interval_price_id':'ETH/USD', f'v0/token/{self.idETH}/loan_collateral_factor':'0.5'}})
+        self.nodes[0].generate(1)
+
+        # Should not show up as collateral token
+        assert_equal(len(self.nodes[0].listcollateraltokens()), 2)
+
+        # Revert
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        self.nodes[0].clearmempool()
+
+        # Set collateral token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/fixed_interval_price_id':'ETH/USD', f'v0/token/{self.idETH}/loan_collateral_enabled':'true', f'v0/token/{self.idETH}/loan_collateral_factor':'0.5'}})
+        self.nodes[0].generate(1)
+
+        # Test setting it again, should not be a problem.
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/fixed_interval_price_id':'ETH/USD', f'v0/token/{self.idETH}/loan_collateral_enabled':'true', f'v0/token/{self.idETH}/loan_collateral_factor':'0.5'}})
+        self.nodes[0].generate(1)
+
+        # Should now show up as collateral token
+        result = self.nodes[0].listcollateraltokens()
+        assert_equal(len(result), 3)
+        assert_equal(result[2]['token'], 'ETH')
+        assert_equal(result[2]['factor'], Decimal('0.50000000'))
+        assert_equal(result[2]['fixedIntervalPriceId'], 'ETH/USD')
+
+        # Should not show up as loan token yet
+        assert_equal(self.nodes[0].gettoken(self.idGOOGL)[self.idGOOGL]['isLoanToken'], False)
+
+        # Test setting loan token partially.
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idGOOGL}/loan_minting_enabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Should not show up as loan token
+        assert_equal(self.nodes[0].gettoken(self.idGOOGL)[self.idGOOGL]['isLoanToken'], False)
+        assert_equal(len(self.nodes[0].listloantokens()), 2)
+
+        # Revert
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        self.nodes[0].clearmempool()
+
+        # Test setting loan token partially.
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idGOOGL}/loan_minting_interest':'1'}})
+        self.nodes[0].generate(1)
+
+        # Should not show up as loan token
+        assert_equal(self.nodes[0].gettoken(self.idGOOGL)[self.idGOOGL]['isLoanToken'], False)
+        assert_equal(len(self.nodes[0].listloantokens()), 2)
+
+        # Revert
+        self.nodes[0].invalidateblock(self.nodes[0].getblockhash(self.nodes[0].getblockcount()))
+        self.nodes[0].clearmempool()
+
+        # Set loan token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idGOOGL}/loan_minting_enabled':'true', f'v0/token/{self.idGOOGL}/loan_minting_interest':'1'}})
+        self.nodes[0].generate(1)
+
+        # Test setting it again, should not be a problem.
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idGOOGL}/loan_minting_enabled':'true', f'v0/token/{self.idGOOGL}/loan_minting_interest':'1'}})
+        self.nodes[0].generate(1)
+
+        # Should now show up as loan token
+        assert_equal(self.nodes[0].gettoken(self.idGOOGL)[self.idGOOGL]['isLoanToken'], True)
+        result = self.nodes[0].listloantokens()
+        assert_equal(len(result), 3)
+        assert_equal(result[0]['token'][str(self.idGOOGL)]['symbol'], 'GOOGL')
+        assert_equal(result[0]['token'][str(self.idGOOGL)]['isLoanToken'], True)
+        assert_equal(result[0]['fixedIntervalPriceId'], 'GOOGL/USD')
+        assert_equal(result[0]['interest'], Decimal('1.00000000'))
+
+        # Set oracle price
+        oracle_prices = [{"currency": "USD", "tokenAmount": "1@DFI"}, {"currency": "USD", "tokenAmount": "1@TSLA"}, {"currency": "USD", "tokenAmount": "0.5@BTC"}, {"currency": "USD", "tokenAmount": "1@ETH"}, {"currency": "USD", "tokenAmount": "2@GOOGL"}]
+        timestamp = calendar.timegm(time.gmtime())
+        self.nodes[0].setoracledata(self.oracles[0], timestamp, oracle_prices)
+        self.nodes[0].generate(240)
+
+        # Create new vault
+        ownerAddress3 = self.nodes[0].getnewaddress("", "legacy")
+        vaultId6 = self.nodes[0].createvault(ownerAddress3)
+        self.nodes[0].generate(1)
+
+        # Fund with DFI
+        self.nodes[0].deposittovault(vaultId6, self.accountDFI, '5@DFI')
+        self.nodes[0].generate(1)
+
+        # Fund with ETH
+        self.nodes[0].minttokens("10@" + self.symbolETH)
+        self.nodes[0].generate(1)
+        self.nodes[0].deposittovault(vaultId6, self.nodes[0].get_genesis_keys().ownerAuthAddress, '5@ETH')
+        self.nodes[0].generate(1)
+
+        # Try and deposit more GOOGL to vault
+        self.nodes[0].minttokens("1@" + self.symbolGOOGL)
+        self.nodes[0].generate(1)
+        assert_raises_rpc_error(-32600, f'Collateral token with id ({self.idGOOGL}) does not exist!', self.nodes[0].deposittovault, vaultId6, self.nodes[0].get_genesis_keys().ownerAuthAddress, '1@GOOGL')
+
+        # Try and take collateral token as loan
+        assert_raises_rpc_error(-32600, f'Loan token with id ({self.idETH}) does not exist!', self.nodes[0].takeloan, {'vaultId': vaultId6, 'amounts': "1@ETH"})
+
+        # Take loan
+        self.nodes[0].takeloan({'vaultId': vaultId6, 'amounts': "1@GOOGL"})
+        self.nodes[0].generate(1)
+
+        # Check collateral ratio
+        assert_equal(self.nodes[0].getvault(vaultId6)['collateralRatio'], 375)
+
+        # Change collateral ratio
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/loan_collateral_factor':'1'}})
+        self.nodes[0].generate(2)
+
+        # Check new ratio
+        assert_equal(self.nodes[0].getvault(vaultId6)['collateralRatio'], 500)
+        assert_equal(self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES'][f'v0/token/{self.idETH}/loan_collateral_factor'], '1')
+
+        # Change collateral currency pair
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/fixed_interval_price_id':'BTC/USD'}})
+        self.nodes[0].generate(1)
+
+        # Check new ratio and currency pair
+        assert_equal(self.nodes[0].getvault(vaultId6)['collateralRatio'], 375)
+        assert_equal(self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES'][f'v0/token/{self.idETH}/fixed_interval_price_id'], 'BTC/USD')
+
+        # Disable collateral token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idETH}/loan_collateral_enabled':'false'}})
+        self.nodes[0].generate(1)
+
+        # Check ETH collateral token disabled
+        assert_equal(self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES'][f'v0/token/{self.idETH}/loan_collateral_enabled'], 'false')
+
+        # Try and deposit disabled collateral to vault
+        assert_raises_rpc_error(-32600, f'Collateral token ({self.idETH}) is disabled', self.nodes[0].deposittovault, vaultId6, self.nodes[0].get_genesis_keys().ownerAuthAddress, '1@ETH')
+
+        # Reduce interest to zero
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/loan_minting_interest':'0'}})
+        self.nodes[0].generate(1)
+
+        # Take new loan with zero interest on the loan token
+        self.nodes[0].takeloan({'vaultId': vaultId6, 'amounts': "1@GOOGL"})
+        self.nodes[0].generate(1)
+
+        # Check interest is now zero
+        interest = self.nodes[0].getvault(vaultId6)['interestValue']
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].getvault(vaultId6)['interestValue'], interest + Decimal('0.000000120'))
+
+        # Set loan token to also be a collateral token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/loan_collateral_enabled':'true', f'v0/token/{self.idGOOGL}/loan_collateral_factor':'0.5'}})
+        self.nodes[0].generate(1)
+
+        # Deposit GOOGL to vault
+        self.nodes[0].deposittovault(vaultId6, ownerAddress3, '1@GOOGL')
+        self.nodes[0].generate(1)
+
+        # Check collateral
+        result = self.nodes[0].getvault(vaultId6)
+        assert_equal(result['collateralRatio'], 212)
+        assert_equal(result['collateralAmounts'], ['5.00000000@DFI', '5.00000000@ETH', '1.00000000@GOOGL'])
+
+        # Disable loan token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idGOOGL}/loan_minting_enabled':'false'}})
+        self.nodes[0].generate(1)
+
+        # Check loan token is false, still shows up in listloantokens as per previous behaviour.
+        result = self.nodes[0].listloantokens()[0]
+        assert_equal(result['token'][str(self.idGOOGL)]['isLoanToken'], False)
+
+        # Check that taking loan now fails
+        assert_raises_rpc_error(-32600, f'Loan cannot be taken on token with id ({self.idGOOGL}) as "mintable" is currently false', self.nodes[0].takeloan, {'vaultId': vaultId6, 'amounts': "1@GOOGL"})
+
+        # Set collateral and loan tokens for 10 blocks time
+        activation_height = self.nodes[0].getblockcount() + 10
+        self.nodes[0].setgovheight({"ATTRIBUTES":{f'v0/token/{self.idAAPL}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idAAPL}/loan_minting_enabled':'true', f'v0/token/{self.idAAPL}/loan_minting_interest':'1',
+                                                  f'v0/token/{self.idUSDT}/fixed_interval_price_id':'GOOGL/USD', f'v0/token/{self.idUSDT}/loan_collateral_enabled':'true', f'v0/token/{self.idUSDT}/loan_collateral_factor':'1'}}, activation_height)
+        self.nodes[0].generate(1)
+
+        # Check pending tokens
+        result = self.nodes[0].listgovs()[8][1][str(activation_height)]
+        assert_equal(result[f'v0/token/{self.idUSDT}/fixed_interval_price_id'], 'GOOGL/USD')
+        assert_equal(result[f'v0/token/{self.idUSDT}/loan_collateral_enabled'], 'true')
+        assert_equal(result[f'v0/token/{self.idUSDT}/loan_collateral_factor'], '1')
+        assert_equal(result[f'v0/token/{self.idAAPL}/fixed_interval_price_id'], 'GOOGL/USD')
+        assert_equal(result[f'v0/token/{self.idAAPL}/loan_minting_enabled'], 'true')
+        assert_equal(result[f'v0/token/{self.idAAPL}/loan_minting_interest'], '1')
+
+        # Move to activation height
+        self.nodes[0].generate(activation_height - self.nodes[0].getblockcount())
+
+        # Check tokens
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result[f'v0/token/{self.idUSDT}/fixed_interval_price_id'], 'GOOGL/USD')
+        assert_equal(result[f'v0/token/{self.idUSDT}/loan_collateral_enabled'], 'true')
+        assert_equal(result[f'v0/token/{self.idUSDT}/loan_collateral_factor'], '1')
+        assert_equal(result[f'v0/token/{self.idAAPL}/fixed_interval_price_id'], 'GOOGL/USD')
+        assert_equal(result[f'v0/token/{self.idAAPL}/loan_minting_enabled'], 'true')
+        assert_equal(result[f'v0/token/{self.idAAPL}/loan_minting_interest'], '1')
+
     def run_test(self):
         self.setup()
         self.createvault_with_invalid_parameters()
@@ -679,6 +1001,7 @@ def run_test(self):
         self.test_50pctDFI_fresh_vault_takeloan_withdraw()
         self.test_50pctDFI_rule_after_BTC_price_increase()
         self.overflowed_collateral_value()
+        self.loan_and_collateral_token_to_govvar()
 
 if __name__ == '__main__':
     VaultTest().main()
diff --git a/test/functional/feature_setgov.py b/test/functional/feature_setgov.py
index 9b35f9e9378..821240b2e9a 100755
--- a/test/functional/feature_setgov.py
+++ b/test/functional/feature_setgov.py
@@ -21,8 +21,8 @@ def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         self.extra_args = [
-            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-subsidytest=1'],
-            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-subsidytest=1']]
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-greatworldheight=1200', '-subsidytest=1'],
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-greatworldheight=1200', '-subsidytest=1']]
 
 
     def run_test(self):
@@ -444,9 +444,9 @@ def run_test(self):
         assert_raises_rpc_error(-5, "Unsupported version", self.nodes[0].setgov, {"ATTRIBUTES":{'1/token/15/payback_dfi':'true'}})
         assert_raises_rpc_error(-5, "Empty value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/15/payback_dfi':''}})
         assert_raises_rpc_error(-5, "Incorrect key for <type>. Object of ['<version>/<type>/ID/<key>','value'] expected", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/payback_dfi':'true'}})
-        assert_raises_rpc_error(-5, "Unrecognised type argument provided, valid types are: params, poolpairs, token,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/unrecognised/5/payback_dfi':'true'}})
-        assert_raises_rpc_error(-5, "Unrecognised key argument provided, valid keys are: dex_in_fee_pct, dex_out_fee_pct, dfip2203, loan_payback, loan_payback_fee_pct, payback_dfi, payback_dfi_fee_pct,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/unrecognised':'true'}})
-        assert_raises_rpc_error(-5, "Value must be a positive integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/not_a_number/payback_dfi':'true'}})
+        assert_raises_rpc_error(-5, "Unrecognised type argument provided, valid types are: locks, oracles, params, poolpairs, token,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/unrecognised/5/payback_dfi':'true'}})
+        assert_raises_rpc_error(-5, "Unrecognised key argument provided, valid keys are: dex_in_fee_pct, dex_out_fee_pct, dfip2203, fixed_interval_price_id, loan_collateral_enabled, loan_collateral_factor, loan_minting_enabled, loan_minting_interest, loan_payback, loan_payback_fee_pct, payback_dfi, payback_dfi_fee_pct,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/unrecognised':'true'}})
+        assert_raises_rpc_error(-5, "Value must be an integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/not_a_number/payback_dfi':'true'}})
         assert_raises_rpc_error(-5, 'Boolean value must be either "true" or "false"', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi':'not_a_number'}})
         assert_raises_rpc_error(-5, 'Boolean value must be either "true" or "false"', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi':'unrecognised'}})
         assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi_fee_pct':'not_a_number'}})
@@ -469,10 +469,10 @@ def run_test(self):
 
         # Setup for loan related tests
         oracle_address = self.nodes[0].getnewaddress("", "legacy")
-        appoint_oracle_tx = self.nodes[0].appointoracle(oracle_address, [{"currency": "USD", "token": "DFI"},{"currency": "USD", "token": "TSLA"}], 1)
+        appoint_oracle_tx = self.nodes[0].appointoracle(oracle_address, [{"currency": "USD", "token": "DFI"},{"currency": "USD", "token": "TSLA"},{"currency": "USD", "token": "AMZN"}], 1)
         self.nodes[0].generate(1)
 
-        oracle_prices = [{"currency": "USD", "tokenAmount": "100.00000000@DFI"},{"currency": "USD", "tokenAmount": "100.00000000@TSLA"}]
+        oracle_prices = [{"currency": "USD", "tokenAmount": "100.00000000@DFI"},{"currency": "USD", "tokenAmount": "100.00000000@TSLA"},{"currency": "USD", "tokenAmount": "100.00000000@AMZN"}]
         self.nodes[0].setoracledata(appoint_oracle_tx, int(time.time()), oracle_prices)
         self.nodes[0].generate(12)
 
@@ -495,6 +495,12 @@ def run_test(self):
                                     'interest': 5})
         self.nodes[0].generate(1)
 
+        self.nodes[0].setcollateraltoken({
+            'token': "DUSD",
+            'factor': 1,
+            'fixedIntervalPriceId': "DFI/USD"})
+        self.nodes[0].generate(1)
+
         # Test setting of new Gov var
         self.nodes[0].setgov({"ATTRIBUTES":{'v0/token/5/payback_dfi':'true'}})
         self.nodes[0].generate(1)
@@ -573,6 +579,7 @@ def run_test(self):
 
         # Test setting FCR ATTRBIUTES
         self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'0.05','v0/params/dfip2203/block_period':'20160','v0/token/5/dfip2203':'true'}})
+        self.nodes[0].generate(1)
         self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
         self.nodes[0].generate(1)
 
@@ -583,5 +590,88 @@ def run_test(self):
         assert_equal(result['v0/params/dfip2203/block_period'], '20160')
         assert_equal(result['v0/token/5/dfip2203'], 'true')
 
+        # Check errors
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/locks/token/5':'true'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/4000': '1/50'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':'TSLA/USD'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_enabled':'true'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_factor':'1.00000000'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_enabled':'true'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before GreatWorld", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_interest':'5.00000000'}})
+
+        # Move to GW fork
+        self.nodes[0].generate(1200 - self.nodes[0].getblockcount())
+
+        # Check errors
+        assert_raises_rpc_error(-5, "Unrecognised locks argument provided, valid lockss are: token,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/locks/oracle/5':'true'}})
+        assert_raises_rpc_error(-32600, "No loan token with id (4)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/locks/token/4':'true'}})
+        assert_raises_rpc_error(-5, "Unrecognised key argument provided", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/ascendant': '1'}})
+        assert_raises_rpc_error(-5, "Unrecognised key argument provided", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/descendant': '1'}})
+        assert_raises_rpc_error(-5, "Unrecognised key argument provided", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/epitaph': '1'}})
+        assert_raises_rpc_error(-5, "Two int values expected for split in id/mutliplier", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1200': '1/50,600'}})
+        assert_raises_rpc_error(-5, "Mutliplier cannot be zero", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1201': '1/0'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Token (127) does not exist", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1201': '127/50'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Only DATs can be split", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1201': '128/50'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Tokenised DFI cannot be split", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1201': '0/50'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Pool tokens cannot be split", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/1201': '1/50'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set at or below current height", self.nodes[0].setgov, {"ATTRIBUTES":{f'v0/oracles/splits/{self.nodes[0].getblockcount()}': '5/50'}})
+        assert_raises_rpc_error(-32600, "No loan token with id (4)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/oracles/splits/4000':'4/2'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Price feed DUFF/USD does not belong to any oracle", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':'DUFF/USD'}})
+        assert_raises_rpc_error(-5, "Empty token / currency", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':' /USD'}})
+        assert_raises_rpc_error(-5, "Empty token / currency", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':'DUFF/ '}})
+        assert_raises_rpc_error(-5, "Empty token / currency", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':' / '}})
+        assert_raises_rpc_error(-32600, "No such token (127)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/127/fixed_interval_price_id':'TSLA/USD'}})
+        assert_raises_rpc_error(-5, "Exactly two entires expected for currency pair", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':'5'}})
+        assert_raises_rpc_error(-5, "Exactly two entires expected for currency pair", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/fixed_interval_price_id':'5/10/20'}})
+        assert_raises_rpc_error(-5, "Boolean value must be either \"true\" or \"false\"", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_enabled':'not_a_bool'}})
+        assert_raises_rpc_error(-32600, "No such token (127)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/127/loan_collateral_enabled':'true'}})
+        assert_raises_rpc_error(-32600, "Fixed interval price currency pair must be set first", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_enabled':'true'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_factor':'-1'}})
+        assert_raises_rpc_error(-5, "Percentage exceeds 100%", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_factor':'1.00000001'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_factor':'not_a_number'}})
+        assert_raises_rpc_error(-32600, "No such token (127)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/127/loan_collateral_factor':'1'}})
+        assert_raises_rpc_error(-32600, "Fixed interval price currency pair must be set first", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_collateral_factor':'1'}})
+        assert_raises_rpc_error(-5, "Boolean value must be either \"true\" or \"false\"", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_enabled':'not_a_bool'}})
+        assert_raises_rpc_error(-32600, "No such token (127)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/127/loan_minting_enabled':'true'}})
+        assert_raises_rpc_error(-32600, "Fixed interval price currency pair must be set first", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_enabled':'true'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_interest':'-1'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_interest':'not_a_number'}})
+        assert_raises_rpc_error(-32600, "No such token (127)", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/127/loan_minting_interest':'1'}})
+        assert_raises_rpc_error(-32600, "Fixed interval price currency pair must be set first", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/loan_minting_interest':'1'}})
+
+
+    # Set locks
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/locks/token/5':'true'}})
+        self.nodes[0].generate(1)
+
+        attriutes = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(attriutes['v0/locks/token/5'], 'true')
+
+        # Set loan token for 4
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/4/fixed_interval_price_id':'TSLA/USD', f'v0/token/4/loan_minting_enabled':'true', f'v0/token/4/loan_minting_interest':'1'}})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/oracles/splits/4000':'4/50,5/5,'}})
+        self.nodes[0].generate(1)
+
+        # Check auto lock
+        assert_equal(self.nodes[0].listgovs()[8][1]['3928'], {'v0/locks/token/4': 'true'})
+
+        # Disable auto lock
+        self.nodes[0].setgovheight({"ATTRIBUTES":{'v0/locks/token/4':'false'}}, 3928)
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].listgovs()[8][1]['3928'], {'v0/locks/token/4': 'false'})
+
+        # Re-enable auto lock
+        self.nodes[0].setgovheight({"ATTRIBUTES":{'v0/locks/token/4':'true'}}, 3928)
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].listgovs()[8][1]['3928'], {'v0/locks/token/4': 'true'})
+
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/oracles/splits/4000':'5/10'}})
+        self.nodes[0].generate(1)
+
+        attriutes = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(attriutes['v0/oracles/splits/4000'], '4/50,5/10,')
+
 if __name__ == '__main__':
     GovsetTest ().main ()
diff --git a/test/functional/feature_token_lock.py b/test/functional/feature_token_lock.py
new file mode 100644
index 00000000000..6e6092416f5
--- /dev/null
+++ b/test/functional/feature_token_lock.py
@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) DeFi Blockchain Developers
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+"""Test Token Lock."""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from decimal import Decimal
+import time
+
+class TokenLockTest(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-eunosheight=1', '-fortcanningheight=1', '-fortcanninghillheight=1', '-fortcanningroadheight=1', '-greatworldheight=200', '-subsidytest=1']]
+
+    def run_test(self):
+        self.nodes[0].generate(150)
+
+        # Set up oracles and tokens
+        self.setup_test()
+
+        # Test pool lock
+        self.pool_lock()
+
+        # Test oracle lock
+        self.oracle_lock()
+
+        # Test vault lock
+        self.vault_lock()
+
+        # Test token lock
+        self.token_lock()
+
+    def setup_test(self):
+
+        # Store address
+        self.address = self.nodes[0].get_genesis_keys().ownerAuthAddress
+
+        # Set token symbols
+        self.symbolDFI   = 'DFI'
+        self.symbolDUSD  = 'DUSD'
+        self.symbolTSLA  = 'TSLA'
+        self.symbolGOOGL = 'GOOGL'
+        self.symbolTD    = 'TSLA-DUSD'
+
+        # Setup oracle
+        oracle_address = self.nodes[0].getnewaddress("", "legacy")
+        price_feeds = [
+            {"currency": "USD", "token": self.symbolDFI},
+            {"currency": "USD", "token": self.symbolTSLA},
+            {"currency": "USD", "token": self.symbolGOOGL},
+        ]
+        self.oracle_id = self.nodes[0].appointoracle(oracle_address, price_feeds, 10)
+        self.nodes[0].generate(1)
+
+        # Create Oracle prices
+        self.price_dfi   = 5
+        self.price_tsla  = 870
+        self.price_googl = 2850
+
+        # Set Oracle data
+        self.oracle_prices = [
+            {"currency": "USD", "tokenAmount": f'{self.price_dfi}@{self.symbolDFI}'},
+            {"currency": "USD", "tokenAmount": f'{self.price_tsla}@{self.symbolTSLA}'},
+            {"currency": "USD", "tokenAmount": f'{self.price_googl}@{self.symbolGOOGL}'},
+        ]
+        self.nodes[0].setoracledata(self.oracle_id, int(time.time()), self.oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Setup loan tokens
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolDUSD,
+            'name': self.symbolDUSD,
+            'fixedIntervalPriceId': f'{self.symbolDUSD}/USD',
+            'mintable': True,
+            'interest': 0})
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolTSLA,
+            'name': self.symbolTSLA,
+            'fixedIntervalPriceId': f'{self.symbolTSLA}/USD',
+            'mintable': True,
+            'interest': 1})
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolGOOGL,
+            'name': self.symbolGOOGL,
+            'fixedIntervalPriceId': f'{self.symbolGOOGL}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        # Set collateral token
+        self.nodes[0].setcollateraltoken({
+            'token': self.symbolDUSD,
+            'factor': 1,
+            'fixedIntervalPriceId': f'{self.symbolDUSD}/USD'
+        })
+
+        # Set token ids
+        self.idDUSD  = list(self.nodes[0].gettoken(self.symbolDUSD).keys())[0]
+        self.idTSLA  = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+        self.idGOOGL  = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+
+        # Mint tokens
+        self.nodes[0].minttokens([f'1000000@{self.idDUSD}'])
+        self.nodes[0].minttokens([f'1000000@{self.idTSLA}'])
+        self.nodes[0].minttokens([f'1000000@{self.idGOOGL}'])
+        self.nodes[0].generate(1)
+
+        # Tokenise DFI
+        self.nodes[0].utxostoaccount({self.address: f'2000@{self.symbolDFI}'})
+        self.nodes[0].generate(1)
+
+        # Create pool
+        self.nodes[0].createpoolpair({
+            "tokenA": self.symbolTSLA,
+            "tokenB": self.symbolDUSD,
+            "commission": 0.01,
+            "status": True,
+            "ownerAddress": self.address,
+            "pairSymbol": self.symbolTD,
+        })
+
+        self.nodes[0].createpoolpair({
+            "tokenA": self.symbolDFI,
+            "tokenB": self.symbolDUSD,
+            "commission": 0.01,
+            "status": True,
+            "ownerAddress": self.address,
+        })
+        self.nodes[0].generate(1)
+
+        # Add liquidity
+        self.nodes[0].addpoolliquidity({
+            self.address: [f'870000@{self.symbolTSLA}', f'1000@{self.symbolDUSD}']
+        }, self.address)
+
+        self.nodes[0].addpoolliquidity({
+            self.address: [f'1000@{self.symbolDFI}', f'5000@{self.symbolDUSD}']
+        }, self.address)
+        self.nodes[0].generate(1)
+
+        # Create loan schemes
+        self.nodes[0].createloanscheme(100, 0.01, 'LOAN100')
+        self.nodes[0].generate(1)
+
+        # Create vault
+        self.vault = self.nodes[0].createvault(self.address)
+        self.nodes[0].generate(1)
+
+        # Fund vault
+        self.nodes[0].deposittovault(self.vault, self.address, f'100000@{self.symbolDUSD}')
+        self.nodes[0].generate(1)
+
+    def pool_lock(self):
+
+        # Move to fork block
+        self.nodes[0].generate(200 - self.nodes[0].getblockcount())
+
+        # Enable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Try test pool swap in both directions
+        assert_raises_rpc_error(-32600, "Pool currently disabled due to locked token", self.nodes[0].poolswap, {
+            "from": self.address,
+            "tokenFrom": self.symbolTSLA,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolDUSD
+        })
+        assert_raises_rpc_error(-32600, "Pool currently disabled due to locked token", self.nodes[0].poolswap, {
+            "from": self.address,
+            "tokenFrom": self.symbolDUSD,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolTSLA
+        })
+
+        # Try pool swap in both directions
+        assert_raises_rpc_error(-32600, "Pool currently disabled due to locked token", self.nodes[0].poolswap, {
+            "from": self.address,
+            "tokenFrom": self.symbolTSLA,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolDUSD
+        })
+        assert_raises_rpc_error(-32600, "Pool currently disabled due to locked token", self.nodes[0].poolswap, {
+            "from": self.address,
+            "tokenFrom": self.symbolDUSD,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolTSLA
+        })
+
+        # Disable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'false'}})
+        self.nodes[0].generate(1)
+
+        # Test pool swap should now work
+        self.nodes[0].testpoolswap({
+            "from": self.address,
+            "tokenFrom": self.symbolDUSD,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolTSLA
+        })
+
+        # Pool swap should now work
+        self.nodes[0].poolswap({
+            "from": self.address,
+            "tokenFrom": self.symbolDUSD,
+            "amountFrom": 1,
+            "to": self.address,
+            "tokenTo": self.symbolTSLA
+        })
+        self.nodes[0].clearmempool()
+
+    def oracle_lock(self):
+
+        # Set Oracle data
+        self.nodes[0].setoracledata(self.oracle_id, int(time.time()), self.oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Check output before lock
+        result = self.nodes[0].getfixedintervalprice(f'{self.symbolTSLA}/USD')
+        assert_equal(result['fixedIntervalPriceId'], f'{self.symbolTSLA}/USD')
+        assert_equal(result['isLive'], True)
+
+        # Enable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Check price feed disabled
+        assert_raises_rpc_error(-5, "Fixed interval price currently disabled due to locked token", self.nodes[0].getfixedintervalprice, f'{self.symbolTSLA}/USD')
+
+        # Disable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'false'}})
+        self.nodes[0].generate(1)
+
+        # Set Oracle data
+        self.nodes[0].setoracledata(self.oracle_id, int(time.time()), self.oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Check output before lock
+        result = self.nodes[0].getfixedintervalprice(f'{self.symbolTSLA}/USD')
+        assert_equal(result['fixedIntervalPriceId'], f'{self.symbolTSLA}/USD')
+        assert_equal(result['isLive'], True)
+
+    def vault_lock(self):
+
+        # Take loan
+        self.nodes[0].takeloan({'vaultId': self.vault, 'amounts': f'1@{self.symbolTSLA}'})
+        self.nodes[0].generate(1)
+
+        # Enable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Try and take loan while token in vault locked
+        assert_raises_rpc_error(-32600, "Cannot take loan while any of the asset's price in the vault is not live", self.nodes[0].takeloan, {'vaultId': self.vault, 'amounts': f'1@{self.symbolTSLA}'})
+        assert_raises_rpc_error(-32600, "Cannot take loan while any of the asset's price in the vault is not live", self.nodes[0].takeloan, {'vaultId': self.vault, 'amounts': f'1@{self.symbolGOOGL}'})
+
+        # Vault amounts should be zero while token locked
+        result = self.nodes[0].getvault(self.vault)
+        assert_equal(result['collateralValue'], 0)
+        assert_equal(result['loanValue'], 0)
+        assert_equal(result['interestValue'], Decimal('0.00000000'))
+        assert_equal(result['informativeRatio'], 0)
+        assert_equal(result['collateralRatio'], 0)
+
+        # Deposit to vault should fail
+        assert_raises_rpc_error(-32600, "Fixed interval price currently disabled due to locked token", self.nodes[0].deposittovault, self.vault, self.address, f'100000@{self.symbolDUSD}')
+
+        # Payback loan with native token failed due to no pool to swap interest to DFI
+        assert_raises_rpc_error(-32600, "Pool currently disabled due to locked token", self.nodes[0].paybackloan, {'vaultId': self.vault, 'from': self.address, 'amounts': f'1@{self.symbolTSLA}'})
+
+        # Disable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'false'}})
+        self.nodes[0].generate(1)
+
+        # Set Oracle data
+        self.nodes[0].setoracledata(self.oracle_id, int(time.time()), self.oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Vault amounts should now be restored
+        result = self.nodes[0].getvault(self.vault)
+        assert_equal(result['collateralValue'], Decimal('100000.00000000'))
+        assert_equal(result['loanValue'], Decimal('870.00217500'))
+        assert_equal(result['interestValue'], Decimal('0.00217500'))
+        assert_equal(result['informativeRatio'], Decimal('11494.22413800'))
+        assert_equal(result['collateralRatio'], 11494)
+
+    def token_lock(self):
+
+        # Enable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Try and update token
+        assert_raises_rpc_error(-32600, "Cannot update token during lock", self.nodes[0].updatetoken, self.idTSLA, {'name':'Tesla'})
+
+        # Disable token lock
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'false'}})
+        self.nodes[0].generate(1)
+
+        # Try same update
+        self.nodes[0].updatetoken(self.idTSLA, {'name':'Tesla'})
+        self.nodes[0].generate(1)
+
+        # Verify results
+        result = self.nodes[0].gettoken(self.idTSLA)[self.idTSLA]
+        assert_equal(result['name'], 'Tesla')
+
+if __name__ == '__main__':
+    TokenLockTest().main()
+
diff --git a/test/functional/feature_token_split.py b/test/functional/feature_token_split.py
new file mode 100644
index 00000000000..4fcb9e000be
--- /dev/null
+++ b/test/functional/feature_token_split.py
@@ -0,0 +1,639 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) DeFi Blockchain Developers
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+"""Test token split"""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from decimal import Decimal
+import time
+import random
+
+def truncate(str, decimal):
+    return str if not str.find('.') + 1 else str[:str.find('.') + decimal + 1]
+
+class TokenSplitTest(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [
+            ['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-eunosheight=1', '-fortcanningheight=1', '-fortcanningmuseumheight=1', '-fortcanninghillheight=1', '-fortcanningroadheight=1', '-greatworldheight=150', '-subsidytest=1']]
+
+    def run_test(self):
+        self.setup_test_tokens()
+        self.token_split()
+        self.setup_test_pools()
+        self.pool_split()
+        self.setup_test_vaults()
+        self.vault_split()
+        self.check_govvar_deletion()
+
+    def setup_test_tokens(self):
+        self.nodes[0].generate(101)
+
+        # Symbols
+        self.symbolDFI = 'DFI'
+        self.symbolDUSD = 'DUSD'
+        self.symbolTSLA = 'TSLA'
+        self.symbolGOOGL = 'GOOGL'
+        self.symbolNVDA = 'NVDA'
+        self.symbolGD = 'GOOGL-DUSD'
+
+        # Store address
+        self.address = self.nodes[0].get_genesis_keys().ownerAuthAddress
+
+        # Price feeds
+        price_feed = [
+            {"currency": "USD", "token": self.symbolDFI},
+            {"currency": "USD", "token": self.symbolDUSD},
+            {"currency": "USD", "token": self.symbolGOOGL},
+            {"currency": "USD", "token": self.symbolTSLA},
+            {"currency": "USD", "token": self.symbolNVDA},
+        ]
+
+        # Appoint oracle
+        oracle_address = self.nodes[0].getnewaddress("", "legacy")
+        oracle = self.nodes[0].appointoracle(oracle_address, price_feed, 10)
+        self.nodes[0].generate(1)
+
+        # Set Oracle prices
+        oracle_prices = [
+            {"currency": "USD", "tokenAmount": f"1@{self.symbolDFI}"},
+            {"currency": "USD", "tokenAmount": f"1@{self.symbolDUSD}"},
+            {"currency": "USD", "tokenAmount": f"1@{self.symbolGOOGL}"},
+            {"currency": "USD", "tokenAmount": f"1@{self.symbolTSLA}"},
+            {"currency": "USD", "tokenAmount": f"1@{self.symbolNVDA}"},
+        ]
+        self.nodes[0].setoracledata(oracle, int(time.time()), oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Set loan tokens
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolGOOGL,
+            'name': self.symbolGOOGL,
+            'fixedIntervalPriceId': f"{self.symbolGOOGL}/USD",
+            "isDAT": True,
+            'interest': 0
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolDUSD,
+            'name': self.symbolDUSD,
+            'fixedIntervalPriceId': f"{self.symbolDUSD}/USD",
+            'mintable': True,
+            'interest': 0
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolTSLA,
+            'name': self.symbolTSLA,
+            'fixedIntervalPriceId': f"{self.symbolTSLA}/USD",
+            'mintable': True,
+            'interest': 0
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolNVDA,
+            'name': self.symbolNVDA,
+            'fixedIntervalPriceId': f"{self.symbolNVDA}/USD",
+            'mintable': True,
+            'interest': 0
+        })
+        self.nodes[0].generate(1)
+
+        # Set collateral tokens
+        self.nodes[0].setcollateraltoken({
+            'token': self.symbolDFI,
+            'factor': 1,
+            'fixedIntervalPriceId': f"{self.symbolDFI}/USD"
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setcollateraltoken({
+            'token': self.symbolDUSD,
+            'factor': 1,
+            'fixedIntervalPriceId': f"{self.symbolDUSD}/USD"
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setcollateraltoken({
+            'token': self.symbolGOOGL,
+            'factor': 1,
+            'fixedIntervalPriceId': f"{self.symbolGOOGL}/USD"
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setcollateraltoken({
+            'token': self.symbolTSLA,
+            'factor': 1,
+            'fixedIntervalPriceId': f"{self.symbolTSLA}/USD"
+        })
+        self.nodes[0].generate(1)
+
+        # Store token IDs
+        self.idDUSD = list(self.nodes[0].gettoken(self.symbolDUSD).keys())[0]
+        self.idGOOGL = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+        self.idTSLA = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+        self.idNVDA = list(self.nodes[0].gettoken(self.symbolNVDA).keys())[0]
+
+    def setup_test_pools(self):
+
+        # Create pool pair
+        self.nodes[0].createpoolpair({
+            "tokenA": self.symbolGOOGL,
+            "tokenB": self.symbolDUSD,
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": self.address,
+            "symbol": self.symbolGD
+        })
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createpoolpair({
+            "tokenA": self.symbolDUSD,
+            "tokenB": self.symbolDFI,
+            "commission": Decimal('0.001'),
+            "status": True,
+            "ownerAddress": self.address
+        }, [])
+        self.nodes[0].generate(1)
+
+        self.nodes[0].createpoolpair({
+            "tokenA": self.symbolDUSD,
+            "tokenB": self.symbolNVDA,
+            "commission": Decimal('0.001'),
+            "status": True,
+            "ownerAddress": self.address
+        }, [])
+        self.nodes[0].generate(1)
+
+        # Fund address for pool
+        self.nodes[0].utxostoaccount({self.address: f'100@{self.symbolDFI}'})
+        self.nodes[0].minttokens([f'200@{self.idDUSD}', f'100@{self.idNVDA}'])
+        self.nodes[0].generate(1)
+
+        # Fund pools
+        self.nodes[0].addpoolliquidity({
+            self.address: [f'100@{self.symbolDUSD}', f'100@{self.symbolDFI}']
+        }, self.address)
+        self.nodes[0].addpoolliquidity({
+            self.address: [f'100@{self.symbolDUSD}', f'100@{self.symbolNVDA}']
+        }, self.address)
+        self.nodes[0].generate(1)
+
+        # Store pool ID
+        self.idGD = list(self.nodes[0].gettoken(self.symbolGD).keys())[0]
+
+        # Set pool gov vars
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/poolpairs/{self.idGD}/token_a_fee_pct': '0.01', f'v0/poolpairs/{self.idGD}/token_b_fee_pct': '0.03',
+                                            f'v0/token/{self.idGOOGL}/dex_in_fee_pct': '0.02', f'v0/token/{self.idGOOGL}/dex_out_fee_pct': '0.005'}})
+        self.nodes[0].setgov({"LP_SPLITS": { str(self.idGD): 1}})
+        self.nodes[0].setgov({"LP_LOAN_TOKEN_SPLITS": { str(self.idGD): 1}})
+        self.nodes[0].generate(1)
+
+        # Randomly populate pool
+        self.poolGDTotal = Decimal('0')
+        for _ in range(100):
+            amount = round(random.uniform(1, 1000), 8)
+            self.nodes[0].minttokens([f'{str(amount)}@{self.idDUSD}'])
+            self.nodes[0].minttokens([f'{str(amount)}@{self.idGOOGL}'])
+            self.nodes[0].generate(1)
+            self.nodes[0].addpoolliquidity({
+                self.address: [f'{str(amount)}@{self.idDUSD}', f'{str(amount)}@{self.idGOOGL}']
+            }, self.address)
+            self.nodes[0].generate(1)
+            self.poolGDTotal += Decimal(str(amount))
+
+    def setup_test_vaults(self):
+
+        # Create loan scheme
+        self.nodes[0].createloanscheme(100, 0.1, 'LOAN0001')
+        self.nodes[0].generate(1)
+
+        # Fund address for vault creation
+        self.nodes[0].utxostoaccount({self.address: f'30000@{self.symbolDFI}'})
+        self.nodes[0].generate(1)
+
+        for _ in range(100):
+            # Create vault
+            vault_id = self.nodes[0].createvault(self.address, '')
+            self.nodes[0].generate(1)
+
+            # Take 1 to 3 loans
+            for _ in range(1, 4):
+                # Deposit random collateral
+                collateral = round(random.uniform(1, 100), 8)
+                loan = truncate(str(collateral / 3), 8)
+                self.nodes[0].deposittovault(vault_id, self.address, f'{str(collateral)}@{self.symbolDFI}')
+                self.nodes[0].generate(1)
+
+                # Take loan
+                self.nodes[0].takeloan({
+                    'vaultId': vault_id,
+                    'amounts': f"{str(loan)}@{self.symbolNVDA}"
+                })
+                self.nodes[0].generate(1)
+
+    def check_token_split(self, token_id, token_symbol, token_suffix, multiplier, minted, loan, collateral):
+
+        # Check old token
+        result = self.nodes[0].gettoken(token_id)[token_id]
+        assert_equal(result['symbol'], f'{token_symbol}{token_suffix}')
+        assert_equal(result['minted'], Decimal('0.00000000'))
+        assert_equal(result['mintable'], False)
+        assert_equal(result['tradeable'], False)
+        assert_equal(result['finalized'], True)
+        assert_equal(result['destructionTx'], self.nodes[0].getbestblockhash())
+        assert_equal(result['destructionHeight'], self.nodes[0].getblockcount())
+
+        # Check old token in Gov vars
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert(f'v0/token/{token_id}/fixed_interval_price_id' not in result)
+        if collateral:
+            assert(f'v0/token/{token_id}/loan_collateral_enabled' not in result)
+            assert(f'v0/token/{token_id}/loan_collateral_factor' not in result)
+        if loan:
+            assert(f'v0/token/{token_id}/loan_minting_enabled' not in result)
+            assert(f'v0/token/{token_id}/loan_minting_interest' not in result)
+        assert(f'v0/locks/token/{token_id}' not in result)
+
+        # Save old ID and get new one
+        token_idv1 = token_id
+        token_id = list(self.nodes[0].gettoken(token_symbol).keys())[0]
+
+        # Check new token in Gov vars
+        assert_equal(result[f'v0/token/{token_id}/fixed_interval_price_id'], f'{token_symbol}/USD')
+        if collateral:
+            assert_equal(result[f'v0/token/{token_id}/loan_collateral_enabled'], 'true')
+            assert_equal(result[f'v0/token/{token_id}/loan_collateral_factor'], '1')
+        if loan:
+            assert_equal(result[f'v0/token/{token_id}/loan_minting_enabled'], 'true')
+            assert_equal(result[f'v0/token/{token_id}/loan_minting_interest'], '0')
+        assert(f'v0/oracles/splits/{self.nodes[0].getblockcount()}' not in result)
+        assert_equal(result[f'v0/token/{token_idv1}/descendant'], f'{token_id}/{self.nodes[0].getblockcount()}')
+        assert_equal(result[f'v0/token/{token_id}/ascendant'], f'{token_idv1}/split')
+        assert_equal(result[f'v0/locks/token/{token_id}'], 'true')
+
+        # Check new token
+        result = self.nodes[0].gettoken(token_id)[token_id]
+        assert_equal(result['symbol'], f'{token_symbol}')
+        assert_equal(result['minted'], Decimal(f'{minted}'))
+        assert_equal(result['mintable'], True)
+        assert_equal(result['tradeable'], True)
+        assert_equal(result['finalized'], False)
+        assert_equal(result['creationTx'], self.nodes[0].getblock(self.nodes[0].getbestblockhash())['tx'][1])
+        assert_equal(result['creationHeight'], self.nodes[0].getblockcount())
+        assert_equal(result['destructionTx'], '0000000000000000000000000000000000000000000000000000000000000000')
+        assert_equal(result['destructionHeight'], -1)
+
+        # Make sure no old tokens remain in the account
+        result = self.nodes[0].getaccount(self.address)
+        for val in result:
+            assert_equal(val.find(f'{token_symbol}{token_suffix}'), -1)
+
+    def check_pool_split(self, pool_id, pool_symbol, token_id, token_symbol, token_suffix, minted, reserve_a, reserve_b):
+
+        # Check old pool
+        result = self.nodes[0].getpoolpair(pool_id)[pool_id]
+        assert_equal(result['symbol'], f'{pool_symbol}{token_suffix}')
+        assert_equal(result['reserveA'], Decimal('0.00000000'))
+        assert_equal(result['reserveB'], Decimal('0.00000000'))
+        assert_equal(result['reserveA/reserveB'], '0')
+        assert_equal(result['reserveB/reserveA'], '0')
+        assert_equal(result['status'], False)
+        assert_equal(result['tradeEnabled'], False)
+        assert('dexFeePctTokenA' not in result)
+        assert('dexFeePctTokenB' not in result)
+        assert('dexFeeInPctTokenA' not in result)
+        assert('dexFeeOutPctTokenA' not in result)
+        assert_equal(result['rewardPct'], Decimal('0.00000000'))
+        assert_equal(result['rewardLoanPct'], Decimal('0.00000000'))
+
+        # Validate old Gov vars removed
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert(f'v0/poolpairs/{pool_id}/token_a_fee_pct' not in result)
+        assert(f'v0/poolpairs/{pool_id}/token_b_fee_pct' not in result)
+        assert(f'v0/token/{token_id}/dex_in_fee_pct' not in result)
+        assert(f'v0/token/{token_id}/dex_out_fee_pct' not in result)
+
+        # Swap old for new values
+        token_id = list(self.nodes[0].gettoken(token_symbol).keys())[0]
+        pool_id = list(self.nodes[0].gettoken(pool_symbol).keys())[0]
+
+        # Validate new Gov vars set
+        assert_equal(result[f'v0/poolpairs/{pool_id}/token_a_fee_pct'], '0.01')
+        assert_equal(result[f'v0/poolpairs/{pool_id}/token_b_fee_pct'], '0.03')
+        assert_equal(result[f'v0/token/{token_id}/dex_in_fee_pct'], '0.02')
+        assert_equal(result[f'v0/token/{token_id}/dex_out_fee_pct'], '0.005')
+
+        # Check new pool
+        result = self.nodes[0].getpoolpair(pool_id)[pool_id]
+        assert_equal(result['symbol'], f'{pool_symbol}')
+        assert_equal(result['reserveA'], Decimal(f'{minted}'))
+        assert_equal(result['reserveB'], self.poolGDTotal)
+        assert_equal(result['reserveA/reserveB'], reserve_a)
+        assert_equal(result['reserveB/reserveA'], reserve_b)
+        assert_equal(result['idTokenA'], str(token_id))
+        assert_equal(result['status'], True)
+        assert_equal(result['tradeEnabled'], True)
+        assert_equal(result['dexFeePctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['dexFeePctTokenB'], Decimal('0.03000000'))
+        assert_equal(result['dexFeeInPctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['dexFeeOutPctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['rewardPct'], Decimal('1.00000000'))
+        assert_equal(result['rewardLoanPct'], Decimal('1.00000000'))
+        assert_equal(result['creationTx'], self.nodes[0].getblock(self.nodes[0].getbestblockhash())['tx'][2])
+        assert_equal(result['creationHeight'], self.nodes[0].getblockcount())
+
+        # Make sure no old pool tokens remain in the account
+        result = self.nodes[0].getaccount(self.address)
+        for val in result:
+            assert_equal(val.find(f'{pool_symbol}{token_suffix}'), -1)
+
+        # Check that LP_SPLITS and LP_LOAN_TOKEN_SPLITS updated
+        assert_equal(self.nodes[0].getgov('LP_SPLITS')['LP_SPLITS'], {pool_id: Decimal('1.00000000')})
+        assert_equal(self.nodes[0].getgov('LP_LOAN_TOKEN_SPLITS')['LP_LOAN_TOKEN_SPLITS'], {pool_id: Decimal('1.00000000')})
+
+    def token_split(self):
+
+        # Move to GW
+        self.nodes[0].generate(151 - self.nodes[0].getblockcount())
+
+        # Set extra Gov vars for token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{self.idTSLA}/dfip2203':'true',
+                                            f'v0/token/{self.idTSLA}/loan_payback/{self.idDUSD}': 'true',
+                                            f'v0/token/{self.idGOOGL}/loan_payback/{self.idTSLA}': 'true',
+                                            f'v0/token/{self.idTSLA}/loan_payback/{self.idTSLA}': 'true',
+                                            f'v0/token/{self.idGOOGL}/loan_payback_fee_pct/{self.idTSLA}': '0.25',
+                                            f'v0/token/{self.idTSLA}/loan_payback_fee_pct/{self.idTSLA}': '0.25',
+                                            f'v0/token/{self.idTSLA}/loan_payback_fee_pct/{self.idDUSD}': '0.25'}})
+        self.nodes[0].generate(1)
+
+        # Make sure we cannot make a token with '/' in its symbol
+        assert_raises_rpc_error(-32600, "token symbol should not contain '/'", self.nodes[0].createtoken, {
+            'symbol': 'bad/v1',
+            "collateralAddress": self.address
+        })
+
+        # Create funded addresses
+        funded_addresses = []
+        for _ in range(100):
+            amount = round(random.uniform(1, 1000), 8)
+            self.nodes[0].minttokens([f'{str(amount)}@{self.idTSLA}'])
+            self.nodes[0].generate(1)
+            address = self.nodes[0].getnewaddress()
+            self.nodes[0].accounttoaccount(self.address, {address: f'{str(amount)}@{self.idTSLA}'})
+            self.nodes[0].generate(1)
+            funded_addresses.append([address, Decimal(str(amount))])
+
+        # Set expected minted amount
+        minted = self.nodes[0].gettoken(self.idTSLA)[self.idTSLA]['minted'] * 2
+
+        # Lock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Token split
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{str(self.nodes[0].getblockcount() + 2)}':f'{self.idTSLA}/2'}})
+        self.nodes[0].generate(2)
+
+        # Check token split correctly
+        self.check_token_split(self.idTSLA, self.symbolTSLA, '/v1', 2, minted, True, True)
+
+        # Swap old for new values
+        self.idTSLA = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+
+        # Verify extra Gov vars copied
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result[f'v0/token/{self.idTSLA}/dfip2203'], 'true')
+        assert_equal(result[f'v0/token/{self.idTSLA}/loan_payback/{self.idDUSD}'], 'true')
+        assert_equal(result[f'v0/token/{self.idGOOGL}/loan_payback/{self.idTSLA}'], 'true')
+        assert_equal(result[f'v0/token/{self.idTSLA}/loan_payback/{self.idTSLA}'], 'true')
+        assert_equal(result[f'v0/token/{self.idTSLA}/loan_payback_fee_pct/{self.idDUSD}'], '0.25')
+        assert_equal(result[f'v0/token/{self.idGOOGL}/loan_payback_fee_pct/{self.idTSLA}'], '0.25')
+        assert_equal(result[f'v0/token/{self.idTSLA}/loan_payback_fee_pct/{self.idTSLA}'], '0.25')
+
+        # Check new balances
+        for [address, amount] in funded_addresses:
+            account = self.nodes[0].getaccount(address)
+            new_amount = Decimal(account[0].split('@')[0])
+            assert_equal(new_amount, amount * 2)
+
+        # Token split
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{str(self.nodes[0].getblockcount() + 2)}':f'{self.idTSLA}/-3'}})
+        self.nodes[0].generate(2)
+
+        # Check new balances
+        minted = Decimal('0')
+        for [address, amount] in funded_addresses:
+            account = self.nodes[0].getaccount(address)
+            amount_scaled = Decimal(truncate(str(amount * 2 / 3), 8))
+            new_amount = Decimal(account[0].split('@')[0])
+            assert_equal(new_amount, amount_scaled)
+            minted += new_amount
+
+        # Check token split correctly
+        self.check_token_split(self.idTSLA, self.symbolTSLA, '/v2', -3, minted, True, True)
+
+        # Swap old for new values
+        self.idTSLA = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+
+        # Unlock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'false'}})
+        self.nodes[0].generate(1)
+
+    def pool_split(self):
+
+        # Check pool before split
+        result = self.nodes[0].getpoolpair(self.idGD)[self.idGD]
+        assert_equal(result['reserveA'], self.poolGDTotal)
+        assert_equal(result['reserveB'], self.poolGDTotal)
+        assert_equal(result['reserveA/reserveB'], Decimal('1.00000000'))
+        assert_equal(result['reserveB/reserveA'], Decimal('1.00000000'))
+        assert_equal(result['status'], True)
+        assert_equal(result['tradeEnabled'], True)
+        assert_equal(result['dexFeePctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['dexFeePctTokenB'], Decimal('0.03000000'))
+        assert_equal(result['dexFeeInPctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['dexFeeOutPctTokenA'], Decimal('0.01000000'))
+        assert_equal(result['rewardPct'], Decimal('1.00000000'))
+        assert_equal(result['rewardLoanPct'], Decimal('1.00000000'))
+
+        # Lock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idGOOGL}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Token split
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{str(self.nodes[0].getblockcount() + 2)}':f'{self.idGOOGL}/2'}})
+        self.nodes[0].generate(2)
+
+        # Check token split correctly
+        self.check_token_split(self.idGOOGL, self.symbolGOOGL, '/v1', 2, str(self.poolGDTotal * 2), False, True)
+
+        # Check pool migrated successfully
+        self.check_pool_split(self.idGD, self.symbolGD, self.idGOOGL, self.symbolGOOGL, '/v1', self.poolGDTotal * 2, Decimal('2.00000000'), Decimal('0.50000000'))
+
+        # Swap old for new values
+        self.idGOOGL = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+        self.idGD = list(self.nodes[0].gettoken(self.symbolGD).keys())[0]
+
+        # Token split
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{str(self.nodes[0].getblockcount() + 2)}':f'{self.idGOOGL}/-3'}})
+        self.nodes[0].generate(2)
+
+        # Check token split correctly
+        minted = truncate(str(self.poolGDTotal * 2 / 3), 8)
+        self.check_token_split(self.idGOOGL, self.symbolGOOGL, '/v2', -3, minted, False, True)
+
+        # Check pool migrated successfully
+        self.check_pool_split(self.idGD, self.symbolGD, self.idGOOGL, self.symbolGOOGL, '/v2', minted, Decimal('0.66666666'), Decimal('1.50000000'))
+
+        # Swap old for new values
+        self.idGOOGL = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+
+        # Unlock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idGOOGL}':'false'}})
+        self.nodes[0].generate(1)
+
+    def execute_vault_split(self, token_id, token_symbol, multiplier, suffix):
+
+        # Get total minted
+        if multiplier < 0:
+            minted = truncate(str(self.nodes[0].gettoken(token_id)[token_id]['minted'] / abs(multiplier)), 8)
+        else:
+            minted = self.nodes[0].gettoken(token_id)[token_id]['minted'] * multiplier
+
+        # Lock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{token_id}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Token split
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{str(self.nodes[0].getblockcount() + 2)}':f'{token_id}/{multiplier}'}})
+        self.nodes[0].generate(1)
+
+        # Vault array
+        self.vault_balances = []
+
+        # Gather pre-split info to compare later
+        pre_get_interest = self.nodes[0].getinterest('LOAN0001', 'NVDA')[0]
+        for vault_info in self.nodes[0].listvaults():
+            if self.skip_vault != vault_info['vaultId']:
+                vault = self.nodes[0].getvault(vault_info['vaultId'])
+                self.vault_balances.append([vault_info['vaultId'], vault])
+
+        # Move to split block
+        self.nodes[0].generate(1)
+
+        # Check token split correctly
+        self.check_token_split(token_id, token_symbol, suffix, multiplier, str(minted), True, False)
+
+        # Compare pre-split vaults with post-split vaults
+        for [vault_id, pre_vault] in self.vault_balances:
+            post_vault = self.nodes[0].getvault(vault_id)
+            pre_interest = Decimal(pre_vault['interestAmounts'][0].split('@')[0])
+            post_interest = Decimal(post_vault['interestAmounts'][0].split('@')[0])
+            pre_loan_amount = Decimal(pre_vault['loanAmounts'][0].split('@')[0]) - pre_interest
+            post_loan_amount = Decimal(post_vault['loanAmounts'][0].split('@')[0]) - post_interest
+            if multiplier < 0:
+                pre_loan_scaled = Decimal(truncate(str(pre_loan_amount / abs(multiplier)), 8))
+            else:
+                pre_loan_scaled = pre_loan_amount * multiplier
+            assert_equal(post_loan_amount, pre_loan_scaled)
+
+        # Check interest has changed as expected
+        post_get_interest = self.nodes[0].getinterest('LOAN0001', 'NVDA')[0]
+        if multiplier < 0:
+            expected_interest = Decimal(truncate(str(pre_get_interest['interestPerBlock'] / abs(multiplier)), 8))
+        else:
+            expected_interest = pre_get_interest['interestPerBlock'] * multiplier
+        current_interest = post_get_interest['interestPerBlock']
+        current_interest_round = current_interest + Decimal('0.00000001')
+        expected_interest_round = expected_interest + Decimal('0.00000001')
+        if current_interest != expected_interest and current_interest_round != expected_interest:
+            assert_equal(current_interest, expected_interest_round)
+
+        # Swap old for new values
+        token_id = list(self.nodes[0].gettoken(token_symbol).keys())[0]
+
+        # Unlock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{token_id}':'false'}})
+        self.nodes[0].generate(1)
+
+    def vault_split(self):
+
+        # Create vault to test split after payback
+        self.skip_vault = self.nodes[0].createvault(self.address, '')
+        self.nodes[0].generate(1)
+
+        # Deposit to vault
+        self.nodes[0].deposittovault(self.skip_vault, self.address, f'100@{self.symbolDFI}')
+        self.nodes[0].generate(1)
+
+        # Take loan
+        self.nodes[0].takeloan({
+            'vaultId': self.skip_vault,
+            'amounts': f'100@{self.symbolNVDA}'
+        })
+        self.nodes[0].generate(1)
+
+        # Payback loan
+        result = self.nodes[0].getvault(self.skip_vault)
+        self.nodes[0].paybackloan({
+            'vaultId': self.skip_vault,
+            'from': self.address,
+            'amounts': result['loanAmounts'][0]
+        })
+        self.nodes[0].generate(1)
+
+        # Multiplier 2
+        self.execute_vault_split(self.idNVDA, self.symbolNVDA, 2, '/v1')
+
+        # Swap old for new values
+        self.idNVDA = list(self.nodes[0].gettoken(self.symbolNVDA).keys())[0]
+
+        # Multiplier -3
+        self.execute_vault_split(self.idNVDA, self.symbolNVDA, -3, '/v2')
+
+        # Swap old for new values
+        self.idNVDA = list(self.nodes[0].gettoken(self.symbolNVDA).keys())[0]
+
+    def check_govvar_deletion(self):
+        # Lock token
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/locks/token/{self.idTSLA}':'true'}})
+        self.nodes[0].generate(1)
+
+        # Token split
+        split_height = self.nodes[0].getblockcount() + 2
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/{split_height}':f'{self.idTSLA}/2'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/oracles/splits/500000':f'{self.idTSLA}/2'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/oracles/splits/1000000':f'{self.idTSLA}/2'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/oracles/splits/1000000':f'{self.idNVDA}/2'}})
+        self.nodes[0].generate(1)
+
+        # Check splits
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert_equal(result[f'v0/oracles/splits/{split_height}'], f'{self.idTSLA}/2,')
+        assert_equal(result[f'v0/oracles/splits/500000'], f'{self.idTSLA}/2,')
+        assert_equal(result[f'v0/oracles/splits/1000000'], f'{self.idTSLA}/2,{self.idNVDA}/2,')
+
+        # Split
+        self.nodes[0].generate(1)
+
+        # Check TSLA entries removed
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert(f'v0/oracles/splits/{split_height}' not in result)
+        assert(f'v0/oracles/splits/500000' not in result)
+        assert_equal(result[f'v0/oracles/splits/1000000'], f'{self.idNVDA}/2,')
+
+        # Swap old for new values
+        self.idTSLA = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+
+if __name__ == '__main__':
+    TokenSplitTest().main()
+
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index cb037f3d3fa..1b316d0aeb8 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -136,6 +136,7 @@ def _test_getblockchaininfo(self):
             'fortcanningpark': {'type': 'buried', 'active': False, 'height': 10000000},
             'fortcanninghill': {'type': 'buried', 'active': False, 'height': 10000000},
             'fortcanningroad': {'type': 'buried', 'active': False, 'height': 10000000},
+            'greatworld': {'type': 'buried', 'active': False, 'height': 10000000},
             'testdummy': {
                 'type': 'bip9',
                 'bip9': {
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 1ce58f730c6..6efd3e6990d 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -122,6 +122,7 @@
     'feature_lock_unspends.py',
     'feature_bitcoin_wallet.py',
     'feature_bitcoin_htlc.py',
+    'feature_token_split.py',
     'feature_communitybalance_reorg.py',
     'feature_auth_return_change.py',
     'feature_setgov.py',
@@ -242,6 +243,7 @@
     'wallet_resendwallettransactions.py',
     'feature_custom_poolreward.py',
     'wallet_fallbackfee.py',
+    'feature_token_lock.py',
     'feature_minchainwork.py',
     'rpc_getblockstats.py',
     'feature_median_time.py',
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 785c924d856..68111416af6 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -36,6 +36,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "masternodes/anchors -> spv/spv_wrapper -> masternodes/anchors"
     "masternodes/anchors -> validation -> masternodes/anchors"
     "masternodes/govvariables/attributes -> masternodes/gv -> masternodes/govvariables/attributes"
+    "masternodes/govvariables/attributes -> masternodes/masternodes -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/masternodes -> validation -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/mn_checks -> masternodes/govvariables/attributes"
     "masternodes/govvariables/icx_takerfee_per_btc -> masternodes/gv -> masternodes/govvariables/icx_takerfee_per_btc"
@@ -43,12 +44,15 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "masternodes/govvariables/loan_daily_reward -> masternodes/masternodes -> validation -> masternodes/govvariables/loan_daily_reward"
     "masternodes/govvariables/loan_liquidation_penalty -> masternodes/gv -> masternodes/govvariables/loan_liquidation_penalty"
     "masternodes/govvariables/loan_splits -> masternodes/gv -> masternodes/govvariables/loan_splits"
+    "masternodes/govvariables/loan_splits -> masternodes/masternodes -> validation -> masternodes/govvariables/loan_splits"
     "masternodes/govvariables/lp_daily_dfi_reward -> masternodes/gv -> masternodes/govvariables/lp_daily_dfi_reward"
     "masternodes/govvariables/lp_daily_dfi_reward -> masternodes/masternodes -> validation -> masternodes/govvariables/lp_daily_dfi_reward"
     "masternodes/govvariables/lp_splits -> masternodes/gv -> masternodes/govvariables/lp_splits"
+    "masternodes/govvariables/lp_splits -> masternodes/masternodes -> validation -> masternodes/govvariables/lp_splits"
     "masternodes/govvariables/oracle_block_interval -> masternodes/gv -> masternodes/govvariables/oracle_block_interval"
     "masternodes/govvariables/oracle_block_interval -> masternodes/masternodes -> masternodes/mn_checks -> masternodes/govvariables/oracle_block_interval"
     "masternodes/govvariables/oracle_deviation -> masternodes/gv -> masternodes/govvariables/oracle_deviation"
+    "masternodes/loan -> masternodes/masternodes -> masternodes/loan"
     "masternodes/masternodes -> masternodes/mn_checks -> masternodes/masternodes"
     "masternodes/masternodes -> masternodes/mn_checks -> masternodes/vaulthistory -> masternodes/masternodes"
     "masternodes/masternodes -> masternodes/oracles -> masternodes/masternodes"
diff --git a/test/lint/lint-locale-dependence.sh b/test/lint/lint-locale-dependence.sh
index 5103e2b6af7..67040293add 100755
--- a/test/lint/lint-locale-dependence.sh
+++ b/test/lint/lint-locale-dependence.sh
@@ -22,6 +22,8 @@ KNOWN_VIOLATIONS=(
     "src/util/strencodings.cpp:.*strtoul"
     "src/util/strencodings.h:.*atoi"
     "src/util/system.cpp:.*atoi"
+    "src/validation.cpp:.*stoi"
+    "src/masternodes/govvariables/attributes.cpp:.*isspace"
 )
 
 REGEXP_IGNORE_EXTERNAL_DEPENDENCIES="^src/(crypto/ctaes/|leveldb/|secp256k1/|tinyformat.h|univalue|spv/)"