diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 377b6b5af5b7..2d7910e34672 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -260,6 +260,9 @@ class CMainParams : public CChainParams {
         // Dash BIP32 prvkeys start with 'xprv' (Bitcoin defaults)
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
 
+        // DIP-18 Dash Platform address HRP (bech32m)
+        bech32_platform_hrp = "dash";
+
         // Dash BIP44 coin type is '5'
         nExtCoinType = 5;
 
@@ -452,6 +455,9 @@ class CTestNetParams : public CChainParams {
         // Testnet Dash BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
+        // DIP-18 Dash Platform address HRP (bech32m)
+        bech32_platform_hrp = "tdash";
+
         // Testnet Dash BIP44 coin type is '1' (All coin's testnet default)
         nExtCoinType = 1;
 
@@ -625,6 +631,9 @@ class CDevNetParams : public CChainParams {
         // Testnet Dash BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
+        // DIP-18 Dash Platform address HRP (bech32m)
+        bech32_platform_hrp = "tdash";
+
         // Testnet Dash BIP44 coin type is '1' (All coin's testnet default)
         nExtCoinType = 1;
 
@@ -900,6 +909,9 @@ class CRegTestParams : public CChainParams {
         // Regtest Dash BIP32 prvkeys start with 'tprv' (Bitcoin defaults)
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
+        // DIP-18 Dash Platform address HRP (bech32m)
+        bech32_platform_hrp = "tdash";
+
         // Regtest Dash BIP44 coin type is '1' (All coin's testnet default)
         nExtCoinType = 1;
 
diff --git a/src/chainparams.h b/src/chainparams.h
index 7b5528b9b550..058570124306 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -124,6 +124,8 @@ class CChainParams
     /** Return the list of hostnames to look up for DNS seeds */
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
+    /** DIP-18 Platform address bech32m HRP: "dash" on mainnet, "tdash" on test chains */
+    const std::string& Bech32PlatformHRP() const { return bech32_platform_hrp; }
     int ExtCoinType() const { return nExtCoinType; }
     const std::vector<uint8_t>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
@@ -164,6 +166,7 @@ class CChainParams
     uint64_t m_assumed_chain_state_size;
     std::vector<std::string> vSeeds;
     std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
+    std::string bech32_platform_hrp;
     int nExtCoinType;
     std::string strNetworkID;
     CBlock genesis;
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index dace5ae1113d..2e391388f55b 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -23,25 +23,10 @@
 using node::BlockManager;
 
 
-/**
- *  Common code for Asset Lock and Asset Unlock
- */
-bool CheckAssetLockUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state)
-{
-    switch (tx.nType) {
-    case TRANSACTION_ASSET_LOCK:
-        return CheckAssetLockTx(tx, state);
-    case TRANSACTION_ASSET_UNLOCK:
-        return CheckAssetUnlockTx(blockman, qman, tx, pindexPrev, indexes, state);
-    default:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-not-asset-locks-at-all");
-    }
-}
-
 /**
  * Asset Lock Transaction
  */
-bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active)
 {
     if (tx.nType != TRANSACTION_ASSET_LOCK) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-type");
@@ -71,6 +56,9 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
     if (opt_assetLockTx->getVersion() == 0 || opt_assetLockTx->getVersion() > CAssetLockPayload::CURRENT_VERSION) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version");
     }
+    if (!is_v24_active && opt_assetLockTx->getVersion() == CAssetLockPayload::CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version-2");
+    }
 
     if (opt_assetLockTx->getCreditOutputs().empty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-emptycreditoutputs");
@@ -83,8 +71,14 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
         }
 
         creditOutputsAmount += out.nValue;
-        if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
+        if (opt_assetLockTx->getVersion() >= 2) {
+            if (!out.scriptPubKey.IsPayToPublicKeyHash() && !out.scriptPubKey.IsPayToScriptHash()) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-script-pubkey");
+            }
+        } else {
+            if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
+            }
         }
     }
     if (creditOutputsAmount != returnAmount) {
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 0f3c688cd83c..09462734e1e4 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -28,7 +28,8 @@ class BlockManager;
 class CAssetLockPayload
 {
 public:
-    static constexpr uint8_t CURRENT_VERSION = 1;
+    static constexpr uint8_t INITIAL_VERSION = 1;
+    static constexpr uint8_t CURRENT_VERSION = 2;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_LOCK;
 
 private:
@@ -36,8 +37,8 @@ class CAssetLockPayload
     std::vector<CTxOut> creditOutputs;
 
 public:
-    explicit CAssetLockPayload(const std::vector<CTxOut>& creditOutputs) :
-        creditOutputs(creditOutputs)
+    explicit CAssetLockPayload(const std::vector<CTxOut>& creditOutputs, uint8_t nVersion = CURRENT_VERSION) :
+        nVersion(nVersion), creditOutputs(creditOutputs)
     {}
 
     CAssetLockPayload() = default;
@@ -154,9 +155,8 @@ class CAssetUnlockPayload
     }
 };
 
-bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active = false);
 bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state);
-bool CheckAssetLockUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state);
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state);
 
 #endif // BITCOIN_EVO_ASSETLOCKTX_H
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 1ccfc998840b..1f019b1cfecb 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -16,7 +16,9 @@
 #include <util/std23.h>
 
 #include <core_io.h>
+#include <key_io.h>
 #include <rpc/util.h>
+#include <script/standard.h>
 #include <util/check.h>
 
 #include <univalue.h>
@@ -98,7 +100,9 @@ RPCResult CAssetLockPayload::GetJsonHelp(const std::string& key, bool optional)
                     {RPCResult::Type::STR, "asm", "The asm"},
                     {RPCResult::Type::STR_HEX, "hex", "The hex"},
                     {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
-        }}}}}}
+                }},
+                {RPCResult::Type::STR, "address", /*optional=*/true, "DIP-18 Platform address (version >= 2 only)"},
+        }}}}
     }};
 }
 
@@ -112,6 +116,16 @@ UniValue CAssetLockPayload::ToJson() const
         UniValue spk(UniValue::VOBJ);
         ScriptToUniv(credit_output.scriptPubKey, spk, /*include_hex=*/true, /*include_address=*/false);
         out.pushKV("scriptPubKey", spk);
+        if (nVersion >= 2) {
+            CTxDestination dest;
+            if (ExtractDestination(credit_output.scriptPubKey, dest)) {
+                if (const auto* pkh = std::get_if<PKHash>(&dest)) {
+                    out.pushKV("address", EncodePlatformDestination(PlatformP2PKHDestination(uint160(*pkh))));
+                } else if (const auto* sh = std::get_if<ScriptHash>(&dest)) {
+                    out.pushKV("address", EncodePlatformDestination(PlatformP2SHDestination(uint160(*sh))));
+                }
+            }
+        }
         outputs.push_back(out);
     }
 
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 287560d936ac..6faa197d9e59 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -22,7 +22,6 @@
 #include <memory>
 #include <stack>
 
-using node::BlockManager;
 using node::ReadBlockFromDisk;
 
 // Forward declaration to prevent a new circular dependencies through masternode/payments.h
@@ -248,8 +247,7 @@ CCreditPoolManager::~CCreditPoolManager() = default;
 
 CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex* pindexPrev,
                                  const Consensus::Params& consensusParams, const CAmount blockSubsidy) :
-    pool(std::move(starter)),
-    pindexPrev(pindexPrev)
+    pool(std::move(starter))
 {
     assert(pindexPrev);
 
@@ -297,15 +295,9 @@ bool CCreditPoolDiff::Unlock(const CTransaction& tx, TxValidationState& state)
     return true;
 }
 
-bool CCreditPoolDiff::ProcessLockUnlockTransaction(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, TxValidationState& state)
+bool CCreditPoolDiff::ProcessLockUnlockTransaction(const CTransaction& tx, TxValidationState& state)
 {
     if (!tx.IsSpecialTxVersion()) return true;
-    if (tx.nType != TRANSACTION_ASSET_LOCK && tx.nType != TRANSACTION_ASSET_UNLOCK) return true;
-
-    if (!CheckAssetLockUnlockTx(blockman, qman, tx, pindexPrev, pool.indexes, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
 
     try {
         switch (tx.nType) {
@@ -322,7 +314,7 @@ bool CCreditPoolDiff::ProcessLockUnlockTransaction(const BlockManager& blockman,
     }
 }
 
-std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpoolman, const BlockManager& blockman, const llmq::CQuorumManager& qman,
+std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpoolman,
                                                          const CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams,
                                                          const CAmount blockSubsidy, BlockValidationState& state)
 {
@@ -333,7 +325,7 @@ std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpo
         for (size_t i = 1; i < block.vtx.size(); ++i) {
             const auto& tx = *block.vtx[i];
             TxValidationState tx_state;
-            if (!creditPoolDiff.ProcessLockUnlockTransaction(blockman, qman, tx, tx_state)) {
+            if (!creditPoolDiff.ProcessLockUnlockTransaction(tx, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS);
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Process Lock/Unlock Transaction failed at Credit Pool (tx hash %s) %s", tx.GetHash().ToString(), tx_state.GetDebugMessage()));
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index e3eb066ecd75..fec44ab680cb 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -33,9 +33,6 @@ struct Params;
 namespace llmq {
 class CQuorumManager;
 } // namespace llmq
-namespace node {
-class BlockManager;
-} // namespace node
 
 struct CCreditPool {
     CAmount locked{0};
@@ -70,16 +67,15 @@ struct CCreditPool {
  * limits should stay same and depends only on the previous block.
  */
 class CCreditPoolDiff {
-private:
+public:
     const CCreditPool pool;
+private:
     std::unordered_set<uint64_t> newIndexes;
 
     CAmount sessionLocked{0};
     CAmount sessionUnlocked{0};
     CAmount platformReward{0};
 
-    const CBlockIndex *pindexPrev{nullptr};
-
 public:
     explicit CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindexPrev,
                              const Consensus::Params& consensusParams,
@@ -90,7 +86,7 @@ class CCreditPoolDiff {
      * to change amount of credit pool
      * @return true if transaction can be included in this block
      */
-    bool ProcessLockUnlockTransaction(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, TxValidationState& state);
+    bool ProcessLockUnlockTransaction(const CTransaction& tx, TxValidationState& state);
 
     /**
      * this function returns total amount of credits for the next block
@@ -147,7 +143,7 @@ class CCreditPoolManager
         EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
 };
 
-std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpoolman, const node::BlockManager& blockman, const llmq::CQuorumManager& qman,
+std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpoolman,
                                                          const CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams,
                                                          const CAmount blockSubsidy, BlockValidationState& state);
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 515c1dd06dec..bf6521585ee6 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -138,7 +138,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
         case TRANSACTION_MNHF_SIGNAL:
             return CheckMNHFTx(chainman, qman, tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
-            return CheckAssetLockTx(tx, state);
+            return CheckAssetLockTx(tx, state, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
         case TRANSACTION_ASSET_UNLOCK:
             return CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, state);
         }
@@ -743,7 +743,7 @@ bool CSpecialTxProcessor::CheckCreditPoolDiffForBlock(const CBlock& block, const
 
     try {
         const CAmount blockSubsidy = GetBlockSubsidy(pindex, m_consensus_params);
-        const auto creditPoolDiff = GetCreditPoolDiffForBlock(m_cpoolman, m_chainman.m_blockman, m_qman, block,
+        const auto creditPoolDiff = GetCreditPoolDiffForBlock(m_cpoolman, block,
                                                               pindex->pprev, m_consensus_params, blockSubsidy, state);
         if (!creditPoolDiff.has_value()) return false;
 
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 0136857973fa..b90c08bb13dd 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -7,6 +7,7 @@
 #include <base58.h>
 #include <bech32.h>
 #include <chainparams.h>
+#include <util/strencodings.h>
 
 #include <algorithm>
 #include <assert.h>
@@ -176,3 +177,99 @@ bool IsValidDestinationString(const std::string& str)
 {
     return IsValidDestinationString(str, Params());
 }
+
+namespace {
+constexpr uint8_t DIP18_TYPE_BYTE_P2PKH = 0xb0;
+constexpr uint8_t DIP18_TYPE_BYTE_P2SH  = 0x80;
+constexpr size_t  DIP18_PAYLOAD_SIZE    = 21; // 1 type byte + 20-byte HASH160
+
+std::string EncodePlatformBech32m(const CChainParams& params, uint8_t type_byte, const BaseHash<uint160>& hash)
+{
+    std::vector<uint8_t> payload;
+    payload.reserve(DIP18_PAYLOAD_SIZE);
+    payload.push_back(type_byte);
+    payload.insert(payload.end(), hash.begin(), hash.end());
+    std::vector<uint8_t> values;
+    values.reserve(((DIP18_PAYLOAD_SIZE * 8) + 4) / 5);
+    ConvertBits<8, 5, true>([&](uint8_t v) { values.push_back(v); }, payload.begin(), payload.end());
+    return bech32::Encode(bech32::Encoding::BECH32M, params.Bech32PlatformHRP(), values);
+}
+
+class PlatformDestinationEncoder
+{
+private:
+    const CChainParams& m_params;
+
+public:
+    explicit PlatformDestinationEncoder(const CChainParams& params) : m_params(params) {}
+
+    std::string operator()(const PlatformP2PKHDestination& id) const
+    {
+        return EncodePlatformBech32m(m_params, DIP18_TYPE_BYTE_P2PKH, id);
+    }
+    std::string operator()(const PlatformP2SHDestination& id) const
+    {
+        return EncodePlatformBech32m(m_params, DIP18_TYPE_BYTE_P2SH, id);
+    }
+    std::string operator()(const CNoDestination&) const { return {}; }
+};
+} // namespace
+
+bool IsValidPlatformDestination(const PlatformDestination& dest)
+{
+    return !std::holds_alternative<CNoDestination>(dest);
+}
+
+std::string EncodePlatformDestination(const PlatformDestination& dest)
+{
+    return std::visit(PlatformDestinationEncoder(Params()), dest);
+}
+
+PlatformDestination DecodePlatformDestination(const std::string& str, const CChainParams& params, std::string& error_str)
+{
+    error_str.clear();
+    const bech32::DecodeResult dec = bech32::Decode(str);
+    if (dec.encoding == bech32::Encoding::INVALID) {
+        error_str = "Invalid bech32m encoding";
+        return CNoDestination();
+    }
+    if (dec.encoding != bech32::Encoding::BECH32M) {
+        error_str = "DIP-18 Platform addresses require bech32m checksum";
+        return CNoDestination();
+    }
+    if (dec.hrp != params.Bech32PlatformHRP()) {
+        error_str = "Invalid Platform HRP for the selected network";
+        return CNoDestination();
+    }
+    std::vector<uint8_t> payload;
+    payload.reserve((dec.data.size() * 5) / 8);
+    if (!ConvertBits<5, 8, false>([&](uint8_t b) { payload.push_back(b); }, dec.data.begin(), dec.data.end())) {
+        error_str = "Invalid Platform address payload encoding";
+        return CNoDestination();
+    }
+    if (payload.size() != DIP18_PAYLOAD_SIZE) {
+        error_str = "Invalid Platform address payload length";
+        return CNoDestination();
+    }
+    uint160 hash;
+    std::copy(payload.begin() + 1, payload.end(), hash.begin());
+    switch (payload[0]) {
+    case DIP18_TYPE_BYTE_P2PKH:
+        return PlatformP2PKHDestination(hash);
+    case DIP18_TYPE_BYTE_P2SH:
+        return PlatformP2SHDestination(hash);
+    }
+    error_str = "Unknown DIP-18 type byte";
+    return CNoDestination();
+}
+
+PlatformDestination DecodePlatformDestination(const std::string& str, std::string& error_str)
+{
+    return DecodePlatformDestination(str, Params(), error_str);
+}
+
+PlatformDestination DecodePlatformDestination(const std::string& str)
+{
+    std::string error_str;
+    return DecodePlatformDestination(str, error_str);
+}
diff --git a/src/key_io.h b/src/key_io.h
index 605a087433f3..11bbe5cd6fb1 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -28,4 +28,35 @@ CTxDestination DecodeDestination(const std::string& str, std::string& error_msg)
 bool IsValidDestinationString(const std::string& str);
 bool IsValidDestinationString(const std::string& str, const CChainParams& params);
 
+/**
+ * DIP-18 Dash Platform addresses (bech32m).
+ *
+ * Platform addresses decode to a 20-byte HASH160 prefixed by a type byte:
+ *   0xb0 -> Platform P2PKH (addresses of the form dash1k... / tdash1k...)
+ *   0x80 -> Platform P2SH  (addresses of the form dash1s... / tdash1s...)
+ *
+ * Unlike base58 Dash addresses, Platform destinations have no on-chain
+ * scriptPubKey: they are only valid as credit output recipients of an
+ * asset-lock special transaction (see DIP-27 and src/evo/assetlocktx.h).
+ */
+struct PlatformP2PKHDestination : public BaseHash<uint160>
+{
+    PlatformP2PKHDestination() = default;
+    explicit PlatformP2PKHDestination(const uint160& hash) : BaseHash(hash) {}
+};
+
+struct PlatformP2SHDestination : public BaseHash<uint160>
+{
+    PlatformP2SHDestination() = default;
+    explicit PlatformP2SHDestination(const uint160& hash) : BaseHash(hash) {}
+};
+
+using PlatformDestination = std::variant<CNoDestination, PlatformP2PKHDestination, PlatformP2SHDestination>;
+
+bool IsValidPlatformDestination(const PlatformDestination& dest);
+std::string EncodePlatformDestination(const PlatformDestination& dest);
+PlatformDestination DecodePlatformDestination(const std::string& str);
+PlatformDestination DecodePlatformDestination(const std::string& str, std::string& error_str);
+PlatformDestination DecodePlatformDestination(const std::string& str, const CChainParams& params, std::string& error_str);
+
 #endif // BITCOIN_KEY_IO_H
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index d93c320eb195..f0d68a595034 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -305,7 +305,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                     LogPrintf("CreateNewBlock() h[%d] CbTx failed to find best CL. Inserting null CL\n", nHeight);
                 }
                 BlockValidationState state;
-                const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_chain_helper.credit_pool_manager, m_blockman, m_qman, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
+                const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_chain_helper.credit_pool_manager, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
                 if (creditPoolDiff == std::nullopt) {
                     throw std::runtime_error(strprintf("%s: GetCreditPoolDiffForBlock failed: %s", __func__, state.ToString()));
                 }
@@ -544,7 +544,20 @@ void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSele
             // `state` is local here because used only to log info about this specific tx
             TxValidationState state;
 
-            if (!creditPoolDiff->ProcessLockUnlockTransaction(m_blockman, m_qman, iter->GetTx(), state)) {
+            if (!iter->GetTx().IsSpecialTxVersion() && iter->GetTx().nType == TRANSACTION_ASSET_UNLOCK) {
+                // ASSET_UNLOCK transactions may expire after being added to mempool
+                // They should not be included to the block
+                if (!CheckAssetUnlockTx(m_blockman, m_qman, iter->GetTx(), pindexPrev, creditPoolDiff->pool.indexes, state)) {
+                    if (fUsingModified) {
+                        mapModifiedTx.get<ancestor_score>().erase(modit);
+                        failedTx.insert(iter);
+                    }
+                    LogPrintf("%s: asset unlock tx %s is skipped due %s\n",
+                              __func__, iter->GetTx().GetHash().ToString(), state.ToString());
+                    continue;
+                }
+            }
+            if (!creditPoolDiff->ProcessLockUnlockTransaction(iter->GetTx(), state)) {
                 if (fUsingModified) {
                     mapModifiedTx.get<ancestor_score>().erase(modit);
                     failedTx.insert(iter);
diff --git a/src/rpc/output_script.cpp b/src/rpc/output_script.cpp
index 2ad98f709d38..61ed5f486913 100644
--- a/src/rpc/output_script.cpp
+++ b/src/rpc/output_script.cpp
@@ -35,6 +35,7 @@ static RPCHelpMan validateaddress()
             RPCResult::Type::OBJ, "", "",
             {
                 {RPCResult::Type::BOOL, "isvalid", "If the address is valid or not"},
+                {RPCResult::Type::BOOL, "isplatform", /*optional=*/true, "If the address is a DIP-18 Dash Platform address"},
                 {RPCResult::Type::STR, "address", /*optional=*/true, "The Dash address validated"},
                 {RPCResult::Type::STR_HEX, "scriptPubKey", /*optional=*/true, "The hex-encoded scriptPubKey generated by the address"},
                 {RPCResult::Type::BOOL, "isscript", /*optional=*/true, "If the key is a script"},
@@ -47,16 +48,15 @@ static RPCHelpMan validateaddress()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
+            const std::string address = request.params[0].get_str();
             std::string error_msg;
-            CTxDestination dest = DecodeDestination(request.params[0].get_str(), error_msg);
+            CTxDestination dest = DecodeDestination(address, error_msg);
             const bool isValid = IsValidDestination(dest);
-            CHECK_NONFATAL(isValid == error_msg.empty());
 
             UniValue ret(UniValue::VOBJ);
-            ret.pushKV("isvalid", isValid);
             if (isValid) {
-                std::string currentAddress = EncodeDestination(dest);
-                ret.pushKV("address", currentAddress);
+                ret.pushKV("isvalid", true);
+                ret.pushKV("address", EncodeDestination(dest));
 
                 CScript scriptPubKey = GetScriptForDestination(dest);
                 ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
@@ -64,7 +64,16 @@ static RPCHelpMan validateaddress()
                 UniValue detail = DescribeAddress(dest);
                 ret.pushKVs(detail);
             } else {
-                ret.pushKV("error", error_msg);
+                std::string platform_error;
+                PlatformDestination platform_dest = DecodePlatformDestination(address, platform_error);
+                if (IsValidPlatformDestination(platform_dest)) {
+                    ret.pushKV("isvalid", true);
+                    ret.pushKV("isplatform", true);
+                    ret.pushKV("address", EncodePlatformDestination(platform_dest));
+                } else {
+                    ret.pushKV("isvalid", false);
+                    ret.pushKV("error", error_msg);
+                }
             }
 
             return ret;
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index d21e8df73a03..f0be30a15b08 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -70,7 +70,7 @@ static CMutableTransaction CreateAssetLockTx(FillableSigningProvider& keystore,
     creditOutputs[1].nValue = 13 * CENT;
     creditOutputs[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
-    CAssetLockPayload assetLockTx(creditOutputs);
+    CAssetLockPayload assetLockTx(creditOutputs, CAssetLockPayload::INITIAL_VERSION);
 
     CMutableTransaction tx;
     tx.nVersion = 3;
@@ -124,9 +124,8 @@ static CMutableTransaction CreateAssetUnlockTx(FillableSigningProvider& keystore
 
 BOOST_FIXTURE_TEST_SUITE(evo_assetlocks_tests, TestChain100Setup)
 
-BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
+static void CheckAssetLockCommon(uint8_t version, bool is_v24_active)
 {
-
     LOCK(cs_main);
     FillableSigningProvider keystore;
     CCoinsView coinsDummy;
@@ -135,7 +134,13 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
     CKey key;
     key.MakeNewKey(true);
 
-    const CTransaction tx{CreateAssetLockTx(keystore, coins, key)};
+    CMutableTransaction baseTx = CreateAssetLockTx(keystore, coins, key);
+    const auto basePayload = GetTxPayload<CAssetLockPayload>(CTransaction(baseTx));
+    const std::vector<CTxOut> creditOutputs = basePayload->getCreditOutputs();
+
+    SetTxPayload(baseTx, CAssetLockPayload(creditOutputs, version));
+
+    const CTransaction tx{baseTx};
     std::string reason;
     BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
 
@@ -144,7 +149,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
     BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), tx_state), strTest);
     BOOST_CHECK(tx_state.IsValid());
 
-    BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state));
+    BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state, is_v24_active));
 
     BOOST_CHECK(AreInputsStandard(CTransaction(tx), coins));
 
@@ -155,14 +160,14 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         const auto opt_payload = GetTxPayload<CAssetLockPayload>(tx);
 
         BOOST_CHECK(opt_payload.has_value());
-        BOOST_CHECK(opt_payload->getVersion() == 1);
+        BOOST_CHECK(opt_payload->getVersion() == version);
     }
 
     {
         // Wrong type "Asset Unlock TX" instead "Asset Lock TX"
         CMutableTransaction txWrongType(tx);
         txWrongType.nType = TRANSACTION_ASSET_UNLOCK;
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txWrongType), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txWrongType), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-type");
     }
 
@@ -176,40 +181,35 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         BOOST_CHECK(inSum == outSum);
 
         // Outputs should not be bigger than inputs
-        CMutableTransaction txBigOutput(tx);
+        CMutableTransaction txBigOutput(baseTx);
         txBigOutput.vout[0].nValue += 1;
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBigOutput), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBigOutput), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
 
         // Smaller outputs are allown
-        CMutableTransaction txSmallOutput(tx);
+        CMutableTransaction txSmallOutput(baseTx);
         txSmallOutput.vout[1].nValue -= 1;
-        BOOST_CHECK(CheckAssetLockTx(CTransaction(txSmallOutput), tx_state));
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txSmallOutput), tx_state, is_v24_active));
     }
 
-    const auto assetLockPayload = GetTxPayload<CAssetLockPayload>(tx);
-    const std::vector<CTxOut> creditOutputs = assetLockPayload->getCreditOutputs();
-
     {
         // Sum of credit output greater than OP_RETURN
         std::vector<CTxOut> wrongOutput = creditOutputs;
         wrongOutput[0].nValue += CENT;
-        CAssetLockPayload greaterCreditsPayload(wrongOutput);
 
-        CMutableTransaction txGreaterCredits(tx);
-        SetTxPayload(txGreaterCredits, greaterCreditsPayload);
+        CMutableTransaction txGreaterCredits(baseTx);
+        SetTxPayload(txGreaterCredits, CAssetLockPayload(wrongOutput, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txGreaterCredits), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txGreaterCredits), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
 
         // Sum of credit output less than OP_RETURN
         wrongOutput[1].nValue -= 2 * CENT;
-        CAssetLockPayload lessCreditsPayload(wrongOutput);
 
-        CMutableTransaction txLessCredits(tx);
-        SetTxPayload(txLessCredits, lessCreditsPayload);
+        CMutableTransaction txLessCredits(baseTx);
+        SetTxPayload(txLessCredits, CAssetLockPayload(wrongOutput, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txLessCredits), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txLessCredits), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
     }
 
@@ -217,24 +217,23 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         // Credit output is out-of-range
         std::vector<CTxOut> creditOutputsOutOfRange = creditOutputs;
         creditOutputsOutOfRange[0].nValue = 0;
-        CAssetLockPayload invalidOutputsPayload(creditOutputsOutOfRange);
 
-        CMutableTransaction txInvalidOutputs(tx);
-        SetTxPayload(txInvalidOutputs, invalidOutputsPayload);
+        CMutableTransaction txInvalidOutputs(baseTx);
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
         // one of output is out of range
         creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1;
-        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
         // sum of some of output is out of range
         creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1 - creditOutputsOutOfRange[1].nValue;
-        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
     }
@@ -242,60 +241,160 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         // One credit output keys is not pub key
         std::vector<CTxOut> creditOutputsNotPubkey = creditOutputs;
         creditOutputsNotPubkey[0].scriptPubKey = CScript() << OP_1;
-        CAssetLockPayload notPubkeyPayload(creditOutputsNotPubkey);
 
-        CMutableTransaction txNotPubkey(tx);
-        SetTxPayload(txNotPubkey, notPubkeyPayload);
+        CMutableTransaction txNotPubkey(baseTx);
+        SetTxPayload(txNotPubkey, CAssetLockPayload(creditOutputsNotPubkey, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNotPubkey), tx_state));
-        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNotPubkey), tx_state, is_v24_active));
+        if (version >= 2) {
+            BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-script-pubkey");
+        } else {
+            BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+        }
 
     }
 
     {
         // OP_RETURN must be only one, not more
-        CMutableTransaction txMultipleReturn(tx);
+        CMutableTransaction txMultipleReturn(baseTx);
         txMultipleReturn.vout[1].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-multiple-return");
 
     }
 
     {
         // zero/negative OP_RETURN
-        CMutableTransaction txReturnOutOfRange(tx);
+        CMutableTransaction txReturnOutOfRange(baseTx);
         txReturnOutOfRange.vout[0].nValue = 0;
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
 
         txReturnOutOfRange.vout[0].nValue = MAX_MONEY + 1;
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
     }
 
 
     {
         // OP_RETURN is missing
-        CMutableTransaction txNoReturn(tx);
+        CMutableTransaction txNoReturn(baseTx);
         txNoReturn.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNoReturn), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNoReturn), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-no-return");
     }
 
     {
         // OP_RETURN should not have any data
-        CMutableTransaction txReturnData(tx);
+        CMutableTransaction txReturnData(baseTx);
         txReturnData.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("abcd");
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnData), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnData), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-non-empty-return");
     }
 }
 
+BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
+{
+    CheckAssetLockCommon(CAssetLockPayload::INITIAL_VERSION, /*is_v24_active=*/false);
+    CheckAssetLockCommon(CAssetLockPayload::INITIAL_VERSION, /*is_v24_active=*/true);
+    CheckAssetLockCommon(CAssetLockPayload::CURRENT_VERSION, /*is_v24_active=*/true);
+}
+
+BOOST_FIXTURE_TEST_CASE(evo_assetlock_v2, TestChain100Setup)
+{
+    LOCK(cs_main);
+    FillableSigningProvider keystore;
+    CCoinsView coinsDummy;
+    CCoinsViewCache coins(&coinsDummy);
+
+    CKey key;
+    key.MakeNewKey(true);
+
+    CMutableTransaction tx = CreateAssetLockTx(keystore, coins, key);
+    TxValidationState tx_state;
+
+    const auto v1Payload = GetTxPayload<CAssetLockPayload>(CTransaction(tx));
+    const std::vector<CTxOut> creditOutputs = v1Payload->getCreditOutputs();
+
+    // Build v2 payload with same P2PKH credit outputs
+    CAssetLockPayload v2Payload(creditOutputs);
+    BOOST_CHECK(v2Payload.getVersion() == CAssetLockPayload::CURRENT_VERSION);
+    SetTxPayload(tx, v2Payload);
+
+    {
+        // v2 P2PKH: accepted with is_v24_active=true
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // v2 P2PKH: rejected pre-v24
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(tx), tx_state, /*is_v24_active=*/false));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-version-2");
+    }
+
+    {
+        // v2 with P2SH credit output: accepted with is_v24_active=true
+        CScript p2sh_script = GetScriptForDestination(ScriptHash(CScript() << OP_1));
+        std::vector<CTxOut> p2shOutputs(1);
+        p2shOutputs[0].nValue = 30 * CENT;
+        p2shOutputs[0].scriptPubKey = p2sh_script;
+
+        CMutableTransaction txP2SH(tx);
+        SetTxPayload(txP2SH, CAssetLockPayload(p2shOutputs));
+
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txP2SH), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // v1 with P2SH credit output: rejected even post-v24
+        CScript p2sh_script = GetScriptForDestination(ScriptHash(CScript() << OP_1));
+        std::vector<CTxOut> p2shOutputs(1);
+        p2shOutputs[0].nValue = 30 * CENT;
+        p2shOutputs[0].scriptPubKey = p2sh_script;
+
+        CMutableTransaction txV1P2SH(tx);
+        SetTxPayload(txV1P2SH, CAssetLockPayload(p2shOutputs, CAssetLockPayload::INITIAL_VERSION));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txV1P2SH), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+    }
+
+    {
+        // v2 with non-P2PKH/non-P2SH credit output: rejected
+        std::vector<CTxOut> badOutputs(1);
+        badOutputs[0].nValue = 30 * CENT;
+        badOutputs[0].scriptPubKey = CScript() << OP_1;
+
+        CMutableTransaction txBad(tx);
+        SetTxPayload(txBad, CAssetLockPayload(badOutputs));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBad), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-script-pubkey");
+    }
+
+    {
+        // v1 still works post-v24
+        CMutableTransaction txV1(tx);
+        SetTxPayload(txV1, CAssetLockPayload(creditOutputs, CAssetLockPayload::INITIAL_VERSION));
+
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txV1), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // version 3 (future): rejected even post-v24
+        CMutableTransaction txV3(tx);
+        SetTxPayload(txV3, CAssetLockPayload(creditOutputs, /*nVersion=*/3));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txV3), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-version");
+    }
+}
+
 BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 {
     LOCK(cs_main);
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index 827c6cc71e18..55a0b22f55fc 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/data/key_io_invalid.json.h>
 #include <test/data/key_io_valid.json.h>
 
+#include <bech32.h>
 #include <chainparams.h>
 #include <key.h>
 #include <key_io.h>
@@ -146,4 +147,102 @@ BOOST_AUTO_TEST_CASE(key_io_invalid)
     }
 }
 
+// DIP-18: Dash Platform bech32m address encoding.
+BOOST_AUTO_TEST_CASE(dip18_platform_roundtrip)
+{
+    struct Sample {
+        std::string hash_hex;
+        std::string address;
+        std::string chain;
+        bool is_p2sh;
+    };
+    // Samples from DIP-0018 (Test Vectors section).
+    const Sample samples[] = {
+        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs",  CBaseChainParams::MAIN, false},
+        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "dash1kzjl7qzxy9lar37j8r37z3kvt07epqe20ckxfezw",  CBaseChainParams::MAIN, false},
+        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "dash1kpkeye606ez89g7lelp7hnldwwpt76va0v3j6x28",  CBaseChainParams::MAIN, false},
+        {"f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525", "tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7", CBaseChainParams::TESTNET, false},
+        {"a5ff0046217fd1c7d238e3e146cc5bfd90832a7e", "tdash1kzjl7qzxy9lar37j8r37z3kvt07epqe20cxp68nq", CBaseChainParams::TESTNET, false},
+        {"6d92674fd64472a3dfcfc3ebcfed7382bf699d7b", "tdash1kpkeye606ez89g7lelp7hnldwwpt76va0vp4fcmf", CBaseChainParams::TESTNET, false},
+        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "dash1sppl5xpu70aka8nacc4kj2htflydspzkxch4cad6",  CBaseChainParams::MAIN, true},
+        {"43fa183cf3fb6e9e7dc62b692aeb4fc8d8045636", "tdash1sppl5xpu70aka8nacc4kj2htflydspzkxc8jtru5", CBaseChainParams::TESTNET, true},
+    };
+    for (const auto& s : samples) {
+        SelectParams(s.chain);
+        std::string err;
+        PlatformDestination dest = DecodePlatformDestination(s.address, err);
+        BOOST_REQUIRE_MESSAGE(IsValidPlatformDestination(dest),
+                              std::string{"decode failed: "} + s.address + " err=" + err);
+        std::vector<unsigned char> got_hash;
+        if (s.is_p2sh) {
+            BOOST_REQUIRE(std::holds_alternative<PlatformP2SHDestination>(dest));
+            const auto& h = std::get<PlatformP2SHDestination>(dest);
+            got_hash.assign(h.begin(), h.end());
+        } else {
+            BOOST_REQUIRE(std::holds_alternative<PlatformP2PKHDestination>(dest));
+            const auto& h = std::get<PlatformP2PKHDestination>(dest);
+            got_hash.assign(h.begin(), h.end());
+        }
+        BOOST_CHECK_EQUAL(HexStr(got_hash), std::string(s.hash_hex));
+        BOOST_CHECK_EQUAL(EncodePlatformDestination(dest), std::string(s.address));
+    }
+    SelectParams(CBaseChainParams::MAIN);
+}
+
+BOOST_AUTO_TEST_CASE(dip18_platform_invalid)
+{
+    SelectParams(CBaseChainParams::MAIN);
+    std::string err;
+
+    // Wrong HRP for the selected network (testnet string on mainnet).
+    BOOST_CHECK(!IsValidPlatformDestination(
+        DecodePlatformDestination("tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7", err)));
+
+    // Mixed case is forbidden by BIP-173.
+    BOOST_CHECK(!IsValidPlatformDestination(
+        DecodePlatformDestination("Dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs", err)));
+
+    // Bech32 (BIP-173) checksum MUST be rejected; only bech32m is valid for DIP-18.
+    // Re-encode the same 21-byte payload with the BIP-173 generator and verify rejection.
+    {
+        std::vector<uint8_t> payload = ParseHex("b0f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525");
+        std::vector<uint8_t> values;
+        ConvertBits<8, 5, true>([&](uint8_t b) { values.push_back(b); }, payload.begin(), payload.end());
+        const std::string bech32_str = bech32::Encode(bech32::Encoding::BECH32, "dash", values);
+        BOOST_REQUIRE(!bech32_str.empty());
+        BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination(bech32_str, err)));
+    }
+
+    // Unknown DIP-18 type byte (0x00) must be rejected.
+    {
+        std::vector<uint8_t> payload = ParseHex("00f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525");
+        std::vector<uint8_t> values;
+        ConvertBits<8, 5, true>([&](uint8_t b) { values.push_back(b); }, payload.begin(), payload.end());
+        const std::string bad = bech32::Encode(bech32::Encoding::BECH32M, "dash", values);
+        BOOST_REQUIRE(!bad.empty());
+        BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination(bad, err)));
+    }
+
+    // Wrong payload length (19-byte hash) must be rejected.
+    {
+        std::vector<uint8_t> payload = ParseHex("b0f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec05");
+        std::vector<uint8_t> values;
+        ConvertBits<8, 5, true>([&](uint8_t b) { values.push_back(b); }, payload.begin(), payload.end());
+        const std::string bad = bech32::Encode(bech32::Encoding::BECH32M, "dash", values);
+        BOOST_REQUIRE(!bad.empty());
+        BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination(bad, err)));
+    }
+
+    // Empty / garbage inputs.
+    BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination("", err)));
+    BOOST_CHECK(!IsValidPlatformDestination(DecodePlatformDestination("not-an-address", err)));
+
+    // Mainnet address on testnet must fail.
+    SelectParams(CBaseChainParams::TESTNET);
+    BOOST_CHECK(!IsValidPlatformDestination(
+        DecodePlatformDestination("dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs", err)));
+
+    SelectParams(CBaseChainParams::MAIN);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
index de9385e82b5d..97b0ac95f845 100644
--- a/src/wallet/rpc/spend.cpp
+++ b/src/wallet/rpc/spend.cpp
@@ -27,17 +27,36 @@ static void ParseRecipients(const UniValue& address_amounts, const UniValue& sub
     std::set<CTxDestination> destinations;
     int i = 0;
     for (const std::string& address: address_amounts.getKeys()) {
-        CTxDestination dest = DecodeDestination(address);
-        if (!IsValidDestination(dest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + address);
-        }
+        CScript script_pub_key;
+        bool is_platform = false;
 
-        if (destinations.count(dest)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + address);
+        CTxDestination dest = DecodeDestination(address);
+        if (IsValidDestination(dest)) {
+            if (destinations.count(dest)) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + address);
+            }
+            destinations.insert(dest);
+            script_pub_key = GetScriptForDestination(dest);
+        } else {
+            std::string platform_error;
+            PlatformDestination platform_dest = DecodePlatformDestination(address, platform_error);
+            if (!IsValidPlatformDestination(platform_dest)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + address);
+            }
+            is_platform = true;
+            if (const auto* pkh = std::get_if<PlatformP2PKHDestination>(&platform_dest)) {
+                uint160 hash;
+                std::copy(pkh->begin(), pkh->end(), hash.begin());
+                script_pub_key = GetScriptForDestination(PKHash(hash));
+            } else if (const auto* sh = std::get_if<PlatformP2SHDestination>(&platform_dest)) {
+                uint160 hash;
+                std::copy(sh->begin(), sh->end(), hash.begin());
+                script_pub_key = GetScriptForDestination(ScriptHash(hash));
+            } else {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Unsupported Platform address type: ") + address);
+            }
         }
-        destinations.insert(dest);
 
-        CScript script_pub_key = GetScriptForDestination(dest);
         CAmount amount = AmountFromValue(address_amounts[i++]);
 
         bool subtract_fee = false;
@@ -48,7 +67,7 @@ static void ParseRecipients(const UniValue& address_amounts, const UniValue& sub
             }
         }
 
-        CRecipient recipient = {script_pub_key, amount, subtract_fee};
+        CRecipient recipient = {script_pub_key, amount, subtract_fee, is_platform};
         recipients.push_back(recipient);
     }
 }
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index bfba61643130..94ea52f0f605 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -6,7 +6,9 @@
 #include <coinjoin/options.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
+#include <evo/assetlocktx.h>
 #include <evo/dmn_types.h>
+#include <evo/specialtx.h>
 #include <interfaces/chain.h>
 #include <policy/policy.h>
 #include <script/signingprovider.h>
@@ -769,7 +771,7 @@ static void DiscourageFeeSniping(CMutableTransaction& tx, FastRandomContext& rng
 
 static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         CWallet& wallet,
-        const std::vector<CRecipient>& vecSend,
+        const std::vector<CRecipient>& vecSend_in,
         int change_pos,
         const CCoinControl& coin_control,
         bool sign,
@@ -777,6 +779,36 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
 {
     AssertLockHeld(wallet.cs_wallet);
 
+    // DIP-27 v2: when platform recipients are present, build asset-lock payload
+    // and replace platform recipients with an OP_RETURN output.
+    std::optional<CAssetLockPayload> opt_assetLockPayload;
+    std::vector<CRecipient> vecSend;
+    const bool has_platform = std::any_of(vecSend_in.cbegin(), vecSend_in.cend(),
+                                           [](const auto& r) { return r.fPlatformTransfer; });
+    if (has_platform) {
+        std::vector<CTxOut> creditOutputs;
+        CAmount platform_total{0};
+
+        for (const auto& recipient : vecSend_in) {
+            if (recipient.fPlatformTransfer) {
+                creditOutputs.emplace_back(recipient.nAmount, recipient.scriptPubKey);
+                platform_total += recipient.nAmount;
+            } else {
+                vecSend.push_back(recipient);
+            }
+        }
+
+        opt_assetLockPayload.emplace(creditOutputs);
+        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+        ss << *opt_assetLockPayload;
+        nExtraPayloadSize = ss.size();
+
+        vecSend.insert(vecSend.begin(),
+                       {CScript() << OP_RETURN << ParseHex(""), platform_total, /*fSubtractFeeFromAmount=*/false});
+    } else {
+        vecSend = vecSend_in;
+    }
+
     // out variables, to be packed into returned result structure
     CAmount nFeeRet;
     int nChangePosInOut = change_pos;
@@ -1056,6 +1088,12 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         return util::Error{error};
     }
 
+    if (opt_assetLockPayload) {
+        txNew.nVersion = 3;
+        txNew.nType = TRANSACTION_ASSET_LOCK;
+        SetTxPayload(txNew, *opt_assetLockPayload);
+    }
+
     if (sign && !wallet.SignTransaction(txNew)) {
         return util::Error{_("Signing transaction failed")};
     }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 97c79ba5bf1e..f8ba6777755d 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -256,6 +256,7 @@ struct CRecipient
     CScript scriptPubKey;
     CAmount nAmount;
     bool fSubtractFeeFromAmount;
+    bool fPlatformTransfer{false};
 };
 
 struct WalletTxHasher
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 709cc386e7b5..ea3b21a62bf0 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -29,6 +29,7 @@
 )
 from test_framework.script import (
     CScript,
+    hash160,
     OP_RETURN,
 )
 from test_framework.script_util import (
@@ -42,6 +43,7 @@
     assert_greater_than_or_equal,
     softfork_active,
 )
+from test_framework.segwit_addr import encode_platform_p2pkh
 from test_framework.wallet_util import bytes_to_wif
 
 llmq_type_test = 106 # LLMQType::LLMQ_TEST_PLATFORM
@@ -63,7 +65,7 @@ def set_test_params(self):
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def create_assetlock(self, coin, amount, pubkey):
+    def create_assetlock(self, coin, amount, pubkey, version=1):
         node_wallet = self.nodes[0]
 
 
@@ -76,7 +78,7 @@ def create_assetlock(self, coin, amount, pubkey):
             credit_outputs.append(CTxOut(COIN, key_to_p2pkh_script(pubkey)))
         credit_outputs.append(CTxOut(tmp_amount, key_to_p2pkh_script(pubkey)))
 
-        lockTx_payload = CAssetLockTx(1, credit_outputs)
+        lockTx_payload = CAssetLockTx(version, credit_outputs)
 
         remaining = int(COIN * coin['amount']) - tiny_amount - amount
 
@@ -269,6 +271,7 @@ def run_test(self):
         self.test_withdrawal_limits(node_wallet, node, pubkey)
         self.test_mn_rr(node_wallet, node, pubkey)
         self.test_withdrawals_fork(node_wallet, node, pubkey)
+        self.test_asset_locks_v2_pre_v24(node_wallet, node, pubkey)
         self.test_v24_fork(node_wallet, node, pubkey)
 
 
@@ -706,8 +709,11 @@ def test_withdrawals_fork(self, node_wallet, node, pubkey):
     def test_v24_fork(self, node_wallet, node, pubkey):
         self.log.info("Testing asset unlock after 'v24' activation...")
         self.activate_by_name('v24', 750)
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
         self.log.info(f'post-v24 height: {node.getblockcount()} credit: {self.get_credit_pool_balance()}')
 
+        self.test_asset_locks_v2(node_wallet, node, pubkey)
+
         index = 601
         while index < 611:
             self.log.info(f"Generating new Asset Unlock tx, index={index}...")
@@ -758,6 +764,69 @@ def test_v24_fork(self, node_wallet, node, pubkey):
         tip_hash = self.generate(node, 1)[0]
         assert txid_in_block not in node.getblock(tip_hash)['tx']
 
+    def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
+        self.log.info("Testing asset lock v2 rejection before v24 activation...")
+        assert not softfork_active(node_wallet, 'v24')
+
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
+
+        coins = node_wallet.listunspent(query_options={'minimumAmount': 1})
+        coin = coins.pop()
+        lock_tx = self.create_assetlock(coin, COIN, pubkey, version=2)
+        self.check_mempool_result(tx=lock_tx,
+            result_expected={'allowed': False, 'reject-reason': 'bad-assetlocktx-version-2'})
+        self.log.info("v2 asset lock correctly rejected pre-v24")
+
+    def test_asset_locks_v2(self, node_wallet, node, pubkey):
+        self.log.info("Testing asset lock v2 after v24 activation...")
+        assert softfork_active(node_wallet, 'v24')
+
+        locked = self.get_credit_pool_balance()
+
+        self.log.info("Test v2 mempool acceptance, sendtoaddress, v1 compat, validateaddress...")
+        coins = node_wallet.listunspent(query_options={'minimumAmount': 1})
+
+        # v2 via raw construction
+        lock_tx_v2 = self.create_assetlock(coins.pop(), COIN, pubkey, version=2)
+        self.check_mempool_result(tx=lock_tx_v2,
+            result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
+        self.send_tx(lock_tx_v2)
+
+        # v2 via sendtoaddress (two different platform addresses)
+        platform_addr_from_key = encode_platform_p2pkh('tdash', hash160(pubkey))
+        txid1 = node_wallet.sendtoaddress(platform_addr_from_key, 1.0)
+
+        val = node_wallet.validateaddress(platform_addr_from_key)
+        assert_equal(val['isvalid'], True)
+        assert_equal(val['isplatform'], True)
+
+        # v1 still accepted post-v24
+        lock_tx_v1 = self.create_assetlock(coins.pop(), COIN, pubkey, version=1)
+        self.send_tx(lock_tx_v1)
+
+        # mine all at once
+        locked += node.getblocktemplate()['masternode'][0]['amount'] + 3 * COIN
+        self.generate(node, 1)
+        assert_equal(self.get_credit_pool_balance(), locked)
+
+        # verify v2 raw tx JSON
+        rpc_v2 = node.getrawtransaction(lock_tx_v2.rehash(), 1)
+        assert_equal(rpc_v2['assetLockTx']['version'], 2)
+        assert rpc_v2['assetLockTx']['creditOutputs'][0]['address'].startswith('tdash1')
+
+        # verify v2 sendtoaddress tx JSON
+        raw1 = node.getrawtransaction(txid1, 1)
+        assert_equal(raw1['type'], 8)
+        assert_equal(raw1['assetLockTx']['version'], 2)
+        assert_equal(raw1['assetLockTx']['creditOutputs'][0]['valueSat'], COIN)
+        assert_equal(raw1['assetLockTx']['creditOutputs'][0]['address'], platform_addr_from_key)
+        assert any(vout['scriptPubKey']['type'] == 'nulldata' and vout['valueSat'] == COIN for vout in raw1['vout'])
+
+        # verify v1 has no 'address' in JSON
+        rpc_v1 = node.getrawtransaction(lock_tx_v1.rehash(), 1)
+        assert_equal(rpc_v1['assetLockTx']['version'], 1)
+        assert 'address' not in rpc_v1['assetLockTx']['creditOutputs'][0]
+
 
 if __name__ == '__main__':
     AssetLocksTest().main()
diff --git a/test/functional/test_framework/segwit_addr.py b/test/functional/test_framework/segwit_addr.py
new file mode 100644
index 000000000000..16d5f5719431
--- /dev/null
+++ b/test/functional/test_framework/segwit_addr.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# Copyright (c) 2017 Pieter Wuille
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Reference implementation for Bech32/Bech32m and segwit addresses."""
+import unittest
+from enum import Enum
+
+CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+BECH32_CONST = 1
+BECH32M_CONST = 0x2bc830a3
+
+class Encoding(Enum):
+    """Enumeration type to list the various supported encodings."""
+    BECH32 = 1
+    BECH32M = 2
+
+
+def bech32_polymod(values):
+    """Internal function that computes the Bech32 checksum."""
+    generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    chk = 1
+    for value in values:
+        top = chk >> 25
+        chk = (chk & 0x1ffffff) << 5 ^ value
+        for i in range(5):
+            chk ^= generator[i] if ((top >> i) & 1) else 0
+    return chk
+
+
+def bech32_hrp_expand(hrp):
+    """Expand the HRP into values for checksum computation."""
+    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
+
+
+def bech32_verify_checksum(hrp, data):
+    """Verify a checksum given HRP and converted data characters."""
+    check = bech32_polymod(bech32_hrp_expand(hrp) + data)
+    if check == BECH32_CONST:
+        return Encoding.BECH32
+    elif check == BECH32M_CONST:
+        return Encoding.BECH32M
+    else:
+        return None
+
+def bech32_create_checksum(encoding, hrp, data):
+    """Compute the checksum values given HRP and data."""
+    values = bech32_hrp_expand(hrp) + data
+    const = BECH32M_CONST if encoding == Encoding.BECH32M else BECH32_CONST
+    polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ const
+    return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
+
+
+def bech32_encode(encoding, hrp, data):
+    """Compute a Bech32 or Bech32m string given HRP and data values."""
+    combined = data + bech32_create_checksum(encoding, hrp, data)
+    return hrp + '1' + ''.join([CHARSET[d] for d in combined])
+
+
+def bech32_decode(bech):
+    """Validate a Bech32/Bech32m string, and determine HRP and data."""
+    if ((any(ord(x) < 33 or ord(x) > 126 for x in bech)) or
+            (bech.lower() != bech and bech.upper() != bech)):
+        return (None, None, None)
+    bech = bech.lower()
+    pos = bech.rfind('1')
+    if pos < 1 or pos + 7 > len(bech) or len(bech) > 90:
+        return (None, None, None)
+    if not all(x in CHARSET for x in bech[pos+1:]):
+        return (None, None, None)
+    hrp = bech[:pos]
+    data = [CHARSET.find(x) for x in bech[pos+1:]]
+    encoding = bech32_verify_checksum(hrp, data)
+    if encoding is None:
+        return (None, None, None)
+    return (encoding, hrp, data[:-6])
+
+
+def convertbits(data, frombits, tobits, pad=True):
+    """General power-of-2 base conversion."""
+    acc = 0
+    bits = 0
+    ret = []
+    maxv = (1 << tobits) - 1
+    max_acc = (1 << (frombits + tobits - 1)) - 1
+    for value in data:
+        if value < 0 or (value >> frombits):
+            return None
+        acc = ((acc << frombits) | value) & max_acc
+        bits += frombits
+        while bits >= tobits:
+            bits -= tobits
+            ret.append((acc >> bits) & maxv)
+    if pad:
+        if bits:
+            ret.append((acc << (tobits - bits)) & maxv)
+    elif bits >= frombits or ((acc << (tobits - bits)) & maxv):
+        return None
+    return ret
+
+
+DIP18_TYPE_P2PKH = 0xb0
+DIP18_TYPE_P2SH = 0x80
+
+
+def encode_platform_p2pkh(hrp, keyhash):
+    """Encode a 20-byte keyhash as a DIP-18 Platform P2PKH bech32m address."""
+    assert len(keyhash) == 20
+    payload = [DIP18_TYPE_P2PKH] + list(keyhash)
+    data = convertbits(payload, 8, 5)
+    return bech32_encode(Encoding.BECH32M, hrp, data)
+
+
+def encode_platform_p2sh(hrp, scripthash):
+    """Encode a 20-byte scripthash as a DIP-18 Platform P2SH bech32m address."""
+    assert len(scripthash) == 20
+    payload = [DIP18_TYPE_P2SH] + list(scripthash)
+    data = convertbits(payload, 8, 5)
+    return bech32_encode(Encoding.BECH32M, hrp, data)
+
+
+def decode_platform_address(hrp, addr):
+    """Decode a DIP-18 bech32m platform address. Returns (type_byte, hash_bytes) or (None, None)."""
+    encoding, hrpgot, data = bech32_decode(addr)
+    if encoding != Encoding.BECH32M or hrpgot != hrp:
+        return (None, None)
+    payload = convertbits(data, 5, 8, pad=False)
+    if payload is None or len(payload) != 21:
+        return (None, None)
+    type_byte = payload[0]
+    if type_byte not in (DIP18_TYPE_P2PKH, DIP18_TYPE_P2SH):
+        return (None, None)
+    return (type_byte, bytes(payload[1:]))
+
+
+class TestFrameworkScript(unittest.TestCase):
+    def test_platform_encode_decode(self):
+        def test_platform_roundtrip(hrp, addr, expected_type):
+            typ, payload = decode_platform_address(hrp, addr)
+            self.assertIsNotNone(typ)
+            self.assertEqual(typ, expected_type)
+            if expected_type == DIP18_TYPE_P2PKH:
+                self.assertEqual(encode_platform_p2pkh(hrp, payload), addr)
+            else:
+                self.assertEqual(encode_platform_p2sh(hrp, payload), addr)
+
+        # DIP-18 P2PKH
+        test_platform_roundtrip('dash', 'dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs', DIP18_TYPE_P2PKH)
+        test_platform_roundtrip('tdash', 'tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7', DIP18_TYPE_P2PKH)
+        # DIP-18 P2SH
+        test_platform_roundtrip('dash', 'dash1sppl5xpu70aka8nacc4kj2htflydspzkxch4cad6', DIP18_TYPE_P2SH)
+        test_platform_roundtrip('tdash', 'tdash1sppl5xpu70aka8nacc4kj2htflydspzkxc8jtru5', DIP18_TYPE_P2SH)
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 90c8fbe8e49e..ff7b7998e932 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -83,6 +83,7 @@
     "crypto.poly1305",
     "crypto.ripemd160",
     "script",
+    "segwit_addr",
 ]
 
 EXTENDED_SCRIPTS = [