diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 64e08d00030..4487027e63b 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -245,6 +245,7 @@ class CMainParams : public CChainParams {
 
         consensus.smartContracts.clear();
         consensus.smartContracts[SMART_CONTRACT_DFIP_2201] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0})));
+        consensus.smartContracts[SMART_CONTRACT_DFIP_2203] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1})));
 
         // owner base58, operator base58
         vMasternodes.push_back({"8PuErAcazqccCVzRcc8vJ3wFaZGm4vFbLe", "8J846CKFF83Jcj5m4EReJmxiaJ6Jy1Y6Ea"});
@@ -462,6 +463,7 @@ class CTestNetParams : public CChainParams {
 
         consensus.smartContracts.clear();
         consensus.smartContracts[SMART_CONTRACT_DFIP_2201] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0})));
+        consensus.smartContracts[SMART_CONTRACT_DFIP_2203] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1})));
 
         // owner base58, operator base58
         vMasternodes.push_back({"7LMorkhKTDjbES6DfRxX2RiNMbeemUkxmp", "7KEu9JMKCx6aJ9wyg138W3p42rjg19DR5D"});
@@ -644,6 +646,7 @@ class CDevNetParams : public CChainParams {
 
         consensus.smartContracts.clear();
         consensus.smartContracts[SMART_CONTRACT_DFIP_2201] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0})));
+        consensus.smartContracts[SMART_CONTRACT_DFIP_2203] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1})));
 
         // owner base58, operator base58
         vMasternodes.push_back({"7M3g9CSERjLdXisE5pv2qryDbURUj9Vpi1", "7Grgx69MZJ4wDKRx1bBxLqTnU9T3quKW7n"});
@@ -832,6 +835,7 @@ class CRegTestParams : public CChainParams {
 
         consensus.smartContracts.clear();
         consensus.smartContracts[SMART_CONTRACT_DFIP_2201] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0})));
+        consensus.smartContracts[SMART_CONTRACT_DFIP_2203] = GetScriptForDestination(CTxDestination(WitnessV0KeyHash(std::vector<unsigned char>{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1})));
 
         // owner base58, operator base58
         vMasternodes.push_back({"mwsZw8nF7pKxWH8eoKL9tPxTpaFkz7QeLU", "mswsMVsyGMj1FzDMbbxw2QW3KvQAv2FKiy"});
diff --git a/src/chainparams.h b/src/chainparams.h
index 2ec2c0d6625..1e0c243cce3 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -120,6 +120,7 @@ class CChainParams
 };
 
 const auto SMART_CONTRACT_DFIP_2201 = "DFIP2201";
+const auto SMART_CONTRACT_DFIP_2203 = "DFIP2203";
 
 /**
  * Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
diff --git a/src/masternodes/accounts.cpp b/src/masternodes/accounts.cpp
index 1644b9d441f..e8bbcd77ae6 100644
--- a/src/masternodes/accounts.cpp
+++ b/src/masternodes/accounts.cpp
@@ -98,3 +98,18 @@ uint32_t CAccountsView::GetBalancesHeight(CScript const & owner)
     bool ok = ReadBy<ByHeightKey>(owner, height);
     return ok ? height : 0;
 }
+
+Res CAccountsView::StoreFuturesUserValues(const CFuturesUserKey& key, const CFuturesUserValue& futures)
+{
+    if (!WriteBy<ByFuturesKey>(key, futures)) {
+        return Res::Err("Failed to store futures");
+    }
+
+    return Res::Ok();
+}
+
+void CAccountsView::ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start)
+{
+    ForEach<ByFuturesKey, CFuturesUserKey, CFuturesUserValue>(callback, start);
+}
+
diff --git a/src/masternodes/accounts.h b/src/masternodes/accounts.h
index c9d3a9555e3..a802f26f991 100644
--- a/src/masternodes/accounts.h
+++ b/src/masternodes/accounts.h
@@ -11,6 +11,44 @@
 #include <amount.h>
 #include <script/script.h>
 
+struct CFuturesUserKey {
+    uint32_t height;
+    CScript owner;
+    uint32_t txn;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        if (ser_action.ForRead()) {
+            READWRITE(WrapBigEndian(height));
+            height = ~height;
+            READWRITE(owner);
+            READWRITE(WrapBigEndian(txn));
+            txn = ~txn;
+        } else {
+            uint32_t height_ = ~height;
+            READWRITE(WrapBigEndian(height_));
+            READWRITE(owner);
+            uint32_t txn_ = ~txn;
+            READWRITE(WrapBigEndian(txn_));
+        }
+    }
+};
+
+struct CFuturesUserValue {
+    CTokenAmount source{};
+    uint32_t destination{};
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(source);
+        READWRITE(destination);
+    }
+};
+
 class CAccountsView : public virtual CStorageView
 {
 public:
@@ -27,9 +65,13 @@ class CAccountsView : public virtual CStorageView
     uint32_t GetBalancesHeight(CScript const & owner);
     Res UpdateBalancesHeight(CScript const & owner, uint32_t height);
 
+    Res StoreFuturesUserValues(const CFuturesUserKey& key, const CFuturesUserValue& futures);
+    void ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start = {});
+
     // tags
     struct ByBalanceKey { static constexpr uint8_t prefix() { return 'a'; } };
     struct ByHeightKey  { static constexpr uint8_t prefix() { return 'b'; } };
+    struct ByFuturesKey  { static constexpr uint8_t prefix() { return 'J'; } };
 
 private:
     Res SetBalance(CScript const & owner, CTokenAmount amount);
diff --git a/src/masternodes/balances.h b/src/masternodes/balances.h
index 64b3539d45f..c5349f3fd65 100644
--- a/src/masternodes/balances.h
+++ b/src/masternodes/balances.h
@@ -224,6 +224,21 @@ struct CSmartContractMessage {
     }
 };
 
+struct CDFIP2203Message {
+    CScript owner;
+    CTokenAmount source{};
+    uint32_t destination{};
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(owner);
+        READWRITE(source);
+        READWRITE(destination);
+    }
+};
+
 inline CBalances SumAllTransfers(CAccounts const & to) {
     CBalances sum;
     for (const auto& kv : to) {
diff --git a/src/masternodes/govvariables/attributes.cpp b/src/masternodes/govvariables/attributes.cpp
index 3dd7c6cc938..d74f7783eef 100644
--- a/src/masternodes/govvariables/attributes.cpp
+++ b/src/masternodes/govvariables/attributes.cpp
@@ -68,7 +68,8 @@ const std::map<uint8_t, std::string>& ATTRIBUTES::displayTypes() {
 
 const std::map<std::string, uint8_t>& ATTRIBUTES::allowedParamIDs() {
     static const std::map<std::string, uint8_t> params{
-        {"dfip2201",    ParamIDs::DFIP2201}
+        {"dfip2201",    ParamIDs::DFIP2201},
+        {"dfip2203",    ParamIDs::DFIP2203},
     };
     return params;
 }
@@ -76,6 +77,7 @@ const std::map<std::string, uint8_t>& ATTRIBUTES::allowedParamIDs() {
 const std::map<uint8_t, std::string>& ATTRIBUTES::displayParamsIDs() {
     static const std::map<uint8_t, std::string> params{
         {ParamIDs::DFIP2201,    "dfip2201"},
+        {ParamIDs::DFIP2203,    "dfip2203"},
         {ParamIDs::Economy,     "economy"},
     };
     return params;
@@ -91,6 +93,7 @@ const std::map<uint8_t, std::map<std::string, uint8_t>>& ATTRIBUTES::allowedKeys
                 {"loan_payback_fee_pct",TokenKeys::LoanPaybackFeePCT},
                 {"dex_in_fee_pct",      TokenKeys::DexInFeePct},
                 {"dex_out_fee_pct",     TokenKeys::DexOutFeePct},
+                {"dfip2203_disabled",   TokenKeys::DFIP2203Disabled},
             }
         },
         {
@@ -101,9 +104,11 @@ const std::map<uint8_t, std::map<std::string, uint8_t>>& ATTRIBUTES::allowedKeys
         },
         {
             AttributeTypes::Param, {
-                {"active",              DFIP2201Keys::Active},
-                {"minswap",             DFIP2201Keys::MinSwap},
-                {"premium",             DFIP2201Keys::Premium},
+                {"active",              DFIPKeys::Active},
+                {"minswap",             DFIPKeys::MinSwap},
+                {"premium",             DFIPKeys::Premium},
+                {"reward_pct",          DFIPKeys::RewardPct},
+                {"block_period",        DFIPKeys::BlockPeriod},
             }
         },
     };
@@ -120,6 +125,7 @@ const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys
                 {TokenKeys::LoanPaybackFeePCT,"loan_payback_fee_pct"},
                 {TokenKeys::DexInFeePct,      "dex_in_fee_pct"},
                 {TokenKeys::DexOutFeePct,     "dex_out_fee_pct"},
+                {TokenKeys::DFIP2203Disabled, "dfip2203_disabled"},
             }
         },
         {
@@ -130,14 +136,17 @@ const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys
         },
         {
             AttributeTypes::Param, {
-                {DFIP2201Keys::Active,        "active"},
-                {DFIP2201Keys::Premium,       "premium"},
-                {DFIP2201Keys::MinSwap,       "minswap"},
+                {DFIPKeys::Active,       "active"},
+                {DFIPKeys::Premium,      "premium"},
+                {DFIPKeys::MinSwap,      "minswap"},
+                {DFIPKeys::RewardPct,    "reward_pct"},
+                {DFIPKeys::BlockPeriod,  "block_period"},
             }
         },
         {
             AttributeTypes::Live, {
                 {EconomyKeys::PaybackDFITokens,  "dfi_payback_tokens"},
+                {EconomyKeys::DFIP2203Tokens,    "dfip_tokens"},
             }
         },
     };
@@ -147,11 +156,19 @@ const std::map<uint8_t, std::map<uint8_t, std::string>>& ATTRIBUTES::displayKeys
 static ResVal<int32_t> VerifyInt32(const std::string& str) {
     int32_t int32;
     if (!ParseInt32(str, &int32) || int32 < 0) {
-        return Res::Err("Identifier must be a positive integer");
+        return Res::Err("Value must be a positive integer");
     }
     return {int32, Res::Ok()};
 }
 
+static ResVal<CAttributeValue> VerifyPositiveInt64(const std::string& str) {
+    CAmount int64;
+    if (!ParseInt64(str, &int64) || int64 < 0) {
+        return Res::Err("Value must be a positive integer");
+    }
+    return {int64, Res::Ok()};
+}
+
 static ResVal<CAttributeValue> VerifyFloat(const std::string& str) {
     CAmount amount = 0;
     if (!ParseFixedPoint(str, 8, &amount) || amount < 0) {
@@ -191,6 +208,7 @@ const std::map<uint8_t, std::map<uint8_t,
                 {TokenKeys::LoanPaybackFeePCT,VerifyPct},
                 {TokenKeys::DexInFeePct,      VerifyPct},
                 {TokenKeys::DexOutFeePct,     VerifyPct},
+                {TokenKeys::DFIP2203Disabled, VerifyBool},
             }
         },
         {
@@ -201,9 +219,11 @@ const std::map<uint8_t, std::map<uint8_t,
         },
         {
             AttributeTypes::Param, {
-                {DFIP2201Keys::Active,       VerifyBool},
-                {DFIP2201Keys::Premium,      VerifyPct},
-                {DFIP2201Keys::MinSwap,      VerifyFloat},
+                {DFIPKeys::Active,       VerifyBool},
+                {DFIPKeys::Premium,      VerifyPct},
+                {DFIPKeys::MinSwap,      VerifyFloat},
+                {DFIPKeys::RewardPct,    VerifyPct},
+                {DFIPKeys::BlockPeriod,  VerifyPositiveInt64},
             }
         },
     };
@@ -282,6 +302,20 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value
 
     auto typeKey = itype->second;
 
+    if (type == AttributeTypes::Param) {
+        if (typeId == ParamIDs::DFIP2201) {
+            if (typeKey == DFIPKeys::RewardPct ||
+                typeKey == DFIPKeys::BlockPeriod) {
+                return Res::Err("Unsupported type for DFIP2201 {%d}", typeKey);
+            }
+        } else {
+            if (typeKey == DFIPKeys::Premium ||
+                typeKey == DFIPKeys::MinSwap) {
+                return Res::Err("Unsupported type for DFIP2203 {%d}", typeKey);
+            }
+        }
+    }
+
     CDataStructureV0 attrV0{type, typeId, typeKey};
 
     if (attrV0.IsExtendedSize()) {
@@ -375,8 +409,12 @@ UniValue ATTRIBUTES::Export() const {
             if (auto bool_val = boost::get<const bool>(&attribute.second)) {
                 ret.pushKV(key, *bool_val ? "true" : "false");
             } else if (auto amount = boost::get<const CAmount>(&attribute.second)) {
-                auto uvalue = ValueFromAmount(*amount);
-                ret.pushKV(key, KeyBuilder(uvalue.get_real()));
+                if (attrV0->typeId == DFIP2203 && attrV0->key == DFIPKeys::BlockPeriod) {
+                    ret.pushKV(key, KeyBuilder(*amount));
+                } else {
+                    auto uvalue = ValueFromAmount(*amount);
+                    ret.pushKV(key, KeyBuilder(uvalue.get_real()));
+                }
             } else if (auto balances = boost::get<const CBalances>(&attribute.second)) {
                 ret.pushKV(key, AmountsToJSON(balances->balances));
             } else if (auto paybacks = boost::get<const CTokenPayback>(&attribute.second)) {
@@ -432,6 +470,14 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
                             return Res::Err("No such token (%d)", attrV0->typeId);
                         }
                     break;
+                    case TokenKeys::DFIP2203Disabled:
+                        if (view.GetLastHeight() < Params().GetConsensus().FortCanningRoadHeight) {
+                            return Res::Err("Cannot be set before FortCanningRoad");
+                        }
+                        if (!view.GetLoanTokenByID(DCT_ID{attrV0->typeId})) {
+                            return Res::Err("No such loan token (%d)", attrV0->typeId);
+                        }
+                    break;
                     default:
                         return Res::Err("Unsupported key");
                 }
@@ -454,7 +500,11 @@ Res ATTRIBUTES::Validate(const CCustomCSView & view) const
             break;
 
             case AttributeTypes::Param:
-                if (attrV0->typeId != ParamIDs::DFIP2201) {
+                if (attrV0->typeId == ParamIDs::DFIP2203) {
+                    if (view.GetLastHeight() < Params().GetConsensus().FortCanningRoadHeight) {
+                        return Res::Err("Cannot be set before FortCanningRoad");
+                    }
+                } else if (attrV0->typeId != ParamIDs::DFIP2201) {
                     return Res::Err("Unrecognised param id");
                 }
             break;
diff --git a/src/masternodes/govvariables/attributes.h b/src/masternodes/govvariables/attributes.h
index f75f2f98e8c..ad549ebd658 100644
--- a/src/masternodes/govvariables/attributes.h
+++ b/src/masternodes/govvariables/attributes.h
@@ -22,18 +22,22 @@ enum AttributeTypes : uint8_t {
 
 enum ParamIDs : uint8_t  {
     DFIP2201  = 'a',
+    DFIP2203  = 'b',
     Economy   = 'e',
 };
 
 enum EconomyKeys : uint8_t {
     PaybackDFITokens = 'a',
     PaybackTokens    = 'b',
+    DFIP2203Tokens   = 'c',
 };
 
-enum DFIP2201Keys : uint8_t  {
-    Active    = 'a',
-    Premium   = 'b',
-    MinSwap   = 'c',
+enum DFIPKeys : uint8_t  {
+    Active       = 'a',
+    Premium      = 'b',
+    MinSwap      = 'c',
+    RewardPct    = 'd',
+    BlockPeriod  = 'e',
 };
 
 enum TokenKeys : uint8_t  {
@@ -43,6 +47,7 @@ enum TokenKeys : uint8_t  {
     LoanPaybackFeePCT   = 'd',
     DexInFeePct         = 'e',
     DexOutFeePct        = 'f',
+    DFIP2203Disabled    = 'g',
 };
 
 enum PoolKeys : uint8_t {
@@ -135,6 +140,12 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
         return std::move(value);
     }
 
+    template<typename K>
+    [[nodiscard]] bool CheckKey(const K& key) const {
+        static_assert(std::is_convertible_v<K, CAttributeType>);
+        return attributes.count(key) > 0;
+    }
+
     ADD_OVERRIDE_VECTOR_SERIALIZE_METHODS
     ADD_OVERRIDE_SERIALIZE_METHODS(CDataStream)
 
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 178dd486043..9c959707208 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -363,7 +363,7 @@ class CCustomCSView
             CFoundationsDebtView    ::  Debt,
             CAnchorRewardsView      ::  BtcTx,
             CTokensView             ::  ID, Symbol, CreationTx, LastDctId,
-            CAccountsView           ::  ByBalanceKey, ByHeightKey,
+            CAccountsView           ::  ByBalanceKey, ByHeightKey, ByFuturesKey,
             CCommunityBalancesView  ::  ById,
             CUndosView              ::  ByUndoKey,
             CPoolPairView           ::  ByID, ByPair, ByShare, ByIDPair, ByPoolSwap, ByReserves, ByRewardPct, ByRewardLoanPct,
@@ -371,7 +371,7 @@ class CCustomCSView
                                         ByPoolLoanReward, ByTokenDexFeePct,
             CGovView                ::  ByName, ByHeightVars,
             CAnchorConfirmsView     ::  BtcTx,
-            COracleView             ::  ByName, FixedIntervalBlockKey, FixedIntervalPriceKey, PriceDeviation,
+            COracleView             ::  ByName, FixedIntervalBlockKey, FixedIntervalPriceKey, PriceDeviation, FuturesPriceKey,
             CICXOrderView           ::  ICXOrderCreationTx, ICXMakeOfferCreationTx, ICXSubmitDFCHTLCCreationTx,
                                         ICXSubmitEXTHTLCCreationTx, ICXClaimDFCHTLCCreationTx, ICXCloseOrderCreationTx,
                                         ICXCloseOfferCreationTx, ICXOrderOpenKey, ICXOrderCloseKey, ICXMakeOfferOpenKey,
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 15863c04f40..4042d7ee4ab 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -49,6 +49,7 @@ std::string ToString(CustomTxType type) {
         case CustomTxType::AccountToAccount:    return "AccountToAccount";
         case CustomTxType::AnyAccountsToAccounts:   return "AnyAccountsToAccounts";
         case CustomTxType::SmartContract:       return "SmartContract";
+        case CustomTxType::DFIP2203:            return "DFIP2203";
         case CustomTxType::SetGovVariable:      return "SetGovVariable";
         case CustomTxType::SetGovVariableHeight:return "SetGovVariableHeight";
         case CustomTxType::AppointOracle:       return "AppointOracle";
@@ -131,6 +132,7 @@ CCustomTxMessage customTypeToMessage(CustomTxType txType) {
         case CustomTxType::AccountToAccount:        return CAccountToAccountMessage{};
         case CustomTxType::AnyAccountsToAccounts:   return CAnyAccountsToAccountsMessage{};
         case CustomTxType::SmartContract:           return CSmartContractMessage{};
+        case CustomTxType::DFIP2203:                return CDFIP2203Message{};
         case CustomTxType::SetGovVariable:          return CGovernanceMessage{};
         case CustomTxType::SetGovVariableHeight:    return CGovernanceHeightMessage{};
         case CustomTxType::AppointOracle:           return CAppointOracleMessage{};
@@ -347,6 +349,11 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
         return !res ? res : serialize(obj);
     }
 
+    Res operator()(CDFIP2203Message& obj) const {
+        auto res = isPostFortCanningRoadFork();
+        return !res ? res : serialize(obj);
+    }
+
     Res operator()(CCreatePoolPairMessage& obj) const {
         auto res = isPostBayfrontFork();
         if (!res) {
@@ -879,15 +886,17 @@ class CCustomTxVisitor : public boost::static_visitor<Res>
 class CCustomTxApplyVisitor : public CCustomTxVisitor
 {
     uint64_t time;
+    uint32_t txn;
 public:
     CCustomTxApplyVisitor(const CTransaction& tx,
                           uint32_t height,
                           const CCoinsViewCache& coins,
                           CCustomCSView& mnview,
                           const Consensus::Params& consensus,
-                          uint64_t time)
+                          uint64_t time,
+                          uint32_t txn)
 
-        : CCustomTxVisitor(tx, height, coins, mnview, consensus), time(time) {}
+        : CCustomTxVisitor(tx, height, coins, mnview, consensus), time(time), txn(txn) {}
 
     Res operator()(const CCreateMasterNodeMessage& obj) const {
         auto res = CheckMasternodeCreationTx();
@@ -1362,7 +1371,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!attributes)
             return Res::Err("Attributes unavailable");
 
-        CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIP2201Keys::Active};
+        CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIPKeys::Active};
 
         if (!attributes->GetValue(activeKey, false))
             return Res::Err("DFIP2201 smart contract is not enabled");
@@ -1386,7 +1395,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (amount <= 0)
             return Res::Err("Amount out of range");
 
-        CDataStructureV0 minSwapKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIP2201Keys::MinSwap};
+        CDataStructureV0 minSwapKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIPKeys::MinSwap};
         auto minSwap = attributes->GetValue(minSwapKey, CAmount{0});
 
         if (minSwap && amount < minSwap) {
@@ -1413,7 +1422,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         if (!resVal)
             return std::move(resVal);
 
-        CDataStructureV0 premiumKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIP2201Keys::Premium};
+        CDataStructureV0 premiumKey{AttributeTypes::Param, ParamIDs::DFIP2201, DFIPKeys::Premium};
         auto premium = attributes->GetValue(premiumKey, CAmount{2500000});
 
         const auto& btcPrice = MultiplyAmounts(*resVal.val, premium + COIN);
@@ -1452,6 +1461,101 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Err("Specified smart contract not found");
     }
 
+    Res operator()(const CDFIP2203Message& obj) const {
+        if (!HasAuth(obj.owner)) {
+            return Res::Err("Transaction must have at least one input from owner");
+        }
+
+        const auto attributes = mnview.GetAttributes();
+        if (!attributes) {
+            return Res::Err("Attributes unavailable");
+        }
+
+        CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::Active};
+        const auto active = attributes->GetValue(activeKey, false);
+        if (!active) {
+            return Res::Err("DFIP2203 not currently active");
+        }
+
+        CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::BlockPeriod};
+        CDataStructureV0 rewardKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::RewardPct};
+        if (!attributes->CheckKey(blockKey) || !attributes->CheckKey(rewardKey)) {
+            return Res::Err("DFIP2203 not currently active");
+        }
+
+        if (obj.source.nValue <= 0) {
+            return Res::Err("Source amount must be more than zero");
+        }
+
+        const auto source = mnview.GetLoanTokenByID(obj.source.nTokenId);
+        if (!source) {
+            return Res::Err("Could not get source loan token %d", obj.source.nTokenId.v);
+        }
+
+        if (source->symbol == "DUSD") {
+            CDataStructureV0 tokenKey{AttributeTypes::Token, obj.destination, TokenKeys::DFIP2203Disabled};
+            const auto disabled = attributes->GetValue(tokenKey, false);
+            if (disabled) {
+                return Res::Err("DFIP2203 currently disabled for token %d", obj.destination);
+            }
+
+            const auto loanToken = mnview.GetLoanTokenByID({obj.destination});
+            if (!loanToken) {
+                return Res::Err("Could not get destination loan token %d. Set valid destination.", obj.destination);
+            }
+
+            const auto res = mnview.GetFuturesPrices({obj.destination});
+            if (!res) {
+                return res;
+            }
+        } else {
+            if (obj.destination != 0) {
+                return Res::Err("Destination should not be set when source amount is a dToken");
+            }
+
+            CDataStructureV0 tokenKey{AttributeTypes::Token, obj.source.nTokenId.v, TokenKeys::DFIP2203Disabled};
+            const auto disabled = attributes->GetValue(tokenKey, false);
+            if (disabled) {
+                return Res::Err("DFIP2203 currently disabled for token %s", obj.source.nTokenId.ToString());
+            }
+
+            const auto res = mnview.GetFuturesPrices({obj.source.nTokenId});
+            if (!res) {
+                return res;
+            }
+        }
+
+        CScript contractAddress;
+        try {
+            contractAddress = Params().GetConsensus().smartContracts.at(SMART_CONTRACT_DFIP_2203);
+        } catch (const std::out_of_range&) {
+            return Res::Err("Failed to get smart contract address from chainparams");
+        }
+
+        CTxDestination dest;
+        ExtractDestination(contractAddress, dest);
+
+        auto res = TransferTokenBalance(obj.source.nTokenId, obj.source.nValue, obj.owner, contractAddress);
+        if (!res) {
+            return res;
+        }
+
+        res = mnview.StoreFuturesUserValues({height, obj.owner, txn}, {obj.source, obj.destination});
+        if (!res) {
+            return res;
+        }
+
+        CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Tokens};
+        auto balances = attributes->GetValue(liveKey, CBalances{});
+
+        balances.Add(CTokenAmount{obj.source.nTokenId, obj.source.nValue});
+        attributes->attributes[liveKey] = balances;
+
+        mnview.SetVariable(*attributes);
+
+        return Res::Ok();
+    }
+
     Res operator()(const CAnyAccountsToAccountsMessage& obj) const {
         // check auth
         for (const auto& kv : obj.from) {
@@ -3223,6 +3327,11 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
+    Res operator()(const CDFIP2203Message& obj) const {
+        EraseHistory(obj.owner);
+        return Res::Ok();
+    }
+
     Res operator()(const CAnyAccountsToAccountsMessage& obj) const {
         for (const auto& account : obj.to) {
             EraseHistory(account.first);
@@ -3428,12 +3537,12 @@ bool IsDisabledTx(uint32_t height, const CTransaction& tx, const Consensus::Para
     return IsDisabledTx(height, txType, consensus);
 }
 
-Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time) {
+Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time, uint32_t txn) {
     if (IsDisabledTx(height, tx, consensus)) {
         return Res::ErrCode(CustomTxErrCodes::Fatal, "Disabled custom transaction");
     }
     try {
-        return boost::apply_visitor(CCustomTxApplyVisitor(tx, height, coins, mnview, consensus, time), txMessage);
+        return boost::apply_visitor(CCustomTxApplyVisitor(tx, height, coins, mnview, consensus, time, txn), txMessage);
     } catch (const std::exception& e) {
         return Res::Err(e.what());
     } catch (...) {
@@ -3567,7 +3676,7 @@ Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
         if (pvaultHistoryDB && writers) {
            PopulateVaultHistoryData(writers, view, txMessage, txType, height, txn, tx.GetHash());
         }
-        res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time);
+        res = CustomTxVisit(view, coins, tx, height, consensus, txMessage, time, txn);
 
         // Track burn fee
         if (txType == CustomTxType::CreateToken || txType == CustomTxType::CreateMasternode) {
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index b2f48d3a45d..ae20060472d 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -67,6 +67,7 @@ enum class CustomTxType : uint8_t
     AccountToAccount      = 'B',
     AnyAccountsToAccounts = 'a',
     SmartContract         = 'K',
+    DFIP2203              = 'Q',
     //set governance variable
     SetGovVariable        = 'G',
     SetGovVariableHeight  = 'j',
@@ -126,6 +127,7 @@ inline CustomTxType CustomTxCodeToType(uint8_t ch) {
         case CustomTxType::AccountToAccount:
         case CustomTxType::AnyAccountsToAccounts:
         case CustomTxType::SmartContract:
+        case CustomTxType::DFIP2203:
         case CustomTxType::SetGovVariable:
         case CustomTxType::SetGovVariableHeight:
         case CustomTxType::AutoAuthPrep:
@@ -344,6 +346,7 @@ typedef boost::variant<
     CAccountToAccountMessage,
     CAnyAccountsToAccountsMessage,
     CSmartContractMessage,
+    CDFIP2203Message,
     CGovernanceMessage,
     CGovernanceHeightMessage,
     CAppointOracleMessage,
@@ -380,7 +383,7 @@ Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& type, UniValu
 Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage);
 Res ApplyCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height, uint64_t time = 0, uint32_t txn = 0, CHistoryWriters* writers = nullptr);
 Res RevertCustomTx(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, const Consensus::Params& consensus, uint32_t height,  uint32_t txn, CHistoryErasers& erasers);
-Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time = 0);
+Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time, uint32_t txn = 0);
 ResVal<uint256> ApplyAnchorRewardTx(CCustomCSView& mnview, const CTransaction& tx, int height, const uint256& prevStakeModifier, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
 ResVal<uint256> ApplyAnchorRewardTxPlus(CCustomCSView& mnview, const CTransaction& tx, int height, const std::vector<unsigned char>& metadata, const Consensus::Params& consensusParams);
 ResVal<CAmount> GetAggregatePrice(CCustomCSView& view, const std::string& token, const std::string& currency, uint64_t lastBlockTime);
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index 5b2a4320146..56764a9c7bf 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -7,6 +7,8 @@
 #include <base58.h>
 #include <policy/settings.h>
 
+#include <masternodes/govvariables/attributes.h>
+
 extern bool EnsureWalletIsAvailable(bool avoidException); // in rpcwallet.cpp
 extern bool DecodeHexTx(CTransaction& tx, std::string const& strHexTx); // in core_io.h
 
@@ -451,6 +453,30 @@ CWalletCoinsUnlocker GetWallet(const JSONRPCRequest& request) {
     return CWalletCoinsUnlocker{std::move(wallet)};
 }
 
+uint64_t GetFuturesBlockPeriod()
+{
+    LOCK(cs_main);
+
+    const auto attributes = pcustomcsview->GetAttributes();
+    if (!attributes) {
+        return 0;
+    }
+
+    CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::Active};
+    const auto active = attributes->GetValue(activeKey, false);
+    if (!active) {
+        return 0;
+    }
+
+    CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::BlockPeriod};
+    CDataStructureV0 rewardKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::RewardPct};
+    if (!attributes->CheckKey(blockKey) || !attributes->CheckKey(rewardKey)) {
+        return 0;
+    }
+
+    return attributes->GetValue(blockKey, CAmount{});
+}
+
 UniValue setgov(const JSONRPCRequest& request) {
     auto pwallet = GetWallet(request);
 
diff --git a/src/masternodes/mn_rpc.h b/src/masternodes/mn_rpc.h
index 51b32b43989..a775c15b5dd 100644
--- a/src/masternodes/mn_rpc.h
+++ b/src/masternodes/mn_rpc.h
@@ -61,5 +61,6 @@ CAccounts SelectAccountsByTargetBalances(const CAccounts& accounts, const CBalan
 void execTestTx(const CTransaction& tx, uint32_t height, CTransactionRef optAuthTx = {});
 CScript CreateScriptForHTLC(const JSONRPCRequest& request, uint32_t &blocks, std::vector<unsigned char>& image);
 CPubKey PublickeyFromString(const std::string &pubkey);
+uint64_t GetFuturesBlockPeriod();
 
 #endif // DEFI_MASTERNODES_MN_RPC_H
diff --git a/src/masternodes/oracles.cpp b/src/masternodes/oracles.cpp
index 44ea551b9d5..9127a84525d 100644
--- a/src/masternodes/oracles.cpp
+++ b/src/masternodes/oracles.cpp
@@ -152,6 +152,42 @@ Res COracleView::SetFixedIntervalPrice(const CFixedIntervalPrice& fixedIntervalP
     return Res::Ok();
 }
 
+Res COracleView::SetFuturesPrices(const DCT_ID id, const CFuturesPrice& price) {
+    if (!WriteBy<FuturesPriceKey>(id, price)) {
+        Res::Err("Failed to write futures prices for %d", id.ToString());
+    }
+
+    return Res::Ok();
+}
+
+ResVal<CFuturesPrice> COracleView::GetFuturesPrices(const DCT_ID id) {
+    CFuturesPrice prices{};
+    if (!ReadBy<FuturesPriceKey>(id, prices)) {
+        Res::Err("Failed to read futures prices for %d", id.ToString());
+    }
+
+    return {prices, Res::Ok()};
+}
+
+void COracleView::EraseAllFuturesPrices() {
+    std::set<DCT_ID> priceIds;
+    ForEachFuturesPrices([&](const DCT_ID id, const CFuturesPrice& price){
+        priceIds.insert(id);
+        return true;
+    });
+
+    for (const auto& id : priceIds) {
+        if (!EraseBy<FuturesPriceKey>(id)) {
+            LogPrintf("Failed to erase futures prices for %d\n", id.ToString());
+        }
+    }
+}
+
+void COracleView::ForEachFuturesPrices(std::function<bool(const DCT_ID id, const CFuturesPrice& price)> callback)
+{
+    ForEach<FuturesPriceKey, DCT_ID, CFuturesPrice>(callback);
+}
+
 ResVal<CFixedIntervalPrice> COracleView::GetFixedIntervalPrice(const CTokenCurrencyPair& fixedIntervalPriceId)
 {
     CFixedIntervalPrice fixedIntervalPrice;
diff --git a/src/masternodes/oracles.h b/src/masternodes/oracles.h
index 5920e626f0b..05dc8e11787 100644
--- a/src/masternodes/oracles.h
+++ b/src/masternodes/oracles.h
@@ -115,6 +115,20 @@ struct CFixedIntervalPrice
     }
 };
 
+struct CFuturesPrice
+{
+    CAmount discount;
+    CAmount premium;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(discount);
+        READWRITE(premium);
+    }
+};
+
 /// View for managing oracles and their data
 class COracleView : public virtual CStorageView
 {
@@ -150,10 +164,16 @@ class COracleView : public virtual CStorageView
     Res SetIntervalBlock(const uint32_t blockInterval);
     uint32_t GetIntervalBlock() const;
 
+    Res SetFuturesPrices(const DCT_ID id, const CFuturesPrice& price);
+    ResVal<CFuturesPrice> GetFuturesPrices(const DCT_ID id);
+    void ForEachFuturesPrices(std::function<bool(const DCT_ID id, const CFuturesPrice& price)> callback);
+    void EraseAllFuturesPrices();
+
     struct ByName { static constexpr uint8_t prefix() { return 'O'; } };
     struct PriceDeviation { static constexpr uint8_t prefix() { return 'Y'; } };
     struct FixedIntervalBlockKey { static constexpr uint8_t prefix() { return 'z'; } };
     struct FixedIntervalPriceKey { static constexpr uint8_t prefix() { return 'y'; } };
+    struct FuturesPriceKey { static constexpr uint8_t prefix() { return 's'; } };
 };
 
 #endif // DEFI_MASTERNODES_ORACLES_H
diff --git a/src/masternodes/res.h b/src/masternodes/res.h
index 97892f309e9..8e1514155a8 100644
--- a/src/masternodes/res.h
+++ b/src/masternodes/res.h
@@ -67,6 +67,16 @@ struct ResVal : public Res
         return *val;
     }
 
+    const T& operator*() const {
+        assert(ok);
+        return *val;
+    }
+
+    T& operator*() {
+        assert(ok);
+        return *val;
+    }
+
     template <typename F>
     T ValOrException(F&& func) const {
         if (!ok) {
diff --git a/src/masternodes/rpc_accounts.cpp b/src/masternodes/rpc_accounts.cpp
index 13e5b48f5d8..9fc8f98129a 100644
--- a/src/masternodes/rpc_accounts.cpp
+++ b/src/masternodes/rpc_accounts.cpp
@@ -1775,6 +1775,8 @@ UniValue getburninfo(const JSONRPCRequest& request) {
     CBalances dexfeeburn;
     CBalances paybackfees;
     CBalances paybacktokens;
+    CBalances dfi2203Tokens;
+
     UniValue dfipaybacktokens{UniValue::VARR};
 
     LOCK(cs_main);
@@ -1865,6 +1867,9 @@ UniValue getburninfo(const JSONRPCRequest& request) {
         auto paybacks = attributes->GetValue(liveKey, CTokenPayback{});
         paybackfees = std::move(paybacks.tokensFee);
         paybacktokens = std::move(paybacks.tokensPayback);
+
+        liveKey = {AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Tokens};
+        dfi2203Tokens = attributes->GetValue(liveKey, CBalances{});
     }
 
     result.pushKV("dfipaybackfee", ValueFromAmount(dfiPaybackFee));
@@ -1881,6 +1886,7 @@ UniValue getburninfo(const JSONRPCRequest& request) {
         }
     }
     result.pushKV("emissionburn", ValueFromAmount(burnt));
+    result.pushKV("dfip2203", AmountsToJSON(dfi2203Tokens.balances));
 
     return result;
 }
@@ -2025,6 +2031,231 @@ UniValue executesmartcontract(const JSONRPCRequest& request) {
     return NullUniValue;
 }
 
+UniValue futureswap(const JSONRPCRequest& request) {
+    auto pwallet = GetWallet(request);
+
+    RPCHelpMan{"futureswap",
+               "\nCreates and submits to the network a futures contract" +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Address to fund contract and receive resulting token"},
+                       {"amount", RPCArg::Type::STR, RPCArg::Optional::NO, "Amount to send in amount@token format"},
+                       {"destination", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "Expected dToken if DUSD supplied"},
+                       {"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("futureswap", "dLb2jq51qkaUbVkLyCiVQCoEHzRSzRPEsJ 1000@TSLA")
+                       + HelpExampleRpc("futureswap", "dLb2jq51qkaUbVkLyCiVQCoEHzRSzRPEsJ, 1000@TSLA")
+               },
+    }.Check(request);
+
+    if (pwallet->chain().isInitialBlockDownload()) {
+        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Cannot create transactions while still in Initial Block Download");
+    }
+    pwallet->BlockUntilSyncedToCurrentChain();
+
+    const auto dest = DecodeDestination(request.params[0].getValStr());
+    if (!IsValidDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+    }
+
+    CDFIP2203Message msg{};
+    msg.owner = GetScriptForDestination(dest);
+    msg.source = DecodeAmount(pwallet->chain(), request.params[1], "");
+
+    if (!request.params[2].isNull()) {
+        msg.destination = request.params[2].get_int();
+    }
+
+    // Encode
+    CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
+    metadata << static_cast<unsigned char>(CustomTxType::DFIP2203)
+             << msg;
+
+    CScript scriptMeta;
+    scriptMeta << OP_RETURN << ToByteVector(metadata);
+
+    int targetHeight = chainHeight(*pwallet->chain().lock()) + 1;
+
+    const auto txVersion = GetTransactionVersion(targetHeight);
+    CMutableTransaction rawTx(txVersion);
+
+    rawTx.vout.emplace_back(0, scriptMeta);
+
+    CTransactionRef optAuthTx;
+    std::set<CScript> auth{msg.owner};
+    rawTx.vin = GetAuthInputsSmart(pwallet, rawTx.nVersion, auth, false, optAuthTx, request.params[3]);
+
+    // Set change address
+    CCoinControl coinControl;
+    coinControl.destChange = dest;
+
+    // Fund
+    fund(rawTx, pwallet, optAuthTx, &coinControl);
+
+    // Check execution
+    execTestTx(CTransaction(rawTx), targetHeight, optAuthTx);
+
+    return signsend(rawTx, pwallet, optAuthTx)->GetHash().GetHex();
+}
+
+UniValue listpendingfutures(const JSONRPCRequest& request) {
+    RPCHelpMan{"listpendingfutures",
+               "Get all pending futures.\n",
+               {},
+               RPCResult{
+                       "\"json\"          (string) array containing json-objects having following fields:\n"
+                       "    owner :       \"address\"\n"
+                       "    values : [{\n"
+                       "        tokenSymbol : \"SYMBOL\"\n"
+                       "        amount :      n.nnnnnnnn\n"
+                       "        destination : \"SYMBOL\"\n"
+                       "    }...]\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listpendingfutures", "")
+               },
+    }.Check(request);
+
+    const auto blockPeriod = GetFuturesBlockPeriod();
+    if (blockPeriod == 0) {
+        return NullUniValue;
+    }
+
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+    const auto startPeriod = currentHeight - (currentHeight % blockPeriod);
+
+    UniValue listFutures{UniValue::VARR};
+    pcustomcsview->ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues){
+        if (key.height < startPeriod) {
+            return false;
+        }
+
+        CTxDestination dest;
+        ExtractDestination(key.owner, dest);
+        if (!IsValidDestination(dest)) {
+            return true;
+        }
+
+        const auto source = pcustomcsview->GetToken(futuresValues.source.nTokenId);
+        if (!source) {
+            return true;
+        }
+
+        UniValue value{UniValue::VOBJ};
+        value.pushKV("owner", EncodeDestination(dest));
+        value.pushKV("source", ValueFromAmount(futuresValues.source.nValue).getValStr() + '@' + source->symbol);
+
+        if (source->symbol == "DUSD") {
+            const auto destination = pcustomcsview->GetLoanTokenByID({futuresValues.destination});
+            if (!destination) {
+                return true;
+            }
+            value.pushKV("destination", destination->symbol);
+        } else {
+            value.pushKV("destination", "DUSD");
+        }
+
+        listFutures.push_back(value);
+
+        return true;
+    }, {std::numeric_limits<uint32_t>::max(), {}, std::numeric_limits<uint32_t>::max()});
+
+    return listFutures;
+}
+
+UniValue getpendingfutures(const JSONRPCRequest& request) {
+    RPCHelpMan{"getpendingfutures",
+               "Get specific pending futures.\n",
+                {
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Address to get futures prices for"},
+                },
+                RPCResult{
+                    "{\n"
+                    "    owner :       \"address\"\n"
+                    "    values : [{\n"
+                    "    tokenSymbol : \"SYMBOL\"\n"
+                    "    amount :      n.nnnnnnnn\n"
+                    "    destination : \"SYMBOL\"\n"
+                    "    }...]\n"
+                    "}\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("getpendingfutures", "address")
+               },
+    }.Check(request);
+
+    const auto blockPeriod = GetFuturesBlockPeriod();
+    if (blockPeriod == 0) {
+        return NullUniValue;
+    }
+
+    const auto owner = DecodeScript(request.params[0].get_str());
+
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+    const auto startPeriod = currentHeight - (currentHeight % blockPeriod);
+
+    std::vector<CFuturesUserValue> storedFutures;
+    pcustomcsview->ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues) {
+        if (key.height < startPeriod) {
+            return false;
+        }
+
+        if (key.owner == owner) {
+            storedFutures.push_back(futuresValues);
+        }
+
+        return true;
+    }, {static_cast<uint32_t>(currentHeight), owner, std::numeric_limits<uint32_t>::max()});
+
+
+    UniValue listValues{UniValue::VARR};
+    for (const auto& item : storedFutures) {
+        UniValue value{UniValue::VOBJ};
+
+        const auto source = pcustomcsview->GetToken(item.source.nTokenId);
+        if (!source) {
+            continue;
+        }
+
+        value.pushKV("source", ValueFromAmount(item.source.nValue).getValStr() + '@' + source->symbol);
+
+        if (source->symbol == "DUSD") {
+            const auto destination = pcustomcsview->GetLoanTokenByID({item.destination});
+            if (!destination) {
+                continue;
+            }
+            value.pushKV("destination", destination->symbol);
+        } else {
+            value.pushKV("destination", "DUSD");
+        }
+
+        listValues.push_back(value);
+    }
+
+    UniValue obj{UniValue::VOBJ};
+    obj.pushKV("owner", request.params[0].get_str());
+    obj.pushKV("values", listValues);
+    return obj;
+}
+
 
 static const CRPCCommand commands[] =
 {
@@ -2045,6 +2276,9 @@ static const CRPCCommand commands[] =
     {"accounts",    "sendtokenstoaddress",   &sendtokenstoaddress,   {"from", "to", "selectionMode"}},
     {"accounts",    "getburninfo",           &getburninfo,           {}},
     {"accounts",    "executesmartcontract",  &executesmartcontract,  {"name", "amount", "inputs"}},
+    {"accounts",    "futureswap",            &futureswap,            {"name", "amount", "destination", "inputs"}},
+    {"accounts",    "listpendingfutures",    &listpendingfutures,    {}},
+    {"accounts",    "getpendingfutures",     &getpendingfutures,     {"address"}},
 };
 
 void RegisterAccountsRPCCommands(CRPCTable& tableRPC) {
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index cd62635cb17..3fc802b6ddb 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -166,6 +166,18 @@ class CCustomTxRpcVisitor : public boost::static_visitor<void>
         rpcInfo.pushKV("accounts", accountsInfo(obj.accounts));
     }
 
+    void operator()(const CDFIP2203Message& obj) const {
+        CTxDestination dest;
+        if (ExtractDestination(obj.owner, dest)) {
+            rpcInfo.pushKV("owner", EncodeDestination(dest));
+        } else {
+            rpcInfo.pushKV("owner", "Invalid destination");
+        }
+
+        rpcInfo.pushKV("source", obj.source.ToString());
+        rpcInfo.pushKV("destination", std::to_string(obj.destination));
+    }
+
     void operator()(const CCreatePoolPairMessage& obj) const {
         rpcInfo.pushKV("creationTx", tx.GetHash().GetHex());
         if (auto tokenPair = mnview.GetTokenByCreationTx(tx.GetHash()))
diff --git a/src/masternodes/rpc_oracles.cpp b/src/masternodes/rpc_oracles.cpp
index 101c61781a6..32b8ad990cf 100644
--- a/src/masternodes/rpc_oracles.cpp
+++ b/src/masternodes/rpc_oracles.cpp
@@ -4,6 +4,8 @@
 
 #include <masternodes/mn_rpc.h>
 
+#include <masternodes/govvariables/attributes.h>
+
 extern CTokenCurrencyPair DecodePriceFeedUni(const UniValue& value);
 extern CTokenCurrencyPair DecodePriceFeedString(const std::string& value);
 /// names of oracle json fields
@@ -1124,7 +1126,106 @@ UniValue listfixedintervalprices(const JSONRPCRequest& request) {
     return listPrice;
 }
 
+UniValue listfutures(const JSONRPCRequest& request) {
+    RPCHelpMan{"listfutures",
+               "Get all futures prices.\n",
+               {},
+               RPCResult{
+                       "\"json\"          (string) array containing json-objects having following fields:\n"
+                       "    tokenSymbol : \"SYMBOL\"\n"
+                       "    discountPrice : n.nnnnnnnn\n"
+                       "    premiumPrice : n.nnnnnnnn\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listfutures", "")
+               },
+    }.Check(request);
+
+    LOCK(cs_main);
+
+    UniValue listPrice{UniValue::VARR};
+    pcustomcsview->ForEachFuturesPrices([&](const DCT_ID& id, const CFuturesPrice& futuresPrices){
+        const auto token = pcustomcsview->GetToken(id);
+        if (!token) {
+            return true;
+        }
+
+        UniValue obj{UniValue::VOBJ};
+        obj.pushKV("tokenSymbol", token->symbol);
+        obj.pushKV("discountPrice", ValueFromAmount(futuresPrices.discount));
+        obj.pushKV("premiumPrice", ValueFromAmount(futuresPrices.premium));
+        listPrice.push_back(obj);
+
+        return true;
+    });
+    return listPrice;
+}
+
+UniValue getfutures(const JSONRPCRequest& request) {
+    RPCHelpMan{"getfutures",
+               "Get specific futures prices.\n",
+               {
+                    {"tokenSymbol", RPCArg::Type::STR, RPCArg::Optional::NO, "Token symbol to get futures prices for"},
+               },
+               RPCResult{
+                       "{\n"
+                       "    tokenSymbol :   \"SYMBOL\"\n"
+                       "    discountPrice : n.nnnnnnnn\n"
+                       "    premiumPrice :  n.nnnnnnnn\n"
+                       "}\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("getfutures", "TSLA")
+               },
+    }.Check(request);
+
+    LOCK(cs_main);
+
+    const auto token = pcustomcsview->GetToken(request.params[0].get_str());
+    if (!token || !token->second) {
+        return NullUniValue;
+    }
+
+    // Limit to loan tokens
+    const auto loanToken = pcustomcsview->GetLoanTokenByID(token->first);
+    if (!loanToken) {
+        return NullUniValue;
+    }
+
+    const auto result = pcustomcsview->GetFuturesPrices(token->first);
+    if (!result) {
+        return NullUniValue;
+    }
+
+    UniValue obj{UniValue::VOBJ};
+    obj.pushKV("tokenSymbol", loanToken->symbol);
+    obj.pushKV("discountPrice", ValueFromAmount(result.val->discount));
+    obj.pushKV("premiumPrice", ValueFromAmount(result.val->premium));
+
+    return obj;
+}
+
 
+UniValue getfuturesblock(const JSONRPCRequest& request) {
+    RPCHelpMan{"getfuturesblock",
+               "Get the next block that futures will execute and update on.\n",
+               {},
+               RPCResult{
+                       "n    (numeric) Futures execution block. Zero if not set.\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("getfuturesblock", "")
+               },
+    }.Check(request);
+
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+
+    const auto blockPeriod = GetFuturesBlockPeriod();
+
+    return currentHeight + (blockPeriod - (currentHeight % blockPeriod));
+}
 
 
 
@@ -1143,6 +1244,9 @@ static const CRPCCommand commands[] =
     {"oracles",     "listprices",              &listprices,               {"pagination"}},
     {"oracles",     "getfixedintervalprice",   &getfixedintervalprice,    {"fixedIntervalPriceId"}},
     {"oracles",     "listfixedintervalprices", &listfixedintervalprices,  {"pagination"}},
+    {"oracles",     "getfutures",              &getfutures,               {"tokenSymbol"}},
+    {"oracles",     "listfutures",             &listfutures,              {}},
+    {"oracles",     "getfuturesblock",         &getfuturesblock,          {}},
 };
 
 void RegisterOraclesRPCCommands(CRPCTable& tableRPC) {
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 757b267d0a2..a76e8b7191c 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -215,6 +215,8 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "accounttoaccount", 2, "inputs" },
     { "accounttoutxos", 1, "to" },
     { "accounttoutxos", 2, "inputs" },
+    { "futureswap", 2, "destination"},
+    { "futureswap", 3, "inputs"},
 
     { "icx_createorder", 0, "order" },
     { "icx_createorder", 1, "inputs" },
diff --git a/src/validation.cpp b/src/validation.cpp
index 87fbdad52b0..06b3755290b 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -20,6 +20,7 @@
 #include <index/txindex.h>
 #include <masternodes/accountshistory.h>
 #include <masternodes/anchors.h>
+#include <masternodes/govvariables/attributes.h>
 #include <masternodes/govvariables/loan_daily_reward.h>
 #include <masternodes/govvariables/lp_daily_dfi_reward.h>
 #include <masternodes/masternodes.h>
@@ -2821,6 +2822,9 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
         ProcessOracleEvents(pindex, cache, chainparams);
         ProcessLoanEvents(pindex, cache, chainparams);
 
+        // Must be before set gov by height to clear futures in case there's a disabling of loan token in v3+
+        ProcessFutures(pindex, cache, chainparams);
+
         if (pindex->nHeight >= chainparams.GetConsensus().FortCanningHeight) {
             // Apply any pending GovVariable changes. Will come into effect on the next block.
             auto storedGovVars = cache.GetStoredVariables(static_cast<uint32_t>(pindex->nHeight));
@@ -3284,6 +3288,101 @@ void CChainState::ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& ca
     }
 }
 
+void CChainState::ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams)
+{
+    if (pindex->nHeight < chainparams.GetConsensus().FortCanningRoadHeight) {
+        return;
+    }
+
+    const auto attributes = cache.GetAttributes();
+    if (!attributes) {
+        return;
+    }
+
+    CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::Active};
+    const auto active = attributes->GetValue(activeKey, false);
+    if (!active) {
+        return;
+    }
+
+    CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::BlockPeriod};
+    CDataStructureV0 rewardKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::RewardPct};
+    if (!attributes->CheckKey(blockKey) || !attributes->CheckKey(rewardKey)) {
+        return;
+    }
+
+    const auto blockPeriod = attributes->GetValue(blockKey, CAmount{});
+    if (pindex->nHeight % blockPeriod != 0) {
+        return;
+    }
+
+    std::map<DCT_ID, CFuturesPrice> futuresPrices;
+    cache.ForEachFuturesPrices([&](const DCT_ID id, const CFuturesPrice& price) {
+        futuresPrices.emplace(id, price);
+        return true;
+    });
+
+    const uint32_t startHeight = pindex->nHeight - blockPeriod;
+    cache.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues){
+        if (key.height <= startHeight) {
+            return false;
+        }
+
+        const auto source = cache.GetLoanTokenByID(futuresValues.source.nTokenId);
+        assert(source);
+
+        if (source->symbol == "DUSD") {
+            const DCT_ID destId{futuresValues.destination};
+            const auto destToken = cache.GetLoanTokenByID(destId);
+            assert(destToken);
+
+            const auto& premiumPrice = futuresPrices.at(destId).premium;
+            const auto total = DivideAmounts(futuresValues.source.nValue, premiumPrice);
+            cache.AddBalance(key.owner, {destId, total});
+        } else {
+            const auto tokenDUSD = cache.GetToken("DUSD");
+            assert(tokenDUSD);
+
+            const auto& discountPrice = futuresPrices.at(futuresValues.source.nTokenId).discount;
+            const auto total = MultiplyAmounts(futuresValues.source.nValue, discountPrice);
+            cache.AddBalance(key.owner, {tokenDUSD->first, total});
+        }
+
+        return true;
+    }, {static_cast<uint32_t>(pindex->nHeight), {}, std::numeric_limits<uint32_t>::max()});
+
+    cache.EraseAllFuturesPrices();
+
+    const auto rewardPct = attributes->GetValue(rewardKey, CAmount{});
+    const auto discount{COIN - rewardPct};
+    const auto premium{COIN + rewardPct};
+
+    CDataStructureV0 tokenKey{AttributeTypes::Token, 0, TokenKeys::DFIP2203Disabled};
+    cache.ForEachLoanToken([&](const DCT_ID& id, const CLoanView::CLoanSetLoanTokenImpl& loanToken) {
+        tokenKey.typeId = id.v;
+        const auto disabled = attributes->GetValue(tokenKey, false);
+        if (disabled) {
+            return true;
+        }
+
+        const auto useNextPrice{false}, requireLivePrice{true};
+        const auto discountPrice = cache.GetAmountInCurrency(discount, loanToken.fixedIntervalPriceId, useNextPrice, requireLivePrice);
+        const auto premiumPrice = cache.GetAmountInCurrency(premium, loanToken.fixedIntervalPriceId, useNextPrice, requireLivePrice);
+        if (!discountPrice || !premiumPrice) {
+            return true;
+        }
+
+        const auto res = cache.SetFuturesPrices(id, {*discountPrice, *premiumPrice});
+        if (!res) {
+            LogPrintf("ProcessFutures(): Failed to set futures price for %s\n", id.ToString());
+        }
+
+        const auto result = cache.GetFuturesPrices(id);
+
+        return true;
+    });
+}
+
 void CChainState::ProcessOracleEvents(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams){
     if (pindex->nHeight < chainparams.GetConsensus().FortCanningHeight) {
         return;
diff --git a/src/validation.h b/src/validation.h
index 8bb4ed74b26..7d19b34f128 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -757,6 +757,8 @@ class CChainState {
     static void ProcessLoanEvents(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams);
 
     static void ProcessOracleEvents(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams);
+
+    static void ProcessFutures(const CBlockIndex* pindex, CCustomCSView& cache, const CChainParams& chainparams);
 };
 
 /** Mark a block as precious and reorganize.
diff --git a/test/functional/feature_futures.py b/test/functional/feature_futures.py
new file mode 100755
index 00000000000..b91adac7087
--- /dev/null
+++ b/test/functional/feature_futures.py
@@ -0,0 +1,497 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) DeFi Blockchain Developers
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+"""Test Futures's contract RPC."""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from decimal import Decimal
+import time
+
+class FuturesTest(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [['-txnotokens=0', '-amkheight=1', '-bayfrontheight=1', '-eunosheight=1', '-fortcanningheight=1', '-fortcanninghillheight=1', '-fortcanningroadheight=150', '-subsidytest=1']]
+
+    def run_test(self):
+        self.nodes[0].generate(101)
+
+        # Set up oracles and tokens
+        self.setup_test()
+
+        # Test setting of futures Gov vars
+        self.futures_setup()
+
+        # Test setting of futures prices
+        self.futures_pricing()
+
+        # Test dToken to DUSD
+        self.test_dtoken_to_dusd()
+
+        # Test DUSD to dToken
+        self.test_dusd_to_dtoken()
+
+        # Test futures block range
+        self.check_block_range()
+
+    def setup_test(self):
+
+        # Store address
+        self.address = self.nodes[0].get_genesis_keys().ownerAuthAddress
+
+        # Store interval
+        self.futures_interval = 50
+
+        # Setup oracle
+        oracle_address = self.nodes[0].getnewaddress("", "legacy")
+        price_feeds = [
+            {"currency": "USD", "token": "DFI"},
+            {"currency": "USD", "token": "TSLA"},
+            {"currency": "USD", "token": "GOOGL"},
+            {"currency": "USD", "token": "TWTR"},
+            {"currency": "USD", "token": "MSFT"},
+            {"currency": "USD", "token": "DOGE"},
+        ]
+        oracle_id = self.nodes[0].appointoracle(oracle_address, price_feeds, 10)
+        self.nodes[0].generate(1)
+
+        # Feed oracle
+        oracle_prices = [
+            {"currency": "USD", "tokenAmount": "870@TSLA"},
+            {"currency": "USD", "tokenAmount": "2600@GOOGL"},
+            {"currency": "USD", "tokenAmount": "37@TWTR"},
+            {"currency": "USD", "tokenAmount": "295@MSFT"},
+            {"currency": "USD", "tokenAmount": "0.09@DOGE"},
+        ]
+        self.nodes[0].setoracledata(oracle_id, int(time.time()), oracle_prices)
+        self.nodes[0].generate(10)
+
+        # Set token symbols
+        self.symbolDUSD  = 'DUSD'
+        self.symbolTSLA  = 'TSLA'
+        self.symbolGOOGL = 'GOOGL'
+        self.symbolTWTR  = 'TWTR'
+        self.symbolMSFT  = 'MSFT'
+        self.symbolDOGE  = 'DOGE'
+        self.symbolBTC   = 'BTC'
+
+        # Set up non-loan token for failure test
+        self.nodes[0].createtoken({
+            "symbol": self.symbolBTC,
+            "name": self.symbolBTC,
+            "isDAT": True,
+            "collateralAddress": self.address
+        })
+        self.nodes[0].generate(1)
+
+        # Setup loan tokens
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolDUSD,
+            'name': self.symbolDUSD,
+            'fixedIntervalPriceId': f'{self.symbolDUSD}/USD',
+            'mintable': True,
+            'interest': 0})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolTSLA,
+            'name': self.symbolTSLA,
+            'fixedIntervalPriceId': f'{self.symbolTSLA}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolGOOGL,
+            'name': self.symbolGOOGL,
+            'fixedIntervalPriceId': f'{self.symbolGOOGL}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolTWTR,
+            'name': self.symbolTWTR,
+            'fixedIntervalPriceId': f'{self.symbolTWTR}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolMSFT,
+            'name': self.symbolMSFT,
+            'fixedIntervalPriceId': f'{self.symbolMSFT}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        self.nodes[0].setloantoken({
+            'symbol': self.symbolDOGE,
+            'name': self.symbolDOGE,
+            'fixedIntervalPriceId': f'{self.symbolDOGE}/USD',
+            'mintable': True,
+            'interest': 1})
+        self.nodes[0].generate(1)
+
+        # Set token ids
+        self.idDUSD  = list(self.nodes[0].gettoken(self.symbolDUSD).keys())[0]
+        self.idTSLA  = list(self.nodes[0].gettoken(self.symbolTSLA).keys())[0]
+        self.idGOOGL = list(self.nodes[0].gettoken(self.symbolGOOGL).keys())[0]
+        self.idTWTR  = list(self.nodes[0].gettoken(self.symbolTWTR).keys())[0]
+        self.idMSFT  = list(self.nodes[0].gettoken(self.symbolMSFT).keys())[0]
+        self.idDOGE  = list(self.nodes[0].gettoken(self.symbolDOGE).keys())[0]
+        self.idBTC   = list(self.nodes[0].gettoken(self.symbolBTC).keys())[0]
+
+        # Mint tokens for swapping
+        self.nodes[0].minttokens([f'100000@{self.idDUSD}'])
+        self.nodes[0].minttokens([f'100000@{self.idTSLA}'])
+        self.nodes[0].minttokens([f'100000@{self.idGOOGL}'])
+        self.nodes[0].minttokens([f'100000@{self.idTWTR}'])
+        self.nodes[0].minttokens([f'100000@{self.idMSFT}'])
+        self.nodes[0].generate(1)
+
+    def futures_setup(self):
+
+        # Move to fork block
+        self.nodes[0].generate(150 - self.nodes[0].getblockcount())
+
+        # Create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Try futureswap before feature is active
+        assert_raises_rpc_error(-32600, "DFIP2203 not currently active", self.nodes[0].futureswap, address, f'1@{self.symbolTWTR}')
+
+        # Set partial futures attributes
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        self.nodes[0].generate(1)
+
+        # Try futureswap before feature is fully active
+        assert_raises_rpc_error(-32600, "DFIP2203 not currently active", self.nodes[0].futureswap, address, f'1@{self.symbolTWTR}')
+
+        # Set all futures attributes but set active to false
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'false','v0/params/dfip2203/reward_pct':'0.05','v0/params/dfip2203/block_period':f'{self.futures_interval}'}})
+        self.nodes[0].generate(1)
+
+        # Try futureswap with DFIP2203 active set to false
+        assert_raises_rpc_error(-32600, "DFIP2203 not currently active", self.nodes[0].futureswap, address, f'1@{self.symbolTWTR}')
+
+        # Fully enable DFIP2203
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        self.nodes[0].generate(1)
+
+        # Verify Gov vars
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result['v0/params/dfip2203/active'], 'true')
+        assert_equal(result['v0/params/dfip2203/reward_pct'], '0.05')
+        assert_equal(result['v0/params/dfip2203/block_period'], '50')
+
+    def futures_pricing(self):
+
+        # Check futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        assert_equal(next_futures_block, self.nodes[0].getfuturesblock())
+
+        # Futures should be empty
+        result = self.nodes[0].listfutures()
+        assert_equal(len(result), 0)
+
+        # Disable DOGE
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{str(self.idDOGE)}/dfip2203_disabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Move to next futures block
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Futures should now be populated excluding DOGE
+        result = self.nodes[0].listfutures()
+        assert_equal(len(result), 5)
+        assert_equal(result[0]['tokenSymbol'], self.symbolDUSD)
+        assert_equal(result[0]['discountPrice'], Decimal('0.95000000'))
+        assert_equal(result[0]['premiumPrice'], Decimal('1.05000000'))
+        assert_equal(result[1]['tokenSymbol'], self.symbolTSLA)
+        assert_equal(result[1]['discountPrice'], Decimal('826.50000000'))
+        assert_equal(result[1]['premiumPrice'], Decimal('913.50000000'))
+        assert_equal(result[2]['tokenSymbol'], self.symbolGOOGL)
+        assert_equal(result[2]['discountPrice'], Decimal('2470.00000000'))
+        assert_equal(result[2]['premiumPrice'], Decimal('2730.00000000'))
+        assert_equal(result[3]['tokenSymbol'], self.symbolTWTR)
+        assert_equal(result[3]['discountPrice'], Decimal('35.15000000'))
+        assert_equal(result[3]['premiumPrice'], Decimal('38.85000000'))
+        assert_equal(result[4]['tokenSymbol'], self.symbolMSFT)
+        assert_equal(result[4]['discountPrice'], Decimal('280.25000000'))
+        assert_equal(result[4]['premiumPrice'], Decimal('309.75000000'))
+
+        # Futures should now be populated
+        result = self.nodes[0].getfutures(self.symbolTSLA)
+        assert_equal(result['tokenSymbol'], self.symbolTSLA)
+        assert_equal(result['discountPrice'], Decimal('826.50000000'))
+        assert_equal(result['premiumPrice'], Decimal('913.50000000'))
+
+        # Disable DUSD
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{str(self.idDUSD)}/dfip2203_disabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Verify Gov vars
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result[f'v0/token/{self.idDUSD}/dfip2203_disabled'], 'true')
+
+        # Move to next futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Make sure that DUSD no longer is in futures prices result
+        result = self.nodes[0].listfutures()
+        assert_equal(len(result), 4)
+        for price in result:
+            assert(price['tokenSymbol'] != self.symbolDUSD)
+
+    def test_dtoken_to_dusd(self):
+
+        # Create addresses for futures
+        address_msft = self.nodes[0].getnewaddress("", "legacy")
+        address_googl = self.nodes[0].getnewaddress("", "legacy")
+        address_tsla = self.nodes[0].getnewaddress("", "legacy")
+        address_twtr = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_msft: f'1@{self.symbolMSFT}'})
+        self.nodes[0].accounttoaccount(self.address, {address_googl: f'1@{self.symbolGOOGL}'})
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'1@{self.symbolTSLA}'})
+        self.nodes[0].accounttoaccount(self.address, {address_twtr: f'1@{self.symbolTWTR}'})
+        self.nodes[0].generate(1)
+
+        # Test futureswap failures
+        assert_raises_rpc_error(-32600, f'Could not get source loan token {self.idBTC}', self.nodes[0].futureswap, self.address, f'1@{self.symbolBTC}')
+        assert_raises_rpc_error(-32600, f'DFIP2203 currently disabled for token {self.idDUSD}', self.nodes[0].futureswap, self.address, f'1@{self.symbolDUSD}', int(self.idDUSD))
+        assert_raises_rpc_error(-32600, f'Could not get destination loan token {self.idBTC}. Set valid destination.', self.nodes[0].futureswap, self.address, f'1@{self.symbolDUSD}', int(self.idBTC))
+        assert_raises_rpc_error(-32600, 'Destination should not be set when source amount is a dToken', self.nodes[0].futureswap, self.address, f'1@{self.symbolTSLA}', int(self.idBTC))
+        assert_raises_rpc_error(-32600, f'DFIP2203 currently disabled for token {self.idDOGE}', self.nodes[0].futureswap, self.address, f'1@{self.symbolDOGE}')
+        assert_raises_rpc_error(-32600, 'amount 0.00000000 is less than 1.00000000', self.nodes[0].futureswap, address_twtr, f'1@{self.symbolTSLA}')
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_twtr, f'1@{self.symbolTWTR}')
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_tsla, f'1@{self.symbolTSLA}')
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_googl, f'1@{self.symbolGOOGL}')
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_msft, f'1@{self.symbolMSFT}')
+        self.nodes[0].generate(1)
+
+        # List user futures contracts
+        result = self.nodes[0].listpendingfutures()
+        assert_equal(result[0]['owner'], address_msft)
+        assert_equal(result[0]['source'], f'{Decimal("1.00000000")}@{self.symbolMSFT}')
+        assert_equal(result[0]['destination'], self.symbolDUSD)
+        assert_equal(result[1]['owner'], address_googl)
+        assert_equal(result[1]['source'], f'{Decimal("1.00000000")}@{self.symbolGOOGL}')
+        assert_equal(result[1]['destination'], self.symbolDUSD)
+        assert_equal(result[2]['owner'], address_tsla)
+        assert_equal(result[2]['source'], f'{Decimal("1.00000000")}@{self.symbolTSLA}')
+        assert_equal(result[2]['destination'], self.symbolDUSD)
+        assert_equal(result[3]['owner'], address_twtr)
+        assert_equal(result[3]['source'], f'{Decimal("1.00000000")}@{self.symbolTWTR}')
+        assert_equal(result[3]['destination'], self.symbolDUSD)
+
+        # Get user MSFT futures swap by address
+        result = self.nodes[0].getpendingfutures(address_msft)
+        assert_equal(result['values'][0]['source'], f'{Decimal("1.00000000")}@{self.symbolMSFT}')
+        assert_equal(result['values'][0]['destination'], self.symbolDUSD)
+
+        # Get user GOOGL futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_googl)
+        assert_equal(result['values'][0]['source'], f'{Decimal("1.00000000")}@{self.symbolGOOGL}')
+        assert_equal(result['values'][0]['destination'], self.symbolDUSD)
+
+        # Get user TSLA futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_tsla)
+        assert_equal(result['values'][0]['source'], f'{Decimal("1.00000000")}@{self.symbolTSLA}')
+        assert_equal(result['values'][0]['destination'], self.symbolDUSD)
+
+        # Get user TWTR futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{Decimal("1.00000000")}@{self.symbolTWTR}')
+        assert_equal(result['values'][0]['destination'], self.symbolDUSD)
+
+        # Move to next futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Pending futures should now be empty
+        result = self.nodes[0].listpendingfutures()
+        assert_equal(len(result), 0)
+        result = self.nodes[0].getpendingfutures(address_msft)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_googl)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_tsla)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_twtr)
+        assert_equal(len(result['values']), 0)
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check DFI2203 address on listgovs
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert_equal(result['v0/live/economy/dfip_tokens'], [f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check DFI2203 address on getburninfo
+        result = self.nodes[0].getburninfo()
+        assert_equal(result['dfip2203'], [f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check that futures have been executed
+        result = self.nodes[0].getaccount(address_msft)
+        assert_equal(result, [f'280.25000000@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'2470.00000000@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'826.50000000@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_twtr)
+        assert_equal(result, [f'35.15000000@{self.symbolDUSD}'])
+
+    def test_dusd_to_dtoken(self):
+
+        # Create addresses for futures
+        address_tsla = self.nodes[0].getnewaddress("", "legacy")
+        address_twtr = self.nodes[0].getnewaddress("", "legacy")
+        address_googl = self.nodes[0].getnewaddress("", "legacy")
+        address_msft = self.nodes[0].getnewaddress("", "legacy")
+
+        # Get futures prices
+        prices = self.nodes[0].listfutures()
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'{prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_googl: f'{prices[1]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_twtr: f'{prices[2]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_msft: f'{prices[3]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_msft, f'{prices[3]["premiumPrice"]}@{self.symbolDUSD}', int(self.idMSFT))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_twtr, f'{prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_googl, f'{prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_tsla, f'{prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # List user futures contracts
+        result = self.nodes[0].listpendingfutures()
+        assert_equal(result[0]['owner'], address_tsla)
+        assert_equal(result[0]['source'], f'{prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[0]['destination'], self.symbolTSLA)
+        assert_equal(result[1]['owner'], address_googl)
+        assert_equal(result[1]['source'], f'{prices[1]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[1]['destination'], self.symbolGOOGL)
+        assert_equal(result[2]['owner'], address_twtr)
+        assert_equal(result[2]['source'], f'{prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[2]['destination'], self.symbolTWTR)
+        assert_equal(result[3]['owner'], address_msft)
+        assert_equal(result[3]['source'], f'{prices[3]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[3]['destination'], self.symbolMSFT)
+
+        # Get user MSFT futures swap by address
+        result = self.nodes[0].getpendingfutures(address_tsla)
+        assert_equal(result['values'][0]['source'], f'{prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTSLA)
+
+        # Get user GOOGL futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_googl)
+        assert_equal(result['values'][0]['source'], f'{prices[1]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolGOOGL)
+
+        # Get user TSLA futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+
+        # Get user TWTR futures contracts by address
+        result = self.nodes[0].getpendingfutures(address_msft)
+        assert_equal(result['values'][0]['source'], f'{prices[3]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolMSFT)
+
+        # Move to next futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Pending futures should now be empty
+        result = self.nodes[0].listpendingfutures()
+        assert_equal(len(result), 0)
+        result = self.nodes[0].getpendingfutures(address_msft)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_googl)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_tsla)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutures(address_twtr)
+        assert_equal(len(result['values']), 0)
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'3992.10000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check DFI2203 address on listgovs
+        result = self.nodes[0].listgovs()[8][0]['ATTRIBUTES']
+        assert_equal(result['v0/live/economy/dfip_tokens'], [f'3992.10000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check DFI2203 address on getburninfo
+        result = self.nodes[0].getburninfo()
+        assert_equal(result['dfip2203'], [f'3992.10000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Check that futures have been executed
+        result = self.nodes[0].getaccount(address_msft)
+        assert_equal(result, [f'1.00000000@{self.symbolMSFT}'])
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'1.00000000@{self.symbolGOOGL}'])
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'1.00000000@{self.symbolTSLA}'])
+        result = self.nodes[0].getaccount(address_twtr)
+        assert_equal(result, [f'1.00000000@{self.symbolTWTR}'])
+
+    def check_block_range(self):
+
+        # Create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Get futures prices
+        prices = self.nodes[0].listfutures()
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address: f'{prices[0]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Move to just before futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount() - 1)
+
+        # Create user futures contracts on futures block
+        self.nodes[0].futureswap(address, f'{prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Check that futures have been executed
+        result = self.nodes[0].getaccount(address)
+        assert_equal(result, [f'913.50000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}'])
+
+        # Move to just next futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval))
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Check that futures has not been executed again
+        result = self.nodes[0].getaccount(address)
+        assert_equal(result, [f'913.50000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'4905.60000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+if __name__ == '__main__':
+    FuturesTest().main()
diff --git a/test/functional/feature_setgov.py b/test/functional/feature_setgov.py
index ec4fce24ea3..f236afaf374 100755
--- a/test/functional/feature_setgov.py
+++ b/test/functional/feature_setgov.py
@@ -21,8 +21,8 @@ def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         self.extra_args = [
-            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1140', '-subsidytest=1'],
-            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1140', '-subsidytest=1']]
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-subsidytest=1'],
+            ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-eunosheight=200', '-fortcanningheight=400', '-fortcanninghillheight=1110', '-fortcanningroadheight=1150', '-subsidytest=1']]
 
 
     def run_test(self):
@@ -445,8 +445,8 @@ def run_test(self):
         assert_raises_rpc_error(-5, "Empty value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/15/payback_dfi':''}})
         assert_raises_rpc_error(-5, "Incorrect key for <type>. Object of ['<version>/<type>/ID/<key>','value'] expected", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/payback_dfi':'true'}})
         assert_raises_rpc_error(-5, "Unrecognised type argument provided, valid types are: params, poolpairs, token,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/unrecognised/5/payback_dfi':'true'}})
-        assert_raises_rpc_error(-5, "Unrecognised key argument provided, valid keys are: dex_in_fee_pct, dex_out_fee_pct, loan_payback, loan_payback_fee_pct, payback_dfi, payback_dfi_fee_pct,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/unrecognised':'true'}})
-        assert_raises_rpc_error(-5, "Identifier must be a positive integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/not_a_number/payback_dfi':'true'}})
+        assert_raises_rpc_error(-5, "Unrecognised key argument provided, valid keys are: dex_in_fee_pct, dex_out_fee_pct, dfip2203_disabled, loan_payback, loan_payback_fee_pct, payback_dfi, payback_dfi_fee_pct,", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/unrecognised':'true'}})
+        assert_raises_rpc_error(-5, "Value must be a positive integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/not_a_number/payback_dfi':'true'}})
         assert_raises_rpc_error(-5, 'Boolean value must be either "true" or "false"', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi':'not_a_number'}})
         assert_raises_rpc_error(-5, 'Boolean value must be either "true" or "false"', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi':'unrecognised'}})
         assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/payback_dfi_fee_pct':'not_a_number'}})
@@ -457,8 +457,16 @@ def run_test(self):
         assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/minswap':'not_a_number'}})
         assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/premium': 'not_a_number'}})
         assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/premium': '-1'}})
+        assert_raises_rpc_error(-5, "Unsupported type for DFIP2201", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/reward_pct': '0.1'}})
+        assert_raises_rpc_error(-5, "Unsupported type for DFIP2201", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/block_period': '2880'}})
         assert_raises_rpc_error(-5, "Percentage exceeds 100%", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2201/premium': '1.00000001'}})
 
+        # Check DFIP2203 attributes cannot be set before FCR
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before FortCanningRoad", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before FortCanningRoad", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'0.05'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before FortCanningRoad", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/block_period':'2880'}})
+        assert_raises_rpc_error(-32600, "ATTRIBUTES: Cannot be set before FortCanningRoad", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/dfip2203_disabled':'true'}})
+
         # Setup for loan related tests
         oracle_address = self.nodes[0].getnewaddress("", "legacy")
         appoint_oracle_tx = self.nodes[0].appointoracle(oracle_address, [{"currency": "USD", "token": "DFI"},{"currency": "USD", "token": "TSLA"}], 1)
@@ -523,6 +531,9 @@ def run_test(self):
         assert_equal(self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES'], {'v0/params/dfip2201/active': 'true', 'v0/params/dfip2201/premium': '0.025', 'v0/params/dfip2201/minswap': '0.001', 'v0/token/5/payback_dfi': 'true', 'v0/token/5/payback_dfi_fee_pct': '0.01'})
         assert_equal(self.nodes[0].listgovs()[8][0]['ATTRIBUTES'], {'v0/params/dfip2201/active': 'true', 'v0/params/dfip2201/premium': '0.025', 'v0/params/dfip2201/minswap': '0.001', 'v0/token/5/payback_dfi': 'true', 'v0/token/5/payback_dfi_fee_pct': '0.01'})
 
+        # Move to FCR fork
+        self.nodes[0].generate(1150 - self.nodes[0].getblockcount())
+
         self.nodes[0].setgov({"ATTRIBUTES":{'v0/token/5/loan_payback/1': 'true', 'v0/token/5/loan_payback/2': 'true', 'v0/token/5/loan_payback_fee_pct/1': '0.25'}})
         self.nodes[0].generate(1)
         attributes = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
@@ -548,5 +559,32 @@ def run_test(self):
         assert_equal(attributes['v0/token/5/dex_in_fee_pct'], '0.6')
         assert_equal(attributes['v0/token/5/dex_out_fee_pct'], '0.12')
 
+        # Set FCR ATTRIBUTE with invalid settings
+        assert_raises_rpc_error(-5, "Boolean value must be either \"true\" or \"false\"", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/active':'not_a_bool'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'not_a_number'}})
+        assert_raises_rpc_error(-5, "Amount must be a positive value", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'-1'}})
+        assert_raises_rpc_error(-5, "Percentage exceeds 100%", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'2'}})
+        assert_raises_rpc_error(-5, "Value must be a positive integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/block_period':'not_a_number'}})
+        assert_raises_rpc_error(-5, "Value must be a positive integer", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/block_period':'-1'}})
+        assert_raises_rpc_error(-5, "Boolean value must be either \"true\" or \"false\"", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/5/dfip2203_disabled':'not_a_bool'}})
+        assert_raises_rpc_error(-32600, "No such loan token", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/token/4/dfip2203_disabled':'true'}})
+        assert_raises_rpc_error(-5, "Unsupported type for DFIP2203", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/premium': '0.025'}})
+        assert_raises_rpc_error(-5, "Unsupported type for DFIP2203", self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/minswap': '0.025'}})
+
+        # Test setting FCR ATTRBIUTES
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/reward_pct':'0.05'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/block_period':'20160'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/token/5/dfip2203_disabled':'true'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true','v0/params/dfip2203/reward_pct':'0.05','v0/params/dfip2203/block_period':'20160','v0/token/5/dfip2203_disabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Verify FCR results
+        result = self.nodes[0].getgov('ATTRIBUTES')['ATTRIBUTES']
+        assert_equal(result['v0/params/dfip2203/active'], 'true')
+        assert_equal(result['v0/params/dfip2203/reward_pct'], '0.05')
+        assert_equal(result['v0/params/dfip2203/block_period'], '20160')
+        assert_equal(result['v0/token/5/dfip2203_disabled'], 'true')
+
 if __name__ == '__main__':
     GovsetTest ().main ()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 6cb085ed407..2114591eed4 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -125,6 +125,7 @@
     'feature_communitybalance_reorg.py',
     'feature_auth_return_change.py',
     'feature_setgov.py',
+    'feature_futures.py',
     'interface_zmq.py',
     'feature_restore_utxo.py',
     'interface_defi_cli.py',
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index dfe6a53efd2..354c4a8cb3e 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -35,6 +35,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "chainparams -> masternodes/mn_checks -> masternodes/vaulthistory -> masternodes/vault -> chainparams"
     "consensus/tx_verify -> masternodes/masternodes -> validation -> consensus/tx_verify"
     "consensus/tx_verify -> masternodes/mn_checks -> txmempool -> consensus/tx_verify"
+    "masternodes/govvariables/attributes -> masternodes/masternodes -> validation -> masternodes/govvariables/attributes"
     "masternodes/govvariables/attributes -> masternodes/gv -> masternodes/govvariables/attributes"
     "masternodes/govvariables/icx_takerfee_per_btc -> masternodes/gv -> masternodes/govvariables/icx_takerfee_per_btc"
     "masternodes/govvariables/loan_daily_reward -> masternodes/gv -> masternodes/govvariables/loan_daily_reward"