update

dist/js/ui/profileModal/ProfileWalletController.js

@@ -0,0 +1,758 @@
+import { devLogger } from "../../utils/logger.js";
+import { NWC_URI_SCHEME } from "../profileModalContract.js";
+
+const noop = () => {};
+const SECRET_PLACEHOLDER = "*****";
+
+export class ProfileWalletController {
+  constructor(mainController) {
+    this.mainController = mainController;
+
+    this.walletUriInput = null;
+    this.walletDefaultZapInput = null;
+    this.walletSaveButton = null;
+    this.walletTestButton = null;
+    this.walletDisconnectButton = null;
+    this.walletStatusText = null;
+    this.walletPane = null;
+  }
+
+  cacheDomReferences() {
+    this.walletUriInput = document.getElementById("profileWalletUri") || null;
+    this.walletDefaultZapInput = document.getElementById("profileWalletDefaultZap") || null;
+    this.walletSaveButton = document.getElementById("profileWalletSave") || null;
+    this.walletTestButton = document.getElementById("profileWalletTest") || null;
+    this.walletDisconnectButton = document.getElementById("profileWalletDisconnect") || null;
+    this.walletStatusText = document.getElementById("profileWalletStatus") || null;
+    this.walletPane = document.getElementById("profilePaneWallet") || null;
+
+    // Backwards compatibility alias if needed by tests/external code
+    this.mainController.profileWalletStatusText = this.walletStatusText;
+  }
+
+  registerEventListeners() {
+    if (this.walletUriInput instanceof HTMLElement) {
+      this.walletUriInput.addEventListener("focus", () => {
+        this.revealSecretInputValue(this.walletUriInput);
+      });
+      this.walletUriInput.addEventListener("blur", () => {
+        this.handleSecretInputBlur(this.walletUriInput);
+        this.applyWalletControlState();
+      });
+      this.walletUriInput.addEventListener("input", () => {
+        this.handleSecretInputChange(this.walletUriInput);
+        this.applyWalletControlState();
+      });
+    }
+
+    if (this.walletDefaultZapInput instanceof HTMLElement) {
+      this.walletDefaultZapInput.addEventListener("input", () => {
+        this.applyWalletControlState();
+      });
+    }
+
+    if (this.walletSaveButton instanceof HTMLElement) {
+      this.walletSaveButton.addEventListener("click", () => {
+        void this.handleWalletSave();
+      });
+    }
+
+    if (this.walletTestButton instanceof HTMLElement) {
+      this.walletTestButton.addEventListener("click", () => {
+        void this.handleWalletTest();
+      });
+    }
+
+    if (this.walletDisconnectButton instanceof HTMLElement) {
+      this.walletDisconnectButton.addEventListener("click", () => {
+        void this.handleWalletDisconnect();
+      });
+    }
+  }
+
+  applyWalletControlState() {
+    const hasActive = Boolean(
+      this.mainController.normalizeHexPubkey(this.mainController.getActivePubkey())
+    );
+    const busy = this.isWalletBusy();
+    const uriValue = this.getSecretInputValue(this.walletUriInput);
+    const hasUri = uriValue.length > 0;
+
+    const applyDisabledState = (element, disabled) => {
+      if (!(element instanceof HTMLElement)) {
+        return;
+      }
+      if ("disabled" in element) {
+        element.disabled = disabled;
+      }
+      if (disabled) {
+        element.setAttribute("aria-disabled", "true");
+      } else {
+        element.removeAttribute("aria-disabled");
+      }
+    };
+
+    applyDisabledState(this.walletUriInput, busy || !hasActive);
+    applyDisabledState(this.walletDefaultZapInput, busy || !hasActive);
+    applyDisabledState(this.walletSaveButton, busy || !hasActive);
+
+    const testDisabled = busy || !hasActive || !hasUri;
+    applyDisabledState(this.walletTestButton, testDisabled);
+
+    const disconnectDisabled = busy || !hasActive || !hasUri;
+    applyDisabledState(this.walletDisconnectButton, disconnectDisabled);
+    if (this.walletDisconnectButton instanceof HTMLElement) {
+      this.walletDisconnectButton.classList.toggle("hidden", !hasUri);
+      if (!hasUri) {
+        this.walletDisconnectButton.setAttribute("aria-hidden", "true");
+      } else {
+        this.walletDisconnectButton.removeAttribute("aria-hidden");
+      }
+    }
+  }
+
+  updateWalletStatus(message, variant = "info") {
+    if (!(this.walletStatusText instanceof HTMLElement)) {
+      return;
+    }
+
+    const element = this.walletStatusText;
+    const variants = {
+      success: "text-status-success",
+      error: "text-status-danger",
+      info: "text-status-info",
+      neutral: "text-status-neutral",
+    };
+
+    element.classList.remove(
+      "text-status-info",
+      "text-status-success",
+      "text-status-danger",
+      "text-status-neutral",
+    );
+    const variantClass = variants[variant] || variants.neutral;
+    element.classList.add(variantClass);
+    element.textContent = message || "";
+  }
+
+  refreshWalletPaneState() {
+    const hasActive = Boolean(
+      this.mainController.normalizeHexPubkey(this.mainController.getActivePubkey())
+    );
+    if (!hasActive) {
+      this.setSecretInputValue(this.walletUriInput, "");
+      if (this.walletDefaultZapInput && "value" in this.walletDefaultZapInput) {
+        try {
+          this.walletDefaultZapInput.value = "";
+        } catch (error) {
+          if (this.walletDefaultZapInput instanceof HTMLElement) {
+            this.walletDefaultZapInput.setAttribute("data-value", "");
+          }
+        }
+      }
+      this.updateWalletStatus("Sign in to connect a wallet.", "info");
+      this.applyWalletControlState();
+      return;
+    }
+
+    let settings = this.mainController.services.nwcSettings.getActiveNwcSettings();
+    if (!settings || typeof settings !== "object") {
+      settings = this.mainController.services.nwcSettings.createDefaultNwcSettings();
+    }
+    this.setSecretInputValue(this.walletUriInput, settings.nwcUri || "");
+    if (this.walletDefaultZapInput && "value" in this.walletDefaultZapInput) {
+      const defaultZapValue =
+        settings.defaultZap === null || settings.defaultZap === undefined
+          ? ""
+          : String(settings.defaultZap);
+      try {
+        this.walletDefaultZapInput.value = defaultZapValue;
+      } catch (error) {
+        if (this.walletDefaultZapInput instanceof HTMLElement) {
+          this.walletDefaultZapInput.setAttribute("data-value", defaultZapValue);
+        }
+      }
+    }
+
+    if (settings.nwcUri) {
+      this.updateWalletStatus(
+        "Wallet connected via Nostr Wallet Connect.",
+        "success",
+      );
+    } else {
+      this.updateWalletStatus("No wallet connected yet.", "info");
+    }
+
+    this.applyWalletControlState();
+  }
+
+  isSecretInputElement(element) {
+    if (!element || typeof element !== "object") {
+      return false;
+    }
+    if (
+      typeof HTMLInputElement !== "undefined" &&
+      element instanceof HTMLInputElement
+    ) {
+      return true;
+    }
+    return typeof element.value === "string";
+  }
+
+  sanitizeSecretValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+  }
+
+  getSecretInputValue(element) {
+    if (!this.isSecretInputElement(element)) {
+      return "";
+    }
+
+    const placeholder =
+      typeof element.dataset?.secretPlaceholder === "string"
+        ? element.dataset.secretPlaceholder
+        : SECRET_PLACEHOLDER;
+    const stored = this.sanitizeSecretValue(
+      typeof element.dataset?.secretValue === "string"
+        ? element.dataset.secretValue
+        : ""
+    );
+    const raw = this.sanitizeSecretValue(element.value);
+    const isMasked = element.dataset?.secretMasked === "true";
+
+    if (isMasked && placeholder && raw === placeholder) {
+      return stored;
+    }
+
+    if (!raw && isMasked) {
+      return stored;
+    }
+
+    return raw;
+  }
+
+  setSecretInputValue(element, value) {
+    if (!this.isSecretInputElement(element)) {
+      return;
+    }
+
+    const sanitized = this.sanitizeSecretValue(value);
+    if (!sanitized) {
+      if (element.dataset) {
+        delete element.dataset.secretValue;
+        delete element.dataset.secretMasked;
+        delete element.dataset.secretPlaceholder;
+      }
+      element.value = "";
+      return;
+    }
+
+    const placeholder = SECRET_PLACEHOLDER;
+    if (element.dataset) {
+      element.dataset.secretValue = sanitized;
+      element.dataset.secretPlaceholder = placeholder;
+      element.dataset.secretMasked = "true";
+    }
+    element.value = placeholder;
+  }
+
+  revealSecretInputValue(element) {
+    if (!this.isSecretInputElement(element)) {
+      return;
+    }
+
+    const stored = this.sanitizeSecretValue(
+      typeof element.dataset?.secretValue === "string"
+        ? element.dataset.secretValue
+        : ""
+    );
+
+    if (!stored) {
+      if (element.dataset) {
+        delete element.dataset.secretMasked;
+      }
+      return;
+    }
+
+    if (element.dataset) {
+      element.dataset.secretMasked = "false";
+    }
+    element.value = stored;
+    try {
+      if (typeof element.setSelectionRange === "function") {
+        const length = stored.length;
+        element.setSelectionRange(length, length);
+      }
+    } catch (error) {
+      // Ignore selection errors on unsupported input types.
+    }
+  }
+
+  handleSecretInputChange(element) {
+    if (!this.isSecretInputElement(element)) {
+      return;
+    }
+
+    const value = this.sanitizeSecretValue(element.value);
+    if (!value) {
+      if (element.dataset) {
+        element.dataset.secretMasked = "false";
+        delete element.dataset.secretValue;
+      }
+      return;
+    }
+
+    if (element.dataset) {
+      element.dataset.secretValue = value;
+      element.dataset.secretMasked = "false";
+      if (!element.dataset.secretPlaceholder) {
+        element.dataset.secretPlaceholder = SECRET_PLACEHOLDER;
+      }
+    }
+  }
+
+  handleSecretInputBlur(element) {
+    if (!this.isSecretInputElement(element)) {
+      return;
+    }
+
+    const value = this.sanitizeSecretValue(this.getSecretInputValue(element));
+    if (!value) {
+      if (element.dataset) {
+        delete element.dataset.secretValue;
+        delete element.dataset.secretMasked;
+        delete element.dataset.secretPlaceholder;
+      }
+      element.value = "";
+      return;
+    }
+
+    if (element.dataset) {
+      element.dataset.secretValue = value;
+      element.dataset.secretPlaceholder =
+        element.dataset.secretPlaceholder || SECRET_PLACEHOLDER;
+      element.dataset.secretMasked = "true";
+    }
+    element.value = element.dataset?.secretPlaceholder || SECRET_PLACEHOLDER;
+  }
+
+  getWalletFormValues() {
+    const uri = this.getSecretInputValue(this.walletUriInput);
+    const defaultZapRaw =
+      typeof this.walletDefaultZapInput?.value === "string"
+        ? this.walletDefaultZapInput.value.trim()
+        : "";
+
+    if (defaultZapRaw) {
+      const numeric = Number(defaultZapRaw);
+      if (!Number.isFinite(numeric)) {
+        return { uri, error: "Default zap amount must be a number." };
+      }
+      const rounded = Math.round(numeric);
+      if (!Number.isFinite(rounded) || rounded < 0) {
+        return {
+          uri,
+          error: "Default zap amount must be a positive whole number.",
+        };
+      }
+      const clamped = Math.min(this.mainController.maxWalletDefaultZap, rounded);
+      return { uri, defaultZap: clamped };
+    }
+
+    return { uri, defaultZap: null };
+  }
+
+  validateWalletUri(uri, { requireValue = false } = {}) {
+    const value = typeof uri === "string" ? uri.trim() : "";
+    if (!value) {
+      if (requireValue) {
+        return {
+          valid: false,
+          sanitized: "",
+          message: "Enter a wallet connect URI before continuing.",
+        };
+      }
+      return { valid: true, sanitized: "" };
+    }
+
+    if (!value.toLowerCase().startsWith(NWC_URI_SCHEME)) {
+      return {
+        valid: false,
+        sanitized: value,
+        message: `Wallet URI must start with ${NWC_URI_SCHEME}.`,
+      };
+    }
+
+    return { valid: true, sanitized: value };
+  }
+
+  async handleWalletSave() {
+    const { uri, defaultZap, error } = this.getWalletFormValues();
+    const context = {
+      uri,
+      defaultZap: defaultZap ?? null,
+      sanitizedUri: null,
+      success: false,
+      reason: null,
+      error: error || null,
+      status: null,
+      variant: null,
+    };
+
+    if (this.isWalletBusy()) {
+      context.reason = "busy";
+      this.mainController.callbacks.onWalletSave(context, this.mainController);
+      return context;
+    }
+
+    if (error) {
+      this.updateWalletStatus(error, "error");
+      this.mainController.showError(error);
+      context.reason = "invalid-default-zap";
+      if (this.walletDefaultZapInput instanceof HTMLElement) {
+        this.walletDefaultZapInput.focus();
+      }
+      this.mainController.callbacks.onWalletSave(context, this.mainController);
+      return context;
+    }
+
+    const { valid, sanitized, message } = this.validateWalletUri(uri);
+    context.sanitizedUri = sanitized;
+    if (!valid) {
+      this.updateWalletStatus(message, "error");
+      this.mainController.showError(message);
+      context.reason = "invalid-uri";
+      context.error = message;
+      if (this.walletUriInput instanceof HTMLElement) {
+        this.walletUriInput.focus();
+      }
+      this.mainController.callbacks.onWalletSave(context, this.mainController);
+      return context;
+    }
+
+    const normalizedActive = this.mainController.normalizeHexPubkey(
+      this.mainController.getActivePubkey()
+    );
+    if (!normalizedActive) {
+      const loginMessage = "Sign in to save wallet settings.";
+      this.updateWalletStatus(loginMessage, "error");
+      this.mainController.showError(loginMessage);
+      context.reason = "no-active-pubkey";
+      context.error = loginMessage;
+      this.mainController.callbacks.onWalletSave(context, this.mainController);
+      return context;
+    }
+
+    this.setWalletPaneBusy(true);
+    let finalStatus = null;
+    let finalVariant = "info";
+    try {
+      const persistResult = await this.persistWalletSettings({
+        nwcUri: sanitized,
+        defaultZap,
+        activePubkey: normalizedActive,
+      });
+      context.persistResult = persistResult || null;
+
+      if (sanitized) {
+        finalStatus = "Wallet settings saved.";
+        finalVariant = "success";
+        this.mainController.showSuccess("Wallet settings saved.");
+        context.reason = "saved";
+      } else {
+        finalStatus = "Wallet connection removed.";
+        finalVariant = "info";
+        this.mainController.showStatus("Wallet connection removed.");
+        context.reason = "cleared";
+      }
+      context.success = true;
+    } catch (error) {
+      const fallbackMessage = "Failed to save wallet settings.";
+      const detail =
+        error && typeof error.message === "string" && error.message.trim()
+          ? error.message.trim()
+          : fallbackMessage;
+      finalStatus = detail;
+      finalVariant = "error";
+      context.error = detail;
+      context.reason = error?.code || "service-error";
+      this.mainController.showError(detail);
+    } finally {
+      this.setWalletPaneBusy(false);
+      this.refreshWalletPaneState();
+      if (finalStatus) {
+        this.updateWalletStatus(finalStatus, finalVariant);
+      }
+      context.status = finalStatus;
+      context.variant = finalVariant;
+      this.mainController.callbacks.onWalletSave(context, this.mainController);
+    }
+
+    return context;
+  }
+
+  async handleWalletTest() {
+    const { uri, defaultZap, error } = this.getWalletFormValues();
+    const context = {
+      uri,
+      defaultZap: defaultZap ?? null,
+      sanitizedUri: null,
+      success: false,
+      reason: null,
+      error: error || null,
+      status: null,
+      variant: null,
+      result: null,
+    };
+
+    if (this.isWalletBusy()) {
+      context.reason = "busy";
+      this.mainController.callbacks.onWalletTest(context, this.mainController);
+      return context.result;
+    }
+
+    if (error) {
+      this.updateWalletStatus(error, "error");
+      this.mainController.showError(error);
+      context.reason = "invalid-default-zap";
+      if (this.walletDefaultZapInput instanceof HTMLElement) {
+        this.walletDefaultZapInput.focus();
+      }
+      this.mainController.callbacks.onWalletTest(context, this.mainController);
+      return context.result;
+    }
+
+    const { valid, sanitized, message } = this.validateWalletUri(uri, {
+      requireValue: true,
+    });
+    context.sanitizedUri = sanitized;
+    if (!valid) {
+      this.updateWalletStatus(message, "error");
+      this.mainController.showError(message);
+      context.reason = "invalid-uri";
+      context.error = message;
+      if (this.walletUriInput instanceof HTMLElement) {
+        this.walletUriInput.focus();
+      }
+      this.mainController.callbacks.onWalletTest(context, this.mainController);
+      return context.result;
+    }
+
+    const normalizedActive = this.mainController.normalizeHexPubkey(
+      this.mainController.getActivePubkey()
+    );
+    if (!normalizedActive) {
+      const loginMessage = "Sign in to test your wallet connection.";
+      this.updateWalletStatus(loginMessage, "error");
+      this.mainController.showError(loginMessage);
+      context.reason = "no-active-pubkey";
+      context.error = loginMessage;
+      this.mainController.callbacks.onWalletTest(context, this.mainController);
+      return context.result;
+    }
+
+    this.setWalletPaneBusy(true);
+    let finalStatus = null;
+    let finalVariant = "info";
+    try {
+      const result = await this.testWalletConnection({
+        nwcUri: sanitized,
+        defaultZap,
+        activePubkey: normalizedActive,
+      });
+      finalStatus = "Wallet connection confirmed.";
+      finalVariant = "success";
+      this.mainController.showSuccess("Wallet connection confirmed.");
+      context.result = result;
+      context.success = true;
+      context.reason = "tested";
+
+      let currentSettings = this.mainController.services.nwcSettings.getActiveNwcSettings();
+      if (!currentSettings || typeof currentSettings !== "object") {
+        currentSettings = this.mainController.services.nwcSettings.createDefaultNwcSettings();
+      }
+      if (currentSettings.nwcUri === sanitized) {
+        await this.persistWalletSettings({
+          lastChecked: Date.now(),
+          activePubkey: normalizedActive,
+        });
+      }
+    } catch (error) {
+      const fallbackMessage = "Failed to reach wallet.";
+      const detail =
+        error && typeof error.message === "string" && error.message.trim()
+          ? error.message.trim()
+          : fallbackMessage;
+      finalStatus = detail;
+      finalVariant = "error";
+      context.error = detail;
+      context.reason = error?.code || "service-error";
+      this.mainController.showError(detail);
+    } finally {
+      this.setWalletPaneBusy(false);
+      this.refreshWalletPaneState();
+      if (finalStatus) {
+        this.updateWalletStatus(finalStatus, finalVariant);
+      }
+      context.status = finalStatus;
+      context.variant = finalVariant;
+      this.mainController.callbacks.onWalletTest(context, this.mainController);
+    }
+
+    return context.result;
+  }
+
+  async handleWalletDisconnect() {
+    const context = {
+      success: false,
+      reason: null,
+      error: null,
+      status: null,
+      variant: null,
+    };
+
+    if (this.isWalletBusy()) {
+      context.reason = "busy";
+      this.mainController.callbacks.onWalletDisconnect(
+        context,
+        this.mainController
+      );
+      return context;
+    }
+
+    const normalizedActive = this.mainController.normalizeHexPubkey(
+      this.mainController.getActivePubkey()
+    );
+    if (!normalizedActive) {
+      const loginMessage = "Sign in to disconnect your wallet.";
+      this.updateWalletStatus(loginMessage, "error");
+      this.mainController.showError(loginMessage);
+      context.reason = "no-active-pubkey";
+      context.error = loginMessage;
+      this.mainController.callbacks.onWalletDisconnect(
+        context,
+        this.mainController
+      );
+      return context;
+    }
+
+    this.setWalletPaneBusy(true);
+    let finalStatus = null;
+    let finalVariant = "info";
+    try {
+      const disconnectResult = await this.disconnectWallet({
+        activePubkey: normalizedActive,
+      });
+      context.result = disconnectResult || null;
+      finalStatus = "Wallet disconnected.";
+      this.mainController.showStatus("Wallet disconnected.");
+      context.success = true;
+      context.reason = "disconnected";
+    } catch (error) {
+      const fallbackMessage = "Failed to disconnect wallet.";
+      const detail =
+        error && typeof error.message === "string" && error.message.trim()
+          ? error.message.trim()
+          : fallbackMessage;
+      finalStatus = detail;
+      finalVariant = "error";
+      context.error = detail;
+      context.reason = error?.code || "service-error";
+      this.mainController.showError(detail);
+    } finally {
+      this.setWalletPaneBusy(false);
+      this.refreshWalletPaneState();
+      if (finalStatus) {
+        this.updateWalletStatus(finalStatus, finalVariant);
+      }
+      context.status = finalStatus;
+      context.variant = finalVariant;
+      this.mainController.callbacks.onWalletDisconnect(
+        context,
+        this.mainController
+      );
+    }
+
+    return context;
+  }
+
+  isWalletBusy() {
+    return Boolean(this.mainController.state.getWalletBusy());
+  }
+
+  setWalletPaneBusy(isBusy) {
+    const result = this.mainController.state.setWalletBusy(Boolean(isBusy));
+    if (this.walletPane instanceof HTMLElement) {
+      this.walletPane.setAttribute(
+        "aria-busy",
+        this.isWalletBusy() ? "true" : "false"
+      );
+    }
+    this.applyWalletControlState();
+    return result;
+  }
+
+  async persistWalletSettings({
+    nwcUri,
+    defaultZap,
+    lastChecked,
+    activePubkey,
+  } = {}) {
+    const callback = this.mainController.callbacks.onWalletPersist;
+    if (callback && callback !== noop) {
+      const result = await callback({
+        controller: this.mainController,
+        nwcUri,
+        defaultZap,
+        lastChecked,
+        activePubkey,
+      });
+      if (result !== undefined) {
+        return result;
+      }
+    }
+
+    return this.mainController.services.nwcSettings.handleProfileWalletPersist({
+      nwcUri,
+      defaultZap,
+      lastChecked,
+    });
+  }
+
+  async testWalletConnection({ nwcUri, defaultZap, activePubkey } = {}) {
+    const callback = this.mainController.callbacks.onWalletTestRequest;
+    if (callback && callback !== noop) {
+      const result = await callback({
+        controller: this.mainController,
+        nwcUri,
+        defaultZap,
+        activePubkey,
+      });
+      if (result !== undefined) {
+        return result;
+      }
+    }
+
+    return this.mainController.services.nwcSettings.ensureWallet({
+      nwcUri,
+      defaultZap,
+    });
+  }
+
+  async disconnectWallet({ activePubkey } = {}) {
+    const callback = this.mainController.callbacks.onWalletDisconnectRequest;
+    if (callback && callback !== noop) {
+      const result = await callback({
+        controller: this.mainController,
+        activePubkey,
+      });
+      if (result !== undefined) {
+        return result;
+      }
+    }
+
+    return this.mainController.services.nwcSettings.updateActiveNwcSettings(
+      this.mainController.services.nwcSettings.createDefaultNwcSettings()
+    );
+  }
+}