@@ -126,7 +126,8 @@ if ENABLE_PLATFORM_GUI
 QT_MOC_CPP += \
   qt/platform/moc_identityflow.cpp \
   qt/platform/moc_platformpage.cpp \
-  qt/platform/moc_platformservice.cpp
+  qt/platform/moc_platformservice.cpp \
+  qt/platform/moc_usernameflow.cpp
 endif
 
 BITCOIN_MM = \
@@ -236,7 +237,8 @@ BITCOIN_QT_H += \
   qt/platform/identityflow.h \
   qt/platform/platformpage.h \
   qt/platform/platformservice.h \
-  qt/platform/platformui.h
+  qt/platform/platformui.h \
+  qt/platform/usernameflow.h
 endif
 
 QT_RES_ICONS = \
@@ -376,7 +378,8 @@ BITCOIN_QT_PLATFORM_CPP = \
   qt/platform/identityflow.cpp \
   qt/platform/platformpage.cpp \
   qt/platform/platformservice.cpp \
-  qt/platform/platformui.cpp
+  qt/platform/platformui.cpp \
+  qt/platform/usernameflow.cpp
 
 BITCOIN_QT_CPP = $(BITCOIN_QT_BASE_CPP)
 if TARGET_WINDOWS
 
@@ -27,8 +27,6 @@ namespace {
 using platform::IdentityPublicKey;
 using Funding = IdentityFlow::Funding;
 
-//! Every identity is index 0 until the UI offers more than one.
-constexpr uint32_t IDENTITY_INDEX{0};
 //! The asset lock's one credit output.
 constexpr uint32_t CREDIT_OUTPUT{0};
 //! rs-dpp IdentityAssetLockTransactionOutPointAlreadyConsumedError.
@@ -53,7 +51,10 @@ constexpr KeySpec REGISTRATION_KEYS[]{
     {5, IdentityPublicKey::Purpose::DECRYPTION, IdentityPublicKey::SecurityLevel::MEDIUM},
 };
 
-std::string RegistrationRecord() { return strprintf("%sidentity/%u", IdentityFlow::FUNDING_PREFIX, IDENTITY_INDEX); }
+std::string RegistrationRecord()
+{
+    return strprintf("%sidentity/%u", IdentityFlow::FUNDING_PREFIX, IdentityFlow::IDENTITY_INDEX);
+}
 std::string TopUpRecord(uint32_t index) { return strprintf("%stopup/%u", IdentityFlow::FUNDING_PREFIX, index); }
 
 std::vector<unsigned char> Encode(const Funding& funding)
@@ -115,7 +116,8 @@ std::pair<CTransactionRef, interfaces::WalletTxStatus> WalletTxOf(interfaces::Wa
 
 std::optional<std::array<uint8_t, 20>> MasterKeyHash(interfaces::Wallet& wallet)
 {
-    const auto key{wallet.getPlatformPubKey(wallet::IdentityAuthKey{IDENTITY_INDEX, REGISTRATION_KEYS[0].id})};
+    const auto key{
+        wallet.getPlatformPubKey(wallet::IdentityAuthKey{IdentityFlow::IDENTITY_INDEX, REGISTRATION_KEYS[0].id})};
     if (!key) return std::nullopt;
     const CKeyID hash{key.value.GetID()};
     std::array<uint8_t, 20> out;
@@ -127,7 +129,7 @@ std::optional<std::vector<IdentityPublicKey>> RegistrationKeys(interfaces::Walle
 {
     std::vector<IdentityPublicKey> keys;
     for (const KeySpec& spec : REGISTRATION_KEYS) {
-        const auto pubkey{wallet.getPlatformPubKey(wallet::IdentityAuthKey{IDENTITY_INDEX, spec.id})};
+        const auto pubkey{wallet.getPlatformPubKey(wallet::IdentityAuthKey{IdentityFlow::IDENTITY_INDEX, spec.id})};
         if (!pubkey) return std::nullopt;
         IdentityPublicKey key;
         key.id = spec.id;
@@ -151,18 +153,6 @@ std::optional<platform::AssetLockProof> NodeProof(interfaces::Node& node, interf
                                          COutPoint{tx->GetHash(), CREDIT_OUTPUT}};
 }
 
-//! Keeps the wallet unlocked until the client has signed the write.
-class WalletUnlock final : public platform::UnlockScope
-{
-public:
-    explicit WalletUnlock(WalletModel::UnlockContext unlock) :
-        m_unlock(std::move(unlock))
-    {
-    }
-
-private:
-    WalletModel::UnlockContext m_unlock;
-};
 } // namespace
 
 IdentityFlow::IdentityFlow(PlatformService& service, Confirm confirm, Proof proof) :
@@ -189,14 +179,6 @@ std::optional<Funding> IdentityFlow::funding() const
     return std::nullopt;
 }
 
-template <typename T>
-platform::PlatformClient::Callback<T> IdentityFlow::tracked(std::function<void(platform::Result<T>)> fn)
-{
-    auto call{std::make_shared<int>(0)};
-    m_call = call;
-    return [call, fn = std::move(fn)](platform::Result<T> result) { fn(std::move(result)); };
-}
-
 void IdentityFlow::serviceChanged()
 {
     // A call the client dropped never calls back; a funding record stays for Continue.
@@ -243,8 +225,9 @@ void IdentityFlow::startLookUp(bool unlock)
     if (m_step != Step::IDLE || !client) return;
     m_step = Step::LOOKING_UP;
     m_error.clear();
-    client->getIdentityByPublicKeyHash(*m_key_hash, tracked<platform::Identity>(
-                                                        [this](auto result) { onLookedUp(std::move(result)); }));
+    client->getIdentityByPublicKeyHash(*m_key_hash, PlatformUi::Tracked<platform::Identity>(m_call, [this](auto result) {
+        onLookedUp(std::move(result));
+    }));
     Q_EMIT changed();
 }
 
@@ -311,7 +294,7 @@ void IdentityFlow::awaitLock(Funding pending, CTransactionRef tx, WalletModel::U
 
 void IdentityFlow::fund(const wallet::AssetLockFundingKey& key, CAmount amount, Funding pending)
 {
-    if (m_step != Step::IDLE || !m_service.client() || funding()) return;
+    if (m_step != Step::IDLE || !m_service.client() || m_service.writing() || funding()) return;
     auto unlock{beginFunding()};
     if (!unlock) return;
     interfaces::Wallet& wallet{m_service.walletModel().wallet()};
@@ -338,7 +321,7 @@ void IdentityFlow::fund(const wallet::AssetLockFundingKey& key, CAmount amount,
 void IdentityFlow::resume()
 {
     auto pending{funding()};
-    if (m_step != Step::IDLE || !m_service.client() || !pending) return;
+    if (m_step != Step::IDLE || !m_service.client() || m_service.writing() || !pending) return;
     interfaces::Wallet& wallet{m_service.walletModel().wallet()};
     const auto [tx, status]{WalletTxOf(wallet, pending->txid)};
     if (!tx || status.is_abandoned || status.depth_in_main_chain < 0) {
@@ -365,20 +348,20 @@ void IdentityFlow::send()
         keys = RegistrationKeys(wallet);
         if (!keys) return finish(tr("Dash Core could not derive your identity's keys from this wallet."));
     }
-    platform::Signing signing{wallet, IDENTITY_INDEX, std::make_unique<WalletUnlock>(std::move(*m_unlock))};
+    platform::Signing signing{wallet, IDENTITY_INDEX, PlatformUi::KeepUnlocked(std::move(*m_unlock))};
     m_unlock.reset();
     m_step = Step::SENDING;
     if (m_funding->top_up) {
         client->topUpIdentity(m_funding->identity, *proof, *m_funding->top_up, std::move(signing),
-                              m_service.trackWrite<uint64_t>(
-                                  tracked<uint64_t>([this, funding = *m_funding](platform::Result<uint64_t> result) {
+                              m_service.trackWrite<uint64_t>(PlatformUi::Tracked<uint64_t>(
+                                  m_call, [this, funding = *m_funding](platform::Result<uint64_t> result) {
                                       if (result.ok() && m_identity) m_identity->balance = result.value;
                                       sent(funding, result.status);
                                   })));
     } else {
         client->registerIdentity(std::move(*keys), *proof, std::move(signing),
-                                 m_service.trackWrite<platform::Identity>(tracked<platform::Identity>(
-                                     [this, funding = *m_funding](platform::Result<platform::Identity> result) {
+                                 m_service.trackWrite<platform::Identity>(PlatformUi::Tracked<platform::Identity>(
+                                     m_call, [this, funding = *m_funding](platform::Result<platform::Identity> result) {
                                          if (result.ok()) {
                                              m_identity = std::move(result.value);
                                              m_looked_up = true;
 
@@ -46,6 +46,8 @@ class IdentityFlow : public QObject
     Q_OBJECT
 
 public:
+    //! Every identity is index 0 until the UI offers more than one.
+    static constexpr uint32_t IDENTITY_INDEX{0};
     //! What a new identity is funded with, as the mobile wallets: enough to
     //! register a username.
     static constexpr CAmount REGISTRATION_AMOUNT{3'000'000};
@@ -118,9 +120,6 @@ class IdentityFlow : public QObject
     void send();
     void sent(const Funding& funding, const platform::Status& status);
     void finish(const QString& error = {});
-    //! The callback of the one call in flight; it expires if the call is dropped.
-    template <typename T>
-    platform::PlatformClient::Callback<T> tracked(std::function<void(platform::Result<T>)> fn);
 
     PlatformService& m_service;
     const Confirm m_confirm;
@@ -132,6 +131,7 @@ class IdentityFlow : public QObject
     //! Hash160 of the MASTER key, kept once derived: deriving needs an
     //! unlocked wallet.
     std::optional<std::array<uint8_t, 20>> m_key_hash;
+    //! The one call in flight, until it calls back or is dropped.
     std::weak_ptr<void> m_call;
     //! The funding being waited for or sent, and the unlock it signs with.
     std::optional<Funding> m_funding;
 
@@ -11,10 +11,12 @@
 #include <qt/optionsmodel.h>
 #include <qt/platform/identityflow.h>
 #include <qt/platform/platformui.h>
+#include <qt/platform/usernameflow.h>
 #include <qt/walletmodel.h>
 
 #include <QHBoxLayout>
 #include <QLabel>
+#include <QLineEdit>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QVBoxLayout>
@@ -26,6 +28,11 @@ PlatformPage::PlatformPage(PlatformService::Sources sources, QWidget* parent) :
     auto* layout{new QVBoxLayout(this)};
     auto* title{new QLabel(tr("DashPay"), this)};
     GUIUtil::setFont({title}, GUIUtil::FontWeight::Bold, 18);
+    m_username = new QLabel(this);
+    m_username->setObjectName("dashPayUsername");
+    m_username->setTextFormat(Qt::PlainText);
+    m_username->setTextInteractionFlags(Qt::TextSelectableByMouse);
+    GUIUtil::setFont({m_username}, GUIUtil::FontWeight::Bold);
     m_identity = new QLabel(this);
     m_identity->setObjectName("dashPayIdentity");
     m_identity->setTextInteractionFlags(Qt::TextSelectableByMouse);
@@ -58,16 +65,36 @@ PlatformPage::PlatformPage(PlatformService::Sources sources, QWidget* parent) :
     actions->addWidget(m_top_up);
     actions->addStretch();
 
+    m_username_input = new QLineEdit(this);
+    m_username_input->setObjectName("dashPayUsernameInput");
+    m_username_input->setPlaceholderText(tr("Username"));
+    m_register = new QPushButton(tr("Register username"), this);
+    m_register->setObjectName("dashPayRegisterUsername");
+    m_username_status = new QLabel(this);
+    m_username_status->setObjectName("dashPayUsernameStatus");
+    m_username_status->setWordWrap(true);
+    auto* username_row{new QHBoxLayout};
+    username_row->addWidget(m_username_input);
+    username_row->addWidget(m_register);
+    username_row->addStretch();
+
+    auto* header{new QHBoxLayout};
+    header->addWidget(m_username);
+    header->addWidget(m_identity);
+    header->addStretch();
+
     m_start = new QPushButton(tr("Start DashPay"), this);
     m_start->setObjectName("dashPayStart");
     m_stop = new QPushButton(tr("Turn off DashPay for this wallet"), this);
     m_stop->setObjectName("dashPayStop");
     layout->addWidget(title);
-    layout->addWidget(m_identity);
+    layout->addLayout(header);
     layout->addWidget(notice);
     layout->addWidget(m_status);
     layout->addWidget(m_identity_status);
     layout->addLayout(actions);
+    layout->addWidget(m_username_status);
+    layout->addLayout(username_row);
     layout->addWidget(m_start, 0, Qt::AlignLeft);
     layout->addWidget(m_stop, 0, Qt::AlignLeft);
     layout->addStretch();
@@ -86,6 +113,11 @@ PlatformPage::PlatformPage(PlatformService::Sources sources, QWidget* parent) :
     connect(m_look_up, &QPushButton::clicked, this, [this] { m_identity_flow->lookUp(); });
     connect(m_create, &QPushButton::clicked, this, [this] { m_identity_flow->create(); });
     connect(m_continue, &QPushButton::clicked, this, [this] { m_identity_flow->resume(); });
+    const auto register_name = [this] {
+        m_username_flow->registerName(m_username_input->text().trimmed().toStdString());
+    };
+    connect(m_register, &QPushButton::clicked, this, register_name);
+    connect(m_username_input, &QLineEdit::returnPressed, this, register_name);
     connect(m_top_up, &QPushButton::clicked, this, [this] {
         bool valid{false};
         const CAmount amount{m_top_up_amount->value(&valid)};
@@ -117,6 +149,7 @@ void PlatformPage::resetService()
 {
     if (m_service) {
         Q_EMIT serviceChanged(nullptr);
+        m_username_flow.reset();
         m_identity_flow.reset();
         m_service.reset();
     }
@@ -127,6 +160,8 @@ void PlatformPage::resetService()
             return confirmFunding(amount, fee);
         });
         connect(m_identity_flow.get(), &IdentityFlow::changed, this, &PlatformPage::refresh);
+        m_username_flow = std::make_unique<UsernameFlow>(*m_service, *m_identity_flow);
+        connect(m_username_flow.get(), &UsernameFlow::changed, this, &PlatformPage::refresh);
         Q_EMIT serviceChanged(m_service.get());
     }
     refresh();
@@ -167,11 +202,17 @@ void PlatformPage::refresh()
                                      PlatformUi::FormatCredits(unit, identity->balance)));
     }
     m_identity->setVisible(identity != nullptr);
+    const UsernameFlow* names{m_username_flow.get()};
+    const auto username{names && identity ? names->username() : std::nullopt};
+    m_username->setText(QString::fromStdString(username.value_or(std::string{})));
+    m_username->setVisible(username.has_value());
 
     using Step = IdentityFlow::Step;
     const Step step{flow ? flow->step() : Step::IDLE};
     const auto funding{running ? flow->funding() : std::nullopt};
-    const bool idle{running && step == Step::IDLE};
+    using NameStep = UsernameFlow::Step;
+    const NameStep name_step{names ? names->step() : NameStep::IDLE};
+    const bool idle{running && step == Step::IDLE && name_step == NameStep::IDLE};
     //! Nothing in flight and no funding waiting for Platform.
     const bool ready{idle && !funding};
     QString identity_status;
@@ -211,4 +252,26 @@ void PlatformPage::refresh()
     m_continue->setVisible(idle && funding.has_value());
     m_top_up_amount->setVisible(ready && identity);
     m_top_up->setVisible(ready && identity);
+
+    QString username_status;
+    switch (name_step) {
+    case NameStep::IDLE:
+        if (running) username_status = names->error();
+        break;
+    case NameStep::CHECKING:
+        username_status = tr("Checking that the username is free…");
+        break;
+    case NameStep::PREPARING:
+        // Until the identity exists its own status says what runs.
+        if (identity) username_status = tr("Registering your username…");
+        break;
+    case NameStep::REGISTERING:
+        username_status = tr("Registering your username…");
+        break;
+    }
+    m_username_status->setText(username_status);
+    m_username_status->setVisible(!username_status.isEmpty());
+    const bool can_register{ready && flow->lookedUp() && (!identity || (names->namesRead() && !username))};
+    m_username_input->setVisible(can_register);
+    m_register->setVisible(can_register);
 }
@@ -14,9 +14,11 @@
 
 class BitcoinAmountField;
 class IdentityFlow;
+class UsernameFlow;
 
 QT_BEGIN_NAMESPACE
 class QLabel;
+class QLineEdit;
 class QPushButton;
 QT_END_NAMESPACE
 
@@ -25,7 +27,8 @@ QT_END_NAMESPACE
  *  It owns the wallet's PlatformService while both models are set, offers
  *  the first DashPay click with a one-line privacy notice, and says why
  *  DashPay can't run when a gate is closed. Once DashPay runs it shows the
- *  wallet's identity and its balance, and creates, continues or tops it up. */
+ *  wallet's identity, its username and its balance; creates, continues or
+ *  tops up the identity; and registers its username. */
 class PlatformPage : public QWidget
 {
     Q_OBJECT
@@ -38,6 +41,7 @@ class PlatformPage : public QWidget
     void setClientModel(ClientModel* client_model);
     PlatformService* service() const { return m_service.get(); }
     IdentityFlow* identityFlow() const { return m_identity_flow.get(); }
+    UsernameFlow* usernameFlow() const { return m_username_flow.get(); }
 
 Q_SIGNALS:
     //! A service was created, or is about to be destroyed (nullptr) while
@@ -55,7 +59,10 @@ class PlatformPage : public QWidget
     std::unique_ptr<PlatformService> m_service;
     //! Destroyed before the service it calls through.
     std::unique_ptr<IdentityFlow> m_identity_flow;
+    //! Destroyed before the identity flow it builds on.
+    std::unique_ptr<UsernameFlow> m_username_flow;
 
+    QLabel* m_username{nullptr};
     QLabel* m_identity{nullptr};
     QLabel* m_status{nullptr};
     QLabel* m_identity_status{nullptr};
@@ -64,6 +71,9 @@ class PlatformPage : public QWidget
     QPushButton* m_continue{nullptr};
     BitcoinAmountField* m_top_up_amount{nullptr};
     QPushButton* m_top_up{nullptr};
+    QLineEdit* m_username_input{nullptr};
+    QPushButton* m_register{nullptr};
+    QLabel* m_username_status{nullptr};
     QPushButton* m_start{nullptr};
     QPushButton* m_stop{nullptr};
 };
 
@@ -115,6 +115,10 @@ class PlatformService : public QObject
     //! rebuild waits for a write. A call whose client is destroyed never
     //! calls back.
     platform::PlatformClient* client() const { return m_paused ? nullptr : m_client.get(); }
+    //! Whether a write is in flight. The wallet's flows start one only when
+    //! none is, which serializes the wallet's unlocks and its identity's
+    //! state transitions.
+    bool writing() const { return m_writes > 0; }
 
     //! Wrap the callback of a write, in the call that starts it: a rebuild
     //! waits until it has run.