diff --git a/configure.ac b/configure.ac
index d36f8046cfa2..daf733fb2224 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2077,7 +2077,9 @@ CPPFLAGS="$CPPFLAGS_TEMP"
 if test -n "$use_sanitizers"; then
   export SECP_CFLAGS="$SECP_CFLAGS $SANITIZER_CFLAGS"
 fi
-ac_configure_args="${ac_configure_args} --disable-shared --with-pic --enable-benchmark=no --enable-module-recovery --disable-module-ecdh --disable-openssl-tests"
+dnl The ECDH module is required by the wallet's Platform key provider
+dnl (DashPay contact request encryption, wallet/platformkeys.cpp).
+ac_configure_args="${ac_configure_args} --disable-shared --with-pic --enable-benchmark=no --enable-module-recovery --enable-module-ecdh --disable-openssl-tests"
 AC_CONFIG_SUBDIRS([src/dashbls src/secp256k1])
 
 AC_OUTPUT
diff --git a/src/Makefile.am b/src/Makefile.am
index 0cf8ce802fdb..e99ab46d3f86 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -478,6 +478,8 @@ BITCOIN_CORE_H = \
   wallet/hdchain.h \
   wallet/ismine.h \
   wallet/load.h \
+  wallet/platformkeys.h \
+  wallet/platformtypes.h \
   wallet/receive.h \
   wallet/rpc/util.h \
   wallet/rpc/wallet.h \
@@ -709,6 +711,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/hdchain.cpp \
   wallet/interfaces.cpp \
   wallet/load.cpp \
+  wallet/platformkeys.cpp \
   wallet/receive.cpp \
   wallet/rpc/addresses.cpp \
   wallet/rpc/backup.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 805083ffeb5f..a3c8cb3aead3 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -224,6 +224,7 @@ if ENABLE_WALLET
 BITCOIN_TESTS += \
   wallet/test/bip39_tests.cpp \
   wallet/test/coinjoin_tests.cpp \
+  wallet/test/platformkeys_tests.cpp \
   wallet/test/psbt_wallet_tests.cpp \
   wallet/test/spend_tests.cpp \
   wallet/test/wallet_tests.cpp \
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 9fc779906135..6bcde7e75af5 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -15,6 +15,7 @@
 #include <util/message.h>
 #include <util/result.h>
 #include <util/ui_change_type.h>
+#include <wallet/platformtypes.h>
 
 #include <cstdint>
 #include <functional>
@@ -142,6 +143,26 @@ class Wallet
     //! Sign special transaction payload
     virtual bool signSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) = 0;
 
+    //! Derive and return a public Platform key. The mnemonic-owning key
+    //! manager performs derivation without exposing the wallet's root seed.
+    virtual wallet::PlatformKeyResult<CPubKey> getPlatformPubKey(const wallet::PlatformKeyRequest& request) = 0;
+
+    //! Sign a 32-byte digest with a platform key (compact/recoverable ECDSA,
+    //! as used by Platform state transitions).
+    virtual wallet::PlatformKeyResult<std::vector<unsigned char>> signPlatformDigest(const wallet::PlatformKeyRequest& request,
+                                                                                     const uint256& digest) = 0;
+
+    //! ECDH shared secret between the identity authentication key
+    //! and a counterparty public key, using the libsecp256k1 ECDH KDF.
+    virtual wallet::PlatformKeyResult<SecureVector> platformECDHSecret(const wallet::IdentityAuthKey& key,
+                                                                       const CPubKey& counterparty) = 0;
+
+    //! Ensure our private DIP-15 receiving chain is imported as a ranged
+    //! descriptor and return the corresponding public chain. Derivation,
+    //! descriptor update and result publication are one wallet-locked action.
+    virtual wallet::PlatformKeyResult<wallet::FriendshipXpub> ensureFriendshipReceivingKeychain(
+        const wallet::FriendshipKeychainRequest& request) = 0;
+
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CScript& script) = 0;
     virtual bool isSpendable(const CTxDestination& dest) = 0;
@@ -170,6 +191,14 @@ class Wallet
     //! Save or remove receive request.
     virtual bool setAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& value) = 0;
 
+    //! Write (or, with an empty value, erase) a generic Platform data
+    //! record. Records are persisted in the wallet database and travel with
+    //! backups; they are opaque to the wallet itself.
+    virtual bool writePlatformData(const std::string& key, const std::vector<unsigned char>& value) = 0;
+
+    //! All Platform data records whose key starts with prefix.
+    virtual std::map<std::string, std::vector<unsigned char>> getPlatformData(const std::string& prefix) = 0;
+
     //! Display address on external signer
     virtual bool displayAddress(const CTxDestination& dest) = 0;
 
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index bdf6252d868e..4454f256a0e3 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -187,6 +187,12 @@ struct PubkeyProvider
 
     /** Derive a private key, if private data is available in arg. */
     virtual bool GetPrivKey(int pos, const SigningProvider& arg, CKey& key) const = 0;
+
+    /** Return this key expression's root extended public key, if any. */
+    virtual bool GetRootExtPubKey(CExtPubKey& key) const { return false; }
+
+    /** Return this key expression's root extended private key, if available. */
+    virtual bool GetRootExtKey(const SigningProvider& arg, CExtKey& key) const { return false; }
 };
 
 class OriginPubkeyProvider final : public PubkeyProvider
@@ -238,6 +244,14 @@ class OriginPubkeyProvider final : public PubkeyProvider
     {
         return m_provider->GetPrivKey(pos, arg, key);
     }
+    bool GetRootExtPubKey(CExtPubKey& key) const override
+    {
+        return m_provider->GetRootExtPubKey(key);
+    }
+    bool GetRootExtKey(const SigningProvider& arg, CExtKey& key) const override
+    {
+        return m_provider->GetRootExtKey(arg, key);
+    }
 };
 
 /** An object representing a parsed constant public key in a descriptor. */
@@ -488,6 +502,15 @@ class BIP32PubkeyProvider final : public PubkeyProvider
         key = extkey.key;
         return true;
     }
+    bool GetRootExtPubKey(CExtPubKey& key) const override
+    {
+        key = m_root_extkey;
+        return true;
+    }
+    bool GetRootExtKey(const SigningProvider& arg, CExtKey& key) const override
+    {
+        return GetExtKey(arg, key);
+    }
 };
 
 /** Base class for all Descriptor implementations. */
@@ -597,6 +620,28 @@ class DescriptorImpl : public Descriptor
         return AddChecksum(ret);
     }
 
+    bool GetRootExtPubKey(CExtPubKey& out) const final
+    {
+        if (m_pubkey_args.size() == 1 && m_subdescriptor_args.empty()) {
+            return m_pubkey_args.front()->GetRootExtPubKey(out);
+        }
+        if (m_pubkey_args.empty() && m_subdescriptor_args.size() == 1) {
+            return m_subdescriptor_args.front()->GetRootExtPubKey(out);
+        }
+        return false;
+    }
+
+    bool GetRootExtKey(const SigningProvider& provider, CExtKey& out) const final
+    {
+        if (m_pubkey_args.size() == 1 && m_subdescriptor_args.empty()) {
+            return m_pubkey_args.front()->GetRootExtKey(provider, out);
+        }
+        if (m_pubkey_args.empty() && m_subdescriptor_args.size() == 1) {
+            return m_subdescriptor_args.front()->GetRootExtKey(provider, out);
+        }
+        return false;
+    }
+
     bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
     {
         bool ret = ToStringHelper(&arg, out, StringType::PRIVATE);
diff --git a/src/script/descriptor.h b/src/script/descriptor.h
index 505c44537b06..7b85eae51986 100644
--- a/src/script/descriptor.h
+++ b/src/script/descriptor.h
@@ -108,6 +108,14 @@ struct Descriptor {
     /** Convert the descriptor back to a string, undoing parsing. */
     virtual std::string ToString() const = 0;
 
+    /** Return the single extended public key at the root of this descriptor's
+     * key expression, if it has one. */
+    virtual bool GetRootExtPubKey(CExtPubKey& out) const { return false; }
+
+    /** Return the corresponding single extended private key when it is
+     * available from `provider`. */
+    virtual bool GetRootExtKey(const SigningProvider& provider, CExtKey& out) const { return false; }
+
     /** Whether this descriptor will return one scriptPubKey or multiple (aka is or is not combo) */
     virtual bool IsSingleType() const = 0;
 
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index 69c03ccddf71..83b1a6b23f12 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <key_io.h>
 #include <pubkey.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
@@ -11,6 +12,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <array>
 #include <optional>
 #include <string>
 #include <vector>
@@ -280,6 +282,33 @@ void Check(const std::string& prv, const std::string& pub, const std::string& no
 
 BOOST_FIXTURE_TEST_SUITE(descriptor_tests, BasicTestingSetup)
 
+BOOST_AUTO_TEST_CASE(descriptor_root_extended_key)
+{
+    const std::array<std::byte, 32> seed{std::byte{1}};
+    CExtKey root;
+    root.SetSeed(seed);
+
+    FlatSigningProvider keys;
+    std::string error;
+    auto descriptor{Parse("sh(pkh(" + EncodeExtKey(root) + "/0/*))", keys, error)};
+    BOOST_REQUIRE_MESSAGE(descriptor, error);
+
+    CExtPubKey root_pub;
+    BOOST_REQUIRE(descriptor->GetRootExtPubKey(root_pub));
+    BOOST_CHECK(root_pub == root.Neuter());
+
+    CExtKey root_priv;
+    BOOST_CHECK(!descriptor->GetRootExtKey(DUMMY_SIGNING_PROVIDER, root_priv));
+    BOOST_REQUIRE(descriptor->GetRootExtKey(keys, root_priv));
+    BOOST_CHECK(root_priv == root);
+
+    FlatSigningProvider constant_keys;
+    auto constant{Parse("pk(" + HexStr(root.key.GetPubKey()) + ")", constant_keys, error)};
+    BOOST_REQUIRE_MESSAGE(constant, error);
+    BOOST_CHECK(!constant->GetRootExtPubKey(root_pub));
+    BOOST_CHECK(!constant->GetRootExtKey(keys, root_priv));
+}
+
 BOOST_AUTO_TEST_CASE(descriptor_test)
 {
     // Basic single-key compressed
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 4af755044de8..64f8bc88b0e7 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -5,6 +5,7 @@
 #include <interfaces/wallet.h>
 
 #include <chain.h>
+#include <chainparams.h>
 #include <coinjoin/client.h>
 #include <consensus/amount.h>
 #include <interfaces/chain.h>
@@ -33,6 +34,7 @@
 #include <wallet/wallet.h>
 #include <wallet/hdchain.h>
 #include <wallet/scriptpubkeyman.h>
+#include <wallet/walletutil.h>
 #include <evo/deterministicmns.h>
 #include <masternode/sync.h>
 #include <txdb.h>
@@ -239,6 +241,25 @@ class WalletImpl : public Wallet
     {
         return m_wallet->SignSpecialTxPayload(hash, keyid, vchSig);
     }
+    wallet::PlatformKeyResult<CPubKey> getPlatformPubKey(const wallet::PlatformKeyRequest& request) override
+    {
+        return m_wallet->GetPlatformPubKey(request);
+    }
+    wallet::PlatformKeyResult<std::vector<unsigned char>> signPlatformDigest(const wallet::PlatformKeyRequest& request,
+                                                                             const uint256& digest) override
+    {
+        return m_wallet->SignPlatformDigest(request, digest);
+    }
+    wallet::PlatformKeyResult<SecureVector> platformECDHSecret(const wallet::IdentityAuthKey& key,
+                                                               const CPubKey& counterparty) override
+    {
+        return m_wallet->PlatformECDHSecret(key, counterparty);
+    }
+    wallet::PlatformKeyResult<wallet::FriendshipXpub> ensureFriendshipReceivingKeychain(
+        const wallet::FriendshipKeychainRequest& request) override
+    {
+        return m_wallet->EnsureFriendshipReceivingKeychain(request);
+    }
     bool isSpendable(const CScript& script) override
     {
         LOCK(m_wallet->cs_wallet);
@@ -316,6 +337,16 @@ class WalletImpl : public Wallet
         return value.empty() ? m_wallet->EraseAddressReceiveRequest(batch, dest, id)
                              : m_wallet->SetAddressReceiveRequest(batch, dest, id, value);
     }
+    bool writePlatformData(const std::string& key, const std::vector<unsigned char>& value) override
+    {
+        LOCK(m_wallet->cs_wallet);
+        return m_wallet->WritePlatformData(key, value);
+    }
+    std::map<std::string, std::vector<unsigned char>> getPlatformData(const std::string& prefix) override
+    {
+        LOCK(m_wallet->cs_wallet);
+        return m_wallet->GetPlatformData(prefix);
+    }
     bool displayAddress(const CTxDestination& dest) override
     {
         LOCK(m_wallet->cs_wallet);
diff --git a/src/wallet/platformkeys.cpp b/src/wallet/platformkeys.cpp
new file mode 100644
index 000000000000..aa188969c7ed
--- /dev/null
+++ b/src/wallet/platformkeys.cpp
@@ -0,0 +1,161 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <wallet/platformkeys.h>
+
+#include <secp256k1.h>
+#include <secp256k1_ecdh.h>
+
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
+
+namespace wallet::platformkeys {
+
+Path IdentityAuthKeyPath(uint32_t coin_type, uint32_t identity_index, uint32_t key_index)
+{
+    // dashj DerivationPathFactory.blockchainIdentityECDSADerivationPath(index):
+    // m/9'/coin'/5'/0'(sub-feature)/0'(key type ECDSA)/identity'/key'
+    return {
+        PathElement::Hardened(FEATURE_PURPOSE),
+        PathElement::Hardened(coin_type),
+        PathElement::Hardened(FEATURE_IDENTITIES),
+        PathElement::Hardened(IDENTITY_AUTHENTICATION),
+        PathElement::Hardened(AUTH_KEY_TYPE_ECDSA),
+        PathElement::Hardened(identity_index),
+        PathElement::Hardened(key_index),
+    };
+}
+
+Path PlatformKeyPath(uint32_t coin_type, const PlatformKeyRequest& request)
+{
+    return std::visit(
+        [coin_type](const auto& key) -> Path {
+            using Key = std::decay_t<decltype(key)>;
+            if constexpr (std::is_same_v<Key, IdentityAuthKey>) {
+                return IdentityAuthKeyPath(coin_type, key.identity_index, key.key_index);
+            } else {
+                uint32_t subfeature;
+                PathElement index;
+                if constexpr (std::is_same_v<Key, RegistrationFundingKey>) {
+                    subfeature = IDENTITY_REGISTRATION_FUNDING;
+                    index = PathElement::Normal(key.identity_index);
+                } else if constexpr (std::is_same_v<Key, TopupFundingKey>) {
+                    subfeature = IDENTITY_TOPUP_FUNDING;
+                    index = PathElement::Normal(key.funding_index);
+                } else {
+                    static_assert(std::is_same_v<Key, InvitationFundingKey>);
+                    subfeature = IDENTITY_INVITATION_FUNDING;
+                    index = PathElement::Hardened(key.invitation_index);
+                }
+                return {
+                    PathElement::Hardened(FEATURE_PURPOSE),
+                    PathElement::Hardened(coin_type),
+                    PathElement::Hardened(FEATURE_IDENTITIES),
+                    PathElement::Hardened(subfeature),
+                    index,
+                };
+            }
+        },
+        request);
+}
+
+Path FriendshipPath(uint32_t coin_type, uint32_t account, Span<const uint8_t> user_a_id, Span<const uint8_t> user_b_id)
+{
+    // dashj FriendKeyChain.getContactPath():
+    // m/9'/coin'/15'/account'/identity_a/identity_b with two 256-bit ids
+    // NOT hardened (DIP-14/DIP-15), enabling watch-only xpub derivation.
+    assert(user_a_id.size() == 32);
+    assert(user_b_id.size() == 32);
+    std::array<uint8_t, 32> a, b;
+    std::copy(user_a_id.begin(), user_a_id.end(), a.begin());
+    std::copy(user_b_id.begin(), user_b_id.end(), b.begin());
+    return {
+        PathElement::Hardened(FEATURE_PURPOSE),
+        PathElement::Hardened(coin_type),
+        PathElement::Hardened(FEATURE_DASHPAY),
+        PathElement::Hardened(account),
+        PathElement::Normal256(a),
+        PathElement::Normal256(b),
+    };
+}
+
+bool DeriveExtKey(const CExtKey& parent, const Path& path, ExtKey256& out)
+{
+    out = {};
+    if (!parent.key.IsValid()) return false;
+
+    CKey key{parent.key};
+    ChainCode chaincode{parent.chaincode};
+
+    for (const auto& element : path) {
+        CKey child_key;
+        ChainCode child_cc;
+        bool ok{false};
+        if (const auto* index32 = std::get_if<uint32_t>(&element.index)) {
+            if (*index32 >> 31) return false; // must use the hardened flag instead
+            ok = key.Derive(child_key, child_cc, *index32 | (element.hardened ? 0x80000000u : 0), chaincode);
+        } else {
+            const auto& index256 = std::get<std::array<uint8_t, 32>>(element.index);
+            ok = key.Derive256(child_key, child_cc, index256, element.hardened, chaincode);
+        }
+        if (!ok) return false;
+        key = child_key;
+        chaincode = child_cc;
+    }
+
+    out.key = key;
+    out.chaincode = chaincode;
+    return true;
+}
+
+bool DerivePubKey(const ExtPubKey256& parent, const PathElement& element, ExtPubKey256& out)
+{
+    // CPubKey::Derive() asserts a valid compressed parent; contact xpubs are
+    // externally supplied, so reject them here instead. A syntactically
+    // compressed but invalid curve point is caught by pubkey parsing inside.
+    if (element.hardened || !parent.pubkey.IsCompressed()) return false;
+    if (const auto* index32 = std::get_if<uint32_t>(&element.index)) {
+        if (*index32 >> 31) return false;
+        return parent.pubkey.Derive(out.pubkey, out.chaincode, *index32, parent.chaincode);
+    }
+    const auto& index256 = std::get<std::array<uint8_t, 32>>(element.index);
+    return parent.pubkey.Derive256(out.pubkey, out.chaincode, index256, parent.chaincode);
+}
+
+bool ComputeECDHSecret(const CKey& key, const CPubKey& counterparty, SecureVector& secret_out)
+{
+    if (!key.IsValid() || !counterparty.IsValid()) return false;
+
+    secp256k1_pubkey pubkey;
+    if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, counterparty.data(), counterparty.size())) {
+        return false;
+    }
+
+    secret_out.assign(32, 0);
+    // Default KDF: SHA256 of the compressed shared point — identical to
+    // dashj's Secp256k1ECDHAgreement (DashPay contact request encryption).
+    if (!secp256k1_ecdh(secp256k1_context_static, secret_out.data(), &pubkey,
+                        UCharCast(key.begin()), nullptr, nullptr)) {
+        secret_out.clear();
+        return false;
+    }
+    return true;
+}
+
+} // namespace wallet::platformkeys
+
+namespace wallet {
+
+bool DeriveFriendshipPaymentDestination(const FriendshipXpub& xpub, uint32_t index, CTxDestination& destination_out)
+{
+    platformkeys::ExtPubKey256 child;
+    if (!platformkeys::DerivePubKey({xpub.pubkey, xpub.chaincode}, platformkeys::PathElement::Normal(index), child)) {
+        return false;
+    }
+    destination_out = PKHash{child.pubkey};
+    return true;
+}
+
+} // namespace wallet
diff --git a/src/wallet/platformkeys.h b/src/wallet/platformkeys.h
new file mode 100644
index 000000000000..aeeeebc59fff
--- /dev/null
+++ b/src/wallet/platformkeys.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_WALLET_PLATFORMKEYS_H
+#define BITCOIN_WALLET_PLATFORMKEYS_H
+
+#include <key.h>
+#include <pubkey.h>
+#include <span.h>
+#include <support/allocators/secure.h>
+#include <wallet/platformtypes.h>
+
+#include <array>
+#include <cstdint>
+#include <variant>
+#include <vector>
+
+/**
+ * Dash Platform (DIP-9/13/14/15) key derivation for the wallet.
+ *
+ * This is pure BIP32/DIP-14 key math: it knows nothing about Platform
+ * documents, contracts or the network. It is only used through the
+ * interfaces::Wallet platform key provider methods.
+ *
+ * References:
+ *  - DIP-9  feature-purpose derivation (m/9'/...)
+ *  - DIP-13 identity keys (m/9'/coin'/5'/...)
+ *  - DIP-14 256-bit child indexes (CKey::Derive256)
+ *  - DIP-15 DashPay friendship keychains (m/9'/coin'/15'/account'/idA/idB)
+ *  - dashj DerivationPathFactory.java / FriendKeyChain.java (reference impl)
+ */
+namespace wallet::platformkeys {
+
+//! One component of a derivation path: a 31-bit BIP32 index or a DIP-14
+//! 256-bit index (big-endian bytes), plus a hardened flag.
+struct PathElement {
+    std::variant<uint32_t, std::array<uint8_t, 32>> index;
+    bool hardened{false};
+
+    static PathElement Hardened(uint32_t i) { return {i, true}; }
+    static PathElement Normal(uint32_t i) { return {i, false}; }
+    static PathElement Normal256(const std::array<uint8_t, 32>& i) { return {i, false}; }
+};
+using Path = std::vector<PathElement>;
+
+// DIP-9 feature purpose, and DIP-13/DIP-15 feature types under it.
+inline constexpr uint32_t FEATURE_PURPOSE{9};
+inline constexpr uint32_t FEATURE_IDENTITIES{5}; // DIP-13
+inline constexpr uint32_t FEATURE_DASHPAY{15};   // DIP-15
+
+// DIP-13 sub-features: m/9'/coin'/5'/<subfeature>'
+inline constexpr uint32_t IDENTITY_AUTHENTICATION{0};
+inline constexpr uint32_t IDENTITY_REGISTRATION_FUNDING{1};
+inline constexpr uint32_t IDENTITY_TOPUP_FUNDING{2};
+inline constexpr uint32_t IDENTITY_INVITATION_FUNDING{3};
+
+// DIP-13 authentication key types: m/9'/coin'/5'/0'/<keytype>'
+inline constexpr uint32_t AUTH_KEY_TYPE_ECDSA{0};
+inline constexpr uint32_t AUTH_KEY_TYPE_BLS{1};
+
+//! An extended key produced by walking a (possibly 256-bit) derivation path.
+//! Unlike CExtKey this does not carry BIP32 serialization metadata; DIP-14
+//! extended-key serialization tracks the path separately.
+struct ExtKey256 {
+    CKey key;
+    ChainCode chaincode;
+
+    ExtKey256() = default;
+};
+
+struct ExtPubKey256 {
+    CPubKey pubkey;
+    ChainCode chaincode;
+};
+
+//! m/9'/coin'/5'/0'/0'/<identity>'/<key>' — ECDSA identity authentication key
+//! (all components hardened; key 0 = MASTER, key 1 = HIGH security level).
+Path IdentityAuthKeyPath(uint32_t coin_type, uint32_t identity_index, uint32_t key_index);
+
+//! Convert a typed Platform key request to its DIP-13 derivation path.
+Path PlatformKeyPath(uint32_t coin_type, const PlatformKeyRequest& request);
+
+//! m/9'/coin'/15'/<account>'/<identity_a>/<identity_b> — DIP-15 friendship keychain
+//! root. The two 256-bit identity ids are NOT hardened (this is what allows
+//! watch-only derivation from an exported xpub); the receiving chain is
+//! (userA = my id, userB = their id), the sending chain is the reverse.
+Path FriendshipPath(uint32_t coin_type, uint32_t account, Span<const uint8_t> user_a_id, Span<const uint8_t> user_b_id);
+
+//! Derive the extended key at `path` from a BIP32 extended private key.
+//! Returns false if the parent key or any derivation step is invalid.
+[[nodiscard]] bool DeriveExtKey(const CExtKey& parent, const Path& path, ExtKey256& out);
+
+//! Derive a (non-hardened) child extended pubkey. Fails on hardened steps.
+[[nodiscard]] bool DerivePubKey(const ExtPubKey256& parent, const PathElement& element, ExtPubKey256& out);
+
+//! ECDH shared secret between `key` and `counterparty`, using the libsecp256k1
+//! ECDH KDF (SHA256 of the compressed shared point). This matches dashj's
+//! KeyCrypterECDH / Secp256k1ECDHAgreement, used for DashPay contact request
+//! encryption. Returns a 32-byte secret.
+[[nodiscard]] bool ComputeECDHSecret(const CKey& key, const CPubKey& counterparty, SecureVector& secret_out);
+
+} // namespace wallet::platformkeys
+
+#endif // BITCOIN_WALLET_PLATFORMKEYS_H
diff --git a/src/wallet/platformtypes.h b/src/wallet/platformtypes.h
new file mode 100644
index 000000000000..2c9e9913be00
--- /dev/null
+++ b/src/wallet/platformtypes.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_WALLET_PLATFORMTYPES_H
+#define BITCOIN_WALLET_PLATFORMTYPES_H
+
+#include <pubkey.h>
+#include <script/standard.h>
+#include <support/allocators/secure.h>
+#include <uint256.h>
+
+#include <cstdint>
+#include <variant>
+
+namespace wallet {
+
+enum class PlatformKeyStatus : uint8_t {
+    SUCCESS,
+    NOT_SUPPORTED,
+    WALLET_LOCKED,
+    AMBIGUOUS_SOURCE,
+    INVALID_SOURCE,
+    INVALID_ARGUMENT,
+    IMPORT_ERROR,
+    DERIVATION_ERROR,
+};
+
+template <typename T>
+struct PlatformKeyResult {
+    PlatformKeyStatus status{PlatformKeyStatus::DERIVATION_ERROR};
+    T value{};
+
+    explicit operator bool() const { return status == PlatformKeyStatus::SUCCESS; }
+};
+
+struct IdentityAuthKey {
+    uint32_t identity_index{0};
+    uint32_t key_index{0};
+};
+
+struct RegistrationFundingKey {
+    uint32_t identity_index{0};
+};
+
+struct TopupFundingKey {
+    uint32_t funding_index{0};
+};
+
+struct InvitationFundingKey {
+    uint32_t invitation_index{0};
+};
+
+using PlatformKeyRequest = std::variant<IdentityAuthKey, RegistrationFundingKey, TopupFundingKey, InvitationFundingKey>;
+
+struct FriendshipKeychainRequest {
+    uint32_t account{0};
+    uint256 local_id;
+    uint256 remote_id;
+    int64_t birth_time{0}; //!< 0 means unknown/genesis.
+};
+
+struct FriendshipXpub {
+    CPubKey pubkey;
+    ChainCode chaincode;
+};
+
+//! Derive one contact payment destination from a DIP-15 friendship xpub.
+//! This is public-only key math and does not require a wallet instance.
+bool DeriveFriendshipPaymentDestination(const FriendshipXpub& xpub, uint32_t index, CTxDestination& destination_out);
+
+} // namespace wallet
+
+#endif // BITCOIN_WALLET_PLATFORMTYPES_H
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index fcd9bbd5c6aa..a0081adf39d6 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <key_io.h>
 #include <chainparams.h>
+#include <key_io.h>
 #include <logging.h>
 #include <messagesigner.h>
 #include <script/descriptor.h>
@@ -16,6 +16,8 @@
 #include <wallet/bip39.h>
 #include <wallet/scriptpubkeyman.h>
 
+#include <array>
+
 namespace wallet {
 util::Result<CTxDestination> LegacyScriptPubKeyMan::GetNewDestination()
 {
@@ -2716,6 +2718,69 @@ bool DescriptorScriptPubKeyMan::SignSpecialTxPayload(const uint256& hash, const
     return CHashSigner::SignHash(hash, key, vchSig);
 }
 
+namespace {
+
+bool IsRootExtPubKey(const CExtPubKey& key)
+{
+    return key.nDepth == 0 && key.nChild == 0 &&
+           std::all_of(std::begin(key.vchFingerprint), std::end(key.vchFingerprint),
+                       [](unsigned char byte) { return byte == 0; }) &&
+           key.pubkey.IsFullyValid();
+}
+
+} // namespace
+
+PlatformKeyStatus DescriptorScriptPubKeyMan::GetPlatformKeySource(std::vector<unsigned char>& identifier) const
+{
+    LOCK(cs_desc_man);
+
+    if (!m_wallet_descriptor.descriptor) return PlatformKeyStatus::NOT_SUPPORTED;
+    CExtPubKey root;
+    if (!m_wallet_descriptor.descriptor->GetRootExtPubKey(root) || !IsRootExtPubKey(root)) {
+        return PlatformKeyStatus::NOT_SUPPORTED;
+    }
+    const CKeyID source_id{root.pubkey.GetID()};
+    if (m_map_keys.count(source_id) == 0 && m_map_crypted_keys.count(source_id) == 0) {
+        return PlatformKeyStatus::NOT_SUPPORTED;
+    }
+
+    // Prefix descriptor sources so identifiers from future key-manager
+    // implementations cannot accidentally compare equal.
+    std::array<unsigned char, BIP32_EXTKEY_SIZE> encoded;
+    root.Encode(encoded.data());
+    identifier.assign(1, 1);
+    identifier.insert(identifier.end(), encoded.begin(), encoded.end());
+    return PlatformKeyStatus::SUCCESS;
+}
+
+PlatformKeyStatus DescriptorScriptPubKeyMan::DerivePlatformKey(const platformkeys::Path& path,
+                                                               platformkeys::ExtKey256& out) const
+{
+    out = {};
+    if (path.empty()) return PlatformKeyStatus::INVALID_ARGUMENT;
+
+    std::vector<unsigned char> identifier;
+    const auto source_status{GetPlatformKeySource(identifier)};
+    if (source_status != PlatformKeyStatus::SUCCESS) return source_status;
+    if (m_storage.IsLocked(false)) return PlatformKeyStatus::WALLET_LOCKED;
+
+    LOCK(cs_desc_man);
+    FlatSigningProvider provider;
+    provider.keys = GetKeys();
+    CExtPubKey root_pub;
+    CExtKey root;
+    if (!m_wallet_descriptor.descriptor ||
+        !m_wallet_descriptor.descriptor->GetRootExtPubKey(root_pub) ||
+        !m_wallet_descriptor.descriptor->GetRootExtKey(provider, root)) {
+        return PlatformKeyStatus::INVALID_SOURCE;
+    }
+
+    if (!IsRootExtPubKey(root_pub) || !root.key.IsValid() || root.Neuter() != root_pub) {
+        return PlatformKeyStatus::INVALID_SOURCE;
+    }
+    return platformkeys::DeriveExtKey(root, path, out) ? PlatformKeyStatus::SUCCESS : PlatformKeyStatus::DERIVATION_ERROR;
+}
+
 TransactionError DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
 {
     if (n_signed) {
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 2cf6805ff52d..b2e0aba3e45f 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -17,6 +17,7 @@
 #include <wallet/crypter.h>
 #include <wallet/hdchain.h>
 #include <wallet/ismine.h>
+#include <wallet/platformkeys.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
@@ -234,6 +235,16 @@ class ScriptPubKeyMan
     /** Sign a message with the given script */
     virtual SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const { return SigningResult::SIGNING_FAILED; };
     virtual bool SignSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) const { return false; }
+    //! Return an unlock-free identifier for this manager's root extended key.
+    virtual PlatformKeyStatus GetPlatformKeySource(std::vector<unsigned char>& identifier) const
+    {
+        return PlatformKeyStatus::NOT_SUPPORTED;
+    }
+    //! Derive one Platform child without exposing the root extended key.
+    virtual PlatformKeyStatus DerivePlatformKey(const platformkeys::Path& path, platformkeys::ExtKey256& out) const
+    {
+        return PlatformKeyStatus::NOT_SUPPORTED;
+    }
     /** Adds script and derivation path information to a PSBT, and optionally signs it. */
     virtual TransactionError FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, int sighash_type = 1 /* SIGHASH_ALL */, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const { return TransactionError::INVALID_PSBT; }
 
@@ -643,6 +654,8 @@ class DescriptorScriptPubKeyMan : public ScriptPubKeyMan
     bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const override;
     SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const override;
     bool SignSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) const override;
+    PlatformKeyStatus GetPlatformKeySource(std::vector<unsigned char>& identifier) const override;
+    PlatformKeyStatus DerivePlatformKey(const platformkeys::Path& path, platformkeys::ExtKey256& out) const override;
     TransactionError FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, int sighash_type = 1 /* SIGHASH_ALL */, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const override;
 
     uint256 GetID() const override;
diff --git a/src/wallet/test/platformkeys_tests.cpp b/src/wallet/test/platformkeys_tests.cpp
new file mode 100644
index 000000000000..3472349c014b
--- /dev/null
+++ b/src/wallet/test/platformkeys_tests.cpp
@@ -0,0 +1,746 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chainparams.h>
+#include <interfaces/coinjoin.h>
+#include <interfaces/wallet.h>
+#include <key.h>
+#include <key_io.h>
+#include <script/descriptor.h>
+#include <script/signingprovider.h>
+#include <script/standard.h>
+#include <test/util/setup_common.h>
+#include <util/strencodings.h>
+#include <wallet/bip39.h>
+#include <wallet/coincontrol.h>
+#include <wallet/context.h>
+#include <wallet/platformkeys.h>
+#include <wallet/scriptpubkeyman.h>
+#include <wallet/spend.h>
+#include <wallet/wallet.h>
+#include <wallet/walletdb.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <array>
+#include <optional>
+#include <set>
+#include <vector>
+
+using namespace wallet;
+using namespace wallet::platformkeys;
+
+BOOST_FIXTURE_TEST_SUITE(platformkeys_tests, BasicTestingSetup)
+
+//! Seed shared by all DIP-14 test vectors (dashpay/dips dip-0014.md), from
+//! mnemonic "birth kingdom trash renew flavor utility donkey gasp regular
+//! alert pave layer".
+static SecureVector Dip14Seed()
+{
+    const std::vector<unsigned char> seed{ParseHex(
+        "b16d3782e714da7c55a397d5f19104cfed7ffa8036ac514509bbb50807f8ac59"
+        "8eeb26f0797bd8cc221a6cbff2168d90a5e9ee025a5bd977977b9eccd97894bb")};
+    return SecureVector{seed.begin(), seed.end()};
+}
+
+static CExtKey Dip14Master()
+{
+    const SecureVector seed{Dip14Seed()};
+    CExtKey master;
+    master.SetSeed(MakeByteSpan(seed));
+    return master;
+}
+
+static std::array<uint8_t, 32> Arr32(const std::string& hex)
+{
+    const std::vector<unsigned char> v{ParseHex(hex)};
+    BOOST_REQUIRE_EQUAL(v.size(), 32U);
+    std::array<uint8_t, 32> out;
+    std::copy(v.begin(), v.end(), out.begin());
+    return out;
+}
+
+static std::string DerivedKeyHex(const Path& path)
+{
+    ExtKey256 out;
+    BOOST_REQUIRE(DeriveExtKey(Dip14Master(), path, out));
+    return HexStr(Span{out.key.begin(), out.key.size()});
+}
+
+// DIP-14 test vector 1: m/<id1>/<id2>'/<id3>/0
+BOOST_AUTO_TEST_CASE(dip14_vector_1)
+{
+    const Path path{
+        PathElement::Normal256(Arr32("775d3854c910b7dee436869c4724bed2fe0784e198b8a39f02bbb49d8ebcfc3b")),
+        PathElement{Arr32("f537439f36d04a15474ff7423e4b904a14373fafb37a41db74c84f1dbb5c89a6"), true},
+        PathElement::Normal256(Arr32("4c4592ca670c983fc43397dfd21a6f427fac9b4ac53cb4dcdc6522ec51e81e79")),
+        PathElement::Normal(0),
+    };
+    BOOST_CHECK_EQUAL(DerivedKeyHex(path), "e8781fdef72862968cd9a4d2df34edaf9dcc5b17629ec505f0d2d1a8ed6f9f09");
+}
+
+// DIP-14 test vector 2: m/9'/5'/15'/0'/<idA>'/<idB>'/0 (DIP-15 shape)
+BOOST_AUTO_TEST_CASE(dip14_vector_2)
+{
+    const Path path{
+        PathElement::Hardened(9),
+        PathElement::Hardened(5),
+        PathElement::Hardened(15),
+        PathElement::Hardened(0),
+        PathElement{Arr32("555d3854c910b7dee436869c4724bed2fe0784e198b8a39f02bbb49d8ebcfc3a"), true},
+        PathElement{Arr32("a137439f36d04a15474ff7423e4b904a14373fafb37a41db74c84f1dbb5c89b5"), true},
+        PathElement::Normal(0),
+    };
+    BOOST_CHECK_EQUAL(DerivedKeyHex(path), "fac40790776d171ee1db90899b5eb2df2f7d2aaf35ad56f07ffb8ed2c57f8e60");
+}
+
+// DIP-14 test vector 3: m/<id> (single 256-bit non-hardened step)
+BOOST_AUTO_TEST_CASE(dip14_vector_3)
+{
+    const Path path{
+        PathElement::Normal256(Arr32("775d3854c910b7dee436869c4724bed2fe0784e198b8a39f02bbb49d8ebcfc3b")),
+    };
+    BOOST_CHECK_EQUAL(DerivedKeyHex(path), "f6a95ae75ea8362d9478932f71b262b3d981918fe030316686a475dea4889938");
+}
+
+// DIP-14 test vector 4: m/<id1>/<id2>'
+BOOST_AUTO_TEST_CASE(dip14_vector_4)
+{
+    const Path path{
+        PathElement::Normal256(Arr32("775d3854c910b7dee436869c4724bed2fe0784e198b8a39f02bbb49d8ebcfc3b")),
+        PathElement{Arr32("f537439f36d04a15474ff7423e4b904a14373fafb37a41db74c84f1dbb5c89a6"), true},
+    };
+    BOOST_CHECK_EQUAL(DerivedKeyHex(path), "b898ad92d3a0698bc3117d3777d82676673816ce52f4fc2f1263a2f676825f90");
+}
+
+//! Non-hardened 256-bit public derivation must match private derivation
+//! (this is what lets a contact derive our friendship addresses from an
+//! exported xpub).
+BOOST_AUTO_TEST_CASE(dip14_public_derivation_matches)
+{
+    const Path parent_path{
+        PathElement::Hardened(9),
+        PathElement::Hardened(1),
+        PathElement::Hardened(15),
+        PathElement::Hardened(0),
+    };
+    ExtKey256 parent;
+    BOOST_REQUIRE(DeriveExtKey(Dip14Master(), parent_path, parent));
+
+    const auto id_a{Arr32("555d3854c910b7dee436869c4724bed2fe0784e198b8a39f02bbb49d8ebcfc3a")};
+    const auto id_b{Arr32("a137439f36d04a15474ff7423e4b904a14373fafb37a41db74c84f1dbb5c89b5")};
+
+    // Private side: parent/idA/idB
+    Path leaf_path{parent_path};
+    leaf_path.push_back(PathElement::Normal256(id_a));
+    leaf_path.push_back(PathElement::Normal256(id_b));
+    ExtKey256 leaf;
+    BOOST_REQUIRE(DeriveExtKey(Dip14Master(), leaf_path, leaf));
+
+    // Public side: neuter parent, then derive idA/idB
+    ExtPubKey256 pub_parent{parent.key.GetPubKey(), parent.chaincode};
+    ExtPubKey256 pub_mid, pub_leaf;
+    BOOST_REQUIRE(DerivePubKey(pub_parent, PathElement::Normal256(id_a), pub_mid));
+    BOOST_REQUIRE(DerivePubKey(pub_mid, PathElement::Normal256(id_b), pub_leaf));
+
+    BOOST_CHECK(pub_leaf.pubkey == leaf.key.GetPubKey());
+    BOOST_CHECK(pub_leaf.chaincode == leaf.chaincode);
+
+    // Hardened steps must be rejected on the public side.
+    ExtPubKey256 unused;
+    BOOST_CHECK(!DerivePubKey(pub_parent, PathElement{id_a, true}, unused));
+    BOOST_CHECK(!DerivePubKey(pub_parent, PathElement::Hardened(0), unused));
+
+    // Invalid or uncompressed parents (contact xpubs are externally supplied)
+    // must fail instead of tripping CPubKey::Derive() asserts.
+    const ExtPubKey256 invalid_parent{CPubKey{}, parent.chaincode};
+    BOOST_CHECK(!DerivePubKey(invalid_parent, PathElement::Normal(0), unused));
+    CKey uncompressed_key;
+    uncompressed_key.MakeNewKey(/*fCompressed=*/false);
+    const ExtPubKey256 uncompressed_parent{uncompressed_key.GetPubKey(), parent.chaincode};
+    BOOST_CHECK(!DerivePubKey(uncompressed_parent, PathElement::Normal(0), unused));
+    BOOST_CHECK(!DerivePubKey(uncompressed_parent, PathElement::Normal256(id_a), unused));
+}
+
+//! Cross-implementation vector: the same friendship path derived by
+//! rust-dashcore's key-wallet crate (`key_wallet::bip32` with
+//! `ChildNumber::Normal256` — the derivation backend behind
+//! dashwallet-ios/android via rs-platform-wallet) from this seed and these
+//! identity ids yields exactly these key bytes. The identity ids are
+//! asymmetric byte sequences, so a byte-order reversal anywhere between the
+//! raw Platform identifier bytes and the DIP-14 256-bit index would change
+//! the result; symmetric fixtures cannot catch that. Identifier bytes enter
+//! the path exactly as Platform serves them (big-endian number, the same
+//! bytes base58-encoded in identity ids) — callers must not round-trip them
+//! through uint256S() of a natural-order hex string, which reverses.
+//! Vector generated with key-wallet at rust-dashcore 36b49cb7f9c0:
+//!   seed = Dip14Seed(), path m/9'/1'/15'/0'/(id_a)/(id_b).
+BOOST_AUTO_TEST_CASE(friendship_derivation_matches_key_wallet)
+{
+    std::array<uint8_t, 32> id_a, id_b;
+    for (size_t i{0}; i < 32; ++i) {
+        id_a[i] = static_cast<uint8_t>(i);          // 000102..1f
+        id_b[i] = static_cast<uint8_t>(0xff - i);   // fffefd..e0
+    }
+    const auto path{FriendshipPath(/*coin_type=*/1, /*account=*/0, id_a, id_b)};
+    ExtKey256 out;
+    BOOST_REQUIRE(DeriveExtKey(Dip14Master(), path, out));
+    BOOST_CHECK_EQUAL(HexStr(Span{out.key.begin(), out.key.size()}),
+                      "815adcfab00d029d50a044a255cebc510fe6800c46082cf679dae8c46ca5e1f5");
+    BOOST_CHECK_EQUAL(HexStr(out.chaincode),
+                      "1ed00e776865c0308fddae8d22fb3ae47ffd51ce409b298d1987aafdec6bef6b");
+    BOOST_CHECK_EQUAL(HexStr(out.key.GetPubKey()),
+                      "025b4ff1b10b9e1990df46dfa2f986300a7e6eb4a85289f4419581950edd3760bf");
+}
+
+//! ECDH secrets must be symmetric and match the libsecp256k1 KDF
+//! (SHA256 of compressed shared point), as used by DashPay contact requests.
+BOOST_AUTO_TEST_CASE(ecdh_symmetry)
+{
+    CKey a, b;
+    a.MakeNewKey(/*fCompressed=*/true);
+    b.MakeNewKey(/*fCompressed=*/true);
+
+    SecureVector s_ab, s_ba;
+    BOOST_REQUIRE(ComputeECDHSecret(a, b.GetPubKey(), s_ab));
+    BOOST_REQUIRE(ComputeECDHSecret(b, a.GetPubKey(), s_ba));
+    BOOST_CHECK_EQUAL(s_ab.size(), 32U);
+    BOOST_CHECK(s_ab == s_ba);
+}
+
+//! Mnemonic behind Dip14Seed() above.
+static constexpr const char* DIP14_MNEMONIC{
+    "birth kingdom trash renew flavor utility donkey gasp regular alert pave layer"};
+
+//! Descriptor wallet with a BIP39 mnemonic, wrapped in the interfaces::Wallet
+//! through which the Platform key provider is served.
+struct FriendshipWalletSetup : public TestChain100Setup {
+    explicit FriendshipWalletSetup(const SecureString& mnemonic = "")
+    {
+        m_context.args = &m_args;
+        m_context.chain = m_node.chain.get();
+        m_context.coinjoin_loader = m_node.coinjoin_loader.get();
+        std::tie(m_wallet, m_iface) = MakeSeededWallet(mnemonic);
+    }
+
+    //! An independent wallet instance (own mock database) set up from the
+    //! given mnemonic — a fresh restore of that recovery phrase.
+    std::pair<std::shared_ptr<CWallet>, std::unique_ptr<interfaces::Wallet>>
+    MakeSeededWallet(const SecureString& mnemonic)
+    {
+        auto wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", m_args,
+                                                CreateMockWalletDatabase());
+        wallet->LoadWallet();
+        {
+            LOCK(wallet->cs_wallet);
+            wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+            wallet->SetupDescriptorScriptPubKeyMans(mnemonic, "");
+        }
+        auto iface = interfaces::MakeWallet(m_context, wallet);
+        return {std::move(wallet), std::move(iface)};
+    }
+
+    std::pair<std::shared_ptr<CWallet>, std::unique_ptr<interfaces::Wallet>>
+    MakeXprvWallet(const CExtKey& root)
+    {
+        auto wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", m_args,
+                                                CreateMockWalletDatabase());
+        wallet->LoadWallet();
+
+        FlatSigningProvider provider;
+        std::string error;
+        auto parsed{Parse("pkh(" + EncodeExtKey(root) + "/*)", provider, error, /*require_checksum=*/false)};
+        BOOST_REQUIRE_MESSAGE(parsed, error);
+        WalletDescriptor descriptor(std::move(parsed), /*creation_time=*/0, /*range_start=*/0,
+                                    /*range_end=*/10, /*next_index=*/0);
+        {
+            LOCK(wallet->cs_wallet);
+            wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+            auto* spk_man{wallet->AddWalletDescriptor(descriptor, provider, "", /*internal=*/false)};
+            BOOST_REQUIRE(spk_man);
+            wallet->AddActiveScriptPubKeyMan(spk_man->GetID(), /*internal=*/false);
+        }
+
+        auto iface{interfaces::MakeWallet(m_context, wallet)};
+        return {std::move(wallet), std::move(iface)};
+    }
+
+    static isminetype IsMineIn(CWallet& wallet, const CTxDestination& destination)
+    {
+        LOCK(wallet.cs_wallet);
+        return wallet.IsMine(GetScriptForDestination(destination));
+    }
+
+    isminetype IsMine(const CTxDestination& destination) { return IsMineIn(*m_wallet, destination); }
+
+    //! Payment address `index` of the friendship chain rooted at (user_a, user_b),
+    //! taken through the same xpub export the contact would receive.
+    static CTxDestination PaymentDestinationVia(interfaces::Wallet& iface, const uint256& user_a,
+                                                const uint256& user_b, uint32_t index)
+    {
+        const auto keychain{iface.ensureFriendshipReceivingKeychain(
+            FriendshipKeychainRequest{ACCOUNT, user_a, user_b, /*birth_time=*/0})};
+        BOOST_REQUIRE(keychain);
+        CTxDestination destination;
+        BOOST_REQUIRE(DeriveFriendshipPaymentDestination(keychain.value, index, destination));
+        return destination;
+    }
+
+    CTxDestination PaymentDestination(const uint256& user_a, const uint256& user_b, uint32_t index)
+    {
+        return PaymentDestinationVia(*m_iface, user_a, user_b, index);
+    }
+
+    static constexpr uint32_t ACCOUNT{0};
+    const uint256 m_my_id{uint256S("1111111111111111111111111111111111111111111111111111111111111111")};
+    const uint256 m_their_id{uint256S("2222222222222222222222222222222222222222222222222222222222222222")};
+
+    WalletContext m_context;
+    std::shared_ptr<CWallet> m_wallet;
+    std::unique_ptr<interfaces::Wallet> m_iface;
+};
+
+//! Our own receiving chain for a friendship is imported as a private
+//! descriptor: its addresses must be spendable, not watch-only, and coins paid
+//! to them must count towards the spendable balance.
+BOOST_FIXTURE_TEST_CASE(friendship_own_chain_is_spendable, FriendshipWalletSetup)
+{
+    const auto keychain{m_iface->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0})};
+    BOOST_REQUIRE(keychain);
+
+    // The public chain returned after import derives the addresses made ours.
+    for (uint32_t index = 0; index < 5; ++index) {
+        CTxDestination destination;
+        BOOST_REQUIRE(DeriveFriendshipPaymentDestination(keychain.value, index, destination));
+        BOOST_CHECK_EQUAL(IsMine(destination), ISMINE_SPENDABLE);
+    }
+
+    const CScript script{GetScriptForDestination(PaymentDestination(m_my_id, m_their_id, 0))};
+    CMutableTransaction payment;
+    payment.vin.emplace_back(g_insecure_rand_ctx.rand256(), 0);
+    payment.vout.emplace_back(COIN, script);
+
+    LOCK(m_wallet->cs_wallet);
+    m_wallet->AddToWallet(MakeTransactionRef(payment), TxStateInMempool{});
+
+    CCoinControl coin_control;
+    coin_control.m_include_unsafe_inputs = true;
+    BOOST_CHECK_EQUAL(AvailableCoins(*m_wallet, &coin_control).size(), 1U);
+}
+
+//! The contact's receiving chain must never become ours. If it did, payments to
+//! the contact would be classified as payments-to-self and their outputs would
+//! be counted as our own coins.
+BOOST_FIXTURE_TEST_CASE(friendship_contact_chain_is_not_ours, FriendshipWalletSetup)
+{
+    const auto keychain{m_iface->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0})};
+    BOOST_REQUIRE(keychain);
+
+    // A real contact derives that chain from their own seed, which our wallet
+    // never sees; those destinations must be foreign too.
+    CExtKey contact_key;
+    const std::array<std::byte, 32> contact_seed{std::byte{7}};
+    contact_key.SetSeed(contact_seed);
+    const CExtPubKey contact_xpub{contact_key.Neuter()};
+    const FriendshipXpub friendship_xpub{contact_xpub.pubkey, contact_xpub.chaincode};
+    for (uint32_t index = 0; index < 5; ++index) {
+        CTxDestination destination;
+        BOOST_REQUIRE(DeriveFriendshipPaymentDestination(friendship_xpub, index, destination));
+        BOOST_CHECK_EQUAL(IsMine(destination), ISMINE_NO);
+    }
+}
+
+struct Dip14WalletSetup : public FriendshipWalletSetup {
+    Dip14WalletSetup() : FriendshipWalletSetup(SecureString{DIP14_MNEMONIC}) {}
+};
+
+//! All active descriptor managers may share one root extended key, but the
+//! provider must reject a wallet whose active managers disagree on the source.
+BOOST_FIXTURE_TEST_CASE(platform_key_source_must_be_unambiguous, Dip14WalletSetup)
+{
+    const auto before{m_iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_REQUIRE(before);
+
+    // The internal hook must not permit an empty path to expose the BIP32
+    // master key, even though the typed public requests cannot form one.
+    {
+        LOCK(m_wallet->cs_wallet);
+        bool checked{false};
+        for (const auto* spk_man : m_wallet->GetActiveScriptPubKeyMans()) {
+            std::vector<unsigned char> source;
+            if (spk_man->GetPlatformKeySource(source) != PlatformKeyStatus::SUCCESS) continue;
+            ExtKey256 out;
+            BOOST_CHECK(spk_man->DerivePlatformKey({}, out) == PlatformKeyStatus::INVALID_ARGUMENT);
+            checked = true;
+            break;
+        }
+        BOOST_REQUIRE(checked);
+    }
+
+    // A second setup replaces the active managers. Re-activating one original
+    // manager leaves the wallet with active managers from two mnemonic roots.
+    std::set<uint256> first_ids;
+    {
+        LOCK(m_wallet->cs_wallet);
+        for (auto* spk_man : m_wallet->GetActiveScriptPubKeyMans()) first_ids.insert(spk_man->GetID());
+        m_wallet->SetupDescriptorScriptPubKeyMans(
+            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about", "");
+        m_wallet->AddActiveScriptPubKeyMan(*first_ids.begin(), /*internal=*/true);
+    }
+
+    const auto ambiguous{m_iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_CHECK(ambiguous.status == PlatformKeyStatus::AMBIGUOUS_SOURCE);
+}
+
+//! An imported root xprv is sufficient for Platform derivation. The mnemonic
+//! and BIP39 seed are only one way to create that extended private key.
+BOOST_FIXTURE_TEST_CASE(xprv_only_wallet_derives_platform_keys, FriendshipWalletSetup)
+{
+    const CExtKey master{Dip14Master()};
+    const auto [wallet, iface]{MakeXprvWallet(master)};
+    const auto result{iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_REQUIRE(result);
+
+    ExtKey256 expected;
+    BOOST_REQUIRE(DeriveExtKey(master, IdentityAuthKeyPath(static_cast<uint32_t>(Params().ExtCoinType()), 0, 0), expected));
+    BOOST_CHECK(result.value == expected.key.GetPubKey());
+}
+
+//! The standardized Platform paths are absolute paths from m. An imported
+//! child xprv cannot be treated as m because hardened ancestors are not
+//! recoverable from it.
+BOOST_FIXTURE_TEST_CASE(child_xprv_has_no_platform_keys, FriendshipWalletSetup)
+{
+    CExtKey child;
+    BOOST_REQUIRE(Dip14Master().Derive(child, 0));
+    const auto [wallet, iface]{MakeXprvWallet(child)};
+    const auto result{iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_CHECK(result.status == PlatformKeyStatus::NOT_SUPPORTED);
+}
+
+//! A root source is the complete extended public key, including its chain
+//! code. The same private scalar paired with another chain code defines a
+//! different Platform key tree and must be rejected as ambiguous.
+BOOST_FIXTURE_TEST_CASE(platform_key_source_includes_chaincode, Dip14WalletSetup)
+{
+    CExtKey alternate{Dip14Master()};
+    *alternate.chaincode.begin() ^= 1;
+
+    FlatSigningProvider provider;
+    std::string error;
+    auto parsed{Parse("pkh(" + EncodeExtKey(alternate) + "/*)", provider, error, /*require_checksum=*/false)};
+    BOOST_REQUIRE_MESSAGE(parsed, error);
+    WalletDescriptor descriptor(std::move(parsed), /*creation_time=*/0, /*range_start=*/0,
+                                /*range_end=*/10, /*next_index=*/0);
+    {
+        LOCK(m_wallet->cs_wallet);
+        auto* spk_man{m_wallet->AddWalletDescriptor(descriptor, provider, "", /*internal=*/true)};
+        BOOST_REQUIRE(spk_man);
+        m_wallet->AddActiveScriptPubKeyMan(spk_man->GetID(), /*internal=*/true);
+    }
+
+    const auto result{m_iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_CHECK(result.status == PlatformKeyStatus::AMBIGUOUS_SOURCE);
+}
+
+//! Platform derivation uses the descriptor root xprv, so damage to the
+//! optional mnemonic metadata cannot redirect it to a different key tree.
+BOOST_FIXTURE_TEST_CASE(invalid_mnemonic_does_not_change_platform_keys, FriendshipWalletSetup)
+{
+    const SecureString bad_mnemonic{
+        "birth kingdom trash renew flavor utility donkey gasp regular alert pave kingdom"};
+    BOOST_REQUIRE(!CMnemonic::Check(bad_mnemonic));
+
+    auto wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", m_args,
+                                            CreateMockWalletDatabase());
+    wallet->LoadWallet();
+
+    // The master key a corrupt record would pair with: derived from the very
+    // string that fails validation (AddKey() asserts the pairing).
+    SecureVector seed;
+    CMnemonic::ToSeed(bad_mnemonic, "", seed);
+    CExtKey master;
+    master.SetSeed(MakeByteSpan(seed));
+
+    FlatSigningProvider provider;
+    std::string error;
+    auto parsed = Parse("pkh(" + EncodeExtKey(master) + "/*)", provider, error, /*require_checksum=*/false);
+    BOOST_REQUIRE_MESSAGE(parsed, error);
+    WalletDescriptor descriptor(std::move(parsed), /*creation_time=*/0, /*range_start=*/0,
+                                /*range_end=*/10, /*next_index=*/0);
+    {
+        LOCK(wallet->cs_wallet);
+        wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+        auto* spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(
+            wallet->AddWalletDescriptor(descriptor, provider, "", /*internal=*/false));
+        BOOST_REQUIRE(spk_man);
+        BOOST_REQUIRE(spk_man->AddKey(master.key.GetPubKey().GetID(), master.key, bad_mnemonic, ""));
+        wallet->AddActiveScriptPubKeyMan(spk_man->GetID(), /*internal=*/false);
+    }
+
+    auto iface = interfaces::MakeWallet(m_context, wallet);
+    const auto result{iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_REQUIRE(result);
+
+    ExtKey256 expected;
+    BOOST_REQUIRE(DeriveExtKey(master, IdentityAuthKeyPath(static_cast<uint32_t>(Params().ExtCoinType()), 0, 0), expected));
+    BOOST_CHECK(result.value == expected.key.GetPubKey());
+}
+
+//! DashPay is descriptor-wallet-only: a legacy wallet must be refused even
+//! with a perfectly recoverable HD chain seed, so no Platform keys can be
+//! created that a later wallet migration would orphan.
+BOOST_FIXTURE_TEST_CASE(legacy_wallet_has_no_platform_keys, FriendshipWalletSetup)
+{
+    auto wallet = std::make_shared<CWallet>(m_node.chain.get(), m_node.coinjoin_loader.get(), "", m_args,
+                                            CreateMockWalletDatabase());
+    wallet->LoadWallet();
+    {
+        LOCK(wallet->cs_wallet);
+        auto* spk_man = wallet->GetOrCreateLegacyScriptPubKeyMan();
+        BOOST_REQUIRE(spk_man);
+        spk_man->GenerateNewHDChain(SecureString{DIP14_MNEMONIC}, "");
+        // The refusal must come from the wallet type, not a missing seed:
+        // the HD chain really holds the DIP-14 seed.
+        CHDChain hd_chain;
+        BOOST_REQUIRE(spk_man->GetHDChain(hd_chain));
+        BOOST_CHECK(hd_chain.GetSeed() == Dip14Seed());
+    }
+
+    auto iface = interfaces::MakeWallet(m_context, wallet);
+    const auto result{iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_CHECK(result.status == PlatformKeyStatus::NOT_SUPPORTED);
+}
+
+//! Two independent wallet instances restored from the same recovery phrase:
+//! the second is what a seed-only restore produces (fresh wallet database, no
+//! platform records). Everything DashPay derives from the seed must come out
+//! identical on both.
+struct SeededWalletPair : public Dip14WalletSetup {
+    SeededWalletPair() { std::tie(m_wallet_b, m_iface_b) = MakeSeededWallet(SecureString{DIP14_MNEMONIC}); }
+
+    std::shared_ptr<CWallet> m_wallet_b;
+    std::unique_ptr<interfaces::Wallet> m_iface_b;
+};
+
+//! Identity authentication and funding pubkeys must rederive byte-identical
+//! after a seed-only restore, and must equal the raw DIP-13 derivation from
+//! the known seed (pinning the interface to the vector-backed path math).
+BOOST_FIXTURE_TEST_CASE(recovery_auth_key_rederivation, SeededWalletPair)
+{
+    const auto coin_type{static_cast<uint32_t>(Params().ExtCoinType())};
+    for (uint32_t identity = 0; identity < 2; ++identity) {
+        for (uint32_t key = 0; key < 5; ++key) {
+            const auto original{m_iface->getPlatformPubKey(IdentityAuthKey{identity, key})};
+            const auto restored{m_iface_b->getPlatformPubKey(IdentityAuthKey{identity, key})};
+            BOOST_REQUIRE(original);
+            BOOST_REQUIRE(restored);
+            BOOST_CHECK(original.value == restored.value);
+
+            ExtKey256 expected;
+            BOOST_REQUIRE(DeriveExtKey(Dip14Master(), IdentityAuthKeyPath(coin_type, identity, key), expected));
+            BOOST_CHECK(original.value == expected.key.GetPubKey());
+        }
+    }
+
+    const auto funding_original{m_iface->getPlatformPubKey(RegistrationFundingKey{0})};
+    const auto funding_restored{m_iface_b->getPlatformPubKey(RegistrationFundingKey{0})};
+    BOOST_REQUIRE(funding_original);
+    BOOST_REQUIRE(funding_restored);
+    BOOST_CHECK(funding_original.value == funding_restored.value);
+}
+
+//! Independent BIP32 vectors generated from Dip14Seed() with Python's stdlib
+//! HMAC-SHA512 and cryptography's secp256k1 implementation. These pin DIP-13's
+//! distinct final-index rules: registration and unbound top-up are normal,
+//! while invitations are hardened.
+BOOST_AUTO_TEST_CASE(dip13_funding_vectors)
+{
+    const struct {
+        PlatformKeyRequest request;
+        const char* expected_key;
+        const char* expected_chaincode;
+    } vectors[]{
+        {RegistrationFundingKey{7}, "804cc77cec9ce9ccf576a9b5978f5da67a86b9307f2686a26fa4cf873bc5645c",
+         "5958f765e78779437d7a4b168297202d5153fd0add543097ad929c4bb412f061"},
+        {TopupFundingKey{11}, "cd6adc39e772ed2b2186ecc42cbdb5b881fe755db086a9c8a94343815af8784a",
+         "43503e58c2e61675d56adaf831b11735acfc5570918d46dad1385c292a8aadc5"},
+        {InvitationFundingKey{13}, "4d731224222afd2b28539a8588fbb7579e85b5d6cec9e328a1c5a78f522581a8",
+         "b2d0561c5974f9969b39a0d62c041277fbfeaa5e9efd88cf31072a2779d9f254"},
+    };
+    for (const auto& vector : vectors) {
+        ExtKey256 key;
+        BOOST_REQUIRE(DeriveExtKey(Dip14Master(), PlatformKeyPath(/*coin_type=*/1, vector.request), key));
+        BOOST_CHECK_EQUAL(HexStr(Span{key.key.begin(), key.key.size()}), vector.expected_key);
+        BOOST_CHECK_EQUAL(HexStr(key.chaincode), vector.expected_chaincode);
+    }
+}
+
+//! Compact signatures from signPlatformDigest must recover to the pubkey
+//! getPlatformPubKey reports for the same key, on both wallet instances.
+BOOST_FIXTURE_TEST_CASE(sign_platform_digest_recovers_to_pubkey, SeededWalletPair)
+{
+    const uint256 digest{g_insecure_rand_ctx.rand256()};
+    const PlatformKeyRequest request{IdentityAuthKey{0, 0}};
+
+    const auto sig_original{m_iface->signPlatformDigest(request, digest)};
+    const auto sig_restored{m_iface_b->signPlatformDigest(request, digest)};
+    BOOST_REQUIRE(sig_original);
+    BOOST_REQUIRE(sig_restored);
+
+    const auto auth_key{m_iface->getPlatformPubKey(request)};
+    BOOST_REQUIRE(auth_key);
+
+    CPubKey recovered;
+    BOOST_REQUIRE(recovered.RecoverCompact(digest, sig_original.value));
+    BOOST_CHECK(recovered == auth_key.value);
+    BOOST_REQUIRE(recovered.RecoverCompact(digest, sig_restored.value));
+    BOOST_CHECK(recovered == auth_key.value);
+}
+
+//! Friendship xpubs and the payment destinations derived from them must
+//! rederive identically after restore, and stay direction-sensitive.
+BOOST_FIXTURE_TEST_CASE(recovery_friendship_xpub_rederivation, SeededWalletPair)
+{
+    const FriendshipKeychainRequest request{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0};
+    const auto keychain_a{m_iface->ensureFriendshipReceivingKeychain(request)};
+    const auto keychain_b{m_iface_b->ensureFriendshipReceivingKeychain(request)};
+    BOOST_REQUIRE(keychain_a);
+    BOOST_REQUIRE(keychain_b);
+    BOOST_CHECK(keychain_a.value.pubkey == keychain_b.value.pubkey);
+    BOOST_CHECK(keychain_a.value.chaincode == keychain_b.value.chaincode);
+
+    for (uint32_t index = 0; index < 10; ++index) {
+        BOOST_CHECK(PaymentDestinationVia(*m_iface, m_my_id, m_their_id, index) ==
+                    PaymentDestinationVia(*m_iface_b, m_my_id, m_their_id, index));
+    }
+
+    const auto reversed{m_iface_b->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_their_id, m_my_id, /*birth_time=*/0})};
+    BOOST_REQUIRE(reversed);
+    BOOST_CHECK(reversed.value.pubkey != keychain_a.value.pubkey);
+}
+
+//! The ECDH secret used to decrypt incoming contact-request xpubs must
+//! survive a restore and agree with the contact's own side — the precondition
+//! for recovering contact xpubs from on-chain requests after a seed restore.
+BOOST_FIXTURE_TEST_CASE(recovery_ecdh_symmetry_across_restore, SeededWalletPair)
+{
+    CKey contact_key;
+    contact_key.MakeNewKey(/*fCompressed=*/true);
+
+    const auto invalid{m_iface->platformECDHSecret(IdentityAuthKey{0, 0}, CPubKey{})};
+    BOOST_CHECK(invalid.status == PlatformKeyStatus::INVALID_ARGUMENT);
+
+    const auto secret_original{m_iface->platformECDHSecret(IdentityAuthKey{0, 0}, contact_key.GetPubKey())};
+    const auto secret_restored{m_iface_b->platformECDHSecret(IdentityAuthKey{0, 0}, contact_key.GetPubKey())};
+    BOOST_REQUIRE(secret_original);
+    BOOST_REQUIRE(secret_restored);
+    BOOST_CHECK(secret_original.value == secret_restored.value);
+
+    const auto our_auth_key{m_iface->getPlatformPubKey(IdentityAuthKey{0, 0})};
+    BOOST_REQUIRE(our_auth_key);
+    SecureVector secret_contact_side;
+    BOOST_REQUIRE(ComputeECDHSecret(contact_key, our_auth_key.value, secret_contact_side));
+    BOOST_CHECK(secret_contact_side == secret_original.value);
+}
+
+//! A payment received before the loss must become spendable again once the
+//! restored wallet re-imports the friendship keychain: the recovery contract
+//! for DIP-15 funds.
+BOOST_FIXTURE_TEST_CASE(recovery_import_after_restore_is_spendable, SeededWalletPair)
+{
+    // The payment targets the xpub the contact holds — exported by wallet A
+    // before the loss.
+    const auto original_keychain{m_iface->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0})};
+    BOOST_REQUIRE(original_keychain);
+    CTxDestination destination;
+    BOOST_REQUIRE(DeriveFriendshipPaymentDestination(original_keychain.value, /*index=*/0, destination));
+    const CScript script{GetScriptForDestination(destination)};
+    CMutableTransaction payment;
+    payment.vin.emplace_back(g_insecure_rand_ctx.rand256(), 0);
+    payment.vout.emplace_back(COIN, script);
+
+    // Restored wallet B: not ours until the friendship keychain is back.
+    BOOST_CHECK_EQUAL(IsMineIn(*m_wallet_b, destination), ISMINE_NO);
+
+    const auto imported{m_iface_b->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0})};
+    BOOST_REQUIRE(imported);
+
+    LOCK(m_wallet_b->cs_wallet);
+    m_wallet_b->AddToWallet(MakeTransactionRef(payment), TxStateInMempool{});
+
+    CCoinControl coin_control;
+    coin_control.m_include_unsafe_inputs = true;
+    BOOST_CHECK_EQUAL(AvailableCoins(*m_wallet_b, &coin_control).size(), 1U);
+}
+
+//! Recovery re-runs re-import friendships it already imported; that must
+//! update in place rather than duplicate spk_mans or change ownership.
+BOOST_FIXTURE_TEST_CASE(recovery_import_idempotent, SeededWalletPair)
+{
+    const FriendshipKeychainRequest request{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/0};
+    BOOST_REQUIRE(m_iface->ensureFriendshipReceivingKeychain(request));
+    size_t spk_mans_after_first;
+    {
+        LOCK(m_wallet->cs_wallet);
+        spk_mans_after_first = m_wallet->GetAllScriptPubKeyMans().size();
+    }
+
+    BOOST_REQUIRE(m_iface->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/1'600'000'000}));
+    {
+        LOCK(m_wallet->cs_wallet);
+        BOOST_CHECK_EQUAL(m_wallet->GetAllScriptPubKeyMans().size(), spk_mans_after_first);
+    }
+    for (uint32_t index = 0; index < 5; ++index) {
+        BOOST_CHECK_EQUAL(IsMine(PaymentDestination(m_my_id, m_their_id, index)), ISMINE_SPENDABLE);
+    }
+
+    // Normal use after import: observing a payment to index 0 advances the
+    // descriptor's next_index and lets TopUp() grow its range past the
+    // initial one.
+    const CScript used_script{GetScriptForDestination(PaymentDestination(m_my_id, m_their_id, 0))};
+    DescriptorScriptPubKeyMan* friendship_spk_man{nullptr};
+    {
+        LOCK(m_wallet->cs_wallet);
+        WalletBatch batch{m_wallet->GetDatabase()};
+        for (auto* spk_man : m_wallet->GetScriptPubKeyMans(used_script)) {
+            friendship_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
+            if (!friendship_spk_man) continue;
+            spk_man->MarkUnusedAddresses(batch, used_script, std::nullopt);
+            BOOST_REQUIRE(spk_man->TopUp());
+            break;
+        }
+    }
+    BOOST_REQUIRE(friendship_spk_man);
+    int32_t used_next_index;
+    int32_t used_range_end;
+    {
+        LOCK(friendship_spk_man->cs_desc_man);
+        const auto used_descriptor{friendship_spk_man->GetWalletDescriptor()};
+        used_next_index = used_descriptor.next_index;
+        used_range_end = used_descriptor.range_end;
+    }
+    BOOST_REQUIRE_EQUAL(used_next_index, 1);
+    BOOST_REQUIRE_GT(used_range_end, 1000);
+
+    // Re-import after use must still succeed and keep the grown range,
+    // derivation progress, and the earliest creation time.
+    BOOST_REQUIRE(m_iface->ensureFriendshipReceivingKeychain(
+        FriendshipKeychainRequest{ACCOUNT, m_my_id, m_their_id, /*birth_time=*/1'700'000'000}));
+    {
+        LOCK(friendship_spk_man->cs_desc_man);
+        const auto reimported{friendship_spk_man->GetWalletDescriptor()};
+        BOOST_CHECK_EQUAL(reimported.next_index, used_next_index);
+        BOOST_CHECK_EQUAL(reimported.range_end, used_range_end);
+        BOOST_CHECK_EQUAL(reimported.creation_time, 0);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/walletdb_tests.cpp b/src/wallet/test/walletdb_tests.cpp
index 0b453b1dece4..a0b26788c9a4 100644
--- a/src/wallet/test/walletdb_tests.cpp
+++ b/src/wallet/test/walletdb_tests.cpp
@@ -61,5 +61,93 @@ BOOST_AUTO_TEST_CASE(walletdb_hdchain_type_mismatch)
     BOOST_CHECK_EQUAL(strErr, "Error reading wallet database: HD chain type mismatch");
 }
 
+BOOST_AUTO_TEST_CASE(walletdb_platform_data_records)
+{
+    LOCK(m_wallet.cs_wallet);
+
+    // Round-trip through the in-memory map: write, prefix query, erase.
+    const std::vector<unsigned char> value_a{0x01, 0x02};
+    const std::vector<unsigned char> value_b{0x03};
+    BOOST_CHECK(m_wallet.WritePlatformData("platform/identity/0", value_a));
+    BOOST_CHECK(m_wallet.WritePlatformData("platform/identity/1", value_b));
+    BOOST_CHECK(m_wallet.WritePlatformData("platform/metadata", value_b));
+
+    auto records{m_wallet.GetPlatformData("platform/identity/")};
+    BOOST_CHECK_EQUAL(records.size(), 2U);
+    BOOST_CHECK(records.at("platform/identity/0") == value_a);
+    BOOST_CHECK(records.at("platform/identity/1") == value_b);
+    BOOST_CHECK_EQUAL(m_wallet.GetPlatformData("").size(), 3U);
+    BOOST_CHECK(m_wallet.GetPlatformData("platform/idem").empty());
+
+    // An empty value erases the record.
+    BOOST_CHECK(m_wallet.WritePlatformData("platform/identity/0", {}));
+    records = m_wallet.GetPlatformData("platform/identity/");
+    BOOST_CHECK_EQUAL(records.size(), 1U);
+    BOOST_CHECK_EQUAL(records.count("platform/identity/0"), 0U);
+
+    // The wallet-load path (ReadKeyValue) must populate the same map.
+    CDataStream ssKey(SER_DISK, CLIENT_VERSION);
+    CDataStream ssValue(SER_DISK, CLIENT_VERSION);
+    ssKey << std::make_pair(DBKeys::PLATFORM_DATA, std::string{"platform/loaded"});
+    ssValue << value_a;
+    std::string strType, strErr;
+    BOOST_CHECK(ReadKeyValue(&m_wallet, ssKey, ssValue, strType, strErr));
+    BOOST_CHECK_EQUAL(strType, DBKeys::PLATFORM_DATA);
+    BOOST_CHECK(m_wallet.GetPlatformData("platform/loaded").at("platform/loaded") == value_a);
+
+    // A truncated value must fail the read and identify PLATFORM_DATA as the
+    // failing type so LoadWallet() can classify the damage as noncritical.
+    CDataStream ssGood(SER_DISK, CLIENT_VERSION);
+    ssGood << value_a;
+    CDataStream ssBadKey(SER_DISK, CLIENT_VERSION);
+    CDataStream ssBadValue(SER_DISK, CLIENT_VERSION);
+    ssBadKey << std::make_pair(DBKeys::PLATFORM_DATA, std::string{"platform/corrupt"});
+    ssBadValue.write({ssGood.data(), ssGood.size() - 1});
+    strType.clear();
+    strErr.clear();
+    BOOST_CHECK(!ReadKeyValue(&m_wallet, ssBadKey, ssBadValue, strType, strErr));
+    BOOST_CHECK_EQUAL(strType, DBKeys::PLATFORM_DATA);
+    BOOST_CHECK(m_wallet.GetPlatformData("platform/corrupt").empty());
+}
+
+//! Load a wallet whose database holds a PLATFORM_DATA record under
+//! `record_key` with a truncated value (claims five bytes, carries none),
+//! next to an intact record, and report the load result and the Platform
+//! data that made it into the wallet.
+static DBErrors LoadWithCorruptPlatformRecord(const node::NodeContext& node, const ArgsManager& args,
+                                              const std::string& record_key,
+                                              std::map<std::string, std::vector<unsigned char>>& platform_data_out)
+{
+    CWallet wallet(node.chain.get(), node.coinjoin_loader.get(), "", args, CreateMockWalletDatabase());
+    const std::vector<unsigned char> truncated{0x05};
+    const std::vector<unsigned char> intact_value{0x01, 0x02};
+    {
+        const std::unique_ptr<DatabaseBatch> batch{wallet.GetDatabase().MakeBatch()};
+        BOOST_REQUIRE(batch->Write(std::make_pair(DBKeys::PLATFORM_DATA, record_key), Span{truncated}));
+        BOOST_REQUIRE(batch->Write(std::make_pair(DBKeys::PLATFORM_DATA, std::string{"platform/intact"}), intact_value));
+    }
+    const DBErrors result{WalletBatch(wallet.GetDatabase()).LoadWallet(&wallet)};
+    platform_data_out = WITH_LOCK(wallet.cs_wallet, return wallet.GetPlatformData(""));
+    return result;
+}
+
+BOOST_AUTO_TEST_CASE(walletdb_platform_data_corruption_policy)
+{
+    // Platform records are opaque cache/metadata. Damage is noncritical, the
+    // wallet still loads, and intact records survive. There is no reserved
+    // Platform seed-selection record.
+    std::map<std::string, std::vector<unsigned char>> platform_data;
+    BOOST_CHECK(LoadWithCorruptPlatformRecord(m_node, m_args, "platform/metadata", platform_data) ==
+                DBErrors::NONCRITICAL_ERROR);
+    BOOST_CHECK_EQUAL(platform_data.count("platform/metadata"), 0U);
+    BOOST_CHECK(platform_data.at("platform/intact") == std::vector<unsigned char>({0x01, 0x02}));
+
+    platform_data.clear();
+    BOOST_CHECK(LoadWithCorruptPlatformRecord(m_node, m_args, "platform/identity/0", platform_data) ==
+                DBErrors::NONCRITICAL_ERROR);
+    BOOST_CHECK_EQUAL(platform_data.count("platform/identity/0"), 0U);
+    BOOST_CHECK(platform_data.at("platform/intact") == std::vector<unsigned char>({0x01, 0x02}));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 } // namespace wallet
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6a941af05ca2..da4a2e08d885 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -44,6 +44,7 @@
 #include <wallet/coincontrol.h>
 #include <wallet/context.h>
 #include <wallet/external_signer_scriptpubkeyman.h>
+#include <wallet/platformkeys.h>
 #include <warnings.h>
 
 #include <coinjoin/options.h>
@@ -3811,6 +3812,162 @@ bool CWallet::WriteGovernanceObject(const Governance::Object& obj)
     return batch.WriteGovernanceObject(obj) && LoadGovernanceObject(obj);
 }
 
+void CWallet::LoadPlatformData(const std::string& key, const std::vector<unsigned char>& value)
+{
+    AssertLockHeld(cs_wallet);
+    m_platform_data[key] = value;
+}
+
+bool CWallet::WritePlatformData(const std::string& key, const std::vector<unsigned char>& value)
+{
+    AssertLockHeld(cs_wallet);
+    WalletBatch batch(GetDatabase());
+    if (value.empty()) {
+        if (!batch.ErasePlatformData(key)) return false;
+        m_platform_data.erase(key);
+        return true;
+    }
+    if (!batch.WritePlatformData(key, value)) return false;
+    m_platform_data[key] = value;
+    return true;
+}
+
+std::map<std::string, std::vector<unsigned char>> CWallet::GetPlatformData(const std::string& prefix) const
+{
+    AssertLockHeld(cs_wallet);
+    std::map<std::string, std::vector<unsigned char>> ret;
+    for (auto it = m_platform_data.lower_bound(prefix); it != m_platform_data.end(); ++it) {
+        if (it->first.compare(0, prefix.size(), prefix) != 0) break;
+        ret.emplace(it->first, it->second);
+    }
+    return ret;
+}
+
+PlatformKeyStatus CWallet::GetPlatformKeySource(const ScriptPubKeyMan*& source) const
+{
+    AssertLockHeld(cs_wallet);
+    source = nullptr;
+    if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) || IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) ||
+        IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
+        return PlatformKeyStatus::NOT_SUPPORTED;
+    }
+
+    std::vector<unsigned char> selected_id;
+    for (const auto* spk_man : GetActiveScriptPubKeyMans()) {
+        std::vector<unsigned char> candidate_id;
+        const auto status{spk_man->GetPlatformKeySource(candidate_id)};
+        if (status == PlatformKeyStatus::NOT_SUPPORTED) continue;
+        if (status != PlatformKeyStatus::SUCCESS) return status;
+        if (source && candidate_id != selected_id) return PlatformKeyStatus::AMBIGUOUS_SOURCE;
+        if (!source) {
+            source = spk_man;
+            selected_id = std::move(candidate_id);
+        }
+    }
+    return source ? PlatformKeyStatus::SUCCESS : PlatformKeyStatus::NOT_SUPPORTED;
+}
+
+PlatformKeyStatus CWallet::DerivePlatformKey(const platformkeys::Path& path, platformkeys::ExtKey256& out) const
+{
+    AssertLockHeld(cs_wallet);
+    const ScriptPubKeyMan* source{nullptr};
+    const auto status{GetPlatformKeySource(source)};
+    if (status != PlatformKeyStatus::SUCCESS) return status;
+    return source->DerivePlatformKey(path, out);
+}
+
+PlatformKeyStatus CWallet::DerivePlatformKey(const PlatformKeyRequest& request, platformkeys::ExtKey256& out) const
+{
+    AssertLockHeld(cs_wallet);
+    return DerivePlatformKey(platformkeys::PlatformKeyPath(static_cast<uint32_t>(Params().ExtCoinType()), request), out);
+}
+
+PlatformKeyResult<CPubKey> CWallet::GetPlatformPubKey(const PlatformKeyRequest& request) const
+{
+    LOCK(cs_wallet);
+    platformkeys::ExtKey256 key;
+    PlatformKeyResult<CPubKey> result;
+    result.status = DerivePlatformKey(request, key);
+    if (result.status == PlatformKeyStatus::SUCCESS) result.value = key.key.GetPubKey();
+    return result;
+}
+
+PlatformKeyResult<std::vector<unsigned char>> CWallet::SignPlatformDigest(const PlatformKeyRequest& request,
+                                                                          const uint256& digest) const
+{
+    LOCK(cs_wallet);
+    platformkeys::ExtKey256 key;
+    PlatformKeyResult<std::vector<unsigned char>> result;
+    result.status = DerivePlatformKey(request, key);
+    if (result.status == PlatformKeyStatus::SUCCESS && !key.key.SignCompact(digest, result.value)) {
+        result.status = PlatformKeyStatus::DERIVATION_ERROR;
+        result.value.clear();
+    }
+    return result;
+}
+
+PlatformKeyResult<SecureVector> CWallet::PlatformECDHSecret(const IdentityAuthKey& request, const CPubKey& counterparty) const
+{
+    LOCK(cs_wallet);
+    PlatformKeyResult<SecureVector> result;
+    if (!counterparty.IsFullyValid()) {
+        result.status = PlatformKeyStatus::INVALID_ARGUMENT;
+        return result;
+    }
+    platformkeys::ExtKey256 key;
+    result.status = DerivePlatformKey(PlatformKeyRequest{request}, key);
+    if (result.status == PlatformKeyStatus::SUCCESS &&
+        !platformkeys::ComputeECDHSecret(key.key, counterparty, result.value)) {
+        result.status = PlatformKeyStatus::DERIVATION_ERROR;
+        result.value.clear();
+    }
+    return result;
+}
+
+PlatformKeyResult<FriendshipXpub> CWallet::EnsureFriendshipReceivingKeychain(const FriendshipKeychainRequest& request)
+{
+    LOCK(cs_wallet);
+    PlatformKeyResult<FriendshipXpub> result;
+    const auto path{platformkeys::FriendshipPath(static_cast<uint32_t>(Params().ExtCoinType()), request.account,
+                                                 Span{request.local_id.begin(), uint256::size()},
+                                                 Span{request.remote_id.begin(), uint256::size()})};
+    platformkeys::ExtKey256 key;
+    result.status = DerivePlatformKey(path, key);
+    if (result.status != PlatformKeyStatus::SUCCESS) return result;
+
+    CExtKey xprv{};
+    xprv.chaincode = key.chaincode;
+    xprv.key = key.key;
+    const CExtPubKey xpub{xprv.Neuter()};
+    FlatSigningProvider provider;
+    provider.keys.emplace(xpub.pubkey.GetID(), xprv.key);
+    std::string parse_error;
+    auto parsed{Parse("pkh(" + EncodeExtPubKey(xpub) + "/*)", provider, parse_error, /*require_checksum=*/false)};
+    if (!parsed) {
+        result.status = PlatformKeyStatus::DERIVATION_ERROR;
+        return result;
+    }
+
+    const int64_t birth_time{std::max<int64_t>(request.birth_time, 0)};
+    WalletDescriptor descriptor(std::move(parsed), birth_time, /*range_start=*/0,
+                                /*range_end=*/DEFAULT_KEYPOOL_SIZE, /*next_index=*/0);
+    if (auto* existing = GetDescriptorScriptPubKeyMan(descriptor)) {
+        LOCK(existing->cs_desc_man);
+        const WalletDescriptor current{existing->GetWalletDescriptor()};
+        descriptor.range_start = current.range_start;
+        descriptor.range_end = std::max(descriptor.range_end, current.range_end);
+        descriptor.next_index = current.next_index;
+        descriptor.creation_time = std::min(descriptor.creation_time, current.creation_time);
+    }
+    if (!AddWalletDescriptor(descriptor, provider, /*label=*/"", /*internal=*/false)) {
+        result.status = PlatformKeyStatus::IMPORT_ERROR;
+        return result;
+    }
+
+    result.value = {key.key.GetPubKey(), key.chaincode};
+    return result;
+}
+
 std::vector<const Governance::Object*> CWallet::GetGovernanceObjects()
 {
     AssertLockHeld(cs_wallet);
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 059e7712c6c4..b77dbc242cfd 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -449,6 +449,12 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
 
     static int64_t GetDefaultNextResend();
 
+    PlatformKeyStatus GetPlatformKeySource(const ScriptPubKeyMan*& source) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    PlatformKeyStatus DerivePlatformKey(const PlatformKeyRequest& request, platformkeys::ExtKey256& out) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    PlatformKeyStatus DerivePlatformKey(const platformkeys::Path& path, platformkeys::ExtKey256& out) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+
 public:
     /**
      * Main wallet lock.
@@ -488,6 +494,10 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     // Map from governance object hash to governance object, they are added by gobject_prepare.
     std::map<uint256, Governance::Object> m_gobjects;
 
+    // Generic per-wallet key/value records used by Dash Platform integration
+    // (opaque to the wallet; persisted as DBKeys::PLATFORM_DATA).
+    std::map<std::string, std::vector<unsigned char>> m_platform_data GUARDED_BY(cs_wallet);
+
     typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
     MasterKeyMap mapMasterKeys;
     unsigned int nMasterKeyMaxID = 0;
@@ -1003,6 +1013,19 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /** Returns a vector containing pointers to the governance objects in m_gobjects */
     std::vector<const Governance::Object*> GetGovernanceObjects() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
+    /** Load a Platform data record into m_platform_data (wallet load). */
+    void LoadPlatformData(const std::string& key, const std::vector<unsigned char>& value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Write (or, with an empty value, erase) a Platform data record. */
+    bool WritePlatformData(const std::string& key, const std::vector<unsigned char>& value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** All Platform data records whose key starts with prefix. */
+    std::map<std::string, std::vector<unsigned char>> GetPlatformData(const std::string& prefix) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+
+    PlatformKeyResult<CPubKey> GetPlatformPubKey(const PlatformKeyRequest& request) const;
+    PlatformKeyResult<std::vector<unsigned char>> SignPlatformDigest(const PlatformKeyRequest& request,
+                                                                     const uint256& digest) const;
+    PlatformKeyResult<SecureVector> PlatformECDHSecret(const IdentityAuthKey& key, const CPubKey& counterparty) const;
+    PlatformKeyResult<FriendshipXpub> EnsureFriendshipReceivingKeychain(const FriendshipKeychainRequest& request);
+
     /**
      * Blocks until the wallet state is up-to-date to /at least/ the current
      * chain at the time this function is entered
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 4b82c166a345..0dc1f7f68203 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -55,6 +55,7 @@ const std::string MINVERSION{"minversion"};
 const std::string NAME{"name"};
 const std::string OLD_KEY{"wkey"};
 const std::string ORDERPOSNEXT{"orderposnext"};
+const std::string PLATFORM_DATA{"platform_data"};
 const std::string POOL{"pool"};
 const std::string PURPOSE{"purpose"};
 const std::string PRIVATESEND_SALT{"ps_salt"};
@@ -247,6 +248,16 @@ bool WalletBatch::WriteGovernanceObject(const Governance::Object& obj)
     return WriteIC(std::make_pair(DBKeys::G_OBJECT, obj.GetHash()), obj, false);
 }
 
+bool WalletBatch::WritePlatformData(const std::string& key, const std::vector<unsigned char>& value)
+{
+    return WriteIC(std::make_pair(DBKeys::PLATFORM_DATA, key), value, true);
+}
+
+bool WalletBatch::ErasePlatformData(const std::string& key)
+{
+    return EraseIC(std::make_pair(DBKeys::PLATFORM_DATA, key));
+}
+
 bool WalletBatch::WriteActiveScriptPubKeyMan(const uint256& id, bool internal)
 {
     std::string key = internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
@@ -357,7 +368,6 @@ class CWalletScanState {
     std::map<std::pair<uint256, CKeyID>, std::pair<std::vector<unsigned char>, std::vector<unsigned char>>> crypted_mnemonics;
     bool tx_corrupt{false};
     bool descriptor_unknown{false};
-
     CWalletScanState() = default;
 };
 
@@ -645,6 +655,12 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
                 strErr = "Invalid governance object: LoadGovernanceObject";
                 return false;
             }
+        } else if (strType == DBKeys::PLATFORM_DATA) {
+            std::string strKey;
+            std::vector<unsigned char> vchValue;
+            ssKey >> strKey;
+            ssValue >> vchValue;
+            pwallet->LoadPlatformData(strKey, vchValue);
         } else if (strType == DBKeys::OLD_KEY) {
             strErr = "Found unsupported 'wkey' record, try loading with version 0.17";
             return false;
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 30c6aebdca30..f06177efeb2f 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -87,6 +87,7 @@ extern const std::string MINVERSION;
 extern const std::string NAME;
 extern const std::string OLD_KEY;
 extern const std::string ORDERPOSNEXT;
+extern const std::string PLATFORM_DATA;
 extern const std::string POOL;
 extern const std::string PURPOSE;
 extern const std::string PRIVATESEND_SALT;
@@ -230,6 +231,11 @@ class WalletBatch
     /** Write a CGovernanceObject to the database */
     bool WriteGovernanceObject(const Governance::Object& obj);
 
+    //! Generic per-wallet key/value records used by Dash Platform
+    //! integration (flow state, identity metadata). Opaque to the wallet.
+    bool WritePlatformData(const std::string& key, const std::vector<unsigned char>& value);
+    bool ErasePlatformData(const std::string& key);
+
     bool WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const CPrivKey& privkey, const SecureString& mnemonic, const SecureString& mnemonic_passphrase);
     bool WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret, const std::vector<unsigned char>& crypted_mnemonic, const std::vector<unsigned char>& crypted_mnemonic_passphrase);
     bool WriteDescriptor(const uint256& desc_id, const WalletDescriptor& descriptor);
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 84d49954a6a0..c4d85dfd469f 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -85,4 +85,7 @@ src/util/wpipe.*
 src/wallet/bip39*
 src/wallet/coinjoin.*
 src/wallet/hdchain.*
+src/wallet/platformkeys.*
+src/wallet/platformtypes.h
+src/wallet/test/platformkeys_tests.cpp
 src/hash_x11.h