From 81715e04f32657b98dcd4f3abb228a900c2e4510 Mon Sep 17 00:00:00 2001
From: Anthony Fieroni <bvbfan@abv.bg>
Date: Thu, 11 Mar 2021 10:10:03 +0200
Subject: [PATCH 1/4] Oracle development

Signed-off-by: Anthony Fieroni <bvbfan@abv.bg>
---
 configure.ac                        |   2 +-
 src/Makefile.am                     |   3 +
 src/Makefile.test.include           |   1 +
 src/amount.h                        |   6 +-
 src/masternodes/masternodes.h       |   2 +
 src/masternodes/mn_checks.cpp       | 103 ++-
 src/masternodes/mn_checks.h         |  85 ++-
 src/masternodes/oracles.cpp         | 130 ++++
 src/masternodes/oracles.h           | 128 ++++
 src/masternodes/rpc_accounts.cpp    |   4 +-
 src/masternodes/rpc_customtx.cpp    |  48 ++
 src/masternodes/rpc_oracles.cpp     | 952 ++++++++++++++++++++++++++++
 src/rpc/client.cpp                  |   4 +
 src/rpc/register.h                  |   3 +
 src/test/oracles_tests.cpp          | 141 ++++
 test/functional/feature_oracles.py  | 359 +++++++++++
 test/functional/rpc_help.py         |   2 +-
 test/functional/test_runner.py      |   1 +
 test/lint/check-rpc-mappings.py     |   1 +
 test/lint/lint-locale-dependence.sh |   2 +
 20 files changed, 1934 insertions(+), 43 deletions(-)
 create mode 100644 src/masternodes/oracles.cpp
 create mode 100644 src/masternodes/oracles.h
 create mode 100644 src/masternodes/rpc_oracles.cpp
 create mode 100644 src/test/oracles_tests.cpp
 create mode 100755 test/functional/feature_oracles.py

diff --git a/configure.ac b/configure.ac
index d302ec0fcc..aedbd1f130 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1031,7 +1031,7 @@ AX_BOOST_CHRONO
 dnl Boost 1.56 through 1.62 allow using std::atomic instead of its own atomic
 dnl counter implementations. In 1.63 and later the std::atomic approach is default.
 m4_pattern_allow(DBOOST_AC_USE_STD_ATOMIC) dnl otherwise it's treated like a macro
-BOOST_CPPFLAGS="-DBOOST_SP_USE_STD_ATOMIC -DBOOST_AC_USE_STD_ATOMIC $BOOST_CPPFLAGS"
+BOOST_CPPFLAGS="-DBOOST_MPL_CFG_NO_PREPROCESSED_HEADERS -DBOOST_MPL_LIMIT_LIST_SIZE=50 -DBOOST_SP_USE_STD_ATOMIC -DBOOST_AC_USE_STD_ATOMIC $BOOST_CPPFLAGS"
 
 if test x$use_reduce_exports = xyes; then
   AC_MSG_CHECKING([for working boost reduced exports])
diff --git a/src/Makefile.am b/src/Makefile.am
index 492097361b..ce9316eced 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -170,6 +170,7 @@ DEFI_CORE_H = \
   masternodes/poolpairs.h \
   masternodes/undo.h \
   masternodes/undos.h \
+  masternodes/oracles.h \
   memusage.h \
   merkleblock.h \
   miner.h \
@@ -366,6 +367,7 @@ libdefi_server_a_SOURCES = \
   masternodes/accountshistory.cpp \
   masternodes/anchors.cpp \
   masternodes/criminals.cpp \
+  masternodes/oracles.cpp \
   masternodes/govvariables/lp_daily_dfi_reward.cpp \
   masternodes/govvariables/lp_splits.cpp \
   masternodes/gv.cpp \
@@ -378,6 +380,7 @@ libdefi_server_a_SOURCES = \
   masternodes/rpc_masternodes.cpp \
   masternodes/rpc_tokens.cpp \
   masternodes/rpc_poolpair.cpp \
+  masternodes/rpc_oracles.cpp \
   masternodes/tokens.cpp \
   masternodes/poolpairs.cpp \
   masternodes/undos.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index f924d6fe5e..632dfac89e 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -125,6 +125,7 @@ DEFI_TESTS =\
   test/multisig_tests.cpp \
   test/net_tests.cpp \
   test/netbase_tests.cpp \
+  test/oracles_tests.cpp \
   test/pmt_tests.cpp \
   test/policyestimator_tests.cpp \
   test/pow_tests.cpp \
diff --git a/src/amount.h b/src/amount.h
index 3e8695e4fb..5d2f45880c 100644
--- a/src/amount.h
+++ b/src/amount.h
@@ -110,11 +110,7 @@ struct CTokenAmount { // simple std::pair is less informative
     CAmount nValue;
 
     std::string ToString() const {
-        const bool sign = nValue < 0;
-        const int64_t n_abs = (sign ? -nValue : nValue);
-        const int64_t quotient = n_abs / COIN;
-        const int64_t remainder = n_abs % COIN;
-        return strprintf("%s%d.%08d@%d", sign ? "-" : "", quotient, remainder, nTokenId.v);
+        return strprintf("%s@%d", GetDecimaleString(nValue), nTokenId.v);
     }
 
     Res Add(CAmount amount) {
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 0616a4423e..373964b972 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -15,6 +15,7 @@
 #include <masternodes/tokens.h>
 #include <masternodes/undos.h>
 #include <masternodes/poolpairs.h>
+#include <masternodes/oracles.h>
 #include <masternodes/gv.h>
 #include <uint256.h>
 #include <wallet/ismine.h>
@@ -244,6 +245,7 @@ class CCustomCSView
         , public CPoolPairView
         , public CGovView
         , public CAnchorConfirmsView
+        , public COracleView
 {
 public:
     // Increase version when underlaying tables are changed
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 692a36b5b3..004d4cd4f4 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -6,6 +6,7 @@
 #include <masternodes/anchors.h>
 #include <masternodes/balances.h>
 #include <masternodes/mn_checks.h>
+#include <masternodes/oracles.h>
 #include <masternodes/res.h>
 
 #include <arith_uint256.h>
@@ -21,8 +22,6 @@
 #include <validation.h>
 
 #include <algorithm>
-#include <sstream>
-#include <cstring>
 
 using namespace std;
 
@@ -45,9 +44,14 @@ std::string ToString(CustomTxType type) {
         case CustomTxType::AccountToAccount:    return "AccountToAccount";
         case CustomTxType::AnyAccountsToAccounts:   return "AnyAccountsToAccounts";
         case CustomTxType::SetGovVariable:      return "SetGovVariable";
+        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";
-        default:                                return "None";
+        case CustomTxType::None:                return "None";
     }
+    return "None";
 }
 
 static ResVal<CBalances> BurntTokens(CTransaction const & tx) {
@@ -108,8 +112,14 @@ CCustomTxMessage customTypeToMessage(CustomTxType txType) {
     case CustomTxType::AccountToAccount:        return CAccountToAccountMessage{};
     case CustomTxType::AnyAccountsToAccounts:   return CAnyAccountsToAccountsMessage{};
     case CustomTxType::SetGovVariable:          return CGovernanceMessage{};
-    default:                                    return CCustomTxMessageNone{};
-    }
+    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::None:                    return CCustomTxMessageNone{};
+    }
+    return CCustomTxMessageNone{};
 }
 
 extern std::string ScriptToString(CScript const& script);
@@ -141,6 +151,13 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
         return Res::Ok();
     }
 
+    Res isPostEunosFork() const {
+        if(static_cast<int>(height) < consensus.EunosHeight) {
+            return Res::Err("called before Eunos height");
+        }
+        return Res::Ok();
+    }
+
     template<typename T>
     Res serialize(T& obj) const {
         CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
@@ -292,6 +309,26 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
         return Res::Ok();
     }
 
+    Res operator()(CAppointOracleMessage& obj) const {
+        auto res = isPostEunosFork();
+        return !res ? res : serialize(obj);
+    }
+
+    Res operator()(CRemoveOracleAppointMessage& obj) const {
+        auto res = isPostEunosFork();
+        return !res ? res : serialize(obj);
+    }
+
+    Res operator()(CUpdateOracleAppointMessage& obj) const {
+        auto res = isPostEunosFork();
+        return !res ? res : serialize(obj);
+    }
+
+    Res operator()(CSetOracleDataMessage& obj) const {
+        auto res = isPostEunosFork();
+        return !res ? res : serialize(obj);
+    }
+
     Res operator()(CCustomTxMessageNone&) const {
         return Res::Ok();
     }
@@ -485,6 +522,20 @@ class CCustomTxVisitor : public boost::static_visitor<Res>
         }
         return Res::Ok();
     }
+
+    Res 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);
+            auto currency = trim_ws(pair.second).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+            if (token.empty() || currency.empty()) {
+                return Res::Err("empty token / currency");
+            }
+            trimmed.emplace(token, currency);
+        }
+        tokenCurrency = std::move(trimmed);
+        return Res::Ok();
+    }
 };
 
 class CCustomTxApplyVisitor : public CCustomTxVisitor
@@ -941,6 +992,43 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
+    Res operator()(const CAppointOracleMessage& obj) const {
+        if (!HasFoundationAuth()) {
+            return Res::Err("tx not from foundation member");
+        }
+        auto msg = obj;
+        auto res = normalizeTokenCurrencyPair(msg.availablePairs);
+        return !res ? res : mnview.AppointOracle(tx.GetHash(), COracle(msg));
+    }
+
+    Res operator()(const CUpdateOracleAppointMessage& obj) const {
+        if (!HasFoundationAuth()) {
+            return Res::Err("tx not from foundation member");
+        }
+        auto msg = obj.newOracleAppoint;
+        auto res = normalizeTokenCurrencyPair(msg.availablePairs);
+        return !res ? res : mnview.UpdateOracle(obj.oracleId, COracle(msg));
+    }
+
+    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 {
+
+        auto oracle = mnview.GetOracleData(obj.oracleId);
+        if (!oracle) {
+            return Res::Err("failed to retrieve oracle <%s> from database", obj.oracleId.GetHex());
+        }
+        if (!HasAuth(oracle.val->oracleAddress)) {
+            return Res::Err("tx must have at least one input from account owner");
+        }
+        return mnview.SetOracleData(obj.oracleId, obj.timestamp, obj.tokenPrices);
+    }
+
     Res operator()(const CCustomTxMessageNone&) const {
         return Res::Ok();
     }
@@ -1235,7 +1323,6 @@ ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView & mnview, CTransaction const &
     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)
 {
     if (height < consensusParams.DakotaHeight) {
@@ -1304,9 +1391,7 @@ ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView & mnview, CTransaction con
     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;
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index 84257fbd71..e710489e87 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -30,44 +30,71 @@ enum CustomTxErrCodes : uint32_t {
     Fatal = uint32_t(1) << 31 // not allowed to fail
 };
 
-enum class CustomTxType : unsigned char
+enum class CustomTxType : uint8_t
 {
     None = 0,
     // masternodes:
-    CreateMasternode    = 'C',
-    ResignMasternode    = 'R',
+    CreateMasternode      = 'C',
+    ResignMasternode      = 'R',
     // custom tokens:
-    CreateToken         = 'T',
-    MintToken           = 'M',
-    UpdateToken         = 'N', // previous type, only DAT flag triggers
-    UpdateTokenAny      = 'n', // new type of token's update with any flags/fields possible
+    CreateToken           = 'T',
+    MintToken             = 'M',
+    UpdateToken           = 'N', // previous type, only DAT flag triggers
+    UpdateTokenAny        = 'n', // new type of token's update with any flags/fields possible
     // dex orders - just not to overlap in future
 //    CreateOrder         = 'O',
 //    DestroyOrder        = 'E',
 //    MatchOrders         = 'A',
     //poolpair
-    CreatePoolPair      = 'p',
-    UpdatePoolPair      = 'u',
-    PoolSwap            = 's',
-    AddPoolLiquidity    = 'l',
-    RemovePoolLiquidity = 'r',
+    CreatePoolPair        = 'p',
+    UpdatePoolPair        = 'u',
+    PoolSwap              = 's',
+    AddPoolLiquidity      = 'l',
+    RemovePoolLiquidity   = 'r',
     // accounts
-    UtxosToAccount     = 'U',
-    AccountToUtxos     = 'b',
-    AccountToAccount   = 'B',
-    AnyAccountsToAccounts  = 'a',
+    UtxosToAccount        = 'U',
+    AccountToUtxos        = 'b',
+    AccountToAccount      = 'B',
+    AnyAccountsToAccounts = 'a',
     //set governance variable
-    SetGovVariable       = 'G',
+    SetGovVariable        = 'G',
     // Auto auth TX
-    AutoAuthPrep       = 'A',
+    AutoAuthPrep          = 'A',
+    // oracles
+    AppointOracle         = 'o',
+    RemoveOracleAppoint   = 'h',
+    UpdateOracleAppoint   = 't',
+    SetOracleData         = 'y',
 };
 
-inline CustomTxType CustomTxCodeToType(unsigned char ch) {
-    constexpr const char txtypes[] = "CRTMNnpuslrUbBaGA";
-    if (memchr(txtypes, ch, sizeof(txtypes) - 1))
-        return static_cast<CustomTxType>(ch);
-    else
-        return CustomTxType::None;
+inline CustomTxType CustomTxCodeToType(uint8_t ch) {
+    auto type = static_cast<CustomTxType>(ch);
+    switch(type) {
+        case CustomTxType::CreateMasternode:
+        case CustomTxType::ResignMasternode:
+        case CustomTxType::CreateToken:
+        case CustomTxType::MintToken:
+        case CustomTxType::UpdateToken:
+        case CustomTxType::UpdateTokenAny:
+        case CustomTxType::CreatePoolPair:
+        case CustomTxType::UpdatePoolPair:
+        case CustomTxType::PoolSwap:
+        case CustomTxType::AddPoolLiquidity:
+        case CustomTxType::RemovePoolLiquidity:
+        case CustomTxType::UtxosToAccount:
+        case CustomTxType::AccountToUtxos:
+        case CustomTxType::AccountToAccount:
+        case CustomTxType::AnyAccountsToAccounts:
+        case CustomTxType::SetGovVariable:
+        case CustomTxType::AutoAuthPrep:
+        case CustomTxType::AppointOracle:
+        case CustomTxType::RemoveOracleAppoint:
+        case CustomTxType::UpdateOracleAppoint:
+        case CustomTxType::SetOracleData:
+        case CustomTxType::None:
+            return type;
+    }
+    return CustomTxType::None;
 }
 
 std::string ToString(CustomTxType type);
@@ -99,6 +126,10 @@ struct CLiquidityMessage;
 struct CPoolSwapMessage;
 struct CRemoveLiquidityMessage;
 struct CUtxosToAccountMessage;
+struct CAppointOracleMessage;
+struct CRemoveOracleAppointMessage;
+struct CUpdateOracleAppointMessage;
+struct CSetOracleDataMessage;
 
 struct CCreateMasterNodeMessage {
     char operatorType;
@@ -203,7 +234,11 @@ typedef boost::variant<
     CAccountToUtxosMessage,
     CAccountToAccountMessage,
     CAnyAccountsToAccountsMessage,
-    CGovernanceMessage
+    CGovernanceMessage,
+    CAppointOracleMessage,
+    CRemoveOracleAppointMessage,
+    CUpdateOracleAppointMessage,
+    CSetOracleDataMessage
 > CCustomTxMessage;
 
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
diff --git a/src/masternodes/oracles.cpp b/src/masternodes/oracles.cpp
new file mode 100644
index 0000000000..e11747ec43
--- /dev/null
+++ b/src/masternodes/oracles.cpp
@@ -0,0 +1,130 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#include <algorithm>
+
+#include <masternodes/oracles.h>
+#include <rpc/protocol.h>
+
+const unsigned char COracleView::ByName::prefix = 'O'; // the big O for Oracles
+
+COracle::COracle(CAppointOracleMessage const& msg) : CAppointOracleMessage(msg)
+{
+}
+
+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)
+{
+    if (!SupportsPair(token, currency)) {
+        return Res::Err("token <%s> - currency <%s> is not allowed", token, currency);
+    }
+
+    tokenPrices[token][currency] = std::make_pair(amount, timestamp);
+
+    return Res::Ok();
+}
+
+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());
+    }
+
+    return Res::Ok();
+}
+
+Res COracleView::UpdateOracle(const COracleId& oracleId, const COracle& newOracle)
+{
+    COracle oracle;
+    if (!ReadBy<ByName>(oracleId, oracle)) {
+        return Res::Err("oracle <%s> not found", oracleId.GetHex());
+    }
+
+    if (!newOracle.tokenPrices.empty()) {
+        return Res::Err("oracle <%s> has token prices on update", oracleId.GetHex());
+    }
+
+    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;
+            if (!newOracle.SupportsPair(token, currency)) {
+                continue;
+            }
+            allowedPrices[token][currency] = price.second;
+        }
+    }
+
+    oracle.tokenPrices = std::move(allowedPrices);
+    oracle.availablePairs = std::move(newOracle.availablePairs);
+
+    // no need to update oracles list
+    if (!WriteBy<ByName>(oracleId, oracle)) {
+        return Res::Err("failed to save oracle <%s>", oracleId.GetHex());
+    }
+
+    return Res::Ok();
+}
+
+Res COracleView::RemoveOracle(const COracleId& oracleId)
+{
+    if (!ExistsBy<ByName>(oracleId)) {
+        return Res::Err("oracle <%s> not found", oracleId.GetHex());
+    }
+
+    // remove oracle
+    if (!EraseBy<ByName>(oracleId)) {
+        return Res::Err("failed to remove oracle <%s>", oracleId.GetHex());
+    }
+
+    return Res::Ok();
+}
+
+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);
+            if (!res.ok) {
+                return res;
+            }
+        }
+    }
+
+    if (!WriteBy<ByName>(oracleId, oracle)) {
+        return Res::Err("failed to store oracle %s to database", oracleId.GetHex());
+    }
+
+    return Res::Ok();
+}
+
+ResVal<COracle> COracleView::GetOracleData(const COracleId& oracleId) const
+{
+    COracle oracle;
+    if (!ReadBy<ByName>(oracleId, oracle)) {
+        return Res::Err("oracle <%s> not found", oracleId.GetHex());
+    }
+
+    return ResVal<COracle>(oracle, Res::Ok());
+}
+
+void COracleView::ForEachOracle(std::function<bool(const COracleId&, CLazySerialize<COracle>)> callback, const COracleId& start)
+{
+    ForEach<ByName, COracleId, COracle>(callback, start);
+}
diff --git a/src/masternodes/oracles.h b/src/masternodes/oracles.h
new file mode 100644
index 0000000000..50ac47e0ae
--- /dev/null
+++ b/src/masternodes/oracles.h
@@ -0,0 +1,128 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef DEFI_MASTERNODES_ORACLES_H
+#define DEFI_MASTERNODES_ORACLES_H
+
+#include <amount.h>
+#include <flushablestorage.h>
+#include <masternodes/balances.h>
+#include <masternodes/res.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <uint256.h>
+
+#include <string>
+#include <vector>
+
+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>>;
+
+struct CAppointOracleMessage {
+    CScript oracleAddress;
+    uint8_t weightage;
+    std::set<CTokenCurrencyPair> availablePairs;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(oracleAddress);
+        READWRITE(weightage);
+        READWRITE(availablePairs);
+    }
+};
+
+struct CRemoveOracleAppointMessage {
+    COracleId oracleId;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(oracleId);
+    }
+};
+
+struct CUpdateOracleAppointMessage {
+    COracleId oracleId;
+    CAppointOracleMessage newOracleAppoint;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(oracleId);
+        READWRITE(newOracleAppoint);
+    }
+};
+
+struct CSetOracleDataMessage {
+    COracleId oracleId;
+    int64_t timestamp;
+    CTokenPrices tokenPrices;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(oracleId);
+        READWRITE(timestamp);
+        READWRITE(tokenPrices);
+    }
+};
+
+/// Oracle representation
+struct COracle : public CAppointOracleMessage {
+    CTokenPricePoints tokenPrices;
+
+    explicit COracle(CAppointOracleMessage const& msg = {});
+    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);
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITEAS(CAppointOracleMessage, *this);
+        READWRITE(tokenPrices);
+    }
+};
+
+/// View for managing oracles and their data
+class COracleView : public virtual CStorageView
+{
+public:
+    ~COracleView() override = default;
+
+    /// register new oracle instance
+    Res AppointOracle(const COracleId& oracleId, const COracle& oracle);
+
+    /// updates oracle info
+    Res UpdateOracle(const COracleId& oracleId, const COracle& newOracle);
+
+    /// remove oracle instancefrom database
+    Res RemoveOracle(const COracleId& oracleId);
+
+    /// store registered oracle data
+    Res SetOracleData(const COracleId& oracleId, int64_t timestamp, const CTokenPrices& tokenPrices);
+
+    /// deserialize oracle instance from database
+    ResVal<COracle> GetOracleData(const COracleId& oracleId) const;
+
+    void ForEachOracle(std::function<bool(const COracleId&, CLazySerialize<COracle>)> callback, const COracleId& start = {});
+
+private:
+    struct ByName { static const unsigned char prefix; };
+};
+
+#endif // DEFI_MASTERNODES_ORACLES_H
diff --git a/src/masternodes/rpc_accounts.cpp b/src/masternodes/rpc_accounts.cpp
index d904cdccf7..d4ebef973f 100644
--- a/src/masternodes/rpc_accounts.cpp
+++ b/src/masternodes/rpc_accounts.cpp
@@ -861,7 +861,7 @@ UniValue listaccounthistory(const JSONRPCRequest& request) {
                                  {"token", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                                   "Filter by token"},
                                  {"txtype", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
-                                  "Filter by transaction type, supported letter from 'CRTMNnpuslrUbBG'"},
+                                  "Filter by transaction type, supported letter from {CustomTxType}"},
                                  {"limit", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
                                   "Maximum number of records to return, 100 by default"},
                             },
@@ -1075,7 +1075,7 @@ UniValue accounthistorycount(const JSONRPCRequest& request) {
                        {
                             {"no_rewards", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Filter out rewards"},
                             {"token", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter by token"},
-                            {"txtype", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter by transaction type, supported letter from 'CRTMNnpuslrUbBG'"},
+                            {"txtype", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter by transaction type, supported letter from {CustomTxType}"},
                        },
                    },
                },
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index fa32c633a6..34b3cdbf6a 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -47,6 +47,17 @@ class CCustomTxRpcVisitor : public boost::static_visitor<void>
         return info;
     }
 
+    void tokenCurrencyPairInfo(const std::set<CTokenCurrencyPair>& pairs) const {
+        UniValue availablePairs(UniValue::VARR);
+        for (const auto& pair : pairs) {
+            UniValue uniPair(UniValue::VOBJ);
+            uniPair.pushKV("token", pair.first);
+            uniPair.pushKV("currency", pair.second);
+            availablePairs.push_back(uniPair);
+        }
+        rpcInfo.pushKV("availablePairs", availablePairs);
+    }
+
 public:
     CCustomTxRpcVisitor(const CTransaction& tx, uint32_t height, CCustomCSView& mnview, UniValue& rpcInfo)
         : height(height), rpcInfo(rpcInfo), mnview(mnview), tx(tx) {
@@ -178,6 +189,43 @@ class CCustomTxRpcVisitor : public boost::static_visitor<void>
         }
     }
 
+    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 {
+        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 {
+        rpcInfo.pushKV("oracleId", obj.oracleId.ToString());
+    }
+
+    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;
+
+                UniValue uniPair(UniValue::VOBJ);
+                uniPair.pushKV("currency", currency);
+                uniPair.pushKV("tokenAmount", strprintf("%s@%s", GetDecimaleString(amount), token));
+                tokenPrices.push_back(uniPair);
+            }
+        }
+        rpcInfo.pushKV("tokenPrices", tokenPrices);
+    }
+
     void operator()(const CCustomTxMessageNone&) const {
     }
 };
diff --git a/src/masternodes/rpc_oracles.cpp b/src/masternodes/rpc_oracles.cpp
new file mode 100644
index 0000000000..ccdf31aa84
--- /dev/null
+++ b/src/masternodes/rpc_oracles.cpp
@@ -0,0 +1,952 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#include <masternodes/mn_rpc.h>
+
+/// names of oracle json fields
+namespace oraclefields {
+    constexpr auto Alive = "live";
+    constexpr auto Token = "token";
+    constexpr auto State = "state";
+    constexpr auto Amount = "amount";
+    constexpr auto Expired = "expired";
+    constexpr auto Currency = "currency";
+    constexpr auto OracleId = "oracleid";
+    constexpr auto RawPrice = "rawprice";
+    constexpr auto Timestamp = "timestamp";
+    constexpr auto Weightage = "weightage";
+    constexpr auto AggregatedPrice = "price";
+    constexpr auto TokenAmount = "tokenAmount";
+    constexpr auto ValidityFlag = "ok";
+    constexpr auto FlagIsValid = true;
+    constexpr auto PriceFeeds = "priceFeeds";
+    constexpr auto OracleAddress = "address";
+    constexpr auto TokenPrices = "tokenPrices";
+    constexpr uint8_t MaxWeightage{100u};
+    constexpr uint8_t MinWeightage{1u};
+}; // namespace oraclefields
+
+namespace {
+    CTokenCurrencyPair DecodeTokenCurrencyPair(const UniValue& value) {
+        if (!value.exists(oraclefields::Currency)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, Res::Err("%s is required field", oraclefields::Currency).msg);
+        }
+        if (!value.exists(oraclefields::Token)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, Res::Err("%s is required field", oraclefields::Token).msg);
+        }
+
+        auto token = value[oraclefields::Token].getValStr();
+        auto currency = value[oraclefields::Currency].getValStr();
+
+        token = trim_ws(token).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+        currency = trim_ws(currency).substr(0, CToken::MAX_TOKEN_SYMBOL_LENGTH);
+
+        if (token.empty() || currency.empty()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, Res::Err("%s/%s is empty", oraclefields::Token, oraclefields::Currency).msg);
+        }
+
+        return std::make_pair(token, currency);
+    }
+
+    std::set<CTokenCurrencyPair> DecodeTokenCurrencyPairs(const std::string& data) {
+        UniValue values{UniValue::VARR};
+        if (!values.read(data)) {
+            throw JSONRPCError(RPC_TRANSACTION_ERROR, "failed to decode token-currency pairs");
+        }
+
+        if (!values.isArray()) {
+            throw JSONRPCError(RPC_INVALID_REQUEST, "data is not array");
+        }
+
+        std::set<CTokenCurrencyPair> pairs;
+
+        for (const auto &value : values.get_array().getValues()) {
+            pairs.insert(DecodeTokenCurrencyPair(value));
+        }
+
+        return pairs;
+    }
+}
+
+UniValue appointoracle(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"appointoracle",
+               "\nCreates (and submits to local node and network) a `appoint oracle transaction`, \n"
+               "and saves oracle to database.\n"
+               "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "oracle address",},
+                       {"pricefeeds", RPCArg::Type::STR, RPCArg::Optional::NO, "list of allowed token-currency pairs"},
+                       {"weightage", RPCArg::Type::NUM, RPCArg::Optional::NO, "oracle weightage"},
+                       {"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(
+                               "appointoracle",
+                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+                       + HelpExampleRpc(
+                               "appointoracle",
+                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params,
+                 {UniValue::VSTR, UniValue::VSTR, UniValue::VNUM}, false);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+
+    // decode
+    CScript script;
+    try {
+        script = DecodeScript(request.params[0].getValStr());
+    } catch(...) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "failed to parse address");
+    }
+
+    std::string allowedPairsStr = request.params[1].getValStr();
+    auto allowedPairs = DecodeTokenCurrencyPairs(allowedPairsStr);
+
+    uint32_t weightage;
+    try {
+        weightage = std::stoul(request.params[2].getValStr());
+    } catch (...) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "failed to decode weightage");
+    }
+
+    if (weightage > oraclefields::MaxWeightage || weightage < oraclefields::MinWeightage) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "the weightage value is out of bounds");
+    }
+
+    int targetHeight = chainHeight(*pwallet->chain().lock()) + 1;
+
+    CAppointOracleMessage msg{std::move(script), static_cast<uint8_t>(weightage), std::move(allowedPairs)};
+    // encode
+    CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    markedMetadata << static_cast<unsigned char>(CustomTxType::AppointOracle)
+                   << msg;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
+
+    const auto txVersion = GetTransactionVersion(targetHeight);
+    CMutableTransaction rawTx(txVersion);
+    rawTx.vout.emplace_back(0, scriptMeta);
+
+    UniValue const &txInputs = request.params[3];
+    CTransactionRef optAuthTx;
+    std::set<CScript> auths;
+    rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, true, optAuthTx, txInputs);
+
+    CCoinControl coinControl;
+
+    // Set change to auth address if there's only one auth address
+    if (auths.size() == 1) {
+        CTxDestination dest;
+        ExtractDestination(*auths.cbegin(), dest);
+        if (IsValidDestination(dest)) {
+            coinControl.destChange = dest;
+        }
+    }
+
+    fund(rawTx, pwallet, optAuthTx, &coinControl);
+
+    // check execution
+    {
+        LOCK(cs_main);
+        CCustomCSView mnview(*pcustomcsview); // don't write into actual DB
+        CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
+        if (optAuthTx)
+            AddCoins(coins, *optAuthTx, targetHeight);
+        auto metadata = ToByteVector(CDataStream{SER_NETWORK, PROTOCOL_VERSION, msg});
+        execTestTx(CTransaction(rawTx), targetHeight, metadata, CAppointOracleMessage{}, coins);
+    }
+
+    return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
+}
+
+UniValue updateoracle(const JSONRPCRequest& request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"updateoracle",
+               "\nCreates (and submits to local node and network) a `update oracle transaction`, \n"
+               "and saves oracle updates to database.\n"
+               "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"oracleid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "oracle id"},
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "oracle address",},
+                       {"pricefeeds", RPCArg::Type::STR, RPCArg::Optional::NO, "list of allowed token-currency pairs"},
+                       {"weightage", RPCArg::Type::NUM, RPCArg::Optional::NO, "oracle weightage"},
+                       {"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(
+                               "updateoracle",
+                               R"(84b22eee1964768304e624c416f29a91d78a01dc5e8e12db26bdac0670c67bb2 mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+                       + HelpExampleRpc(
+                               "updateoracle",
+                               R"(84b22eee1964768304e624c416f29a91d78a01dc5e8e12db26bdac0670c67bb2 mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params,
+                 {UniValue::VSTR, UniValue::VSTR, UniValue::VSTR, UniValue::VNUM},
+                 false);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+
+    // decode oracleid
+    COracleId oracleId = ParseHashV(request.params[0], "oracleid");
+
+    // decode address
+    CScript script;
+    try {
+        script = DecodeScript(request.params[1].getValStr());
+    } catch(...) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "failed to parse address");
+    }
+
+    // decode allowed token-currency pairs
+    std::string allowedPairsStr = request.params[2].getValStr();
+    auto allowedPairs = DecodeTokenCurrencyPairs(allowedPairsStr);
+
+    // decode weightage
+    uint32_t weightage;
+    try {
+        weightage = std::stoul(request.params[3].getValStr());
+    } catch (...) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "failed to decode weightage");
+    }
+
+    if (weightage > oraclefields::MaxWeightage || weightage < oraclefields::MinWeightage) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "the weightage value is out of bounds");
+    }
+
+    int targetHeight = chainHeight(*pwallet->chain().lock()) + 1;
+
+    CUpdateOracleAppointMessage msg{
+            oracleId,
+            CAppointOracleMessage{std::move(script), static_cast<uint8_t>(weightage), std::move(allowedPairs)}
+    };
+
+    // encode
+    CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    markedMetadata << static_cast<unsigned char>(CustomTxType::UpdateOracleAppoint)
+                   << msg;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
+
+    const auto txVersion = GetTransactionVersion(targetHeight);
+    CMutableTransaction rawTx(txVersion);
+    rawTx.vout.emplace_back(0, scriptMeta);
+
+    UniValue const &txInputs = request.params[4];
+    CTransactionRef optAuthTx;
+    std::set<CScript> auths;
+    rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, true, optAuthTx, txInputs);
+
+    CCoinControl coinControl;//    std::string oracles;
+
+    // Set change to auth address if there's only one auth address
+    if (auths.size() == 1) {
+        CTxDestination dest;
+        ExtractDestination(*auths.cbegin(), dest);
+        if (IsValidDestination(dest)) {
+            coinControl.destChange = dest;
+        }
+    }
+
+    fund(rawTx, pwallet, optAuthTx, &coinControl);
+
+    // check execution
+    {
+        LOCK(cs_main);
+        CCustomCSView mnview(*pcustomcsview); // don't write into actual DB
+        CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
+        if (optAuthTx)
+            AddCoins(coins, *optAuthTx, targetHeight);
+        auto metadata = ToByteVector(CDataStream{SER_NETWORK, PROTOCOL_VERSION, msg});
+        execTestTx(CTransaction(rawTx), targetHeight, metadata, CUpdateOracleAppointMessage{}, coins);
+    }
+
+    return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
+}
+
+UniValue removeoracle(const JSONRPCRequest& request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"removeoracle",
+               "\nRemoves oracle, \n"
+               "The only argument is oracleid hex value." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"oracleid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "oracle id"},
+                       {"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("removeoracle", "0xabcd1234ac1243578697085986498694")
+                       + HelpExampleRpc("removeoracle", "0xabcd1234ac1243578697085986498694")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VSTR}, false);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+
+    // decode
+    CRemoveOracleAppointMessage msg{};
+    msg.oracleId = ParseHashV(request.params[0], "oracleid");
+
+    int targetHeight = chainHeight(*pwallet->chain().lock()) + 1;
+
+    // encode
+    CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    markedMetadata << static_cast<unsigned char>(CustomTxType::RemoveOracleAppoint)
+                   << msg;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
+
+    const auto txVersion = GetTransactionVersion(targetHeight);
+    CMutableTransaction rawTx(txVersion);
+    rawTx.vout.emplace_back(0, scriptMeta);
+
+    UniValue const &txInputs = request.params[1];
+    CTransactionRef optAuthTx;
+    std::set<CScript> auths;
+    rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, true, optAuthTx, txInputs);
+
+    CCoinControl coinControl;
+
+    // Set change to auth address if there's only one auth address
+    if (auths.size() == 1) {
+        CTxDestination dest;
+        ExtractDestination(*auths.cbegin(), dest);
+        if (IsValidDestination(dest)) {
+            coinControl.destChange = dest;
+        }
+    }
+
+    // fund
+    fund(rawTx, pwallet, optAuthTx, &coinControl);
+
+    // check execution
+    {
+        LOCK(cs_main);
+        CCustomCSView mnview(*pcustomcsview); // don't write into actual DB
+        CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
+        if (optAuthTx)
+            AddCoins(coins, *optAuthTx, targetHeight);
+        auto metadata = ToByteVector(CDataStream{SER_NETWORK, PROTOCOL_VERSION, msg});
+        execTestTx(CTransaction(rawTx), targetHeight, metadata, CRemoveOracleAppointMessage{}, coins);
+    }
+
+    return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
+}
+
+UniValue setoracledata(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"setoracledata",
+               "\nCreates (and submits to local node and network) a `set oracle data transaction`.\n"
+               "The last optional argument (may be empty array) is an array of specific UTXOs to spend." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"oracleid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "oracle hex id",},
+                       {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO, "balances timestamp",},
+                       {"prices", RPCArg::Type::STR, RPCArg::Optional::NO,
+                        "tokens raw prices:the array of price and token strings in price@token format. ",
+                       },
+                       {"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(
+                               "setoracledata",
+                               "5474b2e9bfa96446e5ef3c9594634e1aa22d3a0722cb79084d61253acbdf87bf 1612237937 "
+                               R"('[{"currency":"USD", "tokenAmount":"38293.12@BTC"}"
+                               ", {currency:"EUR", "tokenAmount":"1328.32@ETH"}]')"
+                       )
+                       + HelpExampleRpc(
+                               "setoracledata",
+                               "5474b2e9bfa96446e5ef3c9594634e1aa22d3a0722cb79084d61253acbdf87bf 1612237937 "
+                               R"('[{"currency":"USD", "tokenAmount":"38293.12@BTC"}"
+                               ", {currency:"EUR", "tokenAmount":"1328.32@ETH"}]')"
+                       )
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params,
+                 {UniValue::VSTR, UniValue::VNUM, UniValue::VSTR},
+                 false);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+
+    // decode oracle id
+    COracleId oracleId = ParseHashV(request.params[0], "oracleid");
+
+    // decode timestamp
+    int64_t timestamp;
+    try {
+        timestamp = std::stoll(request.params[1].getValStr());
+    } catch (...) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "failed to decode timestamp");
+    }
+
+    if (0 == timestamp) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "timestamp cannot be ze");
+    }
+    // decode prices
+    UniValue prices{UniValue::VARR};
+    if (!prices.read(request.params[2].getValStr())) {
+        throw JSONRPCError(RPC_TRANSACTION_ERROR, "failed to decode prices");
+    }
+
+    if (!prices.isArray()) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "data is not array");
+    }
+
+    CMutableTransaction rawTx{};
+    CTransactionRef optAuthTx;
+
+    // check execution
+    {
+        LOCK(cs_main);
+        CCustomCSView mnview(*pcustomcsview); // don't write into actual DB
+
+        auto parseDataItem = [&](const UniValue &value) -> std::pair<std::string, std::pair<CAmount, std::string>> {
+            if (!value.exists(oraclefields::Currency)) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, Res::Err("%s is required field", oraclefields::Currency).msg);
+            }
+            if (!value.exists(oraclefields::TokenAmount)) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, Res::Err("%s is required field", oraclefields::TokenAmount).msg);
+            }
+
+            auto currency = value[oraclefields::Currency].getValStr();
+            auto tokenAmount = value[oraclefields::TokenAmount].getValStr();
+            auto amounts = ParseTokenAmount(tokenAmount);
+            if (!amounts.ok) {
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, amounts.msg);
+            }
+
+            return std::make_pair(currency, *amounts.val);
+        };
+
+        CTokenPrices tokenPrices;
+
+        for (const auto &value : prices.get_array().getValues()) {
+            std::string currency;
+            std::pair<CAmount, std::string> tokenAmount;
+            std::tie(currency, tokenAmount) = parseDataItem(value);
+            tokenPrices[tokenAmount.second][currency] = tokenAmount.first;
+        }
+
+        CSetOracleDataMessage msg{oracleId, timestamp, std::move(tokenPrices)};
+
+        // check if tx parameters are valid
+
+        auto oracleRes = mnview.GetOracleData(oracleId);
+        if (!oracleRes.ok) {
+            throw JSONRPCError(RPC_INVALID_REQUEST, oracleRes.msg);
+        }
+
+        // encode
+        CDataStream markedMetadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+        markedMetadata << static_cast<unsigned char>(CustomTxType::SetOracleData)
+                       << msg;
+
+        CScript scriptMeta;
+        scriptMeta << OP_RETURN << ToByteVector(markedMetadata);
+
+        int targetHeight = chainHeight(*pwallet->chain().lock()) + 1;
+        const auto txVersion = GetTransactionVersion(targetHeight);
+        rawTx = CMutableTransaction(txVersion);
+        rawTx.vout.emplace_back(0, scriptMeta);
+
+        UniValue const &txInputs = request.params[3];
+
+        std::set<CScript> auths;
+        auths.insert({oracleRes.val->oracleAddress});
+
+        rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auths, false, optAuthTx, txInputs);
+
+        CCoinControl coinControl;
+
+        // Set change to auth address if there's only one auth address
+        if (auths.size() == 1) {
+            CTxDestination dest;
+            ExtractDestination(*auths.cbegin(), dest);
+            if (IsValidDestination(dest)) {
+                coinControl.destChange = dest;
+            }
+        }
+
+        fund(rawTx, pwallet, optAuthTx, &coinControl);
+
+        CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
+        if (optAuthTx)
+            AddCoins(coins, *optAuthTx, targetHeight);
+        auto metadata = ToByteVector(CDataStream{SER_NETWORK, PROTOCOL_VERSION, msg});
+        execTestTx(CTransaction(rawTx), targetHeight, metadata, CSetOracleDataMessage{}, coins);
+    }
+
+    return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
+}
+
+namespace {
+    UniValue PriceFeedToJSON(const CTokenCurrencyPair& priceFeed) {
+        UniValue pair(UniValue::VOBJ);
+        pair.pushKV(oraclefields::Token, priceFeed.first);
+        pair.pushKV(oraclefields::Currency, priceFeed.second);
+        return pair;
+    }
+
+    bool diffInHour(int64_t time1, int64_t time2) {
+        constexpr const uint64_t SECONDS_PER_HOUR = 3600u;
+        return std::abs(time1 - time2) < SECONDS_PER_HOUR;
+    }
+
+    UniValue OracleToJSON(const COracleId& oracleId, const COracle& oracle) {
+        UniValue result{UniValue::VOBJ};
+        result.pushKV(oraclefields::Weightage, oracle.weightage);
+        result.pushKV(oraclefields::OracleId, oracleId.GetHex());
+        result.pushKV(oraclefields::OracleAddress, oracle.oracleAddress.GetHex());
+
+        UniValue priceFeeds{UniValue::VARR};
+        for (const auto& feed : oracle.availablePairs) {
+            priceFeeds.push_back(PriceFeedToJSON(feed));
+        }
+
+        result.pushKV(oraclefields::PriceFeeds, priceFeeds);
+
+        UniValue tokenPrices{UniValue::VARR};
+        for (const auto& tokenPrice: oracle.tokenPrices) {
+            for (const auto& price: tokenPrice.second) {
+                const auto& currency = price.first;
+                const auto& pricePair = price.second;
+                auto amount = pricePair.first;
+                auto timestamp = pricePair.second;
+
+                UniValue item(UniValue::VOBJ);
+                item.pushKV(oraclefields::Token, tokenPrice.first);
+                item.pushKV(oraclefields::Currency, currency);
+                item.pushKV(oraclefields::Amount, ValueFromAmount(amount));
+                item.pushKV(oraclefields::Timestamp, timestamp);
+                tokenPrices.push_back(item);
+            }
+        }
+
+        result.pushKV(oraclefields::TokenPrices, tokenPrices);
+        return result;
+    }
+}
+
+UniValue getoracledata(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"getoracledata",
+               "\nReturns oracle data in json form.\n" +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"oracleid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "oracle hex id",},
+               },
+               RPCResult{
+                       "\"json\"                  (string) oracle data in json form\n"
+               },
+               RPCExamples{
+                       HelpExampleCli(
+                               "getoracledata", "5474b2e9bfa96446e5ef3c9594634e1aa22d3a0722cb79084d61253acbdf87bf")
+                       + HelpExampleRpc(
+                               "getoracledata", "5474b2e9bfa96446e5ef3c9594634e1aa22d3a0722cb79084d61253acbdf87bf"
+                       )
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VSTR}, false);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+
+    // decode oracle id
+    COracleId oracleId = ParseHashV(request.params[0], "oracleid");
+
+    LOCK(cs_main);
+    CCustomCSView mnview(*pcustomcsview); // don't write into actual DB
+
+    auto oracleRes = mnview.GetOracleData(oracleId);
+    if (!oracleRes.ok) {
+        throw JSONRPCError(RPC_DATABASE_ERROR, oracleRes.msg);
+    }
+
+    return OracleToJSON(oracleId, *oracleRes.val);
+}
+
+UniValue listoracles(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"listoracles",
+               "\nReturns list of oracle ids." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+               },
+               RPCResult{
+                       "\"hash\"                  (string) list of known oracle ids\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listoracles", "") + HelpExampleRpc("listoracles", "")
+               },
+    }.Check(request);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                           "Cannot create transactions while still in Initial Block Download");
+    }
+
+    pwallet->BlockUntilSyncedToCurrentChain();
+    LockedCoinsScopedGuard lcGuard(pwallet);
+    LOCK(cs_main);
+
+    UniValue value(UniValue::VARR);
+    CCustomCSView view(*pcustomcsview);
+    view.ForEachOracle([&](const COracleId& id, CLazySerialize<COracle>) {
+        value.push_back(id.GetHex());
+        return true;
+    });
+
+    return value;
+}
+
+UniValue listlatestrawprices(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"listlatestrawprices",
+               "\nReturns latest raw price updates through all the oracles for specified token and currency , \n" +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"request", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                        "request in json-form, containing currency and token names"},
+               },
+               RPCResult{
+                       "\"json\"                  (string) Array of json objects containing full information about token prices\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listlatestrawprices",
+                                      R"(listlatestrawprices '{"currency": "USD", "token": "BTC"}')")
+                       + HelpExampleRpc("listlatestrawprices",
+                                        R"(listlatestrawprices '{"currency": "USD", "token": "BTC"}')")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VSTR}, false);
+    bool useAllFeeds = false;
+    UniValue data{UniValue::VOBJ};
+
+    if (request.params.empty()) {
+        useAllFeeds = true;
+    } else if (!data.read(request.params[0].getValStr())) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "failed to read input json");
+    }
+
+    LOCK(cs_main);
+
+    CCustomCSView mnview(*pcustomcsview);
+
+    auto &chain = pwallet->chain();
+    auto lock = chain.lock();
+
+    boost::optional<CTokenCurrencyPair> tokenPair;
+    if (!useAllFeeds) {
+        tokenPair = DecodeTokenCurrencyPair(data);
+    }
+
+    auto optHeight = lock->getHeight();
+    int lastHeight = optHeight ? *optHeight : 0;
+    auto lastBlockTime = lock->getBlockTime(lastHeight);
+
+    UniValue result(UniValue::VARR);
+    mnview.ForEachOracle([&](const COracleId& oracleId, COracle oracle) {
+        if (tokenPair && !oracle.SupportsPair(tokenPair->first, tokenPair->second)) {
+            return true;
+        }
+        for (const auto& tokenPrice: oracle.tokenPrices) {
+            const auto& token = tokenPrice.first;
+            if (tokenPair && tokenPair->first != token) {
+                continue;
+            }
+            for (const auto& price: tokenPrice.second) {
+                const auto& currency = price.first;
+                if (tokenPair && tokenPair->second != currency) {
+                    continue;
+                }
+                const auto& pricePair = price.second;
+                auto amount = pricePair.first;
+                auto timestamp = pricePair.second;
+
+                UniValue value{UniValue::VOBJ};
+                auto tokenCurrency = std::make_pair(token, currency);
+                value.pushKV(oraclefields::PriceFeeds, PriceFeedToJSON(tokenCurrency));
+                value.pushKV(oraclefields::OracleId, oracleId.GetHex());
+                value.pushKV(oraclefields::Weightage, oracle.weightage);
+                value.pushKV(oraclefields::Timestamp, timestamp);
+                value.pushKV(oraclefields::RawPrice, ValueFromAmount(amount));
+                auto state = diffInHour(timestamp, lastBlockTime) ? oraclefields::Alive : oraclefields::Expired;
+                value.pushKV(oraclefields::State, state);
+                result.push_back(value);
+            }
+        }
+        return true;
+    });
+    return result;
+}
+
+namespace {
+    CAmount GetAggregatePrice(CCustomCSView& view, const std::string& token, const std::string& currency, uint64_t lastBlockTime) {
+        arith_uint256 weightedSum = 0;
+        uint64_t numLiveOracles = 0, sumWeights = 0;
+        view.ForEachOracle([&](const COracleId&, COracle oracle) {
+            if (!oracle.SupportsPair(token, currency)) {
+                return true;
+            }
+            for (const auto& tokenPrice : oracle.tokenPrices) {
+                if (token != tokenPrice.first) {
+                    continue;
+                }
+                for (const auto& price : tokenPrice.second) {
+                    if (currency != price.first) {
+                        continue;
+                    }
+                    const auto& pricePair = price.second;
+                    auto amount = pricePair.first;
+                    auto timestamp = pricePair.second;
+                    if (!diffInHour(timestamp, lastBlockTime)) {
+                        continue;
+                    }
+                    ++numLiveOracles;
+                    sumWeights += oracle.weightage;
+                    weightedSum += arith_uint256(amount) * arith_uint256(oracle.weightage);
+                }
+            }
+            return true;
+        });
+
+        if (numLiveOracles == 0) {
+            throw JSONRPCError(RPC_MISC_ERROR, "no live oracles for specified request");
+        }
+
+        if (sumWeights == 0) {
+            throw JSONRPCError(RPC_MISC_ERROR, "all live oracles which meet specified request, have zero weight");
+        }
+
+        return (weightedSum / arith_uint256(sumWeights)).GetLow64();
+    }
+
+    UniValue GetAllAggregatePrices(CCustomCSView& view, uint64_t lastBlockTime) {
+        UniValue result(UniValue::VARR);
+        std::set<CTokenCurrencyPair> setTokenCurrency;
+        view.ForEachOracle([&](const COracleId&, COracle oracle) {
+            const auto& pair = oracle.availablePairs;
+            setTokenCurrency.insert(pair.begin(), pair.end());
+            return true;
+        });
+        for (const auto& tokenCurrency : setTokenCurrency) {
+            UniValue item{UniValue::VOBJ};
+            const auto& token = tokenCurrency.first;
+            const auto& currency = tokenCurrency.second;
+            item.pushKV(oraclefields::Token, token);
+            item.pushKV(oraclefields::Currency, currency);
+            try {
+                auto price = GetAggregatePrice(view, token, currency, lastBlockTime);
+                item.pushKV(oraclefields::AggregatedPrice, ValueFromAmount(price));
+                item.pushKV(oraclefields::ValidityFlag, oraclefields::FlagIsValid);
+            } catch (const UniValue& error) {
+                item.pushKV(oraclefields::ValidityFlag, error["message"]);
+            }
+            result.push_back(item);
+        }
+        return result;
+    }
+} // namespace
+
+UniValue getprice(const JSONRPCRequest &request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"getprice",
+               "\nCalculates aggregated price, \n"
+               "The only argument is a json-form request containing token and currency names." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"request", RPCArg::Type::STR, RPCArg::Optional::NO,
+                        "request in json-form, containing currency and token names, both are mandatory"},
+               },
+               RPCResult{
+                       "\"string\"                  (string) aggregated price if\n"
+                       "                        if no live oracles which meet specified request or their weights are zero, throws error\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("getprice", R"(getprice '{"currency": "USD", "token": "BTC"}')")
+                       + HelpExampleRpc("getprice", R"(getprice '{"currency": "USD", "token": "BTC"}')")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VSTR}, false);
+
+    LOCK(cs_main);
+
+    CCustomCSView view(*pcustomcsview);
+
+    UniValue data{UniValue::VOBJ};
+    if (!data.read(request.params[0].getValStr())) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "failed to read input json");
+    }
+
+    auto tokenPair = DecodeTokenCurrencyPair(data);
+
+    auto &chain = pwallet->chain();
+    auto lock = chain.lock();
+
+    auto optHeight = lock->getHeight();
+    int lastHeight = optHeight ? *optHeight : 0;
+    auto lastBlockTime = lock->getBlockTime(lastHeight);
+
+    auto result = GetAggregatePrice(view, tokenPair.first, tokenPair.second, lastBlockTime);
+    return ValueFromAmount(result);
+}
+
+UniValue listprices(const JSONRPCRequest& request) {
+    CWallet *const pwallet = GetWallet(request);
+
+    RPCHelpMan{"listprices",
+               "\nCalculates aggregated prices for all supported pairs (token, currency), \n"
+               "Takes no arguments." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {},
+               RPCResult{
+                       "\"json\"                  (string) array containing json-objects having following fields:\n"
+                       "                  `token` - token name,\n"
+                       "                  `currency` - currency name,\n"
+                       "                  `price` - aggregated price value,\n"
+                       "                  `ok` - validity flag,\n"
+                       "                  `msg` - optional - if ok is `false`, contains reason\n"
+                       "                   possible reasons for a price result to be invalid:"
+                       "                   1. if there are no live oracles which meet specified request.\n"
+                       "                   2. Sum of the weight of live oracles is zero.\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listprices", "listprices")
+                       + HelpExampleRpc("listprices", "listprices")
+               },
+    }.Check(request);
+
+    RPCTypeCheck(request.params, {}, false);
+
+    LOCK(cs_main);
+
+    CCustomCSView view(*pcustomcsview);
+
+    auto &chain = pwallet->chain();
+    auto lock = chain.lock();
+
+    auto optHeight = lock->getHeight();
+    int lastHeight = optHeight ? *optHeight : 0;
+    auto lastBlockTime = lock->getBlockTime(lastHeight);
+
+    return GetAllAggregatePrices(view, lastBlockTime);
+}
+
+static const CRPCCommand commands[] =
+{
+//  category        name                     actor (function)        params
+//  -------------   ---------------------    --------------------    ----------
+    {"oracles",     "appointoracle",         &appointoracle,          {"address", "pricefeeds", "weightage"}},
+    {"oracles",     "removeoracle",          &removeoracle,           {"oracleid"}},
+    {"oracles",     "updateoracle",          &updateoracle,           {"oracleid", "address", "pricefeeds", "weightage"}},
+    {"oracles",     "setoracledata",         &setoracledata,          {"oracleid", "timestamp", "prices"}},
+    {"oracles",     "getoracledata",         &getoracledata,          {"oracleid"}},
+    {"oracles",     "listoracles",           &listoracles,                 {}},
+    {"oracles",     "listlatestrawprices",   &listlatestrawprices,    {"request"}},
+    {"oracles",     "getprice",              &getprice,               {"request"}},
+    {"oracles",     "listprices",            &listprices,                   {}},
+};
+
+void RegisterOraclesRPCCommands(CRPCTable& tableRPC) {
+    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
+        tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
+}
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index ac4cf9f36f..49214c0c9c 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -254,6 +254,10 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "spv_claimhtlc", 3, "feerate" },
 
     { "spv_refundhtlc", 2, "feerate" },
+
+    { "appointoracle", 2, "weightage" },
+    { "updateoracle", 3, "weightage" },
+    { "setoracledata", 1, "timestamp" },
 };
 // clang-format on
 
diff --git a/src/rpc/register.h b/src/rpc/register.h
index 804e305fca..3f3ef7c80e 100644
--- a/src/rpc/register.h
+++ b/src/rpc/register.h
@@ -31,6 +31,8 @@ void RegisterPoolpairRPCCommands(CRPCTable &tableRPC);
 void RegisterMNBlockchainRPCCommands(CRPCTable &tableRPC);
 /** Register SPV (anchoring) RPC commands */
 void RegisterSpvRPCCommands(CRPCTable &tableRPC);
+/** Register oracles RPC commands */
+void RegisterOraclesRPCCommands(CRPCTable &tableRPC);
 
 static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
 {
@@ -45,6 +47,7 @@ static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
     RegisterPoolpairRPCCommands(t);
     RegisterMNBlockchainRPCCommands(t);
     RegisterSpvRPCCommands(t);
+    RegisterOraclesRPCCommands(t);
 }
 
 #endif // DEFI_RPC_REGISTER_H
diff --git a/src/test/oracles_tests.cpp b/src/test/oracles_tests.cpp
new file mode 100644
index 0000000000..936a1a21c2
--- /dev/null
+++ b/src/test/oracles_tests.cpp
@@ -0,0 +1,141 @@
+// Copyright (c) DeFi Blockchain Developers
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/setup_common.h>
+#include <string>
+#include <boost/test/unit_test.hpp>
+
+#include <masternodes/oracles.h>
+#include <rpc/rawtransaction_util.h>
+#include <masternodes/masternodes.h>
+
+#include <boost/algorithm/string/join.hpp>
+#include <boost/range/adaptor/transformed.hpp>
+
+struct OraclesTestingSetup : public TestingSetup {
+    const std::string data1 =
+            "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
+            "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
+
+    const std::string data2 =
+            "\x9c\x52\x4a\xac\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
+            "\x22\x81\xaa\xb5\x24\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
+
+    const std::string hex1 = "7d1de5eaf9b156d53208f033b5aa8122d2d2355d5e12292b121156cfdb4a529c";
+    const std::vector<unsigned char> rawVector1{data1.begin(), data1.end()};
+    const std::vector<unsigned char> rawVector2{data2.begin(), data2.end()};
+    const std::string address1 = "mhWzxsS5aDfmNY2EpPuM2xQZx7Ju3yjkQ4";
+
+    std::string JoinOracles(const std::vector<COracleId> &oracles) {
+        auto list = boost::algorithm::join(
+                oracles | boost::adaptors::transformed(
+                        [](const COracleId &x) -> std::string {
+                            return x.GetHex();
+                        }),
+                ", ");
+        return "[" + list + "]";
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(oracles_tests, OraclesTestingSetup)
+
+    BOOST_AUTO_TEST_CASE(check_oracleid_compare_operator) {
+        COracleId id1{rawVector1}, id2{}, id3{rawVector1};
+        BOOST_ASSERT_MSG(id1 != id2, "compare unequal failed");
+        BOOST_ASSERT_MSG(id1 == id3, "compare equal failed");
+    }
+
+    BOOST_AUTO_TEST_CASE(oracleid_serialization_test) {
+
+        CDataStream stream(std::vector<unsigned char>{}, SER_NETWORK, PROTOCOL_VERSION);
+        COracleId oracleId{rawVector1};
+        stream << oracleId;
+        COracleId oracleId1{};
+        stream >> oracleId1;
+        BOOST_ASSERT_MSG(oracleId == oracleId1, "failed to serialize/deserialize COracleId");
+    }
+
+    BOOST_AUTO_TEST_CASE(oracle_serialization_test) {
+        COracleId oracleId1{rawVector1};
+        COracleId oracleId2{rawVector2};
+
+        BOOST_ASSERT_MSG(oracleId1 != oracleId2, "bad test data");
+
+        std::vector<unsigned char> tmp{'a', 'b', 'c'};
+        CScript oracleAddress1{tmp.begin(), tmp.end()};
+        uint8_t weightage = 15;
+        std::set<CTokenCurrencyPair> availableTokens = {
+                {"DFI", "USD"},
+                {"TOK", "USD"},
+        };
+        CAppointOracleMessage msg{oracleAddress1, weightage, availableTokens};
+        COracle oracle{msg};
+
+        CCustomCSView mnview(*pcustomcsview);
+        auto res = mnview.AppointOracle(oracleId1, oracle);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+
+        res = mnview.AppointOracle(oracleId2, oracle);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+    }
+
+    BOOST_AUTO_TEST_CASE(remove_oracle_test) {
+
+        COracleId oracleId1{rawVector1};
+        COracleId oracleId2{rawVector2};
+        uint8_t weightage = 15;
+        std::vector<unsigned char> tmp{'a', 'b', 'c'};
+        CScript oracleAddress1{tmp.begin(), tmp.end()};
+        std::set<CTokenCurrencyPair> availableTokens = {
+                {"DFI", "USD"},
+                {"TOK", "USD"},
+        };
+        CAppointOracleMessage msg{oracleAddress1, weightage, availableTokens};
+        COracle oracle1{msg};
+
+        CCustomCSView mnview(*pcustomcsview);
+        auto res = mnview.AppointOracle(oracleId1, oracle1);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+
+        res = mnview.AppointOracle(oracleId2, oracle1);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+
+        auto res1 = mnview.RemoveOracle(oracleId1);
+        BOOST_ASSERT_MSG(res1.ok, "failed to remove oracle");
+
+        auto res2 = mnview.RemoveOracle(oracleId2);
+        BOOST_ASSERT_MSG(res2.ok, "failed to remove oracle");
+    }
+
+    BOOST_AUTO_TEST_CASE(update_oracle_test) {
+
+        COracleId oracleId1{rawVector1};
+        COracleId oracleId2{rawVector2};
+        uint8_t weightage = 15;
+        std::vector<unsigned char> tmp{'a', 'b', 'c'};
+        CScript oracleAddress1{tmp.begin(), tmp.end()};
+        std::set<CTokenCurrencyPair> availableTokens = {
+                {"DFI", "USD"},
+                {"TOK", "USD"},
+        };
+        CAppointOracleMessage msg1{oracleAddress1, weightage, availableTokens};
+        COracle oracle1{msg1};
+
+        uint8_t weightage2 = weightage + 2;
+        availableTokens.insert({"DFI", "EUR"});
+        CAppointOracleMessage msg2{oracleAddress1, weightage2, availableTokens};
+        COracle oracle2{msg2};
+
+        CCustomCSView mnview(*pcustomcsview);
+        auto res = mnview.AppointOracle(oracleId1, oracle1);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+
+        res = mnview.UpdateOracle(oracleId1, oracle2);
+        BOOST_ASSERT_MSG(res.ok, res.msg.c_str());
+
+        auto dataRes = mnview.GetOracleData(oracleId1);
+        BOOST_ASSERT_MSG(dataRes.ok, dataRes.msg.c_str());
+    }
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_oracles.py b/test/functional/feature_oracles.py
new file mode 100755
index 0000000000..6d59993397
--- /dev/null
+++ b/test/functional/feature_oracles.py
@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+# Copyright (c) DeFi Blockchain Developers
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+"""Test token's RPC.
+
+- verify basic token's creation, destruction, revert, collateral locking
+"""
+from test_framework.test_framework import DefiTestFramework
+from test_framework.util import assert_equal, assert_raises_rpc_error
+
+import decimal
+import math
+import calendar
+import time
+import json
+import functools
+
+
+class OraclesTest(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 4
+        # node0: main (foundation)
+        # node1: data accessor
+        # node2: non foundation
+        self.setup_clean_chain = True
+        self.extra_args = [
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=1'],
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=1'],
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=1'],
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=1']]
+
+    @staticmethod
+    def find_address_tx(node, address):
+        vals = node.listunspent()
+        count = len(vals)
+        for i in range(0, count):
+            v = vals[i]
+            if v['address'] == address:
+                return v
+        return None
+
+    @staticmethod
+    def cmp_price_feed(x):
+        return x['token'], x['currency']
+
+    @staticmethod
+    def parse_token_amount(token_amount: str):
+        amount, _, token = token_amount.partition('@')
+        return decimal.Decimal(amount), token
+
+    def assert_compare_oracle_data(self, oracle_data_json, oracle_id=None, oracle_address=None,
+                                   price_feeds: str = None, weightage=None, token_prices: str = None):
+        if oracle_id is not None:
+            if not oracle_id == oracle_data_json['oracleid']:
+                raise Exception("oracleids don't match")
+
+        # normally there is no need to compare oracle address
+        if oracle_address is not None:
+            if not oracle_address == oracle_data_json['address']:
+                raise Exception("oracle addresses don't match")
+
+        if weightage is not None:
+            if not math.isclose(decimal.Decimal(weightage), decimal.Decimal(oracle_data_json['weightage'])):
+                raise Exception("weightages are not equal")
+
+        if price_feeds is not None:
+            price_feeds_proto = json.loads(price_feeds)
+            if not type(price_feeds_proto) is list:
+                raise Exception("price feeds is not list")
+
+            if not sorted(price_feeds_proto, key=self.cmp_price_feed) == \
+                   sorted(oracle_data_json['priceFeeds'], key=self.cmp_price_feed):
+                raise Exception("price feeds don't match")
+
+        if token_prices is not None:
+            token_prices_json = oracle_data_json['tokenPrices']
+            token_prices_proto = json.loads(token_prices)
+            for item in token_prices_proto:
+                amount, token = self.parse_token_amount(item['tokenAmount'])
+                item['token'] = token
+                item['amount'] = amount
+            tpjs = sorted(token_prices_json, key=self.cmp_price_feed)
+            tpps = sorted(token_prices_proto, key=self.cmp_price_feed)
+
+            if not functools.reduce(
+                    lambda x, y: x and y,
+                    map(
+                        lambda p, q:
+                        p['token'] == q['token']
+                        and
+                        p['currency'] == q['currency']
+                        and
+                        math.isclose(decimal.Decimal(p['amount']), decimal.Decimal(q['amount'])),
+                    tpjs, tpps), True):
+                raise Exception("prices are not equal")
+
+    def synchronize(self, node: int, full: bool = False):
+        self.nodes[node].generate(1)
+        self.sync_blocks([self.nodes[0], self.nodes[1], self.nodes[2]])
+        if full:
+            self.sync_mempools([self.nodes[0], self.nodes[1], self.nodes[2]])
+
+    def run_test(self):
+        self.nodes[0].generate(200)
+        self.sync_all()
+
+        # === stop node #3 for future revert ===
+        self.stop_node(3)
+
+        # === create oracle addresses ===
+        oracle_address1 = self.nodes[2].getnewaddress("", "legacy")
+        oracle_address2 = self.nodes[2].getnewaddress("", "legacy")
+
+        assert (self.find_address_tx(self.nodes[1], oracle_address1) is None)
+        assert (self.find_address_tx(self.nodes[1], oracle_address2) is None)
+
+        # === supply oracles with money for transactions ===
+        self.nodes[0].sendtoaddress(oracle_address1, 50)
+        self.nodes[0].sendtoaddress(oracle_address2, 50)
+
+        self.synchronize(0, full=True)
+
+        send_money_tx1, send_money_tx2 = \
+            [self.find_address_tx(self.nodes[2], address) for address in [oracle_address1, oracle_address2]]
+
+        assert (send_money_tx1 is not None)
+        assert (send_money_tx2 is not None)
+
+        assert (send_money_tx1['amount'] == decimal.Decimal(50))
+        assert (send_money_tx2['amount'] == decimal.Decimal(50))
+
+        # === appoint oracles ===
+        price_feeds1 = '[{"currency": "USD", "token": "GOLD"}, {"currency": "USD", "token": "PT"}]'
+
+        # check that only founder can appoint oracles
+        assert_raises_rpc_error(-5, 'Need foundation member authorization',
+                                self.nodes[2].appointoracle, oracle_address1, price_feeds1, 10)
+        oracle_id1 = self.nodes[0].appointoracle(oracle_address1, price_feeds1, 10)
+
+        self.synchronize(node=0)
+
+        all_oracles = self.nodes[1].listoracles()
+        assert_equal(all_oracles, [oracle_id1])
+
+        price_feeds2 = '[{"currency": "EUR", "token": "PT"}, {"currency": "EUR", "token": "GOLD"}]'
+        oracle_id2 = self.nodes[0].appointoracle(oracle_address2, price_feeds2, 15)
+
+        self.synchronize(node=0)
+
+        all_oracles = self.nodes[1].listoracles()
+        assert_equal(sorted(all_oracles), sorted([oracle_id1, oracle_id2]))
+
+        # === remove oracle ===
+        self.nodes[0].removeoracle(oracle_id2)
+
+        # check that only founder can remove oracles
+        assert_raises_rpc_error(-5, 'Need foundation member authorization',
+                                self.nodes[2].removeoracle, oracle_id1)
+
+        self.synchronize(node=0, full=True)
+
+        all_oracles = self.nodes[1].listoracles()
+        assert_equal(all_oracles, [oracle_id1])
+
+        # === try to remove oracle, but fail ===
+        assert_raises_rpc_error(-32600, 'oracle <{}> not found'.format(oracle_id2),
+                                self.nodes[0].removeoracle, oracle_id2)
+
+        # save removed oracle id for future tests
+        invalid_oracle_id = oracle_id2
+
+        # === re-create oracle2 ===
+
+        price_feeds2 = '[{"currency": "EUR", "token": "GOLD"}, {"currency": "EUR", "token": "PT"}]'
+        oracle_id2 = self.nodes[0].appointoracle(oracle_address2, price_feeds2, 15)
+
+        self.synchronize(node=0)
+
+        # === check that price feeds are set correctly ===
+        self.assert_compare_oracle_data(oracle_data_json=self.nodes[1].getoracledata(oracle_id1),
+                                        oracle_id=oracle_id1,
+                                        weightage=10,
+                                        price_feeds=price_feeds1,
+                                        token_prices='[]'   # no prices yet
+                                        )
+
+        self.assert_compare_oracle_data(oracle_data_json=self.nodes[1].getoracledata(oracle_id2),
+                                        oracle_id=oracle_id2,
+                                        weightage=15,
+                                        price_feeds=price_feeds2,
+                                        token_prices='[]'   # no prices yet
+                                        )
+
+        all_oracles = self.nodes[1].listoracles()
+        assert_equal(sorted(all_oracles), sorted([oracle_id1, oracle_id2]))
+
+        # === check get price in case when no live oracles are available ===
+        assert_raises_rpc_error(-1, 'no live oracles for specified request',
+                                self.nodes[1].getprice, '{"currency": "USD", "token": "GOLD"}')
+        assert_raises_rpc_error(-1, 'no live oracles for specified request',
+                                self.nodes[1].getprice, '{"currency": "USD", "token": "PT"}')
+        assert_raises_rpc_error(-1, 'no live oracles for specified request',
+                                self.nodes[1].getprice, '{"currency": "EUR", "token": "GOLD"}')
+        assert_raises_rpc_error(-1, 'no live oracles for specified request',
+                                self.nodes[1].getprice, '{"currency": "EUR", "token": "PT"}')
+
+        timestamp = calendar.timegm(time.gmtime())
+
+        # === set oracle data, simple case ===
+        oracle1_prices = '[{"currency": "USD", "tokenAmount": "10.1@PT"}, ' \
+                         '{"currency": "USD", "tokenAmount": "5@GOLD"}]'
+        self.nodes[2].setoracledata(oracle_id1, timestamp, oracle1_prices)
+
+        self.synchronize(node=2)
+
+        oracle_data_json = self.nodes[1].getoracledata(oracle_id1)
+        self.assert_compare_oracle_data(oracle_data_json=oracle_data_json, oracle_id=oracle_id1,
+                                        price_feeds=price_feeds1, weightage=10,
+                                        token_prices=oracle1_prices)    # now we have prices
+
+        # decimals are not strict values, so we need to look how small is the difference
+        assert (math.isclose(
+            self.nodes[1].getprice('{"currency":"USD", "token":"PT"}'), decimal.Decimal(10.1)))
+
+        assert (math.isclose(
+            self.nodes[1].getprice('{"currency":"USD", "token":"GOLD"}'), decimal.Decimal(5)))
+
+        price_feeds1 = '''
+            [{"currency": "USD", "token": "PT"},
+             {"currency": "EUR", "token": "PT"},
+             {"currency": "EUR", "token": "GOLD"},
+             {"currency": "USD", "token": "GOLD"}]
+        '''
+        self.nodes[0].updateoracle(oracle_id1, oracle_address1, price_feeds1, 20)
+
+        # check that only founder can appoint oracles
+        assert_raises_rpc_error(-5, 'Need foundation member authorization',
+                                self.nodes[2].updateoracle, oracle_id1, oracle_address1, price_feeds1, 10)
+
+        self.synchronize(node=0)
+
+        # === check price feeds ===
+        oracle1_data = self.nodes[1].getoracledata(oracle_id1)
+
+        self.assert_compare_oracle_data(oracle_data_json=oracle1_data,
+                                        oracle_id=oracle_id1,
+                                        price_feeds=price_feeds1,
+                                        weightage=20)
+
+        self.nodes[0].updateoracle(oracle_id1, oracle_address1, price_feeds1, 15)
+
+        self.synchronize(node=0)
+
+        oracle1_data = self.nodes[1].getoracledata(oracle_id1)
+        # check only weightage
+        self.assert_compare_oracle_data(oracle_data_json=oracle1_data,
+                                        weightage=15)
+
+        # check only prices
+        self.assert_compare_oracle_data(oracle_data_json=oracle1_data,
+                                        price_feeds=price_feeds1)
+
+        oracle2_data = self.nodes[1].getoracledata(oracle_id2)
+
+        self.assert_compare_oracle_data(oracle_data_json=oracle2_data,
+                                        oracle_id=oracle_id2,
+                                        price_feeds=price_feeds2,
+                                        weightage=15)
+
+        # === check listprice in case when no valid prices available ===
+        # === the listprices method returns information ===
+        assert (len(self.nodes[1].listprices()) == 4)
+        # === but no valid prices in both oracles ===
+        assert (len([x for x in self.nodes[1].listprices() if x['ok'] == True]) == 2)
+
+        # === check get prices methods complex case ===
+
+        oracle1_prices = '[{"currency": "USD", "tokenAmount": "11.5@PT"},' \
+                         '{"currency": "EUR", "tokenAmount": "5@GOLD"}]'
+
+        self.nodes[2].setoracledata(oracle_id1, timestamp, oracle1_prices)
+
+        oracle2_prices = '[{"currency": "EUR", "tokenAmount": "4@GOLD"}]'
+
+        self.nodes[2].setoracledata(oracle_id2, timestamp, oracle2_prices)
+
+        self.synchronize(node=2)
+
+        # === set missing data ===
+        price_feeds2 = '''
+            [{"currency": "USD", "token": "PT"},
+             {"currency": "EUR", "token": "PT"},
+             {"currency": "EUR", "token": "GOLD"},
+             {"currency": "USD", "token": "GOLD"}]
+        '''
+
+        self.nodes[0].updateoracle(oracle_id2, oracle_address2, price_feeds2, 25)
+
+        self.synchronize(node=0)
+
+        # === we have no valid oracle values for PT#129 in EUR ===
+        assert_raises_rpc_error(-1, 'no live oracles for specified request',
+                                self.nodes[1].getprice, '{"currency": "EUR", "token": "PT"}')
+
+        self.nodes[2].setoracledata(oracle_id2, timestamp,
+                                          '[{"currency":"USD", "tokenAmount":"10@GOLD"},'
+                                          '{"currency":"EUR", "tokenAmount":"7@PT"}]')
+
+        token_prices1 = '[{"currency":"USD", "tokenAmount":"11@GOLD"}, ' \
+                        '{"currency":"EUR", "tokenAmount":"8@PT"}, ' \
+                        '{"currency":"EUR", "tokenAmount":"10@GOLD"}, ' \
+                        '{"currency":"USD", "tokenAmount":"7@PT"}]'
+
+        self.nodes[2].setoracledata(oracle_id1, timestamp, token_prices1)
+
+        self.synchronize(node=2)
+
+        self.assert_compare_oracle_data(oracle_data_json=self.nodes[1].getoracledata(oracle_id1),
+                                        oracle_id=oracle_id1,
+                                        price_feeds=price_feeds1,
+                                        token_prices=token_prices1)
+
+        # === check expired price feed ===
+        token_prices1 = '[{"currency":"USD", "tokenAmount":"11@GOLD"}, ' \
+                        '{"currency":"EUR", "tokenAmount":"8@PT"}, ' \
+                        '{"currency":"EUR", "tokenAmount":"10@GOLD"}, ' \
+                        '{"currency":"USD", "tokenAmount":"7@PT"}]'
+
+        self.nodes[2].setoracledata(oracle_id1, timestamp - 7200, token_prices1)
+
+        self.synchronize(node=2, full=True)
+
+        pt_in_usd_raw_prices = self.nodes[1].listlatestrawprices('{"currency":"USD", "token":"PT"}')
+
+        assert_equal(len(pt_in_usd_raw_prices), 1)
+        assert_equal(pt_in_usd_raw_prices[0]['state'], 'expired')
+
+        # === check for invalid oracle id
+        assert_raises_rpc_error(-20, 'oracle <{}> not found'.format(invalid_oracle_id),
+                                self.nodes[1].getoracledata, invalid_oracle_id)
+
+        assert_raises_rpc_error(-32600, 'oracle <{}> not found'.format(invalid_oracle_id),
+                                self.nodes[0].updateoracle,
+                                invalid_oracle_id, oracle_address2, '[{"currency":"USD", "token":"PT#129"}]', 15)
+
+        assert_raises_rpc_error(-32600, 'oracle <{}> not found'.format(invalid_oracle_id),
+                                self.nodes[0].setoracledata,
+                                invalid_oracle_id, timestamp, '[{"currency":"USD", "tokenAmount":"10@PT#129"}]')
+
+        self.nodes[0].removeoracle(oracle_id1)
+        self.nodes[0].removeoracle(oracle_id2)
+
+        self.synchronize(node=0, full=True)
+
+
+if __name__ == '__main__':
+    OraclesTest().main()
diff --git a/test/functional/rpc_help.py b/test/functional/rpc_help.py
index 026c2eecb8..c4701abf4d 100755
--- a/test/functional/rpc_help.py
+++ b/test/functional/rpc_help.py
@@ -33,7 +33,7 @@ def test_categories(self):
         # command titles
         titles = [line[3:-3] for line in node.help().splitlines() if line.startswith('==')]
 
-        components = ['Accounts', 'Blockchain', 'Control', 'Generating', 'Masternodes', 'Mining', 'Network', 'Poolpair', 'Rawtransactions', 'Spv', 'Tokens', 'Util']
+        components = ['Accounts', 'Blockchain', 'Control', 'Generating', 'Masternodes', 'Mining', 'Network', 'Oracles', 'Poolpair', 'Rawtransactions', 'Spv', 'Tokens', 'Util']
 
         if self.is_wallet_compiled():
             components.append('Wallet')
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 96e7d839e8..08eb54d5ee 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -245,6 +245,7 @@
     'rpc_help.py',
     'feature_help.py',
     'feature_shutdown.py',
+    'feature_oracles.py',
     'rpc_getmininginfo.py',
     # Don't append tests at the end to avoid merge conflicts
     # Put them in a random line within the section that fits their approximate run-time
diff --git a/test/lint/check-rpc-mappings.py b/test/lint/check-rpc-mappings.py
index b417d9dfdb..0198312a5e 100755
--- a/test/lint/check-rpc-mappings.py
+++ b/test/lint/check-rpc-mappings.py
@@ -23,6 +23,7 @@
     "src/masternodes/rpc_accounts.cpp",
     "src/masternodes/rpc_tokens.cpp",
     "src/masternodes/rpc_poolpair.cpp",
+    "src/masternodes/rpc_oracles.cpp",
     "src/spv/spv_rpc.cpp",
 ]
 # Source file (relative to root) containing conversion mapping
diff --git a/test/lint/lint-locale-dependence.sh b/test/lint/lint-locale-dependence.sh
index 5103e2b6af..d092284d53 100755
--- a/test/lint/lint-locale-dependence.sh
+++ b/test/lint/lint-locale-dependence.sh
@@ -22,6 +22,8 @@ KNOWN_VIOLATIONS=(
     "src/util/strencodings.cpp:.*strtoul"
     "src/util/strencodings.h:.*atoi"
     "src/util/system.cpp:.*atoi"
+    "src/masternodes/rpc_oracles.cpp:.*stoul"
+    "src/masternodes/rpc_oracles.cpp:.*stoll"
 )
 
 REGEXP_IGNORE_EXTERNAL_DEPENDENCIES="^src/(crypto/ctaes/|leveldb/|secp256k1/|tinyformat.h|univalue|spv/)"

From bdba64c85807b789e1765c5b4174d7d70ce8d592 Mon Sep 17 00:00:00 2001
From: Xiao Shengguang <shengguangxiao@gmail.com>
Date: Wed, 14 Apr 2021 00:52:07 +0800
Subject: [PATCH 2/4] Fix rpc parameter not converted in defi-cli (#319)

---
 src/rpc/client.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 49214c0c9c..6611accf73 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -250,14 +250,12 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "sendtokenstoaddress", 1, "to" },
     { "getanchorteams", 0, "blockHeight" },
     { "getactivemasternodecount", 0, "blockCount" },
-
-    { "spv_claimhtlc", 3, "feerate" },
-
-    { "spv_refundhtlc", 2, "feerate" },
-
     { "appointoracle", 2, "weightage" },
     { "updateoracle", 3, "weightage" },
     { "setoracledata", 1, "timestamp" },
+
+    { "spv_claimhtlc", 3, "feerate" },
+    { "spv_refundhtlc", 2, "feerate" },
 };
 // clang-format on
 

From 1e0fad2435318662cc0729374d8908725dfed8e9 Mon Sep 17 00:00:00 2001
From: Ahmed Hilali <monstrobishi@gmail.com>
Date: Wed, 14 Apr 2021 14:36:01 +0800
Subject: [PATCH 3/4] Update rpc_oracles.cpp

Fixed rpc documentation
---
 src/masternodes/rpc_oracles.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/masternodes/rpc_oracles.cpp b/src/masternodes/rpc_oracles.cpp
index ccdf31aa84..36e42b181b 100644
--- a/src/masternodes/rpc_oracles.cpp
+++ b/src/masternodes/rpc_oracles.cpp
@@ -98,10 +98,10 @@ UniValue appointoracle(const JSONRPCRequest &request) {
                RPCExamples{
                        HelpExampleCli(
                                "appointoracle",
-                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"}]' 20)")
                        + HelpExampleRpc(
                                "appointoracle",
-                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"]}' 20)")
+                               R"(mwSDMvn1Hoc8DsoB7AkLv7nxdrf5Ja4jsF '[{"currency": "USD", "token": "BTC"}, {"currency": "EUR", "token":"ETH"}]' 20)")
                },
     }.Check(request);
 

From fb5cb69fcb816f8b5a95e48396b1a6723092a34b Mon Sep 17 00:00:00 2001
From: Ahmed Hilali <monstrobishi@gmail.com>
Date: Wed, 14 Apr 2021 15:32:44 +0800
Subject: [PATCH 4/4] Updated devnet heights

---
 src/chainparams.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index d954dad505..2aa653feb4 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -454,9 +454,9 @@ class CDevNetParams : public CChainParams {
         consensus.BayfrontMarinaHeight = 0;
         consensus.BayfrontGardensHeight = 0;
         consensus.ClarkeQuayHeight = 0;
-        consensus.DakotaHeight = 0;
-        consensus.DakotaCrescentHeight = 0;
-        consensus.EunosHeight = 0;
+        consensus.DakotaHeight = 10;
+        consensus.DakotaCrescentHeight = 10;
+        consensus.EunosHeight = 10;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 5 * 60; // 5 min == 10 blocks