Overhauled the Buy Names Page with the Electrum-NMC version

src/names/applications.cpp

@@ -12,6 +12,8 @@
 
 #include <logging.h>
 
+const std::string NAMECOIN_DOMAIN_SUFFIX = ".bit";
+
 namespace
 {
 
@@ -171,7 +173,7 @@ DescFromName (const valtype& name, NameNamespace ns)
             const std::string nameStr = EncodeName (name, NameEncoding::ASCII);
             const std::string label = nameStr.substr(nsLen);
 
-            return label + ".bit";
+            return label + NAMECOIN_DOMAIN_SUFFIX;
         }
         default:
         {
@@ -185,21 +187,20 @@ IsValidJSONOrEmptyString (const std::string& text){
     UniValue v;
 
     return text.empty() || v.read(text);
-}    
+}
 
 bool
 IsMinimalJSONOrEmptyString (const std::string& text){
     UniValue v;
     if(text.empty()){
         return true;
-    } 
+    }
 
-    if(!v.read(text)){ 
+    if(!v.read(text)){
         return false;
-    } 
+    }
 
     const std::string minimalJSON = GetMinimalJSON(text);
-
     const bool isMinimal = (text == minimalJSON);
 
     if(!isMinimal){
@@ -217,3 +218,13 @@ GetMinimalJSON (const std::string& text){
 
     return v.write(0,0);
 }
+
+bool
+IsPurportedNamecoinDomain (const std::string& domain) {
+    return domain.ends_with(NAMECOIN_DOMAIN_SUFFIX);
+}
+
+std::string
+ASCIIFromDomain(const std::string& domain) {
+    return "d/" + domain.substr(0, domain.size()-(NAMECOIN_DOMAIN_SUFFIX.length()));
+}

src/names/applications.h

@@ -29,4 +29,9 @@ bool IsMinimalJSONOrEmptyString (const std::string& text);
 
 std::string GetMinimalJSON (const std::string& text);
 
+bool IsPurportedNamecoinDomain (const std::string& domain);
+
+std::string ASCIIFromDomain (const std::string& domain);
+
 #endif // H_BITCOIN_NAMES_APPLICATIONS
+

src/qt/buynamespage.cpp

@@ -9,7 +9,7 @@
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <rpc/protocol.h>
-
+#include <names/applications.h>
 #include <names/encoding.h>
 #include <univalue.h>
 
@@ -25,10 +25,14 @@ BuyNamesPage::BuyNamesPage(const PlatformStyle *platformStyle, QWidget *parent)
 
     ui->registerNameButton->hide();
 
-    connect(ui->registerName, &QLineEdit::textEdited, this, &BuyNamesPage::onNameEdited);
+    connect(ui->registerNameDomain, &QLineEdit::textEdited, this, &BuyNamesPage::onDomainNameEdited);
+    connect(ui->registerNameAscii, &QLineEdit::textEdited, this, &BuyNamesPage::onAsciiNameEdited);
+    connect(ui->registerNameHex, &QLineEdit::textEdited, this, &BuyNamesPage::onHexNameEdited);
     connect(ui->registerNameButton, &QPushButton::clicked, this, &BuyNamesPage::onRegisterNameAction);
 
-    ui->registerName->installEventFilter(this);
+    ui->registerNameDomain->installEventFilter(this);
+    ui->registerNameAscii->installEventFilter(this);
+    ui->registerNameHex->installEventFilter(this);
 }
 
 BuyNamesPage::~BuyNamesPage()
@@ -45,22 +49,59 @@ bool BuyNamesPage::eventFilter(QObject *object, QEvent *event)
 {
     if (event->type() == QEvent::FocusIn)
     {
-        if (object == ui->registerName)
+        if (object == ui->registerNameAscii)
+        {
+            ui->registerNameButton->setDefault(true);
+        }
+
+        if (object == ui->registerNameHex)
+        {
+            ui->registerNameButton->setDefault(true);
+        }
+
+        if (object == ui->registerNameDomain)
         {
             ui->registerNameButton->setDefault(true);
         }
+
     }
     return QWidget::eventFilter(object, event);
 }
 
-void BuyNamesPage::onNameEdited(const QString &name)
-{
-    if (!walletModel)
-        return;
 
-    const QString availableError = name_available(name);
+QString BuyNamesPage::DomainToASCII(const QString &name) {
+    if(IsPurportedNamecoinDomain(name.toStdString()))
+    {
+        return QString::fromStdString(ASCIIFromDomain(name.toStdString()));
+    }
+    return QString("");
+}
+
+
+QString BuyNamesPage::ASCIIToDomain(const QString &name) {
+    if(NamespaceFromName(name.toStdString()) == NameNamespace::Domain)
+    {
+        return QString::fromStdString(DescFromName(DecodeName(name.toStdString(), NameEncoding::ASCII), NameNamespace::Domain));
+    }
+    return QString("");
+}
+
+
+QString BuyNamesPage::HexToASCII(const QString &name) {
+    return NameTableModel::hexToAscii(name);
+}
+
+
+QString BuyNamesPage::ASCIIToHex(const QString &name) {
+    return NameTableModel::asciiToHex(name);
+}
 
-    if (availableError == "")
+void BuyNamesPage::RefreshAvailableError()
+{
+    QString name = ui->registerNameAscii->text();
+    QString availableError = name_available(name);
+
+    if (availableError.isEmpty())
     {
         ui->statusLabel->setText(tr("%1 is available to register!").arg(name));
         ui->registerNameButton->show();
@@ -72,12 +113,83 @@ void BuyNamesPage::onNameEdited(const QString &name)
     }
 }
 
+void BuyNamesPage::onAsciiNameEdited(const QString &name) {
+    if (!walletModel)
+        return;
+
+    try
+    {
+        const QString hexName = ASCIIToHex(name);
+        const QString domainName = ASCIIToDomain(name);
+
+        ui->registerNameHex->setText(hexName);
+        ui->registerNameDomain->setText(domainName);
+
+        RefreshAvailableError();
+    }
+    catch(InvalidNameString &e)
+    {
+        ui->statusLabel->setText(tr("Not a valid ASCII entry!"));
+    }
+
+}
+
+void BuyNamesPage::onHexNameEdited(const QString &name) {
+    if (!walletModel)
+        return;
+
+    try {
+        const QString asciiName = HexToASCII(name);
+        const QString domainName = ASCIIToDomain(asciiName);
+
+        ui->registerNameAscii->setText(asciiName);
+        ui->registerNameDomain->setText(domainName);
+
+        RefreshAvailableError();
+    }
+    catch(InvalidNameString &e)
+    {
+        ui->statusLabel->setText(tr("Not a valid hex entry!"));
+    }
+
+}
+
+void BuyNamesPage::onDomainNameEdited(const QString &name) {
+    if (!walletModel)
+        return;
+
+    try
+    {
+        const QString asciiName = DomainToASCII(name);
+        const QString hexName = ASCIIToHex(asciiName);
+
+        ui->registerNameAscii->setText(asciiName);
+        ui->registerNameHex->setText(hexName);
+
+        if(IsPurportedNamecoinDomain(name.toStdString()))
+        {
+            RefreshAvailableError();
+        }
+        else
+        {
+            ui->statusLabel->setText(tr("\"%1\" requires .bit at the end to be a valid Namecoin domain!").arg(name));
+            ui->registerNameButton->hide();
+        }
+    }
+    catch(InvalidNameString &e)
+    {
+        ui->statusLabel->setText(tr("Not a valid entry!"));
+    }
+
+
+}
+
 void BuyNamesPage::onRegisterNameAction()
 {
     if (!walletModel)
         return;
 
-    QString name = ui->registerName->text();
+    QString name = ui->registerNameAscii->text();
 
     WalletModel::UnlockContext ctx(walletModel->requestUnlock());
     if (!ctx.isValid())
@@ -99,8 +211,9 @@ void BuyNamesPage::onRegisterNameAction()
         return;
     }
 
-    // reset UI text
-    ui->registerName->setText("d/");
+    ui->registerNameDomain->setText("");
+    ui->registerNameAscii->setText("d/");
+    ui->registerNameHex->setText(HexToASCII(QString("d/")));
     ui->registerNameButton->setDefault(true);
 }
 

src/qt/buynamespage.h

@@ -31,13 +31,22 @@ class BuyNamesPage : public QWidget
     Ui::BuyNamesPage *ui;
     WalletModel *walletModel;
 
+    QString DomainToASCII(const QString &name);
+    QString ASCIIToDomain(const QString &name);
+    QString HexToASCII(const QString &name);
+    QString ASCIIToHex(const QString &name);
+    void RefreshAvailableError();
+
     QString name_available(const QString &name) const;
     QString firstupdate(const QString &name, const std::optional<QString> &value, const std::optional<QString> &transferTo) const;
 
 private Q_SLOTS:
     bool eventFilter(QObject *object, QEvent *event);
 
-    void onNameEdited(const QString &name);
+    void onDomainNameEdited(const QString &name);
+    void onHexNameEdited(const QString &name);
+    void onAsciiNameEdited(const QString &name);
+
     void onRegisterNameAction();
 };