Contractless-GUI-Wallet/frontend/js/startup_forms.js

async function loadTauriStatus() {
  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    return;
  }

  try {
    const status = await invoke("get_app_status");
    if (bridgeStatus) {
      setBridgeStatus(`${status.network === "mainnet" ? "Mainnet" : "Testnet"} disconnected`, "error");
    }
  } catch (error) {
    setBridgeStatus(`${activeNetwork === "mainnet" ? "Mainnet" : "Testnet"} unavailable`, "error");
    console.error(error);
  }
}

loadTauriStatus();

networkButtons.forEach((button) => {
  button.addEventListener("click", () => {
    setActiveNetwork(button.dataset.networkToggle);
    if (!loadWalletForm?.classList.contains("hidden")) {
      refreshWalletList();
    }
  });
});

document.querySelectorAll("[data-start-mode]").forEach((button) => {
  button.addEventListener("click", () => {
    const mode = button.dataset.startMode;
    setActiveStartMode(mode);
    if (mode === "load") {
      createWalletForm?.classList.add("hidden");
      importKeyForm?.classList.add("hidden");
      importImageForm?.classList.add("hidden");
      loadWalletForm?.classList.remove("hidden");
      setStartupMessage("");
      setImportMessage("");
      setImportImageMessage("");
      loadWalletKeyInput?.focus();
      refreshWalletList();
      return;
    }

    if (mode === "import-key") {
      createWalletForm?.classList.add("hidden");
      loadWalletForm?.classList.add("hidden");
      importImageForm?.classList.add("hidden");
      importKeyForm?.classList.remove("hidden");
      setStartupMessage("");
      setLoadMessage("");
      setImportImageMessage("");
      setImportMessage("Paste the private key and choose a new encrypted wallet file name.");
      importWalletNameInput?.focus();
      return;
    }

    if (mode === "import-image") {
      createWalletForm?.classList.add("hidden");
      loadWalletForm?.classList.add("hidden");
      importKeyForm?.classList.add("hidden");
      importImageForm?.classList.remove("hidden");
      setStartupMessage("");
      setLoadMessage("");
      setImportMessage("");
      setImportImageMessage("Select the private key PNG image and choose a new encrypted wallet file name.");
      importImageWalletNameInput?.focus();
      return;
    }

    if (mode !== "create") {
      createWalletForm?.classList.add("hidden");
      loadWalletForm?.classList.add("hidden");
      importKeyForm?.classList.add("hidden");
      importImageForm?.classList.add("hidden");
      setStartupMessage("This wallet action is not wired yet.", "error");
      return;
    }

    loadWalletForm?.classList.add("hidden");
    importKeyForm?.classList.add("hidden");
    importImageForm?.classList.add("hidden");
    createWalletForm?.classList.remove("hidden");
    walletNameInput?.focus();
    setLoadMessage("");
    setImportMessage("");
    setImportImageMessage("");
    setStartupMessage("Name this wallet and choose the key that will encrypt it.");
  });
});

document.querySelectorAll("[data-cancel-startup-form]").forEach((button) => {
  button.addEventListener("click", () => {
    createWalletForm?.classList.add("hidden");
    loadWalletForm?.classList.add("hidden");
    importKeyForm?.classList.add("hidden");
    importImageForm?.classList.add("hidden");
    setStartupMessage("");
    setLoadMessage("");
    setImportMessage("");
    setImportImageMessage("");
  });
});

createWalletForm?.addEventListener("submit", async (event) => {
  event.preventDefault();

  const walletName = walletNameInput?.value || "";
  const walletKey = walletKeyInput?.value || "";
  const walletKeyConfirm = walletKeyConfirmInput?.value || "";
  if (!walletName.trim()) {
    setStartupMessage("Wallet name cannot be empty.", "error");
    walletNameInput?.focus();
    return;
  }
  if (!walletKey.trim()) {
    setStartupMessage("Wallet key cannot be empty.", "error");
    walletKeyInput?.focus();
    return;
  }
  if (walletKey !== walletKeyConfirm) {
    setStartupMessage("Wallet keys do not match.", "error");
    walletKeyConfirmInput?.focus();
    return;
  }

  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    setStartupMessage("Wallet creation requires the desktop app build.", "error");
    return;
  }

  if (createWalletSubmit) {
    createWalletSubmit.disabled = true;
  }
  setStartupMessage("Creating encrypted wallet...");

  try {
    const wallet = await invoke("create_wallet", {
      network: activeNetwork,
      walletName,
      walletKey
    });
    updateActiveWallet(wallet);
    walletNameInput.value = "";
    walletKeyInput.value = "";
    walletKeyConfirmInput.value = "";
    setStartupMessage(`Wallet saved to ${wallet.wallet_path}`, "success");
    document.body.classList.add("wallet-open");
  } catch (error) {
    setStartupMessage(String(error), "error");
  } finally {
    if (createWalletSubmit) {
      createWalletSubmit.disabled = false;
    }
  }
});

document.querySelector("[data-refresh-wallet-list]")?.addEventListener("click", () => {
  if (loadWalletKeyInput) {
    loadWalletKeyInput.value = "";
  }
  refreshWalletList();
});

browseWalletButton?.addEventListener("click", async () => {
  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    setLoadMessage("Wallet browsing requires the desktop app build.", "error");
    return;
  }

  setLoadMessage("Opening wallet file picker...");
  try {
    const wallet = await invoke("select_wallet_file", { network: activeNetwork });
    if (!wallet) {
      setLoadMessage("Wallet selection cancelled.");
      return;
    }

    selectWalletOption(wallet);
    setLoadMessage(`Selected ${wallet.wallet_name}.`);
    loadWalletKeyInput?.focus();
  } catch (error) {
    setLoadMessage(String(error), "error");
  }
});

browsePrivateKeyImageButton?.addEventListener("click", async () => {
  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    setImportImageMessage("Private key image browsing requires the desktop app build.", "error");
    return;
  }

  setImportImageMessage("Opening private key image picker...");
  try {
    const selected = await invoke("select_private_key_image", { network: activeNetwork });
    if (!selected) {
      setImportImageMessage("Private key image selection cancelled.");
      return;
    }

    importImagePathInput.value = selected.file_path;
    setImportImageMessage(`Selected ${selected.file_name}.`);
    importImageWalletKeyInput?.focus();
  } catch (error) {
    setImportImageMessage(String(error), "error");
  }
});

loadWalletForm?.addEventListener("submit", async (event) => {
  event.preventDefault();

  const walletPath = walletListSelect?.value || "";
  const walletKey = loadWalletKeyInput?.value || "";
  if (!walletPath.trim()) {
    setLoadMessage("Choose a saved wallet or browse for a wallet file.", "error");
    walletListSelect?.focus();
    return;
  }
  if (!walletKey.trim()) {
    setLoadMessage("Wallet key cannot be empty.", "error");
    loadWalletKeyInput?.focus();
    return;
  }

  if (loadWalletSubmit) {
    loadWalletSubmit.disabled = true;
  }
  setLoadMessage("Loading wallet...");

  try {
    const wallet = await loadWalletByPath(walletPath, walletKey);
    updateActiveWallet(wallet);
    loadWalletKeyInput.value = "";
    setLoadMessage(`Wallet loaded from ${wallet.wallet_path}`, "success");
    document.body.classList.add("wallet-open");
  } catch (error) {
    setLoadMessage(String(error), "error");
  } finally {
    if (loadWalletSubmit) {
      loadWalletSubmit.disabled = false;
    }
  }
});

importKeyForm?.addEventListener("submit", async (event) => {
  event.preventDefault();

  const walletName = importWalletNameInput?.value || "";
  const privateKey = importPrivateKeyInput?.value || "";
  const walletKey = importWalletKeyInput?.value || "";
  const walletKeyConfirm = importWalletKeyConfirmInput?.value || "";

  if (!walletName.trim()) {
    setImportMessage("Wallet name cannot be empty.", "error");
    importWalletNameInput?.focus();
    return;
  }
  if (!privateKey.trim()) {
    setImportMessage("Private key cannot be empty.", "error");
    importPrivateKeyInput?.focus();
    return;
  }
  if (!walletKey.trim()) {
    setImportMessage("Wallet key cannot be empty.", "error");
    importWalletKeyInput?.focus();
    return;
  }
  if (walletKey !== walletKeyConfirm) {
    setImportMessage("Wallet keys do not match.", "error");
    importWalletKeyConfirmInput?.focus();
    return;
  }

  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    setImportMessage("Private key import requires the desktop app build.", "error");
    return;
  }

  if (importKeySubmit) {
    importKeySubmit.disabled = true;
  }
  setImportMessage("Importing encrypted wallet...");

  try {
    const wallet = await invoke("import_private_key_wallet", {
      network: activeNetwork,
      walletName,
      walletKey,
      privateKey
    });
    updateActiveWallet(wallet);
    importWalletNameInput.value = "";
    importPrivateKeyInput.value = "";
    importWalletKeyInput.value = "";
    importWalletKeyConfirmInput.value = "";
    setImportMessage(`Wallet saved to ${wallet.wallet_path}`, "success");
    document.body.classList.add("wallet-open");
  } catch (error) {
    setImportMessage(String(error), "error");
  } finally {
    if (importKeySubmit) {
      importKeySubmit.disabled = false;
    }
  }
});

importImageForm?.addEventListener("submit", async (event) => {
  event.preventDefault();

  const walletName = importImageWalletNameInput?.value || "";
  const imagePath = importImagePathInput?.value || "";
  const walletKey = importImageWalletKeyInput?.value || "";
  const walletKeyConfirm = importImageWalletKeyConfirmInput?.value || "";

  if (!walletName.trim()) {
    setImportImageMessage("Wallet name cannot be empty.", "error");
    importImageWalletNameInput?.focus();
    return;
  }
  if (!imagePath.trim()) {
    setImportImageMessage("Select a private key PNG image.", "error");
    browsePrivateKeyImageButton?.focus();
    return;
  }
  if (!walletKey.trim()) {
    setImportImageMessage("Wallet key cannot be empty.", "error");
    importImageWalletKeyInput?.focus();
    return;
  }
  if (walletKey !== walletKeyConfirm) {
    setImportImageMessage("Wallet keys do not match.", "error");
    importImageWalletKeyConfirmInput?.focus();
    return;
  }

  const invoke = window.__TAURI__?.core?.invoke;
  if (!invoke) {
    setImportImageMessage("Private key image import requires the desktop app build.", "error");
    return;
  }

  if (importImageSubmit) {
    importImageSubmit.disabled = true;
  }
  setImportImageMessage("Importing encrypted wallet from image...");

  try {
    const wallet = await invoke("import_private_key_image_wallet", {
      network: activeNetwork,
      walletName,
      walletKey,
      imagePath
    });
    updateActiveWallet(wallet);
    importImageWalletNameInput.value = "";
    importImagePathInput.value = "";
    importImageWalletKeyInput.value = "";
    importImageWalletKeyConfirmInput.value = "";
    setImportImageMessage(`Wallet saved to ${wallet.wallet_path}`, "success");
    document.body.classList.add("wallet-open");
  } catch (error) {
    setImportImageMessage(String(error), "error");
  } finally {
    if (importImageSubmit) {
      importImageSubmit.disabled = false;
    }
  }
});

lockWalletButton?.addEventListener("click", async () => {
  const invoke = window.__TAURI__?.core?.invoke;
  try {
    await invoke?.("lock_wallet");
  } finally {
    lockWalletSession();
  }
});

registrationAction?.addEventListener("click", registerActiveWallet);