From 25ab35d0db9936ec048b9c4fd498d664e3c17a2d Mon Sep 17 00:00:00 2001
From: Prasanna Loganathar <pvl@prasannavl.com>
Date: Thu, 24 Nov 2022 18:00:19 +0800
Subject: [PATCH] Enable clang-format on existing code  (#1593)

* Add clang format 14

* Fix log lints to be more friendly to auto format

* Run clang-format-14 on src/masternodes

* masternodes.h: Add exception block

* Config update: AccessModifierOffset

* Update format
---
 src/masternodes/.clang-format                 |  225 ++
 src/masternodes/accounts.cpp                  |   73 +-
 src/masternodes/accounts.h                    |   82 +-
 src/masternodes/accountshistory.cpp           |  138 +-
 src/masternodes/accountshistory.h             |   92 +-
 src/masternodes/anchors.cpp                   |  604 ++--
 src/masternodes/anchors.h                     |  399 ++-
 src/masternodes/auctionhistory.cpp            |   18 +-
 src/masternodes/auctionhistory.h              |   23 +-
 src/masternodes/balances.h                    |   77 +-
 src/masternodes/communityaccounttypes.h       |   19 +-
 src/masternodes/factory.h                     |   24 +-
 src/masternodes/govvariables/attributes.cpp   | 1186 ++++----
 src/masternodes/govvariables/attributes.h     |  372 +--
 .../govvariables/icx_takerfee_per_btc.cpp     |   24 +-
 .../govvariables/icx_takerfee_per_btc.h       |   23 +-
 .../govvariables/loan_daily_reward.cpp        |   24 +-
 .../govvariables/loan_daily_reward.h          |   23 +-
 .../govvariables/loan_liquidation_penalty.cpp |   24 +-
 .../govvariables/loan_liquidation_penalty.h   |   23 +-
 src/masternodes/govvariables/loan_splits.cpp  |   39 +-
 src/masternodes/govvariables/loan_splits.h    |   23 +-
 .../govvariables/lp_daily_dfi_reward.cpp      |   24 +-
 .../govvariables/lp_daily_dfi_reward.h        |   23 +-
 src/masternodes/govvariables/lp_splits.cpp    |   43 +-
 src/masternodes/govvariables/lp_splits.h      |   25 +-
 .../govvariables/oracle_block_interval.cpp    |   24 +-
 .../govvariables/oracle_block_interval.h      |   23 +-
 .../govvariables/oracle_deviation.cpp         |   24 +-
 .../govvariables/oracle_deviation.h           |   23 +-
 src/masternodes/gv.cpp                        |   35 +-
 src/masternodes/gv.h                          |   64 +-
 src/masternodes/icxorder.cpp                  |  290 +-
 src/masternodes/icxorder.h                    |  400 +--
 src/masternodes/incentivefunding.cpp          |   25 +-
 src/masternodes/incentivefunding.h            |   39 +-
 src/masternodes/loan.cpp                      |  353 ++-
 src/masternodes/loan.h                        |  322 ++-
 src/masternodes/masternodes.cpp               |  712 +++--
 src/masternodes/masternodes.h                 |  383 +--
 src/masternodes/mn_checks.cpp                 | 2471 +++++++++--------
 src/masternodes/mn_checks.h                   |  438 +--
 src/masternodes/mn_rpc.h                      |   65 +-
 src/masternodes/oracles.cpp                   |  116 +-
 src/masternodes/oracles.h                     |   90 +-
 src/masternodes/poolpairs.cpp                 |  392 +--
 src/masternodes/poolpairs.h                   |  211 +-
 src/masternodes/proposals.cpp                 |  155 +-
 src/masternodes/proposals.h                   |   90 +-
 src/masternodes/res.h                         |   65 +-
 src/masternodes/rpc_customtx.cpp              |  272 +-
 src/masternodes/rpc_poolpair.cpp              | 1125 ++++----
 src/masternodes/skipped_txs.cpp               |    9 +-
 src/masternodes/tokens.cpp                    |  128 +-
 src/masternodes/tokens.h                      |  149 +-
 src/masternodes/undo.h                        |   26 +-
 src/masternodes/undos.cpp                     |   13 +-
 src/masternodes/undos.h                       |   17 +-
 src/masternodes/vault.cpp                     |   93 +-
 src/masternodes/vault.h                       |  116 +-
 src/masternodes/vaulthistory.cpp              |   53 +-
 src/masternodes/vaulthistory.h                |   88 +-
 test/lint/lint-logs.sh                        |    3 +-
 63 files changed, 6599 insertions(+), 5953 deletions(-)
 create mode 100644 src/masternodes/.clang-format

diff --git a/src/masternodes/.clang-format b/src/masternodes/.clang-format
new file mode 100644
index 0000000000..6e988cfb1c
--- /dev/null
+++ b/src/masternodes/.clang-format
@@ -0,0 +1,225 @@
+---
+Language:        Cpp
+# BasedOnStyle:  Chromium
+# With changes on 
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: Left
+AlignConsecutiveMacros: false
+AlignConsecutiveAssignments: true
+AlignConsecutiveBitFields: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Left
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: Never
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+PPIndentWidth:   -1
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
+ReferenceAlignment: Pointer
+ReflowComments:  true
+RemoveBracesLLVM: false
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
diff --git a/src/masternodes/accounts.cpp b/src/masternodes/accounts.cpp
index 3e578d026a..0d36ca9d61 100644
--- a/src/masternodes/accounts.cpp
+++ b/src/masternodes/accounts.cpp
@@ -4,15 +4,16 @@
 
 #include <masternodes/accounts.h>
 
-void CAccountsView::ForEachBalance(std::function<bool(CScript const &, CTokenAmount const &)> callback, BalanceKey const & start)
-{
-    ForEach<ByBalanceKey, BalanceKey, CAmount>([&callback] (BalanceKey const & key, CAmount val) {
-        return callback(key.owner, CTokenAmount{key.tokenID, val});
-    }, start);
+void CAccountsView::ForEachBalance(std::function<bool(const CScript &, const CTokenAmount &)> callback,
+                                   const BalanceKey &start) {
+    ForEach<ByBalanceKey, BalanceKey, CAmount>(
+        [&callback](const BalanceKey &key, CAmount val) {
+            return callback(key.owner, CTokenAmount{key.tokenID, val});
+        },
+        start);
 }
 
-CTokenAmount CAccountsView::GetBalance(CScript const & owner, DCT_ID tokenID) const
-{
+CTokenAmount CAccountsView::GetBalance(const CScript &owner, DCT_ID tokenID) const {
     CAmount val;
     bool ok = ReadBy<ByBalanceKey>(BalanceKey{owner, tokenID}, val);
     if (ok) {
@@ -21,8 +22,7 @@ CTokenAmount CAccountsView::GetBalance(CScript const & owner, DCT_ID tokenID) co
     return CTokenAmount{tokenID, 0};
 }
 
-Res CAccountsView::SetBalance(CScript const & owner, CTokenAmount amount)
-{
+Res CAccountsView::SetBalance(const CScript &owner, CTokenAmount amount) {
     if (amount.nValue != 0) {
         WriteBy<ByBalanceKey>(BalanceKey{owner, amount.nTokenId}, amount.nValue);
     } else {
@@ -31,35 +31,32 @@ Res CAccountsView::SetBalance(CScript const & owner, CTokenAmount amount)
     return Res::Ok();
 }
 
-Res CAccountsView::AddBalance(CScript const & owner, CTokenAmount amount)
-{
+Res CAccountsView::AddBalance(const CScript &owner, CTokenAmount amount) {
     if (amount.nValue == 0) {
         return Res::Ok();
     }
     auto balance = GetBalance(owner, amount.nTokenId);
-    auto res = balance.Add(amount.nValue);
+    auto res     = balance.Add(amount.nValue);
     if (!res.ok) {
         return res;
     }
     return SetBalance(owner, balance);
 }
 
-Res CAccountsView::SubBalance(CScript const & owner, CTokenAmount amount)
-{
+Res CAccountsView::SubBalance(const CScript &owner, CTokenAmount amount) {
     if (amount.nValue == 0) {
         return Res::Ok();
     }
     auto balance = GetBalance(owner, amount.nTokenId);
-    auto res = balance.Sub(amount.nValue);
+    auto res     = balance.Sub(amount.nValue);
     if (!res.ok) {
         return res;
     }
     return SetBalance(owner, balance);
 }
 
-Res CAccountsView::AddBalances(CScript const & owner, CBalances const & balances)
-{
-    for (const auto& kv : balances.balances) {
+Res CAccountsView::AddBalances(const CScript &owner, const CBalances &balances) {
+    for (const auto &kv : balances.balances) {
         auto res = AddBalance(owner, CTokenAmount{kv.first, kv.second});
         if (!res.ok) {
             return res;
@@ -68,9 +65,8 @@ Res CAccountsView::AddBalances(CScript const & owner, CBalances const & balances
     return Res::Ok();
 }
 
-Res CAccountsView::SubBalances(CScript const & owner, CBalances const & balances)
-{
-    for (const auto& kv : balances.balances) {
+Res CAccountsView::SubBalances(const CScript &owner, const CBalances &balances) {
+    for (const auto &kv : balances.balances) {
         auto res = SubBalance(owner, CTokenAmount{kv.first, kv.second});
         if (!res.ok) {
             return res;
@@ -79,28 +75,23 @@ Res CAccountsView::SubBalances(CScript const & owner, CBalances const & balances
     return Res::Ok();
 }
 
-void CAccountsView::ForEachAccount(std::function<bool(CScript const &)> callback, CScript const & start)
-{
-    ForEach<ByHeightKey, CScript, uint32_t>([&callback] (CScript const & owner, CLazySerialize<uint32_t>) {
-        return callback(owner);
-    }, start);
+void CAccountsView::ForEachAccount(std::function<bool(const CScript &)> callback, const CScript &start) {
+    ForEach<ByHeightKey, CScript, uint32_t>(
+        [&callback](const CScript &owner, CLazySerialize<uint32_t>) { return callback(owner); }, start);
 }
 
-Res CAccountsView::UpdateBalancesHeight(CScript const & owner, uint32_t height)
-{
+Res CAccountsView::UpdateBalancesHeight(const CScript &owner, uint32_t height) {
     WriteBy<ByHeightKey>(owner, height);
     return Res::Ok();
 }
 
-uint32_t CAccountsView::GetBalancesHeight(CScript const & owner)
-{
+uint32_t CAccountsView::GetBalancesHeight(const CScript &owner) {
     uint32_t height;
     bool ok = ReadBy<ByHeightKey>(owner, height);
     return ok ? height : 0;
 }
 
-Res CAccountsView::StoreFuturesUserValues(const CFuturesUserKey& key, const CFuturesUserValue& futures)
-{
+Res CAccountsView::StoreFuturesUserValues(const CFuturesUserKey &key, const CFuturesUserValue &futures) {
     if (!WriteBy<ByFuturesSwapKey>(key, futures)) {
         return Res::Err("Failed to store futures");
     }
@@ -108,13 +99,13 @@ Res CAccountsView::StoreFuturesUserValues(const CFuturesUserKey& key, const CFut
     return Res::Ok();
 }
 
-void CAccountsView::ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start)
-{
+void CAccountsView::ForEachFuturesUserValues(
+    std::function<bool(const CFuturesUserKey &, const CFuturesUserValue &)> callback,
+    const CFuturesUserKey &start) {
     ForEach<ByFuturesSwapKey, CFuturesUserKey, CFuturesUserValue>(callback, start);
 }
 
-Res CAccountsView::EraseFuturesUserValues(const CFuturesUserKey& key)
-{
+Res CAccountsView::EraseFuturesUserValues(const CFuturesUserKey &key) {
     if (!EraseBy<ByFuturesSwapKey>(key)) {
         return Res::Err("Failed to erase futures");
     }
@@ -122,8 +113,7 @@ Res CAccountsView::EraseFuturesUserValues(const CFuturesUserKey& key)
     return Res::Ok();
 }
 
-Res CAccountsView::StoreFuturesDUSD(const CFuturesUserKey& key, const CAmount& amount)
-{
+Res CAccountsView::StoreFuturesDUSD(const CFuturesUserKey &key, const CAmount &amount) {
     if (!WriteBy<ByFuturesDUSDKey>(key, amount)) {
         return Res::Err("Failed to store futures");
     }
@@ -131,13 +121,12 @@ Res CAccountsView::StoreFuturesDUSD(const CFuturesUserKey& key, const CAmount& a
     return Res::Ok();
 }
 
-void CAccountsView::ForEachFuturesDUSD(std::function<bool(const CFuturesUserKey&, const CAmount&)> callback, const CFuturesUserKey& start)
-{
+void CAccountsView::ForEachFuturesDUSD(std::function<bool(const CFuturesUserKey &, const CAmount &)> callback,
+                                       const CFuturesUserKey &start) {
     ForEach<ByFuturesDUSDKey, CFuturesUserKey, CAmount>(callback, start);
 }
 
-Res CAccountsView::EraseFuturesDUSD(const CFuturesUserKey& key)
-{
+Res CAccountsView::EraseFuturesDUSD(const CFuturesUserKey &key) {
     if (!EraseBy<ByFuturesDUSDKey>(key)) {
         return Res::Err("Failed to erase futures");
     }
diff --git a/src/masternodes/accounts.h b/src/masternodes/accounts.h
index 54d1a8a100..5502657fda 100644
--- a/src/masternodes/accounts.h
+++ b/src/masternodes/accounts.h
@@ -5,10 +5,10 @@
 #ifndef DEFI_MASTERNODES_ACCOUNTS_H
 #define DEFI_MASTERNODES_ACCOUNTS_H
 
+#include <amount.h>
 #include <flushablestorage.h>
-#include <masternodes/res.h>
 #include <masternodes/balances.h>
-#include <amount.h>
+#include <masternodes/res.h>
 #include <script/script.h>
 
 struct CFuturesUserKey {
@@ -19,7 +19,7 @@ struct CFuturesUserKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(height));
             height = ~height;
@@ -35,7 +35,7 @@ struct CFuturesUserKey {
         }
     }
 
-    bool operator<(const CFuturesUserKey& o) const {
+    bool operator<(const CFuturesUserKey &o) const {
         return std::tie(height, owner, txn) < std::tie(o.height, o.owner, o.txn);
     }
 };
@@ -47,46 +47,58 @@ struct CFuturesUserValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(source);
         READWRITE(destination);
     }
 };
 
-class CAccountsView : public virtual CStorageView
-{
+class CAccountsView : public virtual CStorageView {
 public:
-    void ForEachAccount(std::function<bool(CScript const &)> callback, CScript const & start = {});
-    void ForEachBalance(std::function<bool(CScript const &, CTokenAmount const &)> callback, BalanceKey const & start = {});
-    CTokenAmount GetBalance(CScript const & owner, DCT_ID tokenID) const;
-
-    virtual Res AddBalance(CScript const & owner, CTokenAmount amount);
-    virtual Res SubBalance(CScript const & owner, CTokenAmount amount);
-
-    Res AddBalances(CScript const & owner, CBalances const & balances);
-    Res SubBalances(CScript const & owner, CBalances const & balances);
-
-    uint32_t GetBalancesHeight(CScript const & owner);
-    Res UpdateBalancesHeight(CScript const & owner, uint32_t height);
-
-    Res StoreFuturesUserValues(const CFuturesUserKey& key, const CFuturesUserValue& futures);
-    Res EraseFuturesUserValues(const CFuturesUserKey& key);
-    void ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start =
-            {std::numeric_limits<uint32_t>::max(), {}, std::numeric_limits<uint32_t>::max()});
-
-    Res StoreFuturesDUSD(const CFuturesUserKey& key, const CAmount& amount);
-    Res EraseFuturesDUSD(const CFuturesUserKey& key);
-    void ForEachFuturesDUSD(std::function<bool(const CFuturesUserKey&, const CAmount&)> callback, const CFuturesUserKey& start =
-            {std::numeric_limits<uint32_t>::max(), {}, std::numeric_limits<uint32_t>::max()});
+    void ForEachAccount(std::function<bool(const CScript &)> callback, const CScript &start = {});
+    void ForEachBalance(std::function<bool(const CScript &, const CTokenAmount &)> callback,
+                        const BalanceKey &start = {});
+    CTokenAmount GetBalance(const CScript &owner, DCT_ID tokenID) const;
+
+    virtual Res AddBalance(const CScript &owner, CTokenAmount amount);
+    virtual Res SubBalance(const CScript &owner, CTokenAmount amount);
+
+    Res AddBalances(const CScript &owner, const CBalances &balances);
+    Res SubBalances(const CScript &owner, const CBalances &balances);
+
+    uint32_t GetBalancesHeight(const CScript &owner);
+    Res UpdateBalancesHeight(const CScript &owner, uint32_t height);
+
+    Res StoreFuturesUserValues(const CFuturesUserKey &key, const CFuturesUserValue &futures);
+    Res EraseFuturesUserValues(const CFuturesUserKey &key);
+    void ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey &, const CFuturesUserValue &)> callback,
+                                  const CFuturesUserKey &start = {std::numeric_limits<uint32_t>::max(),
+                                                                  {},
+                                                                  std::numeric_limits<uint32_t>::max()});
+
+    Res StoreFuturesDUSD(const CFuturesUserKey &key, const CAmount &amount);
+    Res EraseFuturesDUSD(const CFuturesUserKey &key);
+    void ForEachFuturesDUSD(std::function<bool(const CFuturesUserKey &, const CAmount &)> callback,
+                            const CFuturesUserKey &start = {std::numeric_limits<uint32_t>::max(),
+                                                            {},
+                                                            std::numeric_limits<uint32_t>::max()});
 
     // tags
-    struct ByBalanceKey { static constexpr uint8_t prefix() { return 'a'; } };
-    struct ByHeightKey  { static constexpr uint8_t prefix() { return 'b'; } };
-    struct ByFuturesSwapKey  { static constexpr uint8_t prefix() { return 'J'; } };
-    struct ByFuturesDUSDKey  { static constexpr uint8_t prefix() { return 'm'; } };
+    struct ByBalanceKey {
+        static constexpr uint8_t prefix() { return 'a'; }
+    };
+    struct ByHeightKey {
+        static constexpr uint8_t prefix() { return 'b'; }
+    };
+    struct ByFuturesSwapKey {
+        static constexpr uint8_t prefix() { return 'J'; }
+    };
+    struct ByFuturesDUSDKey {
+        static constexpr uint8_t prefix() { return 'm'; }
+    };
 
 private:
-    Res SetBalance(CScript const & owner, CTokenAmount amount);
+    Res SetBalance(const CScript &owner, CTokenAmount amount);
 };
 
-#endif //DEFI_MASTERNODES_ACCOUNTS_H
+#endif  // DEFI_MASTERNODES_ACCOUNTS_H
diff --git a/src/masternodes/accountshistory.cpp b/src/masternodes/accountshistory.cpp
index b6814cd417..607dfd6a57 100644
--- a/src/masternodes/accountshistory.cpp
+++ b/src/masternodes/accountshistory.cpp
@@ -2,21 +2,21 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-#include <masternodes/accountshistory.h>
+#include <key_io.h>
 #include <masternodes/accounts.h>
+#include <masternodes/accountshistory.h>
 #include <masternodes/masternodes.h>
 #include <masternodes/vaulthistory.h>
-#include <key_io.h>
 
 struct AccountHistoryKeyNew {
     uint32_t blockHeight;
     CScript owner;
-    uint32_t txn; // for order in block
+    uint32_t txn;  // for order in block
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
@@ -37,16 +37,15 @@ struct AccountHistoryKeyNew {
     }
 };
 
-static AccountHistoryKeyNew Convert(AccountHistoryKey const & key) {
+static AccountHistoryKeyNew Convert(const AccountHistoryKey &key) {
     return {key.blockHeight, key.owner, key.txn};
 }
 
-static AccountHistoryKey Convert(AccountHistoryKeyNew const & key) {
+static AccountHistoryKey Convert(const AccountHistoryKeyNew &key) {
     return {key.owner, key.blockHeight, key.txn};
 }
 
-void CAccountsHistoryView::CreateMultiIndexIfNeeded()
-{
+void CAccountsHistoryView::CreateMultiIndexIfNeeded() {
     AccountHistoryKeyNew anyNewKey{~0u, {}, ~0u};
     if (auto it = LowerBound<ByAccountHistoryKeyNew>(anyNewKey); it.Valid()) {
         return;
@@ -67,43 +66,43 @@ void CAccountsHistoryView::CreateMultiIndexIfNeeded()
     LogPrint(BCLog::BENCH, "    - Multi index took: %dms\n", GetTimeMillis() - startTime);
 }
 
-void CAccountsHistoryView::ForEachAccountHistory(std::function<bool(AccountHistoryKey const &, AccountHistoryValue)> callback,
-                                                 const CScript & owner, uint32_t height, uint32_t txn)
-{
+void CAccountsHistoryView::ForEachAccountHistory(
+    std::function<bool(const AccountHistoryKey &, AccountHistoryValue)> callback,
+    const CScript &owner,
+    uint32_t height,
+    uint32_t txn) {
     if (!owner.empty()) {
         ForEach<ByAccountHistoryKey, AccountHistoryKey, AccountHistoryValue>(callback, {owner, height, txn});
         return;
     }
 
-    ForEach<ByAccountHistoryKeyNew, AccountHistoryKeyNew, char>([&](AccountHistoryKeyNew const & newKey, char) {
-        auto key = Convert(newKey);
-        auto value = ReadAccountHistory(key);
-        assert(value);
-        return callback(key, *value);
-    }, {height, owner, txn});
+    ForEach<ByAccountHistoryKeyNew, AccountHistoryKeyNew, char>(
+        [&](const AccountHistoryKeyNew &newKey, char) {
+            auto key   = Convert(newKey);
+            auto value = ReadAccountHistory(key);
+            assert(value);
+            return callback(key, *value);
+        },
+        {height, owner, txn});
 }
 
-std::optional<AccountHistoryValue> CAccountsHistoryView::ReadAccountHistory(AccountHistoryKey const & key) const
-{
+std::optional<AccountHistoryValue> CAccountsHistoryView::ReadAccountHistory(const AccountHistoryKey &key) const {
     return ReadBy<ByAccountHistoryKey, AccountHistoryValue>(key);
 }
 
-Res CAccountsHistoryView::WriteAccountHistory(const AccountHistoryKey& key, const AccountHistoryValue& value)
-{
+Res CAccountsHistoryView::WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value) {
     WriteBy<ByAccountHistoryKey>(key, value);
     WriteBy<ByAccountHistoryKeyNew>(Convert(key), '\0');
     return Res::Ok();
 }
 
-Res CAccountsHistoryView::EraseAccountHistory(const AccountHistoryKey& key)
-{
+Res CAccountsHistoryView::EraseAccountHistory(const AccountHistoryKey &key) {
     EraseBy<ByAccountHistoryKey>(key);
     EraseBy<ByAccountHistoryKeyNew>(Convert(key));
     return Res::Ok();
 }
 
-Res CAccountsHistoryView::EraseAccountHistoryHeight(uint32_t height)
-{
+Res CAccountsHistoryView::EraseAccountHistoryHeight(uint32_t height) {
     std::vector<AccountHistoryKey> keysToDelete;
 
     auto it = LowerBound<ByAccountHistoryKeyNew>(AccountHistoryKeyNew{height, {}, ~0u});
@@ -111,31 +110,32 @@ Res CAccountsHistoryView::EraseAccountHistoryHeight(uint32_t height)
         keysToDelete.push_back(Convert(it.Key()));
     }
 
-    for (const auto& key : keysToDelete) {
+    for (const auto &key : keysToDelete) {
         EraseAccountHistory(key);
     }
     return Res::Ok();
 }
 
-CAccountHistoryStorage::CAccountHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
-    : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
-{
-}
+CAccountHistoryStorage::CAccountHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
+    : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe)) {}
 
-CBurnHistoryStorage::CBurnHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
-    : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
-{
-}
+CBurnHistoryStorage::CBurnHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
+    : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe)) {}
 
-CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type,
-                                               CHistoryWriters* writers)
-    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV&>(storage.GetStorage()))), height(height), txn(txn),
-    txid(txid), type(type), writers(writers)
-{
-}
+CAccountsHistoryWriter::CAccountsHistoryWriter(CCustomCSView &storage,
+                                               uint32_t height,
+                                               uint32_t txn,
+                                               const uint256 &txid,
+                                               uint8_t type,
+                                               CHistoryWriters *writers)
+    : CStorageView(new CFlushableStorageKV(static_cast<CStorageKV &>(storage.GetStorage()))),
+      height(height),
+      txn(txn),
+      txid(txid),
+      type(type),
+      writers(writers) {}
 
-Res CAccountsHistoryWriter::AddBalance(CScript const & owner, CTokenAmount amount)
-{
+Res CAccountsHistoryWriter::AddBalance(const CScript &owner, CTokenAmount amount) {
     auto res = CCustomCSView::AddBalance(owner, amount);
     if (writers && amount.nValue != 0 && res.ok) {
         writers->AddBalance(owner, amount, vaultID);
@@ -144,8 +144,7 @@ Res CAccountsHistoryWriter::AddBalance(CScript const & owner, CTokenAmount amoun
     return res;
 }
 
-Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amount)
-{
+Res CAccountsHistoryWriter::SubBalance(const CScript &owner, CTokenAmount amount) {
     auto res = CCustomCSView::SubBalance(owner, amount);
     if (writers && res.ok && amount.nValue != 0) {
         writers->SubBalance(owner, amount, vaultID);
@@ -154,25 +153,27 @@ Res CAccountsHistoryWriter::SubBalance(CScript const & owner, CTokenAmount amoun
     return res;
 }
 
-bool CAccountsHistoryWriter::Flush()
-{
+bool CAccountsHistoryWriter::Flush() {
     if (writers) {
         writers->Flush(height, txid, txn, type, vaultID);
     }
     return CCustomCSView::Flush();
 }
 
-CAccountHistoryStorage* CAccountsHistoryWriter::GetAccountHistoryStore() {
+CAccountHistoryStorage *CAccountsHistoryWriter::GetAccountHistoryStore() {
     return writers ? writers->GetAccountHistoryStore() : nullptr;
 };
 
-CHistoryWriters::CHistoryWriters(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView)
-    : historyView(historyView), burnView(burnView), vaultView(vaultView) {}
+CHistoryWriters::CHistoryWriters(CAccountHistoryStorage *historyView,
+                                 CBurnHistoryStorage *burnView,
+                                 CVaultHistoryStorage *vaultView)
+    : historyView(historyView),
+      burnView(burnView),
+      vaultView(vaultView) {}
 
-extern std::string ScriptToString(CScript const& script);
+extern std::string ScriptToString(const CScript &script);
 
-void CHistoryWriters::AddBalance(const CScript& owner, const CTokenAmount amount, const uint256& vaultID)
-{
+void CHistoryWriters::AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
     if (historyView) {
         diffs[owner][amount.nTokenId] += amount.nValue;
     }
@@ -184,15 +185,13 @@ void CHistoryWriters::AddBalance(const CScript& owner, const CTokenAmount amount
     }
 }
 
-void CHistoryWriters::AddFeeBurn(const CScript& owner, const CAmount amount)
-{
+void CHistoryWriters::AddFeeBurn(const CScript &owner, const CAmount amount) {
     if (burnView && amount != 0) {
         burnDiffs[owner][DCT_ID{0}] += amount;
     }
 }
 
-void CHistoryWriters::SubBalance(const CScript& owner, const CTokenAmount amount, const uint256& vaultID)
-{
+void CHistoryWriters::SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID) {
     if (historyView) {
         diffs[owner][amount.nTokenId] -= amount.nValue;
     }
@@ -204,30 +203,39 @@ void CHistoryWriters::SubBalance(const CScript& owner, const CTokenAmount amount
     }
 }
 
-void CHistoryWriters::Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type, const uint256& vaultID)
-{
+void CHistoryWriters::Flush(const uint32_t height,
+                            const uint256 &txid,
+                            const uint32_t txn,
+                            const uint8_t type,
+                            const uint256 &vaultID) {
     if (historyView) {
-        for (const auto& diff : diffs) {
-            LogPrint(BCLog::ACCOUNTCHANGE, "AccountChange: txid=%s addr=%s change=%s\n", txid.GetHex(), ScriptToString(diff.first), (CBalances{diff.second}.ToString()));
+        for (const auto &diff : diffs) {
+            LogPrint(BCLog::ACCOUNTCHANGE,
+                     "AccountChange: txid=%s addr=%s change=%s\n",
+                     txid.GetHex(),
+                     ScriptToString(diff.first),
+                     (CBalances{diff.second}.ToString()));
             historyView->WriteAccountHistory({diff.first, height, txn}, {txid, type, diff.second});
         }
     }
     if (burnView) {
-        for (const auto& diff : burnDiffs) {
+        for (const auto &diff : burnDiffs) {
             burnView->WriteAccountHistory({diff.first, height, txn}, {txid, type, diff.second});
         }
     }
     if (vaultView) {
-        for (const auto& diff : vaultDiffs) {
-            for (const auto& addresses : diff.second) {
-                vaultView->WriteVaultHistory({height, diff.first, txn, addresses.first}, {txid, type, addresses.second});
+        for (const auto &diff : vaultDiffs) {
+            for (const auto &addresses : diff.second) {
+                vaultView->WriteVaultHistory({height, diff.first, txn, addresses.first},
+                                             {txid, type, addresses.second});
             }
         }
         if (!schemeID.empty()) {
             vaultView->WriteVaultScheme({vaultID, height}, {type, txid, schemeID, txn});
         }
         if (!globalLoanScheme.identifier.empty()) {
-            vaultView->WriteGlobalScheme({height, txn, globalLoanScheme.schemeCreationTxid}, {globalLoanScheme, type, txid});
+            vaultView->WriteGlobalScheme({height, txn, globalLoanScheme.schemeCreationTxid},
+                                         {globalLoanScheme, type, txid});
         }
     }
 }
diff --git a/src/masternodes/accountshistory.h b/src/masternodes/accountshistory.h
index a9c7cf2d70..4e5c53343f 100644
--- a/src/masternodes/accountshistory.h
+++ b/src/masternodes/accountshistory.h
@@ -18,12 +18,12 @@ class CVaultHistoryStorage;
 struct AccountHistoryKey {
     CScript owner;
     uint32_t blockHeight;
-    uint32_t txn; // for order in block
+    uint32_t txn;  // for order in block
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(owner);
 
         if (ser_action.ForRead()) {
@@ -31,8 +31,7 @@ struct AccountHistoryKey {
             blockHeight = ~blockHeight;
             READWRITE(WrapBigEndian(txn));
             txn = ~txn;
-        }
-        else {
+        } else {
             uint32_t blockHeight_ = ~blockHeight;
             READWRITE(WrapBigEndian(blockHeight_));
             uint32_t txn_ = ~txn;
@@ -49,82 +48,95 @@ struct AccountHistoryValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(txid);
         READWRITE(category);
         READWRITE(diff);
     }
 };
 
-class CAccountsHistoryView : public virtual CStorageView
-{
+class CAccountsHistoryView : public virtual CStorageView {
 public:
     void CreateMultiIndexIfNeeded();
     Res EraseAccountHistoryHeight(uint32_t height);
-    [[nodiscard]] std::optional<AccountHistoryValue> ReadAccountHistory(AccountHistoryKey const & key) const;
-    Res WriteAccountHistory(AccountHistoryKey const & key, AccountHistoryValue const & value);
-    Res EraseAccountHistory(AccountHistoryKey const & key);
-    void ForEachAccountHistory(std::function<bool(AccountHistoryKey const &, AccountHistoryValue)> callback,
-                               const CScript& owner = {}, uint32_t height = std::numeric_limits<uint32_t>::max(), uint32_t txn = std::numeric_limits<uint32_t>::max());
+    [[nodiscard]] std::optional<AccountHistoryValue> ReadAccountHistory(const AccountHistoryKey &key) const;
+    Res WriteAccountHistory(const AccountHistoryKey &key, const AccountHistoryValue &value);
+    Res EraseAccountHistory(const AccountHistoryKey &key);
+    void ForEachAccountHistory(std::function<bool(const AccountHistoryKey &, AccountHistoryValue)> callback,
+                               const CScript &owner = {},
+                               uint32_t height      = std::numeric_limits<uint32_t>::max(),
+                               uint32_t txn         = std::numeric_limits<uint32_t>::max());
 
     // tags
-    struct ByAccountHistoryKey    { static constexpr uint8_t prefix() { return 'h'; } };
-    struct ByAccountHistoryKeyNew { static constexpr uint8_t prefix() { return 'H'; } };
+    struct ByAccountHistoryKey {
+        static constexpr uint8_t prefix() { return 'h'; }
+    };
+    struct ByAccountHistoryKeyNew {
+        static constexpr uint8_t prefix() { return 'H'; }
+    };
 };
 
-class CAccountHistoryStorage : public CAccountsHistoryView
-                             , public CAuctionHistoryView
-{
+class CAccountHistoryStorage : public CAccountsHistoryView, public CAuctionHistoryView {
 public:
-    CAccountHistoryStorage(CAccountHistoryStorage& accountHistory) : CStorageView(new CFlushableStorageKV(accountHistory.DB())) {}
-    CAccountHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
+    CAccountHistoryStorage(CAccountHistoryStorage &accountHistory)
+        : CStorageView(new CFlushableStorageKV(accountHistory.DB())) {}
+    CAccountHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
 };
 
-class CBurnHistoryStorage : public CAccountsHistoryView
-{
+class CBurnHistoryStorage : public CAccountsHistoryView {
 public:
-    CBurnHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
+    CBurnHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
 };
 
 class CHistoryWriters {
-    CAccountHistoryStorage* historyView{};
-    CBurnHistoryStorage* burnView{};
+    CAccountHistoryStorage *historyView{};
+    CBurnHistoryStorage *burnView{};
     std::map<CScript, TAmounts> diffs;
     std::map<CScript, TAmounts> burnDiffs;
-    std::map<uint256, std::map<CScript,TAmounts>> vaultDiffs;
+    std::map<uint256, std::map<CScript, TAmounts>> vaultDiffs;
 
 public:
-    CVaultHistoryStorage* vaultView{};
+    CVaultHistoryStorage *vaultView{};
     CLoanSchemeCreation globalLoanScheme;
     std::string schemeID;
 
-    CHistoryWriters(CAccountHistoryStorage* historyView, CBurnHistoryStorage* burnView, CVaultHistoryStorage* vaultView);
+    CHistoryWriters(CAccountHistoryStorage *historyView,
+                    CBurnHistoryStorage *burnView,
+                    CVaultHistoryStorage *vaultView);
 
-    CAccountHistoryStorage* GetAccountHistoryStore() { return historyView; };
+    CAccountHistoryStorage *GetAccountHistoryStore() { return historyView; };
 
-    void AddBalance(const CScript& owner, const CTokenAmount amount, const uint256& vaultID);
-    void AddFeeBurn(const CScript& owner, const CAmount amount);
-    void SubBalance(const CScript& owner, const CTokenAmount amount, const uint256& vaultID);
-    void Flush(const uint32_t height, const uint256& txid, const uint32_t txn, const uint8_t type, const uint256& vaultID);
+    void AddBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
+    void AddFeeBurn(const CScript &owner, const CAmount amount);
+    void SubBalance(const CScript &owner, const CTokenAmount amount, const uint256 &vaultID);
+    void Flush(const uint32_t height,
+               const uint256 &txid,
+               const uint32_t txn,
+               const uint8_t type,
+               const uint256 &vaultID);
 };
 
-class CAccountsHistoryWriter : public CCustomCSView
-{
+class CAccountsHistoryWriter : public CCustomCSView {
     const uint32_t height;
     const uint32_t txn;
     const uint256 txid;
     const uint8_t type;
-    CHistoryWriters* writers{};
+    CHistoryWriters *writers{};
 
 public:
     uint256 vaultID;
 
-    CAccountsHistoryWriter(CCustomCSView & storage, uint32_t height, uint32_t txn, const uint256& txid, uint8_t type, CHistoryWriters* writers);
-    Res AddBalance(CScript const & owner, CTokenAmount amount) override;
-    Res SubBalance(CScript const & owner, CTokenAmount amount) override;
+    CAccountsHistoryWriter(CCustomCSView &storage,
+                           uint32_t height,
+                           uint32_t txn,
+                           const uint256 &txid,
+                           uint8_t type,
+                           CHistoryWriters *writers);
+    Res AddBalance(const CScript &owner, CTokenAmount amount) override;
+    Res SubBalance(const CScript &owner, CTokenAmount amount) override;
     bool Flush() override;
 
-    CAccountHistoryStorage* GetAccountHistoryStore() override;
+    CAccountHistoryStorage *GetAccountHistoryStore() override;
 };
 
 extern std::unique_ptr<CAccountHistoryStorage> paccountHistoryDB;
@@ -132,4 +144,4 @@ extern std::unique_ptr<CBurnHistoryStorage> pburnHistoryDB;
 
 static constexpr bool DEFAULT_ACINDEX = true;
 
-#endif //DEFI_MASTERNODES_ACCOUNTSHISTORY_H
+#endif  // DEFI_MASTERNODES_ACCOUNTSHISTORY_H
diff --git a/src/masternodes/anchors.cpp b/src/masternodes/anchors.cpp
index 90950050bc..61a723a77b 100644
--- a/src/masternodes/anchors.cpp
+++ b/src/masternodes/anchors.cpp
@@ -9,9 +9,9 @@
 #include <key.h>
 #include <logging.h>
 #include <masternodes/masternodes.h>
-#include <streams.h>
 #include <script/standard.h>
 #include <spv/spv_wrapper.h>
+#include <streams.h>
 #include <timedata.h>
 #include <util/system.h>
 #include <util/validation.h>
@@ -25,103 +25,99 @@ std::unique_ptr<CAnchorAuthIndex> panchorauths;
 std::unique_ptr<CAnchorIndex> panchors;
 std::unique_ptr<CAnchorAwaitingConfirms> panchorAwaitingConfirms;
 
-static const char DB_ANCHORS = 'A';
-static const char DB_PENDING = 'p';
+static const char DB_ANCHORS      = 'A';
+static const char DB_PENDING      = 'p';
 static const char DB_BITCOININDEX = 'Z';  // Bitcoin height to blockhash table
 
-uint256 CAnchorData::GetSignHash() const
-{
+uint256 CAnchorData::GetSignHash() const {
     CDataStream ss{SER_GETHASH, PROTOCOL_VERSION};
-    ss << previousAnchor << height << blockHash << nextTeam; // << salt_;
+    ss << previousAnchor << height << blockHash << nextTeam;  // << salt_;
     return Hash(ss.begin(), ss.end());
 }
 
-CAnchorAuthMessage::Signature CAnchorAuthMessage::GetSignature() const
-{
+CAnchorAuthMessage::Signature CAnchorAuthMessage::GetSignature() const {
     return signature;
 }
 
-uint256 CAnchorAuthMessage::GetHash() const
-{
+uint256 CAnchorAuthMessage::GetHash() const {
     CDataStream ss{SER_NETWORK, PROTOCOL_VERSION};
     ss << *this;
     return Hash(ss.begin(), ss.end());
 }
 
-bool CAnchorAuthMessage::SignWithKey(const CKey& key)
-{
+bool CAnchorAuthMessage::SignWithKey(const CKey &key) {
     if (!key.SignCompact(GetSignHash(), signature)) {
         signature.clear();
     }
     return !signature.empty();
 }
 
-bool CAnchorAuthMessage::GetPubKey(CPubKey& pubKey) const
-{
+bool CAnchorAuthMessage::GetPubKey(CPubKey &pubKey) const {
     return !signature.empty() && pubKey.RecoverCompact(GetSignHash(), signature);
 }
 
-CKeyID CAnchorAuthMessage::GetSigner() const
-{
+CKeyID CAnchorAuthMessage::GetSigner() const {
     CPubKey pubKey;
     return (!signature.empty() && pubKey.RecoverCompact(GetSignHash(), signature)) ? pubKey.GetID() : CKeyID{};
 }
 
-CAnchor CAnchor::Create(const std::vector<CAnchorAuthMessage> & auths, CTxDestination const & rewardDest)
-{
+CAnchor CAnchor::Create(const std::vector<CAnchorAuthMessage> &auths, const CTxDestination &rewardDest) {
     // assumed here that all of the auths are uniform, were checked for sigs and consensus has been reached!
     assert(rewardDest.index() == PKHashType || rewardDest.index() == WitV0KeyHashType);
 
     if (auths.size() > 0) {
-        CAnchor anchor(static_cast<CAnchorData const &> (auths.at(0)));
+        CAnchor anchor(static_cast<const CAnchorData &>(auths.at(0)));
 
         for (size_t i = 0; i < auths.size(); ++i) {
             anchor.sigs.push_back(auths[i].GetSignature());
         }
-        anchor.rewardKeyID = rewardDest.index() == PKHashType ? CKeyID(std::get<PKHash>(rewardDest)) : CKeyID(std::get<WitnessV0KeyHash>(rewardDest));
+        anchor.rewardKeyID   = rewardDest.index() == PKHashType ? CKeyID(std::get<PKHash>(rewardDest))
+                                                                : CKeyID(std::get<WitnessV0KeyHash>(rewardDest));
         anchor.rewardKeyType = rewardDest.index();
         return anchor;
     }
     return {};
 }
 
-bool CAnchor::CheckAuthSigs(CTeam const & team) const
-{
+bool CAnchor::CheckAuthSigs(const CTeam &team) const {
     // Sigs must meet quorum size.
     const auto quorum = GetMinAnchorQuorum(team);
     if (sigs.size() < quorum) {
-        return error("%s: Anchor auth team quorum not met. Min quorum: %d sigs size %d", __func__, GetMinAnchorQuorum(team), sigs.size());
+        return error("%s: Anchor auth team quorum not met. Min quorum: %d sigs size %d",
+                     __func__,
+                     GetMinAnchorQuorum(team),
+                     sigs.size());
     }
 
     // Number of unique sigs must meet the required quorum.
     const auto uniqueKeys = CheckSigs(GetSignHash(), sigs, team);
     if (uniqueKeys < quorum) {
-        return error("%s: Anchor auth team unique key quorum not met. Min quorum: %d keys size %d", __func__, quorum, uniqueKeys);
+        return error("%s: Anchor auth team unique key quorum not met. Min quorum: %d keys size %d",
+                     __func__,
+                     quorum,
+                     uniqueKeys);
     }
 
     return true;
 }
 
-const CAnchorAuthIndex::Auth * CAnchorAuthIndex::GetAuth(uint256 const & msgHash) const
-{
+const CAnchorAuthIndex::Auth *CAnchorAuthIndex::GetAuth(const uint256 &msgHash) const {
     AssertLockHeld(cs_main);
 
-    auto const & list = auths.get<Auth::ByMsgHash>();
-    auto const it = list.find(msgHash);
+    const auto &list = auths.get<Auth::ByMsgHash>();
+    const auto it    = list.find(msgHash);
     return it != list.end() ? &(*it) : nullptr;
 }
 
-const CAnchorAuthIndex::Auth * CAnchorAuthIndex::GetVote(const uint256 & signHash, const CKeyID & signer) const
-{
+const CAnchorAuthIndex::Auth *CAnchorAuthIndex::GetVote(const uint256 &signHash, const CKeyID &signer) const {
     AssertLockHeld(cs_main);
 
-    auto const & list = auths.get<Auth::ByVote>();
-    auto const it = list.find(std::make_tuple(signHash, signer));
+    const auto &list = auths.get<Auth::ByVote>();
+    const auto it    = list.find(std::make_tuple(signHash, signer));
     return it != list.end() ? &(*it) : nullptr;
 }
 
-bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth & auth) const
-{
+bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth &auth) const {
     AssertLockHeld(cs_main);
 
     // 1. Prev and top checks
@@ -132,20 +128,33 @@ bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth & auth) const
             auto prev = panchors->GetAnchorByTx(auth.previousAnchor);
 
             if (!prev) {
-                LogPrint(BCLog::ANCHORING, "%s: Got anchor auth, hash %s, blockheight: %d, but can't find previousAnchor %s\n", __func__, auth.GetHash().ToString(), auth.height, auth.previousAnchor.ToString());
+                LogPrint(BCLog::ANCHORING,
+                         "%s: Got anchor auth, hash %s, blockheight: %d, but can't find previousAnchor %s\n",
+                         __func__,
+                         auth.GetHash().ToString(),
+                         auth.height,
+                         auth.previousAnchor.ToString());
                 return false;
             }
 
             if (auth.height <= prev->anchor.height) {
-                LogPrint(BCLog::ANCHORING, "%s: Auth blockHeight should be higher than previousAnchor height! %d > %d\n", __func__, auth.height, prev->anchor.height);
+                LogPrint(BCLog::ANCHORING,
+                         "%s: Auth blockHeight should be higher than previousAnchor height! %d > %d\n",
+                         __func__,
+                         auth.height,
+                         prev->anchor.height);
                 return false;
             }
         }
 
-        auto const * topAnchor = panchors->GetActiveAnchor();
+        const auto *topAnchor = panchors->GetActiveAnchor();
         if (topAnchor) {
             if (auth.height <= topAnchor->anchor.height) {
-                LogPrint(BCLog::ANCHORING, "%s: Auth blockHeight should be higher than top anchor height! %d > %d\n", __func__, auth.height, topAnchor->anchor.height);
+                LogPrint(BCLog::ANCHORING,
+                         "%s: Auth blockHeight should be higher than top anchor height! %d > %d\n",
+                         __func__,
+                         auth.height,
+                         topAnchor->anchor.height);
                 return false;
             }
 
@@ -164,7 +173,7 @@ bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth & auth) const
     }
 
     // 2. chain context:
-    CBlockIndex* block = ::ChainActive()[auth.height];
+    CBlockIndex *block = ::ChainActive()[auth.height];
     if (block == nullptr) {
         LogPrint(BCLog::ANCHORING, "%s: Can't get block from anchor height: %d\n", __func__, auth.height);
         return false;
@@ -185,7 +194,10 @@ bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth & auth) const
     }
 
     if (team.empty()) {
-        LogPrint(BCLog::ANCHORING, "%s: Can't get team for previousAnchor tx %s\n", __func__, auth.previousAnchor.ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Can't get team for previousAnchor tx %s\n",
+                 __func__,
+                 auth.previousAnchor.ToString());
         return false;
     }
 
@@ -193,83 +205,89 @@ bool CAnchorAuthIndex::ValidateAuth(const CAnchorAuthIndex::Auth & auth) const
 
     CPubKey pubKey;
     if (!auth.GetPubKey(pubKey)) {
-        LogPrint(BCLog::ANCHORING, "%s: Can't recover pubkey from sig, auth: %s\n", __func__, auth.GetHash().ToString());
-        return false;;
+        LogPrint(
+            BCLog::ANCHORING, "%s: Can't recover pubkey from sig, auth: %s\n", __func__, auth.GetHash().ToString());
+        return false;
+        ;
     }
     const CKeyID masternodeKey{pubKey.GetID()};
     if (team.find(masternodeKey) == team.end()) {
-        LogPrint(BCLog::ANCHORING, "%s: Recovered keyID %s is not a current team member\n", __func__, masternodeKey.ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Recovered keyID %s is not a current team member\n",
+                 __func__,
+                 masternodeKey.ToString());
         return false;
     }
 
     return true;
 }
 
-bool CAnchorAuthIndex::AddAuth(const CAnchorAuthIndex::Auth & auth)
-{
+bool CAnchorAuthIndex::AddAuth(const CAnchorAuthIndex::Auth &auth) {
     AssertLockHeld(cs_main);
     return auths.insert(auth).second;
 }
 
-uint32_t GetMinAnchorQuorum(const CAnchorData::CTeam &team)
-{
+uint32_t GetMinAnchorQuorum(const CAnchorData::CTeam &team) {
     if (Params().NetworkIDString() == "regtest") {
         return gArgs.GetArg("-anchorquorum", 1);
     }
-    return  static_cast<uint32_t>(1 + (team.size() * 2) / 3); // 66% + 1
+    return static_cast<uint32_t>(1 + (team.size() * 2) / 3);  // 66% + 1
 }
 
-CAmount GetAnchorSubsidy(int anchorHeight, int prevAnchorHeight, const Consensus::Params& consensusParams)
-{
+CAmount GetAnchorSubsidy(int anchorHeight, int prevAnchorHeight, const Consensus::Params &consensusParams) {
     if (anchorHeight < prevAnchorHeight) {
         return 0;
     }
 
     int period = anchorHeight - prevAnchorHeight;
-    return consensusParams.spv.anchorSubsidy + (period / consensusParams.spv.subsidyIncreasePeriod) * consensusParams.spv.subsidyIncreaseValue;
+    return consensusParams.spv.anchorSubsidy +
+           (period / consensusParams.spv.subsidyIncreasePeriod) * consensusParams.spv.subsidyIncreaseValue;
 }
 
 /*
  * Choose best (high) anchor auth group with
  */
-CAnchor CAnchorAuthIndex::CreateBestAnchor(CTxDestination const & rewardDest) const
-{
+CAnchor CAnchorAuthIndex::CreateBestAnchor(const CTxDestination &rewardDest) const {
     AssertLockHeld(cs_main);
     // KList is sorted by defi height + signHash (all except sign)
     typedef Auths::index<Auth::ByKey>::type KList;
-    KList const & list = auths.get<Auth::ByKey>();
+    const KList &list = auths.get<Auth::ByKey>();
 
-    auto const topAnchor = panchors->GetActiveAnchor();
-    uint32_t quorum = 1 + (Params().GetConsensus().mn.anchoringTeamSize * 2) / 3;
-    auto const topHeight = topAnchor ? topAnchor->anchor.height : 0;
+    const auto topAnchor = panchors->GetActiveAnchor();
+    uint32_t quorum      = 1 + (Params().GetConsensus().mn.anchoringTeamSize * 2) / 3;
+    const auto topHeight = topAnchor ? topAnchor->anchor.height : 0;
     LogPrint(BCLog::ANCHORING, "auths size: %d quorum: %d\n", list.size(), quorum);
 
     std::vector<Auth> freshestConsensus;
-    THeight curHeight = 0;
+    THeight curHeight   = 0;
     uint256 curSignHash = {};
 
     // get freshest consensus:
     for (auto it = list.rbegin(); it != list.rend() && it->height > topHeight; ++it) {
-        LogPrint(BCLog::ANCHORING, "%s: height %d, blockHash %s, signHash %s, msg %s\n", __func__, it->height, it->blockHash.ToString(), it->GetSignHash().ToString(), it->GetHash().ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: height %d, blockHash %s, signHash %s, msg %s\n",
+                 __func__,
+                 it->height,
+                 it->blockHash.ToString(),
+                 it->GetSignHash().ToString(),
+                 it->GetHash().ToString());
         if (topAnchor && topAnchor->txHash != it->previousAnchor)
             continue;
 
         if (curHeight != it->height || curSignHash != it->GetSignHash()) {
             // got next group of auths
-            curHeight = it->height;
+            curHeight   = it->height;
             curSignHash = it->GetSignHash();
 
-            if (it->nextTeam.size() == 1)
-            {
+            if (it->nextTeam.size() == 1) {
                 // Team data reference
-                const CKeyID& teamData = *it->nextTeam.begin();
+                const CKeyID &teamData = *it->nextTeam.begin();
 
                 uint64_t anchorCreationHeight;
                 std::shared_ptr<std::vector<unsigned char>> prefix;
 
                 // Check this is post-fork anchor auth
-                if (GetAnchorEmbeddedData(teamData, anchorCreationHeight, prefix))
-                {
+                if (GetAnchorEmbeddedData(teamData, anchorCreationHeight, prefix)) {
                     // Get anchor team at time of creating this auth
                     auto team = pcustomcsview->GetAuthTeam(anchorCreationHeight);
                     if (team) {
@@ -284,11 +302,12 @@ CAnchor CAnchorAuthIndex::CreateBestAnchor(CTxDestination const & rewardDest) co
 
             if (count >= quorum) {
                 KList::iterator it0, it0Copy, it1;
-                std::tie(it0,it1) = list.equal_range(std::make_tuple(curHeight, curSignHash));
+                std::tie(it0, it1) = list.equal_range(std::make_tuple(curHeight, curSignHash));
 
                 // Fix to avoid "Anchor too new" error until F hard fork
                 auto anchorIndex = ::ChainActive()[it0->height];
-                if (!anchorIndex || anchorIndex->nTime + Params().GetConsensus().mn.anchoringTimeDepth > GetAdjustedTime()) {
+                if (!anchorIndex ||
+                    anchorIndex->nTime + Params().GetConsensus().mn.anchoringTimeDepth > GetAdjustedTime()) {
                     continue;
                 }
 
@@ -303,7 +322,11 @@ CAnchor CAnchorAuthIndex::CreateBestAnchor(CTxDestination const & rewardDest) co
 
                 if (validCount >= quorum) {
                     for (uint32_t i = 0; i < quorum && it0 != it1; ++i, ++it0) {
-                        LogPrint(BCLog::ANCHORING, "auths: pick up %d, %s, %s\n", it0->height, it0->blockHash.ToString(), it0->GetHash().ToString());
+                        LogPrint(BCLog::ANCHORING,
+                                 "auths: pick up %d, %s, %s\n",
+                                 it0->height,
+                                 it0->blockHash.ToString(),
+                                 it0->GetHash().ToString());
 
                         freshestConsensus.push_back(*it0);
                     }
@@ -316,41 +339,41 @@ CAnchor CAnchorAuthIndex::CreateBestAnchor(CTxDestination const & rewardDest) co
     return CAnchor::Create(freshestConsensus, rewardDest);
 }
 
-void CAnchorAuthIndex::ForEachAnchorAuthByHeight(std::function<bool (const CAnchorAuthIndex::Auth &)> callback) const
-{
+void CAnchorAuthIndex::ForEachAnchorAuthByHeight(std::function<bool(const CAnchorAuthIndex::Auth &)> callback) const {
     AssertLockHeld(cs_main);
 
     typedef Auths::index<Auth::ByKey>::type KList;
-    KList const & list = auths.get<Auth::ByKey>();
+    const KList &list = auths.get<Auth::ByKey>();
     for (auto it = list.rbegin(); it != list.rend(); ++it)
-        if (!callback(*it)) break;
+        if (!callback(*it))
+            break;
 }
 
-void CAnchorAuthIndex::PruneOlderThan(THeight height)
-{
+void CAnchorAuthIndex::PruneOlderThan(THeight height) {
     AssertLockHeld(cs_main);
     // KList is sorted by defi height + signHash (all except sign)
     typedef Auths::index<Auth::ByKey>::type KList;
-    KList & list = auths.get<Auth::ByKey>();
+    KList &list = auths.get<Auth::ByKey>();
 
     auto it = list.upper_bound(std::make_tuple(height, uint256{}));
     list.erase(list.begin(), it);
 }
 
 CAnchorIndex::CAnchorIndex(size_t nCacheSize, bool fMemory, bool fWipe)
-    : db(std::make_unique<CDBWrapper>(GetDataDir() / "anchors", nCacheSize, fMemory, fWipe))
-{
-}
+    : db(std::make_unique<CDBWrapper>(GetDataDir() / "anchors", nCacheSize, fMemory, fWipe)) {}
 
-bool CAnchorIndex::Load()
-{
+bool CAnchorIndex::Load() {
     AssertLockHeld(cs_main);
 
     AnchorIndexImpl().swap(anchors);
 
-    std::function<void (uint256 const &, AnchorRec &)> onLoad = [this] (uint256 const &, AnchorRec & rec) {
+    std::function<void(const uint256 &, AnchorRec &)> onLoad = [this](const uint256 &, AnchorRec &rec) {
         // just for debug
-        LogPrint(BCLog::ANCHORING, "anchor load: blockHash: %s, height %d, btc height: %d\n", rec.anchor.blockHash.ToString(), rec.anchor.height, rec.btcHeight);
+        LogPrint(BCLog::ANCHORING,
+                 "anchor load: blockHash: %s, height %d, btc height: %d\n",
+                 rec.anchor.blockHash.ToString(),
+                 rec.anchor.height,
+                 rec.btcHeight);
 
         anchors.insert(std::move(rec));
     };
@@ -365,34 +388,31 @@ bool CAnchorIndex::Load()
     return result;
 }
 
-void CAnchorIndex::ForEachAnchorByBtcHeight(std::function<bool(const CAnchorIndex::AnchorRec &)> callback) const
-{
+void CAnchorIndex::ForEachAnchorByBtcHeight(std::function<bool(const CAnchorIndex::AnchorRec &)> callback) const {
     typedef AnchorIndexImpl::index<AnchorRec::ByBtcHeight>::type KList;
-    KList const & list = anchors.get<AnchorRec::ByBtcHeight>();
+    const KList &list = anchors.get<AnchorRec::ByBtcHeight>();
     for (auto it = list.rbegin(); it != list.rend(); ++it)
-        if (!callback(*it)) break;
+        if (!callback(*it))
+            break;
 }
 
-const CAnchorIndex::AnchorRec * CAnchorIndex::GetActiveAnchor() const
-{
+const CAnchorIndex::AnchorRec *CAnchorIndex::GetActiveAnchor() const {
     return top;
 }
 
-const CAnchorIndex::AnchorRec * CAnchorIndex::GetAnchorByTx(const uint256 & hash) const
-{
+const CAnchorIndex::AnchorRec *CAnchorIndex::GetAnchorByTx(const uint256 &hash) const {
     AssertLockHeld(cs_main);
 
-    AnchorIndexImpl const & index = anchors;
-    auto & list = index.get<AnchorRec::ByBtcTxHash>();
-    auto it = list.find(hash);
+    const AnchorIndexImpl &index = anchors;
+    auto &list                   = index.get<AnchorRec::ByBtcTxHash>();
+    auto it                      = list.find(hash);
     return it != list.end() ? &(*it) : nullptr;
 }
 
-bool CAnchorIndex::AddAnchor(CAnchor const & anchor, uint256 const & btcTxHash, THeight btcBlockHeight, bool overwrite)
-{
+bool CAnchorIndex::AddAnchor(const CAnchor &anchor, const uint256 &btcTxHash, THeight btcBlockHeight, bool overwrite) {
     AssertLockHeld(cs_main);
 
-    AnchorRec rec{ anchor, btcTxHash, btcBlockHeight };
+    AnchorRec rec{anchor, btcTxHash, btcBlockHeight};
     if (overwrite) {
         DeleteAnchorByBtcTx(btcTxHash);
     }
@@ -405,17 +425,17 @@ bool CAnchorIndex::AddAnchor(CAnchor const & anchor, uint256 const & btcTxHash,
     return result;
 }
 
-bool CAnchorIndex::DeleteAnchorByBtcTx(const uint256 & btcTxHash)
-{
+bool CAnchorIndex::DeleteAnchorByBtcTx(const uint256 &btcTxHash) {
     AssertLockHeld(cs_main);
 
     auto anchor = GetAnchorByBtcTx(btcTxHash);
 
     if (anchor) {
         // revert top if deleted anchor was in active chain (one of current top parents)
-        for (auto it = top; it && it->btcHeight >= anchor->btcHeight; it = GetAnchorByBtcTx(it->anchor.previousAnchor)) {
+        for (auto it = top; it && it->btcHeight >= anchor->btcHeight;
+             it      = GetAnchorByBtcTx(it->anchor.previousAnchor)) {
             if (anchor == it) {
-                top = GetAnchorByBtcTx(anchor->anchor.previousAnchor);
+                top                  = GetAnchorByBtcTx(anchor->anchor.previousAnchor);
                 possibleReActivation = true;
                 break;
             }
@@ -428,35 +448,32 @@ bool CAnchorIndex::DeleteAnchorByBtcTx(const uint256 & btcTxHash)
     return false;
 }
 
-CAnchorData::CTeam CAnchorIndex::GetNextTeam(const uint256 & btcPrevTx) const
-{
+CAnchorData::CTeam CAnchorIndex::GetNextTeam(const uint256 &btcPrevTx) const {
     AssertLockHeld(cs_main);
 
     if (btcPrevTx.IsNull())
         return Params().GetGenesisTeam();
 
-    AnchorRec const * prev = GetAnchorByTx(btcPrevTx);
+    const AnchorRec *prev = GetAnchorByTx(btcPrevTx);
     if (!prev) {
-        LogPrintf("Can't get previous anchor with btc hash %s\n",  btcPrevTx.ToString());
+        LogPrintf("Can't get previous anchor with btc hash %s\n", btcPrevTx.ToString());
         return CAnchorData::CTeam{};
     }
     return prev->anchor.nextTeam;
 }
 
-CAnchorIndex::AnchorRec const * CAnchorIndex::GetAnchorByBtcTx(uint256 const & txHash) const
-{
+const CAnchorIndex::AnchorRec *CAnchorIndex::GetAnchorByBtcTx(const uint256 &txHash) const {
     AssertLockHeld(cs_main);
 
     typedef AnchorIndexImpl::index<AnchorRec::ByBtcTxHash>::type KList;
-    KList const & list = anchors.get<AnchorRec::ByBtcTxHash>();
+    const KList &list = anchors.get<AnchorRec::ByBtcTxHash>();
 
-    auto const it = list.find(txHash);
+    const auto it = list.find(txHash);
     return it != list.end() ? &*it : nullptr;
 }
 
 /// Get all UNREWARDED and ACTIVE anchors (resided on chain with anchor's top).
-CAnchorIndex::UnrewardedResult CAnchorIndex::GetUnrewarded() const
-{
+CAnchorIndex::UnrewardedResult CAnchorIndex::GetUnrewarded() const {
     AssertLockHeld(cs_main);
 
     auto it = panchors->GetActiveAnchor();
@@ -465,12 +482,12 @@ CAnchorIndex::UnrewardedResult CAnchorIndex::GetUnrewarded() const
         ;
     // create confirmed set
     UnrewardedResult confirmed;
-    for (; it ; it = panchors->GetAnchorByBtcTx(it->anchor.previousAnchor)) {
+    for (; it; it = panchors->GetAnchorByBtcTx(it->anchor.previousAnchor)) {
         confirmed.insert(it->txHash);
     }
 
     // find unrewarded
-    for (auto && it = confirmed.begin(); it != confirmed.end(); /* no advance */) {
+    for (auto &&it = confirmed.begin(); it != confirmed.end(); /* no advance */) {
         if (pcustomcsview->GetRewardForAnchor(*it))
             it = confirmed.erase(it);
         else
@@ -480,40 +497,34 @@ CAnchorIndex::UnrewardedResult CAnchorIndex::GetUnrewarded() const
     return confirmed;
 }
 
-int CAnchorIndex::GetAnchorConfirmations(uint256 const & txHash) const
-{
+int CAnchorIndex::GetAnchorConfirmations(const uint256 &txHash) const {
     AssertLockHeld(cs_main);
     return GetAnchorConfirmations(GetAnchorByBtcTx(txHash));
 }
 
-int CAnchorIndex::GetAnchorConfirmations(const CAnchorIndex::AnchorRec * rec) const
-{
+int CAnchorIndex::GetAnchorConfirmations(const CAnchorIndex::AnchorRec *rec) const {
     AssertLockHeld(cs_main);
     if (!rec) {
         return -1;
     }
-    // for cases when tx->blockHeight == TX_UNCONFIRMED _or_ GetLastBlockHeight() less than already _confirmed_ tx (rescan in progress)
+    // for cases when tx->blockHeight == TX_UNCONFIRMED _or_ GetLastBlockHeight() less than already _confirmed_ tx
+    // (rescan in progress)
     return spvLastHeight < rec->btcHeight ? 0 : spvLastHeight - rec->btcHeight + 1;
 }
 
-void CAnchorIndex::CheckPendingAnchors()
-{
+void CAnchorIndex::CheckPendingAnchors() {
     uint32_t height = spv::pspv ? spv::pspv->GetLastBlockHeight() : 0;
 
     LOCK(cs_main);
 
     spv::PendingSet anchorsPending(spv::PendingOrder);
-    ForEachPending([&anchorsPending](uint256 const &, AnchorRec & rec) {
-        anchorsPending.insert(rec);
-    });
+    ForEachPending([&anchorsPending](const uint256 &, AnchorRec &rec) { anchorsPending.insert(rec); });
 
     std::set<uint256> deletePending;
-    for (const auto& rec : anchorsPending) {
-
+    for (const auto &rec : anchorsPending) {
         CBlockIndex anchorBlock;
         uint64_t anchorCreationHeight;
         if (!ContextualValidateAnchor(rec.anchor, anchorBlock, anchorCreationHeight)) {
-
             // Height used to ignore failure if due to not being in main chain yet.
             if (anchorCreationHeight != std::numeric_limits<uint64_t>::max()) {
                 deletePending.insert(rec.txHash);
@@ -523,7 +534,7 @@ void CAnchorIndex::CheckPendingAnchors()
         }
 
         const auto [blockHeight, timestamp] = spv::pspv->ReadTxHeightTime(rec.txHash);
-        const auto blockHash = panchors->ReadBlockHash(rec.btcHeight);
+        const auto blockHash                = panchors->ReadBlockHash(rec.btcHeight);
 
         // Do not delete, TX time still pending. If block height is set to max we cannot trust the timestamp.
         if (timestamp == 0 || blockHeight == std::numeric_limits<int32_t>::max() || blockHash == uint256()) {
@@ -532,7 +543,11 @@ void CAnchorIndex::CheckPendingAnchors()
 
         // Here we can check new rule that Bitcoin blocktime is three hours more than DeFi anchored block
         if (anchorBlock.nTime > timestamp - Params().GetConsensus().mn.anchoringTimeDepth) {
-            LogPrint(BCLog::ANCHORING, "Anchor too new. DeFi: %d Bitcoin: %d Anchor: %s\n", anchorBlock.nTime, timestamp, rec.txHash.ToString());
+            LogPrint(BCLog::ANCHORING,
+                     "Anchor too new. DeFi: %d Bitcoin: %d Anchor: %s\n",
+                     anchorBlock.nTime,
+                     timestamp,
+                     rec.txHash.ToString());
             deletePending.insert(rec.txHash);
             continue;
         }
@@ -541,14 +556,18 @@ void CAnchorIndex::CheckPendingAnchors()
         CTeam team;
         auto anchorTeam = pcustomcsview->GetAuthTeam(anchorCreationHeight);
         if (!anchorTeam || anchorTeam->empty()) {
-            LogPrint(BCLog::ANCHORING, "No team found at height %ld. Deleting anchor txHash %s\n", anchorCreationHeight, rec.txHash.ToString());
+            LogPrint(BCLog::ANCHORING,
+                     "No team found at height %ld. Deleting anchor txHash %s\n",
+                     anchorCreationHeight,
+                     rec.txHash.ToString());
             deletePending.insert(rec.txHash);
             continue;
         }
 
         // Validate the anchor sigs
         if (!rec.anchor.CheckAuthSigs(*anchorTeam)) {
-            LogPrint(BCLog::ANCHORING, "Signature validation fails. Deleting anchor txHash %s\n", rec.txHash.ToString());
+            LogPrint(
+                BCLog::ANCHORING, "Signature validation fails. Deleting anchor txHash %s\n", rec.txHash.ToString());
             deletePending.insert(rec.txHash);
             continue;
         }
@@ -563,15 +582,15 @@ void CAnchorIndex::CheckPendingAnchors()
         CheckActiveAnchor(height);
     }
 
-    for (const auto& hash : deletePending) {
+    for (const auto &hash : deletePending) {
         DeletePendingByBtcTx(hash);
     }
 }
 
-void CAnchorIndex::CheckActiveAnchor(uint32_t height, bool forced)
-{
+void CAnchorIndex::CheckActiveAnchor(uint32_t height, bool forced) {
     // Only continue with context of chain
-    if (ShutdownRequested()) return;
+    if (ShutdownRequested())
+        return;
 
     {
         LOCK(cs_main);
@@ -579,12 +598,13 @@ void CAnchorIndex::CheckActiveAnchor(uint32_t height, bool forced)
 
         panchors->ActivateBestAnchor(forced);
 
-        // prune auths older than anchor with 6 confirmations. Warning! This constant are using for start confirming reward too!
+        // prune auths older than anchor with 6 confirmations. Warning! This constant are using for start confirming
+        // reward too!
         auto it = panchors->GetActiveAnchor();
         for (; it && GetAnchorConfirmations(it) < 6; it = panchors->GetAnchorByBtcTx(it->anchor.previousAnchor))
             ;
         if (it)
-            panchorauths->PruneOlderThan(it->anchor.height+1);
+            panchorauths->PruneOlderThan(it->anchor.height + 1);
 
         /// @todo panchorAwaitingConfirms - optimize?
         /// @attention - 'it' depends on previous loop conditions (>=6).
@@ -594,15 +614,13 @@ void CAnchorIndex::CheckActiveAnchor(uint32_t height, bool forced)
     }
 }
 
-void CAnchorIndex::UpdateLastHeight(uint32_t height)
-{
+void CAnchorIndex::UpdateLastHeight(uint32_t height) {
     AssertLockHeld(cs_main);
     spvLastHeight = height;
 }
 
 // selects "best" of two anchors at the equal btc height (prevs must be checked before)
-CAnchorIndex::AnchorRec const * BestOfTwo(CAnchorIndex::AnchorRec const * a1, CAnchorIndex::AnchorRec const * a2)
-{
+const CAnchorIndex::AnchorRec *BestOfTwo(const CAnchorIndex::AnchorRec *a1, const CAnchorIndex::AnchorRec *a2) {
     if (a1 == nullptr)
         return a2;
     if (a2 == nullptr)
@@ -612,8 +630,7 @@ CAnchorIndex::AnchorRec const * BestOfTwo(CAnchorIndex::AnchorRec const * a1, CA
 }
 
 /// @returns true if top active anchor has been changed
-bool CAnchorIndex::ActivateBestAnchor(bool forced)
-{
+bool CAnchorIndex::ActivateBestAnchor(bool forced) {
     AssertLockHeld(cs_main);
 
     if (!possibleReActivation && !forced)
@@ -621,9 +638,10 @@ bool CAnchorIndex::ActivateBestAnchor(bool forced)
 
     possibleReActivation = false;
 
-    int const minConfirmations{Params().GetConsensus().spv.minConfirmations};
+    const int minConfirmations{Params().GetConsensus().spv.minConfirmations};
     auto oldTop = top;
-    // rollback if necessary. this should not happen in prod (w/o anchor tx deletion), but possible in test when manually reduce height in btc chain
+    // rollback if necessary. this should not happen in prod (w/o anchor tx deletion), but possible in test when
+    // manually reduce height in btc chain
     for (; top && GetAnchorConfirmations(top) < minConfirmations; top = GetAnchorByBtcTx(top->anchor.previousAnchor))
         ;
 
@@ -632,14 +650,13 @@ bool CAnchorIndex::ActivateBestAnchor(bool forced)
     uint256 prev = top ? top->anchor.previousAnchor : uint256{};
 
     // start running from top anchor height
-    // (yes, it can re-select different best anchor on the "current" top anchor level - for the cases if spv not feed txs of one block "at once")
+    // (yes, it can re-select different best anchor on the "current" top anchor level - for the cases if spv not feed
+    // txs of one block "at once")
     typedef AnchorIndexImpl::index<AnchorRec::ByBtcHeight>::type KList;
-    KList const & list = anchors.get<AnchorRec::ByBtcHeight>();
-    for (auto it = (topHeight == 0 ? list.begin() : list.find(topHeight)); it != list.end(); ) {
-
-        int const confs = GetAnchorConfirmations(&*it);
-        if (confs < minConfirmations)
-        {
+    const KList &list = anchors.get<AnchorRec::ByBtcHeight>();
+    for (auto it = (topHeight == 0 ? list.begin() : list.find(topHeight)); it != list.end();) {
+        const int confs = GetAnchorConfirmations(&*it);
+        if (confs < minConfirmations) {
             // still pending - check it again on next event
             /// @todo may be additional check for confs > 0 (for possibleReActivation)
             possibleReActivation = true;
@@ -647,19 +664,18 @@ bool CAnchorIndex::ActivateBestAnchor(bool forced)
         }
 
         KList::iterator it0, it1;
-        std::tie(it0,it1) = list.equal_range(it->btcHeight);
-        CAnchorIndex::AnchorRec const * choosenOne = nullptr;
+        std::tie(it0, it1)                        = list.equal_range(it->btcHeight);
+        const CAnchorIndex::AnchorRec *choosenOne = nullptr;
         // at least one iteration here
         for (; it0 != it1; ++it0) {
-            if (it0->anchor.previousAnchor == prev)
-            {
+            if (it0->anchor.previousAnchor == prev) {
                 // candidate
                 choosenOne = BestOfTwo(choosenOne, &*it0);
             }
         }
 
         if (choosenOne) {
-            top = choosenOne;
+            top  = choosenOne;
             prev = top->txHash;
             // after the very first iteration, top acts as prev
         }
@@ -668,22 +684,19 @@ bool CAnchorIndex::ActivateBestAnchor(bool forced)
     return top != oldTop;
 }
 
-bool CAnchorIndex::AddToAnchorPending(const AnchorRec& rec)
-{
+bool CAnchorIndex::AddToAnchorPending(const AnchorRec &rec) {
     AssertLockHeld(cs_main);
 
     return db->Write(std::make_pair(DB_PENDING, rec.txHash), rec);
 }
 
-bool CAnchorIndex::GetPendingByBtcTx(uint256 const & txHash, AnchorRec & rec) const
-{
+bool CAnchorIndex::GetPendingByBtcTx(const uint256 &txHash, AnchorRec &rec) const {
     AssertLockHeld(cs_main);
 
     return db->Read(std::make_pair(DB_PENDING, txHash), rec);
 }
 
-void CAnchorIndex::DeletePendingByBtcTx(uint256 const & btcTxHash)
-{
+void CAnchorIndex::DeletePendingByBtcTx(const uint256 &btcTxHash) {
     AssertLockHeld(cs_main);
 
     if (db->Exists(std::make_pair(DB_PENDING, btcTxHash))) {
@@ -691,78 +704,70 @@ void CAnchorIndex::DeletePendingByBtcTx(uint256 const & btcTxHash)
     }
 }
 
-bool CAnchorIndex::WriteBlock(const uint32_t height, const uint256& blockHash)
-{
+bool CAnchorIndex::WriteBlock(const uint32_t height, const uint256 &blockHash) {
     // Store Bitcoin block index
     return db->Write(std::make_pair(DB_BITCOININDEX, height), blockHash);
 }
 
-uint256 CAnchorIndex::ReadBlockHash(const uint32_t& height)
-{
+uint256 CAnchorIndex::ReadBlockHash(const uint32_t &height) {
     uint256 blockHash;
     db->Read(std::make_pair(DB_BITCOININDEX, height), blockHash);
     return blockHash;
 }
 
-void CAnchorIndex::ForEachPending(std::function<void (uint256 const &, AnchorRec &)> callback)
-{
+void CAnchorIndex::ForEachPending(std::function<void(const uint256 &, AnchorRec &)> callback) {
     AssertLockHeld(cs_main);
 
     IterateTable(DB_PENDING, callback);
 }
 
-bool CAnchorIndex::DbExists(const uint256 & hash) const
-{
+bool CAnchorIndex::DbExists(const uint256 &hash) const {
     return db->Exists(std::make_pair(DB_ANCHORS, hash));
 }
 
-bool CAnchorIndex::DbWrite(AnchorRec const & rec)
-{
+bool CAnchorIndex::DbWrite(const AnchorRec &rec) {
     return db->Write(std::make_pair(DB_ANCHORS, rec.txHash), rec);
 }
 
-bool CAnchorIndex::DbErase(uint256 const & hash)
-{
+bool CAnchorIndex::DbErase(const uint256 &hash) {
     return db->Erase(std::make_pair(DB_ANCHORS, hash));
 }
 
-const CAnchorIndex::AnchorRec* CAnchorIndex::GetLatestAnchorUpToDeFiHeight(THeight blockHeightDeFi) const
-{
+const CAnchorIndex::AnchorRec *CAnchorIndex::GetLatestAnchorUpToDeFiHeight(THeight blockHeightDeFi) const {
     AssertLockHeld(cs_main);
 
-    auto & index = anchors.get<AnchorRec::ByDeFiHeight>();
-    auto it = index.lower_bound(blockHeightDeFi);
+    auto &index = anchors.get<AnchorRec::ByDeFiHeight>();
+    auto it     = index.lower_bound(blockHeightDeFi);
     return (it != index.begin()) ? &(*(--it)) : nullptr;
 }
 
 /// Validates all except tx confirmations
-bool ValidateAnchor(const CAnchor & anchor)
-{
+bool ValidateAnchor(const CAnchor &anchor) {
     AssertLockHeld(cs_main);
 
     // Check sig size to avoid storing bogus anchors with large number of sigs
     if (anchor.nextTeam.size() != 1) {
-        return error("%s: Incorrect anchor team size. Found: %d",
-                     __func__, anchor.nextTeam.size());
+        return error("%s: Incorrect anchor team size. Found: %d", __func__, anchor.nextTeam.size());
     }
 
-    if (anchor.sigs.size() <= static_cast<size_t>(Params().GetConsensus().mn.anchoringTeamSize))
-    {
+    if (anchor.sigs.size() <= static_cast<size_t>(Params().GetConsensus().mn.anchoringTeamSize)) {
         // Team entry
-        const CKeyID& teamData = *anchor.nextTeam.begin();
+        const CKeyID &teamData = *anchor.nextTeam.begin();
 
         uint64_t anchorCreationHeight;
         std::shared_ptr<std::vector<unsigned char>> prefix;
 
         // Post-fork anchor, will be added to pending anchors to validate in chain context
-        if (GetAnchorEmbeddedData(teamData, anchorCreationHeight, prefix))
-        {
+        if (GetAnchorEmbeddedData(teamData, anchorCreationHeight, prefix)) {
             // Make sure anchor created after fork.
             if (anchorCreationHeight >= static_cast<uint64_t>(Params().GetConsensus().DakotaHeight)) {
                 return true;
             } else {
-                LogPrint(BCLog::ANCHORING, "%s: Post fork anchor created before fork height. Anchor %ld fork %d\n",
-                         __func__, anchorCreationHeight, Params().GetConsensus().DakotaHeight);
+                LogPrint(BCLog::ANCHORING,
+                         "%s: Post fork anchor created before fork height. Anchor %ld fork %d\n",
+                         __func__,
+                         anchorCreationHeight,
+                         Params().GetConsensus().DakotaHeight);
                 return false;
             }
         }
@@ -771,33 +776,32 @@ bool ValidateAnchor(const CAnchor & anchor)
     return false;
 }
 
-bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBlock, uint64_t &anchorCreationHeight)
-{
+bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex &anchorBlock, uint64_t &anchorCreationHeight) {
     AssertLockHeld(cs_main);
 
     // Validate previous anchor. Set spv::pspv to allow anchor auth relay on non-SPV nodes.
-    if (spv::pspv && !anchor.previousAnchor.IsNull())
-    {
+    if (spv::pspv && !anchor.previousAnchor.IsNull()) {
         auto prev = panchors->GetAnchorByTx(anchor.previousAnchor);
         CAnchorIndex::AnchorRec pending;
-        if (!prev)
-        {
+        if (!prev) {
             // Check pending anchors
-            if (!panchors->GetPendingByBtcTx(anchor.previousAnchor, pending))
-            {
+            if (!panchors->GetPendingByBtcTx(anchor.previousAnchor, pending)) {
                 return error("%s: Previous anchor %s specified, but does not exist.",
-                             __func__, anchor.previousAnchor.ToString());
+                             __func__,
+                             anchor.previousAnchor.ToString());
             }
-        }
-        else if ((prev && anchor.height <= prev->anchor.height) || // Check height in accepted anchor
-                 (!pending.txHash.IsNull() && anchor.height <= pending.anchor.height)) // Check height in pending anchor
+        } else if ((prev && anchor.height <= prev->anchor.height) ||  // Check height in accepted anchor
+                   (!pending.txHash.IsNull() &&
+                    anchor.height <= pending.anchor.height))  // Check height in pending anchor
         {
             return error("%s: Anchor blockHeight should be higher than previousAnchor height! %d > %d",
-                         __func__, anchor.height, prev->anchor.height);
+                         __func__,
+                         anchor.height,
+                         prev->anchor.height);
         }
     }
 
-    CBlockIndex* anchorIndex = ::ChainActive()[anchor.height];
+    CBlockIndex *anchorIndex = ::ChainActive()[anchor.height];
     if (!anchorIndex) {
         // Set to max to be used to avoid deleting pending anchor.
         anchorCreationHeight = std::numeric_limits<uint64_t>::max();
@@ -807,7 +811,10 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
 
     if (anchorIndex->GetBlockHash() != anchor.blockHash) {
         return error("%s: Anchor and blockchain mismatch at height %d. Expected %s found %s",
-                     __func__, anchor.height, anchorIndex->GetBlockHash().ToString(), anchor.blockHash.ToString());
+                     __func__,
+                     anchor.height,
+                     anchorIndex->GetBlockHash().ToString(),
+                     anchor.blockHash.ToString());
     }
 
     // Should already be checked before adding to pending, double check here.
@@ -816,7 +823,7 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
     }
 
     // Team entry
-    const CKeyID& teamData = *anchor.nextTeam.begin();
+    const CKeyID &teamData = *anchor.nextTeam.begin();
 
     std::shared_ptr<std::vector<unsigned char>> prefix;
 
@@ -828,13 +835,18 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
     // Only anchor by specified frequency
     if (anchorCreationHeight % Params().GetConsensus().mn.anchoringFrequency != 0) {
         return error("%s: Anchor height does not meet frequency rule. Height %ld, frequency %d",
-                     __func__, anchorCreationHeight, Params().GetConsensus().mn.anchoringFrequency);
+                     __func__,
+                     anchorCreationHeight,
+                     Params().GetConsensus().mn.anchoringFrequency);
     }
 
     // Make sure height exist
     const auto anchorCreationBlock = ::ChainActive()[anchorCreationHeight];
     if (anchorCreationBlock == nullptr) {
-        LogPrint(BCLog::ANCHORING, "%s: Cannot get block from anchor team data: height %ld\n", __func__, anchorCreationHeight);
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Cannot get block from anchor team data: height %ld\n",
+                 __func__,
+                 anchorCreationHeight);
 
         // Set to max to be used to avoid deleting pending anchor.
         anchorCreationHeight = std::numeric_limits<uint64_t>::max();
@@ -844,10 +856,14 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
 
     // Then match the hash prefix from anchor and active chain
     size_t prefixLength{CKeyID().size() - (spv::BtcAnchorMarker.size() * sizeof(uint8_t)) - sizeof(uint64_t)};
-    std::vector<unsigned char> hashPrefix{anchorCreationBlock->GetBlockHash().begin(), anchorCreationBlock->GetBlockHash().begin() + prefixLength};
+    std::vector<unsigned char> hashPrefix{anchorCreationBlock->GetBlockHash().begin(),
+                                          anchorCreationBlock->GetBlockHash().begin() + prefixLength};
     if (hashPrefix != *prefix) {
         return error("%s: Anchor prefix and active chain do not match. anchor %s active %s height %ld",
-                     __func__, HexStr(*prefix), HexStr(hashPrefix), anchorCreationHeight);
+                     __func__,
+                     HexStr(*prefix),
+                     HexStr(hashPrefix),
+                     anchorCreationHeight);
     }
 
     // Get start anchor height
@@ -874,7 +890,8 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
 
     // Check heights match
     if (static_cast<int>(anchor.height) != anchorHeight) {
-        return error("%s: Anchor height mismatch. Anchor height %d calculated height %d", __func__, anchor.height, anchorHeight);
+        return error(
+            "%s: Anchor height mismatch. Anchor height %d calculated height %d", __func__, anchor.height, anchorHeight);
     }
 
     anchorBlock = *::ChainActive()[anchorHeight];
@@ -882,28 +899,27 @@ bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex& anchorBloc
     return true;
 }
 
-uint256 CAnchorConfirmData::GetSignHash() const
-{
+uint256 CAnchorConfirmData::GetSignHash() const {
     CDataStream ss{SER_GETHASH, 0};
     ss << btcTxHash << anchorHeight << prevAnchorHeight << rewardKeyID << rewardKeyType;
     return Hash(ss.begin(), ss.end());
 }
 
-uint256 CAnchorConfirmDataPlus::GetSignHash() const
-{
+uint256 CAnchorConfirmDataPlus::GetSignHash() const {
     CDataStream ss{SER_GETHASH, 0};
     ss << btcTxHash << anchorHeight << prevAnchorHeight << rewardKeyID << rewardKeyType << dfiBlockHash << btcTxHeight;
     return Hash(ss.begin(), ss.end());
 }
 
-std::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const CAnchor& anchor, const THeight prevAnchorHeight,
-                                                                           const uint256 &btcTxHash, CKey const & key, const THeight btcTxHeight)
-{
+std::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const CAnchor &anchor,
+                                                                         const THeight prevAnchorHeight,
+                                                                         const uint256 &btcTxHash,
+                                                                         const CKey &key,
+                                                                         const THeight btcTxHeight) {
     // Potential post-fork unrewarded anchor
-    if (anchor.nextTeam.size() == 1)
-    {
+    if (anchor.nextTeam.size() == 1) {
         // Team data reference
-        const CKeyID& teamData = *anchor.nextTeam.begin();
+        const CKeyID &teamData = *anchor.nextTeam.begin();
 
         uint64_t anchorCreationHeight;
         std::shared_ptr<std::vector<unsigned char>> prefix;
@@ -912,8 +928,13 @@ std::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const C
         GetAnchorEmbeddedData(teamData, anchorCreationHeight, prefix);
     }
 
-    CAnchorConfirmMessage message(CAnchorConfirmDataPlus{btcTxHash, anchor.height, prevAnchorHeight, anchor.rewardKeyID,
-                                                         anchor.rewardKeyType, anchor.blockHash, btcTxHeight});
+    CAnchorConfirmMessage message(CAnchorConfirmDataPlus{btcTxHash,
+                                                         anchor.height,
+                                                         prevAnchorHeight,
+                                                         anchor.rewardKeyID,
+                                                         anchor.rewardKeyType,
+                                                         anchor.blockHash,
+                                                         btcTxHeight});
 
     if (!key.SignCompact(message.GetSignHash(), message.signature)) {
         message.signature.clear();
@@ -922,26 +943,22 @@ std::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const C
     return message;
 }
 
-uint256 CAnchorConfirmMessage::GetHash() const
-{
+uint256 CAnchorConfirmMessage::GetHash() const {
     CDataStream ss{SER_NETWORK, PROTOCOL_VERSION};
     ss << *this;
     return Hash(ss.begin(), ss.end());
 }
 
-CKeyID CAnchorConfirmMessage::GetSigner() const
-{
+CKeyID CAnchorConfirmMessage::GetSigner() const {
     CPubKey pubKey;
     return (!signature.empty() && pubKey.RecoverCompact(GetSignHash(), signature)) ? pubKey.GetID() : CKeyID{};
 }
 
-bool CAnchorFinalizationMessage::CheckConfirmSigs()
-{
+bool CAnchorFinalizationMessage::CheckConfirmSigs() {
     return CheckSigs(GetSignHash(), sigs, currentTeam);
 }
 
-size_t CAnchorFinalizationMessagePlus::CheckConfirmSigs(const uint32_t height)
-{
+size_t CAnchorFinalizationMessagePlus::CheckConfirmSigs(const uint32_t height) {
     auto team = pcustomcsview->GetConfirmTeam(height);
     if (!team) {
         return false;
@@ -949,39 +966,41 @@ size_t CAnchorFinalizationMessagePlus::CheckConfirmSigs(const uint32_t height)
     return CheckSigs(GetSignHash(), sigs, *team);
 }
 
-bool CAnchorAwaitingConfirms::EraseAnchor(AnchorTxHash const &txHash)
-{
+bool CAnchorAwaitingConfirms::EraseAnchor(const AnchorTxHash &txHash) {
     AssertLockHeld(cs_main);
 
-    auto & list = confirms.get<Confirm::ByAnchor>();
-    auto count = list.erase(txHash); // should erase ALL with that key. Check it!
-    LogPrint(BCLog::ANCHORING, "AnchorConfirms::EraseAnchor: erase %d confirms for anchor %s\n", count, txHash.ToString());
+    auto &list = confirms.get<Confirm::ByAnchor>();
+    auto count = list.erase(txHash);  // should erase ALL with that key. Check it!
+    LogPrint(
+        BCLog::ANCHORING, "AnchorConfirms::EraseAnchor: erase %d confirms for anchor %s\n", count, txHash.ToString());
 
     return count > 0;
 }
 
-const CAnchorConfirmMessage *CAnchorAwaitingConfirms::GetConfirm(ConfirmMessageHash const &msgHash) const
-{
+const CAnchorConfirmMessage *CAnchorAwaitingConfirms::GetConfirm(const ConfirmMessageHash &msgHash) const {
     AssertLockHeld(cs_main);
 
-    auto const & list = confirms.get<Confirm::ByMsgHash>();
-    auto it = list.find(msgHash);
+    const auto &list = confirms.get<Confirm::ByMsgHash>();
+    auto it          = list.find(msgHash);
     return it != list.end() ? &(*it) : nullptr;
 }
 
-bool CAnchorAwaitingConfirms::Validate(CAnchorConfirmMessage const &confirmMessage) const
-{
+bool CAnchorAwaitingConfirms::Validate(const CAnchorConfirmMessage &confirmMessage) const {
     AssertLockHeld(cs_main);
 
     CKeyID signer = confirmMessage.GetSigner();
     if (signer.IsNull()) {
-        LogPrint(BCLog::ANCHORING, "%s: Warning! Signature incorrect. btcTxHash: %s confirmMessageHash: %s Key: %s\n",
-                 __func__, confirmMessage.btcTxHash.ToString(), confirmMessage.GetHash().ToString(), signer.ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Warning! Signature incorrect. btcTxHash: %s confirmMessageHash: %s Key: %s\n",
+                 __func__,
+                 confirmMessage.btcTxHash.ToString(),
+                 confirmMessage.GetHash().ToString(),
+                 signer.ToString());
         return false;
     }
 
     const auto height = ::ChainActive().Height();
-    const auto team = pcustomcsview->GetConfirmTeam(height);
+    const auto team   = pcustomcsview->GetConfirmTeam(height);
     if (!team) {
         LogPrint(BCLog::ANCHORING, "%s: Unable to get team for current height %d\n", __func__, height);
         return false;
@@ -994,19 +1013,29 @@ bool CAnchorAwaitingConfirms::Validate(CAnchorConfirmMessage const &confirmMessa
 
     auto it = pcustomcsview->GetMasternodeIdByOperator(signer);
     if (!it || !pcustomcsview->GetMasternode(*it)->IsActive(height, *pcustomcsview)) {
-        LogPrint(BCLog::ANCHORING, "%s: Warning! Masternode with operator key %s does not exist or not active!\n", __func__, signer.ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Warning! Masternode with operator key %s does not exist or not active!\n",
+                 __func__,
+                 signer.ToString());
         return false;
     }
 
-    CBlockIndex* anchorIndex = ::ChainActive()[confirmMessage.anchorHeight];
+    CBlockIndex *anchorIndex = ::ChainActive()[confirmMessage.anchorHeight];
     if (!anchorIndex) {
-        LogPrint(BCLog::ANCHORING, "%s: Active chain does not contain block height %d\n", __func__, confirmMessage.anchorHeight);
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Active chain does not contain block height %d\n",
+                 __func__,
+                 confirmMessage.anchorHeight);
         return false;
     }
 
     if (anchorIndex->GetBlockHash() != confirmMessage.dfiBlockHash) {
-        LogPrint(BCLog::ANCHORING, "%s: Anchor and blockchain mismatch at height %d. Expected %s found %s\n",
-                 __func__, confirmMessage.anchorHeight, anchorIndex->GetBlockHash().ToString(), confirmMessage.dfiBlockHash.ToString());
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Anchor and blockchain mismatch at height %d. Expected %s found %s\n",
+                 __func__,
+                 confirmMessage.anchorHeight,
+                 anchorIndex->GetBlockHash().ToString(),
+                 confirmMessage.dfiBlockHash.ToString());
         return false;
     }
 
@@ -1018,20 +1047,17 @@ bool CAnchorAwaitingConfirms::Validate(CAnchorConfirmMessage const &confirmMessa
     return true;
 }
 
-bool CAnchorAwaitingConfirms::Add(CAnchorConfirmMessage const &newConfirmMessage)
-{
+bool CAnchorAwaitingConfirms::Add(const CAnchorConfirmMessage &newConfirmMessage) {
     AssertLockHeld(cs_main);
     return confirms.insert(newConfirmMessage).second;
 }
 
-void CAnchorAwaitingConfirms::Clear()
-{
+void CAnchorAwaitingConfirms::Clear() {
     AssertLockHeld(cs_main);
     Confirms().swap(confirms);
 }
 
-void CAnchorAwaitingConfirms::ReVote()
-{
+void CAnchorAwaitingConfirms::ReVote() {
     AssertLockHeld(cs_main);
 
     const auto height = ::ChainActive().Height();
@@ -1046,31 +1072,30 @@ void CAnchorAwaitingConfirms::ReVote()
 
     const auto operatorDetails = AmISignerNow(height, currentTeam);
 
-    for (const auto& keys : operatorDetails) {
+    for (const auto &keys : operatorDetails) {
         CAnchorIndex::UnrewardedResult unrewarded = panchors->GetUnrewarded();
-        for (auto const & btcTxHash : unrewarded) {
-            pcustomcsview->CreateAndRelayConfirmMessageIfNeed(panchors->GetAnchorByTx(btcTxHash), btcTxHash, keys.second);
+        for (const auto &btcTxHash : unrewarded) {
+            pcustomcsview->CreateAndRelayConfirmMessageIfNeed(
+                panchors->GetAnchorByTx(btcTxHash), btcTxHash, keys.second);
         }
     }
-
 }
 
 // for MINERS only!
-std::vector<CAnchorConfirmMessage> CAnchorAwaitingConfirms::GetQuorumFor(const CAnchorData::CTeam & team) const
-{
+std::vector<CAnchorConfirmMessage> CAnchorAwaitingConfirms::GetQuorumFor(const CAnchorData::CTeam &team) const {
     AssertLockHeld(cs_main);
 
     typedef Confirms::index<Confirm::ByKey>::type KList;
-    KList const & list = confirms.get<Confirm::ByKey>();
-    uint32_t quorum = GetMinAnchorQuorum(team);
+    const KList &list = confirms.get<Confirm::ByKey>();
+    uint32_t quorum   = GetMinAnchorQuorum(team);
 
     std::vector<CAnchorConfirmMessage> result;
 
     for (auto it = list.begin(); it != list.end(); /* w/o advance! */) {
         // get next group of confirms
         KList::iterator it0, it1;
-        std::tie(it0,it1) = list.equal_range(std::make_tuple(it->btcTxHeight, it->btcTxHash));
-        if (std::distance(it0,it1) >= quorum) {
+        std::tie(it0, it1) = list.equal_range(std::make_tuple(it->btcTxHeight, it->btcTxHash));
+        if (std::distance(it0, it1) >= quorum) {
             result.clear();
             for (; result.size() < quorum && it0 != it1; ++it0) {
                 if (team.find(it0->GetSigner()) != team.end()) {
@@ -1081,21 +1106,22 @@ std::vector<CAnchorConfirmMessage> CAnchorAwaitingConfirms::GetQuorumFor(const C
                 return result;
             }
         }
-        it = it1; // next group!
+        it = it1;  // next group!
     }
     return {};
 }
 
-void CAnchorAwaitingConfirms::ForEachConfirm(std::function<void (const CAnchorAwaitingConfirms::Confirm &)> callback) const
-{
+void CAnchorAwaitingConfirms::ForEachConfirm(
+    std::function<void(const CAnchorAwaitingConfirms::Confirm &)> callback) const {
     AssertLockHeld(cs_main);
-    auto const & list = confirms.get<Confirm::ByKey>();
+    const auto &list = confirms.get<Confirm::ByKey>();
     for (auto it = list.begin(); it != list.end(); ++it)
         callback(*it);
 }
 
-bool GetAnchorEmbeddedData(const CKeyID& data, uint64_t& anchorCreationHeight, std::shared_ptr<std::vector<unsigned char>>& prefix)
-{
+bool GetAnchorEmbeddedData(const CKeyID &data,
+                           uint64_t &anchorCreationHeight,
+                           std::shared_ptr<std::vector<unsigned char>> &prefix) {
     // Blockhash prefix length
     size_t prefixLength{CKeyID().size() - (spv::BtcAnchorMarker.size() * sizeof(uint8_t)) - sizeof(uint64_t)};
 
@@ -1117,29 +1143,25 @@ bool GetAnchorEmbeddedData(const CKeyID& data, uint64_t& anchorCreationHeight, s
     return true;
 }
 
-namespace spv
-{
-const PendingOrderType PendingOrder = PendingOrderType([](const CAnchorIndex::AnchorRec& a, const CAnchorIndex::AnchorRec& b)
-{
-    if (a.btcHeight == b.btcHeight)
-    {
-        if (a.anchor.height == b.anchor.height)
-        {
-            if (a.anchor.height >= static_cast<THeight>(Params().GetConsensus().EunosHeight))
-            {
-                const auto blockHash = panchors->ReadBlockHash(a.btcHeight);
-                auto aHash = Hash(a.txHash.begin(), a.txHash.end(), blockHash.begin(), blockHash.end());
-                auto bHash = Hash(b.txHash.begin(), b.txHash.end(), blockHash.begin(), blockHash.end());
-                return aHash < bHash;
+namespace spv {
+const PendingOrderType PendingOrder =
+    PendingOrderType([](const CAnchorIndex::AnchorRec &a, const CAnchorIndex::AnchorRec &b) {
+        if (a.btcHeight == b.btcHeight) {
+            if (a.anchor.height == b.anchor.height) {
+                if (a.anchor.height >= static_cast<THeight>(Params().GetConsensus().EunosHeight)) {
+                    const auto blockHash = panchors->ReadBlockHash(a.btcHeight);
+                    auto aHash           = Hash(a.txHash.begin(), a.txHash.end(), blockHash.begin(), blockHash.end());
+                    auto bHash           = Hash(b.txHash.begin(), b.txHash.end(), blockHash.begin(), blockHash.end());
+                    return aHash < bHash;
+                }
+
+                return a.txHash < b.txHash;
             }
 
-            return a.txHash < b.txHash;
+            // Higher DeFi comes first
+            return a.anchor.height > b.anchor.height;
         }
 
-        // Higher DeFi comes first
-        return a.anchor.height > b.anchor.height;
-    }
-
-    return a.btcHeight < b.btcHeight;
-});
+        return a.btcHeight < b.btcHeight;
+    });
 }
diff --git a/src/masternodes/anchors.h b/src/masternodes/anchors.h
index c7659be26b..5129b772ac 100644
--- a/src/masternodes/anchors.h
+++ b/src/masternodes/anchors.h
@@ -15,13 +15,13 @@
 #include <functional>
 #include <vector>
 
-#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/composite_key.hpp>
+#include <boost/multi_index/indexed_by.hpp>
 #include <boost/multi_index/mem_fun.hpp>
 #include <boost/multi_index/member.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/multi_index/indexed_by.hpp>
-#include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/tag.hpp>
+#include <boost/multi_index_container.hpp>
 
 #include <dbwrapper.h>
 
@@ -29,99 +29,92 @@ class CBlockIndex;
 class CKey;
 class CPubkey;
 
-namespace spv
-{
-    class CSpvWrapper;
-    struct BtcAnchorTx;
-}
+namespace spv {
+class CSpvWrapper;
+struct BtcAnchorTx;
+}  // namespace spv
 
-namespace Consensus
-{
-    struct Params;
+namespace Consensus {
+struct Params;
 }
 
-typedef uint32_t THeight; // cause not decided yet which type to use for heights
+typedef uint32_t THeight;  // cause not decided yet which type to use for heights
 
-struct CAnchorData
-{
+struct CAnchorData {
     using CTeam = std::set<CKeyID>;
 
-    uint256 previousAnchor;         ///< Previous tx-AnchorAnnouncement on BTC chain
-    THeight height;                 ///< Height of the anchor block (DeFi)
-    uint256 blockHash;              ///< Hash of the anchor block (DeFi)
-    CTeam nextTeam;                 ///< Calculated based on stake modifier at {blockHash}
+    uint256 previousAnchor;  ///< Previous tx-AnchorAnnouncement on BTC chain
+    THeight height;          ///< Height of the anchor block (DeFi)
+    uint256 blockHash;       ///< Hash of the anchor block (DeFi)
+    CTeam nextTeam;          ///< Calculated based on stake modifier at {blockHash}
 
     uint256 GetSignHash() const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-         READWRITE(previousAnchor);
-         READWRITE(height);
-         READWRITE(blockHash);
-         READWRITE(nextTeam);
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITE(previousAnchor);
+        READWRITE(height);
+        READWRITE(blockHash);
+        READWRITE(nextTeam);
     }
 };
 
-class CAnchorAuthMessage : public CAnchorData
-{
+class CAnchorAuthMessage : public CAnchorData {
     using Signature = std::vector<unsigned char>;
-public:
 
-    CAnchorAuthMessage(CAnchorData const & base = CAnchorData())
-        : CAnchorData(base)
-        , signature()
-    {}
+public:
+    CAnchorAuthMessage(const CAnchorData &base = CAnchorData())
+        : CAnchorData(base),
+          signature() {}
 
     Signature GetSignature() const;
     uint256 GetHash() const;
-    bool SignWithKey(const CKey& key);
-    bool GetPubKey(CPubKey& pubKey) const;
+    bool SignWithKey(const CKey &key);
+    bool GetPubKey(CPubKey &pubKey) const;
     CKeyID GetSigner() const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-         READWRITEAS(CAnchorData, *this);
-         READWRITE(signature);
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITEAS(CAnchorData, *this);
+        READWRITE(signature);
     }
 
     // tags for multiindex
-    struct ByMsgHash{};     // by message hash (for inv)
-    struct ByBlockHash{};   // by blockhash (for locator/GETANCHORAUTHS)
-    struct ByKey{};         // composite, by height and GetSignHash for anchor creation
-    struct ByVote{};        // composite, by GetSignHash and signer, helps detect doublesigning
+    struct ByMsgHash {};    // by message hash (for inv)
+    struct ByBlockHash {};  // by blockhash (for locator/GETANCHORAUTHS)
+    struct ByKey {};        // composite, by height and GetSignHash for anchor creation
+    struct ByVote {};       // composite, by GetSignHash and signer, helps detect doublesigning
 
 private:
     Signature signature;
 };
 
-class CAnchor : public CAnchorData
-{
+class CAnchor : public CAnchorData {
     using Signature = std::vector<unsigned char>;
-    using CTeam = CAnchorData::CTeam;
+    using CTeam     = CAnchorData::CTeam;
 
 public:
     std::vector<Signature> sigs;
     CKeyID rewardKeyID;
     char rewardKeyType;
 
-    CAnchor(CAnchorData const & base = CAnchorData())
-        : CAnchorData(base)
-        , sigs()
-        , rewardKeyID()
-        , rewardKeyType(0)
-    {}
+    CAnchor(const CAnchorData &base = CAnchorData())
+        : CAnchorData(base),
+          sigs(),
+          rewardKeyID(),
+          rewardKeyType(0) {}
 
-    static CAnchor Create(std::vector<CAnchorAuthMessage> const & auths, CTxDestination const & rewardDest);
-    bool CheckAuthSigs(CTeam const & team) const;
+    static CAnchor Create(const std::vector<CAnchorAuthMessage> &auths, const CTxDestination &rewardDest);
+    bool CheckAuthSigs(const CTeam &team) const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAnchorData, *this);
         READWRITE(sigs);
         READWRITE(rewardKeyID);
@@ -129,52 +122,43 @@ class CAnchor : public CAnchorData
     }
 };
 
-
 using namespace boost::multi_index;
 
-class CAnchorAuthIndex
-{
+class CAnchorAuthIndex {
     using CTeam = CAnchorData::CTeam;
 
 public:
     using Auth = CAnchorAuthMessage;
 
-    typedef boost::multi_index_container<Auth,
+    typedef boost::multi_index_container<
+        Auth,
         indexed_by<
             // index for p2p messaging (inv/getdata)
-            ordered_unique<
-                tag<Auth::ByMsgHash>, const_mem_fun<Auth, uint256, &Auth::GetHash>
-            >,
+            ordered_unique<tag<Auth::ByMsgHash>, const_mem_fun<Auth, uint256, &Auth::GetHash>>,
             // index for locator/GETANCHORAUTHS
-            ordered_non_unique<
-                tag<Auth::ByBlockHash>, member<CAnchorData, uint256, &CAnchorData::blockHash>
-            >,
+            ordered_non_unique<tag<Auth::ByBlockHash>, member<CAnchorData, uint256, &CAnchorData::blockHash>>,
             // index for quorum selection (CreateBestAnchor())
             // just to remember that there may be auths with equal blockHash, but with different prevs and teams!
-            ordered_non_unique<
-                tag<Auth::ByKey>, composite_key<Auth,
-                    member<CAnchorData, THeight, &CAnchorData::height>,
-                    const_mem_fun<CAnchorData, uint256, &CAnchorData::GetSignHash>
-                >
-            >,
+            ordered_non_unique<tag<Auth::ByKey>,
+                               composite_key<Auth,
+                                             member<CAnchorData, THeight, &CAnchorData::height>,
+                                             const_mem_fun<CAnchorData, uint256, &CAnchorData::GetSignHash>>>,
             // restriction index that helps detect doublesigning
             // it may by quite expensive to index by GetSigner on the fly, but it should happen only on insertion
-            ordered_unique<
-                tag<Auth::ByVote>, composite_key<Auth,
-                    const_mem_fun<CAnchorData, uint256, &CAnchorData::GetSignHash>,
-                    const_mem_fun<Auth, CKeyID, &Auth::GetSigner>
-                >
-            >
+            ordered_unique<tag<Auth::ByVote>,
+                           composite_key<Auth,
+                                         const_mem_fun<CAnchorData, uint256, &CAnchorData::GetSignHash>,
+                                         const_mem_fun<Auth, CKeyID, &Auth::GetSigner>>>
 
-        >
-    > Auths;
+            >>
+        Auths;
 
-    Auth const * GetAuth(uint256 const & msgHash) const;
-    Auth const * GetVote(uint256 const & signHash, CKeyID const & signer) const;
-    bool ValidateAuth(Auth const & auth) const;
-    bool AddAuth(Auth const & auth);
+    const Auth *GetAuth(const uint256 &msgHash) const;
+    const Auth *GetVote(const uint256 &signHash, const CKeyID &signer) const;
+    bool ValidateAuth(const Auth &auth) const;
+    bool AddAuth(const Auth &auth);
 
-    CAnchor CreateBestAnchor(CTxDestination const & rewardDest) const;
+    CAnchor CreateBestAnchor(const CTxDestination &rewardDest) const;
     void ForEachAnchorAuthByHeight(std::function<bool(const CAnchorAuthIndex::Auth &)> callback) const;
     void PruneOlderThan(THeight height);
 
@@ -182,14 +166,14 @@ class CAnchorAuthIndex
     Auths auths;
 };
 
-class CAnchorIndex
-{
+class CAnchorIndex {
 private:
     std::unique_ptr<CDBWrapper> db;
     std::unique_ptr<CDBBatch> batch;
+
 public:
     using Signature = std::vector<unsigned char>;
-    using CTeam = CAnchorData::CTeam;
+    using CTeam     = CAnchorData::CTeam;
 
     struct AnchorRec {
         CAnchor anchor;
@@ -199,89 +183,85 @@ class CAnchorIndex
         ADD_SERIALIZE_METHODS;
 
         template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
+        inline void SerializationOp(Stream &s, Operation ser_action) {
             READWRITE(anchor);
             READWRITE(txHash);
             READWRITE(btcHeight);
         }
 
         // tags for multiindex
-        struct ByBtcTxHash{};
-        struct ByBtcHeight{};
-        struct ByDeFiHeight{};
+        struct ByBtcTxHash {};
+        struct ByBtcHeight {};
+        struct ByDeFiHeight {};
 
-        THeight DeFiBlockHeight() const {return anchor.height;}
+        THeight DeFiBlockHeight() const { return anchor.height; }
     };
 
-    typedef boost::multi_index_container<AnchorRec,
-        indexed_by<
-            ordered_unique    < tag<AnchorRec::ByBtcTxHash>,  member<AnchorRec, uint256,  &AnchorRec::txHash> >,
-            ordered_non_unique< tag<AnchorRec::ByBtcHeight>,  member<AnchorRec, THeight,  &AnchorRec::btcHeight> >,
-            ordered_non_unique< tag<AnchorRec::ByDeFiHeight>, const_mem_fun<AnchorRec, THeight, &AnchorRec::DeFiBlockHeight> >
-        >
-    > AnchorIndexImpl;
+    typedef boost::multi_index_container<
+        AnchorRec,
+        indexed_by<ordered_unique<tag<AnchorRec::ByBtcTxHash>, member<AnchorRec, uint256, &AnchorRec::txHash>>,
+                   ordered_non_unique<tag<AnchorRec::ByBtcHeight>, member<AnchorRec, THeight, &AnchorRec::btcHeight>>,
+                   ordered_non_unique<tag<AnchorRec::ByDeFiHeight>,
+                                      const_mem_fun<AnchorRec, THeight, &AnchorRec::DeFiBlockHeight>>>>
+        AnchorIndexImpl;
 
     CAnchorIndex(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
     bool Load();
 
     void ForEachAnchorByBtcHeight(std::function<bool(const CAnchorIndex::AnchorRec &)> callback) const;
-    AnchorRec const * GetActiveAnchor() const;
-    bool ActivateBestAnchor(bool forced = false); // rescan anchors
+    const AnchorRec *GetActiveAnchor() const;
+    bool ActivateBestAnchor(bool forced = false);  // rescan anchors
 
-    AnchorRec const * GetAnchorByTx(uint256 const & hash) const;
+    const AnchorRec *GetAnchorByTx(const uint256 &hash) const;
 
-    bool AddAnchor(CAnchor const & anchor, uint256 const & btcTxHash, THeight btcBlockHeight, bool overwrite = true);
-    bool DeleteAnchorByBtcTx(uint256 const & btcTxHash);
+    bool AddAnchor(const CAnchor &anchor, const uint256 &btcTxHash, THeight btcBlockHeight, bool overwrite = true);
+    bool DeleteAnchorByBtcTx(const uint256 &btcTxHash);
 
-    CAnchorData::CTeam GetNextTeam(uint256 const & btcPrevTx) const;
+    CAnchorData::CTeam GetNextTeam(const uint256 &btcPrevTx) const;
 
-    AnchorRec const * GetAnchorByBtcTx(uint256 const & txHash) const;
+    const AnchorRec *GetAnchorByBtcTx(const uint256 &txHash) const;
 
     using UnrewardedResult = std::set<uint256>;
     UnrewardedResult GetUnrewarded() const;
 
-    int GetAnchorConfirmations(uint256 const & txHash) const;
-    int GetAnchorConfirmations(AnchorRec const * rec) const;
+    int GetAnchorConfirmations(const uint256 &txHash) const;
+    int GetAnchorConfirmations(const AnchorRec *rec) const;
 
     void CheckActiveAnchor(uint32_t height, bool forced = false);
     void UpdateLastHeight(uint32_t height);
 
     // Post-fork anchor pending, requires chain context to validate. Some pending may be bogus, intentional or not.
-    bool AddToAnchorPending(const AnchorRec& rec);
-    bool GetPendingByBtcTx(uint256 const & txHash, AnchorRec & rec) const;
-    void DeletePendingByBtcTx(uint256 const & btcTxHash);
-    void ForEachPending(std::function<void (const uint256 &, AnchorRec &)> callback);
+    bool AddToAnchorPending(const AnchorRec &rec);
+    bool GetPendingByBtcTx(const uint256 &txHash, AnchorRec &rec) const;
+    void DeletePendingByBtcTx(const uint256 &btcTxHash);
+    void ForEachPending(std::function<void(const uint256 &, AnchorRec &)> callback);
 
     // Used to apply chain context to post-fork anchors which get added to pending.
     void CheckPendingAnchors();
 
     // Store and read Bitcoin block hash by height, used in BestOfTwo calculation.
-    bool WriteBlock(const uint32_t height, const uint256& blockHash);
-    uint256 ReadBlockHash(const uint32_t& height);
+    bool WriteBlock(const uint32_t height, const uint256 &blockHash);
+    uint256 ReadBlockHash(const uint32_t &height);
 
-    AnchorRec const * GetLatestAnchorUpToDeFiHeight(THeight blockHeightDeFi) const;
+    const AnchorRec *GetLatestAnchorUpToDeFiHeight(THeight blockHeightDeFi) const;
 
 private:
     AnchorIndexImpl anchors;
-    AnchorRec const * top = nullptr;
+    const AnchorRec *top      = nullptr;
     bool possibleReActivation = false;
-    uint32_t spvLastHeight = 0;
+    uint32_t spvLastHeight    = 0;
 
 private:
     template <typename Key, typename Value>
-    bool IterateTable(char prefix, std::function<void(Key const &, Value &)> callback)
-    {
-        std::unique_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
+    bool IterateTable(char prefix, std::function<void(const Key &, Value &)> callback) {
+        std::unique_ptr<CDBIterator> pcursor(const_cast<CDBWrapper *>(&*db)->NewIterator());
         pcursor->Seek(prefix);
 
-        while (pcursor->Valid())
-        {
+        while (pcursor->Valid()) {
             std::pair<char, Key> key;
-            if (pcursor->GetKey(key) && key.first == prefix)
-            {
+            if (pcursor->GetKey(key) && key.first == prefix) {
                 Value value;
-                if (pcursor->GetValue(value))
-                {
+                if (pcursor->GetValue(value)) {
                     callback(key.second, value);
                 } else {
                     return error("Anchors::Load() : unable to read value");
@@ -294,13 +274,12 @@ class CAnchorIndex
         return true;
     }
 
-    bool DbExists(uint256 const & hash) const;
-    bool DbWrite(AnchorRec const & anchor);
-    bool DbErase(uint256 const & hash);
+    bool DbExists(const uint256 &hash) const;
+    bool DbWrite(const AnchorRec &anchor);
+    bool DbErase(const uint256 &hash);
 };
 
-struct CAnchorConfirmData
-{
+struct CAnchorConfirmData {
     uint256 btcTxHash;
     THeight anchorHeight;
     THeight prevAnchorHeight;
@@ -312,7 +291,7 @@ struct CAnchorConfirmData
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(btcTxHash);
         READWRITE(anchorHeight);
         READWRITE(prevAnchorHeight);
@@ -321,10 +300,8 @@ struct CAnchorConfirmData
     }
 };
 
-
 // derived from common struct at list to avoid serialization mistakes
-struct CAnchorFinalizationMessage : public CAnchorConfirmData
-{
+struct CAnchorFinalizationMessage : public CAnchorConfirmData {
     using Signature = std::vector<unsigned char>;
 
     // (base data + teams + all signs)
@@ -332,19 +309,18 @@ struct CAnchorFinalizationMessage : public CAnchorConfirmData
     CAnchorData::CTeam currentTeam;
     std::vector<Signature> sigs;
 
-    CAnchorFinalizationMessage(CAnchorConfirmData const & base = CAnchorConfirmData())
-        : CAnchorConfirmData(base)
-        , nextTeam()
-        , currentTeam()
-        , sigs()
-    {}
+    CAnchorFinalizationMessage(const CAnchorConfirmData &base = CAnchorConfirmData())
+        : CAnchorConfirmData(base),
+          nextTeam(),
+          currentTeam(),
+          sigs() {}
 
     bool CheckConfirmSigs();
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAnchorConfirmData, *this);
         READWRITE(nextTeam);
         READWRITE(currentTeam);
@@ -352,22 +328,23 @@ struct CAnchorFinalizationMessage : public CAnchorConfirmData
     }
 };
 
-
-struct CAnchorConfirmDataPlus : public CAnchorConfirmData
-{
+struct CAnchorConfirmDataPlus : public CAnchorConfirmData {
     uint256 dfiBlockHash;
     THeight btcTxHeight{0};
 
-    CAnchorConfirmDataPlus(const uint256& btcTxHash, const THeight anchorHeight, const THeight prevAnchorHeight, const CKeyID& rewardKeyID,
-                           const char rewardKeyType, const uint256& dfiBlockHash, const THeight btcTxHeight)
+    CAnchorConfirmDataPlus(const uint256 &btcTxHash,
+                           const THeight anchorHeight,
+                           const THeight prevAnchorHeight,
+                           const CKeyID &rewardKeyID,
+                           const char rewardKeyType,
+                           const uint256 &dfiBlockHash,
+                           const THeight btcTxHeight)
         : CAnchorConfirmData{btcTxHash, anchorHeight, prevAnchorHeight, rewardKeyID, rewardKeyType},
           dfiBlockHash{dfiBlockHash},
-          btcTxHeight{btcTxHeight}
-    {}
+          btcTxHeight{btcTxHeight} {}
 
-    explicit CAnchorConfirmDataPlus(const CAnchorFinalizationMessage& base)
-        : CAnchorConfirmData(base)
-    {}
+    explicit CAnchorConfirmDataPlus(const CAnchorFinalizationMessage &base)
+        : CAnchorConfirmData(base) {}
 
     CAnchorConfirmDataPlus() = default;
 
@@ -376,7 +353,7 @@ struct CAnchorConfirmDataPlus : public CAnchorConfirmData
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAnchorConfirmData, *this);
         READWRITE(dfiBlockHash);
         READWRITE(btcTxHeight);
@@ -384,117 +361,108 @@ struct CAnchorConfirmDataPlus : public CAnchorConfirmData
 };
 
 // single confirmation message
-class CAnchorConfirmMessage : public CAnchorConfirmDataPlus
-{
+class CAnchorConfirmMessage : public CAnchorConfirmDataPlus {
 public:
     using Signature = std::vector<unsigned char>;
 
     // (base data + single sign)
     Signature signature;
 
-    CAnchorConfirmMessage(CAnchorConfirmDataPlus const & base = CAnchorConfirmDataPlus())
-        : CAnchorConfirmDataPlus(base)
-        , signature()
-    {}
+    CAnchorConfirmMessage(const CAnchorConfirmDataPlus &base = CAnchorConfirmDataPlus())
+        : CAnchorConfirmDataPlus(base),
+          signature() {}
 
-    static std::optional<CAnchorConfirmMessage> CreateSigned(const CAnchor &anchor, const THeight prevAnchorHeight,
-                                                               const uint256 &btcTxHash, CKey const & key, const THeight btcTxHeight);
+    static std::optional<CAnchorConfirmMessage> CreateSigned(const CAnchor &anchor,
+                                                             const THeight prevAnchorHeight,
+                                                             const uint256 &btcTxHash,
+                                                             const CKey &key,
+                                                             const THeight btcTxHeight);
     uint256 GetHash() const;
     CKeyID GetSigner() const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAnchorConfirmDataPlus, *this);
         READWRITE(signature);
     }
 
     // tags for multiindex
-    struct ByMsgHash{};     // by message hash (for inv)
-    struct ByAnchor{};      // by btctxhash
-    struct ByKey{};         // composite, by btctxhash and GetSignHash for miner/reward creation
-    struct ByVote{};        // composite, by GetSignHash and signer, helps detect doublesigning
+    struct ByMsgHash {};  // by message hash (for inv)
+    struct ByAnchor {};   // by btctxhash
+    struct ByKey {};      // composite, by btctxhash and GetSignHash for miner/reward creation
+    struct ByVote {};     // composite, by GetSignHash and signer, helps detect doublesigning
 };
 
 // derived from common struct at list to avoid serialization mistakes
-struct CAnchorFinalizationMessagePlus : public CAnchorConfirmDataPlus
-{
+struct CAnchorFinalizationMessagePlus : public CAnchorConfirmDataPlus {
     std::vector<CAnchorConfirmMessage::Signature> sigs;
 
-    CAnchorFinalizationMessagePlus(CAnchorConfirmDataPlus const & base = CAnchorConfirmDataPlus())
-        : CAnchorConfirmDataPlus(base)
-        , sigs()
-    {}
+    CAnchorFinalizationMessagePlus(const CAnchorConfirmDataPlus &base = CAnchorConfirmDataPlus())
+        : CAnchorConfirmDataPlus(base),
+          sigs() {}
 
     size_t CheckConfirmSigs(const uint32_t height);
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAnchorConfirmDataPlus, *this);
         READWRITE(sigs);
     }
 };
 
-class CAnchorAwaitingConfirms
-{
+class CAnchorAwaitingConfirms {
     using ConfirmMessageHash = uint256;
-    using AnchorTxHash = uint256;
+    using AnchorTxHash       = uint256;
 
 private:
     using Confirm = CAnchorConfirmMessage;
 
-    typedef boost::multi_index_container<Confirm,
+    typedef boost::multi_index_container<
+        Confirm,
         indexed_by<
             // index for p2p messaging (inv/getdata)
-            ordered_unique<
-                tag<Confirm::ByMsgHash>, const_mem_fun<Confirm, uint256, &Confirm::GetHash>
-            >,
+            ordered_unique<tag<Confirm::ByMsgHash>, const_mem_fun<Confirm, uint256, &Confirm::GetHash>>,
             // index for group confirms deletion
-            ordered_non_unique<
-                tag<Confirm::ByAnchor>, member<CAnchorConfirmData, uint256, &CAnchorConfirmData::btcTxHash>
-            >,
+            ordered_non_unique<tag<Confirm::ByAnchor>,
+                               member<CAnchorConfirmData, uint256, &CAnchorConfirmData::btcTxHash>>,
             // index for quorum selection (miner affected) Protected against double signing.
             // just to remember that there may be confirms with equal btcTxHeight, but with different teams!
-            ordered_unique<
-                tag<Confirm::ByKey>, composite_key<Confirm,
-                    member<CAnchorConfirmDataPlus, THeight, &CAnchorConfirmDataPlus::btcTxHeight>,
-                    member<CAnchorConfirmData, uint256, &CAnchorConfirmData::btcTxHash>,
-                    const_mem_fun<Confirm, CKeyID, &Confirm::GetSigner>
-                >
-            >,
+            ordered_unique<tag<Confirm::ByKey>,
+                           composite_key<Confirm,
+                                         member<CAnchorConfirmDataPlus, THeight, &CAnchorConfirmDataPlus::btcTxHeight>,
+                                         member<CAnchorConfirmData, uint256, &CAnchorConfirmData::btcTxHash>,
+                                         const_mem_fun<Confirm, CKeyID, &Confirm::GetSigner>>>,
             // restriction index that helps detect doublesigning
             // it may by quite expensive to index by GetSigner on the fly, but it should happen only on insertion
             ordered_unique<
-                tag<Confirm::ByVote>, composite_key<Confirm,
-                    const_mem_fun<CAnchorConfirmDataPlus, uint256, &CAnchorConfirmDataPlus::GetSignHash>,
-                    const_mem_fun<Confirm, CKeyID, &Confirm::GetSigner>
-                >
-            >
-        >
-    > Confirms;
+                tag<Confirm::ByVote>,
+                composite_key<Confirm,
+                              const_mem_fun<CAnchorConfirmDataPlus, uint256, &CAnchorConfirmDataPlus::GetSignHash>,
+                              const_mem_fun<Confirm, CKeyID, &Confirm::GetSigner>>>>>
+        Confirms;
 
     Confirms confirms;
 
 public:
-    bool EraseAnchor(AnchorTxHash const &txHash);
-    const CAnchorConfirmMessage *GetConfirm(ConfirmMessageHash const &msgHash) const;
-    bool Add(CAnchorConfirmMessage const &newConfirmMessage);
-    bool Validate(CAnchorConfirmMessage const &confirmMessage) const;
+    bool EraseAnchor(const AnchorTxHash &txHash);
+    const CAnchorConfirmMessage *GetConfirm(const ConfirmMessageHash &msgHash) const;
+    bool Add(const CAnchorConfirmMessage &newConfirmMessage);
+    bool Validate(const CAnchorConfirmMessage &confirmMessage) const;
     void Clear();
     void ReVote();
-    std::vector<CAnchorConfirmMessage> GetQuorumFor(CAnchorData::CTeam const & team) const;
+    std::vector<CAnchorConfirmMessage> GetQuorumFor(const CAnchorData::CTeam &team) const;
 
-    void ForEachConfirm(std::function<void(Confirm const &)> callback) const;
+    void ForEachConfirm(std::function<void(const Confirm &)> callback) const;
 };
 
 template <typename TContainer>
-size_t CheckSigs(uint256 const & sigHash, TContainer const & sigs, std::set<CKeyID> const & keys)
-{
+size_t CheckSigs(const uint256 &sigHash, const TContainer &sigs, const std::set<CKeyID> &keys) {
     std::set<CPubKey> uniqueKeys;
-    for (auto const & sig : sigs) {
+    for (const auto &sig : sigs) {
         CPubKey pubkey;
         if (!pubkey.RecoverCompact(sigHash, sig) || keys.find(pubkey.GetID()) == keys.end())
             return false;
@@ -506,33 +474,34 @@ size_t CheckSigs(uint256 const & sigHash, TContainer const & sigs, std::set<CKey
 
 /// dummy, unknown consensus rules yet. may be additional params needed (smth like 'height')
 /// even may be not here, but in CCustomCSView
-uint32_t GetMinAnchorQuorum(CAnchorData::CTeam const & team);
-CAmount GetAnchorSubsidy(int anchorHeight, int prevAnchorHeight, const Consensus::Params& consensusParams);
+uint32_t GetMinAnchorQuorum(const CAnchorData::CTeam &team);
+CAmount GetAnchorSubsidy(int anchorHeight, int prevAnchorHeight, const Consensus::Params &consensusParams);
 
 // thowing exceptions (not a bool due to more verbose rpc errors. may be 'status' or smth? )
 /// Validates all except tx confirmations
-bool ValidateAnchor(CAnchor const & anchor);
+bool ValidateAnchor(const CAnchor &anchor);
 
 // Validate anchor in the context of the active chain. This is used for anchor auths and anchors read from Bitcoin.
-bool ContextualValidateAnchor(const CAnchorData& anchor, CBlockIndex &anchorBlock, uint64_t &anchorCreationHeight);
+bool ContextualValidateAnchor(const CAnchorData &anchor, CBlockIndex &anchorBlock, uint64_t &anchorCreationHeight);
 
 // Get info from data embedded into CAnchorData::nextTeam
-bool GetAnchorEmbeddedData(const CKeyID& data, uint64_t& anchorCreationHeight, std::shared_ptr<std::vector<unsigned char>>& prefix);
+bool GetAnchorEmbeddedData(const CKeyID &data,
+                           uint64_t &anchorCreationHeight,
+                           std::shared_ptr<std::vector<unsigned char>> &prefix);
 
 // Selects "best" of two anchors at the equal btc height (prevs must be checked before)
-CAnchorIndex::AnchorRec const* BestOfTwo(CAnchorIndex::AnchorRec const* a1, CAnchorIndex::AnchorRec const* a2);
+const CAnchorIndex::AnchorRec *BestOfTwo(const CAnchorIndex::AnchorRec *a1, const CAnchorIndex::AnchorRec *a2);
 
 /** Global variables that points to the anchors and their auths (should be protected by cs_main) */
 extern std::unique_ptr<CAnchorAuthIndex> panchorauths;
 extern std::unique_ptr<CAnchorIndex> panchors;
 extern std::unique_ptr<CAnchorAwaitingConfirms> panchorAwaitingConfirms;
 
-namespace spv
-{
+namespace spv {
 // Define comparator and set to hold pending anchors
-using PendingOrderType = std::function<bool (const CAnchorIndex::AnchorRec&, const CAnchorIndex::AnchorRec&)>;
-using PendingSet = std::set<CAnchorIndex::AnchorRec, PendingOrderType>;
+using PendingOrderType = std::function<bool(const CAnchorIndex::AnchorRec &, const CAnchorIndex::AnchorRec &)>;
+using PendingSet       = std::set<CAnchorIndex::AnchorRec, PendingOrderType>;
 extern const PendingOrderType PendingOrder;
-}
+}  // namespace spv
 
-#endif // DEFI_MASTERNODES_ANCHORS_H
+#endif  // DEFI_MASTERNODES_ANCHORS_H
diff --git a/src/masternodes/auctionhistory.cpp b/src/masternodes/auctionhistory.cpp
index 81e3c97455..fea6aed651 100644
--- a/src/masternodes/auctionhistory.cpp
+++ b/src/masternodes/auctionhistory.cpp
@@ -2,23 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
+#include <key_io.h>
 #include <masternodes/auctionhistory.h>
 #include <masternodes/masternodes.h>
-#include <key_io.h>
 
-void CAuctionHistoryView::ForEachAuctionHistory(std::function<bool(AuctionHistoryKey const &, CLazySerialize<AuctionHistoryValue>)> callback, AuctionHistoryKey const & start)
-{
+void CAuctionHistoryView::ForEachAuctionHistory(
+    std::function<bool(const AuctionHistoryKey &, CLazySerialize<AuctionHistoryValue>)> callback,
+    const AuctionHistoryKey &start) {
     ForEach<ByAuctionHistoryKey, AuctionHistoryKey, AuctionHistoryValue>(callback, start);
 }
 
-Res CAuctionHistoryView::WriteAuctionHistory(const AuctionHistoryKey& key, const AuctionHistoryValue& value)
-{
+Res CAuctionHistoryView::WriteAuctionHistory(const AuctionHistoryKey &key, const AuctionHistoryValue &value) {
     WriteBy<ByAuctionHistoryKey>(key, value);
     return Res::Ok();
 }
 
-Res CAuctionHistoryView::EraseAuctionHistoryHeight(uint32_t height)
-{
+Res CAuctionHistoryView::EraseAuctionHistoryHeight(uint32_t height) {
     std::vector<AuctionHistoryKey> keysToDelete;
 
     auto it = LowerBound<ByAuctionHistoryKey>(AuctionHistoryKey{height});
@@ -26,14 +25,13 @@ Res CAuctionHistoryView::EraseAuctionHistoryHeight(uint32_t height)
         keysToDelete.push_back(it.Key());
     }
 
-    for (const auto& key : keysToDelete) {
+    for (const auto &key : keysToDelete) {
         EraseAuctionHistory(key);
     }
     return Res::Ok();
 }
 
-Res CAuctionHistoryView::EraseAuctionHistory(const AuctionHistoryKey& key)
-{
+Res CAuctionHistoryView::EraseAuctionHistory(const AuctionHistoryKey &key) {
     EraseBy<ByAuctionHistoryKey>(key);
     return Res::Ok();
 }
diff --git a/src/masternodes/auctionhistory.h b/src/masternodes/auctionhistory.h
index 1ef7f84034..3e4d9af589 100644
--- a/src/masternodes/auctionhistory.h
+++ b/src/masternodes/auctionhistory.h
@@ -20,8 +20,7 @@ struct AuctionHistoryKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
@@ -43,23 +42,25 @@ struct AuctionHistoryValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(bidAmount);
         READWRITE(collaterals);
     }
 };
 
-class CAuctionHistoryView : public virtual CStorageView
-{
+class CAuctionHistoryView : public virtual CStorageView {
 public:
-    Res WriteAuctionHistory(AuctionHistoryKey const & key, AuctionHistoryValue const & value);
-    Res EraseAuctionHistory(AuctionHistoryKey const & key);
+    Res WriteAuctionHistory(const AuctionHistoryKey &key, const AuctionHistoryValue &value);
+    Res EraseAuctionHistory(const AuctionHistoryKey &key);
     Res EraseAuctionHistoryHeight(uint32_t height);
-    void ForEachAuctionHistory(std::function<bool(AuctionHistoryKey const &, CLazySerialize<AuctionHistoryValue>)> callback, AuctionHistoryKey const & start = {});
+    void ForEachAuctionHistory(
+        std::function<bool(const AuctionHistoryKey &, CLazySerialize<AuctionHistoryValue>)> callback,
+        const AuctionHistoryKey &start = {});
 
     // tags
-    struct ByAuctionHistoryKey { static constexpr uint8_t prefix() { return 'a'; } };
+    struct ByAuctionHistoryKey {
+        static constexpr uint8_t prefix() { return 'a'; }
+    };
 };
 
-
-#endif //DEFI_MASTERNODES_AUCTIONHISTORY_H
+#endif  // DEFI_MASTERNODES_AUCTIONHISTORY_H
diff --git a/src/masternodes/balances.h b/src/masternodes/balances.h
index ba815223c8..2182474a9b 100644
--- a/src/masternodes/balances.h
+++ b/src/masternodes/balances.h
@@ -5,13 +5,12 @@
 #ifndef DEFI_MASTERNODES_BALANCES_H
 #define DEFI_MASTERNODES_BALANCES_H
 
-#include <cstdint>
 #include <amount.h>
-#include <serialize.h>
 #include <script/script.h>
+#include <serialize.h>
+#include <cstdint>
 
-struct CBalances
-{
+struct CBalances {
     TAmounts balances;
 
     Res Add(CTokenAmount amount) {
@@ -19,7 +18,7 @@ struct CBalances
             return Res::Ok();
         }
         auto current = CTokenAmount{amount.nTokenId, balances[amount.nTokenId]};
-        auto res = current.Add(amount.nValue);
+        auto res     = current.Add(amount.nValue);
         if (!res.ok) {
             return res;
         }
@@ -35,7 +34,7 @@ struct CBalances
             return Res::Ok();
         }
         auto current = CTokenAmount{amount.nTokenId, balances[amount.nTokenId]};
-        auto res = current.Sub(amount.nValue);
+        auto res     = current.Sub(amount.nValue);
         if (!res.ok) {
             return res;
         }
@@ -50,7 +49,7 @@ struct CBalances
         if (amount.nValue == 0) {
             return CTokenAmount{amount.nTokenId, 0};
         }
-        auto current = CTokenAmount{amount.nTokenId, balances[amount.nTokenId]};
+        auto current   = CTokenAmount{amount.nTokenId, balances[amount.nTokenId]};
         auto remainder = current.SubWithRemainder(amount.nValue);
         if (current.nValue == 0) {
             balances.erase(amount.nTokenId);
@@ -59,8 +58,8 @@ struct CBalances
         }
         return CTokenAmount{amount.nTokenId, remainder};
     }
-    Res SubBalances(TAmounts const & other) {
-        for (const auto& kv : other) {
+    Res SubBalances(const TAmounts &other) {
+        for (const auto &kv : other) {
             auto res = Sub(CTokenAmount{kv.first, kv.second});
             if (!res.ok) {
                 return res;
@@ -68,9 +67,9 @@ struct CBalances
         }
         return Res::Ok();
     }
-    CBalances SubBalancesWithRemainder(TAmounts const & other) {
+    CBalances SubBalancesWithRemainder(const TAmounts &other) {
         CBalances remainderBalances;
-        for (const auto& kv : other) {
+        for (const auto &kv : other) {
             CTokenAmount remainder = SubWithRemainder(CTokenAmount{kv.first, kv.second});
             // if remainder token value is zero
             // this addition won't get any effect
@@ -78,8 +77,8 @@ struct CBalances
         }
         return remainderBalances;
     }
-    Res AddBalances(TAmounts const & other) {
-        for (const auto& kv : other) {
+    Res AddBalances(const TAmounts &other) {
+        for (const auto &kv : other) {
             auto res = Add(CTokenAmount{kv.first, kv.second});
             if (!res.ok) {
                 return res;
@@ -91,7 +90,7 @@ struct CBalances
     std::string ToString() const {
         std::string str;
         str.reserve(100);
-        for (const auto& kv : balances) {
+        for (const auto &kv : balances) {
             if (!str.empty()) {
                 str += ",";
             }
@@ -100,27 +99,23 @@ struct CBalances
         return str;
     }
 
-    static CBalances Sum(std::vector<CTokenAmount> const & tokens) {
+    static CBalances Sum(const std::vector<CTokenAmount> &tokens) {
         CBalances res;
-        for (const auto& token : tokens) {
+        for (const auto &token : tokens) {
             res.Add(token);
         }
         return res;
     }
 
-    friend bool operator==(const CBalances& a, const CBalances& b) {
-        return a.balances == b.balances;
-    }
+    friend bool operator==(const CBalances &a, const CBalances &b) { return a.balances == b.balances; }
 
-    friend bool operator!=(const CBalances& a, const CBalances& b) {
-        return a.balances != b.balances;
-    }
+    friend bool operator!=(const CBalances &a, const CBalances &b) { return a.balances != b.balances; }
 
     // NOTE: if some balance from b is hgher than a => a is less than b
-    friend bool operator<(const CBalances& a, const CBalances& b) {
-        for (const auto& b_kv : b.balances) {
+    friend bool operator<(const CBalances &a, const CBalances &b) {
+        for (const auto &b_kv : b.balances) {
             const auto a_value_it = a.balances.find(b_kv.first);
-            CAmount a_value = 0;
+            CAmount a_value       = 0;
             if (a_value_it != a.balances.end()) {
                 a_value = a_value_it->second;
             }
@@ -134,7 +129,7 @@ struct CBalances
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         static_assert(std::is_same<decltype(balances), std::map<DCT_ID, CAmount>>::value, "Following code is invalid");
         std::map<uint32_t, CAmount> serializedBalances;
         if (ser_action.ForRead()) {
@@ -149,7 +144,7 @@ struct CBalances
                 serializedBalances.erase(it++);
             }
         } else {
-            for (const auto& it : balances) {
+            for (const auto &it : balances) {
                 serializedBalances.emplace(it.first.v, it.second);
             }
             READWRITE(serializedBalances);
@@ -165,7 +160,7 @@ struct CAccountToUtxosMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(balances);
         READWRITE(VARINT(mintingOutputsStart));
@@ -176,37 +171,37 @@ using CAccounts = std::map<CScript, CBalances>;
 
 struct CAccountToAccountMessage {
     CScript from;
-    CAccounts to; // to -> balances
+    CAccounts to;  // to -> balances
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(to);
     }
 };
 
 struct CAnyAccountsToAccountsMessage {
-    CAccounts from; // from -> balances
-    CAccounts to; // to -> balances
+    CAccounts from;  // from -> balances
+    CAccounts to;    // to -> balances
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(to);
     }
 };
 
 struct CUtxosToAccountMessage {
-    CAccounts to; // to -> balances
+    CAccounts to;  // to -> balances
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(to);
     }
 };
@@ -218,7 +213,7 @@ struct CSmartContractMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(name);
         READWRITE(accounts);
     }
@@ -233,7 +228,7 @@ struct CFutureSwapMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(owner);
         READWRITE(source);
         READWRITE(destination);
@@ -241,9 +236,9 @@ struct CFutureSwapMessage {
     }
 };
 
-inline CBalances SumAllTransfers(CAccounts const & to) {
+inline CBalances SumAllTransfers(const CAccounts &to) {
     CBalances sum;
-    for (const auto& kv : to) {
+    for (const auto &kv : to) {
         sum.AddBalances(kv.second.balances);
     }
     return sum;
@@ -256,9 +251,9 @@ struct BalanceKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(owner);
         READWRITE(WrapBigEndian(tokenID.v));
     }
 };
-#endif //DEFI_MASTERNODES_BALANCES_H
+#endif  // DEFI_MASTERNODES_BALANCES_H
diff --git a/src/masternodes/communityaccounttypes.h b/src/masternodes/communityaccounttypes.h
index 9166d05cb6..d50f643534 100644
--- a/src/masternodes/communityaccounttypes.h
+++ b/src/masternodes/communityaccounttypes.h
@@ -5,15 +5,14 @@
 #ifndef DEFI_MASTERNODES_COMMUNITYACCOUNTTYPES_H
 #define DEFI_MASTERNODES_COMMUNITYACCOUNTTYPES_H
 
-enum class CommunityAccountType : unsigned char
-{
-    None = 0,
-    IncentiveFunding    = 'I', // or 'yield farming' - source of community rewards for LP (Liquidity Pools)
-    AnchorReward        = 'A',
-    CommunityDevFunds   = 'C',
-    Loan                = 'L',
-    Options             = 'O',
-    Unallocated         = 'U',
+enum class CommunityAccountType : unsigned char {
+    None              = 0,
+    IncentiveFunding  = 'I',  // or 'yield farming' - source of community rewards for LP (Liquidity Pools)
+    AnchorReward      = 'A',
+    CommunityDevFunds = 'C',
+    Loan              = 'L',
+    Options           = 'O',
+    Unallocated       = 'U',
 };
 
-#endif //DEFI_MASTERNODES_COMMUNITYACCOUNTTYPES_H
+#endif  // DEFI_MASTERNODES_COMMUNITYACCOUNTTYPES_H
diff --git a/src/masternodes/factory.h b/src/masternodes/factory.h
index 99fea138d4..95c5c76926 100644
--- a/src/masternodes/factory.h
+++ b/src/masternodes/factory.h
@@ -9,12 +9,11 @@
 #include <string>
 
 template <typename TBaseType>
-class Factory
-{
+class Factory {
 public:
-    typedef TBaseType * (* Creator)(); // creator function
+    typedef TBaseType *(*Creator)();  // creator function
 
-    Factory() = delete;
+    Factory()  = delete;
     ~Factory() = delete;
 
     template <typename TType>
@@ -23,7 +22,7 @@ class Factory
         return res.second;
     }
 
-    static TBaseType * Create(std::string const & name) {
+    static TBaseType *Create(const std::string &name) {
         typename TCreators::const_iterator creator(m_creators.find(name));
         if (creator == m_creators.end()) {
             return {};
@@ -36,11 +35,12 @@ class Factory
     static TCreators m_creators;
 
     // force instantiation of definition of static member, do not touch!
-    template<TCreators&> struct dummy_ref { };
+    template <TCreators &>
+    struct dummy_ref {};
     static dummy_ref<m_creators> referrer;
 };
 
-template<typename TBaseType, typename TDerivedType>
+template <typename TBaseType, typename TDerivedType>
 class AutoRegistrator {
     struct exec_registrate {
         exec_registrate() {
@@ -51,14 +51,16 @@ class AutoRegistrator {
     static exec_registrate register_object;
 
     // force instantiation of definition of static member, do not touch!
-    template<exec_registrate&> struct dummy_ref { };
+    template <exec_registrate &>
+    struct dummy_ref {};
     static dummy_ref<register_object> referrer;
 };
 
 template <typename T>
 typename Factory<T>::TCreators Factory<T>::m_creators;
 
-template<typename TBaseType, typename TDerivedType>
-typename AutoRegistrator<TBaseType, TDerivedType>::exec_registrate AutoRegistrator<TBaseType, TDerivedType>::register_object;
+template <typename TBaseType, typename TDerivedType>
+typename AutoRegistrator<TBaseType, TDerivedType>::exec_registrate
+    AutoRegistrator<TBaseType, TDerivedType>::register_object;
 
-#endif // DEFI_MASTERNODES_FACTORY_H
+#endif  // DEFI_MASTERNODES_FACTORY_H
diff --git a/src/masternodes/govvariables/attributes.cpp b/src/masternodes/govvariables/attributes.cpp
index d5b3dc413b..983c74874d 100644
--- a/src/masternodes/govvariables/attributes.cpp
+++ b/src/masternodes/govvariables/attributes.cpp
@@ -2,31 +2,27 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-#include <masternodes/mn_rpc.h>
 #include <masternodes/govvariables/attributes.h>
+#include <masternodes/mn_rpc.h>
 
-#include <masternodes/accountshistory.h> /// CAccountsHistoryWriter
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <masternodes/mn_checks.h> /// GetAggregatePrice / CustomTxType
-#include <validation.h> /// GetNextAccPosition
+#include <masternodes/accountshistory.h>  /// CAccountsHistoryWriter
+#include <masternodes/masternodes.h>      /// CCustomCSView
+#include <masternodes/mn_checks.h>        /// GetAggregatePrice / CustomTxType
+#include <validation.h>                   /// GetNextAccPosition
 
-#include <amount.h> /// GetDecimaleString
-#include <core_io.h> /// ValueFromAmount
+#include <amount.h>   /// GetDecimaleString
+#include <core_io.h>  /// ValueFromAmount
 #include <util/strencodings.h>
 
-extern UniValue AmountsToJSON(TAmounts const & diffs, AmountFormat format = AmountFormat::Symbol);
+extern UniValue AmountsToJSON(const TAmounts &diffs, AmountFormat format = AmountFormat::Symbol);
 
 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());
+    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;
 }
 
-static std::vector<std::string> KeyBreaker(const std::string& str, const char delim = '/'){
+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;
@@ -37,287 +33,276 @@ static std::vector<std::string> KeyBreaker(const std::string& str, const char de
     return strVec;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedVersions() {
+const std::map<std::string, uint8_t> &ATTRIBUTES::allowedVersions() {
     static const std::map<std::string, uint8_t> versions{
-        {"v0",  VersionTypes::v0},
+        {"v0", VersionTypes::v0},
     };
     return versions;
 }
 
-const std::map<uint8_t, std::string>& ATTRIBUTES::displayVersions() {
+const std::map<uint8_t, std::string> &ATTRIBUTES::displayVersions() {
     static const std::map<uint8_t, std::string> versions{
-        {VersionTypes::v0,  "v0"},
+        {VersionTypes::v0, "v0"},
     };
     return versions;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedTypes() {
+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},
-        {"gov",         AttributeTypes::Governance},
-        {"consortium",  AttributeTypes::Consortium},
+        {"locks",      AttributeTypes::Locks     },
+        {"oracles",    AttributeTypes::Oracles   },
+        {"params",     AttributeTypes::Param     },
+        {"poolpairs",  AttributeTypes::Poolpairs },
+        {"token",      AttributeTypes::Token     },
+        {"gov",        AttributeTypes::Governance},
+        {"consortium", AttributeTypes::Consortium},
     };
     return types;
 }
 
-const std::map<uint8_t, std::string>& ATTRIBUTES::displayTypes() {
+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"},
-        {AttributeTypes::Governance,"gov"},
-        {AttributeTypes::Consortium,"consortium"}
+        {AttributeTypes::Live,       "live"      },
+        {AttributeTypes::Locks,      "locks"     },
+        {AttributeTypes::Oracles,    "oracles"   },
+        {AttributeTypes::Param,      "params"    },
+        {AttributeTypes::Poolpairs,  "poolpairs" },
+        {AttributeTypes::Token,      "token"     },
+        {AttributeTypes::Governance, "gov"       },
+        {AttributeTypes::Consortium, "consortium"}
     };
     return types;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedParamIDs() {
+const std::map<std::string, uint8_t> &ATTRIBUTES::allowedParamIDs() {
     static const std::map<std::string, uint8_t> params{
-        {"dfip2201",    ParamIDs::DFIP2201},
-        {"dfip2203",    ParamIDs::DFIP2203},
-        {"dfip2206a",   ParamIDs::DFIP2206A},
-        // Note: DFIP2206F is currently in beta testing
-        // for testnet. May not be enabled on mainnet until testing is complete.
-        {"dfip2206f",   ParamIDs::DFIP2206F},
-        {"feature",     ParamIDs::Feature},
-        {"foundation",  ParamIDs::Foundation},
+        {"dfip2201",   ParamIDs::DFIP2201  },
+        {"dfip2203",   ParamIDs::DFIP2203  },
+        {"dfip2206a",  ParamIDs::DFIP2206A },
+ // Note: DFIP2206F is currently in beta testing
+  // for testnet. May not be enabled on mainnet until testing is complete.
+        {"dfip2206f",  ParamIDs::DFIP2206F },
+        {"feature",    ParamIDs::Feature   },
+        {"foundation", ParamIDs::Foundation},
     };
     return params;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedLocksIDs() {
+const std::map<std::string, uint8_t> &ATTRIBUTES::allowedLocksIDs() {
     static const std::map<std::string, uint8_t> params{
-            {"token",       ParamIDs::TokenID},
+        {"token", ParamIDs::TokenID},
     };
     return params;
 }
 
-const std::map<uint8_t, std::string>& ATTRIBUTES::displayParamsIDs() {
+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::DFIP2206A,   "dfip2206a"},
-        // Note: DFIP2206F is currently in beta testing
-        // for testnet. May not be enabled on mainnet until testing is complete.
-        {ParamIDs::DFIP2206F,   "dfip2206f"},
-        {ParamIDs::TokenID,     "token"},
-        {ParamIDs::Economy,     "economy"},
-        {ParamIDs::Feature,     "feature"},
-        {ParamIDs::Auction,     "auction"},
-        {ParamIDs::Foundation,  "foundation"},
+        {ParamIDs::DFIP2201,   "dfip2201"  },
+        {ParamIDs::DFIP2203,   "dfip2203"  },
+        {ParamIDs::DFIP2206A,  "dfip2206a" },
+ // Note: DFIP2206F is currently in beta testing
+  // for testnet. May not be enabled on mainnet until testing is complete.
+        {ParamIDs::DFIP2206F,  "dfip2206f" },
+        {ParamIDs::TokenID,    "token"     },
+        {ParamIDs::Economy,    "economy"   },
+        {ParamIDs::Feature,    "feature"   },
+        {ParamIDs::Auction,    "auction"   },
+        {ParamIDs::Foundation, "foundation"},
     };
     return params;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedOracleIDs() {
+const std::map<std::string, uint8_t> &ATTRIBUTES::allowedOracleIDs() {
     static const std::map<std::string, uint8_t> params{
-            {"splits",    OracleIDs::Splits}
+        {"splits", OracleIDs::Splits}
     };
     return params;
 }
 
-const std::map<uint8_t, std::string>& ATTRIBUTES::displayOracleIDs() {
+const std::map<uint8_t, std::string> &ATTRIBUTES::displayOracleIDs() {
     static const std::map<uint8_t, std::string> params{
-            {OracleIDs::Splits,    "splits"},
+        {OracleIDs::Splits, "splits"},
     };
     return params;
 }
 
-const std::map<std::string, uint8_t>& ATTRIBUTES::allowedGovernanceIDs() {
+const std::map<std::string, uint8_t> &ATTRIBUTES::allowedGovernanceIDs() {
     static const std::map<std::string, uint8_t> params{
-            {"proposals", GovernanceIDs::Proposals},
+        {"proposals", GovernanceIDs::Proposals},
     };
     return params;
 }
 
-const std::map<uint8_t, std::string>& ATTRIBUTES::displayGovernanceIDs() {
+const std::map<uint8_t, std::string> &ATTRIBUTES::displayGovernanceIDs() {
     static const std::map<uint8_t, std::string> params{
-            {GovernanceIDs::Proposals, "proposals"},
+        {GovernanceIDs::Proposals, "proposals"},
     };
     return params;
 }
 
-const std::map<uint8_t, std::map<std::string, uint8_t>>& ATTRIBUTES::allowedKeys() {
+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},
-                {"loan_payback_collateral",      TokenKeys::LoanPaybackCollateral},
-                {"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},
-            }
-        },
-        {
-            AttributeTypes::Consortium, {
-                {"members",             ConsortiumKeys::MemberValues},
-                {"mint_limit",          ConsortiumKeys::MintLimit},
-                {"mint_limit_daily",    ConsortiumKeys::DailyMintLimit},
-            }
-        },
-        {
-            AttributeTypes::Poolpairs, {
-                {"token_a_fee_pct",      PoolKeys::TokenAFeePCT},
-                {"token_a_fee_direction",PoolKeys::TokenAFeeDir},
-                {"token_b_fee_pct",      PoolKeys::TokenBFeePCT},
-                {"token_b_fee_direction",PoolKeys::TokenBFeeDir},
-            }
-        },
-        {
-            AttributeTypes::Param, {
-                {"active",                      DFIPKeys::Active},
-                {"minswap",                     DFIPKeys::MinSwap},
-                {"premium",                     DFIPKeys::Premium},
-                {"reward_pct",                  DFIPKeys::RewardPct},
-                {"block_period",                DFIPKeys::BlockPeriod},
-                {"dusd_interest_burn",          DFIPKeys::DUSDInterestBurn},
-                {"dusd_loan_burn",              DFIPKeys::DUSDLoanBurn},
-                {"start_block",                 DFIPKeys::StartBlock},
-                {"gov-unset",                   DFIPKeys::GovUnset},
-                {"gov-foundation",              DFIPKeys::GovFoundation},
-                {"mn-setrewardaddress",         DFIPKeys::MNSetRewardAddress},
-                {"mn-setoperatoraddress",       DFIPKeys::MNSetOperatorAddress},
-                {"mn-setowneraddress",          DFIPKeys::MNSetOwnerAddress},
-                {"gov",                         DFIPKeys::GovernanceEnabled},
-                {"consortium",                  DFIPKeys::ConsortiumEnabled},
-                {"members",                     DFIPKeys::Members},
-                {"gov-payout",                  DFIPKeys::CFPPayout},
-                {"emission-unused-fund",        DFIPKeys::EmissionUnusedFund},
-            }
-        },
-        {
-            AttributeTypes::Governance, {
-                {"fee_redistribution",          GovernanceKeys::FeeRedistribution},
-                {"fee_burn_pct",                GovernanceKeys::FeeBurnPct},
-                {"cfp_fee",                     GovernanceKeys::CFPFee},
-                {"cfp_required_votes",          GovernanceKeys::CFPMajority},
-                {"voc_fee",                     GovernanceKeys::VOCFee},
-                {"voc_emergency_fee",           GovernanceKeys::VOCEmergencyFee},
-                {"voc_emergency_period",        GovernanceKeys::VOCEmergencyPeriod},
-                {"voc_emergency_quorum",        GovernanceKeys::VOCEmergencyQuorum},
-                {"voc_required_votes",          GovernanceKeys::VOCMajority},
-                {"quorum",                      GovernanceKeys::Quorum},
-                {"voting_period",               GovernanceKeys::VotingPeriod},
-            }
-        },
+        {AttributeTypes::Token,
+         {
+             {"payback_dfi", TokenKeys::PaybackDFI},
+             {"payback_dfi_fee_pct", TokenKeys::PaybackDFIFeePCT},
+             {"loan_payback", TokenKeys::LoanPayback},
+             {"loan_payback_fee_pct", TokenKeys::LoanPaybackFeePCT},
+             {"loan_payback_collateral", TokenKeys::LoanPaybackCollateral},
+             {"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},
+         }},
+        {AttributeTypes::Consortium,
+         {
+             {"members", ConsortiumKeys::MemberValues},
+             {"mint_limit", ConsortiumKeys::MintLimit},
+             {"mint_limit_daily", ConsortiumKeys::DailyMintLimit},
+         }},
+        {AttributeTypes::Poolpairs,
+         {
+             {"token_a_fee_pct", PoolKeys::TokenAFeePCT},
+             {"token_a_fee_direction", PoolKeys::TokenAFeeDir},
+             {"token_b_fee_pct", PoolKeys::TokenBFeePCT},
+             {"token_b_fee_direction", PoolKeys::TokenBFeeDir},
+         }},
+        {AttributeTypes::Param,
+         {
+             {"active", DFIPKeys::Active},
+             {"minswap", DFIPKeys::MinSwap},
+             {"premium", DFIPKeys::Premium},
+             {"reward_pct", DFIPKeys::RewardPct},
+             {"block_period", DFIPKeys::BlockPeriod},
+             {"dusd_interest_burn", DFIPKeys::DUSDInterestBurn},
+             {"dusd_loan_burn", DFIPKeys::DUSDLoanBurn},
+             {"start_block", DFIPKeys::StartBlock},
+             {"gov-unset", DFIPKeys::GovUnset},
+             {"gov-foundation", DFIPKeys::GovFoundation},
+             {"mn-setrewardaddress", DFIPKeys::MNSetRewardAddress},
+             {"mn-setoperatoraddress", DFIPKeys::MNSetOperatorAddress},
+             {"mn-setowneraddress", DFIPKeys::MNSetOwnerAddress},
+             {"gov", DFIPKeys::GovernanceEnabled},
+             {"consortium", DFIPKeys::ConsortiumEnabled},
+             {"members", DFIPKeys::Members},
+             {"gov-payout", DFIPKeys::CFPPayout},
+             {"emission-unused-fund", DFIPKeys::EmissionUnusedFund},
+         }},
+        {AttributeTypes::Governance,
+         {
+             {"fee_redistribution", GovernanceKeys::FeeRedistribution},
+             {"fee_burn_pct", GovernanceKeys::FeeBurnPct},
+             {"cfp_fee", GovernanceKeys::CFPFee},
+             {"cfp_required_votes", GovernanceKeys::CFPMajority},
+             {"voc_fee", GovernanceKeys::VOCFee},
+             {"voc_emergency_fee", GovernanceKeys::VOCEmergencyFee},
+             {"voc_emergency_period", GovernanceKeys::VOCEmergencyPeriod},
+             {"voc_emergency_quorum", GovernanceKeys::VOCEmergencyQuorum},
+             {"voc_required_votes", GovernanceKeys::VOCMajority},
+             {"quorum", GovernanceKeys::Quorum},
+             {"voting_period", GovernanceKeys::VotingPeriod},
+         }},
     };
     return keys;
 }
 
-const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys() {
+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::LoanPaybackCollateral,     "loan_payback_collateral"},
-                {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"},
-            }
-        },
-        {
-            AttributeTypes::Consortium, {
-                {ConsortiumKeys::MemberValues,       "members"},
-                {ConsortiumKeys::MintLimit,     "mint_limit"},
-                {ConsortiumKeys::DailyMintLimit,"mint_limit_daily"},
-            }
-        },
-        {
-            AttributeTypes::Poolpairs, {
-                {PoolKeys::TokenAFeePCT,      "token_a_fee_pct"},
-                {PoolKeys::TokenAFeeDir,      "token_a_fee_direction"},
-                {PoolKeys::TokenBFeePCT,      "token_b_fee_pct"},
-                {PoolKeys::TokenBFeeDir,      "token_b_fee_direction"},
-            }
-        },
-        {
-            AttributeTypes::Param, {
-                {DFIPKeys::Active,                  "active"},
-                {DFIPKeys::Premium,                 "premium"},
-                {DFIPKeys::MinSwap,                 "minswap"},
-                {DFIPKeys::RewardPct,               "reward_pct"},
-                {DFIPKeys::BlockPeriod,             "block_period"},
-                {DFIPKeys::DUSDInterestBurn,        "dusd_interest_burn"},
-                {DFIPKeys::DUSDLoanBurn,            "dusd_loan_burn"},
-                {DFIPKeys::StartBlock,              "start_block"},
-                {DFIPKeys::GovUnset,                "gov-unset"},
-                {DFIPKeys::GovFoundation,           "gov-foundation"},
-                {DFIPKeys::MNSetRewardAddress,      "mn-setrewardaddress"},
-                {DFIPKeys::MNSetOperatorAddress,    "mn-setoperatoraddress"},
-                {DFIPKeys::MNSetOwnerAddress,       "mn-setowneraddress"},
-                {DFIPKeys::GovernanceEnabled,       "gov"},
-                {DFIPKeys::ConsortiumEnabled,       "consortium"},
-                {DFIPKeys::Members,                 "members"},
-                {DFIPKeys::CFPPayout,               "gov-payout"},
-                {DFIPKeys::EmissionUnusedFund,      "emission-unused-fund"},
-            }
-        },
-        {
-            AttributeTypes::Live, {
-                {EconomyKeys::PaybackDFITokens,  "dfi_payback_tokens"},
-                {EconomyKeys::PaybackDFITokensPrincipal,"dfi_payback_tokens_principal"},
-                {EconomyKeys::DFIP2203Current,   "dfip2203_current"},
-                {EconomyKeys::DFIP2203Burned,    "dfip2203_burned"},
-                {EconomyKeys::DFIP2203Minted,    "dfip2203_minted"},
-                {EconomyKeys::DexTokens,         "dex"},
-                {EconomyKeys::DFIP2206FCurrent,   "dfip2206f_current"},
-                {EconomyKeys::DFIP2206FBurned,    "dfip2206f_burned"},
-                {EconomyKeys::DFIP2206FMinted,    "dfip2206f_minted"},
-                {EconomyKeys::NegativeInt,        "negative_interest"},
-                {EconomyKeys::NegativeIntCurrent, "negative_interest_current"},
-                {EconomyKeys::ConsortiumMinted,         "consortium"},
-                {EconomyKeys::ConsortiumMembersMinted,  "consortium_members"},
-                {EconomyKeys::BatchRoundingExcess, "batch_rounding_excess"},
-                {EconomyKeys::ConsolidatedInterest, "consolidated_interest"},
-                {EconomyKeys::Loans,              "loans"},
-            }
-        },
-        {
-            AttributeTypes::Governance, {
-                {GovernanceKeys::FeeRedistribution,     "fee_redistribution"},
-                {GovernanceKeys::FeeBurnPct,            "fee_burn_pct"},
-                {GovernanceKeys::CFPFee,                "cfp_fee"},
-                {GovernanceKeys::CFPMajority,           "cfp_required_votes"},
-                {GovernanceKeys::VOCFee,                "voc_fee"},
-                {GovernanceKeys::VOCEmergencyFee,       "voc_emergency_fee"},
-                {GovernanceKeys::VOCEmergencyPeriod,    "voc_emergency_period"},
-                {GovernanceKeys::VOCEmergencyQuorum,    "voc_emergency_quorum"},
-                {GovernanceKeys::VOCMajority,           "voc_required_votes"},
-                {GovernanceKeys::Quorum,                "quorum"},
-                {GovernanceKeys::VotingPeriod,          "voting_period"},
-            }
-        },
+        {AttributeTypes::Token,
+         {
+             {TokenKeys::PaybackDFI, "payback_dfi"},
+             {TokenKeys::PaybackDFIFeePCT, "payback_dfi_fee_pct"},
+             {TokenKeys::LoanPayback, "loan_payback"},
+             {TokenKeys::LoanPaybackFeePCT, "loan_payback_fee_pct"},
+             {TokenKeys::LoanPaybackCollateral, "loan_payback_collateral"},
+             {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"},
+         }},
+        {AttributeTypes::Consortium,
+         {
+             {ConsortiumKeys::MemberValues, "members"},
+             {ConsortiumKeys::MintLimit, "mint_limit"},
+             {ConsortiumKeys::DailyMintLimit, "mint_limit_daily"},
+         }},
+        {AttributeTypes::Poolpairs,
+         {
+             {PoolKeys::TokenAFeePCT, "token_a_fee_pct"},
+             {PoolKeys::TokenAFeeDir, "token_a_fee_direction"},
+             {PoolKeys::TokenBFeePCT, "token_b_fee_pct"},
+             {PoolKeys::TokenBFeeDir, "token_b_fee_direction"},
+         }},
+        {AttributeTypes::Param,
+         {
+             {DFIPKeys::Active, "active"},
+             {DFIPKeys::Premium, "premium"},
+             {DFIPKeys::MinSwap, "minswap"},
+             {DFIPKeys::RewardPct, "reward_pct"},
+             {DFIPKeys::BlockPeriod, "block_period"},
+             {DFIPKeys::DUSDInterestBurn, "dusd_interest_burn"},
+             {DFIPKeys::DUSDLoanBurn, "dusd_loan_burn"},
+             {DFIPKeys::StartBlock, "start_block"},
+             {DFIPKeys::GovUnset, "gov-unset"},
+             {DFIPKeys::GovFoundation, "gov-foundation"},
+             {DFIPKeys::MNSetRewardAddress, "mn-setrewardaddress"},
+             {DFIPKeys::MNSetOperatorAddress, "mn-setoperatoraddress"},
+             {DFIPKeys::MNSetOwnerAddress, "mn-setowneraddress"},
+             {DFIPKeys::GovernanceEnabled, "gov"},
+             {DFIPKeys::ConsortiumEnabled, "consortium"},
+             {DFIPKeys::Members, "members"},
+             {DFIPKeys::CFPPayout, "gov-payout"},
+             {DFIPKeys::EmissionUnusedFund, "emission-unused-fund"},
+         }},
+        {AttributeTypes::Live,
+         {
+             {EconomyKeys::PaybackDFITokens, "dfi_payback_tokens"},
+             {EconomyKeys::PaybackDFITokensPrincipal, "dfi_payback_tokens_principal"},
+             {EconomyKeys::DFIP2203Current, "dfip2203_current"},
+             {EconomyKeys::DFIP2203Burned, "dfip2203_burned"},
+             {EconomyKeys::DFIP2203Minted, "dfip2203_minted"},
+             {EconomyKeys::DexTokens, "dex"},
+             {EconomyKeys::DFIP2206FCurrent, "dfip2206f_current"},
+             {EconomyKeys::DFIP2206FBurned, "dfip2206f_burned"},
+             {EconomyKeys::DFIP2206FMinted, "dfip2206f_minted"},
+             {EconomyKeys::NegativeInt, "negative_interest"},
+             {EconomyKeys::NegativeIntCurrent, "negative_interest_current"},
+             {EconomyKeys::ConsortiumMinted, "consortium"},
+             {EconomyKeys::ConsortiumMembersMinted, "consortium_members"},
+             {EconomyKeys::BatchRoundingExcess, "batch_rounding_excess"},
+             {EconomyKeys::ConsolidatedInterest, "consolidated_interest"},
+             {EconomyKeys::Loans, "loans"},
+         }},
+        {AttributeTypes::Governance,
+         {
+             {GovernanceKeys::FeeRedistribution, "fee_redistribution"},
+             {GovernanceKeys::FeeBurnPct, "fee_burn_pct"},
+             {GovernanceKeys::CFPFee, "cfp_fee"},
+             {GovernanceKeys::CFPMajority, "cfp_required_votes"},
+             {GovernanceKeys::VOCFee, "voc_fee"},
+             {GovernanceKeys::VOCEmergencyFee, "voc_emergency_fee"},
+             {GovernanceKeys::VOCEmergencyPeriod, "voc_emergency_period"},
+             {GovernanceKeys::VOCEmergencyQuorum, "voc_emergency_quorum"},
+             {GovernanceKeys::VOCMajority, "voc_required_votes"},
+             {GovernanceKeys::Quorum, "quorum"},
+             {GovernanceKeys::VotingPeriod, "voting_period"},
+         }},
     };
     return keys;
 }
 
-static ResVal<int32_t> VerifyInt32(const std::string& str) {
+static ResVal<int32_t> VerifyInt32(const std::string &str) {
     int32_t int32;
     if (!ParseInt32(str, &int32)) {
         return Res::Err("Value must be an integer");
@@ -325,7 +310,7 @@ static ResVal<int32_t> VerifyInt32(const std::string& str) {
     return {int32, Res::Ok()};
 }
 
-static ResVal<int32_t> VerifyPositiveInt32(const std::string& str) {
+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");
@@ -333,7 +318,7 @@ static ResVal<int32_t> VerifyPositiveInt32(const std::string& str) {
     return {int32, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyUInt32(const std::string& str) {
+static ResVal<CAttributeValue> VerifyUInt32(const std::string &str) {
     uint32_t uint32;
     if (!ParseUInt32(str, &uint32)) {
         return Res::Err("Value must be an integer");
@@ -341,7 +326,7 @@ static ResVal<CAttributeValue> VerifyUInt32(const std::string& str) {
     return {uint32, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyInt64(const std::string& str) {
+static ResVal<CAttributeValue> VerifyInt64(const std::string &str) {
     CAmount int64;
     if (!ParseInt64(str, &int64) || int64 < 0) {
         return Res::Err("Value must be a positive integer");
@@ -349,7 +334,7 @@ static ResVal<CAttributeValue> VerifyInt64(const std::string& str) {
     return {int64, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyFloat(const std::string& str) {
+static ResVal<CAttributeValue> VerifyFloat(const std::string &str) {
     CAmount amount = 0;
     if (!ParseFixedPoint(str, 8, &amount)) {
         return Res::Err("Amount must be a valid number");
@@ -357,7 +342,7 @@ static ResVal<CAttributeValue> VerifyFloat(const std::string& str) {
     return {amount, Res::Ok()};
 }
 
-ResVal<CAttributeValue> VerifyPositiveFloat(const std::string& str) {
+ResVal<CAttributeValue> VerifyPositiveFloat(const std::string &str) {
     CAmount amount = 0;
     if (!ParseFixedPoint(str, 8, &amount) || amount < 0) {
         return Res::Err("Amount must be a positive value");
@@ -365,7 +350,7 @@ ResVal<CAttributeValue> VerifyPositiveFloat(const std::string& str) {
     return {amount, Res::Ok()};
 }
 
-ResVal<CAttributeValue> VerifyPositiveOrMinusOneFloat(const std::string& str) {
+ResVal<CAttributeValue> VerifyPositiveOrMinusOneFloat(const std::string &str) {
     CAmount amount = 0;
     if (!ParseFixedPoint(str, 8, &amount) || !(amount >= 0 || amount == -1 * COIN)) {
         return Res::Err("Amount must be positive or -1");
@@ -374,30 +359,32 @@ ResVal<CAttributeValue> VerifyPositiveOrMinusOneFloat(const std::string& str) {
     return {amount, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyPct(const std::string& str) {
+static ResVal<CAttributeValue> VerifyPct(const std::string &str) {
     std::string val = str;
-    bool isPct = (val.size() > 0 && val.back() == '%');
-    if (isPct) val.pop_back();
+    bool isPct      = (val.size() > 0 && val.back() == '%');
+    if (isPct)
+        val.pop_back();
     auto resVal = VerifyPositiveFloat(val);
     if (!resVal) {
         return resVal;
     }
     auto value = std::get<CAmount>(*resVal.val);
-    if (isPct && value > 0) (*resVal.val).emplace<CAmount>(value / 100);
+    if (isPct && value > 0)
+        (*resVal.val).emplace<CAmount>(value / 100);
     if (std::get<CAmount>(*resVal.val) > COIN) {
         return Res::Err("Percentage exceeds 100%%");
     }
     return resVal;
 }
 
-static ResVal<CAttributeValue> VerifyBool(const std::string& str) {
+static ResVal<CAttributeValue> VerifyBool(const std::string &str) {
     if (str != "true" && str != "false") {
         return Res::Err(R"(Boolean value must be either "true" or "false")");
     }
     return {str == "true", Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifySplit(const std::string& str) {
+static ResVal<CAttributeValue> VerifySplit(const std::string &str) {
     OracleSplits splits;
     const auto pairs = KeyBreaker(str);
     if (pairs.size() != 2) {
@@ -419,7 +406,7 @@ static ResVal<CAttributeValue> VerifySplit(const std::string& str) {
     return {splits, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyMember(const UniValue& array) {
+static ResVal<CAttributeValue> VerifyMember(const UniValue &array) {
     std::set<std::string> addresses;
     std::set<CScript> members;
     bool removal{};
@@ -433,7 +420,7 @@ static ResVal<CAttributeValue> VerifyMember(const UniValue& array) {
         CTxDestination dest;
         if (member[0] == '-') {
             removal = true;
-            dest = DecodeDestination(member.erase(0, 1));
+            dest    = DecodeDestination(member.erase(0, 1));
             addresses.insert(array[i].getValStr());
         } else if (member[0] == '+') {
             dest = DecodeDestination(member.erase(0, 1));
@@ -457,22 +444,25 @@ static ResVal<CAttributeValue> VerifyMember(const UniValue& array) {
     return {members, Res::Ok()};
 }
 
-static ResVal<CAttributeValue> VerifyCurrencyPair(const std::string& str) {
+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 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()};
+    return {
+        CTokenCurrencyPair{token, currency},
+        Res::Ok()
+    };
 }
 
 static std::set<std::string> dirSet{"both", "in", "out"};
 
-static ResVal<CAttributeValue> VerifyFeeDirection(const std::string& str) {
+static ResVal<CAttributeValue> VerifyFeeDirection(const std::string &str) {
     auto lowerStr = ToLower(str);
     const auto it = dirSet.find(lowerStr);
     if (it == dirSet.end()) {
@@ -481,23 +471,24 @@ static ResVal<CAttributeValue> VerifyFeeDirection(const std::string& str) {
     return {CFeeDir{static_cast<uint8_t>(std::distance(dirSet.begin(), it))}, Res::Ok()};
 }
 
-static bool VerifyToken(const CCustomCSView& view, const uint32_t id) {
+static bool VerifyToken(const CCustomCSView &view, const uint32_t id) {
     return view.GetToken(DCT_ID{id}).has_value();
 }
 
-static ResVal<CAttributeValue> VerifyConsortiumMember(const UniValue& values) {
+static ResVal<CAttributeValue> VerifyConsortiumMember(const UniValue &values) {
     CConsortiumMembers members;
 
-    for (const auto &key : values.getKeys())
-    {
+    for (const auto &key : values.getKeys()) {
         UniValue value(values[key].get_obj());
         CConsortiumMember member;
 
         member.status = 0;
 
-        member.name = trim_all_ws(value["name"].getValStr()).substr(0, CConsortiumMember::MAX_CONSORTIUM_MEMBERS_STRING_LENGTH);
+        member.name =
+            trim_all_ws(value["name"].getValStr()).substr(0, CConsortiumMember::MAX_CONSORTIUM_MEMBERS_STRING_LENGTH);
         if (member.name.size() < CConsortiumMember::MIN_CONSORTIUM_MEMBERS_STRING_LENGTH) {
-            return Res::Err("Member name too short, must be at least %d chars long", int(CConsortiumMember::MIN_CONSORTIUM_MEMBERS_STRING_LENGTH));
+            return Res::Err("Member name too short, must be at least %d chars long",
+                            int(CConsortiumMember::MIN_CONSORTIUM_MEMBERS_STRING_LENGTH));
         }
 
         if (!value["ownerAddress"].isNull()) {
@@ -510,7 +501,8 @@ static ResVal<CAttributeValue> VerifyConsortiumMember(const UniValue& values) {
             return Res::Err("Empty ownerAddress in consortium member data!");
         }
 
-        member.backingId = trim_all_ws(value["backingId"].getValStr()).substr(0, CConsortiumMember::MAX_CONSORTIUM_MEMBERS_STRING_LENGTH);
+        member.backingId = trim_all_ws(value["backingId"].getValStr())
+                               .substr(0, CConsortiumMember::MAX_CONSORTIUM_MEMBERS_STRING_LENGTH);
         if (!AmountFromValue(value["mintLimit"], member.mintLimit) || !member.mintLimit) {
             return Res::Err("Mint limit is an invalid amount");
         }
@@ -519,8 +511,7 @@ static ResVal<CAttributeValue> VerifyConsortiumMember(const UniValue& values) {
             return Res::Err("Daily mint limit is an invalid amount");
         }
 
-        if (!value["status"].isNull())
-        {
+        if (!value["status"].isNull()) {
             uint32_t tmp;
 
             if (ParseUInt32(value["status"].getValStr(), &tmp)) {
@@ -539,117 +530,110 @@ static ResVal<CAttributeValue> VerifyConsortiumMember(const UniValue& values) {
     return {members, Res::Ok()};
 }
 
-static inline void rtrim(std::string& s, unsigned char remove) {
-    s.erase(std::find_if(s.rbegin(), s.rend(), [&remove](unsigned char ch) {
-        return ch != remove;
-    }).base(), s.end());
+static inline void rtrim(std::string &s, unsigned char remove) {
+    s.erase(std::find_if(s.rbegin(), s.rend(), [&remove](unsigned char ch) { return ch != remove; }).base(), s.end());
 }
 
-const std::map<uint8_t, std::map<uint8_t,
-    std::function<ResVal<CAttributeValue>(const std::string&)>>>& ATTRIBUTES::parseValue() {
-
-    static 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::LoanPaybackCollateral,     VerifyBool},
-                {TokenKeys::DexInFeePct,               VerifyPct},
-                {TokenKeys::DexOutFeePct,              VerifyPct},
-                {TokenKeys::FixedIntervalPriceId,      VerifyCurrencyPair},
-                {TokenKeys::LoanCollateralEnabled,     VerifyBool},
-                {TokenKeys::LoanCollateralFactor,      VerifyPositiveFloat},
-                {TokenKeys::LoanMintingEnabled,        VerifyBool},
-                {TokenKeys::LoanMintingInterest,       VerifyFloat},
-                {TokenKeys::DFIP2203Enabled,           VerifyBool},
-            }
-        },
-        {
-            AttributeTypes::Consortium, {
-                {ConsortiumKeys::MintLimit,             VerifyPositiveOrMinusOneFloat},
-                {ConsortiumKeys::DailyMintLimit,        VerifyPositiveOrMinusOneFloat},
-            }
-        },
-        {
-            AttributeTypes::Poolpairs, {
-                {PoolKeys::TokenAFeePCT,      VerifyPct},
-                {PoolKeys::TokenAFeeDir,      VerifyFeeDirection},
-                {PoolKeys::TokenBFeePCT,      VerifyPct},
-                {PoolKeys::TokenBFeeDir,      VerifyFeeDirection},
-            }
-        },
-        {
-            AttributeTypes::Param, {
-                {DFIPKeys::Active,                  VerifyBool},
-                {DFIPKeys::Premium,                 VerifyPct},
-                {DFIPKeys::MinSwap,                 VerifyPositiveFloat},
-                {DFIPKeys::RewardPct,               VerifyPct},
-                {DFIPKeys::BlockPeriod,             VerifyInt64},
-                {DFIPKeys::DUSDInterestBurn,        VerifyBool},
-                {DFIPKeys::DUSDLoanBurn,            VerifyBool},
-                {DFIPKeys::StartBlock,              VerifyInt64},
-                {DFIPKeys::GovUnset,                VerifyBool},
-                {DFIPKeys::GovFoundation,           VerifyBool},
-                {DFIPKeys::MNSetRewardAddress,      VerifyBool},
-                {DFIPKeys::MNSetOperatorAddress,    VerifyBool},
-                {DFIPKeys::MNSetOwnerAddress,       VerifyBool},
-                {DFIPKeys::GovernanceEnabled,       VerifyBool},
-                {DFIPKeys::ConsortiumEnabled,       VerifyBool},
-                {DFIPKeys::CFPPayout,               VerifyBool},
-                {DFIPKeys::EmissionUnusedFund,      VerifyBool},
-            }
-        },
-        {
-            AttributeTypes::Locks, {
-                {ParamIDs::TokenID,          VerifyBool},
-            }
-        },
-        {
-            AttributeTypes::Oracles, {
-                {OracleIDs::Splits,          VerifySplit},
-            }
-        },
-        {
-            AttributeTypes::Governance, {
-                {GovernanceKeys::FeeRedistribution,     VerifyBool},
-                {GovernanceKeys::FeeBurnPct,            VerifyPct},
-                {GovernanceKeys::CFPFee,                VerifyPct},
-                {GovernanceKeys::CFPMajority,           VerifyPct},
-                {GovernanceKeys::VOCFee,                VerifyPositiveFloat},
-                {GovernanceKeys::VOCEmergencyFee,       VerifyPositiveFloat},
-                {GovernanceKeys::VOCEmergencyPeriod,    VerifyUInt32},
-                {GovernanceKeys::VOCEmergencyQuorum,    VerifyPct},
-                {GovernanceKeys::VOCMajority,           VerifyPct},
-                {GovernanceKeys::Quorum,                VerifyPct},
-                {GovernanceKeys::VotingPeriod,          VerifyUInt32},
-            }
-        },
+const std::map<uint8_t, std::map<uint8_t, std::function<ResVal<CAttributeValue>(const std::string &)>>>
+    &ATTRIBUTES::parseValue() {
+    static 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::LoanPaybackCollateral, VerifyBool},
+                 {TokenKeys::DexInFeePct, VerifyPct},
+                 {TokenKeys::DexOutFeePct, VerifyPct},
+                 {TokenKeys::FixedIntervalPriceId, VerifyCurrencyPair},
+                 {TokenKeys::LoanCollateralEnabled, VerifyBool},
+                 {TokenKeys::LoanCollateralFactor, VerifyPositiveFloat},
+                 {TokenKeys::LoanMintingEnabled, VerifyBool},
+                 {TokenKeys::LoanMintingInterest, VerifyFloat},
+                 {TokenKeys::DFIP2203Enabled, VerifyBool},
+             }},
+            {AttributeTypes::Consortium,
+             {
+                 {ConsortiumKeys::MintLimit, VerifyPositiveOrMinusOneFloat},
+                 {ConsortiumKeys::DailyMintLimit, VerifyPositiveOrMinusOneFloat},
+             }},
+            {AttributeTypes::Poolpairs,
+             {
+                 {PoolKeys::TokenAFeePCT, VerifyPct},
+                 {PoolKeys::TokenAFeeDir, VerifyFeeDirection},
+                 {PoolKeys::TokenBFeePCT, VerifyPct},
+                 {PoolKeys::TokenBFeeDir, VerifyFeeDirection},
+             }},
+            {AttributeTypes::Param,
+             {
+                 {DFIPKeys::Active, VerifyBool},
+                 {DFIPKeys::Premium, VerifyPct},
+                 {DFIPKeys::MinSwap, VerifyPositiveFloat},
+                 {DFIPKeys::RewardPct, VerifyPct},
+                 {DFIPKeys::BlockPeriod, VerifyInt64},
+                 {DFIPKeys::DUSDInterestBurn, VerifyBool},
+                 {DFIPKeys::DUSDLoanBurn, VerifyBool},
+                 {DFIPKeys::StartBlock, VerifyInt64},
+                 {DFIPKeys::GovUnset, VerifyBool},
+                 {DFIPKeys::GovFoundation, VerifyBool},
+                 {DFIPKeys::MNSetRewardAddress, VerifyBool},
+                 {DFIPKeys::MNSetOperatorAddress, VerifyBool},
+                 {DFIPKeys::MNSetOwnerAddress, VerifyBool},
+                 {DFIPKeys::GovernanceEnabled, VerifyBool},
+                 {DFIPKeys::ConsortiumEnabled, VerifyBool},
+                 {DFIPKeys::CFPPayout, VerifyBool},
+                 {DFIPKeys::EmissionUnusedFund, VerifyBool},
+             }},
+            {AttributeTypes::Locks,
+             {
+                 {ParamIDs::TokenID, VerifyBool},
+             }},
+            {AttributeTypes::Oracles,
+             {
+                 {OracleIDs::Splits, VerifySplit},
+             }},
+            {AttributeTypes::Governance,
+             {
+                 {GovernanceKeys::FeeRedistribution, VerifyBool},
+                 {GovernanceKeys::FeeBurnPct, VerifyPct},
+                 {GovernanceKeys::CFPFee, VerifyPct},
+                 {GovernanceKeys::CFPMajority, VerifyPct},
+                 {GovernanceKeys::VOCFee, VerifyPositiveFloat},
+                 {GovernanceKeys::VOCEmergencyFee, VerifyPositiveFloat},
+                 {GovernanceKeys::VOCEmergencyPeriod, VerifyUInt32},
+                 {GovernanceKeys::VOCEmergencyQuorum, VerifyPct},
+                 {GovernanceKeys::VOCMajority, VerifyPct},
+                 {GovernanceKeys::Quorum, VerifyPct},
+                 {GovernanceKeys::VotingPeriod, VerifyUInt32},
+             }},
     };
     return parsers;
 }
 
-ResVal<CScript> GetFutureSwapContractAddress(const std::string& contract) {
+ResVal<CScript> GetFutureSwapContractAddress(const std::string &contract) {
     CScript contractAddress;
     try {
         contractAddress = Params().GetConsensus().smartContracts.at(contract);
-    } catch (const std::out_of_range&) {
+    } catch (const std::out_of_range &) {
         return Res::Err("Failed to get smart contract address from chainparams");
     }
     return {contractAddress, Res::Ok()};
 }
 
-static Res ShowError(const std::string& key, const std::map<std::string, uint8_t>& keys) {
+static Res ShowError(const std::string &key, const std::map<std::string, uint8_t> &keys) {
     std::string error{"Unrecognised " + key + " argument provided, valid " + key + "s are:"};
-    for (const auto& pair : keys) {
+    for (const auto &pair : keys) {
         error += ' ' + pair.first + ',';
     }
     return Res::Err(error);
 }
 
-static void TrackLiveBalance(CCustomCSView& mnview, const CTokenAmount& amount, const EconomyKeys dataKey, const bool add) {
+static void TrackLiveBalance(CCustomCSView &mnview,
+                             const CTokenAmount &amount,
+                             const EconomyKeys dataKey,
+                             const bool add) {
     auto attributes = mnview.GetAttributes();
     assert(attributes);
     CDataStructureV0 key{AttributeTypes::Live, ParamIDs::Economy, dataKey};
@@ -666,36 +650,36 @@ static void TrackLiveBalance(CCustomCSView& mnview, const CTokenAmount& amount,
     }
 }
 
-void TrackNegativeInterest(CCustomCSView& mnview, const CTokenAmount& amount) {
+void TrackNegativeInterest(CCustomCSView &mnview, const CTokenAmount &amount) {
     if (!gArgs.GetBoolArg("-negativeinterest", DEFAULT_NEGATIVE_INTEREST)) {
         return;
     }
     TrackLiveBalance(mnview, amount, EconomyKeys::NegativeInt, true);
 }
 
-void TrackDUSDAdd(CCustomCSView& mnview, const CTokenAmount& amount) {
+void TrackDUSDAdd(CCustomCSView &mnview, const CTokenAmount &amount) {
     TrackLiveBalance(mnview, amount, EconomyKeys::Loans, true);
 }
 
-void TrackDUSDSub(CCustomCSView& mnview, const CTokenAmount& amount) {
+void TrackDUSDSub(CCustomCSView &mnview, const CTokenAmount &amount) {
     TrackLiveBalance(mnview, amount, EconomyKeys::Loans, false);
 }
 
-void TrackLiveBalances(CCustomCSView& mnview, const CBalances& balances, const uint8_t key) {
+void TrackLiveBalances(CCustomCSView &mnview, const CBalances &balances, const uint8_t key) {
     auto attributes = mnview.GetAttributes();
     assert(attributes);
     const CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Auction, key};
     auto storedBalances = attributes->GetValue(liveKey, CBalances{});
-    for (const auto& [tokenID, amount] : balances.balances) {
+    for (const auto &[tokenID, amount] : balances.balances) {
         storedBalances.balances[tokenID] += amount;
     }
     attributes->SetValue(liveKey, storedBalances);
     mnview.SetVariable(*attributes);
 }
 
-Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniValue> &value,
-                                std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable) {
-
+Res ATTRIBUTES::ProcessVariable(const std::string &key,
+                                const std::optional<UniValue> &value,
+                                std::function<Res(const CAttributeType &, const CAttributeValue &)> applyVariable) {
     if (key.size() > 128) {
         return Res::Err("Identifier exceeds maximum length (128)");
     }
@@ -705,12 +689,12 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniV
         return Res::Err("Empty version");
     }
 
-    const auto& iver = allowedVersions().find(keys[0]);
+    const auto &iver = allowedVersions().find(keys[0]);
     if (iver == allowedVersions().end()) {
         return Res::Err("Unsupported version");
     }
 
-    const auto& version = iver->second;
+    const auto &version = iver->second;
     if (version != VersionTypes::v0) {
         return Res::Err("Unsupported version");
     }
@@ -792,19 +776,16 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniV
 
         if (type == AttributeTypes::Param) {
             if (typeId == ParamIDs::DFIP2201) {
-                if (typeKey != DFIPKeys::Active && typeKey != DFIPKeys::Premium  &&
-                    typeKey != DFIPKeys::MinSwap ) {
+                if (typeKey != DFIPKeys::Active && typeKey != DFIPKeys::Premium && typeKey != DFIPKeys::MinSwap) {
                     return Res::Err("Unsupported type for DFIP2201 {%d}", typeKey);
                 }
-            } else if (typeId == ParamIDs::DFIP2203 ||
-                       typeId == ParamIDs::DFIP2206F) {
-                if (typeKey != DFIPKeys::Active && typeKey != DFIPKeys::RewardPct &&
-                    typeKey != DFIPKeys::BlockPeriod && typeKey != DFIPKeys::StartBlock) {
+            } else if (typeId == ParamIDs::DFIP2203 || typeId == ParamIDs::DFIP2206F) {
+                if (typeKey != DFIPKeys::Active && typeKey != DFIPKeys::RewardPct && typeKey != DFIPKeys::BlockPeriod &&
+                    typeKey != DFIPKeys::StartBlock) {
                     return Res::Err("Unsupported type for this DFIP {%d}", typeKey);
                 }
 
-                if (typeKey == DFIPKeys::BlockPeriod ||
-                    typeKey == DFIPKeys::StartBlock) {
+                if (typeKey == DFIPKeys::BlockPeriod || typeKey == DFIPKeys::StartBlock) {
                     if (typeId == ParamIDs::DFIP2203) {
                         futureUpdated = true;
                     } else {
@@ -812,42 +793,36 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniV
                     }
                 }
             } else if (typeId == ParamIDs::DFIP2206A) {
-                if (typeKey != DFIPKeys::DUSDInterestBurn &&
-                    typeKey != DFIPKeys::DUSDLoanBurn) {
+                if (typeKey != DFIPKeys::DUSDInterestBurn && typeKey != DFIPKeys::DUSDLoanBurn) {
                     return Res::Err("Unsupported type for DFIP2206A {%d}", typeKey);
                 }
 
             } else if (typeId == ParamIDs::Feature) {
-                if (typeKey != DFIPKeys::GovUnset &&
-                    typeKey != DFIPKeys::GovFoundation &&
-                    typeKey != DFIPKeys::MNSetRewardAddress &&
-                    typeKey != DFIPKeys::MNSetOperatorAddress &&
-                    typeKey != DFIPKeys::MNSetOwnerAddress &&
-                    typeKey != DFIPKeys::GovernanceEnabled &&
-                    typeKey != DFIPKeys::ConsortiumEnabled &&
-                    typeKey != DFIPKeys::CFPPayout &&
+                if (typeKey != DFIPKeys::GovUnset && typeKey != DFIPKeys::GovFoundation &&
+                    typeKey != DFIPKeys::MNSetRewardAddress && typeKey != DFIPKeys::MNSetOperatorAddress &&
+                    typeKey != DFIPKeys::MNSetOwnerAddress && typeKey != DFIPKeys::GovernanceEnabled &&
+                    typeKey != DFIPKeys::ConsortiumEnabled && typeKey != DFIPKeys::CFPPayout &&
                     typeKey != DFIPKeys::EmissionUnusedFund) {
                     return Res::Err("Unsupported type for Feature {%d}", typeKey);
                 }
-            } else if (typeId == ParamIDs::Foundation)  {
+            } else if (typeId == ParamIDs::Foundation) {
                 if (typeKey != DFIPKeys::Members) {
                     return Res::Err("Unsupported type for Foundation {%d}", typeKey);
                 }
-            }  else {
-                    return Res::Err("Unsupported Param ID");
+            } else {
+                return Res::Err("Unsupported Param ID");
             }
         } else if (type == AttributeTypes::Governance) {
             if (typeId == GovernanceIDs::Proposals) {
-                if (typeKey != GovernanceKeys::FeeRedistribution && typeKey != GovernanceKeys::FeeBurnPct
-                    && typeKey != GovernanceKeys::CFPFee
-                    && typeKey != GovernanceKeys::CFPMajority && typeKey != GovernanceKeys::VOCFee
-                    && typeKey != GovernanceKeys::VOCMajority && typeKey != GovernanceKeys::VOCEmergencyPeriod
-                    && typeKey != GovernanceKeys::VOCEmergencyFee && typeKey != GovernanceKeys::VOCEmergencyQuorum
-                    && typeKey != GovernanceKeys::Quorum && typeKey != GovernanceKeys::VotingPeriod)
+                if (typeKey != GovernanceKeys::FeeRedistribution && typeKey != GovernanceKeys::FeeBurnPct &&
+                    typeKey != GovernanceKeys::CFPFee && typeKey != GovernanceKeys::CFPMajority &&
+                    typeKey != GovernanceKeys::VOCFee && typeKey != GovernanceKeys::VOCMajority &&
+                    typeKey != GovernanceKeys::VOCEmergencyPeriod && typeKey != GovernanceKeys::VOCEmergencyFee &&
+                    typeKey != GovernanceKeys::VOCEmergencyQuorum && typeKey != GovernanceKeys::Quorum &&
+                    typeKey != GovernanceKeys::VotingPeriod)
                     return Res::Err("Unsupported key for Governance Proposal section - {%d}", typeKey);
             } else {
                 return Res::Err("Unsupported Governance ID");
-
             }
         }
 
@@ -884,7 +859,8 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniV
             return std::move(attribValue);
         }
         return applyVariable(attrV0, *attribValue.val);
-    } else if (attrV0.type == AttributeTypes::Param && attrV0.typeId == ParamIDs::Foundation && attrV0.key == DFIPKeys::Members) {
+    } else if (attrV0.type == AttributeTypes::Param && attrV0.typeId == ParamIDs::Foundation &&
+               attrV0.key == DFIPKeys::Members) {
         if (value && value->get_array().empty()) {
             return Res::Err("Empty value");
         }
@@ -907,19 +883,18 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::optional<UniV
                 }
                 return applyVariable(attrV0, *attribValue.val);
             }
-        } catch (const std::out_of_range&) {}
+        } catch (const std::out_of_range &) {
+        }
     }
 
     return Res::Err("No parse function {%d, %d}", type, typeKey);
 }
 
-bool ATTRIBUTES::IsEmpty() const
-{
+bool ATTRIBUTES::IsEmpty() const {
     return attributes.empty();
 }
 
-Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID)
-{
+Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID) {
     CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::BlockPeriod};
     const auto blockPeriod = GetValue(blockKey, CAmount{});
     if (blockPeriod == 0) {
@@ -928,17 +903,19 @@ Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t hei
 
     std::map<CFuturesUserKey, CFuturesUserValue> userFuturesValues;
 
-    mnview.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues) {
-        if (tokenID != std::numeric_limits<uint32_t>::max()) {
-            if (futuresValues.source.nTokenId.v == tokenID || futuresValues.destination == tokenID) {
+    mnview.ForEachFuturesUserValues(
+        [&](const CFuturesUserKey &key, const CFuturesUserValue &futuresValues) {
+            if (tokenID != std::numeric_limits<uint32_t>::max()) {
+                if (futuresValues.source.nTokenId.v == tokenID || futuresValues.destination == tokenID) {
+                    userFuturesValues[key] = futuresValues;
+                }
+            } else {
                 userFuturesValues[key] = futuresValues;
             }
-        } else {
-            userFuturesValues[key] = futuresValues;
-        }
 
-        return true;
-    }, {height, {}, std::numeric_limits<uint32_t>::max()});
+            return true;
+        },
+        {height, {}, std::numeric_limits<uint32_t>::max()});
 
     const auto contractAddressValue = GetFutureSwapContractAddress(SMART_CONTRACT_DFIP_2203);
     if (!contractAddressValue) {
@@ -948,15 +925,15 @@ Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t hei
     CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Current};
     auto balances = GetValue(liveKey, CBalances{});
 
-    CAccountHistoryStorage* historyStore{mnview.GetAccountHistoryStore()};
+    CAccountHistoryStorage *historyStore{mnview.GetAccountHistoryStore()};
     const auto currentHeight = mnview.GetLastHeight() + 1;
 
-    for (const auto& [key, value] : userFuturesValues) {
-
+    for (const auto &[key, value] : userFuturesValues) {
         mnview.EraseFuturesUserValues(key);
 
         CHistoryWriters subWriters{historyStore, nullptr, nullptr};
-        CAccountsHistoryWriter subView(mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+        CAccountsHistoryWriter subView(
+            mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
 
         auto res = subView.SubBalance(*contractAddressValue, value.source);
         if (!res) {
@@ -965,7 +942,8 @@ Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t hei
         subView.Flush();
 
         CHistoryWriters addWriters{historyStore, nullptr, nullptr};
-        CAccountsHistoryWriter addView(mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+        CAccountsHistoryWriter addView(
+            mnview, currentHeight, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
 
         res = addView.AddBalance(key.owner, value.source);
         if (!res) {
@@ -984,8 +962,7 @@ Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t hei
     return Res::Ok();
 }
 
-Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
-{
+Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height) {
     CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2206F, DFIPKeys::BlockPeriod};
     const auto blockPeriod = GetValue(blockKey, CAmount{});
     if (blockPeriod == 0) {
@@ -994,10 +971,12 @@ Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
 
     std::map<CFuturesUserKey, CAmount> userFuturesValues;
 
-    mnview.ForEachFuturesDUSD([&](const CFuturesUserKey& key, const CAmount& amount) {
-        userFuturesValues[key] = amount;
-        return true;
-    }, {height, {}, std::numeric_limits<uint32_t>::max()});
+    mnview.ForEachFuturesDUSD(
+        [&](const CFuturesUserKey &key, const CAmount &amount) {
+            userFuturesValues[key] = amount;
+            return true;
+        },
+        {height, {}, std::numeric_limits<uint32_t>::max()});
 
     const auto contractAddressValue = GetFutureSwapContractAddress(SMART_CONTRACT_DFIP2206F);
     if (!contractAddressValue) {
@@ -1007,12 +986,12 @@ Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
     CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2206FCurrent};
     auto balances = GetValue(liveKey, CBalances{});
 
-    for (const auto& [key, amount] : userFuturesValues) {
-
+    for (const auto &[key, amount] : userFuturesValues) {
         mnview.EraseFuturesDUSD(key);
 
         CHistoryWriters subWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter subView(mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
+        CAccountsHistoryWriter subView(
+            mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &subWriters);
         auto res = subView.SubBalance(*contractAddressValue, {DCT_ID{}, amount});
         if (!res) {
             return res;
@@ -1020,7 +999,8 @@ Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
         subView.Flush();
 
         CHistoryWriters addWriters{paccountHistoryDB.get(), nullptr, nullptr};
-        CAccountsHistoryWriter addView(mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
+        CAccountsHistoryWriter addView(
+            mnview, height, GetNextAccPosition(), {}, uint8_t(CustomTxType::FutureSwapRefund), &addWriters);
         res = addView.AddBalance(key.owner, {DCT_ID{}, amount});
         if (!res) {
             return res;
@@ -1038,7 +1018,7 @@ Res ATTRIBUTES::RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height)
     return Res::Ok();
 }
 
-Res ATTRIBUTES::Import(const UniValue & val) {
+Res ATTRIBUTES::Import(const UniValue &val) {
     if (!val.isObject()) {
         return Res::Err("Object of values expected");
     }
@@ -1046,85 +1026,82 @@ Res ATTRIBUTES::Import(const UniValue & val) {
     std::map<std::string, UniValue> objMap;
     val.getObjMap(objMap);
 
-    for (const auto& [key, value] : objMap) {
-        auto res = ProcessVariable(
-            key, value,
-            [this](const CAttributeType& attribute, const CAttributeValue& value) {
-                if (const auto attrV0 = std::get_if<CDataStructureV0>(&attribute)) {
-                    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) {
-                        const auto splitValue = std::get_if<OracleSplits>(&value);
-                        if (!splitValue) {
-                            return Res::Err("Failed to get Oracle split value");
-                        }
-                        if (splitValue->size() != 1)
-                            return Res::Err("Invalid number of token splits, allowed only one per height!");
+    for (const auto &[key, value] : objMap) {
+        auto res = ProcessVariable(key, value, [this](const CAttributeType &attribute, const CAttributeValue &value) {
+            if (const auto attrV0 = std::get_if<CDataStructureV0>(&attribute)) {
+                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) {
+                    const auto splitValue = std::get_if<OracleSplits>(&value);
+                    if (!splitValue) {
+                        return Res::Err("Failed to get Oracle split value");
+                    }
+                    if (splitValue->size() != 1)
+                        return Res::Err("Invalid number of token splits, allowed only one per height!");
 
-                        const auto& [id, multiplier] = *(splitValue->begin());
-                        tokenSplits.insert(id);
+                    const auto &[id, multiplier] = *(splitValue->begin());
+                    tokenSplits.insert(id);
 
-                        SetValue(attribute, *splitValue);
-                        return Res::Ok();
-                    } else if (attrV0->type == AttributeTypes::Param && attrV0->typeId == ParamIDs::Foundation && attrV0->key == DFIPKeys::Members) {
-                        const auto members = std::get_if<std::set<CScript>>(&value);
-                        if (members) {
-                            auto existingMembers = GetValue(attribute, std::set<CScript>{});
-
-                            for (const auto &member : *members) {
-                                if (existingMembers.count(member)) {
-                                    return Res::Err("Member to add already present");
-                                }
-                                existingMembers.insert(member);
+                    SetValue(attribute, *splitValue);
+                    return Res::Ok();
+                } else if (attrV0->type == AttributeTypes::Param && attrV0->typeId == ParamIDs::Foundation &&
+                           attrV0->key == DFIPKeys::Members) {
+                    const auto members = std::get_if<std::set<CScript>>(&value);
+                    if (members) {
+                        auto existingMembers = GetValue(attribute, std::set<CScript>{});
+
+                        for (const auto &member : *members) {
+                            if (existingMembers.count(member)) {
+                                return Res::Err("Member to add already present");
                             }
-
-                            SetValue(attribute, existingMembers);
-                        } else {
-                            SetValue(attribute, value);
+                            existingMembers.insert(member);
                         }
 
-                        return Res::Ok();
-                    } else if (attrV0->type == AttributeTypes::Token && attrV0->key == TokenKeys::LoanMintingInterest) {
-                        interestTokens.insert(attrV0->typeId);
+                        SetValue(attribute, existingMembers);
+                    } else {
+                        SetValue(attribute, value);
                     }
 
-                    // apply DFI via old keys
-                    if (attrV0->IsExtendedSize() && attrV0->keyId == 0) {
-                        auto newAttr = *attrV0;
-                        if (attrV0->key == TokenKeys::LoanPayback) {
-                            newAttr.key = TokenKeys::PaybackDFI;
-                        } else {
-                            newAttr.key = TokenKeys::PaybackDFIFeePCT;
-                        }
-                        SetValue(newAttr, value);
-                        return Res::Ok();
-                    } else if (attrV0->type == AttributeTypes::Consortium && attrV0->key == ConsortiumKeys::MemberValues) {
-                        if (auto attrValue = std::get_if<CConsortiumMembers>(&value)) {
-                            auto members = GetValue(*attrV0, CConsortiumMembers{});
+                    return Res::Ok();
+                } else if (attrV0->type == AttributeTypes::Token && attrV0->key == TokenKeys::LoanMintingInterest) {
+                    interestTokens.insert(attrV0->typeId);
+                }
 
-                            for (auto const & member : *attrValue)
-                            {
-                                for (auto const & tmp : members)
-                                    if (tmp.first != member.first && tmp.second.ownerAddress == member.second.ownerAddress)
-                                        return Res::Err("Cannot add a member with an owner address of a existing consortium member!");
+                // apply DFI via old keys
+                if (attrV0->IsExtendedSize() && attrV0->keyId == 0) {
+                    auto newAttr = *attrV0;
+                    if (attrV0->key == TokenKeys::LoanPayback) {
+                        newAttr.key = TokenKeys::PaybackDFI;
+                    } else {
+                        newAttr.key = TokenKeys::PaybackDFIFeePCT;
+                    }
+                    SetValue(newAttr, value);
+                    return Res::Ok();
+                } else if (attrV0->type == AttributeTypes::Consortium && attrV0->key == ConsortiumKeys::MemberValues) {
+                    if (auto attrValue = std::get_if<CConsortiumMembers>(&value)) {
+                        auto members = GetValue(*attrV0, CConsortiumMembers{});
 
-                                members[member.first] = member.second;
-                            }
-                            SetValue(*attrV0, members);
+                        for (auto const &member : *attrValue) {
+                            for (auto const &tmp : members)
+                                if (tmp.first != member.first && tmp.second.ownerAddress == member.second.ownerAddress)
+                                    return Res::Err(
+                                        "Cannot add a member with an owner address of a existing consortium member!");
 
-                            return Res::Ok();
-                        } else
-                            return Res::Err("Invalid member data");
-                    }
+                            members[member.first] = member.second;
+                        }
+                        SetValue(*attrV0, members);
+
+                        return Res::Ok();
+                    } else
+                        return Res::Err("Invalid member data");
                 }
-                SetValue(attribute, value);
-                return Res::Ok();
             }
-        );
+            SetValue(attribute, value);
+            return Res::Ok();
+        });
         if (!res) {
             return res;
         }
@@ -1148,22 +1125,22 @@ std::set<uint32_t> attrsVersion27TokenHiddenSet = {
 
 UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &prefix) const {
     UniValue ret(UniValue::VOBJ);
-    for (const auto& attribute : attributes) {
+    for (const auto &attribute : attributes) {
         const auto attrV0 = std::get_if<CDataStructureV0>(&attribute.first);
         if (!attrV0) {
             continue;
         }
-        if (filter == GovVarsFilter::LiveAttributes &&
-            attrV0->type != AttributeTypes::Live) {
-                continue;
+        if (filter == GovVarsFilter::LiveAttributes && attrV0->type != AttributeTypes::Live) {
+            continue;
         } else if (filter == GovVarsFilter::Version2Dot7) {
             if (attrV0->type == AttributeTypes::Token &&
-            attrsVersion27TokenHiddenSet.find(attrV0->key) != attrsVersion27TokenHiddenSet.end())
+                attrsVersion27TokenHiddenSet.find(attrV0->key) != attrsVersion27TokenHiddenSet.end())
                 continue;
         }
         try {
             std::string id;
-            if (attrV0->type == AttributeTypes::Param || attrV0->type == AttributeTypes::Live || attrV0->type == AttributeTypes::Locks) {
+            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);
@@ -1173,12 +1150,11 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 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);
+            const auto 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,
-                                  v0Key);
+            auto key = KeyBuilder(displayVersions().at(VersionTypes::v0), displayTypes().at(attrV0->type), id, v0Key);
 
             if (attrV0->IsExtendedSize()) {
                 key = KeyBuilder(key, attrV0->keyId);
@@ -1198,8 +1174,8 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 ret.pushKV(key, KeyBuilder(*number));
             } else if (const auto amount = std::get_if<CAmount>(&attribute.second)) {
                 if (attrV0->type == AttributeTypes::Param &&
-                   (attrV0->typeId == DFIP2203 || attrV0->typeId == DFIP2206F) &&
-                   (attrV0->key == DFIPKeys::BlockPeriod || attrV0->key == DFIPKeys::StartBlock)) {
+                    (attrV0->typeId == DFIP2203 || attrV0->typeId == DFIP2206F) &&
+                    (attrV0->key == DFIPKeys::BlockPeriod || attrV0->key == DFIPKeys::StartBlock)) {
                     ret.pushKV(key, KeyBuilder(*amount));
                 } else {
                     auto decimalStr = GetDecimaleString(*amount);
@@ -1211,10 +1187,8 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
 
                     // Create fee_pct alias of reward_pct.
                     if (v0Key == "reward_pct") {
-                        const auto newKey = KeyBuilder(displayVersions().at(VersionTypes::v0),
-                                                 displayTypes().at(attrV0->type),
-                                                 id,
-                                                 "fee_pct");
+                        const auto newKey = KeyBuilder(
+                            displayVersions().at(VersionTypes::v0), displayTypes().at(attrV0->type), id, "fee_pct");
                         ret.pushKV(newKey, decimalStr);
                     }
                 }
@@ -1226,10 +1200,10 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 result.pushKV("paybacktokens", AmountsToJSON(paybacks->tokensPayback.balances));
                 ret.pushKV(key, result);
             } else if (const auto balances = std::get_if<CDexBalances>(&attribute.second)) {
-                for (const auto& pool : *balances) {
-                    auto& dexTokenA = pool.second.totalTokenA;
-                    auto& dexTokenB = pool.second.totalTokenB;
-                    auto poolkey = KeyBuilder(key, pool.first.v);
+                for (const auto &pool : *balances) {
+                    auto &dexTokenA = pool.second.totalTokenA;
+                    auto &dexTokenB = pool.second.totalTokenB;
+                    auto poolkey    = KeyBuilder(key, pool.first.v);
                     ret.pushKV(KeyBuilder(poolkey, "total_commission_a"), ValueFromUint(dexTokenA.commissions));
                     ret.pushKV(KeyBuilder(poolkey, "total_commission_b"), ValueFromUint(dexTokenB.commissions));
                     ret.pushKV(KeyBuilder(poolkey, "fee_burn_a"), ValueFromUint(dexTokenA.feeburn));
@@ -1239,8 +1213,7 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 }
             } else if (auto members = std::get_if<CConsortiumMembers>(&attribute.second)) {
                 UniValue result(UniValue::VOBJ);
-                for (const auto& [id, member] : *members)
-                {
+                for (const auto &[id, member] : *members) {
                     UniValue elem(UniValue::VOBJ);
                     elem.pushKV("name", member.name);
                     elem.pushKV("ownerAddress", ScriptToString(member.ownerAddress));
@@ -1252,10 +1225,9 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 }
                 ret.pushKV(key, result);
             } else if (auto consortiumMinted = std::get_if<CConsortiumGlobalMinted>(&attribute.second)) {
-                for (const auto& token : *consortiumMinted)
-                {
-                    auto& minted = token.second.minted;
-                    auto& burnt = token.second.burnt;
+                for (const auto &token : *consortiumMinted) {
+                    auto &minted = token.second.minted;
+                    auto &burnt  = token.second.burnt;
 
                     auto tokenKey = KeyBuilder(key, token.first.v);
                     ret.pushKV(KeyBuilder(tokenKey, "minted"), ValueFromAmount(minted));
@@ -1263,17 +1235,17 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                     ret.pushKV(KeyBuilder(tokenKey, "supply"), ValueFromAmount(minted - burnt));
                 }
             } else if (auto membersMinted = std::get_if<CConsortiumMembersMinted>(&attribute.second)) {
-                for (const auto& token : *membersMinted)
-                {
-                    for (const auto& member : token.second)
-                    {
-                        auto& minted = member.second.minted;
-                        auto& burnt = member.second.burnt;
-
-                        auto tokenKey = KeyBuilder(key, token.first.v);
+                for (const auto &token : *membersMinted) {
+                    for (const auto &member : token.second) {
+                        auto &minted = member.second.minted;
+                        auto &burnt  = member.second.burnt;
+
+                        auto tokenKey  = KeyBuilder(key, token.first.v);
                         auto memberKey = KeyBuilder(tokenKey, member.first);
                         ret.pushKV(KeyBuilder(memberKey, "minted"), ValueFromAmount(minted));
-                        ret.pushKV(KeyBuilder(memberKey, "daily_minted"), KeyBuilder(member.second.dailyMinted.first, ValueFromAmount(member.second.dailyMinted.second).getValStr()));
+                        ret.pushKV(KeyBuilder(memberKey, "daily_minted"),
+                                   KeyBuilder(member.second.dailyMinted.first,
+                                              ValueFromAmount(member.second.dailyMinted.second).getValStr()));
                         ret.pushKV(KeyBuilder(memberKey, "burnt"), ValueFromAmount(burnt));
                         ret.pushKV(KeyBuilder(memberKey, "supply"), ValueFromAmount(minted - burnt));
                     }
@@ -1287,9 +1259,9 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                     keyValue += KeyBuilder(it->first, it->second);
                 }
                 ret.pushKV(key, keyValue);
-            } else if (const auto& descendantPair = std::get_if<DescendantValue>(&attribute.second)) {
+            } else if (const auto &descendantPair = std::get_if<DescendantValue>(&attribute.second)) {
                 ret.pushKV(key, KeyBuilder(descendantPair->first, descendantPair->second));
-            } else if (const auto& ascendantPair = std::get_if<AscendantValue>(&attribute.second)) {
+            } else if (const auto &ascendantPair = std::get_if<AscendantValue>(&attribute.second)) {
                 ret.pushKV(key, KeyBuilder(ascendantPair->first, ascendantPair->second));
             } else if (const auto currencyPair = std::get_if<CTokenCurrencyPair>(&attribute.second)) {
                 ret.pushKV(key, currencyPair->first + '/' + currencyPair->second);
@@ -1317,7 +1289,7 @@ UniValue ATTRIBUTES::ExportFiltered(GovVarsFilter filter, const std::string &pre
                 }
                 ret.pushKV(key, array);
             }
-        } catch (const std::out_of_range&) {
+        } catch (const std::out_of_range &) {
             // Should not get here, that's mean maps are mismatched
         }
     }
@@ -1328,12 +1300,11 @@ UniValue ATTRIBUTES::Export() const {
     return ExportFiltered(GovVarsFilter::All, "");
 }
 
-Res ATTRIBUTES::Validate(const CCustomCSView & view) const
-{
+Res ATTRIBUTES::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() < Params().GetConsensus().FortCanningHillHeight)
         return Res::Err("Cannot be set before FortCanningHill");
 
-    for (const auto& [key, value] : attributes) {
+    for (const auto &[key, value] : attributes) {
         const auto attrV0 = std::get_if<CDataStructureV0>(&key);
         if (!attrV0) {
             return Res::Err("Unsupported version");
@@ -1352,7 +1323,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetLoanTokenByID({attrV0->typeId})) {
                             return Res::Err("No such loan token (%d)", attrV0->typeId);
                         }
-                    break;
+                        break;
                     case TokenKeys::LoanPayback:
                     case TokenKeys::LoanPaybackFeePCT:
                         if (view.GetLastHeight() < Params().GetConsensus().FortCanningRoadHeight) {
@@ -1364,7 +1335,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetToken(DCT_ID{attrV0->keyId})) {
                             return Res::Err("No such token (%d)", attrV0->keyId);
                         }
-                    break;
+                        break;
                     case TokenKeys::DexInFeePct:
                     case TokenKeys::DexOutFeePct:
                         if (view.GetLastHeight() < Params().GetConsensus().FortCanningRoadHeight) {
@@ -1373,7 +1344,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetToken(DCT_ID{attrV0->typeId})) {
                             return Res::Err("No such token (%d)", attrV0->typeId);
                         }
-                    break;
+                        break;
                     case TokenKeys::LoanCollateralFactor:
                         if (view.GetLastHeight() < Params().GetConsensus().FortCanningEpilogueHeight) {
                             const auto amount = std::get_if<CAmount>(&value);
@@ -1398,8 +1369,8 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!VerifyToken(view, attrV0->typeId)) {
                             return Res::Err("No such token (%d)", attrV0->typeId);
                         }
-                        CDataStructureV0 intervalPriceKey{AttributeTypes::Token, attrV0->typeId,
-                                                          TokenKeys::FixedIntervalPriceId};
+                        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");
                         }
@@ -1420,15 +1391,15 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetLoanTokenByID(DCT_ID{attrV0->typeId})) {
                             return Res::Err("No such loan token (%d)", attrV0->typeId);
                         }
-                    break;
+                        break;
                     case TokenKeys::Ascendant:
                     case TokenKeys::Descendant:
                     case TokenKeys::Epitaph:
-                    break;
+                        break;
                     default:
                         return Res::Err("Unsupported key");
                 }
-            break;
+                break;
 
             case AttributeTypes::Consortium:
                 switch (attrV0->key) {
@@ -1444,13 +1415,15 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                             return Res::Err("Unexpected value");
                         }
 
-                        CDataStructureV0 maxLimitKey{AttributeTypes::Consortium, attrV0->typeId, ConsortiumKeys::MintLimit};
+                        CDataStructureV0 maxLimitKey{
+                            AttributeTypes::Consortium, attrV0->typeId, ConsortiumKeys::MintLimit};
                         const auto maxLimit = GetValue(maxLimitKey, CAmount{0});
 
-                        CDataStructureV0 dailyLimitKey{AttributeTypes::Consortium, attrV0->typeId, ConsortiumKeys::DailyMintLimit};
+                        CDataStructureV0 dailyLimitKey{
+                            AttributeTypes::Consortium, attrV0->typeId, ConsortiumKeys::DailyMintLimit};
                         const auto dailyLimit = GetValue(dailyLimitKey, CAmount{0});
 
-                        for (const auto& [id, member] : *members) {
+                        for (const auto &[id, member] : *members) {
                             if (member.mintLimit > maxLimit && maxLimit != -1 * COIN) {
                                 return Res::Err("Mint limit higher than global mint limit");
                             }
@@ -1468,7 +1441,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
 
                         if (!view.GetToken(DCT_ID{attrV0->typeId}))
                             return Res::Err("No such token (%d)", attrV0->typeId);
-                    break;
+                        break;
                     default:
                         return Res::Err("Unsupported key");
                 }
@@ -1483,7 +1456,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                     if (!splitMap) {
                         return Res::Err("Unsupported value");
                     }
-                    for (const auto& [tokenId, multipler] : *splitMap) {
+                    for (const auto &[tokenId, multipler] : *splitMap) {
                         if (tokenId == 0) {
                             return Res::Err("Tokenised DFI cannot be split");
                         }
@@ -1504,7 +1477,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                 } else {
                     return Res::Err("Unsupported key");
                 }
-            break;
+                break;
 
             case AttributeTypes::Poolpairs:
                 switch (attrV0->key) {
@@ -1513,7 +1486,7 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetPoolPair({attrV0->typeId})) {
                             return Res::Err("No such pool (%d)", attrV0->typeId);
                         }
-                    break;
+                        break;
                     case PoolKeys::TokenAFeeDir:
                     case PoolKeys::TokenBFeeDir:
                         if (view.GetLastHeight() < Params().GetConsensus().FortCanningSpringHeight) {
@@ -1522,14 +1495,15 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                         if (!view.GetPoolPair({attrV0->typeId})) {
                             return Res::Err("No such pool (%d)", attrV0->typeId);
                         }
-                    break;
+                        break;
                     default:
                         return Res::Err("Unsupported key");
                 }
-            break;
+                break;
 
             case AttributeTypes::Param:
-                if (attrV0->typeId == ParamIDs::Feature || attrV0->typeId == ParamIDs::Foundation || attrV0->key == DFIPKeys::Members) {
+                if (attrV0->typeId == ParamIDs::Feature || attrV0->typeId == ParamIDs::Foundation ||
+                    attrV0->key == DFIPKeys::Members) {
                     if (view.GetLastHeight() < Params().GetConsensus().GrandCentralHeight) {
                         return Res::Err("Cannot be set before GrandCentralHeight");
                     }
@@ -1537,7 +1511,8 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                     if (view.GetLastHeight() < Params().GetConsensus().GrandCentralHeight) {
                         return Res::Err("Cannot be set before GrandCentralHeight");
                     }
-                } else if (attrV0->typeId == ParamIDs::DFIP2206F || attrV0->key == DFIPKeys::StartBlock || attrV0->typeId == ParamIDs::DFIP2206A) {
+                } else if (attrV0->typeId == ParamIDs::DFIP2206F || attrV0->key == DFIPKeys::StartBlock ||
+                           attrV0->typeId == ParamIDs::DFIP2206A) {
                     if (view.GetLastHeight() < Params().GetConsensus().FortCanningSpringHeight) {
                         return Res::Err("Cannot be set before FortCanningSpringHeight");
                     }
@@ -1548,11 +1523,11 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                 } else if (attrV0->typeId != ParamIDs::DFIP2201) {
                     return Res::Err("Unrecognised param id");
                 }
-            break;
+                break;
 
             // Live is set internally
             case AttributeTypes::Live:
-            break;
+                break;
 
             case AttributeTypes::Locks:
                 if (view.GetLastHeight() < Params().GetConsensus().FortCanningCrunchHeight) {
@@ -1564,13 +1539,13 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                 if (!view.GetLoanTokenByID(DCT_ID{attrV0->key}).has_value()) {
                     return Res::Err("No loan token with id (%d)", attrV0->key);
                 }
-            break;
+                break;
 
             case AttributeTypes::Governance:
                 if (view.GetLastHeight() < Params().GetConsensus().GrandCentralHeight) {
                     return Res::Err("Cannot be set before GrandCentral");
                 }
-            break;
+                break;
 
             default:
                 return Res::Err("Unrecognised type (%d)", attrV0->type);
@@ -1580,23 +1555,20 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
     return Res::Ok();
 }
 
-Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
-{
-    for (const auto& attribute : attributes) {
+Res ATTRIBUTES::Apply(CCustomCSView &mnview, const uint32_t height) {
+    for (const auto &attribute : attributes) {
         const auto attrV0 = std::get_if<CDataStructureV0>(&attribute.first);
         if (!attrV0) {
             continue;
         }
         if (attrV0->type == AttributeTypes::Poolpairs) {
-            if (attrV0->key == PoolKeys::TokenAFeePCT ||
-                attrV0->key == PoolKeys::TokenBFeePCT) {
+            if (attrV0->key == PoolKeys::TokenAFeePCT || attrV0->key == PoolKeys::TokenBFeePCT) {
                 auto poolId = DCT_ID{attrV0->typeId};
-                auto pool = mnview.GetPoolPair(poolId);
+                auto pool   = mnview.GetPoolPair(poolId);
                 if (!pool) {
                     return Res::Err("No such pool (%d)", poolId.v);
                 }
-                auto tokenId = attrV0->key == PoolKeys::TokenAFeePCT ?
-                               pool->idTokenA : pool->idTokenB;
+                auto tokenId = attrV0->key == PoolKeys::TokenAFeePCT ? pool->idTokenA : pool->idTokenB;
 
                 const auto valuePct = std::get_if<CAmount>(&attribute.second);
                 if (!valuePct) {
@@ -1607,8 +1579,7 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                 }
             }
         } else if (attrV0->type == AttributeTypes::Token) {
-            if (attrV0->key == TokenKeys::DexInFeePct
-            ||  attrV0->key == TokenKeys::DexOutFeePct) {
+            if (attrV0->key == TokenKeys::DexInFeePct || attrV0->key == TokenKeys::DexOutFeePct) {
                 DCT_ID tokenA{attrV0->typeId}, tokenB{~0u};
                 if (attrV0->key == TokenKeys::DexOutFeePct) {
                     std::swap(tokenA, tokenB);
@@ -1627,17 +1598,16 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                         it.Valid() && it.Key() == *currencyPair) {
                         continue;
                     } else if (!OraclePriceFeed(mnview, *currencyPair)) {
-                        return Res::Err("Price feed %s/%s does not belong to any oracle", currencyPair->first,
+                        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.priceFeedId    = *currencyPair;
+                    fixedIntervalPrice.timestamp      = time;
                     fixedIntervalPrice.priceRecord[1] = -1;
-                    const auto aggregatePrice = GetAggregatePrice(mnview,
-                                                                  fixedIntervalPrice.priceFeedId.first,
-                                                                  fixedIntervalPrice.priceFeedId.second,
-                                                                  time);
+                    const auto aggregatePrice         = GetAggregatePrice(
+                        mnview, fixedIntervalPrice.priceFeedId.first, fixedIntervalPrice.priceFeedId.second, time);
                     if (aggregatePrice) {
                         fixedIntervalPrice.priceRecord[1] = aggregatePrice;
                     }
@@ -1649,7 +1619,6 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     return Res::Err("Unrecognised value for FixedIntervalPriceId");
                 }
             } else if (attrV0->key == TokenKeys::DFIP2203Enabled) {
-
                 const auto value = std::get_if<bool>(&attribute.second);
                 if (!value) {
                     return Res::Err("Unexpected type");
@@ -1675,15 +1644,16 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     return res;
                 }
             } else if (attrV0->key == TokenKeys::LoanMintingInterest) {
-                if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight) && interestTokens.count(attrV0->typeId)) {
+                if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight) &&
+                    interestTokens.count(attrV0->typeId)) {
                     const auto tokenInterest = std::get_if<CAmount>(&attribute.second);
                     if (!tokenInterest) {
                         return Res::Err("Unexpected type");
                     }
 
                     std::set<CVaultId> affectedVaults;
-                    mnview.ForEachLoanTokenAmount([&](const CVaultId& vaultId,  const CBalances& balances){
-                        for (const auto& [tokenId, discarded] : balances.balances) {
+                    mnview.ForEachLoanTokenAmount([&](const CVaultId &vaultId, const CBalances &balances) {
+                        for (const auto &[tokenId, discarded] : balances.balances) {
                             if (tokenId.v == attrV0->typeId) {
                                 affectedVaults.insert(vaultId);
                             }
@@ -1691,7 +1661,7 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                         return true;
                     });
 
-                    for (const auto& vaultId : affectedVaults) {
+                    for (const auto &vaultId : affectedVaults) {
                         const auto vault = mnview.GetVault(vaultId);
                         assert(vault);
 
@@ -1723,7 +1693,8 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                             return Res::Err("Unexpected type");
                         }
                         if (*factor >= *ratio.begin() * CENT) {
-                            return Res::Err("Factor cannot be more than or equal to the lowest scheme rate of %d\n", GetDecimaleString(*ratio.begin() * CENT));
+                            return Res::Err("Factor cannot be more than or equal to the lowest scheme rate of %d\n",
+                                            GetDecimaleString(*ratio.begin() * CENT));
                         }
                     }
                 }
@@ -1731,7 +1702,6 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
         } else if (attrV0->type == AttributeTypes::Param) {
             if (attrV0->typeId == ParamIDs::DFIP2203) {
                 if (attrV0->key == DFIPKeys::Active) {
-
                     const auto value = std::get_if<bool>(&attribute.second);
                     if (!value) {
                         return Res::Err("Unexpected type");
@@ -1747,7 +1717,6 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     }
 
                 } else if (attrV0->key == DFIPKeys::BlockPeriod || attrV0->key == DFIPKeys::StartBlock) {
-
                     // Only check this when block period has been set, otherwise
                     // it will fail when DFIP2203 active is set to true.
                     if (!futureUpdated) {
@@ -1761,7 +1730,6 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                 }
             } else if (attrV0->typeId == ParamIDs::DFIP2206F) {
                 if (attrV0->key == DFIPKeys::Active) {
-
                     const auto value = std::get_if<bool>(&attribute.second);
                     if (!value) {
                         return Res::Err("Unexpected type");
@@ -1777,7 +1745,6 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     }
 
                 } else if (attrV0->key == DFIPKeys::BlockPeriod) {
-
                     // Only check this when block period has been set, otherwise
                     // it will fail when DFIP2206F active is set to true.
                     if (!futureDUSDUpdated) {
@@ -1828,8 +1795,8 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
 
                     CGovernanceHeightMessage lock;
                     lock.startHeight = startHeight;
-                    lock.govVar = govVar;
-                    auto res = storeGovVars(lock, mnview);
+                    lock.govVar      = govVar;
+                    auto res         = storeGovVars(lock, mnview);
                     if (!res) {
                         return res;
                     }
@@ -1843,44 +1810,39 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
     return Res::Ok();
 }
 
-Res ATTRIBUTES::Erase(CCustomCSView & mnview, uint32_t, std::vector<std::string> const & keys)
-{
-    for (const auto& key : keys) {
-        auto res = ProcessVariable(key, {},
-            [&](const CAttributeType& attribute, const CAttributeValue&) {
-                auto attrV0 = std::get_if<CDataStructureV0>(&attribute);
-                if (!attrV0) {
-                    return Res::Ok();
-                }
-                if (attrV0->type == AttributeTypes::Live) {
-                    return Res::Err("Live attribute cannot be deleted");
-                }
-                if (!EraseKey(attribute)) {
-                    return Res::Err("Attribute {%d} not exists", attrV0->type);
+Res ATTRIBUTES::Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &keys) {
+    for (const auto &key : keys) {
+        auto res = ProcessVariable(key, {}, [&](const CAttributeType &attribute, const CAttributeValue &) {
+            auto attrV0 = std::get_if<CDataStructureV0>(&attribute);
+            if (!attrV0) {
+                return Res::Ok();
+            }
+            if (attrV0->type == AttributeTypes::Live) {
+                return Res::Err("Live attribute cannot be deleted");
+            }
+            if (!EraseKey(attribute)) {
+                return Res::Err("Attribute {%d} not exists", attrV0->type);
+            }
+            if (attrV0->type == AttributeTypes::Poolpairs) {
+                auto poolId = DCT_ID{attrV0->typeId};
+                auto pool   = mnview.GetPoolPair(poolId);
+                if (!pool) {
+                    return Res::Err("No such pool (%d)", poolId.v);
                 }
-                if (attrV0->type == AttributeTypes::Poolpairs) {
-                    auto poolId = DCT_ID{attrV0->typeId};
-                    auto pool = mnview.GetPoolPair(poolId);
-                    if (!pool) {
-                        return Res::Err("No such pool (%d)", poolId.v);
-                    }
-                    auto tokenId = attrV0->key == PoolKeys::TokenAFeePCT ?
-                                                pool->idTokenA : pool->idTokenB;
-
-                    return mnview.EraseDexFeePct(poolId, tokenId);
-                } else if (attrV0->type == AttributeTypes::Token) {
-                    if (attrV0->key == TokenKeys::DexInFeePct
-                    ||  attrV0->key == TokenKeys::DexOutFeePct) {
-                        DCT_ID tokenA{attrV0->typeId}, tokenB{~0u};
-                        if (attrV0->key == TokenKeys::DexOutFeePct) {
-                            std::swap(tokenA, tokenB);
-                        }
-                        return mnview.EraseDexFeePct(tokenA, tokenB);
+                auto tokenId = attrV0->key == PoolKeys::TokenAFeePCT ? pool->idTokenA : pool->idTokenB;
+
+                return mnview.EraseDexFeePct(poolId, tokenId);
+            } else if (attrV0->type == AttributeTypes::Token) {
+                if (attrV0->key == TokenKeys::DexInFeePct || attrV0->key == TokenKeys::DexOutFeePct) {
+                    DCT_ID tokenA{attrV0->typeId}, tokenB{~0u};
+                    if (attrV0->key == TokenKeys::DexOutFeePct) {
+                        std::swap(tokenA, tokenB);
                     }
+                    return mnview.EraseDexFeePct(tokenA, tokenB);
                 }
-                return Res::Ok();
             }
-        );
+            return Res::Ok();
+        });
         if (!res) {
             return res;
         }
diff --git a/src/masternodes/govvariables/attributes.h b/src/masternodes/govvariables/attributes.h
index 6fa71fe1d8..1564299583 100644
--- a/src/masternodes/govvariables/attributes.h
+++ b/src/masternodes/govvariables/attributes.h
@@ -15,115 +15,115 @@ enum VersionTypes : uint8_t {
 };
 
 enum AttributeTypes : uint8_t {
-    Live      = 'l',
-    Oracles   = 'o',
-    Param     = 'a',
-    Token     = 't',
-    Poolpairs = 'p',
-    Locks     = 'L',
-    Governance= 'g',
+    Live       = 'l',
+    Oracles    = 'o',
+    Param      = 'a',
+    Token      = 't',
+    Poolpairs  = 'p',
+    Locks      = 'L',
+    Governance = 'g',
     Consortium = 'c',
 };
 
-enum ParamIDs : uint8_t  {
-    DFIP2201  = 'a',
-    DFIP2203  = 'b',
-    TokenID   = 'c',
-    Economy   = 'e',
-    DFIP2206A = 'f',
-    DFIP2206F = 'g',
-    Feature   = 'h',
-    Auction   = 'i',
+enum ParamIDs : uint8_t {
+    DFIP2201   = 'a',
+    DFIP2203   = 'b',
+    TokenID    = 'c',
+    Economy    = 'e',
+    DFIP2206A  = 'f',
+    DFIP2206F  = 'g',
+    Feature    = 'h',
+    Auction    = 'i',
     Foundation = 'j',
 };
 
-enum OracleIDs : uint8_t  {
-    Splits    = 'a',
+enum OracleIDs : uint8_t {
+    Splits = 'a',
 };
 
-enum GovernanceIDs : uint8_t  {
+enum GovernanceIDs : uint8_t {
     Global    = 'a',
     Proposals = 'b',
 };
 
 enum EconomyKeys : uint8_t {
-    PaybackDFITokens   = 'a',
-    PaybackTokens      = 'b',
-    DFIP2203Current    = 'c',
-    DFIP2203Burned     = 'd',
-    DFIP2203Minted     = 'e',
-    DFIP2206FCurrent   = 'f',
-    DFIP2206FBurned    = 'g',
-    DFIP2206FMinted    = 'h',
-    DexTokens          = 'i',
-    NegativeInt        = 'j',
-    NegativeIntCurrent = 'k',
-    ConsortiumMinted        = 'l',
-    ConsortiumMembersMinted = 'm',
-    BatchRoundingExcess = 'n', // Extra added to loan amounts on auction creation due to round errors.
-    ConsolidatedInterest = 'o', // Amount added to loan amounts after auction with no bids.
-    PaybackDFITokensPrincipal = 'p', // Same as PaybackDFITokens but without interest.
-    Loans              = 'q',
+    PaybackDFITokens          = 'a',
+    PaybackTokens             = 'b',
+    DFIP2203Current           = 'c',
+    DFIP2203Burned            = 'd',
+    DFIP2203Minted            = 'e',
+    DFIP2206FCurrent          = 'f',
+    DFIP2206FBurned           = 'g',
+    DFIP2206FMinted           = 'h',
+    DexTokens                 = 'i',
+    NegativeInt               = 'j',
+    NegativeIntCurrent        = 'k',
+    ConsortiumMinted          = 'l',
+    ConsortiumMembersMinted   = 'm',
+    BatchRoundingExcess       = 'n',  // Extra added to loan amounts on auction creation due to round errors.
+    ConsolidatedInterest      = 'o',  // Amount added to loan amounts after auction with no bids.
+    PaybackDFITokensPrincipal = 'p',  // Same as PaybackDFITokens but without interest.
+    Loans                     = 'q',
 };
 
-enum DFIPKeys : uint8_t  {
-    Active                  = 'a',
-    Premium                 = 'b',
-    MinSwap                 = 'c',
-    RewardPct               = 'd',
-    BlockPeriod             = 'e',
-    DUSDInterestBurn        = 'g',
-    DUSDLoanBurn            = 'h',
-    StartBlock              = 'i',
-    GovUnset                = 'j',
-    GovFoundation           = 'k',
-    MNSetRewardAddress      = 'l',
-    MNSetOperatorAddress    = 'm',
-    MNSetOwnerAddress       = 'n',
-    ConsortiumEnabled       = 'o',
-    Members                 = 'p',
-    GovernanceEnabled       = 'q',
-    CFPPayout               = 'r',
-    EmissionUnusedFund          = 's',
+enum DFIPKeys : uint8_t {
+    Active               = 'a',
+    Premium              = 'b',
+    MinSwap              = 'c',
+    RewardPct            = 'd',
+    BlockPeriod          = 'e',
+    DUSDInterestBurn     = 'g',
+    DUSDLoanBurn         = 'h',
+    StartBlock           = 'i',
+    GovUnset             = 'j',
+    GovFoundation        = 'k',
+    MNSetRewardAddress   = 'l',
+    MNSetOperatorAddress = 'm',
+    MNSetOwnerAddress    = 'n',
+    ConsortiumEnabled    = 'o',
+    Members              = 'p',
+    GovernanceEnabled    = 'q',
+    CFPPayout            = 'r',
+    EmissionUnusedFund   = 's',
 };
 
-enum GovernanceKeys : uint8_t  {
-    FeeRedistribution       = 'a',
-    FeeBurnPct              = 'b',
-    CFPFee                  = 'd',
-    CFPMajority             = 'e',
-    VOCFee                  = 'f',
-    VOCEmergencyFee         = 'g',
-    VOCEmergencyPeriod      = 'h',
-    VOCMajority             = 'i',
-    Quorum                  = 'j',
-    VotingPeriod            = 'k',
-    VOCEmergencyQuorum      = 'l',
+enum GovernanceKeys : uint8_t {
+    FeeRedistribution  = 'a',
+    FeeBurnPct         = 'b',
+    CFPFee             = 'd',
+    CFPMajority        = 'e',
+    VOCFee             = 'f',
+    VOCEmergencyFee    = 'g',
+    VOCEmergencyPeriod = 'h',
+    VOCMajority        = 'i',
+    Quorum             = 'j',
+    VotingPeriod       = 'k',
+    VOCEmergencyQuorum = 'l',
 };
 
-enum TokenKeys : uint8_t  {
-    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',
-    LoanPaybackCollateral     = 'p',
+enum TokenKeys : uint8_t {
+    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',
+    LoanPaybackCollateral = 'p',
 };
 
-enum ConsortiumKeys : uint8_t  {
-    MemberValues          = 'a',
-    MintLimit             = 'b',
-    DailyMintLimit        = 'c',
+enum ConsortiumKeys : uint8_t {
+    MemberValues   = 'a',
+    MintLimit      = 'b',
+    DailyMintLimit = 'c',
 };
 
 enum PoolKeys : uint8_t {
@@ -134,7 +134,7 @@ enum PoolKeys : uint8_t {
 };
 
 struct CDataStructureV0 {
-    uint8_t  type;
+    uint8_t type;
     uint32_t typeId;
     uint32_t key;
     uint32_t keyId;
@@ -142,7 +142,7 @@ struct CDataStructureV0 {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(type);
         READWRITE(typeId);
         READWRITE(VARINT(key));
@@ -154,12 +154,10 @@ struct CDataStructureV0 {
     }
 
     bool IsExtendedSize() const {
-        return type == AttributeTypes::Token
-            && (key == TokenKeys::LoanPayback
-            ||  key == TokenKeys::LoanPaybackFeePCT);
+        return type == AttributeTypes::Token && (key == TokenKeys::LoanPayback || key == TokenKeys::LoanPaybackFeePCT);
     }
 
-    bool operator<(const CDataStructureV0& o) const {
+    bool operator<(const CDataStructureV0 &o) const {
         return std::tie(type, typeId, key, keyId) < std::tie(o.type, o.typeId, o.key, o.keyId);
     }
 };
@@ -169,9 +167,9 @@ struct CDataStructureV1 {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {}
+    inline void SerializationOp(Stream &s, Operation ser_action) {}
 
-     bool operator<(const CDataStructureV1& o) const { return false; }
+    bool operator<(const CDataStructureV1 &o) const { return false; }
 };
 
 struct CTokenPayback {
@@ -181,7 +179,7 @@ struct CTokenPayback {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(tokensFee);
         READWRITE(tokensPayback);
     }
@@ -193,12 +191,12 @@ struct CFeeDir {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(feeDir);
     }
 };
 
-ResVal<CScript> GetFutureSwapContractAddress(const std::string& contract);
+ResVal<CScript> GetFutureSwapContractAddress(const std::string &contract);
 
 struct CDexTokenInfo {
     struct CTokenInfo {
@@ -209,7 +207,7 @@ struct CDexTokenInfo {
         ADD_SERIALIZE_METHODS;
 
         template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
+        inline void SerializationOp(Stream &s, Operation ser_action) {
             READWRITE(swaps);
             READWRITE(feeburn);
             READWRITE(commissions);
@@ -222,25 +220,19 @@ struct CDexTokenInfo {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(totalTokenA);
         READWRITE(totalTokenB);
     }
 };
 
-enum FeeDirValues : uint8_t {
-    Both,
-    In,
-    Out
-};
+enum FeeDirValues : uint8_t { Both, In, Out };
 
-struct CConsortiumMember
-{
+struct CConsortiumMember {
     static const uint16_t MAX_CONSORTIUM_MEMBERS_STRING_LENGTH = 512;
     static const uint16_t MIN_CONSORTIUM_MEMBERS_STRING_LENGTH = 3;
-    enum Status : uint8_t
-    {
-        Active = 0,
+    enum Status : uint8_t {
+        Active   = 0,
         Disabled = 0x01,
     };
 
@@ -254,7 +246,7 @@ struct CConsortiumMember
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(name);
         READWRITE(ownerAddress);
         READWRITE(backingId);
@@ -264,50 +256,61 @@ struct CConsortiumMember
     }
 };
 
-struct CConsortiumMinted
-{
+struct CConsortiumMinted {
     CAmount minted;
     CAmount burnt;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(minted);
         READWRITE(burnt);
     }
 };
 
-struct CConsortiumDailyMinted : public CConsortiumMinted
-{
+struct CConsortiumDailyMinted : public CConsortiumMinted {
     std::pair<uint32_t, CAmount> dailyMinted;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CConsortiumMinted, *this);
         READWRITE(dailyMinted);
     }
 };
 
-using CDexBalances = std::map<DCT_ID, CDexTokenInfo>;
-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 CConsortiumMembers = std::map<std::string, CConsortiumMember>;
+using CDexBalances             = std::map<DCT_ID, CDexTokenInfo>;
+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 CConsortiumMembers       = std::map<std::string, CConsortiumMember>;
 using CConsortiumMembersMinted = std::map<DCT_ID, std::map<std::string, CConsortiumDailyMinted>>;
-using CConsortiumGlobalMinted = std::map<DCT_ID, CConsortiumMinted>;
-using CAttributeType = std::variant<CDataStructureV0, CDataStructureV1>;
-using CAttributeValue = std::variant<bool, CAmount, CBalances, CTokenPayback, CTokenCurrencyPair, OracleSplits, DescendantValue, AscendantValue,
-                         CFeeDir, CDexBalances, std::set<CScript>, std::set<std::string>, CConsortiumMembers, CConsortiumMembersMinted, CConsortiumGlobalMinted,
-                         int32_t, uint32_t>;
-
-
-void TrackNegativeInterest(CCustomCSView& mnview, const CTokenAmount& amount);
-void TrackLiveBalances(CCustomCSView& mnview, const CBalances& balances, const uint8_t key);
-void TrackDUSDAdd(CCustomCSView& mnview, const CTokenAmount& amount);
-void TrackDUSDSub(CCustomCSView& mnview, const CTokenAmount& amount);
+using CConsortiumGlobalMinted  = std::map<DCT_ID, CConsortiumMinted>;
+using CAttributeType           = std::variant<CDataStructureV0, CDataStructureV1>;
+using CAttributeValue          = std::variant<bool,
+                                     CAmount,
+                                     CBalances,
+                                     CTokenPayback,
+                                     CTokenCurrencyPair,
+                                     OracleSplits,
+                                     DescendantValue,
+                                     AscendantValue,
+                                     CFeeDir,
+                                     CDexBalances,
+                                     std::set<CScript>,
+                                     std::set<std::string>,
+                                     CConsortiumMembers,
+                                     CConsortiumMembersMinted,
+                                     CConsortiumGlobalMinted,
+                                     int32_t,
+                                     uint32_t>;
+
+void TrackNegativeInterest(CCustomCSView &mnview, const CTokenAmount &amount);
+void TrackLiveBalances(CCustomCSView &mnview, const CBalances &balances, const uint8_t key);
+void TrackDUSDAdd(CCustomCSView &mnview, const CTokenAmount &amount);
+void TrackDUSDSub(CCustomCSView &mnview, const CTokenAmount &amount);
 
 enum GovVarsFilter {
     All,
@@ -318,43 +321,40 @@ enum GovVarsFilter {
     Version2Dot7,
 };
 
-class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRIBUTES>
-{
+class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRIBUTES> {
 public:
     virtual ~ATTRIBUTES() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
     UniValue ExportFiltered(GovVarsFilter filter, const std::string &prefix) const;
 
-    Res Validate(CCustomCSView const& mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, const uint32_t height) override;
-    Res Erase(CCustomCSView& mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "ATTRIBUTES"; }
-    static GovVariable * Create() { return new ATTRIBUTES(); }
+    static constexpr const char *TypeName() { return "ATTRIBUTES"; }
+    static GovVariable *Create() { return new ATTRIBUTES(); }
 
-    template<typename T>
-    static void GetIf(std::optional<T>& opt, const CAttributeValue& var) {
+    template <typename T>
+    static void GetIf(std::optional<T> &opt, const CAttributeValue &var) {
         if (auto value = std::get_if<T>(&var)) {
             opt = *value;
         }
     }
 
-    template<typename T>
-    static void GetIf(T& val, const CAttributeValue& var) {
+    template <typename T>
+    static void GetIf(T &val, const CAttributeValue &var) {
         if (auto value = std::get_if<T>(&var)) {
             val = *value;
         }
     }
 
-    template<typename K, typename T>
-    [[nodiscard]] T GetValue(const K& key, T value) const {
+    template <typename K, typename T>
+    [[nodiscard]] T GetValue(const K &key, T value) const {
         static_assert(std::is_convertible_v<K, CAttributeType>);
         auto it = attributes.find(key);
         if (it != attributes.end()) {
@@ -363,16 +363,16 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         return value;
     }
 
-    template<typename K, typename T>
-    void SetValue(const K& key, T&& 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>
-    bool EraseKey(const K& key) {
+    template <typename K>
+    bool EraseKey(const K &key) {
         static_assert(std::is_convertible_v<K, CAttributeType>);
         if (attributes.erase(key)) {
             changed.insert(key);
@@ -381,14 +381,14 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         return false;
     }
 
-    template<typename K>
-    [[nodiscard]] bool CheckKey(const K& key) const {
+    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 {
+    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) {
@@ -400,31 +400,30 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         }
     }
 
-    [[nodiscard]] const std::map<CAttributeType, CAttributeValue>& GetAttributesMap() const {
-        return attributes;
-    }
+    [[nodiscard]] const std::map<CAttributeType, CAttributeValue> &GetAttributesMap() const { return attributes; }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(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::string>& displayConsortiumIDs();
-    static const std::map<uint8_t, std::string>& displayGovernanceIDs();
-    static const std::map<uint8_t, std::map<uint8_t, std::string>>& displayKeys();
-
-    Res RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID = std::numeric_limits<uint32_t>::max());
+    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::string> &displayConsortiumIDs();
+    static const std::map<uint8_t, std::string> &displayGovernanceIDs();
+    static const std::map<uint8_t, std::map<uint8_t, std::string>> &displayKeys();
+
+    Res RefundFuturesContracts(CCustomCSView &mnview,
+                               const uint32_t height,
+                               const uint32_t tokenID = std::numeric_limits<uint32_t>::max());
 
 private:
     friend class CGovView;
@@ -436,20 +435,21 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
     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<std::string, uint8_t>& allowedConsortiumIDs();
-    static const std::map<std::string, uint8_t>& allowedGovernanceIDs();
-    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();
-
-    Res ProcessVariable(const std::string& key, const std::optional<UniValue> &value,
-                        std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable);
+    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<std::string, uint8_t> &allowedConsortiumIDs();
+    static const std::map<std::string, uint8_t> &allowedGovernanceIDs();
+    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();
+
+    Res ProcessVariable(const std::string &key,
+                        const std::optional<UniValue> &value,
+                        std::function<Res(const CAttributeType &, const CAttributeValue &)> applyVariable);
     Res RefundFuturesDUSD(CCustomCSView &mnview, const uint32_t height);
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_ATTRIBUTES_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_ATTRIBUTES_H
diff --git a/src/masternodes/govvariables/icx_takerfee_per_btc.cpp b/src/masternodes/govvariables/icx_takerfee_per_btc.cpp
index f99e954143..c55292c833 100644
--- a/src/masternodes/govvariables/icx_takerfee_per_btc.cpp
+++ b/src/masternodes/govvariables/icx_takerfee_per_btc.cpp
@@ -2,42 +2,36 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
+#include <core_io.h>  /// ValueFromAmount
 #include <masternodes/govvariables/icx_takerfee_per_btc.h>
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool ICX_TAKERFEE_PER_BTC::IsEmpty() const
-{
+bool ICX_TAKERFEE_PER_BTC::IsEmpty() const {
     return !takerFeePerBTC.has_value();
 }
 
-Res ICX_TAKERFEE_PER_BTC::Import(const UniValue & val)
-{
+Res ICX_TAKERFEE_PER_BTC::Import(const UniValue &val) {
     takerFeePerBTC = AmountFromValue(val);
     return Res::Ok();
 }
 
-UniValue ICX_TAKERFEE_PER_BTC::Export() const
-{
+UniValue ICX_TAKERFEE_PER_BTC::Export() const {
     return ValueFromAmount(takerFeePerBTC.value_or(0));
 }
 
-Res ICX_TAKERFEE_PER_BTC::Validate(const CCustomCSView &mnview) const
-{
+Res ICX_TAKERFEE_PER_BTC::Validate(const CCustomCSView &mnview) const {
     if (takerFeePerBTC <= 0)
         return Res::Err("takerFeePerBTC cannot be 0 or less");
 
     return Res::Ok();
 }
 
-Res ICX_TAKERFEE_PER_BTC::Apply(CCustomCSView & mnview, uint32_t)
-{
+Res ICX_TAKERFEE_PER_BTC::Apply(CCustomCSView &mnview, uint32_t) {
     return mnview.ICXSetTakerFeePerBTC(takerFeePerBTC.value_or(0));
 }
 
-Res ICX_TAKERFEE_PER_BTC::Erase(CCustomCSView & mnview, uint32_t, std::vector<std::string> const &)
-{
+Res ICX_TAKERFEE_PER_BTC::Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &) {
     takerFeePerBTC.reset();
     return mnview.ICXEraseTakerFeePerBTC();
 }
diff --git a/src/masternodes/govvariables/icx_takerfee_per_btc.h b/src/masternodes/govvariables/icx_takerfee_per_btc.h
index 4463ba283e..148ef907d8 100644
--- a/src/masternodes/govvariables/icx_takerfee_per_btc.h
+++ b/src/masternodes/govvariables/icx_takerfee_per_btc.h
@@ -1,37 +1,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_ICX_TAKERFEE_PER_BTC_H
 #define DEFI_MASTERNODES_GOVVARIABLES_ICX_TAKERFEE_PER_BTC_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class ICX_TAKERFEE_PER_BTC : public GovVariable, public AutoRegistrator<GovVariable, ICX_TAKERFEE_PER_BTC>
-{
+class ICX_TAKERFEE_PER_BTC : public GovVariable, public AutoRegistrator<GovVariable, ICX_TAKERFEE_PER_BTC> {
 public:
     virtual ~ICX_TAKERFEE_PER_BTC() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "ICX_TAKERFEE_PER_BTC"; }
-    static GovVariable * Create() { return new ICX_TAKERFEE_PER_BTC(); }
+    static constexpr const char *TypeName() { return "ICX_TAKERFEE_PER_BTC"; }
+    static GovVariable *Create() { return new ICX_TAKERFEE_PER_BTC(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(takerFeePerBTC);
     }
 
     GvOptional<CAmount> takerFeePerBTC;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_ICX_TAKERFEE_PER_BTC_H
\ No newline at end of file
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_ICX_TAKERFEE_PER_BTC_H
\ No newline at end of file
diff --git a/src/masternodes/govvariables/loan_daily_reward.cpp b/src/masternodes/govvariables/loan_daily_reward.cpp
index a3d46abb17..3315c1d6bf 100644
--- a/src/masternodes/govvariables/loan_daily_reward.cpp
+++ b/src/masternodes/govvariables/loan_daily_reward.cpp
@@ -4,41 +4,35 @@
 
 #include <masternodes/govvariables/loan_daily_reward.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool LP_DAILY_LOAN_TOKEN_REWARD::IsEmpty() const
-{
+bool LP_DAILY_LOAN_TOKEN_REWARD::IsEmpty() const {
     return !dailyReward.has_value();
 }
 
-Res LP_DAILY_LOAN_TOKEN_REWARD::Import(const UniValue & val)
-{
+Res LP_DAILY_LOAN_TOKEN_REWARD::Import(const UniValue &val) {
     dailyReward = AmountFromValue(val);
     return Res::Ok();
 }
 
-UniValue LP_DAILY_LOAN_TOKEN_REWARD::Export() const
-{
+UniValue LP_DAILY_LOAN_TOKEN_REWARD::Export() const {
     return ValueFromAmount(dailyReward.value_or(0));
 }
 
-Res LP_DAILY_LOAN_TOKEN_REWARD::Validate(const CCustomCSView & view) const
-{
+Res LP_DAILY_LOAN_TOKEN_REWARD::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() < Params().GetConsensus().FortCanningHeight)
         return Res::Err("Cannot be set before FortCanning");
 
     return Res::Err("Cannot be set manually.");
 }
 
-Res LP_DAILY_LOAN_TOKEN_REWARD::Apply(CCustomCSView & mnview, uint32_t height)
-{
+Res LP_DAILY_LOAN_TOKEN_REWARD::Apply(CCustomCSView &mnview, uint32_t height) {
     return mnview.SetLoanDailyReward(height, dailyReward.value_or(0));
 }
 
-Res LP_DAILY_LOAN_TOKEN_REWARD::Erase(CCustomCSView & mnview, uint32_t height, std::vector<std::string> const &)
-{
+Res LP_DAILY_LOAN_TOKEN_REWARD::Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) {
     dailyReward.reset();
     return mnview.SetLoanDailyReward(height, 0);
 }
diff --git a/src/masternodes/govvariables/loan_daily_reward.h b/src/masternodes/govvariables/loan_daily_reward.h
index a11dac2e0f..3f03a00ffa 100644
--- a/src/masternodes/govvariables/loan_daily_reward.h
+++ b/src/masternodes/govvariables/loan_daily_reward.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_LOAN_DAILY_REWARD_H
 #define DEFI_MASTERNODES_GOVVARIABLES_LOAN_DAILY_REWARD_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class LP_DAILY_LOAN_TOKEN_REWARD : public GovVariable, public AutoRegistrator<GovVariable, LP_DAILY_LOAN_TOKEN_REWARD>
-{
+class LP_DAILY_LOAN_TOKEN_REWARD : public GovVariable, public AutoRegistrator<GovVariable, LP_DAILY_LOAN_TOKEN_REWARD> {
 public:
     virtual ~LP_DAILY_LOAN_TOKEN_REWARD() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "LP_DAILY_LOAN_TOKEN_REWARD"; }
-    static GovVariable * Create() { return new LP_DAILY_LOAN_TOKEN_REWARD(); }
+    static constexpr const char *TypeName() { return "LP_DAILY_LOAN_TOKEN_REWARD"; }
+    static GovVariable *Create() { return new LP_DAILY_LOAN_TOKEN_REWARD(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(dailyReward);
     }
 
     GvOptional<CAmount> dailyReward;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_LOAN_DAILY_REWARD_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_LOAN_DAILY_REWARD_H
diff --git a/src/masternodes/govvariables/loan_liquidation_penalty.cpp b/src/masternodes/govvariables/loan_liquidation_penalty.cpp
index a27d97d4bb..1aa4bb904f 100644
--- a/src/masternodes/govvariables/loan_liquidation_penalty.cpp
+++ b/src/masternodes/govvariables/loan_liquidation_penalty.cpp
@@ -4,28 +4,24 @@
 
 #include <masternodes/govvariables/loan_liquidation_penalty.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool LOAN_LIQUIDATION_PENALTY::IsEmpty() const
-{
+bool LOAN_LIQUIDATION_PENALTY::IsEmpty() const {
     return !penalty.has_value();
 }
 
-Res LOAN_LIQUIDATION_PENALTY::Import(const UniValue & val)
-{
+Res LOAN_LIQUIDATION_PENALTY::Import(const UniValue &val) {
     penalty = AmountFromValue(val);
     return Res::Ok();
 }
 
-UniValue LOAN_LIQUIDATION_PENALTY::Export() const
-{
+UniValue LOAN_LIQUIDATION_PENALTY::Export() const {
     return ValueFromAmount(penalty.value_or(0));
 }
 
-Res LOAN_LIQUIDATION_PENALTY::Validate(const CCustomCSView & view) const
-{
+Res LOAN_LIQUIDATION_PENALTY::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() < Params().GetConsensus().FortCanningHeight)
         return Res::Err("Cannot be set before FortCanning");
 
@@ -35,13 +31,11 @@ Res LOAN_LIQUIDATION_PENALTY::Validate(const CCustomCSView & view) const
     return Res::Ok();
 }
 
-Res LOAN_LIQUIDATION_PENALTY::Apply(CCustomCSView & mnview, uint32_t height)
-{
+Res LOAN_LIQUIDATION_PENALTY::Apply(CCustomCSView &mnview, uint32_t height) {
     return mnview.SetLoanLiquidationPenalty(penalty.value_or(0));
 }
 
-Res LOAN_LIQUIDATION_PENALTY::Erase(CCustomCSView & mnview, uint32_t, std::vector<std::string> const &)
-{
+Res LOAN_LIQUIDATION_PENALTY::Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &) {
     penalty.reset();
     return mnview.EraseLoanLiquidationPenalty();
 }
diff --git a/src/masternodes/govvariables/loan_liquidation_penalty.h b/src/masternodes/govvariables/loan_liquidation_penalty.h
index 177ce06aaf..c25d9d04dd 100644
--- a/src/masternodes/govvariables/loan_liquidation_penalty.h
+++ b/src/masternodes/govvariables/loan_liquidation_penalty.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_LOAN_LIQUIDATION_PENALTY_H
 #define DEFI_MASTERNODES_GOVVARIABLES_LOAN_LIQUIDATION_PENALTY_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class LOAN_LIQUIDATION_PENALTY : public GovVariable, public AutoRegistrator<GovVariable, LOAN_LIQUIDATION_PENALTY>
-{
+class LOAN_LIQUIDATION_PENALTY : public GovVariable, public AutoRegistrator<GovVariable, LOAN_LIQUIDATION_PENALTY> {
 public:
     virtual ~LOAN_LIQUIDATION_PENALTY() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "LOAN_LIQUIDATION_PENALTY"; }
-    static GovVariable * Create() { return new LOAN_LIQUIDATION_PENALTY(); }
+    static constexpr const char *TypeName() { return "LOAN_LIQUIDATION_PENALTY"; }
+    static GovVariable *Create() { return new LOAN_LIQUIDATION_PENALTY(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(penalty);
     }
 
     GvOptional<CAmount> penalty;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_LOAN_LIQUIDATION_PENALTY_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_LOAN_LIQUIDATION_PENALTY_H
diff --git a/src/masternodes/govvariables/loan_splits.cpp b/src/masternodes/govvariables/loan_splits.cpp
index 8a79cb3300..0964316cdf 100644
--- a/src/masternodes/govvariables/loan_splits.cpp
+++ b/src/masternodes/govvariables/loan_splits.cpp
@@ -4,21 +4,19 @@
 
 #include <masternodes/govvariables/loan_splits.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool LP_LOAN_TOKEN_SPLITS::IsEmpty() const
-{
+bool LP_LOAN_TOKEN_SPLITS::IsEmpty() const {
     return splits.empty();
 }
 
-Res LP_LOAN_TOKEN_SPLITS::Import(const UniValue & val)
-{
+Res LP_LOAN_TOKEN_SPLITS::Import(const UniValue &val) {
     if (!val.isObject())
         return Res::Err("object of {poolId: rate,... } expected");
 
-    for (const std::string& key : val.getKeys()) {
+    for (const std::string &key : val.getKeys()) {
         const auto id = DCT_ID::FromString(key);
         if (!id)
             return std::move(id);
@@ -27,27 +25,26 @@ Res LP_LOAN_TOKEN_SPLITS::Import(const UniValue & val)
     return Res::Ok();
 }
 
-UniValue LP_LOAN_TOKEN_SPLITS::Export() const
-{
+UniValue LP_LOAN_TOKEN_SPLITS::Export() const {
     UniValue res(UniValue::VOBJ);
-    for (auto const & kv : splits) {
+    for (const auto &kv : splits) {
         res.pushKV(kv.first.ToString(), ValueFromAmount(kv.second));
     }
     return res;
 }
 
-Res LP_LOAN_TOKEN_SPLITS::Validate(const CCustomCSView & mnview) const
-{
+Res LP_LOAN_TOKEN_SPLITS::Validate(const CCustomCSView &mnview) const {
     if (mnview.GetLastHeight() < Params().GetConsensus().FortCanningHeight)
         return Res::Err("Cannot be set before FortCanning");
 
     CAmount total{0};
-    for (auto const & kv : splits) {
+    for (const auto &kv : splits) {
         if (!mnview.HasPoolPair(kv.first))
             return Res::Err("pool with id=%s not found", kv.first.ToString());
 
         if (kv.second < 0 || kv.second > COIN)
-            return Res::Err("wrong percentage for pool with id=%s, value = %s", kv.first.ToString(), std::to_string(kv.second));
+            return Res::Err(
+                "wrong percentage for pool with id=%s, value = %s", kv.first.ToString(), std::to_string(kv.second));
 
         total += kv.second;
     }
@@ -57,12 +54,11 @@ Res LP_LOAN_TOKEN_SPLITS::Validate(const CCustomCSView & mnview) const
     return Res::Ok();
 }
 
-Res LP_LOAN_TOKEN_SPLITS::Apply(CCustomCSView & mnview, uint32_t height)
-{
-    mnview.ForEachPoolId([&] (DCT_ID poolId) {
+Res LP_LOAN_TOKEN_SPLITS::Apply(CCustomCSView &mnview, uint32_t height) {
+    mnview.ForEachPoolId([&](DCT_ID poolId) {
         // we ought to reset previous value:
         CAmount rewardLoanPct = 0;
-        auto it = splits.find(poolId);
+        auto it               = splits.find(poolId);
         if (it != splits.end())
             rewardLoanPct = it->second;
 
@@ -73,9 +69,8 @@ Res LP_LOAN_TOKEN_SPLITS::Apply(CCustomCSView & mnview, uint32_t height)
     return Res::Ok();
 }
 
-Res LP_LOAN_TOKEN_SPLITS::Erase(CCustomCSView & mnview, uint32_t height, std::vector<std::string> const & keys)
-{
-    for (const auto& key : keys) {
+Res LP_LOAN_TOKEN_SPLITS::Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &keys) {
+    for (const auto &key : keys) {
         auto res = DCT_ID::FromString(key);
         if (!res)
             return std::move(res);
diff --git a/src/masternodes/govvariables/loan_splits.h b/src/masternodes/govvariables/loan_splits.h
index f3ac8012ac..2772b607d6 100644
--- a/src/masternodes/govvariables/loan_splits.h
+++ b/src/masternodes/govvariables/loan_splits.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_LOAN_SPLITS_H
 #define DEFI_MASTERNODES_GOVVARIABLES_LOAN_SPLITS_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class LP_LOAN_TOKEN_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_LOAN_TOKEN_SPLITS>
-{
+class LP_LOAN_TOKEN_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_LOAN_TOKEN_SPLITS> {
 public:
     virtual ~LP_LOAN_TOKEN_SPLITS() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "LP_LOAN_TOKEN_SPLITS"; }
-    static GovVariable * Create() { return new LP_LOAN_TOKEN_SPLITS(); }
+    static constexpr const char *TypeName() { return "LP_LOAN_TOKEN_SPLITS"; }
+    static GovVariable *Create() { return new LP_LOAN_TOKEN_SPLITS(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(splits);
     }
 
     std::map<DCT_ID, CAmount> splits;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_LOAN_SPLITS_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_LOAN_SPLITS_H
diff --git a/src/masternodes/govvariables/lp_daily_dfi_reward.cpp b/src/masternodes/govvariables/lp_daily_dfi_reward.cpp
index e6f317e876..c3bbf28c7d 100644
--- a/src/masternodes/govvariables/lp_daily_dfi_reward.cpp
+++ b/src/masternodes/govvariables/lp_daily_dfi_reward.cpp
@@ -4,28 +4,24 @@
 
 #include <masternodes/govvariables/lp_daily_dfi_reward.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool LP_DAILY_DFI_REWARD::IsEmpty() const
-{
+bool LP_DAILY_DFI_REWARD::IsEmpty() const {
     return !dailyReward.has_value();
 }
 
-Res LP_DAILY_DFI_REWARD::Import(const UniValue & val)
-{
+Res LP_DAILY_DFI_REWARD::Import(const UniValue &val) {
     dailyReward = AmountFromValue(val);
     return Res::Ok();
 }
 
-UniValue LP_DAILY_DFI_REWARD::Export() const
-{
+UniValue LP_DAILY_DFI_REWARD::Export() const {
     return ValueFromAmount(dailyReward.value_or(0));
 }
 
-Res LP_DAILY_DFI_REWARD::Validate(const CCustomCSView & view) const
-{
+Res LP_DAILY_DFI_REWARD::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() >= Params().GetConsensus().EunosHeight)
         return Res::Err("Cannot be set manually after Eunos hard fork");
 
@@ -33,13 +29,11 @@ Res LP_DAILY_DFI_REWARD::Validate(const CCustomCSView & view) const
     return Res::Ok();
 }
 
-Res LP_DAILY_DFI_REWARD::Apply(CCustomCSView & mnview, uint32_t height)
-{
+Res LP_DAILY_DFI_REWARD::Apply(CCustomCSView &mnview, uint32_t height) {
     return mnview.SetDailyReward(height, dailyReward.value_or(0));
 }
 
-Res LP_DAILY_DFI_REWARD::Erase(CCustomCSView & mnview, uint32_t height, std::vector<std::string> const &)
-{
+Res LP_DAILY_DFI_REWARD::Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) {
     dailyReward.reset();
     return mnview.SetDailyReward(height, 0);
 }
diff --git a/src/masternodes/govvariables/lp_daily_dfi_reward.h b/src/masternodes/govvariables/lp_daily_dfi_reward.h
index a057a34b38..1364ac4011 100644
--- a/src/masternodes/govvariables/lp_daily_dfi_reward.h
+++ b/src/masternodes/govvariables/lp_daily_dfi_reward.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_LP_DAILY_DFI_REWARD_H
 #define DEFI_MASTERNODES_GOVVARIABLES_LP_DAILY_DFI_REWARD_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class LP_DAILY_DFI_REWARD : public GovVariable, public AutoRegistrator<GovVariable, LP_DAILY_DFI_REWARD>
-{
+class LP_DAILY_DFI_REWARD : public GovVariable, public AutoRegistrator<GovVariable, LP_DAILY_DFI_REWARD> {
 public:
     virtual ~LP_DAILY_DFI_REWARD() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const&) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "LP_DAILY_DFI_REWARD"; }
-    static GovVariable * Create() { return new LP_DAILY_DFI_REWARD(); }
+    static constexpr const char *TypeName() { return "LP_DAILY_DFI_REWARD"; }
+    static GovVariable *Create() { return new LP_DAILY_DFI_REWARD(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(dailyReward);
     }
 
     GvOptional<CAmount> dailyReward;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_LP_DAILY_DFI_REWARD_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_LP_DAILY_DFI_REWARD_H
diff --git a/src/masternodes/govvariables/lp_splits.cpp b/src/masternodes/govvariables/lp_splits.cpp
index c58a043478..7e56a9eea3 100644
--- a/src/masternodes/govvariables/lp_splits.cpp
+++ b/src/masternodes/govvariables/lp_splits.cpp
@@ -4,47 +4,44 @@
 
 #include <masternodes/govvariables/lp_splits.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool LP_SPLITS::IsEmpty() const
-{
+bool LP_SPLITS::IsEmpty() const {
     return splits.empty();
 }
 
-Res LP_SPLITS::Import(const UniValue & val)
-{
+Res LP_SPLITS::Import(const UniValue &val) {
     if (!val.isObject())
-        return Res::Err("object of {poolId: rate,... } expected"); /// throw here? cause "AmountFromValue" can throw!
+        return Res::Err("object of {poolId: rate,... } expected");  /// throw here? cause "AmountFromValue" can throw!
 
-    for (const std::string& key : val.getKeys()) {
+    for (const std::string &key : val.getKeys()) {
         const auto id = DCT_ID::FromString(key);
         if (!id)
             return std::move(id);
-        splits.emplace(*id.val, AmountFromValue(val[key]));//todo: AmountFromValue
+        splits.emplace(*id.val, AmountFromValue(val[key]));  // todo: AmountFromValue
     }
     return Res::Ok();
 }
 
-UniValue LP_SPLITS::Export() const
-{
+UniValue LP_SPLITS::Export() const {
     UniValue res(UniValue::VOBJ);
-    for (auto const & kv : splits) {
+    for (const auto &kv : splits) {
         res.pushKV(kv.first.ToString(), ValueFromAmount(kv.second));
     }
     return res;
 }
 
-Res LP_SPLITS::Validate(const CCustomCSView & mnview) const
-{
+Res LP_SPLITS::Validate(const CCustomCSView &mnview) const {
     CAmount total{0};
-    for (auto const & kv : splits) {
+    for (const auto &kv : splits) {
         if (!mnview.HasPoolPair(kv.first))
             return Res::Err("pool with id=%s not found", kv.first.ToString());
 
         if (kv.second < 0 || kv.second > COIN)
-            return Res::Err("wrong percentage for pool with id=%s, value = %s", kv.first.ToString(), std::to_string(kv.second));
+            return Res::Err(
+                "wrong percentage for pool with id=%s, value = %s", kv.first.ToString(), std::to_string(kv.second));
 
         total += kv.second;
     }
@@ -54,12 +51,11 @@ Res LP_SPLITS::Validate(const CCustomCSView & mnview) const
     return Res::Ok();
 }
 
-Res LP_SPLITS::Apply(CCustomCSView & mnview, uint32_t height)
-{
-    mnview.ForEachPoolId([&] (DCT_ID poolId) {
+Res LP_SPLITS::Apply(CCustomCSView &mnview, uint32_t height) {
+    mnview.ForEachPoolId([&](DCT_ID poolId) {
         // we ought to reset previous value:
         CAmount rewardPct = 0;
-        auto it = splits.find(poolId);
+        auto it           = splits.find(poolId);
         if (it != splits.end())
             rewardPct = it->second;
 
@@ -69,9 +65,8 @@ Res LP_SPLITS::Apply(CCustomCSView & mnview, uint32_t height)
     return Res::Ok();
 }
 
-Res LP_SPLITS::Erase(CCustomCSView & mnview, uint32_t height, std::vector<std::string> const & keys)
-{
-    for (const auto& key : keys) {
+Res LP_SPLITS::Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &keys) {
+    for (const auto &key : keys) {
         auto res = DCT_ID::FromString(key);
         if (!res)
             return std::move(res);
diff --git a/src/masternodes/govvariables/lp_splits.h b/src/masternodes/govvariables/lp_splits.h
index 35ab60f2aa..6270a27dca 100644
--- a/src/masternodes/govvariables/lp_splits.h
+++ b/src/masternodes/govvariables/lp_splits.h
@@ -5,33 +5,30 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_LP_SPLITS_H
 #define DEFI_MASTERNODES_GOVVARIABLES_LP_SPLITS_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class LP_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_SPLITS>
-{
+class LP_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_SPLITS> {
 public:
     virtual ~LP_SPLITS() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "LP_SPLITS"; }
-    static GovVariable * Create() { return new LP_SPLITS(); }
+    static constexpr const char *TypeName() { return "LP_SPLITS"; }
+    static GovVariable *Create() { return new LP_SPLITS(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         static_assert(std::is_same<decltype(splits), std::map<DCT_ID, CAmount>>::value, "Following code is invalid");
         std::map<uint32_t, CAmount> serliazedSplits;
         if (ser_action.ForRead()) {
@@ -42,7 +39,7 @@ class LP_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_SPL
                 serliazedSplits.erase(it++);
             }
         } else {
-            for (const auto& it : splits) {
+            for (const auto &it : splits) {
                 serliazedSplits.emplace(it.first.v, it.second);
             }
             READWRITE(serliazedSplits);
@@ -52,4 +49,4 @@ class LP_SPLITS : public GovVariable, public AutoRegistrator<GovVariable, LP_SPL
     std::map<DCT_ID, CAmount> splits;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_LP_SPLITS_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_LP_SPLITS_H
diff --git a/src/masternodes/govvariables/oracle_block_interval.cpp b/src/masternodes/govvariables/oracle_block_interval.cpp
index 8fa83a9547..30b436b74e 100644
--- a/src/masternodes/govvariables/oracle_block_interval.cpp
+++ b/src/masternodes/govvariables/oracle_block_interval.cpp
@@ -4,17 +4,15 @@
 
 #include <masternodes/govvariables/oracle_block_interval.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool ORACLE_BLOCK_INTERVAL::IsEmpty() const
-{
+bool ORACLE_BLOCK_INTERVAL::IsEmpty() const {
     return !blockInterval.has_value();
 }
 
-Res ORACLE_BLOCK_INTERVAL::Import(const UniValue & val)
-{
+Res ORACLE_BLOCK_INTERVAL::Import(const UniValue &val) {
     if (!val.isNum())
         throw JSONRPCError(RPC_TYPE_ERROR, "Block interval amount is not a number");
 
@@ -22,13 +20,11 @@ Res ORACLE_BLOCK_INTERVAL::Import(const UniValue & val)
     return Res::Ok();
 }
 
-UniValue ORACLE_BLOCK_INTERVAL::Export() const
-{
+UniValue ORACLE_BLOCK_INTERVAL::Export() const {
     return static_cast<uint64_t>(blockInterval.value_or(0));
 }
 
-Res ORACLE_BLOCK_INTERVAL::Validate(const CCustomCSView & view) const
-{
+Res ORACLE_BLOCK_INTERVAL::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() < Params().GetConsensus().FortCanningHeight)
         return Res::Err("Cannot be set before FortCanning");
 
@@ -38,13 +34,11 @@ Res ORACLE_BLOCK_INTERVAL::Validate(const CCustomCSView & view) const
     return Res::Ok();
 }
 
-Res ORACLE_BLOCK_INTERVAL::Apply(CCustomCSView & mnview, uint32_t height)
-{
+Res ORACLE_BLOCK_INTERVAL::Apply(CCustomCSView &mnview, uint32_t height) {
     return mnview.SetIntervalBlock(blockInterval.value_or(0));
 }
 
-Res ORACLE_BLOCK_INTERVAL::Erase(CCustomCSView & mnview, uint32_t, std::vector<std::string> const &)
-{
+Res ORACLE_BLOCK_INTERVAL::Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &) {
     blockInterval.reset();
     return mnview.EraseIntervalBlock();
 }
diff --git a/src/masternodes/govvariables/oracle_block_interval.h b/src/masternodes/govvariables/oracle_block_interval.h
index 645987ffb7..c086a35043 100644
--- a/src/masternodes/govvariables/oracle_block_interval.h
+++ b/src/masternodes/govvariables/oracle_block_interval.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_ORACLE_BLOCK_INTERVAL_H
 #define DEFI_MASTERNODES_GOVVARIABLES_ORACLE_BLOCK_INTERVAL_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class ORACLE_BLOCK_INTERVAL : public GovVariable, public AutoRegistrator<GovVariable, ORACLE_BLOCK_INTERVAL>
-{
+class ORACLE_BLOCK_INTERVAL : public GovVariable, public AutoRegistrator<GovVariable, ORACLE_BLOCK_INTERVAL> {
 public:
     virtual ~ORACLE_BLOCK_INTERVAL() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const&) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "ORACLE_BLOCK_INTERVAL"; }
-    static GovVariable * Create() { return new ORACLE_BLOCK_INTERVAL(); }
+    static constexpr const char *TypeName() { return "ORACLE_BLOCK_INTERVAL"; }
+    static GovVariable *Create() { return new ORACLE_BLOCK_INTERVAL(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(blockInterval);
     }
 
     GvOptional<uint32_t> blockInterval;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_ORACLE_BLOCK_INTERVAL_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_ORACLE_BLOCK_INTERVAL_H
diff --git a/src/masternodes/govvariables/oracle_deviation.cpp b/src/masternodes/govvariables/oracle_deviation.cpp
index 47326c21bc..bf35bbc530 100644
--- a/src/masternodes/govvariables/oracle_deviation.cpp
+++ b/src/masternodes/govvariables/oracle_deviation.cpp
@@ -4,28 +4,24 @@
 
 #include <masternodes/govvariables/oracle_deviation.h>
 
-#include <core_io.h> /// ValueFromAmount
-#include <masternodes/masternodes.h> /// CCustomCSView
-#include <rpc/util.h> /// AmountFromValue
+#include <core_io.h>                  /// ValueFromAmount
+#include <masternodes/masternodes.h>  /// CCustomCSView
+#include <rpc/util.h>                 /// AmountFromValue
 
-bool ORACLE_DEVIATION::IsEmpty() const
-{
+bool ORACLE_DEVIATION::IsEmpty() const {
     return !deviation.has_value();
 }
 
-Res ORACLE_DEVIATION::Import(const UniValue & val)
-{
+Res ORACLE_DEVIATION::Import(const UniValue &val) {
     deviation = AmountFromValue(val);
     return Res::Ok();
 }
 
-UniValue ORACLE_DEVIATION::Export() const
-{
+UniValue ORACLE_DEVIATION::Export() const {
     return ValueFromAmount(deviation.value_or(0));
 }
 
-Res ORACLE_DEVIATION::Validate(const CCustomCSView & view) const
-{
+Res ORACLE_DEVIATION::Validate(const CCustomCSView &view) const {
     if (view.GetLastHeight() < Params().GetConsensus().FortCanningHeight)
         return Res::Err("Cannot be set before FortCanning");
 
@@ -35,13 +31,11 @@ Res ORACLE_DEVIATION::Validate(const CCustomCSView & view) const
     return Res::Ok();
 }
 
-Res ORACLE_DEVIATION::Apply(CCustomCSView & mnview, uint32_t height)
-{
+Res ORACLE_DEVIATION::Apply(CCustomCSView &mnview, uint32_t height) {
     return mnview.SetPriceDeviation(deviation.value_or(0));
 }
 
-Res ORACLE_DEVIATION::Erase(CCustomCSView & mnview, uint32_t, std::vector<std::string> const &)
-{
+Res ORACLE_DEVIATION::Erase(CCustomCSView &mnview, uint32_t, const std::vector<std::string> &) {
     deviation.reset();
     return mnview.ErasePriceDeviation();
 }
diff --git a/src/masternodes/govvariables/oracle_deviation.h b/src/masternodes/govvariables/oracle_deviation.h
index 9d088423e6..a33f23ca12 100644
--- a/src/masternodes/govvariables/oracle_deviation.h
+++ b/src/masternodes/govvariables/oracle_deviation.h
@@ -5,37 +5,34 @@
 #ifndef DEFI_MASTERNODES_GOVVARIABLES_ORACLE_DEVIATION_H
 #define DEFI_MASTERNODES_GOVVARIABLES_ORACLE_DEVIATION_H
 
-#include <masternodes/gv.h>
 #include <amount.h>
+#include <masternodes/gv.h>
 
-class ORACLE_DEVIATION : public GovVariable, public AutoRegistrator<GovVariable, ORACLE_DEVIATION>
-{
+class ORACLE_DEVIATION : public GovVariable, public AutoRegistrator<GovVariable, ORACLE_DEVIATION> {
 public:
     virtual ~ORACLE_DEVIATION() override {}
 
-    std::string GetName() const override {
-        return TypeName();
-    }
+    std::string GetName() const override { return TypeName(); }
 
     bool IsEmpty() const override;
-    Res Import(UniValue const &val) override;
+    Res Import(const UniValue &val) override;
     UniValue Export() const override;
-    Res Validate(CCustomCSView const &mnview) const override;
+    Res Validate(const CCustomCSView &mnview) const override;
     Res Apply(CCustomCSView &mnview, uint32_t height) override;
-    Res Erase(CCustomCSView &mnview, uint32_t height, std::vector<std::string> const &) override;
+    Res Erase(CCustomCSView &mnview, uint32_t height, const std::vector<std::string> &) override;
 
-    static constexpr char const * TypeName() { return "ORACLE_DEVIATION"; }
-    static GovVariable * Create() { return new ORACLE_DEVIATION(); }
+    static constexpr const char *TypeName() { return "ORACLE_DEVIATION"; }
+    static GovVariable *Create() { return new ORACLE_DEVIATION(); }
 
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(deviation);
     }
 
     GvOptional<CAmount> deviation;
 };
 
-#endif // DEFI_MASTERNODES_GOVVARIABLES_ORACLE_DEVIATION_H
+#endif  // DEFI_MASTERNODES_GOVVARIABLES_ORACLE_DEVIATION_H
diff --git a/src/masternodes/gv.cpp b/src/masternodes/gv.cpp
index 3a8cbcef7a..23feec956f 100644
--- a/src/masternodes/gv.cpp
+++ b/src/masternodes/gv.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-#include <masternodes/gv.h>
 #include <masternodes/govvariables/attributes.h>
 #include <masternodes/govvariables/icx_takerfee_per_btc.h>
 #include <masternodes/govvariables/loan_daily_reward.h>
@@ -12,10 +11,10 @@
 #include <masternodes/govvariables/lp_splits.h>
 #include <masternodes/govvariables/oracle_block_interval.h>
 #include <masternodes/govvariables/oracle_deviation.h>
+#include <masternodes/gv.h>
 
-Res CGovView::SetVariable(GovVariable const & var)
-{
-    auto WriteOrEraseVar = [this](GovVariable const & var) {
+Res CGovView::SetVariable(const GovVariable &var) {
+    auto WriteOrEraseVar = [this](const GovVariable &var) {
         if (var.IsEmpty()) {
             EraseBy<ByName>(var.GetName());
         } else {
@@ -30,11 +29,11 @@ Res CGovView::SetVariable(GovVariable const & var)
     if (!attributes) {
         return WriteOrEraseVar(var);
     }
-    auto& current = dynamic_cast<const ATTRIBUTES&>(var);
+    auto &current = dynamic_cast<const ATTRIBUTES &>(var);
     if (current.changed.empty()) {
         return Res::Ok();
     }
-    for (auto& key : current.changed) {
+    for (auto &key : current.changed) {
         auto it = current.attributes.find(key);
         if (it == current.attributes.end()) {
             attributes->attributes.erase(key);
@@ -45,8 +44,7 @@ Res CGovView::SetVariable(GovVariable const & var)
     return WriteOrEraseVar(*attributes);
 }
 
-std::shared_ptr<GovVariable> CGovView::GetVariable(std::string const & name) const
-{
+std::shared_ptr<GovVariable> CGovView::GetVariable(const std::string &name) const {
     auto var = GovVariable::Create(name);
     if (var) {
         /// @todo empty or NO variable??
@@ -56,9 +54,8 @@ std::shared_ptr<GovVariable> CGovView::GetVariable(std::string const & name) con
     return {};
 }
 
-Res CGovView::SetStoredVariables(const std::set<std::shared_ptr<GovVariable>>& govVars, const uint32_t height)
-{
-    for (auto& item : govVars) {
+Res CGovView::SetStoredVariables(const std::set<std::shared_ptr<GovVariable>> &govVars, const uint32_t height) {
+    for (auto &item : govVars) {
         if (!WriteBy<ByHeightVars>(GovVarKey{height, item->GetName()}, *item)) {
             return Res::Err("Cannot write to DB");
         }
@@ -67,8 +64,7 @@ Res CGovView::SetStoredVariables(const std::set<std::shared_ptr<GovVariable>>& g
     return Res::Ok();
 }
 
-std::set<std::shared_ptr<GovVariable>> CGovView::GetStoredVariables(const uint32_t height)
-{
+std::set<std::shared_ptr<GovVariable>> CGovView::GetStoredVariables(const uint32_t height) {
     // Populate a set of Gov vars for specified height
     std::set<std::shared_ptr<GovVariable>> govVars;
     auto it = LowerBound<ByHeightVars>(GovVarKey{height, {}});
@@ -82,8 +78,9 @@ std::set<std::shared_ptr<GovVariable>> CGovView::GetStoredVariables(const uint32
     return govVars;
 }
 
-std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> CGovView::GetStoredVariablesRange(const uint32_t startHeight, const uint32_t endHeight)
-{
+std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> CGovView::GetStoredVariablesRange(
+    const uint32_t startHeight,
+    const uint32_t endHeight) {
     // Populate a set of Gov vars for specified height
     std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> govVars;
     auto it = LowerBound<ByHeightVars>(GovVarKey{startHeight, {}});
@@ -97,8 +94,7 @@ std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> CGovView::GetStor
     return govVars;
 }
 
-std::map<std::string, std::map<uint64_t, std::shared_ptr<GovVariable>>> CGovView::GetAllStoredVariables()
-{
+std::map<std::string, std::map<uint64_t, std::shared_ptr<GovVariable>>> CGovView::GetAllStoredVariables() {
     // Populate map by var name as key and map of height and Gov vars as elements.
     std::map<std::string, std::map<uint64_t, std::shared_ptr<GovVariable>>> govVars;
     auto it = LowerBound<ByHeightVars>(GovVarKey{std::numeric_limits<uint32_t>::min(), {}});
@@ -113,13 +109,12 @@ std::map<std::string, std::map<uint64_t, std::shared_ptr<GovVariable>>> CGovView
     return govVars;
 }
 
-void CGovView::EraseStoredVariables(const uint32_t height)
-{
+void CGovView::EraseStoredVariables(const uint32_t height) {
     // Retrieve map of vars at specified height
     const auto vars = GetStoredVariables(height);
 
     // Iterate over names at this height and erase
-    for (const auto& var : vars) {
+    for (const auto &var : vars) {
         EraseBy<ByHeightVars>(GovVarKey{height, var->GetName()});
     }
 }
diff --git a/src/masternodes/gv.h b/src/masternodes/gv.h
index 508317d626..5269b8bfad 100644
--- a/src/masternodes/gv.h
+++ b/src/masternodes/gv.h
@@ -13,68 +13,70 @@
 class ATTRIBUTES;
 class CCustomCSView;
 
-template<typename T>
-class GvOptional : public std::optional<T>
-{
+template <typename T>
+class GvOptional : public std::optional<T> {
 public:
     using std::optional<T>::optional;
     using std::optional<T>::operator bool;
 
-    template<typename Stream>
-    inline void Serialize(Stream& s) const {
+    template <typename Stream>
+    inline void Serialize(Stream &s) const {
         assert(this->has_value());
         ::Serialize(s, this->value());
     }
 
-    template<typename Stream>
-    inline void Unserialize(Stream& s) {
+    template <typename Stream>
+    inline void Unserialize(Stream &s) {
         ::Unserialize(s, *this ? this->value() : this->emplace());
     }
 };
 
-class GovVariable
-{
+class GovVariable {
 public:
-    static std::shared_ptr<GovVariable> Create(std::string const & name) {
+    static std::shared_ptr<GovVariable> Create(const std::string &name) {
         return std::shared_ptr<GovVariable>(Factory<GovVariable>::Create(name));
     }
     virtual ~GovVariable() = default;
 
     virtual std::string GetName() const = 0;
 
-    virtual bool IsEmpty() const = 0;
-    virtual Res Import(UniValue const &) = 0;
-    virtual UniValue Export() const = 0;
+    virtual bool IsEmpty() const         = 0;
+    virtual Res Import(const UniValue &) = 0;
+    virtual UniValue Export() const      = 0;
     /// @todo it looks like Validate+Apply may be redundant. refactor for one?
-    virtual Res Validate(CCustomCSView const &) const = 0;
-    virtual Res Apply(CCustomCSView &, uint32_t) = 0;
-    virtual Res Erase(CCustomCSView &, uint32_t, std::vector<std::string> const &) = 0;
+    virtual Res Validate(const CCustomCSView &) const                              = 0;
+    virtual Res Apply(CCustomCSView &, uint32_t)                                   = 0;
+    virtual Res Erase(CCustomCSView &, uint32_t, const std::vector<std::string> &) = 0;
 
-    virtual void Serialize(CVectorWriter& s) const = 0;
-    virtual void Unserialize(VectorReader& s) = 0;
+    virtual void Serialize(CVectorWriter &s) const = 0;
+    virtual void Unserialize(VectorReader &s)      = 0;
 
-    virtual void Serialize(CDataStream& s) const = 0;
-    virtual void Unserialize(CDataStream& s) = 0;
+    virtual void Serialize(CDataStream &s) const = 0;
+    virtual void Unserialize(CDataStream &s)     = 0;
 };
 
-class CGovView : public virtual CStorageView
-{
+class CGovView : public virtual CStorageView {
 public:
-    Res SetVariable(GovVariable const & var);
-    std::shared_ptr<GovVariable> GetVariable(std::string const &govKey) const;
+    Res SetVariable(const GovVariable &var);
+    std::shared_ptr<GovVariable> GetVariable(const std::string &govKey) const;
 
-    Res SetStoredVariables(const std::set<std::shared_ptr<GovVariable>>& govVars, const uint32_t height);
+    Res SetStoredVariables(const std::set<std::shared_ptr<GovVariable>> &govVars, const uint32_t height);
     std::set<std::shared_ptr<GovVariable>> GetStoredVariables(const uint32_t height);
-    std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> GetStoredVariablesRange(const uint32_t startHeight, const uint32_t endHeight);
+    std::vector<std::pair<uint32_t, std::shared_ptr<GovVariable>>> GetStoredVariablesRange(const uint32_t startHeight,
+                                                                                           const uint32_t endHeight);
     std::map<std::string, std::map<uint64_t, std::shared_ptr<GovVariable>>> GetAllStoredVariables();
     void EraseStoredVariables(const uint32_t height);
 
     std::shared_ptr<ATTRIBUTES> GetAttributes() const;
 
-    [[nodiscard]] virtual bool AreTokensLocked(const std::set<uint32_t>& tokenIds) const = 0;
+    [[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'; } };
+    struct ByHeightVars {
+        static constexpr uint8_t prefix() { return 'G'; }
+    };
+    struct ByName {
+        static constexpr uint8_t prefix() { return 'g'; }
+    };
 };
 
 struct GovVarKey {
@@ -84,7 +86,7 @@ struct GovVarKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(WrapBigEndian(height));
         READWRITE(name);
     }
@@ -123,4 +125,4 @@ class GV_EXAMPLE : public GovVariable, public AutoRegistrator<GovVariable, GV_EX
 };
 */
 
-#endif // DEFI_MASTERNODES_GV_H
+#endif  // DEFI_MASTERNODES_GV_H
diff --git a/src/masternodes/icxorder.cpp b/src/masternodes/icxorder.cpp
index 1f3414b53f..5bad1e5bc5 100644
--- a/src/masternodes/icxorder.cpp
+++ b/src/masternodes/icxorder.cpp
@@ -1,57 +1,56 @@
+#include <core_io.h>  /// ValueFromAmount
 #include <masternodes/icxorder.h>
-#include <rpc/util.h> /// AmountFromValue
-#include <core_io.h> /// ValueFromAmount
+#include <rpc/util.h>  /// AmountFromValue
 
 const uint32_t CICXOrder::DEFAULT_EXPIRY = 2880;
-const uint8_t CICXOrder::TYPE_INTERNAL = 1;
-const uint8_t CICXOrder::TYPE_EXTERNAL = 2;
-const uint8_t CICXOrder::STATUS_OPEN = 0;
-const uint8_t CICXOrder::STATUS_CLOSED = 1;
-const uint8_t CICXOrder::STATUS_FILLED = 2;
-const uint8_t CICXOrder::STATUS_EXPIRED = 3;
-const std::string CICXOrder::CHAIN_BTC = "BTC";
-const std::string CICXOrder::TOKEN_BTC = "BTC";
-
-const uint32_t CICXMakeOffer::DEFAULT_EXPIRY = 10;
-const uint32_t CICXMakeOffer::EUNOSPAYA_DEFAULT_EXPIRY = 20;
+const uint8_t CICXOrder::TYPE_INTERNAL   = 1;
+const uint8_t CICXOrder::TYPE_EXTERNAL   = 2;
+const uint8_t CICXOrder::STATUS_OPEN     = 0;
+const uint8_t CICXOrder::STATUS_CLOSED   = 1;
+const uint8_t CICXOrder::STATUS_FILLED   = 2;
+const uint8_t CICXOrder::STATUS_EXPIRED  = 3;
+const std::string CICXOrder::CHAIN_BTC   = "BTC";
+const std::string CICXOrder::TOKEN_BTC   = "BTC";
+
+const uint32_t CICXMakeOffer::DEFAULT_EXPIRY               = 10;
+const uint32_t CICXMakeOffer::EUNOSPAYA_DEFAULT_EXPIRY     = 20;
 const uint32_t CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT = 100;
-const uint8_t CICXMakeOffer::STATUS_OPEN = 0;
-const uint8_t CICXMakeOffer::STATUS_CLOSED = 1;
-const uint8_t CICXMakeOffer::STATUS_EXPIRED = 2;
-const CAmount CICXMakeOffer::DEFAULT_TAKER_FEE_PER_BTC = AmountFromValue(0.003);
-
-const uint32_t CICXSubmitDFCHTLC::MINIMUM_TIMEOUT = 500;
-const uint32_t CICXSubmitDFCHTLC::MINIMUM_2ND_TIMEOUT = 250;
-const uint32_t CICXSubmitDFCHTLC::EUNOSPAYA_MINIMUM_TIMEOUT = 1440;
+const uint8_t CICXMakeOffer::STATUS_OPEN                   = 0;
+const uint8_t CICXMakeOffer::STATUS_CLOSED                 = 1;
+const uint8_t CICXMakeOffer::STATUS_EXPIRED                = 2;
+const CAmount CICXMakeOffer::DEFAULT_TAKER_FEE_PER_BTC     = AmountFromValue(0.003);
+
+const uint32_t CICXSubmitDFCHTLC::MINIMUM_TIMEOUT               = 500;
+const uint32_t CICXSubmitDFCHTLC::MINIMUM_2ND_TIMEOUT           = 250;
+const uint32_t CICXSubmitDFCHTLC::EUNOSPAYA_MINIMUM_TIMEOUT     = 1440;
 const uint32_t CICXSubmitDFCHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT = 480;
-const uint8_t CICXSubmitDFCHTLC::STATUS_OPEN = 0;
-const uint8_t CICXSubmitDFCHTLC::STATUS_CLAIMED = 1;
-const uint8_t CICXSubmitDFCHTLC::STATUS_REFUNDED = 2;
-const uint8_t CICXSubmitDFCHTLC::STATUS_EXPIRED = 3;
-
-const uint32_t CICXSubmitEXTHTLC::MINIMUM_TIMEOUT = 30;
-const uint32_t CICXSubmitEXTHTLC::MINIMUM_2ND_TIMEOUT = 15;
-const uint32_t CICXSubmitEXTHTLC::EUNOSPAYA_MINIMUM_TIMEOUT = 72;
+const uint8_t CICXSubmitDFCHTLC::STATUS_OPEN                    = 0;
+const uint8_t CICXSubmitDFCHTLC::STATUS_CLAIMED                 = 1;
+const uint8_t CICXSubmitDFCHTLC::STATUS_REFUNDED                = 2;
+const uint8_t CICXSubmitDFCHTLC::STATUS_EXPIRED                 = 3;
+
+const uint32_t CICXSubmitEXTHTLC::MINIMUM_TIMEOUT               = 30;
+const uint32_t CICXSubmitEXTHTLC::MINIMUM_2ND_TIMEOUT           = 15;
+const uint32_t CICXSubmitEXTHTLC::EUNOSPAYA_MINIMUM_TIMEOUT     = 72;
 const uint32_t CICXSubmitEXTHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT = 24;
-// constant for calculating BTC block period in DFI block period per hour (BTC estimated to 6 blocks/h, DFI to 96 blocks/h)
-const uint32_t CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS = 16;
+// constant for calculating BTC block period in DFI block period per hour (BTC estimated to 6 blocks/h, DFI to 96
+// blocks/h)
+const uint32_t CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS           = 16;
 const uint32_t CICXSubmitEXTHTLC::EUNOSPAYA_BTC_BLOCKS_IN_DFI_BLOCKS = 20;
-const uint8_t CICXSubmitEXTHTLC::STATUS_OPEN = 0;
-const uint8_t CICXSubmitEXTHTLC::STATUS_CLOSED = 1;
-const uint8_t CICXSubmitEXTHTLC::STATUS_EXPIRED = 3;
+const uint8_t CICXSubmitEXTHTLC::STATUS_OPEN                         = 0;
+const uint8_t CICXSubmitEXTHTLC::STATUS_CLOSED                       = 1;
+const uint8_t CICXSubmitEXTHTLC::STATUS_EXPIRED                      = 3;
 
 const CAmount CICXOrderView::DEFAULT_DFI_BTC_PRICE = 15000;
 
-std::unique_ptr<CICXOrderView::CICXOrderImpl> CICXOrderView::GetICXOrderByCreationTx(uint256 const & txid) const
-{
-    auto order = ReadBy<ICXOrderCreationTx,CICXOrderImpl>(txid);
+std::unique_ptr<CICXOrderView::CICXOrderImpl> CICXOrderView::GetICXOrderByCreationTx(const uint256 &txid) const {
+    auto order = ReadBy<ICXOrderCreationTx, CICXOrderImpl>(txid);
     if (order)
         return std::make_unique<CICXOrderImpl>(*order);
     return {};
 }
 
-uint8_t CICXOrderView::GetICXOrderStatus(OrderKey const & key) const
-{
+uint8_t CICXOrderView::GetICXOrderStatus(const OrderKey &key) const {
     auto status = ReadBy<ICXOrderOpenKey, uint8_t>(key);
 
     if (!status)
@@ -63,9 +62,8 @@ uint8_t CICXOrderView::GetICXOrderStatus(OrderKey const & key) const
     return {};
 }
 
-Res CICXOrderView::ICXCreateOrder(CICXOrderImpl const & order)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXCreateOrder(const CICXOrderImpl &order) {
+    // this should not happen, but for sure
     if (GetICXOrderByCreationTx(order.creationTx))
         return Res::Err("order with creation tx %s already exists!", order.creationTx.GetHex());
     if (order.orderType != CICXOrder::TYPE_INTERNAL && order.orderType != CICXOrder::TYPE_EXTERNAL)
@@ -82,14 +80,14 @@ Res CICXOrderView::ICXCreateOrder(CICXOrderImpl const & order)
     OrderKey key(order.idToken, order.creationTx);
     WriteBy<ICXOrderCreationTx>(order.creationTx, order);
     WriteBy<ICXOrderOpenKey>(key, CICXOrder::STATUS_OPEN);
-    WriteBy<ICXOrderStatus>(StatusKey(order.creationHeight + order.expiry, order.creationTx), CICXOrder::STATUS_EXPIRED);
+    WriteBy<ICXOrderStatus>(StatusKey(order.creationHeight + order.expiry, order.creationTx),
+                            CICXOrder::STATUS_EXPIRED);
 
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXUpdateOrder(CICXOrderImpl const & order)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXUpdateOrder(const CICXOrderImpl &order) {
+    // this should not happen, but for sure
     if (!GetICXOrderByCreationTx(order.creationTx))
         return Res::Err("order with creation tx %s doesn't exists!", order.creationTx.GetHex());
 
@@ -99,8 +97,7 @@ Res CICXOrderView::ICXUpdateOrder(CICXOrderImpl const & order)
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXCloseOrderTx(CICXOrderImpl const & order, uint8_t const status)
-{
+Res CICXOrderView::ICXCloseOrderTx(const CICXOrderImpl &order, const uint8_t status) {
     WriteBy<ICXOrderCreationTx>(order.creationTx, order);
     OrderKey key(order.idToken, order.creationTx);
     EraseBy<ICXOrderOpenKey>(key);
@@ -110,40 +107,36 @@ Res CICXOrderView::ICXCloseOrderTx(CICXOrderImpl const & order, uint8_t const st
     return Res::Ok();
 }
 
-void CICXOrderView::ForEachICXOrderOpen(std::function<bool (OrderKey const &, uint8_t)> callback, DCT_ID const & id)
-{
+void CICXOrderView::ForEachICXOrderOpen(std::function<bool(const OrderKey &, uint8_t)> callback, DCT_ID const &id) {
     ForEach<ICXOrderOpenKey, OrderKey, uint8_t>(callback, OrderKey{id, {}});
 }
 
-void CICXOrderView::ForEachICXOrderClose(std::function<bool (OrderKey const &, uint8_t)> callback, DCT_ID const & id)
-{
+void CICXOrderView::ForEachICXOrderClose(std::function<bool(const OrderKey &, uint8_t)> callback, DCT_ID const &id) {
     ForEach<ICXOrderCloseKey, OrderKey, uint8_t>(callback, OrderKey{id, {}});
 }
 
-void CICXOrderView::ForEachICXOrderExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height)
-{
+void CICXOrderView::ForEachICXOrderExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                          const uint32_t &height) {
     ForEach<ICXOrderStatus, StatusKey, uint8_t>(callback, StatusKey{height, {}});
 }
 
-std::unique_ptr<CICXOrderView::CICXOrderImpl> CICXOrderView::HasICXOrderOpen(DCT_ID const & tokenId, uint256 const & ordertxid)
-{
+std::unique_ptr<CICXOrderView::CICXOrderImpl> CICXOrderView::HasICXOrderOpen(DCT_ID const &tokenId,
+                                                                             const uint256 &ordertxid) {
     auto it = LowerBound<ICXOrderOpenKey>(OrderKey{tokenId, ordertxid});
     if (it.Valid() && it.Key().first == tokenId && it.Key().second == ordertxid)
         return GetICXOrderByCreationTx(it.Key().second);
     return {};
 }
 
-
-std::unique_ptr<CICXOrderView::CICXMakeOfferImpl> CICXOrderView::GetICXMakeOfferByCreationTx(uint256 const & txid) const
-{
-    auto makeoffer = ReadBy<ICXMakeOfferCreationTx,CICXMakeOfferImpl>(txid);
+std::unique_ptr<CICXOrderView::CICXMakeOfferImpl> CICXOrderView::GetICXMakeOfferByCreationTx(
+    const uint256 &txid) const {
+    auto makeoffer = ReadBy<ICXMakeOfferCreationTx, CICXMakeOfferImpl>(txid);
     if (makeoffer)
         return std::make_unique<CICXMakeOfferImpl>(*makeoffer);
     return {};
 }
 
-uint8_t CICXOrderView::GetICXMakeOfferStatus(TxidPairKey const & key) const
-{
+uint8_t CICXOrderView::GetICXMakeOfferStatus(const TxidPairKey &key) const {
     auto status = ReadBy<ICXMakeOfferOpenKey, uint8_t>(key);
 
     if (!status)
@@ -155,9 +148,8 @@ uint8_t CICXOrderView::GetICXMakeOfferStatus(TxidPairKey const & key) const
     return {};
 }
 
-Res CICXOrderView::ICXMakeOffer(CICXMakeOfferImpl const & makeoffer)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXMakeOffer(const CICXMakeOfferImpl &makeoffer) {
+    // this should not happen, but for sure
     if (GetICXMakeOfferByCreationTx(makeoffer.creationTx))
         return Res::Err("makeoffer with creation tx %s already exists!", makeoffer.creationTx.GetHex());
     if (makeoffer.amount == 0)
@@ -165,21 +157,20 @@ Res CICXOrderView::ICXMakeOffer(CICXMakeOfferImpl const & makeoffer)
 
     WriteBy<ICXMakeOfferCreationTx>(makeoffer.creationTx, makeoffer);
     WriteBy<ICXMakeOfferOpenKey>(TxidPairKey(makeoffer.orderTx, makeoffer.creationTx), CICXMakeOffer::STATUS_OPEN);
-    WriteBy<ICXOfferStatus>(StatusKey(makeoffer.creationHeight + makeoffer.expiry, makeoffer.creationTx), CICXMakeOffer::STATUS_EXPIRED);
+    WriteBy<ICXOfferStatus>(StatusKey(makeoffer.creationHeight + makeoffer.expiry, makeoffer.creationTx),
+                            CICXMakeOffer::STATUS_EXPIRED);
 
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXUpdateMakeOffer(CICXMakeOfferImpl const & makeoffer)
-{
+Res CICXOrderView::ICXUpdateMakeOffer(const CICXMakeOfferImpl &makeoffer) {
     WriteBy<ICXMakeOfferCreationTx>(makeoffer.creationTx, makeoffer);
 
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXCloseMakeOfferTx(CICXMakeOfferImpl const & makeoffer, uint8_t const status)
-{
-    TxidPairKey key(makeoffer.orderTx,makeoffer.creationTx);
+Res CICXOrderView::ICXCloseMakeOfferTx(const CICXMakeOfferImpl &makeoffer, const uint8_t status) {
+    TxidPairKey key(makeoffer.orderTx, makeoffer.creationTx);
     EraseBy<ICXMakeOfferOpenKey>(key);
     WriteBy<ICXMakeOfferCloseKey>(key, status);
     EraseBy<ICXOfferStatus>(StatusKey(makeoffer.creationHeight + makeoffer.expiry, makeoffer.creationTx));
@@ -187,40 +178,39 @@ Res CICXOrderView::ICXCloseMakeOfferTx(CICXMakeOfferImpl const & makeoffer, uint
     return Res::Ok();
 }
 
-void CICXOrderView::ForEachICXMakeOfferOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & txid)
-{
+void CICXOrderView::ForEachICXMakeOfferOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                            const uint256 &txid) {
     ForEach<ICXMakeOfferOpenKey, TxidPairKey, uint8_t>(callback, TxidPairKey{txid, {}});
 }
 
-void CICXOrderView::ForEachICXMakeOfferClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & txid)
-{
+void CICXOrderView::ForEachICXMakeOfferClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                             const uint256 &txid) {
     ForEach<ICXMakeOfferCloseKey, TxidPairKey, uint8_t>(callback, TxidPairKey{txid, {}});
 }
 
-void CICXOrderView::ForEachICXMakeOfferExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height)
-{
+void CICXOrderView::ForEachICXMakeOfferExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                              const uint32_t &height) {
     ForEach<ICXOfferStatus, StatusKey, uint8_t>(callback, StatusKey{height, {}});
 }
 
-std::unique_ptr<CICXOrderView::CICXMakeOfferImpl> CICXOrderView::HasICXMakeOfferOpen(uint256 const & ordertxid, uint256 const & offertxid)
-{
+std::unique_ptr<CICXOrderView::CICXMakeOfferImpl> CICXOrderView::HasICXMakeOfferOpen(const uint256 &ordertxid,
+                                                                                     const uint256 &offertxid) {
     auto it = LowerBound<ICXMakeOfferOpenKey>(TxidPairKey{ordertxid, offertxid});
     if (it.Valid() && it.Key().first == ordertxid && it.Key().second == offertxid)
         return GetICXMakeOfferByCreationTx(it.Key().second);
     return {};
 }
 
-std::unique_ptr<CICXOrderView::CICXSubmitDFCHTLCImpl> CICXOrderView::GetICXSubmitDFCHTLCByCreationTx(uint256 const & txid) const
-{
-    auto submitdfchtlc = ReadBy<ICXSubmitDFCHTLCCreationTx,CICXSubmitDFCHTLCImpl>(txid);
+std::unique_ptr<CICXOrderView::CICXSubmitDFCHTLCImpl> CICXOrderView::GetICXSubmitDFCHTLCByCreationTx(
+    const uint256 &txid) const {
+    auto submitdfchtlc = ReadBy<ICXSubmitDFCHTLCCreationTx, CICXSubmitDFCHTLCImpl>(txid);
     if (submitdfchtlc)
         return std::make_unique<CICXSubmitDFCHTLCImpl>(*submitdfchtlc);
     return {};
 }
 
-Res CICXOrderView::ICXSubmitDFCHTLC(CICXSubmitDFCHTLCImpl const & submitdfchtlc)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXSubmitDFCHTLC(const CICXSubmitDFCHTLCImpl &submitdfchtlc) {
+    // this should not happen, but for sure
     if (GetICXSubmitDFCHTLCByCreationTx(submitdfchtlc.creationTx))
         return Res::Err("submitdfchtlc with creation tx %s already exists!", submitdfchtlc.creationTx.GetHex());
     if (submitdfchtlc.amount == 0)
@@ -231,50 +221,54 @@ Res CICXOrderView::ICXSubmitDFCHTLC(CICXSubmitDFCHTLCImpl const & submitdfchtlc)
         return Res::Err("Invalid timeout, must be greater than 0!");
 
     WriteBy<ICXSubmitDFCHTLCCreationTx>(submitdfchtlc.creationTx, submitdfchtlc);
-    WriteBy<ICXSubmitDFCHTLCOpenKey>(TxidPairKey(submitdfchtlc.offerTx, submitdfchtlc.creationTx), CICXSubmitDFCHTLC::STATUS_OPEN);
-    WriteBy<ICXSubmitDFCHTLCStatus>(StatusKey(submitdfchtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitdfchtlc.creationTx), CICXSubmitDFCHTLC::STATUS_EXPIRED);
-    WriteBy<ICXSubmitDFCHTLCStatus>(StatusKey(submitdfchtlc.creationHeight + submitdfchtlc.timeout, submitdfchtlc.creationTx), CICXSubmitDFCHTLC::STATUS_REFUNDED);
+    WriteBy<ICXSubmitDFCHTLCOpenKey>(TxidPairKey(submitdfchtlc.offerTx, submitdfchtlc.creationTx),
+                                     CICXSubmitDFCHTLC::STATUS_OPEN);
+    WriteBy<ICXSubmitDFCHTLCStatus>(
+        StatusKey(submitdfchtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitdfchtlc.creationTx),
+        CICXSubmitDFCHTLC::STATUS_EXPIRED);
+    WriteBy<ICXSubmitDFCHTLCStatus>(
+        StatusKey(submitdfchtlc.creationHeight + submitdfchtlc.timeout, submitdfchtlc.creationTx),
+        CICXSubmitDFCHTLC::STATUS_REFUNDED);
 
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXCloseDFCHTLC(CICXSubmitDFCHTLCImpl const & submitdfchtlc, uint8_t const status)
-{
+Res CICXOrderView::ICXCloseDFCHTLC(const CICXSubmitDFCHTLCImpl &submitdfchtlc, const uint8_t status) {
     WriteBy<ICXSubmitDFCHTLCCreationTx>(submitdfchtlc.creationTx, submitdfchtlc);
     EraseBy<ICXSubmitDFCHTLCOpenKey>(TxidPairKey(submitdfchtlc.offerTx, submitdfchtlc.creationTx));
     WriteBy<ICXSubmitDFCHTLCCloseKey>(TxidPairKey(submitdfchtlc.offerTx, submitdfchtlc.creationTx), status);
 
-    EraseBy<ICXSubmitDFCHTLCStatus>(StatusKey(submitdfchtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitdfchtlc.creationTx));
-    EraseBy<ICXSubmitDFCHTLCStatus>(StatusKey(submitdfchtlc.creationHeight + submitdfchtlc.timeout, submitdfchtlc.creationTx));
+    EraseBy<ICXSubmitDFCHTLCStatus>(StatusKey(
+        submitdfchtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitdfchtlc.creationTx));
+    EraseBy<ICXSubmitDFCHTLCStatus>(
+        StatusKey(submitdfchtlc.creationHeight + submitdfchtlc.timeout, submitdfchtlc.creationTx));
 
     return Res::Ok();
 }
 
-void CICXOrderView::ForEachICXSubmitDFCHTLCOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid)
-{
+void CICXOrderView::ForEachICXSubmitDFCHTLCOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                                const uint256 &offertxid) {
     ForEach<ICXSubmitDFCHTLCOpenKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
 }
 
-void CICXOrderView::ForEachICXSubmitDFCHTLCClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid)
-{
+void CICXOrderView::ForEachICXSubmitDFCHTLCClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                                 const uint256 &offertxid) {
     ForEach<ICXSubmitDFCHTLCCloseKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
 }
 
-void CICXOrderView::ForEachICXSubmitDFCHTLCExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height)
-{
+void CICXOrderView::ForEachICXSubmitDFCHTLCExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                                  const uint32_t &height) {
     ForEach<ICXSubmitDFCHTLCStatus, StatusKey, uint8_t>(callback, StatusKey{height, {}});
 }
 
-std::unique_ptr<CICXOrderView::CICXSubmitDFCHTLCImpl> CICXOrderView::HasICXSubmitDFCHTLCOpen(uint256 const & offertxid)
-{
+std::unique_ptr<CICXOrderView::CICXSubmitDFCHTLCImpl> CICXOrderView::HasICXSubmitDFCHTLCOpen(const uint256 &offertxid) {
     auto it = LowerBound<ICXSubmitDFCHTLCOpenKey>(TxidPairKey{offertxid, {}});
     if (it.Valid() && it.Key().first == offertxid)
         return GetICXSubmitDFCHTLCByCreationTx(it.Key().second);
     return {};
 }
 
-bool CICXOrderView::ExistedICXSubmitDFCHTLC(uint256 const & offertxid, bool isPreEunosPaya)
-{
+bool CICXOrderView::ExistedICXSubmitDFCHTLC(const uint256 &offertxid, bool isPreEunosPaya) {
     bool result = false;
 
     if (HasICXSubmitDFCHTLCOpen(offertxid))
@@ -288,17 +282,16 @@ bool CICXOrderView::ExistedICXSubmitDFCHTLC(uint256 const & offertxid, bool isPr
     return (result);
 }
 
-std::unique_ptr<CICXOrderView::CICXSubmitEXTHTLCImpl> CICXOrderView::GetICXSubmitEXTHTLCByCreationTx(const uint256 & txid) const
-{
-    auto submitexthtlc = ReadBy<ICXSubmitEXTHTLCCreationTx,CICXSubmitEXTHTLCImpl>(txid);
+std::unique_ptr<CICXOrderView::CICXSubmitEXTHTLCImpl> CICXOrderView::GetICXSubmitEXTHTLCByCreationTx(
+    const uint256 &txid) const {
+    auto submitexthtlc = ReadBy<ICXSubmitEXTHTLCCreationTx, CICXSubmitEXTHTLCImpl>(txid);
     if (submitexthtlc)
         return std::make_unique<CICXSubmitEXTHTLCImpl>(*submitexthtlc);
     return {};
 }
 
-Res CICXOrderView::ICXSubmitEXTHTLC(CICXSubmitEXTHTLCImpl const & submitexthtlc)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXSubmitEXTHTLC(const CICXSubmitEXTHTLCImpl &submitexthtlc) {
+    // this should not happen, but for sure
     if (GetICXSubmitEXTHTLCByCreationTx(submitexthtlc.creationTx))
         return Res::Err("submitexthtlc with creation tx %s already exists!", submitexthtlc.creationTx.GetHex());
     if (submitexthtlc.amount == 0)
@@ -313,46 +306,47 @@ Res CICXOrderView::ICXSubmitEXTHTLC(CICXSubmitEXTHTLCImpl const & submitexthtlc)
         return Res::Err("Invalid timout, must be greater than 0!");
 
     WriteBy<ICXSubmitEXTHTLCCreationTx>(submitexthtlc.creationTx, submitexthtlc);
-    WriteBy<ICXSubmitEXTHTLCOpenKey>(TxidPairKey(submitexthtlc.offerTx, submitexthtlc.creationTx), CICXSubmitEXTHTLC::STATUS_OPEN);
-    WriteBy<ICXSubmitEXTHTLCStatus>(StatusKey(submitexthtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitexthtlc.creationTx), CICXSubmitEXTHTLC::STATUS_EXPIRED);
+    WriteBy<ICXSubmitEXTHTLCOpenKey>(TxidPairKey(submitexthtlc.offerTx, submitexthtlc.creationTx),
+                                     CICXSubmitEXTHTLC::STATUS_OPEN);
+    WriteBy<ICXSubmitEXTHTLCStatus>(
+        StatusKey(submitexthtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitexthtlc.creationTx),
+        CICXSubmitEXTHTLC::STATUS_EXPIRED);
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXCloseEXTHTLC(CICXSubmitEXTHTLCImpl const & submitexthtlc, uint8_t const status)
-{
+Res CICXOrderView::ICXCloseEXTHTLC(const CICXSubmitEXTHTLCImpl &submitexthtlc, const uint8_t status) {
     WriteBy<ICXSubmitEXTHTLCCreationTx>(submitexthtlc.creationTx, submitexthtlc);
     EraseBy<ICXSubmitEXTHTLCOpenKey>(TxidPairKey(submitexthtlc.offerTx, submitexthtlc.creationTx));
     WriteBy<ICXSubmitEXTHTLCCloseKey>(TxidPairKey(submitexthtlc.offerTx, submitexthtlc.creationTx), status);
-    EraseBy<ICXSubmitEXTHTLCStatus>(StatusKey(submitexthtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitexthtlc.creationTx));
+    EraseBy<ICXSubmitEXTHTLCStatus>(StatusKey(
+        submitexthtlc.creationHeight + CICXMakeOffer::MAKER_DEPOSIT_REFUND_TIMEOUT, submitexthtlc.creationTx));
 
     return Res::Ok();
 }
 
-void CICXOrderView::ForEachICXSubmitEXTHTLCOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid)
-{
-    ForEach<ICXSubmitEXTHTLCOpenKey,TxidPairKey,uint8_t>(callback, TxidPairKey{offertxid, {}});
+void CICXOrderView::ForEachICXSubmitEXTHTLCOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                                const uint256 &offertxid) {
+    ForEach<ICXSubmitEXTHTLCOpenKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
 }
 
-void CICXOrderView::ForEachICXSubmitEXTHTLCClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid)
-{
+void CICXOrderView::ForEachICXSubmitEXTHTLCClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                                 const uint256 &offertxid) {
     ForEach<ICXSubmitEXTHTLCCloseKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
 }
 
-void CICXOrderView::ForEachICXSubmitEXTHTLCExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height)
-{
+void CICXOrderView::ForEachICXSubmitEXTHTLCExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                                  const uint32_t &height) {
     ForEach<ICXSubmitEXTHTLCStatus, StatusKey, uint8_t>(callback, StatusKey{height, {}});
 }
 
-std::unique_ptr<CICXOrderView::CICXSubmitEXTHTLCImpl> CICXOrderView::HasICXSubmitEXTHTLCOpen(uint256 const & offertxid)
-{
+std::unique_ptr<CICXOrderView::CICXSubmitEXTHTLCImpl> CICXOrderView::HasICXSubmitEXTHTLCOpen(const uint256 &offertxid) {
     auto it = LowerBound<ICXSubmitEXTHTLCOpenKey>(TxidPairKey{offertxid, {}});
     if (it.Valid() && it.Key().first == offertxid)
         return GetICXSubmitEXTHTLCByCreationTx(it.Key().second);
     return {};
 }
 
-bool CICXOrderView::ExistedICXSubmitEXTHTLC(uint256 const & offertxid, bool isPreEunosPaya)
-{
+bool CICXOrderView::ExistedICXSubmitEXTHTLC(const uint256 &offertxid, bool isPreEunosPaya) {
     bool result = false;
 
     if (HasICXSubmitEXTHTLCOpen(offertxid))
@@ -366,22 +360,23 @@ bool CICXOrderView::ExistedICXSubmitEXTHTLC(uint256 const & offertxid, bool isPr
     return (result);
 }
 
-std::unique_ptr<CICXOrderView::CICXClaimDFCHTLCImpl> CICXOrderView::GetICXClaimDFCHTLCByCreationTx(uint256 const & txid) const
-{
-    auto claimdfchtlc = ReadBy<ICXClaimDFCHTLCCreationTx,CICXClaimDFCHTLCImpl>(txid);
+std::unique_ptr<CICXOrderView::CICXClaimDFCHTLCImpl> CICXOrderView::GetICXClaimDFCHTLCByCreationTx(
+    const uint256 &txid) const {
+    auto claimdfchtlc = ReadBy<ICXClaimDFCHTLCCreationTx, CICXClaimDFCHTLCImpl>(txid);
     if (claimdfchtlc)
         return std::make_unique<CICXClaimDFCHTLCImpl>(*claimdfchtlc);
     return {};
 }
 
-Res CICXOrderView::ICXClaimDFCHTLC(CICXClaimDFCHTLCImpl const & claimdfchtlc, uint256 const & offertxid, CICXOrderImpl const & order)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXClaimDFCHTLC(const CICXClaimDFCHTLCImpl &claimdfchtlc,
+                                   const uint256 &offertxid,
+                                   const CICXOrderImpl &order) {
+    // this should not happen, but for sure
     if (GetICXClaimDFCHTLCByCreationTx(claimdfchtlc.creationTx))
         return Res::Err("claimdfchtlc with creation tx %s already exists!", claimdfchtlc.creationTx.GetHex());
 
     WriteBy<ICXClaimDFCHTLCCreationTx>(claimdfchtlc.creationTx, claimdfchtlc);
-    WriteBy<ICXClaimDFCHTLCKey>(TxidPairKey(offertxid, claimdfchtlc.creationTx),CICXSubmitDFCHTLC::STATUS_CLAIMED);
+    WriteBy<ICXClaimDFCHTLCKey>(TxidPairKey(offertxid, claimdfchtlc.creationTx), CICXSubmitDFCHTLC::STATUS_CLAIMED);
 
     if (order.amountToFill != 0)
         WriteBy<ICXOrderCreationTx>(order.creationTx, order);
@@ -389,22 +384,21 @@ Res CICXOrderView::ICXClaimDFCHTLC(CICXClaimDFCHTLCImpl const & claimdfchtlc, ui
     return Res::Ok();
 }
 
-void CICXOrderView::ForEachICXClaimDFCHTLC(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid)
-{
-     ForEach<ICXClaimDFCHTLCKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
+void CICXOrderView::ForEachICXClaimDFCHTLC(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                           const uint256 &offertxid) {
+    ForEach<ICXClaimDFCHTLCKey, TxidPairKey, uint8_t>(callback, TxidPairKey{offertxid, {}});
 }
 
-std::unique_ptr<CICXOrderView::CICXCloseOrderImpl> CICXOrderView::GetICXCloseOrderByCreationTx(uint256 const & txid) const
-{
+std::unique_ptr<CICXOrderView::CICXCloseOrderImpl> CICXOrderView::GetICXCloseOrderByCreationTx(
+    const uint256 &txid) const {
     auto closeorderImpl = ReadBy<ICXCloseOrderCreationTx, CICXCloseOrderImpl>(txid);
     if (closeorderImpl)
         return std::make_unique<CICXCloseOrderImpl>(*closeorderImpl);
     return {};
 }
 
-Res CICXOrderView::ICXCloseOrder(CICXCloseOrderImpl const & closeorder)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXCloseOrder(const CICXCloseOrderImpl &closeorder) {
+    // this should not happen, but for sure
     if (GetICXCloseOrderByCreationTx(closeorder.creationTx))
         return Res::Err("closeorder with creation tx %s already exists!", closeorder.creationTx.GetHex());
 
@@ -413,17 +407,16 @@ Res CICXOrderView::ICXCloseOrder(CICXCloseOrderImpl const & closeorder)
     return Res::Ok();
 }
 
-std::unique_ptr<CICXOrderView::CICXCloseOfferImpl> CICXOrderView::GetICXCloseOfferByCreationTx(uint256 const & txid) const
-{
+std::unique_ptr<CICXOrderView::CICXCloseOfferImpl> CICXOrderView::GetICXCloseOfferByCreationTx(
+    const uint256 &txid) const {
     auto closeofferImpl = ReadBy<ICXCloseOfferCreationTx, CICXCloseOfferImpl>(txid);
     if (closeofferImpl)
         return std::make_unique<CICXCloseOfferImpl>(*closeofferImpl);
     return {};
 }
 
-Res CICXOrderView::ICXCloseOffer(CICXCloseOfferImpl const & closeoffer)
-{
-    //this should not happen, but for sure
+Res CICXOrderView::ICXCloseOffer(const CICXCloseOfferImpl &closeoffer) {
+    // this should not happen, but for sure
     if (GetICXCloseOrderByCreationTx(closeoffer.creationTx))
         return Res::Err("closeooffer with creation tx %s already exists!", closeoffer.creationTx.GetHex());
 
@@ -432,22 +425,19 @@ Res CICXOrderView::ICXCloseOffer(CICXCloseOfferImpl const & closeoffer)
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXSetTakerFeePerBTC(CAmount amount)
-{
+Res CICXOrderView::ICXSetTakerFeePerBTC(CAmount amount) {
     WriteBy<ICXVariables>('A', amount);
 
     return Res::Ok();
 }
 
-Res CICXOrderView::ICXEraseTakerFeePerBTC()
-{
+Res CICXOrderView::ICXEraseTakerFeePerBTC() {
     EraseBy<ICXVariables>('A');
 
     return Res::Ok();
 }
 
-CAmount CICXOrderView::ICXGetTakerFeePerBTC()
-{
+CAmount CICXOrderView::ICXGetTakerFeePerBTC() {
     CAmount takerFeePerBTC = CICXMakeOffer::DEFAULT_TAKER_FEE_PER_BTC;
 
     auto fee = ReadBy<ICXVariables, CAmount>('A');
diff --git a/src/masternodes/icxorder.h b/src/masternodes/icxorder.h
index a1e014c453..d8fe7ebc7f 100644
--- a/src/masternodes/icxorder.h
+++ b/src/masternodes/icxorder.h
@@ -5,38 +5,37 @@
 
 #include <amount.h>
 #include <pubkey.h>
-#include <uint256.h>
 #include <script/script.h>
+#include <uint256.h>
 
 #include <flushablestorage.h>
 #include <masternodes/res.h>
 
-class CICXOrder
-{
+class CICXOrder {
 public:
-    static const uint32_t DEFAULT_EXPIRY; // default period in blocks after order automatically expires
-    static const uint8_t TYPE_INTERNAL; // type for DFI/BTC orders
-    static const uint8_t TYPE_EXTERNAL; // type for BTC/DFI orders
+    static const uint32_t DEFAULT_EXPIRY;  // default period in blocks after order automatically expires
+    static const uint8_t TYPE_INTERNAL;    // type for DFI/BTC orders
+    static const uint8_t TYPE_EXTERNAL;    // type for BTC/DFI orders
     static const uint8_t STATUS_OPEN;
-    static const uint8_t STATUS_CLOSED; // manually close status
-    static const uint8_t STATUS_FILLED; // completely filled status
-    static const uint8_t STATUS_EXPIRED; // offer expired status
+    static const uint8_t STATUS_CLOSED;   // manually close status
+    static const uint8_t STATUS_FILLED;   // completely filled status
+    static const uint8_t STATUS_EXPIRED;  // offer expired status
     static const std::string CHAIN_BTC;
-    static const std::string TOKEN_BTC; // name of BTC token on DFC
+    static const std::string TOKEN_BTC;  // name of BTC token on DFC
 
-    uint8_t orderType = 0; //is maker buying or selling DFC asset to know which htlc to come first
-    DCT_ID idToken{UINT_MAX}; // used for DFT/BTC
-    CScript ownerAddress; //address for DFI token for fees, and in case of DFC/BTC order for DFC asset
-    CPubKey receivePubkey; // address of BTC pubkey in case of BTC/DFC order
-    CAmount amountFrom = 0; // amount of asset that is sold
-    CAmount amountToFill = 0; // how much is left to fill the order
-    CAmount orderPrice = 0; // price of asset buying in asset selling
-    uint32_t expiry = DEFAULT_EXPIRY; // when the order exipres in number of blocks
+    uint8_t orderType = 0;     // is maker buying or selling DFC asset to know which htlc to come first
+    DCT_ID idToken{UINT_MAX};  // used for DFT/BTC
+    CScript ownerAddress;      // address for DFI token for fees, and in case of DFC/BTC order for DFC asset
+    CPubKey receivePubkey;     // address of BTC pubkey in case of BTC/DFC order
+    CAmount amountFrom   = 0;  // amount of asset that is sold
+    CAmount amountToFill = 0;  // how much is left to fill the order
+    CAmount orderPrice   = 0;  // price of asset buying in asset selling
+    uint32_t expiry      = DEFAULT_EXPIRY;  // when the order exipres in number of blocks
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(orderType);
         READWRITE(idToken);
         READWRITE(ownerAddress);
@@ -48,18 +47,17 @@ class CICXOrder
     }
 };
 
-class CICXOrderImplemetation : public CICXOrder
-{
+class CICXOrderImplemetation : public CICXOrder {
 public:
     uint256 creationTx;
     uint256 closeTx;
     int32_t creationHeight = -1;
-    int32_t closeHeight = -1;
+    int32_t closeHeight    = -1;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXOrder, *this);
         READWRITE(creationTx);
         READWRITE(closeTx);
@@ -73,33 +71,33 @@ struct CICXCreateOrderMessage : public CICXOrder {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXOrder, *this);
     }
 };
 
-class CICXMakeOffer
-{
+class CICXMakeOffer {
 public:
-    static const uint32_t DEFAULT_EXPIRY; // default period in blocks after offer automatically expires
+    static const uint32_t DEFAULT_EXPIRY;  // default period in blocks after offer automatically expires
     static const uint32_t EUNOSPAYA_DEFAULT_EXPIRY;
-    static const uint32_t MAKER_DEPOSIT_REFUND_TIMEOUT; // minimum period in DFC blocks in which 2nd HTLC must be created, otherwise makerDeposit is refunded to maker
+    static const uint32_t MAKER_DEPOSIT_REFUND_TIMEOUT;  // minimum period in DFC blocks in which 2nd HTLC must be
+                                                         // created, otherwise makerDeposit is refunded to maker
     static const uint8_t STATUS_OPEN;
     static const uint8_t STATUS_CLOSED;
     static const uint8_t STATUS_EXPIRED;
     static const int64_t DEFAULT_TAKER_FEE_PER_BTC;
 
-    uint256 orderTx; // txid for which order is the offer
-    CAmount amount = 0; // amount of asset to swap
-    CScript ownerAddress; //address for DFI token for fees, and in case of BTC/DFC order for DFC asset
-    CPubKey receivePubkey; // address or BTC pubkey in case of DFC/BTC order
-    uint32_t expiry = 0; // when the offer exipres in number of blocks
+    uint256 orderTx;        // txid for which order is the offer
+    CAmount amount = 0;     // amount of asset to swap
+    CScript ownerAddress;   // address for DFI token for fees, and in case of BTC/DFC order for DFC asset
+    CPubKey receivePubkey;  // address or BTC pubkey in case of DFC/BTC order
+    uint32_t expiry  = 0;   // when the offer exipres in number of blocks
     CAmount takerFee = 0;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(orderTx);
         READWRITE(amount);
         READWRITE(ownerAddress);
@@ -109,18 +107,17 @@ class CICXMakeOffer
     }
 };
 
-class CICXMakeOfferImplemetation : public CICXMakeOffer
-{
+class CICXMakeOfferImplemetation : public CICXMakeOffer {
 public:
     uint256 creationTx;
     uint256 closeTx;
     int32_t creationHeight = -1;
-    int32_t closeHeight = -1;
+    int32_t closeHeight    = -1;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXMakeOffer, *this);
         READWRITE(creationTx);
         READWRITE(closeTx);
@@ -134,33 +131,35 @@ struct CICXMakeOfferMessage : public CICXMakeOffer {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXMakeOffer, *this);
     }
 };
 
-class CICXSubmitDFCHTLC
-{
+class CICXSubmitDFCHTLC {
 public:
-    static const uint32_t MINIMUM_TIMEOUT; // minimum period in blocks after htlc automatically timeouts and funds are returned to owner when it is first htlc
+    static const uint32_t MINIMUM_TIMEOUT;  // minimum period in blocks after htlc automatically timeouts and funds are
+                                            // returned to owner when it is first htlc
     static const uint32_t EUNOSPAYA_MINIMUM_TIMEOUT;
-    static const uint32_t MINIMUM_2ND_TIMEOUT; // minimum period in blocks after htlc automatically timeouts and funds are returned to owner when it is second htlc
+    static const uint32_t MINIMUM_2ND_TIMEOUT;  // minimum period in blocks after htlc automatically timeouts and funds
+                                                // are returned to owner when it is second htlc
     static const uint32_t EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
     static const uint8_t STATUS_OPEN;
     static const uint8_t STATUS_CLAIMED;
     static const uint8_t STATUS_REFUNDED;
     static const uint8_t STATUS_EXPIRED;
 
-    // This tx is acceptance of the offer, HTLC tx and evidence of HTLC on DFC in the same time. It is a CustomTx on DFC chain
-    uint256 offerTx; // txid for which offer is this HTLC
-    CAmount amount = 0; // amount that is put in HTLC
-    uint256 hash; // hash for the hash lock part
-    uint32_t timeout = 0; // timeout (absolute in blocks) for timelock part
+    // This tx is acceptance of the offer, HTLC tx and evidence of HTLC on DFC in the same time. It is a CustomTx on DFC
+    // chain
+    uint256 offerTx;       // txid for which offer is this HTLC
+    CAmount amount = 0;    // amount that is put in HTLC
+    uint256 hash;          // hash for the hash lock part
+    uint32_t timeout = 0;  // timeout (absolute in blocks) for timelock part
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(offerTx);
         READWRITE(amount);
         READWRITE(hash);
@@ -168,8 +167,7 @@ class CICXSubmitDFCHTLC
     }
 };
 
-class CICXSubmitDFCHTLCImplemetation : public CICXSubmitDFCHTLC
-{
+class CICXSubmitDFCHTLCImplemetation : public CICXSubmitDFCHTLC {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -177,7 +175,7 @@ class CICXSubmitDFCHTLCImplemetation : public CICXSubmitDFCHTLC
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXSubmitDFCHTLC, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -189,26 +187,26 @@ struct CICXSubmitDFCHTLCMessage : public CICXSubmitDFCHTLC {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXSubmitDFCHTLC, *this);
     }
 };
 
-class CICXSubmitEXTHTLC
-{
+class CICXSubmitEXTHTLC {
 public:
-    static const uint32_t MINIMUM_TIMEOUT; // default period in blocks after htlc timeouts when it is first htlc
+    static const uint32_t MINIMUM_TIMEOUT;  // default period in blocks after htlc timeouts when it is first htlc
     static const uint32_t EUNOSPAYA_MINIMUM_TIMEOUT;
-    static const uint32_t MINIMUM_2ND_TIMEOUT; // default period in blocks after htlc timeouts when it is second htlc
+    static const uint32_t MINIMUM_2ND_TIMEOUT;  // default period in blocks after htlc timeouts when it is second htlc
     static const uint32_t EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
-    static const uint32_t BTC_BLOCKS_IN_DFI_BLOCKS; // number of BTC blocks in DFI blocks period
-    static const uint32_t EUNOSPAYA_BTC_BLOCKS_IN_DFI_BLOCKS; // number of BTC blocks in DFI blocks period
+    static const uint32_t BTC_BLOCKS_IN_DFI_BLOCKS;            // number of BTC blocks in DFI blocks period
+    static const uint32_t EUNOSPAYA_BTC_BLOCKS_IN_DFI_BLOCKS;  // number of BTC blocks in DFI blocks period
     static const uint8_t STATUS_OPEN;
     static const uint8_t STATUS_CLOSED;
     static const uint8_t STATUS_EXPIRED;
 
-    // This tx is acceptance of the offer and evidence of HTLC on external chain in the same time. It is a CustomTx on DFC chain
-    uint256 offerTx; // txid for which offer is this HTLC
+    // This tx is acceptance of the offer and evidence of HTLC on external chain in the same time. It is a CustomTx on
+    // DFC chain
+    uint256 offerTx;  // txid for which offer is this HTLC
     CAmount amount = 0;
     uint256 hash;
     std::string htlcscriptAddress;
@@ -218,7 +216,7 @@ class CICXSubmitEXTHTLC
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(offerTx);
         READWRITE(amount);
         READWRITE(hash);
@@ -228,8 +226,7 @@ class CICXSubmitEXTHTLC
     }
 };
 
-class CICXSubmitEXTHTLCImplemetation : public CICXSubmitEXTHTLC
-{
+class CICXSubmitEXTHTLCImplemetation : public CICXSubmitEXTHTLC {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -237,7 +234,7 @@ class CICXSubmitEXTHTLCImplemetation : public CICXSubmitEXTHTLC
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXSubmitEXTHTLC, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -249,28 +246,26 @@ struct CICXSubmitEXTHTLCMessage : public CICXSubmitEXTHTLC {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXSubmitEXTHTLC, *this);
     }
 };
 
-class CICXClaimDFCHTLC
-{
+class CICXClaimDFCHTLC {
 public:
-    uint256 dfchtlcTx; // txid of claiming DFC HTLC
-    std::vector<unsigned char> seed; // secret for the hash to claim htlc
+    uint256 dfchtlcTx;                // txid of claiming DFC HTLC
+    std::vector<unsigned char> seed;  // secret for the hash to claim htlc
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(dfchtlcTx);
         READWRITE(seed);
     }
 };
 
-class CICXClaimDFCHTLCImplemetation : public CICXClaimDFCHTLC
-{
+class CICXClaimDFCHTLCImplemetation : public CICXClaimDFCHTLC {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -278,7 +273,7 @@ class CICXClaimDFCHTLCImplemetation : public CICXClaimDFCHTLC
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXClaimDFCHTLC, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -290,26 +285,24 @@ struct CICXClaimDFCHTLCMessage : public CICXClaimDFCHTLC {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXClaimDFCHTLC, *this);
     }
 };
 
-class CICXCloseOrder
-{
+class CICXCloseOrder {
 public:
-    uint256 orderTx; //txid of order which will be closed
+    uint256 orderTx;  // txid of order which will be closed
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(orderTx);
     }
 };
 
-class CICXCloseOrderImplemetation : public CICXCloseOrder
-{
+class CICXCloseOrderImplemetation : public CICXCloseOrder {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -317,7 +310,7 @@ class CICXCloseOrderImplemetation : public CICXCloseOrder
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXCloseOrder, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -329,26 +322,24 @@ struct CICXCloseOrderMessage : public CICXCloseOrder {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXCloseOrder, *this);
     }
 };
 
-class CICXCloseOffer
-{
+class CICXCloseOffer {
 public:
-    uint256 offerTx; //txid of offer which will be closed
+    uint256 offerTx;  // txid of offer which will be closed
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(offerTx);
     }
 };
 
-class CICXCloseOfferImplemetation : public CICXCloseOffer
-{
+class CICXCloseOfferImplemetation : public CICXCloseOffer {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -356,7 +347,7 @@ class CICXCloseOfferImplemetation : public CICXCloseOffer
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXCloseOffer, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -368,7 +359,7 @@ struct CICXCloseOfferMessage : public CICXCloseOffer {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CICXCloseOffer, *this);
     }
 };
@@ -377,103 +368,154 @@ class CICXOrderView : public virtual CStorageView {
 public:
     static const CAmount DEFAULT_DFI_BTC_PRICE;
 
-    using OrderKey = std::pair<DCT_ID, uint256>;
+    using OrderKey    = std::pair<DCT_ID, uint256>;
     using TxidPairKey = std::pair<uint256, uint256>;
-    using StatusKey = std::pair<uint32_t, uint256>;
+    using StatusKey   = std::pair<uint32_t, uint256>;
 
-    using CICXOrderImpl = CICXOrderImplemetation;
-    using CICXMakeOfferImpl = CICXMakeOfferImplemetation;
+    using CICXOrderImpl         = CICXOrderImplemetation;
+    using CICXMakeOfferImpl     = CICXMakeOfferImplemetation;
     using CICXSubmitDFCHTLCImpl = CICXSubmitDFCHTLCImplemetation;
     using CICXSubmitEXTHTLCImpl = CICXSubmitEXTHTLCImplemetation;
-    using CICXClaimDFCHTLCImpl = CICXClaimDFCHTLCImplemetation;
-    using CICXCloseOrderImpl = CICXCloseOrderImplemetation;
-    using CICXCloseOfferImpl = CICXCloseOfferImplemetation;
-
-    //Order
-    std::unique_ptr<CICXOrderImpl> GetICXOrderByCreationTx(uint256 const & txid) const;
-    uint8_t GetICXOrderStatus(OrderKey const & key) const;
-    Res ICXCreateOrder(CICXOrderImpl const & order);
-    Res ICXUpdateOrder(CICXOrderImpl const & order);
-    Res ICXCloseOrderTx(CICXOrderImpl const & order, uint8_t const);
-    void ForEachICXOrderOpen(std::function<bool (OrderKey const &, uint8_t)> callback, DCT_ID const & pair = {0});
-    void ForEachICXOrderClose(std::function<bool (OrderKey const &, uint8_t)> callback, DCT_ID const & pair = {0});
-    void ForEachICXOrderExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height = 0);
-    std::unique_ptr<CICXOrderImpl> HasICXOrderOpen(DCT_ID const & tokenId, uint256 const & ordertxid);
-
-    //MakeOffer
-    std::unique_ptr<CICXMakeOfferImpl> GetICXMakeOfferByCreationTx(uint256 const & txid) const;
-    uint8_t GetICXMakeOfferStatus(TxidPairKey const & key) const;
-    Res ICXMakeOffer(CICXMakeOfferImpl const & makeoffer);
-    Res ICXUpdateMakeOffer(CICXMakeOfferImpl const & makeoffer);
-    Res ICXCloseMakeOfferTx(CICXMakeOfferImpl const & order, uint8_t const);
-    void ForEachICXMakeOfferOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & ordertxid = uint256());
-    void ForEachICXMakeOfferClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & ordertxid = uint256());
-    void ForEachICXMakeOfferExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height = 0);
-    std::unique_ptr<CICXMakeOfferImpl> HasICXMakeOfferOpen(uint256 const & ordertxid, uint256 const & offertxid);
-
-    //SubmitDFCHTLC
-    std::unique_ptr<CICXSubmitDFCHTLCImpl> GetICXSubmitDFCHTLCByCreationTx(uint256 const & txid) const;
-    Res ICXSubmitDFCHTLC(CICXSubmitDFCHTLCImpl const & dfchtlc);
-    Res ICXCloseDFCHTLC(CICXSubmitDFCHTLCImpl const & dfchtlc, uint8_t const);
-    void ForEachICXSubmitDFCHTLCOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid = uint256());
-    void ForEachICXSubmitDFCHTLCClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid = uint256());
-    void ForEachICXSubmitDFCHTLCExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height = 0);
-    std::unique_ptr<CICXSubmitDFCHTLCImpl> HasICXSubmitDFCHTLCOpen(uint256 const & offertxid);
-    bool ExistedICXSubmitDFCHTLC(uint256 const & offertxid, bool isPreEunosPaya);
-
-
-    //SubmitEXTHTLC
-    std::unique_ptr<CICXSubmitEXTHTLCImpl> GetICXSubmitEXTHTLCByCreationTx(uint256 const & txid) const;
-    Res ICXSubmitEXTHTLC(CICXSubmitEXTHTLCImpl const & dfchtlc);
-    Res ICXCloseEXTHTLC(CICXSubmitEXTHTLCImpl const & exthtlc, uint8_t const);
-    void ForEachICXSubmitEXTHTLCOpen(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid = uint256());
-    void ForEachICXSubmitEXTHTLCClose(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid = uint256());
-    void ForEachICXSubmitEXTHTLCExpire(std::function<bool (StatusKey const &, uint8_t)> callback, uint32_t const & height = 0);
-    std::unique_ptr<CICXSubmitEXTHTLCImpl> HasICXSubmitEXTHTLCOpen(uint256 const & offertxid);
-    bool ExistedICXSubmitEXTHTLC(uint256 const & offertxid, bool isPreEunosPaya);
-
-    //ClaimDFCHTLC
-    std::unique_ptr<CICXClaimDFCHTLCImpl> GetICXClaimDFCHTLCByCreationTx(uint256 const & txid) const;
-    Res ICXClaimDFCHTLC(CICXClaimDFCHTLCImpl const & claimdfchtlc, uint256 const & offertxid, CICXOrderImpl const & order);
-    void ForEachICXClaimDFCHTLC(std::function<bool (TxidPairKey const &, uint8_t)> callback, uint256 const & offertxid = uint256());
-
-    //CloseOrder
-    std::unique_ptr<CICXCloseOrderImpl> GetICXCloseOrderByCreationTx(uint256 const & txid) const;
-    Res ICXCloseOrder(CICXCloseOrderImpl const & closeorder);
-
-    //CloseOrder
-    std::unique_ptr<CICXCloseOfferImpl> GetICXCloseOfferByCreationTx(uint256 const & txid) const;
-    Res ICXCloseOffer(CICXCloseOfferImpl const & closeoffer);
+    using CICXClaimDFCHTLCImpl  = CICXClaimDFCHTLCImplemetation;
+    using CICXCloseOrderImpl    = CICXCloseOrderImplemetation;
+    using CICXCloseOfferImpl    = CICXCloseOfferImplemetation;
+
+    // Order
+    std::unique_ptr<CICXOrderImpl> GetICXOrderByCreationTx(const uint256 &txid) const;
+    uint8_t GetICXOrderStatus(const OrderKey &key) const;
+    Res ICXCreateOrder(const CICXOrderImpl &order);
+    Res ICXUpdateOrder(const CICXOrderImpl &order);
+    Res ICXCloseOrderTx(const CICXOrderImpl &order, uint8_t const);
+    void ForEachICXOrderOpen(std::function<bool(const OrderKey &, uint8_t)> callback, DCT_ID const &pair = {0});
+    void ForEachICXOrderClose(std::function<bool(const OrderKey &, uint8_t)> callback, DCT_ID const &pair = {0});
+    void ForEachICXOrderExpire(std::function<bool(const StatusKey &, uint8_t)> callback, const uint32_t &height = 0);
+    std::unique_ptr<CICXOrderImpl> HasICXOrderOpen(DCT_ID const &tokenId, const uint256 &ordertxid);
+
+    // MakeOffer
+    std::unique_ptr<CICXMakeOfferImpl> GetICXMakeOfferByCreationTx(const uint256 &txid) const;
+    uint8_t GetICXMakeOfferStatus(const TxidPairKey &key) const;
+    Res ICXMakeOffer(const CICXMakeOfferImpl &makeoffer);
+    Res ICXUpdateMakeOffer(const CICXMakeOfferImpl &makeoffer);
+    Res ICXCloseMakeOfferTx(const CICXMakeOfferImpl &order, uint8_t const);
+    void ForEachICXMakeOfferOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                 const uint256 &ordertxid = uint256());
+    void ForEachICXMakeOfferClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                  const uint256 &ordertxid = uint256());
+    void ForEachICXMakeOfferExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                   const uint32_t &height = 0);
+    std::unique_ptr<CICXMakeOfferImpl> HasICXMakeOfferOpen(const uint256 &ordertxid, const uint256 &offertxid);
+
+    // SubmitDFCHTLC
+    std::unique_ptr<CICXSubmitDFCHTLCImpl> GetICXSubmitDFCHTLCByCreationTx(const uint256 &txid) const;
+    Res ICXSubmitDFCHTLC(const CICXSubmitDFCHTLCImpl &dfchtlc);
+    Res ICXCloseDFCHTLC(const CICXSubmitDFCHTLCImpl &dfchtlc, uint8_t const);
+    void ForEachICXSubmitDFCHTLCOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                     const uint256 &offertxid = uint256());
+    void ForEachICXSubmitDFCHTLCClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                      const uint256 &offertxid = uint256());
+    void ForEachICXSubmitDFCHTLCExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                       const uint32_t &height = 0);
+    std::unique_ptr<CICXSubmitDFCHTLCImpl> HasICXSubmitDFCHTLCOpen(const uint256 &offertxid);
+    bool ExistedICXSubmitDFCHTLC(const uint256 &offertxid, bool isPreEunosPaya);
+
+    // SubmitEXTHTLC
+    std::unique_ptr<CICXSubmitEXTHTLCImpl> GetICXSubmitEXTHTLCByCreationTx(const uint256 &txid) const;
+    Res ICXSubmitEXTHTLC(const CICXSubmitEXTHTLCImpl &dfchtlc);
+    Res ICXCloseEXTHTLC(const CICXSubmitEXTHTLCImpl &exthtlc, uint8_t const);
+    void ForEachICXSubmitEXTHTLCOpen(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                     const uint256 &offertxid = uint256());
+    void ForEachICXSubmitEXTHTLCClose(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                      const uint256 &offertxid = uint256());
+    void ForEachICXSubmitEXTHTLCExpire(std::function<bool(const StatusKey &, uint8_t)> callback,
+                                       const uint32_t &height = 0);
+    std::unique_ptr<CICXSubmitEXTHTLCImpl> HasICXSubmitEXTHTLCOpen(const uint256 &offertxid);
+    bool ExistedICXSubmitEXTHTLC(const uint256 &offertxid, bool isPreEunosPaya);
+
+    // ClaimDFCHTLC
+    std::unique_ptr<CICXClaimDFCHTLCImpl> GetICXClaimDFCHTLCByCreationTx(const uint256 &txid) const;
+    Res ICXClaimDFCHTLC(const CICXClaimDFCHTLCImpl &claimdfchtlc, const uint256 &offertxid, const CICXOrderImpl &order);
+    void ForEachICXClaimDFCHTLC(std::function<bool(const TxidPairKey &, uint8_t)> callback,
+                                const uint256 &offertxid = uint256());
+
+    // CloseOrder
+    std::unique_ptr<CICXCloseOrderImpl> GetICXCloseOrderByCreationTx(const uint256 &txid) const;
+    Res ICXCloseOrder(const CICXCloseOrderImpl &closeorder);
+
+    // CloseOrder
+    std::unique_ptr<CICXCloseOfferImpl> GetICXCloseOfferByCreationTx(const uint256 &txid) const;
+    Res ICXCloseOffer(const CICXCloseOfferImpl &closeoffer);
 
     // ICX_TAKERFEE_PER_BTC
     Res ICXSetTakerFeePerBTC(CAmount amount);
     Res ICXEraseTakerFeePerBTC();
     CAmount ICXGetTakerFeePerBTC();
 
-    struct ICXOrderCreationTx         { static constexpr uint8_t prefix() { return '1'; } };
-    struct ICXMakeOfferCreationTx     { static constexpr uint8_t prefix() { return '2'; } };
-    struct ICXSubmitDFCHTLCCreationTx { static constexpr uint8_t prefix() { return '3'; } };
-    struct ICXSubmitEXTHTLCCreationTx { static constexpr uint8_t prefix() { return '4'; } };
-    struct ICXClaimDFCHTLCCreationTx  { static constexpr uint8_t prefix() { return '5'; } };
-    struct ICXCloseOrderCreationTx    { static constexpr uint8_t prefix() { return '6'; } };
-    struct ICXCloseOfferCreationTx    { static constexpr uint8_t prefix() { return '7'; } };
-
-    struct ICXOrderOpenKey            { static constexpr uint8_t prefix() { return 0x01; } };
-    struct ICXOrderCloseKey           { static constexpr uint8_t prefix() { return 0x02; } };
-    struct ICXMakeOfferOpenKey        { static constexpr uint8_t prefix() { return 0x03; } };
-    struct ICXMakeOfferCloseKey       { static constexpr uint8_t prefix() { return 0x04; } };
-    struct ICXSubmitDFCHTLCOpenKey    { static constexpr uint8_t prefix() { return 0x05; } };
-    struct ICXSubmitDFCHTLCCloseKey   { static constexpr uint8_t prefix() { return 0x06; } };
-    struct ICXSubmitEXTHTLCOpenKey    { static constexpr uint8_t prefix() { return 0x07; } };
-    struct ICXSubmitEXTHTLCCloseKey   { static constexpr uint8_t prefix() { return 0x08; } };
-    struct ICXClaimDFCHTLCKey         { static constexpr uint8_t prefix() { return 0x09; } };
-
-    struct ICXOrderStatus             { static constexpr uint8_t prefix() { return 0x0A; } };
-    struct ICXOfferStatus             { static constexpr uint8_t prefix() { return 0x0B; } };
-    struct ICXSubmitDFCHTLCStatus     { static constexpr uint8_t prefix() { return 0x0C; } };
-    struct ICXSubmitEXTHTLCStatus     { static constexpr uint8_t prefix() { return 0x0D; } };
-
-    struct ICXVariables               { static constexpr uint8_t prefix() { return 0x0F; } };
+    struct ICXOrderCreationTx {
+        static constexpr uint8_t prefix() { return '1'; }
+    };
+    struct ICXMakeOfferCreationTx {
+        static constexpr uint8_t prefix() { return '2'; }
+    };
+    struct ICXSubmitDFCHTLCCreationTx {
+        static constexpr uint8_t prefix() { return '3'; }
+    };
+    struct ICXSubmitEXTHTLCCreationTx {
+        static constexpr uint8_t prefix() { return '4'; }
+    };
+    struct ICXClaimDFCHTLCCreationTx {
+        static constexpr uint8_t prefix() { return '5'; }
+    };
+    struct ICXCloseOrderCreationTx {
+        static constexpr uint8_t prefix() { return '6'; }
+    };
+    struct ICXCloseOfferCreationTx {
+        static constexpr uint8_t prefix() { return '7'; }
+    };
+
+    struct ICXOrderOpenKey {
+        static constexpr uint8_t prefix() { return 0x01; }
+    };
+    struct ICXOrderCloseKey {
+        static constexpr uint8_t prefix() { return 0x02; }
+    };
+    struct ICXMakeOfferOpenKey {
+        static constexpr uint8_t prefix() { return 0x03; }
+    };
+    struct ICXMakeOfferCloseKey {
+        static constexpr uint8_t prefix() { return 0x04; }
+    };
+    struct ICXSubmitDFCHTLCOpenKey {
+        static constexpr uint8_t prefix() { return 0x05; }
+    };
+    struct ICXSubmitDFCHTLCCloseKey {
+        static constexpr uint8_t prefix() { return 0x06; }
+    };
+    struct ICXSubmitEXTHTLCOpenKey {
+        static constexpr uint8_t prefix() { return 0x07; }
+    };
+    struct ICXSubmitEXTHTLCCloseKey {
+        static constexpr uint8_t prefix() { return 0x08; }
+    };
+    struct ICXClaimDFCHTLCKey {
+        static constexpr uint8_t prefix() { return 0x09; }
+    };
+
+    struct ICXOrderStatus {
+        static constexpr uint8_t prefix() { return 0x0A; }
+    };
+    struct ICXOfferStatus {
+        static constexpr uint8_t prefix() { return 0x0B; }
+    };
+    struct ICXSubmitDFCHTLCStatus {
+        static constexpr uint8_t prefix() { return 0x0C; }
+    };
+    struct ICXSubmitEXTHTLCStatus {
+        static constexpr uint8_t prefix() { return 0x0D; }
+    };
+
+    struct ICXVariables {
+        static constexpr uint8_t prefix() { return 0x0F; }
+    };
 };
 
-#endif // DEFI_MASTERNODES_ICXORDER_H
+#endif  // DEFI_MASTERNODES_ICXORDER_H
diff --git a/src/masternodes/incentivefunding.cpp b/src/masternodes/incentivefunding.cpp
index 10c3594e7f..463927fb59 100644
--- a/src/masternodes/incentivefunding.cpp
+++ b/src/masternodes/incentivefunding.cpp
@@ -4,8 +4,7 @@
 
 #include <masternodes/incentivefunding.h>
 
-CAmount CCommunityBalancesView::GetCommunityBalance(CommunityAccountType account) const
-{
+CAmount CCommunityBalancesView::GetCommunityBalance(CommunityAccountType account) const {
     CAmount val;
     bool ok = ReadBy<ById>(static_cast<unsigned char>(account), val);
     if (ok) {
@@ -14,8 +13,7 @@ CAmount CCommunityBalancesView::GetCommunityBalance(CommunityAccountType account
     return 0;
 }
 
-Res CCommunityBalancesView::SetCommunityBalance(CommunityAccountType account, CAmount amount)
-{
+Res CCommunityBalancesView::SetCommunityBalance(CommunityAccountType account, CAmount amount) {
     // deny negative values on db level!
     if (amount < 0) {
         return Res::Err("negative amount");
@@ -24,16 +22,16 @@ Res CCommunityBalancesView::SetCommunityBalance(CommunityAccountType account, CA
     return Res::Ok();
 }
 
-void CCommunityBalancesView::ForEachCommunityBalance(std::function<bool (CommunityAccountType, CLazySerialize<CAmount>)> callback)
-{
-    ForEach<ById, unsigned char, CAmount>([&callback] (unsigned char const & key, CLazySerialize<CAmount> val) {
-        return callback(CommunityAccountCodeToType(key), val);
-    }, '\0');
-
+void CCommunityBalancesView::ForEachCommunityBalance(
+    std::function<bool(CommunityAccountType, CLazySerialize<CAmount>)> callback) {
+    ForEach<ById, unsigned char, CAmount>(
+        [&callback](const unsigned char &key, CLazySerialize<CAmount> val) {
+            return callback(CommunityAccountCodeToType(key), val);
+        },
+        '\0');
 }
 
-Res CCommunityBalancesView::AddCommunityBalance(CommunityAccountType account, CAmount amount)
-{
+Res CCommunityBalancesView::AddCommunityBalance(CommunityAccountType account, CAmount amount) {
     if (amount == 0) {
         return Res::Ok();
     }
@@ -41,8 +39,7 @@ Res CCommunityBalancesView::AddCommunityBalance(CommunityAccountType account, CA
     return !res.ok ? res : SetCommunityBalance(account, *res.val);
 }
 
-Res CCommunityBalancesView::SubCommunityBalance(CommunityAccountType account, CAmount amount)
-{
+Res CCommunityBalancesView::SubCommunityBalance(CommunityAccountType account, CAmount amount) {
     if (amount == 0) {
         return Res::Ok();
     }
diff --git a/src/masternodes/incentivefunding.h b/src/masternodes/incentivefunding.h
index c5f78c42d0..0fdcfe406c 100644
--- a/src/masternodes/incentivefunding.h
+++ b/src/masternodes/incentivefunding.h
@@ -5,36 +5,39 @@
 #ifndef DEFI_MASTERNODES_INCENTIVEFUNDING_H
 #define DEFI_MASTERNODES_INCENTIVEFUNDING_H
 
+#include <amount.h>
 #include <flushablestorage.h>
 #include <masternodes/communityaccounttypes.h>
 #include <masternodes/res.h>
-#include <amount.h>
 
-inline CommunityAccountType CommunityAccountCodeToType (unsigned char ch) {
-    char const types[] = "IACLOU";
+inline CommunityAccountType CommunityAccountCodeToType(unsigned char ch) {
+    const char types[] = "IACLOU";
     if (memchr(types, ch, strlen(types)))
         return static_cast<CommunityAccountType>(ch);
     else
         return CommunityAccountType::None;
 }
 
-inline char const * GetCommunityAccountName(CommunityAccountType t)
-{
-    switch (t)
-    {
-        case CommunityAccountType::IncentiveFunding: return "IncentiveFunding";
-        case CommunityAccountType::AnchorReward:     return "AnchorReward";
-        case CommunityAccountType::CommunityDevFunds:return "CommunityDevelopmentFunds";
-        case CommunityAccountType::Loan:             return "Loan";
-        case CommunityAccountType::Options:          return "Options";
-        case CommunityAccountType::Unallocated:      return "Burnt";
+inline const char *GetCommunityAccountName(CommunityAccountType t) {
+    switch (t) {
+        case CommunityAccountType::IncentiveFunding:
+            return "IncentiveFunding";
+        case CommunityAccountType::AnchorReward:
+            return "AnchorReward";
+        case CommunityAccountType::CommunityDevFunds:
+            return "CommunityDevelopmentFunds";
+        case CommunityAccountType::Loan:
+            return "Loan";
+        case CommunityAccountType::Options:
+            return "Options";
+        case CommunityAccountType::Unallocated:
+            return "Burnt";
         default:
             return "Unknown";
     }
 }
 
-class CCommunityBalancesView : public virtual CStorageView
-{
+class CCommunityBalancesView : public virtual CStorageView {
 public:
     CAmount GetCommunityBalance(CommunityAccountType account) const;
     Res SetCommunityBalance(CommunityAccountType account, CAmount amount);
@@ -45,7 +48,9 @@ class CCommunityBalancesView : public virtual CStorageView
     Res SubCommunityBalance(CommunityAccountType account, CAmount amount);
 
     // tags
-    struct ById { static constexpr uint8_t prefix() { return 'F'; } };
+    struct ById {
+        static constexpr uint8_t prefix() { return 'F'; }
+    };
 };
 
-#endif //DEFI_MASTERNODES_INCENTIVEFUNDING_H
+#endif  // DEFI_MASTERNODES_INCENTIVEFUNDING_H
diff --git a/src/masternodes/loan.cpp b/src/masternodes/loan.cpp
index c412edd7f3..d01d49b138 100644
--- a/src/masternodes/loan.cpp
+++ b/src/masternodes/loan.cpp
@@ -1,19 +1,17 @@
 
 #include <chainparams.h>
-#include <masternodes/loan.h>
 #include <masternodes/govvariables/attributes.h>
+#include <masternodes/loan.h>
 #include <masternodes/masternodes.h>
 
 #include <boost/multiprecision/cpp_int.hpp>
 
-std::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::GetLoanCollateralToken(uint256 const & txid) const
-{
-    return ReadBy<LoanSetCollateralTokenCreationTx,CLoanSetCollateralTokenImpl>(txid);
+std::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::GetLoanCollateralToken(const uint256 &txid) const {
+    return ReadBy<LoanSetCollateralTokenCreationTx, CLoanSetCollateralTokenImpl>(txid);
 }
 
-Res CLoanView::CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collToken)
-{
-    //this should not happen, but for sure
+Res CLoanView::CreateLoanCollateralToken(const CLoanSetCollateralTokenImpl &collToken) {
+    // this should not happen, but for sure
     if (GetLoanCollateralToken(collToken.creationTx))
         return Res::Err("setCollateralToken with creation tx %s already exists!", collToken.creationTx.GetHex());
     if (collToken.factor > COIN)
@@ -29,8 +27,7 @@ Res CLoanView::CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & col
     return Res::Ok();
 }
 
-Res CLoanView::EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl& collToken)
-{
+Res CLoanView::EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl &collToken) {
     CollateralTokenKey key{collToken.idToken, collToken.activateAfterBlock};
     EraseBy<LoanSetCollateralTokenKey>(key);
     EraseBy<LoanSetCollateralTokenCreationTx>(collToken.creationTx);
@@ -38,13 +35,12 @@ Res CLoanView::EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl& collT
     return Res::Ok();
 }
 
-void CLoanView::ForEachLoanCollateralToken(std::function<bool (CollateralTokenKey const &, uint256 const &)> callback, CollateralTokenKey const & start)
-{
+void CLoanView::ForEachLoanCollateralToken(std::function<bool(const CollateralTokenKey &, const uint256 &)> callback,
+                                           const CollateralTokenKey &start) {
     ForEach<LoanSetCollateralTokenKey, CollateralTokenKey, uint256>(callback, start);
 }
 
-std::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::HasLoanCollateralToken(CollateralTokenKey const & key)
-{
+std::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::HasLoanCollateralToken(const CollateralTokenKey &key) {
     auto it = LowerBound<LoanSetCollateralTokenKey>(key);
     if (it.Valid() && it.Key().id == key.id)
         return GetLoanCollateralToken(it.Value());
@@ -52,17 +48,15 @@ std::optional<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::HasLoanCollater
     return GetCollateralTokenFromAttributes(key.id);
 }
 
-std::optional<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanToken(uint256 const & txid) const
-{
+std::optional<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanToken(const uint256 &txid) const {
     auto id = ReadBy<LoanSetLoanTokenCreationTx, DCT_ID>(txid);
     if (id)
         return GetLoanTokenByID(*id);
     return {};
 }
 
-Res CLoanView::SetLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID const & id)
-{
-    //this should not happen, but for sure
+Res CLoanView::SetLoanToken(const CLoanSetLoanTokenImpl &loanToken, DCT_ID const &id) {
+    // this should not happen, but for sure
     if (GetLoanTokenByID(id))
         return Res::Err("setLoanToken with creation tx %s already exists!", loanToken.creationTx.GetHex());
 
@@ -72,70 +66,62 @@ Res CLoanView::SetLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID cons
     return Res::Ok();
 }
 
-Res CLoanView::UpdateLoanToken(CLoanSetLoanTokenImpl const & loanToken, DCT_ID const & id)
-{
+Res CLoanView::UpdateLoanToken(const CLoanSetLoanTokenImpl &loanToken, DCT_ID const &id) {
     WriteBy<LoanSetLoanTokenKey>(id, loanToken);
 
     return Res::Ok();
 }
 
-Res CLoanView::EraseLoanToken(const DCT_ID& id)
-{
+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)
-{
+void CLoanView::ForEachLoanToken(std::function<bool(DCT_ID const &, const CLoanSetLoanTokenImpl &)> callback,
+                                 DCT_ID const &start) {
     ForEach<LoanSetLoanTokenKey, DCT_ID, CLoanSetLoanTokenImpl>(callback, start);
 }
 
-Res CLoanView::StoreLoanScheme(const CLoanSchemeMessage& loanScheme)
-{
+Res CLoanView::StoreLoanScheme(const CLoanSchemeMessage &loanScheme) {
     WriteBy<LoanSchemeKey>(loanScheme.identifier, static_cast<CLoanSchemeData>(loanScheme));
 
     return Res::Ok();
 }
 
-Res CLoanView::StoreDelayedLoanScheme(const CLoanSchemeMessage& loanScheme)
-{
-    WriteBy<DelayedLoanSchemeKey>(std::pair<std::string, uint64_t>(loanScheme.identifier, loanScheme.updateHeight), loanScheme);
+Res CLoanView::StoreDelayedLoanScheme(const CLoanSchemeMessage &loanScheme) {
+    WriteBy<DelayedLoanSchemeKey>(std::pair<std::string, uint64_t>(loanScheme.identifier, loanScheme.updateHeight),
+                                  loanScheme);
 
     return Res::Ok();
 }
 
-Res CLoanView::StoreDelayedDestroyScheme(const CDestroyLoanSchemeMessage& loanScheme)
-{
+Res CLoanView::StoreDelayedDestroyScheme(const CDestroyLoanSchemeMessage &loanScheme) {
     WriteBy<DestroyLoanSchemeKey>(loanScheme.identifier, loanScheme.destroyHeight);
 
     return Res::Ok();
 }
 
-void CLoanView::ForEachLoanScheme(std::function<bool (const std::string&, const CLoanSchemeData&)> callback)
-{
+void CLoanView::ForEachLoanScheme(std::function<bool(const std::string &, const CLoanSchemeData &)> callback) {
     ForEach<LoanSchemeKey, std::string, CLoanSchemeData>(callback);
 }
 
-void CLoanView::ForEachDelayedLoanScheme(std::function<bool (const std::pair<std::string, uint64_t>&, const CLoanSchemeMessage&)> callback)
-{
+void CLoanView::ForEachDelayedLoanScheme(
+    std::function<bool(const std::pair<std::string, uint64_t> &, const CLoanSchemeMessage &)> callback) {
     ForEach<DelayedLoanSchemeKey, std::pair<std::string, uint64_t>, CLoanSchemeMessage>(callback);
 }
 
-void CLoanView::ForEachDelayedDestroyScheme(std::function<bool (const std::string&, const uint64_t&)> callback)
-{
+void CLoanView::ForEachDelayedDestroyScheme(std::function<bool(const std::string &, const uint64_t &)> callback) {
     ForEach<DestroyLoanSchemeKey, std::string, uint64_t>(callback);
 }
 
-Res CLoanView::StoreDefaultLoanScheme(const std::string& loanSchemeID)
-{
+Res CLoanView::StoreDefaultLoanScheme(const std::string &loanSchemeID) {
     Write(DefaultLoanSchemeKey::prefix(), loanSchemeID);
 
     return Res::Ok();
 }
 
-std::optional<std::string> CLoanView::GetDefaultLoanScheme()
-{
+std::optional<std::string> CLoanView::GetDefaultLoanScheme() {
     std::string loanSchemeID;
     if (Read(DefaultLoanSchemeKey::prefix(), loanSchemeID)) {
         return loanSchemeID;
@@ -144,30 +130,26 @@ std::optional<std::string> CLoanView::GetDefaultLoanScheme()
     return {};
 }
 
-std::optional<CLoanSchemeData> CLoanView::GetLoanScheme(const std::string& loanSchemeID)
-{
+std::optional<CLoanSchemeData> CLoanView::GetLoanScheme(const std::string &loanSchemeID) {
     return ReadBy<LoanSchemeKey, CLoanSchemeData>(loanSchemeID);
 }
 
-std::optional<uint64_t> CLoanView::GetDestroyLoanScheme(const std::string& loanSchemeID)
-{
+std::optional<uint64_t> CLoanView::GetDestroyLoanScheme(const std::string &loanSchemeID) {
     if (const auto res = ReadBy<DestroyLoanSchemeKey, uint64_t>(loanSchemeID))
         return res;
     return {};
 }
 
-Res CLoanView::EraseLoanScheme(const std::string& loanSchemeID)
-{
+Res CLoanView::EraseLoanScheme(const std::string &loanSchemeID) {
     // Find and delete all related loan scheme updates
     std::vector<uint64_t> loanUpdateHeights;
-    ForEachDelayedLoanScheme([&](const std::pair<std::string, uint64_t>& key, const CLoanSchemeMessage&)
-    {
+    ForEachDelayedLoanScheme([&](const std::pair<std::string, uint64_t> &key, const CLoanSchemeMessage &) {
         if (key.first == loanSchemeID)
             loanUpdateHeights.push_back(key.second);
         return true;
     });
 
-    for (const auto& height : loanUpdateHeights)
+    for (const auto &height : loanUpdateHeights)
         EraseDelayedLoanScheme(loanSchemeID, height);
 
     // Delete loan scheme
@@ -176,18 +158,17 @@ Res CLoanView::EraseLoanScheme(const std::string& loanSchemeID)
     return Res::Ok();
 }
 
-void CLoanView::EraseDelayedLoanScheme(const std::string& loanSchemeID, uint64_t height)
-{
+void CLoanView::EraseDelayedLoanScheme(const std::string &loanSchemeID, uint64_t height) {
     EraseBy<DelayedLoanSchemeKey>(std::pair<std::string, uint64_t>(loanSchemeID, height));
 }
 
-void CLoanView::EraseDelayedDestroyScheme(const std::string& loanSchemeID)
-{
+void CLoanView::EraseDelayedDestroyScheme(const std::string &loanSchemeID) {
     EraseBy<DestroyLoanSchemeKey>(loanSchemeID);
 }
 
-std::optional<CInterestRateV3> CLoanView::GetInterestRate(const CVaultId& vaultId, const DCT_ID id, const uint32_t height)
-{
+std::optional<CInterestRateV3> CLoanView::GetInterestRate(const CVaultId &vaultId,
+                                                          const DCT_ID id,
+                                                          const uint32_t height) {
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight)) {
         return ReadBy<LoanInterestV3ByVault, CInterestRateV3>(std::make_pair(vaultId, id));
     }
@@ -206,32 +187,28 @@ std::optional<CInterestRateV3> CLoanView::GetInterestRate(const CVaultId& vaultI
 }
 
 // Precision 64bit
-template<typename T>
-inline T InterestPerBlockCalculationV1(CAmount amount, CAmount tokenInterest, CAmount schemeInterest)
-{
-    const auto netInterest = (tokenInterest + schemeInterest) / 100; // in %
+template <typename T>
+inline T InterestPerBlockCalculationV1(CAmount amount, CAmount tokenInterest, CAmount schemeInterest) {
+    const auto netInterest          = (tokenInterest + schemeInterest) / 100;  // in %
     static const auto blocksPerYear = T(365) * Params().GetConsensus().blocksPerDay();
     return MultiplyAmounts(netInterest, amount) / blocksPerYear;
 }
 
 // Precision 128bit
-inline base_uint<128> InterestPerBlockCalculationV2(CAmount amount, CAmount tokenInterest, CAmount schemeInterest)
-{
-    const auto netInterest = (tokenInterest + schemeInterest) / 100; // in %
+inline base_uint<128> InterestPerBlockCalculationV2(CAmount amount, CAmount tokenInterest, CAmount schemeInterest) {
+    const auto netInterest          = (tokenInterest + schemeInterest) / 100;  // in %
     static const auto blocksPerYear = 365 * Params().GetConsensus().blocksPerDay();
     return arith_uint256(amount) * netInterest * COIN / blocksPerYear;
 }
 
 // Precision 128bit with negative interest
-CInterestAmount InterestPerBlockCalculationV3(CAmount amount, CAmount tokenInterest, CAmount schemeInterest)
-{
-    const auto netInterest = (tokenInterest + schemeInterest) / 100; // in %
+CInterestAmount InterestPerBlockCalculationV3(CAmount amount, CAmount tokenInterest, CAmount schemeInterest) {
+    const auto netInterest          = (tokenInterest + schemeInterest) / 100;  // in %
     static const auto blocksPerYear = 365 * Params().GetConsensus().blocksPerDay();
     return {netInterest < 0 && amount > 0, arith_uint256(amount) * std::abs(netInterest) * COIN / blocksPerYear};
 }
 
-CAmount CeilInterest(const base_uint<128>& value, uint32_t height)
-{
+CAmount CeilInterest(const base_uint<128> &value, uint32_t height) {
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
         CAmount amount = (value / base_uint<128>(HIGH_PRECISION_SCALER)).GetLow64();
         amount += CAmount(value != base_uint<128>(amount) * HIGH_PRECISION_SCALER);
@@ -240,13 +217,11 @@ CAmount CeilInterest(const base_uint<128>& value, uint32_t height)
     return value.GetLow64();
 }
 
-CAmount FloorInterest(const base_uint<128>& value)
-{
+CAmount FloorInterest(const base_uint<128> &value) {
     return (value / base_uint<128>(HIGH_PRECISION_SCALER)).GetLow64();
 }
 
-static base_uint<128> ToHigherPrecision(CAmount amount, uint32_t height)
-{
+static base_uint<128> ToHigherPrecision(CAmount amount, uint32_t height) {
     base_uint<128> amountHP = amount;
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight))
         amountHP *= HIGH_PRECISION_SCALER;
@@ -254,44 +229,48 @@ static base_uint<128> ToHigherPrecision(CAmount amount, uint32_t height)
     return amountHP;
 }
 
-const auto InterestPerBlock = [](const CInterestRateV3& rate, const uint32_t height) {
+const auto InterestPerBlock = [](const CInterestRateV3 &rate, const uint32_t height) {
     return CeilInterest(rate.interestPerBlock.amount, height);
 };
 
-CInterestAmount TotalInterestCalculation(const CInterestRateV3& rate, const uint32_t height)
-{
-    const auto heightDiff = (height - rate.height);
+CInterestAmount TotalInterestCalculation(const CInterestRateV3 &rate, const uint32_t height) {
+    const auto heightDiff     = (height - rate.height);
     const auto interestAmount = rate.interestPerBlock.amount;
-    const auto totalInterest =  interestAmount * heightDiff;
+    const auto totalInterest  = interestAmount * heightDiff;
 
     if (heightDiff != 0 && totalInterest / heightDiff != interestAmount) {
-        LogPrintf("WARNING: Overflow detected. This will soon be saturated. (height=%d, height-diff=%d" /* Continued */
-                  "amount=%s, interest=%s)\n",
-                  height, heightDiff, GetInterestPerBlockHighPrecisionString(rate.interestPerBlock),
-                  GetInterestPerBlockHighPrecisionString({rate.interestPerBlock.negative, totalInterest})
-                  );
+        LogPrintf(
+            "WARNING: Overflow detected. This will soon be saturated. (height=%d, height-diff=%d" /* Continued */
+            "amount=%s, interest=%s)\n",
+            height,
+            heightDiff,
+            GetInterestPerBlockHighPrecisionString(rate.interestPerBlock),
+            GetInterestPerBlockHighPrecisionString({rate.interestPerBlock.negative, totalInterest}));
     }
 
     auto interest = InterestAddition(rate.interestToHeight, {rate.interestPerBlock.negative, totalInterest});
 
-    LogPrint(BCLog::LOAN, "%s(): CInterestRate{.height=%d, .perBlock=%d, .toHeight=%d}, height %d - totalInterest %d\n",
-        __func__,
-        rate.height, rate.interestPerBlock.negative ? -InterestPerBlock(rate, height) : InterestPerBlock(rate, height),
-        rate.interestToHeight.negative ? -FloorInterest(rate.interestToHeight.amount) : CeilInterest(rate.interestToHeight.amount, height),
-        height,
-        interest.negative ? -FloorInterest(interest.amount) : CeilInterest(interest.amount, height));
+    LogPrint(BCLog::LOAN,
+             "%s(): CInterestRate{.height=%d, .perBlock=%d, .toHeight=%d}, height %d - totalInterest %d\n",
+             __func__,
+             rate.height,
+             rate.interestPerBlock.negative ? -InterestPerBlock(rate, height) : InterestPerBlock(rate, height),
+             rate.interestToHeight.negative ? -FloorInterest(rate.interestToHeight.amount)
+                                            : CeilInterest(rate.interestToHeight.amount, height),
+             height,
+             interest.negative ? -FloorInterest(interest.amount) : CeilInterest(interest.amount, height));
 
     return interest;
 }
 
-CAmount TotalInterest(const CInterestRateV3& rate, const uint32_t height)
-{
+CAmount TotalInterest(const CInterestRateV3 &rate, const uint32_t height) {
     const auto totalInterest = TotalInterestCalculation(rate, height);
     return totalInterest.negative ? -FloorInterest(totalInterest.amount) : CeilInterest(totalInterest.amount, height);
 }
 
-void CLoanView::WriteInterestRate(const std::pair<CVaultId, DCT_ID>& pair, const CInterestRateV3& rate, uint32_t height)
-{
+void CLoanView::WriteInterestRate(const std::pair<CVaultId, DCT_ID> &pair,
+                                  const CInterestRateV3 &rate,
+                                  uint32_t height) {
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight)) {
         WriteBy<LoanInterestV3ByVault>(pair, rate);
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
@@ -301,8 +280,12 @@ void CLoanView::WriteInterestRate(const std::pair<CVaultId, DCT_ID>& pair, const
     }
 }
 
-Res CLoanView::IncreaseInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id, const CAmount tokenInterest, const CAmount loanIncreased)
-{
+Res CLoanView::IncreaseInterest(const uint32_t height,
+                                const CVaultId &vaultId,
+                                const std::string &loanSchemeID,
+                                const DCT_ID id,
+                                const CAmount tokenInterest,
+                                const CAmount loanIncreased) {
     const auto scheme = GetLoanScheme(loanSchemeID);
     if (!scheme)
         return Res::Err("No such scheme id %s", loanSchemeID);
@@ -319,33 +302,41 @@ Res CLoanView::IncreaseInterest(const uint32_t height, const CVaultId& vaultId,
         return Res::Err("Cannot store height in the past");
 
     rate.interestToHeight = TotalInterestCalculation(rate, height);
-    rate.height = height;
+    rate.height           = height;
 
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight)) {
         CBalances amounts;
         ReadBy<LoanTokenAmount>(vaultId, amounts);
 
-        // Use argument token interest as update from Gov var TX will not be applied to GetLoanTokenByID at this point in time.
+        // Use argument token interest as update from Gov var TX will not be applied to GetLoanTokenByID at this point
+        // in time.
         rate.interestPerBlock = InterestPerBlockCalculationV3(amounts.balances[id], tokenInterest, scheme->rate);
 
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
         CBalances amounts;
         ReadBy<LoanTokenAmount>(vaultId, amounts);
-        rate.interestPerBlock = {false, InterestPerBlockCalculationV2(amounts.balances[id], token->interest, scheme->rate)};
+        rate.interestPerBlock = {false,
+                                 InterestPerBlockCalculationV2(amounts.balances[id], token->interest, scheme->rate)};
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningMuseumHeight)) {
         CAmount interestPerBlock = rate.interestPerBlock.amount.GetLow64();
-        interestPerBlock += std::ceil(InterestPerBlockCalculationV1<float>(loanIncreased, token->interest, scheme->rate));
+        interestPerBlock +=
+            std::ceil(InterestPerBlockCalculationV1<float>(loanIncreased, token->interest, scheme->rate));
         rate.interestPerBlock = {false, interestPerBlock};
     } else {
-        rate.interestPerBlock.amount += InterestPerBlockCalculationV1<CAmount>(loanIncreased, token->interest, scheme->rate);
+        rate.interestPerBlock.amount +=
+            InterestPerBlockCalculationV1<CAmount>(loanIncreased, token->interest, scheme->rate);
     }
 
     WriteInterestRate(std::make_pair(vaultId, id), rate, height);
     return Res::Ok();
 }
 
-Res CLoanView::DecreaseInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id, const CAmount loanDecreased, const CAmount interestDecreased)
-{
+Res CLoanView::DecreaseInterest(const uint32_t height,
+                                const CVaultId &vaultId,
+                                const std::string &loanSchemeID,
+                                const DCT_ID id,
+                                const CAmount loanDecreased,
+                                const CAmount interestDecreased) {
     auto scheme = GetLoanScheme(loanSchemeID);
     if (!scheme)
         return Res::Err("No such scheme id %s", loanSchemeID);
@@ -364,12 +355,13 @@ Res CLoanView::DecreaseInterest(const uint32_t height, const CVaultId& vaultId,
     if (rate.height == 0)
         return Res::Err("Data mismatch height == 0");
 
-    const auto interestToHeight = TotalInterestCalculation(rate, height);
+    const auto interestToHeight    = TotalInterestCalculation(rate, height);
     const auto interestDecreasedHP = ToHigherPrecision(interestDecreased, height);
 
-    rate.interestToHeight = interestToHeight.amount < interestDecreasedHP ?
-                                CInterestAmount{false, 0} :
-                                CInterestAmount{interestToHeight.negative, interestToHeight.amount - interestDecreasedHP};
+    rate.interestToHeight =
+        interestToHeight.amount < interestDecreasedHP
+            ? CInterestAmount{false, 0}
+            : CInterestAmount{interestToHeight.negative, interestToHeight.amount - interestDecreasedHP};
 
     rate.height = height;
 
@@ -380,24 +372,28 @@ Res CLoanView::DecreaseInterest(const uint32_t height, const CVaultId& vaultId,
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
         CBalances amounts;
         ReadBy<LoanTokenAmount>(vaultId, amounts);
-        rate.interestPerBlock = {false, InterestPerBlockCalculationV2(amounts.balances[id], token->interest, scheme->rate)};
+        rate.interestPerBlock = {false,
+                                 InterestPerBlockCalculationV2(amounts.balances[id], token->interest, scheme->rate)};
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningMuseumHeight)) {
         CAmount interestPerBlock = rate.interestPerBlock.amount.GetLow64();
-        CAmount newInterestPerBlock = std::ceil(InterestPerBlockCalculationV1<float>(loanDecreased, token->interest, scheme->rate));
-        rate.interestPerBlock = {false ,std::max(CAmount{0}, interestPerBlock - newInterestPerBlock)};
+        CAmount newInterestPerBlock =
+            std::ceil(InterestPerBlockCalculationV1<float>(loanDecreased, token->interest, scheme->rate));
+        rate.interestPerBlock = {false, std::max(CAmount{0}, interestPerBlock - newInterestPerBlock)};
     } else {
         auto interestPerBlock = InterestPerBlockCalculationV1<CAmount>(loanDecreased, token->interest, scheme->rate);
-        rate.interestPerBlock = rate.interestPerBlock.amount < interestPerBlock ? CInterestAmount{false, 0}
-                              : CInterestAmount{false, rate.interestPerBlock.amount - interestPerBlock};
+        rate.interestPerBlock = rate.interestPerBlock.amount < interestPerBlock
+                                    ? CInterestAmount{false, 0}
+                                    : CInterestAmount{false, rate.interestPerBlock.amount - interestPerBlock};
     }
 
     WriteInterestRate(std::make_pair(vaultId, id), rate, height);
     return Res::Ok();
 }
 
-
-void CLoanView::ResetInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id)
-{
+void CLoanView::ResetInterest(const uint32_t height,
+                              const CVaultId &vaultId,
+                              const std::string &loanSchemeID,
+                              const DCT_ID id) {
     const auto scheme = GetLoanScheme(loanSchemeID);
     assert(scheme);
 
@@ -408,50 +404,55 @@ void CLoanView::ResetInterest(const uint32_t height, const CVaultId& vaultId, co
     ReadBy<LoanTokenAmount>(vaultId, amounts);
 
     const CInterestRateV3 rate{
-            height,
-            InterestPerBlockCalculationV3(amounts.balances[id], token->interest, scheme->rate),
-            {false, 0}
+        height, InterestPerBlockCalculationV3(amounts.balances[id], token->interest, scheme->rate), {false, 0}
     };
 
     WriteInterestRate(std::make_pair(vaultId, id), rate, height);
 }
 
-void CLoanView::ForEachVaultInterest(std::function<bool(const CVaultId&, DCT_ID, CInterestRate)> callback, const CVaultId& vaultId, DCT_ID id)
-{
-    ForEach<LoanInterestByVault, std::pair<CVaultId, DCT_ID>, CInterestRate>([&](const std::pair<CVaultId, DCT_ID>& pair, CInterestRate rate) {
-        return callback(pair.first, pair.second, rate);
-    }, std::make_pair(vaultId, id));
+void CLoanView::ForEachVaultInterest(std::function<bool(const CVaultId &, DCT_ID, CInterestRate)> callback,
+                                     const CVaultId &vaultId,
+                                     DCT_ID id) {
+    ForEach<LoanInterestByVault, std::pair<CVaultId, DCT_ID>, CInterestRate>(
+        [&](const std::pair<CVaultId, DCT_ID> &pair, CInterestRate rate) {
+            return callback(pair.first, pair.second, rate);
+        },
+        std::make_pair(vaultId, id));
 }
 
-void CLoanView::ForEachVaultInterestV2(std::function<bool(const CVaultId&, DCT_ID, CInterestRateV2)> callback, const CVaultId& vaultId, DCT_ID id)
-{
-    ForEach<LoanInterestV2ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV2>([&](const std::pair<CVaultId, DCT_ID>& pair, CInterestRateV2 rate) {
-        return callback(pair.first, pair.second, rate);
-    }, std::make_pair(vaultId, id));
+void CLoanView::ForEachVaultInterestV2(std::function<bool(const CVaultId &, DCT_ID, CInterestRateV2)> callback,
+                                       const CVaultId &vaultId,
+                                       DCT_ID id) {
+    ForEach<LoanInterestV2ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV2>(
+        [&](const std::pair<CVaultId, DCT_ID> &pair, CInterestRateV2 rate) {
+            return callback(pair.first, pair.second, rate);
+        },
+        std::make_pair(vaultId, id));
 }
 
-void CLoanView::ForEachVaultInterestV3(std::function<bool(const CVaultId&, DCT_ID, CInterestRateV3)> callback, const CVaultId& vaultId, DCT_ID id)
-{
-    ForEach<LoanInterestV3ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV3>([&](const std::pair<CVaultId, DCT_ID>& pair, CInterestRateV3 rate) {
-        return callback(pair.first, pair.second, rate);
-    }, std::make_pair(vaultId, id));
+void CLoanView::ForEachVaultInterestV3(std::function<bool(const CVaultId &, DCT_ID, CInterestRateV3)> callback,
+                                       const CVaultId &vaultId,
+                                       DCT_ID id) {
+    ForEach<LoanInterestV3ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV3>(
+        [&](const std::pair<CVaultId, DCT_ID> &pair, CInterestRateV3 rate) {
+            return callback(pair.first, pair.second, rate);
+        },
+        std::make_pair(vaultId, id));
 }
 
-template<typename BoundType>
-void EraseInterest(CLoanView& view, const CVaultId& vaultId)
-{
+template <typename BoundType>
+void EraseInterest(CLoanView &view, const CVaultId &vaultId) {
     std::vector<std::pair<CVaultId, DCT_ID>> keysToDelete;
 
     auto it = view.LowerBound<BoundType>(std::make_pair(vaultId, DCT_ID{0}));
     for (; it.Valid() && it.Key().first == vaultId; it.Next())
         keysToDelete.push_back(it.Key());
 
-    for (const auto& key : keysToDelete)
+    for (const auto &key : keysToDelete)
         view.EraseBy<BoundType>(key);
 }
 
-Res CLoanView::EraseInterest(const CVaultId& vaultId, uint32_t height)
-{
+Res CLoanView::EraseInterest(const CVaultId &vaultId, uint32_t height) {
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight)) {
         ::EraseInterest<LoanInterestV3ByVault>(*this, vaultId);
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
@@ -463,8 +464,7 @@ Res CLoanView::EraseInterest(const CVaultId& vaultId, uint32_t height)
     return Res::Ok();
 }
 
-void CLoanView::EraseInterest(const CVaultId& vaultId, DCT_ID id, uint32_t height)
-{
+void CLoanView::EraseInterest(const CVaultId &vaultId, DCT_ID id, uint32_t height) {
     if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningGreatWorldHeight)) {
         EraseBy<LoanInterestV3ByVault>(std::make_pair(vaultId, id));
     } else if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight)) {
@@ -472,37 +472,36 @@ void CLoanView::EraseInterest(const CVaultId& vaultId, DCT_ID id, uint32_t heigh
     }
 }
 
-void CLoanView::RevertInterestRateToV1()
-{
+void CLoanView::RevertInterestRateToV1() {
     std::vector<std::pair<CVaultId, DCT_ID>> pairs;
 
-    ForEach<LoanInterestV2ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV2>([&](const std::pair<CVaultId, DCT_ID>& pair, CLazySerialize<CInterestRateV2>) {
-        pairs.emplace_back(pair);
-        return true;
-    });
+    ForEach<LoanInterestV2ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV2>(
+        [&](const std::pair<CVaultId, DCT_ID> &pair, CLazySerialize<CInterestRateV2>) {
+            pairs.emplace_back(pair);
+            return true;
+        });
 
     for (auto it = pairs.begin(); it != pairs.end(); it = pairs.erase(it)) {
         EraseBy<LoanInterestV2ByVault>(*it);
     }
 }
 
-void CLoanView::RevertInterestRateToV2()
-{
+void CLoanView::RevertInterestRateToV2() {
     std::vector<std::pair<CVaultId, DCT_ID>> pairs;
 
-    ForEach<LoanInterestV3ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV3>([&](const std::pair<CVaultId, DCT_ID>& pair, const CInterestRateV3&) {
-        pairs.emplace_back(pair);
-        return true;
-    });
+    ForEach<LoanInterestV3ByVault, std::pair<CVaultId, DCT_ID>, CInterestRateV3>(
+        [&](const std::pair<CVaultId, DCT_ID> &pair, const CInterestRateV3 &) {
+            pairs.emplace_back(pair);
+            return true;
+        });
 
     for (auto it = pairs.begin(); it != pairs.end(); it = pairs.erase(it)) {
         EraseBy<LoanInterestV3ByVault>(*it);
     }
 }
 
-void CLoanView::MigrateInterestRateToV2(CVaultView &view, uint32_t height)
-{
-    ForEachVaultInterest([&](const CVaultId& vaultId, DCT_ID tokenId, CInterestRate rate) {
+void CLoanView::MigrateInterestRateToV2(CVaultView &view, uint32_t height) {
+    ForEachVaultInterest([&](const CVaultId &vaultId, DCT_ID tokenId, CInterestRate rate) {
         auto newRate = ConvertInterestRateToV2(rate);
         newRate.interestPerBlock *= HIGH_PRECISION_SCALER;
         newRate.interestToHeight *= HIGH_PRECISION_SCALER;
@@ -519,9 +518,8 @@ void CLoanView::MigrateInterestRateToV2(CVaultView &view, uint32_t height)
     });
 }
 
-void CLoanView::MigrateInterestRateToV3(CVaultView &view, uint32_t height)
-{
-    ForEachVaultInterestV2([&](const CVaultId& vaultId, DCT_ID tokenId, const CInterestRateV2 &rate) {
+void CLoanView::MigrateInterestRateToV3(CVaultView &view, uint32_t height) {
+    ForEachVaultInterestV2([&](const CVaultId &vaultId, DCT_ID tokenId, const CInterestRateV2 &rate) {
         auto newRate = ConvertInterestRateToV3(rate);
         WriteBy<LoanInterestV3ByVault>(std::make_pair(vaultId, tokenId), newRate);
 
@@ -536,8 +534,7 @@ void CLoanView::MigrateInterestRateToV3(CVaultView &view, uint32_t height)
     });
 }
 
-Res CLoanView::AddLoanToken(const CVaultId& vaultId, CTokenAmount amount)
-{
+Res CLoanView::AddLoanToken(const CVaultId &vaultId, CTokenAmount amount) {
     if (!GetLoanTokenByID(amount.nTokenId))
         return Res::Err("No such loan token id %s", amount.nTokenId.ToString());
 
@@ -553,8 +550,7 @@ Res CLoanView::AddLoanToken(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-Res CLoanView::SubLoanToken(const CVaultId& vaultId, CTokenAmount amount)
-{
+Res CLoanView::SubLoanToken(const CVaultId &vaultId, CTokenAmount amount) {
     if (!GetLoanTokenByID(amount.nTokenId))
         return Res::Err("No such loan token id %s", amount.nTokenId.ToString());
 
@@ -570,30 +566,25 @@ Res CLoanView::SubLoanToken(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-std::optional<CBalances> CLoanView::GetLoanTokens(const CVaultId& vaultId)
-{
+std::optional<CBalances> CLoanView::GetLoanTokens(const CVaultId &vaultId) {
     return ReadBy<LoanTokenAmount, CBalances>(vaultId);
 }
 
-void CLoanView::ForEachLoanTokenAmount(std::function<bool (const CVaultId&, const CBalances&)> callback)
-{
+void CLoanView::ForEachLoanTokenAmount(std::function<bool(const CVaultId &, const CBalances &)> callback) {
     ForEach<LoanTokenAmount, CVaultId, CBalances>(callback);
 }
 
-Res CLoanView::SetLoanLiquidationPenalty(CAmount penalty)
-{
+Res CLoanView::SetLoanLiquidationPenalty(CAmount penalty) {
     Write(LoanLiquidationPenalty::prefix(), penalty);
     return Res::Ok();
 }
 
-Res CLoanView::EraseLoanLiquidationPenalty()
-{
+Res CLoanView::EraseLoanLiquidationPenalty() {
     Erase(LoanLiquidationPenalty::prefix());
     return Res::Ok();
 }
 
-CAmount CLoanView::GetLoanLiquidationPenalty()
-{
+CAmount CLoanView::GetLoanLiquidationPenalty() {
     CAmount penalty;
     if (Read(LoanLiquidationPenalty::prefix(), penalty))
         return penalty;
@@ -601,7 +592,7 @@ CAmount CLoanView::GetLoanLiquidationPenalty()
     return 5 * COIN / 100;
 }
 
-std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInterestAmount& value) {
+std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInterestAmount &value) {
     struct HighPrecisionInterestValue {
         typedef boost::multiprecision::int128_t int128;
         typedef int64_t int64;
@@ -609,22 +600,16 @@ std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInte
         int128 value;
         bool negative;
 
-        explicit HighPrecisionInterestValue(const CInterestAmount& val) {
-            value = int128("0x" + val.amount.GetHex());
+        explicit HighPrecisionInterestValue(const CInterestAmount &val) {
+            value    = int128("0x" + val.amount.GetHex());
             negative = val.negative;
         }
 
-        int64 GetInterestPerBlockSat() const {
-            return int64(value / HIGH_PRECISION_SCALER);
-        }
+        int64 GetInterestPerBlockSat() const { return int64(value / HIGH_PRECISION_SCALER); }
 
-        int64 GetInterestPerBlockSubSat() const {
-            return int64(value % HIGH_PRECISION_SCALER);
-        }
+        int64 GetInterestPerBlockSubSat() const { return int64(value % HIGH_PRECISION_SCALER); }
 
-        int64 GetInterestPerBlockMagnitude() const {
-            return int64(value / HIGH_PRECISION_SCALER / COIN);
-        }
+        int64 GetInterestPerBlockMagnitude() const { return int64(value / HIGH_PRECISION_SCALER / COIN); }
 
         int128 GetInterestPerBlockDecimal() const {
             auto v = GetInterestPerBlockSat();
@@ -647,7 +632,7 @@ std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInte
     return HighPrecisionInterestValue(value).GetInterestPerBlockString();
 }
 
-std::string GetInterestPerBlockHighPrecisionString(const CInterestAmount& value) {
+std::string GetInterestPerBlockHighPrecisionString(const CInterestAmount &value) {
     auto res = TryGetInterestPerBlockHighPrecisionString(value);
     if (!res) {
         LogPrintf("WARNING: High precision interest string conversion failure. Falling back to hex.\n");
diff --git a/src/masternodes/loan.h b/src/masternodes/loan.h
index 5b75844e88..0aa17cae44 100644
--- a/src/masternodes/loan.h
+++ b/src/masternodes/loan.h
@@ -6,14 +6,12 @@
 
 #include <flushablestorage.h>
 #include <masternodes/balances.h>
-#include <masternodes/res.h>
 #include <masternodes/oracles.h>
+#include <masternodes/res.h>
 #include <masternodes/vault.h>
 #include <script/script.h>
 
-
-class CLoanSetCollateralToken
-{
+class CLoanSetCollateralToken {
 public:
     DCT_ID idToken{UINT_MAX};
     CAmount factor;
@@ -23,7 +21,7 @@ class CLoanSetCollateralToken
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(idToken);
         READWRITE(factor);
         READWRITE(fixedIntervalPriceId);
@@ -31,8 +29,7 @@ class CLoanSetCollateralToken
     }
 };
 
-class CLoanSetCollateralTokenImplementation : public CLoanSetCollateralToken
-{
+class CLoanSetCollateralTokenImplementation : public CLoanSetCollateralToken {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -40,7 +37,7 @@ class CLoanSetCollateralTokenImplementation : public CLoanSetCollateralToken
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CLoanSetCollateralToken, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -52,24 +49,23 @@ struct CLoanSetCollateralTokenMessage : public CLoanSetCollateralToken {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CLoanSetCollateralToken, *this);
     }
 };
 
-class CLoanSetLoanToken
-{
+class CLoanSetLoanToken {
 public:
     std::string symbol;
     std::string name;
     CTokenCurrencyPair fixedIntervalPriceId;
-    bool mintable = true;
+    bool mintable    = true;
     CAmount interest = 0;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(symbol);
         READWRITE(name);
         READWRITE(fixedIntervalPriceId);
@@ -78,8 +74,7 @@ class CLoanSetLoanToken
     }
 };
 
-class CLoanSetLoanTokenImplementation : public CLoanSetLoanToken
-{
+class CLoanSetLoanTokenImplementation : public CLoanSetLoanToken {
 public:
     uint256 creationTx;
     int32_t creationHeight = -1;
@@ -87,7 +82,7 @@ class CLoanSetLoanTokenImplementation : public CLoanSetLoanToken
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CLoanSetLoanToken, *this);
         READWRITE(creationTx);
         READWRITE(creationHeight);
@@ -99,7 +94,7 @@ struct CLoanSetLoanTokenMessage : public CLoanSetLoanToken {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CLoanSetLoanToken, *this);
     }
 };
@@ -111,21 +106,20 @@ struct CLoanUpdateLoanTokenMessage : public CLoanSetLoanToken {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CLoanSetLoanToken, *this);
         READWRITE(tokenTx);
     }
 };
 
-struct CollateralTokenKey
-{
+struct CollateralTokenKey {
     DCT_ID id;
     uint32_t height;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(id);
 
         if (ser_action.ForRead()) {
@@ -138,92 +132,84 @@ struct CollateralTokenKey
     }
 };
 
-struct CLoanSchemeData
-{
+struct CLoanSchemeData {
     uint32_t ratio;
     CAmount rate;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(ratio);
         READWRITE(rate);
     }
 };
 
-struct CLoanScheme : public CLoanSchemeData
-{
+struct CLoanScheme : public CLoanSchemeData {
     std::string identifier;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITEAS(CLoanSchemeData,*this);
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITEAS(CLoanSchemeData, *this);
         READWRITE(identifier);
     }
 };
 
-struct CLoanSchemeCreation : public CLoanScheme
-{
+struct CLoanSchemeCreation : public CLoanScheme {
     uint256 schemeCreationTxid;
 };
 
-struct CLoanSchemeMessage : public CLoanScheme
-{
+struct CLoanSchemeMessage : public CLoanScheme {
     uint64_t updateHeight{0};
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITEAS(CLoanScheme,*this);
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        READWRITEAS(CLoanScheme, *this);
         READWRITE(updateHeight);
     }
 };
 
-struct CDefaultLoanSchemeMessage
-{
+struct CDefaultLoanSchemeMessage {
     std::string identifier;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(identifier);
     }
 };
 
-struct CDestroyLoanSchemeMessage : public CDefaultLoanSchemeMessage
-{
+struct CDestroyLoanSchemeMessage : public CDefaultLoanSchemeMessage {
     uint64_t destroyHeight{0};
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CDefaultLoanSchemeMessage, *this);
         READWRITE(destroyHeight);
     }
 };
 
-struct CInterestAmount
-{
+struct CInterestAmount {
     bool negative{};
     base_uint<128> amount;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(negative);
         READWRITE(amount);
     }
 };
 
-struct CInterestRate
-{
+struct CInterestRate {
     uint32_t height;
     CAmount interestPerBlock;
     CAmount interestToHeight;
@@ -231,15 +217,14 @@ struct CInterestRate
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(height);
         READWRITE(interestPerBlock);
         READWRITE(interestToHeight);
     }
 };
 
-struct CInterestRateV2
-{
+struct CInterestRateV2 {
     uint32_t height;
     base_uint<128> interestPerBlock;
     base_uint<128> interestToHeight;
@@ -247,15 +232,14 @@ struct CInterestRateV2
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(height);
         READWRITE(interestPerBlock);
         READWRITE(interestToHeight);
     }
 };
 
-struct CInterestRateV3
-{
+struct CInterestRateV3 {
     uint32_t height;
     CInterestAmount interestPerBlock;
     CInterestAmount interestToHeight;
@@ -263,67 +247,61 @@ struct CInterestRateV3
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(height);
         READWRITE(interestPerBlock);
         READWRITE(interestToHeight);
     }
 };
 
-inline CInterestRate ConvertInterestRateToV1(const CInterestRateV2& rate2)
-{
+inline CInterestRate ConvertInterestRateToV1(const CInterestRateV2 &rate2) {
     CInterestRate rate1{};
-    rate1.height = rate2.height;
+    rate1.height           = rate2.height;
     rate1.interestPerBlock = rate2.interestPerBlock.GetLow64();
     rate1.interestToHeight = rate2.interestToHeight.GetLow64();
 
     return rate1;
 }
 
-inline CInterestRate ConvertInterestRateToV1(const CInterestRateV3& rate3)
-{
+inline CInterestRate ConvertInterestRateToV1(const CInterestRateV3 &rate3) {
     CInterestRate rate1{};
-    rate1.height = rate3.height;
+    rate1.height           = rate3.height;
     rate1.interestPerBlock = rate3.interestPerBlock.amount.GetLow64();
     rate1.interestToHeight = rate3.interestToHeight.amount.GetLow64();
 
     return rate1;
 }
 
-inline CInterestRateV2 ConvertInterestRateToV2(const CInterestRate& rate1)
-{
+inline CInterestRateV2 ConvertInterestRateToV2(const CInterestRate &rate1) {
     CInterestRateV2 rate2{};
-    rate2.height = rate1.height;
+    rate2.height           = rate1.height;
     rate2.interestPerBlock = rate1.interestPerBlock;
     rate2.interestToHeight = rate1.interestToHeight;
 
     return rate2;
 }
 
-inline CInterestRateV2 ConvertInterestRateToV2(const CInterestRateV3& rate3)
-{
+inline CInterestRateV2 ConvertInterestRateToV2(const CInterestRateV3 &rate3) {
     CInterestRateV2 rate2{};
-    rate2.height = rate3.height;
+    rate2.height           = rate3.height;
     rate2.interestPerBlock = rate3.interestPerBlock.amount;
     rate2.interestToHeight = rate3.interestToHeight.amount;
 
     return rate2;
 }
 
-inline CInterestRateV3 ConvertInterestRateToV3(const CInterestRate& rate1)
-{
+inline CInterestRateV3 ConvertInterestRateToV3(const CInterestRate &rate1) {
     CInterestRateV3 rate3{};
-    rate3.height = rate1.height;
+    rate3.height                  = rate1.height;
     rate3.interestPerBlock.amount = rate1.interestPerBlock;
     rate3.interestToHeight.amount = rate1.interestToHeight;
 
     return rate3;
 }
 
-inline CInterestRateV3 ConvertInterestRateToV3(const CInterestRateV2& rate2)
-{
+inline CInterestRateV3 ConvertInterestRateToV3(const CInterestRateV2 &rate2) {
     CInterestRateV3 rate3{};
-    rate3.height = rate2.height;
+    rate3.height           = rate2.height;
     rate3.interestPerBlock = {false, rate2.interestPerBlock};
     rate3.interestToHeight = {false, rate2.interestToHeight};
 
@@ -333,14 +311,14 @@ inline CInterestRateV3 ConvertInterestRateToV3(const CInterestRateV2& rate2)
 inline auto InterestAddition = [](const CInterestAmount &a, const CInterestAmount &b) {
     CInterestAmount interest;
     if (a.negative == b.negative) {
-        interest.amount = a.amount + b.amount;
+        interest.amount   = a.amount + b.amount;
         interest.negative = b.negative;
     } else {
         if (a.amount > b.amount) {
-            interest.amount = a.amount - b.amount;
+            interest.amount   = a.amount - b.amount;
             interest.negative = a.negative;
         } else {
-            interest.amount = b.amount - a.amount;
+            interest.amount   = b.amount - a.amount;
             interest.negative = !a.negative;
         }
     }
@@ -350,20 +328,19 @@ inline auto InterestAddition = [](const CInterestAmount &a, const CInterestAmoun
     return interest;
 };
 
-static const CAmount HIGH_PRECISION_SCALER = COIN * COIN; // 1,0000,0000,0000,0000
+static const CAmount HIGH_PRECISION_SCALER = COIN * COIN;  // 1,0000,0000,0000,0000
 
-CAmount TotalInterest(const CInterestRateV3& rate, const uint32_t height);
-CInterestAmount TotalInterestCalculation(const CInterestRateV3& rate, const uint32_t height);
-CAmount CeilInterest(const base_uint<128>& value, uint32_t height);
+CAmount TotalInterest(const CInterestRateV3 &rate, const uint32_t height);
+CInterestAmount TotalInterestCalculation(const CInterestRateV3 &rate, const uint32_t height);
+CAmount CeilInterest(const base_uint<128> &value, uint32_t height);
 
-std::string GetInterestPerBlockHighPrecisionString(const CInterestAmount& value);
-std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInterestAmount& value);
+std::string GetInterestPerBlockHighPrecisionString(const CInterestAmount &value);
+std::optional<std::string> TryGetInterestPerBlockHighPrecisionString(const CInterestAmount &value);
 
 base_uint<128> InterestPerBlockCalculationV2(CAmount amount, CAmount tokenInterest, CAmount schemeInterest);
 CInterestAmount InterestPerBlockCalculationV3(CAmount amount, CAmount tokenInterest, CAmount schemeInterest);
 
-class CLoanTakeLoanMessage
-{
+class CLoanTakeLoanMessage {
 public:
     CVaultId vaultId;
     CScript to;
@@ -372,15 +349,14 @@ class CLoanTakeLoanMessage
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(to);
         READWRITE(amounts);
     }
 };
 
-class CLoanPaybackLoanMessage
-{
+class CLoanPaybackLoanMessage {
 public:
     CVaultId vaultId;
     CScript from;
@@ -389,15 +365,14 @@ class CLoanPaybackLoanMessage
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(from);
         READWRITE(amounts);
     }
 };
 
-class CLoanPaybackLoanV2Message
-{
+class CLoanPaybackLoanV2Message {
 public:
     CVaultId vaultId;
     CScript from;
@@ -406,7 +381,7 @@ class CLoanPaybackLoanV2Message
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(from);
         READWRITE(loans);
@@ -419,8 +394,7 @@ struct CPaybackWithCollateralMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
     }
 };
@@ -428,75 +402,125 @@ struct CPaybackWithCollateralMessage {
 class CLoanView : public virtual CStorageView {
 public:
     using CLoanSetCollateralTokenImpl = CLoanSetCollateralTokenImplementation;
-    using CLoanSetLoanTokenImpl = CLoanSetLoanTokenImplementation;
-
-    std::optional<CLoanSetCollateralTokenImpl> GetLoanCollateralToken(uint256 const & txid) const;
-    Res CreateLoanCollateralToken(CLoanSetCollateralTokenImpl const & collToken);
-    Res EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl& collToken);
-    void ForEachLoanCollateralToken(std::function<bool (CollateralTokenKey const &, uint256 const &)> callback, CollateralTokenKey const & start = {DCT_ID{0}, UINT_MAX});
-    std::optional<CLoanSetCollateralTokenImpl> HasLoanCollateralToken(CollateralTokenKey const & key);
-
-    std::optional<CLoanSetLoanTokenImpl> GetLoanToken(uint256 const & txid) const;
-    [[nodiscard]] virtual std::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);
-    Res StoreDefaultLoanScheme(const std::string& loanSchemeID);
-    Res StoreDelayedLoanScheme(const CLoanSchemeMessage& loanScheme);
-    Res StoreDelayedDestroyScheme(const CDestroyLoanSchemeMessage& loanScheme);
-    Res EraseLoanScheme(const std::string& loanSchemeID);
-    void EraseDelayedLoanScheme(const std::string& loanSchemeID, uint64_t height);
-    void EraseDelayedDestroyScheme(const std::string& loanSchemeID);
+    using CLoanSetLoanTokenImpl       = CLoanSetLoanTokenImplementation;
+
+    std::optional<CLoanSetCollateralTokenImpl> GetLoanCollateralToken(const uint256 &txid) const;
+    Res CreateLoanCollateralToken(const CLoanSetCollateralTokenImpl &collToken);
+    Res EraseLoanCollateralToken(const CLoanSetCollateralTokenImpl &collToken);
+    void ForEachLoanCollateralToken(std::function<bool(const CollateralTokenKey &, const uint256 &)> callback,
+                                    const CollateralTokenKey &start = {DCT_ID{0}, UINT_MAX});
+    std::optional<CLoanSetCollateralTokenImpl> HasLoanCollateralToken(const CollateralTokenKey &key);
+
+    std::optional<CLoanSetLoanTokenImpl> GetLoanToken(const uint256 &txid) const;
+    [[nodiscard]] virtual std::optional<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const &id) const = 0;
+    Res SetLoanToken(const CLoanSetLoanTokenImpl &loanToken, DCT_ID const &id);
+    Res UpdateLoanToken(const CLoanSetLoanTokenImpl &loanToken, DCT_ID const &id);
+    Res EraseLoanToken(const DCT_ID &id);
+    void ForEachLoanToken(std::function<bool(DCT_ID const &, const CLoanSetLoanTokenImpl &)> callback,
+                          DCT_ID const &start = {0});
+
+    Res StoreLoanScheme(const CLoanSchemeMessage &loanScheme);
+    Res StoreDefaultLoanScheme(const std::string &loanSchemeID);
+    Res StoreDelayedLoanScheme(const CLoanSchemeMessage &loanScheme);
+    Res StoreDelayedDestroyScheme(const CDestroyLoanSchemeMessage &loanScheme);
+    Res EraseLoanScheme(const std::string &loanSchemeID);
+    void EraseDelayedLoanScheme(const std::string &loanSchemeID, uint64_t height);
+    void EraseDelayedDestroyScheme(const std::string &loanSchemeID);
     std::optional<std::string> GetDefaultLoanScheme();
-    std::optional<CLoanSchemeData> GetLoanScheme(const std::string& loanSchemeID);
-    std::optional<uint64_t> GetDestroyLoanScheme(const std::string& loanSchemeID);
-    void ForEachLoanScheme(std::function<bool (const std::string&, const CLoanSchemeData&)> callback);
-    void ForEachDelayedLoanScheme(std::function<bool (const std::pair<std::string, uint64_t>&, const CLoanSchemeMessage&)> callback);
-    void ForEachDelayedDestroyScheme(std::function<bool (const std::string&, const uint64_t&)> callback);
-
-    Res EraseInterest(const CVaultId& vaultId, uint32_t height);
-    void EraseInterest(const CVaultId& vaultId, DCT_ID id, uint32_t height);
-    std::optional<CInterestRateV3> GetInterestRate(const CVaultId& vaultId, const DCT_ID id, const uint32_t height);
-    void WriteInterestRate(const std::pair<CVaultId, DCT_ID>& pair, const CInterestRateV3& rate, uint32_t height);
-    Res IncreaseInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id, const CAmount tokenInterest, const CAmount loanIncreased);
-    Res DecreaseInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id, const CAmount loanDecreased, const CAmount interestDecreased);
-    void ResetInterest(const uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, const DCT_ID id);
-    void ForEachVaultInterest(std::function<bool(const CVaultId&, DCT_ID, CInterestRate)> callback, const CVaultId& vaultId = {}, DCT_ID id = {});
-    void ForEachVaultInterestV2(std::function<bool(const CVaultId&, DCT_ID, CInterestRateV2)> callback, const CVaultId& vaultId = {}, DCT_ID id = {});
-    void ForEachVaultInterestV3(std::function<bool(const CVaultId&, DCT_ID, CInterestRateV3)> callback, const CVaultId& vaultId = {}, DCT_ID id = {});
+    std::optional<CLoanSchemeData> GetLoanScheme(const std::string &loanSchemeID);
+    std::optional<uint64_t> GetDestroyLoanScheme(const std::string &loanSchemeID);
+    void ForEachLoanScheme(std::function<bool(const std::string &, const CLoanSchemeData &)> callback);
+    void ForEachDelayedLoanScheme(
+        std::function<bool(const std::pair<std::string, uint64_t> &, const CLoanSchemeMessage &)> callback);
+    void ForEachDelayedDestroyScheme(std::function<bool(const std::string &, const uint64_t &)> callback);
+
+    Res EraseInterest(const CVaultId &vaultId, uint32_t height);
+    void EraseInterest(const CVaultId &vaultId, DCT_ID id, uint32_t height);
+    std::optional<CInterestRateV3> GetInterestRate(const CVaultId &vaultId, const DCT_ID id, const uint32_t height);
+    void WriteInterestRate(const std::pair<CVaultId, DCT_ID> &pair, const CInterestRateV3 &rate, uint32_t height);
+    Res IncreaseInterest(const uint32_t height,
+                         const CVaultId &vaultId,
+                         const std::string &loanSchemeID,
+                         const DCT_ID id,
+                         const CAmount tokenInterest,
+                         const CAmount loanIncreased);
+    Res DecreaseInterest(const uint32_t height,
+                         const CVaultId &vaultId,
+                         const std::string &loanSchemeID,
+                         const DCT_ID id,
+                         const CAmount loanDecreased,
+                         const CAmount interestDecreased);
+    void ResetInterest(const uint32_t height,
+                       const CVaultId &vaultId,
+                       const std::string &loanSchemeID,
+                       const DCT_ID id);
+    void ForEachVaultInterest(std::function<bool(const CVaultId &, DCT_ID, CInterestRate)> callback,
+                              const CVaultId &vaultId = {},
+                              DCT_ID id               = {});
+    void ForEachVaultInterestV2(std::function<bool(const CVaultId &, DCT_ID, CInterestRateV2)> callback,
+                                const CVaultId &vaultId = {},
+                                DCT_ID id               = {});
+    void ForEachVaultInterestV3(std::function<bool(const CVaultId &, DCT_ID, CInterestRateV3)> callback,
+                                const CVaultId &vaultId = {},
+                                DCT_ID id               = {});
     void RevertInterestRateToV1();
     void RevertInterestRateToV2();
     void MigrateInterestRateToV2(CVaultView &view, uint32_t height);
     void MigrateInterestRateToV3(CVaultView &view, uint32_t height);
 
-    Res AddLoanToken(const CVaultId& vaultId, CTokenAmount amount);
-    Res SubLoanToken(const CVaultId& vaultId, CTokenAmount amount);
-    std::optional<CBalances> GetLoanTokens(const CVaultId& vaultId);
-    void ForEachLoanTokenAmount(std::function<bool (const CVaultId&,  const CBalances&)> callback);
+    Res AddLoanToken(const CVaultId &vaultId, CTokenAmount amount);
+    Res SubLoanToken(const CVaultId &vaultId, CTokenAmount amount);
+    std::optional<CBalances> GetLoanTokens(const CVaultId &vaultId);
+    void ForEachLoanTokenAmount(std::function<bool(const CVaultId &, const CBalances &)> callback);
 
     Res SetLoanLiquidationPenalty(CAmount penalty);
     Res EraseLoanLiquidationPenalty();
     CAmount GetLoanLiquidationPenalty();
 
-    [[nodiscard]] virtual std::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(const DCT_ID& id) const = 0;
-    [[nodiscard]] virtual std::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; } };
-    struct LoanSetLoanTokenKey              { static constexpr uint8_t prefix() { return 0x13; } };
-    struct LoanSchemeKey                    { static constexpr uint8_t prefix() { return 0x14; } };
-    struct DefaultLoanSchemeKey             { static constexpr uint8_t prefix() { return 0x15; } };
-    struct DelayedLoanSchemeKey             { static constexpr uint8_t prefix() { return 0x16; } };
-    struct DestroyLoanSchemeKey             { static constexpr uint8_t prefix() { return 0x17; } };
-    struct LoanInterestByVault              { static constexpr uint8_t prefix() { return 0x18; } };
-    struct LoanTokenAmount                  { static constexpr uint8_t prefix() { return 0x19; } };
-    struct LoanLiquidationPenalty           { static constexpr uint8_t prefix() { return 0x1A; } };
-    struct LoanInterestV2ByVault            { static constexpr uint8_t prefix() { return 0x1B; } };
-    struct LoanInterestV3ByVault            { static constexpr uint8_t prefix() { return 0x1C; } };
+    [[nodiscard]] virtual std::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(
+        const DCT_ID &id) const = 0;
+    [[nodiscard]] virtual std::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; }
+    };
+    struct LoanSetLoanTokenKey {
+        static constexpr uint8_t prefix() { return 0x13; }
+    };
+    struct LoanSchemeKey {
+        static constexpr uint8_t prefix() { return 0x14; }
+    };
+    struct DefaultLoanSchemeKey {
+        static constexpr uint8_t prefix() { return 0x15; }
+    };
+    struct DelayedLoanSchemeKey {
+        static constexpr uint8_t prefix() { return 0x16; }
+    };
+    struct DestroyLoanSchemeKey {
+        static constexpr uint8_t prefix() { return 0x17; }
+    };
+    struct LoanInterestByVault {
+        static constexpr uint8_t prefix() { return 0x18; }
+    };
+    struct LoanTokenAmount {
+        static constexpr uint8_t prefix() { return 0x19; }
+    };
+    struct LoanLiquidationPenalty {
+        static constexpr uint8_t prefix() { return 0x1A; }
+    };
+    struct LoanInterestV2ByVault {
+        static constexpr uint8_t prefix() { return 0x1B; }
+    };
+    struct LoanInterestV3ByVault {
+        static constexpr uint8_t prefix() { return 0x1C; }
+    };
 };
 
-#endif // DEFI_MASTERNODES_LOAN_H
+#endif  // DEFI_MASTERNODES_LOAN_H
diff --git a/src/masternodes/masternodes.cpp b/src/masternodes/masternodes.cpp
index bed2f43ab7..fec773d93d 100644
--- a/src/masternodes/masternodes.cpp
+++ b/src/masternodes/masternodes.cpp
@@ -15,12 +15,12 @@
 #include <core_io.h>
 #include <net_processing.h>
 #include <primitives/transaction.h>
+#include <rpc/resultcache.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <validation.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
-#include <rpc/resultcache.h>
 
 #include <algorithm>
 #include <functional>
@@ -29,31 +29,28 @@
 std::unique_ptr<CCustomCSView> pcustomcsview;
 std::unique_ptr<CStorageLevelDB> pcustomcsDB;
 
-int GetMnActivationDelay(int height)
-{
+int GetMnActivationDelay(int height) {
     // Restore previous activation delay on testnet after FC
-    if (height < Params().GetConsensus().EunosHeight ||
-    (Params().NetworkIDString() == CBaseChainParams::TESTNET && height >= Params().GetConsensus().FortCanningHeight)) {
+    if (height < Params().GetConsensus().EunosHeight || (Params().NetworkIDString() == CBaseChainParams::TESTNET &&
+                                                         height >= Params().GetConsensus().FortCanningHeight)) {
         return Params().GetConsensus().mn.activationDelay;
     }
 
     return Params().GetConsensus().mn.newActivationDelay;
 }
 
-int GetMnResignDelay(int height)
-{
+int GetMnResignDelay(int height) {
     // Restore previous activation delay on testnet after FC
-    if (height < Params().GetConsensus().EunosHeight ||
-    (Params().NetworkIDString() == CBaseChainParams::TESTNET && height >= Params().GetConsensus().FortCanningHeight)) {
+    if (height < Params().GetConsensus().EunosHeight || (Params().NetworkIDString() == CBaseChainParams::TESTNET &&
+                                                         height >= Params().GetConsensus().FortCanningHeight)) {
         return Params().GetConsensus().mn.resignDelay;
     }
 
     return Params().GetConsensus().mn.newResignDelay;
 }
 
-CAmount GetMnCollateralAmount(int height)
-{
-    auto& consensus = Params().GetConsensus();
+CAmount GetMnCollateralAmount(int height) {
+    auto &consensus = Params().GetConsensus();
     if (height < consensus.DakotaHeight) {
         return consensus.mn.collateralAmount;
     } else {
@@ -61,35 +58,32 @@ CAmount GetMnCollateralAmount(int height)
     }
 }
 
-CAmount GetMnCreationFee(int)
-{
+CAmount GetMnCreationFee(int) {
     return Params().GetConsensus().mn.creationFee;
 }
 
-CAmount GetTokenCollateralAmount()
-{
+CAmount GetTokenCollateralAmount() {
     return Params().GetConsensus().token.collateralAmount;
 }
 
-CAmount GetTokenCreationFee(int)
-{
+CAmount GetTokenCreationFee(int) {
     return Params().GetConsensus().token.creationFee;
 }
 
-CAmount GetPropsCreationFee(int, const CCustomCSView& view, const CCreatePropMessage& msg)
-{
-    auto type = static_cast<CPropType>(msg.type);
-    auto options = static_cast<CPropOption>(msg.options);
+CAmount GetPropsCreationFee(int, const CCustomCSView &view, const CCreatePropMessage &msg) {
+    auto type       = static_cast<CPropType>(msg.type);
+    auto options    = static_cast<CPropOption>(msg.options);
     auto attributes = view.GetAttributes();
     assert(attributes);
 
     CDataStructureV0 CFPKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::CFPFee};
     CDataStructureV0 VOCKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCFee};
-    CDataStructureV0 VOCEmergencyKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCEmergencyFee};
+    CDataStructureV0 VOCEmergencyKey{
+        AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCEmergencyFee};
     bool emergency = (options & CPropOption::Emergency);
 
     CAmount cfpFee;
-    switch(type) {
+    switch (type) {
         case CPropType::CommunityFundProposal:
             cfpFee = MultiplyAmounts(msg.nAmount, attributes->GetValue(CFPKey, Params().GetConsensus().props.cfp.fee));
             return 10 * COIN > cfpFee ? 10 * COIN : cfpFee;
@@ -103,23 +97,20 @@ CAmount GetPropsCreationFee(int, const CCustomCSView& view, const CCreatePropMes
 }
 
 CMasternode::CMasternode()
-    : mintedBlocks(0)
-    , ownerAuthAddress()
-    , ownerType(0)
-    , operatorAuthAddress()
-    , operatorType(0)
-    , rewardAddress()
-    , rewardAddressType(0)
-    , creationHeight(0)
-    , resignHeight(-1)
-    , version(-1)
-    , resignTx()
-    , collateralTx()
-{
-}
-
-CMasternode::State CMasternode::GetState(int height, const CMasternodesView& mnview) const
-{
+    : mintedBlocks(0),
+      ownerAuthAddress(),
+      ownerType(0),
+      operatorAuthAddress(),
+      operatorType(0),
+      rewardAddress(),
+      rewardAddressType(0),
+      creationHeight(0),
+      resignHeight(-1),
+      version(-1),
+      resignTx(),
+      collateralTx() {}
+
+CMasternode::State CMasternode::GetState(int height, const CMasternodesView &mnview) const {
     int EunosPayaHeight = Params().GetConsensus().EunosPayaHeight;
 
     if (height < creationHeight) {
@@ -131,7 +122,8 @@ CMasternode::State CMasternode::GetState(int height, const CMasternodesView& mnv
         assert(idHeight);
         if (static_cast<uint32_t>(height) < idHeight->blockHeight) {
             return State::TRANSFERRING;
-        } else if (static_cast<uint32_t>(height) < idHeight->blockHeight + GetMnActivationDelay(idHeight->blockHeight)) {
+        } else if (static_cast<uint32_t>(height) <
+                   idHeight->blockHeight + GetMnActivationDelay(idHeight->blockHeight)) {
             return State::PRE_ENABLED;
         }
     }
@@ -140,16 +132,17 @@ CMasternode::State CMasternode::GetState(int height, const CMasternodesView& mnv
         return State::TRANSFERRING;
     }
 
-    if (resignHeight == -1 || height < resignHeight) { // enabled or pre-enabled
+    if (resignHeight == -1 || height < resignHeight) {  // enabled or pre-enabled
         // Special case for genesis block
-        int activationDelay = height < EunosPayaHeight ? GetMnActivationDelay(height) : GetMnActivationDelay(creationHeight);
+        int activationDelay =
+            height < EunosPayaHeight ? GetMnActivationDelay(height) : GetMnActivationDelay(creationHeight);
         if (creationHeight == 0 || height >= creationHeight + activationDelay) {
             return State::ENABLED;
         }
         return State::PRE_ENABLED;
     }
 
-    if (resignHeight != -1) { // pre-resigned or resigned
+    if (resignHeight != -1) {  // pre-resigned or resigned
         int resignDelay = height < EunosPayaHeight ? GetMnResignDelay(height) : GetMnResignDelay(resignHeight);
         if (height < resignHeight + resignDelay) {
             return State::PRE_RESIGNED;
@@ -159,8 +152,7 @@ CMasternode::State CMasternode::GetState(int height, const CMasternodesView& mnv
     return State::UNKNOWN;
 }
 
-bool CMasternode::IsActive(int height, const CMasternodesView& mnview) const
-{
+bool CMasternode::IsActive(int height, const CMasternodesView &mnview) const {
     State state = GetState(height, mnview);
     if (height >= Params().GetConsensus().EunosPayaHeight) {
         return state == ENABLED;
@@ -168,8 +160,7 @@ bool CMasternode::IsActive(int height, const CMasternodesView& mnview) const
     return state == ENABLED || state == PRE_RESIGNED;
 }
 
-std::string CMasternode::GetHumanReadableState(State state)
-{
+std::string CMasternode::GetHumanReadableState(State state) {
     switch (state) {
         case PRE_ENABLED:
             return "PRE_ENABLED";
@@ -186,95 +177,80 @@ std::string CMasternode::GetHumanReadableState(State state)
     }
 }
 
-std::string CMasternode::GetTimelockToString(TimeLock timelock)
-{
-  switch (timelock) {
-    case FIVEYEAR : return "FIVEYEARTIMELOCK";
-    case TENYEAR  : return "TENYEARTIMELOCK";
-    default       : return "NONE";
-  }
-}
-
-bool operator==(CMasternode const & a, CMasternode const & b)
-{
-    return (a.mintedBlocks == b.mintedBlocks &&
-            a.ownerType == b.ownerType &&
-            a.ownerAuthAddress == b.ownerAuthAddress &&
-            a.operatorType == b.operatorType &&
-            a.operatorAuthAddress == b.operatorAuthAddress &&
-            a.rewardAddress == b.rewardAddress &&
-            a.rewardAddressType == b.rewardAddressType &&
-            a.creationHeight == b.creationHeight &&
-            a.resignHeight == b.resignHeight &&
-            a.version == b.version &&
-            a.resignTx == b.resignTx &&
-            a.collateralTx == b.collateralTx
-            );
-}
-
-bool operator!=(CMasternode const & a, CMasternode const & b)
-{
+std::string CMasternode::GetTimelockToString(TimeLock timelock) {
+    switch (timelock) {
+        case FIVEYEAR:
+            return "FIVEYEARTIMELOCK";
+        case TENYEAR:
+            return "TENYEARTIMELOCK";
+        default:
+            return "NONE";
+    }
+}
+
+bool operator==(const CMasternode &a, const CMasternode &b) {
+    return (a.mintedBlocks == b.mintedBlocks && a.ownerType == b.ownerType &&
+            a.ownerAuthAddress == b.ownerAuthAddress && a.operatorType == b.operatorType &&
+            a.operatorAuthAddress == b.operatorAuthAddress && a.rewardAddress == b.rewardAddress &&
+            a.rewardAddressType == b.rewardAddressType && a.creationHeight == b.creationHeight &&
+            a.resignHeight == b.resignHeight && a.version == b.version && a.resignTx == b.resignTx &&
+            a.collateralTx == b.collateralTx);
+}
+
+bool operator!=(const CMasternode &a, const CMasternode &b) {
     return !(a == b);
 }
 
 /*
  * Check that given node is involved in anchor's subsystem for a given height (or smth like that)
  */
-//bool IsAnchorInvolved(const uint256 & nodeId, int height) const
+// bool IsAnchorInvolved(const uint256 & nodeId, int height) const
 //{
-//    /// @todo to be implemented
-//    return false;
-//}
-
-
-
+//     /// @todo to be implemented
+//     return false;
+// }
 
 /*
  *  CMasternodesView
  */
-std::optional<CMasternode> CMasternodesView::GetMasternode(const uint256 & id) const
-{
+std::optional<CMasternode> CMasternodesView::GetMasternode(const uint256 &id) const {
     return ReadBy<ID, CMasternode>(id);
 }
 
-std::optional<uint256> CMasternodesView::GetMasternodeIdByOperator(const CKeyID & id) const
-{
+std::optional<uint256> CMasternodesView::GetMasternodeIdByOperator(const CKeyID &id) const {
     return ReadBy<Operator, uint256>(id);
 }
 
-std::optional<uint256> CMasternodesView::GetMasternodeIdByOwner(const CKeyID & id) const
-{
+std::optional<uint256> CMasternodesView::GetMasternodeIdByOwner(const CKeyID &id) const {
     return ReadBy<Owner, uint256>(id);
 }
 
-void CMasternodesView::ForEachMasternode(std::function<bool (const uint256 &, CLazySerialize<CMasternode>)> callback, uint256 const & start)
-{
+void CMasternodesView::ForEachMasternode(std::function<bool(const uint256 &, CLazySerialize<CMasternode>)> callback,
+                                         const uint256 &start) {
     ForEach<ID, uint256, CMasternode>(callback, start);
 }
 
-void CMasternodesView::IncrementMintedBy(const uint256& nodeId)
-{
+void CMasternodesView::IncrementMintedBy(const uint256 &nodeId) {
     auto node = GetMasternode(nodeId);
     assert(node);
     ++node->mintedBlocks;
     WriteBy<ID>(nodeId, *node);
 }
 
-void CMasternodesView::DecrementMintedBy(const uint256& nodeId)
-{
+void CMasternodesView::DecrementMintedBy(const uint256 &nodeId) {
     auto node = GetMasternode(nodeId);
     assert(node);
     --node->mintedBlocks;
     WriteBy<ID>(nodeId, *node);
 }
 
-std::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOperator() const
-{
-    auto const operators = gArgs.GetArgs("-masternode_operator");
-    for(auto const & key : operators) {
-        CTxDestination const dest = DecodeDestination(key);
-        CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) :
-                                   dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID();
+std::optional<std::pair<CKeyID, uint256>> CMasternodesView::AmIOperator() const {
+    const auto operators = gArgs.GetArgs("-masternode_operator");
+    for (const auto &key : operators) {
+        const CTxDestination dest = DecodeDestination(key);
+        const CKeyID authAddress  = dest.index() == PKHashType         ? CKeyID(std::get<PKHash>(dest))
+                                    : dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest))
+                                                                       : CKeyID();
         if (!authAddress.IsNull()) {
             if (auto nodeId = GetMasternodeIdByOperator(authAddress)) {
                 return std::make_pair(authAddress, *nodeId);
@@ -284,14 +260,14 @@ std::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOperator() const
     return {};
 }
 
-std::set<std::pair<CKeyID, uint256>> CMasternodesView::GetOperatorsMulti() const
-{
-    auto const operators = gArgs.GetArgs("-masternode_operator");
+std::set<std::pair<CKeyID, uint256>> CMasternodesView::GetOperatorsMulti() const {
+    const auto operators = gArgs.GetArgs("-masternode_operator");
     std::set<std::pair<CKeyID, uint256>> operatorPairs;
-    for(auto const & key : operators) {
-        CTxDestination const dest = DecodeDestination(key);
-        CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) :
-                                   dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID();
+    for (const auto &key : operators) {
+        const CTxDestination dest = DecodeDestination(key);
+        const CKeyID authAddress  = dest.index() == PKHashType         ? CKeyID(std::get<PKHash>(dest))
+                                    : dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest))
+                                                                       : CKeyID();
         if (!authAddress.IsNull()) {
             if (auto nodeId = GetMasternodeIdByOperator(authAddress)) {
                 operatorPairs.insert(std::make_pair(authAddress, *nodeId));
@@ -302,28 +278,28 @@ std::set<std::pair<CKeyID, uint256>> CMasternodesView::GetOperatorsMulti() const
     return operatorPairs;
 }
 
-std::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOwner() const
-{
+std::optional<std::pair<CKeyID, uint256>> CMasternodesView::AmIOwner() const {
     CTxDestination dest = DecodeDestination(gArgs.GetArg("-masternode_owner", ""));
-    CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) : (dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID());
+    const CKeyID authAddress =
+        dest.index() == PKHashType
+            ? CKeyID(std::get<PKHash>(dest))
+            : (dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID());
     if (!authAddress.IsNull()) {
         auto nodeId = GetMasternodeIdByOwner(authAddress);
         if (nodeId)
-            return { std::make_pair(authAddress, *nodeId) };
+            return {std::make_pair(authAddress, *nodeId)};
     }
     return {};
 }
 
-Res CMasternodesView::CreateMasternode(const uint256 & nodeId, const CMasternode & node, uint16_t timelock)
-{
+Res CMasternodesView::CreateMasternode(const uint256 &nodeId, const CMasternode &node, uint16_t timelock) {
     // Check auth addresses and that there in no MN with such owner or operator
     if ((node.operatorType != 1 && node.operatorType != 4) || (node.ownerType != 1 && node.ownerType != 4) ||
-        node.ownerAuthAddress.IsNull() || node.operatorAuthAddress.IsNull() ||
-        GetMasternode(nodeId) ||
-        GetMasternodeIdByOwner(node.ownerAuthAddress)    || GetMasternodeIdByOperator(node.ownerAuthAddress) ||
-        GetMasternodeIdByOwner(node.operatorAuthAddress) || GetMasternodeIdByOperator(node.operatorAuthAddress)
-        ) {
-        return Res::Err("bad owner and|or operator address (should be P2PKH or P2WPKH only) or node with those addresses exists");
+        node.ownerAuthAddress.IsNull() || node.operatorAuthAddress.IsNull() || GetMasternode(nodeId) ||
+        GetMasternodeIdByOwner(node.ownerAuthAddress) || GetMasternodeIdByOperator(node.ownerAuthAddress) ||
+        GetMasternodeIdByOwner(node.operatorAuthAddress) || GetMasternodeIdByOperator(node.operatorAuthAddress)) {
+        return Res::Err(
+            "bad owner and|or operator address (should be P2PKH or P2WPKH only) or node with those addresses exists");
     }
 
     WriteBy<ID>(nodeId, node);
@@ -337,8 +313,7 @@ Res CMasternodesView::CreateMasternode(const uint256 & nodeId, const CMasternode
     return Res::Ok();
 }
 
-Res CMasternodesView::ResignMasternode(CMasternode& node, const uint256 & nodeId, const uint256 & txid, int height)
-{
+Res CMasternodesView::ResignMasternode(CMasternode &node, const uint256 &nodeId, const uint256 &txid, int height) {
     auto state = node.GetState(height, *this);
     if (height >= Params().GetConsensus().EunosPayaHeight) {
         if (state != CMasternode::ENABLED) {
@@ -353,15 +328,18 @@ Res CMasternodesView::ResignMasternode(CMasternode& node, const uint256 & nodeId
         return Res::Err("Trying to resign masternode before timelock expiration.");
     }
 
-    node.resignTx =  txid;
+    node.resignTx     = txid;
     node.resignHeight = height;
     WriteBy<ID>(nodeId, node);
 
     return Res::Ok();
 }
 
-void CMasternodesView::SetForcedRewardAddress(uint256 const & nodeId, CMasternode& node, const char rewardAddressType, CKeyID const & rewardAddress, int height)
-{
+void CMasternodesView::SetForcedRewardAddress(const uint256 &nodeId,
+                                              CMasternode &node,
+                                              const char rewardAddressType,
+                                              const CKeyID &rewardAddress,
+                                              int height) {
     // If old masternode update for new serialisation
     if (node.version < CMasternode::VERSION0) {
         node.version = CMasternode::VERSION0;
@@ -369,15 +347,14 @@ void CMasternodesView::SetForcedRewardAddress(uint256 const & nodeId, CMasternod
 
     // Set new reward address
     node.rewardAddressType = rewardAddressType;
-    node.rewardAddress = rewardAddress;
+    node.rewardAddress     = rewardAddress;
     WriteBy<ID>(nodeId, node);
 
     // Pending change
     WriteBy<PendingHeight>(node.ownerAuthAddress, static_cast<uint32_t>(height + GetMnResignDelay(height)));
 }
 
-void CMasternodesView::RemForcedRewardAddress(uint256 const & nodeId, CMasternode& node, int height)
-{
+void CMasternodesView::RemForcedRewardAddress(const uint256 &nodeId, CMasternode &node, int height) {
     node.rewardAddressType = 0;
     node.rewardAddress.SetNull();
     WriteBy<ID>(nodeId, node);
@@ -390,7 +367,8 @@ std::optional<uint32_t> CMasternodesView::GetPendingHeight(const CKeyID &ownerAu
     return ReadBy<PendingHeight, uint32_t>(ownerAuthAddress);
 }
 
-void CMasternodesView::ForEachPendingHeight(std::function<bool(const CKeyID &ownerAuthAddress, const uint32_t &height)> callback) {
+void CMasternodesView::ForEachPendingHeight(
+    std::function<bool(const CKeyID &ownerAuthAddress, const uint32_t &height)> callback) {
     ForEach<PendingHeight, CKeyID, uint32_t>(callback);
 }
 
@@ -398,12 +376,15 @@ void CMasternodesView::ErasePendingHeight(const CKeyID &ownerAuthAddress) {
     EraseBy<PendingHeight>(ownerAuthAddress);
 }
 
-void CMasternodesView::UpdateMasternodeOperator(uint256 const & nodeId, CMasternode& node, const char operatorType, const CKeyID& operatorAuthAddress, int height)
-{
+void CMasternodesView::UpdateMasternodeOperator(const uint256 &nodeId,
+                                                CMasternode &node,
+                                                const char operatorType,
+                                                const CKeyID &operatorAuthAddress,
+                                                int height) {
     // Remove old record
     EraseBy<Operator>(node.operatorAuthAddress);
 
-    node.operatorType = operatorType;
+    node.operatorType        = operatorType;
     node.operatorAuthAddress = operatorAuthAddress;
 
     // Overwrite and create new record
@@ -414,12 +395,14 @@ void CMasternodesView::UpdateMasternodeOperator(uint256 const & nodeId, CMastern
     WriteBy<PendingHeight>(node.ownerAuthAddress, static_cast<uint32_t>(height + GetMnResignDelay(height)));
 }
 
-void CMasternodesView::UpdateMasternodeOwner(uint256 const & nodeId, CMasternode& node, const char ownerType, const CKeyID& ownerAuthAddress)
-{
+void CMasternodesView::UpdateMasternodeOwner(const uint256 &nodeId,
+                                             CMasternode &node,
+                                             const char ownerType,
+                                             const CKeyID &ownerAuthAddress) {
     // Remove old record
     EraseBy<Owner>(node.ownerAuthAddress);
 
-    node.ownerType = ownerType;
+    node.ownerType        = ownerType;
     node.ownerAuthAddress = ownerAuthAddress;
 
     // Overwrite and create new record
@@ -427,8 +410,10 @@ void CMasternodesView::UpdateMasternodeOwner(uint256 const & nodeId, CMasternode
     WriteBy<Owner>(node.ownerAuthAddress, nodeId);
 }
 
-void CMasternodesView::UpdateMasternodeCollateral(uint256 const & nodeId, CMasternode& node, const uint256& newCollateralTx, const int height)
-{
+void CMasternodesView::UpdateMasternodeCollateral(const uint256 &nodeId,
+                                                  CMasternode &node,
+                                                  const uint256 &newCollateralTx,
+                                                  const int height) {
     // Remove old record.
     EraseBy<NewCollateral>(node.collateralTx);
 
@@ -437,111 +422,110 @@ void CMasternodesView::UpdateMasternodeCollateral(uint256 const & nodeId, CMaste
     WriteBy<ID>(nodeId, node);
 
     // Prioritise fast lookup in CanSpend() and GetState()
-    WriteBy<NewCollateral>(newCollateralTx, MNNewOwnerHeightValue{static_cast<uint32_t>(height + GetMnResignDelay(height)), nodeId});
+    WriteBy<NewCollateral>(newCollateralTx,
+                           MNNewOwnerHeightValue{static_cast<uint32_t>(height + GetMnResignDelay(height)), nodeId});
 }
 
-std::optional<MNNewOwnerHeightValue> CMasternodesView::GetNewCollateral(const uint256& txid) const
-{
+std::optional<MNNewOwnerHeightValue> CMasternodesView::GetNewCollateral(const uint256 &txid) const {
     return ReadBy<NewCollateral, MNNewOwnerHeightValue>(txid);
 }
 
-void CMasternodesView::ForEachNewCollateral(std::function<bool(const uint256&, CLazySerialize<MNNewOwnerHeightValue>)> callback)
-{
+void CMasternodesView::ForEachNewCollateral(
+    std::function<bool(const uint256 &, CLazySerialize<MNNewOwnerHeightValue>)> callback) {
     ForEach<NewCollateral, uint256, MNNewOwnerHeightValue>(callback);
 }
 
-void CMasternodesView::SetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t &blockHeight, const int64_t& time)
-{
+void CMasternodesView::SetMasternodeLastBlockTime(const CKeyID &minter,
+                                                  const uint32_t &blockHeight,
+                                                  const int64_t &time) {
     auto nodeId = GetMasternodeIdByOperator(minter);
     assert(nodeId);
 
     WriteBy<Staker>(MNBlockTimeKey{*nodeId, blockHeight}, time);
 }
 
-std::optional<int64_t> CMasternodesView::GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height)
-{
+std::optional<int64_t> CMasternodesView::GetMasternodeLastBlockTime(const CKeyID &minter, const uint32_t height) {
     auto nodeId = GetMasternodeIdByOperator(minter);
     assert(nodeId);
 
     int64_t time{0};
 
-    ForEachMinterNode([&](const MNBlockTimeKey &key, int64_t blockTime)
-    {
-        if (key.masternodeID == nodeId)
-        {
-            time = blockTime;
-        }
+    ForEachMinterNode(
+        [&](const MNBlockTimeKey &key, int64_t blockTime) {
+            if (key.masternodeID == nodeId) {
+                time = blockTime;
+            }
 
-        // Get first result only and exit
-        return false;
-    }, MNBlockTimeKey{*nodeId, height - 1});
+            // Get first result only and exit
+            return false;
+        },
+        MNBlockTimeKey{*nodeId, height - 1});
 
-    if (time)
-    {
+    if (time) {
         return time;
     }
 
     return {};
 }
 
-void CMasternodesView::EraseMasternodeLastBlockTime(const uint256& nodeId, const uint32_t& blockHeight)
-{
+void CMasternodesView::EraseMasternodeLastBlockTime(const uint256 &nodeId, const uint32_t &blockHeight) {
     EraseBy<Staker>(MNBlockTimeKey{nodeId, blockHeight});
 }
 
-void CMasternodesView::ForEachMinterNode(std::function<bool(MNBlockTimeKey const &, CLazySerialize<int64_t>)> callback, MNBlockTimeKey const & start)
-{
+void CMasternodesView::ForEachMinterNode(std::function<bool(const MNBlockTimeKey &, CLazySerialize<int64_t>)> callback,
+                                         const MNBlockTimeKey &start) {
     ForEach<Staker, MNBlockTimeKey, int64_t>(callback, start);
 }
 
-void CMasternodesView::SetSubNodesBlockTime(const CKeyID & minter, const uint32_t &blockHeight, const uint8_t id, const int64_t& time)
-{
+void CMasternodesView::SetSubNodesBlockTime(const CKeyID &minter,
+                                            const uint32_t &blockHeight,
+                                            const uint8_t id,
+                                            const int64_t &time) {
     auto nodeId = GetMasternodeIdByOperator(minter);
     assert(nodeId);
 
     WriteBy<SubNode>(SubNodeBlockTimeKey{*nodeId, id, blockHeight}, time);
 }
 
-std::vector<int64_t> CMasternodesView::GetSubNodesBlockTime(const CKeyID & minter, const uint32_t height)
-{
+std::vector<int64_t> CMasternodesView::GetSubNodesBlockTime(const CKeyID &minter, const uint32_t height) {
     auto nodeId = GetMasternodeIdByOperator(minter);
     assert(nodeId);
 
     std::vector<int64_t> times(SUBNODE_COUNT, 0);
 
     for (uint8_t i{0}; i < SUBNODE_COUNT; ++i) {
-        ForEachSubNode([&](const SubNodeBlockTimeKey &key, int64_t blockTime)
-        {
-            if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHeight)) {
-                if (key.masternodeID == nodeId && key.subnode == i) {
+        ForEachSubNode(
+            [&](const SubNodeBlockTimeKey &key, int64_t blockTime) {
+                if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHeight)) {
+                    if (key.masternodeID == nodeId && key.subnode == i) {
+                        times[i] = blockTime;
+                    }
+                } else if (key.masternodeID == nodeId) {
                     times[i] = blockTime;
                 }
-            } else if (key.masternodeID == nodeId) {
-                times[i] = blockTime;
-            }
 
-            // Get first result only and exit
-            return false;
-        }, SubNodeBlockTimeKey{*nodeId, i, height - 1});
+                // Get first result only and exit
+                return false;
+            },
+            SubNodeBlockTimeKey{*nodeId, i, height - 1});
     }
 
     return times;
 }
 
-void CMasternodesView::ForEachSubNode(std::function<bool(SubNodeBlockTimeKey const &, CLazySerialize<int64_t>)> callback, SubNodeBlockTimeKey const & start)
-{
+void CMasternodesView::ForEachSubNode(
+    std::function<bool(const SubNodeBlockTimeKey &, CLazySerialize<int64_t>)> callback,
+    const SubNodeBlockTimeKey &start) {
     ForEach<SubNode, SubNodeBlockTimeKey, int64_t>(callback, start);
 }
 
-void CMasternodesView::EraseSubNodesLastBlockTime(const uint256& nodeId, const uint32_t& blockHeight)
-{
+void CMasternodesView::EraseSubNodesLastBlockTime(const uint256 &nodeId, const uint32_t &blockHeight) {
     for (uint8_t i{0}; i < SUBNODE_COUNT; ++i) {
         EraseBy<SubNode>(SubNodeBlockTimeKey{nodeId, i, blockHeight});
     }
 }
 
-uint16_t CMasternodesView::GetTimelock(const uint256& nodeId, const CMasternode& node, const uint64_t height) const
-{
+uint16_t CMasternodesView::GetTimelock(const uint256 &nodeId, const CMasternode &node, const uint64_t height) const {
     auto timelock = ReadBy<Timelock, uint16_t>(nodeId);
     if (timelock) {
         LOCK(cs_main);
@@ -566,15 +550,17 @@ uint16_t CMasternodesView::GetTimelock(const uint256& nodeId, const CMasternode&
         // Below expiration return timelock
         if (averageTime < timelockExpire) {
             return *timelock;
-        } else { // Expired. Return null.
+        } else {  // Expired. Return null.
             return 0;
         }
     }
     return 0;
 }
 
-std::vector<int64_t> CMasternodesView::GetBlockTimes(const CKeyID& keyID, const uint32_t blockHeight, const int32_t creationHeight, const uint16_t timelock)
-{
+std::vector<int64_t> CMasternodesView::GetBlockTimes(const CKeyID &keyID,
+                                                     const uint32_t blockHeight,
+                                                     const int32_t creationHeight,
+                                                     const uint16_t timelock) {
     // Get last block time for non-subnode staking
     std::optional<int64_t> stakerBlockTime = GetMasternodeLastBlockTime(keyID, blockHeight);
 
@@ -587,7 +573,8 @@ std::vector<int64_t> CMasternodesView::GetBlockTimes(const CKeyID& keyID, const
     }
 
     if (auto block = ::ChainActive()[Params().GetConsensus().EunosPayaHeight]) {
-        if (creationHeight < Params().GetConsensus().DakotaCrescentHeight && !stakerBlockTime && !subNodesBlockTime[0]) {
+        if (creationHeight < Params().GetConsensus().DakotaCrescentHeight && !stakerBlockTime &&
+            !subNodesBlockTime[0]) {
             if (auto dakotaBlock = ::ChainActive()[Params().GetConsensus().DakotaCrescentHeight]) {
                 subNodesBlockTime[0] = dakotaBlock->GetBlockTime();
             }
@@ -608,16 +595,14 @@ std::vector<int64_t> CMasternodesView::GetBlockTimes(const CKeyID& keyID, const
 /*
  *  CLastHeightView
  */
-int CLastHeightView::GetLastHeight() const
-{
+int CLastHeightView::GetLastHeight() const {
     int result;
     if (Read(Height::prefix(), result))
         return result;
     return 0;
 }
 
-void CLastHeightView::SetLastHeight(int height)
-{
+void CLastHeightView::SetLastHeight(int height) {
     SetLastValidatedHeight(height);
     Write(Height::prefix(), height);
 }
@@ -625,31 +610,26 @@ void CLastHeightView::SetLastHeight(int height)
 /*
  *  CFoundationsDebtView
  */
-CAmount CFoundationsDebtView::GetFoundationsDebt() const
-{
+CAmount CFoundationsDebtView::GetFoundationsDebt() const {
     CAmount debt(0);
-    if(Read(Debt::prefix(), debt))
+    if (Read(Debt::prefix(), debt))
         assert(debt >= 0);
     return debt;
 }
 
-void CFoundationsDebtView::SetFoundationsDebt(CAmount debt)
-{
+void CFoundationsDebtView::SetFoundationsDebt(CAmount debt) {
     assert(debt >= 0);
     Write(Debt::prefix(), debt);
 }
 
-
 /*
  *  CTeamView
  */
-void CTeamView::SetTeam(const CTeamView::CTeam & newTeam)
-{
+void CTeamView::SetTeam(const CTeamView::CTeam &newTeam) {
     Write(CurrentTeam::prefix(), newTeam);
 }
 
-CTeamView::CTeam CTeamView::GetCurrentTeam() const
-{
+CTeamView::CTeam CTeamView::GetCurrentTeam() const {
     CTeam team;
     if (Read(CurrentTeam::prefix(), team) && team.size() > 0)
         return team;
@@ -657,19 +637,24 @@ CTeamView::CTeam CTeamView::GetCurrentTeam() const
     return Params().GetGenesisTeam();
 }
 
-void CTeamView::SetAnchorTeams(const CTeam& authTeam, const CTeam& confirmTeam, const int height)
-{
+void CTeamView::SetAnchorTeams(const CTeam &authTeam, const CTeam &confirmTeam, const int height) {
     // Called after fork height
     if (height < Params().GetConsensus().DakotaHeight) {
-        LogPrint(BCLog::ANCHORING, "%s: Called below fork. Fork: %d Arg height: %d\n",
-                 __func__, Params().GetConsensus().DakotaHeight, height);
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Called below fork. Fork: %d Arg height: %d\n",
+                 __func__,
+                 Params().GetConsensus().DakotaHeight,
+                 height);
         return;
     }
 
     // Called every on team change intercal from fork height
     if (height % Params().GetConsensus().mn.anchoringTeamChange != 0) {
-        LogPrint(BCLog::ANCHORING, "%s: Not called on interval of %d, arg height %d\n",
-                 __func__, Params().GetConsensus().mn.anchoringTeamChange, height);
+        LogPrint(BCLog::ANCHORING,
+                 "%s: Not called on interval of %d, arg height %d\n",
+                 __func__,
+                 Params().GetConsensus().mn.anchoringTeamChange,
+                 height);
         return;
     }
 
@@ -682,15 +667,13 @@ void CTeamView::SetAnchorTeams(const CTeam& authTeam, const CTeam& confirmTeam,
     }
 }
 
-std::optional<CTeamView::CTeam> CTeamView::GetAuthTeam(int height) const
-{
+std::optional<CTeamView::CTeam> CTeamView::GetAuthTeam(int height) const {
     height -= height % Params().GetConsensus().mn.anchoringTeamChange;
 
     return ReadBy<AuthTeam, CTeam>(height);
 }
 
-std::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const
-{
+std::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const {
     height -= height % Params().GetConsensus().mn.anchoringTeamChange;
 
     return ReadBy<ConfirmTeam, CTeam>(height);
@@ -699,23 +682,23 @@ std::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const
 /*
  *  CAnchorRewardsView
  */
-std::optional<CAnchorRewardsView::RewardTxHash> CAnchorRewardsView::GetRewardForAnchor(const CAnchorRewardsView::AnchorTxHash & btcTxHash) const
-{
+std::optional<CAnchorRewardsView::RewardTxHash> CAnchorRewardsView::GetRewardForAnchor(
+    const CAnchorRewardsView::AnchorTxHash &btcTxHash) const {
     return ReadBy<BtcTx, RewardTxHash>(btcTxHash);
 }
 
-void CAnchorRewardsView::AddRewardForAnchor(const CAnchorRewardsView::AnchorTxHash & btcTxHash, const CAnchorRewardsView::RewardTxHash & rewardTxHash)
-{
+void CAnchorRewardsView::AddRewardForAnchor(const CAnchorRewardsView::AnchorTxHash &btcTxHash,
+                                            const CAnchorRewardsView::RewardTxHash &rewardTxHash) {
     WriteBy<BtcTx>(btcTxHash, rewardTxHash);
 }
 
-void CAnchorRewardsView::RemoveRewardForAnchor(const CAnchorRewardsView::AnchorTxHash & btcTxHash)
-{
+void CAnchorRewardsView::RemoveRewardForAnchor(const CAnchorRewardsView::AnchorTxHash &btcTxHash) {
     EraseBy<BtcTx>(btcTxHash);
 }
 
-void CAnchorRewardsView::ForEachAnchorReward(std::function<bool (const CAnchorRewardsView::AnchorTxHash &, CLazySerialize<CAnchorRewardsView::RewardTxHash>)> callback)
-{
+void CAnchorRewardsView::ForEachAnchorReward(
+    std::function<bool(const CAnchorRewardsView::AnchorTxHash &, CLazySerialize<CAnchorRewardsView::RewardTxHash>)>
+        callback) {
     ForEach<BtcTx, AnchorTxHash, RewardTxHash>(callback);
 }
 
@@ -723,29 +706,27 @@ void CAnchorRewardsView::ForEachAnchorReward(std::function<bool (const CAnchorRe
  *  CAnchorConfirmsView
  */
 
-void CAnchorConfirmsView::AddAnchorConfirmData(const CAnchorConfirmDataPlus& data)
-{
+void CAnchorConfirmsView::AddAnchorConfirmData(const CAnchorConfirmDataPlus &data) {
     WriteBy<BtcTx>(data.btcTxHash, data);
 }
 
-void CAnchorConfirmsView::EraseAnchorConfirmData(uint256 btcTxHash)
-{
+void CAnchorConfirmsView::EraseAnchorConfirmData(uint256 btcTxHash) {
     EraseBy<BtcTx>(btcTxHash);
 }
 
-void CAnchorConfirmsView::ForEachAnchorConfirmData(std::function<bool(const AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus>)> callback)
-{
+void CAnchorConfirmsView::ForEachAnchorConfirmData(
+    std::function<bool(const AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus>)> callback) {
     ForEach<BtcTx, AnchorTxHash, CAnchorConfirmDataPlus>(callback);
 }
 
-std::vector<CAnchorConfirmDataPlus> CAnchorConfirmsView::GetAnchorConfirmData()
-{
+std::vector<CAnchorConfirmDataPlus> CAnchorConfirmsView::GetAnchorConfirmData() {
     std::vector<CAnchorConfirmDataPlus> confirms;
 
-    ForEachAnchorConfirmData([&confirms](const CAnchorConfirmsView::AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus> data) {
-        confirms.push_back(data);
-        return true;
-    });
+    ForEachAnchorConfirmData(
+        [&confirms](const CAnchorConfirmsView::AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus> data) {
+            confirms.push_back(data);
+            return true;
+        });
 
     return confirms;
 }
@@ -754,71 +735,61 @@ std::vector<CAnchorConfirmDataPlus> CAnchorConfirmsView::GetAnchorConfirmData()
  *  CSettingsView
  */
 
-void CSettingsView::SetDexStatsLastHeight(const int32_t height)
-{
+void CSettingsView::SetDexStatsLastHeight(const int32_t height) {
     WriteBy<KVSettings>(DEX_STATS_LAST_HEIGHT, height);
 }
 
-std::optional<int32_t> CSettingsView::GetDexStatsLastHeight()
-{
+std::optional<int32_t> CSettingsView::GetDexStatsLastHeight() {
     return ReadBy<KVSettings, int32_t>(DEX_STATS_LAST_HEIGHT);
 }
 
-void CSettingsView::SetDexStatsEnabled(const bool enabled)
-{
+void CSettingsView::SetDexStatsEnabled(const bool enabled) {
     WriteBy<KVSettings>(DEX_STATS_ENABLED, enabled);
 }
 
-std::optional<bool> CSettingsView::GetDexStatsEnabled()
-{
+std::optional<bool> CSettingsView::GetDexStatsEnabled() {
     return ReadBy<KVSettings, bool>(DEX_STATS_ENABLED);
 }
 /*
  *  CCustomCSView
  */
-CCustomCSView::CCustomCSView()
-{
+CCustomCSView::CCustomCSView() {
     CheckPrefixes();
 }
 
 CCustomCSView::~CCustomCSView() = default;
 
-CCustomCSView::CCustomCSView(CStorageKV & st)
-    : CStorageView(new CFlushableStorageKV(st))
-{
+CCustomCSView::CCustomCSView(CStorageKV &st)
+    : CStorageView(new CFlushableStorageKV(st)) {
     CheckPrefixes();
 }
 
 // cache-upon-a-cache (not a copy!) constructor
-CCustomCSView::CCustomCSView(CCustomCSView & other)
-    : CStorageView(new CFlushableStorageKV(other.DB()))
-{
+CCustomCSView::CCustomCSView(CCustomCSView &other)
+    : CStorageView(new CFlushableStorageKV(other.DB())) {
     CheckPrefixes();
 }
 
-int CCustomCSView::GetDbVersion() const
-{
+int CCustomCSView::GetDbVersion() const {
     int version;
     if (Read(DbVersion::prefix(), version))
         return version;
     return 0;
 }
 
-void CCustomCSView::SetDbVersion(int version)
-{
+void CCustomCSView::SetDbVersion(int version) {
     Write(DbVersion::prefix(), version);
 }
 
-CTeamView::CTeam CCustomCSView::CalcNextTeam(int height, const uint256 & stakeModifier)
-{
+CTeamView::CTeam CCustomCSView::CalcNextTeam(int height, const uint256 &stakeModifier) {
     if (stakeModifier == uint256())
         return Params().GetGenesisTeam();
 
     int anchoringTeamSize = Params().GetConsensus().mn.anchoringTeamSize;
 
     std::map<arith_uint256, CKeyID, std::less<arith_uint256>> priorityMN;
-    ForEachMasternode([&] (uint256 const & id, CMasternode node) {
-        if(!node.IsActive(height, *this))
+    ForEachMasternode([&](const uint256 &id, CMasternode node) {
+        if (!node.IsActive(height, *this))
             return true;
 
         CDataStream ss{SER_GETHASH, PROTOCOL_VERSION};
@@ -828,26 +799,22 @@ CTeamView::CTeam CCustomCSView::CalcNextTeam(int height, const uint256 & stakeMo
     });
 
     CTeam newTeam;
-    auto && it = priorityMN.begin();
+    auto &&it = priorityMN.begin();
     for (int i = 0; i < anchoringTeamSize && it != priorityMN.end(); ++i, ++it) {
         newTeam.insert(it->second);
     }
     return newTeam;
 }
 
-enum AnchorTeams {
-    AuthTeam,
-    ConfirmTeam
-};
+enum AnchorTeams { AuthTeam, ConfirmTeam };
 
-void CCustomCSView::CalcAnchoringTeams(const uint256 & stakeModifier, const CBlockIndex *pindexNew)
-{
+void CCustomCSView::CalcAnchoringTeams(const uint256 &stakeModifier, const CBlockIndex *pindexNew) {
     std::set<uint256> masternodeIDs;
-    const int blockSample = 7 * Params().GetConsensus().blocksPerDay(); // One week
+    const int blockSample = 7 * Params().GetConsensus().blocksPerDay();  // One week
 
     {
         LOCK(cs_main);
-        const CBlockIndex* pindex = pindexNew;
+        const CBlockIndex *pindex = pindexNew;
         for (int i{0}; pindex && i < blockSample; pindex = pindex->pprev, ++i) {
             if (auto id = GetMasternodeIdByOperator(pindex->minterKey())) {
                 masternodeIDs.insert(*id);
@@ -857,8 +824,8 @@ void CCustomCSView::CalcAnchoringTeams(const uint256 & stakeModifier, const CBlo
 
     std::map<arith_uint256, CKeyID, std::less<arith_uint256>> authMN;
     std::map<arith_uint256, CKeyID, std::less<arith_uint256>> confirmMN;
-    ForEachMasternode([&] (uint256 const & id, CMasternode node) {
-        if(!node.IsActive(pindexNew->nHeight, *this))
+    ForEachMasternode([&](const uint256 &id, CMasternode node) {
+        if (!node.IsActive(pindexNew->nHeight, *this))
             return true;
 
         // Not in our list of MNs from last week, skip.
@@ -868,11 +835,13 @@ void CCustomCSView::CalcAnchoringTeams(const uint256 & stakeModifier, const CBlo
 
         CDataStream authStream{SER_GETHASH, PROTOCOL_VERSION};
         authStream << id << stakeModifier << static_cast<int>(AnchorTeams::AuthTeam);
-        authMN.insert(std::make_pair(UintToArith256(Hash(authStream.begin(), authStream.end())), node.operatorAuthAddress));
+        authMN.insert(
+            std::make_pair(UintToArith256(Hash(authStream.begin(), authStream.end())), node.operatorAuthAddress));
 
         CDataStream confirmStream{SER_GETHASH, PROTOCOL_VERSION};
         confirmStream << id << stakeModifier << static_cast<int>(AnchorTeams::ConfirmTeam);
-        confirmMN.insert(std::make_pair(UintToArith256(Hash(confirmStream.begin(), confirmStream.end())), node.operatorAuthAddress));
+        confirmMN.insert(
+            std::make_pair(UintToArith256(Hash(confirmStream.begin(), confirmStream.end())), node.operatorAuthAddress));
 
         return true;
     });
@@ -880,7 +849,7 @@ void CCustomCSView::CalcAnchoringTeams(const uint256 & stakeModifier, const CBlo
     int anchoringTeamSize = Params().GetConsensus().mn.anchoringTeamSize;
 
     CTeam authTeam;
-    auto && it = authMN.begin();
+    auto &&it = authMN.begin();
     for (int i = 0; i < anchoringTeamSize && it != authMN.end(); ++i, ++it) {
         authTeam.insert(it->second);
     }
@@ -899,20 +868,22 @@ void CCustomCSView::CalcAnchoringTeams(const uint256 & stakeModifier, const CBlo
     // Debug logging
     LogPrint(BCLog::ANCHORING, "MNs found: %d Team sizes: %d\n", masternodeIDs.size(), authTeam.size());
 
-    for (auto& item : authTeam) {
+    for (auto &item : authTeam) {
         LogPrint(BCLog::ANCHORING, "Auth team operator addresses: %s\n", item.ToString());
     }
 
-    for (auto& item : confirmTeam) {
+    for (auto &item : confirmTeam) {
         LogPrint(BCLog::ANCHORING, "Confirm team operator addresses: %s\n", item.ToString());
     }
 }
 
 /// @todo newbase move to networking?
-void CCustomCSView::CreateAndRelayConfirmMessageIfNeed(const CAnchorIndex::AnchorRec *anchor, const uint256 & btcTxHash, const CKey& masternodeKey)
-{
-    auto prev = panchors->GetAnchorByTx(anchor->anchor.previousAnchor);
-    auto confirmMessage = CAnchorConfirmMessage::CreateSigned(anchor->anchor, prev ? prev->anchor.height : 0, btcTxHash, masternodeKey, anchor->btcHeight);
+void CCustomCSView::CreateAndRelayConfirmMessageIfNeed(const CAnchorIndex::AnchorRec *anchor,
+                                                       const uint256 &btcTxHash,
+                                                       const CKey &masternodeKey) {
+    auto prev           = panchors->GetAnchorByTx(anchor->anchor.previousAnchor);
+    auto confirmMessage = CAnchorConfirmMessage::CreateSigned(
+        anchor->anchor, prev ? prev->anchor.height : 0, btcTxHash, masternodeKey, anchor->btcHeight);
 
     if (panchorAwaitingConfirms->Add(*confirmMessage)) {
         LogPrint(BCLog::ANCHORING, "%s: Create message %s\n", __func__, confirmMessage->GetHash().GetHex());
@@ -920,18 +891,16 @@ void CCustomCSView::CreateAndRelayConfirmMessageIfNeed(const CAnchorIndex::Ancho
     }
 }
 
-void CCustomCSView::OnUndoTx(uint256 const & txid, uint32_t height)
-{
+void CCustomCSView::OnUndoTx(const uint256 &txid, uint32_t height) {
     const auto undo = GetUndo(UndoKey{height, txid});
     if (!undo) {
-        return; // not custom tx, or no changes done
+        return;  // not custom tx, or no changes done
     }
-    CUndo::Revert(GetStorage(), *undo); // revert the changes of this tx
-    DelUndo(UndoKey{height, txid}); // erase undo data, it served its purpose
+    CUndo::Revert(GetStorage(), *undo);  // revert the changes of this tx
+    DelUndo(UndoKey{height, txid});      // erase undo data, it served its purpose
 }
 
-bool CCustomCSView::CanSpend(const uint256 & txId, int height) const
-{
+bool CCustomCSView::CanSpend(const uint256 &txId, int height) const {
     auto node = GetMasternode(txId);
     // check if it was mn collateral and mn was resigned or banned
     if (node) {
@@ -952,62 +921,60 @@ bool CCustomCSView::CanSpend(const uint256 & txId, int height) const
     return !pair || pair->second.destructionTx != uint256{} || pair->second.IsPoolShare();
 }
 
-bool CCustomCSView::CalculateOwnerRewards(CScript const & owner, uint32_t targetHeight)
-{
+bool CCustomCSView::CalculateOwnerRewards(const CScript &owner, uint32_t targetHeight) {
     auto balanceHeight = GetBalancesHeight(owner);
     if (balanceHeight >= targetHeight) {
         return false;
     }
-    ForEachPoolId([&] (DCT_ID const & poolId) {
+    ForEachPoolId([&](DCT_ID const &poolId) {
         auto height = GetShare(poolId, owner);
         if (!height || *height >= targetHeight) {
-            return true; // no share or target height is before a pool share' one
+            return true;  // no share or target height is before a pool share' one
         }
-        auto onLiquidity = [&]() -> CAmount {
-            return GetBalance(owner, poolId).nValue;
-        };
+        auto onLiquidity = [&]() -> CAmount { return GetBalance(owner, poolId).nValue; };
         auto beginHeight = std::max(*height, balanceHeight);
-        CalculatePoolRewards(poolId, onLiquidity, beginHeight, targetHeight,
-            [&](RewardType, CTokenAmount amount, uint32_t height) {
+        CalculatePoolRewards(
+            poolId, onLiquidity, beginHeight, targetHeight, [&](RewardType, CTokenAmount amount, uint32_t height) {
                 auto res = AddBalance(owner, amount);
                 if (!res) {
-                    LogPrintf("Pool rewards: can't update balance of %s: %s, height %ld\n", owner.GetHex(), res.msg, targetHeight);
+                    LogPrintf("Pool rewards: can't update balance of %s: %s, height %ld\n",
+                              owner.GetHex(),
+                              res.msg,
+                              targetHeight);
                 }
-            }
-        );
+            });
         return true;
     });
 
     return UpdateBalancesHeight(owner, targetHeight);
 }
 
-double CCollateralLoans::calcRatio(uint64_t maxRatio) const
-{
+double CCollateralLoans::calcRatio(uint64_t maxRatio) const {
     return !totalLoans ? double(maxRatio) : double(totalCollaterals) / totalLoans;
 }
 
-uint32_t CCollateralLoans::ratio() const
-{
+uint32_t CCollateralLoans::ratio() const {
     constexpr auto maxRatio = std::numeric_limits<uint32_t>::max();
-    auto ratio = calcRatio(maxRatio) * 100;
+    auto ratio              = calcRatio(maxRatio) * 100;
     return ratio > maxRatio ? maxRatio : uint32_t(lround(ratio));
 }
 
-CAmount CCollateralLoans::precisionRatio() const
-{
+CAmount CCollateralLoans::precisionRatio() const {
     constexpr auto maxRatio = std::numeric_limits<CAmount>::max();
-    auto ratio = calcRatio(maxRatio);
-    const auto precision = COIN * 100;
+    auto ratio              = calcRatio(maxRatio);
+    const auto precision    = COIN * 100;
     return ratio > maxRatio / precision ? -COIN : CAmount(ratio * precision);
 }
 
-ResVal<CAmount> CCustomCSView::GetAmountInCurrency(CAmount amount, CTokenCurrencyPair priceFeedId, bool useNextPrice, bool requireLivePrice)
-{
+ResVal<CAmount> CCustomCSView::GetAmountInCurrency(CAmount amount,
+                                                   CTokenCurrencyPair priceFeedId,
+                                                   bool useNextPrice,
+                                                   bool requireLivePrice) {
     auto priceResult = GetValidatedIntervalPrice(priceFeedId, useNextPrice, requireLivePrice);
     if (!priceResult)
         return priceResult;
 
-    auto price = *priceResult.val;
+    auto price            = *priceResult.val;
     auto amountInCurrency = MultiplyAmounts(price, amount);
     if (price > COIN && amountInCurrency < amount)
         return Res::Err("Value/price too high (%s/%s)", GetDecimaleString(amount), GetDecimaleString(price));
@@ -1015,9 +982,12 @@ ResVal<CAmount> CCustomCSView::GetAmountInCurrency(CAmount amount, CTokenCurrenc
     return {amountInCurrency, Res::Ok()};
 }
 
-ResVal<CCollateralLoans> CCustomCSView::GetLoanCollaterals(CVaultId const& vaultId, CBalances const& collaterals, uint32_t height,
-                                                           int64_t blockTime, bool useNextPrice, bool requireLivePrice)
-{
+ResVal<CCollateralLoans> CCustomCSView::GetLoanCollaterals(const CVaultId &vaultId,
+                                                           const CBalances &collaterals,
+                                                           uint32_t height,
+                                                           int64_t blockTime,
+                                                           bool useNextPrice,
+                                                           bool requireLivePrice) {
     const auto vault = GetVault(vaultId);
     if (!vault || vault->isUnderLiquidation)
         return Res::Err("Vault is under liquidation");
@@ -1031,16 +1001,21 @@ ResVal<CCollateralLoans> CCustomCSView::GetLoanCollaterals(CVaultId const& vault
     if (!res)
         return std::move(res);
 
-    LogPrint(BCLog::LOAN, "%s(): totalCollaterals - %lld, totalLoans - %lld, ratio - %d\n",
-        __func__, result.totalCollaterals, result.totalLoans, result.ratio());
+    LogPrint(BCLog::LOAN,
+             "%s(): totalCollaterals - %lld, totalLoans - %lld, ratio - %d\n",
+             __func__,
+             result.totalCollaterals,
+             result.totalLoans,
+             result.ratio());
 
     return {result, Res::Ok()};
 }
 
-ResVal<CAmount> CCustomCSView::GetValidatedIntervalPrice(const 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;
+    auto currency    = priceFeedId.second;
 
     auto priceFeed = GetFixedIntervalPrice(priceFeedId);
     if (!priceFeed)
@@ -1050,22 +1025,24 @@ ResVal<CAmount> CCustomCSView::GetValidatedIntervalPrice(const CTokenCurrencyPai
         return Res::Err("No live fixed prices for %s/%s", tokenSymbol, currency);
 
     auto priceRecordIndex = useNextPrice ? 1 : 0;
-    auto price = priceFeed.val->priceRecord[priceRecordIndex];
+    auto price            = priceFeed.val->priceRecord[priceRecordIndex];
     if (price <= 0)
         return Res::Err("Negative price (%s/%s)", tokenSymbol, currency);
 
     return {price, Res::Ok()};
 }
 
-Res CCustomCSView::PopulateLoansData(CCollateralLoans& result, CVaultId const& vaultId, uint32_t height,
-                                     int64_t blockTime, bool useNextPrice, bool requireLivePrice)
-{
+Res CCustomCSView::PopulateLoansData(CCollateralLoans &result,
+                                     const CVaultId &vaultId,
+                                     uint32_t height,
+                                     int64_t blockTime,
+                                     bool useNextPrice,
+                                     bool requireLivePrice) {
     const auto loanTokens = GetLoanTokens(vaultId);
     if (!loanTokens)
         return Res::Ok();
 
-    for (const auto& [loanTokenId, loanTokenAmount] : loanTokens->balances) {
-
+    for (const auto &[loanTokenId, loanTokenAmount] : loanTokens->balances) {
         const auto token = GetLoanTokenByID(loanTokenId);
         if (!token)
             return Res::Err("Loan token with id (%s) does not exist!", loanTokenId.ToString());
@@ -1081,7 +1058,8 @@ Res CCustomCSView::PopulateLoansData(CCollateralLoans& result, CVaultId const& v
         if (totalAmount < 0) {
             totalAmount = 0;
         }
-        const auto amountInCurrency = GetAmountInCurrency(totalAmount, token->fixedIntervalPriceId, useNextPrice, requireLivePrice);
+        const auto amountInCurrency =
+            GetAmountInCurrency(totalAmount, token->fixedIntervalPriceId, useNextPrice, requireLivePrice);
         if (!amountInCurrency)
             return amountInCurrency;
 
@@ -1096,18 +1074,23 @@ Res CCustomCSView::PopulateLoansData(CCollateralLoans& result, CVaultId const& v
     return Res::Ok();
 }
 
-Res CCustomCSView::PopulateCollateralData(CCollateralLoans& result, CVaultId const& vaultId, CBalances const& collaterals,
-                                          uint32_t height, int64_t blockTime, bool useNextPrice, bool requireLivePrice)
-{
-    for (const auto& col : collaterals.balances) {
-        auto tokenId = col.first;
+Res CCustomCSView::PopulateCollateralData(CCollateralLoans &result,
+                                          const CVaultId &vaultId,
+                                          const CBalances &collaterals,
+                                          uint32_t height,
+                                          int64_t blockTime,
+                                          bool useNextPrice,
+                                          bool requireLivePrice) {
+    for (const auto &col : collaterals.balances) {
+        auto tokenId     = col.first;
         auto tokenAmount = col.second;
 
         auto token = HasLoanCollateralToken({tokenId, height});
         if (!token)
             return Res::Err("Collateral token with id (%s) does not exist!", tokenId.ToString());
 
-        auto amountInCurrency = GetAmountInCurrency(tokenAmount, token->fixedIntervalPriceId, useNextPrice, requireLivePrice);
+        auto amountInCurrency =
+            GetAmountInCurrency(tokenAmount, token->fixedIntervalPriceId, useNextPrice, requireLivePrice);
         if (!amountInCurrency)
             return std::move(amountInCurrency);
 
@@ -1129,7 +1112,7 @@ uint256 CCustomCSView::MerkleRoot() {
     if (rawMap.empty()) {
         return {};
     }
-    auto isAttributes = [](const TBytes& key) {
+    auto isAttributes = [](const TBytes &key) {
         MapKV map = {std::make_pair(key, TBytes{})};
         // Attributes should not be part of merkle root
         static const std::string attributes("ATTRIBUTES");
@@ -1140,16 +1123,16 @@ uint256 CCustomCSView::MerkleRoot() {
     auto it = NewKVIterator<CUndosView::ByUndoKey>(UndoKey{}, rawMap);
     for (; it.Valid(); it.Next()) {
         CUndo value = it.Value();
-        auto& map = value.before;
+        auto &map   = value.before;
         for (auto it = map.begin(); it != map.end();) {
             isAttributes(it->first) ? map.erase(it++) : ++it;
         }
-        auto key = std::make_pair(CUndosView::ByUndoKey::prefix(), static_cast<const UndoKey&>(it.Key()));
+        auto key = std::make_pair(CUndosView::ByUndoKey::prefix(), static_cast<const UndoKey &>(it.Key()));
         rawMap[DbTypeToBytes(key)] = DbTypeToBytes(value);
     }
 
     std::vector<uint256> hashes;
-    for (const auto& [key, value] : rawMap) {
+    for (const auto &[key, value] : rawMap) {
         if (!isAttributes(key)) {
             hashes.push_back(Hash2(key, value ? *value : TBytes{}));
         }
@@ -1157,14 +1140,13 @@ uint256 CCustomCSView::MerkleRoot() {
     return ComputeMerkleRoot(std::move(hashes));
 }
 
-bool CCustomCSView::AreTokensLocked(const std::set<uint32_t>& tokenIds) const
-{
+bool CCustomCSView::AreTokensLocked(const std::set<uint32_t> &tokenIds) const {
     const auto attributes = GetAttributes();
     if (!attributes) {
         return false;
     }
 
-    for (const auto& tokenId : tokenIds) {
+    for (const auto &tokenId : tokenIds) {
         CDataStructureV0 lockKey{AttributeTypes::Locks, ParamIDs::TokenID, tokenId};
         if (attributes->GetValue(lockKey, false)) {
             return true;
@@ -1174,8 +1156,7 @@ bool CCustomCSView::AreTokensLocked(const std::set<uint32_t>& tokenIds) const
     return false;
 }
 
-std::optional<CTokensView::CTokenImpl> CCustomCSView::GetTokenGuessId(const std::string & str, DCT_ID & id) const
-{
+std::optional<CTokensView::CTokenImpl> CCustomCSView::GetTokenGuessId(const std::string &str, DCT_ID &id) const {
     std::string const key = trim_ws(str);
 
     if (key.empty()) {
@@ -1202,8 +1183,7 @@ std::optional<CTokensView::CTokenImpl> CCustomCSView::GetTokenGuessId(const std:
     return {};
 }
 
-std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenByID(DCT_ID const & id) const
-{
+std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenByID(DCT_ID const &id) const {
     auto loanToken = ReadBy<LoanSetLoanTokenKey, CLoanSetLoanTokenImpl>(id);
     if (loanToken) {
         return loanToken;
@@ -1212,14 +1192,12 @@ std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenByID(
     return GetLoanTokenFromAttributes(id);
 }
 
-std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team)
-{
+std::map<CKeyID, CKey> AmISignerNow(int height, const CAnchorData::CTeam &team) {
     AssertLockHeld(cs_main);
 
     std::map<CKeyID, CKey> operatorDetails;
-    auto const mnIds = pcustomcsview->GetOperatorsMulti();
-    for (const auto& mnId : mnIds)
-    {
+    const auto mnIds = pcustomcsview->GetOperatorsMulti();
+    for (const auto &mnId : mnIds) {
         auto node = pcustomcsview->GetMasternode(mnId.second);
         if (!node) {
             continue;
@@ -1228,7 +1206,7 @@ std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team)
         if (node->IsActive(height, *pcustomcsview) && team.find(mnId.first) != team.end()) {
             CKey masternodeKey;
             std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
-            for (auto const & wallet : wallets) {
+            for (const auto &wallet : wallets) {
                 if (wallet->GetKey(mnId.first, masternodeKey)) {
                     break;
                 }
@@ -1243,20 +1221,20 @@ std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team)
     return operatorDetails;
 }
 
-std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenFromAttributes(const DCT_ID& id) const {
+std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenFromAttributes(const DCT_ID &id) const {
     if (const auto attributes = GetAttributes()) {
-
         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 (const auto token = GetToken(id); token && attributes->CheckKey(pairKey) && attributes->CheckKey(interestKey) && attributes->CheckKey(mintableKey)) {
+        if (const auto token = GetToken(id); token && attributes->CheckKey(pairKey) &&
+                                             attributes->CheckKey(interestKey) && attributes->CheckKey(mintableKey)) {
             CLoanView::CLoanSetLoanTokenImpl loanToken;
             loanToken.fixedIntervalPriceId = attributes->GetValue(pairKey, CTokenCurrencyPair{});
-            loanToken.interest = attributes->GetValue(interestKey, CAmount{});
-            loanToken.mintable = attributes->GetValue(mintableKey, false);
-            loanToken.symbol = token->symbol;
-            loanToken.name = token->name;
+            loanToken.interest             = attributes->GetValue(interestKey, CAmount{});
+            loanToken.mintable             = attributes->GetValue(mintableKey, false);
+            loanToken.symbol               = token->symbol;
+            loanToken.name                 = token->name;
             return loanToken;
         }
     }
@@ -1264,7 +1242,8 @@ std::optional<CLoanView::CLoanSetLoanTokenImpl> CCustomCSView::GetLoanTokenFromA
     return {};
 }
 
-std::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollateralTokenFromAttributes(const DCT_ID& id) const {
+std::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollateralTokenFromAttributes(
+    const DCT_ID &id) const {
     if (const auto attributes = GetAttributes()) {
         CLoanSetCollateralTokenImplementation collToken;
 
@@ -1272,10 +1251,9 @@ std::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollater
         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;
+            collToken.factor               = attributes->GetValue(factorKey, CAmount{0});
+            collToken.idToken              = id;
 
             auto token = GetToken(id);
             if (token) {
@@ -1289,11 +1267,11 @@ std::optional<CLoanView::CLoanSetCollateralTokenImpl> CCustomCSView::GetCollater
     return {};
 }
 
-CAccountHistoryStorage* CCustomCSView::GetAccountHistoryStore() {
+CAccountHistoryStorage *CCustomCSView::GetAccountHistoryStore() {
     return accHistoryStore.get();
 }
 
-CVaultHistoryStorage* CCustomCSView::GetVaultHistoryStore() {
+CVaultHistoryStorage *CCustomCSView::GetVaultHistoryStore() {
     return vauHistoryStore.get();
 }
 
@@ -1311,8 +1289,7 @@ void CCustomCSView::SetVaultHistoryStore() {
     }
 }
 
-uint32_t CCustomCSView::GetVotingPeriodFromAttributes() const
-{
+uint32_t CCustomCSView::GetVotingPeriodFromAttributes() const {
     auto attributes = GetAttributes();
     assert(attributes);
 
@@ -1321,8 +1298,7 @@ uint32_t CCustomCSView::GetVotingPeriodFromAttributes() const
     return attributes->GetValue(votingKey, Params().GetConsensus().props.votingPeriod);
 }
 
-uint32_t CCustomCSView::GetEmergencyPeriodFromAttributes(const CPropType& type) const
-{
+uint32_t CCustomCSView::GetEmergencyPeriodFromAttributes(const CPropType &type) const {
     auto attributes = GetAttributes();
     assert(attributes);
 
@@ -1330,15 +1306,14 @@ uint32_t CCustomCSView::GetEmergencyPeriodFromAttributes(const CPropType& type)
     return attributes->GetValue(VOCKey, uint32_t{8640});
 }
 
-CAmount CCustomCSView::GetApprovalThresholdFromAttributes(const CPropType& type) const
-{
+CAmount CCustomCSView::GetApprovalThresholdFromAttributes(const CPropType &type) const {
     auto attributes = GetAttributes();
     assert(attributes);
 
     CDataStructureV0 CFPKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::CFPMajority};
     CDataStructureV0 VOCKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCMajority};
 
-    switch(type) {
+    switch (type) {
         case CPropType::CommunityFundProposal:
             return attributes->GetValue(CFPKey, Params().GetConsensus().props.cfp.approvalThreshold) / 10000;
         case CPropType::VoteOfConfidence:
@@ -1348,13 +1323,13 @@ CAmount CCustomCSView::GetApprovalThresholdFromAttributes(const CPropType& type)
     return 0;
 }
 
-CAmount CCustomCSView::GetQuorumFromAttributes(const CPropType& type, bool emergency) const
-{
+CAmount CCustomCSView::GetQuorumFromAttributes(const CPropType &type, bool emergency) const {
     auto attributes = GetAttributes();
     assert(attributes);
 
     CDataStructureV0 quorumKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::Quorum};
-    CDataStructureV0 vocEmergencyQuorumKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCEmergencyQuorum};
+    CDataStructureV0 vocEmergencyQuorumKey{
+        AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::VOCEmergencyQuorum};
 
     if (type == CPropType::VoteOfConfidence && emergency) {
         return attributes->GetValue(vocEmergencyQuorumKey, COIN / 10) / 10000;
@@ -1363,8 +1338,7 @@ CAmount CCustomCSView::GetQuorumFromAttributes(const CPropType& type, bool emerg
     return attributes->GetValue(quorumKey, Params().GetConsensus().props.quorum) / 10000;
 }
 
-CAmount CCustomCSView::GetFeeBurnPctFromAttributes() const
-{
+CAmount CCustomCSView::GetFeeBurnPctFromAttributes() const {
     auto attributes = GetAttributes();
     assert(attributes);
 
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 5c0ec32800..a0b9e7ae68 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -7,8 +7,6 @@
 
 #include <amount.h>
 #include <flushablestorage.h>
-#include <pubkey.h>
-#include <serialize.h>
 #include <masternodes/accounts.h>
 #include <masternodes/anchors.h>
 #include <masternodes/gv.h>
@@ -21,14 +19,16 @@
 #include <masternodes/tokens.h>
 #include <masternodes/undos.h>
 #include <masternodes/vault.h>
+#include <pubkey.h>
+#include <serialize.h>
 #include <uint256.h>
 #include <wallet/ismine.h>
 
+#include <stdint.h>
 #include <functional>
 #include <iostream>
 #include <map>
 #include <set>
-#include <stdint.h>
 
 class CAccountHistoryStorage;
 class CBlockIndex;
@@ -43,21 +43,19 @@ CAmount GetTokenCollateralAmount();
 CAmount GetMnCreationFee(int height);
 CAmount GetTokenCreationFee(int height);
 CAmount GetMnCollateralAmount(int height);
-CAmount GetPropsCreationFee(int height, const CCustomCSView& view, const CCreatePropMessage& msg);
-
-enum class UpdateMasternodeType : uint8_t
-{
-    None                   = 0x00,
-    OwnerAddress           = 0x01,
-    OperatorAddress        = 0x02,
-    SetRewardAddress       = 0x03,
-    RemRewardAddress       = 0x04
+CAmount GetPropsCreationFee(int height, const CCustomCSView &view, const CCreatePropMessage &msg);
+
+enum class UpdateMasternodeType : uint8_t {
+    None             = 0x00,
+    OwnerAddress     = 0x01,
+    OperatorAddress  = 0x02,
+    SetRewardAddress = 0x03,
+    RemRewardAddress = 0x04
 };
 
 constexpr uint8_t SUBNODE_COUNT{4};
 
-class CMasternode
-{
+class CMasternode {
 public:
     enum State {
         PRE_ENABLED,
@@ -65,18 +63,14 @@ class CMasternode
         PRE_RESIGNED,
         RESIGNED,
         TRANSFERRING,
-        UNKNOWN // unreachable
+        UNKNOWN  // unreachable
     };
 
-    enum TimeLock {
-        ZEROYEAR,
-        FIVEYEAR = 260,
-        TENYEAR = 520
-    };
+    enum TimeLock { ZEROYEAR, FIVEYEAR = 260, TENYEAR = 520 };
 
     enum Version : int32_t {
         PRE_FORT_CANNING = -1,
-        VERSION0 = 0,
+        VERSION0         = 0,
     };
 
     //! Minted blocks counter
@@ -108,8 +102,8 @@ class CMasternode
     //! empty constructor
     CMasternode();
 
-    State GetState(int height, const CMasternodesView& mnview) const;
-    bool IsActive(int height, const CMasternodesView& mnview) const;
+    State GetState(int height, const CMasternodesView &mnview) const;
+    bool IsActive(int height, const CMasternodesView &mnview) const;
 
     static std::string GetHumanReadableState(State state);
     static std::string GetTimelockToString(TimeLock timelock);
@@ -117,8 +111,7 @@ class CMasternode
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(mintedBlocks);
         READWRITE(ownerAuthAddress);
         READWRITE(ownerType);
@@ -140,20 +133,18 @@ class CMasternode
     }
 
     //! equality test
-    friend bool operator==(CMasternode const & a, CMasternode const & b);
-    friend bool operator!=(CMasternode const & a, CMasternode const & b);
+    friend bool operator==(const CMasternode &a, const CMasternode &b);
+    friend bool operator!=(const CMasternode &a, const CMasternode &b);
 };
 
-
-struct MNBlockTimeKey
-{
+struct MNBlockTimeKey {
     uint256 masternodeID;
     uint32_t blockHeight;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(masternodeID);
 
         if (ser_action.ForRead()) {
@@ -166,8 +157,7 @@ struct MNBlockTimeKey
     }
 };
 
-struct SubNodeBlockTimeKey
-{
+struct SubNodeBlockTimeKey {
     uint256 masternodeID;
     uint8_t subnode;
     uint32_t blockHeight;
@@ -175,7 +165,7 @@ struct SubNodeBlockTimeKey
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(masternodeID);
         READWRITE(subnode);
 
@@ -189,33 +179,31 @@ struct SubNodeBlockTimeKey
     }
 };
 
-struct MNNewOwnerHeightValue
-{
+struct MNNewOwnerHeightValue {
     uint32_t blockHeight;
     uint256 masternodeID;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(blockHeight);
         READWRITE(masternodeID);
     }
 };
 
-class CMasternodesView : public virtual CStorageView
-{
+class CMasternodesView : public virtual CStorageView {
     std::map<CKeyID, std::pair<uint32_t, int64_t>> minterTimeCache;
 
 public:
+    std::optional<CMasternode> GetMasternode(const uint256 &id) const;
+    std::optional<uint256> GetMasternodeIdByOperator(const CKeyID &id) const;
+    std::optional<uint256> GetMasternodeIdByOwner(const CKeyID &id) const;
+    void ForEachMasternode(std::function<bool(const uint256 &, CLazySerialize<CMasternode>)> callback,
+                           const uint256 &start = uint256());
 
-    std::optional<CMasternode> GetMasternode(uint256 const & id) const;
-    std::optional<uint256> GetMasternodeIdByOperator(CKeyID const & id) const;
-    std::optional<uint256> GetMasternodeIdByOwner(CKeyID const & id) const;
-    void ForEachMasternode(std::function<bool(uint256 const &, CLazySerialize<CMasternode>)> callback, uint256 const & start = uint256());
-
-    void IncrementMintedBy(const uint256& nodeId);
-    void DecrementMintedBy(const uint256& nodeId);
+    void IncrementMintedBy(const uint256 &nodeId);
+    void DecrementMintedBy(const uint256 &nodeId);
 
     std::optional<std::pair<CKeyID, uint256>> AmIOperator() const;
     std::optional<std::pair<CKeyID, uint256>> AmIOwner() const;
@@ -223,135 +211,180 @@ class CMasternodesView : public virtual CStorageView
     // Multiple operator support
     std::set<std::pair<CKeyID, uint256>> GetOperatorsMulti() const;
 
-    Res CreateMasternode(uint256 const & nodeId, CMasternode const & node, uint16_t timelock);
-    Res ResignMasternode(CMasternode& node, uint256 const & nodeId, uint256 const & txid, int height);
+    Res CreateMasternode(const uint256 &nodeId, const CMasternode &node, uint16_t timelock);
+    Res ResignMasternode(CMasternode &node, const uint256 &nodeId, const uint256 &txid, int height);
 
     // Masternode updates
-    void SetForcedRewardAddress(uint256 const & nodeId, CMasternode& node, const char rewardAddressType, CKeyID const & rewardAddress, int height);
-    void RemForcedRewardAddress(uint256 const & nodeId, CMasternode& node, int height);
-    void UpdateMasternodeOperator(uint256 const & nodeId, CMasternode& node, const char operatorType, const CKeyID& operatorAuthAddress, int height);
-    void UpdateMasternodeOwner(uint256 const & nodeId, CMasternode& node, const char ownerType, const CKeyID& ownerAuthAddress);
-    void UpdateMasternodeCollateral(uint256 const & nodeId, CMasternode& node, const uint256& newCollateralTx, const int height);
-    [[nodiscard]] std::optional<MNNewOwnerHeightValue> GetNewCollateral(const uint256& txid) const;
+    void SetForcedRewardAddress(const uint256 &nodeId,
+                                CMasternode &node,
+                                const char rewardAddressType,
+                                const CKeyID &rewardAddress,
+                                int height);
+    void RemForcedRewardAddress(const uint256 &nodeId, CMasternode &node, int height);
+    void UpdateMasternodeOperator(const uint256 &nodeId,
+                                  CMasternode &node,
+                                  const char operatorType,
+                                  const CKeyID &operatorAuthAddress,
+                                  int height);
+    void UpdateMasternodeOwner(const uint256 &nodeId,
+                               CMasternode &node,
+                               const char ownerType,
+                               const CKeyID &ownerAuthAddress);
+    void UpdateMasternodeCollateral(const uint256 &nodeId,
+                                    CMasternode &node,
+                                    const uint256 &newCollateralTx,
+                                    const int height);
+    [[nodiscard]] std::optional<MNNewOwnerHeightValue> GetNewCollateral(const uint256 &txid) const;
     [[nodiscard]] std::optional<uint32_t> GetPendingHeight(const CKeyID &ownerAuthAddress) const;
-    void ForEachNewCollateral(std::function<bool(const uint256&, CLazySerialize<MNNewOwnerHeightValue>)> callback);
+    void ForEachNewCollateral(std::function<bool(const uint256 &, CLazySerialize<MNNewOwnerHeightValue>)> callback);
     void ForEachPendingHeight(std::function<bool(const CKeyID &ownerAuthAddress, const uint32_t &height)> callback);
     void ErasePendingHeight(const CKeyID &ownerAuthAddress);
 
     // Get blocktimes for non-subnode and subnode with fork logic
-    std::vector<int64_t> GetBlockTimes(const CKeyID& keyID, const uint32_t blockHeight, const int32_t creationHeight, const uint16_t timelock);
+    std::vector<int64_t> GetBlockTimes(const CKeyID &keyID,
+                                       const uint32_t blockHeight,
+                                       const int32_t creationHeight,
+                                       const uint16_t timelock);
 
     // Non-subnode block times
-    void SetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t &blockHeight, const int64_t &time);
-    std::optional<int64_t> GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height);
-    void EraseMasternodeLastBlockTime(const uint256 &minter, const uint32_t& blockHeight);
-    void ForEachMinterNode(std::function<bool(MNBlockTimeKey const &, CLazySerialize<int64_t>)> callback,
-        MNBlockTimeKey const & start = {uint256{}, std::numeric_limits<uint32_t>::max()});
+    void SetMasternodeLastBlockTime(const CKeyID &minter, const uint32_t &blockHeight, const int64_t &time);
+    std::optional<int64_t> GetMasternodeLastBlockTime(const CKeyID &minter, const uint32_t height);
+    void EraseMasternodeLastBlockTime(const uint256 &minter, const uint32_t &blockHeight);
+    void ForEachMinterNode(std::function<bool(const MNBlockTimeKey &, CLazySerialize<int64_t>)> callback,
+                           const MNBlockTimeKey &start = {uint256{}, std::numeric_limits<uint32_t>::max()});
 
     // Subnode block times
-    void SetSubNodesBlockTime(const CKeyID & minter, const uint32_t &blockHeight, const uint8_t id, const int64_t& time);
-    std::vector<int64_t> GetSubNodesBlockTime(const CKeyID & minter, const uint32_t height);
-    void EraseSubNodesLastBlockTime(const uint256& nodeId, const uint32_t& blockHeight);
-    void ForEachSubNode(std::function<bool(SubNodeBlockTimeKey const &, CLazySerialize<int64_t>)> callback,
-        SubNodeBlockTimeKey const & start = {uint256{}, uint8_t{}, std::numeric_limits<uint32_t>::max()});
+    void SetSubNodesBlockTime(const CKeyID &minter, const uint32_t &blockHeight, const uint8_t id, const int64_t &time);
+    std::vector<int64_t> GetSubNodesBlockTime(const CKeyID &minter, const uint32_t height);
+    void EraseSubNodesLastBlockTime(const uint256 &nodeId, const uint32_t &blockHeight);
+    void ForEachSubNode(std::function<bool(const SubNodeBlockTimeKey &, CLazySerialize<int64_t>)> callback,
+                        const SubNodeBlockTimeKey &start = {uint256{},
+                                                            uint8_t{},
+                                                            std::numeric_limits<uint32_t>::max()});
 
-    uint16_t GetTimelock(const uint256& nodeId, const CMasternode& node, const uint64_t height) const;
+    uint16_t GetTimelock(const uint256 &nodeId, const CMasternode &node, const uint64_t height) const;
 
     // tags
-    struct ID       { static constexpr uint8_t prefix() { return 'M'; } };
-    struct Operator { static constexpr uint8_t prefix() { return 'o'; } };
-    struct Owner    { static constexpr uint8_t prefix() { return 'w'; } };
-    struct NewCollateral { static constexpr uint8_t prefix() { return 's'; } };
-    struct PendingHeight { static constexpr uint8_t prefix() { return 'E'; } };
+    struct ID {
+        static constexpr uint8_t prefix() { return 'M'; }
+    };
+    struct Operator {
+        static constexpr uint8_t prefix() { return 'o'; }
+    };
+    struct Owner {
+        static constexpr uint8_t prefix() { return 'w'; }
+    };
+    struct NewCollateral {
+        static constexpr uint8_t prefix() { return 's'; }
+    };
+    struct PendingHeight {
+        static constexpr uint8_t prefix() { return 'E'; }
+    };
 
     // For storing last staked block time
-    struct Staker   { static constexpr uint8_t prefix() { return 'X'; } };
-    struct SubNode  { static constexpr uint8_t prefix() { return 'Z'; } };
+    struct Staker {
+        static constexpr uint8_t prefix() { return 'X'; }
+    };
+    struct SubNode {
+        static constexpr uint8_t prefix() { return 'Z'; }
+    };
 
     // Store long term time lock
-    struct Timelock { static constexpr uint8_t prefix() { return 'K'; } };
+    struct Timelock {
+        static constexpr uint8_t prefix() { return 'K'; }
+    };
 };
 
-class CLastHeightView : public virtual CStorageView
-{
+class CLastHeightView : public virtual CStorageView {
 public:
     int GetLastHeight() const;
     void SetLastHeight(int height);
 
-    struct Height { static constexpr uint8_t prefix() { return 'H'; } };
+    struct Height {
+        static constexpr uint8_t prefix() { return 'H'; }
+    };
 };
 
-class CFoundationsDebtView : public virtual CStorageView
-{
+class CFoundationsDebtView : public virtual CStorageView {
 public:
     CAmount GetFoundationsDebt() const;
     void SetFoundationsDebt(CAmount debt);
 
-    struct Debt { static constexpr uint8_t prefix() { return 'd'; } };
+    struct Debt {
+        static constexpr uint8_t prefix() { return 'd'; }
+    };
 };
 
-class CTeamView : public virtual CStorageView
-{
+class CTeamView : public virtual CStorageView {
 public:
     using CTeam = CAnchorData::CTeam;
 
-    void SetTeam(CTeam const & newTeam);
-    void SetAnchorTeams(CTeam const & authTeam, CTeam const & confirmTeam, const int height);
+    void SetTeam(const CTeam &newTeam);
+    void SetAnchorTeams(const CTeam &authTeam, const CTeam &confirmTeam, const int height);
 
     CTeam GetCurrentTeam() const;
     std::optional<CTeam> GetAuthTeam(int height) const;
     std::optional<CTeam> GetConfirmTeam(int height) const;
 
-    struct AuthTeam     { static constexpr uint8_t prefix() { return 'v'; } };
-    struct ConfirmTeam  { static constexpr uint8_t prefix() { return 'V'; } };
-    struct CurrentTeam  { static constexpr uint8_t prefix() { return 't'; } };
+    struct AuthTeam {
+        static constexpr uint8_t prefix() { return 'v'; }
+    };
+    struct ConfirmTeam {
+        static constexpr uint8_t prefix() { return 'V'; }
+    };
+    struct CurrentTeam {
+        static constexpr uint8_t prefix() { return 't'; }
+    };
 };
 
-class CAnchorRewardsView : public virtual CStorageView
-{
+class CAnchorRewardsView : public virtual CStorageView {
 public:
     using RewardTxHash = uint256;
     using AnchorTxHash = uint256;
 
-    std::optional<RewardTxHash> GetRewardForAnchor(AnchorTxHash const &btcTxHash) const;
+    std::optional<RewardTxHash> GetRewardForAnchor(const AnchorTxHash &btcTxHash) const;
 
-    void AddRewardForAnchor(AnchorTxHash const &btcTxHash, RewardTxHash const & rewardTxHash);
-    void RemoveRewardForAnchor(AnchorTxHash const &btcTxHash);
-    void ForEachAnchorReward(std::function<bool(AnchorTxHash const &, CLazySerialize<RewardTxHash>)> callback);
+    void AddRewardForAnchor(const AnchorTxHash &btcTxHash, const RewardTxHash &rewardTxHash);
+    void RemoveRewardForAnchor(const AnchorTxHash &btcTxHash);
+    void ForEachAnchorReward(std::function<bool(const AnchorTxHash &, CLazySerialize<RewardTxHash>)> callback);
 
-    struct BtcTx { static constexpr uint8_t prefix() { return 'r'; } };
+    struct BtcTx {
+        static constexpr uint8_t prefix() { return 'r'; }
+    };
 };
 
-class CAnchorConfirmsView : public virtual CStorageView
-{
+class CAnchorConfirmsView : public virtual CStorageView {
 public:
     using AnchorTxHash = uint256;
 
     std::vector<CAnchorConfirmDataPlus> GetAnchorConfirmData();
 
-    void AddAnchorConfirmData(const CAnchorConfirmDataPlus& data);
+    void AddAnchorConfirmData(const CAnchorConfirmDataPlus &data);
     void EraseAnchorConfirmData(const uint256 btcTxHash);
-    void ForEachAnchorConfirmData(std::function<bool(const AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus>)> callback);
+    void ForEachAnchorConfirmData(
+        std::function<bool(const AnchorTxHash &, CLazySerialize<CAnchorConfirmDataPlus>)> callback);
 
-    struct BtcTx { static constexpr uint8_t prefix() { return 'x'; } };
+    struct BtcTx {
+        static constexpr uint8_t prefix() { return 'x'; }
+    };
 };
 
-class CSettingsView : public virtual CStorageView
-{
-
+class CSettingsView : public virtual CStorageView {
 public:
     const std::string DEX_STATS_LAST_HEIGHT = "DexStatsLastHeight";
-    const std::string DEX_STATS_ENABLED = "DexStatsEnabled";
+    const std::string DEX_STATS_ENABLED     = "DexStatsEnabled";
 
     void SetDexStatsLastHeight(int32_t height);
     std::optional<int32_t> GetDexStatsLastHeight();
     void SetDexStatsEnabled(bool enabled);
     std::optional<bool> GetDexStatsEnabled();
 
-    struct KVSettings { static constexpr uint8_t prefix() { return '0'; } };
+    struct KVSettings {
+        static constexpr uint8_t prefix() { return '0'; }
+    };
 };
 
-class CCollateralLoans { // in USD
+class CCollateralLoans {  // in USD
 
     double calcRatio(uint64_t maxRatio) const;
 
@@ -367,7 +400,7 @@ class CCollateralLoans { // in USD
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(totalCollaterals);
         READWRITE(totalLoans);
         READWRITE(collaterals);
@@ -375,39 +408,35 @@ class CCollateralLoans { // in USD
     }
 };
 
-template<typename T>
-inline void CheckPrefix()
-{
-}
+template <typename T>
+inline void CheckPrefix() {}
 
-template<typename T1, typename T2, typename... TN>
-inline void CheckPrefix()
-{
+template <typename T1, typename T2, typename... TN>
+inline void CheckPrefix() {
     static_assert(T1::prefix() != T2::prefix(), "prefixes are equal");
     CheckPrefix<T1, TN...>();
     CheckPrefix<T2, TN...>();
 }
 
-class CCustomCSView
-        : public CMasternodesView
-        , public CLastHeightView
-        , public CTeamView
-        , public CFoundationsDebtView
-        , public CAnchorRewardsView
-        , public CTokensView
-        , public CAccountsView
-        , public CCommunityBalancesView
-        , public CUndosView
-        , public CPoolPairView
-        , public CGovView
-        , public CAnchorConfirmsView
-        , public COracleView
-        , public CICXOrderView
-        , public CLoanView
-        , public CVaultView
-        , public CSettingsView
-        , public CPropsView
-{
+class CCustomCSView : public CMasternodesView,
+                      public CLastHeightView,
+                      public CTeamView,
+                      public CFoundationsDebtView,
+                      public CAnchorRewardsView,
+                      public CTokensView,
+                      public CAccountsView,
+                      public CCommunityBalancesView,
+                      public CUndosView,
+                      public CPoolPairView,
+                      public CGovView,
+                      public CAnchorConfirmsView,
+                      public COracleView,
+                      public CICXOrderView,
+                      public CLoanView,
+                      public CVaultView,
+                      public CSettingsView,
+                      public CPropsView {
+    // clang-format off
     void CheckPrefixes()
     {
         CheckPrefix<
@@ -441,51 +470,79 @@ class CCustomCSView
             CPropsView              ::  ByType, ByCycle, ByMnVote, ByStatus
         >();
     }
+    // clang-format on
+
 private:
-    Res PopulateLoansData(CCollateralLoans& result, CVaultId const& vaultId, uint32_t height, int64_t blockTime, bool useNextPrice, bool requireLivePrice);
-    Res PopulateCollateralData(CCollateralLoans& result, CVaultId const& vaultId, CBalances const& collaterals, uint32_t height, int64_t blockTime, bool useNextPrice, bool requireLivePrice);
+    Res PopulateLoansData(CCollateralLoans &result,
+                          const CVaultId &vaultId,
+                          uint32_t height,
+                          int64_t blockTime,
+                          bool useNextPrice,
+                          bool requireLivePrice);
+    Res PopulateCollateralData(CCollateralLoans &result,
+                               const CVaultId &vaultId,
+                               const CBalances &collaterals,
+                               uint32_t height,
+                               int64_t blockTime,
+                               bool useNextPrice,
+                               bool requireLivePrice);
 
     std::unique_ptr<CAccountHistoryStorage> accHistoryStore;
     std::unique_ptr<CVaultHistoryStorage> vauHistoryStore;
+
 public:
     // Increase version when underlaying tables are changed
     static constexpr const int DbVersion = 1;
 
     CCustomCSView();
-    explicit CCustomCSView(CStorageKV & st);
+    explicit CCustomCSView(CStorageKV &st);
 
     // cache-upon-a-cache (not a copy!) constructor
-    CCustomCSView(CCustomCSView & other);
+    CCustomCSView(CCustomCSView &other);
 
     ~CCustomCSView();
 
     // cause depends on current mns:
-    CTeamView::CTeam CalcNextTeam(int height, uint256 const & stakeModifier);
+    CTeamView::CTeam CalcNextTeam(int height, const uint256 &stakeModifier);
 
     // Generate auth and custom anchor teams based on current block
-    void CalcAnchoringTeams(uint256 const & stakeModifier, const CBlockIndex *pindexNew);
+    void CalcAnchoringTeams(const uint256 &stakeModifier, const CBlockIndex *pindexNew);
 
     /// @todo newbase move to networking?
-    void CreateAndRelayConfirmMessageIfNeed(const CAnchorIndex::AnchorRec* anchor, const uint256 & btcTxHash, const CKey &masternodeKey);
+    void CreateAndRelayConfirmMessageIfNeed(const CAnchorIndex::AnchorRec *anchor,
+                                            const uint256 &btcTxHash,
+                                            const CKey &masternodeKey);
 
     // simplified version of undo, without any unnecessary undo data
-    void OnUndoTx(uint256 const & txid, uint32_t height);
+    void OnUndoTx(const uint256 &txid, uint32_t height);
 
-    bool CanSpend(const uint256 & txId, int height) const;
+    bool CanSpend(const uint256 &txId, int height) const;
 
-    bool CalculateOwnerRewards(CScript const & owner, uint32_t height);
+    bool CalculateOwnerRewards(const CScript &owner, uint32_t height);
 
-    ResVal<CAmount> GetAmountInCurrency(CAmount amount, CTokenCurrencyPair priceFeedId, bool useNextPrice = false, bool requireLivePrice = true);
+    ResVal<CAmount> GetAmountInCurrency(CAmount amount,
+                                        CTokenCurrencyPair priceFeedId,
+                                        bool useNextPrice     = false,
+                                        bool requireLivePrice = true);
 
-    ResVal<CCollateralLoans> GetLoanCollaterals(CVaultId const & vaultId, CBalances const & collaterals, uint32_t height, int64_t blockTime, bool useNextPrice = false, bool requireLivePrice = true);
+    ResVal<CCollateralLoans> GetLoanCollaterals(const CVaultId &vaultId,
+                                                const CBalances &collaterals,
+                                                uint32_t height,
+                                                int64_t blockTime,
+                                                bool useNextPrice     = false,
+                                                bool requireLivePrice = true);
 
-    ResVal<CAmount> GetValidatedIntervalPrice(const 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]] std::optional<CTokenImpl> GetTokenGuessId(const std::string & str, DCT_ID & id) const override;
-    [[nodiscard]] std::optional<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const & id) const override;
-    [[nodiscard]] std::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(const DCT_ID& id) const override;
-    [[nodiscard]] std::optional<CLoanSetCollateralTokenImpl> GetCollateralTokenFromAttributes(const DCT_ID& id) const override;
+    [[nodiscard]] bool AreTokensLocked(const std::set<uint32_t> &tokenIds) const override;
+    [[nodiscard]] std::optional<CTokenImpl> GetTokenGuessId(const std::string &str, DCT_ID &id) const override;
+    [[nodiscard]] std::optional<CLoanSetLoanTokenImpl> GetLoanTokenByID(DCT_ID const &id) const override;
+    [[nodiscard]] std::optional<CLoanSetLoanTokenImplementation> GetLoanTokenFromAttributes(
+        const DCT_ID &id) const override;
+    [[nodiscard]] std::optional<CLoanSetCollateralTokenImpl> GetCollateralTokenFromAttributes(
+        const DCT_ID &id) const override;
 
     void SetDbVersion(int version);
 
@@ -494,28 +551,28 @@ class CCustomCSView
     uint256 MerkleRoot();
 
     // we construct it as it
-    CFlushableStorageKV& GetStorage() {
-        return static_cast<CFlushableStorageKV&>(DB());
-    }
+    CFlushableStorageKV &GetStorage() { return static_cast<CFlushableStorageKV &>(DB()); }
 
-    virtual CAccountHistoryStorage* GetAccountHistoryStore();
-    CVaultHistoryStorage* GetVaultHistoryStore();
+    virtual CAccountHistoryStorage *GetAccountHistoryStore();
+    CVaultHistoryStorage *GetVaultHistoryStore();
     void SetAccountHistoryStore();
     void SetVaultHistoryStore();
 
     uint32_t GetVotingPeriodFromAttributes() const override;
-    uint32_t GetEmergencyPeriodFromAttributes(const CPropType& type) const override;
-    CAmount GetApprovalThresholdFromAttributes(const CPropType& type) const override;
-    CAmount GetQuorumFromAttributes(const CPropType& type, bool emergency = false) const override;
+    uint32_t GetEmergencyPeriodFromAttributes(const CPropType &type) const override;
+    CAmount GetApprovalThresholdFromAttributes(const CPropType &type) const override;
+    CAmount GetQuorumFromAttributes(const CPropType &type, bool emergency = false) const override;
     CAmount GetFeeBurnPctFromAttributes() const override;
 
-    struct DbVersion { static constexpr uint8_t prefix() { return 'D'; } };
+    struct DbVersion {
+        static constexpr uint8_t prefix() { return 'D'; }
+    };
 };
 
-std::map<CKeyID, CKey> AmISignerNow(int height, CAnchorData::CTeam const & team);
+std::map<CKeyID, CKey> AmISignerNow(int height, const CAnchorData::CTeam &team);
 
 /** Global DB and view that holds enhanced chainstate data (should be protected by cs_main) */
 extern std::unique_ptr<CStorageLevelDB> pcustomcsDB;
 extern std::unique_ptr<CCustomCSView> pcustomcsview;
 
-#endif // DEFI_MASTERNODES_MASTERNODES_H
+#endif  // DEFI_MASTERNODES_MASTERNODES_H
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 5ce7a0d873..67bff3dd9d 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -14,92 +14,153 @@
 
 #include <algorithm>
 
-constexpr std::string_view ERR_STRING_MIN_COLLATERAL_DFI_PCT = "At least 50%% of the minimum required collateral must be in DFI";
-constexpr std::string_view ERR_STRING_MIN_COLLATERAL_DFI_DUSD_PCT = "At least 50%% of the minimum required collateral must be in DFI or DUSD";
+constexpr std::string_view ERR_STRING_MIN_COLLATERAL_DFI_PCT =
+    "At least 50%% of the minimum required collateral must be in DFI";
+constexpr std::string_view ERR_STRING_MIN_COLLATERAL_DFI_DUSD_PCT =
+    "At least 50%% of the minimum required collateral must be in DFI or DUSD";
 
 std::string ToString(CustomTxType type) {
-    switch (type)
-    {
-        case CustomTxType::CreateMasternode:    return "CreateMasternode";
-        case CustomTxType::ResignMasternode:    return "ResignMasternode";
-        case CustomTxType::UpdateMasternode:    return "UpdateMasternode";
-        case CustomTxType::CreateToken:         return "CreateToken";
-        case CustomTxType::UpdateToken:         return "UpdateToken";
-        case CustomTxType::UpdateTokenAny:      return "UpdateTokenAny";
-        case CustomTxType::MintToken:           return "MintToken";
-        case CustomTxType::BurnToken:           return "BurnToken";
-        case CustomTxType::CreatePoolPair:      return "CreatePoolPair";
-        case CustomTxType::UpdatePoolPair:      return "UpdatePoolPair";
-        case CustomTxType::PoolSwap:            return "PoolSwap";
-        case CustomTxType::PoolSwapV2:          return "PoolSwap";
-        case CustomTxType::AddPoolLiquidity:    return "AddPoolLiquidity";
-        case CustomTxType::RemovePoolLiquidity: return "RemovePoolLiquidity";
-        case CustomTxType::UtxosToAccount:      return "UtxosToAccount";
-        case CustomTxType::AccountToUtxos:      return "AccountToUtxos";
-        case CustomTxType::AccountToAccount:    return "AccountToAccount";
-        case CustomTxType::AnyAccountsToAccounts:   return "AnyAccountsToAccounts";
-        case CustomTxType::SmartContract:           return "SmartContract";
-        case CustomTxType::FutureSwap:              return "DFIP2203";
-        case CustomTxType::SetGovVariable:          return "SetGovVariable";
-        case CustomTxType::SetGovVariableHeight:    return "SetGovVariableHeight";
-        case CustomTxType::AppointOracle:           return "AppointOracle";
-        case CustomTxType::RemoveOracleAppoint:     return "RemoveOracleAppoint";
-        case CustomTxType::UpdateOracleAppoint:     return "UpdateOracleAppoint";
-        case CustomTxType::SetOracleData:           return "SetOracleData";
-        case CustomTxType::AutoAuthPrep:            return "AutoAuth";
-        case CustomTxType::ICXCreateOrder:          return "ICXCreateOrder";
-        case CustomTxType::ICXMakeOffer:            return "ICXMakeOffer";
-        case CustomTxType::ICXSubmitDFCHTLC:        return "ICXSubmitDFCHTLC";
-        case CustomTxType::ICXSubmitEXTHTLC:        return "ICXSubmitEXTHTLC";
-        case CustomTxType::ICXClaimDFCHTLC:         return "ICXClaimDFCHTLC";
-        case CustomTxType::ICXCloseOrder:           return "ICXCloseOrder";
-        case CustomTxType::ICXCloseOffer:           return "ICXCloseOffer";
-        case CustomTxType::SetLoanCollateralToken:  return "SetLoanCollateralToken";
-        case CustomTxType::SetLoanToken:            return "SetLoanToken";
-        case CustomTxType::UpdateLoanToken:         return "UpdateLoanToken";
-        case CustomTxType::LoanScheme:              return "LoanScheme";
-        case CustomTxType::DefaultLoanScheme:       return "DefaultLoanScheme";
-        case CustomTxType::DestroyLoanScheme:       return "DestroyLoanScheme";
-        case CustomTxType::Vault:                   return "Vault";
-        case CustomTxType::CloseVault:              return "CloseVault";
-        case CustomTxType::UpdateVault:             return "UpdateVault";
-        case CustomTxType::DepositToVault:          return "DepositToVault";
-        case CustomTxType::WithdrawFromVault:       return "WithdrawFromVault";
-        case CustomTxType::PaybackWithCollateral:   return "PaybackWithCollateral";
-        case CustomTxType::TakeLoan:                return "TakeLoan";
-        case CustomTxType::PaybackLoan:             return "PaybackLoan";
-        case CustomTxType::PaybackLoanV2:           return "PaybackLoan";
-        case CustomTxType::AuctionBid:              return "AuctionBid";
-        case CustomTxType::FutureSwapExecution:     return "FutureSwapExecution";
-        case CustomTxType::FutureSwapRefund:        return "FutureSwapRefund";
-        case CustomTxType::TokenSplit:              return "TokenSplit";
-        case CustomTxType::Reject:                  return "Reject";
-        case CustomTxType::CreateCfp:               return "CreateCfp";
-        case CustomTxType::ProposalFeeRedistribution:return "ProposalFeeRedistribution";
-        case CustomTxType::CreateVoc:               return "CreateVoc";
-        case CustomTxType::Vote:                    return "Vote";
-        case CustomTxType::UnsetGovVariable:    return "UnsetGovVariable";
-        case CustomTxType::None:                    return "None";
+    switch (type) {
+        case CustomTxType::CreateMasternode:
+            return "CreateMasternode";
+        case CustomTxType::ResignMasternode:
+            return "ResignMasternode";
+        case CustomTxType::UpdateMasternode:
+            return "UpdateMasternode";
+        case CustomTxType::CreateToken:
+            return "CreateToken";
+        case CustomTxType::UpdateToken:
+            return "UpdateToken";
+        case CustomTxType::UpdateTokenAny:
+            return "UpdateTokenAny";
+        case CustomTxType::MintToken:
+            return "MintToken";
+        case CustomTxType::BurnToken:
+            return "BurnToken";
+        case CustomTxType::CreatePoolPair:
+            return "CreatePoolPair";
+        case CustomTxType::UpdatePoolPair:
+            return "UpdatePoolPair";
+        case CustomTxType::PoolSwap:
+            return "PoolSwap";
+        case CustomTxType::PoolSwapV2:
+            return "PoolSwap";
+        case CustomTxType::AddPoolLiquidity:
+            return "AddPoolLiquidity";
+        case CustomTxType::RemovePoolLiquidity:
+            return "RemovePoolLiquidity";
+        case CustomTxType::UtxosToAccount:
+            return "UtxosToAccount";
+        case CustomTxType::AccountToUtxos:
+            return "AccountToUtxos";
+        case CustomTxType::AccountToAccount:
+            return "AccountToAccount";
+        case CustomTxType::AnyAccountsToAccounts:
+            return "AnyAccountsToAccounts";
+        case CustomTxType::SmartContract:
+            return "SmartContract";
+        case CustomTxType::FutureSwap:
+            return "DFIP2203";
+        case CustomTxType::SetGovVariable:
+            return "SetGovVariable";
+        case CustomTxType::SetGovVariableHeight:
+            return "SetGovVariableHeight";
+        case CustomTxType::AppointOracle:
+            return "AppointOracle";
+        case CustomTxType::RemoveOracleAppoint:
+            return "RemoveOracleAppoint";
+        case CustomTxType::UpdateOracleAppoint:
+            return "UpdateOracleAppoint";
+        case CustomTxType::SetOracleData:
+            return "SetOracleData";
+        case CustomTxType::AutoAuthPrep:
+            return "AutoAuth";
+        case CustomTxType::ICXCreateOrder:
+            return "ICXCreateOrder";
+        case CustomTxType::ICXMakeOffer:
+            return "ICXMakeOffer";
+        case CustomTxType::ICXSubmitDFCHTLC:
+            return "ICXSubmitDFCHTLC";
+        case CustomTxType::ICXSubmitEXTHTLC:
+            return "ICXSubmitEXTHTLC";
+        case CustomTxType::ICXClaimDFCHTLC:
+            return "ICXClaimDFCHTLC";
+        case CustomTxType::ICXCloseOrder:
+            return "ICXCloseOrder";
+        case CustomTxType::ICXCloseOffer:
+            return "ICXCloseOffer";
+        case CustomTxType::SetLoanCollateralToken:
+            return "SetLoanCollateralToken";
+        case CustomTxType::SetLoanToken:
+            return "SetLoanToken";
+        case CustomTxType::UpdateLoanToken:
+            return "UpdateLoanToken";
+        case CustomTxType::LoanScheme:
+            return "LoanScheme";
+        case CustomTxType::DefaultLoanScheme:
+            return "DefaultLoanScheme";
+        case CustomTxType::DestroyLoanScheme:
+            return "DestroyLoanScheme";
+        case CustomTxType::Vault:
+            return "Vault";
+        case CustomTxType::CloseVault:
+            return "CloseVault";
+        case CustomTxType::UpdateVault:
+            return "UpdateVault";
+        case CustomTxType::DepositToVault:
+            return "DepositToVault";
+        case CustomTxType::WithdrawFromVault:
+            return "WithdrawFromVault";
+        case CustomTxType::PaybackWithCollateral:
+            return "PaybackWithCollateral";
+        case CustomTxType::TakeLoan:
+            return "TakeLoan";
+        case CustomTxType::PaybackLoan:
+            return "PaybackLoan";
+        case CustomTxType::PaybackLoanV2:
+            return "PaybackLoan";
+        case CustomTxType::AuctionBid:
+            return "AuctionBid";
+        case CustomTxType::FutureSwapExecution:
+            return "FutureSwapExecution";
+        case CustomTxType::FutureSwapRefund:
+            return "FutureSwapRefund";
+        case CustomTxType::TokenSplit:
+            return "TokenSplit";
+        case CustomTxType::Reject:
+            return "Reject";
+        case CustomTxType::CreateCfp:
+            return "CreateCfp";
+        case CustomTxType::ProposalFeeRedistribution:
+            return "ProposalFeeRedistribution";
+        case CustomTxType::CreateVoc:
+            return "CreateVoc";
+        case CustomTxType::Vote:
+            return "Vote";
+        case CustomTxType::UnsetGovVariable:
+            return "UnsetGovVariable";
+        case CustomTxType::None:
+            return "None";
     }
     return "None";
 }
 
-CustomTxType FromString(const std::string& str) {
+CustomTxType FromString(const std::string &str) {
     static const auto customTxTypeMap = []() {
-     std::map<std::string, CustomTxType> generatedMap;
-     for (auto i = 0u; i < 256; i++) {
-          auto txType = static_cast<CustomTxType>(i);
-          generatedMap.emplace(ToString(txType), txType);
-     }
-     return generatedMap;
+        std::map<std::string, CustomTxType> generatedMap;
+        for (auto i = 0u; i < 256; i++) {
+            auto txType = static_cast<CustomTxType>(i);
+            generatedMap.emplace(ToString(txType), txType);
+        }
+        return generatedMap;
     }();
     auto type = customTxTypeMap.find(str);
     return type == customTxTypeMap.end() ? CustomTxType::None : type->second;
 }
 
-static ResVal<CBalances> BurntTokens(CTransaction const & tx) {
+static ResVal<CBalances> BurntTokens(const CTransaction &tx) {
     CBalances balances;
-    for (const auto& out : tx.vout) {
+    for (const auto &out : tx.vout) {
         if (out.scriptPubKey.size() > 0 && out.scriptPubKey[0] == OP_RETURN) {
             auto res = balances.Add(out.TokenAmount());
             if (!res.ok) {
@@ -110,9 +171,9 @@ static ResVal<CBalances> BurntTokens(CTransaction const & tx) {
     return {balances, Res::Ok()};
 }
 
-static ResVal<CBalances> MintedTokens(CTransaction const & tx, uint32_t mintingOutputsStart) {
+static ResVal<CBalances> MintedTokens(const CTransaction &tx, uint32_t mintingOutputsStart) {
     CBalances balances;
-    for (uint32_t i = mintingOutputsStart; i < (uint32_t) tx.vout.size(); i++) {
+    for (uint32_t i = mintingOutputsStart; i < (uint32_t)tx.vout.size(); i++) {
         auto res = balances.Add(tx.vout[i].TokenAmount());
         if (!res.ok) {
             return res;
@@ -122,145 +183,203 @@ static ResVal<CBalances> MintedTokens(CTransaction const & tx, uint32_t mintingO
 }
 
 CCustomTxMessage customTypeToMessage(CustomTxType txType) {
-    switch (txType)
-    {
-        case CustomTxType::CreateMasternode:        return CCreateMasterNodeMessage{};
-        case CustomTxType::ResignMasternode:        return CResignMasterNodeMessage{};
-        case CustomTxType::UpdateMasternode:        return CUpdateMasterNodeMessage{};
-        case CustomTxType::CreateToken:             return CCreateTokenMessage{};
-        case CustomTxType::UpdateToken:             return CUpdateTokenPreAMKMessage{};
-        case CustomTxType::UpdateTokenAny:          return CUpdateTokenMessage{};
-        case CustomTxType::MintToken:               return CMintTokensMessage{};
-        case CustomTxType::BurnToken:               return CBurnTokensMessage{};
-        case CustomTxType::CreatePoolPair:          return CCreatePoolPairMessage{};
-        case CustomTxType::UpdatePoolPair:          return CUpdatePoolPairMessage{};
-        case CustomTxType::PoolSwap:                return CPoolSwapMessage{};
-        case CustomTxType::PoolSwapV2:              return CPoolSwapMessageV2{};
-        case CustomTxType::AddPoolLiquidity:        return CLiquidityMessage{};
-        case CustomTxType::RemovePoolLiquidity:     return CRemoveLiquidityMessage{};
-        case CustomTxType::UtxosToAccount:          return CUtxosToAccountMessage{};
-        case CustomTxType::AccountToUtxos:          return CAccountToUtxosMessage{};
-        case CustomTxType::AccountToAccount:        return CAccountToAccountMessage{};
-        case CustomTxType::AnyAccountsToAccounts:   return CAnyAccountsToAccountsMessage{};
-        case CustomTxType::SmartContract:           return CSmartContractMessage{};
-        case CustomTxType::FutureSwap:                return CFutureSwapMessage{};
-        case CustomTxType::SetGovVariable:          return CGovernanceMessage{};
-        case CustomTxType::SetGovVariableHeight:    return CGovernanceHeightMessage{};
-        case CustomTxType::AppointOracle:           return CAppointOracleMessage{};
-        case CustomTxType::RemoveOracleAppoint:     return CRemoveOracleAppointMessage{};
-        case CustomTxType::UpdateOracleAppoint:     return CUpdateOracleAppointMessage{};
-        case CustomTxType::SetOracleData:           return CSetOracleDataMessage{};
-        case CustomTxType::AutoAuthPrep:            return CCustomTxMessageNone{};
-        case CustomTxType::ICXCreateOrder:          return CICXCreateOrderMessage{};
-        case CustomTxType::ICXMakeOffer:            return CICXMakeOfferMessage{};
-        case CustomTxType::ICXSubmitDFCHTLC:        return CICXSubmitDFCHTLCMessage{};
-        case CustomTxType::ICXSubmitEXTHTLC:        return CICXSubmitEXTHTLCMessage{};
-        case CustomTxType::ICXClaimDFCHTLC:         return CICXClaimDFCHTLCMessage{};
-        case CustomTxType::ICXCloseOrder:           return CICXCloseOrderMessage{};
-        case CustomTxType::ICXCloseOffer:           return CICXCloseOfferMessage{};
-        case CustomTxType::SetLoanCollateralToken:  return CLoanSetCollateralTokenMessage{};
-        case CustomTxType::SetLoanToken:            return CLoanSetLoanTokenMessage{};
-        case CustomTxType::UpdateLoanToken:         return CLoanUpdateLoanTokenMessage{};
-        case CustomTxType::LoanScheme:              return CLoanSchemeMessage{};
-        case CustomTxType::DefaultLoanScheme:       return CDefaultLoanSchemeMessage{};
-        case CustomTxType::DestroyLoanScheme:       return CDestroyLoanSchemeMessage{};
-        case CustomTxType::Vault:                   return CVaultMessage{};
-        case CustomTxType::CloseVault:              return CCloseVaultMessage{};
-        case CustomTxType::UpdateVault:             return CUpdateVaultMessage{};
-        case CustomTxType::DepositToVault:          return CDepositToVaultMessage{};
-        case CustomTxType::WithdrawFromVault:       return CWithdrawFromVaultMessage{};
-        case CustomTxType::PaybackWithCollateral:   return CPaybackWithCollateralMessage{};
-        case CustomTxType::TakeLoan:                return CLoanTakeLoanMessage{};
-        case CustomTxType::PaybackLoan:             return CLoanPaybackLoanMessage{};
-        case CustomTxType::PaybackLoanV2:           return CLoanPaybackLoanV2Message{};
-        case CustomTxType::AuctionBid:              return CAuctionBidMessage{};
-        case CustomTxType::FutureSwapExecution:     return CCustomTxMessageNone{};
-        case CustomTxType::FutureSwapRefund:        return CCustomTxMessageNone{};
-        case CustomTxType::TokenSplit:              return CCustomTxMessageNone{};
-        case CustomTxType::Reject:                  return CCustomTxMessageNone{};
-        case CustomTxType::CreateCfp:               return CCreatePropMessage{};
-        case CustomTxType::CreateVoc:               return CCreatePropMessage{};
-        case CustomTxType::Vote:                    return CPropVoteMessage{};
-        case CustomTxType::ProposalFeeRedistribution:return CCustomTxMessageNone{};
-        case CustomTxType::UnsetGovVariable:        return CGovernanceUnsetMessage{};
-        case CustomTxType::None:                    return CCustomTxMessageNone{};
+    switch (txType) {
+        case CustomTxType::CreateMasternode:
+            return CCreateMasterNodeMessage{};
+        case CustomTxType::ResignMasternode:
+            return CResignMasterNodeMessage{};
+        case CustomTxType::UpdateMasternode:
+            return CUpdateMasterNodeMessage{};
+        case CustomTxType::CreateToken:
+            return CCreateTokenMessage{};
+        case CustomTxType::UpdateToken:
+            return CUpdateTokenPreAMKMessage{};
+        case CustomTxType::UpdateTokenAny:
+            return CUpdateTokenMessage{};
+        case CustomTxType::MintToken:
+            return CMintTokensMessage{};
+        case CustomTxType::BurnToken:
+            return CBurnTokensMessage{};
+        case CustomTxType::CreatePoolPair:
+            return CCreatePoolPairMessage{};
+        case CustomTxType::UpdatePoolPair:
+            return CUpdatePoolPairMessage{};
+        case CustomTxType::PoolSwap:
+            return CPoolSwapMessage{};
+        case CustomTxType::PoolSwapV2:
+            return CPoolSwapMessageV2{};
+        case CustomTxType::AddPoolLiquidity:
+            return CLiquidityMessage{};
+        case CustomTxType::RemovePoolLiquidity:
+            return CRemoveLiquidityMessage{};
+        case CustomTxType::UtxosToAccount:
+            return CUtxosToAccountMessage{};
+        case CustomTxType::AccountToUtxos:
+            return CAccountToUtxosMessage{};
+        case CustomTxType::AccountToAccount:
+            return CAccountToAccountMessage{};
+        case CustomTxType::AnyAccountsToAccounts:
+            return CAnyAccountsToAccountsMessage{};
+        case CustomTxType::SmartContract:
+            return CSmartContractMessage{};
+        case CustomTxType::FutureSwap:
+            return CFutureSwapMessage{};
+        case CustomTxType::SetGovVariable:
+            return CGovernanceMessage{};
+        case CustomTxType::SetGovVariableHeight:
+            return CGovernanceHeightMessage{};
+        case CustomTxType::AppointOracle:
+            return CAppointOracleMessage{};
+        case CustomTxType::RemoveOracleAppoint:
+            return CRemoveOracleAppointMessage{};
+        case CustomTxType::UpdateOracleAppoint:
+            return CUpdateOracleAppointMessage{};
+        case CustomTxType::SetOracleData:
+            return CSetOracleDataMessage{};
+        case CustomTxType::AutoAuthPrep:
+            return CCustomTxMessageNone{};
+        case CustomTxType::ICXCreateOrder:
+            return CICXCreateOrderMessage{};
+        case CustomTxType::ICXMakeOffer:
+            return CICXMakeOfferMessage{};
+        case CustomTxType::ICXSubmitDFCHTLC:
+            return CICXSubmitDFCHTLCMessage{};
+        case CustomTxType::ICXSubmitEXTHTLC:
+            return CICXSubmitEXTHTLCMessage{};
+        case CustomTxType::ICXClaimDFCHTLC:
+            return CICXClaimDFCHTLCMessage{};
+        case CustomTxType::ICXCloseOrder:
+            return CICXCloseOrderMessage{};
+        case CustomTxType::ICXCloseOffer:
+            return CICXCloseOfferMessage{};
+        case CustomTxType::SetLoanCollateralToken:
+            return CLoanSetCollateralTokenMessage{};
+        case CustomTxType::SetLoanToken:
+            return CLoanSetLoanTokenMessage{};
+        case CustomTxType::UpdateLoanToken:
+            return CLoanUpdateLoanTokenMessage{};
+        case CustomTxType::LoanScheme:
+            return CLoanSchemeMessage{};
+        case CustomTxType::DefaultLoanScheme:
+            return CDefaultLoanSchemeMessage{};
+        case CustomTxType::DestroyLoanScheme:
+            return CDestroyLoanSchemeMessage{};
+        case CustomTxType::Vault:
+            return CVaultMessage{};
+        case CustomTxType::CloseVault:
+            return CCloseVaultMessage{};
+        case CustomTxType::UpdateVault:
+            return CUpdateVaultMessage{};
+        case CustomTxType::DepositToVault:
+            return CDepositToVaultMessage{};
+        case CustomTxType::WithdrawFromVault:
+            return CWithdrawFromVaultMessage{};
+        case CustomTxType::PaybackWithCollateral:
+            return CPaybackWithCollateralMessage{};
+        case CustomTxType::TakeLoan:
+            return CLoanTakeLoanMessage{};
+        case CustomTxType::PaybackLoan:
+            return CLoanPaybackLoanMessage{};
+        case CustomTxType::PaybackLoanV2:
+            return CLoanPaybackLoanV2Message{};
+        case CustomTxType::AuctionBid:
+            return CAuctionBidMessage{};
+        case CustomTxType::FutureSwapExecution:
+            return CCustomTxMessageNone{};
+        case CustomTxType::FutureSwapRefund:
+            return CCustomTxMessageNone{};
+        case CustomTxType::TokenSplit:
+            return CCustomTxMessageNone{};
+        case CustomTxType::Reject:
+            return CCustomTxMessageNone{};
+        case CustomTxType::CreateCfp:
+            return CCreatePropMessage{};
+        case CustomTxType::CreateVoc:
+            return CCreatePropMessage{};
+        case CustomTxType::Vote:
+            return CPropVoteMessage{};
+        case CustomTxType::ProposalFeeRedistribution:
+            return CCustomTxMessageNone{};
+        case CustomTxType::UnsetGovVariable:
+            return CGovernanceUnsetMessage{};
+        case CustomTxType::None:
+            return CCustomTxMessageNone{};
     }
     return CCustomTxMessageNone{};
 }
 
-extern std::string ScriptToString(CScript const& script);
+extern std::string ScriptToString(const CScript &script);
 
-class CCustomMetadataParseVisitor
-{
+class CCustomMetadataParseVisitor {
     uint32_t height;
-    const Consensus::Params& consensus;
-    const std::vector<unsigned char>& metadata;
+    const Consensus::Params &consensus;
+    const std::vector<unsigned char> &metadata;
 
     Res isPostAMKFork() const {
-        if(static_cast<int>(height) < consensus.AMKHeight) {
+        if (static_cast<int>(height) < consensus.AMKHeight) {
             return Res::Err("called before AMK height");
         }
         return Res::Ok();
     }
 
     Res isPostBayfrontFork() const {
-        if(static_cast<int>(height) < consensus.BayfrontHeight) {
+        if (static_cast<int>(height) < consensus.BayfrontHeight) {
             return Res::Err("called before Bayfront height");
         }
         return Res::Ok();
     }
 
     Res isPostBayfrontGardensFork() const {
-        if(static_cast<int>(height) < consensus.BayfrontGardensHeight) {
+        if (static_cast<int>(height) < consensus.BayfrontGardensHeight) {
             return Res::Err("called before Bayfront Gardens height");
         }
         return Res::Ok();
     }
 
     Res isPostEunosFork() const {
-        if(static_cast<int>(height) < consensus.EunosHeight) {
+        if (static_cast<int>(height) < consensus.EunosHeight) {
             return Res::Err("called before Eunos height");
         }
         return Res::Ok();
     }
 
     Res isPostFortCanningFork() const {
-        if(static_cast<int>(height) < consensus.FortCanningHeight) {
+        if (static_cast<int>(height) < consensus.FortCanningHeight) {
             return Res::Err("called before FortCanning height");
         }
         return Res::Ok();
     }
 
     Res isPostFortCanningHillFork() const {
-        if(static_cast<int>(height) < consensus.FortCanningHillHeight) {
+        if (static_cast<int>(height) < consensus.FortCanningHillHeight) {
             return Res::Err("called before FortCanningHill height");
         }
         return Res::Ok();
     }
 
     Res isPostFortCanningRoadFork() const {
-        if(static_cast<int>(height) < consensus.FortCanningRoadHeight) {
+        if (static_cast<int>(height) < consensus.FortCanningRoadHeight) {
             return Res::Err("called before FortCanningRoad height");
         }
         return Res::Ok();
     }
 
     Res isPostFortCanningEpilogueFork() const {
-        if(static_cast<int>(height) < consensus.FortCanningEpilogueHeight) {
+        if (static_cast<int>(height) < consensus.FortCanningEpilogueHeight) {
             return Res::Err("called before FortCanningEpilogue height");
         }
         return Res::Ok();
     }
 
     Res isPostGrandCentralFork() const {
-        if(static_cast<int>(height) < consensus.GrandCentralHeight) {
+        if (static_cast<int>(height) < consensus.GrandCentralHeight) {
             return Res::Err("called before GrandCentral height");
         }
         return Res::Ok();
     }
 
-    template<typename T>
-    Res serialize(T& obj) const {
+    template <typename T>
+    Res serialize(T &obj) const {
         CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
         ss >> obj;
         if (!ss.empty()) {
@@ -271,98 +390,98 @@ class CCustomMetadataParseVisitor
 
 public:
     CCustomMetadataParseVisitor(uint32_t height,
-                                const Consensus::Params& consensus,
-                                const std::vector<unsigned char>& metadata)
-        : height(height), consensus(consensus), metadata(metadata) {}
+                                const Consensus::Params &consensus,
+                                const std::vector<unsigned char> &metadata)
+        : height(height),
+          consensus(consensus),
+          metadata(metadata) {}
 
-    Res operator()(CCreateMasterNodeMessage& obj) const {
-        return serialize(obj);
-    }
+    Res operator()(CCreateMasterNodeMessage &obj) const { return serialize(obj); }
 
-    Res operator()(CResignMasterNodeMessage& obj) const {
+    Res operator()(CResignMasterNodeMessage &obj) const {
         if (metadata.size() != sizeof(obj)) {
             return Res::Err("metadata must contain 32 bytes");
         }
         return serialize(obj);
     }
 
-    Res operator()(CUpdateMasterNodeMessage& obj) const {
+    Res operator()(CUpdateMasterNodeMessage &obj) const {
         auto res = isPostGrandCentralFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CCreateTokenMessage& obj) const {
+    Res operator()(CCreateTokenMessage &obj) const {
         auto res = isPostAMKFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CUpdateTokenPreAMKMessage& obj) const {
+    Res operator()(CUpdateTokenPreAMKMessage &obj) const {
         auto res = isPostAMKFork();
         if (!res) {
             return res;
         }
-        if(isPostBayfrontFork()) {
+        if (isPostBayfrontFork()) {
             return Res::Err("called post Bayfront height");
         }
         return serialize(obj);
     }
 
-    Res operator()(CUpdateTokenMessage& obj) const {
+    Res operator()(CUpdateTokenMessage &obj) const {
         auto res = isPostBayfrontFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CMintTokensMessage& obj) const {
+    Res operator()(CMintTokensMessage &obj) const {
         auto res = isPostAMKFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CPoolSwapMessage& obj) const {
+    Res operator()(CPoolSwapMessage &obj) const {
         auto res = isPostBayfrontFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLiquidityMessage& obj) const {
+    Res operator()(CLiquidityMessage &obj) const {
         auto res = isPostBayfrontFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CRemoveLiquidityMessage& obj) const {
+    Res operator()(CRemoveLiquidityMessage &obj) const {
         auto res = isPostBayfrontFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CUtxosToAccountMessage& obj) const {
+    Res operator()(CUtxosToAccountMessage &obj) const {
         auto res = isPostAMKFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CAccountToUtxosMessage& obj) const {
+    Res operator()(CAccountToUtxosMessage &obj) const {
         auto res = isPostAMKFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CAccountToAccountMessage& obj) const {
+    Res operator()(CAccountToAccountMessage &obj) const {
         auto res = isPostAMKFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CAnyAccountsToAccountsMessage& obj) const {
+    Res operator()(CAnyAccountsToAccountsMessage &obj) const {
         auto res = isPostBayfrontGardensFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CSmartContractMessage& obj) const {
+    Res operator()(CSmartContractMessage &obj) const {
         auto res = isPostFortCanningHillFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CFutureSwapMessage& obj) const {
+    Res operator()(CFutureSwapMessage &obj) const {
         auto res = isPostFortCanningRoadFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CCreatePoolPairMessage& obj) const {
+    Res operator()(CCreatePoolPairMessage &obj) const {
         auto res = isPostBayfrontFork();
         if (!res) {
             return res;
@@ -382,7 +501,7 @@ class CCustomMetadataParseVisitor
         return Res::Ok();
     }
 
-    Res operator()(CUpdatePoolPairMessage& obj) const {
+    Res operator()(CUpdatePoolPairMessage &obj) const {
         auto res = isPostBayfrontFork();
         if (!res) {
             return res;
@@ -406,14 +525,14 @@ class CCustomMetadataParseVisitor
         return Res::Ok();
     }
 
-    Res operator()(CGovernanceMessage& obj) const {
+    Res operator()(CGovernanceMessage &obj) const {
         auto res = isPostBayfrontFork();
         if (!res) {
             return res;
         }
         std::string name;
         CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
-        while(!ss.empty()) {
+        while (!ss.empty()) {
             ss >> name;
             auto var = GovVariable::Create(name);
             if (!var) {
@@ -425,7 +544,7 @@ class CCustomMetadataParseVisitor
         return Res::Ok();
     }
 
-    Res operator()(CGovernanceHeightMessage& obj) const {
+    Res operator()(CGovernanceHeightMessage &obj) const {
         auto res = isPostFortCanningFork();
         if (!res) {
             return res;
@@ -442,182 +561,183 @@ class CCustomMetadataParseVisitor
         return Res::Ok();
     }
 
-    Res operator()(CAppointOracleMessage& obj) const {
+    Res operator()(CAppointOracleMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CRemoveOracleAppointMessage& obj) const {
+    Res operator()(CRemoveOracleAppointMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CUpdateOracleAppointMessage& obj) const {
+    Res operator()(CUpdateOracleAppointMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CSetOracleDataMessage& obj) const {
+    Res operator()(CSetOracleDataMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXCreateOrderMessage& obj) const {
+    Res operator()(CICXCreateOrderMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXMakeOfferMessage& obj) const {
+    Res operator()(CICXMakeOfferMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXSubmitDFCHTLCMessage& obj) const {
+    Res operator()(CICXSubmitDFCHTLCMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXSubmitEXTHTLCMessage& obj) const {
+    Res operator()(CICXSubmitEXTHTLCMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXClaimDFCHTLCMessage& obj) const {
+    Res operator()(CICXClaimDFCHTLCMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXCloseOrderMessage& obj) const {
+    Res operator()(CICXCloseOrderMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CICXCloseOfferMessage& obj) const {
+    Res operator()(CICXCloseOfferMessage &obj) const {
         auto res = isPostEunosFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CPoolSwapMessageV2& obj) const {
+    Res operator()(CPoolSwapMessageV2 &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanSetCollateralTokenMessage& obj) const {
+    Res operator()(CLoanSetCollateralTokenMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanSetLoanTokenMessage& obj) const {
+    Res operator()(CLoanSetLoanTokenMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanUpdateLoanTokenMessage& obj) const {
+    Res operator()(CLoanUpdateLoanTokenMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanSchemeMessage& obj) const {
+    Res operator()(CLoanSchemeMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CDefaultLoanSchemeMessage& obj) const {
+    Res operator()(CDefaultLoanSchemeMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CDestroyLoanSchemeMessage& obj) const {
+    Res operator()(CDestroyLoanSchemeMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CVaultMessage& obj) const {
+    Res operator()(CVaultMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CCloseVaultMessage& obj) const {
+    Res operator()(CCloseVaultMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CUpdateVaultMessage& obj) const {
+    Res operator()(CUpdateVaultMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CDepositToVaultMessage& obj) const {
+    Res operator()(CDepositToVaultMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CWithdrawFromVaultMessage& obj) const {
+    Res operator()(CWithdrawFromVaultMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CPaybackWithCollateralMessage& obj) const {
+    Res operator()(CPaybackWithCollateralMessage &obj) const {
         auto res = isPostFortCanningEpilogueFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanTakeLoanMessage& obj) const {
+    Res operator()(CLoanTakeLoanMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanPaybackLoanMessage& obj) const {
+    Res operator()(CLoanPaybackLoanMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CLoanPaybackLoanV2Message& obj) const {
+    Res operator()(CLoanPaybackLoanV2Message &obj) const {
         auto res = isPostFortCanningRoadFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CAuctionBidMessage& obj) const {
+    Res operator()(CAuctionBidMessage &obj) const {
         auto res = isPostFortCanningFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CBurnTokensMessage& obj) const {
+    Res operator()(CBurnTokensMessage &obj) const {
         auto res = isPostGrandCentralFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CCreatePropMessage& obj) const {
+    Res operator()(CCreatePropMessage &obj) const {
         auto res = isPostGrandCentralFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CPropVoteMessage& obj) const {
+    Res operator()(CPropVoteMessage &obj) const {
         auto res = isPostGrandCentralFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CGovernanceUnsetMessage& obj) const {
+    Res operator()(CGovernanceUnsetMessage &obj) const {
         auto res = isPostGrandCentralFork();
         return !res ? res : serialize(obj);
     }
 
-    Res operator()(CCustomTxMessageNone&) const {
-        return Res::Ok();
-    }
+    Res operator()(CCustomTxMessageNone &) const { return Res::Ok(); }
 };
 
-CCustomTxVisitor::CCustomTxVisitor(const CTransaction& tx,
-    uint32_t height,
-    const CCoinsViewCache& coins,
-    CCustomCSView& mnview,
-    const Consensus::Params& consensus)
-    : height(height), mnview(mnview), tx(tx), coins(coins), consensus(consensus) {}
-
-bool CCustomTxVisitor::HasAuth(const CScript& auth) const
-{
-    for (const auto& input : tx.vin) {
-        const Coin& coin = coins.AccessCoin(input.prevout);
+CCustomTxVisitor::CCustomTxVisitor(const CTransaction &tx,
+                                   uint32_t height,
+                                   const CCoinsViewCache &coins,
+                                   CCustomCSView &mnview,
+                                   const Consensus::Params &consensus)
+    : height(height),
+      mnview(mnview),
+      tx(tx),
+      coins(coins),
+      consensus(consensus) {}
+
+bool CCustomTxVisitor::HasAuth(const CScript &auth) const {
+    for (const auto &input : tx.vin) {
+        const Coin &coin = coins.AccessCoin(input.prevout);
         if (!coin.IsSpent() && coin.out.scriptPubKey == auth) {
             return true;
         }
@@ -625,28 +745,29 @@ bool CCustomTxVisitor::HasAuth(const CScript& auth) const
     return false;
 }
 
-Res CCustomTxVisitor::HasCollateralAuth(const uint256& collateralTx) const
-{
-    const Coin& auth = coins.AccessCoin(COutPoint(collateralTx, 1)); // always n=1 output
+Res CCustomTxVisitor::HasCollateralAuth(const uint256 &collateralTx) const {
+    const Coin &auth = coins.AccessCoin(COutPoint(collateralTx, 1));  // always n=1 output
     if (!HasAuth(auth.out.scriptPubKey)) {
         return Res::Err("tx must have at least one input from the owner");
     }
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::HasFoundationAuth() const
-{
-    auto members = consensus.foundationMembers;
+Res CCustomTxVisitor::HasFoundationAuth() const {
+    auto members          = consensus.foundationMembers;
     const auto attributes = mnview.GetAttributes();
     assert(attributes);
-    if (attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::GovFoundation}, false)) {
-        if (const auto databaseMembers = attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Foundation, DFIPKeys::Members}, std::set<CScript>{}); !databaseMembers.empty()) {
+    if (attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::GovFoundation},
+                             false)) {
+        if (const auto databaseMembers = attributes->GetValue(
+                CDataStructureV0{AttributeTypes::Param, ParamIDs::Foundation, DFIPKeys::Members}, std::set<CScript>{});
+            !databaseMembers.empty()) {
             members = databaseMembers;
         }
     }
 
-    for (const auto& input : tx.vin) {
-        const Coin& coin = coins.AccessCoin(input.prevout);
+    for (const auto &input : tx.vin) {
+        const Coin &coin = coins.AccessCoin(input.prevout);
         if (!coin.IsSpent() && members.count(coin.out.scriptPubKey) > 0) {
             return Res::Ok();
         }
@@ -654,24 +775,23 @@ Res CCustomTxVisitor::HasFoundationAuth() const
     return Res::Err("tx not from foundation member");
 }
 
-Res CCustomTxVisitor::CheckMasternodeCreationTx() const
-{
-    if (tx.vout.size() < 2 || tx.vout[0].nValue < GetMnCreationFee(height) || tx.vout[0].nTokenId != DCT_ID{0} || tx.vout[1].nValue != GetMnCollateralAmount(height) || tx.vout[1].nTokenId != DCT_ID{0}) {
+Res CCustomTxVisitor::CheckMasternodeCreationTx() const {
+    if (tx.vout.size() < 2 || tx.vout[0].nValue < GetMnCreationFee(height) || tx.vout[0].nTokenId != DCT_ID{0} ||
+        tx.vout[1].nValue != GetMnCollateralAmount(height) || tx.vout[1].nTokenId != DCT_ID{0}) {
         return Res::Err("malformed tx vouts (wrong creation fee or collateral amount)");
     }
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::CheckTokenCreationTx() const
-{
-    if (tx.vout.size() < 2 || tx.vout[0].nValue < GetTokenCreationFee(height) || tx.vout[0].nTokenId != DCT_ID{0} || tx.vout[1].nValue != GetTokenCollateralAmount() || tx.vout[1].nTokenId != DCT_ID{0}) {
+Res CCustomTxVisitor::CheckTokenCreationTx() const {
+    if (tx.vout.size() < 2 || tx.vout[0].nValue < GetTokenCreationFee(height) || tx.vout[0].nTokenId != DCT_ID{0} ||
+        tx.vout[1].nValue != GetTokenCollateralAmount() || tx.vout[1].nTokenId != DCT_ID{0}) {
         return Res::Err("malformed tx vouts (wrong creation fee or collateral amount)");
     }
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::CheckCustomTx() const
-{
+Res CCustomTxVisitor::CheckCustomTx() const {
     if (static_cast<int>(height) < consensus.EunosPayaHeight && tx.vout.size() != 2) {
         return Res::Err("malformed tx vouts ((wrong number of vouts)");
     }
@@ -681,16 +801,14 @@ Res CCustomTxVisitor::CheckCustomTx() const
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::CheckProposalTx(const CCreatePropMessage& msg) const
-{
+Res CCustomTxVisitor::CheckProposalTx(const CCreatePropMessage &msg) const {
     if (tx.vout[0].nValue != GetPropsCreationFee(height, mnview, msg) || tx.vout[0].nTokenId != DCT_ID{0})
         return Res::Err("malformed tx vouts (wrong creation fee)");
 
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::TransferTokenBalance(DCT_ID id, CAmount amount, CScript const& from, CScript const& to) const
-{
+Res CCustomTxVisitor::TransferTokenBalance(DCT_ID id, CAmount amount, const CScript &from, const CScript &to) const {
     assert(!from.empty() || !to.empty());
 
     CTokenAmount tokenAmount{id, amount};
@@ -711,51 +829,53 @@ Res CCustomTxVisitor::TransferTokenBalance(DCT_ID id, CAmount amount, CScript co
     return Res::Ok();
 }
 
-DCT_ID CCustomTxVisitor::FindTokenByPartialSymbolName(const std::string& symbol) const
-{
+DCT_ID CCustomTxVisitor::FindTokenByPartialSymbolName(const std::string &symbol) const {
     DCT_ID res{0};
-    mnview.ForEachToken([&](DCT_ID id, CTokenImplementation token) {
-        if (token.symbol.find(symbol) == 0) {
-            res = id;
-            return false;
-        }
-        return true;
-    },
+    mnview.ForEachToken(
+        [&](DCT_ID id, CTokenImplementation token) {
+            if (token.symbol.find(symbol) == 0) {
+                res = id;
+                return false;
+            }
+            return true;
+        },
         DCT_ID{1});
     assert(res.v != 0);
     return res;
 }
 
-CPoolPair CCustomTxVisitor::GetBTCDFIPoolPair() const
-{
-    auto BTC = FindTokenByPartialSymbolName(CICXOrder::TOKEN_BTC);
+CPoolPair CCustomTxVisitor::GetBTCDFIPoolPair() const {
+    auto BTC  = FindTokenByPartialSymbolName(CICXOrder::TOKEN_BTC);
     auto pair = mnview.GetPoolPair(BTC, DCT_ID{0});
     assert(pair);
     return std::move(pair->second);
 }
 
-static CAmount GetDFIperBTC(const CPoolPair& BTCDFIPoolPair)
-{
+static CAmount GetDFIperBTC(const CPoolPair &BTCDFIPoolPair) {
     if (BTCDFIPoolPair.idTokenA == DCT_ID({0}))
         return DivideAmounts(BTCDFIPoolPair.reserveA, BTCDFIPoolPair.reserveB);
     return DivideAmounts(BTCDFIPoolPair.reserveB, BTCDFIPoolPair.reserveA);
 }
 
-CAmount CCustomTxVisitor::CalculateTakerFee(CAmount amount) const
-{
+CAmount CCustomTxVisitor::CalculateTakerFee(CAmount amount) const {
     auto tokenBTC = mnview.GetToken(CICXOrder::TOKEN_BTC);
     assert(tokenBTC);
     auto pair = mnview.GetPoolPair(tokenBTC->first, DCT_ID{0});
     assert(pair);
-    return (arith_uint256(amount) * mnview.ICXGetTakerFeePerBTC() / COIN * GetDFIperBTC(pair->second) / COIN).GetLow64();
+    return (arith_uint256(amount) * mnview.ICXGetTakerFeePerBTC() / COIN * GetDFIperBTC(pair->second) / COIN)
+        .GetLow64();
 }
 
-ResVal<CScript> CCustomTxVisitor::MintableToken(DCT_ID id, const CTokenImplementation& token, bool anybodyCanMint) const {
+ResVal<CScript> CCustomTxVisitor::MintableToken(DCT_ID id,
+                                                const CTokenImplementation &token,
+                                                bool anybodyCanMint) const {
     if (token.destructionTx != uint256{}) {
-        return Res::Err("token %s already destroyed at height %i by tx %s", token.symbol,
-                        token.destructionHeight, token.destructionTx.GetHex());
+        return Res::Err("token %s already destroyed at height %i by tx %s",
+                        token.symbol,
+                        token.destructionHeight,
+                        token.destructionTx.GetHex());
     }
-    const Coin& auth = coins.AccessCoin(COutPoint(token.creationTx, 1)); // always n=1 output
+    const Coin &auth = coins.AccessCoin(COutPoint(token.creationTx, 1));  // always n=1 output
 
     // pre-bayfront logic:
     if (static_cast<int>(height) < consensus.BayfrontHeight) {
@@ -784,10 +904,11 @@ ResVal<CScript> CCustomTxVisitor::MintableToken(DCT_ID id, const CTokenImplement
     }
 
     ResVal<CScript> result = {auth.out.scriptPubKey, Res::Ok()};
-    if (anybodyCanMint || HasAuth(auth.out.scriptPubKey)) return result;
+    if (anybodyCanMint || HasAuth(auth.out.scriptPubKey))
+        return result;
 
-    // Historic: in the case of DAT, it's ok to do not check foundation auth cause exact DAT owner is foundation member himself
-    // The above is no longer true.
+    // Historic: in the case of DAT, it's ok to do not check foundation auth cause exact DAT owner is foundation member
+    // himself The above is no longer true.
 
     if (token.IsDAT()) {
         // Is a DAT, check founders auth
@@ -801,8 +922,7 @@ ResVal<CScript> CCustomTxVisitor::MintableToken(DCT_ID id, const CTokenImplement
     return result;
 }
 
-Res CCustomTxVisitor::EraseEmptyBalances(TAmounts& balances) const
-{
+Res CCustomTxVisitor::EraseEmptyBalances(TAmounts &balances) const {
     for (auto it = balances.begin(), next_it = it; it != balances.end(); it = next_it) {
         ++next_it;
 
@@ -818,9 +938,8 @@ Res CCustomTxVisitor::EraseEmptyBalances(TAmounts& balances) const
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::SetShares(const CScript& owner, const TAmounts& balances) const
-{
-    for (const auto& balance : balances) {
+Res CCustomTxVisitor::SetShares(const CScript &owner, const TAmounts &balances) const {
+    for (const auto &balance : balances) {
         auto token = mnview.GetToken(balance.first);
         if (token && token->IsPoolShare()) {
             const auto bal = mnview.GetBalance(owner, balance.first);
@@ -835,9 +954,8 @@ Res CCustomTxVisitor::SetShares(const CScript& owner, const TAmounts& balances)
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::DelShares(const CScript& owner, const TAmounts& balances) const
-{
-    for (const auto& kv : balances) {
+Res CCustomTxVisitor::DelShares(const CScript &owner, const TAmounts &balances) const {
+    for (const auto &kv : balances) {
         auto token = mnview.GetToken(kv.first);
         if (token && token->IsPoolShare()) {
             const auto balance = mnview.GetBalance(owner, kv.first);
@@ -853,15 +971,13 @@ Res CCustomTxVisitor::DelShares(const CScript& owner, const TAmounts& balances)
 }
 
 // we need proxy view to prevent add/sub balance record
-void CCustomTxVisitor::CalculateOwnerRewards(const CScript& owner) const
-{
+void CCustomTxVisitor::CalculateOwnerRewards(const CScript &owner) const {
     CCustomCSView view(mnview);
     view.CalculateOwnerRewards(owner, height);
     view.Flush();
 }
 
-Res CCustomTxVisitor::SubBalanceDelShares(const CScript& owner, const CBalances& balance) const
-{
+Res CCustomTxVisitor::SubBalanceDelShares(const CScript &owner, const CBalances &balance) const {
     CalculateOwnerRewards(owner);
     auto res = mnview.SubBalances(owner, balance);
     if (!res) {
@@ -870,16 +986,14 @@ Res CCustomTxVisitor::SubBalanceDelShares(const CScript& owner, const CBalances&
     return DelShares(owner, balance.balances);
 }
 
-Res CCustomTxVisitor::AddBalanceSetShares(const CScript& owner, const CBalances& balance) const
-{
+Res CCustomTxVisitor::AddBalanceSetShares(const CScript &owner, const CBalances &balance) const {
     CalculateOwnerRewards(owner);
     auto res = mnview.AddBalances(owner, balance);
     return !res ? res : SetShares(owner, balance.balances);
 }
 
-Res CCustomTxVisitor::AddBalancesSetShares(const CAccounts& accounts) const
-{
-    for (const auto& account : accounts) {
+Res CCustomTxVisitor::AddBalancesSetShares(const CAccounts &accounts) const {
+    for (const auto &account : accounts) {
         auto res = AddBalanceSetShares(account.first, account.second);
         if (!res) {
             return res;
@@ -888,9 +1002,8 @@ Res CCustomTxVisitor::AddBalancesSetShares(const CAccounts& accounts) const
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::SubBalancesDelShares(const CAccounts& accounts) const
-{
-    for (const auto& account : accounts) {
+Res CCustomTxVisitor::SubBalancesDelShares(const CAccounts &accounts) const {
+    for (const auto &account : accounts) {
         auto res = SubBalanceDelShares(account.first, account.second);
         if (!res) {
             return res;
@@ -899,11 +1012,10 @@ Res CCustomTxVisitor::SubBalancesDelShares(const CAccounts& accounts) const
     return Res::Ok();
 }
 
-Res CCustomTxVisitor::NormalizeTokenCurrencyPair(std::set<CTokenCurrencyPair>& tokenCurrency) const
-{
+Res CCustomTxVisitor::NormalizeTokenCurrencyPair(std::set<CTokenCurrencyPair> &tokenCurrency) const {
     std::set<CTokenCurrencyPair> trimmed;
-    for (const auto& pair : tokenCurrency) {
-        auto token = trim_ws(pair.first).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+    for (const auto &pair : tokenCurrency) {
+        auto token    = trim_ws(pair.first).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
         auto currency = trim_ws(pair.second).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
         if (token.empty() || currency.empty()) {
             return Res::Err("empty token / currency");
@@ -914,13 +1026,11 @@ Res CCustomTxVisitor::NormalizeTokenCurrencyPair(std::set<CTokenCurrencyPair>& t
     return Res::Ok();
 }
 
-bool CCustomTxVisitor::IsTokensMigratedToGovVar() const
-{
+bool CCustomTxVisitor::IsTokensMigratedToGovVar() const {
     return static_cast<int>(height) > consensus.FortCanningCrunchHeight + 1;
 }
 
-Res CCustomTxVisitor::IsOnChainGovernanceEnabled() const
-{
+Res CCustomTxVisitor::IsOnChainGovernanceEnabled() const {
     CDataStructureV0 enabledKey{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::GovernanceEnabled};
 
     auto attributes = mnview.GetAttributes();
@@ -935,22 +1045,24 @@ Res CCustomTxVisitor::IsOnChainGovernanceEnabled() const
     return Res::Ok();
 }
 
-class CCustomTxApplyVisitor : public CCustomTxVisitor
-{
+class CCustomTxApplyVisitor : public CCustomTxVisitor {
     uint64_t time;
     uint32_t txn;
+
 public:
-    CCustomTxApplyVisitor(const CTransaction& tx,
+    CCustomTxApplyVisitor(const CTransaction &tx,
                           uint32_t height,
-                          const CCoinsViewCache& coins,
-                          CCustomCSView& mnview,
-                          const Consensus::Params& consensus,
+                          const CCoinsViewCache &coins,
+                          CCustomCSView &mnview,
+                          const Consensus::Params &consensus,
                           uint64_t time,
                           uint32_t txn)
 
-        : CCustomTxVisitor(tx, height, coins, mnview, consensus), time(time), txn(txn) {}
+        : CCustomTxVisitor(tx, height, coins, mnview, consensus),
+          time(time),
+          txn(txn) {}
 
-    Res operator()(const CCreateMasterNodeMessage& obj) const {
+    Res operator()(const CCreateMasterNodeMessage &obj) const {
         auto res = CheckMasternodeCreationTx();
         if (!res) {
             return res;
@@ -961,7 +1073,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         if (height >= static_cast<uint32_t>(Params().GetConsensus().EunosPayaHeight)) {
-            switch(obj.timelock) {
+            switch (obj.timelock) {
                 case CMasternode::ZEROYEAR:
                 case CMasternode::FIVEYEAR:
                 case CMasternode::TENYEAR:
@@ -977,15 +1089,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         CTxDestination dest;
         if (ExtractDestination(tx.vout[1].scriptPubKey, dest)) {
             if (dest.index() == PKHashType) {
-                node.ownerType = 1;
+                node.ownerType        = 1;
                 node.ownerAuthAddress = CKeyID(std::get<PKHash>(dest));
             } else if (dest.index() == WitV0KeyHashType) {
-                node.ownerType = 4;
+                node.ownerType        = 4;
                 node.ownerAuthAddress = CKeyID(std::get<WitnessV0KeyHash>(dest));
             }
         }
-        node.creationHeight = height;
-        node.operatorType = obj.operatorType;
+        node.creationHeight      = height;
+        node.operatorType        = obj.operatorType;
         node.operatorAuthAddress = obj.operatorAuthAddress;
 
         // Set masternode version2 after FC for new serialisation
@@ -994,16 +1106,17 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         bool duplicate{};
-        mnview.ForEachNewCollateral([&](const uint256& key, CLazySerialize<MNNewOwnerHeightValue> valueKey) {
-            const auto& value = valueKey.get();
+        mnview.ForEachNewCollateral([&](const uint256 &key, CLazySerialize<MNNewOwnerHeightValue> valueKey) {
+            const auto &value = valueKey.get();
             if (height > value.blockHeight) {
                 return true;
             }
-            const auto& coin = coins.AccessCoin({key, 1});
+            const auto &coin = coins.AccessCoin({key, 1});
             assert(!coin.IsSpent());
             CTxDestination pendingDest;
             assert(ExtractDestination(coin.out.scriptPubKey, pendingDest));
-            const CKeyID storedID = pendingDest.index() == PKHashType ? CKeyID(std::get<PKHash>(pendingDest)) : CKeyID(std::get<WitnessV0KeyHash>(pendingDest));
+            const CKeyID storedID = pendingDest.index() == PKHashType ? CKeyID(std::get<PKHash>(pendingDest))
+                                                                      : CKeyID(std::get<WitnessV0KeyHash>(pendingDest));
             if (storedID == node.ownerAuthAddress || storedID == node.operatorAuthAddress) {
                 duplicate = true;
                 return false;
@@ -1029,7 +1142,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return res;
     }
 
-    Res operator()(const CResignMasterNodeMessage& obj) const {
+    Res operator()(const CResignMasterNodeMessage &obj) const {
         auto node = mnview.GetMasternode(obj);
         if (!node) {
             return Res::Err("node %s does not exists", obj.ToString());
@@ -1038,7 +1151,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ResignMasternode(*node, obj, tx.GetHash(), height);
     }
 
-    Res operator()(const CUpdateMasterNodeMessage& obj) const {
+    Res operator()(const CUpdateMasterNodeMessage &obj) const {
         if (obj.updates.empty()) {
             return Res::Err("No update arguments provided");
         }
@@ -1053,7 +1166,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         const auto collateralTx = node->collateralTx.IsNull() ? obj.mnId : node->collateralTx;
-        const auto res = HasCollateralAuth(collateralTx);
+        const auto res          = HasCollateralAuth(collateralTx);
         if (!res) {
             return res;
         }
@@ -1067,8 +1180,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         assert(attributes);
 
         bool ownerType{}, operatorType{}, rewardType{};
-        for (const auto& [type, addressPair] : obj.updates) {
-            const auto& [addressType, rawAddress] = addressPair;
+        for (const auto &[type, addressPair] : obj.updates) {
+            const auto &[addressType, rawAddress] = addressPair;
             if (type == static_cast<uint8_t>(UpdateMasternodeType::OwnerAddress)) {
                 CDataStructureV0 key{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::MNSetOwnerAddress};
                 if (!attributes->GetValue(key, false)) {
@@ -1079,7 +1192,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 }
                 ownerType = true;
                 bool collateralFound{};
-                for (const auto& vin : tx.vin) {
+                for (const auto &vin : tx.vin) {
                     if (vin.prevout.hash == collateralTx && vin.prevout.n == 1) {
                         collateralFound = true;
                     }
@@ -1092,7 +1205,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 }
 
                 CTxDestination dest;
-                if (!ExtractDestination(tx.vout[1].scriptPubKey, dest) || (dest.index() != PKHashType && dest.index() != WitV0KeyHashType)) {
+                if (!ExtractDestination(tx.vout[1].scriptPubKey, dest) ||
+                    (dest.index() != PKHashType && dest.index() != WitV0KeyHashType)) {
                     return Res::Err("Owner address must be P2PKH or P2WPKH type");
                 }
 
@@ -1100,22 +1214,25 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                     return Res::Err("Incorrect collateral amount");
                 }
 
-                const auto keyID = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) : CKeyID(std::get<WitnessV0KeyHash>(dest));
+                const auto keyID = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest))
+                                                              : CKeyID(std::get<WitnessV0KeyHash>(dest));
                 if (mnview.GetMasternodeIdByOwner(keyID) || mnview.GetMasternodeIdByOperator(keyID)) {
                     return Res::Err("Masternode with collateral address as operator or owner already exists");
                 }
 
                 bool duplicate{};
-                mnview.ForEachNewCollateral([&](const uint256& key, CLazySerialize<MNNewOwnerHeightValue> valueKey) {
-                    const auto& value = valueKey.get();
+                mnview.ForEachNewCollateral([&](const uint256 &key, CLazySerialize<MNNewOwnerHeightValue> valueKey) {
+                    const auto &value = valueKey.get();
                     if (height > value.blockHeight) {
                         return true;
                     }
-                    const auto& coin = coins.AccessCoin({key, 1});
+                    const auto &coin = coins.AccessCoin({key, 1});
                     assert(!coin.IsSpent());
                     CTxDestination pendingDest;
                     assert(ExtractDestination(coin.out.scriptPubKey, pendingDest));
-                    const CKeyID storedID = pendingDest.index() == PKHashType ? CKeyID(std::get<PKHash>(pendingDest)) : CKeyID(std::get<WitnessV0KeyHash>(pendingDest));
+                    const CKeyID storedID = pendingDest.index() == PKHashType
+                                                ? CKeyID(std::get<PKHash>(pendingDest))
+                                                : CKeyID(std::get<WitnessV0KeyHash>(pendingDest));
                     if (storedID == keyID) {
                         duplicate = true;
                         return false;
@@ -1123,7 +1240,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                     return true;
                 });
                 if (duplicate) {
-                    return Res::ErrCode(CustomTxErrCodes::Fatal, "Masternode exist with that owner address pending already");
+                    return Res::ErrCode(CustomTxErrCodes::Fatal,
+                                        "Masternode exist with that owner address pending already");
                 }
 
                 mnview.UpdateMasternodeCollateral(obj.mnId, *node, tx.GetHash(), height);
@@ -1181,26 +1299,27 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CCreateTokenMessage& obj) const {
+    Res operator()(const CCreateTokenMessage &obj) const {
         auto res = CheckTokenCreationTx();
         if (!res) {
             return res;
         }
 
         CTokenImplementation token;
-        static_cast<CToken&>(token) = obj;
+        static_cast<CToken &>(token) = obj;
 
-        token.symbol = trim_ws(token.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
-        token.name = trim_ws(token.name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
-        token.creationTx = tx.GetHash();
+        token.symbol         = trim_ws(token.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+        token.name           = trim_ws(token.name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
+        token.creationTx     = tx.GetHash();
         token.creationHeight = height;
 
-        //check foundation auth
+        // check foundation auth
         if (token.IsDAT() && !HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
 
-        if (static_cast<int>(height) >= consensus.BayfrontHeight) { // formal compatibility if someone cheat and create LPS token on the pre-bayfront node
+        if (static_cast<int>(height) >= consensus.BayfrontHeight) {  // formal compatibility if someone cheat and create
+                                                                     // LPS token on the pre-bayfront node
             if (token.IsPoolShare()) {
                 return Res::Err("Cant't manually create 'Liquidity Pool Share' token; use poolpair creation");
             }
@@ -1209,14 +1328,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.CreateToken(token, static_cast<int>(height) < consensus.BayfrontHeight);
     }
 
-    Res operator()(const CUpdateTokenPreAMKMessage& obj) const {
+    Res operator()(const CUpdateTokenPreAMKMessage &obj) const {
         auto pair = mnview.GetTokenByCreationTx(obj.tokenTx);
         if (!pair) {
             return Res::Err("token with creationTx %s does not exist", obj.tokenTx.ToString());
         }
         auto token = pair->second;
 
-        //check foundation auth
+        // check foundation auth
         auto res = HasFoundationAuth();
 
         if (token.IsDAT() != obj.isDAT && pair->first >= CTokensView::DCT_ID_START) {
@@ -1226,20 +1345,20 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return res;
     }
 
-    Res operator()(const CUpdateTokenMessage& obj) const {
+    Res operator()(const CUpdateTokenMessage &obj) const {
         auto pair = mnview.GetTokenByCreationTx(obj.tokenTx);
         if (!pair) {
             return Res::Err("token with creationTx %s does not exist", obj.tokenTx.ToString());
         }
         if (pair->first == DCT_ID{0}) {
-            return Res::Err("Can't alter DFI token!"); // may be redundant cause DFI is 'finalized'
+            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;
+        const auto &token = pair->second;
 
         // need to check it exectly here cause lps has no collateral auth (that checked next)
         if (token.IsPoolShare()) {
@@ -1247,15 +1366,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         // check auth, depends from token's "origins"
-        const Coin& auth = coins.AccessCoin(COutPoint(token.creationTx, 1)); // always n=1 output
+        const Coin &auth = coins.AccessCoin(COutPoint(token.creationTx, 1));  // always n=1 output
 
         const auto attributes = mnview.GetAttributes();
         assert(attributes);
         std::set<CScript> databaseMembers;
-        if (attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::GovFoundation}, false)) {
-            databaseMembers = attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Foundation, DFIPKeys::Members}, std::set<CScript>{});
+        if (attributes->GetValue(CDataStructureV0{AttributeTypes::Param, ParamIDs::Feature, DFIPKeys::GovFoundation},
+                                 false)) {
+            databaseMembers = attributes->GetValue(
+                CDataStructureV0{AttributeTypes::Param, ParamIDs::Foundation, DFIPKeys::Members}, std::set<CScript>{});
         }
-        bool isFoundersToken = !databaseMembers.empty() ? databaseMembers.count(auth.out.scriptPubKey) > 0 : consensus.foundationMembers.count(auth.out.scriptPubKey) > 0;
+        bool isFoundersToken = !databaseMembers.empty() ? databaseMembers.count(auth.out.scriptPubKey) > 0
+                                                        : consensus.foundationMembers.count(auth.out.scriptPubKey) > 0;
 
         auto res = Res::Ok();
         if (isFoundersToken && !(res = HasFoundationAuth())) {
@@ -1266,15 +1388,16 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // Check for isDAT change in non-foundation token after set height
         if (static_cast<int>(height) >= consensus.BayfrontMarinaHeight) {
-            //check foundation auth
-            if (obj.token.IsDAT() != token.IsDAT() && !HasFoundationAuth()) { //no need to check Authority if we don't create isDAT
+            // check foundation auth
+            if (obj.token.IsDAT() != token.IsDAT() &&
+                !HasFoundationAuth()) {  // no need to check Authority if we don't create isDAT
                 return Res::Err("can't set isDAT to true, tx not from foundation member");
             }
         }
 
         CTokenImplementation updatedToken{obj.token};
-        updatedToken.creationTx = token.creationTx;
-        updatedToken.destructionTx = token.destructionTx;
+        updatedToken.creationTx        = token.creationTx;
+        updatedToken.destructionTx     = token.destructionTx;
         updatedToken.destructionHeight = token.destructionHeight;
         if (height >= static_cast<uint32_t>(consensus.FortCanningHeight)) {
             updatedToken.symbol = trim_ws(updatedToken.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
@@ -1283,16 +1406,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.UpdateToken(updatedToken);
     }
 
-    Res operator()(const CMintTokensMessage& obj) const {
-        const auto isRegTest = Params().NetworkIDString() == CBaseChainParams::REGTEST;
+    Res operator()(const CMintTokensMessage &obj) const {
+        const auto isRegTest                = Params().NetworkIDString() == CBaseChainParams::REGTEST;
         const auto isRegTestSimulateMainnet = gArgs.GetArg("-regtest-minttoken-simulate-mainnet", false);
-        const auto fortCanningCrunchHeight = static_cast<uint32_t>(consensus.FortCanningCrunchHeight);
-        const auto grandCentralHeight = static_cast<uint32_t>(consensus.GrandCentralHeight);
+        const auto fortCanningCrunchHeight  = static_cast<uint32_t>(consensus.FortCanningCrunchHeight);
+        const auto grandCentralHeight       = static_cast<uint32_t>(consensus.GrandCentralHeight);
 
         // check auth and increase balance of token's owner
-        for (const auto& [tokenId, amount] : obj.balances) {
-            if (Params().NetworkIDString() == CBaseChainParams::MAIN &&
-                height >= fortCanningCrunchHeight &&
+        for (const auto &[tokenId, amount] : obj.balances) {
+            if (Params().NetworkIDString() == CBaseChainParams::MAIN && height >= fortCanningCrunchHeight &&
                 mnview.GetLoanTokenByID(tokenId)) {
                 return Res::Err("Loan tokens cannot be minted");
             }
@@ -1302,7 +1424,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 return Res::Err("token %s does not exist!", tokenId.ToString());
 
             bool anybodyCanMint = isRegTest && !isRegTestSimulateMainnet;
-            auto mintable = MintableToken(tokenId, *token, anybodyCanMint);
+            auto mintable       = MintableToken(tokenId, *token, anybodyCanMint);
 
             auto mintTokensInternal = [&](DCT_ID tokenId, CAmount amount) {
                 auto minted = mnview.AddMintedTokens(tokenId, amount);
@@ -1320,10 +1442,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             if (!mintable)
                 return std::move(mintable);
 
-            if (anybodyCanMint || height < grandCentralHeight || !token->IsDAT() || HasFoundationAuth())
-            {
+            if (anybodyCanMint || height < grandCentralHeight || !token->IsDAT() || HasFoundationAuth()) {
                 auto res = mintTokensInternal(tokenId, amount);
-                if (!res) return res;
+                if (!res)
+                    return res;
                 continue;
             }
 
@@ -1335,26 +1457,26 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             const auto members = attributes->GetValue(membersKey, CConsortiumMembers{});
 
             if (!attributes->GetValue(enableKey, false) || members.empty()) {
-                const Coin& auth = coins.AccessCoin(COutPoint(token->creationTx, 1)); // always n=1 output
+                const Coin &auth = coins.AccessCoin(COutPoint(token->creationTx, 1));  // always n=1 output
                 if (!HasAuth(auth.out.scriptPubKey))
                     return Res::Err("You are not a foundation member or token owner and cannot mint this token!");
 
                 auto res = mintTokensInternal(tokenId, amount);
-                if (!res) return res;
+                if (!res)
+                    return res;
                 continue;
             }
 
             mintable.ok = false;
 
-            CDataStructureV0 membersMintedKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMembersMinted};
+            CDataStructureV0 membersMintedKey{
+                AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMembersMinted};
             auto membersBalances = attributes->GetValue(membersMintedKey, CConsortiumMembersMinted{});
 
             const auto dailyInterval = height / consensus.blocksPerDay() * consensus.blocksPerDay();
 
-            for (auto const& [key, member] : members)
-            {
-                if (HasAuth(member.ownerAddress))
-                {
+            for (const auto &[key, member] : members) {
+                if (HasAuth(member.ownerAddress)) {
                     if (member.status != CConsortiumMember::Status::Active)
                         return Res::Err("Cannot mint token, not an active member of consortium for %s!", token->symbol);
 
@@ -1369,19 +1491,21 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                             return (std::move(add));
                         membersBalances[tokenId][key].dailyMinted.second = add;
                     } else {
-                        membersBalances[tokenId][key].dailyMinted.first = dailyInterval;
+                        membersBalances[tokenId][key].dailyMinted.first  = dailyInterval;
                         membersBalances[tokenId][key].dailyMinted.second = amount;
                     }
 
                     if (membersBalances[tokenId][key].minted > member.mintLimit)
-                        return Res::Err("You will exceed your maximum mint limit for %s token by minting this amount!", token->symbol);
+                        return Res::Err("You will exceed your maximum mint limit for %s token by minting this amount!",
+                                        token->symbol);
 
                     if (membersBalances[tokenId][key].dailyMinted.second > member.dailyMintLimit) {
-                        return Res::Err("You will exceed your daily mint limit for %s token by minting this amount", token->symbol);
+                        return Res::Err("You will exceed your daily mint limit for %s token by minting this amount",
+                                        token->symbol);
                     }
 
                     *mintable.val = member.ownerAddress;
-                    mintable.ok = true;
+                    mintable.ok   = true;
                     break;
                 }
             }
@@ -1395,7 +1519,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             CDataStructureV0 dailyLimitKey{AttributeTypes::Consortium, tokenId.v, ConsortiumKeys::DailyMintLimit};
             const auto dailyLimit = attributes->GetValue(dailyLimitKey, CAmount{0});
 
-            CDataStructureV0 consortiumMintedKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMinted};
+            CDataStructureV0 consortiumMintedKey{
+                AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMinted};
             auto globalBalances = attributes->GetValue(consortiumMintedKey, CConsortiumGlobalMinted{});
 
             auto add = SafeAdd(globalBalances[tokenId].minted, amount);
@@ -1405,17 +1530,21 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             globalBalances[tokenId].minted = add;
 
             if (maxLimit != -1 * COIN && globalBalances[tokenId].minted > maxLimit)
-                return Res::Err("You will exceed global maximum consortium mint limit for %s token by minting this amount!", token->symbol);
+                return Res::Err(
+                    "You will exceed global maximum consortium mint limit for %s token by minting this amount!",
+                    token->symbol);
 
             CAmount totalDaily{};
-            for (const auto& [key, value] : membersBalances[tokenId]) {
+            for (const auto &[key, value] : membersBalances[tokenId]) {
                 if (value.dailyMinted.first == dailyInterval) {
                     totalDaily += value.dailyMinted.second;
                 }
             }
 
             if (dailyLimit != -1 * COIN && totalDaily > dailyLimit)
-                return Res::Err("You will exceed global daily maximum consortium mint limit for %s token by minting this amount.", token->symbol);
+                return Res::Err(
+                    "You will exceed global daily maximum consortium mint limit for %s token by minting this amount.",
+                    token->symbol);
 
             attributes->SetValue(consortiumMintedKey, globalBalances);
             attributes->SetValue(membersMintedKey, membersBalances);
@@ -1425,19 +1554,19 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 return saved;
 
             auto minted = mintTokensInternal(tokenId, amount);
-            if (!minted) return minted;
+            if (!minted)
+                return minted;
         }
 
         return Res::Ok();
     }
 
-    Res operator()(const CBurnTokensMessage& obj) const {
+    Res operator()(const CBurnTokensMessage &obj) const {
         if (obj.amounts.balances.empty()) {
             return Res::Err("tx must have balances to burn");
         }
 
-        for (const auto& [tokenId, amount] : obj.amounts.balances)
-        {
+        for (const auto &[tokenId, amount] : obj.amounts.balances) {
             // check auth
             if (!HasAuth(obj.from))
                 return Res::Err("tx must have at least one input from account owner");
@@ -1449,7 +1578,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             if (auto address = std::get_if<CScript>(&obj.context); address && !address->empty())
                 ownerAddress = *address;
-            else ownerAddress = obj.from;
+            else
+                ownerAddress = obj.from;
 
             auto attributes = mnview.GetAttributes();
             if (!attributes)
@@ -1457,15 +1587,16 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             CDataStructureV0 membersKey{AttributeTypes::Consortium, tokenId.v, ConsortiumKeys::MemberValues};
             const auto members = attributes->GetValue(membersKey, CConsortiumMembers{});
-            CDataStructureV0 membersMintedKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMembersMinted};
+            CDataStructureV0 membersMintedKey{
+                AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMembersMinted};
             auto membersBalances = attributes->GetValue(membersMintedKey, CConsortiumMembersMinted{});
-            CDataStructureV0 consortiumMintedKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMinted};
+            CDataStructureV0 consortiumMintedKey{
+                AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::ConsortiumMinted};
             auto globalBalances = attributes->GetValue(consortiumMintedKey, CConsortiumGlobalMinted{});
 
             bool setVariable = false;
-            for (auto const& tmp : members)
-                if (tmp.second.ownerAddress == ownerAddress)
-                {
+            for (const auto &tmp : members)
+                if (tmp.second.ownerAddress == ownerAddress) {
                     auto add = SafeAdd(membersBalances[tokenId][tmp.first].burnt, amount);
                     if (!add)
                         return (std::move(add));
@@ -1482,8 +1613,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                     break;
                 }
 
-            if (setVariable)
-            {
+            if (setVariable) {
                 attributes->SetValue(membersMintedKey, membersBalances);
                 attributes->SetValue(consortiumMintedKey, globalBalances);
 
@@ -1500,11 +1630,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         return Res::Ok();
-
     }
 
-    Res operator()(const CCreatePoolPairMessage& obj) const {
-        //check foundation auth
+    Res operator()(const CCreatePoolPairMessage &obj) const {
+        // check foundation auth
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
@@ -1512,16 +1641,17 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("wrong commission");
         }
 
-        if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningCrunchHeight) && obj.pairSymbol.find('/') != std::string::npos) {
+        if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningCrunchHeight) &&
+            obj.pairSymbol.find('/') != std::string::npos) {
             return Res::Err("token symbol should not contain '/'");
         }
 
         /// @todo ownerAddress validity checked only in rpc. is it enough?
         CPoolPair poolPair(obj.poolPair);
-        auto pairSymbol = obj.pairSymbol;
-        poolPair.creationTx = tx.GetHash();
+        auto pairSymbol         = obj.pairSymbol;
+        poolPair.creationTx     = tx.GetHash();
         poolPair.creationHeight = height;
-        auto& rewards = poolPair.rewards;
+        auto &rewards           = poolPair.rewards;
 
         auto tokenA = mnview.GetToken(poolPair.idTokenA);
         if (!tokenA) {
@@ -1533,7 +1663,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("token %s does not exist!", poolPair.idTokenB.ToString());
         }
 
-        const auto symbolLength = height >= static_cast<uint32_t>(consensus.FortCanningHeight) ? CToken::MAX_TOKEN_POOLPAIR_LENGTH : CToken::MAX_TOKEN_SYMBOL_LENGTH;
+        const auto symbolLength = height >= static_cast<uint32_t>(consensus.FortCanningHeight)
+                                      ? CToken::MAX_TOKEN_POOLPAIR_LENGTH
+                                      : CToken::MAX_TOKEN_SYMBOL_LENGTH;
         if (pairSymbol.empty()) {
             pairSymbol = trim_ws(tokenA->symbol + "-" + tokenB->symbol).substr(0, symbolLength);
         } else {
@@ -1541,14 +1673,12 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         CTokenImplementation token;
-        token.flags = (uint8_t)CToken::TokenFlags::DAT |
-                      (uint8_t)CToken::TokenFlags::LPS |
-                      (uint8_t)CToken::TokenFlags::Tradeable |
-                      (uint8_t)CToken::TokenFlags::Finalized;
-
-        token.name = trim_ws(tokenA->name + "-" + tokenB->name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
-        token.symbol = pairSymbol;
-        token.creationTx = tx.GetHash();
+        token.flags = (uint8_t)CToken::TokenFlags::DAT | (uint8_t)CToken::TokenFlags::LPS |
+                      (uint8_t)CToken::TokenFlags::Tradeable | (uint8_t)CToken::TokenFlags::Finalized;
+
+        token.name           = trim_ws(tokenA->name + "-" + tokenB->name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
+        token.symbol         = pairSymbol;
+        token.creationTx     = tx.GetHash();
         token.creationHeight = height;
 
         auto tokenId = mnview.CreateToken(token);
@@ -1568,8 +1698,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.SetPoolPair(tokenId, height, poolPair);
     }
 
-    Res operator()(const CUpdatePoolPairMessage& obj) const {
-        //check foundation auth
+    Res operator()(const CUpdatePoolPairMessage &obj) const {
+        // check foundation auth
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
@@ -1577,8 +1707,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         auto rewards = obj.rewards;
         if (!rewards.balances.empty()) {
             // Check for special case to wipe rewards
-            if (!(rewards.balances.size() == 1 && rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()}
-            && rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max())) {
+            if (!(rewards.balances.size() == 1 &&
+                  rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()} &&
+                  rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max())) {
                 // Check if tokens exist and remove empty reward amounts
                 auto res = EraseEmptyBalances(rewards.balances);
                 if (!res) {
@@ -1589,7 +1720,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.UpdatePoolPair(obj.poolId, height, obj.status, obj.commission, obj.ownerAddress, rewards);
     }
 
-    Res operator()(const CPoolSwapMessage& obj) const {
+    Res operator()(const CPoolSwapMessage &obj) const {
         // check auth
         if (!HasAuth(obj.from)) {
             return Res::Err("tx must have at least one input from account owner");
@@ -1598,7 +1729,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return CPoolSwap(obj, height).ExecuteSwap(mnview, {});
     }
 
-    Res operator()(const CPoolSwapMessageV2& obj) const {
+    Res operator()(const CPoolSwapMessageV2 &obj) const {
         // check auth
         if (!HasAuth(obj.swapInfo.from)) {
             return Res::Err("tx must have at least one input from account owner");
@@ -1607,7 +1738,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return CPoolSwap(obj.swapInfo, height).ExecuteSwap(mnview, obj.poolIDs);
     }
 
-    Res operator()(const CLiquidityMessage& obj) const {
+    Res operator()(const CLiquidityMessage &obj) const {
         CBalances sumTx = SumAllTransfers(obj.from);
         if (sumTx.balances.size() != 2) {
             return Res::Err("the pool pair requires two tokens");
@@ -1626,13 +1757,13 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("there is no such pool pair");
         }
 
-        for (const auto& kv : obj.from) {
+        for (const auto &kv : obj.from) {
             if (!HasAuth(kv.first)) {
                 return Res::Err("tx must have at least one input from account owner");
             }
         }
 
-        for (const auto& kv : obj.from) {
+        for (const auto &kv : obj.from) {
             CalculateOwnerRewards(kv.first);
             auto res = mnview.SubBalances(kv.first, kv.second);
             if (!res) {
@@ -1640,8 +1771,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             }
         }
 
-        const auto& lpTokenID = pair->first;
-        auto& pool = pair->second;
+        const auto &lpTokenID = pair->first;
+        auto &pool            = pair->second;
 
         // normalize A & B to correspond poolpair's tokens
         if (amountA.first != pool.idTokenA) {
@@ -1649,18 +1780,21 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         bool slippageProtection = static_cast<int>(height) >= consensus.BayfrontMarinaHeight;
-        auto res = pool.AddLiquidity(amountA.second, amountB.second, [&] /*onMint*/(CAmount liqAmount) {
-
-            CBalances balance{TAmounts{{lpTokenID, liqAmount}}};
-            return AddBalanceSetShares(obj.shareAddress, balance);
-        }, slippageProtection);
+        auto res                = pool.AddLiquidity(
+            amountA.second,
+            amountB.second,
+            [&] /*onMint*/ (CAmount liqAmount) {
+                CBalances balance{TAmounts{{lpTokenID, liqAmount}}};
+                return AddBalanceSetShares(obj.shareAddress, balance);
+            },
+            slippageProtection);
 
         return !res ? res : mnview.SetPoolPair(lpTokenID, height, pool);
     }
 
-    Res operator()(const CRemoveLiquidityMessage& obj) const {
-        const auto& from = obj.from;
-        auto amount = obj.amount;
+    Res operator()(const CRemoveLiquidityMessage &obj) const {
+        const auto &from = obj.from;
+        auto amount      = obj.amount;
 
         // checked internally too. remove here?
         if (amount.nValue <= 0) {
@@ -1676,7 +1810,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("tx must have at least one input from account owner");
         }
 
-        CPoolPair& pool = pair.value();
+        CPoolPair &pool = pair.value();
 
         // subtract liq.balance BEFORE RemoveLiquidity call to check balance correctness
         {
@@ -1687,17 +1821,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             }
         }
 
-        auto res = pool.RemoveLiquidity(amount.nValue, [&] (CAmount amountA, CAmount amountB) {
-
+        auto res = pool.RemoveLiquidity(amount.nValue, [&](CAmount amountA, CAmount amountB) {
             CalculateOwnerRewards(from);
-            CBalances balances{TAmounts{{pool.idTokenA, amountA}, {pool.idTokenB, amountB}}};
+            CBalances balances{
+                TAmounts{{pool.idTokenA, amountA}, {pool.idTokenB, amountB}}
+            };
             return mnview.AddBalances(from, balances);
         });
 
         return !res ? res : mnview.SetPoolPair(amount.nTokenId, height, pool);
     }
 
-    Res operator()(const CUtxosToAccountMessage& obj) const {
+    Res operator()(const CUtxosToAccountMessage &obj) const {
         // check enough tokens are "burnt"
         const auto burnt = BurntTokens(tx);
         if (!burnt) {
@@ -1706,14 +1841,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         const auto mustBeBurnt = SumAllTransfers(obj.to);
         if (*burnt.val != mustBeBurnt) {
-            return Res::Err("transfer tokens mismatch burnt tokens: (%s) != (%s)", mustBeBurnt.ToString(), burnt.val->ToString());
+            return Res::Err(
+                "transfer tokens mismatch burnt tokens: (%s) != (%s)", mustBeBurnt.ToString(), burnt.val->ToString());
         }
 
         // transfer
         return AddBalancesSetShares(obj.to);
     }
 
-    Res operator()(const CAccountToUtxosMessage& obj) const {
+    Res operator()(const CAccountToUtxosMessage &obj) const {
         // check auth
         if (!HasAuth(obj.from)) {
             return Res::Err("tx must have at least one input from account owner");
@@ -1726,12 +1862,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         if (obj.balances != *minted.val) {
-            return Res::Err("amount of minted tokens in UTXOs and metadata do not match: (%s) != (%s)", minted.val->ToString(), obj.balances.ToString());
+            return Res::Err("amount of minted tokens in UTXOs and metadata do not match: (%s) != (%s)",
+                            minted.val->ToString(),
+                            obj.balances.ToString());
         }
 
         // block for non-DFI transactions
-        for (const auto& kv : obj.balances.balances) {
-            const DCT_ID& tokenId = kv.first;
+        for (const auto &kv : obj.balances.balances) {
+            const DCT_ID &tokenId = kv.first;
             if (tokenId != DCT_ID{0}) {
                 return Res::Err("only available for DFI transactions");
             }
@@ -1741,7 +1879,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return SubBalanceDelShares(obj.from, obj.balances);
     }
 
-    Res operator()(const CAccountToAccountMessage& obj) const {
+    Res operator()(const CAccountToAccountMessage &obj) const {
         // check auth
         if (!HasAuth(obj.from)) {
             return Res::Err("tx must have at least one input from account owner");
@@ -1752,8 +1890,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : AddBalancesSetShares(obj.to);
     }
 
-
-    Res HandleDFIP2201Contract(const CSmartContractMessage& obj) const {
+    Res HandleDFIP2201Contract(const CSmartContractMessage &obj) const {
         const auto attributes = mnview.GetAttributes();
         if (!attributes)
             return Res::Err("Attributes unavailable");
@@ -1772,12 +1909,12 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (obj.accounts.begin()->second.balances.size() != 1)
             return Res::Err("Only one amount entry expected for " + obj.name);
 
-        const auto& script = obj.accounts.begin()->first;
+        const auto &script = obj.accounts.begin()->first;
         if (!HasAuth(script))
             return Res::Err("Must have at least one input from supplied address");
 
-        const auto& id = obj.accounts.begin()->second.balances.begin()->first;
-        const auto& amount = obj.accounts.begin()->second.balances.begin()->second;
+        const auto &id     = obj.accounts.begin()->second.balances.begin()->first;
+        const auto &amount = obj.accounts.begin()->second.balances.begin()->second;
 
         if (amount <= 0)
             return Res::Err("Amount out of range");
@@ -1800,9 +1937,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!res)
             return res;
 
-        const CTokenCurrencyPair btcUsd{"BTC","USD"};
-        const CTokenCurrencyPair dfiUsd{"DFI","USD"};
-
+        const CTokenCurrencyPair btcUsd{"BTC", "USD"};
+        const CTokenCurrencyPair dfiUsd{"DFI", "USD"};
 
         bool useNextPrice{false}, requireLivePrice{true};
         auto resVal = mnview.GetValidatedIntervalPrice(btcUsd, useNextPrice, requireLivePrice);
@@ -1812,7 +1948,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         CDataStructureV0 premiumKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIPKeys::Premium};
         auto premium = attributes->GetValue(premiumKey, CAmount{2500000});
 
-        const auto& btcPrice = MultiplyAmounts(*resVal.val, premium + COIN);
+        const auto &btcPrice = MultiplyAmounts(*resVal.val, premium + COIN);
 
         resVal = mnview.GetValidatedIntervalPrice(dfiUsd, useNextPrice, requireLivePrice);
         if (!resVal)
@@ -1831,7 +1967,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CSmartContractMessage& obj) const {
+    Res operator()(const CSmartContractMessage &obj) const {
         if (obj.accounts.empty()) {
             return Res::Err("Contract account parameters missing");
         }
@@ -1848,7 +1984,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Err("Specified smart contract not found");
     }
 
-    Res operator()(const CFutureSwapMessage& obj) const {
+    Res operator()(const CFutureSwapMessage &obj) const {
         if (!HasAuth(obj.owner)) {
             return Res::Err("Transaction must have at least one input from owner");
         }
@@ -1858,14 +1994,13 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("Attributes unavailable");
         }
 
-        bool dfiToDUSD = !obj.source.nTokenId.v;
+        bool dfiToDUSD     = !obj.source.nTokenId.v;
         const auto paramID = dfiToDUSD ? ParamIDs::DFIP2206F : ParamIDs::DFIP2203;
 
         CDataStructureV0 activeKey{AttributeTypes::Param, paramID, DFIPKeys::Active};
         CDataStructureV0 blockKey{AttributeTypes::Param, paramID, DFIPKeys::BlockPeriod};
         CDataStructureV0 rewardKey{AttributeTypes::Param, paramID, DFIPKeys::RewardPct};
-        if (!attributes->GetValue(activeKey, false) ||
-            !attributes->CheckKey(blockKey) ||
+        if (!attributes->GetValue(activeKey, false) || !attributes->CheckKey(blockKey) ||
             !attributes->CheckKey(rewardKey)) {
             return Res::Err("%s not currently active", dfiToDUSD ? "DFIP2206F" : "DFIP2203");
         }
@@ -1926,12 +2061,13 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 }
 
                 if (obj.destination != id.v) {
-                    return Res::Err("Incorrect destination defined for DFI swap, DUSD destination expected id: %d", id.v);
+                    return Res::Err("Incorrect destination defined for DFI swap, DUSD destination expected id: %d",
+                                    id.v);
                 }
             }
         }
 
-        const auto contractType = dfiToDUSD ? SMART_CONTRACT_DFIP2206F : SMART_CONTRACT_DFIP_2203;
+        const auto contractType         = dfiToDUSD ? SMART_CONTRACT_DFIP2206F : SMART_CONTRACT_DFIP_2203;
         const auto contractAddressValue = GetFutureSwapContractAddress(contractType);
         if (!contractAddressValue) {
             return contractAddressValue;
@@ -1946,37 +2082,39 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         if (obj.withdraw) {
-
             CTokenAmount totalFutures{};
             totalFutures.nTokenId = obj.source.nTokenId;
 
             if (!dfiToDUSD) {
                 std::map<CFuturesUserKey, CFuturesUserValue> userFuturesValues;
 
-                mnview.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues) {
-                    if (key.owner == obj.owner &&
-                        futuresValues.source.nTokenId == obj.source.nTokenId &&
-                        futuresValues.destination == obj.destination) {
-                        userFuturesValues[key] = futuresValues;
-                    }
-                    return true;
-                }, {height, obj.owner, std::numeric_limits<uint32_t>::max()});
+                mnview.ForEachFuturesUserValues(
+                    [&](const CFuturesUserKey &key, const CFuturesUserValue &futuresValues) {
+                        if (key.owner == obj.owner && futuresValues.source.nTokenId == obj.source.nTokenId &&
+                            futuresValues.destination == obj.destination) {
+                            userFuturesValues[key] = futuresValues;
+                        }
+                        return true;
+                    },
+                    {height, obj.owner, std::numeric_limits<uint32_t>::max()});
 
-                for (const auto& [key, value] : userFuturesValues) {
+                for (const auto &[key, value] : userFuturesValues) {
                     totalFutures.Add(value.source.nValue);
                     mnview.EraseFuturesUserValues(key);
                 }
             } else {
                 std::map<CFuturesUserKey, CAmount> userFuturesValues;
 
-                mnview.ForEachFuturesDUSD([&](const CFuturesUserKey& key, const CAmount& futuresValues) {
-                    if (key.owner == obj.owner) {
-                        userFuturesValues[key] = futuresValues;
-                    }
-                    return true;
-                }, {height, obj.owner, std::numeric_limits<uint32_t>::max()});
+                mnview.ForEachFuturesDUSD(
+                    [&](const CFuturesUserKey &key, const CAmount &futuresValues) {
+                        if (key.owner == obj.owner) {
+                            userFuturesValues[key] = futuresValues;
+                        }
+                        return true;
+                    },
+                    {height, obj.owner, std::numeric_limits<uint32_t>::max()});
 
-                for (const auto& [key, amount] : userFuturesValues) {
+                for (const auto &[key, amount] : userFuturesValues) {
                     totalFutures.Add(amount);
                     mnview.EraseFuturesDUSD(key);
                 }
@@ -2033,9 +2171,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CAnyAccountsToAccountsMessage& obj) const {
+    Res operator()(const CAnyAccountsToAccountsMessage &obj) const {
         // check auth
-        for (const auto& kv : obj.from) {
+        for (const auto &kv : obj.from) {
             if (!HasAuth(kv.first)) {
                 return Res::Err("tx must have at least one input from account owner");
             }
@@ -2043,7 +2181,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // compare
         const auto sumFrom = SumAllTransfers(obj.from);
-        const auto sumTo = SumAllTransfers(obj.to);
+        const auto sumTo   = SumAllTransfers(obj.to);
 
         if (sumFrom != sumTo) {
             return Res::Err("sum of inputs (from) != sum of outputs (to)");
@@ -2056,12 +2194,12 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : AddBalancesSetShares(obj.to);
     }
 
-    Res operator()(const CGovernanceMessage& obj) const {
-        //check foundation auth
+    Res operator()(const CGovernanceMessage &obj) const {
+        // check foundation auth
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
-        for(const auto& gov : obj.govs) {
+        for (const auto &gov : obj.govs) {
             Res res{};
 
             auto var = gov;
@@ -2118,15 +2256,13 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
                     // Remove this key and apply any other changes
                     newVar->EraseKey(key);
-                    if (!(res = govVar->Import(newVar->Export()))
-                        ||  !(res = govVar->Validate(mnview))
-                        ||  !(res = govVar->Apply(mnview, height)))
+                    if (!(res = govVar->Import(newVar->Export())) || !(res = govVar->Validate(mnview)) ||
+                        !(res = govVar->Apply(mnview, height)))
                         return Res::Err("%s: %s", var->GetName(), res.msg);
                 } else {
                     // Validate as complete set. Check for future conflicts between key pairs.
-                    if (!(res = govVar->Import(var->Export()))
-                        ||  !(res = govVar->Validate(mnview))
-                        ||  !(res = govVar->Apply(mnview, height)))
+                    if (!(res = govVar->Import(var->Export())) || !(res = govVar->Validate(mnview)) ||
+                        !(res = govVar->Apply(mnview, height)))
                         return Res::Err("%s: %s", var->GetName(), res.msg);
                 }
 
@@ -2162,8 +2298,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CGovernanceUnsetMessage& obj) const {
-        //check foundation auth
+    Res operator()(const CGovernanceUnsetMessage &obj) const {
+        // check foundation auth
         if (!HasFoundationAuth())
             return Res::Err("tx not from foundation member");
 
@@ -2174,7 +2310,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("Unset Gov variables not currently enabled in attributes.");
         }
 
-        for(const auto& gov : obj.govs) {
+        for (const auto &gov : obj.govs) {
             auto var = mnview.GetVariable(gov.first);
             if (!var)
                 return Res::Err("'%s': variable does not registered", gov.first);
@@ -2189,8 +2325,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CGovernanceHeightMessage& obj) const {
-        //check foundation auth
+    Res operator()(const CGovernanceHeightMessage &obj) const {
+        // check foundation auth
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
@@ -2203,8 +2339,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         // Validate GovVariables before storing
-        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && obj.govVar->GetName() == "ATTRIBUTES") {
-
+        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) &&
+            obj.govVar->GetName() == "ATTRIBUTES") {
             auto govVar = mnview.GetAttributes();
             if (!govVar) {
                 return Res::Err("%s: %s", obj.govVar->GetName(), "Failed to get existing ATTRIBUTES");
@@ -2214,7 +2350,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             Res res{};
             CCustomCSView govCache(mnview);
-            for (const auto& [varHeight, var] : storedGovVars) {
+            for (const auto &[varHeight, var] : storedGovVars) {
                 if (var->GetName() == "ATTRIBUTES") {
                     if (res = govVar->Import(var->Export()); !res) {
                         return Res::Err("%s: Failed to import stored vars: %s", obj.govVar->GetName(), res.msg);
@@ -2227,21 +2363,21 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 if (const auto attrVar = std::dynamic_pointer_cast<ATTRIBUTES>(govVar); attrVar) {
                     const auto attrMap = attrVar->GetAttributesMap();
                     std::vector<CDataStructureV0> keysToErase;
-                    for (const auto& [key, value] : attrMap) {
+                    for (const auto &[key, value] : attrMap) {
                         if (const auto attrV0 = std::get_if<CDataStructureV0>(&key); attrV0) {
-                            if (attrV0->type == AttributeTypes::Oracles && attrV0->typeId == OracleIDs::Splits && attrV0->key < obj.startHeight) {
+                            if (attrV0->type == AttributeTypes::Oracles && attrV0->typeId == OracleIDs::Splits &&
+                                attrV0->key < obj.startHeight) {
                                 keysToErase.push_back(*attrV0);
                             }
                         }
                     }
-                    for (const auto& key : keysToErase) {
+                    for (const auto &key : keysToErase) {
                         attrVar->EraseKey(key);
                     }
                 }
             }
 
-            if (!(res = govVar->Import(obj.govVar->Export())) ||
-                !(res = govVar->Validate(govCache)) ||
+            if (!(res = govVar->Import(obj.govVar->Export())) || !(res = govVar->Validate(govCache)) ||
                 !(res = govVar->Apply(govCache, obj.startHeight))) {
                 return Res::Err("%s: Cumulative application of Gov vars failed: %s", obj.govVar->GetName(), res.msg);
             }
@@ -2257,35 +2393,34 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-    Res operator()(const CAppointOracleMessage& obj) const {
+    Res operator()(const CAppointOracleMessage &obj) const {
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
         COracle oracle;
-        static_cast<CAppointOracleMessage&>(oracle) = obj;
-        auto res = NormalizeTokenCurrencyPair(oracle.availablePairs);
+        static_cast<CAppointOracleMessage &>(oracle) = obj;
+        auto res                                     = NormalizeTokenCurrencyPair(oracle.availablePairs);
         return !res ? res : mnview.AppointOracle(tx.GetHash(), oracle);
     }
 
-    Res operator()(const CUpdateOracleAppointMessage& obj) const {
+    Res operator()(const CUpdateOracleAppointMessage &obj) const {
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
         COracle oracle;
-        static_cast<CAppointOracleMessage&>(oracle) = obj.newOracleAppoint;
-        auto res = NormalizeTokenCurrencyPair(oracle.availablePairs);
+        static_cast<CAppointOracleMessage &>(oracle) = obj.newOracleAppoint;
+        auto res                                     = NormalizeTokenCurrencyPair(oracle.availablePairs);
         return !res ? res : mnview.UpdateOracle(obj.oracleId, std::move(oracle));
     }
 
-    Res operator()(const CRemoveOracleAppointMessage& obj) const {
+    Res operator()(const CRemoveOracleAppointMessage &obj) const {
         if (!HasFoundationAuth()) {
             return Res::Err("tx not from foundation member");
         }
         return mnview.RemoveOracle(obj.oracleId);
     }
 
-    Res operator()(const CSetOracleDataMessage& obj) const {
-
+    Res operator()(const CSetOracleDataMessage &obj) const {
         auto oracle = mnview.GetOracleData(obj.oracleId);
         if (!oracle) {
             return Res::Err("failed to retrieve oracle <%s> from database", obj.oracleId.GetHex());
@@ -2294,16 +2429,16 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("tx must have at least one input from account owner");
         }
         if (height >= uint32_t(Params().GetConsensus().FortCanningHeight)) {
-            for (const auto& tokenPrice : obj.tokenPrices) {
-                for (const auto& price : tokenPrice.second) {
+            for (const auto &tokenPrice : obj.tokenPrices) {
+                for (const auto &price : tokenPrice.second) {
                     if (price.second <= 0) {
                         return Res::Err("Amount out of range");
                     }
                     auto timestamp = time;
                     extern bool diffInHour(int64_t time1, int64_t time2);
                     if (!diffInHour(obj.timestamp, timestamp)) {
-                        return Res::Err("Timestamp (%d) is out of price update window (median: %d)",
-                            obj.timestamp, timestamp);
+                        return Res::Err(
+                            "Timestamp (%d) is out of price update window (median: %d)", obj.timestamp, timestamp);
                     }
                 }
             }
@@ -2311,15 +2446,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.SetOracleData(obj.oracleId, obj.timestamp, obj.tokenPrices);
     }
 
-    Res operator()(const CICXCreateOrderMessage& obj) const {
+    Res operator()(const CICXCreateOrderMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXOrderImplemetation order;
-        static_cast<CICXOrder&>(order) = obj;
+        static_cast<CICXOrder &>(order) = obj;
 
-        order.creationTx = tx.GetHash();
+        order.creationTx     = tx.GetHash();
         order.creationHeight = height;
 
         if (!HasAuth(order.ownerAddress))
@@ -2341,15 +2476,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ICXCreateOrder(order);
     }
 
-    Res operator()(const CICXMakeOfferMessage& obj) const {
+    Res operator()(const CICXMakeOfferMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXMakeOfferImplemetation makeoffer;
-        static_cast<CICXMakeOffer&>(makeoffer) = obj;
+        static_cast<CICXMakeOffer &>(makeoffer) = obj;
 
-        makeoffer.creationTx = tx.GetHash();
+        makeoffer.creationTx     = tx.GetHash();
         makeoffer.creationHeight = height;
 
         if (!HasAuth(makeoffer.ownerAddress))
@@ -2359,7 +2494,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!order)
             return Res::Err("order with creation tx " + makeoffer.orderTx.GetHex() + " does not exists!");
 
-        auto expiry = static_cast<int>(height) < consensus.EunosPayaHeight ? CICXMakeOffer::DEFAULT_EXPIRY : CICXMakeOffer::EUNOSPAYA_DEFAULT_EXPIRY;
+        auto expiry = static_cast<int>(height) < consensus.EunosPayaHeight ? CICXMakeOffer::DEFAULT_EXPIRY
+                                                                           : CICXMakeOffer::EUNOSPAYA_DEFAULT_EXPIRY;
 
         if (makeoffer.expiry < expiry)
             return Res::Err("offer expiry must be greater than %d!", expiry - 1);
@@ -2374,7 +2510,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 return Res::Err("receivePubkey must be valid pubkey");
 
             // calculating takerFee
-            CAmount BTCAmount(static_cast<CAmount>((arith_uint256(makeoffer.amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice)).GetLow64()));
+            CAmount BTCAmount(static_cast<CAmount>(
+                (arith_uint256(makeoffer.amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice)).GetLow64()));
             makeoffer.takerFee = CalculateTakerFee(BTCAmount);
         }
 
@@ -2385,16 +2522,16 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ICXMakeOffer(makeoffer);
     }
 
-    Res operator()(const CICXSubmitDFCHTLCMessage& obj) const {
+    Res operator()(const CICXSubmitDFCHTLCMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res) {
             return res;
         }
 
         CICXSubmitDFCHTLCImplemetation submitdfchtlc;
-        static_cast<CICXSubmitDFCHTLC&>(submitdfchtlc) = obj;
+        static_cast<CICXSubmitDFCHTLC &>(submitdfchtlc) = obj;
 
-        submitdfchtlc.creationTx = tx.GetHash();
+        submitdfchtlc.creationTx     = tx.GetHash();
         submitdfchtlc.creationHeight = height;
 
         auto offer = mnview.GetICXMakeOfferByCreationTx(submitdfchtlc.offerTx);
@@ -2413,7 +2550,6 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         CScript srcAddr;
         if (order->orderType == CICXOrder::TYPE_INTERNAL) {
-
             // check auth
             if (!HasAuth(order->ownerAddress))
                 return Res::Err("tx must have at least one input from order owner");
@@ -2434,23 +2570,27 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             CScript offerTxidAddr(offer->creationTx.begin(), offer->creationTx.end());
 
-            CAmount calcAmount(static_cast<CAmount>((arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
+            CAmount calcAmount(static_cast<CAmount>(
+                (arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN))
+                    .GetLow64()));
             if (calcAmount > offer->amount)
                 return Res::Err("amount must be lower or equal the offer one");
 
             CAmount takerFee = offer->takerFee;
-            //EunosPaya: calculating adjusted takerFee only if amount in htlc different than in offer
-            if (static_cast<int>(height) >= consensus.EunosPayaHeight)
-            {
-                if (calcAmount < offer->amount)
-                {
-                    CAmount BTCAmount(static_cast<CAmount>((arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
-                    takerFee = static_cast<CAmount>((arith_uint256(BTCAmount) * arith_uint256(offer->takerFee) / arith_uint256(offer->amount)).GetLow64());
+            // EunosPaya: calculating adjusted takerFee only if amount in htlc different than in offer
+            if (static_cast<int>(height) >= consensus.EunosPayaHeight) {
+                if (calcAmount < offer->amount) {
+                    CAmount BTCAmount(static_cast<CAmount>(
+                        (arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN))
+                            .GetLow64()));
+                    takerFee = static_cast<CAmount>(
+                        (arith_uint256(BTCAmount) * arith_uint256(offer->takerFee) / arith_uint256(offer->amount))
+                            .GetLow64());
                 }
-            }
-            else
-            {
-                CAmount BTCAmount(static_cast<CAmount>((arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
+            } else {
+                CAmount BTCAmount(static_cast<CAmount>(
+                    (arith_uint256(submitdfchtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN))
+                        .GetLow64()));
                 takerFee = CalculateTakerFee(BTCAmount);
             }
 
@@ -2487,25 +2627,25 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             auto exthtlc = mnview.HasICXSubmitEXTHTLCOpen(submitdfchtlc.offerTx);
             if (!exthtlc)
-                return Res::Err("offer (%s) needs to have ext htlc submitted first, but no external htlc found!", submitdfchtlc.offerTx.GetHex());
+                return Res::Err("offer (%s) needs to have ext htlc submitted first, but no external htlc found!",
+                                submitdfchtlc.offerTx.GetHex());
 
-            CAmount calcAmount(static_cast<CAmount>((arith_uint256(exthtlc->amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
+            CAmount calcAmount(static_cast<CAmount>(
+                (arith_uint256(exthtlc->amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
             if (submitdfchtlc.amount != calcAmount)
                 return Res::Err("amount must be equal to calculated exthtlc amount");
 
             if (submitdfchtlc.hash != exthtlc->hash)
                 return Res::Err("Invalid hash, dfc htlc hash is different than extarnal htlc hash - %s != %s",
-                        submitdfchtlc.hash.GetHex(),exthtlc->hash.GetHex());
+                                submitdfchtlc.hash.GetHex(),
+                                exthtlc->hash.GetHex());
 
             uint32_t timeout, btcBlocksInDfi;
-            if (static_cast<int>(height) < consensus.EunosPayaHeight)
-            {
-                timeout = CICXSubmitDFCHTLC::MINIMUM_2ND_TIMEOUT;
+            if (static_cast<int>(height) < consensus.EunosPayaHeight) {
+                timeout        = CICXSubmitDFCHTLC::MINIMUM_2ND_TIMEOUT;
                 btcBlocksInDfi = CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS;
-            }
-            else
-            {
-                timeout = CICXSubmitDFCHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
+            } else {
+                timeout        = CICXSubmitDFCHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
                 btcBlocksInDfi = CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS;
             }
 
@@ -2523,15 +2663,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ICXSubmitDFCHTLC(submitdfchtlc);
     }
 
-    Res operator()(const CICXSubmitEXTHTLCMessage& obj) const {
+    Res operator()(const CICXSubmitEXTHTLCMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXSubmitEXTHTLCImplemetation submitexthtlc;
-        static_cast<CICXSubmitEXTHTLC&>(submitexthtlc) = obj;
+        static_cast<CICXSubmitEXTHTLC &>(submitexthtlc) = obj;
 
-        submitexthtlc.creationTx = tx.GetHash();
+        submitexthtlc.creationTx     = tx.GetHash();
         submitexthtlc.creationHeight = height;
 
         auto offer = mnview.GetICXMakeOfferByCreationTx(submitexthtlc.offerTx);
@@ -2542,22 +2682,24 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!order)
             return Res::Err("order with creation tx %s does not exists!", offer->orderTx.GetHex());
 
-        if (order->creationHeight + order->expiry < height + (submitexthtlc.timeout * CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS))
+        if (order->creationHeight + order->expiry <
+            height + (submitexthtlc.timeout * CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS))
             return Res::Err("order will expire before ext htlc expires!");
 
         if (mnview.HasICXSubmitEXTHTLCOpen(submitexthtlc.offerTx))
             return Res::Err("ext htlc already submitted!");
 
         if (order->orderType == CICXOrder::TYPE_INTERNAL) {
-
             if (!HasAuth(offer->ownerAddress))
                 return Res::Err("tx must have at least one input from offer owner");
 
             auto dfchtlc = mnview.HasICXSubmitDFCHTLCOpen(submitexthtlc.offerTx);
             if (!dfchtlc)
-                return Res::Err("offer (%s) needs to have dfc htlc submitted first, but no dfc htlc found!", submitexthtlc.offerTx.GetHex());
+                return Res::Err("offer (%s) needs to have dfc htlc submitted first, but no dfc htlc found!",
+                                submitexthtlc.offerTx.GetHex());
 
-            CAmount calcAmount(static_cast<CAmount>((arith_uint256(dfchtlc->amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
+            CAmount calcAmount(static_cast<CAmount>(
+                (arith_uint256(dfchtlc->amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
             if (submitexthtlc.amount != calcAmount)
                 return Res::Err("amount must be equal to calculated dfchtlc amount");
 
@@ -2565,14 +2707,11 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 return Res::Err("Invalid hash, external htlc hash is different than dfc htlc hash");
 
             uint32_t timeout, btcBlocksInDfi;
-            if (static_cast<int>(height) < consensus.EunosPayaHeight)
-            {
-                timeout = CICXSubmitEXTHTLC::MINIMUM_2ND_TIMEOUT;
+            if (static_cast<int>(height) < consensus.EunosPayaHeight) {
+                timeout        = CICXSubmitEXTHTLC::MINIMUM_2ND_TIMEOUT;
                 btcBlocksInDfi = CICXSubmitEXTHTLC::BTC_BLOCKS_IN_DFI_BLOCKS;
-            }
-            else
-            {
-                timeout = CICXSubmitEXTHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
+            } else {
+                timeout        = CICXSubmitEXTHTLC::EUNOSPAYA_MINIMUM_2ND_TIMEOUT;
                 btcBlocksInDfi = CICXSubmitEXTHTLC::EUNOSPAYA_BTC_BLOCKS_IN_DFI_BLOCKS;
             }
 
@@ -2582,7 +2721,6 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             if (submitexthtlc.timeout * btcBlocksInDfi >= (dfchtlc->creationHeight + dfchtlc->timeout) - height)
                 return Res::Err("timeout must be less than expiration period of 1st htlc in DFC blocks");
         } else if (order->orderType == CICXOrder::TYPE_EXTERNAL) {
-
             if (!HasAuth(order->ownerAddress))
                 return Res::Err("tx must have at least one input from order owner");
 
@@ -2600,22 +2738,24 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             CScript offerTxidAddr(offer->creationTx.begin(), offer->creationTx.end());
 
-            CAmount calcAmount(static_cast<CAmount>((arith_uint256(submitexthtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN)).GetLow64()));
+            CAmount calcAmount(static_cast<CAmount>(
+                (arith_uint256(submitexthtlc.amount) * arith_uint256(order->orderPrice) / arith_uint256(COIN))
+                    .GetLow64()));
             if (calcAmount > offer->amount)
                 return Res::Err("amount must be lower or equal the offer one");
 
             CAmount takerFee = offer->takerFee;
-            //EunosPaya: calculating adjusted takerFee only if amount in htlc different than in offer
-            if (static_cast<int>(height) >= consensus.EunosPayaHeight)
-            {
-                if (calcAmount < offer->amount)
-                {
-                    CAmount BTCAmount(static_cast<CAmount>((arith_uint256(offer->amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice)).GetLow64()));
-                    takerFee = static_cast<CAmount>((arith_uint256(submitexthtlc.amount) * arith_uint256(offer->takerFee) / arith_uint256(BTCAmount)).GetLow64());
+            // EunosPaya: calculating adjusted takerFee only if amount in htlc different than in offer
+            if (static_cast<int>(height) >= consensus.EunosPayaHeight) {
+                if (calcAmount < offer->amount) {
+                    CAmount BTCAmount(static_cast<CAmount>(
+                        (arith_uint256(offer->amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice))
+                            .GetLow64()));
+                    takerFee = static_cast<CAmount>((arith_uint256(submitexthtlc.amount) *
+                                                     arith_uint256(offer->takerFee) / arith_uint256(BTCAmount))
+                                                        .GetLow64());
                 }
-            }
-            else
-            {
+            } else {
                 takerFee = CalculateTakerFee(submitexthtlc.amount);
             }
 
@@ -2644,15 +2784,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ICXSubmitEXTHTLC(submitexthtlc);
     }
 
-    Res operator()(const CICXClaimDFCHTLCMessage& obj) const {
+    Res operator()(const CICXClaimDFCHTLCMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXClaimDFCHTLCImplemetation claimdfchtlc;
-        static_cast<CICXClaimDFCHTLC&>(claimdfchtlc) = obj;
+        static_cast<CICXClaimDFCHTLC &>(claimdfchtlc) = obj;
 
-        claimdfchtlc.creationTx = tx.GetHash();
+        claimdfchtlc.creationTx     = tx.GetHash();
         claimdfchtlc.creationHeight = height;
 
         auto dfchtlc = mnview.GetICXSubmitDFCHTLCByCreationTx(claimdfchtlc.dfchtlcTx);
@@ -2664,13 +2804,13 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         uint256 calcHash;
         uint8_t calcSeedBytes[32];
-        CSHA256()
-            .Write(claimdfchtlc.seed.data(), claimdfchtlc.seed.size())
-            .Finalize(calcSeedBytes);
+        CSHA256().Write(claimdfchtlc.seed.data(), claimdfchtlc.seed.size()).Finalize(calcSeedBytes);
         calcHash.SetHex(HexStr(calcSeedBytes, calcSeedBytes + 32));
 
         if (dfchtlc->hash != calcHash)
-            return Res::Err("hash generated from given seed is different than in dfc htlc: %s - %s!", calcHash.GetHex(), dfchtlc->hash.GetHex());
+            return Res::Err("hash generated from given seed is different than in dfc htlc: %s - %s!",
+                            calcHash.GetHex(),
+                            dfchtlc->hash.GetHex());
 
         auto offer = mnview.GetICXMakeOfferByCreationTx(dfchtlc->offerTx);
         if (!offer)
@@ -2687,12 +2827,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         // claim DFC HTLC to receiveAddress
         CalculateOwnerRewards(order->ownerAddress);
         CScript htlcTxidAddr(dfchtlc->creationTx.begin(), dfchtlc->creationTx.end());
-        if (order->orderType == CICXOrder::TYPE_INTERNAL)
-        {
+        if (order->orderType == CICXOrder::TYPE_INTERNAL) {
             CalculateOwnerRewards(offer->ownerAddress);
             res = TransferTokenBalance(order->idToken, dfchtlc->amount, htlcTxidAddr, offer->ownerAddress);
-        }
-        else if (order->orderType == CICXOrder::TYPE_EXTERNAL)
+        } else if (order->orderType == CICXOrder::TYPE_EXTERNAL)
             res = TransferTokenBalance(order->idToken, dfchtlc->amount, htlcTxidAddr, order->ownerAddress);
         if (!res)
             return res;
@@ -2711,7 +2849,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         DCT_ID BTC = FindTokenByPartialSymbolName(CICXOrder::TOKEN_BTC);
         if (order->idToken == BTC && order->orderPrice == COIN) {
             if ((Params().NetworkIDString() == CBaseChainParams::TESTNET && height >= 1250000) ||
-                 Params().NetworkIDString() == CBaseChainParams::REGTEST) {
+                Params().NetworkIDString() == CBaseChainParams::REGTEST) {
                 res = TransferTokenBalance(DCT_ID{0}, offer->takerFee * 50 / 100, CScript(), order->ownerAddress);
             } else {
                 res = TransferTokenBalance(BTC, offer->takerFee * 50 / 100, CScript(), order->ownerAddress);
@@ -2723,18 +2861,19 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (order->orderType == CICXOrder::TYPE_INTERNAL)
             order->amountToFill -= dfchtlc->amount;
         else if (order->orderType == CICXOrder::TYPE_EXTERNAL)
-            order->amountToFill -= static_cast<CAmount>((arith_uint256(dfchtlc->amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice)).GetLow64());
+            order->amountToFill -= static_cast<CAmount>(
+                (arith_uint256(dfchtlc->amount) * arith_uint256(COIN) / arith_uint256(order->orderPrice)).GetLow64());
 
         // Order fulfilled, close order.
         if (order->amountToFill == 0) {
-            order->closeTx = claimdfchtlc.creationTx;
+            order->closeTx     = claimdfchtlc.creationTx;
             order->closeHeight = height;
-            res = mnview.ICXCloseOrderTx(*order, CICXOrder::STATUS_FILLED);
+            res                = mnview.ICXCloseOrderTx(*order, CICXOrder::STATUS_FILLED);
             if (!res)
                 return res;
         }
 
-        res = mnview.ICXClaimDFCHTLC(claimdfchtlc,offer->creationTx,*order);
+        res = mnview.ICXClaimDFCHTLC(claimdfchtlc, offer->creationTx, *order);
         if (!res)
             return res;
         // Close offer
@@ -2745,26 +2884,24 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!res)
             return res;
 
-        if (static_cast<int>(height) >= consensus.EunosPayaHeight)
-        {
+        if (static_cast<int>(height) >= consensus.EunosPayaHeight) {
             if (exthtlc)
                 return mnview.ICXCloseEXTHTLC(*exthtlc, CICXSubmitEXTHTLC::STATUS_CLOSED);
             else
                 return (Res::Ok());
-        }
-        else
+        } else
             return mnview.ICXCloseEXTHTLC(*exthtlc, CICXSubmitEXTHTLC::STATUS_CLOSED);
     }
 
-    Res operator()(const CICXCloseOrderMessage& obj) const {
+    Res operator()(const CICXCloseOrderMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXCloseOrderImplemetation closeorder;
-        static_cast<CICXCloseOrder&>(closeorder) = obj;
+        static_cast<CICXCloseOrder &>(closeorder) = obj;
 
-        closeorder.creationTx = tx.GetHash();
+        closeorder.creationTx     = tx.GetHash();
         closeorder.creationHeight = height;
 
         std::unique_ptr<CICXOrderImplemetation> order;
@@ -2781,7 +2918,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasAuth(order->ownerAddress))
             return Res::Err("tx must have at least one input from order owner");
 
-        order->closeTx = closeorder.creationTx;
+        order->closeTx     = closeorder.creationTx;
         order->closeHeight = closeorder.creationHeight;
 
         if (order->orderType == CICXOrder::TYPE_INTERNAL && order->amountToFill > 0) {
@@ -2794,18 +2931,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         res = mnview.ICXCloseOrder(closeorder);
-        return !res ? res : mnview.ICXCloseOrderTx(*order,CICXOrder::STATUS_CLOSED);
+        return !res ? res : mnview.ICXCloseOrderTx(*order, CICXOrder::STATUS_CLOSED);
     }
 
-    Res operator()(const CICXCloseOfferMessage& obj) const {
+    Res operator()(const CICXCloseOfferMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
 
         CICXCloseOfferImplemetation closeoffer;
-        static_cast<CICXCloseOffer&>(closeoffer) = obj;
+        static_cast<CICXCloseOffer &>(closeoffer) = obj;
 
-        closeoffer.creationTx = tx.GetHash();
+        closeoffer.creationTx     = tx.GetHash();
         closeoffer.creationHeight = height;
 
         std::unique_ptr<CICXMakeOfferImplemetation> offer;
@@ -2826,32 +2963,29 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasAuth(offer->ownerAddress))
             return Res::Err("tx must have at least one input from offer owner");
 
-        offer->closeTx = closeoffer.creationTx;
+        offer->closeTx     = closeoffer.creationTx;
         offer->closeHeight = closeoffer.creationHeight;
 
         bool isPreEunosPaya = static_cast<int>(height) < consensus.EunosPayaHeight;
 
-        if (order->orderType == CICXOrder::TYPE_INTERNAL && !mnview.ExistedICXSubmitDFCHTLC(offer->creationTx, isPreEunosPaya))
-        {
+        if (order->orderType == CICXOrder::TYPE_INTERNAL &&
+            !mnview.ExistedICXSubmitDFCHTLC(offer->creationTx, isPreEunosPaya)) {
             // subtract takerFee from txidAddr and return to owner
             CScript txidAddr(offer->creationTx.begin(), offer->creationTx.end());
             CalculateOwnerRewards(offer->ownerAddress);
             res = TransferTokenBalance(DCT_ID{0}, offer->takerFee, txidAddr, offer->ownerAddress);
             if (!res)
                 return res;
-        }
-        else if (order->orderType == CICXOrder::TYPE_EXTERNAL) {
+        } else if (order->orderType == CICXOrder::TYPE_EXTERNAL) {
             // subtract the balance from txidAddr and return to owner
             CScript txidAddr(offer->creationTx.begin(), offer->creationTx.end());
             CalculateOwnerRewards(offer->ownerAddress);
-            if (isPreEunosPaya)
-            {
+            if (isPreEunosPaya) {
                 res = TransferTokenBalance(order->idToken, offer->amount, txidAddr, offer->ownerAddress);
                 if (!res)
                     return res;
             }
-            if (!mnview.ExistedICXSubmitEXTHTLC(offer->creationTx, isPreEunosPaya))
-            {
+            if (!mnview.ExistedICXSubmitEXTHTLC(offer->creationTx, isPreEunosPaya)) {
                 res = TransferTokenBalance(DCT_ID{0}, offer->takerFee, txidAddr, offer->ownerAddress);
                 if (!res)
                     return res;
@@ -2862,7 +2996,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return !res ? res : mnview.ICXCloseMakeOfferTx(*offer, CICXMakeOffer::STATUS_CLOSED);
     }
 
-    Res operator()(const CLoanSetCollateralTokenMessage& obj) const {
+    Res operator()(const CLoanSetCollateralTokenMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -2870,11 +3004,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasFoundationAuth())
             return Res::Err("tx not from foundation member!");
 
-        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar())
-        {
-            const auto& tokenId = obj.idToken.v;
+        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar()) {
+            const auto &tokenId = obj.idToken.v;
 
-            auto attributes = mnview.GetAttributes();
+            auto attributes  = mnview.GetAttributes();
             attributes->time = time;
 
             CDataStructureV0 collateralEnabled{AttributeTypes::Token, tokenId, TokenKeys::LoanCollateralEnabled};
@@ -2911,9 +3044,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         CLoanSetCollateralTokenImplementation collToken;
-        static_cast<CLoanSetCollateralToken&>(collToken) = obj;
+        static_cast<CLoanSetCollateralToken &>(collToken) = obj;
 
-        collToken.creationTx = tx.GetHash();
+        collToken.creationTx     = tx.GetHash();
         collToken.creationHeight = height;
 
         auto token = mnview.GetToken(collToken.idToken);
@@ -2927,17 +3060,20 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("activateAfterBlock cannot be less than current height!");
 
         if (!OraclePriceFeed(mnview, collToken.fixedIntervalPriceId))
-            return Res::Err("Price feed %s/%s does not belong to any oracle", collToken.fixedIntervalPriceId.first, collToken.fixedIntervalPriceId.second);
+            return Res::Err("Price feed %s/%s does not belong to any oracle",
+                            collToken.fixedIntervalPriceId.first,
+                            collToken.fixedIntervalPriceId.second);
 
         CFixedIntervalPrice fixedIntervalPrice;
         fixedIntervalPrice.priceFeedId = collToken.fixedIntervalPriceId;
 
-        auto price = GetAggregatePrice(mnview, collToken.fixedIntervalPriceId.first, collToken.fixedIntervalPriceId.second, time);
+        auto price = GetAggregatePrice(
+            mnview, collToken.fixedIntervalPriceId.first, collToken.fixedIntervalPriceId.second, time);
         if (!price)
             return Res::Err(price.msg);
 
         fixedIntervalPrice.priceRecord[1] = price;
-        fixedIntervalPrice.timestamp = time;
+        fixedIntervalPrice.timestamp      = time;
 
         auto resSetFixedPrice = mnview.SetFixedIntervalPrice(fixedIntervalPrice);
         if (!resSetFixedPrice)
@@ -2946,7 +3082,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.CreateLoanCollateralToken(collToken);
     }
 
-    Res operator()(const CLoanSetLoanTokenMessage& obj) const {
+    Res operator()(const CLoanSetLoanTokenMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -2959,22 +3095,23 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         CTokenImplementation token;
-        token.symbol = trim_ws(obj.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
-        token.name = trim_ws(obj.name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
-        token.creationTx = tx.GetHash();
+        token.symbol         = trim_ws(obj.symbol).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+        token.name           = trim_ws(obj.name).substr(0, CToken::MAX_TOKEN_NAME_LENGTH);
+        token.creationTx     = tx.GetHash();
         token.creationHeight = height;
-        token.flags = obj.mintable ? static_cast<uint8_t>(CToken::TokenFlags::Default) : static_cast<uint8_t>(CToken::TokenFlags::Tradeable);
-        token.flags |= static_cast<uint8_t>(CToken::TokenFlags::LoanToken) | static_cast<uint8_t>(CToken::TokenFlags::DAT);
+        token.flags          = obj.mintable ? static_cast<uint8_t>(CToken::TokenFlags::Default)
+                                            : static_cast<uint8_t>(CToken::TokenFlags::Tradeable);
+        token.flags |=
+            static_cast<uint8_t>(CToken::TokenFlags::LoanToken) | static_cast<uint8_t>(CToken::TokenFlags::DAT);
 
         auto tokenId = mnview.CreateToken(token);
         if (!tokenId)
             return std::move(tokenId);
 
-        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar())
-        {
-            const auto& id = tokenId.val->v;
+        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar()) {
+            const auto &id = tokenId.val->v;
 
-            auto attributes = mnview.GetAttributes();
+            auto attributes  = mnview.GetAttributes();
             attributes->time = time;
 
             CDataStructureV0 mintEnabled{AttributeTypes::Token, id, TokenKeys::LoanMintingEnabled};
@@ -3011,22 +3148,25 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         CLoanSetLoanTokenImplementation loanToken;
-        static_cast<CLoanSetLoanToken&>(loanToken) = obj;
+        static_cast<CLoanSetLoanToken &>(loanToken) = obj;
 
-        loanToken.creationTx = tx.GetHash();
+        loanToken.creationTx     = tx.GetHash();
         loanToken.creationHeight = height;
 
-        auto nextPrice = GetAggregatePrice(mnview, obj.fixedIntervalPriceId.first, obj.fixedIntervalPriceId.second, time);
+        auto nextPrice =
+            GetAggregatePrice(mnview, obj.fixedIntervalPriceId.first, obj.fixedIntervalPriceId.second, time);
         if (!nextPrice)
             return Res::Err(nextPrice.msg);
 
         if (!OraclePriceFeed(mnview, obj.fixedIntervalPriceId))
-            return Res::Err("Price feed %s/%s does not belong to any oracle", obj.fixedIntervalPriceId.first, obj.fixedIntervalPriceId.second);
+            return Res::Err("Price feed %s/%s does not belong to any oracle",
+                            obj.fixedIntervalPriceId.first,
+                            obj.fixedIntervalPriceId.second);
 
         CFixedIntervalPrice fixedIntervalPrice;
-        fixedIntervalPrice.priceFeedId = loanToken.fixedIntervalPriceId;
+        fixedIntervalPrice.priceFeedId    = loanToken.fixedIntervalPriceId;
         fixedIntervalPrice.priceRecord[1] = nextPrice;
-        fixedIntervalPrice.timestamp = time;
+        fixedIntervalPrice.timestamp      = time;
 
         auto resSetFixedPrice = mnview.SetFixedIntervalPrice(fixedIntervalPrice);
         if (!resSetFixedPrice)
@@ -3035,7 +3175,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.SetLoanToken(loanToken, *(tokenId.val));
     }
 
-    Res operator()(const CLoanUpdateLoanTokenMessage& obj) const {
+    Res operator()(const CLoanUpdateLoanTokenMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3051,8 +3191,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!pair)
             return Res::Err("Loan token (%s) does not exist!", obj.tokenTx.GetHex());
 
-        auto loanToken = (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar()) ?
-                mnview.GetLoanTokenByID(pair->first) : mnview.GetLoanToken(obj.tokenTx);
+        auto loanToken =
+            (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar())
+                ? mnview.GetLoanTokenByID(pair->first)
+                : mnview.GetLoanToken(obj.tokenTx);
 
         if (!loanToken)
             return Res::Err("Loan token (%s) does not exist!", obj.tokenTx.GetHex());
@@ -3076,11 +3218,10 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!res)
             return res;
 
-        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar())
-        {
-            const auto& id = pair->first.v;
+        if (height >= static_cast<uint32_t>(consensus.FortCanningCrunchHeight) && IsTokensMigratedToGovVar()) {
+            const auto &id = pair->first.v;
 
-            auto attributes = mnview.GetAttributes();
+            auto attributes  = mnview.GetAttributes();
             attributes->time = time;
 
             CDataStructureV0 mintEnabled{AttributeTypes::Token, id, TokenKeys::LoanMintingEnabled};
@@ -3118,7 +3259,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         if (obj.fixedIntervalPriceId != loanToken->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);
+                return Res::Err("Price feed %s/%s does not belong to any oracle",
+                                obj.fixedIntervalPriceId.first,
+                                obj.fixedIntervalPriceId.second);
 
             loanToken->fixedIntervalPriceId = obj.fixedIntervalPriceId;
         }
@@ -3126,7 +3269,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.UpdateLoanToken(*loanToken, pair->first);
     }
 
-    Res operator()(const CLoanSchemeMessage& obj) const {
+    Res operator()(const CLoanSchemeMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res) {
             return res;
@@ -3151,12 +3294,11 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         // Look for loan scheme which already has matching rate and ratio
         bool duplicateLoan = false;
         std::string duplicateID;
-        mnview.ForEachLoanScheme([&](const std::string& key, const CLoanSchemeData& data)
-        {
+        mnview.ForEachLoanScheme([&](const std::string &key, const CLoanSchemeData &data) {
             // Duplicate scheme already exists
             if (data.ratio == obj.ratio && data.rate == obj.rate) {
                 duplicateLoan = true;
-                duplicateID = key;
+                duplicateID   = key;
                 return false;
             }
             return true;
@@ -3167,19 +3309,21 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         } else {
             // Look for delayed loan scheme which already has matching rate and ratio
             std::pair<std::string, uint64_t> duplicateKey;
-            mnview.ForEachDelayedLoanScheme([&](const std::pair<std::string, uint64_t>& key, const CLoanSchemeMessage& data)
-            {
-                // Duplicate delayed loan scheme
-                if (data.ratio == obj.ratio && data.rate == obj.rate) {
-                    duplicateLoan = true;
-                    duplicateKey = key;
-                    return false;
-                }
-                return true;
-            });
+            mnview.ForEachDelayedLoanScheme(
+                [&](const std::pair<std::string, uint64_t> &key, const CLoanSchemeMessage &data) {
+                    // Duplicate delayed loan scheme
+                    if (data.ratio == obj.ratio && data.rate == obj.rate) {
+                        duplicateLoan = true;
+                        duplicateKey  = key;
+                        return false;
+                    }
+                    return true;
+                });
 
             if (duplicateLoan) {
-                return Res::Err("Loan scheme %s with same interestrate and mincolratio pending on block %d", duplicateKey.first, duplicateKey.second);
+                return Res::Err("Loan scheme %s with same interestrate and mincolratio pending on block %d",
+                                duplicateKey.first,
+                                duplicateKey.second);
             }
         }
 
@@ -3193,7 +3337,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         // Update set, not max uint64_t which indicates immediate update and not updated on this block.
-        if (obj.updateHeight && obj.updateHeight != std::numeric_limits<uint64_t>::max() && obj.updateHeight != height) {
+        if (obj.updateHeight && obj.updateHeight != std::numeric_limits<uint64_t>::max() &&
+            obj.updateHeight != height) {
             if (obj.updateHeight < height) {
                 return Res::Err("Update height below current block height, set future height");
             }
@@ -3209,7 +3354,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.StoreLoanScheme(obj);
     }
 
-    Res operator()(const CDefaultLoanSchemeMessage& obj) const {
+    Res operator()(const CDefaultLoanSchemeMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res) {
             return res;
@@ -3236,10 +3381,11 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("Cannot set %s as default, set to destroyed on block %d", obj.identifier, *height);
         }
 
-        return mnview.StoreDefaultLoanScheme(obj.identifier);;
+        return mnview.StoreDefaultLoanScheme(obj.identifier);
+        ;
     }
 
-    Res operator()(const CDestroyLoanSchemeMessage& obj) const {
+    Res operator()(const CDestroyLoanSchemeMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res) {
             return res;
@@ -3270,7 +3416,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return mnview.StoreDelayedDestroyScheme(obj);
         }
 
-        mnview.ForEachVault([&](const CVaultId& vaultId, CVaultData vault) {
+        mnview.ForEachVault([&](const CVaultId &vaultId, CVaultData vault) {
             if (vault.schemeId == obj.identifier) {
                 vault.schemeId = *mnview.GetDefaultLoanScheme();
                 mnview.StoreVault(vaultId, vault);
@@ -3281,19 +3427,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.EraseLoanScheme(obj.identifier);
     }
 
-    Res operator()(const CVaultMessage& obj) const {
-
+    Res operator()(const CVaultMessage &obj) const {
         auto vaultCreationFee = consensus.vaultCreationFee;
         if (tx.vout[0].nValue != vaultCreationFee || tx.vout[0].nTokenId != DCT_ID{0}) {
             return Res::Err("malformed tx vouts, creation vault fee is %s DFI", GetDecimaleString(vaultCreationFee));
         }
 
         CVaultData vault{};
-        static_cast<CVaultMessage&>(vault) = obj;
+        static_cast<CVaultMessage &>(vault) = obj;
 
         // set loan scheme to default if non provided
         if (obj.schemeId.empty()) {
-            if (auto defaultScheme = mnview.GetDefaultLoanScheme()){
+            if (auto defaultScheme = mnview.GetDefaultLoanScheme()) {
                 vault.schemeId = *defaultScheme;
             } else {
                 return Res::Err("There is no default loan scheme");
@@ -3314,7 +3459,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.StoreVault(vaultId, vault);
     }
 
-    Res operator()(const CCloseVaultMessage& obj) const {
+    Res operator()(const CCloseVaultMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3333,7 +3478,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("tx must have at least one input from token owner");
 
         if (const auto loans = mnview.GetLoanTokens(obj.vaultId)) {
-            for (const auto& [tokenId, amount] : loans->balances) {
+            for (const auto &[tokenId, amount] : loans->balances) {
                 const auto rate = mnview.GetInterestRate(obj.vaultId, tokenId, height);
                 if (!rate) {
                     return Res::Err("Cannot get interest rate for this token (%d)", tokenId.v);
@@ -3345,14 +3490,15 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 }
 
                 if (totalInterest < 0) {
-                    TrackNegativeInterest(mnview, {tokenId, amount > std::abs(totalInterest)  ? std::abs(totalInterest) : amount});
+                    TrackNegativeInterest(
+                        mnview, {tokenId, amount > std::abs(totalInterest) ? std::abs(totalInterest) : amount});
                 }
             }
         }
 
         CalculateOwnerRewards(obj.to);
         if (auto collaterals = mnview.GetVaultCollaterals(obj.vaultId)) {
-            for (const auto& col : collaterals->balances) {
+            for (const auto &col : collaterals->balances) {
                 auto res = mnview.AddBalance(obj.to, {col.first, col.second});
                 if (!res)
                     return res;
@@ -3366,11 +3512,11 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // return half fee, the rest is burned at creation
         auto feeBack = consensus.vaultCreationFee / 2;
-        res = mnview.AddBalance(obj.to, {DCT_ID{0}, feeBack});
+        res          = mnview.AddBalance(obj.to, {DCT_ID{0}, feeBack});
         return !res ? res : mnview.EraseVault(obj.vaultId);
     }
 
-    Res operator()(const CUpdateVaultMessage& obj) const {
+    Res operator()(const CUpdateVaultMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3405,20 +3551,25 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             if (auto collaterals = mnview.GetVaultCollaterals(obj.vaultId)) {
                 for (int i = 0; i < 2; i++) {
                     bool useNextPrice = i > 0, requireLivePrice = true;
-                    auto collateralsLoans = mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
+                    auto collateralsLoans = mnview.GetLoanCollaterals(
+                        obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
                     if (!collateralsLoans)
                         return std::move(collateralsLoans);
 
                     if (collateralsLoans.val->ratio() < scheme->ratio)
-                        return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d", collateralsLoans.val->ratio(), scheme->ratio);
+                        return Res::Err(
+                            "Vault does not have enough collateralization ratio defined by loan scheme - %d < %d",
+                            collateralsLoans.val->ratio(),
+                            scheme->ratio);
                 }
             }
             if (height >= static_cast<uint32_t>(consensus.FortCanningGreatWorldHeight)) {
                 if (const auto loanTokens = mnview.GetLoanTokens(obj.vaultId)) {
-                    for (const auto& [tokenId, tokenAmount] : loanTokens->balances) {
+                    for (const auto &[tokenId, tokenAmount] : loanTokens->balances) {
                         const auto loanToken = mnview.GetLoanTokenByID(tokenId);
                         assert(loanToken);
-                        res = mnview.IncreaseInterest(height, obj.vaultId, obj.schemeId, tokenId, loanToken->interest, 0);
+                        res =
+                            mnview.IncreaseInterest(height, obj.vaultId, obj.schemeId, tokenId, loanToken->interest, 0);
                         if (!res) {
                             return res;
                         }
@@ -3427,13 +3578,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             }
         }
 
-        vault->schemeId = obj.schemeId;
+        vault->schemeId     = obj.schemeId;
         vault->ownerAddress = obj.ownerAddress;
         return mnview.UpdateVault(obj.vaultId, *vault);
     }
 
-    Res CollateralPctCheck(const bool hasDUSDLoans, const CCollateralLoans& collateralsLoans, const uint32_t ratio) const {
-
+    Res CollateralPctCheck(const bool hasDUSDLoans,
+                           const CCollateralLoans &collateralsLoans,
+                           const uint32_t ratio) const {
         std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> tokenDUSD;
         if (static_cast<int>(height) >= consensus.FortCanningRoadHeight) {
             tokenDUSD = mnview.GetToken("DUSD");
@@ -3441,19 +3593,19 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // Calculate DFI and DUSD value separately
         CAmount totalCollateralsDUSD = 0;
-        CAmount totalCollateralsDFI = 0;
-        CAmount factorDUSD = 0;
-        CAmount factorDFI = 0;
+        CAmount totalCollateralsDFI  = 0;
+        CAmount factorDUSD           = 0;
+        CAmount factorDFI            = 0;
 
-        for (auto& col : collateralsLoans.collaterals){
+        for (auto &col : collateralsLoans.collaterals) {
             auto token = mnview.GetCollateralTokenFromAttributes(col.nTokenId);
 
-            if (col.nTokenId == DCT_ID{0} ){
+            if (col.nTokenId == DCT_ID{0}) {
                 totalCollateralsDFI += col.nValue;
                 factorDFI = token->factor;
             }
 
-            if(tokenDUSD && col.nTokenId == tokenDUSD->first){
+            if (tokenDUSD && col.nTokenId == tokenDUSD->first) {
                 totalCollateralsDUSD += col.nValue;
                 factorDUSD = token->factor;
             }
@@ -3461,42 +3613,44 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // Height checks
         auto isPostFCH = static_cast<int>(height) >= consensus.FortCanningHillHeight;
-        auto isPreFCH  = static_cast<int>(height) <  consensus.FortCanningHillHeight;
+        auto isPreFCH  = static_cast<int>(height) < consensus.FortCanningHillHeight;
         auto isPostFCE = static_cast<int>(height) >= consensus.FortCanningEpilogueHeight;
         auto isPostFCR = static_cast<int>(height) >= consensus.FortCanningRoadHeight;
         auto isPostGC  = static_cast<int>(height) >= consensus.GrandCentralHeight;
 
-        if(isPostGC){
+        if (isPostGC) {
             totalCollateralsDUSD = MultiplyAmounts(totalCollateralsDUSD, factorDUSD);
             totalCollateralsDFI  = MultiplyAmounts(totalCollateralsDFI, factorDFI);
         }
         auto totalCollaterals = totalCollateralsDUSD + totalCollateralsDFI;
 
         // Condition checks
-        auto isDFILessThanHalfOfTotalCollateral = arith_uint256(totalCollateralsDFI) < arith_uint256(collateralsLoans.totalCollaterals) / 2;
-        auto isDFIAndDUSDLessThanHalfOfRequiredCollateral = arith_uint256(totalCollaterals) * 100 < (arith_uint256(collateralsLoans.totalLoans) * ratio / 2);
-        auto isDFILessThanHalfOfRequiredCollateral = arith_uint256(totalCollateralsDFI) * 100 < (arith_uint256(collateralsLoans.totalLoans) * ratio / 2);
-
-        if(isPostFCE){
-            if (hasDUSDLoans){
-                if(isDFILessThanHalfOfRequiredCollateral)
+        auto isDFILessThanHalfOfTotalCollateral =
+            arith_uint256(totalCollateralsDFI) < arith_uint256(collateralsLoans.totalCollaterals) / 2;
+        auto isDFIAndDUSDLessThanHalfOfRequiredCollateral =
+            arith_uint256(totalCollaterals) * 100 < (arith_uint256(collateralsLoans.totalLoans) * ratio / 2);
+        auto isDFILessThanHalfOfRequiredCollateral =
+            arith_uint256(totalCollateralsDFI) * 100 < (arith_uint256(collateralsLoans.totalLoans) * ratio / 2);
+
+        if (isPostFCE) {
+            if (hasDUSDLoans) {
+                if (isDFILessThanHalfOfRequiredCollateral)
                     return Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_PCT));
-            }else {
-                if(isDFIAndDUSDLessThanHalfOfRequiredCollateral)
+            } else {
+                if (isDFIAndDUSDLessThanHalfOfRequiredCollateral)
                     return Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_DUSD_PCT));
             }
             return Res::Ok();
         }
 
         if (isPostFCR)
-            return isDFIAndDUSDLessThanHalfOfRequiredCollateral ?
-                Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_DUSD_PCT)) :
-                Res::Ok();
+            return isDFIAndDUSDLessThanHalfOfRequiredCollateral
+                       ? Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_DUSD_PCT))
+                       : Res::Ok();
 
         if (isPostFCH)
-            return isDFILessThanHalfOfRequiredCollateral ?
-                Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_PCT)) :
-                Res::Ok();
+            return isDFILessThanHalfOfRequiredCollateral ? Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_PCT))
+                                                         : Res::Ok();
 
         if (isPreFCH && isDFILessThanHalfOfTotalCollateral)
             return Res::Err(std::string(ERR_STRING_MIN_COLLATERAL_DFI_PCT));
@@ -3504,8 +3658,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
-
-    Res operator()(const CDepositToVaultMessage& obj) const {
+    Res operator()(const CDepositToVaultMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3525,36 +3678,42 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
         // 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};
+            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
+        // check balance
         CalculateOwnerRewards(obj.from);
         res = mnview.SubBalance(obj.from, obj.amount);
         if (!res)
-            return Res::Err("Insufficient funds: can't subtract balance of %s: %s\n", ScriptToString(obj.from), res.msg);
+            return Res::Err(
+                "Insufficient funds: can't subtract balance of %s: %s\n", ScriptToString(obj.from), res.msg);
 
         res = mnview.AddVaultCollateral(obj.vaultId, obj.amount);
-        if (!res) return res;
+        if (!res)
+            return res;
 
         bool useNextPrice = false, requireLivePrice = false;
         auto collaterals = mnview.GetVaultCollaterals(obj.vaultId);
 
-        auto collateralsLoans = mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
+        auto collateralsLoans =
+            mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
         if (!collateralsLoans)
             return std::move(collateralsLoans);
 
         auto scheme = mnview.GetLoanScheme(vault->schemeId);
         if (collateralsLoans.val->ratio() < scheme->ratio)
-            return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d", collateralsLoans.val->ratio(), scheme->ratio);
+            return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d",
+                            collateralsLoans.val->ratio(),
+                            scheme->ratio);
 
         return Res::Ok();
     }
 
-    Res operator()(const CWithdrawFromVaultMessage& obj) const {
+    Res operator()(const CWithdrawFromVaultMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3586,11 +3745,9 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             tokenDUSD = mnview.GetToken("DUSD");
         }
 
-        if (const auto loanAmounts = mnview.GetLoanTokens(obj.vaultId))
-        {
+        if (const auto loanAmounts = mnview.GetLoanTokens(obj.vaultId)) {
             // Update negative interest in vault
-            for (const auto& [tokenId, currentLoanAmount] : loanAmounts->balances) {
-
+            for (const auto &[tokenId, currentLoanAmount] : loanAmounts->balances) {
                 if (tokenDUSD && tokenId == tokenDUSD->first) {
                     hasDUSDLoans = true;
                 }
@@ -3605,7 +3762,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                     continue;
                 }
 
-                const auto subAmount = currentLoanAmount > std::abs(totalInterest) ? std::abs(totalInterest) : currentLoanAmount;
+                const auto subAmount =
+                    currentLoanAmount > std::abs(totalInterest) ? std::abs(totalInterest) : currentLoanAmount;
 
                 if (const auto token = mnview.GetToken("DUSD"); token && tokenId == token->first) {
                     TrackDUSDSub(mnview, {tokenId, subAmount});
@@ -3619,26 +3777,27 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 TrackNegativeInterest(mnview, {tokenId, subAmount});
 
                 mnview.ResetInterest(height, obj.vaultId, vault->schemeId, tokenId);
-
             }
 
-            if (auto collaterals = mnview.GetVaultCollaterals(obj.vaultId))
-            {
-
+            if (auto collaterals = mnview.GetVaultCollaterals(obj.vaultId)) {
                 const auto scheme = mnview.GetLoanScheme(vault->schemeId);
                 for (int i = 0; i < 2; i++) {
                     // check collaterals for active and next price
                     bool useNextPrice = i > 0, requireLivePrice = true;
 
-                    auto collateralsLoans = mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
+                    auto collateralsLoans = mnview.GetLoanCollaterals(
+                        obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
                     if (!collateralsLoans)
                         return std::move(collateralsLoans);
 
                     if (collateralsLoans.val->ratio() < scheme->ratio)
-                        return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d", collateralsLoans.val->ratio(), scheme->ratio);
+                        return Res::Err(
+                            "Vault does not have enough collateralization ratio defined by loan scheme - %d < %d",
+                            collateralsLoans.val->ratio(),
+                            scheme->ratio);
 
                     res = CollateralPctCheck(hasDUSDLoans, collateralsLoans, scheme->ratio);
-                    if(!res)
+                    if (!res)
                         return res;
                 }
             } else {
@@ -3649,7 +3808,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.AddBalance(obj.to, obj.amount);
     }
 
-    Res operator()(const CPaybackWithCollateralMessage& obj) const {
+    Res operator()(const CPaybackWithCollateralMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3670,7 +3829,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return PaybackWithCollateral(mnview, *vault, obj.vaultId, height, time);
     }
 
-    Res operator()(const CLoanTakeLoanMessage& obj) const {
+    Res operator()(const CLoanTakeLoanMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3703,8 +3862,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         }
 
         uint64_t totalLoansActivePrice = 0, totalLoansNextPrice = 0;
-        for (const auto& [tokenId, tokenAmount] : obj.amounts.balances)
-        {
+        for (const auto &[tokenId, tokenAmount] : obj.amounts.balances) {
             if (height >= static_cast<uint32_t>(consensus.FortCanningGreatWorldHeight) && tokenAmount <= 0)
                 return Res::Err("Valid loan amount required (input: %d@%d)", tokenAmount, tokenId.v);
 
@@ -3713,7 +3871,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 return Res::Err("Loan token with id (%s) does not exist!", tokenId.ToString());
 
             if (!loanToken->mintable)
-                return Res::Err("Loan cannot be taken on token with id (%s) as \"mintable\" is currently false",tokenId.ToString());
+                return Res::Err("Loan cannot be taken on token with id (%s) as \"mintable\" is currently false",
+                                tokenId.ToString());
 
             if (tokenDUSD && tokenId == tokenDUSD->first) {
                 hasDUSDLoans = true;
@@ -3726,22 +3885,27 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             if (loanAmounts && loanAmounts->balances.count(tokenId)) {
                 currentLoanAmount = loanAmounts->balances.at(tokenId);
-                const auto rate = mnview.GetInterestRate(obj.vaultId, tokenId, height);
+                const auto rate   = mnview.GetInterestRate(obj.vaultId, tokenId, height);
                 assert(rate);
                 const auto totalInterest = TotalInterest(*rate, height);
 
                 if (totalInterest < 0) {
-                    loanAmountChange = currentLoanAmount > std::abs(totalInterest) ?
-                        // Interest to decrease smaller than overall existing loan amount.
-                        // So reduce interest from the borrowing principal. If this is negative,
-                        // we'll reduce from principal.
-                        tokenAmount + totalInterest :
-                        // Interest to decrease is larger than old loan amount.
-                        // We reduce from the borrowing principal. If this is negative,
-                        // we'll reduce from principal.
-                        tokenAmount - currentLoanAmount;
+                    loanAmountChange      = currentLoanAmount > std::abs(totalInterest)
+                                                ?
+                                                // Interest to decrease smaller than overall existing loan amount.
+                                           // So reduce interest from the borrowing principal. If this is negative,
+                                           // we'll reduce from principal.
+                                           tokenAmount + totalInterest
+                                                :
+                                                // Interest to decrease is larger than old loan amount.
+                                           // We reduce from the borrowing principal. If this is negative,
+                                           // we'll reduce from principal.
+                                           tokenAmount - currentLoanAmount;
                     resetInterestToHeight = true;
-                    TrackNegativeInterest(mnview, {tokenId, currentLoanAmount > std::abs(totalInterest) ? std::abs(totalInterest) : currentLoanAmount});
+                    TrackNegativeInterest(
+                        mnview,
+                        {tokenId,
+                         currentLoanAmount > std::abs(totalInterest) ? std::abs(totalInterest) : currentLoanAmount});
                 }
             }
 
@@ -3754,7 +3918,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 if (!res)
                     return res;
             } else {
-                const auto subAmount = currentLoanAmount > std::abs(loanAmountChange) ? std::abs(loanAmountChange) : currentLoanAmount;
+                const auto subAmount =
+                    currentLoanAmount > std::abs(loanAmountChange) ? std::abs(loanAmountChange) : currentLoanAmount;
 
                 if (const auto token = mnview.GetToken("DUSD"); token && token->first == tokenId) {
                     TrackDUSDSub(mnview, {tokenId, subAmount});
@@ -3769,7 +3934,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             if (resetInterestToHeight) {
                 mnview.ResetInterest(height, obj.vaultId, vault->schemeId, tokenId);
             } else {
-                res = mnview.IncreaseInterest(height, obj.vaultId, vault->schemeId, tokenId, loanToken->interest, loanAmountChange);
+                res = mnview.IncreaseInterest(
+                    height, obj.vaultId, vault->schemeId, tokenId, loanToken->interest, loanAmountChange);
                 if (!res)
                     return res;
             }
@@ -3785,13 +3951,14 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
             for (int i = 0; i < 2; i++) {
                 // check active and next price
-                auto price = priceFeed.val->priceRecord[int(i > 0)];
+                auto price  = priceFeed.val->priceRecord[int(i > 0)];
                 auto amount = MultiplyAmounts(price, tokenAmount);
                 if (price > COIN && amount < tokenAmount)
-                    return Res::Err("Value/price too high (%s/%s)", GetDecimaleString(tokenAmount), GetDecimaleString(price));
+                    return Res::Err(
+                        "Value/price too high (%s/%s)", GetDecimaleString(tokenAmount), GetDecimaleString(price));
 
-                auto& totalLoans = i > 0 ? totalLoansNextPrice : totalLoansActivePrice;
-                auto prevLoans = totalLoans;
+                auto &totalLoans = i > 0 ? totalLoansNextPrice : totalLoansActivePrice;
+                auto prevLoans   = totalLoans;
                 totalLoans += amount;
                 if (prevLoans > totalLoans)
                     return Res::Err("Exceed maximum loans");
@@ -3801,8 +3968,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             if (!res)
                 return res;
 
-            const auto& address = !obj.to.empty() ? obj.to
-                                                  : vault->ownerAddress;
+            const auto &address = !obj.to.empty() ? obj.to : vault->ownerAddress;
             CalculateOwnerRewards(address);
             res = mnview.AddBalance(address, CTokenAmount{tokenId, tokenAmount});
             if (!res)
@@ -3814,48 +3980,44 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             // check ratio against current and active price
             bool useNextPrice = i > 0, requireLivePrice = true;
 
-            auto collateralsLoans = mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
+            auto collateralsLoans =
+                mnview.GetLoanCollaterals(obj.vaultId, *collaterals, height, time, useNextPrice, requireLivePrice);
             if (!collateralsLoans)
                 return std::move(collateralsLoans);
 
             if (collateralsLoans.val->ratio() < scheme->ratio)
-                return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d", collateralsLoans.val->ratio(), scheme->ratio);
+                return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d",
+                                collateralsLoans.val->ratio(),
+                                scheme->ratio);
 
             res = CollateralPctCheck(hasDUSDLoans, collateralsLoans, scheme->ratio);
-            if(!res)
+            if (!res)
                 return res;
         }
         return Res::Ok();
     }
 
-    Res operator()(const CLoanPaybackLoanMessage& obj) const {
+    Res operator()(const CLoanPaybackLoanMessage &obj) const {
         std::map<DCT_ID, CBalances> loans;
-        for (auto& balance: obj.amounts.balances) {
-            auto id = balance.first;
+        for (auto &balance : obj.amounts.balances) {
+            auto id     = balance.first;
             auto amount = balance.second;
 
-            CBalances* loan;
-            if (id == DCT_ID{0})
-            {
+            CBalances *loan;
+            if (id == DCT_ID{0}) {
                 auto tokenDUSD = mnview.GetToken("DUSD");
                 if (!tokenDUSD)
                     return Res::Err("Loan token DUSD does not exist!");
                 loan = &loans[tokenDUSD->first];
-            }
-            else
+            } else
                 loan = &loans[id];
 
             loan->Add({id, amount});
         }
-        return (*this)(
-            CLoanPaybackLoanV2Message{
-                obj.vaultId,
-                obj.from,
-                loans
-            });
+        return (*this)(CLoanPaybackLoanV2Message{obj.vaultId, obj.from, loans});
     }
 
-    Res operator()(const CLoanPaybackLoanV2Message& obj) const {
+    Res operator()(const CLoanPaybackLoanV2Message &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -3874,29 +4036,28 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!HasAuth(obj.from))
             return Res::Err("tx must have at least one input from token owner");
 
-        if (static_cast<int>(height) < consensus.FortCanningRoadHeight && !IsVaultPriceValid(mnview, obj.vaultId, height))
+        if (static_cast<int>(height) < consensus.FortCanningRoadHeight &&
+            !IsVaultPriceValid(mnview, obj.vaultId, height))
             return Res::Err("Cannot payback loan while any of the asset's price is invalid");
 
         // Handle payback with collateral special case
-        if (static_cast<int>(height) >= consensus.FortCanningEpilogueHeight
-        && IsPaybackWithCollateral(mnview, obj.loans)) {
+        if (static_cast<int>(height) >= consensus.FortCanningEpilogueHeight &&
+            IsPaybackWithCollateral(mnview, obj.loans)) {
             return PaybackWithCollateral(mnview, *vault, obj.vaultId, height, time);
         }
 
         auto shouldSetVariable = false;
-        auto attributes = mnview.GetAttributes();
+        auto attributes        = mnview.GetAttributes();
         assert(attributes);
 
-        for (const auto& [loanTokenId, paybackAmounts] : obj.loans)
-        {
+        for (const auto &[loanTokenId, paybackAmounts] : obj.loans) {
             const auto loanToken = mnview.GetLoanTokenByID(loanTokenId);
             if (!loanToken)
                 return Res::Err("Loan token with id (%s) does not exist!", loanTokenId.ToString());
 
-            for (const auto& kv : paybackAmounts.balances)
-            {
-                const auto& paybackTokenId = kv.first;
-                auto paybackAmount = kv.second;
+            for (const auto &kv : paybackAmounts.balances) {
+                const auto &paybackTokenId = kv.first;
+                auto paybackAmount         = kv.second;
 
                 if (height >= static_cast<uint32_t>(consensus.FortCanningGreatWorldHeight) && paybackAmount <= 0) {
                     return Res::Err("Valid payback amount required (input: %d@%d)", paybackAmount, paybackTokenId.v);
@@ -3908,8 +4069,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 if (!paybackToken)
                     return Res::Err("Token with id (%s) does not exists", paybackTokenId.ToString());
 
-                if (loanTokenId != paybackTokenId)
-                {
+                if (loanTokenId != paybackTokenId) {
                     if (!IsVaultPriceValid(mnview, obj.vaultId, height))
                         return Res::Err("Cannot payback loan while any of the asset's price is invalid");
 
@@ -3917,28 +4077,28 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                         return Res::Err("Payback is not currently active");
 
                     // search in token to token
-                    if (paybackTokenId != DCT_ID{0})
-                    {
-                        CDataStructureV0 activeKey{AttributeTypes::Token, loanTokenId.v, TokenKeys::LoanPayback, paybackTokenId.v};
+                    if (paybackTokenId != DCT_ID{0}) {
+                        CDataStructureV0 activeKey{
+                            AttributeTypes::Token, loanTokenId.v, TokenKeys::LoanPayback, paybackTokenId.v};
                         if (!attributes->GetValue(activeKey, false))
-                            return Res::Err("Payback of loan via %s token is not currently active", paybackToken->symbol);
+                            return Res::Err("Payback of loan via %s token is not currently active",
+                                            paybackToken->symbol);
 
-                        CDataStructureV0 penaltyKey{AttributeTypes::Token, loanTokenId.v, TokenKeys::LoanPaybackFeePCT, paybackTokenId.v};
+                        CDataStructureV0 penaltyKey{
+                            AttributeTypes::Token, loanTokenId.v, TokenKeys::LoanPaybackFeePCT, paybackTokenId.v};
                         penaltyPct -= attributes->GetValue(penaltyKey, CAmount{0});
-                    }
-                    else
-                    {
+                    } else {
                         CDataStructureV0 activeKey{AttributeTypes::Token, loanTokenId.v, TokenKeys::PaybackDFI};
                         if (!attributes->GetValue(activeKey, false))
-                            return Res::Err("Payback of loan via %s token is not currently active", paybackToken->symbol);
+                            return Res::Err("Payback of loan via %s token is not currently active",
+                                            paybackToken->symbol);
 
                         CDataStructureV0 penaltyKey{AttributeTypes::Token, loanTokenId.v, TokenKeys::PaybackDFIFeePCT};
                         penaltyPct -= attributes->GetValue(penaltyKey, COIN / 100);
-
                     }
 
                     // Get token price in USD
-                    const CTokenCurrencyPair tokenUsdPair{paybackToken->symbol,"USD"};
+                    const CTokenCurrencyPair tokenUsdPair{paybackToken->symbol, "USD"};
                     bool useNextPrice{false}, requireLivePrice{true};
                     const auto resVal = mnview.GetValidatedIntervalPrice(tokenUsdPair, useNextPrice, requireLivePrice);
                     if (!resVal)
@@ -3949,18 +4109,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                     // Calculate the DFI amount in DUSD
                     auto usdAmount = MultiplyAmounts(paybackUsdPrice, kv.second);
 
-                    if (loanToken->symbol == "DUSD")
-                    {
+                    if (loanToken->symbol == "DUSD") {
                         paybackAmount = usdAmount;
                         if (paybackUsdPrice > COIN && paybackAmount < kv.second)
-                            return Res::Err("Value/price too high (%s/%s)", GetDecimaleString(kv.second), GetDecimaleString(paybackUsdPrice));
-                    }
-                    else
-                    {
+                            return Res::Err("Value/price too high (%s/%s)",
+                                            GetDecimaleString(kv.second),
+                                            GetDecimaleString(paybackUsdPrice));
+                    } else {
                         // Get dToken price in USD
                         const CTokenCurrencyPair dTokenUsdPair{loanToken->symbol, "USD"};
                         bool useNextPrice{false}, requireLivePrice{true};
-                        const auto resVal = mnview.GetValidatedIntervalPrice(dTokenUsdPair, useNextPrice, requireLivePrice);
+                        const auto resVal =
+                            mnview.GetValidatedIntervalPrice(dTokenUsdPair, useNextPrice, requireLivePrice);
                         if (!resVal)
                             return std::move(resVal);
 
@@ -3977,7 +4137,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 if (!loanAmounts->balances.count(loanTokenId))
                     return Res::Err("There is no loan on token (%s) in this vault!", loanToken->symbol);
 
-                const auto& currentLoanAmount = loanAmounts->balances.at(loanTokenId);
+                const auto &currentLoanAmount = loanAmounts->balances.at(loanTokenId);
 
                 const auto rate = mnview.GetInterestRate(obj.vaultId, loanTokenId, height);
                 if (!rate)
@@ -3986,19 +4146,18 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 auto subInterest = TotalInterest(*rate, height);
 
                 if (subInterest < 0) {
-                    TrackNegativeInterest(mnview, {loanTokenId, currentLoanAmount > std::abs(subInterest) ? std::abs(subInterest) : subInterest});
+                    TrackNegativeInterest(
+                        mnview,
+                        {loanTokenId, currentLoanAmount > std::abs(subInterest) ? std::abs(subInterest) : subInterest});
                 }
 
                 // In the case of negative subInterest the amount ends up being added to paybackAmount
                 auto subLoan = paybackAmount - subInterest;
 
-                if (paybackAmount < subInterest)
-                {
+                if (paybackAmount < subInterest) {
                     subInterest = paybackAmount;
-                    subLoan = 0;
-                }
-                else if (currentLoanAmount - subLoan < 0)
-                {
+                    subLoan     = 0;
+                } else if (currentLoanAmount - subLoan < 0) {
                     subLoan = currentLoanAmount;
                 }
 
@@ -4013,27 +4172,34 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                 // Eraseinterest. On subInterest is nil interest ITH and IPB will be updated, if
                 // subInterest is negative or IPB is negative and subLoan is equal to the loan amount
                 // then IPB will be updated and ITH will be wiped.
-                res = mnview.DecreaseInterest(height, obj.vaultId, vault->schemeId, loanTokenId, subLoan,
-                    subInterest < 0 || (rate->interestPerBlock.negative && subLoan == currentLoanAmount) ? std::numeric_limits<CAmount>::max() : subInterest);
+                res = mnview.DecreaseInterest(
+                    height,
+                    obj.vaultId,
+                    vault->schemeId,
+                    loanTokenId,
+                    subLoan,
+                    subInterest < 0 || (rate->interestPerBlock.negative && subLoan == currentLoanAmount)
+                        ? std::numeric_limits<CAmount>::max()
+                        : subInterest);
                 if (!res)
                     return res;
 
-                if (height >= static_cast<uint32_t>(consensus.FortCanningMuseumHeight) &&
-                    subLoan < currentLoanAmount &&
-                    height < static_cast<uint32_t>(consensus.FortCanningGreatWorldHeight))
-                {
+                if (height >= static_cast<uint32_t>(consensus.FortCanningMuseumHeight) && subLoan < currentLoanAmount &&
+                    height < static_cast<uint32_t>(consensus.FortCanningGreatWorldHeight)) {
                     auto newRate = mnview.GetInterestRate(obj.vaultId, loanTokenId, height);
                     if (!newRate)
                         return Res::Err("Cannot get interest rate for this token (%s)!", loanToken->symbol);
 
                     if (newRate->interestPerBlock.amount == 0)
-                        return Res::Err("Cannot payback this amount of loan for %s, either payback full amount or less than this amount!", loanToken->symbol);
+                        return Res::Err(
+                            "Cannot payback this amount of loan for %s, either payback full amount or less than this "
+                            "amount!",
+                            loanToken->symbol);
                 }
 
                 CalculateOwnerRewards(obj.from);
 
-                if (paybackTokenId == loanTokenId)
-                {
+                if (paybackTokenId == loanTokenId) {
                     res = mnview.SubMintedTokens(loanTokenId, subInterest > 0 ? subLoan : subLoan + subInterest);
                     if (!res)
                         return res;
@@ -4044,51 +4210,50 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
                     // Do not sub balance if negative interest fully negates the current loan amount
                     if (!(subInterest < 0 && std::abs(subInterest) >= currentLoanAmount)) {
-
-                        // If negative interest plus payback amount overpays then reduce payback amount by the difference
+                        // If negative interest plus payback amount overpays then reduce payback amount by the
+                        // difference
                         if (subInterest < 0 && paybackAmount - subInterest > currentLoanAmount) {
                             subLoan = currentLoanAmount + subInterest;
                         }
 
                         // subtract loan amount first, interest is burning below
-                        LogPrint(BCLog::LOAN, "CLoanPaybackLoanMessage(): Sub loan from balance - %lld, height - %d\n", subLoan, height);
+                        LogPrint(BCLog::LOAN,
+                                 "CLoanPaybackLoanMessage(): Sub loan from balance - %lld, height - %d\n",
+                                 subLoan,
+                                 height);
                         res = mnview.SubBalance(obj.from, CTokenAmount{loanTokenId, subLoan});
                         if (!res)
                             return res;
                     }
 
                     // burn interest Token->USD->DFI->burnAddress
-                    if (subInterest > 0)
-                    {
-                        LogPrint(BCLog::LOAN, "CLoanPaybackLoanMessage(): Swapping %s interest to DFI - %lld, height - %d\n", loanToken->symbol, subInterest, height);
-                        res = SwapToDFIorDUSD(mnview, loanTokenId, subInterest, obj.from, consensus.burnAddress, height);
+                    if (subInterest > 0) {
+                        LogPrint(BCLog::LOAN,
+                                 "CLoanPaybackLoanMessage(): Swapping %s interest to DFI - %lld, height - %d\n",
+                                 loanToken->symbol,
+                                 subInterest,
+                                 height);
+                        res =
+                            SwapToDFIorDUSD(mnview, loanTokenId, subInterest, obj.from, consensus.burnAddress, height);
                     }
-                }
-                else
-                {
+                } else {
                     CAmount subInToken;
                     const auto subAmount = subLoan + subInterest;
 
                     // if payback overpay loan and interest amount
-                    if (paybackAmount > subAmount)
-                    {
-                        if (loanToken->symbol == "DUSD")
-                        {
+                    if (paybackAmount > subAmount) {
+                        if (loanToken->symbol == "DUSD") {
                             subInToken = DivideAmounts(subAmount, paybackUsdPrice);
                             if (MultiplyAmounts(subInToken, paybackUsdPrice) != subAmount)
                                 subInToken += 1;
-                        }
-                        else
-                        {
+                        } else {
                             auto tempAmount = MultiplyAmounts(subAmount, loanUsdPrice);
 
                             subInToken = DivideAmounts(tempAmount, paybackUsdPrice);
                             if (DivideAmounts(MultiplyAmounts(subInToken, paybackUsdPrice), loanUsdPrice) != subAmount)
                                 subInToken += 1;
                         }
-                    }
-                    else
-                    {
+                    } else {
                         subInToken = kv.second;
                     }
 
@@ -4096,25 +4261,30 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
 
                     auto penalty = MultiplyAmounts(subInToken, COIN - penaltyPct);
 
-                    if (paybackTokenId == DCT_ID{0})
-                    {
-                        CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::PaybackDFITokens};
+                    if (paybackTokenId == DCT_ID{0}) {
+                        CDataStructureV0 liveKey{
+                            AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::PaybackDFITokens};
                         auto balances = attributes->GetValue(liveKey, CBalances{});
                         balances.Add({loanTokenId, subAmount});
                         balances.Add({paybackTokenId, penalty});
                         attributes->SetValue(liveKey, balances);
 
                         liveKey.key = EconomyKeys::PaybackDFITokensPrincipal;
-                        balances = attributes->GetValue(liveKey, CBalances{});
+                        balances    = attributes->GetValue(liveKey, CBalances{});
                         balances.Add({loanTokenId, subLoan});
                         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);
+                        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);
 
                         res = TransferTokenBalance(paybackTokenId, subInToken, obj.from, consensus.burnAddress);
-                    }
-                    else
-                    {
+                    } else {
                         CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::PaybackTokens};
                         auto balances = attributes->GetValue(liveKey, CTokenPayback{});
 
@@ -4122,12 +4292,26 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
                         balances.tokensFee.Add(CTokenAmount{paybackTokenId, penalty});
                         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);
-
-                        CDataStructureV0 directBurnKey{AttributeTypes::Param, ParamIDs::DFIP2206A, DFIPKeys::DUSDLoanBurn};
+                        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);
+
+                        CDataStructureV0 directBurnKey{
+                            AttributeTypes::Param, ParamIDs::DFIP2206A, DFIPKeys::DUSDLoanBurn};
                         auto directLoanBurn = attributes->GetValue(directBurnKey, false);
 
-                        res = SwapToDFIorDUSD(mnview, paybackTokenId, subInToken, obj.from, consensus.burnAddress, height, !directLoanBurn);
+                        res = SwapToDFIorDUSD(mnview,
+                                              paybackTokenId,
+                                              subInToken,
+                                              obj.from,
+                                              consensus.burnAddress,
+                                              height,
+                                              !directLoanBurn);
                     }
                 }
 
@@ -4139,7 +4323,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return shouldSetVariable ? mnview.SetVariable(*attributes) : Res::Ok();
     }
 
-    Res operator()(const CAuctionBidMessage& obj) const {
+    Res operator()(const CAuctionBidMessage &obj) const {
         auto res = CheckCustomTx();
         if (!res)
             return res;
@@ -4172,32 +4356,32 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!bid) {
             auto amount = MultiplyAmounts(batch->loanAmount.nValue, COIN + data->liquidationPenalty);
             if (amount > obj.amount.nValue)
-                return Res::Err("First bid should include liquidation penalty of %d%%", data->liquidationPenalty * 100 / COIN);
+                return Res::Err("First bid should include liquidation penalty of %d%%",
+                                data->liquidationPenalty * 100 / COIN);
 
-            if (static_cast<int>(height) >= consensus.FortCanningMuseumHeight
-            && data->liquidationPenalty && obj.amount.nValue == batch->loanAmount.nValue)
+            if (static_cast<int>(height) >= consensus.FortCanningMuseumHeight && data->liquidationPenalty &&
+                obj.amount.nValue == batch->loanAmount.nValue)
                 return Res::Err("First bid should be higher than batch one");
         } else {
             auto amount = MultiplyAmounts(bid->second.nValue, COIN + (COIN / 100));
             if (amount > obj.amount.nValue)
                 return Res::Err("Bid override should be at least 1%% higher than current one");
 
-            if (static_cast<int>(height) >= consensus.FortCanningMuseumHeight
-            && obj.amount.nValue == bid->second.nValue)
+            if (static_cast<int>(height) >= consensus.FortCanningMuseumHeight &&
+                obj.amount.nValue == bid->second.nValue)
                 return Res::Err("Bid override should be higher than last one");
 
             // immediate refund previous bid
             CalculateOwnerRewards(bid->first);
             mnview.AddBalance(bid->first, bid->second);
         }
-        //check balance
+        // check balance
         CalculateOwnerRewards(obj.from);
         res = mnview.SubBalance(obj.from, obj.amount);
         return !res ? res : mnview.StoreAuctionBid({obj.vaultId, obj.index}, {obj.from, obj.amount});
     }
 
-    Res operator()(const CCreatePropMessage& obj) const
-    {
+    Res operator()(const CCreatePropMessage &obj) const {
         auto res = IsOnChainGovernanceEnabled();
         if (!res) {
             return res;
@@ -4262,8 +4446,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return mnview.CreateProp(tx.GetHash(), height, obj, tx.vout[0].nValue);
     }
 
-    Res operator()(const CPropVoteMessage& obj) const
-    {
+    Res operator()(const CPropVoteMessage &obj) const {
         auto res = IsOnChainGovernanceEnabled();
         if (!res) {
             return res;
@@ -4280,7 +4463,8 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!node)
             return Res::Err("masternode <%s> does not exist", obj.masternodeId.GetHex());
 
-        auto ownerDest = node->ownerType == 1 ? CTxDestination(PKHash(node->ownerAuthAddress)) : CTxDestination(WitnessV0KeyHash(node->ownerAuthAddress));
+        auto ownerDest = node->ownerType == 1 ? CTxDestination(PKHash(node->ownerAuthAddress))
+                                              : CTxDestination(WitnessV0KeyHash(node->ownerAuthAddress));
 
         if (!HasAuth(GetScriptForDestination(ownerDest)))
             return Res::Err("tx must have at least one input from the owner");
@@ -4292,33 +4476,34 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("masternode <%s> does not mine at least one block", obj.masternodeId.GetHex());
 
         switch (obj.vote) {
-        case CPropVoteType::VoteNo:
-        case CPropVoteType::VoteYes:
-        case CPropVoteType::VoteNeutral:
-            break;
-        default:
-            return Res::Err("unsupported vote type");
+            case CPropVoteType::VoteNo:
+            case CPropVoteType::VoteYes:
+            case CPropVoteType::VoteNeutral:
+                break;
+            default:
+                return Res::Err("unsupported vote type");
         }
         auto vote = static_cast<CPropVoteType>(obj.vote);
         return mnview.AddPropVote(obj.propId, obj.masternodeId, vote);
     }
 
-    Res operator()(const CCustomTxMessageNone&) const {
-        return Res::Ok();
-    }
+    Res operator()(const CCustomTxMessageNone &) const { return Res::Ok(); }
 };
 
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage) {
+Res CustomMetadataParse(uint32_t height,
+                        const Consensus::Params &consensus,
+                        const std::vector<unsigned char> &metadata,
+                        CCustomTxMessage &txMessage) {
     try {
         return std::visit(CCustomMetadataParseVisitor(height, consensus, metadata), txMessage);
-    } catch (const std::exception& e) {
+    } catch (const std::exception &e) {
         return Res::Err(e.what());
     } catch (...) {
         return Res::Err("unexpected error");
     }
 }
 
-bool IsDisabledTx(uint32_t height, CustomTxType type, const Consensus::Params& consensus) {
+bool IsDisabledTx(uint32_t height, CustomTxType type, const Consensus::Params &consensus) {
     // All the heights that are involved in disabled Txs
     auto fortCanningParkHeight = static_cast<uint32_t>(consensus.FortCanningParkHeight);
     auto fortCanningHillHeight = static_cast<uint32_t>(consensus.FortCanningHillHeight);
@@ -4337,7 +4522,7 @@ bool IsDisabledTx(uint32_t height, CustomTxType type, const Consensus::Params& c
                 return true;
             default:
                 break;
-            }
+        }
     }
 
     // ICXCreateOrder      = '1',
@@ -4367,90 +4552,113 @@ bool IsDisabledTx(uint32_t height, CustomTxType type, const Consensus::Params& c
     }
 }
 
-bool IsDisabledTx(uint32_t height, const CTransaction& tx, const Consensus::Params& consensus) {
+bool IsDisabledTx(uint32_t height, const CTransaction &tx, const Consensus::Params &consensus) {
     TBytes dummy;
     auto txType = GuessCustomTxType(tx, dummy);
     return IsDisabledTx(height, txType, consensus);
 }
 
-Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time, uint32_t txn) {
+Res CustomTxVisit(CCustomCSView &mnview,
+                  const CCoinsViewCache &coins,
+                  const CTransaction &tx,
+                  uint32_t height,
+                  const Consensus::Params &consensus,
+                  const CCustomTxMessage &txMessage,
+                  uint64_t time,
+                  uint32_t txn) {
     if (IsDisabledTx(height, tx, consensus)) {
         return Res::ErrCode(CustomTxErrCodes::Fatal, "Disabled custom transaction");
     }
     try {
         return std::visit(CCustomTxApplyVisitor(tx, height, coins, mnview, consensus, time, txn), txMessage);
-    } catch (const std::bad_variant_access& e) {
+    } catch (const std::bad_variant_access &e) {
         return Res::Err(e.what());
     } catch (...) {
         return Res::Err("unexpected error");
     }
 }
 
-bool ShouldReturnNonFatalError(const CTransaction& tx, uint32_t height) {
+bool ShouldReturnNonFatalError(const CTransaction &tx, uint32_t height) {
     static const std::map<uint32_t, uint256> skippedTx = {
-        { 471222, uint256S("0ab0b76352e2d865761f4c53037041f33e1200183d55cdf6b09500d6f16b7329") },
+        {471222, uint256S("0ab0b76352e2d865761f4c53037041f33e1200183d55cdf6b09500d6f16b7329")},
     };
     auto it = skippedTx.find(height);
     return it != skippedTx.end() && it->second == tx.GetHash();
 }
 
-void PopulateVaultHistoryData(CHistoryWriters* writers, CAccountsHistoryWriter& view, const CCustomTxMessage& txMessage, const CustomTxType txType, const uint32_t height, const uint32_t txn, const uint256& txid) {
+void PopulateVaultHistoryData(CHistoryWriters *writers,
+                              CAccountsHistoryWriter &view,
+                              const CCustomTxMessage &txMessage,
+                              const CustomTxType txType,
+                              const uint32_t height,
+                              const uint32_t txn,
+                              const uint256 &txid) {
     if (txType == CustomTxType::Vault) {
-        auto obj = std::get<CVaultMessage>(txMessage);
+        auto obj          = std::get<CVaultMessage>(txMessage);
         writers->schemeID = obj.schemeId;
-        view.vaultID = txid;
+        view.vaultID      = txid;
     } else if (txType == CustomTxType::CloseVault) {
-        auto obj = std::get<CCloseVaultMessage>(txMessage);
+        auto obj     = std::get<CCloseVaultMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::UpdateVault) {
-        auto obj = std::get<CUpdateVaultMessage>(txMessage);
+        auto obj     = std::get<CUpdateVaultMessage>(txMessage);
         view.vaultID = obj.vaultId;
         if (!obj.schemeId.empty()) {
             writers->schemeID = obj.schemeId;
         }
     } else if (txType == CustomTxType::DepositToVault) {
-        auto obj = std::get<CDepositToVaultMessage>(txMessage);
+        auto obj     = std::get<CDepositToVaultMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::WithdrawFromVault) {
-        auto obj = std::get<CWithdrawFromVaultMessage>(txMessage);
+        auto obj     = std::get<CWithdrawFromVaultMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::PaybackWithCollateral) {
-        auto obj = std::get<CPaybackWithCollateralMessage>(txMessage);
+        auto obj     = std::get<CPaybackWithCollateralMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::TakeLoan) {
-        auto obj = std::get<CLoanTakeLoanMessage>(txMessage);
+        auto obj     = std::get<CLoanTakeLoanMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::PaybackLoan) {
-        auto obj = std::get<CLoanPaybackLoanMessage>(txMessage);
+        auto obj     = std::get<CLoanPaybackLoanMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::PaybackLoanV2) {
-        auto obj = std::get<CLoanPaybackLoanV2Message>(txMessage);
+        auto obj     = std::get<CLoanPaybackLoanV2Message>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::AuctionBid) {
-        auto obj = std::get<CAuctionBidMessage>(txMessage);
+        auto obj     = std::get<CAuctionBidMessage>(txMessage);
         view.vaultID = obj.vaultId;
     } else if (txType == CustomTxType::LoanScheme) {
-        auto obj = std::get<CLoanSchemeMessage>(txMessage);
+        auto obj                             = std::get<CLoanSchemeMessage>(txMessage);
         writers->globalLoanScheme.identifier = obj.identifier;
-        writers->globalLoanScheme.ratio = obj.ratio;
-        writers->globalLoanScheme.rate = obj.rate;
+        writers->globalLoanScheme.ratio      = obj.ratio;
+        writers->globalLoanScheme.rate       = obj.rate;
         if (!obj.updateHeight) {
             writers->globalLoanScheme.schemeCreationTxid = txid;
         } else {
-            writers->vaultView->ForEachGlobalScheme([&writers](VaultGlobalSchemeKey const & key, CLazySerialize<VaultGlobalSchemeValue> value) {
-                if (value.get().loanScheme.identifier != writers->globalLoanScheme.identifier) {
-                    return true;
-                }
-                writers->globalLoanScheme.schemeCreationTxid = key.schemeCreationTxid;
-                return false;
-            }, {height, txn, {}});
+            writers->vaultView->ForEachGlobalScheme(
+                [&writers](const VaultGlobalSchemeKey &key, CLazySerialize<VaultGlobalSchemeValue> value) {
+                    if (value.get().loanScheme.identifier != writers->globalLoanScheme.identifier) {
+                        return true;
+                    }
+                    writers->globalLoanScheme.schemeCreationTxid = key.schemeCreationTxid;
+                    return false;
+                },
+                {height, txn, {}});
         }
     }
 }
 
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time, uint256* canSpend, uint32_t txn, CHistoryWriters* writers) {
+Res ApplyCustomTx(CCustomCSView &mnview,
+                  const CCoinsViewCache &coins,
+                  const CTransaction &tx,
+                  const Consensus::Params &consensus,
+                  uint32_t height,
+                  uint64_t time,
+                  uint256 *canSpend,
+                  uint32_t txn,
+                  CHistoryWriters *writers) {
     auto res = Res::Ok();
-    if (tx.IsCoinBase() && height > 0) { // genesis contains custom coinbase txs
+    if (tx.IsCoinBase() && height > 0) {  // genesis contains custom coinbase txs
         return res;
     }
     std::vector<unsigned char> metadata;
@@ -4468,13 +4676,13 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
     CAccountsHistoryWriter view(mnview, height, txn, tx.GetHash(), uint8_t(txType), writers);
     if ((res = CustomMetadataParse(height, consensus, metadata, txMessage))) {
         if (pvaultHistoryDB && writers) {
-           PopulateVaultHistoryData(writers, view, txMessage, txType, height, txn, tx.GetHash());
+            PopulateVaultHistoryData(writers, view, txMessage, txType, height, txn, tx.GetHash());
         }
         res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time, txn);
 
         if (res && canSpend && txType == CustomTxType::UpdateMasternode) {
             auto obj = std::get<CUpdateMasterNodeMessage>(txMessage);
-            for (const auto& item : obj.updates) {
+            for (const auto &item : obj.updates) {
                 if (item.first == static_cast<uint8_t>(UpdateMasternodeType::OwnerAddress)) {
                     if (const auto node = mnview.GetMasternode(obj.mnId)) {
                         *canSpend = node->collateralTx.IsNull() ? obj.mnId : node->collateralTx;
@@ -4485,8 +4693,7 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
         }
 
         // Track burn fee
-        if (txType == CustomTxType::CreateToken
-        || txType == CustomTxType::CreateMasternode) {
+        if (txType == CustomTxType::CreateToken || txType == CustomTxType::CreateMasternode) {
             if (writers) {
                 writers->AddFeeBurn(tx.vout[0].scriptPubKey, tx.vout[0].nValue);
             }
@@ -4494,7 +4701,8 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
 
         if (txType == CustomTxType::CreateCfp || txType == CustomTxType::CreateVoc) {
             // burn fee_burn_pct of creation fee, the rest is distributed among voting masternodes
-            CDataStructureV0 burnPctKey{AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::FeeBurnPct};
+            CDataStructureV0 burnPctKey{
+                AttributeTypes::Governance, GovernanceIDs::Proposals, GovernanceKeys::FeeBurnPct};
 
             auto attributes = view.GetAttributes();
             assert(attributes);
@@ -4530,8 +4738,8 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
     }
 
     // construct undo
-    auto& flushable = view.GetStorage();
-    auto undo = CUndo::Construct(mnview.GetStorage(), flushable.GetRaw());
+    auto &flushable = view.GetStorage();
+    auto undo       = CUndo::Construct(mnview.GetStorage(), flushable.GetRaw());
     // flush changes
     view.Flush();
     // write undo
@@ -4541,8 +4749,12 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
     return res;
 }
 
-ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView & mnview, CTransaction const & tx, int height, uint256 const & prevStakeModifier, std::vector<unsigned char> const & metadata, Consensus::Params const & consensusParams)
-{
+ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView &mnview,
+                                    const CTransaction &tx,
+                                    int height,
+                                    const uint256 &prevStakeModifier,
+                                    const std::vector<unsigned char> &metadata,
+                                    const Consensus::Params &consensusParams) {
     if (height >= consensusParams.DakotaHeight) {
         return Res::Err("Old anchor TX type after Dakota fork. Height %d", height);
     }
@@ -4553,8 +4765,10 @@ ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView & mnview, CTransaction const &
 
     auto rewardTx = mnview.GetRewardForAnchor(finMsg.btcTxHash);
     if (rewardTx) {
-        return Res::ErrDbg("bad-ar-exists", "reward for anchor %s already exists (tx: %s)",
-                           finMsg.btcTxHash.ToString(), (*rewardTx).ToString());
+        return Res::ErrDbg("bad-ar-exists",
+                           "reward for anchor %s already exists (tx: %s)",
+                           finMsg.btcTxHash.ToString(),
+                           (*rewardTx).ToString());
     }
 
     if (!finMsg.CheckConfirmSigs()) {
@@ -4562,31 +4776,35 @@ ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView & mnview, CTransaction const &
     }
 
     if (finMsg.sigs.size() < GetMinAnchorQuorum(finMsg.currentTeam)) {
-        return Res::ErrDbg("bad-ar-sigs-quorum", "anchor sigs (%d) < min quorum (%) ",
-                           finMsg.sigs.size(), GetMinAnchorQuorum(finMsg.currentTeam));
+        return Res::ErrDbg("bad-ar-sigs-quorum",
+                           "anchor sigs (%d) < min quorum (%) ",
+                           finMsg.sigs.size(),
+                           GetMinAnchorQuorum(finMsg.currentTeam));
     }
 
     // check reward sum
     if (height >= consensusParams.AMKHeight) {
-        auto const cbValues = tx.GetValuesOut();
+        const auto cbValues = tx.GetValuesOut();
         if (cbValues.size() != 1 || cbValues.begin()->first != DCT_ID{0})
             return Res::ErrDbg("bad-ar-wrong-tokens", "anchor reward should be payed only in Defi coins");
 
-        auto const anchorReward = mnview.GetCommunityBalance(CommunityAccountType::AnchorReward);
+        const auto anchorReward = mnview.GetCommunityBalance(CommunityAccountType::AnchorReward);
         if (cbValues.begin()->second != anchorReward) {
-            return Res::ErrDbg("bad-ar-amount", "anchor pays wrong amount (actual=%d vs expected=%d)",
-                               cbValues.begin()->second, anchorReward);
+            return Res::ErrDbg("bad-ar-amount",
+                               "anchor pays wrong amount (actual=%d vs expected=%d)",
+                               cbValues.begin()->second,
+                               anchorReward);
         }
-    }
-    else { // pre-AMK logic
+    } else {  // pre-AMK logic
         auto anchorReward = GetAnchorSubsidy(finMsg.anchorHeight, finMsg.prevAnchorHeight, consensusParams);
         if (tx.GetValueOut() > anchorReward) {
-            return Res::ErrDbg("bad-ar-amount", "anchor pays too much (actual=%d vs limit=%d)",
-                               tx.GetValueOut(), anchorReward);
+            return Res::ErrDbg(
+                "bad-ar-amount", "anchor pays too much (actual=%d vs limit=%d)", tx.GetValueOut(), anchorReward);
         }
     }
 
-    CTxDestination destination = finMsg.rewardKeyType == 1 ? CTxDestination(PKHash(finMsg.rewardKeyID)) : CTxDestination(WitnessV0KeyHash(finMsg.rewardKeyID));
+    CTxDestination destination = finMsg.rewardKeyType == 1 ? CTxDestination(PKHash(finMsg.rewardKeyID))
+                                                           : CTxDestination(WitnessV0KeyHash(finMsg.rewardKeyID));
     if (tx.vout[1].scriptPubKey != GetScriptForDestination(destination)) {
         return Res::ErrDbg("bad-ar-dest", "anchor pay destination is incorrect");
     }
@@ -4600,18 +4818,24 @@ ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView & mnview, CTransaction const &
     }
     mnview.SetTeam(finMsg.nextTeam);
     if (height >= consensusParams.AMKHeight) {
-        LogPrint(BCLog::ACCOUNTCHANGE, "AccountChange: txid=%s fund=%s change=%s\n", tx.GetHash().ToString(), GetCommunityAccountName(CommunityAccountType::AnchorReward), (CBalances{{{{0}, -mnview.GetCommunityBalance(CommunityAccountType::AnchorReward)}}}.ToString()));
-        mnview.SetCommunityBalance(CommunityAccountType::AnchorReward, 0); // just reset
-    }
-    else {
+        LogPrint(BCLog::ACCOUNTCHANGE,
+                 "AccountChange: txid=%s fund=%s change=%s\n",
+                 tx.GetHash().ToString(),
+                 GetCommunityAccountName(CommunityAccountType::AnchorReward),
+                 (CBalances{{{{0}, -mnview.GetCommunityBalance(CommunityAccountType::AnchorReward)}}}.ToString()));
+        mnview.SetCommunityBalance(CommunityAccountType::AnchorReward, 0);  // just reset
+    } else {
         mnview.SetFoundationsDebt(mnview.GetFoundationsDebt() + tx.GetValueOut());
     }
 
-    return { finMsg.btcTxHash, Res::Ok() };
+    return {finMsg.btcTxHash, Res::Ok()};
 }
 
-ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView & mnview, CTransaction const & tx, int height, std::vector<unsigned char> const & metadata, Consensus::Params const & consensusParams)
-{
+ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView &mnview,
+                                        const CTransaction &tx,
+                                        int height,
+                                        const std::vector<unsigned char> &metadata,
+                                        const Consensus::Params &consensusParams) {
     if (height < consensusParams.DakotaHeight) {
         return Res::Err("New anchor TX type before Dakota fork. Height %d", height);
     }
@@ -4622,13 +4846,15 @@ ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView & mnview, CTransaction con
 
     auto rewardTx = mnview.GetRewardForAnchor(finMsg.btcTxHash);
     if (rewardTx) {
-        return Res::ErrDbg("bad-ar-exists", "reward for anchor %s already exists (tx: %s)",
-                           finMsg.btcTxHash.ToString(), (*rewardTx).ToString());
+        return Res::ErrDbg("bad-ar-exists",
+                           "reward for anchor %s already exists (tx: %s)",
+                           finMsg.btcTxHash.ToString(),
+                           (*rewardTx).ToString());
     }
 
     // Miner used confirm team at chain height when creating this TX, this is height - 1.
     int anchorHeight = height - 1;
-    auto uniqueKeys = finMsg.CheckConfirmSigs(anchorHeight);
+    auto uniqueKeys  = finMsg.CheckConfirmSigs(anchorHeight);
     if (!uniqueKeys) {
         return Res::ErrDbg("bad-ar-sigs", "anchor signatures are incorrect");
     }
@@ -4640,55 +4866,64 @@ ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView & mnview, CTransaction con
 
     auto quorum = GetMinAnchorQuorum(*team);
     if (finMsg.sigs.size() < quorum) {
-        return Res::ErrDbg("bad-ar-sigs-quorum", "anchor sigs (%d) < min quorum (%) ",
-                           finMsg.sigs.size(), quorum);
+        return Res::ErrDbg("bad-ar-sigs-quorum", "anchor sigs (%d) < min quorum (%) ", finMsg.sigs.size(), quorum);
     }
 
     if (uniqueKeys < quorum) {
-        return Res::ErrDbg("bad-ar-sigs-quorum", "anchor unique keys (%d) < min quorum (%) ",
-                           uniqueKeys, quorum);
+        return Res::ErrDbg("bad-ar-sigs-quorum", "anchor unique keys (%d) < min quorum (%) ", uniqueKeys, quorum);
     }
 
     // Make sure anchor block height and hash exist in chain.
-    CBlockIndex* anchorIndex = ::ChainActive()[finMsg.anchorHeight];
+    CBlockIndex *anchorIndex = ::ChainActive()[finMsg.anchorHeight];
     if (!anchorIndex) {
-        return Res::ErrDbg("bad-ar-height", "Active chain does not contain block height %d. Chain height %d",
-                           finMsg.anchorHeight, ::ChainActive().Height());
+        return Res::ErrDbg("bad-ar-height",
+                           "Active chain does not contain block height %d. Chain height %d",
+                           finMsg.anchorHeight,
+                           ::ChainActive().Height());
     }
 
     if (anchorIndex->GetBlockHash() != finMsg.dfiBlockHash) {
-        return Res::ErrDbg("bad-ar-hash", "Anchor and blockchain mismatch at height %d. Expected %s found %s",
-                           finMsg.anchorHeight, anchorIndex->GetBlockHash().ToString(), finMsg.dfiBlockHash.ToString());
+        return Res::ErrDbg("bad-ar-hash",
+                           "Anchor and blockchain mismatch at height %d. Expected %s found %s",
+                           finMsg.anchorHeight,
+                           anchorIndex->GetBlockHash().ToString(),
+                           finMsg.dfiBlockHash.ToString());
     }
 
     // check reward sum
-    auto const cbValues = tx.GetValuesOut();
+    const auto cbValues = tx.GetValuesOut();
     if (cbValues.size() != 1 || cbValues.begin()->first != DCT_ID{0})
         return Res::ErrDbg("bad-ar-wrong-tokens", "anchor reward should be paid in DFI only");
 
-    auto const anchorReward = mnview.GetCommunityBalance(CommunityAccountType::AnchorReward);
+    const auto anchorReward = mnview.GetCommunityBalance(CommunityAccountType::AnchorReward);
     if (cbValues.begin()->second != anchorReward) {
-        return Res::ErrDbg("bad-ar-amount", "anchor pays wrong amount (actual=%d vs expected=%d)",
-                           cbValues.begin()->second, anchorReward);
+        return Res::ErrDbg("bad-ar-amount",
+                           "anchor pays wrong amount (actual=%d vs expected=%d)",
+                           cbValues.begin()->second,
+                           anchorReward);
     }
 
-    CTxDestination destination = finMsg.rewardKeyType == 1 ? CTxDestination(PKHash(finMsg.rewardKeyID)) : CTxDestination(WitnessV0KeyHash(finMsg.rewardKeyID));
+    CTxDestination destination = finMsg.rewardKeyType == 1 ? CTxDestination(PKHash(finMsg.rewardKeyID))
+                                                           : CTxDestination(WitnessV0KeyHash(finMsg.rewardKeyID));
     if (tx.vout[1].scriptPubKey != GetScriptForDestination(destination)) {
         return Res::ErrDbg("bad-ar-dest", "anchor pay destination is incorrect");
     }
 
-    LogPrint(BCLog::ACCOUNTCHANGE, "AccountChange: txid=%s fund=%s change=%s\n", tx.GetHash().ToString(), GetCommunityAccountName(CommunityAccountType::AnchorReward), (CBalances{{{{0}, -mnview.GetCommunityBalance(CommunityAccountType::AnchorReward)}}}.ToString()));
-    mnview.SetCommunityBalance(CommunityAccountType::AnchorReward, 0); // just reset
+    LogPrint(BCLog::ACCOUNTCHANGE,
+             "AccountChange: txid=%s fund=%s change=%s\n",
+             tx.GetHash().ToString(),
+             GetCommunityAccountName(CommunityAccountType::AnchorReward),
+             (CBalances{{{{0}, -mnview.GetCommunityBalance(CommunityAccountType::AnchorReward)}}}.ToString()));
+    mnview.SetCommunityBalance(CommunityAccountType::AnchorReward, 0);  // just reset
     mnview.AddRewardForAnchor(finMsg.btcTxHash, tx.GetHash());
 
     // Store reward data for RPC info
     mnview.AddAnchorConfirmData(CAnchorConfirmDataPlus{finMsg});
 
-    return { finMsg.btcTxHash, Res::Ok() };
+    return {finMsg.btcTxHash, Res::Ok()};
 }
 
-bool IsMempooledCustomTxCreate(const CTxMemPool & pool, const uint256 & txid)
-{
+bool IsMempooledCustomTxCreate(const CTxMemPool &pool, const uint256 &txid) {
     CTransactionRef ptx = pool.get(txid);
     if (ptx) {
         std::vector<unsigned char> dummy;
@@ -4698,16 +4933,14 @@ bool IsMempooledCustomTxCreate(const CTxMemPool & pool, const uint256 & txid)
     return false;
 }
 
-std::vector<DCT_ID> CPoolSwap::CalculateSwaps(CCustomCSView& view, bool testOnly) {
-
+std::vector<DCT_ID> CPoolSwap::CalculateSwaps(CCustomCSView &view, bool testOnly) {
     std::vector<std::vector<DCT_ID>> poolPaths = CalculatePoolPaths(view);
 
     // Record best pair
     std::pair<std::vector<DCT_ID>, CAmount> bestPair{{}, -1};
 
     // Loop through all common pairs
-    for (const auto& path : poolPaths) {
-
+    for (const auto &path : poolPaths) {
         // Test on copy of view
         CCustomCSView dummy(view);
 
@@ -4731,32 +4964,33 @@ std::vector<DCT_ID> CPoolSwap::CalculateSwaps(CCustomCSView& view, bool testOnly
     return bestPair.first;
 }
 
-std::vector<std::vector<DCT_ID>> CPoolSwap::CalculatePoolPaths(CCustomCSView& view) {
-
+std::vector<std::vector<DCT_ID>> CPoolSwap::CalculatePoolPaths(CCustomCSView &view) {
     std::vector<std::vector<DCT_ID>> poolPaths;
 
     // For tokens to be traded get all pairs and pool IDs
     std::multimap<uint32_t, DCT_ID> fromPoolsID, toPoolsID;
-    view.ForEachPoolPair([&](DCT_ID const & id, const CPoolPair& pool) {
-        if ((obj.idTokenFrom == pool.idTokenA && obj.idTokenTo == pool.idTokenB)
-        || (obj.idTokenTo == pool.idTokenA && obj.idTokenFrom == pool.idTokenB)) {
-            // Push poolId when direct path
-            poolPaths.push_back({{id}});
-        }
+    view.ForEachPoolPair(
+        [&](DCT_ID const &id, const CPoolPair &pool) {
+            if ((obj.idTokenFrom == pool.idTokenA && obj.idTokenTo == pool.idTokenB) ||
+                (obj.idTokenTo == pool.idTokenA && obj.idTokenFrom == pool.idTokenB)) {
+                // Push poolId when direct path
+                poolPaths.push_back({{id}});
+            }
 
-        if (pool.idTokenA == obj.idTokenFrom) {
-            fromPoolsID.emplace(pool.idTokenB.v, id);
-        } else if (pool.idTokenB == obj.idTokenFrom) {
-            fromPoolsID.emplace(pool.idTokenA.v, id);
-        }
+            if (pool.idTokenA == obj.idTokenFrom) {
+                fromPoolsID.emplace(pool.idTokenB.v, id);
+            } else if (pool.idTokenB == obj.idTokenFrom) {
+                fromPoolsID.emplace(pool.idTokenA.v, id);
+            }
 
-        if (pool.idTokenA == obj.idTokenTo) {
-            toPoolsID.emplace(pool.idTokenB.v, id);
-        } else if (pool.idTokenB == obj.idTokenTo) {
-            toPoolsID.emplace(pool.idTokenA.v, id);
-        }
-        return true;
-    }, {0});
+            if (pool.idTokenA == obj.idTokenTo) {
+                toPoolsID.emplace(pool.idTokenB.v, id);
+            } else if (pool.idTokenB == obj.idTokenTo) {
+                toPoolsID.emplace(pool.idTokenA.v, id);
+            }
+            return true;
+        },
+        {0});
 
     if (fromPoolsID.empty() || toPoolsID.empty()) {
         return {};
@@ -4764,18 +4998,18 @@ std::vector<std::vector<DCT_ID>> CPoolSwap::CalculatePoolPaths(CCustomCSView& vi
 
     // Find intersection on key
     std::map<uint32_t, DCT_ID> commonPairs;
-    set_intersection(fromPoolsID.begin(), fromPoolsID.end(), toPoolsID.begin(), toPoolsID.end(),
+    set_intersection(fromPoolsID.begin(),
+                     fromPoolsID.end(),
+                     toPoolsID.begin(),
+                     toPoolsID.end(),
                      std::inserter(commonPairs, commonPairs.begin()),
-                     [](std::pair<uint32_t, DCT_ID> a, std::pair<uint32_t, DCT_ID> b) {
-                         return a.first < b.first;
-                     });
+                     [](std::pair<uint32_t, DCT_ID> a, std::pair<uint32_t, DCT_ID> b) { return a.first < b.first; });
 
     // Loop through all common pairs and record direct pool to pool swaps
-    for (const auto& item : commonPairs) {
+    for (const auto &item : commonPairs) {
         // Loop through all source/intermediate pools matching common pairs
         const auto poolFromIDs = fromPoolsID.equal_range(item.first);
         for (auto fromID = poolFromIDs.first; fromID != poolFromIDs.second; ++fromID) {
-
             // Loop through all destination pools matching common pairs
             const auto poolToIDs = toPoolsID.equal_range(item.first);
             for (auto toID = poolToIDs.first; toID != poolToIDs.second; ++toID) {
@@ -4786,23 +5020,24 @@ std::vector<std::vector<DCT_ID>> CPoolSwap::CalculatePoolPaths(CCustomCSView& vi
     }
 
     // Look for pools that bridges token. Might be in addition to common token pairs paths.
-    view.ForEachPoolPair([&](DCT_ID const & id, const CPoolPair& pool) {
-
-        // Loop through from pool multimap on unique keys only
-        for (auto fromIt = fromPoolsID.begin(); fromIt != fromPoolsID.end(); fromIt = fromPoolsID.equal_range(fromIt->first).second) {
-
-            // Loop through to pool multimap on unique keys only
-            for (auto toIt = toPoolsID.begin(); toIt != toPoolsID.end(); toIt = toPoolsID.equal_range(toIt->first).second) {
-
-                // If a pool pairs matches from pair and to pair add it to the pool paths
-                if ((fromIt->first == pool.idTokenA.v && toIt->first == pool.idTokenB.v) ||
-                    (fromIt->first == pool.idTokenB.v && toIt->first == pool.idTokenA.v)) {
-                    poolPaths.push_back({fromIt->second, id, toIt->second});
+    view.ForEachPoolPair(
+        [&](DCT_ID const &id, const CPoolPair &pool) {
+            // Loop through from pool multimap on unique keys only
+            for (auto fromIt = fromPoolsID.begin(); fromIt != fromPoolsID.end();
+                 fromIt      = fromPoolsID.equal_range(fromIt->first).second) {
+                // Loop through to pool multimap on unique keys only
+                for (auto toIt = toPoolsID.begin(); toIt != toPoolsID.end();
+                     toIt      = toPoolsID.equal_range(toIt->first).second) {
+                    // If a pool pairs matches from pair and to pair add it to the pool paths
+                    if ((fromIt->first == pool.idTokenA.v && toIt->first == pool.idTokenB.v) ||
+                        (fromIt->first == pool.idTokenB.v && toIt->first == pool.idTokenA.v)) {
+                        poolPaths.push_back({fromIt->second, id, toIt->second});
+                    }
                 }
             }
-        }
-        return true;
-    }, {0});
+            return true;
+        },
+        {0});
 
     // return pool paths
     return poolPaths;
@@ -4811,8 +5046,7 @@ std::vector<std::vector<DCT_ID>> CPoolSwap::CalculatePoolPaths(CCustomCSView& vi
 // Note: `testOnly` doesn't update views, and as such can result in a previous price calculations
 // for a pool, if used multiple times (or duplicated pool IDs) with the same view.
 // testOnly is only meant for one-off tests per well defined view.
-Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, bool testOnly) {
-
+Res CPoolSwap::ExecuteSwap(CCustomCSView &view, std::vector<DCT_ID> poolIDs, bool testOnly) {
     Res poolResult = Res::Ok();
 
     // No composite swap allowed before Fort Canning
@@ -4824,13 +5058,15 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
         return Res::Err("Input amount should be positive");
     }
 
-    if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight) && poolIDs.size() > MAX_POOL_SWAPS) {
-        return Res::Err(strprintf("Too many pool IDs provided, max %d allowed, %d provided", MAX_POOL_SWAPS, poolIDs.size()));
+    if (height >= static_cast<uint32_t>(Params().GetConsensus().FortCanningHillHeight) &&
+        poolIDs.size() > MAX_POOL_SWAPS) {
+        return Res::Err(
+            strprintf("Too many pool IDs provided, max %d allowed, %d provided", MAX_POOL_SWAPS, poolIDs.size()));
     }
 
     // Single swap if no pool IDs provided
     auto poolPrice = POOLPRICE_MAX;
-    std::optional<std::pair<DCT_ID, CPoolPair> > poolPair;
+    std::optional<std::pair<DCT_ID, CPoolPair>> poolPair;
     if (poolIDs.empty()) {
         poolPair = view.GetPoolPair(obj.idTokenFrom, obj.idTokenTo);
         if (!poolPair) {
@@ -4861,7 +5097,6 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
     CTokenAmount swapAmountResult{obj.idTokenFrom, obj.amountFrom};
 
     for (size_t i{0}; i < poolIDs.size(); ++i) {
-
         // Also used to generate pool specific error messages for RPC users
         currentID = poolIDs[i];
 
@@ -4869,8 +5104,7 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
         std::optional<CPoolPair> pool;
         if (poolPair) {
             pool = poolPair->second;
-        }
-        else // Or get pools from IDs provided for composite swap
+        } else  // Or get pools from IDs provided for composite swap
         {
             pool = view.GetPoolPair(currentID);
             if (!pool) {
@@ -4898,97 +5132,104 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
 
         CDataStructureV0 dirAKey{AttributeTypes::Poolpairs, currentID.v, PoolKeys::TokenAFeeDir};
         CDataStructureV0 dirBKey{AttributeTypes::Poolpairs, currentID.v, PoolKeys::TokenBFeeDir};
-        const auto dirA = attributes->GetValue(dirAKey, CFeeDir{FeeDirValues::Both});
-        const auto dirB = attributes->GetValue(dirBKey, CFeeDir{FeeDirValues::Both});
+        const auto dirA          = attributes->GetValue(dirAKey, CFeeDir{FeeDirValues::Both});
+        const auto dirB          = attributes->GetValue(dirBKey, CFeeDir{FeeDirValues::Both});
         const auto asymmetricFee = std::make_pair(dirA, dirB);
 
         auto dexfeeInPct = view.GetDexFeeInPct(currentID, swapAmount.nTokenId);
-        auto& balances = dexBalances[currentID];
-        auto forward = swapAmount.nTokenId == pool->idTokenA;
+        auto &balances   = dexBalances[currentID];
+        auto forward     = swapAmount.nTokenId == pool->idTokenA;
 
-        auto& totalTokenA = forward ? balances.totalTokenA : balances.totalTokenB;
-        auto& totalTokenB = forward ? balances.totalTokenB : balances.totalTokenA;
+        auto &totalTokenA = forward ? balances.totalTokenA : balances.totalTokenB;
+        auto &totalTokenB = forward ? balances.totalTokenB : balances.totalTokenA;
 
-        const auto& reserveAmount = forward ? pool->reserveA : pool->reserveB;
-        const auto& blockCommission = forward ? pool->blockCommissionA : pool->blockCommissionB;
+        const auto &reserveAmount   = forward ? pool->reserveA : pool->reserveB;
+        const auto &blockCommission = forward ? pool->blockCommissionA : pool->blockCommissionB;
 
-        const auto initReserveAmount = reserveAmount;
+        const auto initReserveAmount   = reserveAmount;
         const auto initBlockCommission = blockCommission;
 
         // Perform swap
-        poolResult = pool->Swap(swapAmount, dexfeeInPct, poolPrice, asymmetricFee, [&] (const CTokenAmount& dexfeeInAmount, const CTokenAmount& tokenAmount) {
-            // Save swap amount for next loop
-            swapAmountResult = tokenAmount;
-
-            CTokenAmount dexfeeOutAmount{tokenAmount.nTokenId, 0};
-
-            auto dexfeeOutPct = view.GetDexFeeOutPct(currentID, tokenAmount.nTokenId);
-            if (dexfeeOutPct > 0 && poolOutFee(swapAmount.nTokenId == pool->idTokenA, asymmetricFee)) {
-                dexfeeOutAmount.nValue = MultiplyAmounts(tokenAmount.nValue, dexfeeOutPct);
-                swapAmountResult.nValue -= dexfeeOutAmount.nValue;
-            }
-
-            // If we're just testing, don't do any balance transfers.
-            // Just go over pools and return result. The only way this can
-            // cause inaccurate result is if we go over the same path twice,
-            // which shouldn't happen in the first place.
-            if (testOnly)
-                return Res::Ok();
-
-            auto res = view.SetPoolPair(currentID, height, *pool);
-            if (!res) {
-                return res;
-            }
+        poolResult = pool->Swap(
+            swapAmount,
+            dexfeeInPct,
+            poolPrice,
+            asymmetricFee,
+            [&](const CTokenAmount &dexfeeInAmount, const CTokenAmount &tokenAmount) {
+                // Save swap amount for next loop
+                swapAmountResult = tokenAmount;
+
+                CTokenAmount dexfeeOutAmount{tokenAmount.nTokenId, 0};
+
+                auto dexfeeOutPct = view.GetDexFeeOutPct(currentID, tokenAmount.nTokenId);
+                if (dexfeeOutPct > 0 && poolOutFee(swapAmount.nTokenId == pool->idTokenA, asymmetricFee)) {
+                    dexfeeOutAmount.nValue = MultiplyAmounts(tokenAmount.nValue, dexfeeOutPct);
+                    swapAmountResult.nValue -= dexfeeOutAmount.nValue;
+                }
 
-            CCustomCSView intermediateView(view);
-            // hide interemidiate swaps
-            auto& subView = i == 0 ? view : intermediateView;
-            res = subView.SubBalance(obj.from, swapAmount);
-            if (!res) {
-                return res;
-            }
-            intermediateView.Flush();
+                // If we're just testing, don't do any balance transfers.
+                // Just go over pools and return result. The only way this can
+                // cause inaccurate result is if we go over the same path twice,
+                // which shouldn't happen in the first place.
+                if (testOnly)
+                    return Res::Ok();
 
-            auto& addView = lastSwap ? view : intermediateView;
-            if (height >= static_cast<uint32_t>(Params().GetConsensus().GrandCentralHeight)) {
-                res = addView.AddBalance(lastSwap ? (obj.to.empty() ? obj.from : obj.to) : obj.from, swapAmountResult);
-            } else {
-                res = addView.AddBalance(lastSwap ? obj.to : obj.from, swapAmountResult);
-            }
-            if (!res) {
-                return res;
-            }
-            intermediateView.Flush();
-
-            const auto token = view.GetToken("DUSD");
+                auto res = view.SetPoolPair(currentID, height, *pool);
+                if (!res) {
+                    return res;
+                }
 
-            // burn the dex in amount
-            if (dexfeeInAmount.nValue > 0) {
-                res = view.AddBalance(Params().GetConsensus().burnAddress, dexfeeInAmount);
+                CCustomCSView intermediateView(view);
+                // hide interemidiate swaps
+                auto &subView = i == 0 ? view : intermediateView;
+                res           = subView.SubBalance(obj.from, swapAmount);
                 if (!res) {
                     return res;
                 }
-                totalTokenA.feeburn += dexfeeInAmount.nValue;
-            }
+                intermediateView.Flush();
 
-            // burn the dex out amount
-            if (dexfeeOutAmount.nValue > 0) {
-                res = view.AddBalance(Params().GetConsensus().burnAddress, dexfeeOutAmount);
+                auto &addView = lastSwap ? view : intermediateView;
+                if (height >= static_cast<uint32_t>(Params().GetConsensus().GrandCentralHeight)) {
+                    res = addView.AddBalance(lastSwap ? (obj.to.empty() ? obj.from : obj.to) : obj.from,
+                                             swapAmountResult);
+                } else {
+                    res = addView.AddBalance(lastSwap ? obj.to : obj.from, swapAmountResult);
+                }
                 if (!res) {
                     return res;
                 }
-                totalTokenB.feeburn += dexfeeOutAmount.nValue;
-            }
+                intermediateView.Flush();
 
-            totalTokenA.swaps += (reserveAmount - initReserveAmount);
-            totalTokenA.commissions += (blockCommission - initBlockCommission);
+                const auto token = view.GetToken("DUSD");
 
-            if (lastSwap && obj.to == Params().GetConsensus().burnAddress) {
-                totalTokenB.feeburn += swapAmountResult.nValue;
-            }
+                // burn the dex in amount
+                if (dexfeeInAmount.nValue > 0) {
+                    res = view.AddBalance(Params().GetConsensus().burnAddress, dexfeeInAmount);
+                    if (!res) {
+                        return res;
+                    }
+                    totalTokenA.feeburn += dexfeeInAmount.nValue;
+                }
+
+                // burn the dex out amount
+                if (dexfeeOutAmount.nValue > 0) {
+                    res = view.AddBalance(Params().GetConsensus().burnAddress, dexfeeOutAmount);
+                    if (!res) {
+                        return res;
+                    }
+                    totalTokenB.feeburn += dexfeeOutAmount.nValue;
+                }
+
+                totalTokenA.swaps += (reserveAmount - initReserveAmount);
+                totalTokenA.commissions += (blockCommission - initBlockCommission);
+
+                if (lastSwap && obj.to == Params().GetConsensus().burnAddress) {
+                    totalTokenB.feeburn += swapAmountResult.nValue;
+                }
 
-           return res;
-        }, static_cast<int>(height));
+                return res;
+            },
+            static_cast<int>(height));
 
         if (!poolResult) {
             return poolResult;
@@ -5021,19 +5262,24 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, boo
     return poolResult;
 }
 
-Res  SwapToDFIorDUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CScript const & from, CScript const & to, uint32_t height, bool forceLoanSwap)
-{
+Res SwapToDFIorDUSD(CCustomCSView &mnview,
+                    DCT_ID tokenId,
+                    CAmount amount,
+                    const CScript &from,
+                    const CScript &to,
+                    uint32_t height,
+                    bool forceLoanSwap) {
     CPoolSwapMessage obj;
 
-    obj.from = from;
-    obj.to = to;
+    obj.from        = from;
+    obj.to          = to;
     obj.idTokenFrom = tokenId;
-    obj.idTokenTo = DCT_ID{0};
-    obj.amountFrom = amount;
-    obj.maxPrice = POOLPRICE_MAX;
+    obj.idTokenTo   = DCT_ID{0};
+    obj.amountFrom  = amount;
+    obj.maxPrice    = POOLPRICE_MAX;
 
     auto poolSwap = CPoolSwap(obj, height);
-    auto token = mnview.GetToken(tokenId);
+    auto token    = mnview.GetToken(tokenId);
     if (!token)
         return Res::Err("Cannot find token with id %s!", tokenId.ToString());
 
@@ -5050,8 +5296,7 @@ Res  SwapToDFIorDUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CSc
 
     // Direct swap from DUSD to DFI as defined in the CPoolSwapMessage.
     if (tokenId == dUsdToken->first) {
-        if (to == Params().GetConsensus().burnAddress && !forceLoanSwap && attributes->GetValue(directBurnKey, false))
-        {
+        if (to == Params().GetConsensus().burnAddress && !forceLoanSwap && attributes->GetValue(directBurnKey, false)) {
             // direct burn dUSD
             CTokenAmount dUSD{dUsdToken->first, amount};
 
@@ -5060,8 +5305,7 @@ Res  SwapToDFIorDUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CSc
                 return res;
 
             return mnview.AddBalance(to, dUSD);
-        }
-        else
+        } else
             // swap dUSD -> DFI and burn DFI
             return poolSwap.ExecuteSwap(mnview, {});
     }
@@ -5070,26 +5314,23 @@ Res  SwapToDFIorDUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CSc
     if (!pooldUSDDFI)
         return Res::Err("Cannot find pool pair DUSD-DFI!");
 
-    auto poolTokendUSD = mnview.GetPoolPair(tokenId,dUsdToken->first);
+    auto poolTokendUSD = mnview.GetPoolPair(tokenId, dUsdToken->first);
     if (!poolTokendUSD)
         return Res::Err("Cannot find pool pair %s-DUSD!", token->symbol);
 
-    if (to == Params().GetConsensus().burnAddress && !forceLoanSwap && attributes->GetValue(directBurnKey, false))
-    {
+    if (to == Params().GetConsensus().burnAddress && !forceLoanSwap && attributes->GetValue(directBurnKey, false)) {
         obj.idTokenTo = dUsdToken->first;
 
         // swap tokenID -> dUSD and burn dUSD
         return poolSwap.ExecuteSwap(mnview, {});
-    }
-    else
+    } else
         // swap tokenID -> dUSD -> DFI and burn DFI
         return poolSwap.ExecuteSwap(mnview, {poolTokendUSD->first, pooldUSDDFI->first});
 }
 
-bool IsVaultPriceValid(CCustomCSView& mnview, const CVaultId& vaultId, uint32_t height)
-{
+bool IsVaultPriceValid(CCustomCSView &mnview, const CVaultId &vaultId, uint32_t height) {
     if (auto collaterals = mnview.GetVaultCollaterals(vaultId))
-        for (const auto& collateral : collaterals->balances) {
+        for (const auto &collateral : collaterals->balances) {
             if (auto collateralToken = mnview.HasLoanCollateralToken({collateral.first, height})) {
                 if (auto fixedIntervalPrice = mnview.GetFixedIntervalPrice(collateralToken->fixedIntervalPriceId)) {
                     if (!fixedIntervalPrice.val->isLive(mnview.GetPriceDeviation())) {
@@ -5106,7 +5347,7 @@ bool IsVaultPriceValid(CCustomCSView& mnview, const CVaultId& vaultId, uint32_t
         }
 
     if (auto loans = mnview.GetLoanTokens(vaultId))
-        for (const auto& loan : loans->balances) {
+        for (const auto &loan : loans->balances) {
             if (auto loanToken = mnview.GetLoanTokenByID(loan.first)) {
                 if (auto fixedIntervalPrice = mnview.GetFixedIntervalPrice(loanToken->fixedIntervalPriceId)) {
                     if (!fixedIntervalPrice.val->isLive(mnview.GetPriceDeviation())) {
@@ -5124,20 +5365,23 @@ bool IsVaultPriceValid(CCustomCSView& mnview, const CVaultId& vaultId, uint32_t
     return true;
 }
 
-bool IsPaybackWithCollateral(CCustomCSView& view, const std::map<DCT_ID, CBalances>& loans) {
+bool IsPaybackWithCollateral(CCustomCSView &view, const std::map<DCT_ID, CBalances> &loans) {
     auto tokenDUSD = view.GetToken("DUSD");
     if (!tokenDUSD)
         return false;
 
-    if (loans.size() == 1
-    && loans.count(tokenDUSD->first)
-    && loans.at(tokenDUSD->first) == CBalances{{{tokenDUSD->first, 999999999999999999LL}}}) {
+    if (loans.size() == 1 && loans.count(tokenDUSD->first) &&
+        loans.at(tokenDUSD->first) == CBalances{{{tokenDUSD->first, 999999999999999999LL}}}) {
         return true;
     }
     return false;
 }
 
-Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CVaultId& vaultId, uint32_t height, uint64_t time) {
+Res PaybackWithCollateral(CCustomCSView &view,
+                          const CVaultData &vault,
+                          const CVaultId &vaultId,
+                          uint32_t height,
+                          uint64_t time) {
     const auto attributes = view.GetAttributes();
     if (!attributes)
         return Res::Err("Attributes unavailable");
@@ -5157,7 +5401,7 @@ Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CV
     if (!collateralAmounts->balances.count(dUsdToken->first)) {
         return Res::Err("Vault does not have any DUSD collaterals");
     }
-    const auto& collateralDUSD = collateralAmounts->balances.at(dUsdToken->first);
+    const auto &collateralDUSD = collateralAmounts->balances.at(dUsdToken->first);
 
     const auto loanAmounts = view.GetLoanTokens(vaultId);
     if (!loanAmounts) {
@@ -5166,7 +5410,7 @@ Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CV
     if (!loanAmounts->balances.count(dUsdToken->first)) {
         return Res::Err("Vault does not have any DUSD loans");
     }
-    const auto& loanDUSD = loanAmounts->balances.at(dUsdToken->first);
+    const auto &loanDUSD = loanAmounts->balances.at(dUsdToken->first);
 
     const auto rate = view.GetInterestRate(vaultId, dUsdToken->first, height);
     if (!rate)
@@ -5183,51 +5427,54 @@ Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CV
         subCollateralAmount = collateralDUSD;
 
         res = view.SubVaultCollateral(vaultId, {dUsdToken->first, subCollateralAmount});
-        if (!res) return res;
+        if (!res)
+            return res;
 
         res = view.DecreaseInterest(height, vaultId, vault.schemeId, dUsdToken->first, 0, subCollateralAmount);
-        if (!res) return res;
+        if (!res)
+            return res;
 
         burnAmount = subCollateralAmount;
     } else {
         // Postive interest: Loan + interest > collateral.
         // Negative interest: Loan - abs(interest) > collateral.
         if (loanDUSD + subInterest > collateralDUSD) {
-            subLoanAmount = collateralDUSD - subInterest;
+            subLoanAmount       = collateralDUSD - subInterest;
             subCollateralAmount = collateralDUSD;
         } else {
             // Common case: Collateral > loans.
-            subLoanAmount = loanDUSD;
+            subLoanAmount       = loanDUSD;
             subCollateralAmount = loanDUSD + subInterest;
         }
 
         if (subLoanAmount > 0) {
             TrackDUSDSub(view, {dUsdToken->first, subLoanAmount});
             res = view.SubLoanToken(vaultId, {dUsdToken->first, subLoanAmount});
-            if (!res) return res;
+            if (!res)
+                return res;
         }
 
         if (subCollateralAmount > 0) {
-            res = view.SubVaultCollateral(vaultId, {dUsdToken->first,subCollateralAmount});
-            if (!res) return res;
+            res = view.SubVaultCollateral(vaultId, {dUsdToken->first, subCollateralAmount});
+            if (!res)
+                return res;
         }
 
         view.ResetInterest(height, vaultId, vault.schemeId, dUsdToken->first);
         burnAmount = subInterest;
     }
 
-
-    if (burnAmount > 0)
-    {
+    if (burnAmount > 0) {
         res = view.AddBalance(Params().GetConsensus().burnAddress, {dUsdToken->first, burnAmount});
-        if (!res) return res;
+        if (!res)
+            return res;
     } else {
         TrackNegativeInterest(view, {dUsdToken->first, std::abs(burnAmount)});
     }
 
     // Guard against liquidation
     const auto collaterals = view.GetVaultCollaterals(vaultId);
-    const auto loans = view.GetLoanTokens(vaultId);
+    const auto loans       = view.GetLoanTokens(vaultId);
     if (!collaterals && loans)
         return Res::Err("Vault cannot have loans without collaterals");
 
@@ -5236,25 +5483,27 @@ Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CV
         return std::move(collateralsLoans);
 
     // The check is required to do a ratio check safe guard, or the vault of ratio is unreliable.
-    // This can later be removed, if all edge cases of price deviations and max collateral factor for DUSD (1.5 currently)
-    // can be tested for economical stability. Taking the safer approach for now.
+    // This can later be removed, if all edge cases of price deviations and max collateral factor for DUSD (1.5
+    // currently) can be tested for economical stability. Taking the safer approach for now.
     if (!IsVaultPriceValid(view, vaultId, height))
         return Res::Err("Cannot payback vault with non-DUSD assets while any of the asset's price is invalid");
 
     const auto scheme = view.GetLoanScheme(vault.schemeId);
     if (collateralsLoans.val->ratio() < scheme->ratio)
-        return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d", collateralsLoans.val->ratio(), scheme->ratio);
+        return Res::Err("Vault does not have enough collateralization ratio defined by loan scheme - %d < %d",
+                        collateralsLoans.val->ratio(),
+                        scheme->ratio);
 
     if (subCollateralAmount > 0) {
         res = view.SubMintedTokens(dUsdToken->first, subCollateralAmount);
-        if (!res) return res;
+        if (!res)
+            return res;
     }
 
     return Res::Ok();
 }
 
-Res storeGovVars(const CGovernanceHeightMessage& obj, CCustomCSView& view) {
-
+Res storeGovVars(const CGovernanceHeightMessage &obj, CCustomCSView &view) {
     // Retrieve any stored GovVariables at startHeight
     auto storedGovVars = view.GetStoredVariables(obj.startHeight);
 
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index f4d1c2fe90..4e12ee24bd 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -6,10 +6,10 @@
 #define DEFI_MASTERNODES_MN_CHECKS_H
 
 #include <consensus/params.h>
-#include <masternodes/masternodes.h>
 #include <consensus/tx_check.h>
-#include <vector>
+#include <masternodes/masternodes.h>
 #include <cstring>
+#include <vector>
 
 #include <variant>
 
@@ -20,46 +20,45 @@ class CCoinsViewCache;
 
 class CCustomCSView;
 class CAccountsHistoryView;
-class CCustomTxVisitor
-{
-    protected:
-        uint32_t height;
-        CCustomCSView& mnview;
-        const CTransaction& tx;
-        const CCoinsViewCache& coins;
-        const Consensus::Params& consensus;
-
-    public:
-        CCustomTxVisitor(const CTransaction& tx,
-            uint32_t height,
-            const CCoinsViewCache& coins,
-            CCustomCSView& mnview,
-            const Consensus::Params& consensus);
-
-    protected:
-        bool HasAuth(const CScript& auth) const;
-        Res HasCollateralAuth(const uint256& collateralTx) const;
-        Res HasFoundationAuth() const;
-        Res CheckMasternodeCreationTx() const;
-        Res CheckProposalTx(const CCreatePropMessage& msg) const;
-        Res CheckTokenCreationTx() const;
-        Res CheckCustomTx() const;
-        Res TransferTokenBalance(DCT_ID id, CAmount amount, CScript const& from, CScript const& to) const;
-        DCT_ID FindTokenByPartialSymbolName(const std::string& symbol) const;
-        CPoolPair GetBTCDFIPoolPair() const;
-        CAmount CalculateTakerFee(CAmount amount) const;
-        ResVal<CScript> MintableToken(DCT_ID id, const CTokenImplementation& token, bool anybodyCanMint) const;
-        Res EraseEmptyBalances(TAmounts& balances) const;
-        Res SetShares(const CScript& owner, const TAmounts& balances) const;
-        Res DelShares(const CScript& owner, const TAmounts& balances) const;
-        void CalculateOwnerRewards(const CScript& owner) const;
-        Res SubBalanceDelShares(const CScript& owner, const CBalances& balance) const;
-        Res AddBalanceSetShares(const CScript& owner, const CBalances& balance) const;
-        Res AddBalancesSetShares(const CAccounts& accounts) const;
-        Res SubBalancesDelShares(const CAccounts& accounts) const;
-        Res NormalizeTokenCurrencyPair(std::set<CTokenCurrencyPair>& tokenCurrency) const;
-        bool IsTokensMigratedToGovVar() const;
-        Res IsOnChainGovernanceEnabled() const;
+class CCustomTxVisitor {
+protected:
+    uint32_t height;
+    CCustomCSView &mnview;
+    const CTransaction &tx;
+    const CCoinsViewCache &coins;
+    const Consensus::Params &consensus;
+
+public:
+    CCustomTxVisitor(const CTransaction &tx,
+                     uint32_t height,
+                     const CCoinsViewCache &coins,
+                     CCustomCSView &mnview,
+                     const Consensus::Params &consensus);
+
+protected:
+    bool HasAuth(const CScript &auth) const;
+    Res HasCollateralAuth(const uint256 &collateralTx) const;
+    Res HasFoundationAuth() const;
+    Res CheckMasternodeCreationTx() const;
+    Res CheckProposalTx(const CCreatePropMessage &msg) const;
+    Res CheckTokenCreationTx() const;
+    Res CheckCustomTx() const;
+    Res TransferTokenBalance(DCT_ID id, CAmount amount, const CScript &from, const CScript &to) const;
+    DCT_ID FindTokenByPartialSymbolName(const std::string &symbol) const;
+    CPoolPair GetBTCDFIPoolPair() const;
+    CAmount CalculateTakerFee(CAmount amount) const;
+    ResVal<CScript> MintableToken(DCT_ID id, const CTokenImplementation &token, bool anybodyCanMint) const;
+    Res EraseEmptyBalances(TAmounts &balances) const;
+    Res SetShares(const CScript &owner, const TAmounts &balances) const;
+    Res DelShares(const CScript &owner, const TAmounts &balances) const;
+    void CalculateOwnerRewards(const CScript &owner) const;
+    Res SubBalanceDelShares(const CScript &owner, const CBalances &balance) const;
+    Res AddBalanceSetShares(const CScript &owner, const CBalances &balance) const;
+    Res AddBalancesSetShares(const CAccounts &accounts) const;
+    Res SubBalancesDelShares(const CAccounts &accounts) const;
+    Res NormalizeTokenCurrencyPair(std::set<CTokenCurrencyPair> &tokenCurrency) const;
+    bool IsTokensMigratedToGovVar() const;
+    Res IsOnChainGovernanceEnabled() const;
 };
 class CVaultHistoryView;
 class CHistoryWriters;
@@ -68,58 +67,57 @@ constexpr uint8_t MAX_POOL_SWAPS = 3;
 
 enum CustomTxErrCodes : uint32_t {
     NotSpecified = 0,
-//    NotCustomTx  = 1,
+    //    NotCustomTx  = 1,
     NotEnoughBalance = 1024,
-    Fatal = uint32_t(1) << 31 // not allowed to fail
+    Fatal            = uint32_t(1) << 31  // not allowed to fail
 };
 
-enum class CustomTxType : uint8_t
-{
-    None = 0,
-    Reject = 1, // Invalid TX type. Returned by GuessCustomTxType on invalid custom TX.
+enum class CustomTxType : uint8_t {
+    None   = 0,
+    Reject = 1,  // Invalid TX type. Returned by GuessCustomTxType on invalid custom TX.
 
     // masternodes:
-    CreateMasternode       = 'C',
-    ResignMasternode       = 'R',
-    UpdateMasternode       = 'm',
+    CreateMasternode = 'C',
+    ResignMasternode = 'R',
+    UpdateMasternode = 'm',
     // custom tokens:
-    CreateToken           = 'T',
-    MintToken             = 'M',
-    BurnToken             = 'F',
-    UpdateToken           = 'N', // previous type, only DAT flag triggers
-    UpdateTokenAny        = 'n', // new type of token's update with any flags/fields possible
-    //poolpair
-    CreatePoolPair         = 'p',
-    UpdatePoolPair         = 'u',
-    PoolSwap               = 's',
-    PoolSwapV2             = 'i',
-    AddPoolLiquidity       = 'l',
-    RemovePoolLiquidity    = 'r',
+    CreateToken    = 'T',
+    MintToken      = 'M',
+    BurnToken      = 'F',
+    UpdateToken    = 'N',  // previous type, only DAT flag triggers
+    UpdateTokenAny = 'n',  // new type of token's update with any flags/fields possible
+    // poolpair
+    CreatePoolPair      = 'p',
+    UpdatePoolPair      = 'u',
+    PoolSwap            = 's',
+    PoolSwapV2          = 'i',
+    AddPoolLiquidity    = 'l',
+    RemovePoolLiquidity = 'r',
     // accounts
-    UtxosToAccount         = 'U',
-    AccountToUtxos         = 'b',
-    AccountToAccount       = 'B',
-    AnyAccountsToAccounts  = 'a',
-    SmartContract          = 'K',
-    FutureSwap             = 'Q',
-    //set governance variable
-    SetGovVariable         = 'G',
-    SetGovVariableHeight   = 'j',
+    UtxosToAccount        = 'U',
+    AccountToUtxos        = 'b',
+    AccountToAccount      = 'B',
+    AnyAccountsToAccounts = 'a',
+    SmartContract         = 'K',
+    FutureSwap            = 'Q',
+    // set governance variable
+    SetGovVariable       = 'G',
+    SetGovVariableHeight = 'j',
     // Auto auth TX
-    AutoAuthPrep           = 'A',
+    AutoAuthPrep = 'A',
     // oracles
-    AppointOracle          = 'o',
-    RemoveOracleAppoint    = 'h',
-    UpdateOracleAppoint    = 't',
-    SetOracleData          = 'y',
+    AppointOracle       = 'o',
+    RemoveOracleAppoint = 'h',
+    UpdateOracleAppoint = 't',
+    SetOracleData       = 'y',
     // ICX
-    ICXCreateOrder         = '1',
-    ICXMakeOffer           = '2',
-    ICXSubmitDFCHTLC       = '3',
-    ICXSubmitEXTHTLC       = '4',
-    ICXClaimDFCHTLC        = '5',
-    ICXCloseOrder          = '6',
-    ICXCloseOffer          = '7',
+    ICXCreateOrder   = '1',
+    ICXMakeOffer     = '2',
+    ICXSubmitDFCHTLC = '3',
+    ICXSubmitEXTHTLC = '4',
+    ICXClaimDFCHTLC  = '5',
+    ICXCloseOrder    = '6',
+    ICXCloseOffer    = '7',
     // Loans
     SetLoanCollateralToken = 'c',
     SetLoanToken           = 'g',
@@ -138,20 +136,20 @@ enum class CustomTxType : uint8_t
     PaybackLoanV2          = 'k',
     AuctionBid             = 'I',
     // Marker TXs
-    FutureSwapExecution    = 'q',
-    FutureSwapRefund       = 'w',
-    TokenSplit             = 'P',
+    FutureSwapExecution = 'q',
+    FutureSwapRefund    = 'w',
+    TokenSplit          = 'P',
     // On-Chain-Gov
-    CreateCfp              = 'z',
-    Vote                   = 'O',  // NOTE: Check whether this overlapping with CreateOrder above is fine
-    CreateVoc              = 'E',  // NOTE: Check whether this overlapping with DestroyOrder above is fine
+    CreateCfp                 = 'z',
+    Vote                      = 'O',  // NOTE: Check whether this overlapping with CreateOrder above is fine
+    CreateVoc                 = 'E',  // NOTE: Check whether this overlapping with DestroyOrder above is fine
     ProposalFeeRedistribution = 'Y',
-    UnsetGovVariable       = 'Z',
+    UnsetGovVariable          = 'Z',
 };
 
 inline CustomTxType CustomTxCodeToType(uint8_t ch) {
     auto type = static_cast<CustomTxType>(ch);
-    switch(type) {
+    switch (type) {
         case CustomTxType::CreateMasternode:
         case CustomTxType::ResignMasternode:
         case CustomTxType::UpdateMasternode:
@@ -218,21 +216,21 @@ inline CustomTxType CustomTxCodeToType(uint8_t ch) {
 }
 
 std::string ToString(CustomTxType type);
-CustomTxType FromString(const std::string& str);
+CustomTxType FromString(const std::string &str);
 
 // it's disabled after Dakota height
 inline bool NotAllowedToFail(CustomTxType txType, int height) {
-    return (height < Params().GetConsensus().DakotaHeight
-        && (txType == CustomTxType::MintToken || txType == CustomTxType::AccountToUtxos));
+    return (height < Params().GetConsensus().DakotaHeight &&
+            (txType == CustomTxType::MintToken || txType == CustomTxType::AccountToUtxos));
 }
 
-template<typename Stream>
-inline void Serialize(Stream& s, CustomTxType txType) {
+template <typename Stream>
+inline void Serialize(Stream &s, CustomTxType txType) {
     Serialize(s, static_cast<unsigned char>(txType));
 }
 
-template<typename Stream>
-inline void Unserialize(Stream& s, CustomTxType & txType) {
+template <typename Stream>
+inline void Unserialize(Stream &s, CustomTxType &txType) {
     unsigned char ch;
     Unserialize(s, ch);
 
@@ -246,7 +244,7 @@ struct CCreateMasterNodeMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(operatorType);
         READWRITE(operatorAuthAddress);
 
@@ -262,7 +260,7 @@ struct CResignMasterNodeMessage : public uint256 {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(uint256, *this);
     }
 };
@@ -273,7 +271,7 @@ struct CUpdateMasterNodeMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(mnId);
         READWRITE(updates);
     }
@@ -284,7 +282,7 @@ struct CCreateTokenMessage : public CToken {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CToken, *this);
     }
 };
@@ -295,7 +293,7 @@ struct CUpdateTokenPreAMKMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(tokenTx);
         READWRITE(isDAT);
     }
@@ -307,7 +305,7 @@ struct CUpdateTokenMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(tokenTx);
         READWRITE(token);
     }
@@ -318,14 +316,13 @@ struct CMintTokensMessage : public CBalances {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CBalances, *this);
     }
 };
 
 struct CBurnTokensMessage {
-    enum BurnType : uint8_t
-    {
+    enum BurnType : uint8_t {
         TokenBurn = 0,
     };
 
@@ -336,7 +333,7 @@ struct CBurnTokensMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(amounts);
         READWRITE(from);
         READWRITE(static_cast<uint8_t>(burnType));
@@ -344,7 +341,6 @@ struct CBurnTokensMessage {
     }
 };
 
-
 struct CCreatePoolPairMessage {
     CPoolPairMessage poolPair;
     std::string pairSymbol;
@@ -373,91 +369,129 @@ struct CGovernanceUnsetMessage {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(govs);
     }
 };
 
 struct CCustomTxMessageNone {};
 
-using CCustomTxMessage = std::variant<
-    CCustomTxMessageNone,
-    CCreateMasterNodeMessage,
-    CResignMasterNodeMessage,
-    CUpdateMasterNodeMessage,
-    CCreateTokenMessage,
-    CUpdateTokenPreAMKMessage,
-    CUpdateTokenMessage,
-    CMintTokensMessage,
-    CBurnTokensMessage,
-    CCreatePoolPairMessage,
-    CUpdatePoolPairMessage,
-    CPoolSwapMessage,
-    CPoolSwapMessageV2,
-    CLiquidityMessage,
-    CRemoveLiquidityMessage,
-    CUtxosToAccountMessage,
-    CAccountToUtxosMessage,
-    CAccountToAccountMessage,
-    CAnyAccountsToAccountsMessage,
-    CSmartContractMessage,
-    CFutureSwapMessage,
-    CGovernanceMessage,
-    CGovernanceUnsetMessage,
-    CGovernanceHeightMessage,
-    CAppointOracleMessage,
-    CRemoveOracleAppointMessage,
-    CUpdateOracleAppointMessage,
-    CSetOracleDataMessage,
-    CICXCreateOrderMessage,
-    CICXMakeOfferMessage,
-    CICXSubmitDFCHTLCMessage,
-    CICXSubmitEXTHTLCMessage,
-    CICXClaimDFCHTLCMessage,
-    CICXCloseOrderMessage,
-    CICXCloseOfferMessage,
-    CLoanSetCollateralTokenMessage,
-    CLoanSetLoanTokenMessage,
-    CLoanUpdateLoanTokenMessage,
-    CLoanSchemeMessage,
-    CDefaultLoanSchemeMessage,
-    CDestroyLoanSchemeMessage,
-    CVaultMessage,
-    CCloseVaultMessage,
-    CUpdateVaultMessage,
-    CDepositToVaultMessage,
-    CWithdrawFromVaultMessage,
-    CPaybackWithCollateralMessage,
-    CLoanTakeLoanMessage,
-    CLoanPaybackLoanMessage,
-    CLoanPaybackLoanV2Message,
-    CAuctionBidMessage,
-    CCreatePropMessage,
-    CPropVoteMessage
->;
+using CCustomTxMessage = std::variant<CCustomTxMessageNone,
+                                      CCreateMasterNodeMessage,
+                                      CResignMasterNodeMessage,
+                                      CUpdateMasterNodeMessage,
+                                      CCreateTokenMessage,
+                                      CUpdateTokenPreAMKMessage,
+                                      CUpdateTokenMessage,
+                                      CMintTokensMessage,
+                                      CBurnTokensMessage,
+                                      CCreatePoolPairMessage,
+                                      CUpdatePoolPairMessage,
+                                      CPoolSwapMessage,
+                                      CPoolSwapMessageV2,
+                                      CLiquidityMessage,
+                                      CRemoveLiquidityMessage,
+                                      CUtxosToAccountMessage,
+                                      CAccountToUtxosMessage,
+                                      CAccountToAccountMessage,
+                                      CAnyAccountsToAccountsMessage,
+                                      CSmartContractMessage,
+                                      CFutureSwapMessage,
+                                      CGovernanceMessage,
+                                      CGovernanceUnsetMessage,
+                                      CGovernanceHeightMessage,
+                                      CAppointOracleMessage,
+                                      CRemoveOracleAppointMessage,
+                                      CUpdateOracleAppointMessage,
+                                      CSetOracleDataMessage,
+                                      CICXCreateOrderMessage,
+                                      CICXMakeOfferMessage,
+                                      CICXSubmitDFCHTLCMessage,
+                                      CICXSubmitEXTHTLCMessage,
+                                      CICXClaimDFCHTLCMessage,
+                                      CICXCloseOrderMessage,
+                                      CICXCloseOfferMessage,
+                                      CLoanSetCollateralTokenMessage,
+                                      CLoanSetLoanTokenMessage,
+                                      CLoanUpdateLoanTokenMessage,
+                                      CLoanSchemeMessage,
+                                      CDefaultLoanSchemeMessage,
+                                      CDestroyLoanSchemeMessage,
+                                      CVaultMessage,
+                                      CCloseVaultMessage,
+                                      CUpdateVaultMessage,
+                                      CDepositToVaultMessage,
+                                      CWithdrawFromVaultMessage,
+                                      CPaybackWithCollateralMessage,
+                                      CLoanTakeLoanMessage,
+                                      CLoanPaybackLoanMessage,
+                                      CLoanPaybackLoanV2Message,
+                                      CAuctionBidMessage,
+                                      CCreatePropMessage,
+                                      CPropVoteMessage>;
 
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
-bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
-Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValue& results);
-Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage);
-Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint256* canSpend = nullptr, uint32_t txn = 0, CHistoryWriters* writers = nullptr);
-Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time, uint32_t txn = 0);
-ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView& mnview, const CTransaction& tx, int height, const uint256& prevStakeModifier, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
-ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransaction& tx, int height, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
-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);
-bool IsPaybackWithCollateral(CCustomCSView& mnview, const std::map<DCT_ID, CBalances>& loans);
-Res PaybackWithCollateral(CCustomCSView& view, const CVaultData& vault, const CVaultId& vaultId, uint32_t height, uint64_t time);
-Res SwapToDFIorDUSD(CCustomCSView & mnview, DCT_ID tokenId, CAmount amount, CScript const & from, CScript const & to, uint32_t height, bool forceLoanSwap = false);
-Res storeGovVars(const CGovernanceHeightMessage& obj, CCustomCSView& view);
-
-inline bool OraclePriceFeed(CCustomCSView& view, const CTokenCurrencyPair& priceFeed) {
+bool IsMempooledCustomTxCreate(const CTxMemPool &pool, const uint256 &txid);
+Res RpcInfo(const CTransaction &tx, uint32_t height, CustomTxType &type, UniValue &results);
+Res CustomMetadataParse(uint32_t height,
+                        const Consensus::Params &consensus,
+                        const std::vector<unsigned char> &metadata,
+                        CCustomTxMessage &txMessage);
+Res ApplyCustomTx(CCustomCSView &mnview,
+                  const CCoinsViewCache &coins,
+                  const CTransaction &tx,
+                  const Consensus::Params &consensus,
+                  uint32_t height,
+                  uint64_t time            = 0,
+                  uint256 *canSpend        = nullptr,
+                  uint32_t txn             = 0,
+                  CHistoryWriters *writers = nullptr);
+Res CustomTxVisit(CCustomCSView &mnview,
+                  const CCoinsViewCache &coins,
+                  const CTransaction &tx,
+                  uint32_t height,
+                  const Consensus::Params &consensus,
+                  const CCustomTxMessage &txMessage,
+                  uint64_t time,
+                  uint32_t txn = 0);
+ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView &mnview,
+                                    const CTransaction &tx,
+                                    int height,
+                                    const uint256 &prevStakeModifier,
+                                    const std::vector<unsigned char> &metadata,
+                                    const Consensus::Params &consensusParams);
+ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView &mnview,
+                                        const CTransaction &tx,
+                                        int height,
+                                        const std::vector<unsigned char> &metadata,
+                                        const Consensus::Params &consensusParams);
+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);
+bool IsPaybackWithCollateral(CCustomCSView &mnview, const std::map<DCT_ID, CBalances> &loans);
+Res PaybackWithCollateral(CCustomCSView &view,
+                          const CVaultData &vault,
+                          const CVaultId &vaultId,
+                          uint32_t height,
+                          uint64_t time);
+Res SwapToDFIorDUSD(CCustomCSView &mnview,
+                    DCT_ID tokenId,
+                    CAmount amount,
+                    const CScript &from,
+                    const CScript &to,
+                    uint32_t height,
+                    bool forceLoanSwap = false);
+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) {
+    view.ForEachOracle([&](const COracleId &, COracle oracle) {
         return !(found = oracle.SupportsPair(priceFeed.first, priceFeed.second));
     });
     return found;
@@ -465,8 +499,10 @@ inline bool OraclePriceFeed(CCustomCSView& view, const CTokenCurrencyPair& price
 
 /*
  * Checks if given tx is probably one of 'CustomTx', returns tx type and serialized metadata in 'data'
-*/
-inline CustomTxType GuessCustomTxType(CTransaction const & tx, std::vector<unsigned char> & metadata, bool metadataValidation = false){
+ */
+inline CustomTxType GuessCustomTxType(const CTransaction &tx,
+                                      std::vector<unsigned char> &metadata,
+                                      bool metadataValidation = false) {
     if (tx.vout.empty()) {
         return CustomTxType::None;
     }
@@ -501,14 +537,12 @@ inline CustomTxType GuessCustomTxType(CTransaction const & tx, std::vector<unsig
     return txType;
 }
 
-inline bool IsMintTokenTx(const CTransaction& tx)
-{
+inline bool IsMintTokenTx(const CTransaction &tx) {
     std::vector<unsigned char> metadata;
     return GuessCustomTxType(tx, metadata) == CustomTxType::MintToken;
 }
 
-inline std::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(const CTransaction & tx)
-{
+inline std::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(const CTransaction &tx) {
     std::vector<unsigned char> metadata;
     if (GuessCustomTxType(tx, metadata) == CustomTxType::AccountToUtxos) {
         return metadata;
@@ -516,8 +550,7 @@ inline std::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(const
     return {};
 }
 
-inline std::optional<CAccountToUtxosMessage> GetAccountToUtxosMsg(const CTransaction & tx)
-{
+inline std::optional<CAccountToUtxosMessage> GetAccountToUtxosMsg(const CTransaction &tx) {
     const auto metadata = GetAccountToUtxosMetadata(tx);
     if (metadata) {
         CAccountToUtxosMessage msg;
@@ -532,20 +565,18 @@ inline std::optional<CAccountToUtxosMessage> GetAccountToUtxosMsg(const CTransac
     return {};
 }
 
-inline TAmounts GetNonMintedValuesOut(const CTransaction & tx)
-{
+inline TAmounts GetNonMintedValuesOut(const CTransaction &tx) {
     uint32_t mintingOutputsStart = std::numeric_limits<uint32_t>::max();
-    const auto accountToUtxos = GetAccountToUtxosMsg(tx);
+    const auto accountToUtxos    = GetAccountToUtxosMsg(tx);
     if (accountToUtxos) {
         mintingOutputsStart = accountToUtxos->mintingOutputsStart;
     }
     return tx.GetValuesOut(mintingOutputsStart);
 }
 
-inline CAmount GetNonMintedValueOut(const CTransaction & tx, DCT_ID tokenID)
-{
+inline CAmount GetNonMintedValueOut(const CTransaction &tx, DCT_ID tokenID) {
     uint32_t mintingOutputsStart = std::numeric_limits<uint32_t>::max();
-    const auto accountToUtxos = GetAccountToUtxosMsg(tx);
+    const auto accountToUtxos    = GetAccountToUtxosMsg(tx);
     if (accountToUtxos) {
         mintingOutputsStart = accountToUtxos->mintingOutputsStart;
     }
@@ -553,7 +584,7 @@ inline CAmount GetNonMintedValueOut(const CTransaction & tx, DCT_ID tokenID)
 }
 
 class CPoolSwap {
-    const CPoolSwapMessage& obj;
+    const CPoolSwapMessage &obj;
     uint32_t height;
     CAmount result{0};
     DCT_ID currentID;
@@ -561,13 +592,14 @@ class CPoolSwap {
 public:
     std::vector<std::pair<std::string, std::string>> errors;
 
-    CPoolSwap(const CPoolSwapMessage& obj, uint32_t height)
-    : obj(obj), height(height) {}
+    CPoolSwap(const CPoolSwapMessage &obj, uint32_t height)
+        : obj(obj),
+          height(height) {}
 
-    std::vector<DCT_ID> CalculateSwaps(CCustomCSView& view, bool testOnly = false);
-    Res ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs, bool testOnly = false);
-    std::vector<std::vector<DCT_ID>> CalculatePoolPaths(CCustomCSView& view);
+    std::vector<DCT_ID> CalculateSwaps(CCustomCSView &view, bool testOnly = false);
+    Res ExecuteSwap(CCustomCSView &view, std::vector<DCT_ID> poolIDs, bool testOnly = false);
+    std::vector<std::vector<DCT_ID>> CalculatePoolPaths(CCustomCSView &view);
     CTokenAmount GetResult() { return CTokenAmount{obj.idTokenTo, result}; };
 };
 
-#endif // DEFI_MASTERNODES_MN_CHECKS_H
+#endif  // DEFI_MASTERNODES_MN_CHECKS_H
diff --git a/src/masternodes/mn_rpc.h b/src/masternodes/mn_rpc.h
index 992da82a6a..8e22580e69 100644
--- a/src/masternodes/mn_rpc.h
+++ b/src/masternodes/mn_rpc.h
@@ -12,8 +12,8 @@
 #include <masternodes/mn_checks.h>
 
 #include <rpc/rawtransaction_util.h>
-#include <rpc/server.h>
 #include <rpc/resultcache.h>
+#include <rpc/server.h>
 #include <rpc/util.h>
 
 //#ifdef ENABLE_WALLET
@@ -36,27 +36,28 @@ typedef enum {
 } AccountSelectionMode;
 
 enum class AmountFormat : uint8_t {
-        Unknown,
-        // amount@0
-        Id,
-        // amount@DFI
-        Symbol,
-        // amount@0#DFI
-        Combined,
+    Unknown,
+    // amount@0
+    Id,
+    // amount@DFI
+    Symbol,
+    // amount@0#DFI
+    Combined,
 };
 
 class CWalletCoinsUnlocker {
     std::shared_ptr<CWallet> pwallet;
     std::vector<COutPoint> coins;
+
 public:
     explicit CWalletCoinsUnlocker(std::shared_ptr<CWallet> pwallet);
-    CWalletCoinsUnlocker(const CWalletCoinsUnlocker&) = delete;
-    CWalletCoinsUnlocker(CWalletCoinsUnlocker&&) = default;
+    CWalletCoinsUnlocker(const CWalletCoinsUnlocker &) = delete;
+    CWalletCoinsUnlocker(CWalletCoinsUnlocker &&)      = default;
     ~CWalletCoinsUnlocker();
-    CWallet* operator->();
-    CWallet& operator*();
-    operator CWallet*();
-    void AddLockedCoin(const COutPoint& coin);
+    CWallet *operator->();
+    CWallet &operator*();
+    operator CWallet *();
+    void AddLockedCoin(const COutPoint &coin);
 };
 
 struct FutureSwapHeightInfo {
@@ -65,19 +66,29 @@ struct FutureSwapHeightInfo {
 };
 
 // common functions
-bool IsSkippedTx(const uint256& hash);
-int chainHeight(interfaces::Chain::Lock& locked_chain);
-CMutableTransaction fund(CMutableTransaction& mtx, CWalletCoinsUnlocker& pwallet, CTransactionRef optAuthTx, CCoinControl* coin_control = nullptr);
-CTransactionRef signsend(CMutableTransaction& mtx, CWalletCoinsUnlocker& pwallet, CTransactionRef optAuthTx);
-CWalletCoinsUnlocker GetWallet(const JSONRPCRequest& request);
-std::vector<CTxIn> GetAuthInputsSmart(CWalletCoinsUnlocker& pwallet, int32_t txVersion, std::set<CScript>& auths, bool needFounderAuth, CTransactionRef& optAuthTx, UniValue const& explicitInputs);
-std::string ScriptToString(CScript const& script);
-CAccounts GetAllMineAccounts(CWallet* const pwallet);
-CAccounts SelectAccountsByTargetBalances(const CAccounts& accounts, const CBalances& targetBalances, AccountSelectionMode selectionMode);
-void execTestTx(const CTransaction& tx, uint32_t height, CTransactionRef optAuthTx = {});
-CScript CreateScriptForHTLC(const JSONRPCRequest& request, uint32_t &blocks, std::vector<unsigned char>& image);
+bool IsSkippedTx(const uint256 &hash);
+int chainHeight(interfaces::Chain::Lock &locked_chain);
+CMutableTransaction fund(CMutableTransaction &mtx,
+                         CWalletCoinsUnlocker &pwallet,
+                         CTransactionRef optAuthTx,
+                         CCoinControl *coin_control = nullptr);
+CTransactionRef signsend(CMutableTransaction &mtx, CWalletCoinsUnlocker &pwallet, CTransactionRef optAuthTx);
+CWalletCoinsUnlocker GetWallet(const JSONRPCRequest &request);
+std::vector<CTxIn> GetAuthInputsSmart(CWalletCoinsUnlocker &pwallet,
+                                      int32_t txVersion,
+                                      std::set<CScript> &auths,
+                                      bool needFounderAuth,
+                                      CTransactionRef &optAuthTx,
+                                      const UniValue &explicitInputs);
+std::string ScriptToString(const CScript &script);
+CAccounts GetAllMineAccounts(CWallet *const pwallet);
+CAccounts SelectAccountsByTargetBalances(const CAccounts &accounts,
+                                         const CBalances &targetBalances,
+                                         AccountSelectionMode selectionMode);
+void execTestTx(const CTransaction &tx, uint32_t height, CTransactionRef optAuthTx = {});
+CScript CreateScriptForHTLC(const JSONRPCRequest &request, uint32_t &blocks, std::vector<unsigned char> &image);
 CPubKey PublickeyFromString(const std::string &pubkey);
-std::optional<CScript> AmIFounder(CWallet* const pwallet);
+std::optional<CScript> AmIFounder(CWallet *const pwallet);
 std::optional<FutureSwapHeightInfo> GetFuturesBlock(const uint32_t typeId);
 
-#endif // DEFI_MASTERNODES_MN_RPC_H
+#endif  // DEFI_MASTERNODES_MN_RPC_H
diff --git a/src/masternodes/oracles.cpp b/src/masternodes/oracles.cpp
index 6b777800e0..84641fd01c 100644
--- a/src/masternodes/oracles.cpp
+++ b/src/masternodes/oracles.cpp
@@ -8,13 +8,11 @@
 
 #include <algorithm>
 
-bool COracle::SupportsPair(const std::string& token, const std::string& currency) const
-{
+bool COracle::SupportsPair(const std::string &token, const std::string &currency) const {
     return availablePairs.count(std::make_pair(token, currency)) > 0;
 }
 
-Res COracle::SetTokenPrice(const std::string& token, const std::string& currency, CAmount amount, int64_t timestamp)
-{
+Res COracle::SetTokenPrice(const std::string &token, const std::string &currency, CAmount amount, int64_t timestamp) {
     if (!SupportsPair(token, currency)) {
         return Res::Err("token <%s> - currency <%s> is not allowed", token, currency);
     }
@@ -24,8 +22,7 @@ Res COracle::SetTokenPrice(const std::string& token, const std::string& currency
     return Res::Ok();
 }
 
-ResVal<CAmount> COracle::GetTokenPrice(const std::string& token, const std::string& currency)
-{
+ResVal<CAmount> COracle::GetTokenPrice(const std::string &token, const std::string &currency) {
     if (!SupportsPair(token, currency)) {
         return Res::Err("token <%s> - currency <%s> is not allowed", token, currency);
     }
@@ -33,8 +30,7 @@ ResVal<CAmount> COracle::GetTokenPrice(const std::string& token, const std::stri
     return ResVal<CAmount>(tokenPrices[token][currency].first, Res::Ok());
 }
 
-Res COracleView::AppointOracle(const COracleId& oracleId, const COracle& oracle)
-{
+Res COracleView::AppointOracle(const COracleId &oracleId, const COracle &oracle) {
     if (!WriteBy<ByName>(oracleId, oracle)) {
         return Res::Err("failed to appoint the new oracle <%s>", oracleId.GetHex());
     }
@@ -42,8 +38,7 @@ Res COracleView::AppointOracle(const COracleId& oracleId, const COracle& oracle)
     return Res::Ok();
 }
 
-Res COracleView::UpdateOracle(const COracleId& oracleId, COracle&& newOracle)
-{
+Res COracleView::UpdateOracle(const COracleId &oracleId, COracle &&newOracle) {
     COracle oracle;
     if (!ReadBy<ByName>(oracleId, oracle)) {
         return Res::Err("oracle <%s> not found", oracleId.GetHex());
@@ -53,14 +48,14 @@ Res COracleView::UpdateOracle(const COracleId& oracleId, COracle&& newOracle)
         return Res::Err("oracle <%s> has token prices on update", oracleId.GetHex());
     }
 
-    oracle.weightage = newOracle.weightage;
+    oracle.weightage     = newOracle.weightage;
     oracle.oracleAddress = std::move(newOracle.oracleAddress);
 
     CTokenPricePoints allowedPrices;
-    for (const auto& tokenPrice : oracle.tokenPrices) {
-        const auto& token = tokenPrice.first;
-        for (const auto& price : tokenPrice.second) {
-            const auto& currency = price.first;
+    for (const auto &tokenPrice : oracle.tokenPrices) {
+        const auto &token = tokenPrice.first;
+        for (const auto &price : tokenPrice.second) {
+            const auto &currency = price.first;
             if (!newOracle.SupportsPair(token, currency)) {
                 continue;
             }
@@ -68,7 +63,7 @@ Res COracleView::UpdateOracle(const COracleId& oracleId, COracle&& newOracle)
         }
     }
 
-    oracle.tokenPrices = std::move(allowedPrices);
+    oracle.tokenPrices    = std::move(allowedPrices);
     oracle.availablePairs = std::move(newOracle.availablePairs);
 
     // no need to update oracles list
@@ -79,8 +74,7 @@ Res COracleView::UpdateOracle(const COracleId& oracleId, COracle&& newOracle)
     return Res::Ok();
 }
 
-Res COracleView::RemoveOracle(const COracleId& oracleId)
-{
+Res COracleView::RemoveOracle(const COracleId &oracleId) {
     if (!ExistsBy<ByName>(oracleId)) {
         return Res::Err("oracle <%s> not found", oracleId.GetHex());
     }
@@ -93,18 +87,17 @@ Res COracleView::RemoveOracle(const COracleId& oracleId)
     return Res::Ok();
 }
 
-Res COracleView::SetOracleData(const COracleId& oracleId, int64_t timestamp, const CTokenPrices& tokenPrices)
-{
+Res COracleView::SetOracleData(const COracleId &oracleId, int64_t timestamp, const CTokenPrices &tokenPrices) {
     COracle oracle;
     if (!ReadBy<ByName>(oracleId, oracle)) {
         return Res::Err("failed to read oracle %s from database", oracleId.GetHex());
     }
 
-    for (const auto& tokenPrice : tokenPrices) {
-        const auto& token = tokenPrice.first;
-        for (const auto& price : tokenPrice.second) {
-            const auto& currency = price.first;
-            auto res = oracle.SetTokenPrice(token, currency, price.second, timestamp);
+    for (const auto &tokenPrice : tokenPrices) {
+        const auto &token = tokenPrice.first;
+        for (const auto &price : tokenPrice.second) {
+            const auto &currency = price.first;
+            auto res             = oracle.SetTokenPrice(token, currency, price.second, timestamp);
             if (!res.ok) {
                 return res;
             }
@@ -118,8 +111,7 @@ Res COracleView::SetOracleData(const COracleId& oracleId, int64_t timestamp, con
     return Res::Ok();
 }
 
-ResVal<COracle> COracleView::GetOracleData(const COracleId& oracleId) const
-{
+ResVal<COracle> COracleView::GetOracleData(const COracleId &oracleId) const {
     COracle oracle;
     if (!ReadBy<ByName>(oracleId, oracle)) {
         return Res::Err("oracle <%s> not found", oracleId.GetHex());
@@ -128,39 +120,42 @@ ResVal<COracle> COracleView::GetOracleData(const COracleId& oracleId) const
     return ResVal<COracle>(oracle, Res::Ok());
 }
 
-void COracleView::ForEachOracle(std::function<bool(const COracleId&, CLazySerialize<COracle>)> callback, const COracleId& start)
-{
+void COracleView::ForEachOracle(std::function<bool(const COracleId &, CLazySerialize<COracle>)> callback,
+                                const COracleId &start) {
     ForEach<ByName, COracleId, COracle>(callback, start);
 }
 
-bool CFixedIntervalPrice::isLive(const CAmount deviationThreshold) const
-{
-    return (
-        priceRecord[0] > 0 &&
-        priceRecord[1] > 0 &&
-        (std::abs(priceRecord[1] - priceRecord[0]) < MultiplyAmounts(priceRecord[0], deviationThreshold))
-    );
+bool CFixedIntervalPrice::isLive(const CAmount deviationThreshold) const {
+    return (priceRecord[0] > 0 && priceRecord[1] > 0 &&
+            (std::abs(priceRecord[1] - priceRecord[0]) < MultiplyAmounts(priceRecord[0], deviationThreshold)));
 }
 
-Res COracleView::SetFixedIntervalPrice(const CFixedIntervalPrice& fixedIntervalPrice){
-
+Res COracleView::SetFixedIntervalPrice(const CFixedIntervalPrice &fixedIntervalPrice) {
     if (!WriteBy<FixedIntervalPriceKey>(fixedIntervalPrice.priceFeedId, fixedIntervalPrice)) {
-        return Res::Err("failed to set new price feed <%s/%s>", fixedIntervalPrice.priceFeedId.first, fixedIntervalPrice.priceFeedId.second);
-    }
-    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 Res::Err("failed to set new price feed <%s/%s>",
+                        fixedIntervalPrice.priceFeedId.first,
+                        fixedIntervalPrice.priceFeedId.second);
+    }
+    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 Res::Ok();
 }
 
-ResVal<CFixedIntervalPrice> COracleView::GetFixedIntervalPrice(const CTokenCurrencyPair& fixedIntervalPriceId)
-{
+ResVal<CFixedIntervalPrice> COracleView::GetFixedIntervalPrice(const CTokenCurrencyPair &fixedIntervalPriceId) {
     CFixedIntervalPrice fixedIntervalPrice;
     if (!ReadBy<FixedIntervalPriceKey>(fixedIntervalPriceId, fixedIntervalPrice)) {
-        return Res::Err("fixedIntervalPrice with id <%s/%s> not found", fixedIntervalPriceId.first, fixedIntervalPriceId.second);
+        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 firstToken  = GetTokenGuessId(fixedIntervalPriceId.first, firstID);
     const auto secondToken = GetTokenGuessId(fixedIntervalPriceId.second, secondID);
 
     std::set<uint32_t> loanTokens;
@@ -176,29 +171,33 @@ ResVal<CFixedIntervalPrice> COracleView::GetFixedIntervalPrice(const CTokenCurre
         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]);
+    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());
 }
 
-void COracleView::ForEachFixedIntervalPrice(std::function<bool(const CTokenCurrencyPair&, CLazySerialize<CFixedIntervalPrice>)> callback, const CTokenCurrencyPair& start)
-{
+void COracleView::ForEachFixedIntervalPrice(
+    std::function<bool(const CTokenCurrencyPair &, CLazySerialize<CFixedIntervalPrice>)> callback,
+    const CTokenCurrencyPair &start) {
     ForEach<FixedIntervalPriceKey, CTokenCurrencyPair, CFixedIntervalPrice>(callback, start);
 }
 
-Res COracleView::SetPriceDeviation(const uint32_t deviation)
-{
+Res COracleView::SetPriceDeviation(const uint32_t deviation) {
     Write(PriceDeviation::prefix(), deviation);
     return Res::Ok();
 }
 
-Res COracleView::ErasePriceDeviation()
-{
+Res COracleView::ErasePriceDeviation() {
     Erase(PriceDeviation::prefix());
     return Res::Ok();
 }
 
-CAmount COracleView::GetPriceDeviation() const
-{
+CAmount COracleView::GetPriceDeviation() const {
     uint32_t deviation;
     if (Read(PriceDeviation::prefix(), deviation)) {
         return deviation;
@@ -208,20 +207,17 @@ CAmount COracleView::GetPriceDeviation() const
     return 3 * COIN / 10;
 }
 
-Res COracleView::SetIntervalBlock(const uint32_t blockInterval)
-{
+Res COracleView::SetIntervalBlock(const uint32_t blockInterval) {
     Write(FixedIntervalBlockKey::prefix(), blockInterval);
     return Res::Ok();
 }
 
-Res COracleView::EraseIntervalBlock()
-{
+Res COracleView::EraseIntervalBlock() {
     Erase(FixedIntervalBlockKey::prefix());
     return Res::Ok();
 }
 
-uint32_t COracleView::GetIntervalBlock() const
-{
+uint32_t COracleView::GetIntervalBlock() const {
     uint32_t blockInterval;
     if (Read(FixedIntervalBlockKey::prefix(), blockInterval)) {
         return blockInterval;
diff --git a/src/masternodes/oracles.h b/src/masternodes/oracles.h
index bb4fc46c09..66988299f2 100644
--- a/src/masternodes/oracles.h
+++ b/src/masternodes/oracles.h
@@ -19,11 +19,11 @@
 class CTokenImplementation;
 class CLoanSetLoanTokenImplementation;
 
-using COracleId = uint256;
-using CPriceTimePair = std::pair<CAmount, int64_t>;
+using COracleId          = uint256;
+using CPriceTimePair     = std::pair<CAmount, int64_t>;
 using CTokenCurrencyPair = std::pair<std::string, std::string>;
-using CTokenPrices = std::map<std::string, std::map<std::string, CAmount>>;
-using CTokenPricePoints = std::map<std::string, std::map<std::string, CPriceTimePair>>;
+using CTokenPrices       = std::map<std::string, std::map<std::string, CAmount>>;
+using CTokenPricePoints  = std::map<std::string, std::map<std::string, CPriceTimePair>>;
 
 struct CAppointOracleMessage {
     CScript oracleAddress;
@@ -33,8 +33,7 @@ struct CAppointOracleMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(oracleAddress);
         READWRITE(weightage);
         READWRITE(availablePairs);
@@ -47,8 +46,7 @@ struct CRemoveOracleAppointMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(oracleId);
     }
 };
@@ -60,8 +58,7 @@ struct CUpdateOracleAppointMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(oracleId);
         READWRITE(newOracleAppoint);
     }
@@ -75,8 +72,7 @@ struct CSetOracleDataMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(oracleId);
         READWRITE(timestamp);
         READWRITE(tokenPrices);
@@ -87,71 +83,70 @@ struct CSetOracleDataMessage {
 struct COracle : public CAppointOracleMessage {
     CTokenPricePoints tokenPrices;
 
-    bool SupportsPair(const std::string& token, const std::string& currency) const;
-    Res SetTokenPrice(const std::string& token, const std::string& currency, CAmount amount, int64_t timestamp);
-    ResVal<CAmount> GetTokenPrice(const std::string& token, const std::string& currency);
+    bool SupportsPair(const std::string &token, const std::string &currency) const;
+    Res SetTokenPrice(const std::string &token, const std::string &currency, CAmount amount, int64_t timestamp);
+    ResVal<CAmount> GetTokenPrice(const std::string &token, const std::string &currency);
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CAppointOracleMessage, *this);
         READWRITE(tokenPrices);
     }
 };
 
-struct CFixedIntervalPrice
-{
+struct CFixedIntervalPrice {
     CTokenCurrencyPair priceFeedId;
     int64_t timestamp;
-    std::vector<CAmount> priceRecord{0, 0}; // priceHistory[0] = active price, priceHistory[1] = next price
+    std::vector<CAmount> priceRecord{0, 0};  // priceHistory[0] = active price, priceHistory[1] = next price
     bool isLive(const CAmount deviationThreshold) const;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(priceFeedId);
         READWRITE(timestamp);
         READWRITE(priceRecord);
     }
 };
 
-struct CFuturesPrice
-{
+struct CFuturesPrice {
     CAmount discount;
     CAmount premium;
 };
 
 /// View for managing oracles and their data
-class COracleView : public virtual CStorageView
-{
+class COracleView : public virtual CStorageView {
 public:
     ~COracleView() override = default;
 
     /// register new oracle instance
-    Res AppointOracle(const COracleId& oracleId, const COracle& oracle);
+    Res AppointOracle(const COracleId &oracleId, const COracle &oracle);
 
     /// updates oracle info
-    Res UpdateOracle(const COracleId& oracleId, COracle&& newOracle);
+    Res UpdateOracle(const COracleId &oracleId, COracle &&newOracle);
 
     /// remove oracle instancefrom database
-    Res RemoveOracle(const COracleId& oracleId);
+    Res RemoveOracle(const COracleId &oracleId);
 
     /// store registered oracle data
-    Res SetOracleData(const COracleId& oracleId, int64_t timestamp, const CTokenPrices& tokenPrices);
+    Res SetOracleData(const COracleId &oracleId, int64_t timestamp, const CTokenPrices &tokenPrices);
 
     /// deserialize oracle instance from database
-    ResVal<COracle> GetOracleData(const COracleId& oracleId) const;
+    ResVal<COracle> GetOracleData(const COracleId &oracleId) const;
 
-    void ForEachOracle(std::function<bool(const COracleId&, CLazySerialize<COracle>)> callback, const COracleId& start = {});
+    void ForEachOracle(std::function<bool(const COracleId &, CLazySerialize<COracle>)> callback,
+                       const COracleId &start = {});
 
-    Res SetFixedIntervalPrice(const CFixedIntervalPrice& PriceFeed);
+    Res SetFixedIntervalPrice(const CFixedIntervalPrice &PriceFeed);
 
-    ResVal<CFixedIntervalPrice> GetFixedIntervalPrice(const CTokenCurrencyPair& priceFeedId);
+    ResVal<CFixedIntervalPrice> GetFixedIntervalPrice(const CTokenCurrencyPair &priceFeedId);
 
-    void ForEachFixedIntervalPrice(std::function<bool(const CTokenCurrencyPair&, CLazySerialize<CFixedIntervalPrice>)> callback, const CTokenCurrencyPair& start = {});
+    void ForEachFixedIntervalPrice(
+        std::function<bool(const CTokenCurrencyPair &, CLazySerialize<CFixedIntervalPrice>)> callback,
+        const CTokenCurrencyPair &start = {});
 
     Res SetPriceDeviation(const uint32_t deviation);
     Res ErasePriceDeviation();
@@ -161,14 +156,23 @@ class COracleView : public virtual CStorageView
     Res EraseIntervalBlock();
     uint32_t GetIntervalBlock() const;
 
-    [[nodiscard]] virtual bool AreTokensLocked(const std::set<uint32_t>& tokenIds) const = 0;
-    [[nodiscard]] virtual std::optional<CTokenImplementation> GetTokenGuessId(const std::string & str, DCT_ID & id) const = 0;
-    [[nodiscard]] virtual std::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'; } };
-    struct FixedIntervalPriceKey { static constexpr uint8_t prefix() { return 'y'; } };
+    [[nodiscard]] virtual bool AreTokensLocked(const std::set<uint32_t> &tokenIds) const                          = 0;
+    [[nodiscard]] virtual std::optional<CTokenImplementation> GetTokenGuessId(const std::string &str,
+                                                                              DCT_ID &id) const                   = 0;
+    [[nodiscard]] virtual std::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'; }
+    };
+    struct FixedIntervalPriceKey {
+        static constexpr uint8_t prefix() { return 'y'; }
+    };
 };
 
-#endif // DEFI_MASTERNODES_ORACLES_H
+#endif  // DEFI_MASTERNODES_ORACLES_H
diff --git a/src/masternodes/poolpairs.cpp b/src/masternodes/poolpairs.cpp
index c384d627a9..961331f05b 100644
--- a/src/masternodes/poolpairs.cpp
+++ b/src/masternodes/poolpairs.cpp
@@ -17,7 +17,7 @@ struct PoolSwapValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(swapEvent);
         READWRITE(blockCommissionA);
         READWRITE(blockCommissionB);
@@ -31,14 +31,13 @@ struct PoolReservesValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(reserveA);
         READWRITE(reserveB);
     }
 };
 
-std::string RewardToString(RewardType type)
-{
+std::string RewardToString(RewardType type) {
     if (type & RewardType::Rewards) {
         return "Rewards";
     } else if (type == RewardType::Commission) {
@@ -47,18 +46,21 @@ std::string RewardToString(RewardType type)
     return "Unknown";
 }
 
-std::string RewardTypeToString(RewardType type)
-{
-    switch(type) {
-        case RewardType::Coinbase: return "Coinbase";
-        case RewardType::Pool: return "Pool";
-        case RewardType::LoanTokenDEXReward: return "LoanTokenDEXReward";
-        default: return "Unknown";
+std::string RewardTypeToString(RewardType type) {
+    switch (type) {
+        case RewardType::Coinbase:
+            return "Coinbase";
+        case RewardType::Pool:
+            return "Pool";
+        case RewardType::LoanTokenDEXReward:
+            return "LoanTokenDEXReward";
+        default:
+            return "Unknown";
     }
 }
 
 template <typename By, typename ReturnType>
-ReturnType ReadValueAt(CPoolPairView * poolView, PoolHeightKey const & poolKey) {
+ReturnType ReadValueAt(CPoolPairView *poolView, const PoolHeightKey &poolKey) {
     auto it = poolView->LowerBound<By>(poolKey);
     if (it.Valid() && it.Key().poolID == poolKey.poolID) {
         return it.Value();
@@ -66,17 +68,15 @@ ReturnType ReadValueAt(CPoolPairView * poolView, PoolHeightKey const & poolKey)
     return {};
 }
 
-Res CPoolPairView::SetPoolPair(DCT_ID const & poolId, uint32_t height, CPoolPair const & pool)
-{
+Res CPoolPairView::SetPoolPair(DCT_ID const &poolId, uint32_t height, const CPoolPair &pool) {
     if (pool.idTokenA == pool.idTokenB) {
         return Res::Err("Error: tokens IDs are the same.");
     }
 
-    auto poolPairByID = GetPoolPair(poolId);
+    auto poolPairByID   = GetPoolPair(poolId);
     auto poolIdByTokens = ReadBy<ByPair, DCT_ID>(ByPairKey{pool.idTokenA, pool.idTokenB});
 
-    if ((!poolPairByID && poolIdByTokens)
-    || (poolPairByID && !poolIdByTokens)) {
+    if ((!poolPairByID && poolIdByTokens) || (poolPairByID && !poolIdByTokens)) {
         return Res::Err("Error, there is already a poolpair with same tokens, but different poolId");
     }
 
@@ -97,12 +97,9 @@ Res CPoolPairView::SetPoolPair(DCT_ID const & poolId, uint32_t height, CPoolPair
     assert(poolPairByTokens);
 
     // update
-    if(poolPairByID->idTokenA == pool.idTokenA
-    && poolPairByID->idTokenB == pool.idTokenB
-    && poolPairByTokens->idTokenA == pool.idTokenA
-    && poolPairByTokens->idTokenB == pool.idTokenB) {
-        if (poolPairByID->reserveA != pool.reserveA
-        || poolPairByID->reserveB != pool.reserveB) {
+    if (poolPairByID->idTokenA == pool.idTokenA && poolPairByID->idTokenB == pool.idTokenB &&
+        poolPairByTokens->idTokenA == pool.idTokenA && poolPairByTokens->idTokenB == pool.idTokenB) {
+        if (poolPairByID->reserveA != pool.reserveA || poolPairByID->reserveB != pool.reserveB) {
             WriteBy<ByReserves>(poolId, PoolReservesValue{pool.reserveA, pool.reserveB});
         }
         PoolHeightKey poolKey = {poolId, height};
@@ -118,20 +115,24 @@ Res CPoolPairView::SetPoolPair(DCT_ID const & poolId, uint32_t height, CPoolPair
     return Res::Err("Error, idTokenA or idTokenB is incorrect.");
 }
 
-Res CPoolPairView::UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool status, CAmount const & commission, CScript const & ownerAddress, CBalances const & rewards)
-{
+Res CPoolPairView::UpdatePoolPair(DCT_ID const &poolId,
+                                  uint32_t height,
+                                  bool status,
+                                  const CAmount &commission,
+                                  const CScript &ownerAddress,
+                                  const CBalances &rewards) {
     auto poolPair = GetPoolPair(poolId);
     if (!poolPair) {
         return Res::Err("Pool with poolId %s does not exist", poolId.ToString());
     }
 
-    CPoolPair & pool = poolPair.value();
+    CPoolPair &pool = poolPair.value();
 
     if (pool.status != status) {
         pool.status = status;
     }
 
-    if (commission >= 0) { // default/not set is -1
+    if (commission >= 0) {  // default/not set is -1
         if (commission > COIN) {
             return Res::Err("commission > 100%%");
         }
@@ -145,8 +146,9 @@ Res CPoolPairView::UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool s
     if (!rewards.balances.empty()) {
         auto customRewards = rewards;
         // Check for special case to wipe rewards
-        if (rewards.balances.size() == 1 && rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()}
-        && rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
+        if (rewards.balances.size() == 1 &&
+            rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()} &&
+            rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
             customRewards.balances.clear();
         }
         if (pool.rewards != customRewards) {
@@ -159,8 +161,7 @@ Res CPoolPairView::UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool s
     return Res::Ok();
 }
 
-std::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) const
-{
+std::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) const {
     auto pool = ReadBy<ByID, CPoolPair>(poolId);
     if (!pool) {
         return {};
@@ -177,20 +178,20 @@ std::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) const
     }
     PoolHeightKey poolKey = {poolId, UINT_MAX};
     // it's safe needed by iterator creation
-    auto view = const_cast<CPoolPairView *>(this);
+    auto view      = const_cast<CPoolPairView *>(this);
     auto swapValue = ReadValueAt<ByPoolSwap, PoolSwapValue>(view, poolKey);
     /// @Note swapEvent isn't restored
     pool->blockCommissionA = swapValue.blockCommissionA;
     pool->blockCommissionB = swapValue.blockCommissionB;
-    pool->totalLiquidity = ReadValueAt<ByTotalLiquidity, CAmount>(view, poolKey);
+    pool->totalLiquidity   = ReadValueAt<ByTotalLiquidity, CAmount>(view, poolKey);
     return pool;
 }
 
-std::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const DCT_ID &tokenA, const DCT_ID &tokenB) const
-{
+std::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const DCT_ID &tokenA,
+                                                                        const DCT_ID &tokenB) const {
     DCT_ID poolId;
-    ByPairKey key {tokenA, tokenB};
-    if(ReadBy<ByPair, ByPairKey>(key, poolId)) {
+    ByPairKey key{tokenA, tokenB};
+    if (ReadBy<ByPair, ByPairKey>(key, poolId)) {
         if (auto poolPair = GetPoolPair(poolId)) {
             return std::make_pair(poolId, std::move(*poolPair));
         }
@@ -199,17 +200,17 @@ std::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const DC
 }
 
 inline CAmount liquidityReward(CAmount reward, CAmount liquidity, CAmount totalLiquidity) {
-    return static_cast<CAmount>((arith_uint256(reward) * arith_uint256(liquidity) / arith_uint256(totalLiquidity)).GetLow64());
+    return static_cast<CAmount>(
+        (arith_uint256(reward) * arith_uint256(liquidity) / arith_uint256(totalLiquidity)).GetLow64());
 }
 
-template<typename TIterator>
-bool MatchPoolId(TIterator & it, DCT_ID poolId) {
+template <typename TIterator>
+bool MatchPoolId(TIterator &it, DCT_ID poolId) {
     return it.Valid() && it.Key().poolID == poolId;
 }
 
-template<typename TIterator, typename ValueType>
-void ReadValueMoveToNext(TIterator & it, DCT_ID poolId, ValueType & value, uint32_t & height) {
-
+template <typename TIterator, typename ValueType>
+void ReadValueMoveToNext(TIterator &it, DCT_ID poolId, ValueType &value, uint32_t &height) {
     if (MatchPoolId(it, poolId)) {
         value = it.Value();
         /// @Note we store keys in desc order so Prev is actually go in forward
@@ -220,15 +221,14 @@ void ReadValueMoveToNext(TIterator & it, DCT_ID poolId, ValueType & value, uint3
     }
 }
 
-template<typename By, typename Value>
-auto InitPoolVars(CPoolPairView & view, PoolHeightKey poolKey, uint32_t end) {
-
+template <typename By, typename Value>
+auto InitPoolVars(CPoolPairView &view, PoolHeightKey poolKey, uint32_t end) {
     auto poolId = poolKey.poolID;
-    auto it = view.LowerBound<By>(poolKey);
+    auto it     = view.LowerBound<By>(poolKey);
 
-    auto height = poolKey.height;
+    auto height                       = poolKey.height;
     static const uint32_t startHeight = Params().GetConsensus().GrandCentralHeight;
-    poolKey.height = std::max(height, startHeight);
+    poolKey.height                    = std::max(height, startHeight);
 
     while (!MatchPoolId(it, poolId) && poolKey.height < end) {
         height = poolKey.height;
@@ -241,31 +241,38 @@ auto InitPoolVars(CPoolPairView & view, PoolHeightKey poolKey, uint32_t end) {
     return std::make_tuple(std::move(value), std::move(it), height);
 }
 
-void CPoolPairView::CalculatePoolRewards(DCT_ID const & poolId, std::function<CAmount()> onLiquidity, uint32_t begin, uint32_t end, std::function<void(RewardType, CTokenAmount, uint32_t)> onReward) {
+void CPoolPairView::CalculatePoolRewards(DCT_ID const &poolId,
+                                         std::function<CAmount()> onLiquidity,
+                                         uint32_t begin,
+                                         uint32_t end,
+                                         std::function<void(RewardType, CTokenAmount, uint32_t)> onReward) {
     if (begin >= end) {
         return;
     }
     constexpr const uint32_t PRECISION = 10000;
-    const auto newCalcHeight = uint32_t(Params().GetConsensus().BayfrontGardensHeight);
+    const auto newCalcHeight           = uint32_t(Params().GetConsensus().BayfrontGardensHeight);
 
     auto tokenIds = ReadBy<ByIDPair, ByPairKey>(poolId);
-    assert(tokenIds); // contract to verify pool data
+    assert(tokenIds);  // contract to verify pool data
 
     PoolHeightKey poolKey = {poolId, begin};
 
     auto [poolReward, itPoolReward, startPoolReward] = InitPoolVars<ByPoolReward, CAmount>(*this, poolKey, end);
-    auto nextPoolReward = startPoolReward;
+    auto nextPoolReward                              = startPoolReward;
 
-    auto [poolLoanReward, itPoolLoanReward, startPoolLoanReward] = InitPoolVars<ByPoolLoanReward, CAmount>(*this, poolKey, end);
+    auto [poolLoanReward, itPoolLoanReward, startPoolLoanReward] =
+        InitPoolVars<ByPoolLoanReward, CAmount>(*this, poolKey, end);
     auto nextPoolLoanReward = startPoolLoanReward;
 
-    auto [totalLiquidity, itTotalLiquidity, nextTotalLiquidity] = InitPoolVars<ByTotalLiquidity, CAmount>(*this, poolKey, end);
+    auto [totalLiquidity, itTotalLiquidity, nextTotalLiquidity] =
+        InitPoolVars<ByTotalLiquidity, CAmount>(*this, poolKey, end);
 
-    auto [customRewards, itCustomRewards, startCustomRewards] = InitPoolVars<ByCustomReward, CBalances>(*this, poolKey, end);
+    auto [customRewards, itCustomRewards, startCustomRewards] =
+        InitPoolVars<ByCustomReward, CBalances>(*this, poolKey, end);
     auto nextCustomRewards = startCustomRewards;
 
-    auto poolSwapHeight = std::numeric_limits<uint32_t>::max();
-    auto nextPoolSwap = std::numeric_limits<uint32_t>::max();
+    auto poolSwapHeight                  = std::numeric_limits<uint32_t>::max();
+    auto nextPoolSwap                    = std::numeric_limits<uint32_t>::max();
     auto [poolSwap, itPoolSwap, discard] = InitPoolVars<ByPoolSwap, PoolSwapValue>(*this, poolKey, end);
     if (itPoolSwap.Valid() && itPoolSwap.Key().poolID == poolId) {
         nextPoolSwap = itPoolSwap.Key().height;
@@ -296,10 +303,10 @@ void CPoolPairView::CalculatePoolRewards(DCT_ID const & poolId, std::function<CA
         // daily rewards
         if (height >= startPoolReward && poolReward != 0) {
             CAmount providerReward = 0;
-            if (height < newCalcHeight) { // old calculation
+            if (height < newCalcHeight) {  // old calculation
                 uint32_t liqWeight = liquidity * PRECISION / totalLiquidity;
-                providerReward = poolReward * liqWeight / PRECISION;
-            } else { // new calculation
+                providerReward     = poolReward * liqWeight / PRECISION;
+            } else {  // new calculation
                 providerReward = liquidityReward(poolReward, liquidity, totalLiquidity);
             }
             onReward(RewardType::Coinbase, {DCT_ID{0}, providerReward}, height);
@@ -313,8 +320,8 @@ void CPoolPairView::CalculatePoolRewards(DCT_ID const & poolId, std::function<CA
             CAmount feeA, feeB;
             if (height < newCalcHeight) {
                 uint32_t liqWeight = liquidity * PRECISION / totalLiquidity;
-                feeA = poolSwap.blockCommissionA * liqWeight / PRECISION;
-                feeB = poolSwap.blockCommissionB * liqWeight / PRECISION;
+                feeA               = poolSwap.blockCommissionA * liqWeight / PRECISION;
+                feeB               = poolSwap.blockCommissionB * liqWeight / PRECISION;
             } else {
                 feeA = liquidityReward(poolSwap.blockCommissionA, liquidity, totalLiquidity);
                 feeB = liquidityReward(poolSwap.blockCommissionB, liquidity, totalLiquidity);
@@ -328,7 +335,7 @@ void CPoolPairView::CalculatePoolRewards(DCT_ID const & poolId, std::function<CA
         }
         // custom rewards
         if (height >= startCustomRewards) {
-            for (const auto& reward : customRewards.balances) {
+            for (const auto &reward : customRewards.balances) {
                 if (auto providerReward = liquidityReward(reward.second, liquidity, totalLiquidity)) {
                     onReward(RewardType::Pool, {reward.first, providerReward}, height);
                 }
@@ -338,7 +345,10 @@ void CPoolPairView::CalculatePoolRewards(DCT_ID const & poolId, std::function<CA
     }
 }
 
-Res CPoolPair::AddLiquidity(CAmount amountA, CAmount amountB, std::function<Res(CAmount)> onMint, bool slippageProtection) {
+Res CPoolPair::AddLiquidity(CAmount amountA,
+                            CAmount amountB,
+                            std::function<Res(CAmount)> onMint,
+                            bool slippageProtection) {
     // instead of assertion due to tests
     if (amountA <= 0 || amountB <= 0) {
         return Res::Err("amounts should be positive");
@@ -346,8 +356,10 @@ Res CPoolPair::AddLiquidity(CAmount amountA, CAmount amountB, std::function<Res(
 
     CAmount liquidity{0};
     if (totalLiquidity == 0) {
-        liquidity = (CAmount) (arith_uint256(amountA) * arith_uint256(amountB)).sqrt().GetLow64(); // sure this is below std::numeric_limits<CAmount>::max() due to sqrt natue
-        if (liquidity <= MINIMUM_LIQUIDITY) { // ensure that it'll be non-zero
+        liquidity = (CAmount)(arith_uint256(amountA) * arith_uint256(amountB))
+                        .sqrt()
+                        .GetLow64();  // sure this is below std::numeric_limits<CAmount>::max() due to sqrt natue
+        if (liquidity <= MINIMUM_LIQUIDITY) {  // ensure that it'll be non-zero
             return Res::Err("liquidity too low");
         }
         liquidity -= MINIMUM_LIQUIDITY;
@@ -356,13 +368,13 @@ Res CPoolPair::AddLiquidity(CAmount amountA, CAmount amountB, std::function<Res(
     } else {
         CAmount liqA = (arith_uint256(amountA) * arith_uint256(totalLiquidity) / reserveA).GetLow64();
         CAmount liqB = (arith_uint256(amountB) * arith_uint256(totalLiquidity) / reserveB).GetLow64();
-        liquidity = std::min(liqA, liqB);
+        liquidity    = std::min(liqA, liqB);
 
         if (liquidity == 0) {
             return Res::Err("amounts too low, zero liquidity");
         }
 
-        if(slippageProtection) {
+        if (slippageProtection) {
             if ((std::max(liqA, liqB) - liquidity) * 100 / liquidity >= 3) {
                 return Res::Err("Exceeds max ratio slippage protection of 3%%");
             }
@@ -391,7 +403,8 @@ Res CPoolPair::AddLiquidity(CAmount amountA, CAmount amountB, std::function<Res(
 
 Res CPoolPair::RemoveLiquidity(CAmount liqAmount, std::function<Res(CAmount, CAmount)> onReclaim) {
     // instead of assertion due to tests
-    // IRL it can't be more than "total-1000", and was checked indirectly by balances before. but for tests and incapsulation:
+    // IRL it can't be more than "total-1000", and was checked indirectly by balances before. but for tests and
+    // incapsulation:
     if (liqAmount <= 0 || liqAmount >= totalLiquidity) {
         return Res::Err("incorrect liquidity");
     }
@@ -400,39 +413,45 @@ Res CPoolPair::RemoveLiquidity(CAmount liqAmount, std::function<Res(CAmount, CAm
     resAmountA = (arith_uint256(liqAmount) * arith_uint256(reserveA) / totalLiquidity).GetLow64();
     resAmountB = (arith_uint256(liqAmount) * arith_uint256(reserveB) / totalLiquidity).GetLow64();
 
-    reserveA -= resAmountA; // safe due to previous math
+    reserveA -= resAmountA;  // safe due to previous math
     reserveB -= resAmountB;
     totalLiquidity -= liqAmount;
 
     return onReclaim(resAmountA, resAmountB);
 }
 
-Res CPoolPair::Swap(CTokenAmount in, CAmount dexfeeInPct, PoolPrice const & maxPrice, const std::pair<CFeeDir, CFeeDir>& asymmetricFee, std::function<Res (const CTokenAmount &, const CTokenAmount &)> onTransfer, int height) {
+Res CPoolPair::Swap(CTokenAmount in,
+                    CAmount dexfeeInPct,
+                    const PoolPrice &maxPrice,
+                    const std::pair<CFeeDir, CFeeDir> &asymmetricFee,
+                    std::function<Res(const CTokenAmount &, const CTokenAmount &)> onTransfer,
+                    int height) {
     if (in.nTokenId != idTokenA && in.nTokenId != idTokenB)
-        return Res::Err("Error, input token ID (" + in.nTokenId.ToString() + ") doesn't match pool tokens (" + idTokenA.ToString() + "," + idTokenB.ToString() + ")");
+        return Res::Err("Error, input token ID (" + in.nTokenId.ToString() + ") doesn't match pool tokens (" +
+                        idTokenA.ToString() + "," + idTokenB.ToString() + ")");
 
     if (!status)
         return Res::Err("Pool trading is turned off!");
 
-    bool const forward = in.nTokenId == idTokenA;
-    auto& reserveF = forward ? reserveA : reserveB;
-    auto& reserveT = forward ? reserveB : reserveA;
+    const bool forward = in.nTokenId == idTokenA;
+    auto &reserveF     = forward ? reserveA : reserveB;
+    auto &reserveT     = forward ? reserveB : reserveA;
 
-    // it is important that reserves are at least SLOPE_SWAP_RATE (1000) to be able to slide, otherwise it can lead to underflow
+    // it is important that reserves are at least SLOPE_SWAP_RATE (1000) to be able to slide, otherwise it can lead to
+    // underflow
     if (reserveA < SLOPE_SWAP_RATE || reserveB < SLOPE_SWAP_RATE)
         return Res::Err("Lack of liquidity.");
 
-    auto const maxPrice256 = arith_uint256(maxPrice.integer) * PRECISION + maxPrice.fraction;
+    const auto maxPrice256 = arith_uint256(maxPrice.integer) * PRECISION + maxPrice.fraction;
     // NOTE it has a bug prior Dakota hardfork
-    auto const price = height < Params().GetConsensus().DakotaHeight
-                              ? arith_uint256(reserveT) * PRECISION / reserveF
-                              : arith_uint256(reserveF) * PRECISION / reserveT;
+    const auto price = height < Params().GetConsensus().DakotaHeight ? arith_uint256(reserveT) * PRECISION / reserveF
+                                                                     : arith_uint256(reserveF) * PRECISION / reserveT;
     if (price > maxPrice256)
         return Res::Err("Price is higher than indicated.");
 
     // claim trading fee
     if (commission) {
-        CAmount const tradeFee = MultiplyAmounts(in.nValue, commission);
+        const CAmount tradeFee = MultiplyAmounts(in.nValue, commission);
         in.nValue -= tradeFee;
         if (forward) {
             blockCommissionA += tradeFee;
@@ -457,23 +476,23 @@ Res CPoolPair::Swap(CTokenAmount in, CAmount dexfeeInPct, PoolPrice const & maxP
 
     CAmount result = slopeSwap(in.nValue, reserveF, reserveT, height);
 
-    swapEvent = true; // (!!!)
+    swapEvent = true;  // (!!!)
 
-    return onTransfer(dexfeeInAmount, { forward ? idTokenB : idTokenA, result });
+    return onTransfer(dexfeeInAmount, {forward ? idTokenB : idTokenA, result});
 }
 
 CAmount CPoolPair::slopeSwap(CAmount unswapped, CAmount &poolFrom, CAmount &poolTo, int height) {
-    assert (unswapped >= 0);
-    assert (SafeAdd(unswapped, poolFrom).ok);
+    assert(unswapped >= 0);
+    assert(SafeAdd(unswapped, poolFrom).ok);
 
     arith_uint256 poolF = arith_uint256(poolFrom);
     arith_uint256 poolT = arith_uint256(poolTo);
 
     arith_uint256 swapped = 0;
     if (height < Params().GetConsensus().BayfrontGardensHeight) {
-        CAmount chunk = poolFrom/SLOPE_SWAP_RATE < unswapped ? poolFrom/SLOPE_SWAP_RATE : unswapped;
+        CAmount chunk = poolFrom / SLOPE_SWAP_RATE < unswapped ? poolFrom / SLOPE_SWAP_RATE : unswapped;
         while (unswapped > 0) {
-            //arith_uint256 stepFrom = std::min(poolFrom/1000, unswapped); // 0.1%
+            // arith_uint256 stepFrom = std::min(poolFrom/1000, unswapped); // 0.1%
             CAmount stepFrom = std::min(chunk, unswapped);
             arith_uint256 stepFrom256(stepFrom);
             arith_uint256 stepTo = poolT * stepFrom256 / poolF;
@@ -495,22 +514,23 @@ CAmount CPoolPair::slopeSwap(CAmount unswapped, CAmount &poolFrom, CAmount &pool
     }
 
     poolFrom = poolF.GetLow64();
-    poolTo = poolT.GetLow64();
+    poolTo   = poolT.GetLow64();
     return swapped.GetLow64();
 }
 
-std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(std::function<CTokenAmount(CScript const &, DCT_ID)> onGetBalance, std::function<Res(CScript const &, CScript const &, CTokenAmount)> onTransfer, int nHeight) {
-
-    bool newRewardCalc = nHeight >= Params().GetConsensus().BayfrontGardensHeight;
-    bool newRewardLogic = nHeight >= Params().GetConsensus().EunosHeight;
+std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(
+    std::function<CTokenAmount(const CScript &, DCT_ID)> onGetBalance,
+    std::function<Res(const CScript &, const CScript &, CTokenAmount)> onTransfer,
+    int nHeight) {
+    bool newRewardCalc    = nHeight >= Params().GetConsensus().BayfrontGardensHeight;
+    bool newRewardLogic   = nHeight >= Params().GetConsensus().EunosHeight;
     bool newCustomRewards = nHeight >= Params().GetConsensus().ClarkeQuayHeight;
 
-    constexpr uint32_t const PRECISION = 10000; // (== 100%) just searching the way to avoid arith256 inflating
-    CAmount totalDistributed = 0;
-    CAmount totalLoanDistributed = 0;
-
-    ForEachPoolId([&] (DCT_ID const & poolId) {
+    constexpr const uint32_t PRECISION = 10000;  // (== 100%) just searching the way to avoid arith256 inflating
+    CAmount totalDistributed           = 0;
+    CAmount totalLoanDistributed       = 0;
 
+    ForEachPoolId([&](DCT_ID const &poolId) {
         CAmount distributedFeeA = 0;
         CAmount distributedFeeB = 0;
         std::optional<CScript> ownerAddress;
@@ -520,7 +540,7 @@ std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(std::function<CToke
         CBalances rewards;
         if (newCustomRewards) {
             if (auto pool = ReadBy<ByID, CPoolPair>(poolId)) {
-                rewards = std::move(pool->rewards);
+                rewards      = std::move(pool->rewards);
                 ownerAddress = std::move(pool->ownerAddress);
             }
 
@@ -546,12 +566,11 @@ std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(std::function<CToke
             return true;
         }
 
-        auto swapValue = ReadBy<ByPoolSwap, PoolSwapValue>(poolKey);
+        auto swapValue       = ReadBy<ByPoolSwap, PoolSwapValue>(poolKey);
         const auto swapEvent = swapValue && swapValue->swapEvent;
-        auto poolReward = ReadValueAt<ByPoolReward, CAmount>(this, poolKey);
+        auto poolReward      = ReadValueAt<ByPoolReward, CAmount>(this, poolKey);
 
         if (newRewardLogic) {
-
             if (swapEvent) {
                 // it clears block commission
                 distributedFeeA = swapValue->blockCommissionA;
@@ -565,90 +584,93 @@ std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(std::function<CToke
             totalDistributed += poolReward;
             totalLoanDistributed += poolLoanReward;
 
-            for (const auto& reward : rewards.balances) {
+            for (const auto &reward : rewards.balances) {
                 // subtract pool's owner account by custom block reward
                 onTransfer(*ownerAddress, {}, {reward.first, reward.second});
             }
 
         } else {
             if (!swapEvent && poolReward == 0 && rewards.balances.empty()) {
-                return true; // no events, skip to the next pool
+                return true;  // no events, skip to the next pool
             }
 
-            ForEachPoolShare([&] (DCT_ID const & currentId, CScript const & provider, uint32_t) {
-                if (currentId != poolId) {
-                    return false; // stop
-                }
-                CAmount const liquidity = onGetBalance(provider, poolId).nValue;
-
-                uint32_t const liqWeight = liquidity * PRECISION / totalLiquidity;
-                assert (liqWeight < PRECISION);
-
-                // distribute trading fees
-                if (swapEvent) {
-                    CAmount feeA, feeB;
-                    if (newRewardCalc) {
-                        feeA = liquidityReward(swapValue->blockCommissionA, liquidity, totalLiquidity);
-                        feeB = liquidityReward(swapValue->blockCommissionB, liquidity, totalLiquidity);
-                    } else {
-                        feeA = swapValue->blockCommissionA * liqWeight / PRECISION;
-                        feeB = swapValue->blockCommissionB * liqWeight / PRECISION;
+            ForEachPoolShare(
+                [&](DCT_ID const &currentId, CScript const &provider, uint32_t) {
+                    if (currentId != poolId) {
+                        return false;  // stop
                     }
-                    auto tokenIds = ReadBy<ByIDPair, ByPairKey>(poolId);
-                    assert(tokenIds);
-                    if (onTransfer({}, provider, {tokenIds->idTokenA, feeA})) {
-                        distributedFeeA += feeA;
+                    CAmount const liquidity = onGetBalance(provider, poolId).nValue;
+
+                    uint32_t const liqWeight = liquidity * PRECISION / totalLiquidity;
+                    assert(liqWeight < PRECISION);
+
+                    // distribute trading fees
+                    if (swapEvent) {
+                        CAmount feeA, feeB;
+                        if (newRewardCalc) {
+                            feeA = liquidityReward(swapValue->blockCommissionA, liquidity, totalLiquidity);
+                            feeB = liquidityReward(swapValue->blockCommissionB, liquidity, totalLiquidity);
+                        } else {
+                            feeA = swapValue->blockCommissionA * liqWeight / PRECISION;
+                            feeB = swapValue->blockCommissionB * liqWeight / PRECISION;
+                        }
+                        auto tokenIds = ReadBy<ByIDPair, ByPairKey>(poolId);
+                        assert(tokenIds);
+                        if (onTransfer({}, provider, {tokenIds->idTokenA, feeA})) {
+                            distributedFeeA += feeA;
+                        }
+                        if (onTransfer({}, provider, {tokenIds->idTokenB, feeB})) {
+                            distributedFeeB += feeB;
+                        }
                     }
-                    if (onTransfer({}, provider, {tokenIds->idTokenB, feeB})) {
-                        distributedFeeB += feeB;
-                    }
-                }
 
-                // distribute yield farming
-                if (poolReward) {
-                    CAmount providerReward;
-                    if (newRewardCalc) {
-                        providerReward = liquidityReward(poolReward, liquidity, totalLiquidity);
-                    } else {
-                        providerReward = poolReward * liqWeight / PRECISION;
-                    }
-                    if (onTransfer({}, provider, {DCT_ID{0}, providerReward})) {
-                        totalDistributed += providerReward;
+                    // distribute yield farming
+                    if (poolReward) {
+                        CAmount providerReward;
+                        if (newRewardCalc) {
+                            providerReward = liquidityReward(poolReward, liquidity, totalLiquidity);
+                        } else {
+                            providerReward = poolReward * liqWeight / PRECISION;
+                        }
+                        if (onTransfer({}, provider, {DCT_ID{0}, providerReward})) {
+                            totalDistributed += providerReward;
+                        }
                     }
-                }
 
-                for (const auto& reward : rewards.balances) {
-                    if (auto providerReward = liquidityReward(reward.second, liquidity, totalLiquidity)) {
-                        onTransfer(*ownerAddress, provider, {reward.first, providerReward});
+                    for (const auto &reward : rewards.balances) {
+                        if (auto providerReward = liquidityReward(reward.second, liquidity, totalLiquidity)) {
+                            onTransfer(*ownerAddress, provider, {reward.first, providerReward});
+                        }
                     }
-                }
 
-                return true;
-            }, PoolShareKey{poolId, CScript{}});
+                    return true;
+                },
+                PoolShareKey{poolId, CScript{}});
         }
 
         if (swapEvent) {
             swapValue->blockCommissionA -= distributedFeeA;
             swapValue->blockCommissionB -= distributedFeeB;
-            poolKey.height++; // block commissions to next block
-            WriteBy<ByPoolSwap>(poolKey, PoolSwapValue{false, swapValue->blockCommissionA, swapValue->blockCommissionB});
+            poolKey.height++;  // block commissions to next block
+            WriteBy<ByPoolSwap>(poolKey,
+                                PoolSwapValue{false, swapValue->blockCommissionA, swapValue->blockCommissionB});
         }
         return true;
     });
     return {totalDistributed, totalLoanDistributed};
 }
 
-Res CPoolPairView::SetShare(DCT_ID const & poolId, CScript const & provider, uint32_t height) {
+Res CPoolPairView::SetShare(DCT_ID const &poolId, const CScript &provider, uint32_t height) {
     WriteBy<ByShare>(PoolShareKey{poolId, provider}, height);
     return Res::Ok();
 }
 
-Res CPoolPairView::DelShare(DCT_ID const & poolId, CScript const & provider) {
+Res CPoolPairView::DelShare(DCT_ID const &poolId, const CScript &provider) {
     EraseBy<ByShare>(PoolShareKey{poolId, provider});
     return Res::Ok();
 }
 
-std::optional<uint32_t> CPoolPairView::GetShare(DCT_ID const & poolId, CScript const & provider) {
+std::optional<uint32_t> CPoolPairView::GetShare(DCT_ID const &poolId, const CScript &provider) {
     if (const auto res = ReadBy<ByShare, uint32_t>(PoolShareKey{poolId, provider}))
         return res;
     return {};
@@ -658,7 +680,7 @@ inline CAmount PoolRewardPerBlock(CAmount dailyReward, CAmount rewardPct) {
     return dailyReward / Params().GetConsensus().blocksPerDay() * rewardPct / COIN;
 }
 
-Res CPoolPairView::SetRewardPct(DCT_ID const & poolId, uint32_t height, CAmount rewardPct) {
+Res CPoolPairView::SetRewardPct(DCT_ID const &poolId, uint32_t height, CAmount rewardPct) {
     if (!HasPoolPair(poolId)) {
         return Res::Err("No such pool pair");
     }
@@ -669,7 +691,7 @@ Res CPoolPairView::SetRewardPct(DCT_ID const & poolId, uint32_t height, CAmount
     return Res::Ok();
 }
 
-Res CPoolPairView::SetRewardLoanPct(DCT_ID const & poolId, uint32_t height, CAmount rewardLoanPct) {
+Res CPoolPairView::SetRewardLoanPct(DCT_ID const &poolId, uint32_t height, CAmount rewardLoanPct) {
     if (!HasPoolPair(poolId)) {
         return Res::Err("No such pool pair");
     }
@@ -681,7 +703,7 @@ Res CPoolPairView::SetRewardLoanPct(DCT_ID const & poolId, uint32_t height, CAmo
 }
 
 Res CPoolPairView::SetDailyReward(uint32_t height, CAmount reward) {
-    ForEachPoolId([&](DCT_ID const & poolId) {
+    ForEachPoolId([&](DCT_ID const &poolId) {
         if (auto rewardPct = ReadBy<ByRewardPct, CAmount>(poolId)) {
             WriteBy<ByPoolReward>(PoolHeightKey{poolId, height}, PoolRewardPerBlock(reward, *rewardPct));
         }
@@ -691,9 +713,8 @@ Res CPoolPairView::SetDailyReward(uint32_t height, CAmount reward) {
     return Res::Ok();
 }
 
-Res CPoolPairView::SetLoanDailyReward(const uint32_t height, const CAmount reward)
-{
-    ForEachPoolId([&](DCT_ID const & poolId) {
+Res CPoolPairView::SetLoanDailyReward(const uint32_t height, const CAmount reward) {
+    ForEachPoolId([&](DCT_ID const &poolId) {
         if (auto rewardLoanPct = ReadBy<ByRewardLoanPct, CAmount>(poolId)) {
             WriteBy<ByPoolLoanReward>(PoolHeightKey{poolId, height}, PoolRewardPerBlock(reward, *rewardLoanPct));
         }
@@ -703,26 +724,27 @@ Res CPoolPairView::SetLoanDailyReward(const uint32_t height, const CAmount rewar
     return Res::Ok();
 }
 
-bool CPoolPairView::HasPoolPair(DCT_ID const & poolId) const {
+bool CPoolPairView::HasPoolPair(DCT_ID const &poolId) const {
     return ExistsBy<ByID>(poolId);
 }
 
-void CPoolPairView::ForEachPoolId(std::function<bool(const DCT_ID &)> callback, DCT_ID const & start) {
-    ForEach<ByID, DCT_ID, CPoolPair>([&callback](const DCT_ID & poolId, CLazySerialize<CPoolPair>) {
-        return callback(poolId);
-    }, start);
+void CPoolPairView::ForEachPoolId(std::function<bool(const DCT_ID &)> callback, DCT_ID const &start) {
+    ForEach<ByID, DCT_ID, CPoolPair>(
+        [&callback](const DCT_ID &poolId, CLazySerialize<CPoolPair>) { return callback(poolId); }, start);
 }
 
-void CPoolPairView::ForEachPoolPair(std::function<bool(const DCT_ID &, CPoolPair)> callback, DCT_ID const & start) {
-    ForEach<ByID, DCT_ID, CPoolPair>([&](const DCT_ID & poolId, CLazySerialize<CPoolPair>) {
-        return callback(poolId, *GetPoolPair(poolId));
-    }, start);
+void CPoolPairView::ForEachPoolPair(std::function<bool(const DCT_ID &, CPoolPair)> callback, DCT_ID const &start) {
+    ForEach<ByID, DCT_ID, CPoolPair>(
+        [&](const DCT_ID &poolId, CLazySerialize<CPoolPair>) { return callback(poolId, *GetPoolPair(poolId)); }, start);
 }
 
-void CPoolPairView::ForEachPoolShare(std::function<bool (DCT_ID const &, CScript const &, uint32_t)> callback, const PoolShareKey &startKey) {
-    ForEach<ByShare, PoolShareKey, uint32_t>([&callback] (PoolShareKey const & poolShareKey, uint32_t height) {
-        return callback(poolShareKey.poolID, poolShareKey.owner, height);
-    }, startKey);
+void CPoolPairView::ForEachPoolShare(std::function<bool(DCT_ID const &, const CScript &, uint32_t)> callback,
+                                     const PoolShareKey &startKey) {
+    ForEach<ByShare, PoolShareKey, uint32_t>(
+        [&callback](const PoolShareKey &poolShareKey, uint32_t height) {
+            return callback(poolShareKey.poolID, poolShareKey.owner, height);
+        },
+        startKey);
 }
 
 Res CPoolPairView::SetDexFeePct(DCT_ID poolId, DCT_ID tokenId, CAmount feePct) {
@@ -740,29 +762,33 @@ Res CPoolPairView::EraseDexFeePct(DCT_ID poolId, DCT_ID tokenId) {
 
 CAmount CPoolPairView::GetDexFeeInPct(DCT_ID poolId, DCT_ID tokenId) const {
     uint32_t feePct;
-    return ReadBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId), feePct)
-        || ReadBy<ByTokenDexFeePct>(std::make_pair(tokenId, DCT_ID{~0u}), feePct)
-        ? feePct : 0;
+    return ReadBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId), feePct) ||
+                   ReadBy<ByTokenDexFeePct>(std::make_pair(tokenId, DCT_ID{~0u}), feePct)
+               ? feePct
+               : 0;
 }
 
 CAmount CPoolPairView::GetDexFeeOutPct(DCT_ID poolId, DCT_ID tokenId) const {
     uint32_t feePct;
-    return ReadBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId), feePct)
-        || ReadBy<ByTokenDexFeePct>(std::make_pair(DCT_ID{~0u}, tokenId), feePct)
-        ? feePct : 0;
+    return ReadBy<ByTokenDexFeePct>(std::make_pair(poolId, tokenId), feePct) ||
+                   ReadBy<ByTokenDexFeePct>(std::make_pair(DCT_ID{~0u}, tokenId), feePct)
+               ? feePct
+               : 0;
 }
 
-bool poolInFee(const bool forward, const std::pair<CFeeDir, CFeeDir>& asymmetricFee) {
-    const auto& [dirA, dirB] = asymmetricFee;
-    if ((forward && (dirA.feeDir == FeeDirValues::Both || dirA.feeDir == FeeDirValues::In)) || (!forward && (dirB.feeDir == FeeDirValues::Both || dirB.feeDir == FeeDirValues::In))) {
+bool poolInFee(const bool forward, const std::pair<CFeeDir, CFeeDir> &asymmetricFee) {
+    const auto &[dirA, dirB] = asymmetricFee;
+    if ((forward && (dirA.feeDir == FeeDirValues::Both || dirA.feeDir == FeeDirValues::In)) ||
+        (!forward && (dirB.feeDir == FeeDirValues::Both || dirB.feeDir == FeeDirValues::In))) {
         return true;
     }
     return false;
 }
 
-bool poolOutFee(const bool forward, const std::pair<CFeeDir, CFeeDir>& asymmetricFee) {
-    const auto& [dirA, dirB] = asymmetricFee;
-    if ((forward && (dirB.feeDir == FeeDirValues::Both || dirB.feeDir == FeeDirValues::Out)) || (!forward && (dirA.feeDir == FeeDirValues::Both || dirA.feeDir == FeeDirValues::Out))) {
+bool poolOutFee(const bool forward, const std::pair<CFeeDir, CFeeDir> &asymmetricFee) {
+    const auto &[dirA, dirB] = asymmetricFee;
+    if ((forward && (dirB.feeDir == FeeDirValues::Both || dirB.feeDir == FeeDirValues::Out)) ||
+        (!forward && (dirA.feeDir == FeeDirValues::Both || dirA.feeDir == FeeDirValues::Out))) {
         return true;
     }
     return false;
diff --git a/src/masternodes/poolpairs.h b/src/masternodes/poolpairs.h
index 08106327e2..bb52a90dda 100644
--- a/src/masternodes/poolpairs.h
+++ b/src/masternodes/poolpairs.h
@@ -10,11 +10,11 @@
 #include <amount.h>
 #include <arith_uint256.h>
 #include <chainparams.h>
+#include <masternodes/balances.h>
 #include <masternodes/res.h>
 #include <script/script.h>
 #include <serialize.h>
 #include <uint256.h>
-#include <masternodes/balances.h>
 
 struct CFeeDir;
 
@@ -25,7 +25,7 @@ struct ByPairKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(idTokenA);
         READWRITE(idTokenB);
     }
@@ -37,17 +37,16 @@ struct PoolPrice {
 
     ADD_SERIALIZE_METHODS;
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(integer);
         READWRITE(fraction);
     }
 
-    bool operator!=(const PoolPrice& rhs) const {
-        return integer != rhs.integer || fraction != rhs.fraction;
-    }
+    bool operator!=(const PoolPrice &rhs) const { return integer != rhs.integer || fraction != rhs.fraction; }
 };
 
-static constexpr auto POOLPRICE_MAX = PoolPrice{std::numeric_limits<CAmount>::max(), std::numeric_limits<CAmount>::max()};
+static constexpr auto POOLPRICE_MAX =
+    PoolPrice{std::numeric_limits<CAmount>::max(), std::numeric_limits<CAmount>::max()};
 
 struct CPoolSwapMessage {
     CScript from, to;
@@ -58,7 +57,7 @@ struct CPoolSwapMessage {
     ADD_SERIALIZE_METHODS
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(idTokenFrom);
         READWRITE(amountFrom);
@@ -75,7 +74,7 @@ struct CPoolSwapMessageV2 {
     ADD_SERIALIZE_METHODS
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(swapInfo);
         READWRITE(poolIDs);
     }
@@ -83,14 +82,14 @@ struct CPoolSwapMessageV2 {
 
 struct CPoolPairMessage {
     DCT_ID idTokenA, idTokenB;
-    CAmount commission;   // comission %% for traders
+    CAmount commission;  // comission %% for traders
     CScript ownerAddress;
     bool status = true;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(idTokenA);
         READWRITE(idTokenB);
         READWRITE(commission);
@@ -99,25 +98,25 @@ struct CPoolPairMessage {
     }
 };
 
-class CPoolPair : public CPoolPairMessage
-{
+class CPoolPair : public CPoolPairMessage {
 public:
     static const CAmount MINIMUM_LIQUIDITY = 1000;
-    static const CAmount SLOPE_SWAP_RATE = 1000;
-    static const uint32_t PRECISION = (uint32_t) COIN; // or just PRECISION_BITS for "<<" and ">>"
-    CPoolPair(CPoolPairMessage const & msg = {}) : CPoolPairMessage(msg) {}
+    static const CAmount SLOPE_SWAP_RATE   = 1000;
+    static const uint32_t PRECISION        = (uint32_t)COIN;  // or just PRECISION_BITS for "<<" and ">>"
+    CPoolPair(const CPoolPairMessage &msg = {})
+        : CPoolPairMessage(msg) {}
     virtual ~CPoolPair() = default;
 
     // temporary values, not serialized
-    CAmount reserveA = 0;
-    CAmount reserveB = 0;
-    CAmount totalLiquidity = 0;
+    CAmount reserveA         = 0;
+    CAmount reserveB         = 0;
+    CAmount totalLiquidity   = 0;
     CAmount blockCommissionA = 0;
     CAmount blockCommissionB = 0;
 
-    CAmount rewardPct = 0;       // pool yield farming reward %%
+    CAmount rewardPct     = 0;  // pool yield farming reward %%
     CAmount rewardLoanPct = 0;
-    bool swapEvent = false;
+    bool swapEvent        = false;
 
     // serialized
     CBalances rewards;
@@ -125,40 +124,47 @@ class CPoolPair : public CPoolPairMessage
     uint32_t creationHeight = -1;
 
     // 'amountA' && 'amountB' should be normalized (correspond) to actual 'tokenA' and 'tokenB' ids in the pair!!
-    // otherwise, 'AddLiquidity' should be () external to 'CPairPool' (i.e. CPoolPairView::AddLiquidity(TAmount a,b etc) with internal lookup of pool by TAmount a,b)
-    Res AddLiquidity(CAmount amountA, CAmount amountB, std::function<Res(CAmount)> onMint, bool slippageProtection = false);
+    // otherwise, 'AddLiquidity' should be () external to 'CPairPool' (i.e. CPoolPairView::AddLiquidity(TAmount a,b etc)
+    // with internal lookup of pool by TAmount a,b)
+    Res AddLiquidity(CAmount amountA,
+                     CAmount amountB,
+                     std::function<Res(CAmount)> onMint,
+                     bool slippageProtection = false);
     Res RemoveLiquidity(CAmount liqAmount, std::function<Res(CAmount, CAmount)> onReclaim);
 
-    Res Swap(CTokenAmount in, CAmount dexfeeInPct, PoolPrice const & maxPrice, const std::pair<CFeeDir, CFeeDir>& asymmetricFee, std::function<Res(CTokenAmount const &, CTokenAmount const &)> onTransfer, int height = INT_MAX);
+    Res Swap(CTokenAmount in,
+             CAmount dexfeeInPct,
+             const PoolPrice &maxPrice,
+             const std::pair<CFeeDir, CFeeDir> &asymmetricFee,
+             std::function<Res(const CTokenAmount &, const CTokenAmount &)> onTransfer,
+             int height = INT_MAX);
 
 private:
-    CAmount slopeSwap(CAmount unswapped, CAmount & poolFrom, CAmount & poolTo, int height);
-
-    inline void ioProofer() const { // Maybe it's more reasonable to use unsigned everywhere, but for basic CAmount compatibility
-        if (reserveA < 0 || reserveB < 0 ||
-            totalLiquidity < 0 ||
-            blockCommissionA < 0 || blockCommissionB < 0 ||
-            rewardPct < 0 || commission < 0 ||
-            rewardLoanPct < 0
-            ) {
+    CAmount slopeSwap(CAmount unswapped, CAmount &poolFrom, CAmount &poolTo, int height);
+
+    inline void ioProofer()
+        const {  // Maybe it's more reasonable to use unsigned everywhere, but for basic CAmount compatibility
+        if (reserveA < 0 || reserveB < 0 || totalLiquidity < 0 || blockCommissionA < 0 || blockCommissionB < 0 ||
+            rewardPct < 0 || commission < 0 || rewardLoanPct < 0) {
             throw std::ios_base::failure("negative pool's 'CAmounts'");
         }
     }
 
 public:
-
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (!ser_action.ForRead()) ioProofer();
+    inline void SerializationOp(Stream &s, Operation ser_action) {
+        if (!ser_action.ForRead())
+            ioProofer();
 
         READWRITEAS(CPoolPairMessage, *this);
         READWRITE(rewards);
         READWRITE(creationTx);
         READWRITE(creationHeight);
 
-        if (ser_action.ForRead()) ioProofer();
+        if (ser_action.ForRead())
+            ioProofer();
     }
 };
 
@@ -169,7 +175,7 @@ struct PoolShareKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(WrapBigEndian(poolID.v));
         READWRITE(owner);
     }
@@ -182,7 +188,7 @@ struct PoolHeightKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(poolID);
 
         if (ser_action.ForRead()) {
@@ -195,77 +201,118 @@ struct PoolHeightKey {
     }
 };
 
-enum RewardType
-{
-    Commission = 127,
-    Rewards = 128,
-    Coinbase = Rewards | 1,
-    Pool = Rewards | 2,
+enum RewardType {
+    Commission         = 127,
+    Rewards            = 128,
+    Coinbase           = Rewards | 1,
+    Pool               = Rewards | 2,
     LoanTokenDEXReward = Rewards | 4,
 };
 
 std::string RewardToString(RewardType type);
 std::string RewardTypeToString(RewardType type);
 
-class CPoolPairView : public virtual CStorageView
-{
+class CPoolPairView : public virtual CStorageView {
 public:
-    Res SetPoolPair(const DCT_ID &poolId, uint32_t height, CPoolPair const & pool);
-    Res UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool status, CAmount const & commission, CScript const & ownerAddress, CBalances const & rewards);
+    Res SetPoolPair(const DCT_ID &poolId, uint32_t height, const CPoolPair &pool);
+    Res UpdatePoolPair(DCT_ID const &poolId,
+                       uint32_t height,
+                       bool status,
+                       const CAmount &commission,
+                       const CScript &ownerAddress,
+                       const CBalances &rewards);
 
     std::optional<CPoolPair> GetPoolPair(const DCT_ID &poolId) const;
-    std::optional<std::pair<DCT_ID, CPoolPair> > GetPoolPair(DCT_ID const & tokenA, DCT_ID const & tokenB) const;
+    std::optional<std::pair<DCT_ID, CPoolPair> > GetPoolPair(DCT_ID const &tokenA, DCT_ID const &tokenB) const;
 
-    void ForEachPoolId(std::function<bool(DCT_ID const &)> callback, DCT_ID const & start = DCT_ID{0});
-    void ForEachPoolPair(std::function<bool(DCT_ID const &, CPoolPair)> callback, DCT_ID const & start = DCT_ID{0});
-    void ForEachPoolShare(std::function<bool(DCT_ID const &, CScript const &, uint32_t)> callback, PoolShareKey const &startKey = {});
+    void ForEachPoolId(std::function<bool(DCT_ID const &)> callback, DCT_ID const &start = DCT_ID{0});
+    void ForEachPoolPair(std::function<bool(DCT_ID const &, CPoolPair)> callback, DCT_ID const &start = DCT_ID{0});
+    void ForEachPoolShare(std::function<bool(DCT_ID const &, const CScript &, uint32_t)> callback,
+                          const PoolShareKey &startKey = {});
 
-    Res SetShare(DCT_ID const & poolId, CScript const & provider, uint32_t height);
-    Res DelShare(DCT_ID const & poolId, CScript const & provider);
+    Res SetShare(DCT_ID const &poolId, const CScript &provider, uint32_t height);
+    Res DelShare(DCT_ID const &poolId, const CScript &provider);
 
-    std::optional<uint32_t> GetShare(DCT_ID const & poolId, CScript const & provider);
+    std::optional<uint32_t> GetShare(DCT_ID const &poolId, const CScript &provider);
 
-    void CalculatePoolRewards(DCT_ID const & poolId, std::function<CAmount()> onLiquidity, uint32_t begin, uint32_t end, std::function<void(RewardType, CTokenAmount, uint32_t)> onReward);
+    void CalculatePoolRewards(DCT_ID const &poolId,
+                              std::function<CAmount()> onLiquidity,
+                              uint32_t begin,
+                              uint32_t end,
+                              std::function<void(RewardType, CTokenAmount, uint32_t)> onReward);
 
     Res SetLoanDailyReward(const uint32_t height, const CAmount reward);
     Res SetDailyReward(uint32_t height, CAmount reward);
-    Res SetRewardPct(DCT_ID const & poolId, uint32_t height, CAmount rewardPct);
-    Res SetRewardLoanPct(DCT_ID const & poolId, uint32_t height, CAmount rewardLoanPct);
-    bool HasPoolPair(DCT_ID const & poolId) const;
+    Res SetRewardPct(DCT_ID const &poolId, uint32_t height, CAmount rewardPct);
+    Res SetRewardLoanPct(DCT_ID const &poolId, uint32_t height, CAmount rewardLoanPct);
+    bool HasPoolPair(DCT_ID const &poolId) const;
 
     Res SetDexFeePct(DCT_ID poolId, DCT_ID tokenId, CAmount feePct);
     Res 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;
 
-    std::pair<CAmount, CAmount> UpdatePoolRewards(std::function<CTokenAmount(CScript const &, DCT_ID)> onGetBalance, std::function<Res(CScript const &, CScript const &, CTokenAmount)> onTransfer, int nHeight = 0);
+    std::pair<CAmount, CAmount> UpdatePoolRewards(
+        std::function<CTokenAmount(const CScript &, DCT_ID)> onGetBalance,
+        std::function<Res(const CScript &, const CScript &, CTokenAmount)> onTransfer,
+        int nHeight = 0);
 
     // tags
-    struct ByID             { static constexpr uint8_t prefix() { return 'i'; } };
-    struct ByPair           { static constexpr uint8_t prefix() { return 'j'; } };
-    struct ByShare          { static constexpr uint8_t prefix() { return 'k'; } };
-    struct ByIDPair         { static constexpr uint8_t prefix() { return 'C'; } };
-    struct ByPoolSwap       { static constexpr uint8_t prefix() { return 'P'; } };
-    struct ByReserves       { static constexpr uint8_t prefix() { return 'R'; } };
-    struct ByRewardPct      { static constexpr uint8_t prefix() { return 'Q'; } };
-    struct ByPoolReward     { static constexpr uint8_t prefix() { return 'I'; } };
-    struct ByDailyReward    { static constexpr uint8_t prefix() { return 'B'; } };
-    struct ByCustomReward   { static constexpr uint8_t prefix() { return 'A'; } };
-    struct ByTotalLiquidity { static constexpr uint8_t prefix() { return 'f'; } };
-    struct ByDailyLoanReward{ static constexpr uint8_t prefix() { return 'q'; } };
-    struct ByRewardLoanPct  { static constexpr uint8_t prefix() { return 'U'; } };
-    struct ByPoolLoanReward { static constexpr uint8_t prefix() { return 'W'; } };
-    struct ByTokenDexFeePct { static constexpr uint8_t prefix() { return 'l'; } };
+    struct ByID {
+        static constexpr uint8_t prefix() { return 'i'; }
+    };
+    struct ByPair {
+        static constexpr uint8_t prefix() { return 'j'; }
+    };
+    struct ByShare {
+        static constexpr uint8_t prefix() { return 'k'; }
+    };
+    struct ByIDPair {
+        static constexpr uint8_t prefix() { return 'C'; }
+    };
+    struct ByPoolSwap {
+        static constexpr uint8_t prefix() { return 'P'; }
+    };
+    struct ByReserves {
+        static constexpr uint8_t prefix() { return 'R'; }
+    };
+    struct ByRewardPct {
+        static constexpr uint8_t prefix() { return 'Q'; }
+    };
+    struct ByPoolReward {
+        static constexpr uint8_t prefix() { return 'I'; }
+    };
+    struct ByDailyReward {
+        static constexpr uint8_t prefix() { return 'B'; }
+    };
+    struct ByCustomReward {
+        static constexpr uint8_t prefix() { return 'A'; }
+    };
+    struct ByTotalLiquidity {
+        static constexpr uint8_t prefix() { return 'f'; }
+    };
+    struct ByDailyLoanReward {
+        static constexpr uint8_t prefix() { return 'q'; }
+    };
+    struct ByRewardLoanPct {
+        static constexpr uint8_t prefix() { return 'U'; }
+    };
+    struct ByPoolLoanReward {
+        static constexpr uint8_t prefix() { return 'W'; }
+    };
+    struct ByTokenDexFeePct {
+        static constexpr uint8_t prefix() { return 'l'; }
+    };
 };
 
 struct CLiquidityMessage {
-    CAccounts from; // from -> balances
+    CAccounts from;  // from -> balances
     CScript shareAddress;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(shareAddress);
     }
@@ -278,13 +325,13 @@ struct CRemoveLiquidityMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(from);
         READWRITE(amount);
     }
 };
 
-bool poolInFee(const bool forward, const std::pair<CFeeDir, CFeeDir>& asymmetricFee);
-bool poolOutFee(const bool forward, const std::pair<CFeeDir, CFeeDir>& asymmetricFee);
+bool poolInFee(const bool forward, const std::pair<CFeeDir, CFeeDir> &asymmetricFee);
+bool poolOutFee(const bool forward, const std::pair<CFeeDir, CFeeDir> &asymmetricFee);
 
-#endif // DEFI_MASTERNODES_POOLPAIRS_H
+#endif  // DEFI_MASTERNODES_POOLPAIRS_H
diff --git a/src/masternodes/proposals.cpp b/src/masternodes/proposals.cpp
index e946c3fcf0..f3ee266712 100644
--- a/src/masternodes/proposals.cpp
+++ b/src/masternodes/proposals.cpp
@@ -3,66 +3,67 @@
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <masternodes/proposals.h>
 #include <masternodes/masternodes.h>
+#include <masternodes/proposals.h>
 
-std::string CPropTypeToString(const CPropType status)
-{
-    switch(status) {
-        case CPropType::CommunityFundProposal:  return "CommunityFundProposal";
-        case CPropType::VoteOfConfidence:       return "VoteOfConfidence";
+std::string CPropTypeToString(const CPropType status) {
+    switch (status) {
+        case CPropType::CommunityFundProposal:
+            return "CommunityFundProposal";
+        case CPropType::VoteOfConfidence:
+            return "VoteOfConfidence";
     }
     return "Unknown";
 }
 
-std::string CPropOptionToString(const CPropOption option)
-{
-    switch(option) {
-        case CPropOption::Emergency:  return "Emergency";
+std::string CPropOptionToString(const CPropOption option) {
+    switch (option) {
+        case CPropOption::Emergency:
+            return "Emergency";
     }
     return "Unknown";
 }
 
-std::string CPropStatusToString(const CPropStatusType status)
-{
-    switch(status) {
-        case CPropStatusType::Voting:    return "Voting";
-        case CPropStatusType::Rejected:  return "Rejected";
-        case CPropStatusType::Completed: return "Completed";
+std::string CPropStatusToString(const CPropStatusType status) {
+    switch (status) {
+        case CPropStatusType::Voting:
+            return "Voting";
+        case CPropStatusType::Rejected:
+            return "Rejected";
+        case CPropStatusType::Completed:
+            return "Completed";
     }
     return "Unknown";
 }
 
-std::string CPropVoteToString(const CPropVoteType vote)
-{
-    switch(vote) {
-        case CPropVoteType::VoteNo:      return "NO";
-        case CPropVoteType::VoteYes:     return "YES";
-        case CPropVoteType::VoteNeutral: return "NEUTRAL";
+std::string CPropVoteToString(const CPropVoteType vote) {
+    switch (vote) {
+        case CPropVoteType::VoteNo:
+            return "NO";
+        case CPropVoteType::VoteYes:
+            return "YES";
+        case CPropVoteType::VoteNeutral:
+            return "NEUTRAL";
     }
     return "Unknown";
 }
 
-Res CPropsView::CreateProp(const CPropId& propId, uint32_t height, const CCreatePropMessage& msg, const CAmount fee)
-{
+Res CPropsView::CreateProp(const CPropId &propId, uint32_t height, const CCreatePropMessage &msg, const CAmount fee) {
     CPropObject prop{msg};
     bool emergency = prop.options & CPropOption::Emergency;
-    auto type = static_cast<CPropType>(prop.type);
+    auto type      = static_cast<CPropType>(prop.type);
 
     prop.creationHeight = height;
-    prop.votingPeriod = (emergency ? GetEmergencyPeriodFromAttributes(type) : GetVotingPeriodFromAttributes());
-    prop.fee = fee;
-    prop.feeBurnAmount = MultiplyAmounts(fee, GetFeeBurnPctFromAttributes());
+    prop.votingPeriod   = (emergency ? GetEmergencyPeriodFromAttributes(type) : GetVotingPeriodFromAttributes());
+    prop.fee            = fee;
+    prop.feeBurnAmount  = MultiplyAmounts(fee, GetFeeBurnPctFromAttributes());
 
     auto key = std::make_pair(uint8_t(CPropStatusType::Voting), propId);
     WriteBy<ByStatus>(key, static_cast<uint8_t>(1));
-    if (emergency)
-    {
+    if (emergency) {
         height += prop.votingPeriod;
         WriteBy<ByCycle>(std::make_pair(height, propId), static_cast<uint8_t>(1));
-    }
-    else
-    {
+    } else {
         height = height + (prop.votingPeriod - height % prop.votingPeriod);
         for (uint8_t i = 1; i <= prop.nCycles; ++i) {
             height += prop.votingPeriod;
@@ -75,8 +76,7 @@ Res CPropsView::CreateProp(const CPropId& propId, uint32_t height, const CCreate
     return Res::Ok();
 }
 
-std::optional<CPropObject> CPropsView::GetProp(const CPropId& propId)
-{
+std::optional<CPropObject> CPropsView::GetProp(const CPropId &propId) {
     auto prop = ReadBy<ByType, CPropObject>(propId);
     if (!prop)
         return prop;
@@ -84,25 +84,25 @@ std::optional<CPropObject> CPropsView::GetProp(const CPropId& propId)
     auto guessStatus = [&](CPropStatusType status) {
         auto key = std::make_pair(uint8_t(status), propId);
         if (auto cycle = ReadBy<ByStatus, uint8_t>(key)) {
-            prop->cycle = *cycle;
-            prop->status = status;
-            prop->cycleEndHeight = prop->creationHeight + (prop->votingPeriod - prop->creationHeight % prop->votingPeriod) + prop->votingPeriod * *cycle;
+            prop->cycle          = *cycle;
+            prop->status         = status;
+            prop->cycleEndHeight = prop->creationHeight +
+                                   (prop->votingPeriod - prop->creationHeight % prop->votingPeriod) +
+                                   prop->votingPeriod * *cycle;
             return true;
         }
         return false;
     };
-    guessStatus(CPropStatusType::Voting)   ||
-    guessStatus(CPropStatusType::Rejected) ||
-    guessStatus(CPropStatusType::Completed);
+    guessStatus(CPropStatusType::Voting) || guessStatus(CPropStatusType::Rejected) ||
+        guessStatus(CPropStatusType::Completed);
     return prop;
 }
 
-Res CPropsView::UpdatePropCycle(const CPropId& propId, uint8_t cycle)
-{
+Res CPropsView::UpdatePropCycle(const CPropId &propId, uint8_t cycle) {
     if (cycle < 1 || cycle > 3)
         return Res::Err("Cycle out of range");
 
-    auto key = std::make_pair(uint8_t(CPropStatusType::Voting), propId);
+    auto key    = std::make_pair(uint8_t(CPropStatusType::Voting), propId);
     auto pcycle = ReadBy<ByStatus, uint8_t>(key);
     if (!pcycle)
         Res::Err("Proposal <%s> is not in voting period", propId.GetHex());
@@ -114,9 +114,8 @@ Res CPropsView::UpdatePropCycle(const CPropId& propId, uint8_t cycle)
     return Res::Ok();
 }
 
-Res CPropsView::UpdatePropStatus(const CPropId& propId, uint32_t height, CPropStatusType status)
-{
-    auto key = std::make_pair(uint8_t(CPropStatusType::Voting), propId);
+Res CPropsView::UpdatePropStatus(const CPropId &propId, uint32_t height, CPropStatusType status) {
+    auto key  = std::make_pair(uint8_t(CPropStatusType::Voting), propId);
     auto stat = ReadBy<ByStatus, uint8_t>(key);
     if (!stat)
         return Res::Err("Proposal <%s> is not in voting period", propId.GetHex());
@@ -132,9 +131,9 @@ Res CPropsView::UpdatePropStatus(const CPropId& propId, uint32_t height, CPropSt
     auto p_prop = GetProp(propId);
     assert(p_prop);
 
-    uint8_t i = 0;
+    uint8_t i   = 0;
     auto cycles = p_prop->nCycles;
-    auto ckey = std::make_pair(p_prop->creationHeight, propId);
+    auto ckey   = std::make_pair(p_prop->creationHeight, propId);
     for (auto it = LowerBound<ByCycle>(ckey); i < cycles && it.Valid(); it.Next()) {
         if (it.Key().second == propId) {
             EraseBy<ByCycle>(it.Key());
@@ -149,8 +148,7 @@ Res CPropsView::UpdatePropStatus(const CPropId& propId, uint32_t height, CPropSt
     return Res::Ok();
 }
 
-Res CPropsView::AddPropVote(const CPropId& propId, const uint256& masternodeId, CPropVoteType vote)
-{
+Res CPropsView::AddPropVote(const CPropId &propId, const uint256 &masternodeId, CPropVoteType vote) {
     auto cycle = ReadBy<ByStatus, uint8_t>(std::make_pair(uint8_t(CPropStatusType::Voting), propId));
     if (!cycle)
         return Res::Err("Proposal <%s> is not in voting period", propId.GetHex());
@@ -160,8 +158,9 @@ Res CPropsView::AddPropVote(const CPropId& propId, const uint256& masternodeId,
     return Res::Ok();
 }
 
-std::optional<CPropVoteType> CPropsView::GetPropVote(const CPropId& propId, uint8_t cycle, const uint256& masternodeId)
-{
+std::optional<CPropVoteType> CPropsView::GetPropVote(const CPropId &propId,
+                                                     uint8_t cycle,
+                                                     const uint256 &masternodeId) {
     CMnVotePerCycle key{propId, cycle, masternodeId};
     auto vote = ReadBy<ByMnVote, uint8_t>(key);
     if (!vote)
@@ -169,31 +168,35 @@ std::optional<CPropVoteType> CPropsView::GetPropVote(const CPropId& propId, uint
     return static_cast<CPropVoteType>(*vote);
 }
 
-void CPropsView::ForEachProp(std::function<bool(CPropId const &, CPropObject const &)> callback, uint8_t status)
-{
-    ForEach<ByStatus, std::pair<uint8_t, uint256>, uint8_t>([&](const std::pair<uint8_t, uint256>& key, uint8_t i) {
-        auto prop = GetProp(key.second);
-        assert(prop);
-        return callback(key.second, *prop);
-    }, std::make_pair(status, uint256{}));
+void CPropsView::ForEachProp(std::function<bool(const CPropId &, const CPropObject &)> callback, uint8_t status) {
+    ForEach<ByStatus, std::pair<uint8_t, uint256>, uint8_t>(
+        [&](const std::pair<uint8_t, uint256> &key, uint8_t i) {
+            auto prop = GetProp(key.second);
+            assert(prop);
+            return callback(key.second, *prop);
+        },
+        std::make_pair(status, uint256{}));
 }
 
-void CPropsView::ForEachPropVote(std::function<bool(CPropId const &, uint8_t, uint256 const &, CPropVoteType)> callback, CMnVotePerCycle const & start)
-{
-    ForEach<ByMnVote, CMnVotePerCycle, uint8_t>([&](const CMnVotePerCycle& key, uint8_t vote) {
-        return callback(key.propId, key.cycle, key.masternodeId, static_cast<CPropVoteType>(vote));
-    }, start);
+void CPropsView::ForEachPropVote(std::function<bool(const CPropId &, uint8_t, const uint256 &, CPropVoteType)> callback,
+                                 const CMnVotePerCycle &start) {
+    ForEach<ByMnVote, CMnVotePerCycle, uint8_t>(
+        [&](const CMnVotePerCycle &key, uint8_t vote) {
+            return callback(key.propId, key.cycle, key.masternodeId, static_cast<CPropVoteType>(vote));
+        },
+        start);
 }
 
-void CPropsView::ForEachCycleProp(std::function<bool(CPropId const &, CPropObject const &)> callback, uint32_t height)
-{
-    ForEach<ByCycle, std::pair<uint32_t, uint256>, uint8_t>([&](const std::pair<uint32_t, uint256>& key, uint8_t i) {
-        // limited to exact height
-        if (key.first != height)
-            return false;
-
-        auto prop = GetProp(key.second);
-        assert(prop);
-        return callback(key.second, *prop);
-    }, std::make_pair(height, uint256{}));
+void CPropsView::ForEachCycleProp(std::function<bool(const CPropId &, const CPropObject &)> callback, uint32_t height) {
+    ForEach<ByCycle, std::pair<uint32_t, uint256>, uint8_t>(
+        [&](const std::pair<uint32_t, uint256> &key, uint8_t i) {
+            // limited to exact height
+            if (key.first != height)
+                return false;
+
+            auto prop = GetProp(key.second);
+            assert(prop);
+            return callback(key.second, *prop);
+        },
+        std::make_pair(height, uint256{}));
 }
diff --git a/src/masternodes/proposals.h b/src/masternodes/proposals.h
index 98f592809e..8d054ad60c 100644
--- a/src/masternodes/proposals.h
+++ b/src/masternodes/proposals.h
@@ -12,19 +12,19 @@
 #include <serialize.h>
 #include <uint256.h>
 
-using CPropId = uint256;
-constexpr const uint8_t VOC_CYCLES = 2;
-constexpr const uint8_t MAX_CYCLES = 100;
-constexpr const uint16_t MAX_PROP_TITLE_SIZE = 128;
+using CPropId                                  = uint256;
+constexpr const uint8_t VOC_CYCLES             = 2;
+constexpr const uint8_t MAX_CYCLES             = 100;
+constexpr const uint16_t MAX_PROP_TITLE_SIZE   = 128;
 constexpr const uint16_t MAX_PROP_CONTEXT_SIZE = 512;
 
 enum CPropType : uint8_t {
-    CommunityFundProposal   = 0x01,
-    VoteOfConfidence        = 0x02,
+    CommunityFundProposal = 0x01,
+    VoteOfConfidence      = 0x02,
 };
 
 enum CPropOption : uint8_t {
-    Emergency   = 0x01,
+    Emergency = 0x01,
 };
 
 enum CPropStatusType : uint8_t {
@@ -57,8 +57,7 @@ struct CCreatePropMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(type);
         READWRITE(address);
         READWRITE(nAmount);
@@ -78,8 +77,7 @@ struct CPropVoteMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(propId);
         READWRITE(masternodeId);
         READWRITE(vote);
@@ -88,7 +86,8 @@ struct CPropVoteMessage {
 
 struct CPropObject : public CCreatePropMessage {
     CPropObject() = default;
-    explicit CPropObject(const CCreatePropMessage& other) : CCreatePropMessage(other) {}
+    explicit CPropObject(const CCreatePropMessage &other)
+        : CCreatePropMessage(other) {}
 
     uint32_t creationHeight{};
     uint32_t proposalEndHeight{};
@@ -105,8 +104,7 @@ struct CPropObject : public CCreatePropMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CCreatePropMessage, *this);
         READWRITE(creationHeight);
         READWRITE(proposalEndHeight);
@@ -124,8 +122,7 @@ struct CMnVotePerCycle {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(propId);
         READWRITE(cycle);
         READWRITE(masternodeId);
@@ -133,32 +130,41 @@ struct CMnVotePerCycle {
 };
 
 /// View for managing proposals and their data
-class CPropsView : public virtual CStorageView
-{
+class CPropsView : public virtual CStorageView {
 public:
-
-    Res CreateProp(const CPropId& propId, uint32_t height, const CCreatePropMessage& prop, const CAmount fee);
-    std::optional<CPropObject> GetProp(const CPropId& propId);
-    Res UpdatePropCycle(const CPropId& propId, uint8_t cycle);
-    Res UpdatePropStatus(const CPropId& propId, uint32_t height, CPropStatusType status);
-    Res AddPropVote(const CPropId& propId, const uint256& masternodeId, CPropVoteType vote);
-    std::optional<CPropVoteType> GetPropVote(const CPropId& propId, uint8_t cycle, const uint256& masternodeId);
-
-    void ForEachProp(std::function<bool(CPropId const &, CPropObject const &)> callback, uint8_t status = 0);
-    void ForEachPropVote(std::function<bool(CPropId const &, uint8_t, uint256 const &, CPropVoteType)> callback, CMnVotePerCycle const & start = {});
-    void ForEachCycleProp(std::function<bool(CPropId const &, CPropObject const &)> callback, uint32_t height);
-
-    virtual uint32_t GetVotingPeriodFromAttributes() const = 0;
-    virtual uint32_t GetEmergencyPeriodFromAttributes(const CPropType& type) const = 0;
-    virtual CAmount GetApprovalThresholdFromAttributes(const CPropType& type) const = 0;
-    virtual CAmount GetQuorumFromAttributes(const CPropType& type, bool emergency = false) const = 0;
-    virtual CAmount GetFeeBurnPctFromAttributes() const = 0;
-
-    struct ByType   { static constexpr uint8_t prefix() { return 0x2B; } };
-    struct ByCycle  { static constexpr uint8_t prefix() { return 0x2C; } };
-    struct ByMnVote { static constexpr uint8_t prefix() { return 0x2D; } };
-    struct ByStatus { static constexpr uint8_t prefix() { return 0x2E; } };
-    struct ByVoting { static constexpr uint8_t prefix() { return 0x2F; } };
+    Res CreateProp(const CPropId &propId, uint32_t height, const CCreatePropMessage &prop, const CAmount fee);
+    std::optional<CPropObject> GetProp(const CPropId &propId);
+    Res UpdatePropCycle(const CPropId &propId, uint8_t cycle);
+    Res UpdatePropStatus(const CPropId &propId, uint32_t height, CPropStatusType status);
+    Res AddPropVote(const CPropId &propId, const uint256 &masternodeId, CPropVoteType vote);
+    std::optional<CPropVoteType> GetPropVote(const CPropId &propId, uint8_t cycle, const uint256 &masternodeId);
+
+    void ForEachProp(std::function<bool(const CPropId &, const CPropObject &)> callback, uint8_t status = 0);
+    void ForEachPropVote(std::function<bool(const CPropId &, uint8_t, const uint256 &, CPropVoteType)> callback,
+                         const CMnVotePerCycle &start = {});
+    void ForEachCycleProp(std::function<bool(const CPropId &, const CPropObject &)> callback, uint32_t height);
+
+    virtual uint32_t GetVotingPeriodFromAttributes() const                                       = 0;
+    virtual uint32_t GetEmergencyPeriodFromAttributes(const CPropType &type) const               = 0;
+    virtual CAmount GetApprovalThresholdFromAttributes(const CPropType &type) const              = 0;
+    virtual CAmount GetQuorumFromAttributes(const CPropType &type, bool emergency = false) const = 0;
+    virtual CAmount GetFeeBurnPctFromAttributes() const                                          = 0;
+
+    struct ByType {
+        static constexpr uint8_t prefix() { return 0x2B; }
+    };
+    struct ByCycle {
+        static constexpr uint8_t prefix() { return 0x2C; }
+    };
+    struct ByMnVote {
+        static constexpr uint8_t prefix() { return 0x2D; }
+    };
+    struct ByStatus {
+        static constexpr uint8_t prefix() { return 0x2E; }
+    };
+    struct ByVoting {
+        static constexpr uint8_t prefix() { return 0x2F; }
+    };
 };
 
-#endif // DEFI_MASTERNODES_PROPOSALS_H
+#endif  // DEFI_MASTERNODES_PROPOSALS_H
diff --git a/src/masternodes/res.h b/src/masternodes/res.h
index 35377e5780..bd75f28045 100644
--- a/src/masternodes/res.h
+++ b/src/masternodes/res.h
@@ -1,84 +1,79 @@
 #ifndef DEFI_MASTERNODES_RES_H
 #define DEFI_MASTERNODES_RES_H
 
+#include <tinyformat.h>
 #include <optional>
 #include <string>
-#include <tinyformat.h>
 
-struct Res
-{
+struct Res {
     bool ok;
     std::string msg;
     uint32_t code;
-    std::string dbgMsg; // CValidationState support
+    std::string dbgMsg;  // CValidationState support
 
     Res() = delete;
 
-    operator bool() const {
-        return ok;
-    }
+    operator bool() const { return ok; }
 
-    template<typename... Args>
-    static Res Err(std::string const & err, const Args&... args) {
-        return Res{false, tfm::format(err, args...), 0, {} };
+    template <typename... Args>
+    static Res Err(const std::string &err, const Args &...args) {
+        return Res{false, tfm::format(err, args...), 0, {}};
     }
 
-    template<typename... Args>
-    static Res ErrCode(uint32_t code, std::string const & err, const Args&... args) {
-        return Res{false, tfm::format(err, args...), code, {} };
+    template <typename... Args>
+    static Res ErrCode(uint32_t code, const std::string &err, const Args &...args) {
+        return Res{false, tfm::format(err, args...), code, {}};
     }
 
     // extended version just for CValidationState support
-    template<typename... Args>
-    static Res ErrDbg(std::string const & debugMsg, std::string const & err, const Args&... args) {
-        return {false, tfm::format(err, args...), 0, debugMsg };
+    template <typename... Args>
+    static Res ErrDbg(const std::string &debugMsg, const std::string &err, const Args &...args) {
+        return {false, tfm::format(err, args...), 0, debugMsg};
     }
 
-    template<typename... Args>
-    static Res Ok(std::string const & msg, const Args&... args) {
-        return Res{true, tfm::format(msg, args...), 0, {} };
+    template <typename... Args>
+    static Res Ok(const std::string &msg, const Args &...args) {
+        return Res{true, tfm::format(msg, args...), 0, {}};
     }
 
-    static Res Ok() {
-        return Res{true, {}, 0, {} };
-    }
+    static Res Ok() { return Res{true, {}, 0, {}}; }
 };
 
 template <typename T>
-struct ResVal : public Res
-{
+struct ResVal : public Res {
     std::optional<T> val{};
 
     ResVal() = delete;
 
-    ResVal(Res const & errRes) : Res(errRes) {
-        assert(!this->ok); // if value is not provided, then it's always an error
+    ResVal(const Res &errRes)
+        : Res(errRes) {
+        assert(!this->ok);  // if value is not provided, then it's always an error
     }
-    ResVal(T value, Res const & okRes) : Res(okRes), val(std::move(value)) {
-        assert(this->ok); // if value if provided, then it's never an error
+    ResVal(T value, const Res &okRes)
+        : Res(okRes),
+          val(std::move(value)) {
+        assert(this->ok);  // if value if provided, then it's never an error
     }
 
-    operator bool() const {
-        return ok;
-    }
+    operator bool() const { return ok; }
 
     operator T() const {
         assert(ok);
         return *val;
     }
 
-    const T& operator*() const {
+    const T &operator*() const {
         assert(ok);
         return *val;
     }
 
-    T& operator*() {
+    T &operator*() {
         assert(ok);
         return *val;
     }
 
     template <typename F>
-    T ValOrException(F&& func) const {
+    T ValOrException(F &&func) const {
         if (!ok) {
             throw func(code, msg);
         }
@@ -93,4 +88,4 @@ struct ResVal : public Res
     }
 };
 
-#endif //DEFI_MASTERNODES_RES_H
+#endif  // DEFI_MASTERNODES_RES_H
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index e92a5d3ec9..8a237f5260 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -1,23 +1,22 @@
 
 #include <core_io.h>
 #include <key_io.h>
-#include <masternodes/res.h>
 #include <masternodes/mn_checks.h>
+#include <masternodes/res.h>
 #include <primitives/transaction.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <univalue.h>
 
-extern std::string ScriptToString(CScript const& script);
+extern std::string ScriptToString(const CScript &script);
 
-class CCustomTxRpcVisitor
-{
+class CCustomTxRpcVisitor {
     uint32_t height;
-    UniValue& rpcInfo;
-    CCustomCSView& mnview;
-    const CTransaction& tx;
+    UniValue &rpcInfo;
+    CCustomCSView &mnview;
+    const CTransaction &tx;
 
-    void tokenInfo(const CToken& token) const {
+    void tokenInfo(const CToken &token) const {
         rpcInfo.pushKV("name", token.name);
         rpcInfo.pushKV("symbol", token.symbol);
         rpcInfo.pushKV("isDAT", token.IsDAT());
@@ -26,9 +25,9 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("finalized", token.IsFinalized());
     }
 
-    void customRewardsInfo(const CBalances& rewards) const {
+    void customRewardsInfo(const CBalances &rewards) const {
         UniValue rewardArr(UniValue::VARR);
-        for (const auto& reward : rewards.balances) {
+        for (const auto &reward : rewards.balances) {
             if (reward.second > 0) {
                 rewardArr.push_back(CTokenAmount{reward.first, reward.second}.ToString());
             }
@@ -38,17 +37,17 @@ class CCustomTxRpcVisitor
         }
     }
 
-    UniValue accountsInfo(const CAccounts& accounts) const {
+    UniValue accountsInfo(const CAccounts &accounts) const {
         UniValue info(UniValue::VOBJ);
-        for (const auto& account : accounts) {
+        for (const auto &account : accounts) {
             info.pushKV(ScriptToString(account.first), account.second.ToString());
         }
         return info;
     }
 
-    void tokenCurrencyPairInfo(const std::set<CTokenCurrencyPair>& pairs) const {
+    void tokenCurrencyPairInfo(const std::set<CTokenCurrencyPair> &pairs) const {
         UniValue availablePairs(UniValue::VARR);
-        for (const auto& pair : pairs) {
+        for (const auto &pair : pairs) {
             UniValue uniPair(UniValue::VOBJ);
             uniPair.pushKV("token", pair.first);
             uniPair.pushKV("currency", pair.second);
@@ -57,76 +56,74 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("availablePairs", availablePairs);
     }
 
-    UniValue tokenBalances(const CBalances& balances) const {
+    UniValue tokenBalances(const CBalances &balances) const {
         UniValue info(UniValue::VOBJ);
-        for (const auto& kv : balances.balances) {
+        for (const auto &kv : balances.balances) {
             info.pushKV(kv.first.ToString(), ValueFromAmount(kv.second));
         }
         return info;
     }
 
 public:
-    CCustomTxRpcVisitor(const CTransaction& tx, uint32_t height, CCustomCSView& mnview, UniValue& rpcInfo)
-        : height(height), rpcInfo(rpcInfo), mnview(mnview), tx(tx) {
-    }
+    CCustomTxRpcVisitor(const CTransaction &tx, uint32_t height, CCustomCSView &mnview, UniValue &rpcInfo)
+        : height(height),
+          rpcInfo(rpcInfo),
+          mnview(mnview),
+          tx(tx) {}
 
-    void operator()(const CCreateMasterNodeMessage& obj) const {
+    void operator()(const CCreateMasterNodeMessage &obj) const {
         rpcInfo.pushKV("collateralamount", ValueFromAmount(GetMnCollateralAmount(height)));
-        rpcInfo.pushKV("masternodeoperator", EncodeDestination(obj.operatorType == PKHashType ?
-                                                CTxDestination(PKHash(obj.operatorAuthAddress)) :
-                                                CTxDestination(WitnessV0KeyHash(obj.operatorAuthAddress))));
+        rpcInfo.pushKV("masternodeoperator",
+                       EncodeDestination(obj.operatorType == PKHashType
+                                             ? CTxDestination(PKHash(obj.operatorAuthAddress))
+                                             : CTxDestination(WitnessV0KeyHash(obj.operatorAuthAddress))));
         rpcInfo.pushKV("timelock", CMasternode::GetTimelockToString(static_cast<CMasternode::TimeLock>(obj.timelock)));
     }
 
-    void operator()(const CResignMasterNodeMessage& obj) const {
-        rpcInfo.pushKV("id", obj.GetHex());
-    }
+    void operator()(const CResignMasterNodeMessage &obj) const { rpcInfo.pushKV("id", obj.GetHex()); }
 
-    void operator()(const CUpdateMasterNodeMessage& obj) const {
+    void operator()(const CUpdateMasterNodeMessage &obj) const {
         rpcInfo.pushKV("id", obj.mnId.GetHex());
-        for (const auto& [updateType, addressPair] : obj.updates) {
-            const auto& [addressType, rawAddress] = addressPair;
+        for (const auto &[updateType, addressPair] : obj.updates) {
+            const auto &[addressType, rawAddress] = addressPair;
             if (updateType == static_cast<uint8_t>(UpdateMasternodeType::OperatorAddress)) {
-                rpcInfo.pushKV("operatorAddress", EncodeDestination(addressType == PKHashType ?
-                                                                    CTxDestination(PKHash(rawAddress)) :
-                                                                    CTxDestination(WitnessV0KeyHash(rawAddress))));
+                rpcInfo.pushKV(
+                    "operatorAddress",
+                    EncodeDestination(addressType == PKHashType ? CTxDestination(PKHash(rawAddress))
+                                                                : CTxDestination(WitnessV0KeyHash(rawAddress))));
             } else if (updateType == static_cast<uint8_t>(UpdateMasternodeType::OwnerAddress)) {
-                rpcInfo.pushKV("ownerAddress", EncodeDestination(addressType == PKHashType ?
-                                                                    CTxDestination(PKHash(rawAddress)) :
-                                                                    CTxDestination(WitnessV0KeyHash(rawAddress))));
-            } if (updateType == static_cast<uint8_t>(UpdateMasternodeType::SetRewardAddress)) {
-                rpcInfo.pushKV("rewardAddress", EncodeDestination(addressType == PKHashType ?
-                                                                  CTxDestination(PKHash(rawAddress)) :
-                                                                  CTxDestination(WitnessV0KeyHash(rawAddress))));
+                rpcInfo.pushKV(
+                    "ownerAddress",
+                    EncodeDestination(addressType == PKHashType ? CTxDestination(PKHash(rawAddress))
+                                                                : CTxDestination(WitnessV0KeyHash(rawAddress))));
+            }
+            if (updateType == static_cast<uint8_t>(UpdateMasternodeType::SetRewardAddress)) {
+                rpcInfo.pushKV(
+                    "rewardAddress",
+                    EncodeDestination(addressType == PKHashType ? CTxDestination(PKHash(rawAddress))
+                                                                : CTxDestination(WitnessV0KeyHash(rawAddress))));
             } else if (updateType == static_cast<uint8_t>(UpdateMasternodeType::RemRewardAddress)) {
                 rpcInfo.pushKV("rewardAddress", "");
             }
         }
     }
 
-    void operator()(const CCreateTokenMessage& obj) const {
+    void operator()(const CCreateTokenMessage &obj) const {
         rpcInfo.pushKV("creationTx", tx.GetHash().GetHex());
         tokenInfo(obj);
     }
 
-    void operator()(const CUpdateTokenPreAMKMessage& obj) const {
-        rpcInfo.pushKV("isDAT", obj.isDAT);
-    }
+    void operator()(const CUpdateTokenPreAMKMessage &obj) const { rpcInfo.pushKV("isDAT", obj.isDAT); }
 
-    void operator()(const CUpdateTokenMessage& obj) const {
-        tokenInfo(obj.token);
-    }
+    void operator()(const CUpdateTokenMessage &obj) const { tokenInfo(obj.token); }
 
-    void operator()(const CMintTokensMessage& obj) const {
-        rpcInfo.pushKVs(tokenBalances(obj));
-    }
+    void operator()(const CMintTokensMessage &obj) const { rpcInfo.pushKVs(tokenBalances(obj)); }
 
-    void operator()(const CBurnTokensMessage& obj) const {
+    void operator()(const CBurnTokensMessage &obj) const {
         rpcInfo.pushKVs(tokenBalances(obj.amounts));
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         std::string type;
-        switch (obj.burnType)
-        {
+        switch (obj.burnType) {
             case CBurnTokensMessage::BurnType::TokenBurn:
                 type = "TokenBurn";
                 break;
@@ -139,7 +136,7 @@ class CCustomTxRpcVisitor
             rpcInfo.pushKV("context", ScriptToString(*addr));
     }
 
-    void operator()(const CLiquidityMessage& obj) const {
+    void operator()(const CLiquidityMessage &obj) const {
         CBalances sumTx = SumAllTransfers(obj.from);
         if (sumTx.balances.size() == 2) {
             auto amountA = *sumTx.balances.begin();
@@ -150,41 +147,39 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CRemoveLiquidityMessage& obj) const {
+    void operator()(const CRemoveLiquidityMessage &obj) const {
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         rpcInfo.pushKV("amount", obj.amount.ToString());
     }
 
-    void operator()(const CUtxosToAccountMessage& obj) const {
-        rpcInfo.pushKVs(accountsInfo(obj.to));
-    }
+    void operator()(const CUtxosToAccountMessage &obj) const { rpcInfo.pushKVs(accountsInfo(obj.to)); }
 
-    void operator()(const CAccountToUtxosMessage& obj) const {
+    void operator()(const CAccountToUtxosMessage &obj) const {
         rpcInfo.pushKV("from", ScriptToString(obj.from));
 
         UniValue dest(UniValue::VOBJ);
-        for (uint32_t i = obj.mintingOutputsStart; i <  static_cast<uint32_t>(tx.vout.size()); i++) {
+        for (uint32_t i = obj.mintingOutputsStart; i < static_cast<uint32_t>(tx.vout.size()); i++) {
             dest.pushKV(ScriptToString(tx.vout[i].scriptPubKey), tx.vout[i].TokenAmount().ToString());
         }
         rpcInfo.pushKV("to", dest);
     }
 
-    void operator()(const CAccountToAccountMessage& obj) const {
+    void operator()(const CAccountToAccountMessage &obj) const {
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         rpcInfo.pushKV("to", accountsInfo(obj.to));
     }
 
-    void operator()(const CAnyAccountsToAccountsMessage& obj) const {
+    void operator()(const CAnyAccountsToAccountsMessage &obj) const {
         rpcInfo.pushKV("from", accountsInfo(obj.from));
         rpcInfo.pushKV("to", accountsInfo(obj.to));
     }
 
-    void operator()(const CSmartContractMessage& obj) const {
+    void operator()(const CSmartContractMessage &obj) const {
         rpcInfo.pushKV("name", obj.name);
         rpcInfo.pushKV("accounts", accountsInfo(obj.accounts));
     }
 
-    void operator()(const CFutureSwapMessage& obj) const {
+    void operator()(const CFutureSwapMessage &obj) const {
         CTxDestination dest;
         if (ExtractDestination(obj.owner, dest)) {
             rpcInfo.pushKV("owner", EncodeDestination(dest));
@@ -196,7 +191,7 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("destination", std::to_string(obj.destination));
     }
 
-    void operator()(const CCreatePoolPairMessage& obj) const {
+    void operator()(const CCreatePoolPairMessage &obj) const {
         rpcInfo.pushKV("creationTx", tx.GetHash().GetHex());
         if (auto tokenPair = mnview.GetTokenByCreationTx(tx.GetHash()))
             tokenInfo(tokenPair->second);
@@ -210,7 +205,7 @@ class CCustomTxRpcVisitor
         customRewardsInfo(obj.rewards);
     }
 
-    void operator()(const CUpdatePoolPairMessage& obj) const {
+    void operator()(const CUpdatePoolPairMessage &obj) const {
         rpcInfo.pushKV("commission", ValueFromAmount(obj.commission));
         rpcInfo.pushKV("status", obj.status);
         rpcInfo.pushKV("ownerAddress", ScriptToString(obj.ownerAddress));
@@ -218,10 +213,11 @@ class CCustomTxRpcVisitor
         // Add rewards here before processing them below to avoid adding current rewards
         if (!obj.rewards.balances.empty()) {
             UniValue rewardArr(UniValue::VARR);
-            auto& rewards = obj.rewards;
+            auto &rewards = obj.rewards;
             // Check for special case to wipe rewards
-            if (rewards.balances.size() == 1 && rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()}
-            && rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
+            if (rewards.balances.size() == 1 &&
+                rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()} &&
+                rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
                 rpcInfo.pushKV("customRewards", rewardArr);
             } else {
                 customRewardsInfo(rewards);
@@ -229,7 +225,7 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CPoolSwapMessage& obj) const {
+    void operator()(const CPoolSwapMessage &obj) const {
         rpcInfo.pushKV("fromAddress", ScriptToString(obj.from));
         rpcInfo.pushKV("fromToken", obj.idTokenFrom.ToString());
         rpcInfo.pushKV("fromAmount", ValueFromAmount(obj.amountFrom));
@@ -238,10 +234,10 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("maxPrice", ValueFromAmount((obj.maxPrice.integer * COIN) + obj.maxPrice.fraction));
     }
 
-    void operator()(const CPoolSwapMessageV2& obj) const {
+    void operator()(const CPoolSwapMessageV2 &obj) const {
         (*this)(obj.swapInfo);
         std::string str;
-        for (auto& id : obj.poolIDs) {
+        for (auto &id : obj.poolIDs) {
             if (auto token = mnview.GetToken(id)) {
                 if (!str.empty()) {
                     str += '/';
@@ -254,54 +250,54 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CGovernanceMessage& obj) const {
-        for (const auto& var : obj.govs) {
+    void operator()(const CGovernanceMessage &obj) const {
+        for (const auto &var : obj.govs) {
             rpcInfo.pushKV(var->GetName(), var->Export());
         }
     }
 
-    void operator()(const CGovernanceUnsetMessage& obj) const {
-        for (const auto& gov : obj.govs) {
+    void operator()(const CGovernanceUnsetMessage &obj) const {
+        for (const auto &gov : obj.govs) {
             UniValue keys(UniValue::VARR);
-            for (const auto& key : gov.second)
+            for (const auto &key : gov.second)
                 keys.push_back(key);
 
             rpcInfo.pushKV(gov.first, keys);
         }
     }
 
-    void operator()(const CGovernanceHeightMessage& obj) const {
+    void operator()(const CGovernanceHeightMessage &obj) const {
         rpcInfo.pushKV(obj.govVar->GetName(), obj.govVar->Export());
         rpcInfo.pushKV("startHeight", static_cast<uint64_t>(obj.startHeight));
     }
 
-    void operator()(const CAppointOracleMessage& obj) const {
+    void operator()(const CAppointOracleMessage &obj) const {
         rpcInfo.pushKV("oracleAddress", ScriptToString(obj.oracleAddress));
         rpcInfo.pushKV("weightage", obj.weightage);
         tokenCurrencyPairInfo(obj.availablePairs);
     }
 
-    void operator()(const CUpdateOracleAppointMessage& obj) const {
+    void operator()(const CUpdateOracleAppointMessage &obj) const {
         rpcInfo.pushKV("oracleId", obj.oracleId.ToString());
         rpcInfo.pushKV("oracleAddress", ScriptToString(obj.newOracleAppoint.oracleAddress));
         rpcInfo.pushKV("weightage", obj.newOracleAppoint.weightage);
         tokenCurrencyPairInfo(obj.newOracleAppoint.availablePairs);
     }
 
-    void operator()(const CRemoveOracleAppointMessage& obj) const {
+    void operator()(const CRemoveOracleAppointMessage &obj) const {
         rpcInfo.pushKV("oracleId", obj.oracleId.ToString());
     }
 
-    void operator()(const CSetOracleDataMessage& obj) const {
+    void operator()(const CSetOracleDataMessage &obj) const {
         rpcInfo.pushKV("oracleId", obj.oracleId.ToString());
         rpcInfo.pushKV("timestamp", obj.timestamp);
 
         UniValue tokenPrices(UniValue::VARR);
-        for (const auto& tokenPice : obj.tokenPrices) {
-            const auto& token = tokenPice.first;
-            for (const auto& price : tokenPice.second) {
-                const auto& currency = price.first;
-                auto amount = price.second;
+        for (const auto &tokenPice : obj.tokenPrices) {
+            const auto &token = tokenPice.first;
+            for (const auto &price : tokenPice.second) {
+                const auto &currency = price.first;
+                auto amount          = price.second;
 
                 UniValue uniPair(UniValue::VOBJ);
                 uniPair.pushKV("currency", currency);
@@ -312,17 +308,14 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("tokenPrices", tokenPrices);
     }
 
-    void operator()(const CICXCreateOrderMessage& obj) const {
-        if (obj.orderType == CICXOrder::TYPE_INTERNAL)
-        {
-            rpcInfo.pushKV("type","DFC");
+    void operator()(const CICXCreateOrderMessage &obj) const {
+        if (obj.orderType == CICXOrder::TYPE_INTERNAL) {
+            rpcInfo.pushKV("type", "DFC");
             if (auto token = mnview.GetToken(obj.idToken))
                 rpcInfo.pushKV("tokenFrom", token->CreateSymbolKey(obj.idToken));
             rpcInfo.pushKV("chainto", CICXOrder::CHAIN_BTC);
-        }
-        else if (obj.orderType == CICXOrder::TYPE_EXTERNAL)
-        {
-            rpcInfo.pushKV("type","EXTERNAL");
+        } else if (obj.orderType == CICXOrder::TYPE_EXTERNAL) {
+            rpcInfo.pushKV("type", "EXTERNAL");
             rpcInfo.pushKV("chainFrom", CICXOrder::CHAIN_BTC);
             if (auto token = mnview.GetToken(obj.idToken))
                 rpcInfo.pushKV("tokenTo", token->CreateSymbolKey(obj.idToken));
@@ -333,12 +326,13 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("amountFrom", ValueFromAmount(obj.amountFrom));
         rpcInfo.pushKV("amountToFill", ValueFromAmount(obj.amountToFill));
         rpcInfo.pushKV("orderPrice", ValueFromAmount(obj.orderPrice));
-        CAmount calcedAmount(static_cast<CAmount>((arith_uint256(obj.amountToFill) * arith_uint256(obj.orderPrice) / arith_uint256(COIN)).GetLow64()));
+        CAmount calcedAmount(static_cast<CAmount>(
+            (arith_uint256(obj.amountToFill) * arith_uint256(obj.orderPrice) / arith_uint256(COIN)).GetLow64()));
         rpcInfo.pushKV("amountToFillInToAsset", ValueFromAmount(calcedAmount));
         rpcInfo.pushKV("expiry", static_cast<int>(obj.expiry));
     }
 
-    void operator()(const CICXMakeOfferMessage& obj) const {
+    void operator()(const CICXMakeOfferMessage &obj) const {
         rpcInfo.pushKV("orderTx", obj.orderTx.GetHex());
         rpcInfo.pushKV("amount", ValueFromAmount(obj.amount));
         rpcInfo.pushKV("ownerAddress", ScriptToString(obj.ownerAddress));
@@ -348,7 +342,7 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("expiry", static_cast<int>(obj.expiry));
     }
 
-    void operator()(const CICXSubmitDFCHTLCMessage& obj) const {
+    void operator()(const CICXSubmitDFCHTLCMessage &obj) const {
         rpcInfo.pushKV("type", "DFC");
         rpcInfo.pushKV("offerTx", obj.offerTx.GetHex());
         rpcInfo.pushKV("amount", ValueFromAmount(obj.amount));
@@ -356,7 +350,7 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("timeout", static_cast<int>(obj.timeout));
     }
 
-    void operator()(const CICXSubmitEXTHTLCMessage& obj) const {
+    void operator()(const CICXSubmitEXTHTLCMessage &obj) const {
         rpcInfo.pushKV("type", "EXTERNAL");
         rpcInfo.pushKV("offerTx", obj.offerTx.GetHex());
         rpcInfo.pushKV("amount", ValueFromAmount(obj.amount));
@@ -366,21 +360,17 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("timeout", static_cast<int>(obj.timeout));
     }
 
-    void operator()(const CICXClaimDFCHTLCMessage& obj) const {
+    void operator()(const CICXClaimDFCHTLCMessage &obj) const {
         rpcInfo.pushKV("type", "CLAIM DFC");
         rpcInfo.pushKV("dfchtlcTx", obj.dfchtlcTx.GetHex());
         rpcInfo.pushKV("seed", HexStr(obj.seed));
     }
 
-    void operator()(const CICXCloseOrderMessage& obj) const {
-        rpcInfo.pushKV("orderTx", obj.orderTx.GetHex());
-    }
+    void operator()(const CICXCloseOrderMessage &obj) const { rpcInfo.pushKV("orderTx", obj.orderTx.GetHex()); }
 
-    void operator()(const CICXCloseOfferMessage& obj) const {
-        rpcInfo.pushKV("offerTx", obj.offerTx.GetHex());
-    }
+    void operator()(const CICXCloseOfferMessage &obj) const { rpcInfo.pushKV("offerTx", obj.offerTx.GetHex()); }
 
-    void operator()(const CLoanSetCollateralTokenMessage& obj) const {
+    void operator()(const CLoanSetCollateralTokenMessage &obj) const {
         if (auto token = mnview.GetToken(obj.idToken))
             rpcInfo.pushKV("token", token->CreateSymbolKey(obj.idToken));
         rpcInfo.pushKV("factor", ValueFromAmount(obj.factor));
@@ -389,7 +379,7 @@ class CCustomTxRpcVisitor
             rpcInfo.pushKV("activateAfterBlock", static_cast<int>(obj.activateAfterBlock));
     }
 
-    void operator()(const CLoanSetLoanTokenMessage& obj) const {
+    void operator()(const CLoanSetLoanTokenMessage &obj) const {
         rpcInfo.pushKV("symbol", obj.symbol);
         rpcInfo.pushKV("name", obj.name);
         rpcInfo.pushKV("fixedIntervalPriceId", obj.fixedIntervalPriceId.first + "/" + obj.fixedIntervalPriceId.second);
@@ -397,7 +387,7 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("interest", ValueFromAmount(obj.interest));
     }
 
-    void operator()(const CLoanUpdateLoanTokenMessage& obj) const {
+    void operator()(const CLoanUpdateLoanTokenMessage &obj) const {
         rpcInfo.pushKV("id", obj.tokenTx.ToString());
         rpcInfo.pushKV("symbol", obj.symbol);
         rpcInfo.pushKV("name", obj.name);
@@ -406,63 +396,59 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("interest", ValueFromAmount(obj.interest));
     }
 
-    void operator()(const CLoanSchemeMessage& obj) const {
+    void operator()(const CLoanSchemeMessage &obj) const {
         rpcInfo.pushKV("id", obj.identifier);
         rpcInfo.pushKV("mincolratio", static_cast<uint64_t>(obj.ratio));
         rpcInfo.pushKV("interestrate", ValueFromAmount(obj.rate));
         rpcInfo.pushKV("updateHeight", obj.updateHeight);
     }
 
-    void operator()(const CDefaultLoanSchemeMessage& obj) const {
-        rpcInfo.pushKV("id", obj.identifier);
-    }
+    void operator()(const CDefaultLoanSchemeMessage &obj) const { rpcInfo.pushKV("id", obj.identifier); }
 
-    void operator()(const CDestroyLoanSchemeMessage& obj) const {
+    void operator()(const CDestroyLoanSchemeMessage &obj) const {
         rpcInfo.pushKV("id", obj.identifier);
         rpcInfo.pushKV("destroyHeight", obj.destroyHeight);
     }
 
-    void operator()(const CVaultMessage& obj) const {
+    void operator()(const CVaultMessage &obj) const {
         // Add Vault attributes
         rpcInfo.pushKV("ownerAddress", ScriptToString(obj.ownerAddress));
         rpcInfo.pushKV("loanSchemeId", obj.schemeId);
     }
 
-    void operator()(const CCloseVaultMessage& obj) const {
+    void operator()(const CCloseVaultMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("to", ScriptToString(obj.to));
     }
 
-    void operator()(const CUpdateVaultMessage& obj) const {
+    void operator()(const CUpdateVaultMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("ownerAddress", ScriptToString(obj.ownerAddress));
         rpcInfo.pushKV("loanSchemeId", obj.schemeId);
     }
 
-    void operator()(const CDepositToVaultMessage& obj) const {
+    void operator()(const CDepositToVaultMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         rpcInfo.pushKV("amount", obj.amount.ToString());
     }
 
-    void operator()(const CWithdrawFromVaultMessage& obj) const {
+    void operator()(const CWithdrawFromVaultMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("to", ScriptToString(obj.to));
         rpcInfo.pushKV("amount", obj.amount.ToString());
     }
 
-    void operator()(const CPaybackWithCollateralMessage& obj) const {
-        rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
-    }
+    void operator()(const CPaybackWithCollateralMessage &obj) const { rpcInfo.pushKV("vaultId", obj.vaultId.GetHex()); }
 
-    void operator()(const CLoanTakeLoanMessage& obj) const {
+    void operator()(const CLoanTakeLoanMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         if (!obj.to.empty())
             rpcInfo.pushKV("to", ScriptToString(obj.to));
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
-        for (auto const & kv : obj.amounts.balances) {
+        for (const auto &kv : obj.amounts.balances) {
             if (auto token = mnview.GetToken(kv.first)) {
-                auto tokenImpl = static_cast<CTokenImplementation const&>(*token);
+                auto tokenImpl = static_cast<const CTokenImplementation &>(*token);
                 if (auto tokenPair = mnview.GetTokenByCreationTx(tokenImpl.creationTx)) {
                     rpcInfo.pushKV(tokenPair->first.ToString(), ValueFromAmount(kv.second));
                 }
@@ -470,12 +456,12 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CLoanPaybackLoanMessage& obj) const {
+    void operator()(const CLoanPaybackLoanMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("from", ScriptToString(obj.from));
-        for (auto const & kv : obj.amounts.balances) {
+        for (const auto &kv : obj.amounts.balances) {
             if (auto token = mnview.GetToken(kv.first)) {
-                auto tokenImpl = static_cast<CTokenImplementation const&>(*token);
+                auto tokenImpl = static_cast<const CTokenImplementation &>(*token);
                 if (auto tokenPair = mnview.GetTokenByCreationTx(tokenImpl.creationTx)) {
                     rpcInfo.pushKV(tokenPair->first.ToString(), ValueFromAmount(kv.second));
                 }
@@ -483,21 +469,21 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CLoanPaybackLoanV2Message& obj) const {
+    void operator()(const CLoanPaybackLoanV2Message &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         UniValue loans{UniValue::VARR};
-        for (auto const & idx : obj.loans) {
+        for (const auto &idx : obj.loans) {
             UniValue loan{UniValue::VOBJ};
             if (auto dtoken = mnview.GetToken(idx.first)) {
-                auto dtokenImpl = static_cast<CTokenImplementation const&>(*dtoken);
+                auto dtokenImpl = static_cast<const CTokenImplementation &>(*dtoken);
                 if (auto dtokenPair = mnview.GetTokenByCreationTx(dtokenImpl.creationTx)) {
-                    loan.pushKV("dTokens",dtokenPair->first.ToString());
+                    loan.pushKV("dTokens", dtokenPair->first.ToString());
                 }
             }
-            for (auto const & kv : idx.second.balances) {
+            for (const auto &kv : idx.second.balances) {
                 if (auto token = mnview.GetToken(kv.first)) {
-                    auto tokenImpl = static_cast<CTokenImplementation const&>(*token);
+                    auto tokenImpl = static_cast<const CTokenImplementation &>(*token);
                     if (auto tokenPair = mnview.GetTokenByCreationTx(tokenImpl.creationTx)) {
                         loan.pushKV(tokenPair->first.ToString(), ValueFromAmount(kv.second));
                     }
@@ -505,17 +491,17 @@ class CCustomTxRpcVisitor
             }
             loans.push_back(loan);
         }
-        rpcInfo.pushKV("dToken",loans);
+        rpcInfo.pushKV("dToken", loans);
     }
 
-    void operator()(const CAuctionBidMessage& obj) const {
+    void operator()(const CAuctionBidMessage &obj) const {
         rpcInfo.pushKV("vaultId", obj.vaultId.GetHex());
         rpcInfo.pushKV("index", int64_t(obj.index));
         rpcInfo.pushKV("from", ScriptToString(obj.from));
         rpcInfo.pushKV("amount", obj.amount.ToString());
     }
 
-    void operator()(const CCreatePropMessage& obj) const {
+    void operator()(const CCreatePropMessage &obj) const {
         auto propId = tx.GetHash();
         rpcInfo.pushKV("proposalId", propId.GetHex());
         auto type = static_cast<CPropType>(obj.type);
@@ -525,7 +511,7 @@ class CCustomTxRpcVisitor
         rpcInfo.pushKV("amount", ValueFromAmount(obj.nAmount));
         rpcInfo.pushKV("cycles", int(obj.nCycles));
         auto proposalEndHeight = height;
-        bool emergency = obj.options & CPropOption::Emergency;
+        bool emergency         = obj.options & CPropOption::Emergency;
         if (auto prop = mnview.GetProp(propId)) {
             proposalEndHeight = prop->proposalEndHeight;
         } else {
@@ -537,8 +523,7 @@ class CCustomTxRpcVisitor
         }
         rpcInfo.pushKV("proposalEndHeight", int64_t(proposalEndHeight));
         rpcInfo.pushKV("payoutAddress", ScriptToString(obj.address));
-        if (obj.options)
-        {
+        if (obj.options) {
             UniValue opt = UniValue(UniValue::VARR);
             if (obj.options & CPropOption::Emergency)
                 opt.push_back("emergency");
@@ -547,25 +532,24 @@ class CCustomTxRpcVisitor
         }
     }
 
-    void operator()(const CPropVoteMessage& obj) const {
+    void operator()(const CPropVoteMessage &obj) const {
         rpcInfo.pushKV("proposalId", obj.propId.GetHex());
         rpcInfo.pushKV("masternodeId", obj.masternodeId.GetHex());
         auto vote = static_cast<CPropVoteType>(obj.vote);
         rpcInfo.pushKV("vote", CPropVoteToString(vote));
     }
 
-    void operator()(const CCustomTxMessageNone&) const {
-    }
+    void operator()(const CCustomTxMessageNone &) const {}
 };
 
-Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& txType, UniValue& results) {
+Res RpcInfo(const CTransaction &tx, uint32_t height, CustomTxType &txType, UniValue &results) {
     std::vector<unsigned char> metadata;
     txType = GuessCustomTxType(tx, metadata);
     if (txType == CustomTxType::None) {
         return Res::Ok();
     }
     auto txMessage = customTypeToMessage(txType);
-    auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
+    auto res       = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
     if (res) {
         CCustomCSView mnview(*pcustomcsview);
         std::visit(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
diff --git a/src/masternodes/rpc_poolpair.cpp b/src/masternodes/rpc_poolpair.cpp
index 67265f71a8..d112ea4de0 100644
--- a/src/masternodes/rpc_poolpair.cpp
+++ b/src/masternodes/rpc_poolpair.cpp
@@ -2,7 +2,11 @@
 
 #include <masternodes/govvariables/attributes.h>
 
-UniValue poolToJSON(const CCustomCSView view, DCT_ID const& id, CPoolPair const& pool, CToken const& token, bool verbose) {
+UniValue poolToJSON(const CCustomCSView view,
+                    DCT_ID const &id,
+                    const CPoolPair &pool,
+                    const CToken &token,
+                    bool verbose) {
     UniValue poolObj(UniValue::VOBJ);
     poolObj.pushKV("symbol", token.symbol);
     poolObj.pushKV("name", token.name);
@@ -50,15 +54,20 @@ UniValue poolToJSON(const CCustomCSView view, DCT_ID const& id, CPoolPair const&
         if (pool.reserveB == 0) {
             poolObj.pushKV("reserveA/reserveB", "0");
         } else {
-            poolObj.pushKV("reserveA/reserveB", ValueFromAmount((arith_uint256(pool.reserveA) * arith_uint256(COIN) / pool.reserveB).GetLow64()));
+            poolObj.pushKV(
+                "reserveA/reserveB",
+                ValueFromAmount((arith_uint256(pool.reserveA) * arith_uint256(COIN) / pool.reserveB).GetLow64()));
         }
 
         if (pool.reserveA == 0) {
             poolObj.pushKV("reserveB/reserveA", "0");
         } else {
-            poolObj.pushKV("reserveB/reserveA", ValueFromAmount((arith_uint256(pool.reserveB) * arith_uint256(COIN) / pool.reserveA).GetLow64()));
+            poolObj.pushKV(
+                "reserveB/reserveA",
+                ValueFromAmount((arith_uint256(pool.reserveB) * arith_uint256(COIN) / pool.reserveA).GetLow64()));
         }
-        poolObj.pushKV("tradeEnabled", pool.reserveA >= CPoolPair::SLOPE_SWAP_RATE && pool.reserveB >= CPoolPair::SLOPE_SWAP_RATE);
+        poolObj.pushKV("tradeEnabled",
+                       pool.reserveA >= CPoolPair::SLOPE_SWAP_RATE && pool.reserveB >= CPoolPair::SLOPE_SWAP_RATE);
 
         poolObj.pushKV("ownerAddress", ScriptToString(pool.ownerAddress));
 
@@ -85,7 +94,7 @@ UniValue poolToJSON(const CCustomCSView view, DCT_ID const& id, CPoolPair const&
             if (!rewards.balances.empty()) {
                 UniValue rewardArr(UniValue::VARR);
 
-                for (const auto& reward : rewards.balances) {
+                for (const auto &reward : rewards.balances) {
                     rewardArr.push_back(CTokenAmount{reward.first, reward.second}.ToString());
                 }
 
@@ -94,7 +103,7 @@ UniValue poolToJSON(const CCustomCSView view, DCT_ID const& id, CPoolPair const&
         }
 
         poolObj.pushKV("creationTx", pool.creationTx.GetHex());
-        poolObj.pushKV("creationHeight", (uint64_t) pool.creationHeight);
+        poolObj.pushKV("creationHeight", (uint64_t)pool.creationHeight);
     }
 
     UniValue ret(UniValue::VOBJ);
@@ -102,11 +111,16 @@ UniValue poolToJSON(const CCustomCSView view, DCT_ID const& id, CPoolPair const&
     return ret;
 }
 
-UniValue poolShareToJSON(DCT_ID const & poolId, CScript const & provider, CAmount const& amount, CPoolPair const& poolPair, bool verbose) {
+UniValue poolShareToJSON(DCT_ID const &poolId,
+                         const CScript &provider,
+                         const CAmount &amount,
+                         const CPoolPair &poolPair,
+                         bool verbose) {
     UniValue poolObj(UniValue::VOBJ);
     poolObj.pushKV("poolID", poolId.ToString());
     poolObj.pushKV("owner", ScriptToString(provider));
-    CAmount percentage = (arith_uint256(amount * 100) * arith_uint256(COIN) / arith_uint256(poolPair.totalLiquidity)).GetLow64();
+    CAmount percentage =
+        (arith_uint256(amount * 100) * arith_uint256(COIN) / arith_uint256(poolPair.totalLiquidity)).GetLow64();
     poolObj.pushKV("%", ValueFromAmount(percentage));
 
     if (verbose) {
@@ -119,19 +133,18 @@ UniValue poolShareToJSON(DCT_ID const & poolId, CScript const & provider, CAmoun
     return ret;
 }
 
-
-UniValue poolPathsToJSON(std::vector<std::vector<DCT_ID>> & poolPaths) {
+UniValue poolPathsToJSON(std::vector<std::vector<DCT_ID>> &poolPaths) {
     UniValue paths(UniValue::VARR);
     for (auto poolIds : poolPaths) {
         UniValue pathObj(UniValue::VARR);
-        for (auto poolId : poolIds){
+        for (auto poolId : poolIds) {
             pathObj.push_back(poolId.ToString());
         }
         paths.push_back(pathObj);
     }
     return paths;
 }
-void CheckAndFillPoolSwapMessage(const JSONRPCRequest& request, CPoolSwapMessage &poolSwapMsg) {
+void CheckAndFillPoolSwapMessage(const JSONRPCRequest &request, CPoolSwapMessage &poolSwapMsg) {
     std::string tokenFrom, tokenTo;
     UniValue metadataObj = request.params[0].get_obj();
 
@@ -167,45 +180,55 @@ void CheckAndFillPoolSwapMessage(const JSONRPCRequest& request, CPoolSwapMessage
             throw JSONRPCError(RPC_INVALID_PARAMETER, "TokenTo was not found");
 
         if (!metadataObj["maxPrice"].isNull()) {
-            CAmount maxPrice = AmountFromValue(metadataObj["maxPrice"]);
-            poolSwapMsg.maxPrice.integer = maxPrice / COIN;
+            CAmount maxPrice              = AmountFromValue(metadataObj["maxPrice"]);
+            poolSwapMsg.maxPrice.integer  = maxPrice / COIN;
             poolSwapMsg.maxPrice.fraction = maxPrice % COIN;
         } else {
             // There is no maxPrice calculation anymore
-            poolSwapMsg.maxPrice.integer = std::numeric_limits<CAmount>::max();
+            poolSwapMsg.maxPrice.integer  = std::numeric_limits<CAmount>::max();
             poolSwapMsg.maxPrice.fraction = std::numeric_limits<CAmount>::max();
         }
     }
 }
 
-UniValue listpoolpairs(const JSONRPCRequest& request) {
-    RPCHelpMan{"listpoolpairs",
-               "\nReturns information about pools.\n",
-               {
-                        {"pagination", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                            {
-                                 {"start", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                  "Optional first key to iterate from, in lexicographical order."
-                                  "Typically it's set to last ID from previous request."},
-                                 {"including_start", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                                  "If true, then iterate including starting position. False by default"},
-                                 {"limit", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                  "Maximum number of pools to return, 100 by default"},
-                            },
-                        },
-                        {"verbose", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                                    "Flag for verbose list (default = true), otherwise only ids, symbols and names are listed"},
-               },
-               RPCResult{
-                       "{id:{...},...}     (array) Json object with pools information\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("listpoolpairs", "'{\"start\":128}' false")
-                       + HelpExampleRpc("listpoolpairs", "'{\"start\":128}' false")
-               },
-    }.Check(request);
-
-    if (auto res = GetRPCResultCache().TryGet(request)) return *res;
+UniValue listpoolpairs(const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "listpoolpairs",
+        "\nReturns information about pools.\n",
+        {
+          {
+                "pagination",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::OMITTED,
+                "",
+                {
+                    {"start",
+                     RPCArg::Type::NUM,
+                     RPCArg::Optional::OMITTED,
+                     "Optional first key to iterate from, in lexicographical order."
+                     "Typically it's set to last ID from previous request."},
+                    {"including_start",
+                     RPCArg::Type::BOOL,
+                     RPCArg::Optional::OMITTED,
+                     "If true, then iterate including starting position. False by default"},
+                    {"limit",
+                     RPCArg::Type::NUM,
+                     RPCArg::Optional::OMITTED,
+                     "Maximum number of pools to return, 100 by default"},
+                },
+            },                                                               {"verbose",
+             RPCArg::Type::BOOL,
+             RPCArg::Optional::OMITTED,
+             "Flag for verbose list (default = true), otherwise only ids, symbols and names are listed"},
+          },
+        RPCResult{"{id:{...},...}     (array) Json object with pools information\n"},
+        RPCExamples{HelpExampleCli("listpoolpairs",                                       "'{\"start\":128}' false") +
+                    HelpExampleRpc("listpoolpairs", "'{\"start\":128}' false")},
+    }
+        .Check(request);
+
+    if (auto res = GetRPCResultCache().TryGet(request))
+        return *res;
 
     bool verbose = true;
     if (request.params.size() > 1) {
@@ -220,11 +243,11 @@ UniValue listpoolpairs(const JSONRPCRequest& request) {
         if (request.params.size() > 0) {
             UniValue paginationObj = request.params[0].get_obj();
             if (!paginationObj["limit"].isNull()) {
-                limit = (size_t) paginationObj["limit"].get_int64();
+                limit = (size_t)paginationObj["limit"].get_int64();
             }
             if (!paginationObj["start"].isNull()) {
                 including_start = false;
-                start.v = (uint32_t) paginationObj["start"].get_int();
+                start.v         = (uint32_t)paginationObj["start"].get_int();
             }
             if (!paginationObj["including_start"].isNull()) {
                 including_start = paginationObj["including_start"].getBool();
@@ -241,38 +264,39 @@ UniValue listpoolpairs(const JSONRPCRequest& request) {
     LOCK(cs_main);
 
     UniValue ret(UniValue::VOBJ);
-    pcustomcsview->ForEachPoolPair([&](DCT_ID const & id, CPoolPair pool) {
-        const auto token = pcustomcsview->GetToken(id);
-        if (token) {
-            ret.pushKVs(poolToJSON(*pcustomcsview, id, pool, *token, verbose));
-            limit--;
-        }
+    pcustomcsview->ForEachPoolPair(
+        [&](DCT_ID const &id, CPoolPair pool) {
+            const auto token = pcustomcsview->GetToken(id);
+            if (token) {
+                ret.pushKVs(poolToJSON(*pcustomcsview, id, pool, *token, verbose));
+                limit--;
+            }
 
-        return limit != 0;
-    }, start);
+            return limit != 0;
+        },
+        start);
 
     return GetRPCResultCache().Set(request, ret);
 }
 
-UniValue getpoolpair(const JSONRPCRequest& request) {
-    RPCHelpMan{"getpoolpair",
-               "\nReturns information about pool.\n",
-               {
-                       {"key", RPCArg::Type::STR, RPCArg::Optional::NO,
-                        "One of the keys may be specified (id/symbol/creationTx)"},
-                       {"verbose", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                        "Flag for verbose list (default = true), otherwise limited objects are listed"},
-               },
-               RPCResult{
-                       "{id:{...}}     (array) Json object with pool information\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("getpoolpair", "GOLD")
-                       + HelpExampleRpc("getpoolpair", "GOLD")
-               },
-    }.Check(request);
-
-    if (auto res = GetRPCResultCache().TryGet(request)) return *res;
+UniValue getpoolpair(const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "getpoolpair",
+        "\nReturns information about pool.\n",
+        {
+          {"key", RPCArg::Type::STR, RPCArg::Optional::NO, "One of the keys may be specified (id/symbol/creationTx)"},
+          {"verbose",
+             RPCArg::Type::BOOL,
+             RPCArg::Optional::OMITTED,
+             "Flag for verbose list (default = true), otherwise limited objects are listed"},
+          },
+        RPCResult{"{id:{...}}     (array) Json object with pool information\n"                                               },
+        RPCExamples{HelpExampleCli("getpoolpair",                                                                                                    "GOLD") + HelpExampleRpc("getpoolpair", "GOLD")},
+    }
+        .Check(request);
+
+    if (auto res = GetRPCResultCache().TryGet(request))
+        return *res;
 
     bool verbose = true;
     if (request.params.size() > 1) {
@@ -294,62 +318,76 @@ UniValue getpoolpair(const JSONRPCRequest& request) {
     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Pool not found");
 }
 
-UniValue addpoolliquidity(const JSONRPCRequest& request) {
+UniValue addpoolliquidity(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"addpoolliquidity",
-               "\nCreates (and submits to local node and network) a add pool liquidity transaction.\n"
-               "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                       {"from", RPCArg::Type::OBJ, RPCArg::Optional::NO, "",
+    RPCHelpMan{
+        "addpoolliquidity",
+        "\nCreates (and submits to local node and network) a add pool liquidity transaction.\n"
+        "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {
+                "from",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::NO,
+                "",
+                {
+                    {"address",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "The defi address(es) is the key(s), the value(s) is amount in amount@token format. "
+                     "You should provide exectly two types of tokens for pool's 'token A' and 'token B' in any "
+                     "combinations."
+                     "If multiple tokens from one address are to be transferred, specify an array [\"amount1@t1\", "
+                     "\"amount2@t2\"]"
+                     "If \"from\" obj contain only one amount entry with address-key: \"*\" (star), it's means "
+                     "auto-selection accounts from wallet."},
+                },
+            },                                                                                                    {"shareAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The defi address for crediting tokens."},
+                          {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
                         {
-                                {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The defi address(es) is the key(s), the value(s) is amount in amount@token format. "
-                                                                                     "You should provide exectly two types of tokens for pool's 'token A' and 'token B' in any combinations."
-                                                                                     "If multiple tokens from one address are to be transferred, specify an array [\"amount1@t1\", \"amount2@t2\"]"
-                                                                                     "If \"from\" obj contain only one amount entry with address-key: \"*\" (star), it's means auto-selection accounts from wallet."},
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
                         },
-                       },
-                       {"shareAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The defi address for crediting tokens."},
-                       {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG,
-                        "A json array of json objects",
-                        {
-                                {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                                 {
-                                         {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                         {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                                 },
-                                },
-                        },
-                       },
-               },
-               RPCResult{
-                       "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("addpoolliquidity",
-                                      "'{\"address1\":\"1.0@DFI\",\"address2\":\"1.0@DFI\"}' "
-                                      "share_address '[]'")
-                       + HelpExampleCli("addpoolliquidity",
-                                      "'{\"*\": [\"2.0@BTC\", \"3.0@ETH\"]}' "
-                                      "share_address '[]'")
-                       + HelpExampleRpc("addpoolliquidity",
-                                      "'{\"address1\":\"1.0@DFI\",\"address2\":\"1.0@DFI\"}' "
-                                      "share_address '[]'")
-               },
-    }.Check(request);
+                    },
+                },
+            },                                     },
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"},
+        RPCExamples{HelpExampleCli("addpoolliquidity",
+                          "'{\"address1\":\"1.0@DFI\",\"address2\":\"1.0@DFI\"}' "
+                                   "share_address '[]'") +
+                    HelpExampleCli("addpoolliquidity",
+                          "'{\"*\": [\"2.0@BTC\", \"3.0@ETH\"]}' "
+                                   "share_address '[]'") +
+                    HelpExampleRpc("addpoolliquidity",
+                          "'{\"address1\":\"1.0@DFI\",\"address2\":\"1.0@DFI\"}' "
+                                   "share_address '[]'")},
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
     }
     pwallet->BlockUntilSyncedToCurrentChain();
 
-    RPCTypeCheck(request.params, { UniValue::VOBJ, UniValue::VSTR, UniValue::VARR }, true);
+    RPCTypeCheck(request.params, {UniValue::VOBJ, UniValue::VSTR, UniValue::VARR}, true);
 
     // decode
     CLiquidityMessage msg{};
     if (request.params[0].get_obj().getKeys().size() == 1 &&
-        request.params[0].get_obj().getKeys()[0] == "*") { // auto-selection accounts from wallet
+        request.params[0].get_obj().getKeys()[0] == "*") {  // auto-selection accounts from wallet
 
         CAccounts foundMineAccounts = GetAllMineAccounts(pwallet);
 
@@ -359,18 +397,16 @@ UniValue addpoolliquidity(const JSONRPCRequest& request) {
 
         if (msg.from.empty()) {
             throw JSONRPCError(RPC_INVALID_REQUEST,
-                                   "Not enough balance on wallet accounts, call utxostoaccount to increase it.\n");
+                               "Not enough balance on wallet accounts, call utxostoaccount to increase it.\n");
         }
-    }
-    else {
+    } else {
         msg.from = DecodeRecipients(pwallet->chain(), request.params[0].get_obj());
     }
     msg.shareAddress = DecodeScript(request.params[1].get_str());
 
     // encode
     CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
-    markedMetadata << static_cast<unsigned char>(CustomTxType::AddPoolLiquidity)
-                   << msg;
+    markedMetadata << static_cast<unsigned char>(CustomTxType::AddPoolLiquidity) << msg;
     CScript scriptMeta;
     scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
 
@@ -382,10 +418,10 @@ UniValue addpoolliquidity(const JSONRPCRequest& request) {
 
     // auth
     std::set<CScript> auths;
-    for (const auto& kv : msg.from) {
+    for (const auto &kv : msg.from) {
         auths.emplace(kv.first);
     }
-    UniValue const & txInputs = request.params[2];
+    const UniValue &txInputs = request.params[2];
     CTransactionRef optAuthTx;
     rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, false /*needFoundersAuth*/, optAuthTx, txInputs);
 
@@ -409,57 +445,61 @@ UniValue addpoolliquidity(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue removepoolliquidity(const JSONRPCRequest& request) {
+UniValue removepoolliquidity(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"removepoolliquidity",
-               "\nCreates (and submits to local node and network) a remove pool liquidity transaction.\n"
-               "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                       {"from", RPCArg::Type::STR, RPCArg::Optional::NO, "The defi address which has tokens"},
-                       {"amount", RPCArg::Type::STR, RPCArg::Optional::NO, "Liquidity amount@Liquidity pool symbol"},
-                       {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG,
-                            "A json array of json objects",
-                            {
-                                {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                                    {
-                                        {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                        {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                                    },
-                                },
-                            },
-                       },
-               },
-               RPCResult{
-                       "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("removepoolliquidity", "from_address 1.0@LpSymbol")
-                       + HelpExampleRpc("removepoolliquidity", "from_address 1.0@LpSymbol")
-               },
-    }.Check(request);
+    RPCHelpMan{
+        "removepoolliquidity",
+        "\nCreates (and submits to local node and network) a remove pool liquidity transaction.\n"
+        "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {"from", RPCArg::Type::STR, RPCArg::Optional::NO, "The defi address which has tokens"},
+                          {"amount", RPCArg::Type::STR, RPCArg::Optional::NO, "Liquidity amount@Liquidity pool symbol"},
+                          {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },},
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"                                                                                      },
+        RPCExamples{HelpExampleCli("removepoolliquidity",                               "from_address 1.0@LpSymbol") +
+                    HelpExampleRpc("removepoolliquidity",       "from_address 1.0@LpSymbol")                                                                                 },
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
     }
     pwallet->BlockUntilSyncedToCurrentChain();
 
-    RPCTypeCheck(request.params, { UniValue::VSTR, UniValue::VSTR, UniValue::VARR }, true);
+    RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VSTR, UniValue::VARR}, true);
 
-    std::string from = request.params[0].get_str();
-    std::string amount = request.params[1].get_str();
-    UniValue const & txInputs = request.params[2];
+    std::string from         = request.params[0].get_str();
+    std::string amount       = request.params[1].get_str();
+    const UniValue &txInputs = request.params[2];
 
     // decode
     CRemoveLiquidityMessage msg{};
-    msg.from = DecodeScript(from);
+    msg.from   = DecodeScript(from);
     msg.amount = DecodeAmount(pwallet->chain(), amount, from);
 
     // encode
     CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
-    markedMetadata << static_cast<unsigned char>(CustomTxType::RemovePoolLiquidity)
-                   << msg;
+    markedMetadata << static_cast<unsigned char>(CustomTxType::RemovePoolLiquidity) << msg;
     CScript scriptMeta;
     scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
 
@@ -475,7 +515,7 @@ UniValue removepoolliquidity(const JSONRPCRequest& request) {
 
     CCoinControl coinControl;
 
-     // Set change to from address
+    // Set change to from address
     CTxDestination dest;
     ExtractDestination(msg.from, dest);
     if (IsValidDestination(dest)) {
@@ -491,77 +531,89 @@ UniValue removepoolliquidity(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue createpoolpair(const JSONRPCRequest& request) {
+UniValue createpoolpair(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"createpoolpair",
-               "\nCreates (and submits to local node and network) a poolpair transaction with given metadata.\n"
-               "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                   {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                       {
-                            {"tokenA", RPCArg::Type::STR, RPCArg::Optional::NO,
-                            "One of the keys may be specified (id/symbol)"},
-                            {"tokenB", RPCArg::Type::STR, RPCArg::Optional::NO,
-                            "One of the keys may be specified (id/symbol)"},
-                            {"commission", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                            "Pool commission, up to 10^-8"},
-                            {"status", RPCArg::Type::BOOL, RPCArg::Optional::NO,
-                            "Pool Status: True is Active, False is Restricted"},
-                            {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
-                            "Address of the pool owner."},
-                            {"customRewards", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
-                            "Token reward to be paid on each block, multiple can be specified."},
-                            {"pairSymbol", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
-                             "Pair symbol (unique), no longer than " +
-                             std::to_string(CToken::MAX_TOKEN_SYMBOL_LENGTH)},
-                       },
-                   },
-                   {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects",
-                       {
-                           {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                               {
-                                   {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                   {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                               },
-                           },
-                       },
-                   },
-               },
-               RPCResult{
-                       "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("createpoolpair",   "'{\"tokenA\":\"MyToken1\","
-                                                          "\"tokenB\":\"MyToken2\","
-                                                          "\"commission\":\"0.001\","
-                                                          "\"status\":\"True\","
-                                                          "\"ownerAddress\":\"Address\","
-                                                          "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
-                                                          "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-                       + HelpExampleRpc("createpoolpair", "'{\"tokenA\":\"MyToken1\","
-                                                          "\"tokenB\":\"MyToken2\","
-                                                          "\"commission\":\"0.001\","
-                                                          "\"status\":\"True\","
-                                                          "\"ownerAddress\":\"Address\","
-                                                          "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
-                                                          "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-               },
-    }.Check(request);
+    RPCHelpMan{
+        "createpoolpair",
+        "\nCreates (and submits to local node and network) a poolpair transaction with given metadata.\n"
+        "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {
+                "metadata",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::OMITTED,
+                "",
+                {
+                    {"tokenA", RPCArg::Type::STR, RPCArg::Optional::NO, "One of the keys may be specified (id/symbol)"},
+                    {"tokenB", RPCArg::Type::STR, RPCArg::Optional::NO, "One of the keys may be specified (id/symbol)"},
+                    {"commission", RPCArg::Type::NUM, RPCArg::Optional::NO, "Pool commission, up to 10^-8"},
+                    {"status",
+                     RPCArg::Type::BOOL,
+                     RPCArg::Optional::NO,
+                     "Pool Status: True is Active, False is Restricted"},
+                    {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the pool owner."},
+                    {"customRewards",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::OMITTED,
+                     "Token reward to be paid on each block, multiple can be specified."},
+                    {"pairSymbol",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::OMITTED,
+                     "Pair symbol (unique), no longer than " + std::to_string(CToken::MAX_TOKEN_SYMBOL_LENGTH)},
+                },
+            },                                                                                                    {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },                                                                                                                    },
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"},
+        RPCExamples{HelpExampleCli("createpoolpair",
+                          "'{\"tokenA\":\"MyToken1\","
+                                   "\"tokenB\":\"MyToken2\","
+                                   "\"commission\":\"0.001\","
+                                   "\"status\":\"True\","
+                                   "\"ownerAddress\":\"Address\","
+                                   "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'") +
+                    HelpExampleRpc("createpoolpair",
+                          "'{\"tokenA\":\"MyToken1\","
+                                   "\"tokenB\":\"MyToken2\","
+                                   "\"commission\":\"0.001\","
+                                   "\"status\":\"True\","
+                                   "\"ownerAddress\":\"Address\","
+                                   "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'")},
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
     }
     pwallet->BlockUntilSyncedToCurrentChain();
 
     RPCTypeCheck(request.params, {UniValue::VOBJ, UniValue::VARR}, true);
 
     std::string tokenA, tokenB, pairSymbol;
-    CAmount commission = 0; // !!!
+    CAmount commission = 0;  // !!!
     CScript ownerAddress;
     CBalances rewards;
-    bool status = true; // default Active
+    bool status          = true;  // default Active
     UniValue metadataObj = request.params[0].get_obj();
     if (!metadataObj["tokenA"].isNull()) {
         tokenA = metadataObj["tokenA"].getValStr();
@@ -601,21 +653,22 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
         targetHeight = ::ChainActive().Height() + 1;
     }
 
-    const auto symbolLength = targetHeight >= Params().GetConsensus().FortCanningHeight ? CToken::MAX_TOKEN_POOLPAIR_LENGTH : CToken::MAX_TOKEN_SYMBOL_LENGTH;
-    if(pairSymbol.length() > symbolLength){
+    const auto symbolLength = targetHeight >= Params().GetConsensus().FortCanningHeight
+                                  ? CToken::MAX_TOKEN_POOLPAIR_LENGTH
+                                  : CToken::MAX_TOKEN_SYMBOL_LENGTH;
+    if (pairSymbol.length() > symbolLength) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("pairSymbol is larger than %d", symbolLength));
     }
 
     CPoolPairMessage poolPairMsg;
-    poolPairMsg.idTokenA = idtokenA;
-    poolPairMsg.idTokenB = idtokenB;
-    poolPairMsg.commission = commission;
-    poolPairMsg.status = status;
+    poolPairMsg.idTokenA     = idtokenA;
+    poolPairMsg.idTokenB     = idtokenB;
+    poolPairMsg.commission   = commission;
+    poolPairMsg.status       = status;
     poolPairMsg.ownerAddress = ownerAddress;
 
     CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
-    metadata << static_cast<unsigned char>(CustomTxType::CreatePoolPair)
-             << poolPairMsg << pairSymbol;
+    metadata << static_cast<unsigned char>(CustomTxType::CreatePoolPair) << poolPairMsg << pairSymbol;
 
     if (targetHeight >= Params().GetConsensus().ClarkeQuayHeight) {
         metadata << rewards;
@@ -628,7 +681,7 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
     CMutableTransaction rawTx(txVersion);
     rawTx.vout.push_back(CTxOut(0, scriptMeta));
 
-    UniValue const & txInputs = request.params[1];
+    const UniValue &txInputs = request.params[1];
 
     CTransactionRef optAuthTx;
     std::set<CScript> auths;
@@ -651,49 +704,62 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue updatepoolpair(const JSONRPCRequest& request) {
+UniValue updatepoolpair(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"updatepoolpair",
-               "\nCreates (and submits to local node and network) a pool status update transaction.\n"
-               "The second optional argument (may be empty array) is an array of specific UTXOs to spend. One of UTXO's must belong to the pool's owner (collateral) address" +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                   {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                       {
-                           {"pool", RPCArg::Type::STR, RPCArg::Optional::NO, "The pool's symbol, id or creation tx"},
-                           {"status", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Pool Status new property (bool)"},
-                           {"commission", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Pool commission, up to 10^-8"},
-                           {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address of the pool owner."},
-                           {"customRewards", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Token reward to be paid on each block, multiple can be specified."},
-                       },
-                   },
-                   {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects",
+    RPCHelpMan{
+        "updatepoolpair",
+        "\nCreates (and submits to local node and network) a pool status update transaction.\n"
+        "The second optional argument (may be empty array) is an array of specific UTXOs to spend. One of UTXO's must "
+        "belong to the pool's owner (collateral) address" +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {
+                "metadata",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::OMITTED,
+                "",
+                {
+                    {"pool", RPCArg::Type::STR, RPCArg::Optional::NO, "The pool's symbol, id or creation tx"},
+                    {"status", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Pool Status new property (bool)"},
+                    {"commission", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Pool commission, up to 10^-8"},
+                    {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address of the pool owner."},
+                    {"customRewards",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::OMITTED,
+                     "Token reward to be paid on each block, multiple can be specified."},
+                },
+            },                                                                                                    {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
                         {
-                            {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                                {
-                                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                    {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                                },
-                            },
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
                         },
-                   },
-
-               },
-               RPCResult{
-                       "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("updatepoolpair", "'{\"pool\":\"POOL\",\"status\":true,"
-                                                     "\"commission\":0.01,\"ownerAddress\":\"Address\","
-                                                     "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
-                                                     "'[{\"txid\":\"id\",\"vout\":0}]'")
-                       + HelpExampleRpc("updatepoolpair", "'{\"pool\":\"POOL\",\"status\":true,"
-                                                       "\"commission\":0.01,\"ownerAddress\":\"Address\","
-                                                       "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
-                                                       "'[{\"txid\":\"id\",\"vout\":0}]'")
-               },
-    }.Check(request);
+                    },
+                },
+            },                                                                                                                    },
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"},
+        RPCExamples{HelpExampleCli("updatepoolpair",
+                          "'{\"pool\":\"POOL\",\"status\":true,"
+                                   "\"commission\":0.01,\"ownerAddress\":\"Address\","
+                                   "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
+                                   "'[{\"txid\":\"id\",\"vout\":0}]'") +
+                    HelpExampleRpc("updatepoolpair",
+                          "'{\"pool\":\"POOL\",\"status\":true,"
+                                   "\"commission\":0.01,\"ownerAddress\":\"Address\","
+                                   "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
+                                   "'[{\"txid\":\"id\",\"vout\":0}]'")},
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
@@ -703,12 +769,12 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
 
     RPCTypeCheck(request.params, {UniValue::VOBJ, UniValue::VARR}, true);
 
-    bool status = true;
+    bool status        = true;
     CAmount commission = -1;
     CScript ownerAddress;
     CBalances rewards;
-    UniValue const & metaObj = request.params[0].get_obj();
-    UniValue const & txInputs = request.params[1];
+    const UniValue &metaObj  = request.params[0].get_obj();
+    const UniValue &txInputs = request.params[1];
 
     std::string const poolStr = trim_ws(metaObj["pool"].getValStr());
     DCT_ID poolId;
@@ -724,7 +790,7 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
         if (!pool) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Pool %s does not exist!", poolStr));
         }
-        status = pool->status;
+        status       = pool->status;
         targetHeight = ::ChainActive().Height() + 1;
     }
 
@@ -742,7 +808,8 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
 
         if (rewards.balances.empty()) {
             // Add special case to wipe rewards
-            rewards.balances.insert(std::pair<DCT_ID, CAmount>(DCT_ID{std::numeric_limits<uint32_t>::max()}, std::numeric_limits<CAmount>::max()));
+            rewards.balances.insert(std::pair<DCT_ID, CAmount>(DCT_ID{std::numeric_limits<uint32_t>::max()},
+                                                               std::numeric_limits<CAmount>::max()));
         }
     }
 
@@ -784,64 +851,75 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue poolswap(const JSONRPCRequest& request) {
+UniValue poolswap(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"poolswap",
-               "\nCreates (and submits to local node and network) a poolswap transaction with given metadata.\n"
-               "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                   {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::NO, "",
-                       {
-                           {"from", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenA."},
-                           {"tokenFrom", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                                       "tokenFrom coins amount"},
-                           {"to", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenB."},
-                           {"tokenTo", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                       "Maximum acceptable price"},
-                       },
-                   },
-                   {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects",
-                       {
-                           {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                               {
-                                   {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                   {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                               },
-                           },
-                       },
-                   },
-               },
-                      RPCResult{
-                          "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-                      },
-                             RPCExamples{
-                                 HelpExampleCli("poolswap",   "'{\"from\":\"MyAddress\","
-                                                                    "\"tokenFrom\":\"MyToken1\","
-                                                                    "\"amountFrom\":\"0.001\","
-                                                                    "\"to\":\"Address\","
-                                                                    "\"tokenTo\":\"Token2\","
-                                                                    "\"maxPrice\":\"0.01\""
-                                                                    "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-                                         + HelpExampleRpc("poolswap", "'{\"from\":\"MyAddress\","
-                                                                            "\"tokenFrom\":\"MyToken1\","
-                                                                            "\"amountFrom\":\"0.001\","
-                                                                            "\"to\":\"Address\","
-                                                                            "\"tokenTo\":\"Token2\","
-                                                                            "\"maxPrice\":\"0.01\""
-                                                                            "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-                             },
-              }.Check(request);
+    RPCHelpMan{
+        "poolswap",
+        "\nCreates (and submits to local node and network) a poolswap transaction with given metadata.\n"
+        "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {
+                "metadata",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::NO,
+                "",
+                {
+                    {"from", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenA."},
+                    {"tokenFrom",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO, "tokenFrom coins amount"},
+                    {"to", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenB."},
+                    {"tokenTo",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Maximum acceptable price"},
+                },
+            },                                                                                                    {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },                                                                                                              },
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"},
+        RPCExamples{HelpExampleCli("poolswap",
+                          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'") +
+                    HelpExampleRpc("poolswap",
+                          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'")},
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
     }
     pwallet->BlockUntilSyncedToCurrentChain();
 
@@ -862,7 +940,7 @@ UniValue poolswap(const JSONRPCRequest& request) {
     CMutableTransaction rawTx(txVersion);
     rawTx.vout.emplace_back(0, scriptMeta);
 
-    UniValue const & txInputs = request.params[1];
+    const UniValue &txInputs = request.params[1];
     CTransactionRef optAuthTx;
     std::set<CScript> auths{poolSwapMsg.from};
     rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, false /*needFoundersAuth*/, optAuthTx, txInputs);
@@ -885,64 +963,76 @@ UniValue poolswap(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue compositeswap(const JSONRPCRequest& request) {
+UniValue compositeswap(const JSONRPCRequest &request) {
     auto pwallet = GetWallet(request);
 
-    RPCHelpMan{"compositeswap",
-               "\nCreates (and submits to local node and network) a composite swap (swap between multiple poolpairs) transaction with given metadata.\n"
-               "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
-               HelpRequiringPassphrase(pwallet) + "\n",
-               {
-                   {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::NO, "",
-                       {
-                           {"from", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenA."},
-                           {"tokenFrom", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                                       "tokenFrom coins amount"},
-                           {"to", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenB."},
-                           {"tokenTo", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                       "Maximum acceptable price"},
-                       },
-                   },
-                   {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects",
-                       {
-                           {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                               {
-                                   {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                                   {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                               },
-                           },
-                       },
-                   },
-               },
-                      RPCResult{
-                          "\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"
-                      },
-                             RPCExamples{
-                                 HelpExampleCli("compositeswap",   "'{\"from\":\"MyAddress\","
-                                                                    "\"tokenFrom\":\"MyToken1\","
-                                                                    "\"amountFrom\":\"0.001\","
-                                                                    "\"to\":\"Address\","
-                                                                    "\"tokenTo\":\"Token2\","
-                                                                    "\"maxPrice\":\"0.01\""
-                                                                    "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-                                         + HelpExampleRpc("compositeswap", "'{\"from\":\"MyAddress\","
-                                                                            "\"tokenFrom\":\"MyToken1\","
-                                                                            "\"amountFrom\":\"0.001\","
-                                                                            "\"to\":\"Address\","
-                                                                            "\"tokenTo\":\"Token2\","
-                                                                            "\"maxPrice\":\"0.01\""
-                                                                            "}' '[{\"txid\":\"id\",\"vout\":0}]'")
-                             },
-              }.Check(request);
+    RPCHelpMan{
+        "compositeswap",
+        "\nCreates (and submits to local node and network) a composite swap (swap between multiple poolpairs) "
+        "transaction with given metadata.\n"
+        "The second optional argument (may be empty array) is an array of specific UTXOs to spend." +
+            HelpRequiringPassphrase(pwallet) + "\n",
+        {
+                          {
+                "metadata",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::NO,
+                "",
+                {
+                    {"from", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenA."},
+                    {"tokenFrom",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO, "tokenFrom coins amount"},
+                    {"to", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenB."},
+                    {"tokenTo",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Maximum acceptable price"},
+                },
+            },                                                                                                    {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::OMITTED_NAMED_ARG,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                        },
+                    },
+                },
+            },                                                                                                                   },
+        RPCResult{"\"hash\"                  (string) The hex-encoded hash of broadcasted transaction\n"},
+        RPCExamples{HelpExampleCli("compositeswap",
+                          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'") +
+                    HelpExampleRpc("compositeswap",
+                          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}' '[{\"txid\":\"id\",\"vout\":0}]'")},
+    }
+        .Check(request);
 
     if (pwallet->chain().isInitialBlockDownload()) {
-        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
     }
     pwallet->BlockUntilSyncedToCurrentChain();
 
@@ -954,7 +1044,7 @@ UniValue compositeswap(const JSONRPCRequest& request) {
     RPCTypeCheck(request.params, {UniValue::VOBJ, UniValue::VARR}, true);
 
     CPoolSwapMessageV2 poolSwapMsgV2{};
-    CPoolSwapMessage& poolSwapMsg = poolSwapMsgV2.swapInfo;
+    CPoolSwapMessage &poolSwapMsg = poolSwapMsgV2.swapInfo;
     CheckAndFillPoolSwapMessage(request, poolSwapMsg);
 
     {
@@ -962,8 +1052,7 @@ UniValue compositeswap(const JSONRPCRequest& request) {
         // If no direct swap found search for composite swap
         auto directPool = pcustomcsview->GetPoolPair(poolSwapMsg.idTokenFrom, poolSwapMsg.idTokenTo);
         if (!directPool || !directPool->second.status) {
-
-            auto compositeSwap = CPoolSwap(poolSwapMsg, targetHeight);
+            auto compositeSwap    = CPoolSwap(poolSwapMsg, targetHeight);
             poolSwapMsgV2.poolIDs = compositeSwap.CalculateSwaps(*pcustomcsview);
 
             // No composite or direct pools found
@@ -973,7 +1062,8 @@ UniValue compositeswap(const JSONRPCRequest& request) {
                 if (!compositeSwap.errors.empty()) {
                     errorMsg += " Details: (";
                     for (size_t i{0}; i < compositeSwap.errors.size(); ++i) {
-                        errorMsg += '"' + compositeSwap.errors[i].first + "\":\"" +  compositeSwap.errors[i].second + '"' + (i + 1 < compositeSwap.errors.size() ? "," : "");
+                        errorMsg += '"' + compositeSwap.errors[i].first + "\":\"" + compositeSwap.errors[i].second +
+                                    '"' + (i + 1 < compositeSwap.errors.size() ? "," : "");
                     }
                     errorMsg += ')';
                 }
@@ -993,7 +1083,7 @@ UniValue compositeswap(const JSONRPCRequest& request) {
     CMutableTransaction rawTx(txVersion);
     rawTx.vout.emplace_back(0, scriptMeta);
 
-    UniValue const & txInputs = request.params[1];
+    const UniValue &txInputs = request.params[1];
     CTransactionRef optAuthTx;
     std::set<CScript> auths{poolSwapMsg.from};
     rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, false /*needFoundersAuth*/, optAuthTx, txInputs);
@@ -1016,60 +1106,63 @@ UniValue compositeswap(const JSONRPCRequest& request) {
     return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
 }
 
-UniValue testpoolswap(const JSONRPCRequest& request) {
-
-    RPCHelpMan{"testpoolswap",
-               "\nTests a poolswap transaction with given metadata and returns poolswap result.\n",
-               {
-                   {"metadata", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                       {
-                           {"from", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenA."},
-                           {"tokenFrom", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                                       "tokenFrom coins amount"},
-                           {"to", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "Address of the owner of tokenB."},
-                           {"tokenTo", RPCArg::Type::STR, RPCArg::Optional::NO,
-                                       "One of the keys may be specified (id/symbol)"},
-                           {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                       "Maximum acceptable price"},
-                       },
-                   },
-                   {
-                       "path", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
-                       "One of auto/direct (default = direct)\n"
-                       "auto - automatically use composite swap or direct swap as needed.\n"
-                       "direct - uses direct path only or fails.\n"
-                       "composite - uses composite path only or fails.\n"
-                       "Note: The default will be switched to auto in the upcoming versions."
-                   },
-                   {
-                       "verbose", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                       "Returns estimated composite path when true (default = false)"
-                   },
-               },
-               RPCResult{
-                          "\"amount@tokenId\"    (string) The string with amount result of poolswap in format AMOUNT@TOKENID.\n"
-               },
-               RPCExamples{
-                    HelpExampleCli("testpoolswap",   "'{\"from\":\"MyAddress\","
-                                                    "\"tokenFrom\":\"MyToken1\","
-                                                    "\"amountFrom\":\"0.001\","
-                                                    "\"to\":\"Address\","
-                                                    "\"tokenTo\":\"Token2\","
-                                                    "\"maxPrice\":\"0.01\""
-                                                    "}'")
-                    + HelpExampleRpc("testpoolswap", "'{\"from\":\"MyAddress\","
-                                                    "\"tokenFrom\":\"MyToken1\","
-                                                    "\"amountFrom\":\"0.001\","
-                                                    "\"to\":\"Address\","
-                                                    "\"tokenTo\":\"Token2\","
-                                                    "\"maxPrice\":\"0.01\""
-                                                    "}'")
-               },
-    }.Check(request);
+UniValue testpoolswap(const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "testpoolswap",
+        "\nTests a poolswap transaction with given metadata and returns poolswap result.\n",
+        {
+          {
+                "metadata",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::OMITTED,
+                "",
+                {
+                    {"from", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenA."},
+                    {"tokenFrom",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"amountFrom", RPCArg::Type::NUM, RPCArg::Optional::NO, "tokenFrom coins amount"},
+                    {"to", RPCArg::Type::STR, RPCArg::Optional::NO, "Address of the owner of tokenB."},
+                    {"tokenTo",
+                     RPCArg::Type::STR,
+                     RPCArg::Optional::NO,
+                     "One of the keys may be specified (id/symbol)"},
+                    {"maxPrice", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Maximum acceptable price"},
+                },
+            },                                     {"path",
+             RPCArg::Type::STR,
+             RPCArg::Optional::OMITTED,
+             "One of auto/direct (default = direct)\n"
+             "auto - automatically use composite swap or direct swap as needed.\n"
+             "direct - uses direct path only or fails.\n"
+             "composite - uses composite path only or fails.\n"
+             "Note: The default will be switched to auto in the upcoming versions."},
+          {"verbose",
+             RPCArg::Type::BOOL,
+             RPCArg::Optional::OMITTED,
+             "Returns estimated composite path when true (default = false)"},
+          },
+        RPCResult{
+          "\"amount@tokenId\"    (string) The string with amount result of poolswap in format AMOUNT@TOKENID.\n"                                                 },
+        RPCExamples{HelpExampleCli("testpoolswap",
+          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}'") +
+                    HelpExampleRpc("testpoolswap",
+          "'{\"from\":\"MyAddress\","
+                                   "\"tokenFrom\":\"MyToken1\","
+                                   "\"amountFrom\":\"0.001\","
+                                   "\"to\":\"Address\","
+                                   "\"tokenTo\":\"Token2\","
+                                   "\"maxPrice\":\"0.01\""
+                                   "}'")                                                                                                                         },
+    }
+        .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VOBJ, UniValueType(), UniValue::VBOOL}, true);
 
@@ -1092,19 +1185,21 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
     Res res = Res::Ok();
     {
         LOCK(cs_main);
-        CCustomCSView mnview_dummy(*pcustomcsview); // create dummy cache for test state writing
+        CCustomCSView mnview_dummy(*pcustomcsview);  // create dummy cache for test state writing
 
         uint32_t targetHeight = ::ChainActive().Height() + 1;
-        auto poolSwap = CPoolSwap({poolSwapMsg, targetHeight});
+        auto poolSwap         = CPoolSwap({poolSwapMsg, targetHeight});
         std::vector<DCT_ID> poolIds;
         auto poolPair = mnview_dummy.GetPoolPair(poolSwapMsg.idTokenFrom, poolSwapMsg.idTokenTo);
 
-        if (poolPair && poolPair->second.status && path == "auto") path = "direct";
+        if (poolPair && poolPair->second.status && path == "auto")
+            path = "direct";
 
         // If no direct swap found search for composite swap
         if (path == "direct") {
             if (!poolPair)
-                throw JSONRPCError(RPC_INVALID_REQUEST, "Direct pool pair not found. Use 'auto' mode to use composite swap.");
+                throw JSONRPCError(RPC_INVALID_REQUEST,
+                                   "Direct pool pair not found. Use 'auto' mode to use composite swap.");
 
             poolIds.push_back(poolPair->first);
         } else if (path == "auto" || path == "composite") {
@@ -1119,7 +1214,7 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
                 poolArray.read(request.params[1].getValStr().c_str());
             }
 
-            for (const auto& id : poolArray.getValues()) {
+            for (const auto &id : poolArray.getValues()) {
                 poolIds.push_back(DCT_ID::FromString(id.getValStr()));
             }
         }
@@ -1130,7 +1225,8 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
             if (!poolSwap.errors.empty()) {
                 errorMsg += " Details: (";
                 for (size_t i{0}; i < poolSwap.errors.size(); ++i) {
-                    errorMsg += '"' + poolSwap.errors[i].first + "\":\"" +  poolSwap.errors[i].second + '"' + (i + 1 < poolSwap.errors.size() ? "," : "");
+                    errorMsg += '"' + poolSwap.errors[i].first + "\":\"" + poolSwap.errors[i].second + '"' +
+                                (i + 1 < poolSwap.errors.size() ? "," : "");
                 }
                 errorMsg += ')';
             } else {
@@ -1139,7 +1235,7 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
             }
             throw JSONRPCError(RPC_INVALID_REQUEST, errorMsg);
         }
-        for (const auto& id : poolIds) {
+        for (const auto &id : poolIds) {
             pools.push_back(id.ToString());
         }
         res.msg = poolSwap.GetResult().ToString();
@@ -1156,35 +1252,47 @@ UniValue testpoolswap(const JSONRPCRequest& request) {
     return res.msg;
 }
 
-UniValue listpoolshares(const JSONRPCRequest& request) {
-    RPCHelpMan{"listpoolshares",
-               "\nReturns information about pool shares.\n",
-               {
-                        {"pagination", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                            {
-                                 {"start", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                  "Optional first key to iterate from, in lexicographical order."},
-                                 {"including_start", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                                  "If true, then iterate including starting position. False by default"},
-                                 {"limit", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
-                                  "Maximum number of pools to return, 100 by default"},
-                            },
-                        },
-                        {"verbose", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                                    "Flag for verbose list (default = true), otherwise only % are shown."},
-                        {"is_mine_only", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED,
-                                    "Get shares for all accounts belonging to the wallet (default = false)"},
-               },
-               RPCResult{
-                       "{id:{...},...}     (array) Json object with pools information\n"
-               },
-               RPCExamples{
-                       HelpExampleCli("listpoolshares", "'{\"start\":128}' false false")
-                       + HelpExampleRpc("listpoolshares", "'{\"start\":128}' false false")
-               },
-    }.Check(request);
-
-    if (auto res = GetRPCResultCache().TryGet(request)) return *res;
+UniValue listpoolshares(const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "listpoolshares",
+        "\nReturns information about pool shares.\n",
+        {
+          {
+                "pagination",
+                RPCArg::Type::OBJ,
+                RPCArg::Optional::OMITTED,
+                "",
+                {
+                    {"start",
+                     RPCArg::Type::NUM,
+                     RPCArg::Optional::OMITTED,
+                     "Optional first key to iterate from, in lexicographical order."},
+                    {"including_start",
+                     RPCArg::Type::BOOL,
+                     RPCArg::Optional::OMITTED,
+                     "If true, then iterate including starting position. False by default"},
+                    {"limit",
+                     RPCArg::Type::NUM,
+                     RPCArg::Optional::OMITTED,
+                     "Maximum number of pools to return, 100 by default"},
+                },
+            },                                                 {"verbose",
+             RPCArg::Type::BOOL,
+             RPCArg::Optional::OMITTED,
+             "Flag for verbose list (default = true), otherwise only % are shown."},
+          {"is_mine_only",
+             RPCArg::Type::BOOL,
+             RPCArg::Optional::OMITTED,
+             "Get shares for all accounts belonging to the wallet (default = false)"},
+          },
+        RPCResult{"{id:{...},...}     (array) Json object with pools information\n"                                                             },
+        RPCExamples{HelpExampleCli("listpoolshares", "'{\"start\":128}' false false") +
+                    HelpExampleRpc("listpoolshares",                                "'{\"start\":128}' false false") },
+    }
+        .Check(request);
+
+    if (auto res = GetRPCResultCache().TryGet(request))
+        return *res;
 
     bool verbose = true;
     if (request.params.size() > 1) {
@@ -1206,11 +1314,11 @@ UniValue listpoolshares(const JSONRPCRequest& request) {
         if (request.params.size() > 0) {
             UniValue paginationObj = request.params[0].get_obj();
             if (!paginationObj["limit"].isNull()) {
-                limit = (size_t) paginationObj["limit"].get_int64();
+                limit = (size_t)paginationObj["limit"].get_int64();
             }
             if (!paginationObj["start"].isNull()) {
                 including_start = false;
-                start.v = (uint32_t) paginationObj["start"].get_int();
+                start.v         = (uint32_t)paginationObj["start"].get_int();
             }
             if (!paginationObj["including_start"].isNull()) {
                 including_start = paginationObj["including_start"].getBool();
@@ -1226,51 +1334,52 @@ UniValue listpoolshares(const JSONRPCRequest& request) {
 
     LOCK(cs_main);
 
-    PoolShareKey startKey{ start, CScript{} };
-//    startKey.poolID = start;
-//    startKey.owner = CScript(0);
+    PoolShareKey startKey{start, CScript{}};
+    //    startKey.poolID = start;
+    //    startKey.owner = CScript(0);
 
     UniValue ret(UniValue::VOBJ);
-    pcustomcsview->ForEachPoolShare([&](DCT_ID const & poolId, CScript const & provider, uint32_t) {
-        const CTokenAmount tokenAmount = pcustomcsview->GetBalance(provider, poolId);
-        if(tokenAmount.nValue) {
-            const auto poolPair = pcustomcsview->GetPoolPair(poolId);
-            if(poolPair) {
-                if (isMineOnly) {
-                    if (IsMineCached(*pwallet, provider) == ISMINE_SPENDABLE) {
+    pcustomcsview->ForEachPoolShare(
+        [&](DCT_ID const &poolId, const CScript &provider, uint32_t) {
+            const CTokenAmount tokenAmount = pcustomcsview->GetBalance(provider, poolId);
+            if (tokenAmount.nValue) {
+                const auto poolPair = pcustomcsview->GetPoolPair(poolId);
+                if (poolPair) {
+                    if (isMineOnly) {
+                        if (IsMineCached(*pwallet, provider) == ISMINE_SPENDABLE) {
+                            ret.pushKVs(poolShareToJSON(poolId, provider, tokenAmount.nValue, *poolPair, verbose));
+                            limit--;
+                        }
+                    } else {
                         ret.pushKVs(poolShareToJSON(poolId, provider, tokenAmount.nValue, *poolPair, verbose));
                         limit--;
                     }
-                } else {
-                    ret.pushKVs(poolShareToJSON(poolId, provider, tokenAmount.nValue, *poolPair, verbose));
-                    limit--;
                 }
             }
-        }
 
-        return limit != 0;
-    }, startKey);
+            return limit != 0;
+        },
+        startKey);
 
     return GetRPCResultCache().Set(request, ret);
 }
 
-static const CRPCCommand commands[] =
-{
-//  category        name                        actor (function)            params
-//  -------------   -----------------------     ---------------------       ----------
-    {"poolpair",    "listpoolpairs",            &listpoolpairs,             {"pagination", "verbose"}},
-    {"poolpair",    "getpoolpair",              &getpoolpair,               {"key", "verbose" }},
-    {"poolpair",    "addpoolliquidity",         &addpoolliquidity,          {"from", "shareAddress", "inputs"}},
-    {"poolpair",    "removepoolliquidity",      &removepoolliquidity,       {"from", "amount", "inputs"}},
-    {"poolpair",    "createpoolpair",           &createpoolpair,            {"metadata", "inputs"}},
-    {"poolpair",    "updatepoolpair",           &updatepoolpair,            {"metadata", "inputs"}},
-    {"poolpair",    "poolswap",                 &poolswap,                  {"metadata", "inputs"}},
-    {"poolpair",    "compositeswap",            &compositeswap,             {"metadata", "inputs"}},
-    {"poolpair",    "listpoolshares",           &listpoolshares,            {"pagination", "verbose", "is_mine_only"}},
-    {"poolpair",    "testpoolswap",             &testpoolswap,              {"metadata", "path", "verbose"}},
+static const CRPCCommand commands[] = {
+  //  category        name                        actor (function)            params
+  //  -------------   -----------------------     ---------------------       ----------
+    {"poolpair", "listpoolpairs",       &listpoolpairs,       {"pagination", "verbose"}                },
+    {"poolpair", "getpoolpair",         &getpoolpair,         {"key", "verbose"}                       },
+    {"poolpair", "addpoolliquidity",    &addpoolliquidity,    {"from", "shareAddress", "inputs"}       },
+    {"poolpair", "removepoolliquidity", &removepoolliquidity, {"from", "amount", "inputs"}             },
+    {"poolpair", "createpoolpair",      &createpoolpair,      {"metadata", "inputs"}                   },
+    {"poolpair", "updatepoolpair",      &updatepoolpair,      {"metadata", "inputs"}                   },
+    {"poolpair", "poolswap",            &poolswap,            {"metadata", "inputs"}                   },
+    {"poolpair", "compositeswap",       &compositeswap,       {"metadata", "inputs"}                   },
+    {"poolpair", "listpoolshares",      &listpoolshares,      {"pagination", "verbose", "is_mine_only"}},
+    {"poolpair", "testpoolswap",        &testpoolswap,        {"metadata", "path", "verbose"}          },
 };
 
-void RegisterPoolpairRPCCommands(CRPCTable& tableRPC) {
+void RegisterPoolpairRPCCommands(CRPCTable &tableRPC) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
         tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
 }
diff --git a/src/masternodes/skipped_txs.cpp b/src/masternodes/skipped_txs.cpp
index 5e0a7289e7..1992e64bfd 100644
--- a/src/masternodes/skipped_txs.cpp
+++ b/src/masternodes/skipped_txs.cpp
@@ -1,12 +1,11 @@
 
-#include <algorithm>
 #include <chainparams.h>
+#include <uint256.h>
+#include <algorithm>
 #include <string>
 #include <vector>
-#include <uint256.h>
-
-bool IsSkippedTx(const uint256& hash) {
 
+bool IsSkippedTx(const uint256 &hash) {
     static const std::vector<std::string> skipped_txs_mainnet = {
         "ffcafd71820269ffe9cbecc12619154a3c5b272f1437d4e0242ff73d2bf09e4e",
         "4218d310d9a67b5e9a93d2a9ecf17bd70bda7a3670191efbc755b05c5fb8a6a4",
@@ -369,7 +368,7 @@ bool IsSkippedTx(const uint256& hash) {
         "e30ad732c4ec80946a9aef649e3eef521bf408f29539c0ff254b67272cc908ea",
     };
 
-    static const auto& skipped_txs = Params().NetworkIDString() == "main" ? skipped_txs_mainnet : skipped_txs_testnet;
+    static const auto &skipped_txs = Params().NetworkIDString() == "main" ? skipped_txs_mainnet : skipped_txs_testnet;
 
     return std::find(skipped_txs.begin(), skipped_txs.end(), hash.GetHex()) != skipped_txs.end();
 }
diff --git a/src/masternodes/tokens.cpp b/src/masternodes/tokens.cpp
index 7c6cb31f11..e8e4dc1dbb 100644
--- a/src/masternodes/tokens.cpp
+++ b/src/masternodes/tokens.cpp
@@ -5,7 +5,7 @@
 #include <masternodes/tokens.h>
 
 #include <amount.h>
-#include <chainparams.h> // Params()
+#include <chainparams.h>  // Params()
 #include <core_io.h>
 #include <primitives/transaction.h>
 #include <util/strencodings.h>
@@ -16,13 +16,12 @@ const DCT_ID CTokensView::DCT_ID_START = DCT_ID{128};
 
 extern const std::string CURRENCY_UNIT;
 
-std::optional<CTokensView::CTokenImpl> CTokensView::GetToken(DCT_ID id) const
-{
+std::optional<CTokensView::CTokenImpl> CTokensView::GetToken(DCT_ID id) const {
     return ReadBy<ID, CTokenImpl>(id);
 }
 
-std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> CTokensView::GetToken(const std::string & symbolKey) const
-{
+std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> CTokensView::GetToken(
+    const std::string &symbolKey) const {
     DCT_ID id;
     if (ReadBy<Symbol, std::string>(symbolKey, id)) {
         return std::make_pair(id, GetToken(id));
@@ -30,8 +29,7 @@ std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> CTokens
     return {};
 }
 
-std::optional<std::pair<DCT_ID, CTokensView::CTokenImpl> > CTokensView::GetTokenByCreationTx(const uint256 & txid) const
-{
+std::optional<std::pair<DCT_ID, CTokensView::CTokenImpl>> CTokensView::GetTokenByCreationTx(const uint256 &txid) const {
     DCT_ID id;
     if (ReadBy<CreationTx, uint256>(txid, id)) {
         if (auto tokenImpl = ReadBy<ID, CTokenImpl>(id)) {
@@ -41,19 +39,18 @@ std::optional<std::pair<DCT_ID, CTokensView::CTokenImpl> > CTokensView::GetToken
     return {};
 }
 
-void CTokensView::ForEachToken(std::function<bool (const DCT_ID &, CLazySerialize<CTokenImpl>)> callback, DCT_ID const & start)
-{
+void CTokensView::ForEachToken(std::function<bool(const DCT_ID &, CLazySerialize<CTokenImpl>)> callback,
+                               DCT_ID const &start) {
     ForEach<ID, DCT_ID, CTokenImpl>(callback, start);
 }
 
-Res CTokensView::CreateDFIToken()
-{
+Res CTokensView::CreateDFIToken() {
     CTokenImpl token;
-    token.symbol = CURRENCY_UNIT;
-    token.name = "Default Defi token";
-    token.creationTx = uint256();
+    token.symbol         = CURRENCY_UNIT;
+    token.name           = "Default Defi token";
+    token.creationTx     = uint256();
     token.creationHeight = 0;
-    token.flags = '\0';
+    token.flags          = '\0';
     token.flags |= (uint8_t)CToken::TokenFlags::DAT;
     token.flags |= (uint8_t)CToken::TokenFlags::Tradeable;
     token.flags |= (uint8_t)CToken::TokenFlags::Finalized;
@@ -65,8 +62,7 @@ Res CTokensView::CreateDFIToken()
     return Res::Ok();
 }
 
-ResVal<DCT_ID> CTokensView::CreateToken(const CTokensView::CTokenImpl & token, bool isPreBayfront)
-{
+ResVal<DCT_ID> CTokensView::CreateToken(const CTokensView::CTokenImpl &token, bool isPreBayfront) {
     // this should not happen, but for sure
     if (GetTokenByCreationTx(token.creationTx)) {
         return Res::Err("token with creation tx %s already exists!", token.creationTx.ToString());
@@ -78,20 +74,30 @@ ResVal<DCT_ID> CTokensView::CreateToken(const CTokensView::CTokenImpl & token, b
     }
 
     DCT_ID id{0};
-    if(token.IsDAT()) {
+    if (token.IsDAT()) {
         if (GetToken(token.symbol)) {
             return Res::Err("token '%s' already exists!", token.symbol);
         }
-        ForEachToken([&](DCT_ID const& currentId, CLazySerialize<CTokenImplementation>) {
-            if(currentId < DCT_ID_START)
-                id.v = currentId.v + 1;
-            return currentId < DCT_ID_START;
-        }, id);
+        ForEachToken(
+            [&](DCT_ID const &currentId, CLazySerialize<CTokenImplementation>) {
+                if (currentId < DCT_ID_START)
+                    id.v = currentId.v + 1;
+                return currentId < DCT_ID_START;
+            },
+            id);
         if (id == DCT_ID_START) {
             if (isPreBayfront)
-                return Res::Err("Critical fault: trying to create DCT_ID same as DCT_ID_START for Foundation owner\n"); // asserted before BayfrontHeight, keep it for strict sameness
+                return Res::Err(
+                    "Critical fault: trying to create DCT_ID same as DCT_ID_START for Foundation owner\n");  // asserted
+                                                                                                             // before
+                                                                                                             // BayfrontHeight,
+                                                                                                             // keep it
+                                                                                                             // for
+                                                                                                             // strict
+                                                                                                             // sameness
             id = IncrementLastDctId();
-            LogPrintf("Warning! Range <DCT_ID_START already filled. Using \"common\" id=%s for new token\n", id.ToString().c_str());
+            LogPrintf("Warning! Range <DCT_ID_START already filled. Using \"common\" id=%s for new token\n",
+                      id.ToString().c_str());
         }
     } else {
         id = IncrementLastDctId();
@@ -105,16 +111,17 @@ ResVal<DCT_ID> CTokensView::CreateToken(const CTokensView::CTokenImpl & token, b
     return {id, Res::Ok()};
 }
 
-Res CTokensView::UpdateToken(const CTokenImpl& newToken, bool isPreBayfront, const bool tokenSplitUpdate)
-{
+Res CTokensView::UpdateToken(const CTokenImpl &newToken, bool isPreBayfront, const bool tokenSplitUpdate) {
     auto pair = GetTokenByCreationTx(newToken.creationTx);
     if (!pair) {
         return Res::Err("token with creationTx %s does not exist!", newToken.creationTx.ToString());
     }
-    DCT_ID id = pair->first;
-    CTokenImpl & oldToken = pair->second;
+    DCT_ID id            = pair->first;
+    CTokenImpl &oldToken = pair->second;
 
-    if (!isPreBayfront && oldToken.IsFinalized()) { // for compatibility, in potential case when someone cheat and create finalized token with old node (and then alter dat for ex.)
+    if (!isPreBayfront &&
+        oldToken.IsFinalized()) {  // for compatibility, in potential case when someone cheat and create finalized token
+                                   // with old node (and then alter dat for ex.)
         return Res::Err("can't alter 'Finalized' tokens");
     }
 
@@ -130,7 +137,8 @@ Res CTokensView::UpdateToken(const CTokenImpl& newToken, bool isPreBayfront, con
     }
 
     // deal with DB symbol indexes before touching symbols/DATs:
-    if (oldToken.symbol != newToken.symbol || oldToken.IsDAT() != newToken.IsDAT()) { // in both cases it leads to index changes
+    if (oldToken.symbol != newToken.symbol ||
+        oldToken.IsDAT() != newToken.IsDAT()) {  // in both cases it leads to index changes
         // create keys with regard of new flag
         std::string oldSymbolKey = oldToken.CreateSymbolKey(id);
         std::string newSymbolKey = newToken.CreateSymbolKey(id);
@@ -153,7 +161,7 @@ Res CTokensView::UpdateToken(const CTokenImpl& newToken, bool isPreBayfront, con
     if (oldToken.IsTradeable() != newToken.IsTradeable())
         oldToken.flags ^= (uint8_t)CToken::TokenFlags::Tradeable;
 
-    if (!oldToken.IsFinalized() && newToken.IsFinalized()) // IsFinalized() itself was checked upthere (with Err)
+    if (!oldToken.IsFinalized() && newToken.IsFinalized())  // IsFinalized() itself was checked upthere (with Err)
         oldToken.flags |= (uint8_t)CToken::TokenFlags::Finalized;
 
     if (tokenSplitUpdate && oldToken.IsLoanToken() != newToken.IsLoanToken())
@@ -175,30 +183,30 @@ Res CTokensView::UpdateToken(const CTokenImpl& newToken, bool isPreBayfront, con
  * Removes `Finalized` and/or `LPS` flags _possibly_set_ by bytecoded (cheated) txs before bayfront fork
  * Call this EXECTLY at the 'bayfrontHeight-1' block
  */
-Res CTokensView::BayfrontFlagsCleanup()
-{
-    ForEachToken([&] (DCT_ID const & id, CTokenImpl token){
-        bool changed{false};
-        if (token.IsFinalized()) {
-            token.flags ^= (uint8_t)CToken::TokenFlags::Finalized;
-            LogPrintf("Warning! Got `Finalized` token, id=%s\n", id.ToString().c_str());
-            changed = true;
-        }
-        if (token.IsPoolShare()) {
-            token.flags ^= (uint8_t)CToken::TokenFlags::LPS;
-            LogPrintf("Warning! Got `LPS` token, id=%s\n", id.ToString().c_str());
-            changed = true;
-        }
-        if (changed) {
-            WriteBy<ID>(id, token);
-        }
-        return true;
-    }, DCT_ID{1}); // start from non-DFI
+Res CTokensView::BayfrontFlagsCleanup() {
+    ForEachToken(
+        [&](DCT_ID const &id, CTokenImpl token) {
+            bool changed{false};
+            if (token.IsFinalized()) {
+                token.flags ^= (uint8_t)CToken::TokenFlags::Finalized;
+                LogPrintf("Warning! Got `Finalized` token, id=%s\n", id.ToString().c_str());
+                changed = true;
+            }
+            if (token.IsPoolShare()) {
+                token.flags ^= (uint8_t)CToken::TokenFlags::LPS;
+                LogPrintf("Warning! Got `LPS` token, id=%s\n", id.ToString().c_str());
+                changed = true;
+            }
+            if (changed) {
+                WriteBy<ID>(id, token);
+            }
+            return true;
+        },
+        DCT_ID{1});  // start from non-DFI
     return Res::Ok();
 }
 
-Res CTokensView::AddMintedTokens(DCT_ID const &id, CAmount const & amount)
-{
+Res CTokensView::AddMintedTokens(DCT_ID const &id, const CAmount &amount) {
     auto tokenImpl = GetToken(id);
     if (!tokenImpl) {
         return Res::Err("token with id %d does not exist!", id.v);
@@ -214,8 +222,7 @@ Res CTokensView::AddMintedTokens(DCT_ID const &id, CAmount const & amount)
     return Res::Ok();
 }
 
-Res CTokensView::SubMintedTokens(DCT_ID const &id, CAmount const & amount)
-{
+Res CTokensView::SubMintedTokens(DCT_ID const &id, const CAmount &amount) {
     auto tokenImpl = GetToken(id);
     if (!tokenImpl) {
         return Res::Err("token with id %d does not exist!", id.v);
@@ -231,19 +238,17 @@ Res CTokensView::SubMintedTokens(DCT_ID const &id, CAmount const & amount)
     return Res::Ok();
 }
 
-DCT_ID CTokensView::IncrementLastDctId()
-{
+DCT_ID CTokensView::IncrementLastDctId() {
     DCT_ID result{DCT_ID_START};
     auto lastDctId = ReadLastDctId();
     if (lastDctId) {
         result = DCT_ID{std::max(lastDctId->v + 1, result.v)};
     }
-    assert (Write(LastDctId::prefix(), result));
+    assert(Write(LastDctId::prefix(), result));
     return result;
 }
 
-std::optional<DCT_ID> CTokensView::ReadLastDctId() const
-{
+std::optional<DCT_ID> CTokensView::ReadLastDctId() const {
     DCT_ID lastDctId{DCT_ID_START};
     if (Read(LastDctId::prefix(), lastDctId)) {
         return {lastDctId};
@@ -251,8 +256,7 @@ std::optional<DCT_ID> CTokensView::ReadLastDctId() const
     return {};
 }
 
-inline Res CTokenImplementation::IsValidSymbol() const
-{
+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");
     }
diff --git a/src/masternodes/tokens.h b/src/masternodes/tokens.h
index ff99b62973..819d893c86 100644
--- a/src/masternodes/tokens.h
+++ b/src/masternodes/tokens.h
@@ -16,72 +16,51 @@
 class CTransaction;
 class UniValue;
 
-class CToken
-{
+class CToken {
 public:
-    static const uint8_t MAX_TOKEN_NAME_LENGTH = 128;
-    static const uint8_t MAX_TOKEN_SYMBOL_LENGTH = 8;
+    static const uint8_t MAX_TOKEN_NAME_LENGTH     = 128;
+    static const uint8_t MAX_TOKEN_SYMBOL_LENGTH   = 8;
     static const uint8_t MAX_TOKEN_POOLPAIR_LENGTH = 16;
-    enum class TokenFlags : uint8_t
-    {
-        None = 0,
-        Mintable = 0x01,
+    enum class TokenFlags : uint8_t {
+        None      = 0,
+        Mintable  = 0x01,
         Tradeable = 0x02,
-        DAT = 0x04,
-        LPS = 0x08, // Liquidity Pool Share
-        Finalized = 0x10, // locked forever
-        LoanToken = 0x20, // token created for loan
-        Default = TokenFlags::Mintable | TokenFlags::Tradeable
+        DAT       = 0x04,
+        LPS       = 0x08,  // Liquidity Pool Share
+        Finalized = 0x10,  // locked forever
+        LoanToken = 0x20,  // token created for loan
+        Default   = TokenFlags::Mintable | TokenFlags::Tradeable
     };
 
     //! basic properties
     std::string symbol;
     std::string name;
-    uint8_t decimal;    // now fixed to 8
-    CAmount limit;      // now isn't tracked
-    uint8_t flags;      // minting support, tradeability
+    uint8_t decimal;  // now fixed to 8
+    CAmount limit;    // now isn't tracked
+    uint8_t flags;    // minting support, tradeability
 
     CToken()
-        : symbol("")
-        , name("")
-        , decimal(8)
-        , limit(0)
-        , flags(uint8_t(TokenFlags::Default))
-    {}
+        : symbol(""),
+          name(""),
+          decimal(8),
+          limit(0),
+          flags(uint8_t(TokenFlags::Default)) {}
     virtual ~CToken() = default;
 
-    inline bool IsMintable() const
-    {
-        return flags & (uint8_t)TokenFlags::Mintable;
-    }
-    inline bool IsTradeable() const
-    {
-        return flags & (uint8_t)TokenFlags::Tradeable;
-    }
-    inline bool IsDAT() const
-    {
-        return flags & (uint8_t)TokenFlags::DAT;
-    }
-    inline bool IsPoolShare() const
-    {
-        return flags & (uint8_t)TokenFlags::LPS;
-    }
-    inline bool IsFinalized() const
-    {
-        return flags & (uint8_t)TokenFlags::Finalized;
-    }
-    inline bool IsLoanToken () const
-    {
-        return flags & (uint8_t)TokenFlags::LoanToken;
-    }
-    inline std::string CreateSymbolKey(DCT_ID const & id) const {
+    inline bool IsMintable() const { return flags & (uint8_t)TokenFlags::Mintable; }
+    inline bool IsTradeable() const { return flags & (uint8_t)TokenFlags::Tradeable; }
+    inline bool IsDAT() const { return flags & (uint8_t)TokenFlags::DAT; }
+    inline bool IsPoolShare() const { return flags & (uint8_t)TokenFlags::LPS; }
+    inline bool IsFinalized() const { return flags & (uint8_t)TokenFlags::Finalized; }
+    inline bool IsLoanToken() const { return flags & (uint8_t)TokenFlags::LoanToken; }
+    inline std::string CreateSymbolKey(DCT_ID const &id) const {
         return symbol + (IsDAT() ? "" : "#" + std::to_string(id.v));
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(symbol);
         READWRITE(name);
         READWRITE(decimal);
@@ -90,30 +69,28 @@ class CToken
     }
 };
 
-class CTokenImplementation : public CToken
-{
+class CTokenImplementation : public CToken {
 public:
     //! tx related properties
     CAmount minted;
     uint256 creationTx;
     uint256 destructionTx;
-    int32_t creationHeight; // @todo use unsigned integers, because serialization of signed integers isn't fulled defined
+    int32_t
+        creationHeight;  // @todo use unsigned integers, because serialization of signed integers isn't fulled defined
     int32_t destructionHeight;
 
     CTokenImplementation()
-        : CToken()
-        , minted(0)
-        , creationTx()
-        , destructionTx()
-        , creationHeight(-1)
-        , destructionHeight(-1)
-    {}
-    explicit CTokenImplementation(const CToken& token)
-            : CToken(token)
-            , minted(0)
-            , creationHeight(-1)
-            , destructionHeight(-1)
-    {}
+        : CToken(),
+          minted(0),
+          creationTx(),
+          destructionTx(),
+          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;
@@ -121,7 +98,7 @@ class CTokenImplementation : public CToken
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CToken, *this);
         READWRITE(minted);
         READWRITE(creationTx);
@@ -131,34 +108,42 @@ class CTokenImplementation : public CToken
     }
 };
 
-class CTokensView : public virtual CStorageView
-{
+class CTokensView : public virtual CStorageView {
 public:
-    static const DCT_ID DCT_ID_START; // = 128;
-    static const unsigned char DB_TOKEN_LASTID; // = 'L';
+    static const DCT_ID DCT_ID_START;            // = 128;
+    static const unsigned char DB_TOKEN_LASTID;  // = 'L';
 
     using CTokenImpl = CTokenImplementation;
     std::optional<CTokenImpl> GetToken(DCT_ID id) const;
-    std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> GetToken(std::string const & symbol) const;
+    std::optional<std::pair<DCT_ID, std::optional<CTokensView::CTokenImpl>>> GetToken(const std::string &symbol) const;
     // the only possible type of token (with creationTx) is CTokenImpl
-    std::optional<std::pair<DCT_ID, CTokenImpl>> GetTokenByCreationTx(uint256 const & txid) const;
-    [[nodiscard]] virtual std::optional<CTokenImpl> GetTokenGuessId(const std::string & str, DCT_ID & id) const = 0;
+    std::optional<std::pair<DCT_ID, CTokenImpl>> GetTokenByCreationTx(const uint256 &txid) const;
+    [[nodiscard]] virtual std::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});
+    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 = false);
-    Res UpdateToken(CTokenImpl const & newToken, bool isPreBayfront = false, const bool tokenSplitUpdatea = false);
+    ResVal<DCT_ID> CreateToken(const CTokenImpl &token, bool isPreBayfront = false);
+    Res UpdateToken(const CTokenImpl &newToken, bool isPreBayfront = false, const bool tokenSplitUpdatea = false);
 
     Res BayfrontFlagsCleanup();
-    Res AddMintedTokens(DCT_ID const & id, CAmount const & amount);
-    Res SubMintedTokens(DCT_ID const & id, CAmount const & amount);
+    Res AddMintedTokens(DCT_ID const &id, const CAmount &amount);
+    Res SubMintedTokens(DCT_ID const &id, const CAmount &amount);
 
     // tags
-    struct ID           { static constexpr uint8_t prefix() { return 'T'; } };
-    struct Symbol       { static constexpr uint8_t prefix() { return 'S'; } };
-    struct CreationTx   { static constexpr uint8_t prefix() { return 'c'; } };
-    struct LastDctId    { static constexpr uint8_t prefix() { return 'L'; } };
+    struct ID {
+        static constexpr uint8_t prefix() { return 'T'; }
+    };
+    struct Symbol {
+        static constexpr uint8_t prefix() { return 'S'; }
+    };
+    struct CreationTx {
+        static constexpr uint8_t prefix() { return 'c'; }
+    };
+    struct LastDctId {
+        static constexpr uint8_t prefix() { return 'L'; }
+    };
 
 private:
     // have to incapsulate "last token id" related methods here
@@ -166,4 +151,4 @@ class CTokensView : public virtual CStorageView
     std::optional<DCT_ID> ReadLastDctId() const;
 };
 
-#endif // DEFI_MASTERNODES_TOKENS_H
+#endif  // DEFI_MASTERNODES_TOKENS_H
diff --git a/src/masternodes/undo.h b/src/masternodes/undo.h
index b9f6e1e967..ae9a76479a 100644
--- a/src/masternodes/undo.h
+++ b/src/masternodes/undo.h
@@ -5,21 +5,20 @@
 #ifndef DEFI_MASTERNODES_UNDO_H
 #define DEFI_MASTERNODES_UNDO_H
 
-
-#include <cstdint>
-#include <uint256.h>
+#include <flushablestorage.h>
 #include <serialize.h>
 #include <serialize_optional.h>
-#include <flushablestorage.h>
+#include <uint256.h>
+#include <cstdint>
 
 struct UndoKey {
-    uint32_t height; // height is there to be able to prune older undos using lexicographic iteration
+    uint32_t height;  // height is there to be able to prune older undos using lexicographic iteration
     uint256 txid;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(WrapBigEndian(height));
         READWRITE(txid);
     }
@@ -28,10 +27,10 @@ struct UndoKey {
 struct CUndo {
     MapKV before;
 
-    static CUndo Construct(CStorageKV const & before, MapKV const & diff) {
+    static CUndo Construct(const CStorageKV &before, const MapKV &diff) {
         CUndo result;
-        for (const auto & kv : diff) {
-            const auto& beforeKey = kv.first;
+        for (const auto &kv : diff) {
+            const auto &beforeKey = kv.first;
             TBytes beforeVal;
             if (before.Read(beforeKey, beforeVal)) {
                 result.before[beforeKey] = std::move(beforeVal);
@@ -42,8 +41,8 @@ struct CUndo {
         return result;
     }
 
-    static void Revert(CStorageKV & after, CUndo const & undo) {
-        for (const auto & kv : undo.before) {
+    static void Revert(CStorageKV &after, const CUndo &undo) {
+        for (const auto &kv : undo.before) {
             if (kv.second) {
                 after.Write(kv.first, *kv.second);
             } else {
@@ -55,10 +54,9 @@ struct CUndo {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(before);
     }
 };
 
-
-#endif //DEFI_MASTERNODES_UNDO_H
+#endif  // DEFI_MASTERNODES_UNDO_H
diff --git a/src/masternodes/undos.cpp b/src/masternodes/undos.cpp
index 47bd1d9bfd..26a5ba72e9 100644
--- a/src/masternodes/undos.cpp
+++ b/src/masternodes/undos.cpp
@@ -4,25 +4,22 @@
 
 #include <masternodes/undos.h>
 
-void CUndosView::ForEachUndo(std::function<bool(UndoKey const &, CLazySerialize<CUndo>)> callback, UndoKey const & start)
-{
+void CUndosView::ForEachUndo(std::function<bool(const UndoKey &, CLazySerialize<CUndo>)> callback,
+                             const UndoKey &start) {
     ForEach<ByUndoKey, UndoKey, CUndo>(callback, start);
 }
 
-Res CUndosView::SetUndo(UndoKey const & key, CUndo const & undo)
-{
+Res CUndosView::SetUndo(const UndoKey &key, const CUndo &undo) {
     WriteBy<ByUndoKey>(key, undo);
     return Res::Ok();
 }
 
-Res CUndosView::DelUndo(UndoKey const & key)
-{
+Res CUndosView::DelUndo(const UndoKey &key) {
     EraseBy<ByUndoKey>(key);
     return Res::Ok();
 }
 
-std::optional<CUndo> CUndosView::GetUndo(UndoKey const & key) const
-{
+std::optional<CUndo> CUndosView::GetUndo(const UndoKey &key) const {
     CUndo val;
     bool ok = ReadBy<ByUndoKey>(key, val);
     if (ok) {
diff --git a/src/masternodes/undos.h b/src/masternodes/undos.h
index bf9ebe1f1c..7fb9b4507d 100644
--- a/src/masternodes/undos.h
+++ b/src/masternodes/undos.h
@@ -5,21 +5,22 @@
 #ifndef DEFI_MASTERNODES_UNDOS_H
 #define DEFI_MASTERNODES_UNDOS_H
 
-#include <masternodes/undo.h>
 #include <flushablestorage.h>
 #include <masternodes/res.h>
+#include <masternodes/undo.h>
 
 class CUndosView : public virtual CStorageView {
 public:
-    void ForEachUndo(std::function<bool(UndoKey const &, CLazySerialize<CUndo>)> callback, UndoKey const & start = {});
+    void ForEachUndo(std::function<bool(const UndoKey &, CLazySerialize<CUndo>)> callback, const UndoKey &start = {});
 
-    std::optional<CUndo> GetUndo(UndoKey const & key) const;
-    Res SetUndo(UndoKey const & key, CUndo const & undo);
-    Res DelUndo(UndoKey const & key);
+    std::optional<CUndo> GetUndo(const UndoKey &key) const;
+    Res SetUndo(const UndoKey &key, const CUndo &undo);
+    Res DelUndo(const UndoKey &key);
 
     // tags
-    struct ByUndoKey { static constexpr uint8_t prefix() { return 'u'; } };
+    struct ByUndoKey {
+        static constexpr uint8_t prefix() { return 'u'; }
+    };
 };
 
-
-#endif //DEFI_MASTERNODES_UNDOS_H
+#endif  // DEFI_MASTERNODES_UNDOS_H
diff --git a/src/masternodes/vault.cpp b/src/masternodes/vault.cpp
index b305fc9f22..c57fa73f04 100644
--- a/src/masternodes/vault.cpp
+++ b/src/masternodes/vault.cpp
@@ -9,22 +9,19 @@ struct CAuctionKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(WrapBigEndian(height));
         READWRITE(vaultId);
     }
 };
 
-Res CVaultView::StoreVault(const CVaultId& vaultId, const CVaultData& vault)
-{
+Res CVaultView::StoreVault(const CVaultId &vaultId, const CVaultData &vault) {
     WriteBy<VaultKey>(vaultId, vault);
     WriteBy<OwnerVaultKey>(std::make_pair(vault.ownerAddress, vaultId), '\0');
     return Res::Ok();
 }
 
-Res CVaultView::EraseVault(const CVaultId& vaultId)
-{
+Res CVaultView::EraseVault(const CVaultId &vaultId) {
     auto vault = GetVault(vaultId);
     if (!vault) {
         return Res::Err("Vault <%s> not found", vaultId.GetHex());
@@ -35,13 +32,11 @@ Res CVaultView::EraseVault(const CVaultId& vaultId)
     return Res::Ok();
 }
 
-std::optional<CVaultData> CVaultView::GetVault(const CVaultId& vaultId) const
-{
+std::optional<CVaultData> CVaultView::GetVault(const CVaultId &vaultId) const {
     return ReadBy<VaultKey, CVaultData>(vaultId);
 }
 
-Res CVaultView::UpdateVault(const CVaultId& vaultId, const CVaultMessage& newVault)
-{
+Res CVaultView::UpdateVault(const CVaultId &vaultId, const CVaultMessage &newVault) {
     auto vault = GetVault(vaultId);
     if (!vault) {
         return Res::Err("Vault <%s> not found", vaultId.GetHex());
@@ -50,24 +45,26 @@ Res CVaultView::UpdateVault(const CVaultId& vaultId, const CVaultMessage& newVau
     EraseBy<OwnerVaultKey>(std::make_pair(vault->ownerAddress, vaultId));
 
     vault->ownerAddress = newVault.ownerAddress;
-    vault->schemeId = newVault.schemeId;
+    vault->schemeId     = newVault.schemeId;
 
     return StoreVault(vaultId, *vault);
 }
 
-void CVaultView::ForEachVault(std::function<bool(const CVaultId&, const CVaultData&)> callback, const CVaultId& start, const CScript& ownerAddress)
-{
+void CVaultView::ForEachVault(std::function<bool(const CVaultId &, const CVaultData &)> callback,
+                              const CVaultId &start,
+                              const CScript &ownerAddress) {
     if (ownerAddress.empty()) {
         ForEach<VaultKey, CVaultId, CVaultData>(callback, start);
     } else {
-        ForEach<OwnerVaultKey, std::pair<CScript, CVaultId>, char>([&](const std::pair<CScript, CVaultId>& key, const char) {
-            return callback(key.second, *GetVault(key.second));
-        }, std::make_pair(ownerAddress, start));
+        ForEach<OwnerVaultKey, std::pair<CScript, CVaultId>, char>(
+            [&](const std::pair<CScript, CVaultId> &key, const char) {
+                return callback(key.second, *GetVault(key.second));
+            },
+            std::make_pair(ownerAddress, start));
     }
 }
 
-Res CVaultView::AddVaultCollateral(const CVaultId& vaultId, CTokenAmount amount)
-{
+Res CVaultView::AddVaultCollateral(const CVaultId &vaultId, CTokenAmount amount) {
     CBalances amounts;
     ReadBy<CollateralKey>(vaultId, amounts);
     auto res = amounts.Add(amount);
@@ -80,8 +77,7 @@ Res CVaultView::AddVaultCollateral(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-Res CVaultView::SubVaultCollateral(const CVaultId& vaultId, CTokenAmount amount)
-{
+Res CVaultView::SubVaultCollateral(const CVaultId &vaultId, CTokenAmount amount) {
     auto amounts = GetVaultCollaterals(vaultId);
     if (!amounts || !amounts->Sub(amount)) {
         return Res::Err("Collateral for vault <%s> not found", vaultId.GetHex());
@@ -94,24 +90,20 @@ Res CVaultView::SubVaultCollateral(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-std::optional<CBalances> CVaultView::GetVaultCollaterals(const CVaultId& vaultId)
-{
+std::optional<CBalances> CVaultView::GetVaultCollaterals(const CVaultId &vaultId) {
     return ReadBy<CollateralKey, CBalances>(vaultId);
 }
 
-void CVaultView::ForEachVaultCollateral(std::function<bool(const CVaultId&, const CBalances&)> callback)
-{
+void CVaultView::ForEachVaultCollateral(std::function<bool(const CVaultId &, const CBalances &)> callback) {
     ForEach<CollateralKey, CVaultId, CBalances>(callback);
 }
 
-Res CVaultView::StoreAuction(const CVaultId& vaultId, const CAuctionData& data)
-{
+Res CVaultView::StoreAuction(const CVaultId &vaultId, const CAuctionData &data) {
     WriteBy<AuctionHeightKey>(CAuctionKey{vaultId, data.liquidationHeight}, data);
     return Res::Ok();
 }
 
-Res CVaultView::EraseAuction(const CVaultId& vaultId, uint32_t height)
-{
+Res CVaultView::EraseAuction(const CVaultId &vaultId, uint32_t height) {
     auto it = LowerBound<AuctionHeightKey>(CAuctionKey{vaultId, height});
     for (; it.Valid(); it.Next()) {
         if (it.Key().vaultId == vaultId) {
@@ -127,12 +119,11 @@ Res CVaultView::EraseAuction(const CVaultId& vaultId, uint32_t height)
     return Res::Err("Auction for vault <%s> not found", vaultId.GetHex());
 }
 
-std::optional<CAuctionData> CVaultView::GetAuction(const CVaultId& vaultId, uint32_t height)
-{
+std::optional<CAuctionData> CVaultView::GetAuction(const CVaultId &vaultId, uint32_t height) {
     auto it = LowerBound<AuctionHeightKey>(CAuctionKey{vaultId, height});
     for (; it.Valid(); it.Next()) {
         if (it.Key().vaultId == vaultId) {
-            CAuctionData data = it.Value();
+            CAuctionData data      = it.Value();
             data.liquidationHeight = it.Key().height;
             return data;
         }
@@ -140,54 +131,50 @@ std::optional<CAuctionData> CVaultView::GetAuction(const CVaultId& vaultId, uint
     return {};
 }
 
-Res CVaultView::StoreAuctionBatch(const AuctionStoreKey& key, const CAuctionBatch& batch)
-{
+Res CVaultView::StoreAuctionBatch(const AuctionStoreKey &key, const CAuctionBatch &batch) {
     WriteBy<AuctionBatchKey>(key, batch);
     return Res::Ok();
 }
 
-Res CVaultView::EraseAuctionBatch(const AuctionStoreKey& key)
-{
+Res CVaultView::EraseAuctionBatch(const AuctionStoreKey &key) {
     EraseBy<AuctionBatchKey>(key);
     return Res::Ok();
 }
 
-std::optional<CAuctionBatch> CVaultView::GetAuctionBatch(const AuctionStoreKey& key)
-{
+std::optional<CAuctionBatch> CVaultView::GetAuctionBatch(const AuctionStoreKey &key) {
     return ReadBy<AuctionBatchKey, CAuctionBatch>(key);
 }
 
-void CVaultView::ForEachAuctionBatch(std::function<bool(const AuctionStoreKey&, const CAuctionBatch&)> callback)
-{
+void CVaultView::ForEachAuctionBatch(std::function<bool(const AuctionStoreKey &, const CAuctionBatch &)> callback) {
     ForEach<AuctionBatchKey, AuctionStoreKey, CAuctionBatch>(callback);
 }
 
-void CVaultView::ForEachVaultAuction(std::function<bool(const CVaultId&, const CAuctionData&)> callback, uint32_t height, const CVaultId& vaultId)
-{
-    ForEach<AuctionHeightKey, CAuctionKey, CAuctionData>([&](const CAuctionKey& auction, CAuctionData data) {
-        data.liquidationHeight = auction.height;
-        return callback(auction.vaultId, data);
-    }, CAuctionKey{vaultId, height});
+void CVaultView::ForEachVaultAuction(std::function<bool(const CVaultId &, const CAuctionData &)> callback,
+                                     uint32_t height,
+                                     const CVaultId &vaultId) {
+    ForEach<AuctionHeightKey, CAuctionKey, CAuctionData>(
+        [&](const CAuctionKey &auction, CAuctionData data) {
+            data.liquidationHeight = auction.height;
+            return callback(auction.vaultId, data);
+        },
+        CAuctionKey{vaultId, height});
 }
 
-Res CVaultView::StoreAuctionBid(const AuctionStoreKey& key, COwnerTokenAmount amount)
-{
+Res CVaultView::StoreAuctionBid(const AuctionStoreKey &key, COwnerTokenAmount amount) {
     WriteBy<AuctionBidKey>(key, amount);
     return Res::Ok();
 }
 
-Res CVaultView::EraseAuctionBid(const AuctionStoreKey& key)
-{
+Res CVaultView::EraseAuctionBid(const AuctionStoreKey &key) {
     EraseBy<AuctionBidKey>(key);
     return Res::Ok();
 }
 
-std::optional<CVaultView::COwnerTokenAmount> CVaultView::GetAuctionBid(const AuctionStoreKey& key)
-{
+std::optional<CVaultView::COwnerTokenAmount> CVaultView::GetAuctionBid(const AuctionStoreKey &key) {
     return ReadBy<AuctionBidKey, COwnerTokenAmount>(key);
 }
 
-void CVaultView::ForEachAuctionBid(std::function<bool(const AuctionStoreKey& key, const COwnerTokenAmount& amount)> callback)
-{
+void CVaultView::ForEachAuctionBid(
+    std::function<bool(const AuctionStoreKey &key, const COwnerTokenAmount &amount)> callback) {
     ForEach<AuctionBidKey, AuctionStoreKey, COwnerTokenAmount>(callback);
 }
diff --git a/src/masternodes/vault.h b/src/masternodes/vault.h
index 9abd72412d..bc7983e0d2 100644
--- a/src/masternodes/vault.h
+++ b/src/masternodes/vault.h
@@ -19,8 +19,7 @@ struct CVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(ownerAddress);
         READWRITE(schemeId);
     }
@@ -32,8 +31,7 @@ struct CVaultData : public CVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITEAS(CVaultMessage, *this);
         READWRITE(isUnderLiquidation);
     }
@@ -46,8 +44,7 @@ struct CCloseVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(to);
     }
@@ -61,8 +58,7 @@ struct CUpdateVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(ownerAddress);
         READWRITE(schemeId);
@@ -77,8 +73,7 @@ struct CDepositToVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(from);
         READWRITE(amount);
@@ -93,8 +88,7 @@ struct CWithdrawFromVaultMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(to);
         READWRITE(amount);
@@ -110,8 +104,7 @@ struct CAuctionBidMessage {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultId);
         READWRITE(index);
         READWRITE(from);
@@ -121,14 +114,13 @@ struct CAuctionBidMessage {
 
 struct CAuctionData {
     uint32_t batchCount;
-    uint32_t liquidationHeight; // temporary
+    uint32_t liquidationHeight;  // temporary
     CAmount liquidationPenalty;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(batchCount);
         READWRITE(liquidationPenalty);
     }
@@ -142,51 +134,65 @@ struct CAuctionBatch {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action)
-    {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(collaterals);
         READWRITE(loanAmount);
         READWRITE(loanInterest);
     }
 };
 
-class CVaultView : public virtual CStorageView
-{
+class CVaultView : public virtual CStorageView {
 public:
     using COwnerTokenAmount = std::pair<CScript, CTokenAmount>;
-    using AuctionStoreKey = std::pair<CVaultId, uint32_t>;
-
-    Res StoreVault(const CVaultId&, const CVaultData&);
-    Res EraseVault(const CVaultId&);
-    std::optional<CVaultData> GetVault(const CVaultId&) const;
-    Res UpdateVault(const CVaultId& vaultId, const CVaultMessage& newVault);
-    void ForEachVault(std::function<bool(const CVaultId&, const CVaultData&)> callback, const CVaultId& start = {}, const CScript& ownerAddress = {});
-
-    Res AddVaultCollateral(const CVaultId& vaultId, CTokenAmount amount);
-    Res SubVaultCollateral(const CVaultId& vaultId, CTokenAmount amount);
-    std::optional<CBalances> GetVaultCollaterals(const CVaultId& vaultId);
-    void ForEachVaultCollateral(std::function<bool(const CVaultId&, const CBalances&)> callback);
-
-    Res StoreAuction(const CVaultId& vaultId, const CAuctionData& data);
-    Res EraseAuction(const CVaultId& vaultId, uint32_t height);
-    std::optional<CAuctionData> GetAuction(const CVaultId& vaultId, uint32_t height);
-    Res StoreAuctionBatch(const AuctionStoreKey& key, const CAuctionBatch& batch);
-    Res EraseAuctionBatch(const AuctionStoreKey& key);
-    std::optional<CAuctionBatch> GetAuctionBatch(const AuctionStoreKey& vaultId);
-    void ForEachVaultAuction(std::function<bool(const CVaultId&, const CAuctionData&)> callback, uint32_t height, const CVaultId& vaultId = {});
-    void ForEachAuctionBatch(std::function<bool(const AuctionStoreKey&, const CAuctionBatch&)> callback);
-
-    Res StoreAuctionBid(const AuctionStoreKey& key, COwnerTokenAmount amount);
-    Res EraseAuctionBid(const AuctionStoreKey& key);
-    std::optional<COwnerTokenAmount> GetAuctionBid(const AuctionStoreKey& key);
-    void ForEachAuctionBid(std::function<bool(const AuctionStoreKey& key, const COwnerTokenAmount& amount)> callback);
-
-    struct VaultKey         { static constexpr uint8_t prefix() { return 0x20; } };
-    struct OwnerVaultKey    { static constexpr uint8_t prefix() { return 0x21; } };
-    struct CollateralKey    { static constexpr uint8_t prefix() { return 0x22; } };
-    struct AuctionBatchKey  { static constexpr uint8_t prefix() { return 0x23; } };
-    struct AuctionHeightKey { static constexpr uint8_t prefix() { return 0x24; } };
-    struct AuctionBidKey    { static constexpr uint8_t prefix() { return 0x25; } };
+    using AuctionStoreKey   = std::pair<CVaultId, uint32_t>;
+
+    Res StoreVault(const CVaultId &, const CVaultData &);
+    Res EraseVault(const CVaultId &);
+    std::optional<CVaultData> GetVault(const CVaultId &) const;
+    Res UpdateVault(const CVaultId &vaultId, const CVaultMessage &newVault);
+    void ForEachVault(std::function<bool(const CVaultId &, const CVaultData &)> callback,
+                      const CVaultId &start       = {},
+                      const CScript &ownerAddress = {});
+
+    Res AddVaultCollateral(const CVaultId &vaultId, CTokenAmount amount);
+    Res SubVaultCollateral(const CVaultId &vaultId, CTokenAmount amount);
+    std::optional<CBalances> GetVaultCollaterals(const CVaultId &vaultId);
+    void ForEachVaultCollateral(std::function<bool(const CVaultId &, const CBalances &)> callback);
+
+    Res StoreAuction(const CVaultId &vaultId, const CAuctionData &data);
+    Res EraseAuction(const CVaultId &vaultId, uint32_t height);
+    std::optional<CAuctionData> GetAuction(const CVaultId &vaultId, uint32_t height);
+    Res StoreAuctionBatch(const AuctionStoreKey &key, const CAuctionBatch &batch);
+    Res EraseAuctionBatch(const AuctionStoreKey &key);
+    std::optional<CAuctionBatch> GetAuctionBatch(const AuctionStoreKey &vaultId);
+    void ForEachVaultAuction(std::function<bool(const CVaultId &, const CAuctionData &)> callback,
+                             uint32_t height,
+                             const CVaultId &vaultId = {});
+    void ForEachAuctionBatch(std::function<bool(const AuctionStoreKey &, const CAuctionBatch &)> callback);
+
+    Res StoreAuctionBid(const AuctionStoreKey &key, COwnerTokenAmount amount);
+    Res EraseAuctionBid(const AuctionStoreKey &key);
+    std::optional<COwnerTokenAmount> GetAuctionBid(const AuctionStoreKey &key);
+    void ForEachAuctionBid(std::function<bool(const AuctionStoreKey &key, const COwnerTokenAmount &amount)> callback);
+
+    struct VaultKey {
+        static constexpr uint8_t prefix() { return 0x20; }
+    };
+    struct OwnerVaultKey {
+        static constexpr uint8_t prefix() { return 0x21; }
+    };
+    struct CollateralKey {
+        static constexpr uint8_t prefix() { return 0x22; }
+    };
+    struct AuctionBatchKey {
+        static constexpr uint8_t prefix() { return 0x23; }
+    };
+    struct AuctionHeightKey {
+        static constexpr uint8_t prefix() { return 0x24; }
+    };
+    struct AuctionBidKey {
+        static constexpr uint8_t prefix() { return 0x25; }
+    };
 };
 
-#endif // DEFI_MASTERNODES_VAULT_H
+#endif  // DEFI_MASTERNODES_VAULT_H
diff --git a/src/masternodes/vaulthistory.cpp b/src/masternodes/vaulthistory.cpp
index 180d0b0d46..63a49593bd 100644
--- a/src/masternodes/vaulthistory.cpp
+++ b/src/masternodes/vaulthistory.cpp
@@ -2,33 +2,31 @@
 
 #include <chain.h>
 
-void CVaultHistoryView::ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start)
-{
+void CVaultHistoryView::ForEachVaultHistory(
+    std::function<bool(const VaultHistoryKey &, CLazySerialize<VaultHistoryValue>)> callback,
+    const VaultHistoryKey &start) {
     ForEach<ByVaultHistoryKey, VaultHistoryKey, VaultHistoryValue>(callback, start);
 }
 
-void CVaultHistoryView::WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value) {
+void CVaultHistoryView::WriteVaultHistory(const VaultHistoryKey &key, const VaultHistoryValue &value) {
     WriteBy<ByVaultHistoryKey>(key, value);
 }
 
-void CVaultHistoryView::WriteVaultScheme(VaultSchemeKey const & key, const VaultSchemeValue& value)
-{
+void CVaultHistoryView::WriteVaultScheme(const VaultSchemeKey &key, const VaultSchemeValue &value) {
     WriteBy<ByVaultSchemeKey>(key, value);
 }
 
-void CVaultHistoryView::WriteGlobalScheme(VaultGlobalSchemeKey const & key, const VaultGlobalSchemeValue& value)
-{
+void CVaultHistoryView::WriteGlobalScheme(const VaultGlobalSchemeKey &key, const VaultGlobalSchemeValue &value) {
     WriteBy<ByVaultGlobalSchemeKey>(key, value);
 }
 
-void CVaultHistoryView::EraseVaultHistory(const uint32_t height)
-{
+void CVaultHistoryView::EraseVaultHistory(const uint32_t height) {
     std::vector<VaultHistoryKey> keys;
     auto historyIt = LowerBound<ByVaultHistoryKey>(VaultHistoryKey{height});
     for (; historyIt.Valid() && historyIt.Key().blockHeight == height; historyIt.Next()) {
         keys.push_back(historyIt.Key());
     }
-    for (auto& key : keys) {
+    for (auto &key : keys) {
         EraseBy<ByVaultHistoryKey>(key);
         const auto stateKey = VaultStateKey{key.vaultID, key.blockHeight};
         EraseBy<ByVaultStateKey>(stateKey);
@@ -40,28 +38,33 @@ void CVaultHistoryView::EraseVaultHistory(const uint32_t height)
     for (; schemeIt.Valid() && schemeIt.Key().blockHeight == height; schemeIt.Next()) {
         schemeKeys.push_back(schemeIt.Key());
     }
-    for (auto& key : schemeKeys) {
+    for (auto &key : schemeKeys) {
         EraseGlobalScheme(key);
     }
 }
 
-void CVaultHistoryView::ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start)
-{
+void CVaultHistoryView::ForEachVaultScheme(
+    std::function<bool(const VaultSchemeKey &, CLazySerialize<VaultSchemeValue>)> callback,
+    const VaultSchemeKey &start) {
     ForEach<ByVaultSchemeKey, VaultSchemeKey, VaultSchemeValue>(callback, start);
 }
 
-void CVaultHistoryView::ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start)
-{
+void CVaultHistoryView::ForEachVaultState(
+    std::function<bool(const VaultStateKey &, CLazySerialize<VaultStateValue>)> callback,
+    const VaultStateKey &start) {
     ForEach<ByVaultStateKey, VaultStateKey, VaultStateValue>(callback, start);
 }
 
-void CVaultHistoryView::ForEachGlobalScheme(std::function<bool(VaultGlobalSchemeKey const &, CLazySerialize<VaultGlobalSchemeValue>)> callback, VaultGlobalSchemeKey const & start)
-{
+void CVaultHistoryView::ForEachGlobalScheme(
+    std::function<bool(const VaultGlobalSchemeKey &, CLazySerialize<VaultGlobalSchemeValue>)> callback,
+    const VaultGlobalSchemeKey &start) {
     ForEach<ByVaultGlobalSchemeKey, VaultGlobalSchemeKey, VaultGlobalSchemeValue>(callback, start);
 }
 
-void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio)
-{
+void CVaultHistoryView::WriteVaultState(CCustomCSView &mnview,
+                                        const CBlockIndex &pindex,
+                                        const uint256 &vaultID,
+                                        const uint32_t ratio) {
     const auto vault = mnview.GetVault(vaultID);
     assert(vault);
 
@@ -71,7 +74,8 @@ void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex
     }
 
     bool useNextPrice = false, requireLivePrice = false;
-    auto rate = mnview.GetLoanCollaterals(vaultID, *collaterals, pindex.nHeight, pindex.nTime, useNextPrice, requireLivePrice);
+    auto rate =
+        mnview.GetLoanCollaterals(vaultID, *collaterals, pindex.nHeight, pindex.nTime, useNextPrice, requireLivePrice);
 
     CCollateralLoans collateralLoans{0, 0, {}, {}};
     if (rate) {
@@ -91,14 +95,11 @@ void CVaultHistoryView::WriteVaultState(CCustomCSView& mnview, const CBlockIndex
     WriteBy<ByVaultStateKey>(VaultStateKey{vaultID, static_cast<uint32_t>(pindex.nHeight)}, value);
 }
 
-void CVaultHistoryView::EraseGlobalScheme(const VaultGlobalSchemeKey& key)
-{
+void CVaultHistoryView::EraseGlobalScheme(const VaultGlobalSchemeKey &key) {
     EraseBy<ByVaultGlobalSchemeKey>(key);
 }
 
-CVaultHistoryStorage::CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
-        : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe))
-{
-}
+CVaultHistoryStorage::CVaultHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory, bool fWipe)
+    : CStorageView(new CStorageLevelDB(dbName, cacheSize, fMemory, fWipe)) {}
 
 std::unique_ptr<CVaultHistoryStorage> pvaultHistoryDB;
diff --git a/src/masternodes/vaulthistory.h b/src/masternodes/vaulthistory.h
index e6afa58f21..76a489a9a5 100644
--- a/src/masternodes/vaulthistory.h
+++ b/src/masternodes/vaulthistory.h
@@ -14,18 +14,17 @@
 struct VaultHistoryKey {
     uint32_t blockHeight;
     uint256 vaultID;
-    uint32_t txn; // for order in block
+    uint32_t txn;  // for order in block
     CScript address;
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
-        }
-        else {
+        } else {
             uint32_t blockHeight_ = ~blockHeight;
             READWRITE(WrapBigEndian(blockHeight_));
         }
@@ -33,8 +32,7 @@ struct VaultHistoryKey {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(txn));
             txn = ~txn;
-        }
-        else {
+        } else {
             uint32_t txn_ = ~txn;
             READWRITE(WrapBigEndian(txn_));
         }
@@ -50,7 +48,7 @@ struct VaultHistoryValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(txid);
         READWRITE(category);
         READWRITE(diff);
@@ -64,14 +62,13 @@ struct VaultStateKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vaultID);
 
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
-        }
-        else {
+        } else {
             uint32_t blockHeight_ = ~blockHeight;
             READWRITE(WrapBigEndian(blockHeight_));
         }
@@ -87,7 +84,7 @@ struct VaultStateValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(collaterals);
         READWRITE(collateralsValues);
         READWRITE(auctionBatches);
@@ -101,12 +98,12 @@ struct VaultSchemeValue {
     unsigned char category;
     uint256 txid;
     std::string schemeID;
-    uint32_t txn; // For looking up global scheme from specific place in the block
+    uint32_t txn;  // For looking up global scheme from specific place in the block
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(category);
         READWRITE(txid);
         READWRITE(schemeID);
@@ -122,15 +119,13 @@ struct VaultGlobalSchemeKey {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         if (ser_action.ForRead()) {
             READWRITE(WrapBigEndian(blockHeight));
             blockHeight = ~blockHeight;
             READWRITE(WrapBigEndian(txn));
             txn = ~txn;
-        }
-        else {
+        } else {
             uint32_t blockHeight_ = ~blockHeight;
             READWRITE(WrapBigEndian(blockHeight_));
             uint32_t txn_ = ~txn;
@@ -149,46 +144,61 @@ struct VaultGlobalSchemeValue {
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
+    inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(loanScheme);
         READWRITE(category);
         READWRITE(txid);
     }
 };
 
-class CVaultHistoryView : public virtual CStorageView
-{
+class CVaultHistoryView : public virtual CStorageView {
 public:
-    void WriteVaultHistory(VaultHistoryKey const & key, VaultHistoryValue const & value);
-    void WriteVaultScheme(VaultSchemeKey const & key, const VaultSchemeValue& value);
-    void WriteVaultState(CCustomCSView& mnview, const CBlockIndex& pindex, const uint256& vaultID, const uint32_t ratio = 0);
+    void WriteVaultHistory(const VaultHistoryKey &key, const VaultHistoryValue &value);
+    void WriteVaultScheme(const VaultSchemeKey &key, const VaultSchemeValue &value);
+    void WriteVaultState(CCustomCSView &mnview,
+                         const CBlockIndex &pindex,
+                         const uint256 &vaultID,
+                         const uint32_t ratio = 0);
 
     void EraseVaultHistory(const uint32_t height);
 
-    void ForEachVaultHistory(std::function<bool(VaultHistoryKey const &, CLazySerialize<VaultHistoryValue>)> callback, VaultHistoryKey const & start = {});
-    void ForEachVaultScheme(std::function<bool(VaultSchemeKey const &, CLazySerialize<VaultSchemeValue>)> callback, VaultSchemeKey const & start = {});
-    void ForEachVaultState(std::function<bool(VaultStateKey const &, CLazySerialize<VaultStateValue>)> callback, VaultStateKey const & start = {});
+    void ForEachVaultHistory(std::function<bool(const VaultHistoryKey &, CLazySerialize<VaultHistoryValue>)> callback,
+                             const VaultHistoryKey &start = {});
+    void ForEachVaultScheme(std::function<bool(const VaultSchemeKey &, CLazySerialize<VaultSchemeValue>)> callback,
+                            const VaultSchemeKey &start = {});
+    void ForEachVaultState(std::function<bool(const VaultStateKey &, CLazySerialize<VaultStateValue>)> callback,
+                           const VaultStateKey &start = {});
 
     // Loan Scheme storage
-    void WriteGlobalScheme(VaultGlobalSchemeKey const & key, const VaultGlobalSchemeValue& value);
-    void EraseGlobalScheme(const VaultGlobalSchemeKey& key);
-    void ForEachGlobalScheme(std::function<bool(VaultGlobalSchemeKey const &, CLazySerialize<VaultGlobalSchemeValue>)> callback, VaultGlobalSchemeKey const & start = {});
-
-    struct ByVaultHistoryKey { static constexpr uint8_t prefix() { return 0x01; } };
-    struct ByVaultStateKey { static constexpr uint8_t prefix() { return 0x02; } };
-    struct ByVaultSchemeKey { static constexpr uint8_t prefix() { return 0x03; } };
-    struct ByVaultGlobalSchemeKey { static constexpr uint8_t prefix() { return 0x04; } };
+    void WriteGlobalScheme(const VaultGlobalSchemeKey &key, const VaultGlobalSchemeValue &value);
+    void EraseGlobalScheme(const VaultGlobalSchemeKey &key);
+    void ForEachGlobalScheme(
+        std::function<bool(const VaultGlobalSchemeKey &, CLazySerialize<VaultGlobalSchemeValue>)> callback,
+        const VaultGlobalSchemeKey &start = {});
+
+    struct ByVaultHistoryKey {
+        static constexpr uint8_t prefix() { return 0x01; }
+    };
+    struct ByVaultStateKey {
+        static constexpr uint8_t prefix() { return 0x02; }
+    };
+    struct ByVaultSchemeKey {
+        static constexpr uint8_t prefix() { return 0x03; }
+    };
+    struct ByVaultGlobalSchemeKey {
+        static constexpr uint8_t prefix() { return 0x04; }
+    };
 };
 
-class CVaultHistoryStorage : public CVaultHistoryView
-{
+class CVaultHistoryStorage : public CVaultHistoryView {
 public:
-    CVaultHistoryStorage(CVaultHistoryStorage& vaultHistory) : CStorageView(new CFlushableStorageKV(vaultHistory.DB())) {}
-    CVaultHistoryStorage(const fs::path& dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
+    CVaultHistoryStorage(CVaultHistoryStorage &vaultHistory)
+        : CStorageView(new CFlushableStorageKV(vaultHistory.DB())) {}
+    CVaultHistoryStorage(const fs::path &dbName, std::size_t cacheSize, bool fMemory = false, bool fWipe = false);
 };
 
 extern std::unique_ptr<CVaultHistoryStorage> pvaultHistoryDB;
 
 static constexpr bool DEFAULT_VAULTINDEX = false;
 
-#endif //DEFI_MASTERNODES_VAULTHISTORY_H
\ No newline at end of file
+#endif  // DEFI_MASTERNODES_VAULTHISTORY_H
\ No newline at end of file
diff --git a/test/lint/lint-logs.sh b/test/lint/lint-logs.sh
index feec155bbc..f49161e9dc 100755
--- a/test/lint/lint-logs.sh
+++ b/test/lint/lint-logs.sh
@@ -13,7 +13,8 @@
 # ignored
 
 export LC_ALL=C
-UNTERMINATED_LOGS=$(git grep --extended-regexp "LogPrintf?\(" -- "*.cpp" | \
+UNTERMINATED_LOGS=$(git grep --extended-regexp "LogPrintf\(" -- "*.cpp" | \
+    git grep --extended-regexp "LogPrint\(.*, ?\"" -- "*.cpp" | \
     grep -v '\\n"' | \
     grep -v "/\* Continued \*/" | \
     grep -v "LogPrint()" | \