diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 3e6666ffa2..f81339d04a 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 2ec2c0d662..1e0c243cce 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/logging.cpp b/src/logging.cpp
index 367f898151..529af630a3 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -155,6 +155,7 @@ const CLogCategoryDesc LogCategories[] =
     {BCLog::ORACLE, "oracle"},
     {BCLog::LOAN, "loan"},
     {BCLog::ACCOUNTCHANGE, "accountchange"},
+    {BCLog::FUTURESWAP, "futureswap"},
     {BCLog::ALL, "1"},
     {BCLog::ALL, "all"},
 };
diff --git a/src/logging.h b/src/logging.h
index c1034a1f20..7125f829a1 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -61,6 +61,7 @@ namespace BCLog {
         ORACLE        = (1 << 24),
         LOAN          = (1 << 25),
         ACCOUNTCHANGE = (1 << 26),
+        FUTURESWAP    = (1 << 27),
         ALL           = ~(uint32_t)0,
     };
 
diff --git a/src/masternodes/accounts.cpp b/src/masternodes/accounts.cpp
index 1644b9d441..2b79fb5368 100644
--- a/src/masternodes/accounts.cpp
+++ b/src/masternodes/accounts.cpp
@@ -98,3 +98,60 @@ 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<ByFuturesSourceKey>(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<ByFuturesSourceKey, CFuturesUserKey, CFuturesUserValue>(callback, start);
+}
+
+Res CAccountsView::EraseFuturesUserValues(const CFuturesUserKey& key)
+{
+    if (!EraseBy<ByFuturesSourceKey>(key)) {
+        return Res::Err("Failed to erase futures");
+    }
+
+    return Res::Ok();
+}
+
+boost::optional<uint32_t> CAccountsView::GetMostRecentFuturesHeight()
+{
+    const CFuturesUserKey key{std::numeric_limits<uint32_t>::max(), {}, std::numeric_limits<uint32_t>::max()};
+    auto it = LowerBound<ByFuturesSourceKey>(key);
+    if (it.Valid()) {
+        return it.Key().height;
+    }
+
+    return {};
+}
+
+Res CAccountsView::StoreFuturesDestValues(const CFuturesUserKey& key, const CFuturesUserValue& destination)
+{
+    if (!WriteBy<ByFuturesDestKey>(key, destination)) {
+        return Res::Err("Failed to store futures destination");
+    }
+
+    return Res::Ok();
+}
+
+ResVal<CFuturesUserValue> CAccountsView::GetFuturesUserValues(const CFuturesUserKey& key) {
+    CFuturesUserValue source;
+    if (!ReadBy<ByFuturesSourceKey>(key, source)) {
+        return Res::Err("Failed to read futures source");
+    }
+
+    return {source, Res::Ok()};
+}
+
+void CAccountsView::ForEachFuturesDestValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start)
+{
+    ForEach<ByFuturesDestKey, CFuturesUserKey, CFuturesUserValue>(callback, start);
+}
diff --git a/src/masternodes/accounts.h b/src/masternodes/accounts.h
index c9d3a9555e..fe259f17c5 100644
--- a/src/masternodes/accounts.h
+++ b/src/masternodes/accounts.h
@@ -11,6 +11,48 @@
 #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_));
+        }
+    }
+
+    bool operator<(const CFuturesUserKey& o) const {
+        return std::tie(height, owner, txn) < std::tie(o.height, o.owner, o.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 +69,19 @@ 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);
+    Res StoreFuturesDestValues(const CFuturesUserKey& key, const CFuturesUserValue& destination);
+    ResVal<CFuturesUserValue> GetFuturesUserValues(const CFuturesUserKey& key);
+    Res EraseFuturesUserValues(const CFuturesUserKey& key);
+    boost::optional<uint32_t> GetMostRecentFuturesHeight();
+    void ForEachFuturesUserValues(std::function<bool(const CFuturesUserKey&, const CFuturesUserValue&)> callback, const CFuturesUserKey& start = {});
+    void ForEachFuturesDestValues(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 ByFuturesSourceKey  { static constexpr uint8_t prefix() { return 'J'; } };
+    struct ByFuturesDestKey  { static constexpr uint8_t prefix() { return 's'; } };
 
 private:
     Res SetBalance(CScript const & owner, CTokenAmount amount);
diff --git a/src/masternodes/balances.h b/src/masternodes/balances.h
index 64b3539d45..ba815223c8 100644
--- a/src/masternodes/balances.h
+++ b/src/masternodes/balances.h
@@ -224,6 +224,23 @@ struct CSmartContractMessage {
     }
 };
 
+struct CFutureSwapMessage {
+    CScript owner;
+    CTokenAmount source{};
+    uint32_t destination{};
+    bool withdraw{};
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(owner);
+        READWRITE(source);
+        READWRITE(destination);
+        READWRITE(withdraw);
+    }
+};
+
 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 3dd7c6cc93..383908f825 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> VerifyInt64(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,15 +219,27 @@ 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,  VerifyInt64},
             }
         },
     };
     return parsers;
 }
 
+ResVal<CScript> GetFutureSwapContractAddress() {
+    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");
+    }
+    return {contractAddress, Res::Ok()};
+}
+
 static Res ShowError(const std::string& key, const std::map<std::string, uint8_t>& keys) {
     std::string error{"Unrecognised " + key + " argument provided, valid " + key + "s are:"};
     for (const auto& pair : keys) {
@@ -219,7 +249,7 @@ static Res ShowError(const std::string& key, const std::map<std::string, uint8_t
 }
 
 Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value,
-                                std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable) const {
+                                std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable) {
 
     if (key.size() > 128) {
         return Res::Err("Identifier exceeds maximum length (128)");
@@ -282,6 +312,26 @@ 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 (typeId == ParamIDs::DFIP2203) {
+            if (typeKey == DFIPKeys::Premium ||
+                typeKey == DFIPKeys::MinSwap) {
+                return Res::Err("Unsupported type for DFIP2203 {%d}", typeKey);
+            }
+
+            if (typeKey == DFIPKeys::BlockPeriod) {
+                futureBlockUpdated = true;
+            }
+        } else {
+            return Res::Err("Unsupported Param ID");
+        }
+    }
+
     CDataStructureV0 attrV0{type, typeId, typeKey};
 
     if (attrV0.IsExtendedSize()) {
@@ -312,6 +362,65 @@ Res ATTRIBUTES::ProcessVariable(const std::string& key, const std::string& value
     return Res::Err("No parse function {%d, %d}", type, typeKey);
 }
 
+Res ATTRIBUTES::RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID)
+{
+    CDataStructureV0 blockKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::BlockPeriod};
+    const auto blockPeriod = GetValue(blockKey, CAmount{});
+    if (blockPeriod == 0) {
+        return Res::Ok();
+    }
+
+    const uint32_t startHeight = height - (height % blockPeriod);
+    std::map<CFuturesUserKey, CFuturesUserValue> userFuturesValues;
+
+    mnview.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues) {
+        if (key.height <= startHeight) {
+            return false;
+        }
+
+        if (tokenID != std::numeric_limits<uint32_t>::max()) {
+            if (futuresValues.source.nTokenId.v == tokenID || futuresValues.destination == tokenID) {
+                userFuturesValues[key] = futuresValues;
+            }
+        } else {
+            userFuturesValues[key] = futuresValues;
+        }
+
+        return true;
+    }, {height, {}, std::numeric_limits<uint32_t>::max()});
+
+    const auto contractAddressValue = GetFutureSwapContractAddress();
+    if (!contractAddressValue) {
+        return contractAddressValue;
+    }
+
+    CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Tokens};
+    auto balances = GetValue(liveKey, CBalances{});
+
+    for (const auto& [key, value] : userFuturesValues) {
+        mnview.EraseFuturesUserValues(key);
+
+        auto res = mnview.SubBalance(*contractAddressValue, value.source);
+        if (!res) {
+            return res;
+        }
+
+        res = mnview.AddBalance(key.owner, value.source);
+        if (!res) {
+            return res;
+        }
+
+        res = balances.Sub(value.source);
+        if (!res) {
+            return res;
+        }
+    }
+
+    attributes[liveKey] = balances;
+
+    return Res::Ok();
+}
+
 Res ATTRIBUTES::Import(const UniValue & val) {
     if (!val.isObject()) {
         return Res::Err("Object of values expected");
@@ -375,8 +484,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 +545,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 +575,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;
@@ -503,7 +628,73 @@ Res ATTRIBUTES::Apply(CCustomCSView & mnview, const uint32_t height)
                     return res;
                 }
             }
+            if (attrV0->key == TokenKeys::DFIP2203Disabled) {
+
+                // Skip on block period change to avoid refunding and erasing entries.
+                // Block period change will check for conflicting entries, deleting them
+                // via RefundFuturesContracts will fail that check.
+                if (futureBlockUpdated) {
+                    continue;
+                }
+
+                const auto token = mnview.GetLoanTokenByID(DCT_ID{attrV0->typeId});
+                if (!token) {
+                    return Res::Err("No such loan token (%d)", attrV0->typeId);
+                }
+
+                // Special case: DUSD will be used as a source for swaps but will
+                // be set as disabled for Future swap destination.
+                if (token->symbol == "DUSD") {
+                    continue;
+                }
+
+                auto res = RefundFuturesContracts(mnview, height, attrV0->typeId);
+                if (!res) {
+                    return res;
+                }
+            }
+        } else if (attrV0->type == AttributeTypes::Param && attrV0->typeId == ParamIDs::DFIP2203) {
+            if (attrV0->key == DFIPKeys::Active) {
+
+                // Skip on block period change to avoid refunding and erasing entries.
+                // Block period change will check for conflicting entries, deleting them
+                // via RefundFuturesContracts will fail that check.
+                if (futureBlockUpdated) {
+                    continue;
+                }
+
+                auto value = boost::get<bool>(attribute.second);
+                if (value) {
+                    continue;
+                }
+
+                auto res = RefundFuturesContracts(mnview, height);
+                if (!res) {
+                    return res;
+                }
+
+            } else if (attrV0->key == DFIPKeys::BlockPeriod) {
+
+                // Only check this when block period has been set, otherwise
+                // it will fail when DFIP2203 active is set to true.
+                if (!futureBlockUpdated) {
+                    continue;
+                }
+
+                CDataStructureV0 activeKey{AttributeTypes::Param, ParamIDs::DFIP2203, DFIPKeys::Active};
+                if (GetValue(activeKey, false)) {
+                    return Res::Err("Cannot set block period while DFIP2203 is active");
+                }
+
+                auto blockPeriod = boost::get<CAmount>(attribute.second);
+                const auto recentFuturesHeight = mnview.GetMostRecentFuturesHeight();
+
+                if (recentFuturesHeight && *recentFuturesHeight > height - (height % blockPeriod)) {
+                    return Res::Err("Historical Futures contracts in this period");
+                }
+            }
         }
     }
+
     return Res::Ok();
 }
diff --git a/src/masternodes/govvariables/attributes.h b/src/masternodes/govvariables/attributes.h
index f75f2f98e8..f7f32ec4db 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 {
@@ -104,6 +109,8 @@ struct CTokenPayback {
     }
 };
 
+ResVal<CScript> GetFutureSwapContractAddress();
+
 using CAttributeType = boost::variant<CDataStructureV0, CDataStructureV1>;
 using CAttributeValue = boost::variant<bool, CAmount, CBalances, CTokenPayback>;
 
@@ -125,7 +132,7 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
     static GovVariable * Create() { return new ATTRIBUTES(); }
 
     template<typename T>
-    T GetValue(const CAttributeType& key, T value) {
+    [[nodiscard]] T GetValue(const CAttributeType& key, T value) const {
         auto it = attributes.find(key);
         if (it != attributes.end()) {
             if (auto val = boost::get<const T>(&it->second)) {
@@ -135,6 +142,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)
 
@@ -146,6 +159,8 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
     std::map<CAttributeType, CAttributeValue> attributes;
 
 private:
+    bool futureBlockUpdated{};
+
     // Defined allowed arguments
     static const std::map<std::string, uint8_t>& allowedVersions();
     static const std::map<std::string, uint8_t>& allowedTypes();
@@ -161,7 +176,8 @@ class ATTRIBUTES : public GovVariable, public AutoRegistrator<GovVariable, ATTRI
     static const std::map<uint8_t, std::map<uint8_t, std::string>>& displayKeys();
 
     Res ProcessVariable(const std::string& key, const std::string& value,
-                        std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable) const;
+                        std::function<Res(const CAttributeType&, const CAttributeValue&)> applyVariable);
+    Res RefundFuturesContracts(CCustomCSView &mnview, const uint32_t height, const uint32_t tokenID = std::numeric_limits<uint32_t>::max());
 };
 
 #endif // DEFI_MASTERNODES_GOVVARIABLES_ATTRIBUTES_H
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 178dd48604..b352d52913 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, ByFuturesSourceKey, ByFuturesDestKey,
             CCommunityBalancesView  ::  ById,
             CUndosView              ::  ByUndoKey,
             CPoolPairView           ::  ByID, ByPair, ByShare, ByIDPair, ByPoolSwap, ByReserves, ByRewardPct, ByRewardLoanPct,
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 15863c04f4..e2743d8bb7 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 CFutureSwapMessage{};
         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()(CFutureSwapMessage& 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,137 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         return Res::Err("Specified smart contract not found");
     }
 
+    Res operator()(const CFutureSwapMessage& 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);
+            }
+        } 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 contractAddressValue = GetFutureSwapContractAddress();
+        if (!contractAddressValue) {
+            return contractAddressValue;
+        }
+
+        CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Tokens};
+        auto balances = attributes->GetValue(liveKey, CBalances{});
+
+        if (obj.withdraw) {
+            const auto blockPeriod = attributes->GetValue(blockKey, CAmount{});
+            const uint32_t startHeight = height - (height % blockPeriod);
+            std::map<CFuturesUserKey, CFuturesUserValue> userFuturesValues;
+
+            mnview.ForEachFuturesUserValues([&](const CFuturesUserKey& key, const CFuturesUserValue& futuresValues) {
+                if (key.height <= startHeight) {
+                    return false;
+                }
+
+                if (key.owner == obj.owner &&
+                    futuresValues.source.nTokenId == obj.source.nTokenId &&
+                    futuresValues.destination == obj.destination) {
+                    userFuturesValues[key] = futuresValues;
+                }
+
+                return true;
+            }, {height, obj.owner, std::numeric_limits<uint32_t>::max()});
+
+            CTokenAmount totalFutures{};
+            totalFutures.nTokenId = obj.source.nTokenId;
+
+            for (const auto& [key, value] : userFuturesValues) {
+                totalFutures.Add(value.source.nValue);
+                mnview.EraseFuturesUserValues(key);
+            }
+
+            auto res = totalFutures.Sub(obj.source.nValue);
+            if (!res) {
+                return res;
+            }
+
+            if (totalFutures.nValue > 0) {
+                auto res = mnview.StoreFuturesUserValues({height, obj.owner, txn}, {totalFutures, obj.destination});
+                if (!res) {
+                    return res;
+                }
+            }
+
+            res = TransferTokenBalance(obj.source.nTokenId, obj.source.nValue, *contractAddressValue, obj.owner);
+            if (!res) {
+                return res;
+            }
+
+            res = balances.Sub(obj.source);
+            if (!res) {
+                return res;
+            }
+        } else {
+            auto res = TransferTokenBalance(obj.source.nTokenId, obj.source.nValue, obj.owner, *contractAddressValue);
+            if (!res) {
+                return res;
+            }
+
+            res = mnview.StoreFuturesUserValues({height, obj.owner, txn}, {obj.source, obj.destination});
+            if (!res) {
+                return res;
+            }
+
+            balances.Add(obj.source);
+        }
+
+        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 +3363,11 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
         return Res::Ok();
     }
 
+    Res operator()(const CFutureSwapMessage& 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 +3573,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 +3712,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 b2f48d3a45..298c3197c4 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,
+    CFutureSwapMessage,
     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 5b2a432014..d8de7e82d6 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)};
 }
 
+std::optional<std::pair<CAmount, CAmount>> GetFuturesBlockAndReward()
+{
+    LOCK(cs_main);
+
+    const auto attributes = pcustomcsview->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 {};
+    }
+
+    return std::pair{attributes->GetValue(blockKey, CAmount{}), attributes->GetValue(rewardKey, 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 51b32b4398..67cc490017 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);
+std::optional<std::pair<CAmount, CAmount>> GetFuturesBlockAndReward();
 
 #endif // DEFI_MASTERNODES_MN_RPC_H
diff --git a/src/masternodes/oracles.h b/src/masternodes/oracles.h
index 5920e626f0..acce6e1315 100644
--- a/src/masternodes/oracles.h
+++ b/src/masternodes/oracles.h
@@ -115,6 +115,12 @@ struct CFixedIntervalPrice
     }
 };
 
+struct CFuturesPrice
+{
+    CAmount discount;
+    CAmount premium;
+};
+
 /// View for managing oracles and their data
 class COracleView : public virtual CStorageView
 {
diff --git a/src/masternodes/res.h b/src/masternodes/res.h
index 97892f309e..8e1514155a 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 13e5b48f5d..646e3be307 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,483 @@ 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")
+                       + HelpExampleCli("futureswap", "dLb2jq51qkaUbVkLyCiVQCoEHzRSzRPEsJ 1000@DUSD TSLA")
+                       + HelpExampleRpc("futureswap", "dLb2jq51qkaUbVkLyCiVQCoEHzRSzRPEsJ, 1000@TSLA")
+                       + HelpExampleRpc("futureswap", "dLb2jq51qkaUbVkLyCiVQCoEHzRSzRPEsJ, 1000@DUSD, 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");
+    }
+
+    CFutureSwapMessage 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 withdrawfutureswap(const JSONRPCRequest& request) {
+    auto pwallet = GetWallet(request);
+
+    RPCHelpMan{"withdrawfutureswap",
+               "\nCreates and submits to the network a withdrawl from futures contract transaction.\n"
+               " Withdrawal will be back to the address specified in the futures contract." +
+               HelpRequiringPassphrase(pwallet) + "\n",
+               {
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Address used to fund contract with"},
+                       {"amount", RPCArg::Type::STR, RPCArg::Optional::NO, "Amount to withdraw in amount@token format"},
+                       {"destination", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "The 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");
+    }
+
+    CFutureSwapMessage msg{};
+    msg.owner = GetScriptForDestination(dest);
+    msg.source = DecodeAmount(pwallet->chain(), request.params[1], "");
+    msg.withdraw = true;
+
+    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 listpendingfutureswaps(const JSONRPCRequest& request) {
+    RPCHelpMan{"listpendingfutureswaps",
+               "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("listpendingfutureswaps", "")
+               },
+    }.Check(request);
+
+    UniValue listFutures{UniValue::VARR};
+    const auto blockAndReward = GetFuturesBlockAndReward();
+    if (!blockAndReward) {
+        return listFutures;
+    }
+
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+    const auto startPeriod = currentHeight - (currentHeight % blockAndReward->first);
+
+    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 getpendingfutureswaps(const JSONRPCRequest& request) {
+    RPCHelpMan{"getpendingfutureswaps",
+               "Get specific pending futures.\n",
+                {
+                       {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Address to get all pending future swaps"},
+                },
+                RPCResult{
+                    "{\n"
+                    "    owner :       \"address\"\n"
+                    "    values : [{\n"
+                    "    tokenSymbol : \"SYMBOL\"\n"
+                    "    amount :      n.nnnnnnnn\n"
+                    "    destination : \"SYMBOL\"\n"
+                    "    }...]\n"
+                    "}\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("getpendingfutureswaps", "address")
+               },
+    }.Check(request);
+
+    UniValue listValues{UniValue::VARR};
+    const auto blockAndReward = GetFuturesBlockAndReward();
+    if (!blockAndReward) {
+        return listValues;
+    }
+
+    const auto owner = DecodeScript(request.params[0].get_str());
+
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+    const auto startPeriod = currentHeight - (currentHeight % blockAndReward->first);
+
+    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()});
+
+    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;
+}
+
+
+UniValue listfutureswaphistory(const JSONRPCRequest& request) {
+    auto pwallet = GetWallet(request);
+
+    RPCHelpMan{"listfutureswaphistory",
+               "\nReturns information about future swap history.\n",
+               {
+                       {"owner", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                        "Single account ID (CScript or address) or reserved words: \"mine\" - to list history for all owned accounts or \"all\" to list whole DB (default = \"mine\")."},
+                       {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                                {"maxBlockHeight", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Optional height to iterate from (downto genesis block), (default = chaintip)."},
+                                {"depth", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Maximum depth, from the genesis block is the default"},
+                                {"token", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                                 "Filter by token"},
+                                {"limit", RPCArg::Type::NUM, RPCArg::Optional::OMITTED,
+                                 "Maximum number of records to return, 100 by default"},
+                        },
+                       },
+               },
+               RPCResult{
+                       "[{},{}...]     (array) Objects with future swap history information\n"
+               },
+               RPCExamples{
+                       HelpExampleCli("listfutureswaphistory", "all '{\"maxBlockHeight\":160,\"depth\":10}'")
+                       + HelpExampleRpc("listfutureswaphistory", "all, '{\"maxBlockHeight\":160,\"depth\":10}'")
+               },
+    }.Check(request);
+
+
+    std::string accounts = "mine";
+    if (request.params.size() > 0) {
+        accounts = request.params[0].getValStr();
+    }
+
+    if (!paccountHistoryDB) {
+        throw JSONRPCError(RPC_INVALID_REQUEST, "-acindex is needed for account history");
+    }
+
+    auto maxBlockHeight = std::numeric_limits<uint32_t>::max();
+    auto depth{maxBlockHeight};
+    std::string tokenFilter;
+    uint32_t limit = 100;
+
+    if (request.params.size() > 1) {
+        UniValue optionsObj = request.params[1].get_obj();
+        RPCTypeCheckObj(optionsObj,
+                        {
+                                {"maxBlockHeight", UniValueType(UniValue::VNUM)},
+                                {"depth", UniValueType(UniValue::VNUM)},
+                                {"token", UniValueType(UniValue::VSTR)},
+                                {"limit", UniValueType(UniValue::VNUM)},
+                        }, true, true);
+
+        if (!optionsObj["maxBlockHeight"].isNull()) {
+            maxBlockHeight = (uint32_t) optionsObj["maxBlockHeight"].get_int64();
+        }
+
+        if (!optionsObj["depth"].isNull()) {
+            depth = (uint32_t) optionsObj["depth"].get_int64();
+        }
+
+        if (!optionsObj["token"].isNull()) {
+            tokenFilter = optionsObj["token"].get_str();
+        }
+
+        if (!optionsObj["limit"].isNull()) {
+            limit = (uint32_t) optionsObj["limit"].get_int64();
+        }
+
+        if (limit == 0) {
+            limit = std::numeric_limits<decltype(limit)>::max();
+        }
+    }
+
+    pwallet->BlockUntilSyncedToCurrentChain();
+
+    std::function<bool(CScript const &)> isMatchOwner = [](const CScript &) {
+        return true;
+    };
+
+    DCT_ID tokenID{};
+
+    if (!tokenFilter.empty()) {
+        const auto token = pcustomcsview->GetTokenGuessId(tokenFilter, tokenID);
+
+        if (!token) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Token %s does not exist.", tokenFilter));
+        }
+    }
+
+    CScript account{};
+    auto isMine{false};
+    auto filter{ISMINE_ALL};
+
+    if (accounts == "mine") {
+        isMine = true;
+        filter = ISMINE_SPENDABLE;
+    } else if (accounts != "all") {
+        account = DecodeScript(accounts);
+        isMatchOwner = [&account](CScript const & owner) {
+            return owner == account;
+        };
+    }
+
+    maxBlockHeight = std::min(maxBlockHeight, uint32_t(::ChainActive().Height()));
+    if (depth > maxBlockHeight) {
+        depth = maxBlockHeight;
+    }
+
+    UniValue result(UniValue::VARR);
+    pcustomcsview->ForEachFuturesDestValues([&](const CFuturesUserKey& key, const CFuturesUserValue& destination) {
+        if (key.height < maxBlockHeight - depth) {
+            return false;
+        }
+
+        if (!isMatchOwner(key.owner)) {
+            return true;
+        }
+
+        if (isMine && !(IsMineCached(*pwallet, key.owner) & filter)) {
+            return true;
+        }
+
+        const auto userValue = pcustomcsview->GetFuturesUserValues(key);
+        if (!userValue) {
+            return true;
+        }
+
+        const auto& source = userValue.val->source;
+
+        if (!tokenFilter.empty()) {
+            if (tokenID != source.nTokenId && tokenID != destination.source.nTokenId) {
+                return true;
+            }
+        }
+
+        const auto sourceToken = pcustomcsview->GetToken(source.nTokenId);
+        if (!sourceToken) {
+            return true;
+        }
+
+        const auto destToken = pcustomcsview->GetToken(destination.source.nTokenId);
+        if (!destToken) {
+            return true;
+        }
+
+        CTxDestination dest;
+        if (!ExtractDestination(key.owner, dest)) {
+            return true;
+        }
+
+        UniValue item(UniValue::VOBJ);
+        item.pushKV("height", static_cast<uint64_t>(destination.destination));
+        item.pushKV("address", EncodeDestination(dest));
+        item.pushKV("source", GetDecimaleString(source.nValue) + '@' + sourceToken->symbol);
+        item.pushKV("destination", GetDecimaleString(destination.source.nValue) + '@' + destToken->symbol);
+        result.push_back(item);
+
+        return --limit > 0;
+    }, {maxBlockHeight, account, std::numeric_limits<uint32_t>::max()});
+
+    return result;
+}
+
 
 static const CRPCCommand commands[] =
 {
@@ -2045,6 +2528,11 @@ static const CRPCCommand commands[] =
     {"accounts",    "sendtokenstoaddress",   &sendtokenstoaddress,   {"from", "to", "selectionMode"}},
     {"accounts",    "getburninfo",           &getburninfo,           {}},
     {"accounts",    "executesmartcontract",  &executesmartcontract,  {"name", "amount", "inputs"}},
+    {"accounts",    "futureswap",            &futureswap,            {"address", "amount", "destination", "inputs"}},
+    {"accounts",    "withdrawfutureswap",    &withdrawfutureswap,    {"address", "amount", "destination", "inputs"}},
+    {"accounts",    "listpendingfutureswaps",    &listpendingfutureswaps,    {}},
+    {"accounts",    "getpendingfutureswaps",     &getpendingfutureswaps,     {"address"}},
+    {"accounts",    "listfutureswaphistory",     &listfutureswaphistory,     {"owner", "options"}},
 };
 
 void RegisterAccountsRPCCommands(CRPCTable& tableRPC) {
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index cd62635cb1..f25a0d4b01 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 CFutureSwapMessage& 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 101c61781a..42ef3b8102 100644
--- a/src/masternodes/rpc_oracles.cpp
+++ b/src/masternodes/rpc_oracles.cpp
@@ -1124,7 +1124,29 @@ UniValue listfixedintervalprices(const JSONRPCRequest& request) {
     return listPrice;
 }
 
+UniValue getfutureswapblock(const JSONRPCRequest& request) {
+    RPCHelpMan{"getfutureswapblock",
+               "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("getfutureswapblock", "")
+               },
+    }.Check(request);
 
+    LOCK(cs_main);
+
+    const auto currentHeight = ::ChainActive().Height();
+
+    const auto blockAndReward = GetFuturesBlockAndReward();
+    if (!blockAndReward) {
+        return 0;
+    }
+
+    return currentHeight + (blockAndReward->first - (currentHeight % blockAndReward->first));
+}
 
 
 
@@ -1143,6 +1165,7 @@ static const CRPCCommand commands[] =
     {"oracles",     "listprices",              &listprices,               {"pagination"}},
     {"oracles",     "getfixedintervalprice",   &getfixedintervalprice,    {"fixedIntervalPriceId"}},
     {"oracles",     "listfixedintervalprices", &listfixedintervalprices,  {"pagination"}},
+    {"oracles",     "getfutureswapblock",         &getfutureswapblock,          {}},
 };
 
 void RegisterOraclesRPCCommands(CRPCTable& tableRPC) {
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 757b267d0a..9136385b65 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -215,6 +215,10 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "accounttoaccount", 2, "inputs" },
     { "accounttoutxos", 1, "to" },
     { "accounttoutxos", 2, "inputs" },
+    { "futureswap", 2, "destination"},
+    { "futureswap", 3, "inputs"},
+    { "withdrawfutureswap", 2, "destination"},
+    { "withdrawfutureswap", 3, "inputs"},
 
     { "icx_createorder", 0, "order" },
     { "icx_createorder", 1, "inputs" },
@@ -305,6 +309,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "getaccounthistory", 2, "txn" },
     { "listburnhistory", 0, "options" },
     { "accounthistorycount", 1, "options" },
+    { "listfutureswaphistory", 1, "options" },
 
     { "setgov", 0, "variables" },
     { "setgov", 1, "inputs" },
diff --git a/src/validation.cpp b/src/validation.cpp
index 87fbdad52b..0b9da9c623 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,129 @@ 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;
+    }
+
+    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;
+    }
+
+    const auto rewardPct = attributes->GetValue(rewardKey, CAmount{});
+    const auto discount{COIN - rewardPct};
+    const auto premium{COIN + rewardPct};
+
+    std::map<DCT_ID, CFuturesPrice> futuresPrices;
+    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;
+        }
+
+        futuresPrices.emplace(id, CFuturesPrice{*discountPrice, *premiumPrice});
+
+        return true;
+    });
+
+    const uint32_t startHeight = pindex->nHeight - blockPeriod;
+    std::map<CFuturesUserKey, CFuturesUserValue> unpaidContracts;
+    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);
+
+            try {
+                const auto& premiumPrice = futuresPrices.at(destId).premium;
+                if (premiumPrice > 0) {
+                    const auto total = DivideAmounts(futuresValues.source.nValue, premiumPrice);
+                    CTokenAmount destination{destId, total};
+                    cache.AddBalance(key.owner, destination);
+                    cache.StoreFuturesDestValues(key, {destination, static_cast<uint32_t>(pindex->nHeight)});
+                    LogPrint(BCLog::FUTURESWAP, "ProcessFutures(): Owner %s source %s destination %s\n",
+                             key.owner.GetHex(), futuresValues.source.ToString(), destination.ToString());
+                }
+            } catch (const std::out_of_range&) {
+                unpaidContracts.emplace(key, futuresValues);
+            }
+
+        } else {
+            const auto tokenDUSD = cache.GetToken("DUSD");
+            assert(tokenDUSD);
+
+            try {
+                const auto& discountPrice = futuresPrices.at(futuresValues.source.nTokenId).discount;
+                const auto total = MultiplyAmounts(futuresValues.source.nValue, discountPrice);
+                CTokenAmount destination{tokenDUSD->first, total};
+                cache.AddBalance(key.owner, destination);
+                cache.StoreFuturesDestValues(key, {destination, static_cast<uint32_t>(pindex->nHeight)});
+                LogPrint(BCLog::FUTURESWAP, "ProcessFutures(): Owner %s source %s destination %s\n",
+                         key.owner.GetHex(), futuresValues.source.ToString(), destination.ToString());
+            } catch (const std::out_of_range&) {
+                unpaidContracts.emplace(key, futuresValues);
+            }
+        }
+
+        return true;
+    }, {static_cast<uint32_t>(pindex->nHeight), {}, std::numeric_limits<uint32_t>::max()});
+
+    const auto contractAddressValue = GetFutureSwapContractAddress();
+    assert(contractAddressValue);
+
+    CDataStructureV0 liveKey{AttributeTypes::Live, ParamIDs::Economy, EconomyKeys::DFIP2203Tokens};
+    auto balances = attributes->GetValue(liveKey, CBalances{});
+
+    // Refund unpaid contracts
+    for (const auto& [key, value] : unpaidContracts) {
+        cache.EraseFuturesUserValues(key);
+        cache.SubBalance(*contractAddressValue, value.source);
+        cache.AddBalance(key.owner, value.source);
+        balances.Sub(value.source);
+    }
+
+    if (!unpaidContracts.empty()) {
+        attributes->attributes[liveKey] = balances;
+        cache.SetVariable(*attributes);
+    }
+}
+
 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 8bb4ed74b2..7d19b34f12 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 0000000000..7a0dfeb72c
--- /dev/null
+++ b/test/functional/feature_futures.py
@@ -0,0 +1,918 @@
+#!/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 contract RPC."""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from decimal import Decimal
+import time
+
+class 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 dToken to DUSD
+        self.test_dtoken_to_dusd()
+
+        # Test DUSD to dToken
+        self.test_dusd_to_dtoken()
+
+        # Test futures block range
+        self.check_swap_block_range()
+
+        # Test multiple swaps per account
+        self.check_multiple_swaps()
+
+        # Test withdrawal
+        self.check_withdrawals()
+
+        # Test Satoshi swaps
+        self.check_minimum_swaps()
+
+        # Test changing Gov vars
+        self.check_gov_var_change()
+
+        # Test refunding of unpaid futures
+        self.unpaid_contract()
+
+        # Test list future swap history
+        self.rpc_history()
+
+    def setup_test(self):
+
+        # Store address
+        self.address = self.nodes[0].get_genesis_keys().ownerAuthAddress
+
+        # Store interval
+        self.futures_interval = 25
+
+        # RPC history checks
+        self.list_history = []
+
+        # Set token symbols
+        self.symbolDFI   = 'DFI'
+        self.symbolDUSD  = 'DUSD'
+        self.symbolTSLA  = 'TSLA'
+        self.symbolGOOGL = 'GOOGL'
+        self.symbolTWTR  = 'TWTR'
+        self.symbolMSFT  = 'MSFT'
+        self.symbolBTC   = 'BTC'
+
+        # Setup oracle
+        oracle_address = self.nodes[0].getnewaddress("", "legacy")
+        price_feeds = [
+            {"currency": "USD", "token": self.symbolDFI},
+            {"currency": "USD", "token": self.symbolTSLA},
+            {"currency": "USD", "token": self.symbolGOOGL},
+            {"currency": "USD", "token": self.symbolTWTR},
+            {"currency": "USD", "token": self.symbolMSFT}
+        ]
+        self.oracle_id = self.nodes[0].appointoracle(oracle_address, price_feeds, 10)
+        self.nodes[0].generate(1)
+
+        # Create Oracle prices
+        self.price_tsla = 870
+        self.price_googl = 2600
+        self.price_twtr = 37
+        self.price_msft = 295
+
+        # Calculate future swap prices
+        self.prices = []
+        self.prices.append({
+            'premiumPrice': Decimal(str(Decimal(str(self.price_tsla)) * Decimal('1.05000000'))),
+            'discountPrice': Decimal(str(Decimal(str(self.price_tsla)) * Decimal('0.95000000')))
+        })
+        self.prices.append({
+            'premiumPrice': Decimal(str(Decimal(str(self.price_googl)) * Decimal('1.05000000'))),
+            'discountPrice': Decimal(str(Decimal(str(self.price_googl)) * Decimal('0.95000000')))
+        })
+        self.prices.append({
+            'premiumPrice': Decimal(str(Decimal(str(self.price_twtr)) * Decimal('1.05000000'))),
+            'discountPrice': Decimal(str(Decimal(str(self.price_twtr)) * Decimal('0.95000000')))
+        })
+        self.prices.append({
+            'premiumPrice': Decimal(str(Decimal(str(self.price_msft)) * Decimal('1.05000000'))),
+            'discountPrice': Decimal(str(Decimal(str(self.price_msft)) * Decimal('0.95000000')))
+        })
+
+        # Feed oracle
+        oracle_prices = [
+            {"currency": "USD", "tokenAmount": f'{self.price_tsla}@{self.symbolTSLA}'},
+            {"currency": "USD", "tokenAmount": f'{self.price_googl}@{self.symbolGOOGL}'},
+            {"currency": "USD", "tokenAmount": f'{self.price_twtr}@{self.symbolTWTR}'},
+            {"currency": "USD", "tokenAmount": f'{self.price_msft}@{self.symbolMSFT}'},
+        ]
+        self.nodes[0].setoracledata(self.oracle_id, int(time.time()), oracle_prices)
+        self.nodes[0].generate(10)
+
+        # 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)
+
+        # 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.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'], str(self.futures_interval))
+
+        # 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')
+
+        # 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].getfutureswapblock())
+
+    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, '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].listpendingfutureswaps()
+        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].getpendingfutureswaps(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].getpendingfutureswaps(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].getpendingfutureswaps(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].getpendingfutureswaps(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].listpendingfutureswaps()
+        assert_equal(len(result), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_msft)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_googl)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(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'{self.prices[3]["discountPrice"]}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'{self.prices[1]["discountPrice"]}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'{self.prices[0]["discountPrice"]}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_twtr)
+        assert_equal(result, [f'{self.prices[2]["discountPrice"]}@{self.symbolDUSD}'])
+
+        # Populate RPC check
+        self.list_history.append({'height': self.nodes[0].getblockcount(), 'swaps': [
+            {'address': address_tsla, 'source': f'{Decimal("1.00000000")}@{self.symbolTSLA}', 'destination': f'{self.prices[0]["discountPrice"]}@{self.symbolDUSD}'},
+            {'address': address_googl, 'source': f'{Decimal("1.00000000")}@{self.symbolGOOGL}', 'destination': f'{self.prices[1]["discountPrice"]}@{self.symbolDUSD}'},
+            {'address': address_twtr, 'source': f'{Decimal("1.00000000")}@{self.symbolTWTR}', 'destination': f'{self.prices[1]["discountPrice"]}@{self.symbolDUSD}'},
+            {'address': address_msft, 'source': f'{Decimal("1.00000000")}@{self.symbolMSFT}', 'destination': f'{self.prices[3]["discountPrice"]}@{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")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_googl: f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_twtr: f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_msft: f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_msft, f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}', int(self.idMSFT))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_twtr, f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_googl, f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].generate(1)
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # List user futures contracts
+        result = self.nodes[0].listpendingfutureswaps()
+        assert_equal(result[0]['owner'], address_tsla)
+        assert_equal(result[0]['source'], f'{self.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'{self.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'{self.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'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[3]['destination'], self.symbolMSFT)
+
+        # Get user TSLA futures swap by address
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(result['values'][0]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTSLA)
+
+        # Get user GOOGL futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_googl)
+        assert_equal(result['values'][0]['source'], f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolGOOGL)
+
+        # Get user TWTR futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+
+        # Get user MSFT futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_msft)
+        assert_equal(result['values'][0]['source'], f'{self.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].listpendingfutureswaps()
+        assert_equal(len(result), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_msft)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_googl)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(len(result['values']), 0)
+        result = self.nodes[0].getpendingfutureswaps(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}'])
+
+        # Populate RPC check
+        self.list_history.append({'height': self.nodes[0].getblockcount(), 'swaps': [
+            {'address': address_tsla, 'source': f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', 'destination': f'1.00000000@{self.symbolTSLA}'},
+            {'address': address_googl, 'source': f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', 'destination': f'1.00000000@{self.symbolGOOGL}'},
+            {'address': address_twtr, 'source': f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', 'destination': f'1.00000000@{self.symbolTWTR}'},
+            {'address': address_msft, 'source': f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}', 'destination': f'1.00000000@{self.symbolMSFT}'},
+        ]})
+
+    def check_swap_block_range(self):
+
+        # Create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address: f'{self.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'{self.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'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}'])
+
+        # Check all pending swaps shows no entries
+        result = self.nodes[0].listpendingfutureswaps()
+        assert_equal(len(result), 0)
+
+        # Check user pending swaps is empty
+        result = self.nodes[0].getpendingfutureswaps(address)
+        assert_equal(len(result['values']), 0)
+
+        # Try and withdraw smallest amount now contract has been paid
+        assert_raises_rpc_error(-32600, 'amount 0.00000000 is less than 0.00000001', self.nodes[0].withdrawfutureswap, address, f'{Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTSLA))
+
+        # Populate RPC check
+        self.list_history.append({'height': self.nodes[0].getblockcount(), 'swaps': [
+            {'address': address, 'source': f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', 'destination': f'1.00000000@{self.symbolTSLA}'},
+        ]})
+
+        # 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())
+
+        # 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}'])
+
+    def check_multiple_swaps(self):
+
+        # Create addresses for futures
+        address_tsla = self.nodes[0].getnewaddress("", "legacy")
+        address_twtr = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'{self.prices[0]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_twtr: f'{self.prices[2]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create two user futures contracts
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].futureswap(address_twtr, f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].futureswap(address_twtr, f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].generate(1)
+
+        # Get user TSLA futures swap by address
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(result['values'][0]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTSLA)
+        assert_equal(result['values'][1]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][1]['destination'], self.symbolTSLA)
+
+        # Get user TWTR futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+        assert_equal(result['values'][0]['source'], f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+
+        # 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())
+
+        # Check that futures have been executed
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'2.00000000@{self.symbolTSLA}'])
+        result = self.nodes[0].getaccount(address_twtr)
+        assert_equal(result, [f'2.00000000@{self.symbolTWTR}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'6810.30000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+    def check_withdrawals(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")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'{self.prices[0]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_googl: f'{self.prices[1]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_twtr: f'{self.prices[2]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_msft: f'{self.prices[3]["premiumPrice"] * 2}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_msft, f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}', int(self.idMSFT))
+        self.nodes[0].futureswap(address_msft, f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}', int(self.idMSFT))
+        self.nodes[0].futureswap(address_twtr, f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].futureswap(address_twtr, f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].futureswap(address_googl, f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].futureswap(address_googl, f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Get user MSFT futures swap by address
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(result['values'][0]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTSLA)
+        assert_equal(result['values'][1]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][1]['destination'], self.symbolTSLA)
+
+        # Get user GOOGL futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_googl)
+        assert_equal(result['values'][0]['source'], f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolGOOGL)
+        assert_equal(result['values'][1]['source'], f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][1]['destination'], self.symbolGOOGL)
+
+        # Get user TSLA futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+        assert_equal(result['values'][1]['source'], f'{self.prices[2]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][1]['destination'], self.symbolTWTR)
+
+        # Get user TWTR futures contracts by address
+        result = self.nodes[0].getpendingfutureswaps(address_msft)
+        assert_equal(result['values'][0]['source'], f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolMSFT)
+        assert_equal(result['values'][1]['source'], f'{self.prices[3]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result['values'][1]['destination'], self.symbolMSFT)
+
+        # Check withdrawal failures
+        assert_raises_rpc_error(-32600, f'amount 0.00000000 is less than {self.prices[2]["premiumPrice"] * 2}', self.nodes[0].withdrawfutureswap, address_tsla, f'{self.prices[2]["premiumPrice"] * 2}@{self.symbolDUSD}', int(self.idTWTR))
+        assert_raises_rpc_error(-32600, f'amount {self.prices[0]["premiumPrice"] * 2} is less than {(self.prices[0]["premiumPrice"] * 2) + Decimal("0.00000001")}', self.nodes[0].withdrawfutureswap, address_tsla, f'{(self.prices[0]["premiumPrice"] * 2) + Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTSLA))
+
+        # Withdraw both TSLA contracts
+        self.nodes[0].withdrawfutureswap(address_tsla, f'{self.prices[0]["premiumPrice"] * 2}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Check user pending swap is empty
+        result = self.nodes[0].getpendingfutureswaps(address_tsla)
+        assert_equal(len(result['values']), 0)
+
+        # Try and withdraw smallest amount now contract empty
+        assert_raises_rpc_error(-32600, 'amount 0.00000000 is less than 0.00000001', self.nodes[0].withdrawfutureswap, address_tsla, f'{Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTSLA))
+
+        # Withdraw frm GOOGL everything but one Sat
+        self.nodes[0].withdrawfutureswap(address_googl, f'{(self.prices[1]["premiumPrice"] * 2) - Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].generate(1)
+
+        # Check user pending swap
+        result = self.nodes[0].getpendingfutureswaps(address_googl)
+        assert_equal(result['values'][0]['source'], f'0.00000001@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolGOOGL)
+
+        # Withdraw one TWTR contract plus 1 Sat of the second one
+        self.nodes[0].withdrawfutureswap(address_twtr, f'{self.prices[2]["premiumPrice"] + Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTWTR))
+        self.nodes[0].generate(1)
+
+        # Check user pending swap
+        result = self.nodes[0].getpendingfutureswaps(address_twtr)
+        assert_equal(result['values'][0]['source'], f'{self.prices[2]["premiumPrice"] - Decimal("0.00000001")}@{self.symbolDUSD}')
+        assert_equal(result['values'][0]['destination'], self.symbolTWTR)
+
+        # Withdraw one Sat
+        self.nodes[0].withdrawfutureswap(address_msft, f'{Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idMSFT))
+        self.nodes[0].generate(1)
+
+        # Check user pending swap
+        result = self.nodes[0].getpendingfutureswaps(address_msft)
+        assert_equal(result['values'][0]['source'], f'{(self.prices[3]["premiumPrice"] * 2) - Decimal("0.00000001")}@{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())
+
+        # Check final balances
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'{self.prices[0]["premiumPrice"] * 2}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_twtr)
+        assert_equal(result, [f'{self.prices[2]["premiumPrice"] + Decimal("0.00000001")}@{self.symbolDUSD}', f'0.99999999@{self.symbolTWTR}'])
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'{(self.prices[1]["premiumPrice"] * 2) - Decimal("0.00000001")}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_msft)
+        assert_equal(result, [f'0.00000001@{self.symbolDUSD}', f'1.99999999@{self.symbolMSFT}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.64999999@{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'7468.64999999@{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'7468.64999999@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+    def check_minimum_swaps(self):
+
+        # Create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address: f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contract with 1 Satoshi
+        self.nodes[0].futureswap(address, f'{Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # 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())
+
+        # Check one Satoshi swap yields no TSLA
+        result = self.nodes[0].getaccount(address)
+        assert_equal(result, [f'{self.prices[0]["premiumPrice"] - Decimal("0.00000001")}@{self.symbolDUSD}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.65000000@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Create user futures contract to purchase one Satoshi of TSLA
+        min_purchase = round(self.prices[0]["premiumPrice"] / 100000000, 8)
+        self.nodes[0].futureswap(address, f'{min_purchase}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # 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())
+
+        # Check one Satoshi swap yields one TSLA Satoshi
+        result = self.nodes[0].getaccount(address)
+        assert_equal(result, [f'{self.prices[0]["premiumPrice"] - Decimal("0.00000001") - Decimal(min_purchase)}@{self.symbolDUSD}', f'0.00000001@{self.symbolTSLA}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.65000914@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+    def check_gov_var_change(self):
+
+        # Set up for block range change, create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address: f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Move to before next futures block
+        next_futures_block = self.nodes[0].getblockcount() + (self.futures_interval - (self.nodes[0].getblockcount() % self.futures_interval)) - 1
+        self.nodes[0].generate(next_futures_block - self.nodes[0].getblockcount())
+
+        # Create user futures contract with 1 Satoshi to invalidate block period change
+        self.nodes[0].futureswap(address, f'{Decimal("0.00000001")}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Check contract address has updated
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.65000915@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Test changing block period while DFIP2203 still active
+        assert_raises_rpc_error(-32600, 'Cannot set block period while DFIP2203 is active', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/block_period':f'{self.futures_interval}'}})
+
+        # Disable DFIP2203 to be able to change block period
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'false'}})
+        self.nodes[0].generate(1)
+
+        # Check contract address has not changed, no refund on disabling DFIP2203.
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.65000915@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Test changing block period to include historical future contracts
+        self.futures_interval = self.futures_interval * 2
+        assert_raises_rpc_error(-32600, 'Historical Futures contracts in this period', self.nodes[0].setgov, {"ATTRIBUTES":{'v0/params/dfip2203/block_period':f'{self.futures_interval}'}})
+
+        # 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())
+
+        # Now set the new block period
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/block_period':f'{self.futures_interval}'}})
+        self.nodes[0].generate(1)
+
+        # Enable DFIP2203
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        self.nodes[0].generate(1)
+
+        # Create addresses
+        address_tsla = self.nodes[0].getnewaddress("", "legacy")
+        address_googl = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address_tsla: f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].accounttoaccount(self.address, {address_googl: f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_googl, f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Disable DFIP2203
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'false'}})
+        self.nodes[0].generate(1)
+
+        # Balances should be restored
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}'])
+
+        # Check contract address remains the same
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'7468.65000915@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+        # Enable DFIP2203
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'true'}})
+        self.nodes[0].generate(1)
+
+        # Create user futures contracts
+        self.nodes[0].futureswap(address_googl, f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}', int(self.idGOOGL))
+        self.nodes[0].futureswap(address_tsla, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Disable GOOGL
+        self.nodes[0].setgov({"ATTRIBUTES":{f'v0/token/{str(self.idGOOGL)}/dfip2203_disabled':'true'}})
+        self.nodes[0].generate(1)
+
+        # Only TSLA contract should remain
+        result = self.nodes[0].listpendingfutureswaps()
+        assert_equal(len(result), 1)
+        assert_equal(result[0]['owner'], address_tsla)
+        assert_equal(result[0]['source'], f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}')
+        assert_equal(result[0]['destination'], self.symbolTSLA)
+
+        # Balance should be restored
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}'])
+
+        # TSLA balance should be empty
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [])
+
+        # 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())
+
+        # Check all balances
+        result = self.nodes[0].getaccount(address_googl)
+        assert_equal(result, [f'{self.prices[1]["premiumPrice"]}@{self.symbolDUSD}'])
+        result = self.nodes[0].getaccount(address_tsla)
+        assert_equal(result, [f'1.00000000@{self.symbolTSLA}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'8382.15000915@{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'8382.15000915@{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'8382.15000915@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+    def unpaid_contract(self):
+
+        # Create addresses for futures
+        address = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fund addresses
+        self.nodes[0].accounttoaccount(self.address, {address: f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'})
+        self.nodes[0].generate(1)
+
+        # Create user futures contract
+        self.nodes[0].futureswap(address, f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}', int(self.idTSLA))
+        self.nodes[0].generate(1)
+
+        # Remove Oracle
+        self.nodes[0].removeoracle(self.oracle_id)
+        self.nodes[0].generate(1)
+
+        # 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())
+
+        # Check user has been refunded
+        result = self.nodes[0].getaccount(address)
+        assert_equal(result, [f'{self.prices[0]["premiumPrice"]}@{self.symbolDUSD}'])
+
+        # Check contract address
+        result = self.nodes[0].getaccount('bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpsqgljc')
+        assert_equal(result, [f'8382.15000915@{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'8382.15000915@{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'8382.15000915@{self.symbolDUSD}', f'1.00000000@{self.symbolTSLA}', f'1.00000000@{self.symbolGOOGL}', f'1.00000000@{self.symbolTWTR}', f'1.00000000@{self.symbolMSFT}'])
+
+    def rpc_history(self):
+
+        # Check some historical swaps
+        for history in self.list_history:
+            result = self.nodes[0].listfutureswaphistory('all', {"maxBlockHeight":history['height'], "depth":1})
+            swap_count = len(result)
+            assert_equal(len(result), swap_count)
+            for index in range(swap_count):
+                assert_equal(result[index]['height'], history['height'])
+                assert_equal(result[index]['address'], history['swaps'][index]['address'])
+                assert_equal(result[index]['source'], history['swaps'][index]['source'])
+                assert_equal(result[index]['destination'], history['swaps'][index]['destination'])
+
+        # Check all swaps present
+        result = self.nodes[0].listfutureswaphistory('all')
+        assert_equal(len(result), 20)
+
+        # Check swap by specific address
+        result = self.nodes[0].listfutureswaphistory(self.list_history[0]['swaps'][0]['address'])
+        assert_equal(len(result), 1)
+        assert_equal(result[0]['height'], self.list_history[0]['height'])
+        assert_equal(result[0]['address'], self.list_history[0]['swaps'][0]['address'])
+        assert_equal(result[0]['source'], self.list_history[0]['swaps'][0]['source'])
+        assert_equal(result[0]['destination'], self.list_history[0]['swaps'][0]['destination'])
+
+        # Check all wallet swaps present, still all of them!
+        result = self.nodes[0].listfutureswaphistory('mine')
+        assert_equal(len(result), 20)
+
+        # Check limit working
+        result = self.nodes[0].listfutureswaphistory('all', {'limit': 1})
+        assert_equal(len(result), 1)
+
+        # Filter on token
+        result = self.nodes[0].listfutureswaphistory('all', {'token': 'MSFT'})
+        assert_equal(len(result), 3)
+        for history in result:
+            if history['source'].find('MSFT') == -1:
+                assert(history['destination'].find('MSFT') != -1)
+
+if __name__ == '__main__':
+    FuturesTest().main()
diff --git a/test/functional/feature_setgov.py b/test/functional/feature_setgov.py
index ec4fce24ea..811f619859 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,29 @@ 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/reward_pct':'0.05','v0/params/dfip2203/block_period':'20160','v0/token/5/dfip2203_disabled':'true'}})
+        self.nodes[0].setgov({"ATTRIBUTES":{'v0/params/dfip2203/active':'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 6cb085ed40..2114591eed 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 dfe6a53efd..354c4a8cb3 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"