";
+const ADDRESS_BOOK_WRITE_DELAY_MS = 500;
+const ADDRESS_BOOK_VANITY_DELAY_MS = 650;
+
+function normalizeAddressBook(source) {
+ const entries = source?.entries && typeof source.entries === "object" && !Array.isArray(source.entries)
+ ? source.entries
+ : {};
+ const normalized = {};
+
+ Object.entries(entries).forEach(([address, entry]) => {
+ if (isRawVanityAddressHex(address)) {
+ return;
+ }
+
+ const canonical = canonicalAddressBookAddress(address);
+ if (!canonical || !entry || typeof entry !== "object") {
+ return;
+ }
+
+ normalized[canonical] = {
+ label: stringOrDefault(entry.label, ADDRESS_BOOK_UNKNOWN),
+ label_source: stringOrDefault(entry.label_source, "sync"),
+ vanity: stringOrDefault(entry.vanity, ADDRESS_BOOK_UNKNOWN),
+ latest_txid: stringOrDefault(entry.latest_txid, ""),
+ created_at: Number(entry.created_at || 0) || currentUnixSeconds(),
+ updated_at: Number(entry.updated_at || 0) || currentUnixSeconds()
+ };
+ });
+
+ return { entries: normalized };
+}
+
+function stringOrDefault(value, fallback) {
+ const text = String(value ?? "").trim();
+ return text || fallback;
+}
+
+function currentUnixSeconds() {
+ return Math.floor(Date.now() / 1000);
+}
+
+function shortAddressFromRawAddressHex(address) {
+ const text = String(address || "").trim().toLowerCase();
+ if (!/^[a-f0-9]{44}$/.test(text) || text.slice(40, 42) !== "2e") {
+ return "";
+ }
+
+ const network = {
+ "01": "clc",
+ "02": "cltc"
+ }[text.slice(42, 44)];
+
+ return network ? `${text.slice(0, 40)}.${network}` : "";
+}
+
+function vanityAddressFromRawAddressHex(address) {
+ const text = String(address || "").trim().toLowerCase();
+ if (!/^[a-f0-9]{44}$/.test(text) || text.slice(40, 42) !== "2e") {
+ return "";
+ }
+
+ const network = {
+ "01": "clc",
+ "02": "cltc"
+ }[text.slice(42, 44)];
+ if (!network) {
+ return "";
+ }
+
+ const payloadBytes = text.slice(0, 40).match(/../g) || [];
+ const payload = payloadBytes
+ .map((part) => String.fromCharCode(Number.parseInt(part, 16)))
+ .join("")
+ .trimStart();
+ if (!payload || !/^[a-z]+$/i.test(payload)) {
+ return "";
+ }
+
+ return `${payload.toLowerCase()}.${network}`;
+}
+
+function isRawVanityAddressHex(address) {
+ return Boolean(vanityAddressFromRawAddressHex(address));
+}
+
+function canonicalAddressBookAddress(address) {
+ const text = String(address || "").trim().toLowerCase();
+ if (/^[a-f0-9]{40}\.[a-z0-9]+$/.test(text)) {
+ return text;
+ }
+ if (isRawVanityAddressHex(text)) {
+ return "";
+ }
+ const fromRawBytes = shortAddressFromRawAddressHex(text);
+ if (fromRawBytes) {
+ return fromRawBytes;
+ }
+ return "";
+}
+
+function shouldSkipAddressBookAddress(address) {
+ const canonical = canonicalAddressBookAddress(address);
+ return (
+ !canonical ||
+ canonical === canonicalAddressBookAddress(activeWalletAddressShort) ||
+ canonical === "network" ||
+ canonical === "self"
+ );
+}
+
+function addressBookSleep(ms) {
+ return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function addressBookEscape(value) {
+ return String(value ?? "")
+ .replaceAll("&", "&")
+ .replaceAll("<", "<")
+ .replaceAll(">", ">")
+ .replaceAll('"', """)
+ .replaceAll("'", "'");
+}
+
+function addressBookInvoke() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ throw new Error("Tauri bridge is not ready.");
+ }
+ return invoke;
+}
+
+async function lookupAddressBookVanity(address) {
+ const broadcastNode = typeof activeBroadcastNode === "function" ? activeBroadcastNode() : "";
+ if (!walletLoaded || !broadcastNode) {
+ return "";
+ }
+
+ const invoke = addressBookInvoke();
+ const vanity = await invoke("lookup_address_vanity", {
+ broadcastNode,
+ address
+ });
+ return String(vanity || "").trim();
+}
+
+function enqueueAddressBookVanityLookup(address) {
+ const canonical = canonicalAddressBookAddress(address);
+ if (!canonical || shouldSkipAddressBookAddress(canonical)) {
+ return;
+ }
+
+ addressBookVanityLookupQueue.add(canonical);
+ runAddressBookVanityLookupQueue();
+}
+
+async function runAddressBookVanityLookupQueue() {
+ if (addressBookVanityLookupRunning) {
+ return;
+ }
+
+ addressBookVanityLookupRunning = true;
+ try {
+ while (walletLoaded && addressBookVanityLookupQueue.size) {
+ const [address] = addressBookVanityLookupQueue;
+ addressBookVanityLookupQueue.delete(address);
+
+ await loadAddressBookCache();
+ const entry = addressBookCache.entries[address];
+ if (!entry || (entry.vanity && entry.vanity !== ADDRESS_BOOK_UNKNOWN)) {
+ continue;
+ }
+
+ try {
+ const vanity = await lookupAddressBookVanity(address);
+ if (vanity && addressBookCache.entries[address]?.vanity !== vanity) {
+ addressBookCache.entries[address].vanity = vanity;
+ addressBookCache.entries[address].updated_at = currentUnixSeconds();
+ scheduleAddressBookWrite();
+ renderAddressBookPage();
+ }
+ } catch (_) {
+ // Vanity lookup is best-effort; failed lookups should not block address discovery.
+ }
+
+ if (addressBookVanityLookupQueue.size) {
+ await addressBookSleep(ADDRESS_BOOK_VANITY_DELAY_MS);
+ }
+ }
+ } finally {
+ addressBookVanityLookupRunning = false;
+ }
+}
+
+async function loadAddressBookCache(force = false) {
+ if (!walletLoaded) {
+ addressBookCache = { entries: {} };
+ addressBookLoaded = false;
+ return addressBookCache;
+ }
+
+ if (addressBookLoaded && !force) {
+ return addressBookCache;
+ }
+
+ if (addressBookLoadingPromise && !force) {
+ return addressBookLoadingPromise;
+ }
+
+ addressBookLoadingPromise = (async () => {
+ try {
+ const invoke = addressBookInvoke();
+ const raw = await invoke("read_address_book");
+ addressBookCache = normalizeAddressBook(JSON.parse(raw || "{}"));
+ } catch (_) {
+ addressBookCache = { entries: {} };
+ } finally {
+ addressBookLoaded = true;
+ addressBookLoadingPromise = null;
+ }
+ renderAddressBookPage();
+ return addressBookCache;
+ })();
+
+ return addressBookLoadingPromise;
+}
+
+function scheduleAddressBookWrite() {
+ if (!walletLoaded || !addressBookLoaded) {
+ return;
+ }
+ clearTimeout(addressBookWriteTimer);
+ addressBookWriteTimer = setTimeout(() => {
+ addressBookWritePromise = addressBookWritePromise
+ .catch(() => {})
+ .then(() => {
+ const invoke = addressBookInvoke();
+ return invoke("write_address_book", {
+ addressBookJson: JSON.stringify(normalizeAddressBook(addressBookCache))
+ });
+ })
+ .catch((error) => console.error("Address book write failed:", error));
+ }, ADDRESS_BOOK_WRITE_DELAY_MS);
+}
+
+async function flushAddressBookWrite() {
+ clearTimeout(addressBookWriteTimer);
+ if (!walletLoaded || !addressBookLoaded) {
+ return;
+ }
+ addressBookWritePromise = addressBookWritePromise
+ .catch(() => {})
+ .then(() => {
+ const invoke = addressBookInvoke();
+ return invoke("write_address_book", {
+ addressBookJson: JSON.stringify(normalizeAddressBook(addressBookCache))
+ });
+ });
+ await addressBookWritePromise;
+}
+
+async function upsertAddressBookEntry(address, options = {}) {
+ const canonical = canonicalAddressBookAddress(address);
+ if (shouldSkipAddressBookAddress(canonical)) {
+ return false;
+ }
+
+ await loadAddressBookCache();
+
+ const now = currentUnixSeconds();
+ const existing = addressBookCache.entries[canonical];
+ const label = String(options.label || "").trim();
+ const labelSource = options.labelSource || "sync";
+ const vanity = String(options.vanity || "").trim();
+ let changed = false;
+ let shouldLookupVanity = false;
+
+ if (!existing) {
+ addressBookCache.entries[canonical] = {
+ label: label || ADDRESS_BOOK_UNKNOWN,
+ label_source: label ? labelSource : "sync",
+ vanity: vanity || ADDRESS_BOOK_UNKNOWN,
+ latest_txid: String(options.latestTxid || ""),
+ created_at: now,
+ updated_at: now
+ };
+ changed = true;
+ shouldLookupVanity = !vanity;
+ } else {
+ const canReplaceLabel =
+ label &&
+ existing.label_source !== "user" &&
+ (!existing.label || existing.label === ADDRESS_BOOK_UNKNOWN || existing.label_source === "sync");
+
+ if (canReplaceLabel && existing.label !== label) {
+ existing.label = label;
+ existing.label_source = labelSource;
+ changed = true;
+ }
+
+ if (options.latestTxid && existing.latest_txid !== options.latestTxid) {
+ existing.latest_txid = String(options.latestTxid);
+ changed = true;
+ }
+
+ if (vanity && existing.vanity !== vanity) {
+ existing.vanity = vanity;
+ changed = true;
+ }
+
+ if (changed) {
+ existing.updated_at = now;
+ }
+ }
+
+ if (changed) {
+ scheduleAddressBookWrite();
+ renderAddressBookPage();
+ }
+ if (shouldLookupVanity) {
+ enqueueAddressBookVanityLookup(canonical);
+ }
+ return changed;
+}
+
+async function upsertVanityRegistrationAddressBookEntry(txid, transaction) {
+ const vanity = transaction?.unsigned_vanity_address;
+ if (!vanity) {
+ return false;
+ }
+
+ const owner = canonicalAddressBookAddress(vanity.address);
+ const displayVanity = vanityAddressFromRawAddressHex(vanity.vanity_address);
+ if (!owner || !displayVanity) {
+ return false;
+ }
+
+ return upsertAddressBookEntry(owner, {
+ vanity: displayVanity,
+ latestTxid: txid,
+ labelSource: "sync"
+ });
+}
+
+function collectAddressBookAddressesFromValue(value, found = new Set()) {
+ if (!value || typeof value !== "object") {
+ if (typeof value === "string") {
+ const canonical = canonicalAddressBookAddress(value);
+ if (!shouldSkipAddressBookAddress(canonical)) {
+ found.add(canonical);
+ }
+ }
+ return found;
+ }
+
+ if (Array.isArray(value)) {
+ value.forEach((item) => collectAddressBookAddressesFromValue(item, found));
+ return found;
+ }
+
+ Object.entries(value).forEach(([key, item]) => {
+ const keyText = String(key || "").toLowerCase();
+ if (["sender", "receiver", "creator", "advertiser", "sender1", "sender2", "lender", "borrower", "address"].includes(keyText)) {
+ const canonical = canonicalAddressBookAddress(item);
+ if (!shouldSkipAddressBookAddress(canonical)) {
+ found.add(canonical);
+ }
+ return;
+ }
+ collectAddressBookAddressesFromValue(item, found);
+ });
+
+ return found;
+}
+
+async function syncAddressBookFromTransactionRecord(txid, record) {
+ const vanityChanged = await upsertVanityRegistrationAddressBookEntry(txid, record?.transaction);
+ const found = collectAddressBookAddressesFromValue(record?.transaction);
+ if (!found.size) {
+ if (vanityChanged) {
+ await flushAddressBookWrite();
+ }
+ return;
+ }
+
+ for (const address of found) {
+ await upsertAddressBookEntry(address, { latestTxid: txid, labelSource: "sync" });
+ }
+}
+
+async function addPaymentUriAddressBookEntry(address, label) {
+ const changed = await upsertAddressBookEntry(address, {
+ label,
+ labelSource: "payment_uri"
+ });
+ if (changed) {
+ await flushAddressBookWrite();
+ }
+}
+
+function resetAddressBookPage() {
+ addressBookCache = { entries: {} };
+ addressBookLoaded = false;
+ addressBookLoadingPromise = null;
+ clearTimeout(addressBookWriteTimer);
+ addressBookVanityRefreshRunning = false;
+ addressBookVanityRefreshDoneForWallet = "";
+ addressBookVanityLookupRunning = false;
+ addressBookVanityLookupQueue.clear();
+ if (addressBookSearch) {
+ addressBookSearch.value = "";
+ }
+ renderAddressBookPage();
+}
+
+function sortedAddressBookEntries() {
+ const query = String(addressBookSearch?.value || "").trim().toLowerCase();
+ const sort = addressBookSort?.value || "latest";
+ let entries = Object.entries(addressBookCache.entries || {}).map(([address, entry]) => ({
+ address,
+ ...entry
+ }));
+
+ if (query) {
+ entries = entries.filter((entry) => {
+ return [entry.address, entry.label, entry.vanity, entry.latest_txid]
+ .some((value) => String(value || "").toLowerCase().includes(query));
+ });
+ }
+
+ entries.sort((left, right) => {
+ if (sort === "label") {
+ return String(left.label || "").localeCompare(String(right.label || ""));
+ }
+ if (sort === "vanity") {
+ return String(left.vanity || "").localeCompare(String(right.vanity || ""));
+ }
+ return Number(right.updated_at || 0) - Number(left.updated_at || 0);
+ });
+
+ return entries;
+}
+
+function renderAddressBookPage() {
+ if (!addressBookRows) {
+ return;
+ }
+
+ const entries = sortedAddressBookEntries();
+ const entryParts = entries.map((entry) => {
+ const txid = entry.latest_txid || "";
+ const label = entry.label && entry.label !== ADDRESS_BOOK_UNKNOWN ? entry.label : "";
+ const vanity = entry.vanity && entry.vanity !== ADDRESS_BOOK_UNKNOWN ? entry.vanity : "";
+ const escapedAddress = addressBookEscape(entry.address);
+ const escapedLabel = addressBookEscape(label);
+ const escapedVanity = addressBookEscape(vanity);
+ const escapedTxid = addressBookEscape(shortenAddress(txid));
+ return {
+ txid,
+ vanity,
+ escapedAddress,
+ escapedLabel,
+ escapedVanity,
+ escapedTxid
+ };
+ });
+
+ addressBookRows.innerHTML = entries.map((entry) => {
+ const txid = entry.latest_txid || "";
+ const label = entry.label && entry.label !== ADDRESS_BOOK_UNKNOWN ? entry.label : "";
+ const vanity = entry.vanity && entry.vanity !== ADDRESS_BOOK_UNKNOWN ? entry.vanity : "";
+ return `
+
+
+
+ ${vanity ? `${addressBookEscape(vanity)} ` : ADDRESS_BOOK_UNKNOWN}
+ ${addressBookEscape(entry.address)}${txid ? `${addressBookEscape(shortenAddress(txid))}` : "--"}
+
+ x
+
+
+ `;
+ }).join("");
+
+ if (addressBookCards) {
+ addressBookCards.innerHTML = entryParts.map((entry) => `
+
+
+ x
+
+
+ Vanity
+ ${entry.vanity ? `${entry.escapedVanity} ` : ADDRESS_BOOK_UNKNOWN}
+
+
+ Address
+ ${entry.escapedAddress}
+
+ Last Transaction
+ ${entry.txid ? `${entry.escapedTxid}` : "--"}
+
+
+ `).join("");
+ }
+
+ if (addressBookState) {
+ addressBookState.textContent = walletLoaded
+ ? `${entries.length} contact${entries.length === 1 ? "" : "s"}`
+ : "Load a wallet to view the address book.";
+ }
+}
+
+async function prepareAddressBookPage() {
+ await loadAddressBookCache();
+ renderAddressBookPage();
+}
+
+async function refreshAddressBookVanitiesOnce(force = false) {
+ if (!walletLoaded || addressBookVanityRefreshRunning) {
+ return;
+ }
+
+ const walletKey = activeWalletAddressShort || activeWalletPath || "";
+ if (!force && addressBookVanityRefreshDoneForWallet === walletKey) {
+ return;
+ }
+
+ addressBookVanityRefreshRunning = true;
+ addressBookVanityRefreshDoneForWallet = walletKey;
+
+ try {
+ await loadAddressBookCache();
+ const addresses = Object.keys(addressBookCache.entries || {});
+ for (const address of addresses) {
+ if (!walletLoaded || (activeWalletAddressShort || activeWalletPath || "") !== walletKey) {
+ return;
+ }
+ try {
+ const invoke = addressBookInvoke();
+ const vanity = await invoke("lookup_address_vanity", {
+ broadcastNode: activeBroadcastNode(),
+ address
+ });
+ const entry = addressBookCache.entries[address];
+ const nextVanity = vanity || ADDRESS_BOOK_UNKNOWN;
+ if (entry && entry.vanity !== nextVanity) {
+ entry.vanity = nextVanity;
+ entry.updated_at = currentUnixSeconds();
+ scheduleAddressBookWrite();
+ renderAddressBookPage();
+ }
+ } catch (_) {
+ // Vanity refresh is best-effort; connection errors should not block the wallet.
+ }
+ await addressBookSleep(ADDRESS_BOOK_VANITY_DELAY_MS);
+ }
+ } finally {
+ addressBookVanityRefreshRunning = false;
+ }
+}
+
+addressBookSearch?.addEventListener("input", renderAddressBookPage);
+addressBookSort?.addEventListener("change", renderAddressBookPage);
+addressBookRefreshVanity?.addEventListener("click", () => refreshAddressBookVanitiesOnce(true));
+
+async function handleAddressBookLabelChange(event) {
+ const input = event.target.closest("[data-address-book-label]");
+ if (!input) {
+ return;
+ }
+
+ const address = canonicalAddressBookAddress(input.dataset.addressBookLabel);
+ if (!address) {
+ return;
+ }
+
+ await loadAddressBookCache();
+ const entry = addressBookCache.entries[address];
+ if (!entry) {
+ return;
+ }
+
+ entry.label = input.value.trim() || ADDRESS_BOOK_UNKNOWN;
+ entry.label_source = "user";
+ entry.updated_at = currentUnixSeconds();
+ scheduleAddressBookWrite();
+ renderAddressBookPage();
+}
+
+async function handleAddressBookClick(event) {
+ const copyButton = event.target.closest("[data-address-book-copy]");
+ if (copyButton) {
+ const value = copyButton.dataset.addressBookCopy || "";
+ const copied = typeof writeClipboardText === "function"
+ ? await writeClipboardText(value)
+ : false;
+ if (copied) {
+ const previous = copyButton.textContent;
+ copyButton.textContent = "Copied";
+ setTimeout(() => {
+ if (copyButton.isConnected) {
+ copyButton.textContent = previous;
+ }
+ }, 1000);
+ }
+ return;
+ }
+
+ const button = event.target.closest("[data-address-book-delete]");
+ if (!button) {
+ return;
+ }
+
+ const address = canonicalAddressBookAddress(button.dataset.addressBookDelete);
+ if (!address) {
+ return;
+ }
+
+ await loadAddressBookCache();
+ if (!addressBookCache.entries[address]) {
+ return;
+ }
+
+ delete addressBookCache.entries[address];
+ scheduleAddressBookWrite();
+ renderAddressBookPage();
+}
+
+function handleAddressBookKeydown(event) {
+ const input = event.target.closest("[data-address-book-label]");
+ if (input && event.key === "Enter") {
+ event.preventDefault();
+ input.blur();
+ }
+}
+
+[addressBookRows, addressBookCards].forEach((container) => {
+ container?.addEventListener("change", handleAddressBookLabelChange);
+ container?.addEventListener("click", handleAddressBookClick);
+ container?.addEventListener("keydown", handleAddressBookKeydown);
+});
diff --git a/frontend/js/app_state.js b/frontend/js/app_state.js
new file mode 100644
index 0000000..284c0ea
--- /dev/null
+++ b/frontend/js/app_state.js
@@ -0,0 +1,899 @@
+const titles = {
+ dashboard: ["Dashboard", "Overview for the active address."],
+ send: ["Send", "Create and preview transaction forms."],
+ receive: ["Receive", "Show wallet address and payment request details."],
+ history: ["History", "Full local transaction history for the active address."],
+ transactions: ["Transactions", "Review local and confirmed transaction activity."],
+ assets: ["Assets", "View CLC, tokens, and balances."],
+ nfts: ["NFTs", "View and manage non-fungible token holdings."],
+ loans: ["Loans", "Create loans, payments, and collateral claims."],
+ marketing: ["Marketing", "Review campaign activity from agency wallets."],
+ addressbook: ["Address Book", "Manage known addresses and labels."],
+ settings: ["Settings", "Manage wallets, nodes, security, and app preferences."]
+};
+
+let currentTransactionType = "";
+
+function setScopedTransactionMessage(formType, element, message, type = "") {
+ if (!element) {
+ return;
+ }
+ if (message && (currentView !== "send" || currentTransactionType !== formType)) {
+ return;
+ }
+ element.textContent = message;
+ element.classList.toggle("hidden", !message);
+ element.classList.toggle("error", type === "error");
+ element.classList.toggle("success", type === "success");
+}
+
+const navButtons = document.querySelectorAll("[data-view]");
+const dashboardView = document.querySelector("#dashboard-view");
+const transactionView = document.querySelector("#transaction-view");
+const receiveView = document.querySelector("#receive-view");
+const historyView = document.querySelector("#history-view");
+const assetsView = document.querySelector("#assets-view");
+const nftsView = document.querySelector("#nfts-view");
+const loansView = document.querySelector("#loans-view");
+const marketingView = document.querySelector("#marketing-view");
+const addressbookView = document.querySelector("#addressbook-view");
+const settingsView = document.querySelector("#settings-view");
+const viewTitle = document.querySelector("#view-title");
+const viewSubtitle = document.querySelector("#view-subtitle");
+const transactionTitle = document.querySelector("#transaction-panel-title");
+const transactionCopy = document.querySelector("#transaction-panel-copy");
+const transactionList = document.querySelector("[data-transaction-list]");
+const formPanel = document.querySelector("[data-form-panel]");
+const reviewPanel = document.querySelector("[data-review-panel]");
+const unbroadcastListMessage = document.querySelector("[data-unbroadcast-list-message]");
+const unbroadcastReviewGrid = document.querySelector("[data-unbroadcast-review-grid]");
+const unbroadcastJsonPreview = document.querySelector("[data-unbroadcast-json]");
+const unbroadcastReviewMessage = document.querySelector("[data-unbroadcast-review-message]");
+const unbroadcastBackButton = document.querySelector("[data-unbroadcast-back]");
+const unbroadcastDeleteButton = document.querySelector("[data-unbroadcast-delete]");
+const unbroadcastSignButton = document.querySelector("[data-unbroadcast-sign]");
+const unbroadcastBroadcastButton = document.querySelector("[data-unbroadcast-broadcast]");
+const transferAssetSelect = document.querySelector("[data-transfer-asset]");
+const transferReceiverInput = document.querySelector("[data-transfer-receiver]");
+const transferAmountInput = document.querySelector("[data-transfer-amount]");
+const transferFeeInput = document.querySelector("[data-transfer-fee]");
+const transferCoin = document.querySelector("[data-transfer-coin]");
+const transferNftSeries = document.querySelector("[data-transfer-nft-series]");
+const transferBalance = document.querySelector("[data-transfer-balance]");
+const transferSender = document.querySelector("[data-transfer-sender]");
+const transferMessage = document.querySelector("[data-transfer-message]");
+const transferActions = document.querySelector("[data-transfer-actions]");
+const marketingCampaignForm = document.querySelector("[data-marketing-campaign-form]");
+const marketingCampaignAdvertiserInput = document.querySelector("[data-marketing-campaign-advertiser]");
+const marketingCampaignIdInput = document.querySelector("[data-marketing-campaign-id]");
+const marketingCampaignLoadButton = document.querySelector("[data-marketing-campaign-load]");
+const marketingCampaignRefreshButton = document.querySelector("[data-marketing-campaign-refresh]");
+const marketingCampaignRows = document.querySelector("[data-marketing-campaign-rows]");
+const marketingCampaignCards = document.querySelector("[data-marketing-campaign-cards]");
+const marketingCampaignState = document.querySelector("[data-marketing-campaign-state]");
+const marketingCampaignCount = document.querySelector("[data-marketing-campaign-count]");
+const marketingCampaignPagination = document.querySelector("[data-marketing-campaign-pagination]");
+const marketingCampaignPageInput = document.querySelector("[data-marketing-campaign-page-input]");
+const marketingCampaignPageTotal = document.querySelector("[data-marketing-campaign-page-total]");
+const marketingTotalRecords = document.querySelector("[data-marketing-total-records]");
+const marketingTotalImpressions = document.querySelector("[data-marketing-total-impressions]");
+const marketingTotalClicks = document.querySelector("[data-marketing-total-clicks]");
+const marketingAvgImpressionValue = document.querySelector("[data-marketing-avg-impression-value]");
+const marketingAvgClickValue = document.querySelector("[data-marketing-avg-click-value]");
+const marketingTotalValue = document.querySelector("[data-marketing-total-value]");
+const createTokenForm = document.querySelector("[data-create-token-form]");
+const createTokenActions = document.querySelector("[data-create-token-actions]");
+const createTokenTickerInput = document.querySelector("[data-create-token-ticker]");
+const createTokenNumberInput = document.querySelector("[data-create-token-number]");
+const createTokenFeeInput = document.querySelector("[data-create-token-fee]");
+const createTokenAllowMoreInput = document.querySelector("[data-create-token-allow-more]");
+const createTokenCap = document.querySelector("[data-create-token-cap]");
+const createTokenCreator = document.querySelector("[data-create-token-creator]");
+const createTokenFeeLabel = document.querySelector("[data-create-token-fee-label]");
+const createTokenMessage = document.querySelector("[data-create-token-message]");
+const issueTokenForm = document.querySelector("[data-issue-token-form]");
+const issueTokenActions = document.querySelector("[data-issue-token-actions]");
+const issueTokenTickerSelect = document.querySelector("[data-issue-token-ticker]");
+const issueTokenNumberInput = document.querySelector("[data-issue-token-number]");
+const issueTokenFeeInput = document.querySelector("[data-issue-token-fee]");
+const issueTokenCreator = document.querySelector("[data-issue-token-creator]");
+const issueTokenPolicy = document.querySelector("[data-issue-token-policy]");
+const issueTokenFeeLabel = document.querySelector("[data-issue-token-fee-label]");
+const issueTokenMessage = document.querySelector("[data-issue-token-message]");
+const createNftForm = document.querySelector("[data-create-nft-form]");
+const createNftActions = document.querySelector("[data-create-nft-actions]");
+const createNftSeriesSelect = document.querySelector("[data-create-nft-series]");
+const createNftNameInput = document.querySelector("[data-create-nft-name]");
+const createNftIpfsInput = document.querySelector("[data-create-nft-ipfs]");
+const createNftCountInput = document.querySelector("[data-create-nft-count]");
+const createNftDescriptionInput = document.querySelector("[data-create-nft-description]");
+const createNftFeeInput = document.querySelector("[data-create-nft-fee]");
+const createNftCreator = document.querySelector("[data-create-nft-creator]");
+const createNftTypeLabel = document.querySelector("[data-create-nft-type-label]");
+const createNftCountLabel = document.querySelector("[data-create-nft-count-label]");
+const createNftFeeLabel = document.querySelector("[data-create-nft-fee-label]");
+const createNftMessage = document.querySelector("[data-create-nft-message]");
+const swapOfferForm = document.querySelector("[data-swap-offer-form]");
+const swapOfferActions = document.querySelector("[data-swap-offer-actions]");
+const swapOfferAssetSelect = document.querySelector("[data-swap-offer-asset]");
+const swapOfferAmountInput = document.querySelector("[data-swap-offer-amount]");
+const swapOfferTipInput = document.querySelector("[data-swap-offer-tip]");
+const swapRequestAssetSelect = document.querySelector("[data-swap-request-asset]");
+const swapRequestAmountInput = document.querySelector("[data-swap-request-amount]");
+const swapRequestTipInput = document.querySelector("[data-swap-request-tip]");
+const swapCounterpartyInput = document.querySelector("[data-swap-counterparty]");
+const swapExpirationInput = document.querySelector("[data-swap-expiration]");
+const swapSender = document.querySelector("[data-swap-sender]");
+const swapAvailable = document.querySelector("[data-swap-available]");
+const swapFees = document.querySelector("[data-swap-fees]");
+const swapSavedPathPanel = document.querySelector("[data-swap-saved-path-panel]");
+const swapSavedPathInput = document.querySelector("[data-swap-saved-path]");
+const swapCopyPathButton = document.querySelector("[data-swap-copy-path]");
+const swapOfferMessage = document.querySelector("[data-swap-offer-message]");
+const loanOfferForm = document.querySelector("[data-loan-offer-form]");
+const loanOfferActions = document.querySelector("[data-loan-offer-actions]");
+const loanAssetSelect = document.querySelector("[data-loan-asset]");
+const loanAmountInput = document.querySelector("[data-loan-amount]");
+const loanBorrowerInput = document.querySelector("[data-loan-borrower]");
+const loanStartInput = document.querySelector("[data-loan-start]");
+const loanCollateralSelect = document.querySelector("[data-loan-collateral]");
+const loanCollateralAmountInput = document.querySelector("[data-loan-collateral-amount]");
+const loanPaymentPeriodSelect = document.querySelector("[data-loan-payment-period]");
+const loanPaymentNumberInput = document.querySelector("[data-loan-payment-number]");
+const loanPaymentAmountInput = document.querySelector("[data-loan-payment-amount]");
+const loanGracePeriodInput = document.querySelector("[data-loan-grace-period]");
+const loanMaxLateValueInput = document.querySelector("[data-loan-max-late-value]");
+const loanFeeInput = document.querySelector("[data-loan-fee]");
+const loanLender = document.querySelector("[data-loan-lender]");
+const loanAvailable = document.querySelector("[data-loan-available]");
+const loanTotalRepayment = document.querySelector("[data-loan-total-repayment]");
+const loanSavedPathPanel = document.querySelector("[data-loan-saved-path-panel]");
+const loanSavedPathInput = document.querySelector("[data-loan-saved-path]");
+const loanCopyPathButton = document.querySelector("[data-loan-copy-path]");
+const loanOfferMessage = document.querySelector("[data-loan-offer-message]");
+const loanPaymentForm = document.querySelector("[data-loan-payment-form]");
+const loanPaymentActions = document.querySelector("[data-loan-payment-actions]");
+const loanPaymentContractSelect = document.querySelector("[data-loan-payment-contract]");
+const loanPaymentValueInput = document.querySelector("[data-loan-payment-value]");
+const loanPaymentTipInput = document.querySelector("[data-loan-payment-tip]");
+const loanPaymentFeeInput = document.querySelector("[data-loan-payment-fee]");
+const loanPaymentLender = document.querySelector("[data-loan-payment-lender]");
+const loanPaymentAsset = document.querySelector("[data-loan-payment-asset]");
+const loanPaymentScheduled = document.querySelector("[data-loan-payment-scheduled]");
+const loanPaymentConfirmed = document.querySelector("[data-loan-payment-confirmed]");
+const loanPaymentPending = document.querySelector("[data-loan-payment-pending]");
+const loanPaymentRemaining = document.querySelector("[data-loan-payment-remaining]");
+const loanPaymentWarning = document.querySelector("[data-loan-payment-warning]");
+const loanPaymentMessage = document.querySelector("[data-loan-payment-message]");
+const collateralClaimForm = document.querySelector("[data-collateral-claim-form]");
+const collateralClaimActions = document.querySelector("[data-collateral-claim-actions]");
+const collateralClaimContractSelect = document.querySelector("[data-collateral-claim-contract]");
+const collateralClaimFeeInput = document.querySelector("[data-collateral-claim-fee]");
+const collateralClaimRole = document.querySelector("[data-collateral-claim-role]");
+const collateralClaimReason = document.querySelector("[data-collateral-claim-reason]");
+const collateralClaimLender = document.querySelector("[data-collateral-claim-lender]");
+const collateralClaimBorrower = document.querySelector("[data-collateral-claim-borrower]");
+const collateralClaimLoan = document.querySelector("[data-collateral-claim-loan]");
+const collateralClaimCollateral = document.querySelector("[data-collateral-claim-collateral]");
+const collateralClaimConfirmed = document.querySelector("[data-collateral-claim-confirmed]");
+const collateralClaimRemaining = document.querySelector("[data-collateral-claim-remaining]");
+const collateralClaimMessage = document.querySelector("[data-collateral-claim-message]");
+const burnForm = document.querySelector("[data-burn-form]");
+const burnActions = document.querySelector("[data-burn-actions]");
+const burnAssetSelect = document.querySelector("[data-burn-asset]");
+const burnAmountInput = document.querySelector("[data-burn-amount]");
+const burnFeeInput = document.querySelector("[data-burn-fee]");
+const burnAddress = document.querySelector("[data-burn-address]");
+const burnAvailable = document.querySelector("[data-burn-available]");
+const burnType = document.querySelector("[data-burn-type]");
+const burnFeeLabel = document.querySelector("[data-burn-fee-label]");
+const burnMessage = document.querySelector("[data-burn-message]");
+const marketingForm = document.querySelector("[data-marketing-form]");
+const marketingActions = document.querySelector("[data-marketing-actions]");
+const marketingCampaignInput = document.querySelector("[data-marketing-campaign]");
+const marketingAdTypeSelect = document.querySelector("[data-marketing-ad-type]");
+const marketingKeywordInput = document.querySelector("[data-marketing-keyword]");
+const marketingDisplayedInput = document.querySelector("[data-marketing-displayed]");
+const marketingImpressionInput = document.querySelector("[data-marketing-impression]");
+const marketingClickInput = document.querySelector("[data-marketing-click]");
+const marketingImpressionValueInput = document.querySelector("[data-marketing-impression-value]");
+const marketingClickValueInput = document.querySelector("[data-marketing-click-value]");
+const marketingFeeInput = document.querySelector("[data-marketing-fee]");
+const marketingAdvertiser = document.querySelector("[data-marketing-advertiser]");
+const marketingFeeLabel = document.querySelector("[data-marketing-fee-label]");
+const marketingMessage = document.querySelector("[data-marketing-message]");
+const vanityForm = document.querySelector("[data-vanity-form]");
+const vanityActions = document.querySelector("[data-vanity-actions]");
+const vanityNameInput = document.querySelector("[data-vanity-name]");
+const vanityFeeInput = document.querySelector("[data-vanity-fee]");
+const vanityOwner = document.querySelector("[data-vanity-owner]");
+const vanityPreview = document.querySelector("[data-vanity-preview]");
+const vanityFeeLabel = document.querySelector("[data-vanity-fee-label]");
+const vanityMessage = document.querySelector("[data-vanity-message]");
+const bridgeStatus = document.querySelector("[data-bridge-status]");
+const createWalletForm = document.querySelector("[data-create-wallet-form]");
+const loadWalletForm = document.querySelector("[data-load-wallet-form]");
+const importKeyForm = document.querySelector("[data-import-key-form]");
+const importImageForm = document.querySelector("[data-import-image-form]");
+const walletNameInput = document.querySelector("[data-wallet-name]");
+const walletKeyInput = document.querySelector("[data-wallet-key]");
+const walletKeyConfirmInput = document.querySelector("[data-wallet-key-confirm]");
+const createWalletSubmit = document.querySelector("[data-create-wallet-submit]");
+const startupMessage = document.querySelector("[data-startup-message]");
+const walletListSelect = document.querySelector("[data-wallet-list]");
+const loadWalletKeyInput = document.querySelector("[data-load-wallet-key]");
+const loadWalletSubmit = document.querySelector("[data-load-wallet-submit]");
+const loadMessage = document.querySelector("[data-load-message]");
+const importWalletNameInput = document.querySelector("[data-import-wallet-name]");
+const importPrivateKeyInput = document.querySelector("[data-import-private-key]");
+const importWalletKeyInput = document.querySelector("[data-import-wallet-key]");
+const importWalletKeyConfirmInput = document.querySelector("[data-import-wallet-key-confirm]");
+const importKeySubmit = document.querySelector("[data-import-key-submit]");
+const importMessage = document.querySelector("[data-import-message]");
+const importImageWalletNameInput = document.querySelector("[data-import-image-wallet-name]");
+const importImagePathInput = document.querySelector("[data-import-image-path]");
+const importImageWalletKeyInput = document.querySelector("[data-import-image-wallet-key]");
+const importImageWalletKeyConfirmInput = document.querySelector("[data-import-image-wallet-key-confirm]");
+const importImageSubmit = document.querySelector("[data-import-image-submit]");
+const importImageMessage = document.querySelector("[data-import-image-message]");
+const lockWalletButton = document.querySelector("[data-lock-wallet]");
+const browseWalletButton = document.querySelector("[data-browse-wallet]");
+const browsePrivateKeyImageButton = document.querySelector("[data-browse-private-key-image]");
+const networkButtons = document.querySelectorAll("[data-network-toggle]");
+const networkLabels = document.querySelectorAll("[data-network-label]");
+const clcBalance = document.querySelector("[data-clc-balance]");
+const baseBalanceLabel = document.querySelector("[data-base-balance-label]");
+const balanceStatus = document.querySelector("[data-balance-status]");
+const tokenBalances = document.querySelector("[data-token-balances]");
+const broadcastNodeButton = document.querySelector("[data-broadcast-node]");
+const registrationBadge = document.querySelector(".registration-badge");
+const registrationAction = document.querySelector("[data-registration-action]");
+const registrationNotice = document.querySelector("[data-registration-notice]");
+const recentTransactionsBody = document.querySelector("[data-recent-transactions]");
+const recentTransactionsState = document.querySelector("[data-recent-transactions-state]");
+const historyTransactionsBody = document.querySelector("[data-history-transactions]");
+const historyCards = document.querySelector("[data-history-cards]");
+const historyState = document.querySelector("[data-history-state]");
+const historyCount = document.querySelector("[data-history-count]");
+const historyPagination = document.querySelector("[data-history-pagination]");
+const historyPageInput = document.querySelector("[data-history-page-input]");
+const historyPageTotal = document.querySelector("[data-history-page-total]");
+const historySearch = document.querySelector("[data-history-search]");
+const historyExportOpen = document.querySelector("[data-history-export-open]");
+const historyExportModal = document.querySelector("[data-history-export-modal]");
+const historyExportClose = document.querySelector("[data-history-export-close]");
+const historyExportMessage = document.querySelector("[data-history-export-message]");
+const historyExportFormatButtons = document.querySelectorAll("[data-history-export-format]");
+const assetsSearch = document.querySelector("[data-assets-search]");
+const assetsSort = document.querySelector("[data-assets-sort]");
+const assetsFilterButtons = document.querySelectorAll("[data-assets-filter]");
+const assetsCards = document.querySelector("[data-assets-cards]");
+const assetsState = document.querySelector("[data-assets-state]");
+const loansSearch = document.querySelector("[data-loans-search]");
+const loansRoleFilter = document.querySelector("[data-loans-role-filter]");
+const loansStatusButtons = document.querySelectorAll("[data-loans-status-filter]");
+const loansRefreshButton = document.querySelector("[data-loans-refresh]");
+const loansCreateButton = document.querySelector("[data-loans-create]");
+const loansList = document.querySelector("[data-loans-list]");
+const loansState = document.querySelector("[data-loans-state]");
+const loanDetailGrid = document.querySelector("[data-loan-detail-grid]");
+const loanPaymentHistory = document.querySelector("[data-loan-payment-history]");
+const loanCopyContractButton = document.querySelector("[data-loan-copy-contract]");
+const loanMakePaymentButton = document.querySelector("[data-loan-make-payment]");
+const loanClaimCollateralButton = document.querySelector("[data-loan-claim-collateral]");
+const networkInfoHeight = document.querySelector("[data-network-info-height]");
+const networkInfoNetwork = document.querySelector("[data-network-info-network]");
+const networkInfoDifficulty = document.querySelector("[data-network-info-difficulty]");
+const networkInfoMempool = document.querySelector("[data-network-info-mempool]");
+const networkInfoChainTx = document.querySelector("[data-network-info-chain-tx]");
+const nodeInfoNode = document.querySelector("[data-node-info-node]");
+const nodeInfoHeight = document.querySelector("[data-node-info-height]");
+const nodeInfoTime = document.querySelector("[data-node-info-time]");
+const nodeInfoLastChecked = document.querySelector("[data-node-info-last-checked]");
+const nodeInfoLargestFee = document.querySelector("[data-node-info-largest-fee]");
+const paymentAssetSelect = document.querySelector("[data-payment-asset]");
+const paymentAmountInput = document.querySelector("[data-payment-amount]");
+const paymentLabelInput = document.querySelector("[data-payment-label]");
+const paymentUriInput = document.querySelector("[data-payment-uri]");
+const topbarPaymentUriForm = document.querySelector("[data-payment-uri-entry]");
+const topbarPaymentUriInput = document.querySelector("[data-topbar-payment-uri]");
+const paymentQrCanvas = document.querySelector("[data-payment-qr]");
+const paymentQrLabel = document.querySelector("[data-payment-qr-label]");
+const copyPaymentQrButton = document.querySelector("[data-copy-payment-qr]");
+const copyPaymentUriButton = document.querySelector("[data-copy-payment-uri]");
+const paymentMessage = document.querySelector("[data-payment-message]");
+const receiveRegistration = document.querySelector("[data-receive-registration]");
+const addressBookRows = document.querySelector("[data-address-book-rows]");
+const addressBookCards = document.querySelector("[data-address-book-cards]");
+const addressBookSearch = document.querySelector("[data-address-book-search]");
+const addressBookSort = document.querySelector("[data-address-book-sort]");
+const addressBookState = document.querySelector("[data-address-book-state]");
+const addressBookRefreshVanity = document.querySelector("[data-address-book-refresh-vanity]");
+const settingsSaveButton = document.querySelector("[data-settings-save]");
+const settingsMessage = document.querySelector("[data-settings-message]");
+const settingsWalletPath = document.querySelector("[data-settings-wallet-path]");
+const settingsDefaultNode = document.querySelector("[data-settings-default-node]");
+const settingsSavedNodes = document.querySelector("[data-settings-saved-nodes]");
+const settingsUnbroadcastPath = document.querySelector("[data-settings-unbroadcast-path]");
+const settingsAddressBookPath = document.querySelector("[data-settings-address-book-path]");
+const settingsIpfsGateway = document.querySelector("[data-settings-ipfs-gateway]");
+const settingsAutoLockTimeout = document.querySelector("[data-settings-auto-lock-timeout]");
+const settingsClipboardTimeout = document.querySelector("[data-settings-clipboard-timeout]");
+const settingsRequireKey = document.querySelector("[data-settings-require-key]");
+const settingsBrowseButtons = document.querySelectorAll("[data-settings-browse]");
+const settingsTestNodeButton = document.querySelector("[data-settings-test-node]");
+const settingsNodeTestStatus = document.querySelector("[data-settings-node-test-status]");
+const settingsCacheOpenButton = document.querySelector("[data-settings-cache-open]");
+const cacheClearModal = document.querySelector("[data-cache-clear-modal]");
+const cacheClearCloseButton = document.querySelector("[data-cache-clear-close]");
+const cacheClearMessage = document.querySelector("[data-cache-clear-message]");
+const nftsList = document.querySelector("[data-nfts-list]");
+const nftsState = document.querySelector("[data-nfts-state]");
+const nftsRefreshButton = document.querySelector("[data-nfts-refresh]");
+const nftsPagination = document.querySelector("[data-nfts-pagination]");
+const nftsPageInput = document.querySelector("[data-nfts-page-input]");
+const nftsPageTotal = document.querySelector("[data-nfts-page-total]");
+const nftDetailTitle = document.querySelector("[data-nft-detail-title]");
+const nftDetailSubtitle = document.querySelector("[data-nft-detail-subtitle]");
+const nftDetailName = document.querySelector("[data-nft-detail-name]");
+const nftDetailAsset = document.querySelector("[data-nft-detail-asset]");
+const nftDetailCreator = document.querySelector("[data-nft-detail-creator]");
+const nftDetailGenesis = document.querySelector("[data-nft-detail-genesis]");
+const nftDetailMetadata = document.querySelector("[data-nft-detail-metadata]");
+const nftMetadataSummary = document.querySelector("[data-nft-metadata-summary]");
+const nftHistory = document.querySelector("[data-nft-history]");
+let activeNetwork = "testnet";
+let currentView = "dashboard";
+let walletLoaded = false;
+let registrationRegistered = false;
+let registrationCheckInFlight = false;
+let registrationRequestId = 0;
+let dashboardRegisteredLoadId = 0;
+let balanceRefreshTimer = null;
+let balanceRefreshInFlight = false;
+let balanceRefreshRequestId = 0;
+let dashboardLastBalanceStatus = "";
+let activeWalletBalances = [];
+let activeUnbroadcastTransaction = null;
+let unbroadcastRefreshInFlight = false;
+let unbroadcastReviewInFlight = false;
+let networkInfoRefreshTimer = null;
+let nodeInfoRefreshTimer = null;
+let networkInfoRefreshInFlight = false;
+let nodeInfoRefreshInFlight = false;
+let recentTransactionsCacheReadId = 0;
+let latestTransactionsSyncId = 0;
+let latestTransactionsSyncInFlight = false;
+let latestDashboardTransactionsTimer = null;
+let latestDashboardTxids = [];
+let latestDashboardTransactionRecords = new Map();
+let backgroundTransactionSyncId = 0;
+let historyRefreshTimer = null;
+let historyRefreshReadId = 0;
+let historyRefreshInFlight = false;
+let historyRefreshPending = false;
+let historyCurrentPage = 1;
+let historyLastRenderSignature = "";
+let historySearchDebounceTimer = null;
+let transactionCacheMutationChain = Promise.resolve();
+let guiRuntimeSettings = {
+ auto_lock_timeout: "15 minutes",
+ clipboard_clear_timeout: "60 seconds",
+ require_key_before_signing: true
+};
+let autoLockTimer = null;
+let clipboardClearTimer = null;
+let lastClipboardText = "";
+let activeWalletAddressHex = "";
+let activeWalletAddressShort = "";
+let latestKnownBlockHeight = 0;
+const BALANCE_REFRESH_MS = 120000;
+const NETWORK_INFO_REFRESH_MS = 60000;
+const NODE_INFO_REFRESH_MS = 15000;
+const DASHBOARD_RECENT_LIMIT = 5;
+const BACKGROUND_HISTORY_PAGE_SIZE = 100;
+const BACKGROUND_SYNC_IDLE_MS = 15000;
+const DASHBOARD_LATEST_REFRESH_MS = 5000;
+const DASHBOARD_INITIAL_TX_FETCH_DELAY_MS = 500;
+const DASHBOARD_REFRESH_TX_FETCH_DELAY_MS = 2000;
+const BACKGROUND_TX_FETCH_DELAY_MS = 2000;
+const HISTORY_REFRESH_MS = 5000;
+const HISTORY_PAGE_SIZE = 100;
+const WALLET_RPC_RETRY_LIMIT = 3;
+const WALLET_RPC_BACKOFF_BASE_MS = 1500;
+const WALLET_RPC_BACKOFF_MAX_MS = 15000;
+const CONFIRMED_AFTER_BLOCKS = 20;
+const CHAIN_STATUS_PENDING = "pending";
+const CHAIN_STATUS_FINALIZED = "finalized";
+const startupTitle = document.querySelector(".startup-copy h1");
+const startupDescription = document.querySelector(".startup-copy p");
+const startModeButtons = document.querySelectorAll("[data-start-mode]");
+const topWalletListSelect = document.querySelector("[data-top-wallet-list]");
+const walletSwitchModal = document.querySelector("[data-wallet-switch-modal]");
+const walletSwitchForm = document.querySelector("[data-wallet-switch-form]");
+const walletSwitchName = document.querySelector("[data-wallet-switch-name]");
+const walletSwitchKeyInput = document.querySelector("[data-wallet-switch-key]");
+const walletSwitchSubmit = document.querySelector("[data-wallet-switch-submit]");
+const walletSwitchMessage = document.querySelector("[data-wallet-switch-message]");
+const walletSwitchCloseButton = document.querySelector("[data-wallet-switch-close]");
+const walletSwitchCancelButton = document.querySelector("[data-wallet-switch-cancel]");
+const backupKeyModal = document.querySelector("[data-backup-key-modal]");
+const backupKeyForm = document.querySelector("[data-backup-key-form]");
+const backupKeyTitle = document.querySelector("[data-backup-key-title]");
+const backupKeyCopy = document.querySelector("[data-backup-key-copy]");
+const backupKeyInput = document.querySelector("[data-backup-key-input]");
+const backupKeyMessage = document.querySelector("[data-backup-key-message]");
+const backupKeyCloseButton = document.querySelector("[data-backup-key-close]");
+const backupKeyCancelButton = document.querySelector("[data-backup-key-cancel]");
+const backupKeySubmitButton = document.querySelector("[data-backup-key-submit]");
+let activeWalletPath = "";
+let pendingWalletSwitch = null;
+let pendingBackupKeyRequest = null;
+
+const startupCopy = {
+ load: ["Open Wallet", "Select a wallet file already on this device."],
+ create: ["Create New Wallet", "Generate a new encrypted wallet file."],
+ "import-key": ["Import Private Key", "Restore from a private key value."],
+ "import-image": ["Import Private Key Image", "Restore from a base64 or image-based key backup."]
+};
+
+function setActiveStartMode(mode) {
+ startModeButtons.forEach((button) => {
+ button.classList.toggle("primary-start", button.dataset.startMode === mode);
+ });
+
+ const [title, description] = startupCopy[mode] || startupCopy.load;
+
+ if (startupTitle) {
+ startupTitle.textContent = title;
+ }
+
+ if (startupDescription) {
+ startupDescription.textContent = description;
+ }
+}
+
+function activeBaseCoin() {
+ return activeNetwork === "mainnet" ? "CLC" : "CLTC";
+}
+
+function shortenAddress(address) {
+ if (!address || address.length <= 17) {
+ return address || "No wallet";
+ }
+
+ const suffix = address.includes(".") ? address.slice(address.lastIndexOf(".") - 4) : address.slice(-8);
+ return `${address.slice(0, 4)}...${suffix}`;
+}
+
+function privateKeyImageSrc(privateKeyImage) {
+ const image = (privateKeyImage || "").trim();
+ if (!image) {
+ return "";
+ }
+
+ return image.startsWith("data:") ? image : `data:image/png;base64,${image}`;
+}
+
+function setWalletImageMarks(privateKeyImage) {
+ const imageSrc = privateKeyImageSrc(privateKeyImage);
+
+ document.querySelectorAll("[data-wallet-image-mark]").forEach((item) => {
+ if (!imageSrc) {
+ item.classList.remove("wallet-image");
+ item.style.backgroundImage = "";
+ item.textContent = "C";
+ return;
+ }
+
+ item.classList.add("wallet-image");
+ item.style.backgroundImage = `url("${imageSrc}")`;
+ item.textContent = "";
+ });
+}
+
+function formatAtomicBalance(value) {
+ const atomic = BigInt(value || "0");
+ const whole = atomic / 100000000n;
+ const fractionalRaw = atomic % 100000000n;
+ const fractional = fractionalRaw.toString().padStart(8, "0").replace(/0+$/, "");
+ return fractional ? `${whole}.${fractional}` : `${whole}`;
+}
+
+function formatNumber(value) {
+ return Number(value || 0).toLocaleString();
+}
+
+function formatNetworkTime(timestamp) {
+ const numeric = Number(timestamp || 0);
+ if (!numeric) {
+ return "--";
+ }
+ return new Date(numeric * 1000).toLocaleString();
+}
+
+function formatLargestFee(value) {
+ const formatted = formatAtomicBalance(value);
+ return `${formatted} ${activeBaseCoin()}`;
+}
+
+function networkDisplayName(info) {
+ const network = String(info?.network || activeNetwork || "").trim();
+ const prefix = String(info?.wallet_prefix || activeBaseCoin()).trim();
+ const label = network ? network.charAt(0).toUpperCase() + network.slice(1) : "Network";
+ return prefix ? `${label} / ${prefix}` : label;
+}
+
+async function populateTopWalletList() {
+ const invoke = window.__TAURI__?.core?.invoke;
+
+ if (!invoke || !topWalletListSelect) {
+ return;
+ }
+
+ try {
+ const wallets = await invoke("list_wallets", { network: activeNetwork });
+
+ topWalletListSelect.innerHTML = "";
+
+ if (!wallets.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No wallets found";
+ topWalletListSelect.appendChild(option);
+ return;
+ }
+
+ wallets.forEach((wallet) => {
+ const option = document.createElement("option");
+ option.value = wallet.wallet_path;
+ option.textContent = wallet.wallet_name;
+
+ if (wallet.wallet_path === activeWalletPath) {
+ option.selected = true;
+ }
+
+ topWalletListSelect.appendChild(option);
+ });
+ } catch (error) {
+ console.error(error);
+ }
+}
+
+function setBroadcastNodeOptions(nodes) {
+ if (!broadcastNodeButton) {
+ return;
+ }
+
+ const previous = activeBroadcastNode();
+ const normalized = Array.isArray(nodes) ? nodes.filter((node) => node?.address) : [];
+ broadcastNodeButton.innerHTML = "";
+
+ if (!normalized.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No broadcast nodes";
+ broadcastNodeButton.appendChild(option);
+ return;
+ }
+
+ normalized.forEach((node) => {
+ const option = document.createElement("option");
+ option.value = node.address;
+ option.textContent = node.address;
+ option.title = node.label ? `${node.label}: ${node.address}` : node.address;
+ broadcastNodeButton.appendChild(option);
+ });
+
+ const selected = normalized.some((node) => node.address === previous)
+ ? previous
+ : normalized[0].address;
+ broadcastNodeButton.value = selected;
+}
+
+async function populateBroadcastNodeList() {
+ const invoke = window.__TAURI__?.core?.invoke;
+
+ if (!invoke || !broadcastNodeButton) {
+ return;
+ }
+
+ try {
+ const nodes = await invoke("list_broadcast_nodes");
+ setBroadcastNodeOptions(nodes);
+ } catch (error) {
+ console.error(error);
+ setBroadcastNodeOptions([]);
+ }
+}
+
+function assetInitial(asset) {
+ return (asset || "?").trim().slice(0, 1).toUpperCase() || "?";
+}
+
+function balanceAssetLabel(balance) {
+ if (balance.nft_series && balance.nft_series > 0) {
+ return `${balance.asset} #${balance.nft_series}`;
+ }
+
+ return balance.asset;
+}
+
+let knownNftBalanceKeys = new Set();
+let knownNftBalanceNode = "";
+let knownNftBalanceLoadedAt = 0;
+let knownNftBalanceLoad = null;
+const DASHBOARD_NFT_BALANCE_CACHE_MS = 300_000;
+
+function balanceRegistryKey(balance) {
+ const asset = String(balance?.asset || "").trim().toLowerCase();
+ const series = Number(balance?.nft_series || 0);
+ return `${asset}|${series}`;
+}
+
+function isDashboardNftBalance(balance) {
+ if (Number(balance?.nft_series || 0) > 0) {
+ return true;
+ }
+
+ return knownNftBalanceKeys.has(balanceRegistryKey(balance));
+}
+
+function dashboardNftBalanceKeysReady() {
+ const broadcastNode = typeof activeBroadcastNode === "function" ? activeBroadcastNode() : "";
+ return (
+ Boolean(broadcastNode) &&
+ knownNftBalanceNode === broadcastNode
+ );
+}
+
+function dashboardNftBalanceKeysFresh() {
+ const broadcastNode = typeof activeBroadcastNode === "function" ? activeBroadcastNode() : "";
+ return (
+ dashboardNftBalanceKeysReady() &&
+ Date.now() - knownNftBalanceLoadedAt < DASHBOARD_NFT_BALANCE_CACHE_MS
+ );
+}
+
+function invalidateDashboardNftBalanceKeys() {
+ knownNftBalanceNode = "";
+ knownNftBalanceLoadedAt = 0;
+}
+
+async function refreshDashboardNftBalanceKeys() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = typeof activeBroadcastNode === "function" ? activeBroadcastNode() : "";
+
+ if (!invoke || !broadcastNode) {
+ return false;
+ }
+
+ if (dashboardNftBalanceKeysFresh()) {
+ return false;
+ }
+
+ if (knownNftBalanceLoad) {
+ return knownNftBalanceLoad;
+ }
+
+ knownNftBalanceLoad = invoke("nft_list", { broadcastNode })
+ .then((rows) => {
+ const nextKeys = new Set();
+ (Array.isArray(rows) ? rows : []).forEach((nft) => {
+ const name = String(nft?.nft_name || "").trim().toLowerCase();
+ if (!name) {
+ return;
+ }
+ nextKeys.add(`${name}|${Number(nft?.series || 0)}`);
+ });
+
+ const previous = Array.from(knownNftBalanceKeys).sort().join(",");
+ const next = Array.from(nextKeys).sort().join(",");
+ knownNftBalanceKeys = nextKeys;
+ knownNftBalanceNode = broadcastNode;
+ knownNftBalanceLoadedAt = Date.now();
+ return previous !== next;
+ })
+ .catch(() => false)
+ .finally(() => {
+ knownNftBalanceLoad = null;
+ });
+
+ return knownNftBalanceLoad;
+}
+
+function setBalanceStatus(message, type = "") {
+ if (!balanceStatus) {
+ return;
+ }
+
+ balanceStatus.textContent = message;
+ balanceStatus.classList.toggle("error", type === "error");
+ balanceStatus.classList.toggle("success", type === "success");
+}
+
+function setBridgeStatus(message, type = "") {
+ if (!bridgeStatus) {
+ return;
+ }
+
+ bridgeStatus.textContent = message;
+ bridgeStatus.classList.toggle("error", type === "error");
+ bridgeStatus.classList.toggle("success", type === "success");
+}
+
+function renderBalances(balances) {
+ const normalized = Array.isArray(balances) ? balances : [];
+ activeWalletBalances = normalized;
+ if (typeof refreshTransferAssetOptions === "function") {
+ refreshTransferAssetOptions();
+ }
+ if (typeof refreshActiveTransactionFormAfterWalletData === "function") {
+ refreshActiveTransactionFormAfterWalletData();
+ }
+
+ const baseCoin = activeBaseCoin();
+ const baseBalance = normalized.find((balance) => {
+ return (balance.asset || "").trim().toUpperCase() === baseCoin && !balance.nft_series;
+ });
+ const nftKeysReady = dashboardNftBalanceKeysReady();
+ const tokenRows = normalized
+ .filter((balance) => {
+ const isBaseCoin = (balance.asset || "").trim().toUpperCase() === baseCoin && !balance.nft_series;
+ return !isBaseCoin && !isDashboardNftBalance(balance);
+ })
+ .sort((left, right) => {
+ const leftBalance = BigInt(left.balance || "0");
+ const rightBalance = BigInt(right.balance || "0");
+ if (rightBalance !== leftBalance) {
+ return rightBalance > leftBalance ? 1 : -1;
+ }
+ return balanceAssetLabel(left).localeCompare(balanceAssetLabel(right));
+ });
+
+ if (baseBalanceLabel) {
+ baseBalanceLabel.textContent = `${baseCoin} Balance`;
+ }
+
+ if (clcBalance) {
+ clcBalance.textContent = baseBalance ? `${formatAtomicBalance(baseBalance.balance)} ${baseCoin}` : `0 ${baseCoin}`;
+ }
+
+ if (!tokenBalances) {
+ return;
+ }
+
+ const rerenderAfterNftKeyRefresh = () => {
+ refreshDashboardNftBalanceKeys().then((changed) => {
+ if (changed && Array.isArray(activeWalletBalances)) {
+ renderBalances(activeWalletBalances);
+ }
+ });
+ };
+
+ tokenBalances.innerHTML = "";
+ const title = document.createElement("div");
+ title.className = "token-title";
+ title.textContent = nftKeysReady ? `Token Balances (${tokenRows.length})` : "Token Balances";
+ tokenBalances.appendChild(title);
+
+ if (!nftKeysReady) {
+ const pending = document.createElement("div");
+ pending.className = "empty-balance";
+ pending.textContent = "Loading token balances...";
+ tokenBalances.appendChild(pending);
+ rerenderAfterNftKeyRefresh();
+ return;
+ }
+
+ if (!tokenRows.length) {
+ const empty = document.createElement("div");
+ empty.className = "empty-balance";
+ empty.textContent = "No token balances found.";
+ tokenBalances.appendChild(empty);
+ rerenderAfterNftKeyRefresh();
+ return;
+ }
+
+ tokenRows.slice(0, 4).forEach((balance) => {
+ const row = document.createElement("div");
+ row.className = "token-row";
+
+ const mark = document.createElement("span");
+ mark.className = "asset-mark mini";
+ mark.textContent = assetInitial(balance.asset);
+
+ const asset = document.createElement("span");
+ asset.textContent = balanceAssetLabel(balance);
+
+ const amount = document.createElement("b");
+ amount.textContent = formatAtomicBalance(balance.balance);
+
+ row.append(mark, asset, amount);
+ tokenBalances.appendChild(row);
+ });
+
+ rerenderAfterNftKeyRefresh();
+
+ if (currentView === "assets" && typeof renderAssetsPage === "function") {
+ renderAssetsPage();
+ }
+}
+
+function resetTransactionForms() {
+ [
+ "resetTransferSession",
+ "resetCreateTokenSession",
+ "resetIssueTokenSession",
+ "resetCreateNftSession",
+ "resetSwapOfferSession",
+ "resetLoanOfferSession",
+ "resetLoanPaymentSession",
+ "resetCollateralClaimSession",
+ "resetBurnSession",
+ "resetMarketingSession",
+ "resetVanityAddressSession"
+ ].forEach((name) => {
+ if (typeof window[name] === "function") {
+ window[name]();
+ }
+ });
+
+ [
+ "clearTransferForm",
+ "clearCreateTokenForm",
+ "clearIssueTokenForm",
+ "clearCreateNftForm",
+ "clearSwapOfferForm",
+ "clearLoanOfferForm",
+ "clearLoanPaymentForm",
+ "clearCollateralClaimForm",
+ "clearBurnForm",
+ "clearMarketingForm",
+ "clearVanityForm"
+ ].forEach((name) => {
+ if (typeof window[name] === "function") {
+ window[name]();
+ }
+ });
+
+ [
+ transferMessage,
+ createTokenMessage,
+ issueTokenMessage,
+ createNftMessage,
+ swapOfferMessage,
+ loanOfferMessage,
+ loanPaymentMessage,
+ collateralClaimMessage,
+ burnMessage,
+ marketingMessage,
+ vanityMessage
+ ].forEach((element) => {
+ if (!element) {
+ return;
+ }
+ element.textContent = "";
+ element.classList.add("hidden");
+ element.classList.remove("error", "success");
+ });
+
+ loanSavedPathPanel?.classList.add("hidden");
+ currentTransactionType = "";
+}
+
+function setRecentTransactionsState(message, mode = "") {
+ if (!recentTransactionsState) {
+ return;
+ }
+
+ recentTransactionsState.textContent = message;
+ recentTransactionsState.classList.toggle("hidden", !message);
+ recentTransactionsState.classList.toggle("loading", mode === "loading");
+}
+
+function clearRecentTransactionsRows() {
+ if (recentTransactionsBody) {
+ recentTransactionsBody.innerHTML = "";
+ }
+}
diff --git a/frontend/js/assets_page.js b/frontend/js/assets_page.js
new file mode 100644
index 0000000..554135d
--- /dev/null
+++ b/frontend/js/assets_page.js
@@ -0,0 +1,256 @@
+let assetsCatalog = [];
+let assetsLoadedForNode = "";
+let assetsLoadInFlight = false;
+let assetsRefreshId = 0;
+let activeAssetFilter = "all";
+let assetsEmptyStateMessage = "";
+
+function invalidateAssetsCatalog() {
+ assetsLoadedForNode = "";
+}
+
+function assetCatalogBalance(asset) {
+ const ticker = String(asset || "").trim().toLowerCase();
+ const match = activeWalletBalances.find((balance) => {
+ return (
+ String(balance.asset || "").trim().toLowerCase() === ticker &&
+ Number(balance.nft_series || 0) === 0
+ );
+ });
+ return match ? String(match.balance || "0") : "0";
+}
+
+function formatAssetSupply(value) {
+ return formatAtomicBalance(value || 0);
+}
+
+function assetCreatorLabel(asset, isCreator) {
+ const creator = String(asset.creator || "").trim();
+ if (isCreator) {
+ return "You";
+ }
+ return creator ? shortenAddress(creator) : "Unknown";
+}
+
+function formatAssetDate(timestamp) {
+ const numeric = Number(timestamp || 0);
+ if (!numeric) {
+ return "--";
+ }
+ return new Date(numeric * 1000).toLocaleDateString();
+}
+
+function escapeAssetText(value) {
+ return String(value ?? "")
+ .replaceAll("&", "&")
+ .replaceAll("<", "<")
+ .replaceAll(">", ">")
+ .replaceAll('"', """)
+ .replaceAll("'", "'");
+}
+
+function compareAssetBalance(left, right) {
+ const leftBalance = BigInt(assetCatalogBalance(left.ticker));
+ const rightBalance = BigInt(assetCatalogBalance(right.ticker));
+ if (rightBalance !== leftBalance) {
+ return rightBalance > leftBalance ? 1 : -1;
+ }
+ return String(left.ticker || "").localeCompare(String(right.ticker || ""));
+}
+
+function sortedAssetCards() {
+ const query = String(assetsSearch?.value || "").trim().toLowerCase();
+ const sortMode = assetsSort?.value || "default";
+ const activeShortAddress = String(activeWalletAddressShort || "").toLowerCase();
+ const sourceRows = assetsCatalog;
+
+ let rows = sourceRows.filter((asset) => {
+ const ticker = String(asset.ticker || "").trim();
+ if (!ticker) {
+ return false;
+ }
+ const balance = BigInt(assetCatalogBalance(ticker));
+ const creator = String(asset.creator || "").toLowerCase();
+ const searchText = `${ticker} ${asset.origin_txid || ""} ${asset.creator || ""}`.toLowerCase();
+
+ if (activeAssetFilter === "holding" && balance <= 0n) {
+ return false;
+ }
+ if (activeAssetFilter === "created" && creator !== activeShortAddress) {
+ return false;
+ }
+ return !query || searchText.includes(query);
+ });
+
+ if (sortMode === "balance" || sortMode === "default") {
+ rows.sort(compareAssetBalance);
+ if (sortMode === "default") {
+ rows.sort((left, right) => {
+ const leftHolding = BigInt(assetCatalogBalance(left.ticker)) > 0n ? 0 : 1;
+ const rightHolding = BigInt(assetCatalogBalance(right.ticker)) > 0n ? 0 : 1;
+ return leftHolding - rightHolding || compareAssetBalance(left, right);
+ });
+ }
+ } else if (sortMode === "created") {
+ rows.sort((left, right) => Number(right.created_timestamp || 0) - Number(left.created_timestamp || 0));
+ } else {
+ rows.sort((left, right) => String(left.ticker || "").localeCompare(String(right.ticker || "")));
+ }
+
+ return rows;
+}
+
+function renderAssetCard(asset) {
+ const ticker = String(asset.ticker || "").trim();
+ const balance = assetCatalogBalance(ticker);
+ const isHolding = BigInt(balance || "0") > 0n;
+ const isCreator = String(asset.creator || "").toLowerCase() === String(activeWalletAddressShort || "").toLowerCase();
+ const policy = asset.hard_limit ? "Fixed Supply" : "Issuable";
+ const escapedTicker = escapeAssetText(ticker);
+ const escapedPolicy = escapeAssetText(policy);
+ const creatorLabel = assetCreatorLabel(asset, isCreator);
+
+ return `
+
+
+
${escapeAssetText(assetInitial(ticker))}
+
+ ${escapedTicker}
+ ${escapedPolicy}
+
+
${escapeAssetText(formatAtomicBalance(balance))} ${escapedTicker}
+
+ ${isHolding ? 'Holding ' : ""}
+ ${isCreator ? 'Created by me ' : ""}
+ ${escapedPolicy}
+
+
+ ${escapeAssetText(asset.origin_txid || "")}
+
+ `;
+}
+
+function setAssetsState(message) {
+ if (assetsState) {
+ assetsState.textContent = message || "";
+ }
+}
+
+function renderAssetsPage() {
+ if (!assetsCards) {
+ return;
+ }
+
+ const rows = sortedAssetCards();
+ assetsCards.innerHTML = rows.map(renderAssetCard).join("");
+
+ if (!walletLoaded) {
+ setAssetsState("Load a wallet to view assets.");
+ } else if (assetsLoadInFlight && !assetsCatalog.length) {
+ setAssetsState("Loading assets...");
+ } else if (!assetsCatalog.length) {
+ setAssetsState(assetsEmptyStateMessage || "Token catalog returned no rows.");
+ } else if (!rows.length) {
+ setAssetsState("No assets match the current filter.");
+ } else {
+ setAssetsState(`${rows.length} token${rows.length === 1 ? "" : "s"} shown`);
+ }
+}
+
+async function loadAssetsCatalog({ force = false } = {}) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const initialBroadcastNode = activeBroadcastNode();
+ if (!walletLoaded) {
+ assetsCatalog = [];
+ assetsEmptyStateMessage = "Asset catalog skipped: no wallet is loaded.";
+ renderAssetsPage();
+ return;
+ }
+ if (!invoke) {
+ assetsCatalog = [];
+ assetsEmptyStateMessage = "Asset catalog skipped: Tauri invoke is unavailable.";
+ renderAssetsPage();
+ return;
+ }
+ if (!initialBroadcastNode) {
+ assetsCatalog = [];
+ assetsEmptyStateMessage = "Asset catalog skipped: no broadcast node is selected.";
+ renderAssetsPage();
+ return;
+ }
+
+ const broadcastNode = initialBroadcastNode;
+ if (!force && assetsCatalog.length && assetsLoadedForNode === broadcastNode) {
+ renderAssetsPage();
+ return;
+ }
+ if (assetsLoadInFlight) {
+ return;
+ }
+
+ const refreshId = ++assetsRefreshId;
+ assetsLoadInFlight = true;
+ assetsEmptyStateMessage = "Calling token catalog RPC command 48...";
+ renderAssetsPage();
+
+ try {
+ const catalog = await invokeWalletRpcWithBackoff(
+ "asset catalog",
+ () => invoke("token_catalog", { broadcastNode }),
+ () => refreshId === assetsRefreshId && activeBroadcastNode() === broadcastNode
+ );
+ if (refreshId !== assetsRefreshId || activeBroadcastNode() !== broadcastNode) {
+ return;
+ }
+ assetsCatalog = Array.isArray(catalog) ? catalog : [];
+ assetsEmptyStateMessage = assetsCatalog.length
+ ? ""
+ : "Token catalog command 48 returned 0 rows from the selected node.";
+ assetsLoadedForNode = broadcastNode;
+ } catch (error) {
+ if (refreshId === assetsRefreshId) {
+ assetsCatalog = [];
+ assetsEmptyStateMessage = `Token catalog command 48 failed: ${String(error)}`;
+ setAssetsState(String(error));
+ }
+ } finally {
+ if (refreshId === assetsRefreshId) {
+ assetsLoadInFlight = false;
+ renderAssetsPage();
+ }
+ }
+}
+
+function prepareAssetsPage() {
+ renderAssetsPage();
+ loadAssetsCatalog({ force: true });
+}
+
+function resetAssetsPage() {
+ assetsRefreshId += 1;
+ assetsCatalog = [];
+ assetsEmptyStateMessage = "";
+ assetsLoadedForNode = "";
+ assetsLoadInFlight = false;
+ renderAssetsPage();
+}
+
+assetsSearch?.addEventListener("input", renderAssetsPage);
+assetsSort?.addEventListener("change", renderAssetsPage);
+assetsFilterButtons.forEach((button) => {
+ button.addEventListener("click", () => {
+ activeAssetFilter = button.dataset.assetsFilter || "all";
+ assetsFilterButtons.forEach((item) => {
+ item.classList.toggle("active", item === button);
+ });
+ renderAssetsPage();
+ });
+});
diff --git a/frontend/js/burn_form.js b/frontend/js/burn_form.js
new file mode 100644
index 0000000..b5bfefb
--- /dev/null
+++ b/frontend/js/burn_form.js
@@ -0,0 +1,273 @@
+const BURN_FEE_ATOMIC = 10000n;
+let burnBalancesRefreshPromise = null;
+
+function setBurnMessage(message, type = "") {
+ setScopedTransactionMessage("Burn", burnMessage, message, type);
+}
+
+function burnableBalances() {
+ return (Array.isArray(activeWalletBalances) ? activeWalletBalances : [])
+ .filter((balance) => {
+ const asset = String(balance.asset || "").trim();
+ return asset
+ && !isBaseTransferAsset(asset)
+ && balanceAtomicValue(balance) > 0n;
+ });
+}
+
+function burnAssetOptionLabel(balance) {
+ const amount = formatAtomicBalance(balance.balance || "0");
+ const series = Number(balance.nft_series || 0);
+ if (series > 0) {
+ return `${balance.asset} #${series} (${amount})`;
+ }
+ return `${balance.asset} (${amount})`;
+}
+
+function selectedBurnAsset() {
+ const option = burnAssetSelect?.selectedOptions?.[0];
+ if (!option?.value) {
+ return null;
+ }
+ return {
+ asset: option.dataset.asset || "",
+ nftSeries: Number(option.dataset.nftSeries || 0),
+ balance: BigInt(option.dataset.balance || "0")
+ };
+}
+
+function populateBurnAssets() {
+ if (!burnAssetSelect) {
+ return;
+ }
+ const previous = burnAssetSelect.value;
+ burnAssetSelect.innerHTML = "";
+ const balances = burnableBalances();
+ if (balances.length) {
+ const placeholder = document.createElement("option");
+ placeholder.value = "";
+ placeholder.textContent = "Select an asset";
+ burnAssetSelect.appendChild(placeholder);
+ }
+ balances.forEach((balance) => {
+ const option = document.createElement("option");
+ option.value = transferAssetKey(balance);
+ option.dataset.asset = balance.asset || "";
+ option.dataset.nftSeries = String(balance.nft_series || 0);
+ option.dataset.balance = String(balance.balance || "0");
+ option.textContent = burnAssetOptionLabel(balance);
+ burnAssetSelect.appendChild(option);
+ });
+ if (!balances.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No burnable assets";
+ burnAssetSelect.appendChild(option);
+ } else if ([...burnAssetSelect.options].some((option) => option.value === previous)) {
+ burnAssetSelect.value = previous;
+ }
+ updateBurnDerivedFields();
+}
+
+async function ensureBurnBalances() {
+ if (activeWalletBalances.length || !walletLoaded || !registrationRegistered) {
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode) {
+ return;
+ }
+ burnBalancesRefreshPromise ||= invoke("get_active_wallet_balances", { broadcastNode })
+ .then((balances) => {
+ activeWalletBalances = Array.isArray(balances) ? balances : [];
+ })
+ .finally(() => {
+ burnBalancesRefreshPromise = null;
+ });
+ await burnBalancesRefreshPromise;
+}
+
+function updateBurnDerivedFields() {
+ const selected = selectedBurnAsset();
+ if (burnFeeInput) {
+ burnFeeInput.value = atomicToDecimal(BURN_FEE_ATOMIC);
+ }
+ if (burnFeeLabel) {
+ burnFeeLabel.textContent = `${atomicToDecimal(BURN_FEE_ATOMIC)} ${activeBaseCoin()}`;
+ }
+ if (burnAddress) {
+ burnAddress.textContent = activeWalletAddressShort || activeWalletAddressHex || "--";
+ }
+ if (!selected) {
+ if (burnAvailable) {
+ burnAvailable.textContent = "--";
+ }
+ if (burnType) {
+ burnType.textContent = "--";
+ }
+ if (burnAmountInput) {
+ burnAmountInput.disabled = false;
+ burnAmountInput.value = "";
+ }
+ return;
+ }
+
+ const isNft = selected.nftSeries > 0;
+ if (burnAvailable) {
+ burnAvailable.textContent = `${atomicToDecimal(selected.balance)} ${selected.asset}`;
+ }
+ if (burnType) {
+ burnType.textContent = isNft ? `NFT #${selected.nftSeries}` : "Token";
+ }
+ if (burnAmountInput) {
+ burnAmountInput.disabled = isNft;
+ if (isNft) {
+ burnAmountInput.value = "1.00000000";
+ }
+ }
+}
+
+function validateBurnForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before burning an asset.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before burning an asset.";
+ }
+ const selected = selectedBurnAsset();
+ if (!selected) {
+ return "Select an asset to burn.";
+ }
+ const amount = decimalToAtomic(burnAmountInput?.value);
+ if (amount === null || amount <= 0n) {
+ return "Enter a valid burn amount.";
+ }
+ if (selected.nftSeries > 0 && amount !== ATOMIC_UNITS_PER_COIN) {
+ return "NFT burns must destroy exactly 1.00000000 units.";
+ }
+ if (amount > selected.balance) {
+ return "Burn amount cannot exceed the selected asset balance.";
+ }
+ if (baseCoinBalanceAtomic() < BURN_FEE_ATOMIC) {
+ return `Burning requires ${atomicToDecimal(BURN_FEE_ATOMIC)} ${activeBaseCoin()} for the transaction fee.`;
+ }
+ return "";
+}
+
+function burnPayload() {
+ const selected = selectedBurnAsset();
+ return {
+ coin: selected.asset,
+ nftSeries: selected.nftSeries,
+ value: String(decimalToAtomic(burnAmountInput.value)),
+ txfee: String(BURN_FEE_ATOMIC)
+ };
+}
+
+function clearBurnForm() {
+ if (burnAssetSelect) {
+ burnAssetSelect.value = "";
+ }
+ if (burnAmountInput) {
+ burnAmountInput.value = "";
+ burnAmountInput.disabled = false;
+ }
+ updateBurnDerivedFields();
+}
+
+function setBurnButtonsDisabled(disabled) {
+ document.querySelector("[data-burn-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-burn-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+async function handleBurnAction(action) {
+ try {
+ await ensureBurnBalances();
+ populateBurnAssets();
+ } catch (error) {
+ setBurnMessage(String(error), "error");
+ return;
+ }
+
+ const validationError = validateBurnForm();
+ if (validationError) {
+ setBurnMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setBurnMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setBurnMessage("Signing cancelled.");
+ return;
+ }
+
+ setBurnButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setBurnMessage("Saving burn transaction...");
+ const review = await invoke("save_burn_transaction", {
+ ...burnPayload(),
+ walletKey
+ });
+ clearBurnForm();
+ setBurnMessage(`Burn transaction saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ const broadcastNode = activeBroadcastNode();
+ if (!broadcastNode) {
+ throw new Error("Select a broadcast node before broadcasting.");
+ }
+ setBurnMessage("Broadcasting burn transaction...");
+ const result = await invoke("broadcast_burn_transaction", {
+ ...burnPayload(),
+ broadcastNode,
+ walletKey
+ });
+ if (typeof invalidateAssetsCatalog === "function") {
+ invalidateAssetsCatalog();
+ }
+ activeWalletBalances = [];
+ clearBurnForm();
+ setBurnMessage(result.response || "Burn transaction broadcast.", "success");
+ }
+ } catch (error) {
+ setBurnMessage(String(error), "error");
+ } finally {
+ setBurnButtonsDisabled(false);
+ }
+}
+
+async function prepareBurnForm() {
+ setBurnMessage("");
+ try {
+ await ensureBurnBalances();
+ } catch (error) {
+ setBurnMessage(String(error), "error");
+ }
+ populateBurnAssets();
+}
+
+function resetBurnSession() {
+ burnBalancesRefreshPromise = null;
+ clearBurnForm();
+ setBurnMessage("");
+}
+
+burnAssetSelect?.addEventListener("change", () => {
+ setBurnMessage("");
+ updateBurnDerivedFields();
+});
+burnAmountInput?.addEventListener("input", () => setBurnMessage(""));
+document
+ .querySelector("[data-burn-save]")
+ ?.addEventListener("click", () => handleBurnAction("save"));
+document
+ .querySelector("[data-burn-broadcast]")
+ ?.addEventListener("click", () => handleBurnAction("broadcast"));
diff --git a/frontend/js/collateral_claim_form.js b/frontend/js/collateral_claim_form.js
new file mode 100644
index 0000000..5445198
--- /dev/null
+++ b/frontend/js/collateral_claim_form.js
@@ -0,0 +1,220 @@
+const COLLATERAL_CLAIM_FEE_ATOMIC = 300000000n;
+let collateralClaimContracts = [];
+let collateralClaimLoadPromise = null;
+let collateralClaimContractsKey = "";
+
+function setCollateralClaimMessage(message, type = "") {
+ setScopedTransactionMessage("Collateral Claim", collateralClaimMessage, message, type);
+}
+
+function selectedCollateralClaimContract() {
+ const hash = String(collateralClaimContractSelect?.value || "");
+ return collateralClaimContracts.find((contract) => contract.contract === hash) || null;
+}
+
+function claimAssetLabel(asset, amount) {
+ return `${atomicToDecimal(BigInt(amount || "0"))} ${String(asset || "").trim()}`.trim();
+}
+
+function collateralClaimOptionLabel(contract) {
+ const role = String(contract.role || "").toLowerCase() === "borrower"
+ ? "reclaim"
+ : "claim";
+ return `${role} ${claimAssetLabel(contract.collateral, contract.collateral_amount)} from ${truncateMiddle(contract.contract, 8, 8)}`;
+}
+
+function populateCollateralClaimContracts() {
+ if (!collateralClaimContractSelect) {
+ return;
+ }
+ const previous = collateralClaimContractSelect.value;
+ collateralClaimContractSelect.innerHTML = "";
+ if (collateralClaimContracts.length) {
+ const placeholder = document.createElement("option");
+ placeholder.value = "";
+ placeholder.textContent = "Select claimable collateral";
+ collateralClaimContractSelect.appendChild(placeholder);
+ }
+ collateralClaimContracts.forEach((contract) => {
+ const option = document.createElement("option");
+ option.value = contract.contract;
+ option.textContent = collateralClaimOptionLabel(contract);
+ collateralClaimContractSelect.appendChild(option);
+ });
+ if (!collateralClaimContracts.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No collateral is currently claimable";
+ collateralClaimContractSelect.appendChild(option);
+ } else if ([...collateralClaimContractSelect.options].some((option) => option.value === previous)) {
+ collateralClaimContractSelect.value = previous;
+ }
+ updateCollateralClaimDetails();
+}
+
+async function loadCollateralClaimContracts(force = false) {
+ if (collateralClaimLoadPromise) {
+ return collateralClaimLoadPromise;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode || !walletLoaded || !registrationRegistered) {
+ return;
+ }
+ const key = `${activeWalletAddressShort || activeWalletAddressHex}|${broadcastNode}`;
+ if (!force && collateralClaimContractsKey === key) {
+ populateCollateralClaimContracts();
+ return;
+ }
+
+ collateralClaimLoadPromise = (async () => {
+ setCollateralClaimMessage("Loading claimable collateral...");
+ const contracts = await invoke("claimable_collateral_contracts", { broadcastNode });
+ collateralClaimContracts = Array.isArray(contracts) ? contracts : [];
+ collateralClaimContractsKey = key;
+ populateCollateralClaimContracts();
+ setCollateralClaimMessage(
+ collateralClaimContracts.length ? "" : "No collateral is currently claimable."
+ );
+ })().catch((error) => {
+ collateralClaimContracts = [];
+ populateCollateralClaimContracts();
+ setCollateralClaimMessage(String(error), "error");
+ throw error;
+ }).finally(() => {
+ collateralClaimLoadPromise = null;
+ });
+ return collateralClaimLoadPromise;
+}
+
+function updateCollateralClaimDetails() {
+ const contract = selectedCollateralClaimContract();
+ if (!contract) {
+ collateralClaimRole.textContent = "--";
+ collateralClaimReason.textContent = "--";
+ collateralClaimLender.textContent = "--";
+ collateralClaimBorrower.textContent = "--";
+ collateralClaimLoan.textContent = "--";
+ collateralClaimCollateral.textContent = "--";
+ collateralClaimConfirmed.textContent = "--";
+ collateralClaimRemaining.textContent = "--";
+ collateralClaimFeeInput.value = atomicToDecimal(COLLATERAL_CLAIM_FEE_ATOMIC);
+ return;
+ }
+
+ collateralClaimRole.textContent = contract.role === "borrower" ? "Borrower reclaim" : "Lender claim";
+ collateralClaimReason.textContent = contract.reason || "Collateral claim is currently allowed.";
+ collateralClaimLender.textContent = contract.lender;
+ collateralClaimBorrower.textContent = contract.borrower;
+ collateralClaimLoan.textContent = claimAssetLabel(contract.loan_asset, contract.loan_amount);
+ collateralClaimCollateral.textContent = claimAssetLabel(contract.collateral, contract.collateral_amount);
+ collateralClaimConfirmed.textContent = claimAssetLabel(contract.loan_asset, contract.confirmed_paid);
+ collateralClaimRemaining.textContent = claimAssetLabel(contract.loan_asset, contract.remaining_balance);
+ collateralClaimFeeInput.value = atomicToDecimal(BigInt(contract.fee || COLLATERAL_CLAIM_FEE_ATOMIC));
+}
+
+function validateCollateralClaimForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before claiming collateral.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before claiming collateral.";
+ }
+ if (!selectedCollateralClaimContract()) {
+ return "Select claimable collateral.";
+ }
+ if (baseCoinBalanceAtomic() < COLLATERAL_CLAIM_FEE_ATOMIC) {
+ return `Claiming collateral requires ${atomicToDecimal(COLLATERAL_CLAIM_FEE_ATOMIC)} ${activeBaseCoin()} for the transaction fee.`;
+ }
+ return "";
+}
+
+function collateralClaimPayload() {
+ return {
+ broadcastNode: activeBroadcastNode(),
+ contractHash: selectedCollateralClaimContract().contract
+ };
+}
+
+function setCollateralClaimButtonsDisabled(disabled) {
+ document.querySelector("[data-collateral-claim-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-collateral-claim-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+function clearCollateralClaimForm() {
+ collateralClaimContractSelect.value = "";
+ updateCollateralClaimDetails();
+}
+
+async function handleCollateralClaimAction(action) {
+ const validationError = validateCollateralClaimForm();
+ if (validationError) {
+ setCollateralClaimMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setCollateralClaimMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setCollateralClaimMessage("Signing cancelled.");
+ return;
+ }
+
+ setCollateralClaimButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setCollateralClaimMessage("Saving collateral claim transaction...");
+ const review = await invoke("save_collateral_claim_transaction", {
+ ...collateralClaimPayload(),
+ walletKey
+ });
+ clearCollateralClaimForm();
+ setCollateralClaimMessage(`Collateral claim saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ setCollateralClaimMessage("Broadcasting collateral claim...");
+ const result = await invoke("broadcast_collateral_claim_transaction", {
+ ...collateralClaimPayload(),
+ walletKey
+ });
+ await loadCollateralClaimContracts(true);
+ clearCollateralClaimForm();
+ setCollateralClaimMessage(result.response || "Collateral claim broadcast.", "success");
+ }
+ } catch (error) {
+ setCollateralClaimMessage(String(error), "error");
+ await loadCollateralClaimContracts(true).catch(() => {});
+ } finally {
+ setCollateralClaimButtonsDisabled(false);
+ }
+}
+
+function prepareCollateralClaimForm() {
+ setCollateralClaimMessage("");
+ loadCollateralClaimContracts(false).catch(() => {});
+}
+
+function resetCollateralClaimSession() {
+ collateralClaimContracts = [];
+ collateralClaimLoadPromise = null;
+ collateralClaimContractsKey = "";
+ collateralClaimContractSelect.innerHTML = "";
+ updateCollateralClaimDetails();
+ setCollateralClaimMessage("");
+}
+
+collateralClaimContractSelect?.addEventListener("change", () => {
+ setCollateralClaimMessage("");
+ updateCollateralClaimDetails();
+});
+document
+ .querySelector("[data-collateral-claim-save]")
+ ?.addEventListener("click", () => handleCollateralClaimAction("save"));
+document
+ .querySelector("[data-collateral-claim-broadcast]")
+ ?.addEventListener("click", () => handleCollateralClaimAction("broadcast"));
diff --git a/frontend/js/create_nft_form.js b/frontend/js/create_nft_form.js
new file mode 100644
index 0000000..79f271e
--- /dev/null
+++ b/frontend/js/create_nft_form.js
@@ -0,0 +1,248 @@
+const CREATE_NFT_FEE_ATOMIC = 50000000n;
+let createNftBalancesRefreshPromise = null;
+
+function setCreateNftMessage(message, type = "") {
+ setScopedTransactionMessage("Create NFT", createNftMessage, message, type);
+}
+
+function createNftSeriesValue() {
+ return Number(createNftSeriesSelect?.value || 0) === 1 ? 1 : 0;
+}
+
+function normalizeCreateNftCountInput() {
+ const isCollection = createNftSeriesValue() === 1;
+ if (createNftCountInput) {
+ createNftCountInput.disabled = !isCollection;
+ createNftCountInput.min = isCollection ? "2" : "1";
+ if (!isCollection) {
+ createNftCountInput.value = "1";
+ } else if (Number(createNftCountInput.value || 0) < 2) {
+ createNftCountInput.value = "2";
+ }
+ }
+}
+
+function updateCreateNftDerivedFields({ clampCount = false } = {}) {
+ const isCollection = createNftSeriesValue() === 1;
+ if (clampCount) {
+ normalizeCreateNftCountInput();
+ } else if (createNftCountInput) {
+ createNftCountInput.disabled = !isCollection;
+ createNftCountInput.min = isCollection ? "2" : "1";
+ }
+
+ const rawCount = String(createNftCountInput?.value || "").trim();
+ const parsedCount = Number.parseInt(rawCount, 10);
+ const countLabel = Number.isInteger(parsedCount) && parsedCount > 0 ? String(parsedCount) : "--";
+ if (createNftFeeInput) {
+ createNftFeeInput.value = tokenAtomicToDecimal(CREATE_NFT_FEE_ATOMIC);
+ }
+ if (createNftCreator) {
+ createNftCreator.textContent = activeWalletAddressShort || activeWalletAddressHex || "--";
+ }
+ if (createNftTypeLabel) {
+ createNftTypeLabel.textContent = isCollection ? "Collection" : "Standalone NFT";
+ }
+ if (createNftCountLabel) {
+ createNftCountLabel.textContent = countLabel;
+ }
+ if (createNftFeeLabel) {
+ createNftFeeLabel.textContent =
+ `${tokenAtomicToDecimal(CREATE_NFT_FEE_ATOMIC)} ${activeBaseCoin()}`;
+ }
+}
+
+function validateCreateNftForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before creating an NFT.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before creating an NFT.";
+ }
+
+ const name = String(createNftNameInput?.value || "").trim();
+ if (!name) {
+ return "NFT name is required.";
+ }
+ if (!/^[A-Za-z0-9\s]+$/.test(name)) {
+ return "NFT name can only contain letters, numbers, and spaces.";
+ }
+ const canonicalName = name.replace(/\s+/g, "").toLowerCase();
+ if (canonicalName.length < 3 || canonicalName.length > 15) {
+ return "NFT name must normalize to 3 to 15 letters or numbers.";
+ }
+ if (canonicalName.toUpperCase() === activeBaseCoin()) {
+ return "NFT name is reserved for the base coin.";
+ }
+
+ const cid = String(createNftIpfsInput?.value || "").trim();
+ if (!cid) {
+ return "IPFS CID is required.";
+ }
+ if (!/^[\x20-\x7E]+$/.test(cid) || cid.length > 100) {
+ return "IPFS CID must be an ASCII value no longer than 100 characters.";
+ }
+
+ const description = String(createNftDescriptionInput?.value || "").trim();
+ if (description && (!/^[\x20-\x7E]+$/.test(description) || description.length > 100)) {
+ return "NFT description must be ASCII and no longer than 100 characters.";
+ }
+
+ const count = Number.parseInt(createNftCountInput?.value || "0", 10);
+ if (!Number.isInteger(count) || count < 1 || count > 4294967295) {
+ return "Enter a valid NFT item count.";
+ }
+ if (createNftSeriesValue() === 0 && count !== 1) {
+ return "A standalone NFT must create exactly 1 item.";
+ }
+ if (createNftSeriesValue() === 1 && count < 2) {
+ return "An NFT collection must contain at least 2 items.";
+ }
+
+ if (baseCoinBalanceAtomic() < CREATE_NFT_FEE_ATOMIC) {
+ return `This transaction requires ${tokenAtomicToDecimal(CREATE_NFT_FEE_ATOMIC)} ${activeBaseCoin()}.`;
+ }
+ return "";
+}
+
+function createNftPayload() {
+ return {
+ series: createNftSeriesValue(),
+ nftName: String(createNftNameInput?.value || "").trim(),
+ itemIpfs: String(createNftIpfsInput?.value || "").trim(),
+ count: Number.parseInt(createNftCountInput?.value || "1", 10),
+ description: String(createNftDescriptionInput?.value || "").trim(),
+ txfee: String(CREATE_NFT_FEE_ATOMIC)
+ };
+}
+
+function clearCreateNftForm() {
+ if (createNftSeriesSelect) {
+ createNftSeriesSelect.value = "0";
+ }
+ if (createNftNameInput) {
+ createNftNameInput.value = "";
+ }
+ if (createNftIpfsInput) {
+ createNftIpfsInput.value = "";
+ }
+ if (createNftCountInput) {
+ createNftCountInput.value = "1";
+ }
+ if (createNftDescriptionInput) {
+ createNftDescriptionInput.value = "";
+ }
+ updateCreateNftDerivedFields({ clampCount: true });
+}
+
+function setCreateNftButtonsDisabled(disabled) {
+ document.querySelector("[data-create-nft-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-create-nft-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+async function handleCreateNftAction(action) {
+ if (!activeWalletBalances.length && walletLoaded && registrationRegistered) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (invoke && broadcastNode) {
+ createNftBalancesRefreshPromise ||= invoke("get_active_wallet_balances", { broadcastNode })
+ .then((balances) => {
+ activeWalletBalances = Array.isArray(balances) ? balances : [];
+ })
+ .finally(() => {
+ createNftBalancesRefreshPromise = null;
+ });
+ try {
+ await createNftBalancesRefreshPromise;
+ } catch (error) {
+ setCreateNftMessage(String(error), "error");
+ return;
+ }
+ }
+ }
+
+ const validationError = validateCreateNftForm();
+ if (validationError) {
+ setCreateNftMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setCreateNftMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setCreateNftMessage("Signing cancelled.");
+ return;
+ }
+
+ setCreateNftButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setCreateNftMessage("Saving NFT transaction...");
+ const review = await invoke("save_create_nft_transaction", {
+ ...createNftPayload(),
+ walletKey
+ });
+ clearCreateNftForm();
+ setCreateNftMessage(`NFT transaction saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ const broadcastNode = activeBroadcastNode();
+ if (!broadcastNode) {
+ throw new Error("Select a broadcast node before broadcasting.");
+ }
+ setCreateNftMessage("Broadcasting NFT transaction...");
+ const result = await invoke("broadcast_create_nft_transaction", {
+ ...createNftPayload(),
+ broadcastNode,
+ walletKey
+ });
+ if (typeof invalidateDashboardNftBalanceKeys === "function") {
+ invalidateDashboardNftBalanceKeys();
+ }
+ clearCreateNftForm();
+ setCreateNftMessage(result.response || "NFT transaction broadcast.", "success");
+ }
+ } catch (error) {
+ setCreateNftMessage(String(error), "error");
+ } finally {
+ setCreateNftButtonsDisabled(false);
+ }
+}
+
+function prepareCreateNftForm() {
+ updateCreateNftDerivedFields({ clampCount: true });
+ setCreateNftMessage("");
+}
+
+function resetCreateNftSession() {
+ createNftBalancesRefreshPromise = null;
+ clearCreateNftForm();
+ setCreateNftMessage("");
+}
+
+createNftSeriesSelect?.addEventListener("change", () => {
+ updateCreateNftDerivedFields({ clampCount: true });
+ setCreateNftMessage("");
+});
+createNftCountInput?.addEventListener("input", () => {
+ updateCreateNftDerivedFields();
+ setCreateNftMessage("");
+});
+createNftCountInput?.addEventListener("blur", () => {
+ updateCreateNftDerivedFields({ clampCount: true });
+});
+createNftNameInput?.addEventListener("input", () => setCreateNftMessage(""));
+createNftIpfsInput?.addEventListener("input", () => setCreateNftMessage(""));
+createNftDescriptionInput?.addEventListener("input", () => setCreateNftMessage(""));
+document
+ .querySelector("[data-create-nft-save]")
+ ?.addEventListener("click", () => handleCreateNftAction("save"));
+document
+ .querySelector("[data-create-nft-broadcast]")
+ ?.addEventListener("click", () => handleCreateNftAction("broadcast"));
diff --git a/frontend/js/create_token_form.js b/frontend/js/create_token_form.js
new file mode 100644
index 0000000..82d907b
--- /dev/null
+++ b/frontend/js/create_token_form.js
@@ -0,0 +1,171 @@
+const CREATE_TOKEN_FEE_ATOMIC = 50000000000n;
+const TOKEN_ATOMIC_UNITS = 100000000n;
+
+function setCreateTokenMessage(message, type = "") {
+ setScopedTransactionMessage("Create Token", createTokenMessage, message, type);
+}
+
+function tokenDecimalToAtomic(value) {
+ const text = String(value || "").trim();
+ if (!/^\d+(\.\d{0,8})?$/.test(text)) {
+ return null;
+ }
+
+ const [whole, fraction = ""] = text.split(".");
+ const paddedFraction = fraction.padEnd(8, "0");
+ return BigInt(whole || "0") * TOKEN_ATOMIC_UNITS + BigInt(paddedFraction || "0");
+}
+
+function tokenAtomicToDecimal(value) {
+ const atomic = BigInt(value || 0);
+ const whole = atomic / TOKEN_ATOMIC_UNITS;
+ const fraction = String(atomic % TOKEN_ATOMIC_UNITS).padStart(8, "0");
+ return `${whole}.${fraction}`;
+}
+
+function updateCreateTokenDerivedFields() {
+ if (createTokenFeeInput) {
+ createTokenFeeInput.value = tokenAtomicToDecimal(CREATE_TOKEN_FEE_ATOMIC);
+ }
+ if (createTokenFeeLabel) {
+ createTokenFeeLabel.textContent = `${tokenAtomicToDecimal(CREATE_TOKEN_FEE_ATOMIC)} ${activeBaseCoin()}`;
+ }
+ if (createTokenCap) {
+ createTokenCap.textContent = createTokenAllowMoreInput?.checked ? "Future issuance allowed" : "Hard capped";
+ }
+ if (createTokenCreator) {
+ createTokenCreator.textContent = activeWalletAddressShort || activeWalletAddressHex || "--";
+ }
+}
+
+function validateCreateTokenForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before creating a token.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before creating a token.";
+ }
+
+ const ticker = String(createTokenTickerInput?.value || "").trim();
+ if (!ticker) {
+ return "Token ticker is required.";
+ }
+ if (!/^[A-Za-z0-9\s]+$/.test(ticker)) {
+ return "Token ticker can only contain letters, numbers, and spaces.";
+ }
+ const canonicalTicker = ticker.replace(/\s+/g, "").toLowerCase();
+ if (canonicalTicker.length < 3 || canonicalTicker.length > 15) {
+ return "Token ticker must normalize to 3 to 15 letters or numbers.";
+ }
+ if (canonicalTicker.toUpperCase() === activeBaseCoin()) {
+ return "Token ticker is reserved for the base coin.";
+ }
+
+ const number = tokenDecimalToAtomic(createTokenNumberInput?.value);
+ if (number === null || number <= 0n) {
+ return "Enter a valid initial supply with up to 8 decimal places.";
+ }
+
+ return "";
+}
+
+function createTokenPayload() {
+ return {
+ ticker: String(createTokenTickerInput?.value || "").trim(),
+ number: String(tokenDecimalToAtomic(createTokenNumberInput?.value) || 0n),
+ allowMore: Boolean(createTokenAllowMoreInput?.checked),
+ txfee: String(CREATE_TOKEN_FEE_ATOMIC)
+ };
+}
+
+function clearCreateTokenForm() {
+ if (createTokenTickerInput) {
+ createTokenTickerInput.value = "";
+ }
+ if (createTokenNumberInput) {
+ createTokenNumberInput.value = "";
+ }
+ if (createTokenAllowMoreInput) {
+ createTokenAllowMoreInput.checked = false;
+ }
+ updateCreateTokenDerivedFields();
+}
+
+function setCreateTokenButtonsDisabled(disabled) {
+ document.querySelector("[data-create-token-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-create-token-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+async function handleCreateTokenAction(action) {
+ const error = validateCreateTokenForm();
+ if (error) {
+ setCreateTokenMessage(error, "error");
+ return;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setCreateTokenMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setCreateTokenMessage("Signing cancelled.");
+ return;
+ }
+
+ setCreateTokenButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setCreateTokenMessage("Saving token transaction...");
+ const review = await invoke("save_create_token_transaction", {
+ ...createTokenPayload(),
+ walletKey
+ });
+ clearCreateTokenForm();
+ setCreateTokenMessage(`Token transaction saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ const broadcastNode = activeBroadcastNode();
+ if (!broadcastNode) {
+ throw new Error("Select a broadcast node before broadcasting.");
+ }
+ setCreateTokenMessage("Broadcasting token transaction...");
+ const result = await invoke("broadcast_create_token_transaction", {
+ ...createTokenPayload(),
+ broadcastNode,
+ walletKey
+ });
+ if (typeof invalidateAssetsCatalog === "function") {
+ invalidateAssetsCatalog();
+ }
+ clearCreateTokenForm();
+ setCreateTokenMessage(result.response || "Token transaction broadcast.", "success");
+ }
+ } catch (error) {
+ setCreateTokenMessage(String(error), "error");
+ } finally {
+ setCreateTokenButtonsDisabled(false);
+ }
+}
+
+function prepareCreateTokenForm() {
+ updateCreateTokenDerivedFields();
+ setCreateTokenMessage("");
+}
+
+createTokenTickerInput?.addEventListener("input", () => {
+ updateCreateTokenDerivedFields();
+ setCreateTokenMessage("");
+});
+createTokenNumberInput?.addEventListener("input", () => setCreateTokenMessage(""));
+createTokenAllowMoreInput?.addEventListener("change", () => {
+ updateCreateTokenDerivedFields();
+ setCreateTokenMessage("");
+});
+document.querySelector("[data-create-token-save]")?.addEventListener("click", () => handleCreateTokenAction("save"));
+document.querySelector("[data-create-token-broadcast]")?.addEventListener("click", () => handleCreateTokenAction("broadcast"));
+
diff --git a/frontend/js/dashboard_balance_registration.js b/frontend/js/dashboard_balance_registration.js
new file mode 100644
index 0000000..8383855
--- /dev/null
+++ b/frontend/js/dashboard_balance_registration.js
@@ -0,0 +1,369 @@
+function setRecentTransactionsForWalletState(state) {
+ recentTransactionsCacheReadId += 1;
+ latestTransactionsSyncId += 1;
+ clearRecentTransactionsRows();
+ stopLatestDashboardTransactionsPolling();
+
+ if (state === "registered") {
+ setRecentTransactionsState("");
+ resetLatestDashboardTransactionsMemory();
+ updateLatestDashboardTransactionsPolling();
+ startBackgroundTransactionSync();
+ return;
+ }
+
+ stopBackgroundTransactionSync();
+ resetLatestDashboardTransactionsMemory();
+ if (state === "checking") {
+ setRecentTransactionsState("Checking address registration before loading transactions.");
+ return;
+ }
+
+ if (state === "unregistered") {
+ setRecentTransactionsState("Address registration required before transactions can appear.");
+ return;
+ }
+
+ setRecentTransactionsState("Load a wallet to view recent transactions.");
+}
+
+function resetBalances(message = "Load wallet", statusMessage = "Balances refresh while dashboard is open.") {
+ activeWalletBalances = [];
+ if (typeof refreshTransferAssetOptions === "function") {
+ refreshTransferAssetOptions();
+ }
+ if (typeof refreshActiveTransactionFormAfterWalletData === "function") {
+ refreshActiveTransactionFormAfterWalletData();
+ }
+
+ if (baseBalanceLabel) {
+ baseBalanceLabel.textContent = `${activeBaseCoin()} Balance`;
+ }
+
+ if (clcBalance) {
+ clcBalance.textContent = message;
+ }
+
+ if (tokenBalances) {
+ tokenBalances.innerHTML = `
+ Token Balances
+ No wallet loaded.
+ `;
+ }
+
+ dashboardLastBalanceStatus = "";
+ setBalanceStatus(statusMessage);
+}
+
+async function refreshDashboardBalances({ force = false, quiet = false } = {}) {
+ if (!walletLoaded || !registrationRegistered || currentView !== "dashboard" || balanceRefreshInFlight) {
+ return false;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode) {
+ return false;
+ }
+
+ balanceRefreshInFlight = true;
+ const requestId = ++balanceRefreshRequestId;
+ if (force && !quiet) {
+ setBalanceStatus("Refreshing balances...");
+ }
+
+ try {
+ const balances = await invoke("get_active_wallet_balances", {
+ broadcastNode
+ });
+ if (requestId !== balanceRefreshRequestId || !walletLoaded) {
+ return false;
+ }
+ renderBalances(balances);
+ dashboardLastBalanceStatus = `Updated ${new Date().toLocaleTimeString()}`;
+ setBalanceStatus(dashboardLastBalanceStatus, "success");
+ return true;
+ } catch (error) {
+ if (requestId !== balanceRefreshRequestId || !walletLoaded) {
+ return false;
+ }
+ setBalanceStatus(String(error), "error");
+ return false;
+ } finally {
+ if (requestId === balanceRefreshRequestId) {
+ balanceRefreshInFlight = false;
+ }
+ }
+}
+
+function startBalanceRefresh({ immediate = true } = {}) {
+ if (balanceRefreshTimer || !walletLoaded || !registrationRegistered || currentView !== "dashboard") {
+ return;
+ }
+
+ if (immediate) {
+ refreshDashboardBalances({ force: true });
+ }
+ balanceRefreshTimer = setInterval(() => {
+ refreshDashboardBalances();
+ }, BALANCE_REFRESH_MS);
+}
+
+function stopBalanceRefresh() {
+ if (balanceRefreshTimer) {
+ clearInterval(balanceRefreshTimer);
+ balanceRefreshTimer = null;
+ }
+}
+
+function updateBalanceRefreshState() {
+ if (walletLoaded && registrationRegistered && currentView === "dashboard") {
+ startBalanceRefresh();
+ return;
+ }
+
+ stopBalanceRefresh();
+}
+
+function restoreLatestDashboardTransactionsFromMemory() {
+ if (!latestDashboardTransactionRecords.size || !latestDashboardTxids.length) {
+ return false;
+ }
+
+ const latestCache = { transactions: Object.fromEntries(latestDashboardTransactionRecords) };
+ updateTransactionCacheChainStatus(latestCache);
+ latestDashboardTransactionRecords = new Map(Object.entries(latestCache.transactions));
+ renderRecentTransactions(normalizeRecentTransactionRecords(
+ transactionRecordsForTxids(latestCache, latestDashboardTxids),
+ { preserveOrder: true }
+ ));
+ setRecentTransactionsState("");
+ return true;
+}
+
+async function startRegisteredDashboardLoadSequence({ resetTransactions = false, quiet = false } = {}) {
+ const loadId = ++dashboardRegisteredLoadId;
+ stopLatestDashboardTransactionsPolling();
+ stopBalanceRefresh();
+
+ if (resetTransactions) {
+ resetLatestDashboardTransactionsMemory();
+ }
+
+ const restoredTransactions = restoreLatestDashboardTransactionsFromMemory();
+ if (!restoredTransactions && !quiet) {
+ setRecentTransactionsForWalletState("checking");
+ }
+
+ if (!walletLoaded || !registrationRegistered || currentView !== "dashboard") {
+ return;
+ }
+
+ if (dashboardLastBalanceStatus) {
+ setBalanceStatus(dashboardLastBalanceStatus, "success");
+ }
+
+ await refreshDashboardBalances({ force: true, quiet: quiet || Boolean(dashboardLastBalanceStatus) });
+ if (
+ loadId !== dashboardRegisteredLoadId ||
+ !walletLoaded ||
+ !registrationRegistered ||
+ currentView !== "dashboard"
+ ) {
+ return;
+ }
+
+ startBalanceRefresh({ immediate: false });
+ if (!restoredTransactions) {
+ setRecentTransactionsForWalletState("registered");
+ return;
+ }
+
+ updateLatestDashboardTransactionsPolling();
+ startBackgroundTransactionSync();
+}
+
+function startNetworkInfoRefresh() {
+ if (networkInfoRefreshTimer || !walletLoaded || currentView !== "dashboard") {
+ return;
+ }
+
+ refreshNetworkInfo({ target: "dashboard" });
+ networkInfoRefreshTimer = setInterval(() => {
+ refreshNetworkInfo({ target: "dashboard" });
+ }, NETWORK_INFO_REFRESH_MS);
+}
+
+function stopNetworkInfoRefresh() {
+ if (networkInfoRefreshTimer) {
+ clearInterval(networkInfoRefreshTimer);
+ networkInfoRefreshTimer = null;
+ }
+}
+
+function updateNetworkInfoRefreshState() {
+ if (walletLoaded && currentView === "dashboard") {
+ startNetworkInfoRefresh();
+ return;
+ }
+
+ stopNetworkInfoRefresh();
+}
+
+function startNodeInfoRefresh() {
+ if (nodeInfoRefreshTimer || !walletLoaded) {
+ renderNodeInfo(null);
+ return;
+ }
+
+ refreshNetworkInfo({ target: "node", force: true });
+ nodeInfoRefreshTimer = setInterval(() => {
+ refreshNetworkInfo({ target: "node", force: true });
+ }, NODE_INFO_REFRESH_MS);
+}
+
+function stopNodeInfoRefresh() {
+ if (nodeInfoRefreshTimer) {
+ clearInterval(nodeInfoRefreshTimer);
+ nodeInfoRefreshTimer = null;
+ }
+}
+
+function activeBroadcastNode() {
+ return broadcastNodeButton?.value || broadcastNodeButton?.dataset.broadcastNode || broadcastNodeButton?.textContent?.trim() || "";
+}
+
+function setRegistrationState(state) {
+ const states = ["registered", "unregistered", "checking"];
+ registrationBadge?.classList.remove(...states);
+ registrationAction?.classList.remove(...states);
+ registrationNotice?.classList.remove(...states);
+
+ if (state === "registered") {
+ registrationRegistered = true;
+ registrationBadge && (registrationBadge.textContent = "Registered");
+ registrationBadge?.classList.add("registered");
+ if (registrationNotice) {
+ registrationNotice.textContent = "Address registered. This wallet can receive coins and tokens.";
+ registrationNotice.classList.add("registered");
+ }
+ if (registrationAction) {
+ registrationAction.textContent = "Address Registered";
+ registrationAction.disabled = true;
+ registrationAction.classList.add("registered");
+ }
+ startRegisteredDashboardLoadSequence();
+ updateHistoryRefreshState();
+ updateNetworkInfoRefreshState();
+ refreshReceivePage();
+ if (typeof refreshActiveTransactionFormAfterWalletData === "function") {
+ refreshActiveTransactionFormAfterWalletData();
+ }
+ return;
+ }
+
+ if (state === "checking") {
+ registrationBadge && (registrationBadge.textContent = "Checking");
+ registrationBadge?.classList.add("checking");
+ if (registrationNotice) {
+ registrationNotice.textContent = "Checking whether this address can receive coins and tokens.";
+ registrationNotice.classList.add("checking");
+ }
+ if (registrationAction) {
+ registrationAction.textContent = "Checking...";
+ registrationAction.disabled = true;
+ registrationAction.classList.add("checking");
+ }
+ dashboardRegisteredLoadId += 1;
+ stopBalanceRefresh();
+ setRecentTransactionsForWalletState("checking");
+ updateHistoryRefreshState();
+ refreshReceivePage();
+ return;
+ }
+
+ registrationRegistered = false;
+ registrationBadge && (registrationBadge.textContent = "Unregistered");
+ registrationBadge?.classList.add("unregistered");
+ if (registrationNotice) {
+ registrationNotice.textContent = "Address must be registered before this wallet can receive coins or tokens.";
+ registrationNotice.classList.add("unregistered");
+ }
+ if (registrationAction) {
+ registrationAction.textContent = "Register Address";
+ registrationAction.disabled = false;
+ registrationAction.classList.add("unregistered");
+ }
+ dashboardRegisteredLoadId += 1;
+ stopBalanceRefresh();
+ setRecentTransactionsForWalletState("unregistered");
+ updateHistoryRefreshState();
+ updateNetworkInfoRefreshState();
+ refreshReceivePage();
+}
+
+async function checkWalletRegistrationOnce() {
+ if (!walletLoaded || registrationRegistered || registrationCheckInFlight) {
+ return;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode) {
+ setRegistrationState("unregistered");
+ return;
+ }
+
+ registrationCheckInFlight = true;
+ const requestId = ++registrationRequestId;
+ setRegistrationState("checking");
+ try {
+ const status = await invoke("check_wallet_registration", { broadcastNode });
+ if (requestId !== registrationRequestId || !walletLoaded) {
+ return;
+ }
+ setRegistrationState(status?.registered ? "registered" : "unregistered");
+ } catch (_) {
+ if (requestId !== registrationRequestId || !walletLoaded) {
+ return;
+ }
+ setRegistrationState("unregistered");
+ } finally {
+ if (requestId === registrationRequestId) {
+ registrationCheckInFlight = false;
+ }
+ }
+}
+
+async function registerActiveWallet() {
+ if (!walletLoaded || registrationRegistered || registrationCheckInFlight) {
+ return;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode) {
+ setRegistrationState("unregistered");
+ return;
+ }
+
+ registrationCheckInFlight = true;
+ const requestId = ++registrationRequestId;
+ setRegistrationState("checking");
+ try {
+ const status = await invoke("register_active_wallet", { broadcastNode });
+ if (requestId !== registrationRequestId || !walletLoaded) {
+ return;
+ }
+ setRegistrationState(status?.registered ? "registered" : "unregistered");
+ } catch (_) {
+ if (requestId !== registrationRequestId || !walletLoaded) {
+ return;
+ }
+ setRegistrationState("unregistered");
+ } finally {
+ if (requestId === registrationRequestId) {
+ registrationCheckInFlight = false;
+ }
+ }
+}
diff --git a/frontend/js/dashboard_network.js b/frontend/js/dashboard_network.js
new file mode 100644
index 0000000..27bf65c
--- /dev/null
+++ b/frontend/js/dashboard_network.js
@@ -0,0 +1,284 @@
+function renderDashboardNetworkInfo(info) {
+ if (!info || typeof info !== "object") {
+ return;
+ }
+
+ latestKnownBlockHeight = Number(info.height || latestKnownBlockHeight || 0);
+ setBridgeStatus(`${networkDisplayName(info)} connected`, "success");
+ networkInfoHeight && (networkInfoHeight.textContent = formatNumber(info.height));
+ networkInfoNetwork && (networkInfoNetwork.textContent = networkDisplayName(info));
+ networkInfoDifficulty && (networkInfoDifficulty.textContent = formatNumber(info.next_block_difficulty));
+ networkInfoMempool && (networkInfoMempool.textContent = formatNumber(info.total_mempool_transactions));
+ networkInfoChainTx && (networkInfoChainTx.textContent = formatNumber(info.total_block_transactions));
+}
+
+function renderNodeInfo(info, checkedAt = new Date()) {
+ const broadcastNode = activeBroadcastNode();
+ nodeInfoNode && (nodeInfoNode.textContent = broadcastNode || "--");
+
+ if (!info || typeof info !== "object") {
+ nodeInfoHeight && (nodeInfoHeight.textContent = "--");
+ nodeInfoTime && (nodeInfoTime.textContent = "--");
+ nodeInfoLastChecked && (nodeInfoLastChecked.textContent = "--");
+ nodeInfoLargestFee && (nodeInfoLargestFee.textContent = "--");
+ return;
+ }
+
+ nodeInfoHeight && (nodeInfoHeight.textContent = formatNumber(info.height));
+ nodeInfoTime && (nodeInfoTime.textContent = formatNetworkTime(info.time));
+ nodeInfoLastChecked && (nodeInfoLastChecked.textContent = checkedAt.toLocaleTimeString());
+ nodeInfoLargestFee && (nodeInfoLargestFee.textContent = formatLargestFee(info.largest_tx_fee));
+}
+
+function resetNetworkInfoDisplays() {
+ const networkName = activeNetwork === "mainnet" ? "Mainnet" : "Testnet";
+ networkInfoHeight && (networkInfoHeight.textContent = "--");
+ networkInfoNetwork && (networkInfoNetwork.textContent = `${networkName} / ${activeBaseCoin()}`);
+ networkInfoDifficulty && (networkInfoDifficulty.textContent = "--");
+ networkInfoMempool && (networkInfoMempool.textContent = "--");
+ networkInfoChainTx && (networkInfoChainTx.textContent = "--");
+ setBridgeStatus(`${networkName} disconnected`, "error");
+ renderNodeInfo(null);
+}
+
+async function refreshNetworkInfo({ target = "dashboard", force = false } = {}) {
+ if (!walletLoaded) {
+ renderNodeInfo(null);
+ setBridgeStatus(`${activeNetwork === "mainnet" ? "Mainnet" : "Testnet"} disconnected`, "error");
+ return null;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode) {
+ setBridgeStatus(`${activeNetwork === "mainnet" ? "Mainnet" : "Testnet"} unavailable`, "error");
+ return null;
+ }
+
+ if (target === "node" && nodeInfoRefreshInFlight) {
+ return null;
+ }
+ if (target !== "node" && networkInfoRefreshInFlight) {
+ return null;
+ }
+
+ if (target === "node") {
+ nodeInfoRefreshInFlight = true;
+ } else {
+ networkInfoRefreshInFlight = true;
+ }
+
+ try {
+ const info = await invokeWalletRpcWithBackoff(
+ "Network info lookup",
+ () => invoke("network_info", { broadcastNode }),
+ () => walletLoaded && activeBroadcastNode() === broadcastNode
+ );
+ const checkedAt = new Date();
+ renderDashboardNetworkInfo(info);
+ if (target === "node" || force) {
+ renderNodeInfo(info, checkedAt);
+ }
+ return info;
+ } catch (error) {
+ setBridgeStatus(`${activeNetwork === "mainnet" ? "Mainnet" : "Testnet"} disconnected`, "error");
+ if (target === "node") {
+ nodeInfoLastChecked && (nodeInfoLastChecked.textContent = String(error));
+ }
+ return null;
+ } finally {
+ if (target === "node") {
+ nodeInfoRefreshInFlight = false;
+ } else {
+ networkInfoRefreshInFlight = false;
+ }
+ }
+}
+
+function sleepMs(ms) {
+ return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function walletRpcBackoffDelay(attempt) {
+ return Math.min(WALLET_RPC_BACKOFF_BASE_MS * 2 ** Math.max(0, attempt - 1), WALLET_RPC_BACKOFF_MAX_MS);
+}
+
+async function invokeWalletRpcWithBackoff(label, operation, shouldContinue = () => true) {
+ let lastError = null;
+
+ for (let attempt = 1; attempt <= WALLET_RPC_RETRY_LIMIT; attempt += 1) {
+ if (!shouldContinue()) {
+ throw new Error(`${label} cancelled`);
+ }
+
+ try {
+ return await operation();
+ } catch (error) {
+ lastError = error;
+ if (attempt >= WALLET_RPC_RETRY_LIMIT || !shouldContinue()) {
+ break;
+ }
+ await sleepMs(walletRpcBackoffDelay(attempt));
+ }
+ }
+
+ throw lastError || new Error(`${label} failed`);
+}
+
+function bytesToHex(bytes) {
+ return Array.from(bytes || [])
+ .map((byte) => Number(byte).toString(16).padStart(2, "0"))
+ .join("");
+}
+
+function bytesToText(bytes) {
+ return String.fromCharCode(...Array.from(bytes || [])).trim();
+}
+
+function readU32LE(bytes, offset) {
+ return (
+ Number(bytes[offset] || 0) |
+ (Number(bytes[offset + 1] || 0) << 8) |
+ (Number(bytes[offset + 2] || 0) << 16) |
+ (Number(bytes[offset + 3] || 0) << 24)
+ ) >>> 0;
+}
+
+function readU64LE(bytes, offset) {
+ let value = 0n;
+ for (let index = 7; index >= 0; index -= 1) {
+ value = (value << 8n) + BigInt(Number(bytes[offset + index] || 0));
+ }
+ return value;
+}
+
+function formatAtomicValue(value) {
+ const atomic = typeof value === "bigint" ? value : BigInt(value || 0);
+ const whole = atomic / 100000000n;
+ const fraction = atomic % 100000000n;
+ const fractionText = fraction.toString().padStart(8, "0").replace(/0+$/, "");
+ return fractionText ? `${whole}.${fractionText}` : whole.toString();
+}
+
+function bytesToAddressHex(bytes) {
+ return bytesToHex(bytes).toLowerCase();
+}
+
+function addressLabel(addressHex) {
+ return addressHex ? `${addressHex.slice(0, 8)}...${addressHex.slice(-8)}` : "Unknown";
+}
+
+function isActiveAddress(addressHex) {
+ return Boolean(addressHex && activeWalletAddressHex && addressHex.toLowerCase() === activeWalletAddressHex.toLowerCase());
+}
+
+function isActiveShortAddress(address) {
+ return Boolean(address && activeWalletAddressShort && String(address).trim().toLowerCase() === activeWalletAddressShort.toLowerCase());
+}
+
+function isActiveWalletAddress(address) {
+ const clean = String(address || "").trim().toLowerCase();
+ if (!clean) {
+ return false;
+ }
+ return clean.includes(".") ? isActiveShortAddress(clean) : isActiveAddress(clean);
+}
+
+function assetWithSeries(asset, series) {
+ const cleanAsset = (asset || "").trim() || activeBaseCoin();
+ return Number(series || 0) > 0 ? `${cleanAsset} #${series}` : cleanAsset;
+}
+
+function signedAmount(sign, value) {
+ const formatted = formatAtomicValue(value);
+ if (!formatted || formatted === "0") {
+ return formatted;
+ }
+ return `${sign}${formatted}`;
+}
+
+function signedBaseFee(sign, value) {
+ const amount = signedAmount(sign, value);
+ return amount && amount !== "0" ? `${amount} ${activeBaseCoin()}` : "--";
+}
+
+function statusForBlock(blockHeight, currentHeight = latestKnownBlockHeight) {
+ if (!currentHeight || !blockHeight || currentHeight < blockHeight) {
+ return "Pending";
+ }
+ return currentHeight - blockHeight >= CONFIRMED_AFTER_BLOCKS ? "Confirmed" : "Pending";
+}
+
+function walletStatusForBlock(blockHeight, currentHeight = latestKnownBlockHeight) {
+ const height = Number(blockHeight || 0);
+ if (!height) {
+ return "Unconfirmed";
+ }
+ return statusForBlock(height, currentHeight);
+}
+
+function blockValueFromRecord(record) {
+ const block = record?.block ?? record?.block_height ?? record?.blockHeight ?? null;
+ const numeric = Number(block || 0);
+ return numeric > 0 ? numeric : null;
+}
+
+function dashboardRow(base, type, asset, counterparty, amount, fee = "--") {
+ return {
+ ...base,
+ type,
+ asset,
+ counterparty,
+ amount,
+ fee
+ };
+}
+
+function txTypeName(type) {
+ return {
+ 0: "Genesis",
+ 1: "Reward",
+ 2: "Transfer",
+ 3: "Create Token",
+ 4: "Create NFT",
+ 5: "Marketing",
+ 6: "Swap",
+ 7: "Create Loan",
+ 8: "Loan Payment",
+ 9: "Collateral Claim",
+ 10: "Burn",
+ 11: "Issue Token",
+ 12: "Vanity Address"
+ }[type] || "Transaction";
+}
+
+function parseLoanContractSummary(transaction) {
+ if (transaction && typeof transaction === "object" && !Array.isArray(transaction)) {
+ const unsigned = transaction.unsigned_loan_contract;
+ if (!unsigned) {
+ return null;
+ }
+ return {
+ loanCoin: unsigned.loan_coin || "Loan",
+ loanAmount: unsigned.loan_amount || 0,
+ lender: unsigned.lender || "",
+ collateral: unsigned.collateral || "Collateral",
+ collateralAmount: unsigned.collateral_amount || 0,
+ borrower: unsigned.borrower || ""
+ };
+ }
+
+ const bytes = Array.from(transaction || []);
+ if (Number(bytes[0] || 0) !== 7) {
+ return null;
+ }
+ return {
+ loanCoin: bytesToText(bytes.slice(5, 20)) || "Loan",
+ loanAmount: readU64LE(bytes, 20),
+ lender: bytesToAddressHex(bytes.slice(28, 50)),
+ collateral: bytesToText(bytes.slice(50, 71)) || "Collateral",
+ collateralAmount: readU64LE(bytes, 71),
+ borrower: bytesToAddressHex(bytes.slice(79, 101))
+ };
+}
+
diff --git a/frontend/js/history_page.js b/frontend/js/history_page.js
new file mode 100644
index 0000000..87436dc
--- /dev/null
+++ b/frontend/js/history_page.js
@@ -0,0 +1,639 @@
+function setHistoryState(message, mode = "") {
+ if (!historyState) {
+ return;
+ }
+
+ historyState.textContent = message;
+ historyState.classList.toggle("hidden", !message);
+ historyState.classList.toggle("loading", mode === "loading");
+}
+
+function clearHistoryRows() {
+ if (historyTransactionsBody) {
+ historyTransactionsBody.innerHTML = "";
+ }
+ if (historyCards) {
+ historyCards.innerHTML = "";
+ }
+}
+
+function setHistoryFooter(
+ visibleCount = 0,
+ totalCount = 0,
+ overallCount = totalCount,
+ searchTerm = "",
+ page = 1,
+ totalPages = 1,
+ pageStart = 0
+) {
+ if (historyCount) {
+ const normalizedSearchTerm = String(searchTerm || "").trim();
+ const rangeStart = visibleCount ? pageStart + 1 : 0;
+ const rangeEnd = pageStart + visibleCount;
+ if (normalizedSearchTerm && overallCount !== totalCount) {
+ historyCount.textContent = totalCount
+ ? `Showing ${formatNumber(rangeStart)}-${formatNumber(rangeEnd)} of ${formatNumber(totalCount)} matches (${formatNumber(overallCount)} total)`
+ : `No matches (${formatNumber(overallCount)} total)`;
+ } else {
+ historyCount.textContent = totalCount
+ ? `Showing ${formatNumber(rangeStart)}-${formatNumber(rangeEnd)} of ${formatNumber(totalCount)}`
+ : "";
+ }
+ }
+ if (historyPagination) {
+ historyPagination.hidden = totalPages <= 1;
+ historyPagination.querySelectorAll("[data-history-page]").forEach((button) => {
+ const action = button.dataset.historyPage;
+ button.disabled = action === "first" || action === "previous"
+ ? page <= 1
+ : page >= totalPages;
+ });
+ }
+ if (historyPageInput) {
+ historyPageInput.value = String(page);
+ historyPageInput.max = String(Math.max(1, totalPages));
+ historyPageInput.disabled = totalPages <= 1;
+ }
+ if (historyPageTotal) {
+ historyPageTotal.textContent = formatNumber(Math.max(1, totalPages));
+ }
+}
+
+function normalizedHistorySearchTerm(value) {
+ return String(value || "").trim().toLowerCase();
+}
+
+function compactHistorySearchText(value) {
+ return normalizedHistorySearchTerm(value).replace(/[\s_-]+/g, "");
+}
+
+function historyTypeSearchLabels(type) {
+ const numeric = Number(type || 0);
+ const key = txTypeKey(numeric);
+ const aliases = {
+ 0: ["genesis"],
+ 1: ["reward", "mining reward"],
+ 2: ["transfer", "transfer in", "transfer out"],
+ 3: ["token create", "create token"],
+ 4: ["nft create", "create nft"],
+ 5: ["marketing"],
+ 6: ["swap"],
+ 7: ["loan create", "loan contract"],
+ 8: ["loan payment", "contract payment"],
+ 9: ["collateral claim"],
+ 10: ["burn"],
+ 11: ["token issue", "issue token"],
+ 12: ["vanity", "vanity address"]
+ };
+ return [String(numeric), key, key.replace(/_/g, " "), ...(aliases[numeric] || [])];
+}
+
+function historyTransactionMatchesSearch(index, txid, searchTerm) {
+ const term = normalizedHistorySearchTerm(searchTerm);
+ if (!term) {
+ return true;
+ }
+
+ const compactTerm = compactHistorySearchText(term);
+ if (String(txid || "").toLowerCase().includes(term)) {
+ return true;
+ }
+
+ const type = Number(index?.txid_to_type?.[txid] ?? 0);
+ return historyTypeSearchLabels(type).some((label) => {
+ const normalized = normalizedHistorySearchTerm(label);
+ return normalized.includes(term) || compactHistorySearchText(normalized).includes(compactTerm);
+ });
+}
+
+function historyTxidsForSearch(index, orderedTxids, searchTerm) {
+ const term = normalizedHistorySearchTerm(searchTerm);
+ if (!term) {
+ return orderedTxids;
+ }
+ return orderedTxids.filter((txid) => historyTransactionMatchesSearch(index, txid, term));
+}
+
+function historyExportRows(transactions) {
+ return transactions.map((transaction) => ({
+ date: formatHistoryDate(transaction.timestamp),
+ timestamp: Number(transaction.timestamp || 0),
+ type: recentTransactionField(transaction, ["type", "tx_type", "transactionType"], "Transaction"),
+ asset: recentTransactionField(transaction, ["asset", "coin", "token"], activeBaseCoin()),
+ counterparty: recentTransactionField(transaction, ["counterparty", "to", "from", "address"], ""),
+ status: recentTransactionField(transaction, ["status"], "Pending"),
+ amount: recentTransactionField(transaction, ["amount", "value", "display_amount"], ""),
+ fee: recentTransactionField(transaction, ["fee", "txfee", "display_fee"], "--"),
+ txid: recentTransactionField(transaction, ["txid"], ""),
+ block: Number(transaction.block_height || transaction.blockHeight || transaction.height || 0) || null
+ }));
+}
+
+function csvCell(value) {
+ const text = value === null || value === undefined ? "" : String(value);
+ return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+function historyRowsToCsv(rows) {
+ const headers = ["date", "timestamp", "type", "asset", "counterparty", "status", "amount", "fee", "txid", "block"];
+ return [
+ headers.join(","),
+ ...rows.map((row) => headers.map((header) => csvCell(row[header])).join(","))
+ ].join("\r\n");
+}
+
+function xmlEscape(value) {
+ return String(value ?? "")
+ .replace(/&/g, "&")
+ .replace(//g, ">")
+ .replace(/"/g, """)
+ .replace(/'/g, "'");
+}
+
+function historyRowsToXml(rows) {
+ const body = rows.map((row) => `
+ ${xmlEscape(row.date)}
+ ${xmlEscape(row.timestamp)}
+ ${xmlEscape(row.type)}
+ ${xmlEscape(row.asset)}
+ ${xmlEscape(row.counterparty)}
+ ${xmlEscape(row.status)}
+ ${xmlEscape(row.amount)}
+ ${xmlEscape(row.fee)}
+ ${xmlEscape(row.txid)}
+ ${xmlEscape(row.block ?? "")}
+ `).join("\n");
+ return `\n\n${body}\n \n`;
+}
+
+function historyRowsToExport(rows, format) {
+ const normalizedFormat = String(format || "").toLowerCase();
+ if (normalizedFormat === "json") {
+ return JSON.stringify({
+ exported_at: new Date().toISOString(),
+ address: activeWalletAddressShort || activeWalletAddressHex || "",
+ transactions: rows
+ }, null, 2);
+ }
+ if (normalizedFormat === "xml") {
+ return historyRowsToXml(rows);
+ }
+ if (normalizedFormat === "csv") {
+ return historyRowsToCsv(rows);
+ }
+ throw new Error("Unsupported export format.");
+}
+
+function setHistoryExportMessage(message, mode = "") {
+ if (!historyExportMessage) {
+ return;
+ }
+ historyExportMessage.textContent = message;
+ historyExportMessage.classList.toggle("error", mode === "error");
+ historyExportMessage.classList.toggle("success", mode === "success");
+}
+
+function toggleHistoryExportModal(open) {
+ if (!historyExportModal) {
+ return;
+ }
+ historyExportModal.classList.toggle("hidden", !open);
+ if (open) {
+ setHistoryExportMessage("");
+ }
+}
+
+async function exportFullHistory(format) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke || !walletLoaded || !registrationRegistered) {
+ setHistoryExportMessage("Load a registered wallet before exporting history.", "error");
+ return;
+ }
+
+ const normalizedFormat = String(format || "").toLowerCase();
+ const walletToken = activeWalletCacheToken();
+ setHistoryExportMessage("Preparing export. This may take several minutes.");
+ historyExportFormatButtons.forEach((button) => {
+ button.disabled = true;
+ });
+
+ try {
+ const cache = await readTransactionCacheObject(walletToken);
+ if (!isActiveWalletCacheToken(walletToken)) {
+ throw new Error("Wallet changed before export completed.");
+ }
+ const rows = historyExportRows(normalizeHistoryTransactions(cache));
+ if (!rows.length) {
+ throw new Error("No local transaction history is available to export.");
+ }
+
+ const contents = historyRowsToExport(rows, normalizedFormat);
+ const address = activeWalletAddressShort || activeWalletAddressHex || "address";
+ const safeAddress = String(address).replace(/[^a-z0-9._-]/gi, "_");
+ const savedPath = await invoke("save_history_export", {
+ defaultFileName: `${safeAddress}-history.${normalizedFormat}`,
+ format: normalizedFormat,
+ contents
+ });
+
+ if (savedPath) {
+ setHistoryExportMessage(`Saved to ${savedPath}`, "success");
+ } else {
+ setHistoryExportMessage("Export cancelled.");
+ }
+ } catch (error) {
+ setHistoryExportMessage(String(error), "error");
+ } finally {
+ historyExportFormatButtons.forEach((button) => {
+ button.disabled = false;
+ });
+ }
+}
+
+function historyTransactionTimestamp(record) {
+ const transaction = record?.transaction;
+ if (Array.isArray(transaction)) {
+ const timestamp = Number(readU32LE(transaction, 1));
+ return Number.isFinite(timestamp) && timestamp > 0 ? timestamp : 0;
+ }
+
+ const candidates = [
+ transaction?.unsigned?.timestamp,
+ transaction?.unsigned?.time,
+ transaction?.unsigned_transfer?.timestamp,
+ transaction?.unsigned_transfer?.time,
+ transaction?.unsigned_create_token?.timestamp,
+ transaction?.unsigned_create_token?.time,
+ transaction?.unsigned_create_nft?.timestamp,
+ transaction?.unsigned_create_nft?.time,
+ transaction?.unsigned_marketing?.timestamp,
+ transaction?.unsigned_marketing?.time,
+ transaction?.unsigned_swap?.timestamp,
+ transaction?.unsigned_swap?.time,
+ transaction?.unsigned_loan_contract?.timestamp,
+ transaction?.unsigned_loan_contract?.time,
+ transaction?.unsigned_contract_payment?.timestamp,
+ transaction?.unsigned_contract_payment?.time,
+ transaction?.unsigned_collateral_claim?.timestamp,
+ transaction?.unsigned_collateral_claim?.time,
+ transaction?.unsigned_burn?.timestamp,
+ transaction?.unsigned_burn?.time,
+ transaction?.unsigned_issue_token?.timestamp,
+ transaction?.unsigned_issue_token?.time,
+ transaction?.unsigned_vanity_address?.timestamp,
+ transaction?.unsigned_vanity_address?.time
+ ];
+ const timestamp = candidates.map(Number).find((value) => Number.isFinite(value) && value > 0);
+ return timestamp || 0;
+}
+
+function formatHistoryDate(timestamp) {
+ const numeric = Number(timestamp || 0);
+ if (!numeric) {
+ return "--";
+ }
+
+ return new Date(numeric * 1000).toLocaleString();
+}
+
+function historyStatusClass(status) {
+ return String(status || "").trim().toLowerCase() === "confirmed" ? "confirmed" : "pending";
+}
+
+function historyBlockLabel(block) {
+ const numeric = Number(block || 0);
+ return numeric > 0 ? formatNumber(numeric) : "Pending";
+}
+
+function normalizeHistoryTransactions(cache) {
+ const normalized = normalizeTransactionCache(cache);
+ const orderedTxids = normalizeOrderedTxids(normalized);
+ const records = transactionRecordsForTxids(normalized, orderedTxids);
+
+ return records
+ .flatMap((record, recordIndex) => {
+ const repaired = repairCachedTransactionRecord(record.txid, record);
+ const block = blockValueFromRecord(repaired);
+ const timestamp = historyTransactionTimestamp(repaired);
+ const status = repaired.status || walletStatusForBlock(block);
+ return parseDashboardTransactionRows(
+ repaired.txid,
+ block,
+ repaired.transaction,
+ repaired.linked_transactions || {},
+ repaired.miner_earnings || []
+ ).map((row, rowIndex) => ({
+ ...row,
+ txid: row.txid || repaired.txid,
+ block_height: row.block_height ?? block,
+ status,
+ timestamp,
+ __order: recordIndex + rowIndex / 1000
+ }));
+ })
+ .sort((left, right) => {
+ const leftPending = historyStatusClass(left.status) === "pending" ? 1 : 0;
+ const rightPending = historyStatusClass(right.status) === "pending" ? 1 : 0;
+ if (rightPending !== leftPending) {
+ return rightPending - leftPending;
+ }
+
+ const leftBlock = Number(left.block_height || 0);
+ const rightBlock = Number(right.block_height || 0);
+ if (rightBlock !== leftBlock) {
+ return rightBlock - leftBlock;
+ }
+
+ const leftTimestamp = Number(left.timestamp || 0);
+ const rightTimestamp = Number(right.timestamp || 0);
+ if (rightTimestamp !== leftTimestamp) {
+ return rightTimestamp - leftTimestamp;
+ }
+
+ return right.__order - left.__order;
+ })
+ .map(({ __order: _order, ...transaction }) => transaction);
+}
+
+function renderHistoryTransactions(transactions) {
+ clearHistoryRows();
+
+ if (!historyTransactionsBody || !historyCards) {
+ return;
+ }
+
+ transactions.forEach((transaction) => {
+ const type = recentTransactionField(transaction, ["type", "tx_type", "transactionType"], "Transaction");
+ const asset = recentTransactionField(transaction, ["asset", "coin", "token"], activeBaseCoin());
+ const counterparty = recentTransactionField(transaction, ["counterparty", "to", "from", "address"], shortenAddress(transaction.txid));
+ const status = recentTransactionField(transaction, ["status"], "Pending");
+ const amount = recentTransactionField(transaction, ["amount", "value", "display_amount"], "");
+ const fee = recentTransactionField(transaction, ["fee", "txfee", "display_fee"], "--");
+ const txid = recentTransactionField(transaction, ["txid"], "");
+ const block = historyBlockLabel(recentTransactionField(transaction, ["block_height", "blockHeight", "height"], "0"));
+ const date = formatHistoryDate(transaction.timestamp);
+ const statusClass = historyStatusClass(status);
+ const shortTxid = shortenAddress(txid);
+
+ const row = document.createElement("tr");
+ row.innerHTML = `
+
+ Load a wallet first ';
+ }
+ clearIssueTokenForm();
+ setIssueTokenMessage("");
+}
+
+issueTokenTickerSelect?.addEventListener("change", refreshIssueTokenEligibility);
+issueTokenNumberInput?.addEventListener("input", () => {
+ if (issueTokenEligibility?.eligible) {
+ setIssueTokenMessage("");
+ }
+});
+document
+ .querySelector("[data-issue-token-save]")
+ ?.addEventListener("click", () => handleIssueTokenAction("save"));
+document
+ .querySelector("[data-issue-token-broadcast]")
+ ?.addEventListener("click", () => handleIssueTokenAction("broadcast"));
diff --git a/frontend/js/loan_offer_form.js b/frontend/js/loan_offer_form.js
new file mode 100644
index 0000000..e6b44bd
--- /dev/null
+++ b/frontend/js/loan_offer_form.js
@@ -0,0 +1,465 @@
+const LOAN_FEE_ATOMIC = 300000000n;
+let loanOfferLoadPromise = null;
+let loanCollateralAssets = [];
+let loanNftKeys = new Set();
+let loanOfferAssetsKey = "";
+
+function setLoanOfferMessage(message, type = "") {
+ setScopedTransactionMessage("Create Loan", loanOfferMessage, message, type);
+}
+
+function loanNftKey(asset, series) {
+ return `${String(asset || "").trim().toLowerCase()}|${Number(series || 0)}`;
+}
+
+function selectedLoanAsset() {
+ const option = loanAssetSelect?.selectedOptions?.[0];
+ if (!option?.value) {
+ return null;
+ }
+ return {
+ asset: option.dataset.asset || "",
+ balance: BigInt(option.dataset.balance || "0")
+ };
+}
+
+function selectedLoanCollateral() {
+ const option = loanCollateralSelect?.selectedOptions?.[0];
+ if (!option?.value) {
+ return null;
+ }
+ return {
+ asset: option.dataset.asset || "",
+ kind: option.dataset.kind || "token",
+ series: Number(option.dataset.series || 0),
+ wireName: option.dataset.wireName || option.dataset.asset || ""
+ };
+}
+
+function loanLocalInputValue(timestampMs) {
+ const date = new Date(timestampMs);
+ const pad = (value) => String(value).padStart(2, "0");
+ return [
+ date.getFullYear(),
+ "-",
+ pad(date.getMonth() + 1),
+ "-",
+ pad(date.getDate()),
+ "T",
+ pad(date.getHours()),
+ ":",
+ pad(date.getMinutes())
+ ].join("");
+}
+
+function loanStartTimestamp() {
+ const value = String(loanStartInput?.value || "");
+ const match = value.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/);
+ if (!match) {
+ return null;
+ }
+ const timestamp = new Date(
+ Number(match[1]),
+ Number(match[2]) - 1,
+ Number(match[3]),
+ Number(match[4]),
+ Number(match[5]),
+ 0
+ ).getTime();
+ if (!Number.isFinite(timestamp) || timestamp < 0) {
+ return null;
+ }
+ return Math.floor(timestamp / 1000);
+}
+
+function populateLoanAssetSelect() {
+ if (!loanAssetSelect) {
+ return;
+ }
+ const previous = loanAssetSelect.value;
+ const assets = (Array.isArray(activeWalletBalances) ? activeWalletBalances : [])
+ .filter((balance) => {
+ const asset = String(balance.asset || "").trim();
+ const series = Number(balance.nft_series || 0);
+ return asset
+ && balanceAtomicValue(balance) > 0n
+ && !loanNftKeys.has(loanNftKey(asset, series));
+ })
+ .sort((left, right) => String(left.asset).localeCompare(String(right.asset)));
+
+ loanAssetSelect.innerHTML = "";
+ assets.forEach((balance) => {
+ const option = document.createElement("option");
+ option.value = String(balance.asset || "").trim();
+ option.textContent =
+ `${option.value} (${formatAtomicBalance(String(balance.balance || "0"))})`;
+ option.dataset.asset = option.value;
+ option.dataset.balance = String(balance.balance || "0");
+ loanAssetSelect.appendChild(option);
+ });
+ if (!assets.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = walletLoaded ? "No lendable assets available" : "Load a wallet first";
+ loanAssetSelect.appendChild(option);
+ } else if ([...loanAssetSelect.options].some((option) => option.value === previous)) {
+ loanAssetSelect.value = previous;
+ }
+}
+
+function populateLoanCollateralSelect() {
+ if (!loanCollateralSelect) {
+ return;
+ }
+ const previous = loanCollateralSelect.value;
+ loanCollateralSelect.innerHTML = "";
+ loanCollateralAssets.forEach((asset) => {
+ const option = document.createElement("option");
+ option.value = `${asset.kind}|${asset.wireName}`;
+ option.textContent = asset.label;
+ option.dataset.asset = asset.asset;
+ option.dataset.kind = asset.kind;
+ option.dataset.series = String(asset.series || 0);
+ option.dataset.wireName = asset.wireName;
+ loanCollateralSelect.appendChild(option);
+ });
+ if (!loanCollateralAssets.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No collateral assets available";
+ loanCollateralSelect.appendChild(option);
+ } else if ([...loanCollateralSelect.options].some((option) => option.value === previous)) {
+ loanCollateralSelect.value = previous;
+ }
+}
+
+function refreshLoanOfferSelects() {
+ populateLoanAssetSelect();
+ populateLoanCollateralSelect();
+ updateLoanOfferDerivedFields();
+}
+
+async function loadLoanOfferAssets() {
+ if (loanOfferLoadPromise) {
+ return loanOfferLoadPromise;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode || !walletLoaded || !registrationRegistered) {
+ return;
+ }
+ const key = `${activeWalletAddressShort || activeWalletAddressHex}|${broadcastNode}`;
+ if (loanOfferAssetsKey === key && loanCollateralAssets.length) {
+ refreshLoanOfferSelects();
+ return;
+ }
+
+ loanOfferLoadPromise = (async () => {
+ setLoanOfferMessage("Loading loan assets...");
+ const [balances, tokens, nfts] = await Promise.all([
+ activeWalletBalances.length
+ ? Promise.resolve(activeWalletBalances)
+ : invoke("get_active_wallet_balances", { broadcastNode }),
+ invoke("token_list", { broadcastNode }),
+ invoke("nft_list", { broadcastNode })
+ ]);
+ activeWalletBalances = Array.isArray(balances) ? balances : [];
+ const tokenRows = Array.isArray(tokens) ? tokens : [];
+ const nftRows = Array.isArray(nfts) ? nfts : [];
+ loanNftKeys = new Set(nftRows.map((nft) => loanNftKey(nft.nft_name, nft.series)));
+
+ loanCollateralAssets = [
+ {
+ asset: activeBaseCoin(),
+ wireName: activeBaseCoin(),
+ series: 0,
+ kind: "coin",
+ label: `${activeBaseCoin()} (Base Coin)`
+ },
+ ...tokenRows
+ .filter((token) => {
+ return String(token.ticker || "").trim().toLowerCase()
+ !== activeBaseCoin().toLowerCase();
+ })
+ .map((token) => {
+ const asset = String(token.ticker || "").trim();
+ return { asset, wireName: asset, series: 0, kind: "token", label: `${asset} (Token)` };
+ }),
+ ...nftRows.map((nft) => {
+ const asset = String(nft.nft_name || "").trim();
+ const series = Number(nft.series || 0);
+ return {
+ asset,
+ wireName: series > 0 ? `${asset}_${series}` : asset,
+ series,
+ kind: "nft",
+ label: series > 0 ? `${asset} #${series} (NFT)` : `${asset} (NFT)`
+ };
+ })
+ ].filter((asset) => {
+ return asset.asset
+ && asset.wireName.length <= 21
+ && (asset.kind !== "nft" || asset.series <= 99999);
+ });
+ loanCollateralAssets.sort((left, right) => left.label.localeCompare(right.label));
+ loanOfferAssetsKey = key;
+ refreshLoanOfferSelects();
+ setLoanOfferMessage("");
+ })().catch((error) => {
+ setLoanOfferMessage(String(error), "error");
+ throw error;
+ }).finally(() => {
+ loanOfferLoadPromise = null;
+ });
+
+ return loanOfferLoadPromise;
+}
+
+function updateLoanOfferDerivedFields() {
+ const loanAsset = selectedLoanAsset();
+ const collateral = selectedLoanCollateral();
+ if (loanLender) {
+ loanLender.textContent = activeWalletAddressShort || activeWalletAddressHex || "--";
+ }
+ if (loanAvailable) {
+ loanAvailable.textContent = loanAsset
+ ? `${formatAtomicBalance(String(loanAsset.balance))} ${loanAsset.asset}`
+ : "--";
+ }
+ if (loanFeeInput) {
+ loanFeeInput.value = atomicToDecimal(LOAN_FEE_ATOMIC);
+ }
+ if (collateral?.kind === "nft") {
+ loanCollateralAmountInput.value = "1";
+ loanCollateralAmountInput.disabled = true;
+ } else if (loanCollateralAmountInput) {
+ loanCollateralAmountInput.disabled = false;
+ }
+
+ const paymentAmount = decimalToAtomic(loanPaymentAmountInput?.value);
+ const paymentNumber = Number.parseInt(loanPaymentNumberInput?.value || "0", 10);
+ if (loanTotalRepayment) {
+ loanTotalRepayment.textContent =
+ paymentAmount !== null && paymentAmount > 0n && paymentNumber > 0
+ ? `${atomicToDecimal(paymentAmount * BigInt(paymentNumber))} ${loanAsset?.asset || ""}`.trim()
+ : "--";
+ }
+}
+
+function validateLoanOfferForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before creating a loan offer.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before creating a loan offer.";
+ }
+ const loanAsset = selectedLoanAsset();
+ const collateral = selectedLoanCollateral();
+ if (!loanAsset) {
+ return "Select an asset to lend.";
+ }
+ if (!collateral) {
+ return "Select the collateral required from the borrower.";
+ }
+ const borrower = String(loanBorrowerInput?.value || "").trim();
+ if (!borrower) {
+ return "Enter the borrower wallet address.";
+ }
+ if (
+ borrower.toLowerCase() === String(activeWalletAddressShort || "").toLowerCase()
+ || borrower.toLowerCase() === String(activeWalletAddressHex || "").toLowerCase()
+ ) {
+ return "Borrower cannot be the active lender wallet.";
+ }
+
+ const loanAmount = decimalToAtomic(loanAmountInput?.value);
+ const collateralAmount = collateral.kind === "nft"
+ ? ATOMIC_UNITS_PER_COIN
+ : decimalToAtomic(loanCollateralAmountInput?.value);
+ const paymentAmount = decimalToAtomic(loanPaymentAmountInput?.value);
+ const maxLateValue = decimalToAtomic(loanMaxLateValueInput?.value);
+ if (loanAmount === null || loanAmount <= 0n) {
+ return "Enter a valid loan amount.";
+ }
+ if (collateralAmount === null || collateralAmount <= 0n) {
+ return "Enter a valid collateral amount.";
+ }
+ if (paymentAmount === null || paymentAmount <= 0n) {
+ return "Enter a valid payment amount.";
+ }
+ if (maxLateValue === null) {
+ return "Enter a valid maximum overdue value.";
+ }
+ if (paymentAmount > loanAmount) {
+ return "A single payment cannot exceed the loan amount.";
+ }
+
+ const paymentNumber = Number.parseInt(loanPaymentNumberInput?.value || "0", 10);
+ const gracePeriod = Number.parseInt(loanGracePeriodInput?.value || "0", 10);
+ if (!Number.isInteger(paymentNumber) || paymentNumber < 1 || paymentNumber > 255) {
+ return "Number of payments must be between 1 and 255.";
+ }
+ if (!Number.isInteger(gracePeriod) || gracePeriod < 0 || gracePeriod > paymentNumber) {
+ return "Missed payments allowed must be between 0 and the payment count.";
+ }
+ if (paymentAmount * BigInt(paymentNumber) < loanAmount) {
+ return "Scheduled payments must repay at least the loan principal.";
+ }
+ if (maxLateValue > loanAmount) {
+ return "Maximum overdue value cannot exceed the loan amount.";
+ }
+
+ const startTimestamp = loanStartTimestamp();
+ if (startTimestamp === null || startTimestamp > 4294967295) {
+ return "Enter a valid loan start date and time.";
+ }
+ if (loanAmount > loanAsset.balance) {
+ return "Loan amount exceeds the available asset balance.";
+ }
+ const baseBalance = baseCoinBalanceAtomic();
+ if (isBaseTransferAsset(loanAsset.asset)) {
+ if (loanAmount + LOAN_FEE_ATOMIC > loanAsset.balance) {
+ return `The loan amount and ${atomicToDecimal(LOAN_FEE_ATOMIC)} ${activeBaseCoin()} fee exceed the available balance.`;
+ }
+ } else if (baseBalance < LOAN_FEE_ATOMIC) {
+ return `Creating a loan requires ${atomicToDecimal(LOAN_FEE_ATOMIC)} ${activeBaseCoin()} for the lender fee.`;
+ }
+ return "";
+}
+
+function loanOfferPayload() {
+ const loanAsset = selectedLoanAsset();
+ const collateral = selectedLoanCollateral();
+ const collateralAmount = collateral.kind === "nft"
+ ? ATOMIC_UNITS_PER_COIN
+ : decimalToAtomic(loanCollateralAmountInput.value);
+ return {
+ broadcastNode: activeBroadcastNode(),
+ loanCoin: loanAsset.asset,
+ loanAmount: String(decimalToAtomic(loanAmountInput.value)),
+ borrower: String(loanBorrowerInput.value || "").trim(),
+ collateral: collateral.wireName,
+ collateralAmount: String(collateralAmount),
+ paymentPeriod: String(loanPaymentPeriodSelect.value || "d"),
+ paymentNumber: Number.parseInt(loanPaymentNumberInput.value, 10),
+ paymentAmount: String(decimalToAtomic(loanPaymentAmountInput.value)),
+ gracePeriod: Number.parseInt(loanGracePeriodInput.value, 10),
+ maxLateValue: String(decimalToAtomic(loanMaxLateValueInput.value)),
+ startTimestamp: loanStartTimestamp()
+ };
+}
+
+function clearLoanOfferForm() {
+ loanAmountInput.value = "";
+ loanBorrowerInput.value = "";
+ loanCollateralAmountInput.value = "";
+ loanPaymentPeriodSelect.value = "d";
+ loanPaymentNumberInput.value = "1";
+ loanPaymentAmountInput.value = "";
+ loanGracePeriodInput.value = "0";
+ loanMaxLateValueInput.value = "";
+ loanStartInput.value = loanLocalInputValue(Date.now() + 24 * 60 * 60 * 1000);
+ updateLoanOfferDerivedFields();
+}
+
+function setSavedLoanOfferPath(path = "") {
+ if (loanSavedPathInput) {
+ loanSavedPathInput.value = path;
+ }
+ loanSavedPathPanel?.classList.toggle("hidden", !path);
+}
+
+async function saveLoanOffer() {
+ const validationError = validateLoanOfferForm();
+ if (validationError) {
+ setLoanOfferMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setLoanOfferMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setLoanOfferMessage("Signing cancelled.");
+ return;
+ }
+
+ const button = document.querySelector("[data-loan-offer-save]");
+ button.disabled = true;
+ setSavedLoanOfferPath("");
+ setLoanOfferMessage("Signing and saving loan offer...");
+ try {
+ const result = await invoke("save_loan_offer", {
+ ...loanOfferPayload(),
+ walletKey
+ });
+ clearLoanOfferForm();
+ setSavedLoanOfferPath(result.file_path || "");
+ setLoanOfferMessage(
+ `Loan offer signed and saved as ${result.review?.file_name || "a local transaction file"}. Send this file to the borrower for review and signature.`,
+ "success"
+ );
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } catch (error) {
+ setLoanOfferMessage(String(error), "error");
+ } finally {
+ button.disabled = false;
+ }
+}
+
+function prepareLoanOfferForm() {
+ if (!loanStartInput.value) {
+ loanStartInput.value = loanLocalInputValue(Date.now() + 24 * 60 * 60 * 1000);
+ }
+ setLoanOfferMessage("");
+ loadLoanOfferAssets().catch(() => {
+ // The form displays the lookup error.
+ });
+ updateLoanOfferDerivedFields();
+}
+
+function resetLoanOfferSession() {
+ loanOfferLoadPromise = null;
+ loanCollateralAssets = [];
+ loanNftKeys = new Set();
+ loanOfferAssetsKey = "";
+ clearLoanOfferForm();
+ setSavedLoanOfferPath("");
+ loanAssetSelect.innerHTML = "";
+ loanCollateralSelect.innerHTML = "";
+ setLoanOfferMessage("");
+}
+
+[
+ loanAssetSelect,
+ loanCollateralSelect,
+ loanAmountInput,
+ loanCollateralAmountInput,
+ loanPaymentPeriodSelect,
+ loanPaymentNumberInput,
+ loanPaymentAmountInput,
+ loanGracePeriodInput,
+ loanMaxLateValueInput,
+ loanStartInput
+].forEach((element) => element?.addEventListener("input", () => {
+ setLoanOfferMessage("");
+ updateLoanOfferDerivedFields();
+}));
+loanBorrowerInput?.addEventListener("input", () => setLoanOfferMessage(""));
+document.querySelector("[data-loan-offer-save]")?.addEventListener("click", saveLoanOffer);
+loanCopyPathButton?.addEventListener("click", async () => {
+ const path = String(loanSavedPathInput?.value || "");
+ if (!path || !(await writeClipboardText(path))) {
+ setLoanOfferMessage("Unable to copy the saved loan offer path.", "error");
+ return;
+ }
+ const original = loanCopyPathButton.textContent;
+ loanCopyPathButton.textContent = "Copied";
+ setTimeout(() => {
+ loanCopyPathButton.textContent = original;
+ }, 1200);
+});
diff --git a/frontend/js/loan_payment_form.js b/frontend/js/loan_payment_form.js
new file mode 100644
index 0000000..2949549
--- /dev/null
+++ b/frontend/js/loan_payment_form.js
@@ -0,0 +1,287 @@
+const LOAN_PAYMENT_FEE_ATOMIC = 1000000n;
+let loanPaymentContracts = [];
+let loanPaymentLoadPromise = null;
+let loanPaymentContractsKey = "";
+
+function setLoanPaymentMessage(message, type = "") {
+ setScopedTransactionMessage("Loan Payment", loanPaymentMessage, message, type);
+}
+
+function selectedLoanPaymentContract() {
+ const hash = String(loanPaymentContractSelect?.value || "");
+ return loanPaymentContracts.find((contract) => contract.contract === hash) || null;
+}
+
+function loanPaymentPeriodLabel(period) {
+ return {
+ daily: "Daily",
+ weekly: "Weekly",
+ monthly: "Monthly"
+ }[String(period || "").toLowerCase()] || String(period || "Payment");
+}
+
+function populateLoanPaymentContracts() {
+ if (!loanPaymentContractSelect) {
+ return;
+ }
+ const previous = loanPaymentContractSelect.value;
+ loanPaymentContractSelect.innerHTML = "";
+ if (loanPaymentContracts.length) {
+ const placeholder = document.createElement("option");
+ placeholder.value = "";
+ placeholder.textContent = "Select an active loan";
+ loanPaymentContractSelect.appendChild(placeholder);
+ }
+ loanPaymentContracts.forEach((contract) => {
+ const option = document.createElement("option");
+ option.value = contract.contract;
+ const remaining = formatAtomicBalance(contract.remaining_after_pending || "0");
+ option.textContent =
+ `${contract.loan_asset} loan from ${truncateMiddle(contract.lender, 8, 8)} (${remaining} remaining)`;
+ loanPaymentContractSelect.appendChild(option);
+ });
+ if (!loanPaymentContracts.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No active borrower loans";
+ loanPaymentContractSelect.appendChild(option);
+ } else if ([...loanPaymentContractSelect.options].some((option) => option.value === previous)) {
+ loanPaymentContractSelect.value = previous;
+ }
+ updateLoanPaymentDerivedFields(true);
+}
+
+async function loadLoanPaymentContracts(force = false) {
+ if (loanPaymentLoadPromise) {
+ return loanPaymentLoadPromise;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !broadcastNode || !walletLoaded || !registrationRegistered) {
+ return;
+ }
+ const key = `${activeWalletAddressShort || activeWalletAddressHex}|${broadcastNode}`;
+ if (!force && loanPaymentContractsKey === key) {
+ populateLoanPaymentContracts();
+ return;
+ }
+
+ loanPaymentLoadPromise = (async () => {
+ setLoanPaymentMessage("Loading active loans...");
+ const contracts = await invoke("active_loan_contracts", { broadcastNode });
+ loanPaymentContracts = Array.isArray(contracts) ? contracts : [];
+ loanPaymentContractsKey = key;
+ populateLoanPaymentContracts();
+ setLoanPaymentMessage(
+ loanPaymentContracts.length ? "" : "No active loans require payment."
+ );
+ })().catch((error) => {
+ loanPaymentContracts = [];
+ populateLoanPaymentContracts();
+ setLoanPaymentMessage(String(error), "error");
+ throw error;
+ }).finally(() => {
+ loanPaymentLoadPromise = null;
+ });
+ return loanPaymentLoadPromise;
+}
+
+function expectedLoanPayment(contract) {
+ if (!contract) {
+ return 0n;
+ }
+ const scheduled = BigInt(contract.payment_amount || "0");
+ const remaining = BigInt(contract.remaining_after_pending || "0");
+ return scheduled < remaining ? scheduled : remaining;
+}
+
+function updateLoanPaymentWarning(contract, amount) {
+ if (!loanPaymentWarning) {
+ return;
+ }
+ const expected = expectedLoanPayment(contract);
+ const show = contract && amount !== null && amount > 0n && amount < expected;
+ loanPaymentWarning.classList.toggle("hidden", !show);
+ loanPaymentWarning.textContent = show
+ ? `This is less than the expected ${atomicToDecimal(expected)} ${contract.loan_asset} payment. Partial payments are allowed, but the unpaid amount still counts toward the loan's overdue balance.`
+ : "";
+}
+
+function updateLoanPaymentDerivedFields(setSuggestedAmount = false) {
+ const contract = selectedLoanPaymentContract();
+ if (!contract) {
+ loanPaymentLender.textContent = "--";
+ loanPaymentAsset.textContent = "--";
+ loanPaymentScheduled.textContent = "--";
+ loanPaymentConfirmed.textContent = "--";
+ loanPaymentPending.textContent = "--";
+ loanPaymentRemaining.textContent = "--";
+ loanPaymentTipInput.value = "";
+ loanPaymentFeeInput.value = atomicToDecimal(LOAN_PAYMENT_FEE_ATOMIC);
+ updateLoanPaymentWarning(null, null);
+ return;
+ }
+
+ const expected = expectedLoanPayment(contract);
+ if (setSuggestedAmount || !loanPaymentValueInput.value) {
+ loanPaymentValueInput.value = atomicToDecimal(expected);
+ }
+ const amount = decimalToAtomic(loanPaymentValueInput.value);
+ const tip = amount !== null && amount > 0n ? (amount + 99n) / 100n : 0n;
+
+ loanPaymentLender.textContent = contract.lender;
+ loanPaymentAsset.textContent = contract.loan_asset;
+ loanPaymentScheduled.textContent =
+ `${loanPaymentPeriodLabel(contract.payment_period)}: ${atomicToDecimal(BigInt(contract.payment_amount || "0"))} ${contract.loan_asset}`;
+ loanPaymentConfirmed.textContent =
+ `${atomicToDecimal(BigInt(contract.confirmed_paid || "0"))} ${contract.loan_asset}`;
+ loanPaymentPending.textContent =
+ `${atomicToDecimal(BigInt(contract.pending_paid || "0"))} ${contract.loan_asset}`;
+ loanPaymentRemaining.textContent =
+ `${atomicToDecimal(BigInt(contract.remaining_after_pending || "0"))} ${contract.loan_asset}`;
+ loanPaymentTipInput.value = atomicToDecimal(tip);
+ loanPaymentFeeInput.value = atomicToDecimal(LOAN_PAYMENT_FEE_ATOMIC);
+ updateLoanPaymentWarning(contract, amount);
+}
+
+function loanPaymentBalance(asset) {
+ return activeWalletBalances.find((balance) => {
+ return String(balance.asset || "").trim().toLowerCase() === String(asset || "").trim().toLowerCase()
+ && Number(balance.nft_series || 0) === 0;
+ });
+}
+
+function validateLoanPaymentForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before making a loan payment.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before making a loan payment.";
+ }
+ const contract = selectedLoanPaymentContract();
+ if (!contract) {
+ return "Select an active loan.";
+ }
+ const amount = decimalToAtomic(loanPaymentValueInput?.value);
+ if (amount === null || amount <= 0n) {
+ return "Enter a valid payment amount.";
+ }
+ const remaining = BigInt(contract.remaining_after_pending || "0");
+ if (amount > remaining) {
+ return `Payment cannot exceed the remaining ${atomicToDecimal(remaining)} ${contract.loan_asset}.`;
+ }
+ const tip = (amount + 99n) / 100n;
+ const available = balanceAtomicValue(loanPaymentBalance(contract.loan_asset));
+ if (amount + tip > available) {
+ return `This wallet cannot cover the payment and 1% miner tip in ${contract.loan_asset}.`;
+ }
+ const baseBalance = baseCoinBalanceAtomic();
+ if (isBaseTransferAsset(contract.loan_asset)) {
+ if (amount + tip + LOAN_PAYMENT_FEE_ATOMIC > available) {
+ return `This wallet cannot cover the payment, tip, and ${atomicToDecimal(LOAN_PAYMENT_FEE_ATOMIC)} ${activeBaseCoin()} fee.`;
+ }
+ } else if (baseBalance < LOAN_PAYMENT_FEE_ATOMIC) {
+ return `This payment requires ${atomicToDecimal(LOAN_PAYMENT_FEE_ATOMIC)} ${activeBaseCoin()} for the transaction fee.`;
+ }
+ return "";
+}
+
+function loanPaymentPayload() {
+ const contract = selectedLoanPaymentContract();
+ return {
+ broadcastNode: activeBroadcastNode(),
+ contractHash: contract.contract,
+ paybackAmount: String(decimalToAtomic(loanPaymentValueInput.value))
+ };
+}
+
+function setLoanPaymentButtonsDisabled(disabled) {
+ document.querySelector("[data-loan-payment-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-loan-payment-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+function clearLoanPaymentForm() {
+ loanPaymentContractSelect.value = "";
+ loanPaymentValueInput.value = "";
+ updateLoanPaymentDerivedFields(false);
+}
+
+async function handleLoanPaymentAction(action) {
+ const validationError = validateLoanPaymentForm();
+ if (validationError) {
+ setLoanPaymentMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setLoanPaymentMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setLoanPaymentMessage("Signing cancelled.");
+ return;
+ }
+
+ setLoanPaymentButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setLoanPaymentMessage("Saving loan payment transaction...");
+ const review = await invoke("save_loan_payment_transaction", {
+ ...loanPaymentPayload(),
+ walletKey
+ });
+ clearLoanPaymentForm();
+ setLoanPaymentMessage(`Loan payment saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ setLoanPaymentMessage("Broadcasting loan payment...");
+ const result = await invoke("broadcast_loan_payment_transaction", {
+ ...loanPaymentPayload(),
+ walletKey
+ });
+ await loadLoanPaymentContracts(true);
+ clearLoanPaymentForm();
+ setLoanPaymentMessage(result.response || "Loan payment broadcast.", "success");
+ }
+ } catch (error) {
+ setLoanPaymentMessage(String(error), "error");
+ await loadLoanPaymentContracts(true).catch(() => {});
+ } finally {
+ setLoanPaymentButtonsDisabled(false);
+ }
+}
+
+function prepareLoanPaymentForm() {
+ setLoanPaymentMessage("");
+ loadLoanPaymentContracts(false).catch(() => {
+ // The form displays the lookup error.
+ });
+}
+
+function resetLoanPaymentSession() {
+ loanPaymentContracts = [];
+ loanPaymentLoadPromise = null;
+ loanPaymentContractsKey = "";
+ loanPaymentContractSelect.innerHTML = "";
+ loanPaymentValueInput.value = "";
+ updateLoanPaymentDerivedFields(false);
+ setLoanPaymentMessage("");
+}
+
+loanPaymentContractSelect?.addEventListener("change", () => {
+ setLoanPaymentMessage("");
+ updateLoanPaymentDerivedFields(true);
+});
+loanPaymentValueInput?.addEventListener("input", () => {
+ setLoanPaymentMessage("");
+ updateLoanPaymentDerivedFields(false);
+});
+document
+ .querySelector("[data-loan-payment-save]")
+ ?.addEventListener("click", () => handleLoanPaymentAction("save"));
+document
+ .querySelector("[data-loan-payment-broadcast]")
+ ?.addEventListener("click", () => handleLoanPaymentAction("broadcast"));
diff --git a/frontend/js/loans_page.js b/frontend/js/loans_page.js
new file mode 100644
index 0000000..b7b1d97
--- /dev/null
+++ b/frontend/js/loans_page.js
@@ -0,0 +1,488 @@
+let loansContracts = [];
+let loansLoadedForKey = "";
+let loansLoadInFlight = false;
+let selectedLoanContractHash = "";
+let activeLoansStatusFilter = "all";
+let loansStateMessage = "";
+
+function loanFormatAtomic(value) {
+ if (typeof atomicToDecimal === "function") {
+ return atomicToDecimal(BigInt(value || "0"));
+ }
+ if (typeof formatAtomicBalance === "function") {
+ return formatAtomicBalance(value || "0");
+ }
+ return String(value || "0");
+}
+
+function loanShort(value, left = 8, right = 8) {
+ if (typeof truncateMiddle === "function") {
+ return truncateMiddle(value, left, right);
+ }
+ const text = String(value || "");
+ return text.length > left + right + 3 ? `${text.slice(0, left)}...${text.slice(-right)}` : text;
+}
+
+function escapeLoanText(value) {
+ return String(value ?? "")
+ .replaceAll("&", "&")
+ .replaceAll("<", "<")
+ .replaceAll(">", ">")
+ .replaceAll('"', """)
+ .replaceAll("'", "'");
+}
+
+function activeLoanRole(contract) {
+ const active = String(activeWalletAddressShort || "").trim().toLowerCase();
+ if (String(contract.lender || "").trim().toLowerCase() === active) {
+ return "lender";
+ }
+ if (String(contract.borrower || "").trim().toLowerCase() === active) {
+ return "borrower";
+ }
+ return "unknown";
+}
+
+function loanRoleLabel(role) {
+ return role === "lender" ? "Lending" : role === "borrower" ? "Borrowing" : "Related";
+}
+
+function loanCounterparty(contract) {
+ return activeLoanRole(contract) === "lender" ? contract.borrower : contract.lender;
+}
+
+function loanStatusClass(status) {
+ const normalized = String(status || "").toLowerCase();
+ if (normalized === "delinquent") {
+ return "due";
+ }
+ if (normalized === "inactive") {
+ return "claimable";
+ }
+ return "active";
+}
+
+function loanStatusLabel(status) {
+ const normalized = String(status || "").toLowerCase();
+ if (normalized === "inactive") {
+ return "Completed";
+ }
+ return normalized ? normalized.charAt(0).toUpperCase() + normalized.slice(1) : "Unknown";
+}
+
+function loanPaymentCount(contract) {
+ return Array.isArray(contract.payments) ? contract.payments.length : 0;
+}
+
+function loanAmountLabel(value, asset) {
+ return `${loanFormatAtomic(value)} ${String(asset || "").trim()}`.trim();
+}
+
+function addUtcMonths(timestampSeconds, monthsToAdd) {
+ const start = new Date(Number(timestampSeconds || 0) * 1000);
+ if (Number.isNaN(start.getTime())) {
+ return null;
+ }
+ const year = start.getUTCFullYear();
+ const month = start.getUTCMonth() + Number(monthsToAdd || 0);
+ const day = start.getUTCDate();
+ const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+ return new Date(Date.UTC(
+ year,
+ month,
+ Math.min(day, lastDay),
+ start.getUTCHours(),
+ start.getUTCMinutes(),
+ start.getUTCSeconds()
+ ));
+}
+
+function loanDueDateForPayment(contract, paymentIndex) {
+ const startTimestamp = Number(contract.start_timestamp || 0);
+ if (!startTimestamp || !paymentIndex) {
+ return null;
+ }
+ const period = String(contract.payment_period || "").trim().toLowerCase();
+ if (period === "daily") {
+ return new Date((startTimestamp + paymentIndex * 86_400) * 1000);
+ }
+ if (period === "weekly") {
+ return new Date((startTimestamp + paymentIndex * 7 * 86_400) * 1000);
+ }
+ if (period === "monthly") {
+ return addUtcMonths(startTimestamp, paymentIndex);
+ }
+ return null;
+}
+
+function formatLoanDueDate(date) {
+ if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+ return "--";
+ }
+ return date.toLocaleString(undefined, {
+ year: "numeric",
+ month: "short",
+ day: "numeric",
+ hour: "numeric",
+ minute: "2-digit",
+ timeZoneName: "short"
+ });
+}
+
+function nextLoanPaymentDueLabel(contract) {
+ if (String(contract.status || "").toLowerCase() === "inactive") {
+ return "No remaining payments";
+ }
+ const paymentAmount = BigInt(contract.payment_amount || "0");
+ const confirmedPaid = BigInt(contract.confirmed_paid || "0");
+ const paymentNumber = Number(contract.payment_number || 0);
+ if (!paymentNumber || paymentAmount <= 0n) {
+ return "--";
+ }
+ const completedPayments = Number(confirmedPaid / paymentAmount);
+ if (completedPayments >= paymentNumber) {
+ return "No remaining payments";
+ }
+ return formatLoanDueDate(loanDueDateForPayment(contract, completedPayments + 1));
+}
+
+function sortedLoans() {
+ const query = String(loansSearch?.value || "").trim().toLowerCase();
+ const roleFilter = loansRoleFilter?.value || "all";
+
+ return loansContracts
+ .filter((contract) => {
+ const role = activeLoanRole(contract);
+ const status = String(contract.status || "").toLowerCase();
+ const searchText = [
+ contract.contract,
+ contract.lender,
+ contract.borrower,
+ contract.loan_asset,
+ contract.collateral,
+ status,
+ role
+ ].join(" ").toLowerCase();
+
+ if (roleFilter !== "all" && role !== roleFilter) {
+ return false;
+ }
+ if (activeLoansStatusFilter !== "all" && status !== activeLoansStatusFilter) {
+ return false;
+ }
+ return !query || searchText.includes(query);
+ })
+ .sort((left, right) => Number(right.start_timestamp || 0) - Number(left.start_timestamp || 0));
+}
+
+function renderLoanCard(contract) {
+ const role = activeLoanRole(contract);
+ const selected = contract.contract === selectedLoanContractHash;
+ const counterparty = loanCounterparty(contract);
+ const principal = loanAmountLabel(contract.loan_amount, contract.loan_asset);
+ const remaining = loanAmountLabel(contract.remaining_after_pending, contract.loan_asset);
+ const payments = `${loanPaymentCount(contract)} / ${contract.payment_number || 0}`;
+ const nextDue = nextLoanPaymentDueLabel(contract);
+
+ return `
+
+
+
+ Loan ${escapeLoanText(loanShort(contract.contract, 6, 6))}
+ ${activeLoanRole(contract) === "lender" ? "Borrower" : "Lender"} ${escapeLoanText(loanShort(counterparty, 8, 8))}
+
+
+ ${escapeLoanText(loanRoleLabel(role))}
+ ${escapeLoanText(loanStatusLabel(contract.status))}
+
+
+
Principal ${escapeLoanText(principal)}
+
Remaining ${escapeLoanText(remaining)}
+
Payments ${escapeLoanText(payments)}
+
+ Next payment due by:
+ ${escapeLoanText(nextDue)}
+
+
+ `;
+}
+
+function selectedLoanContract() {
+ return loansContracts.find((contract) => contract.contract === selectedLoanContractHash) || null;
+}
+
+function detailItem(label, value) {
+ return `${escapeLoanText(label)} ${escapeLoanText(value || "--")}
`;
+}
+
+function renderLoanPaymentHistory(contract) {
+ if (!loanPaymentHistory) {
+ return;
+ }
+ const payments = Array.isArray(contract?.payments) ? contract.payments : [];
+ if (!payments.length) {
+ loanPaymentHistory.innerHTML = 'No confirmed payments recorded for this loan.
';
+ return;
+ }
+ loanPaymentHistory.innerHTML = `
+
+
+
+ Date
+ Amount
+ Payer
+ Tx Hash
+
+
+
+ ${payments.map((payment) => `
+
+ ${escapeLoanText(payment.date || "--")}
+ ${escapeLoanText(payment.amount || "0")} ${escapeLoanText(contract.loan_asset || "")}
+ ${escapeLoanText(loanShort(payment.payer || "", 8, 8))}
+ ${escapeLoanText(loanShort(payment.txid || "", 8, 8))}
+
+ `).join("")}
+
+
+ `;
+}
+
+function renderLoanDetail() {
+ const contract = selectedLoanContract();
+ if (!loanDetailGrid) {
+ return;
+ }
+ if (!contract) {
+ loanDetailGrid.innerHTML = detailItem("Selected Loan", "Select a loan to view details.");
+ if (loanPaymentHistory) {
+ loanPaymentHistory.innerHTML = 'No loan selected.
';
+ }
+ loanCopyContractButton?.toggleAttribute("disabled", true);
+ loanMakePaymentButton?.toggleAttribute("disabled", true);
+ loanClaimCollateralButton?.toggleAttribute("disabled", true);
+ return;
+ }
+
+ const role = activeLoanRole(contract);
+ const collateral = loanAmountLabel(contract.collateral_amount, contract.collateral);
+ const payment = loanAmountLabel(contract.payment_amount, contract.loan_asset);
+ const confirmed = loanAmountLabel(contract.confirmed_paid, contract.loan_asset);
+ const pending = loanAmountLabel(contract.pending_paid, contract.loan_asset);
+ const remaining = loanAmountLabel(contract.remaining_after_pending, contract.loan_asset);
+
+ loanDetailGrid.innerHTML = [
+ detailItem("Contract Hash", contract.contract),
+ detailItem("Role", loanRoleLabel(role)),
+ detailItem("Status", loanStatusLabel(contract.status)),
+ detailItem("Principal", loanAmountLabel(contract.loan_amount, contract.loan_asset)),
+ detailItem("Payment Amount", payment),
+ detailItem("Collateral", collateral),
+ detailItem("Payment Schedule", `${contract.payment_number || 0} ${contract.payment_period || "payments"}`),
+ detailItem("Confirmed Paid", confirmed),
+ detailItem("Pending Total", pending),
+ detailItem("Remaining", remaining),
+ detailItem("Lender", contract.lender),
+ detailItem("Borrower", contract.borrower)
+ ].join("");
+
+ renderLoanPaymentHistory(contract);
+ loanCopyContractButton?.toggleAttribute("disabled", false);
+ loanMakePaymentButton?.toggleAttribute(
+ "disabled",
+ !(role === "borrower" && String(contract.status || "").toLowerCase() !== "inactive")
+ );
+ loanClaimCollateralButton?.toggleAttribute("disabled", String(contract.status || "").toLowerCase() === "inactive");
+}
+
+function renderLoansPage() {
+ if (!loansList) {
+ return;
+ }
+ const rows = sortedLoans();
+ if (!selectedLoanContractHash && rows.length) {
+ selectedLoanContractHash = rows[0].contract;
+ }
+ if (selectedLoanContractHash && !loansContracts.some((contract) => contract.contract === selectedLoanContractHash)) {
+ selectedLoanContractHash = rows[0]?.contract || "";
+ }
+
+ loansList.innerHTML = rows.map(renderLoanCard).join("");
+ if (!walletLoaded) {
+ loansState && (loansState.textContent = "Load a wallet to view loans.");
+ } else if (loansLoadInFlight && !loansContracts.length) {
+ loansState && (loansState.textContent = "Loading loans...");
+ } else if (loansStateMessage) {
+ loansState && (loansState.textContent = loansStateMessage);
+ } else if (!loansContracts.length) {
+ loansState && (loansState.textContent = "No loan contracts found for this wallet.");
+ } else if (!rows.length) {
+ loansState && (loansState.textContent = "No loans match the current filters.");
+ } else {
+ loansState && (loansState.textContent = `${rows.length} loan${rows.length === 1 ? "" : "s"} shown`);
+ }
+ renderLoanDetail();
+}
+
+async function loadLoansPage({ force = false } = {}) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!walletLoaded) {
+ loansContracts = [];
+ selectedLoanContractHash = "";
+ loansStateMessage = "Load a wallet to view loans.";
+ renderLoansPage();
+ return;
+ }
+ if (!invoke) {
+ loansContracts = [];
+ selectedLoanContractHash = "";
+ loansStateMessage = "Loan lookup skipped: Tauri invoke is unavailable.";
+ renderLoansPage();
+ return;
+ }
+ if (!broadcastNode) {
+ loansContracts = [];
+ selectedLoanContractHash = "";
+ loansStateMessage = "Loan lookup skipped: no broadcast node is selected.";
+ renderLoansPage();
+ return;
+ }
+ const key = `${activeWalletAddressShort || activeWalletAddressHex}|${broadcastNode}`;
+ if (!force && loansLoadedForKey === key) {
+ renderLoansPage();
+ return;
+ }
+ if (loansLoadInFlight) {
+ return;
+ }
+
+ loansLoadInFlight = true;
+ loansStateMessage = "Loading loans...";
+ renderLoansPage();
+ try {
+ const contracts = await invokeWalletRpcWithBackoff(
+ "loan contracts",
+ () => invoke("loan_contracts", { broadcastNode }),
+ () => currentView === "loans" && activeBroadcastNode() === broadcastNode
+ );
+ loansContracts = Array.isArray(contracts) ? contracts : [];
+ loansLoadedForKey = key;
+ selectedLoanContractHash = loansContracts[0]?.contract || "";
+ loansStateMessage = loansContracts.length
+ ? ""
+ : "Loan contract command returned 0 contracts for this wallet.";
+ } catch (error) {
+ loansContracts = [];
+ selectedLoanContractHash = "";
+ loansStateMessage = `Loan contract lookup failed: ${String(error)}`;
+ } finally {
+ loansLoadInFlight = false;
+ renderLoansPage();
+ }
+}
+
+function prepareLoansPage({ force = false } = {}) {
+ renderLoansPage();
+ loadLoansPage({ force });
+}
+
+function resetLoansPage() {
+ loansContracts = [];
+ loansLoadedForKey = "";
+ loansLoadInFlight = false;
+ selectedLoanContractHash = "";
+ activeLoansStatusFilter = "all";
+ loansStateMessage = "";
+ loansSearch && (loansSearch.value = "");
+ loansRoleFilter && (loansRoleFilter.value = "all");
+ loansStatusButtons.forEach((button) => {
+ button.classList.toggle("active", button.dataset.loansStatusFilter === "all");
+ });
+ renderLoansPage();
+}
+
+loansSearch?.addEventListener("input", renderLoansPage);
+loansRoleFilter?.addEventListener("change", renderLoansPage);
+loansRefreshButton?.addEventListener("click", () => loadLoansPage({ force: true }));
+loansCreateButton?.addEventListener("click", () => {
+ setActiveView("send");
+ setActiveTransactionType("Create Loan");
+});
+loansStatusButtons.forEach((button) => {
+ button.addEventListener("click", () => {
+ activeLoansStatusFilter = button.dataset.loansStatusFilter || "all";
+ loansStatusButtons.forEach((item) => item.classList.toggle("active", item === button));
+ selectedLoanContractHash = "";
+ renderLoansPage();
+ });
+});
+loansList?.addEventListener("click", (event) => {
+ const card = event.target.closest("[data-loan-contract]");
+ if (!card) {
+ return;
+ }
+ selectedLoanContractHash = card.dataset.loanContract || "";
+ renderLoansPage();
+});
+loanCopyContractButton?.addEventListener("click", async () => {
+ const contract = selectedLoanContract();
+ if (!contract) {
+ return;
+ }
+ const copied = typeof writeClipboardText === "function"
+ ? await writeClipboardText(contract.contract)
+ : false;
+ if (!copied) {
+ return;
+ }
+ const original = loanCopyContractButton.textContent;
+ loanCopyContractButton.textContent = "Copied";
+ setTimeout(() => {
+ loanCopyContractButton.textContent = original;
+ }, 900);
+});
+loanMakePaymentButton?.addEventListener("click", () => {
+ const contract = selectedLoanContract();
+ if (typeof openTransactionType === "function") {
+ openTransactionType("Loan Payment");
+ } else {
+ setActiveView("send");
+ setActiveTransactionType("Loan Payment");
+ showTransactionForm("Loan Payment");
+ }
+ const selectContract = () => {
+ if (contract?.contract && loanPaymentContractSelect) {
+ loanPaymentContractSelect.value = contract.contract;
+ updateLoanPaymentDerivedFields(true);
+ }
+ };
+ if (typeof loadLoanPaymentContracts === "function") {
+ loadLoanPaymentContracts(false).then(selectContract).catch(() => {});
+ } else {
+ setTimeout(selectContract, 0);
+ }
+});
+loanClaimCollateralButton?.addEventListener("click", () => {
+ const contract = selectedLoanContract();
+ if (typeof openTransactionType === "function") {
+ openTransactionType("Collateral Claim");
+ } else {
+ setActiveView("send");
+ setActiveTransactionType("Collateral Claim");
+ showTransactionForm("Collateral Claim");
+ }
+ const selectContract = () => {
+ if (contract?.contract && collateralClaimContractSelect) {
+ collateralClaimContractSelect.value = contract.contract;
+ updateCollateralClaimDetails();
+ }
+ };
+ if (typeof loadCollateralClaimContracts === "function") {
+ loadCollateralClaimContracts(false).then(selectContract).catch(() => {});
+ } else {
+ setTimeout(selectContract, 0);
+ }
+});
diff --git a/frontend/js/marketing_campaign_page.js b/frontend/js/marketing_campaign_page.js
new file mode 100644
index 0000000..a07c3ec
--- /dev/null
+++ b/frontend/js/marketing_campaign_page.js
@@ -0,0 +1,290 @@
+const MARKETING_CAMPAIGN_PAGE_SIZE = 100;
+
+let marketingCampaignPage = 1;
+let marketingCampaignTotalRows = 0;
+let marketingCampaignLastQuery = null;
+let marketingCampaignLoading = false;
+
+function setMarketingCampaignState(message, mode = "") {
+ if (!marketingCampaignState) {
+ return;
+ }
+ marketingCampaignState.textContent = message;
+ marketingCampaignState.classList.toggle("hidden", !message);
+ marketingCampaignState.classList.toggle("loading", mode === "loading");
+ marketingCampaignState.classList.toggle("error", mode === "error");
+}
+
+function clearMarketingCampaignRows() {
+ if (marketingCampaignRows) {
+ marketingCampaignRows.innerHTML = "";
+ }
+ if (marketingCampaignCards) {
+ marketingCampaignCards.innerHTML = "";
+ }
+}
+
+function marketingBigInt(value) {
+ try {
+ return BigInt(String(value || "0"));
+ } catch (_) {
+ return 0n;
+ }
+}
+
+function formatMarketingInteger(value) {
+ const text = marketingBigInt(value).toString();
+ return text.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+function formatMarketingCents(value) {
+ const cents = marketingBigInt(value);
+ const sign = cents < 0n ? "-" : "";
+ const absolute = cents < 0n ? -cents : cents;
+ const whole = absolute / 100n;
+ const fraction = String(absolute % 100n).padStart(2, "0");
+ return `${sign}${formatMarketingInteger(whole)}.${fraction}`;
+}
+
+function formatMarketingAverage(totalValue, count) {
+ const total = marketingBigInt(totalValue);
+ const divisor = marketingBigInt(count);
+ if (divisor === 0n) {
+ return "--";
+ }
+ return formatMarketingCents(total / divisor);
+}
+
+function setMarketingCampaignSummary(data = null) {
+ const totalRecords = marketingBigInt(data?.total_records);
+ const totalImpressions = marketingBigInt(data?.total_impressions);
+ const totalClicks = marketingBigInt(data?.total_clicks);
+ const totalImpressionValue = marketingBigInt(data?.total_impression_value);
+ const totalClickValue = marketingBigInt(data?.total_click_value);
+ const totalValue = totalImpressionValue + totalClickValue;
+
+ if (marketingTotalRecords) {
+ marketingTotalRecords.textContent = data ? formatMarketingInteger(totalRecords) : "--";
+ }
+ if (marketingTotalImpressions) {
+ marketingTotalImpressions.textContent = data ? formatMarketingInteger(totalImpressions) : "--";
+ }
+ if (marketingTotalClicks) {
+ marketingTotalClicks.textContent = data ? formatMarketingInteger(totalClicks) : "--";
+ }
+ if (marketingAvgImpressionValue) {
+ marketingAvgImpressionValue.textContent = data
+ ? formatMarketingAverage(totalImpressionValue, totalImpressions)
+ : "--";
+ }
+ if (marketingAvgClickValue) {
+ marketingAvgClickValue.textContent = data
+ ? formatMarketingAverage(totalClickValue, totalClicks)
+ : "--";
+ }
+ if (marketingTotalValue) {
+ marketingTotalValue.textContent = data ? formatMarketingCents(totalValue) : "--";
+ }
+}
+
+function setMarketingCampaignFooter(visibleCount = 0, totalCount = 0, page = 1) {
+ const totalPages = Math.max(1, Math.ceil(totalCount / MARKETING_CAMPAIGN_PAGE_SIZE));
+ const pageStart = totalCount && visibleCount ? (page - 1) * MARKETING_CAMPAIGN_PAGE_SIZE : 0;
+ if (marketingCampaignCount) {
+ marketingCampaignCount.textContent = totalCount
+ ? `Showing ${formatMarketingInteger(pageStart + 1)}-${formatMarketingInteger(pageStart + visibleCount)} of ${formatMarketingInteger(totalCount)}`
+ : "";
+ }
+ if (marketingCampaignPagination) {
+ marketingCampaignPagination.hidden = totalPages <= 1;
+ marketingCampaignPagination.querySelectorAll("[data-marketing-campaign-page]").forEach((button) => {
+ const action = button.dataset.marketingCampaignPage;
+ button.disabled = action === "first" || action === "previous"
+ ? page <= 1
+ : page >= totalPages;
+ });
+ }
+ if (marketingCampaignPageInput) {
+ marketingCampaignPageInput.value = String(page);
+ marketingCampaignPageInput.max = String(totalPages);
+ marketingCampaignPageInput.disabled = totalPages <= 1;
+ }
+ if (marketingCampaignPageTotal) {
+ marketingCampaignPageTotal.textContent = formatNumber(totalPages);
+ }
+}
+
+function marketingStatusClass(status) {
+ return String(status || "").toLowerCase() === "pending" ? "pending" : "confirmed";
+}
+
+function renderMarketingCampaignRows(rows = []) {
+ clearMarketingCampaignRows();
+ const tableFragment = document.createDocumentFragment();
+ const cardFragment = document.createDocumentFragment();
+
+ rows.forEach((row) => {
+ const tr = document.createElement("tr");
+ tr.innerHTML = `
+ ${formatHistoryDate(row.time)}
+ ${htmlEscape(row.campaign)}
+ ${htmlEscape(row.ad_type)}
+ ${htmlEscape(row.keyword)}
+ ${htmlEscape(row.displayed)}
+ ${formatMarketingInteger(row.impression || 0)}
+ ${formatMarketingInteger(row.click || 0)}
+ ${formatMarketingCents(row.impression_value || 0)}
+ ${formatMarketingCents(row.click_value || 0)}
+ ${htmlEscape(row.status)} Time ${formatHistoryDate(row.time)}
+ Campaign ${htmlEscape(row.campaign)}
+ Ad Type ${htmlEscape(row.ad_type)}
+ Keyword ${htmlEscape(row.keyword)}
+ Displayed ${htmlEscape(row.displayed)}
+ Impressions ${formatMarketingInteger(row.impression || 0)}
+ Clicks ${formatMarketingInteger(row.click || 0)}
+ Status ${htmlEscape(row.status)}
+ `;
+ cardFragment.appendChild(card);
+ });
+
+ marketingCampaignRows?.appendChild(tableFragment);
+ marketingCampaignCards?.appendChild(cardFragment);
+}
+
+function validateMarketingCampaignQuery() {
+ const advertiser = String(marketingCampaignAdvertiserInput?.value || "").trim();
+ const campaign = String(marketingCampaignIdInput?.value || "").trim();
+ if (!walletLoaded) {
+ return { error: "Load a wallet before viewing campaign data." };
+ }
+ if (!activeBroadcastNode()) {
+ return { error: "Select a broadcast node before viewing campaign data." };
+ }
+ if (!advertiser) {
+ return { error: "Agency wallet address is required." };
+ }
+ if (!/^\d+$/.test(campaign)) {
+ return { error: "Campaign ID must be a whole number." };
+ }
+ return { advertiser, campaign };
+}
+
+async function loadMarketingCampaignPage(page = marketingCampaignPage) {
+ if (marketingCampaignLoading) {
+ return;
+ }
+ const query = validateMarketingCampaignQuery();
+ if (query.error) {
+ clearMarketingCampaignRows();
+ setMarketingCampaignSummary(null);
+ setMarketingCampaignFooter(0, 0, 1);
+ setMarketingCampaignState(query.error, "error");
+ return;
+ }
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setMarketingCampaignState("Wallet bridge is not available.", "error");
+ return;
+ }
+
+ marketingCampaignLoading = true;
+ marketingCampaignLoadButton?.toggleAttribute("disabled", true);
+ marketingCampaignRefreshButton?.toggleAttribute("disabled", true);
+ setMarketingCampaignState("Loading campaign activity...", "loading");
+
+ try {
+ const normalizedPage = Math.max(1, Number.parseInt(page || 1, 10));
+ const skip = (normalizedPage - 1) * MARKETING_CAMPAIGN_PAGE_SIZE;
+ const data = await invoke("marketing_campaign_history", {
+ broadcastNode: activeBroadcastNode(),
+ advertiser: query.advertiser,
+ campaign: query.campaign,
+ skip,
+ limit: MARKETING_CAMPAIGN_PAGE_SIZE
+ });
+
+ marketingCampaignLastQuery = query;
+ marketingCampaignPage = normalizedPage;
+ marketingCampaignTotalRows = Number(marketingBigInt(data?.total_records));
+ setMarketingCampaignSummary(data);
+ renderMarketingCampaignRows(data?.rows || []);
+ setMarketingCampaignFooter((data?.rows || []).length, marketingCampaignTotalRows, marketingCampaignPage);
+ setMarketingCampaignState((data?.rows || []).length ? "" : "No campaign records found.");
+ } catch (error) {
+ setMarketingCampaignState(String(error), "error");
+ } finally {
+ marketingCampaignLoading = false;
+ marketingCampaignLoadButton?.toggleAttribute("disabled", false);
+ marketingCampaignRefreshButton?.toggleAttribute("disabled", false);
+ }
+}
+
+function prepareMarketingCampaignPage() {
+ if (!marketingCampaignLastQuery) {
+ setMarketingCampaignSummary(null);
+ setMarketingCampaignFooter(0, 0, 1);
+ if (!marketingCampaignRows?.children.length) {
+ setMarketingCampaignState("Enter an agency wallet and campaign ID to load campaign activity.");
+ }
+ }
+}
+
+function resetMarketingCampaignPage() {
+ marketingCampaignPage = 1;
+ marketingCampaignTotalRows = 0;
+ marketingCampaignLastQuery = null;
+ marketingCampaignLoading = false;
+ if (marketingCampaignAdvertiserInput) {
+ marketingCampaignAdvertiserInput.value = "";
+ }
+ if (marketingCampaignIdInput) {
+ marketingCampaignIdInput.value = "";
+ }
+ clearMarketingCampaignRows();
+ setMarketingCampaignSummary(null);
+ setMarketingCampaignFooter(0, 0, 1);
+ setMarketingCampaignState("Enter an agency wallet and campaign ID to load campaign activity.");
+}
+
+marketingCampaignForm?.addEventListener("submit", (event) => {
+ event.preventDefault();
+ marketingCampaignPage = 1;
+ loadMarketingCampaignPage(1);
+});
+
+marketingCampaignRefreshButton?.addEventListener("click", () => {
+ loadMarketingCampaignPage(marketingCampaignPage);
+});
+
+marketingCampaignPagination?.querySelectorAll("[data-marketing-campaign-page]").forEach((button) => {
+ button.addEventListener("click", () => {
+ const action = button.dataset.marketingCampaignPage;
+ const totalPages = Math.max(1, Math.ceil(marketingCampaignTotalRows / MARKETING_CAMPAIGN_PAGE_SIZE));
+ if (action === "first") {
+ loadMarketingCampaignPage(1);
+ } else if (action === "previous") {
+ loadMarketingCampaignPage(Math.max(1, marketingCampaignPage - 1));
+ } else if (action === "next") {
+ loadMarketingCampaignPage(Math.min(totalPages, marketingCampaignPage + 1));
+ } else if (action === "last") {
+ loadMarketingCampaignPage(totalPages);
+ }
+ });
+});
+
+marketingCampaignPageInput?.addEventListener("change", () => {
+ const totalPages = Math.max(1, Math.ceil(marketingCampaignTotalRows / MARKETING_CAMPAIGN_PAGE_SIZE));
+ const requestedPage = Math.min(
+ totalPages,
+ Math.max(1, Number.parseInt(marketingCampaignPageInput.value || "1", 10))
+ );
+ loadMarketingCampaignPage(requestedPage);
+});
diff --git a/frontend/js/marketing_form.js b/frontend/js/marketing_form.js
new file mode 100644
index 0000000..2de95d2
--- /dev/null
+++ b/frontend/js/marketing_form.js
@@ -0,0 +1,188 @@
+const MARKETING_FEE_ATOMIC = 100000000n;
+
+function setMarketingMessage(message, type = "") {
+ setScopedTransactionMessage("Marketing", marketingMessage, message, type);
+}
+
+function decimalToCents(value) {
+ const text = String(value || "").trim();
+ if (!/^\d+(\.\d{0,2})?$/.test(text)) {
+ return null;
+ }
+ const [whole, fraction = ""] = text.split(".");
+ const cents = Number.parseInt(whole || "0", 10) * 100
+ + Number.parseInt(fraction.padEnd(2, "0") || "0", 10);
+ return Number.isInteger(cents) && cents >= 0 && cents <= 65535 ? cents : null;
+}
+
+function updateMarketingDerivedFields() {
+ if (marketingFeeInput) {
+ marketingFeeInput.value = atomicToDecimal(MARKETING_FEE_ATOMIC);
+ }
+ if (marketingAdvertiser) {
+ marketingAdvertiser.textContent = activeWalletAddressShort || activeWalletAddressHex || "--";
+ }
+ if (marketingFeeLabel) {
+ marketingFeeLabel.textContent = `${atomicToDecimal(MARKETING_FEE_ATOMIC)} ${activeBaseCoin()}`;
+ }
+}
+
+function marketingCountValue(input) {
+ const value = Number.parseInt(input?.value || "0", 10);
+ return Number.isInteger(value) && value >= 0 && value <= 255 ? value : null;
+}
+
+function validateMarketingForm() {
+ if (!walletLoaded) {
+ return "Load a wallet before creating a marketing transaction.";
+ }
+ if (!registrationRegistered) {
+ return "Address registration is required before creating a marketing transaction.";
+ }
+ const campaign = String(marketingCampaignInput?.value || "").trim();
+ if (!/^\d+$/.test(campaign)) {
+ return "Campaign ID must be a whole number.";
+ }
+ const keyword = String(marketingKeywordInput?.value || "").trim();
+ if (!keyword) {
+ return "Keyword is required.";
+ }
+ if (!/^[\x20-\x7E]+$/.test(keyword) || keyword.length > 40) {
+ return "Keyword must be ASCII and no longer than 40 characters.";
+ }
+ const displayed = String(marketingDisplayedInput?.value || "").trim();
+ if (!displayed) {
+ return "Displayed location is required.";
+ }
+ if (!/^[\x20-\x7E]+$/.test(displayed) || displayed.length > 100) {
+ return "Displayed location must be ASCII and no longer than 100 characters.";
+ }
+ if (marketingCountValue(marketingImpressionInput) === null) {
+ return "Impressions must be between 0 and 255.";
+ }
+ if (marketingCountValue(marketingClickInput) === null) {
+ return "Clicks must be between 0 and 255.";
+ }
+ if (decimalToCents(marketingImpressionValueInput?.value) === null) {
+ return "Impression value must be between 0.00 and 655.35.";
+ }
+ if (decimalToCents(marketingClickValueInput?.value) === null) {
+ return "Click value must be between 0.00 and 655.35.";
+ }
+ if (baseCoinBalanceAtomic() < MARKETING_FEE_ATOMIC) {
+ return `Marketing transactions require ${atomicToDecimal(MARKETING_FEE_ATOMIC)} ${activeBaseCoin()} for the fee.`;
+ }
+ return "";
+}
+
+function marketingPayload() {
+ return {
+ campaign: String(marketingCampaignInput.value || "0").trim(),
+ adType: marketingAdTypeSelect.value,
+ keyword: String(marketingKeywordInput.value || "").trim(),
+ displayed: String(marketingDisplayedInput.value || "").trim(),
+ impression: marketingCountValue(marketingImpressionInput),
+ click: marketingCountValue(marketingClickInput),
+ impressionValue: decimalToCents(marketingImpressionValueInput.value),
+ clickValue: decimalToCents(marketingClickValueInput.value),
+ txfee: String(MARKETING_FEE_ATOMIC)
+ };
+}
+
+function clearMarketingForm() {
+ marketingCampaignInput.value = "";
+ marketingAdTypeSelect.value = "banner";
+ marketingKeywordInput.value = "";
+ marketingDisplayedInput.value = "";
+ marketingImpressionInput.value = "0";
+ marketingClickInput.value = "0";
+ marketingImpressionValueInput.value = "";
+ marketingClickValueInput.value = "";
+ updateMarketingDerivedFields();
+}
+
+function setMarketingButtonsDisabled(disabled) {
+ document.querySelector("[data-marketing-save]")?.toggleAttribute("disabled", disabled);
+ document.querySelector("[data-marketing-broadcast]")?.toggleAttribute("disabled", disabled);
+}
+
+async function handleMarketingAction(action) {
+ const validationError = validateMarketingForm();
+ if (validationError) {
+ setMarketingMessage(validationError, "error");
+ return;
+ }
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setMarketingMessage("Wallet bridge is not available.", "error");
+ return;
+ }
+ const walletKey = await requestSigningWalletKey();
+ if (guiRuntimeSettings.require_key_before_signing !== false && !walletKey) {
+ setMarketingMessage("Signing cancelled.");
+ return;
+ }
+
+ setMarketingButtonsDisabled(true);
+ try {
+ if (action === "save") {
+ setMarketingMessage("Saving marketing transaction...");
+ const review = await invoke("save_marketing_transaction", {
+ ...marketingPayload(),
+ walletKey
+ });
+ clearMarketingForm();
+ setMarketingMessage(`Marketing transaction saved: ${review.file_name}`, "success");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+ } else {
+ const broadcastNode = activeBroadcastNode();
+ if (!broadcastNode) {
+ throw new Error("Select a broadcast node before broadcasting.");
+ }
+ setMarketingMessage("Broadcasting marketing transaction...");
+ const result = await invoke("broadcast_marketing_transaction", {
+ ...marketingPayload(),
+ broadcastNode,
+ walletKey
+ });
+ clearMarketingForm();
+ setMarketingMessage(result.response || "Marketing transaction broadcast.", "success");
+ }
+ } catch (error) {
+ setMarketingMessage(String(error), "error");
+ } finally {
+ setMarketingButtonsDisabled(false);
+ }
+}
+
+function prepareMarketingForm() {
+ updateMarketingDerivedFields();
+ setMarketingMessage("");
+}
+
+function resetMarketingSession() {
+ clearMarketingForm();
+ setMarketingMessage("");
+}
+
+[
+ marketingCampaignInput,
+ marketingAdTypeSelect,
+ marketingKeywordInput,
+ marketingDisplayedInput,
+ marketingImpressionInput,
+ marketingClickInput,
+ marketingImpressionValueInput,
+ marketingClickValueInput
+].forEach((element) => {
+ element?.addEventListener("input", () => setMarketingMessage(""));
+ element?.addEventListener("change", () => setMarketingMessage(""));
+});
+document
+ .querySelector("[data-marketing-save]")
+ ?.addEventListener("click", () => handleMarketingAction("save"));
+document
+ .querySelector("[data-marketing-broadcast]")
+ ?.addEventListener("click", () => handleMarketingAction("broadcast"));
diff --git a/frontend/js/modals_events.js b/frontend/js/modals_events.js
new file mode 100644
index 0000000..cabd9af
--- /dev/null
+++ b/frontend/js/modals_events.js
@@ -0,0 +1,154 @@
+const nodeInfoButton = document.querySelector("[data-node-info]");
+const nodeModal = document.querySelector("[data-node-modal]");
+const nodeCloseButton = document.querySelector("[data-node-close]");
+const nftInstructionsOpenButton = document.querySelector("[data-nft-instructions-open]");
+const nftInstructionsModal = document.querySelector("[data-nft-instructions-modal]");
+const nftInstructionsCloseButton = document.querySelector("[data-nft-instructions-close]");
+
+function toggleNodeModal(open) {
+ if (!nodeModal) {
+ return;
+ }
+ nodeModal.classList.toggle("hidden", !open);
+ if (open) {
+ startNodeInfoRefresh();
+ return;
+ }
+ stopNodeInfoRefresh();
+}
+
+function toggleNftInstructionsModal(open) {
+ nftInstructionsModal?.classList.toggle("hidden", !open);
+}
+
+nodeInfoButton?.addEventListener("click", () => toggleNodeModal(true));
+nodeCloseButton?.addEventListener("click", () => toggleNodeModal(false));
+nodeModal?.addEventListener("click", (event) => {
+ if (event.target === nodeModal) {
+ toggleNodeModal(false);
+ }
+});
+
+nftInstructionsOpenButton?.addEventListener("click", () => toggleNftInstructionsModal(true));
+nftInstructionsCloseButton?.addEventListener("click", () => toggleNftInstructionsModal(false));
+nftInstructionsModal?.addEventListener("click", (event) => {
+ if (event.target === nftInstructionsModal) {
+ toggleNftInstructionsModal(false);
+ }
+});
+
+document.querySelectorAll(".nft-hosting-links a").forEach((link) => {
+ link.addEventListener("click", async (event) => {
+ event.preventDefault();
+ const url = link.href;
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (invoke) {
+ try {
+ await invoke("open_external_url", { url });
+ return;
+ } catch (error) {
+ console.error(error);
+ }
+ }
+ window.open(url, "_blank", "noopener,noreferrer");
+ });
+});
+
+document.addEventListener("keydown", (event) => {
+ if (event.key === "Escape") {
+ toggleNodeModal(false);
+ toggleNftInstructionsModal(false);
+ if (!walletSwitchModal?.classList.contains("hidden")) {
+ closeWalletSwitchModal();
+ }
+ if (!historyExportModal?.classList.contains("hidden")) {
+ toggleHistoryExportModal(false);
+ }
+ if (!backupKeyModal?.classList.contains("hidden")) {
+ closeBackupKeyModal(null);
+ }
+ }
+});
+
+topWalletListSelect?.addEventListener("change", () => {
+ const selectedWalletPath = topWalletListSelect.value;
+
+ if (!selectedWalletPath || selectedWalletPath === activeWalletPath) {
+ restoreActiveWalletSelection();
+ return;
+ }
+
+ openWalletSwitchModal(selectedWalletPath);
+});
+
+walletSwitchForm?.addEventListener("submit", async (event) => {
+ event.preventDefault();
+ if (!pendingWalletSwitch) {
+ closeWalletSwitchModal();
+ return;
+ }
+
+ const walletKey = walletSwitchKeyInput?.value || "";
+ if (!walletKey.trim()) {
+ setWalletSwitchMessage("Wallet key cannot be empty.", "error");
+ walletSwitchKeyInput?.focus();
+ return;
+ }
+
+ if (walletSwitchSubmit) {
+ walletSwitchSubmit.disabled = true;
+ }
+ setWalletSwitchMessage("Unlocking wallet...");
+
+ try {
+ const wallet = await loadWalletByPath(pendingWalletSwitch.walletPath, walletKey);
+ updateActiveWallet(wallet);
+ document.body.classList.add("wallet-open");
+ closeWalletSwitchModal({ restoreSelection: false });
+ await populateTopWalletList();
+ } catch (error) {
+ setWalletSwitchMessage(String(error), "error");
+ walletSwitchKeyInput?.focus();
+ } finally {
+ if (walletSwitchSubmit) {
+ walletSwitchSubmit.disabled = false;
+ }
+ }
+});
+
+walletSwitchCloseButton?.addEventListener("click", () => closeWalletSwitchModal());
+walletSwitchCancelButton?.addEventListener("click", () => closeWalletSwitchModal());
+walletSwitchModal?.addEventListener("click", (event) => {
+ if (event.target === walletSwitchModal) {
+ closeWalletSwitchModal();
+ }
+});
+
+broadcastNodeButton?.addEventListener("change", () => {
+ if (!walletLoaded) {
+ return;
+ }
+
+ if (currentView === "send" && !issueTokenForm?.classList.contains("hidden")) {
+ refreshIssueTokenList();
+ }
+
+ if (registrationRegistered) {
+ resetLatestDashboardTransactionsMemory();
+ stopLatestDashboardTransactionsPolling();
+ refreshReceivePage();
+ startRegisteredDashboardLoadSequence({ resetTransactions: true });
+ stopNetworkInfoRefresh();
+ updateNetworkInfoRefreshState();
+ if (!nodeModal?.classList.contains("hidden")) {
+ refreshNetworkInfo({ target: "node", force: true });
+ }
+ return;
+ }
+
+ refreshNetworkInfo({ target: "dashboard", force: !nodeModal?.classList.contains("hidden") });
+ refreshReceivePage();
+ checkWalletRegistrationOnce();
+});
+
+populateBroadcastNodeList();
diff --git a/frontend/js/navigation_actions.js b/frontend/js/navigation_actions.js
new file mode 100644
index 0000000..92ff80e
--- /dev/null
+++ b/frontend/js/navigation_actions.js
@@ -0,0 +1,401 @@
+function setActiveView(view) {
+ if (view === "transactions") {
+ view = "history";
+ }
+
+ const previousView = currentView;
+ if (previousView === "send" && view !== "send" && typeof resetTransactionForms === "function") {
+ resetTransactionForms();
+ }
+ if (previousView === "marketing" && view !== "marketing" && typeof resetMarketingCampaignPage === "function") {
+ resetMarketingCampaignPage();
+ }
+ if (previousView === "nfts" && view !== "nfts" && typeof resetNftsPage === "function") {
+ resetNftsPage();
+ }
+
+ const [title, subtitle] = titles[view] || titles.dashboard;
+ currentView = view;
+
+ navButtons.forEach((button) => {
+ button.classList.toggle("active", button.dataset.view === view);
+ });
+ closeMobileMoreMenu();
+ document.querySelector("[data-mobile-more]")?.classList.toggle(
+ "active",
+ ["assets", "marketing", "addressbook", "settings"].includes(view)
+ );
+
+ if (viewTitle) {
+ viewTitle.textContent = title;
+ }
+ if (viewSubtitle) {
+ viewSubtitle.textContent = subtitle;
+ }
+
+ if (view === "dashboard") {
+ dashboardView.classList.remove("hidden");
+ transactionView.classList.add("hidden");
+ receiveView.classList.add("hidden");
+ historyView.classList.add("hidden");
+ assetsView.classList.add("hidden");
+ nftsView.classList.add("hidden");
+ loansView.classList.add("hidden");
+ marketingView.classList.add("hidden");
+ addressbookView.classList.add("hidden");
+ settingsView.classList.add("hidden");
+ updateNetworkInfoRefreshState();
+ if (registrationRegistered) {
+ startRegisteredDashboardLoadSequence({ quiet: true });
+ } else {
+ updateBalanceRefreshState();
+ updateLatestDashboardTransactionsPolling();
+ }
+ updateHistoryRefreshState();
+ return;
+ }
+
+ updateBalanceRefreshState();
+ updateNetworkInfoRefreshState();
+ updateLatestDashboardTransactionsPolling();
+ updateHistoryRefreshState();
+ dashboardView.classList.add("hidden");
+ transactionView.classList.add("hidden");
+ receiveView.classList.add("hidden");
+ historyView.classList.add("hidden");
+ assetsView.classList.add("hidden");
+ nftsView.classList.add("hidden");
+ loansView.classList.add("hidden");
+ marketingView.classList.add("hidden");
+ addressbookView.classList.add("hidden");
+ settingsView.classList.add("hidden");
+
+ if (view === "receive") {
+ receiveView.classList.remove("hidden");
+ refreshReceivePage();
+ return;
+ }
+
+ if (view === "history") {
+ historyView.classList.remove("hidden");
+ updateHistoryRefreshState();
+ return;
+ }
+
+ if (view === "assets") {
+ assetsView.classList.remove("hidden");
+ prepareAssetsPage();
+ return;
+ }
+
+ if (view === "nfts") {
+ nftsView.classList.remove("hidden");
+ prepareNftsPage();
+ return;
+ }
+
+ if (view === "loans") {
+ loansView.classList.remove("hidden");
+ prepareLoansPage();
+ return;
+ }
+
+ if (view === "marketing") {
+ marketingView.classList.remove("hidden");
+ prepareMarketingCampaignPage();
+ return;
+ }
+
+ if (view === "addressbook") {
+ addressbookView.classList.remove("hidden");
+ prepareAddressBookPage();
+ return;
+ }
+
+ if (view === "settings") {
+ settingsView.classList.remove("hidden");
+ loadSettingsPage();
+ return;
+ }
+
+ transactionView.classList.remove("hidden");
+
+ if (view === "send") {
+ setActiveTransactionType("Transfer");
+ showTransactionList();
+ return;
+ }
+
+ showTransactionList(title, subtitle);
+}
+
+navButtons.forEach((button) => {
+ button.addEventListener("click", () => setActiveView(button.dataset.view));
+});
+
+function setMobileMoreMenuOpen(open) {
+ const moreButton = document.querySelector("[data-mobile-more]");
+ const backdrop = document.querySelector("[data-mobile-more-backdrop]");
+ const sheet = document.querySelector("[data-mobile-more-sheet]");
+ moreButton?.setAttribute("aria-expanded", open ? "true" : "false");
+ backdrop?.classList.toggle("hidden", !open);
+ sheet?.classList.toggle("hidden", !open);
+}
+
+function closeMobileMoreMenu() {
+ setMobileMoreMenuOpen(false);
+}
+
+document.querySelector("[data-mobile-more]")?.addEventListener("click", () => {
+ const moreButton = document.querySelector("[data-mobile-more]");
+ setMobileMoreMenuOpen(moreButton?.getAttribute("aria-expanded") !== "true");
+});
+
+document.querySelector("[data-mobile-more-backdrop]")?.addEventListener("click", closeMobileMoreMenu);
+
+function showTransactionList(title = "Unbroadcast Transactions", copy = "Transactions saved locally and waiting for review.") {
+ currentTransactionType = "";
+ transactionTitle.textContent = title;
+ transactionCopy.textContent = copy;
+ transactionList.classList.remove("hidden");
+ formPanel.classList.add("hidden");
+ reviewPanel.classList.add("hidden");
+ unbroadcastListMessage?.classList.remove("hidden");
+ if (typeof refreshUnbroadcastTransactions === "function") {
+ refreshUnbroadcastTransactions();
+ }
+}
+
+function setActiveTransactionType(type = "Transfer") {
+ document
+ .querySelectorAll("[data-transaction-type]")
+ .forEach((item) => item.classList.toggle("active", item.dataset.transactionType === type));
+}
+
+function refreshActiveTransactionFormAfterWalletData() {
+ if (currentView !== "send" || !currentTransactionType || !walletLoaded || !registrationRegistered) {
+ return;
+ }
+
+ if (currentTransactionType === "Transfer" && typeof refreshTransferBalancesIfNeeded === "function") {
+ refreshTransferBalancesIfNeeded().catch(() => {});
+ } else if (currentTransactionType === "Issue More Tokens" && typeof prepareIssueTokenForm === "function") {
+ prepareIssueTokenForm();
+ } else if (currentTransactionType === "Create NFT" && typeof prepareCreateNftForm === "function") {
+ prepareCreateNftForm();
+ } else if (currentTransactionType === "Swap" && typeof prepareSwapOfferForm === "function") {
+ prepareSwapOfferForm();
+ } else if (currentTransactionType === "Create Loan" && typeof prepareLoanOfferForm === "function") {
+ prepareLoanOfferForm();
+ } else if (currentTransactionType === "Loan Payment" && typeof prepareLoanPaymentForm === "function") {
+ prepareLoanPaymentForm();
+ } else if (currentTransactionType === "Collateral Claim" && typeof prepareCollateralClaimForm === "function") {
+ prepareCollateralClaimForm();
+ } else if (currentTransactionType === "Burn" && typeof prepareBurnForm === "function") {
+ prepareBurnForm();
+ }
+}
+
+function isActiveTransactionType(type) {
+ return currentView === "send" && currentTransactionType === type;
+}
+
+function clearInactiveTransactionMessages(activeType) {
+ const messageByType = {
+ "Transfer": transferMessage,
+ "Create Token": createTokenMessage,
+ "Issue More Tokens": issueTokenMessage,
+ "Create NFT": createNftMessage,
+ "Swap": swapOfferMessage,
+ "Create Loan": loanOfferMessage,
+ "Loan Payment": loanPaymentMessage,
+ "Collateral Claim": collateralClaimMessage,
+ "Burn": burnMessage,
+ "Marketing": marketingMessage,
+ "Vanity Address": vanityMessage
+ };
+ Object.entries(messageByType).forEach(([type, element]) => {
+ if (!element || type === activeType) {
+ return;
+ }
+ element.textContent = "";
+ element.classList.add("hidden");
+ element.classList.remove("error", "success");
+ });
+}
+
+function showTransactionForm(type) {
+ currentTransactionType = type;
+ clearInactiveTransactionMessages(type);
+ transactionTitle.textContent = type;
+ transactionCopy.textContent = "Create, save, or broadcast this transaction type.";
+ transactionList.classList.add("hidden");
+ unbroadcastListMessage?.classList.add("hidden");
+ reviewPanel.classList.add("hidden");
+ formPanel.classList.remove("hidden");
+
+ const isTransfer = type === "Transfer";
+ const isCreateToken = type === "Create Token";
+ const isIssueToken = type === "Issue More Tokens";
+ const isCreateNft = type === "Create NFT";
+ const isSwap = type === "Swap";
+ const isLoan = type === "Create Loan";
+ const isLoanPayment = type === "Loan Payment";
+ const isCollateralClaim = type === "Collateral Claim";
+ const isBurn = type === "Burn";
+ const isMarketing = type === "Marketing";
+ const isVanity = type === "Vanity Address";
+ document.querySelector("[data-transfer-form]")?.classList.toggle("hidden", !isTransfer);
+ transferActions?.classList.toggle("hidden", !isTransfer);
+ transferMessage?.classList.toggle("hidden", !isTransfer);
+ createTokenForm?.classList.toggle("hidden", !isCreateToken);
+ createTokenActions?.classList.toggle("hidden", !isCreateToken);
+ createTokenMessage?.classList.toggle("hidden", !isCreateToken);
+ issueTokenForm?.classList.toggle("hidden", !isIssueToken);
+ issueTokenActions?.classList.toggle("hidden", !isIssueToken);
+ issueTokenMessage?.classList.toggle("hidden", !isIssueToken);
+ createNftForm?.classList.toggle("hidden", !isCreateNft);
+ createNftActions?.classList.toggle("hidden", !isCreateNft);
+ createNftMessage?.classList.toggle("hidden", !isCreateNft);
+ swapOfferForm?.classList.toggle("hidden", !isSwap);
+ swapOfferActions?.classList.toggle("hidden", !isSwap);
+ swapOfferMessage?.classList.toggle("hidden", !isSwap);
+ loanOfferForm?.classList.toggle("hidden", !isLoan);
+ loanOfferActions?.classList.toggle("hidden", !isLoan);
+ loanSavedPathPanel?.classList.toggle("hidden", !isLoan || !loanSavedPathInput?.value);
+ loanOfferMessage?.classList.toggle("hidden", !isLoan);
+ loanPaymentForm?.classList.toggle("hidden", !isLoanPayment);
+ loanPaymentActions?.classList.toggle("hidden", !isLoanPayment);
+ loanPaymentMessage?.classList.toggle("hidden", !isLoanPayment);
+ collateralClaimForm?.classList.toggle("hidden", !isCollateralClaim);
+ collateralClaimActions?.classList.toggle("hidden", !isCollateralClaim);
+ collateralClaimMessage?.classList.toggle("hidden", !isCollateralClaim);
+ burnForm?.classList.toggle("hidden", !isBurn);
+ burnActions?.classList.toggle("hidden", !isBurn);
+ burnMessage?.classList.toggle("hidden", !isBurn);
+ marketingForm?.classList.toggle("hidden", !isMarketing);
+ marketingActions?.classList.toggle("hidden", !isMarketing);
+ marketingMessage?.classList.toggle("hidden", !isMarketing);
+ vanityForm?.classList.toggle("hidden", !isVanity);
+ vanityActions?.classList.toggle("hidden", !isVanity);
+ vanityMessage?.classList.toggle("hidden", !isVanity);
+
+ if (isTransfer && typeof prepareTransferForm === "function") {
+ prepareTransferForm();
+ } else if (isCreateToken && typeof prepareCreateTokenForm === "function") {
+ prepareCreateTokenForm();
+ } else if (isIssueToken && typeof prepareIssueTokenForm === "function") {
+ prepareIssueTokenForm();
+ } else if (isCreateNft && typeof prepareCreateNftForm === "function") {
+ prepareCreateNftForm();
+ } else if (isSwap && typeof prepareSwapOfferForm === "function") {
+ prepareSwapOfferForm();
+ } else if (isLoan && typeof prepareLoanOfferForm === "function") {
+ prepareLoanOfferForm();
+ } else if (isLoanPayment && typeof prepareLoanPaymentForm === "function") {
+ prepareLoanPaymentForm();
+ } else if (isCollateralClaim && typeof prepareCollateralClaimForm === "function") {
+ prepareCollateralClaimForm();
+ } else if (isBurn && typeof prepareBurnForm === "function") {
+ prepareBurnForm();
+ } else if (isMarketing && typeof prepareMarketingForm === "function") {
+ prepareMarketingForm();
+ } else if (isVanity && typeof prepareVanityAddressForm === "function") {
+ prepareVanityAddressForm();
+ }
+}
+
+function openTransactionType(type) {
+ setActiveView("send");
+ setActiveTransactionType(type);
+ showTransactionForm(type);
+}
+
+function openImportTransaction() {
+ setActiveView("send");
+ if (typeof showUnbroadcastList === "function") {
+ showUnbroadcastList();
+ return;
+ }
+ showTransactionList();
+}
+
+function showTransactionReview() {
+ transactionTitle.textContent = "Review Transaction";
+ transactionCopy.textContent = "Inspect this local transaction before broadcasting.";
+ transactionList.classList.add("hidden");
+ formPanel.classList.add("hidden");
+ reviewPanel.classList.remove("hidden");
+}
+
+document.querySelectorAll("[data-transaction-type]").forEach((button) => {
+ button.addEventListener("click", () => {
+ setActiveTransactionType(button.dataset.transactionType);
+ showTransactionForm(button.dataset.transactionType);
+ });
+});
+
+document.querySelector("[data-open-create-transaction]")?.addEventListener("click", () => {
+ openTransactionType("Transfer");
+});
+
+document.querySelector("[data-view-all-transactions]")?.addEventListener("click", () => {
+ setActiveView("history");
+});
+
+document.querySelector("[data-open-import-transaction]")?.addEventListener("click", () => {
+ openImportTransaction();
+});
+
+document.querySelector("[data-open-vanity-transaction]")?.addEventListener("click", () => {
+ openTransactionType("Vanity Address");
+});
+
+document.querySelector("[data-open-address-book]")?.addEventListener("click", () => {
+ setActiveView("addressbook");
+});
+
+function flashCopyButton(button) {
+ if (!button) {
+ return;
+ }
+ const original = button.textContent || "Copy";
+ button.textContent = "Copied";
+ setTimeout(() => {
+ button.textContent = original;
+ }, 1200);
+}
+
+async function copyReceiveValue(selector, button) {
+ const value = document.querySelector(selector)?.textContent?.trim();
+ if (value && value !== "N/A" && await writeClipboardText(value)) {
+ flashCopyButton(button);
+ }
+}
+
+document.querySelector("[data-copy-address]")?.addEventListener("click", async (event) => {
+ await copyReceiveValue("[data-active-address]", event.currentTarget);
+});
+
+document.querySelector("[data-copy-vanity]")?.addEventListener("click", async (event) => {
+ await copyReceiveValue("[data-active-vanity]", event.currentTarget);
+});
+
+document.querySelectorAll("[data-copy-hash]").forEach((button) => {
+ button.addEventListener("click", () => {
+ const original = button.textContent;
+ button.textContent = "Copied";
+ setTimeout(() => {
+ button.textContent = original;
+ }, 1200);
+ });
+});
+
+document.querySelectorAll("[data-loan-card]").forEach((button) => {
+ button.addEventListener("click", () => {
+ document
+ .querySelectorAll("[data-loan-card]")
+ .forEach((item) => item.classList.toggle("active", item === button));
+ });
+});
+
diff --git a/frontend/js/nfts_page.js b/frontend/js/nfts_page.js
new file mode 100644
index 0000000..da4b392
--- /dev/null
+++ b/frontend/js/nfts_page.js
@@ -0,0 +1,597 @@
+let ownedNfts = [];
+let ownedNftRows = [];
+let selectedNftKey = "";
+let nftsLoadId = 0;
+let nftsLoading = false;
+let nftsPage = 1;
+let nftsCachingVisible = false;
+const NFTS_PAGE_SIZE = 30;
+const nftMetadataCache = new Map();
+
+function nftKey(nft) {
+ return `${String(nft.nft_name || nft.asset || "").trim().toLowerCase()}|${Number(nft.series || nft.nft_series || 0)}`;
+}
+
+function nftCacheKey(nft) {
+ return `${String(nft.nft_name || nft.asset || "").trim().toLowerCase()}_${Number(nft.series || nft.nft_series || 0)}`;
+}
+
+function escapeNftText(value) {
+ return String(value ?? "")
+ .replaceAll("&", "&")
+ .replaceAll("<", "<")
+ .replaceAll(">", ">")
+ .replaceAll('"', """)
+ .replaceAll("'", "'");
+}
+
+function shortenNftTx(txid) {
+ const value = String(txid || "");
+ return value.length > 16 ? `${value.slice(0, 6)}...${value.slice(-8)}` : value || "--";
+}
+
+function nftDisplayName(nft) {
+ const metadataName = String(nft.metadata?.name || "").trim();
+ if (metadataName) {
+ return metadataName;
+ }
+ const name = String(nft.nft_name || nft.asset || "NFT").trim();
+ return Number(nft.series || 0) > 0 ? `${name} #${Number(nft.series)}` : name;
+}
+
+function nftImageUri(nft) {
+ const cachedImage = String(nft.image_data_url || nft.imageDataUrl || "").trim();
+ if (cachedImage) {
+ return cachedImage;
+ }
+ return String(
+ nft.metadata?.image
+ || nft.metadata?.image_url
+ || nft.metadata?.animation_url
+ || ""
+ ).trim();
+}
+
+function normalizeIpfsGateway(gateway) {
+ const fallback = "https://gateway.pinata.cloud/ipfs/";
+ const clean = String(gateway || "").trim() || fallback;
+ return clean.endsWith("/") ? clean : `${clean}/`;
+}
+
+function normalizeIpfsPath(value) {
+ let path = String(value || "").trim();
+ let previous = "";
+ while (path && path !== previous) {
+ previous = path;
+ path = path
+ .replace(/^ipfs:\/\//i, "")
+ .replace(/^ipfs:\//i, "")
+ .replace(/^ipfs:/i, "")
+ .replace(/^\/?ipfs\//i, "")
+ .replace(/^\/+/, "");
+ }
+ return path;
+}
+
+function ipfsToGatewayUrl(uri, gateway) {
+ const value = String(uri || "").trim();
+ if (!value) {
+ return "";
+ }
+ if (value.startsWith("http://") || value.startsWith("https://")) {
+ return value;
+ }
+ if (value.startsWith("data:image/")) {
+ return value;
+ }
+ const path = normalizeIpfsPath(value);
+ return `${normalizeIpfsGateway(gateway)}${path}`;
+}
+
+function nftTypeLabel(nft) {
+ const metadataType = String(nft.metadata?.contractless?.metadata_type || "").trim();
+ if (metadataType.toLowerCase() === "rwa") {
+ return "RWA";
+ }
+ if (nftImageUri(nft)) {
+ return "Image NFT";
+ }
+ return "NFT";
+}
+
+function setNftsState(message) {
+ if (nftsState) {
+ nftsState.textContent = message || "";
+ }
+}
+
+function setNftDetailText(element, value) {
+ if (element) {
+ element.textContent = value || "--";
+ }
+}
+
+function resetNftDetails(message = "Select an owned NFT.") {
+ if (nftDetailTitle) {
+ nftDetailTitle.textContent = "NFT Details";
+ }
+ if (nftDetailSubtitle) {
+ nftDetailSubtitle.textContent = message;
+ }
+ setNftDetailText(nftDetailName, "");
+ setNftDetailText(nftDetailAsset, "");
+ setNftDetailText(nftDetailCreator, "");
+ setNftDetailText(nftDetailGenesis, "");
+ setNftDetailText(nftDetailMetadata, "");
+ if (nftMetadataSummary) {
+ nftMetadataSummary.innerHTML = "";
+ }
+ if (nftHistory) {
+ nftHistory.innerHTML = "";
+ }
+}
+
+function hasOwnedBalance(balance) {
+ try {
+ return BigInt(String(balance?.balance || "0")) > 0n;
+ } catch (_) {
+ return Number(balance?.balance || 0) > 0;
+ }
+}
+
+function ownedNftRowsFromBalances(balances, registry) {
+ const normalizedBalances = Array.isArray(balances) ? balances : [];
+ const registryRows = Array.isArray(registry) ? registry : [];
+ const balanceByAsset = new Map();
+ normalizedBalances.forEach((balance) => {
+ if (!hasOwnedBalance(balance)) {
+ return;
+ }
+ const asset = String(balance.asset || "").trim().toLowerCase();
+ const series = Number(balance.nft_series || 0);
+ balanceByAsset.set(`${asset}|${series}`, balance);
+ });
+
+ return registryRows
+ .map((nft) => {
+ const nftName = String(nft.nft_name || "").trim();
+ const series = Number(nft.series || 0);
+ const balance = balanceByAsset.get(`${nftName.toLowerCase()}|${series}`);
+ if (!balance) {
+ return null;
+ }
+ return {
+ asset: nftName,
+ nft_name: nftName,
+ series,
+ balance: String(balance.balance || "0"),
+ origin_txid: nft.origin_txid || ""
+ };
+ })
+ .filter(Boolean)
+ .filter((nft) => nft.nft_name);
+}
+
+function legacyOwnedNftRowsFromBalances(balances) {
+ return (Array.isArray(balances) ? balances : [])
+ .filter((balance) => {
+ const series = Number(balance.nft_series || 0);
+ let owned = false;
+ try {
+ owned = BigInt(String(balance.balance || "0")) > 0n;
+ } catch (_) {
+ owned = Number(balance.balance || 0) > 0;
+ }
+ return series > 0 && owned;
+ })
+ .map((balance) => ({
+ asset: String(balance.asset || "").trim(),
+ nft_name: String(balance.asset || "").trim(),
+ series: Number(balance.nft_series || 0),
+ balance: String(balance.balance || "0")
+ }))
+ .filter((nft) => nft.nft_name);
+}
+
+function metadataDescription(metadata) {
+ return String(metadata?.description || metadata?.summary || "").trim();
+}
+
+function renderNftCard(nft) {
+ const key = nftKey(nft);
+ const name = nftDisplayName(nft);
+ const image = nftImageUri(nft);
+ const type = nftTypeLabel(nft);
+ const active = key === selectedNftKey ? " active" : "";
+ const preview = image && nft.gateway
+ ? `${escapeNftText(assetInitial(name))}
`;
+
+ return `
+
+ ${preview}
+
+
+ ${escapeNftText(name)}
+ ${escapeNftText(type)} - ${escapeNftText(nft.asset_name || `${nft.nft_name}_${nft.series}`)}
+
+
+ Metadata
+ ${escapeNftText(nft.metadata_uri || nft.item_ipfs || "--")}
+
+
+ View Details
+
+
+ `;
+}
+
+function renderNftHistoryEntry(entry) {
+ const asset = entry.received_asset
+ ? `${entry.received_asset}${Number(entry.received_series || 0) > 0 ? ` #${entry.received_series}` : ""}`
+ : "";
+ return `
+
+
+ ${escapeNftText(entry.action || "Unknown")}
+ Block ${escapeNftText(formatNumber(entry.block || 0))}
+
+
${escapeNftText(shortenNftTx(entry.txid || ""))}
+ ${entry.from ? `
From ${escapeNftText(shortenAddress(entry.from))}
` : ""}
+ ${entry.to ? `
To ${escapeNftText(shortenAddress(entry.to))}
` : ""}
+ ${asset ? `
Received ${escapeNftText(asset)}
` : ""}
+
${escapeNftText(description)}
`);
+ }
+ if (attributes.length) {
+ parts.push(`
+
+ ${attributes.slice(0, 8).map((attribute) => `
+
+ ${escapeNftText(attribute.trait_type || attribute.type || "Trait")}
+ ${escapeNftText(attribute.value ?? "")}
+
+ `).join("")}
+
+ ${Object.entries(contractless).slice(0, 6).map(([key, value]) => `
+
${escapeNftText(key)} ${escapeNftText(value)}
+ `).join("")}
+
No metadata summary available.
";
+}
+
+function renderNftDetails(nft) {
+ if (!nft) {
+ resetNftDetails();
+ return;
+ }
+
+ const name = nftDisplayName(nft);
+ if (nftDetailTitle) {
+ nftDetailTitle.textContent = name;
+ }
+ if (nftDetailSubtitle) {
+ nftDetailSubtitle.textContent = nftTypeLabel(nft);
+ }
+
+ setNftDetailText(nftDetailName, name);
+ setNftDetailText(nftDetailAsset, nft.asset_name || `${nft.nft_name}_${nft.series}`);
+ setNftDetailText(nftDetailCreator, nft.creator ? shortenAddress(nft.creator) : "");
+ setNftDetailText(nftDetailGenesis, nft.genesis_txid ? shortenNftTx(nft.genesis_txid) : "");
+ setNftDetailText(nftDetailMetadata, nft.metadata_uri || nft.item_ipfs || "");
+
+ if (nftMetadataSummary) {
+ nftMetadataSummary.innerHTML = renderNftMetadataSummary(nft);
+ }
+ if (nftHistory) {
+ nftHistory.innerHTML = Array.isArray(nft.history) && nft.history.length
+ ? nft.history.map(renderNftHistoryEntry).join("")
+ : 'No provenance records returned.
';
+ }
+}
+
+function renderNftsPage() {
+ if (!nftsList) {
+ return;
+ }
+ nftsList.innerHTML = ownedNfts.map(renderNftCard).join("");
+ const selected = ownedNfts.find((nft) => nftKey(nft) === selectedNftKey) || ownedNfts[0];
+ selectedNftKey = selected ? nftKey(selected) : "";
+ renderNftDetails(selected);
+
+ if (!walletLoaded) {
+ setNftsState("Load a wallet to view NFTs.");
+ } else if (!ownedNftRows.length) {
+ setNftsState(nftsLoading ? "Loading owned NFTs..." : "No owned NFTs found for this address.");
+ } else if (!ownedNfts.length) {
+ const start = (nftsPage - 1) * NFTS_PAGE_SIZE + 1;
+ const end = Math.min(start + NFTS_PAGE_SIZE - 1, ownedNftRows.length);
+ const suffix = nftsCachingVisible ? " - Caching media..." : "";
+ setNftsState(`Loading ${start}-${end} of ${ownedNftRows.length} NFTs${suffix}`);
+ } else {
+ const start = (nftsPage - 1) * NFTS_PAGE_SIZE + 1;
+ const end = Math.min(start + ownedNfts.length - 1, ownedNftRows.length);
+ const suffix = nftsCachingVisible ? " - Caching media..." : "";
+ setNftsState(`Showing ${start}-${end} of ${ownedNftRows.length} NFTs${suffix}`);
+ }
+ renderNftsPagination();
+}
+
+async function loadNftMetadata(invoke, detail, gateway) {
+ const metadataUri = detail.metadata_uri || detail.item_ipfs || "";
+ if (!metadataUri) {
+ return null;
+ }
+ const cacheKey = `${gateway}|${metadataUri}`;
+ if (nftMetadataCache.has(cacheKey)) {
+ return nftMetadataCache.get(cacheKey);
+ }
+ const metadata = await invoke("fetch_ipfs_metadata", {
+ ipfsPath: metadataUri,
+ gateway
+ });
+ nftMetadataCache.set(cacheKey, metadata);
+ return metadata;
+}
+
+function nftFromCache(row, cached, gateway) {
+ const detail = cached?.detail && typeof cached.detail === "object" ? cached.detail : {};
+ const metadata = cached?.metadata && typeof cached.metadata === "object" ? cached.metadata : {};
+ return {
+ ...row,
+ ...detail,
+ metadata,
+ image_data_url: cached?.image_data_url || "",
+ gateway
+ };
+}
+
+function renderNftsPagination() {
+ if (!nftsPagination) {
+ return;
+ }
+ const totalPages = Math.max(1, Math.ceil(ownedNftRows.length / NFTS_PAGE_SIZE));
+ const showPagination = ownedNftRows.length > NFTS_PAGE_SIZE;
+ nftsPagination.hidden = !showPagination;
+ if (nftsPageTotal) {
+ nftsPageTotal.textContent = String(totalPages);
+ }
+ if (nftsPageInput && Number(nftsPageInput.value) !== nftsPage) {
+ nftsPageInput.value = String(nftsPage);
+ }
+ document.querySelectorAll("[data-nfts-page]").forEach((button) => {
+ const action = button.dataset.nftsPage;
+ button.disabled = !showPagination
+ || (["first", "previous"].includes(action) && nftsPage <= 1)
+ || (["next", "last"].includes(action) && nftsPage >= totalPages);
+ });
+}
+
+function clampNftsPage(page) {
+ const totalPages = Math.max(1, Math.ceil(ownedNftRows.length / NFTS_PAGE_SIZE));
+ return Math.min(Math.max(1, Number(page) || 1), totalPages);
+}
+
+function visibleNftRows() {
+ const start = (nftsPage - 1) * NFTS_PAGE_SIZE;
+ return ownedNftRows.slice(start, start + NFTS_PAGE_SIZE);
+}
+
+async function hydrateVisibleNftPage({ loadId, gateway, broadcastNode, force }) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke || loadId !== nftsLoadId) {
+ return;
+ }
+ const rows = visibleNftRows();
+ const loaded = [];
+ nftsCachingVisible = false;
+ for (const row of rows) {
+ if (loadId !== nftsLoadId || currentView !== "nfts") {
+ return;
+ }
+ try {
+ if (!force) {
+ const cached = await invoke("read_nft_cache", {
+ nftName: row.nft_name,
+ series: row.series
+ });
+ if (cached) {
+ loaded.push(nftFromCache(row, cached, gateway));
+ ownedNfts = loaded.slice();
+ renderNftsPage();
+ continue;
+ }
+ }
+
+ nftsCachingVisible = true;
+ renderNftsPage();
+ const detail = await invoke("nft_details", {
+ broadcastNode,
+ nftName: row.nft_name,
+ series: row.series
+ });
+ let metadata = null;
+ try {
+ metadata = await loadNftMetadata(invoke, detail, gateway);
+ } catch (error) {
+ metadata = { description: `Metadata unavailable: ${String(error)}` };
+ }
+ const imageUrl = ipfsToGatewayUrl(
+ String(metadata?.image || metadata?.image_url || metadata?.animation_url || ""),
+ gateway
+ );
+ let cacheRecord = null;
+ try {
+ cacheRecord = await invoke("write_nft_cache", {
+ nftName: row.nft_name,
+ series: row.series,
+ detailJson: JSON.stringify(detail),
+ metadataJson: JSON.stringify(metadata || {}),
+ imageUrl
+ });
+ } catch (_) {
+ cacheRecord = null;
+ }
+
+ loaded.push(cacheRecord ? nftFromCache(row, cacheRecord, gateway) : {
+ ...row,
+ ...detail,
+ metadata,
+ gateway
+ });
+ ownedNfts = loaded.slice();
+ renderNftsPage();
+ } catch (error) {
+ loaded.push({
+ ...row,
+ metadata: { description: `NFT details unavailable: ${String(error)}` },
+ gateway
+ });
+ ownedNfts = loaded.slice();
+ renderNftsPage();
+ }
+ }
+ nftsCachingVisible = false;
+ ownedNfts = loaded;
+ renderNftsPage();
+}
+
+async function prepareNftsPage({ force = false } = {}) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!walletLoaded) {
+ ownedNfts = [];
+ ownedNftRows = [];
+ renderNftsPage();
+ return;
+ }
+ if (!invoke || !broadcastNode) {
+ ownedNfts = [];
+ ownedNftRows = [];
+ setNftsState("NFT lookup skipped: wallet bridge or broadcast node is unavailable.");
+ renderNftsPage();
+ return;
+ }
+ if (nftsLoading && !force) {
+ return;
+ }
+
+ const loadId = ++nftsLoadId;
+ nftsLoading = true;
+ nftsCachingVisible = false;
+ renderNftsPage();
+
+ try {
+ const [balances, settings, nftRegistry] = await Promise.all([
+ invoke("get_active_wallet_balances", { broadcastNode }),
+ invoke("read_gui_settings"),
+ invoke("nft_list", { broadcastNode })
+ ]);
+ if (loadId !== nftsLoadId || currentView !== "nfts") {
+ return;
+ }
+
+ const gateway = normalizeIpfsGateway(settings?.ipfs_gateway);
+ ownedNftRows = ownedNftRowsFromBalances(balances, nftRegistry);
+ if (!ownedNftRows.length && !Array.isArray(nftRegistry)) {
+ ownedNftRows = legacyOwnedNftRowsFromBalances(balances);
+ }
+ nftsPage = clampNftsPage(nftsPage);
+ invoke("prune_nft_cache", {
+ keepKeys: ownedNftRows.map(nftCacheKey)
+ }).catch(() => {});
+
+ ownedNfts = [];
+ renderNftsPage();
+ await hydrateVisibleNftPage({ loadId, gateway, broadcastNode, force });
+ } catch (error) {
+ ownedNfts = [];
+ ownedNftRows = [];
+ setNftsState(String(error));
+ } finally {
+ if (loadId === nftsLoadId) {
+ nftsLoading = false;
+ renderNftsPage();
+ }
+ }
+}
+
+function resetNftsPage() {
+ nftsLoadId += 1;
+ ownedNfts = [];
+ ownedNftRows = [];
+ selectedNftKey = "";
+ nftsPage = 1;
+ nftsLoading = false;
+ nftsCachingVisible = false;
+ resetNftDetails();
+ renderNftsPage();
+}
+
+nftsList?.addEventListener("click", (event) => {
+ const button = event.target.closest("[data-nft-select]");
+ const card = event.target.closest("[data-nft-key]");
+ const key = button?.dataset.nftSelect || card?.dataset.nftKey || "";
+ if (!key) {
+ return;
+ }
+ selectedNftKey = key;
+ renderNftsPage();
+});
+
+nftsRefreshButton?.addEventListener("click", () => {
+ nftMetadataCache.clear();
+ prepareNftsPage({ force: true });
+});
+
+function reloadNftPageFromControls(force = false) {
+ nftsLoadId += 1;
+ nftsLoading = false;
+ nftsCachingVisible = false;
+ ownedNfts = [];
+ selectedNftKey = "";
+ prepareNftsPage({ force });
+}
+
+document.querySelectorAll("[data-nfts-page]").forEach((button) => {
+ button.addEventListener("click", () => {
+ const totalPages = Math.max(1, Math.ceil(ownedNftRows.length / NFTS_PAGE_SIZE));
+ const action = button.dataset.nftsPage;
+ if (action === "first") {
+ nftsPage = 1;
+ } else if (action === "previous") {
+ nftsPage = clampNftsPage(nftsPage - 1);
+ } else if (action === "next") {
+ nftsPage = clampNftsPage(nftsPage + 1);
+ } else if (action === "last") {
+ nftsPage = totalPages;
+ }
+ reloadNftPageFromControls();
+ });
+});
+
+nftsPageInput?.addEventListener("change", () => {
+ nftsPage = clampNftsPage(nftsPageInput.value);
+ reloadNftPageFromControls();
+});
diff --git a/frontend/js/receive_page.js b/frontend/js/receive_page.js
new file mode 100644
index 0000000..d70b1e0
--- /dev/null
+++ b/frontend/js/receive_page.js
@@ -0,0 +1,433 @@
+let receiveTokenListRequestId = 0;
+
+function setPaymentMessage(message, mode = "") {
+ if (!paymentMessage) {
+ return;
+ }
+ paymentMessage.textContent = message;
+ paymentMessage.classList.toggle("error", mode === "error");
+ paymentMessage.classList.toggle("success", mode === "success");
+}
+
+function receiveAddress() {
+ return activeWalletAddressShort || activeWalletAddressHex || "";
+}
+
+function paymentRequestUri() {
+ const address = receiveAddress();
+ if (!address) {
+ return "";
+ }
+
+ const params = new URLSearchParams();
+ const asset = paymentAssetSelect?.value || activeBaseCoin();
+ const amount = paymentAmountInput?.value?.trim() || "";
+ const label = paymentLabelInput?.value?.trim() || "";
+
+ if (asset) {
+ params.set("asset", asset);
+ }
+ if (amount) {
+ params.set("amount", amount);
+ }
+ if (label) {
+ params.set("label", label);
+ }
+
+ const query = params.toString();
+ return `contractless:${address}${query ? `?${query}` : ""}`;
+}
+
+function qrGaloisTables() {
+ const exp = new Array(512).fill(0);
+ const log = new Array(256).fill(0);
+ let value = 1;
+ for (let index = 0; index < 255; index += 1) {
+ exp[index] = value;
+ log[value] = index;
+ value <<= 1;
+ if (value & 0x100) {
+ value ^= 0x11d;
+ }
+ }
+ for (let index = 255; index < 512; index += 1) {
+ exp[index] = exp[index - 255];
+ }
+ return { exp, log };
+}
+
+function qrMultiply(left, right, tables) {
+ if (!left || !right) {
+ return 0;
+ }
+ return tables.exp[tables.log[left] + tables.log[right]];
+}
+
+function qrGeneratorPolynomial(degree, tables) {
+ let poly = [1];
+ for (let index = 0; index < degree; index += 1) {
+ const next = new Array(poly.length + 1).fill(0);
+ poly.forEach((coefficient, coefficientIndex) => {
+ next[coefficientIndex] ^= coefficient;
+ next[coefficientIndex + 1] ^= qrMultiply(coefficient, tables.exp[index], tables);
+ });
+ poly = next;
+ }
+ return poly;
+}
+
+function qrReedSolomon(data, eccLength) {
+ const tables = qrGaloisTables();
+ const generator = qrGeneratorPolynomial(eccLength, tables);
+ const ecc = new Array(eccLength).fill(0);
+
+ data.forEach((byte) => {
+ const factor = byte ^ ecc.shift();
+ ecc.push(0);
+ for (let index = 0; index < eccLength; index += 1) {
+ ecc[index] ^= qrMultiply(generator[index + 1], factor, tables);
+ }
+ });
+ return ecc;
+}
+
+function qrAppendBits(bits, value, length) {
+ for (let bit = length - 1; bit >= 0; bit -= 1) {
+ bits.push((value >>> bit) & 1);
+ }
+}
+
+function qrEncodeBytes(text) {
+ const bytes = Array.from(new TextEncoder().encode(text));
+ if (bytes.length > 134) {
+ throw new Error("Payment URI is too long for the QR code. Shorten the label or amount.");
+ }
+
+ const bits = [];
+ qrAppendBits(bits, 0b0100, 4);
+ qrAppendBits(bits, bytes.length, 8);
+ bytes.forEach((byte) => qrAppendBits(bits, byte, 8));
+ const dataBitCapacity = 136 * 8;
+ const terminator = Math.min(4, dataBitCapacity - bits.length);
+ qrAppendBits(bits, 0, terminator);
+ while (bits.length % 8) {
+ bits.push(0);
+ }
+
+ const data = [];
+ for (let index = 0; index < bits.length; index += 8) {
+ data.push(bits.slice(index, index + 8).reduce((value, bit) => (value << 1) | bit, 0));
+ }
+ for (let pad = 0xec; data.length < 136; pad = pad === 0xec ? 0x11 : 0xec) {
+ data.push(pad);
+ }
+
+ const block1 = data.slice(0, 68);
+ const block2 = data.slice(68, 136);
+ const ecc1 = qrReedSolomon(block1, 18);
+ const ecc2 = qrReedSolomon(block2, 18);
+ const codewords = [];
+ for (let index = 0; index < 68; index += 1) {
+ codewords.push(block1[index], block2[index]);
+ }
+ for (let index = 0; index < 18; index += 1) {
+ codewords.push(ecc1[index], ecc2[index]);
+ }
+ return codewords.flatMap((byte) => {
+ const out = [];
+ qrAppendBits(out, byte, 8);
+ return out;
+ });
+}
+
+function qrFormatBits() {
+ let data = 0b01000; // ECC level L, mask 0.
+ let value = data << 10;
+ const generator = 0x537;
+ for (let bit = 14; bit >= 10; bit -= 1) {
+ if ((value >>> bit) & 1) {
+ value ^= generator << (bit - 10);
+ }
+ }
+ return ((data << 10) | value) ^ 0x5412;
+}
+
+function qrSet(matrix, reserved, row, col, value, isReserved = true) {
+ if (row < 0 || col < 0 || row >= matrix.length || col >= matrix.length) {
+ return;
+ }
+ matrix[row][col] = Boolean(value);
+ if (isReserved) {
+ reserved[row][col] = true;
+ }
+}
+
+function qrFinder(matrix, reserved, row, col) {
+ for (let y = -1; y <= 7; y += 1) {
+ for (let x = -1; x <= 7; x += 1) {
+ const r = row + y;
+ const c = col + x;
+ const dark = x >= 0 && x <= 6 && y >= 0 && y <= 6
+ && (x === 0 || x === 6 || y === 0 || y === 6 || (x >= 2 && x <= 4 && y >= 2 && y <= 4));
+ qrSet(matrix, reserved, r, c, dark);
+ }
+ }
+}
+
+function qrAlignment(matrix, reserved, row, col) {
+ for (let y = -2; y <= 2; y += 1) {
+ for (let x = -2; x <= 2; x += 1) {
+ qrSet(matrix, reserved, row + y, col + x, Math.max(Math.abs(x), Math.abs(y)) !== 1);
+ }
+ }
+}
+
+function qrBuildMatrix(text) {
+ const size = 41;
+ const matrix = Array.from({ length: size }, () => new Array(size).fill(false));
+ const reserved = Array.from({ length: size }, () => new Array(size).fill(false));
+
+ qrFinder(matrix, reserved, 0, 0);
+ qrFinder(matrix, reserved, 0, size - 7);
+ qrFinder(matrix, reserved, size - 7, 0);
+ qrAlignment(matrix, reserved, 34, 34);
+
+ for (let index = 8; index < size - 8; index += 1) {
+ qrSet(matrix, reserved, 6, index, index % 2 === 0);
+ qrSet(matrix, reserved, index, 6, index % 2 === 0);
+ }
+ qrSet(matrix, reserved, 33, 8, true);
+
+ for (let index = 0; index < 9; index += 1) {
+ if (index !== 6) {
+ reserved[8][index] = true;
+ reserved[index][8] = true;
+ }
+ }
+ for (let index = 0; index < 8; index += 1) {
+ reserved[8][size - 1 - index] = true;
+ reserved[size - 1 - index][8] = true;
+ }
+
+ const bits = qrEncodeBytes(text);
+ let bitIndex = 0;
+ let upward = true;
+ for (let col = size - 1; col > 0; col -= 2) {
+ if (col === 6) {
+ col -= 1;
+ }
+ for (let step = 0; step < size; step += 1) {
+ const row = upward ? size - 1 - step : step;
+ for (let offset = 0; offset < 2; offset += 1) {
+ const c = col - offset;
+ if (reserved[row][c]) {
+ continue;
+ }
+ const dark = bitIndex < bits.length ? bits[bitIndex] === 1 : false;
+ matrix[row][c] = ((row + c) % 2 === 0) ? !dark : dark;
+ bitIndex += 1;
+ }
+ }
+ upward = !upward;
+ }
+
+ const format = qrFormatBits();
+ for (let index = 0; index < 15; index += 1) {
+ const bit = ((format >>> index) & 1) === 1;
+ const first = [
+ [8, 0], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 7], [8, 8],
+ [7, 8], [5, 8], [4, 8], [3, 8], [2, 8], [1, 8], [0, 8]
+ ][index];
+ const second = index < 8 ? [size - 1 - index, 8] : [8, size - 15 + index];
+ qrSet(matrix, reserved, first[0], first[1], bit);
+ qrSet(matrix, reserved, second[0], second[1], bit);
+ }
+
+ return matrix;
+}
+
+function drawPaymentQr(canvas, text, label) {
+ if (!canvas) {
+ return;
+ }
+
+ const size = canvas.width || 256;
+ const context = canvas.getContext("2d");
+ if (!context) {
+ return;
+ }
+
+ context.fillStyle = "#ffffff";
+ context.fillRect(0, 0, size, size);
+ context.fillStyle = "#101820";
+
+ try {
+ const matrix = qrBuildMatrix(text);
+ const modules = matrix.length;
+ const quiet = 4;
+ const cell = Math.floor(size / (modules + quiet * 2));
+ const offset = Math.floor((size - cell * modules) / 2);
+ matrix.forEach((row, y) => {
+ row.forEach((dark, x) => {
+ if (dark) {
+ context.fillRect(offset + x * cell, offset + y * cell, cell, cell);
+ }
+ });
+ });
+ setPaymentMessage("");
+ } catch (error) {
+ context.fillStyle = "#101820";
+ context.font = "16px sans-serif";
+ context.textAlign = "center";
+ context.fillText("QR unavailable", size / 2, size / 2 - 8);
+ context.font = "12px sans-serif";
+ context.fillText("Shorten request text", size / 2, size / 2 + 14);
+ setPaymentMessage(String(error), "error");
+ }
+
+ if (label) {
+ const footerHeight = 28;
+ context.fillStyle = "rgba(255,255,255,0.92)";
+ context.fillRect(0, size - footerHeight, size, footerHeight);
+ context.fillStyle = "#101820";
+ context.font = "13px sans-serif";
+ context.textAlign = "center";
+ const trimmed = label.length > 30 ? `${label.slice(0, 27)}...` : label;
+ context.fillText(trimmed, size / 2, size - 10);
+ }
+}
+
+function drawEmptyPaymentQr(canvas) {
+ if (!canvas) {
+ return;
+ }
+ const size = canvas.width || 256;
+ const context = canvas.getContext("2d");
+ if (!context) {
+ return;
+ }
+ context.fillStyle = "#ffffff";
+ context.fillRect(0, 0, size, size);
+ context.fillStyle = "#101820";
+ context.font = "16px sans-serif";
+ context.textAlign = "center";
+ context.fillText("Load wallet", size / 2, size / 2);
+}
+
+function renderPaymentQr(uri, label) {
+ if (!uri) {
+ drawEmptyPaymentQr(paymentQrCanvas);
+ return;
+ }
+ drawPaymentQr(paymentQrCanvas, uri, label);
+}
+
+function updateReceiveDetails() {
+ if (receiveRegistration) {
+ receiveRegistration.textContent = registrationRegistered ? "Registered" : "Unregistered";
+ }
+}
+
+function updatePaymentRequest() {
+ const uri = paymentRequestUri();
+ if (paymentUriInput) {
+ paymentUriInput.value = uri;
+ }
+ if (paymentQrLabel) {
+ paymentQrLabel.textContent = paymentLabelInput?.value?.trim() || "Payment Request";
+ }
+ renderPaymentQr(uri, paymentQrLabel?.textContent || "");
+ updateReceiveDetails();
+}
+
+async function refreshReceiveTokenList() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ const broadcastNode = activeBroadcastNode();
+ if (!invoke || !walletLoaded || !broadcastNode || !paymentAssetSelect) {
+ return;
+ }
+
+ const requestId = ++receiveTokenListRequestId;
+ const selected = paymentAssetSelect.value || activeBaseCoin();
+ paymentAssetSelect.innerHTML = "";
+ const baseOption = document.createElement("option");
+ baseOption.value = activeBaseCoin();
+ baseOption.textContent = activeBaseCoin();
+ paymentAssetSelect.appendChild(baseOption);
+
+ try {
+ const tokens = await invokeWalletRpcWithBackoff(
+ "Token list lookup",
+ () => invoke("token_list", { broadcastNode }),
+ () => requestId === receiveTokenListRequestId && walletLoaded
+ );
+ if (requestId !== receiveTokenListRequestId || !walletLoaded) {
+ return;
+ }
+
+ (Array.isArray(tokens) ? tokens : []).forEach((token) => {
+ const ticker = String(token?.ticker || "").trim();
+ if (!ticker || ticker.toLowerCase() === activeBaseCoin().toLowerCase()) {
+ return;
+ }
+ const option = document.createElement("option");
+ option.value = ticker;
+ option.textContent = ticker;
+ paymentAssetSelect.appendChild(option);
+ });
+ paymentAssetSelect.value = [...paymentAssetSelect.options].some((option) => option.value === selected)
+ ? selected
+ : activeBaseCoin();
+ } catch (error) {
+ setPaymentMessage(String(error), "error");
+ } finally {
+ updatePaymentRequest();
+ }
+}
+
+async function copyPaymentUri() {
+ const uri = paymentRequestUri();
+ if (!uri || !(await writeClipboardText(uri))) {
+ setPaymentMessage("Payment URI is not available to copy.", "error");
+ return;
+ }
+ setPaymentMessage("Payment URI copied.", "success");
+}
+
+async function copyPaymentQr() {
+ if (!paymentQrCanvas || !navigator.clipboard || typeof ClipboardItem === "undefined") {
+ await copyPaymentUri();
+ return;
+ }
+
+ paymentQrCanvas.toBlob(async (blob) => {
+ if (!blob) {
+ setPaymentMessage("Payment QR is not available to copy.", "error");
+ return;
+ }
+ try {
+ await navigator.clipboard.write([
+ new ClipboardItem({
+ [blob.type]: blob
+ })
+ ]);
+ setPaymentMessage("Payment request QR copied.", "success");
+ } catch (_) {
+ await copyPaymentUri();
+ }
+ }, "image/png");
+}
+
+function refreshReceivePage() {
+ updateReceiveDetails();
+ updatePaymentRequest();
+ refreshReceiveTokenList();
+}
+
+[paymentAssetSelect, paymentAmountInput, paymentLabelInput].forEach((input) => {
+ input?.addEventListener("input", updatePaymentRequest);
+ input?.addEventListener("change", updatePaymentRequest);
+});
+
+copyPaymentUriButton?.addEventListener("click", copyPaymentUri);
+copyPaymentQrButton?.addEventListener("click", copyPaymentQr);
diff --git a/frontend/js/settings_page.js b/frontend/js/settings_page.js
new file mode 100644
index 0000000..4129538
--- /dev/null
+++ b/frontend/js/settings_page.js
@@ -0,0 +1,574 @@
+let settingsLoaded = false;
+
+function durationSettingMs(value) {
+ const text = String(value || "").trim().toLowerCase();
+ if (!text || text === "never") {
+ return 0;
+ }
+ const amount = Number.parseFloat(text);
+ if (!Number.isFinite(amount) || amount <= 0) {
+ return 0;
+ }
+ if (text.includes("second")) {
+ return amount * 1000;
+ }
+ if (text.includes("minute")) {
+ return amount * 60 * 1000;
+ }
+ return 0;
+}
+
+function resetAutoLockTimer() {
+ if (autoLockTimer) {
+ clearTimeout(autoLockTimer);
+ autoLockTimer = null;
+ }
+ if (!walletLoaded) {
+ return;
+ }
+
+ const timeoutMs = durationSettingMs(guiRuntimeSettings.auto_lock_timeout);
+ if (!timeoutMs) {
+ return;
+ }
+
+ autoLockTimer = setTimeout(async () => {
+ if (!walletLoaded) {
+ return;
+ }
+ try {
+ await window.__TAURI__?.core?.invoke?.("lock_wallet");
+ } catch (_) {
+ // Local UI lock is still the important user-facing behavior.
+ }
+ lockWalletSession();
+ }, timeoutMs);
+}
+
+function applyRuntimeGuiSettings(settings) {
+ guiRuntimeSettings = {
+ ...guiRuntimeSettings,
+ auto_lock_timeout: settings?.auto_lock_timeout || guiRuntimeSettings.auto_lock_timeout,
+ clipboard_clear_timeout: settings?.clipboard_clear_timeout || guiRuntimeSettings.clipboard_clear_timeout,
+ require_key_before_signing: settings?.require_key_before_signing !== false
+ };
+ resetAutoLockTimer();
+}
+
+async function loadRuntimeGuiSettings() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ return;
+ }
+ try {
+ applyRuntimeGuiSettings(await invoke("read_gui_settings"));
+ } catch (_) {
+ resetAutoLockTimer();
+ }
+}
+
+function resetAutoLockOnActivity() {
+ if (walletLoaded) {
+ resetAutoLockTimer();
+ }
+}
+
+function scheduleClipboardClear(copiedText) {
+ if (clipboardClearTimer) {
+ clearTimeout(clipboardClearTimer);
+ clipboardClearTimer = null;
+ }
+ lastClipboardText = copiedText || "";
+ const timeoutMs = durationSettingMs(guiRuntimeSettings.clipboard_clear_timeout);
+ if (!timeoutMs || !lastClipboardText || !navigator.clipboard) {
+ return;
+ }
+
+ clipboardClearTimer = setTimeout(async () => {
+ lastClipboardText = "";
+ try {
+ await navigator.clipboard.writeText("");
+ } catch (_) {
+ // Clipboard writes can fail outside a user gesture; never prompt or block.
+ }
+ }, timeoutMs);
+}
+
+async function clearWalletClipboard() {
+ if (clipboardClearTimer) {
+ clearTimeout(clipboardClearTimer);
+ clipboardClearTimer = null;
+ }
+ lastClipboardText = "";
+
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (invoke) {
+ try {
+ await invoke("clear_system_clipboard");
+ return;
+ } catch (_) {
+ // Fall back to the Web Clipboard API when the native bridge is unavailable.
+ }
+ }
+
+ if (!navigator.clipboard) {
+ return;
+ }
+ try {
+ await navigator.clipboard.writeText("");
+ } catch (_) {}
+}
+
+async function writeClipboardText(text) {
+ if (!text || !navigator.clipboard) {
+ return false;
+ }
+ await navigator.clipboard.writeText(text);
+ scheduleClipboardClear(text);
+ return true;
+}
+
+function setSettingsMessage(message, mode = "") {
+ if (!settingsMessage) {
+ return;
+ }
+ settingsMessage.textContent = message;
+ settingsMessage.classList.toggle("error", mode === "error");
+ settingsMessage.classList.toggle("success", mode === "success");
+}
+
+function settingsFieldMap() {
+ return {
+ wallet_path: settingsWalletPath,
+ default_node: settingsDefaultNode,
+ unbroadcast_transactions_path: settingsUnbroadcastPath,
+ address_book_path: settingsAddressBookPath,
+ ipfs_gateway: settingsIpfsGateway,
+ auto_lock_timeout: settingsAutoLockTimeout,
+ clipboard_clear_timeout: settingsClipboardTimeout
+ };
+}
+
+function applyGuiSettings(settings) {
+ applyRuntimeGuiSettings(settings);
+ const fields = settingsFieldMap();
+ Object.entries(fields).forEach(([key, input]) => {
+ if (input) {
+ input.value = settings?.[key] || "";
+ }
+ });
+
+ if (settingsSavedNodes) {
+ settingsSavedNodes.value = Array.isArray(settings?.saved_nodes)
+ ? settings.saved_nodes.join("\n")
+ : "";
+ }
+ if (settingsRequireKey) {
+ settingsRequireKey.checked = settings?.require_key_before_signing !== false;
+ }
+}
+
+function collectGuiSettings() {
+ return {
+ wallet_path: settingsWalletPath?.value?.trim() || "",
+ unbroadcast_transactions_path: settingsUnbroadcastPath?.value?.trim() || "",
+ address_book_path: settingsAddressBookPath?.value?.trim() || "",
+ default_node: settingsDefaultNode?.value?.trim() || "",
+ saved_nodes: (settingsSavedNodes?.value || "")
+ .split(/\r?\n/)
+ .map((node) => node.trim())
+ .filter(Boolean),
+ ipfs_gateway: settingsIpfsGateway?.value?.trim() || "",
+ auto_load_trusted_nft_images: true,
+ auto_lock_timeout: settingsAutoLockTimeout?.value || "15 minutes",
+ clipboard_clear_timeout: settingsClipboardTimeout?.value || "60 seconds",
+ require_key_before_signing: Boolean(settingsRequireKey?.checked),
+ settings_path: ""
+ };
+}
+
+async function loadSettingsPage({ force = false } = {}) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke || (settingsLoaded && !force)) {
+ return;
+ }
+
+ try {
+ const settings = await invoke("read_gui_settings");
+ applyGuiSettings(settings);
+ settingsLoaded = true;
+ setSettingsMessage("");
+ } catch (error) {
+ setSettingsMessage(String(error), "error");
+ }
+}
+
+async function saveSettingsPage() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setSettingsMessage("Settings can only be saved from the desktop app.", "error");
+ return;
+ }
+
+ if (settingsSaveButton) {
+ settingsSaveButton.disabled = true;
+ }
+ setSettingsMessage("Saving settings...");
+ try {
+ await invoke("save_gui_settings", { settings: collectGuiSettings() });
+ settingsLoaded = false;
+ await loadSettingsPage({ force: true });
+ await populateBroadcastNodeList();
+ setSettingsMessage("Settings saved.", "success");
+ } catch (error) {
+ setSettingsMessage(String(error), "error");
+ } finally {
+ if (settingsSaveButton) {
+ settingsSaveButton.disabled = false;
+ }
+ }
+}
+
+async function browseSettingsPath(button) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ return;
+ }
+
+ const key = button.dataset.settingsBrowse;
+ const input = settingsFieldMap()[key];
+ if (!input) {
+ return;
+ }
+
+ try {
+ const selected = await invoke("select_settings_path", {
+ kind: button.dataset.settingsBrowseKind || "folder",
+ currentPath: input.value || ""
+ });
+ if (selected) {
+ input.value = selected;
+ }
+ } catch (error) {
+ setSettingsMessage(String(error), "error");
+ }
+}
+
+function setNodeTestStatus(message, mode = "") {
+ if (!settingsNodeTestStatus) {
+ return;
+ }
+ settingsNodeTestStatus.textContent = message || "";
+ settingsNodeTestStatus.classList.toggle("hidden", !message);
+ settingsNodeTestStatus.classList.toggle("error", mode === "error");
+ settingsNodeTestStatus.classList.toggle("success", mode === "success");
+}
+
+async function testSelectedSettingsNode() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ setNodeTestStatus("Node testing is only available in the desktop app.", "error");
+ return;
+ }
+ const broadcastNode = settingsDefaultNode?.value?.trim() || activeBroadcastNode();
+ if (!broadcastNode) {
+ setNodeTestStatus("Select a node before testing.", "error");
+ return;
+ }
+
+ settingsTestNodeButton && (settingsTestNodeButton.disabled = true);
+ setNodeTestStatus("Testing node...");
+ try {
+ const timestamp = await invoke("test_broadcast_node_time", { broadcastNode });
+ setNodeTestStatus(`Active - node time ${formatNetworkTime(timestamp)}`, "success");
+ } catch (error) {
+ setNodeTestStatus(String(error), "error");
+ } finally {
+ settingsTestNodeButton && (settingsTestNodeButton.disabled = false);
+ }
+}
+
+function setCacheClearMessage(message, mode = "") {
+ if (!cacheClearMessage) {
+ return;
+ }
+ cacheClearMessage.textContent = message || "";
+ cacheClearMessage.classList.toggle("error", mode === "error");
+ cacheClearMessage.classList.toggle("success", mode === "success");
+}
+
+function setCacheClearModalOpen(open) {
+ cacheClearModal?.classList.toggle("hidden", !open);
+ if (open) {
+ setCacheClearMessage("");
+ }
+}
+
+async function clearSelectedWalletCache(kind, button) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke || !walletLoaded) {
+ setCacheClearMessage("Load a wallet before clearing local cache.", "error");
+ return;
+ }
+
+ button && (button.disabled = true);
+ setCacheClearMessage("Clearing cache...");
+ try {
+ await invoke("clear_wallet_cache", { cacheKind: kind });
+ if (kind === "history") {
+ clearHistoryRows();
+ resetLatestDashboardTransactionsMemory();
+ if (typeof resetHistoryPage === "function") {
+ resetHistoryPage();
+ }
+ } else if (kind === "nft" || kind === "nft_details") {
+ if (typeof resetNftsPage === "function") {
+ resetNftsPage();
+ }
+ if (currentView === "nfts" && typeof prepareNftsPage === "function") {
+ prepareNftsPage({ force: true });
+ }
+ } else if (kind === "address_book") {
+ if (typeof resetAddressBookPage === "function") {
+ resetAddressBookPage();
+ }
+ if (currentView === "addressbook" && typeof prepareAddressBookPage === "function") {
+ prepareAddressBookPage();
+ }
+ }
+ setCacheClearMessage("Cache cleared.", "success");
+ } catch (error) {
+ setCacheClearMessage(String(error), "error");
+ } finally {
+ button && (button.disabled = false);
+ }
+}
+
+function setBackupKeyMessage(message, mode = "") {
+ if (!backupKeyMessage) {
+ return;
+ }
+ backupKeyMessage.textContent = message;
+ backupKeyMessage.classList.toggle("error", mode === "error");
+ backupKeyMessage.classList.toggle("success", mode === "success");
+}
+
+function closeBackupKeyModal(value = null) {
+ if (backupKeyModal) {
+ backupKeyModal.classList.add("hidden");
+ }
+ if (backupKeyInput) {
+ backupKeyInput.value = "";
+ }
+ setBackupKeyMessage("");
+ if (pendingBackupKeyRequest) {
+ pendingBackupKeyRequest.resolve(value);
+ pendingBackupKeyRequest = null;
+ }
+}
+
+function requestWalletBackupKey(copy, title = "Wallet Backup") {
+ if (!backupKeyModal) {
+ return Promise.resolve(null);
+ }
+
+ if (pendingBackupKeyRequest) {
+ closeBackupKeyModal(null);
+ }
+
+ backupKeyTitle && (backupKeyTitle.textContent = title);
+ backupKeyCopy && (backupKeyCopy.textContent = copy || "Enter the wallet encryption key.");
+ backupKeyInput && (backupKeyInput.value = "");
+ setBackupKeyMessage("");
+ backupKeyModal.classList.remove("hidden");
+ setTimeout(() => backupKeyInput?.focus(), 0);
+
+ return new Promise((resolve) => {
+ pendingBackupKeyRequest = { resolve };
+ });
+}
+
+async function requestSigningWalletKey() {
+ if (guiRuntimeSettings.require_key_before_signing === false) {
+ return null;
+ }
+
+ return requestWalletBackupKey(
+ "Enter the wallet encryption key to sign this transaction.",
+ "Sign Transaction"
+ );
+}
+
+function htmlEscape(value) {
+ return String(value ?? "")
+ .replace(/&/g, "&")
+ .replace(//g, ">")
+ .replace(/"/g, """)
+ .replace(/'/g, "'");
+}
+
+function printWalletBackup(data) {
+ const printFrame = document.createElement("iframe");
+ printFrame.setAttribute("title", "Contractless Wallet Backup Print");
+ printFrame.style.position = "fixed";
+ printFrame.style.right = "0";
+ printFrame.style.bottom = "0";
+ printFrame.style.width = "0";
+ printFrame.style.height = "0";
+ printFrame.style.border = "0";
+ printFrame.style.opacity = "0";
+ printFrame.style.pointerEvents = "none";
+ document.body.appendChild(printFrame);
+
+ const printDocument = printFrame.contentWindow?.document;
+ if (!printDocument) {
+ printFrame.remove();
+ setSettingsMessage("Unable to prepare print document.", "error");
+ return;
+ }
+
+ printDocument.open();
+ printDocument.write(`
+
+
+ Contractless Wallet Backup
+
+
+
+ Contractless Wallet Backup
+ Keep this page private. Anyone with the private key and encryption key can control this wallet.
+ Wallet ${htmlEscape(data.wallet_name)} Private Key ${htmlEscape(data.private_key)} Encryption Key ${htmlEscape(data.encryption_key)} v ";
+ }
+
+ refreshReceivePage();
+}
+
+function lockWalletSession() {
+ clearWalletClipboard();
+ walletNameInput && (walletNameInput.value = "");
+ walletKeyInput && (walletKeyInput.value = "");
+ walletKeyConfirmInput && (walletKeyConfirmInput.value = "");
+ loadWalletKeyInput && (loadWalletKeyInput.value = "");
+ importWalletNameInput && (importWalletNameInput.value = "");
+ importPrivateKeyInput && (importPrivateKeyInput.value = "");
+ importWalletKeyInput && (importWalletKeyInput.value = "");
+ importWalletKeyConfirmInput && (importWalletKeyConfirmInput.value = "");
+ importImageWalletNameInput && (importImageWalletNameInput.value = "");
+ importImagePathInput && (importImagePathInput.value = "");
+ importImageWalletKeyInput && (importImageWalletKeyInput.value = "");
+ importImageWalletKeyConfirmInput && (importImageWalletKeyConfirmInput.value = "");
+ createWalletForm?.classList.add("hidden");
+ loadWalletForm?.classList.add("hidden");
+ importKeyForm?.classList.add("hidden");
+ importImageForm?.classList.add("hidden");
+ setStartupMessage("");
+ setLoadMessage("");
+ setImportMessage("");
+ setImportImageMessage("");
+ toggleNodeModal(false);
+ closeWalletSwitchModal({ restoreSelection: false });
+ clearActiveWallet();
+ setActiveView("dashboard");
+ document.body.classList.remove("wallet-open");
+}
+
+async function refreshWalletList() {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke || !walletListSelect) {
+ setLoadMessage("Wallet loading requires the desktop app build.", "error");
+ return;
+ }
+
+ setLoadMessage("Checking saved wallets...");
+ try {
+ const wallets = await invoke("list_wallets", { network: activeNetwork });
+ walletListSelect.innerHTML = "";
+ if (!wallets.length) {
+ const option = document.createElement("option");
+ option.value = "";
+ option.textContent = "No wallets found";
+ walletListSelect.appendChild(option);
+ setLoadMessage("No app-managed wallets found. You can load an external wallet path.");
+ return;
+ }
+
+ wallets.forEach((wallet) => {
+ const option = document.createElement("option");
+ option.value = wallet.wallet_path;
+ option.textContent = wallet.wallet_name;
+ walletListSelect.appendChild(option);
+ });
+ setLoadMessage("Choose a saved wallet or enter an external wallet path.");
+ } catch (error) {
+ setLoadMessage(String(error), "error");
+ }
+ await populateTopWalletList();
+}
+
+async function loadWalletByPath(walletPath, walletKey) {
+ const invoke = window.__TAURI__?.core?.invoke;
+ if (!invoke) {
+ throw new Error("Wallet loading requires the desktop app build.");
+ }
+
+ return invoke("load_wallet", { walletPath, walletKey });
+}
+
+function restoreActiveWalletSelection() {
+ if (topWalletListSelect) {
+ topWalletListSelect.value = activeWalletPath || "";
+ }
+}
+
+function closeWalletSwitchModal({ restoreSelection = true } = {}) {
+ walletSwitchModal?.classList.add("hidden");
+ pendingWalletSwitch = null;
+ if (walletSwitchSubmit) {
+ walletSwitchSubmit.disabled = false;
+ }
+ if (walletSwitchKeyInput) {
+ walletSwitchKeyInput.value = "";
+ }
+ setWalletSwitchMessage("");
+ if (restoreSelection) {
+ restoreActiveWalletSelection();
+ }
+}
+
+function openWalletSwitchModal(walletPath) {
+ if (!walletPath || walletPath === activeWalletPath) {
+ restoreActiveWalletSelection();
+ return;
+ }
+
+ const selectedOption = topWalletListSelect?.selectedOptions?.[0];
+ pendingWalletSwitch = {
+ walletPath,
+ walletName: selectedOption?.textContent?.trim() || "selected wallet"
+ };
+
+ if (walletSwitchName) {
+ walletSwitchName.textContent = `Unlock ${pendingWalletSwitch.walletName}`;
+ }
+ setWalletSwitchMessage("");
+ if (walletSwitchKeyInput) {
+ walletSwitchKeyInput.value = "";
+ }
+ walletSwitchModal?.classList.remove("hidden");
+ setTimeout(() => walletSwitchKeyInput?.focus(), 0);
+}
+
+function selectWalletOption(wallet) {
+ if (!walletListSelect || !wallet) {
+ return;
+ }
+
+ const existing = Array.from(walletListSelect.options).find((option) => option.value === wallet.wallet_path);
+ if (existing) {
+ existing.selected = true;
+ return;
+ }
+
+ const placeholder = Array.from(walletListSelect.options).find((option) => !option.value);
+ if (placeholder) {
+ placeholder.remove();
+ }
+
+ const option = document.createElement("option");
+ option.value = wallet.wallet_path;
+ option.textContent = wallet.wallet_name;
+ option.selected = true;
+ walletListSelect.appendChild(option);
+}
diff --git a/frontend/styles.css b/frontend/styles.css
new file mode 100644
index 0000000..c8a3ad4
--- /dev/null
+++ b/frontend/styles.css
@@ -0,0 +1,3442 @@
+:root {
+ --bg: #f5f6f3;
+ --surface: #ffffff;
+ --surface-soft: #eef3ef;
+ --text: #17201d;
+ --muted: #65716c;
+ --line: #dce3df;
+ --green: #157347;
+ --green-soft: #e3f3ea;
+ --blue: #245b8f;
+ --amber: #9a6a10;
+ --ink: #24302c;
+ --shadow: 0 14px 40px rgba(31, 42, 37, 0.08);
+ font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* {
+ box-sizing: border-box;
+}
+
+body {
+ margin: 0;
+ min-height: 100vh;
+ background: var(--bg);
+ color: var(--text);
+ overflow-x: hidden;
+}
+
+button,
+input,
+select,
+textarea {
+ font: inherit;
+}
+
+button {
+ cursor: pointer;
+}
+
+.app-shell {
+ display: grid;
+ grid-template-columns: 220px minmax(0, 1fr);
+ width: min(1450px, 100vw);
+ min-height: 720px;
+ margin: 0 auto;
+ background: var(--surface);
+ border-left: 1px solid var(--line);
+ border-right: 1px solid var(--line);
+}
+
+body:not(.wallet-open) .app-shell,
+body:not(.wallet-open) .mobile-nav,
+body:not(.wallet-open) .mobile-more-backdrop,
+body:not(.wallet-open) .mobile-more-sheet {
+ display: none;
+}
+
+.startup-screen {
+ min-height: 100vh;
+ display: grid;
+ place-items: center;
+ padding: 24px;
+ background: radial-gradient(circle at top, #1d2a36 0, #111820 52%);
+}
+
+.startup-card {
+ width: min(520px, 100%);
+ display: grid;
+ gap: 22px;
+ padding: 24px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface);
+ box-shadow: var(--shadow);
+}
+
+.startup-brand {
+ border-bottom: 1px solid var(--line);
+ padding: 0 0 16px;
+}
+
+.startup-copy {
+ display: grid;
+ gap: 8px;
+}
+
+.startup-copy h1 {
+ font-size: 30px;
+}
+
+.startup-copy p {
+ color: var(--muted);
+ line-height: 1.45;
+}
+
+.startup-actions {
+ display: grid;
+ gap: 10px;
+}
+
+.network-toggle {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: 8px;
+ padding: 4px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface-soft);
+}
+
+.network-toggle button {
+ min-height: 40px;
+ border: 1px solid transparent;
+ border-radius: 6px;
+ background: transparent;
+ color: var(--muted);
+ font-weight: 800;
+}
+
+.network-toggle button.active {
+ border-color: #3e6fa3;
+ background: #1f3550;
+ color: var(--text);
+}
+
+.startup-action {
+ min-height: 72px;
+ display: grid;
+ gap: 5px;
+ text-align: left;
+ padding: 13px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #121b24;
+ color: var(--text);
+}
+
+.startup-action:hover,
+.startup-action.primary-start {
+ border-color: #3e6fa3;
+ background: #1f3550;
+}
+
+.startup-action span {
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.startup-form {
+ display: grid;
+ gap: 14px;
+ padding-top: 2px;
+}
+
+.startup-form label {
+ display: grid;
+ gap: 7px;
+ color: var(--muted);
+ font-weight: 700;
+}
+
+.startup-form input,
+.startup-form select,
+.startup-form textarea {
+ width: 100%;
+ min-height: 48px;
+ padding: 10px 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface-soft);
+ color: var(--text);
+}
+
+.startup-form textarea {
+ min-height: 120px;
+ resize: vertical;
+ font-family: ui-monospace, SFMono-Regular, Consolas, "Liberation Mono", monospace;
+ line-height: 1.4;
+}
+
+.wallet-picker-row {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 52px;
+ gap: 8px;
+}
+
+.browse-wallet-button {
+ min-height: 48px;
+ padding: 0;
+ font-weight: 900;
+}
+
+.startup-form-actions {
+ display: flex;
+ justify-content: flex-end;
+ gap: 10px;
+}
+
+.startup-message {
+ min-height: 20px;
+ color: var(--muted);
+ font-size: 13px;
+ line-height: 1.4;
+}
+
+.startup-message.error {
+ color: #ff9f9f;
+}
+
+.startup-message.success {
+ color: #73d99f;
+}
+
+body.wallet-open .startup-screen {
+ display: none;
+}
+
+.sidebar {
+ position: sticky;
+ top: 0;
+ height: 100vh;
+ padding: 20px 14px;
+ background: #ffffff;
+ color: var(--text);
+ border-right: 1px solid var(--line);
+ display: flex;
+ flex-direction: column;
+ gap: 22px;
+}
+
+.brand {
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ padding: 0 8px 12px;
+ border-bottom: 1px solid var(--line);
+}
+
+.brand-mark {
+ width: 38px;
+ height: 38px;
+ display: grid;
+ place-items: center;
+ border-radius: 8px;
+ background: #eef5ff;
+ color: #174f9d;
+ font-weight: 800;
+}
+
+.brand-mark.wallet-image {
+ background-image: url("images/iconw.png");
+ background-size: cover;
+ background-position: center;
+ background-repeat: no-repeat;
+ color: transparent;
+ overflow: hidden;
+}
+
+.brand-name {
+ font-weight: 750;
+ line-height: 1.1;
+}
+
+.brand-subtitle,
+.mini-label {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.nav-list {
+ display: grid;
+ gap: 4px;
+}
+
+.nav-item,
+.mobile-item {
+ border: 0;
+ background: transparent;
+}
+
+.nav-item {
+ width: 100%;
+ min-height: 42px;
+ padding: 0 10px;
+ color: #33423d;
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ border-radius: 8px;
+ text-align: left;
+}
+
+.nav-item:hover,
+.nav-item.active {
+ color: #ffffff;
+ background: #174f9d;
+}
+
+.nav-icon {
+ width: 24px;
+ text-align: center;
+ color: currentColor;
+}
+
+.sidebar-footer {
+ margin-top: auto;
+ padding: 12px;
+ border-top: 1px solid var(--line);
+ border-radius: 0;
+}
+
+.network-chip,
+.height-pill {
+ display: inline-flex;
+ align-items: center;
+ gap: 8px;
+}
+
+.network-chip {
+ margin-top: 8px;
+ color: var(--green);
+ font-weight: 650;
+}
+
+.bridge-label {
+ display: block;
+ margin-top: 10px;
+}
+
+.bridge-label.success {
+ color: var(--green);
+}
+
+.bridge-label.error {
+ color: #ff9a8d;
+}
+
+.status-dot {
+ width: 8px;
+ height: 8px;
+ border-radius: 50%;
+ background: #35b86d;
+ box-shadow: 0 0 0 3px rgba(53, 184, 109, 0.16);
+}
+
+.main-shell {
+ min-width: 0;
+}
+
+.topbar {
+ min-height: 58px;
+ padding: 9px 20px;
+ background: rgba(255, 255, 255, 0.88);
+ backdrop-filter: blur(14px);
+ border-bottom: 1px solid var(--line);
+ display: flex;
+ align-items: center;
+ gap: 14px;
+ position: sticky;
+ top: 0;
+ z-index: 5;
+}
+
+.menu-button {
+ display: none;
+ width: 40px;
+ height: 40px;
+ border-radius: 8px;
+ border: 1px solid var(--line);
+ background: var(--surface);
+}
+
+.topbar-wallet-mark {
+ display: none;
+ flex: 0 0 auto;
+}
+
+.topbar-group {
+ display: grid;
+ gap: 5px;
+ min-width: 0;
+}
+
+.topbar-label,
+.field-label {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 650;
+}
+
+.select-button,
+.icon-button,
+.secondary-button,
+.primary-button,
+.text-button,
+.quick-actions button {
+ border-radius: 8px;
+ border: 1px solid var(--line);
+ background: var(--surface);
+ color: var(--text);
+}
+
+.select-button {
+ min-height: 34px;
+ padding: 0 10px;
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ justify-content: space-between;
+ font-weight: 650;
+ min-width: 0;
+ overflow: hidden;
+ white-space: nowrap;
+ text-overflow: ellipsis;
+}
+
+.node-select .select-button {
+ min-width: 210px;
+}
+
+.wallet-select .select-button {
+ min-width: 170px;
+}
+
+.payment-uri-entry {
+ flex: 1 1 260px;
+ max-width: 430px;
+}
+
+.payment-uri-entry input {
+ width: 100%;
+ min-width: 0;
+ min-height: 34px;
+ padding: 0 10px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface);
+ color: var(--text);
+}
+
+.payment-uri-entry input:focus {
+ border-color: var(--blue);
+ outline: 2px solid rgba(56, 132, 219, 0.18);
+ outline-offset: 0;
+}
+
+.payment-uri-entry input:invalid {
+ border-color: #ef6f6f;
+}
+
+.topbar-spacer {
+ flex: 1;
+}
+
+.height-pill {
+ min-height: 34px;
+ padding: 0 12px;
+ border-radius: 999px;
+ background: var(--green-soft);
+ color: var(--green);
+ font-weight: 700;
+}
+
+.icon-button {
+ width: 38px;
+ height: 38px;
+}
+
+.content {
+ padding: 22px;
+ min-width: 0;
+}
+
+.view-heading {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 18px;
+ margin-bottom: 20px;
+}
+
+h1,
+h2,
+p {
+ margin: 0;
+}
+
+h1 {
+ font-size: 30px;
+ line-height: 1.1;
+ letter-spacing: 0;
+}
+
+.view-heading p,
+.panel-header p {
+ color: var(--muted);
+ margin-top: 6px;
+}
+
+.heading-actions {
+ display: flex;
+ gap: 10px;
+}
+
+.secondary-button,
+.primary-button {
+ min-height: 40px;
+ padding: 0 14px;
+ font-weight: 750;
+}
+
+.secondary-button:disabled {
+ cursor: not-allowed;
+ opacity: 0.48;
+}
+
+.primary-button {
+ border-color: #12211b;
+ background: #17201d;
+ color: #ffffff;
+}
+
+.dashboard-grid {
+ display: grid;
+ grid-template-columns: minmax(330px, 1.25fr) minmax(230px, 0.82fr) minmax(220px, 0.65fr);
+ grid-template-areas:
+ "balance registration quick"
+ "transactions transactions network"
+ "notice notice notice";
+ gap: 14px;
+ align-items: stretch;
+ min-width: 0;
+}
+
+.panel {
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ box-shadow: 0 12px 34px rgba(31, 42, 37, 0.05);
+ padding: 14px;
+ min-width: 0;
+}
+
+.balance-panel {
+ grid-area: balance;
+}
+
+.transactions-panel {
+ grid-area: transactions;
+}
+
+.registration-panel {
+ grid-area: registration;
+}
+
+.quick-panel {
+ grid-area: quick;
+}
+
+.network-panel {
+ grid-area: network;
+}
+
+.registration-notice {
+ grid-area: notice;
+ border: 2px solid #fff3ee;
+ border-radius: 4px;
+ padding: 10px 14px;
+ background: rgba(255, 240, 237, 0.18);
+ color: #ffd7cf;
+ font-size: 14px;
+ font-weight: 750;
+ text-align: center;
+}
+
+.registration-notice.checking {
+ border-color: #d8e0ea;
+ background: rgba(238, 242, 247, 0.12);
+ color: #c2cfdd;
+}
+
+.registration-notice.registered {
+ border-color: rgba(85, 214, 129, 0.45);
+ background: rgba(85, 214, 129, 0.08);
+ color: #7ee0a3;
+}
+
+.assets-panel {
+ grid-area: assets;
+}
+
+.node-panel {
+ grid-area: node;
+}
+
+.panel-header {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 12px;
+ margin-bottom: 16px;
+}
+
+.panel h2 {
+ font-size: 17px;
+ letter-spacing: 0;
+}
+
+.registration-badge,
+.table-status {
+ border-radius: 999px;
+ padding: 5px 9px;
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.registration-badge,
+.table-status.confirmed {
+ background: var(--green-soft);
+ color: var(--green);
+}
+
+.registration-badge.unregistered,
+.registration-action.unregistered {
+ background: #fff0ed;
+ color: #a33b2f;
+}
+
+.registration-badge.checking,
+.registration-action.checking {
+ background: #eef2f7;
+ color: #526b89;
+}
+
+.table-status.pending {
+ background: #fff4d8;
+ color: var(--amber);
+}
+
+.balance-value {
+ margin-top: 4px;
+ font-size: 20px;
+ line-height: 1.1;
+ font-weight: 800;
+ overflow-wrap: anywhere;
+}
+
+.balance-main {
+ display: flex;
+ align-items: center;
+ gap: 20px;
+ min-height: 120px;
+ min-width: 0;
+}
+
+.balance-split {
+ display: grid;
+ grid-template-columns: minmax(190px, 1fr) minmax(170px, 0.8fr);
+ gap: 18px;
+ align-items: center;
+ min-width: 0;
+}
+
+.coin-stack {
+ width: 58px;
+ height: 58px;
+ border-radius: 50%;
+ display: grid;
+ place-items: center;
+ background: #e2f0ff;
+ color: #1f74c8;
+ font-weight: 850;
+ font-size: 24px;
+}
+
+.usd-value {
+ margin-top: 4px;
+ color: #526b89;
+ font-weight: 650;
+}
+
+.usd-value.error {
+ color: #ffb4a8;
+}
+
+.usd-value.success {
+ color: #7ee0a3;
+}
+
+.balance-meta {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 8px;
+ margin-top: 18px;
+}
+
+.balance-meta span {
+ padding: 7px 10px;
+ border-radius: 999px;
+ background: var(--surface-soft);
+ color: var(--muted);
+ font-size: 13px;
+ font-weight: 650;
+}
+
+.quick-actions {
+ display: grid;
+ gap: 12px;
+}
+
+.quick-actions button {
+ min-height: 42px;
+ text-align: center;
+ padding: 0 12px;
+ font-weight: 700;
+}
+
+.token-balances {
+ border-left: 1px solid var(--line);
+ padding-left: 18px;
+ display: grid;
+ gap: 10px;
+ min-width: 0;
+}
+
+.token-title {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.empty-balance {
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.token-row {
+ display: grid;
+ grid-template-columns: 28px minmax(48px, 1fr) minmax(0, auto);
+ gap: 8px;
+ align-items: center;
+ font-size: 13px;
+ min-width: 0;
+}
+
+.token-row span,
+.token-row b {
+ min-width: 0;
+ overflow-wrap: anywhere;
+}
+
+.asset-mark.mini {
+ width: 24px;
+ height: 24px;
+ border-radius: 50%;
+ font-size: 12px;
+}
+
+.asset-mark.gold {
+ background: #fff0cf;
+ color: var(--amber);
+}
+
+.asset-mark.usdg {
+ background: #dff1e7;
+ color: var(--green);
+}
+
+.quick-actions button:nth-child(1) {
+ background: #eef6ff;
+ color: #165eb5;
+ border-color: #bad8f6;
+}
+
+.quick-actions button:nth-child(2) {
+ background: #eef9f1;
+ color: #157347;
+ border-color: #bfdfc9;
+}
+
+.quick-actions button:nth-child(3) {
+ background: #fff7e7;
+ color: #9a6a10;
+ border-color: #ead6a8;
+}
+
+.quick-actions button:nth-child(4) {
+ background: #f7f0ff;
+ color: #7432a8;
+ border-color: #d8c2eb;
+}
+
+.quick-actions button:hover,
+.text-button:hover,
+.secondary-button:hover {
+ border-color: #a9b8b1;
+}
+
+.asset-list,
+.status-list {
+ display: grid;
+ gap: 12px;
+}
+
+.asset-row {
+ display: grid;
+ grid-template-columns: 42px minmax(0, 1fr) auto;
+ align-items: center;
+ gap: 12px;
+ padding: 10px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+}
+
+.asset-row span {
+ display: block;
+ color: var(--muted);
+ font-size: 12px;
+ margin-top: 2px;
+}
+
+.asset-mark {
+ width: 42px;
+ height: 42px;
+ display: grid;
+ place-items: center;
+ border-radius: 8px;
+ font-weight: 800;
+}
+
+.asset-mark.clc {
+ background: #dff1e7;
+ color: #17613e;
+}
+
+.asset-mark.fun {
+ background: #e8eef9;
+ color: var(--blue);
+}
+
+.asset-mark.api {
+ background: #fff0cf;
+ color: var(--amber);
+}
+
+.asset-mark.art {
+ background: #f0e4fb;
+ color: #8538b5;
+}
+
+.text-button {
+ padding: 7px 10px;
+ color: var(--green);
+ font-weight: 750;
+}
+
+.address-card {
+ display: grid;
+ gap: 7px;
+ padding: 12px;
+ background: #f8faf8;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+}
+
+.registration-action {
+ justify-self: start;
+ border: 1px solid currentColor;
+ border-radius: 8px;
+ padding: 8px 13px;
+ background: var(--green-soft);
+ color: var(--green);
+ font-size: 12px;
+ font-weight: 800;
+}
+
+.registration-action:not(:disabled) {
+ cursor: pointer;
+}
+
+.registration-action:disabled {
+ cursor: default;
+ opacity: 1;
+}
+
+code {
+ white-space: normal;
+ word-break: break-all;
+ color: var(--ink);
+}
+
+.status-list div {
+ display: flex;
+ justify-content: space-between;
+ gap: 12px;
+ padding-bottom: 10px;
+ border-bottom: 1px solid var(--line);
+ min-width: 0;
+}
+
+.status-list.compact div {
+ border-bottom: 0;
+ padding-bottom: 0;
+}
+
+.status-list b {
+ text-align: right;
+ min-width: 0;
+ overflow-wrap: anywhere;
+}
+
+.status-list span {
+ color: var(--muted);
+}
+
+.table-wrap {
+ position: relative;
+ overflow-x: auto;
+}
+
+.recent-transactions-state {
+ display: grid;
+ min-height: 112px;
+ place-items: center;
+ padding: 18px;
+ color: var(--muted);
+ text-align: center;
+ border-top: 1px solid var(--line);
+}
+
+.recent-transactions-state.hidden {
+ display: none;
+}
+
+.recent-transactions-state.loading::before {
+ content: "";
+ width: 26px;
+ height: 26px;
+ margin-right: 10px;
+ border: 3px solid rgba(45, 112, 177, 0.22);
+ border-top-color: var(--blue);
+ border-radius: 50%;
+ animation: recent-spin 0.8s linear infinite;
+}
+
+.recent-transactions-state.loading {
+ grid-auto-flow: column;
+ justify-content: center;
+}
+
+@keyframes recent-spin {
+ to {
+ transform: rotate(360deg);
+ }
+}
+
+table {
+ width: 100%;
+ min-width: 0;
+ border-collapse: collapse;
+}
+
+.info-button {
+ width: 34px;
+ height: 34px;
+ border-radius: 8px;
+ border: 1px solid var(--line);
+ background: var(--surface);
+ color: var(--ink);
+ font-weight: 850;
+}
+
+.icon-button {
+ width: auto;
+ min-width: 42px;
+ padding: 0 10px;
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.info-button,
+.icon-button {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.button-icon {
+ width: 18px;
+ height: 18px;
+ fill: none;
+ stroke: currentColor;
+ stroke-width: 2;
+ stroke-linecap: round;
+ stroke-linejoin: round;
+ pointer-events: none;
+}
+
+.modal-backdrop {
+ position: fixed;
+ inset: 0;
+ z-index: 30;
+ display: grid;
+ place-items: end;
+ padding: 24px;
+ background: rgba(23, 32, 29, 0.18);
+}
+
+.modal-backdrop.hidden {
+ display: none;
+}
+
+.node-modal {
+ width: min(360px, calc(100vw - 32px));
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ box-shadow: 0 24px 70px rgba(23, 32, 29, 0.22);
+ padding: 16px;
+}
+
+.nft-instructions-backdrop {
+ place-items: center;
+}
+
+.nft-instructions-modal {
+ width: min(900px, calc(100vw - 32px));
+ max-height: calc(100vh - 48px);
+ overflow: auto;
+}
+
+.nft-instructions-body {
+ display: grid;
+ gap: 16px;
+ margin-top: 14px;
+}
+
+.nft-instructions-body section {
+ display: grid;
+ gap: 10px;
+ padding: 14px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #121b24;
+}
+
+.nft-instructions-body h3 {
+ margin: 0;
+ font-size: 16px;
+}
+
+.nft-instructions-body p {
+ margin: 0;
+ color: var(--muted);
+ line-height: 1.45;
+}
+
+.nft-hosting-links {
+ display: grid;
+ grid-template-columns: repeat(4, minmax(0, 1fr));
+ gap: 8px;
+}
+
+.nft-hosting-links a {
+ min-height: 40px;
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ border: 1px solid #2d5f93;
+ border-radius: 8px;
+ background: #183557;
+ color: #8fc3ff;
+ font-weight: 800;
+ text-decoration: none;
+}
+
+.nft-instructions-body pre {
+ max-width: 100%;
+ margin: 0;
+ overflow: auto;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #0d151d;
+ color: var(--text);
+ font-size: 12px;
+ line-height: 1.45;
+}
+
+.nft-instructions-body code {
+ color: var(--text);
+ white-space: pre;
+}
+
+.modal-form {
+ margin-top: 14px;
+}
+
+.info-button.close {
+ width: 30px;
+ height: 30px;
+}
+
+.asset-summary-grid {
+ display: grid;
+ grid-template-columns: repeat(4, minmax(0, 1fr));
+ gap: 12px;
+}
+
+.asset-card {
+ min-height: 132px;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ display: grid;
+ align-content: start;
+ gap: 8px;
+}
+
+.asset-card .asset-mark {
+ width: 40px;
+ height: 40px;
+}
+
+.asset-card b {
+ font-size: 20px;
+}
+
+.asset-card span {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.wide-button {
+ width: 100%;
+ min-height: 44px;
+ margin-top: 18px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #ffffff;
+ color: #174f9d;
+ font-weight: 750;
+}
+
+.status-dot.inline {
+ display: inline-block;
+ margin-right: 6px;
+ vertical-align: 1px;
+}
+
+th,
+td {
+ padding: 12px 10px;
+ border-bottom: 1px solid var(--line);
+ text-align: left;
+}
+
+th {
+ color: var(--muted);
+ font-size: 12px;
+ text-transform: uppercase;
+}
+
+.placeholder-view {
+ max-width: 980px;
+}
+
+.transaction-view {
+ min-width: 0;
+}
+
+.receive-view {
+ min-width: 0;
+}
+
+.history-view {
+ min-width: 0;
+}
+
+.assets-view {
+ min-width: 0;
+}
+
+.nfts-view {
+ min-width: 0;
+}
+
+.loans-view {
+ min-width: 0;
+}
+
+.addressbook-view {
+ min-width: 0;
+}
+
+.settings-view {
+ min-width: 0;
+}
+
+.transaction-workspace {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 230px;
+ gap: 14px;
+ min-height: 610px;
+ max-height: 610px;
+}
+
+.transaction-main,
+.transaction-types {
+ min-height: 0;
+ overflow: hidden;
+}
+
+.transaction-main {
+ display: flex;
+ flex-direction: column;
+ align-items: stretch;
+}
+
+.transaction-header {
+ margin-bottom: 12px;
+}
+
+.unbroadcast-list {
+ display: grid;
+ align-content: start;
+ gap: 10px;
+ overflow: auto;
+ padding-right: 2px;
+}
+
+.local-transaction {
+ min-height: 82px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #121b24;
+ color: var(--text);
+ display: grid;
+ gap: 5px;
+ padding: 12px;
+ text-align: left;
+ cursor: pointer;
+}
+
+.local-transaction.active,
+.local-transaction:hover {
+ border-color: #7db7ff;
+ background: #183557;
+}
+
+.local-transaction span {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.local-transaction strong {
+ font-size: 15px;
+ overflow-wrap: anywhere;
+}
+
+.muted-file {
+ overflow-wrap: anywhere;
+}
+
+.tx-kind {
+ width: fit-content;
+ padding: 4px 8px;
+ border-radius: 999px;
+ background: var(--green-soft);
+ color: var(--green) !important;
+ font-weight: 800;
+}
+
+.transaction-type-list {
+ display: grid;
+ gap: 9px;
+ max-height: none;
+ overflow: visible;
+ padding-right: 2px;
+}
+
+.transaction-type {
+ min-height: 38px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #121b24;
+ color: var(--text);
+ text-align: left;
+ padding: 0 11px;
+ font-weight: 750;
+}
+
+.transaction-type.active,
+.transaction-type:hover {
+ border-color: #7db7ff;
+ background: #183557;
+ color: #ffffff;
+}
+
+.transaction-form,
+.transaction-review {
+ min-height: 0;
+ overflow: auto;
+}
+
+.transaction-form {
+ align-self: stretch;
+}
+
+.transaction-json-preview {
+ max-height: 180px;
+ margin: 14px 0 0;
+ overflow: auto;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #0d151d;
+ color: var(--muted);
+ font-size: 12px;
+ line-height: 1.45;
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+}
+
+.form-grid.compact {
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.create-nft-description {
+ grid-column: 1 / -1;
+}
+
+.create-nft-description textarea {
+ min-height: 82px;
+ resize: vertical;
+}
+
+.create-nft-help-row {
+ grid-column: 1 / -1;
+ display: flex;
+ justify-content: flex-end;
+}
+
+.form-section-title {
+ grid-column: 1 / -1;
+ padding-bottom: 6px;
+ border-bottom: 1px solid var(--line);
+ color: var(--text);
+ font-size: 14px;
+ font-weight: 700;
+}
+
+.loan-condition-note {
+ grid-column: 1 / -1;
+ padding: 11px 12px;
+ border: 1px solid #8a6b26;
+ border-radius: 8px;
+ background: #302817;
+ color: #ffd982;
+ font-size: 13px;
+ line-height: 1.45;
+}
+
+.loan-payment-warning {
+ grid-column: 1 / -1;
+ padding: 11px 12px;
+ border: 1px solid #8a6b26;
+ border-radius: 8px;
+ background: #302817;
+ color: #ffd982;
+ font-size: 13px;
+ line-height: 1.45;
+}
+
+.input-with-suffix {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ align-items: center;
+ gap: 8px;
+}
+
+.input-with-suffix > span {
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.saved-transaction-path {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ align-items: end;
+ gap: 10px;
+ margin-top: 12px;
+}
+
+.saved-transaction-path > div {
+ display: grid;
+ gap: 6px;
+ min-width: 0;
+}
+
+.saved-transaction-path span {
+ color: var(--muted);
+ font-size: 13px;
+ font-weight: 700;
+}
+
+.saved-transaction-path input {
+ width: 100%;
+}
+
+.form-actions {
+ display: flex;
+ justify-content: flex-end;
+ gap: 10px;
+ margin-top: 16px;
+ padding-top: 14px;
+ border-top: 1px solid var(--line);
+}
+
+.review-grid {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 10px;
+}
+
+.review-grid div {
+ min-height: 62px;
+ display: grid;
+ gap: 5px;
+ align-content: center;
+ padding: 10px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #121b24;
+}
+
+.review-grid span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.review-grid b {
+ overflow-wrap: anywhere;
+}
+
+.receive-workspace {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 250px;
+ gap: 14px;
+ min-height: 552px;
+ max-height: 552px;
+}
+
+.receive-main,
+.receive-side {
+ min-height: 0;
+ overflow: hidden;
+}
+
+.receive-address-card {
+ display: grid;
+ gap: 8px;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #fbfcfb;
+}
+
+.copy-row {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ gap: 10px;
+ align-items: center;
+}
+
+.receive-request {
+ display: grid;
+ grid-template-columns: 220px minmax(0, 1fr);
+ gap: 16px;
+ margin-top: 14px;
+ min-height: 0;
+}
+
+.qr-placeholder {
+ min-height: 260px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #ffffff;
+ display: grid;
+ place-items: center;
+ gap: 10px;
+ align-content: center;
+ color: var(--muted);
+ font-weight: 750;
+}
+
+.qr-placeholder canvas {
+ width: 196px;
+ height: 196px;
+ border-radius: 8px;
+ image-rendering: pixelated;
+}
+
+.request-form {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 12px;
+ align-content: start;
+}
+
+.request-form label {
+ display: grid;
+ gap: 7px;
+}
+
+.request-form label:nth-child(3),
+.request-form label:nth-child(4),
+.request-form .form-actions,
+.request-form .startup-message {
+ grid-column: 1 / -1;
+}
+
+.request-form span {
+ color: var(--muted);
+ font-weight: 700;
+ font-size: 13px;
+}
+
+.request-form input,
+.request-form select {
+ width: 100%;
+ min-height: 40px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.compact-actions {
+ margin-top: 2px;
+}
+
+.history-workspace {
+ min-height: 552px;
+ height: calc(100vh - 142px);
+ display: grid;
+ grid-template-rows: auto minmax(0, 1fr) auto auto;
+ overflow: hidden;
+}
+
+.history-tools {
+ display: flex;
+ justify-content: flex-end;
+ min-width: min(320px, 100%);
+}
+
+.history-tools input {
+ width: min(320px, 100%);
+ min-height: 38px;
+ border-radius: 8px;
+ border: 1px solid var(--line);
+ padding: 0 12px;
+ font-weight: 650;
+}
+
+.marketing-campaign-controls {
+ display: grid;
+ grid-template-columns: minmax(260px, 1fr) 150px auto;
+ gap: 12px;
+ align-items: end;
+ min-width: min(640px, 100%);
+}
+
+.marketing-campaign-controls label {
+ display: grid;
+ gap: 5px;
+}
+
+.marketing-campaign-controls span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.marketing-campaign-controls input {
+ min-height: 38px;
+ width: 100%;
+ min-width: 0;
+ border-radius: 8px;
+ border: 1px solid var(--line);
+ padding: 0 12px;
+ font-weight: 650;
+}
+
+.marketing-workspace {
+ grid-template-rows: auto auto minmax(0, 1fr) auto auto;
+}
+
+.marketing-summary-grid {
+ display: grid;
+ grid-template-columns: repeat(6, minmax(0, 1fr));
+ gap: 8px;
+ margin: 14px 0 12px;
+}
+
+.history-workspace.panel {
+ display: grid;
+ grid-template-rows:
+ auto /* header */
+ auto /* summary */
+ minmax(0,1fr) /* table */
+ auto; /* footer */
+}
+
+.marketing-table-wrap {
+ min-height: 0;
+ overflow: auto;
+}
+
+.marketing-summary-grid > div {
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 10px 12px;
+ background: var(--bg);
+ min-width: 0;
+ min-height: 72px;
+ max-height: 72px;
+ flex-direction: column;
+ justify-content: center;
+}
+
+.marketing-summary-grid span {
+ display: block;
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+ margin-bottom: 4px;
+}
+
+.marketing-summary-grid div div {
+ display: block;
+}
+
+.marketing-summary-grid div div b {
+ color: var(--text);
+ font-size: 16px;
+ overflow-wrap: anywhere;
+}
+
+.marketing-table {
+ min-width: 1120px;
+}
+
+.marketing-displayed-cell {
+ max-width: 260px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+@media (max-width: 1240px) {
+ .marketing-campaign-controls {
+ grid-template-columns: minmax(240px, 1fr) 140px;
+ }
+
+ .marketing-campaign-controls .primary-button {
+ grid-column: 1 / -1;
+ justify-self: end;
+ }
+
+ .marketing-summary-grid {
+ grid-template-columns: repeat(3, minmax(0, 1fr));
+ }
+}
+
+.history-table-wrap {
+ min-height: 0;
+ overflow: auto;
+}
+
+.history-table {
+ min-width: 900px;
+}
+
+.history-table thead {
+ background: var(--bg);
+ position: sticky;
+ top: 0;
+}
+
+.hash-button {
+ border: 0;
+ background: transparent;
+ color: #174f9d;
+ padding: 0;
+ font-weight: 750;
+}
+
+.hash-button:hover {
+ text-decoration: underline;
+}
+
+.history-card-list {
+ display: none;
+ min-height: 0;
+ overflow: auto;
+ gap: 10px;
+}
+
+.history-card {
+ display: grid;
+ gap: 8px;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface);
+ color: var(--text);
+}
+
+.history-card div {
+ display: flex;
+ justify-content: space-between;
+ gap: 10px;
+ align-items: center;
+}
+
+.history-card span {
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.history-footer {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
+ align-items: center;
+ gap: 12px;
+ min-height: 42px;
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.history-footer > .secondary-button {
+ justify-self: end;
+}
+
+.history-footer-center,
+.history-export-options {
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ gap: 12px;
+}
+
+.history-footer-center {
+ flex-direction: column;
+ gap: 6px;
+}
+
+.history-pagination {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+}
+
+.history-page-button {
+ width: 34px;
+ min-width: 34px;
+ height: 34px;
+ min-height: 34px;
+ padding: 0;
+ font-weight: 750;
+}
+
+.history-page-label {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ white-space: nowrap;
+}
+
+.history-page-label input {
+ width: 58px;
+ height: 34px;
+ padding: 0 6px;
+ text-align: center;
+}
+
+.history-export-options {
+ margin-top: 16px;
+}
+
+.cache-clear-options {
+ display: grid;
+ gap: 10px;
+ margin-top: 16px;
+}
+
+.secondary-button.danger {
+ border-color: rgba(239, 111, 111, 0.5);
+ color: #ff9a9a;
+}
+
+.assets-workspace {
+ min-height: 552px;
+ max-height: 552px;
+ display: grid;
+ grid-template-rows: auto auto minmax(0, 1fr);
+ overflow: hidden;
+}
+
+.assets-header {
+ align-items: center;
+}
+
+.asset-controls {
+ display: grid;
+ grid-template-columns: minmax(160px, 1fr) 150px;
+ gap: 10px;
+}
+
+.asset-controls input,
+.asset-controls select {
+ min-height: 38px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.asset-filter-row {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 8px;
+ margin-bottom: 12px;
+}
+
+.filter-pill {
+ min-height: 32px;
+ border: 1px solid var(--line);
+ border-radius: 999px;
+ background: #ffffff;
+ color: var(--muted);
+ padding: 0 12px;
+ font-weight: 750;
+}
+
+.filter-pill.active,
+.filter-pill:hover {
+ border-color: #bad8f6;
+ background: #eef6ff;
+ color: #165eb5;
+}
+
+.portfolio-grid {
+ min-height: 0;
+ overflow: auto;
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 12px;
+ padding-right: 2px;
+}
+
+.portfolio-card {
+ min-height: 196px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #fbfcfb;
+ padding: 13px;
+ display: grid;
+ gap: 12px;
+}
+
+.portfolio-top {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+}
+
+.portfolio-top span {
+ display: block;
+ color: var(--muted);
+ font-size: 12px;
+ margin-top: 2px;
+}
+
+.portfolio-card > b {
+ font-size: 21px;
+ overflow-wrap: anywhere;
+}
+
+.portfolio-meta {
+ display: grid;
+ grid-template-columns: repeat(3, minmax(0, 1fr));
+ gap: 8px;
+}
+
+.portfolio-meta div {
+ display: grid;
+ gap: 4px;
+}
+
+.portfolio-meta span {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.portfolio-meta strong {
+ overflow-wrap: anywhere;
+}
+
+.asset-card-tags {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 6px;
+}
+
+.asset-card-tag {
+ display: inline-flex;
+ align-items: center;
+ min-height: 24px;
+ border-radius: 999px;
+ padding: 0 9px;
+ background: var(--panel-strong);
+ color: var(--muted);
+ border: 1px solid var(--line);
+ font-size: 12px;
+ font-weight: 800;
+}
+
+.asset-card-tag.holding {
+ background: rgba(70, 230, 136, 0.14);
+ border-color: rgba(70, 230, 136, 0.45);
+ color: var(--green);
+}
+
+.asset-card-tag.created {
+ background: rgba(89, 169, 255, 0.14);
+ border-color: rgba(89, 169, 255, 0.45);
+ color: var(--blue);
+}
+
+.asset-card-tag.fixed {
+ background: rgba(255, 193, 96, 0.16);
+ border-color: rgba(255, 193, 96, 0.44);
+ color: #ffca68;
+}
+
+.asset-origin {
+ color: var(--blue);
+ font-size: 12px;
+ overflow-wrap: anywhere;
+}
+
+.assets-state {
+ min-height: 22px;
+ color: var(--muted);
+ font-size: 13px;
+ text-align: right;
+}
+
+.portfolio-actions {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 8px;
+ align-self: end;
+}
+
+.nfts-workspace {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 280px;
+ gap: 14px;
+ min-height: 552px;
+ height: calc(100vh - 142px);
+ overflow: hidden;
+}
+
+.nft-main,
+.nft-config {
+ min-height: 0;
+}
+
+.nft-main {
+ display: block;
+ overflow: auto;
+ padding-bottom: 14px;
+}
+
+.nft-config {
+ overflow: auto;
+}
+
+.nft-list {
+ min-height: auto;
+ overflow: visible;
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ align-content: start;
+ gap: 12px;
+ padding: 0;
+}
+
+.nft-record {
+ display: grid;
+ gap: 10px;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #111c27;
+ box-shadow: none;
+ overflow: hidden;
+ color: var(--text);
+ cursor: pointer;
+}
+
+.nft-record.active {
+ border-color: var(--blue);
+ background: #17304d;
+}
+
+.nft-card-media,
+.nft-preview {
+ min-height: 150px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #0c141d;
+ display: grid;
+ place-items: center;
+ overflow: hidden;
+}
+
+.nft-card-media img,
+.nft-preview img {
+ width: 100%;
+ height: 100%;
+ object-fit: cover;
+}
+
+.nft-preview {
+ min-height: 220px;
+}
+
+.nft-preview-placeholder {
+ width: 72px;
+ height: 72px;
+ border-radius: 8px;
+ display: grid;
+ place-items: center;
+ background: #20354b;
+ color: #8fc3ff;
+ font-weight: 900;
+ font-size: 28px;
+}
+
+.nft-record-top {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+}
+
+.nft-record-top span {
+ display: block;
+ color: var(--muted);
+ font-size: 12px;
+ margin-top: 2px;
+}
+
+.nft-link-row {
+ display: grid;
+ grid-template-columns: 82px minmax(0, 1fr);
+ gap: 10px;
+ align-items: start;
+}
+
+.nft-link-row span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.nft-actions {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr);
+ gap: 8px;
+}
+
+.nft-actions .secondary-button {
+ min-height: 34px;
+ box-shadow: none;
+}
+
+.nft-config {
+ padding-bottom: 14px;
+}
+
+.nft-footer {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 12px;
+ margin-top: 12px;
+ flex-wrap: wrap;
+}
+
+.nft-detail-list b,
+.nft-link-row code {
+ overflow-wrap: anywhere;
+}
+
+.nft-metadata-summary {
+ display: grid;
+ gap: 10px;
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.nft-metadata-summary p {
+ margin: 0;
+ line-height: 1.45;
+}
+
+.nft-attributes,
+.nft-rwa-fields {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 8px;
+}
+
+.nft-attributes div,
+.nft-rwa-fields div,
+.nft-history-row {
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #0c141d;
+ padding: 10px;
+}
+
+.nft-attributes span,
+.nft-rwa-fields span,
+.nft-history-row span {
+ display: block;
+ color: var(--muted);
+ font-size: 11px;
+ font-weight: 800;
+ margin-bottom: 3px;
+}
+
+.nft-attributes b,
+.nft-rwa-fields b,
+.nft-history-row strong {
+ overflow-wrap: anywhere;
+}
+
+.nft-provenance {
+ display: grid;
+ gap: 10px;
+}
+
+.nft-provenance h3 {
+ margin: 0;
+ font-size: 15px;
+}
+
+.nft-provenance [data-nft-history] {
+ display: grid;
+ gap: 8px;
+}
+
+.nft-history-row {
+ display: grid;
+ gap: 8px;
+}
+
+.nft-history-row code {
+ color: var(--blue);
+ overflow-wrap: anywhere;
+}
+
+.nft-history-empty {
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.settings-form {
+ display: grid;
+ gap: 12px;
+}
+
+.settings-form label {
+ display: grid;
+ gap: 7px;
+}
+
+.settings-form span {
+ color: var(--muted);
+ font-weight: 700;
+ font-size: 13px;
+}
+
+.settings-form input {
+ width: 100%;
+ min-height: 40px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.check-row {
+ grid-template-columns: 18px minmax(0, 1fr);
+ align-items: center;
+}
+
+.check-row input {
+ min-height: auto;
+}
+
+.loans-workspace {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 300px;
+ gap: 14px;
+ height: 552px;
+}
+
+.loan-main,
+.loan-detail {
+ min-height: 0;
+ overflow: auto;
+}
+
+.loans-header {
+ align-items: center;
+}
+
+.loan-controls {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 150px;
+ gap: 10px;
+ margin-bottom: 10px;
+}
+
+.loan-controls input,
+.loan-controls select {
+ min-height: 38px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.loan-filter-row {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 8px;
+ margin-bottom: 12px;
+ align-items: center;
+}
+
+.compact-button {
+ min-height: 32px;
+ padding: 6px 10px;
+ margin-left: auto;
+}
+
+.subtle-state {
+ color: var(--muted);
+ font-size: 13px;
+ padding: 10px 2px;
+}
+
+.loan-list {
+ display: grid;
+ gap: 10px;
+}
+
+.loan-card {
+ border: 1px solid var(--line);
+ border-left-width: 5px;
+ border-radius: 8px;
+ background: #ffffff;
+ color: var(--text);
+ padding: 12px;
+ display: grid;
+ gap: 12px;
+ text-align: left;
+}
+
+.loan-card:has(.role-badge.lending) {
+ border-left-color: #165eb5;
+}
+
+.loan-card:has(.role-badge.borrowing) {
+ border-left-color: #8a5a13;
+}
+
+.loan-card.active,
+.loan-card:hover {
+ border-color: #9fc5ec;
+ background: #f8fbff;
+}
+
+.loan-card-top {
+ display: flex;
+ justify-content: space-between;
+ gap: 12px;
+}
+
+.loan-badges {
+ display: flex;
+ align-items: flex-start;
+ gap: 6px;
+ flex-wrap: wrap;
+ justify-content: flex-end;
+}
+
+.loan-card-top span {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.role-badge,
+.loan-status {
+ height: fit-content;
+ border-radius: 999px;
+ padding: 5px 8px;
+ font-size: 12px;
+ font-weight: 800;
+ white-space: nowrap;
+}
+
+.role-badge.lending {
+ background: #eef6ff;
+ color: #165eb5;
+}
+
+.role-badge.borrowing {
+ background: #fff4d8;
+ color: #8a5a13;
+}
+
+.loan-status.active {
+ background: var(--green-soft);
+ color: var(--green);
+}
+
+.loan-status.due {
+ background: #fff4d8;
+ color: var(--amber);
+}
+
+.loan-status.claimable {
+ background: #fde8e8;
+ color: #a13f3f;
+}
+
+.loan-metrics {
+ display: grid;
+ grid-template-columns: repeat(3, minmax(0, 1fr));
+ gap: 8px;
+}
+
+.loan-next-due {
+ display: grid;
+ justify-items: center;
+ gap: 4px;
+ padding: 10px 8px 2px;
+ border-top: 1px solid var(--line);
+ text-align: center;
+}
+
+.loan-next-due span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 800;
+}
+
+.loan-next-due b {
+ font-size: 14px;
+ font-weight: 900;
+ overflow-wrap: anywhere;
+}
+
+.loan-metrics div,
+.loan-detail-grid div,
+.loan-timeline div {
+ display: grid;
+ gap: 4px;
+}
+
+.loan-metrics span,
+.loan-detail-grid span,
+.loan-timeline span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.loan-detail-grid {
+ display: grid;
+ gap: 10px;
+}
+
+.loan-detail-grid div {
+ padding-bottom: 9px;
+ border-bottom: 1px solid var(--line);
+}
+
+.loan-detail-grid b,
+.loan-metrics b,
+.loan-timeline b {
+ overflow-wrap: anywhere;
+}
+
+.loan-timeline {
+ display: grid;
+ gap: 9px;
+ margin-top: 18px;
+ padding-top: 14px;
+ border-top: 1px solid var(--line);
+}
+
+.loan-timeline h3 {
+ margin: 0;
+ font-size: 15px;
+}
+
+.loan-timeline div {
+ grid-template-columns: minmax(0, 1fr) auto;
+}
+
+.loan-payment-table {
+ overflow: auto;
+}
+
+.loan-payment-table table {
+ width: 100%;
+ border-collapse: collapse;
+ min-width: 460px;
+}
+
+.loan-payment-table th,
+.loan-payment-table td {
+ border-bottom: 1px solid var(--line);
+ padding: 8px 6px;
+ text-align: left;
+ vertical-align: top;
+ font-size: 13px;
+}
+
+.loan-payment-table th {
+ color: var(--muted);
+ font-size: 11px;
+ text-transform: uppercase;
+}
+
+.loan-actions {
+ display: grid;
+ gap: 9px;
+ margin-top: 18px;
+}
+
+.addressbook-workspace {
+ min-height: 552px;
+ max-height: 552px;
+ display: grid;
+ grid-template-rows: auto auto minmax(0, 1fr);
+ overflow: hidden;
+}
+
+.addressbook-header {
+ align-items: center;
+}
+
+.addressbook-controls {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 190px;
+ gap: 10px;
+ margin-bottom: 12px;
+}
+
+.addressbook-controls input,
+.addressbook-controls select {
+ min-height: 38px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.addressbook-table-wrap {
+ min-height: 0;
+ overflow: auto;
+}
+
+.addressbook-card-list {
+ display: none;
+ min-height: 0;
+ overflow: auto;
+ gap: 10px;
+}
+
+.addressbook-card {
+ display: grid;
+ gap: 10px;
+ padding: 12px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface);
+ color: var(--text);
+}
+
+.addressbook-card-top {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 42px;
+ gap: 8px;
+ align-items: center;
+}
+
+.addressbook-card > div:not(.addressbook-card-top) {
+ display: grid;
+ gap: 4px;
+}
+
+.addressbook-card span {
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 750;
+}
+
+.addressbook-card b {
+ min-width: 0;
+ overflow-wrap: anywhere;
+}
+
+.addressbook-table {
+ min-width: 760px;
+}
+
+.addressbook-table code {
+ font-size: 13px;
+}
+
+.addressbook-copy-value {
+ border: 0;
+ background: transparent;
+ color: var(--accent);
+ padding: 0;
+ font: inherit;
+ font-weight: 750;
+ cursor: pointer;
+}
+
+.addressbook-copy-value:hover,
+.addressbook-copy-value:focus {
+ text-decoration: underline;
+ outline: none;
+}
+
+.addressbook-table th:last-child,
+.addressbook-table td:last-child {
+ width: 48px;
+ text-align: right;
+}
+
+.addressbook-actions {
+ white-space: nowrap;
+}
+
+.addressbook-delete-button {
+ color: #ffb4a8;
+}
+
+.addressbook-delete-button:hover,
+.addressbook-delete-button:focus {
+ border-color: rgba(255, 106, 89, 0.65);
+ color: #ffd0c8;
+}
+
+.addressbook-label-input {
+ width: 100%;
+ min-height: 34px;
+ border: 1px solid transparent;
+ border-radius: 8px;
+ padding: 7px 9px;
+ background: transparent;
+ color: var(--text);
+ font-weight: 700;
+}
+
+.addressbook-label-input:hover,
+.addressbook-label-input:focus {
+ border-color: var(--line);
+ background: var(--panel-strong);
+ outline: none;
+}
+
+.addressbook-state {
+ min-height: 22px;
+ color: var(--muted);
+ font-size: 13px;
+ text-align: right;
+}
+
+.addressbook-table td:nth-child(3) {
+ max-width: 360px;
+}
+
+.settings-workspace {
+ min-height: 552px;
+ height: calc(100vh - 142px);
+ display: grid;
+ grid-template-rows: auto minmax(0, 1fr) auto;
+ overflow: hidden;
+}
+
+.settings-header {
+ align-items: center;
+}
+
+.settings-grid {
+ min-height: 0;
+ overflow: auto;
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 12px;
+ padding-right: 2px;
+}
+
+.settings-section {
+ display: grid;
+ align-content: start;
+ gap: 11px;
+ padding: 13px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: #ffffff;
+}
+
+.settings-section h3 {
+ margin: 0;
+ font-size: 16px;
+}
+
+.settings-section label {
+ display: grid;
+ gap: 7px;
+}
+
+.settings-section span {
+ color: var(--muted);
+ font-size: 13px;
+ font-weight: 750;
+}
+
+.settings-help {
+ margin: -3px 0 2px;
+ color: var(--muted);
+ font-size: 12px;
+ line-height: 1.45;
+}
+
+.settings-section input,
+.settings-section select,
+.settings-section textarea {
+ width: 100%;
+ min-height: 38px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 8px 10px;
+ background: #fbfcfb;
+ color: var(--text);
+}
+
+.settings-section textarea {
+ min-height: 82px;
+ resize: vertical;
+}
+
+.settings-path-row {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) 42px;
+ gap: 8px;
+ align-items: center;
+}
+
+.settings-path-row .secondary-button {
+ min-width: 0;
+ padding: 0;
+}
+
+/* Dark application theme */
+:root {
+ --bg: #111820;
+ --surface: #18222d;
+ --surface-soft: #202d39;
+ --text: #edf3f7;
+ --muted: #9facb8;
+ --line: #30404e;
+ --green: #58d08b;
+ --green-soft: #173a2d;
+ --blue: #7db7ff;
+ --amber: #f0bf69;
+ --ink: #f4f8fb;
+ --shadow: 0 18px 44px rgba(2, 8, 14, 0.34);
+}
+
+body {
+ background: var(--bg);
+}
+
+.app-shell,
+.sidebar,
+.topbar,
+.panel,
+.node-modal,
+.select-button,
+.icon-button,
+.info-button,
+.secondary-button,
+.text-button,
+.wide-button,
+.filter-pill,
+.transaction-type,
+.quick-actions button,
+.address-card,
+.local-transaction,
+.review-grid div,
+.receive-address-card,
+.qr-placeholder,
+.portfolio-card,
+.nft-record,
+.loan-card,
+.settings-section {
+ background: var(--surface);
+ color: var(--text);
+ border-color: var(--line);
+}
+
+.topbar {
+ background: rgba(24, 34, 45, 0.92);
+}
+
+.brand-mark,
+.coin-stack {
+ background: #24364a;
+ color: #8fc3ff;
+}
+
+.nav-item {
+ color: #cad5df;
+}
+
+.nav-item:hover,
+.nav-item.active {
+ background: #285f9f;
+ color: #ffffff;
+}
+
+.primary-button {
+ border-color: #5fbb8a;
+ background: #1f7a51;
+ color: #ffffff;
+}
+
+.height-pill,
+.registration-badge,
+.table-status.confirmed,
+.loan-status.active {
+ background: #173a2d;
+ color: #75dea0;
+}
+
+.table-status.pending,
+.loan-status.due,
+.role-badge.borrowing {
+ background: #3d321e;
+ color: #f0bf69;
+}
+
+.role-badge.lending,
+.transaction-type.active,
+.transaction-type:hover,
+.filter-pill.active,
+.filter-pill:hover,
+.local-transaction.active,
+.local-transaction:hover,
+.loan-card.active,
+.loan-card:hover,
+.quick-actions button:nth-child(1) {
+ background: #1f3550;
+ color: #8fc3ff;
+ border-color: #3e6fa3;
+}
+
+.quick-actions button:nth-child(2) {
+ background: #173a2d;
+ color: #75dea0;
+ border-color: #2f6d4b;
+}
+
+.quick-actions button:nth-child(3) {
+ background: #3d321e;
+ color: #f0bf69;
+ border-color: #745c29;
+}
+
+.quick-actions button:nth-child(4) {
+ background: #302849;
+ color: #c8a8ff;
+ border-color: #5b4c83;
+}
+
+.asset-mark.clc,
+.asset-mark.usdg {
+ background: #173a2d;
+ color: #75dea0;
+}
+
+.asset-mark.fun,
+.asset-mark.gold,
+.asset-mark.api {
+ background: #3d321e;
+ color: #f0bf69;
+}
+
+.asset-mark.art {
+ background: #302849;
+ color: #c8a8ff;
+}
+
+input,
+select,
+textarea,
+.request-form input,
+.request-form select,
+.form-grid input,
+.form-grid select,
+.form-grid textarea,
+.asset-controls input,
+.asset-controls select,
+.loan-controls input,
+.loan-controls select,
+.addressbook-controls input,
+.addressbook-controls select,
+.settings-section input,
+.settings-section select,
+.settings-section textarea,
+.settings-form input {
+ background: #121b24;
+ color: var(--text);
+ border-color: var(--line);
+}
+
+input::placeholder {
+ color: #718190;
+}
+
+code,
+.hash-button,
+.text-button,
+.wide-button {
+ color: #8fc3ff;
+}
+
+.modal-backdrop {
+ background: rgba(2, 8, 14, 0.52);
+}
+
+th,
+td {
+ border-bottom-color: var(--line);
+}
+
+tr:hover td {
+ background: rgba(143, 195, 255, 0.04);
+}
+
+* {
+ scrollbar-color: #607488 #121b24;
+}
+
+.hidden {
+ display: none !important;
+}
+
+.form-grid {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 14px;
+}
+
+.form-grid label {
+ display: grid;
+ gap: 7px;
+}
+
+.form-grid span {
+ color: var(--muted);
+ font-weight: 700;
+ font-size: 13px;
+}
+
+.form-grid input,
+.form-grid select,
+.form-grid textarea {
+ width: 100%;
+ min-height: 42px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 9px 11px;
+ background: #121b24;
+ color: var(--text);
+}
+
+.input-with-button {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ gap: 8px;
+ align-items: center;
+}
+
+.input-with-button .secondary-button {
+ min-height: 42px;
+ white-space: nowrap;
+}
+
+.form-grid input:read-only,
+.form-grid input:disabled {
+ background: #0d151d;
+ color: var(--muted);
+ cursor: default;
+}
+
+.form-grid .checkbox-row {
+ grid-template-columns: 18px 1fr;
+ align-items: center;
+ gap: 10px;
+ min-height: 42px;
+}
+
+.form-grid .checkbox-row input[type="checkbox"] {
+ width: 18px;
+ min-height: 18px;
+ accent-color: var(--accent);
+}
+
+.form-grid .checkbox-row span {
+ color: var(--text);
+}
+
+.form-grid textarea {
+ min-height: 150px;
+ resize: vertical;
+}
+
+.form-grid .wide {
+ grid-column: 1 / -1;
+}
+
+.mobile-nav {
+ display: none;
+}
+
+.mobile-more-backdrop,
+.mobile-more-sheet {
+ display: none;
+}
+
+@media (max-width: 980px) {
+ .app-shell {
+ grid-template-columns: 1fr;
+ min-height: 100vh;
+ }
+
+ .sidebar {
+ display: none;
+ }
+
+ .topbar-wallet-mark {
+ display: inline-grid;
+ }
+
+ .topbar {
+ flex-wrap: wrap;
+ padding: 12px 16px;
+ }
+
+ .topbar-spacer {
+ display: none;
+ }
+
+ .topbar-group {
+ flex: 1 1 180px;
+ }
+
+ .payment-uri-entry {
+ max-width: none;
+ }
+
+ .select-button,
+ .node-select .select-button,
+ .wallet-select .select-button {
+ width: 100%;
+ min-width: 0;
+ }
+
+ .content {
+ padding: 20px 16px 90px;
+ }
+
+ .dashboard-grid {
+ grid-template-columns: 1fr;
+ grid-template-areas:
+ "balance"
+ "registration"
+ "quick"
+ "transactions"
+ "network"
+ "notice";
+ }
+
+ .transaction-workspace {
+ grid-template-columns: 1fr;
+ min-height: auto;
+ max-height: none;
+ }
+
+ .receive-workspace {
+ grid-template-columns: 1fr;
+ min-height: auto;
+ max-height: none;
+ }
+
+ .history-workspace {
+ min-height: auto;
+ height: auto;
+ max-height: none;
+ }
+
+ .marketing-campaign-controls {
+ grid-template-columns: 1fr;
+ width: 100%;
+ }
+
+ .marketing-summary-grid {
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ }
+
+ .assets-workspace {
+ min-height: auto;
+ max-height: none;
+ }
+
+ .nfts-workspace {
+ grid-template-columns: 1fr;
+ height: auto;
+ overflow: visible;
+ }
+
+ .loans-workspace {
+ grid-template-columns: 1fr;
+ height: auto;
+ }
+
+ .addressbook-workspace {
+ min-height: auto;
+ max-height: none;
+ }
+
+ .settings-workspace {
+ min-height: auto;
+ height: auto;
+ max-height: none;
+ }
+
+ .nft-main,
+ .nft-config {
+ max-height: none;
+ }
+
+ .transaction-types {
+ order: -1;
+ }
+
+ .transaction-type-list {
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ max-height: none;
+ }
+
+ .receive-request {
+ grid-template-columns: 190px minmax(0, 1fr);
+ }
+
+ .portfolio-grid {
+ grid-template-columns: 1fr;
+ }
+
+ table {
+ min-width: 0;
+ }
+
+ .transactions-panel {
+ grid-column: auto;
+ }
+
+ .asset-summary-grid {
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ }
+
+ .mobile-nav {
+ position: fixed;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ z-index: 10;
+ display: grid;
+ grid-template-columns: repeat(5, 1fr);
+ min-height: 66px;
+ background: var(--surface);
+ border-top: 1px solid var(--line);
+ }
+
+ .mobile-item {
+ color: var(--muted);
+ display: grid;
+ place-items: center;
+ gap: 3px;
+ font-size: 18px;
+ }
+
+ .mobile-item span {
+ font-size: 11px;
+ font-weight: 700;
+ }
+
+ .mobile-item.active {
+ color: var(--green);
+ }
+
+ .mobile-more-backdrop {
+ position: fixed;
+ inset: 0;
+ z-index: 11;
+ display: block;
+ background: rgba(9, 16, 22, 0.42);
+ }
+
+ .mobile-more-backdrop.hidden {
+ display: none;
+ }
+
+ .mobile-more-sheet {
+ position: fixed;
+ left: 10px;
+ right: 10px;
+ bottom: 78px;
+ z-index: 12;
+ display: grid;
+ gap: 8px;
+ padding: 10px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface);
+ box-shadow: var(--shadow);
+ }
+
+ .mobile-more-sheet.hidden {
+ display: none;
+ }
+
+ .mobile-more-item {
+ min-height: 48px;
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ background: var(--surface-soft);
+ color: var(--text);
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ padding: 0 12px;
+ text-align: left;
+ }
+
+ .mobile-more-item span {
+ width: 22px;
+ color: var(--green);
+ text-align: center;
+ font-weight: 800;
+ }
+
+ .mobile-more-item b {
+ font-size: 14px;
+ }
+}
+
+@media (max-width: 1180px) and (min-width: 981px) {
+ .balance-split {
+ grid-template-columns: 1fr;
+ align-items: start;
+ }
+
+ .token-balances {
+ border-left: 0;
+ border-top: 1px solid var(--line);
+ padding-left: 0;
+ padding-top: 14px;
+ }
+
+ .balance-main {
+ min-height: auto;
+ }
+}
+
+@media (max-width: 640px) {
+ .view-heading {
+ display: grid;
+ }
+
+ .heading-actions {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ }
+
+ .topbar {
+ display: grid;
+ grid-template-columns: 1fr auto auto 1fr;
+ gap: 10px;
+ padding: 12px;
+ }
+
+ .topbar-wallet-mark {
+ grid-column: 1;
+ justify-self: start;
+ }
+
+ .topbar > .info-button {
+ grid-column: 2;
+ justify-self: end;
+ }
+
+ .topbar > .icon-button {
+ grid-column: 3;
+ justify-self: start;
+ }
+
+ .topbar-group {
+ grid-column: 1 / -1;
+ width: 100%;
+ }
+
+ .height-pill {
+ flex: 1;
+ justify-content: center;
+ }
+
+ h1 {
+ font-size: 25px;
+ }
+
+ .balance-value {
+ font-size: 27px;
+ }
+
+ .panel {
+ padding: 15px;
+ }
+
+ #marketing-view .panel-header {
+ display: grid;
+ grid-template-columns: 1fr;
+ align-items: stretch;
+ gap: 14px;
+ }
+
+ #marketing-view .marketing-campaign-controls {
+ grid-template-columns: 1fr;
+ min-width: 0;
+ width: 100%;
+ }
+
+ #marketing-view .marketing-campaign-controls .primary-button {
+ width: 100%;
+ justify-self: stretch;
+ }
+
+ .asset-row {
+ grid-template-columns: 38px minmax(0, 1fr);
+ }
+
+ .asset-row b {
+ grid-column: 2;
+ }
+
+ .asset-summary-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .nft-list,
+ .nft-attributes,
+ .nft-rwa-fields {
+ grid-template-columns: 1fr;
+ }
+
+ table {
+ min-width: 0;
+ }
+
+ th:nth-child(3),
+ td:nth-child(3) {
+ display: none;
+ }
+
+ .balance-split {
+ grid-template-columns: 1fr;
+ }
+
+ .token-balances {
+ border-left: 0;
+ border-top: 1px solid var(--line);
+ padding-left: 0;
+ padding-top: 14px;
+ }
+
+ .form-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .form-grid.compact,
+ .review-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .input-with-button {
+ grid-template-columns: 1fr;
+ }
+
+ .create-nft-help-row {
+ justify-content: stretch;
+ }
+
+ .create-nft-help-row .secondary-button {
+ width: 100%;
+ }
+
+ .nft-instructions-backdrop {
+ padding: 12px;
+ }
+
+ .nft-instructions-modal {
+ width: 100%;
+ max-height: calc(100vh - 24px);
+ padding: 12px;
+ }
+
+ .nft-hosting-links {
+ grid-template-columns: 1fr;
+ }
+
+ .nft-instructions-body section {
+ padding: 12px;
+ }
+
+ .transaction-type-list {
+ grid-template-columns: 1fr;
+ }
+
+ .receive-request,
+ .request-form {
+ grid-template-columns: 1fr;
+ }
+
+ .copy-row {
+ grid-template-columns: 1fr;
+ }
+
+ .history-table-wrap {
+ display: none;
+ }
+
+ .history-card-list {
+ display: grid;
+ }
+
+ .history-footer {
+ grid-template-columns: 1fr;
+ }
+
+ .history-footer > .secondary-button {
+ justify-self: center;
+ }
+
+ .history-pagination {
+ flex-wrap: wrap;
+ justify-content: center;
+ }
+
+ .assets-header {
+ display: grid;
+ }
+
+ .asset-controls,
+ .portfolio-meta {
+ grid-template-columns: 1fr;
+ }
+
+ .nft-actions {
+ grid-template-columns: 1fr;
+ }
+
+ .loan-controls,
+ .loan-metrics,
+ .addressbook-controls {
+ grid-template-columns: 1fr;
+ }
+
+ .addressbook-table-wrap {
+ display: none;
+ }
+
+ .addressbook-card-list {
+ display: grid;
+ }
+
+ .settings-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .nft-link-row {
+ grid-template-columns: 1fr;
+ }
+
+ .transaction-header,
+ .form-actions {
+ display: grid;
+ justify-content: stretch;
+ }
+}
diff --git a/gen/schemas/acl-manifests.json b/gen/schemas/acl-manifests.json
new file mode 100644
index 0000000..0eebfc4
--- /dev/null
+++ b/gen/schemas/acl-manifests.json
@@ -0,0 +1 @@
+{"core":{"default_permission":{"identifier":"default","description":"Default core plugins set.","permissions":["core:path:default","core:event:default","core:window:default","core:webview:default","core:app:default","core:image:default","core:resources:default","core:menu:default","core:tray:default"]},"permissions":{},"permission_sets":{},"global_scope_schema":null},"core:app":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-version","allow-name","allow-tauri-version","allow-identifier","allow-bundle-type","allow-register-listener","allow-remove-listener","allow-supports-multiple-windows"]},"permissions":{"allow-app-hide":{"identifier":"allow-app-hide","description":"Enables the app_hide command without any pre-configured scope.","commands":{"allow":["app_hide"],"deny":[]}},"allow-app-show":{"identifier":"allow-app-show","description":"Enables the app_show command without any pre-configured scope.","commands":{"allow":["app_show"],"deny":[]}},"allow-bundle-type":{"identifier":"allow-bundle-type","description":"Enables the bundle_type command without any pre-configured scope.","commands":{"allow":["bundle_type"],"deny":[]}},"allow-default-window-icon":{"identifier":"allow-default-window-icon","description":"Enables the default_window_icon command without any pre-configured scope.","commands":{"allow":["default_window_icon"],"deny":[]}},"allow-fetch-data-store-identifiers":{"identifier":"allow-fetch-data-store-identifiers","description":"Enables the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":["fetch_data_store_identifiers"],"deny":[]}},"allow-identifier":{"identifier":"allow-identifier","description":"Enables the identifier command without any pre-configured scope.","commands":{"allow":["identifier"],"deny":[]}},"allow-name":{"identifier":"allow-name","description":"Enables the name command without any pre-configured scope.","commands":{"allow":["name"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-data-store":{"identifier":"allow-remove-data-store","description":"Enables the remove_data_store command without any pre-configured scope.","commands":{"allow":["remove_data_store"],"deny":[]}},"allow-remove-listener":{"identifier":"allow-remove-listener","description":"Enables the remove_listener command without any pre-configured scope.","commands":{"allow":["remove_listener"],"deny":[]}},"allow-set-app-theme":{"identifier":"allow-set-app-theme","description":"Enables the set_app_theme command without any pre-configured scope.","commands":{"allow":["set_app_theme"],"deny":[]}},"allow-set-dock-visibility":{"identifier":"allow-set-dock-visibility","description":"Enables the set_dock_visibility command without any pre-configured scope.","commands":{"allow":["set_dock_visibility"],"deny":[]}},"allow-supports-multiple-windows":{"identifier":"allow-supports-multiple-windows","description":"Enables the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":["supports_multiple_windows"],"deny":[]}},"allow-tauri-version":{"identifier":"allow-tauri-version","description":"Enables the tauri_version command without any pre-configured scope.","commands":{"allow":["tauri_version"],"deny":[]}},"allow-version":{"identifier":"allow-version","description":"Enables the version command without any pre-configured scope.","commands":{"allow":["version"],"deny":[]}},"deny-app-hide":{"identifier":"deny-app-hide","description":"Denies the app_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["app_hide"]}},"deny-app-show":{"identifier":"deny-app-show","description":"Denies the app_show command without any pre-configured scope.","commands":{"allow":[],"deny":["app_show"]}},"deny-bundle-type":{"identifier":"deny-bundle-type","description":"Denies the bundle_type command without any pre-configured scope.","commands":{"allow":[],"deny":["bundle_type"]}},"deny-default-window-icon":{"identifier":"deny-default-window-icon","description":"Denies the default_window_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["default_window_icon"]}},"deny-fetch-data-store-identifiers":{"identifier":"deny-fetch-data-store-identifiers","description":"Denies the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":[],"deny":["fetch_data_store_identifiers"]}},"deny-identifier":{"identifier":"deny-identifier","description":"Denies the identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["identifier"]}},"deny-name":{"identifier":"deny-name","description":"Denies the name command without any pre-configured scope.","commands":{"allow":[],"deny":["name"]}},"deny-register-listener":{"identifier":"deny-register-listener","description":"Denies the register_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["register_listener"]}},"deny-remove-data-store":{"identifier":"deny-remove-data-store","description":"Denies the remove_data_store command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_data_store"]}},"deny-remove-listener":{"identifier":"deny-remove-listener","description":"Denies the remove_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_listener"]}},"deny-set-app-theme":{"identifier":"deny-set-app-theme","description":"Denies the set_app_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_app_theme"]}},"deny-set-dock-visibility":{"identifier":"deny-set-dock-visibility","description":"Denies the set_dock_visibility command without any pre-configured scope.","commands":{"allow":[],"deny":["set_dock_visibility"]}},"deny-supports-multiple-windows":{"identifier":"deny-supports-multiple-windows","description":"Denies the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["supports_multiple_windows"]}},"deny-tauri-version":{"identifier":"deny-tauri-version","description":"Denies the tauri_version command without any pre-configured scope.","commands":{"allow":[],"deny":["tauri_version"]}},"deny-version":{"identifier":"deny-version","description":"Denies the version command without any pre-configured scope.","commands":{"allow":[],"deny":["version"]}}},"permission_sets":{},"global_scope_schema":null},"core:event":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-listen","allow-unlisten","allow-emit","allow-emit-to"]},"permissions":{"allow-emit":{"identifier":"allow-emit","description":"Enables the emit command without any pre-configured scope.","commands":{"allow":["emit"],"deny":[]}},"allow-emit-to":{"identifier":"allow-emit-to","description":"Enables the emit_to command without any pre-configured scope.","commands":{"allow":["emit_to"],"deny":[]}},"allow-listen":{"identifier":"allow-listen","description":"Enables the listen command without any pre-configured scope.","commands":{"allow":["listen"],"deny":[]}},"allow-unlisten":{"identifier":"allow-unlisten","description":"Enables the unlisten command without any pre-configured scope.","commands":{"allow":["unlisten"],"deny":[]}},"deny-emit":{"identifier":"deny-emit","description":"Denies the emit command without any pre-configured scope.","commands":{"allow":[],"deny":["emit"]}},"deny-emit-to":{"identifier":"deny-emit-to","description":"Denies the emit_to command without any pre-configured scope.","commands":{"allow":[],"deny":["emit_to"]}},"deny-listen":{"identifier":"deny-listen","description":"Denies the listen command without any pre-configured scope.","commands":{"allow":[],"deny":["listen"]}},"deny-unlisten":{"identifier":"deny-unlisten","description":"Denies the unlisten command without any pre-configured scope.","commands":{"allow":[],"deny":["unlisten"]}}},"permission_sets":{},"global_scope_schema":null},"core:image":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-from-bytes","allow-from-path","allow-rgba","allow-size"]},"permissions":{"allow-from-bytes":{"identifier":"allow-from-bytes","description":"Enables the from_bytes command without any pre-configured scope.","commands":{"allow":["from_bytes"],"deny":[]}},"allow-from-path":{"identifier":"allow-from-path","description":"Enables the from_path command without any pre-configured scope.","commands":{"allow":["from_path"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-rgba":{"identifier":"allow-rgba","description":"Enables the rgba command without any pre-configured scope.","commands":{"allow":["rgba"],"deny":[]}},"allow-size":{"identifier":"allow-size","description":"Enables the size command without any pre-configured scope.","commands":{"allow":["size"],"deny":[]}},"deny-from-bytes":{"identifier":"deny-from-bytes","description":"Denies the from_bytes command without any pre-configured scope.","commands":{"allow":[],"deny":["from_bytes"]}},"deny-from-path":{"identifier":"deny-from-path","description":"Denies the from_path command without any pre-configured scope.","commands":{"allow":[],"deny":["from_path"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-rgba":{"identifier":"deny-rgba","description":"Denies the rgba command without any pre-configured scope.","commands":{"allow":[],"deny":["rgba"]}},"deny-size":{"identifier":"deny-size","description":"Denies the size command without any pre-configured scope.","commands":{"allow":[],"deny":["size"]}}},"permission_sets":{},"global_scope_schema":null},"core:menu":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-append","allow-prepend","allow-insert","allow-remove","allow-remove-at","allow-items","allow-get","allow-popup","allow-create-default","allow-set-as-app-menu","allow-set-as-window-menu","allow-text","allow-set-text","allow-is-enabled","allow-set-enabled","allow-set-accelerator","allow-set-as-windows-menu-for-nsapp","allow-set-as-help-menu-for-nsapp","allow-is-checked","allow-set-checked","allow-set-icon"]},"permissions":{"allow-append":{"identifier":"allow-append","description":"Enables the append command without any pre-configured scope.","commands":{"allow":["append"],"deny":[]}},"allow-create-default":{"identifier":"allow-create-default","description":"Enables the create_default command without any pre-configured scope.","commands":{"allow":["create_default"],"deny":[]}},"allow-get":{"identifier":"allow-get","description":"Enables the get command without any pre-configured scope.","commands":{"allow":["get"],"deny":[]}},"allow-insert":{"identifier":"allow-insert","description":"Enables the insert command without any pre-configured scope.","commands":{"allow":["insert"],"deny":[]}},"allow-is-checked":{"identifier":"allow-is-checked","description":"Enables the is_checked command without any pre-configured scope.","commands":{"allow":["is_checked"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-items":{"identifier":"allow-items","description":"Enables the items command without any pre-configured scope.","commands":{"allow":["items"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-popup":{"identifier":"allow-popup","description":"Enables the popup command without any pre-configured scope.","commands":{"allow":["popup"],"deny":[]}},"allow-prepend":{"identifier":"allow-prepend","description":"Enables the prepend command without any pre-configured scope.","commands":{"allow":["prepend"],"deny":[]}},"allow-remove":{"identifier":"allow-remove","description":"Enables the remove command without any pre-configured scope.","commands":{"allow":["remove"],"deny":[]}},"allow-remove-at":{"identifier":"allow-remove-at","description":"Enables the remove_at command without any pre-configured scope.","commands":{"allow":["remove_at"],"deny":[]}},"allow-set-accelerator":{"identifier":"allow-set-accelerator","description":"Enables the set_accelerator command without any pre-configured scope.","commands":{"allow":["set_accelerator"],"deny":[]}},"allow-set-as-app-menu":{"identifier":"allow-set-as-app-menu","description":"Enables the set_as_app_menu command without any pre-configured scope.","commands":{"allow":["set_as_app_menu"],"deny":[]}},"allow-set-as-help-menu-for-nsapp":{"identifier":"allow-set-as-help-menu-for-nsapp","description":"Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_help_menu_for_nsapp"],"deny":[]}},"allow-set-as-window-menu":{"identifier":"allow-set-as-window-menu","description":"Enables the set_as_window_menu command without any pre-configured scope.","commands":{"allow":["set_as_window_menu"],"deny":[]}},"allow-set-as-windows-menu-for-nsapp":{"identifier":"allow-set-as-windows-menu-for-nsapp","description":"Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_windows_menu_for_nsapp"],"deny":[]}},"allow-set-checked":{"identifier":"allow-set-checked","description":"Enables the set_checked command without any pre-configured scope.","commands":{"allow":["set_checked"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-text":{"identifier":"allow-set-text","description":"Enables the set_text command without any pre-configured scope.","commands":{"allow":["set_text"],"deny":[]}},"allow-text":{"identifier":"allow-text","description":"Enables the text command without any pre-configured scope.","commands":{"allow":["text"],"deny":[]}},"deny-append":{"identifier":"deny-append","description":"Denies the append command without any pre-configured scope.","commands":{"allow":[],"deny":["append"]}},"deny-create-default":{"identifier":"deny-create-default","description":"Denies the create_default command without any pre-configured scope.","commands":{"allow":[],"deny":["create_default"]}},"deny-get":{"identifier":"deny-get","description":"Denies the get command without any pre-configured scope.","commands":{"allow":[],"deny":["get"]}},"deny-insert":{"identifier":"deny-insert","description":"Denies the insert command without any pre-configured scope.","commands":{"allow":[],"deny":["insert"]}},"deny-is-checked":{"identifier":"deny-is-checked","description":"Denies the is_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["is_checked"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-items":{"identifier":"deny-items","description":"Denies the items command without any pre-configured scope.","commands":{"allow":[],"deny":["items"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-popup":{"identifier":"deny-popup","description":"Denies the popup command without any pre-configured scope.","commands":{"allow":[],"deny":["popup"]}},"deny-prepend":{"identifier":"deny-prepend","description":"Denies the prepend command without any pre-configured scope.","commands":{"allow":[],"deny":["prepend"]}},"deny-remove":{"identifier":"deny-remove","description":"Denies the remove command without any pre-configured scope.","commands":{"allow":[],"deny":["remove"]}},"deny-remove-at":{"identifier":"deny-remove-at","description":"Denies the remove_at command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_at"]}},"deny-set-accelerator":{"identifier":"deny-set-accelerator","description":"Denies the set_accelerator command without any pre-configured scope.","commands":{"allow":[],"deny":["set_accelerator"]}},"deny-set-as-app-menu":{"identifier":"deny-set-as-app-menu","description":"Denies the set_as_app_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_app_menu"]}},"deny-set-as-help-menu-for-nsapp":{"identifier":"deny-set-as-help-menu-for-nsapp","description":"Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_help_menu_for_nsapp"]}},"deny-set-as-window-menu":{"identifier":"deny-set-as-window-menu","description":"Denies the set_as_window_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_window_menu"]}},"deny-set-as-windows-menu-for-nsapp":{"identifier":"deny-set-as-windows-menu-for-nsapp","description":"Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_windows_menu_for_nsapp"]}},"deny-set-checked":{"identifier":"deny-set-checked","description":"Denies the set_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["set_checked"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-text":{"identifier":"deny-set-text","description":"Denies the set_text command without any pre-configured scope.","commands":{"allow":[],"deny":["set_text"]}},"deny-text":{"identifier":"deny-text","description":"Denies the text command without any pre-configured scope.","commands":{"allow":[],"deny":["text"]}}},"permission_sets":{},"global_scope_schema":null},"core:path":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-resolve-directory","allow-resolve","allow-normalize","allow-join","allow-dirname","allow-extname","allow-basename","allow-is-absolute"]},"permissions":{"allow-basename":{"identifier":"allow-basename","description":"Enables the basename command without any pre-configured scope.","commands":{"allow":["basename"],"deny":[]}},"allow-dirname":{"identifier":"allow-dirname","description":"Enables the dirname command without any pre-configured scope.","commands":{"allow":["dirname"],"deny":[]}},"allow-extname":{"identifier":"allow-extname","description":"Enables the extname command without any pre-configured scope.","commands":{"allow":["extname"],"deny":[]}},"allow-is-absolute":{"identifier":"allow-is-absolute","description":"Enables the is_absolute command without any pre-configured scope.","commands":{"allow":["is_absolute"],"deny":[]}},"allow-join":{"identifier":"allow-join","description":"Enables the join command without any pre-configured scope.","commands":{"allow":["join"],"deny":[]}},"allow-normalize":{"identifier":"allow-normalize","description":"Enables the normalize command without any pre-configured scope.","commands":{"allow":["normalize"],"deny":[]}},"allow-resolve":{"identifier":"allow-resolve","description":"Enables the resolve command without any pre-configured scope.","commands":{"allow":["resolve"],"deny":[]}},"allow-resolve-directory":{"identifier":"allow-resolve-directory","description":"Enables the resolve_directory command without any pre-configured scope.","commands":{"allow":["resolve_directory"],"deny":[]}},"deny-basename":{"identifier":"deny-basename","description":"Denies the basename command without any pre-configured scope.","commands":{"allow":[],"deny":["basename"]}},"deny-dirname":{"identifier":"deny-dirname","description":"Denies the dirname command without any pre-configured scope.","commands":{"allow":[],"deny":["dirname"]}},"deny-extname":{"identifier":"deny-extname","description":"Denies the extname command without any pre-configured scope.","commands":{"allow":[],"deny":["extname"]}},"deny-is-absolute":{"identifier":"deny-is-absolute","description":"Denies the is_absolute command without any pre-configured scope.","commands":{"allow":[],"deny":["is_absolute"]}},"deny-join":{"identifier":"deny-join","description":"Denies the join command without any pre-configured scope.","commands":{"allow":[],"deny":["join"]}},"deny-normalize":{"identifier":"deny-normalize","description":"Denies the normalize command without any pre-configured scope.","commands":{"allow":[],"deny":["normalize"]}},"deny-resolve":{"identifier":"deny-resolve","description":"Denies the resolve command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve"]}},"deny-resolve-directory":{"identifier":"deny-resolve-directory","description":"Denies the resolve_directory command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve_directory"]}}},"permission_sets":{},"global_scope_schema":null},"core:resources":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-close"]},"permissions":{"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}}},"permission_sets":{},"global_scope_schema":null},"core:tray":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-get-by-id","allow-remove-by-id","allow-set-icon","allow-set-menu","allow-set-tooltip","allow-set-title","allow-set-visible","allow-set-temp-dir-path","allow-set-icon-as-template","allow-set-icon-with-as-template","allow-set-show-menu-on-left-click"]},"permissions":{"allow-get-by-id":{"identifier":"allow-get-by-id","description":"Enables the get_by_id command without any pre-configured scope.","commands":{"allow":["get_by_id"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-remove-by-id":{"identifier":"allow-remove-by-id","description":"Enables the remove_by_id command without any pre-configured scope.","commands":{"allow":["remove_by_id"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-icon-as-template":{"identifier":"allow-set-icon-as-template","description":"Enables the set_icon_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_as_template"],"deny":[]}},"allow-set-icon-with-as-template":{"identifier":"allow-set-icon-with-as-template","description":"Enables the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_with_as_template"],"deny":[]}},"allow-set-menu":{"identifier":"allow-set-menu","description":"Enables the set_menu command without any pre-configured scope.","commands":{"allow":["set_menu"],"deny":[]}},"allow-set-show-menu-on-left-click":{"identifier":"allow-set-show-menu-on-left-click","description":"Enables the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":["set_show_menu_on_left_click"],"deny":[]}},"allow-set-temp-dir-path":{"identifier":"allow-set-temp-dir-path","description":"Enables the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":["set_temp_dir_path"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-tooltip":{"identifier":"allow-set-tooltip","description":"Enables the set_tooltip command without any pre-configured scope.","commands":{"allow":["set_tooltip"],"deny":[]}},"allow-set-visible":{"identifier":"allow-set-visible","description":"Enables the set_visible command without any pre-configured scope.","commands":{"allow":["set_visible"],"deny":[]}},"deny-get-by-id":{"identifier":"deny-get-by-id","description":"Denies the get_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["get_by_id"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-remove-by-id":{"identifier":"deny-remove-by-id","description":"Denies the remove_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_by_id"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-icon-as-template":{"identifier":"deny-set-icon-as-template","description":"Denies the set_icon_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_as_template"]}},"deny-set-icon-with-as-template":{"identifier":"deny-set-icon-with-as-template","description":"Denies the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_with_as_template"]}},"deny-set-menu":{"identifier":"deny-set-menu","description":"Denies the set_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_menu"]}},"deny-set-show-menu-on-left-click":{"identifier":"deny-set-show-menu-on-left-click","description":"Denies the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":[],"deny":["set_show_menu_on_left_click"]}},"deny-set-temp-dir-path":{"identifier":"deny-set-temp-dir-path","description":"Denies the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":[],"deny":["set_temp_dir_path"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-tooltip":{"identifier":"deny-set-tooltip","description":"Denies the set_tooltip command without any pre-configured scope.","commands":{"allow":[],"deny":["set_tooltip"]}},"deny-set-visible":{"identifier":"deny-set-visible","description":"Denies the set_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible"]}}},"permission_sets":{},"global_scope_schema":null},"core:webview":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-webviews","allow-webview-position","allow-webview-size","allow-internal-toggle-devtools"]},"permissions":{"allow-clear-all-browsing-data":{"identifier":"allow-clear-all-browsing-data","description":"Enables the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":["clear_all_browsing_data"],"deny":[]}},"allow-create-webview":{"identifier":"allow-create-webview","description":"Enables the create_webview command without any pre-configured scope.","commands":{"allow":["create_webview"],"deny":[]}},"allow-create-webview-window":{"identifier":"allow-create-webview-window","description":"Enables the create_webview_window command without any pre-configured scope.","commands":{"allow":["create_webview_window"],"deny":[]}},"allow-get-all-webviews":{"identifier":"allow-get-all-webviews","description":"Enables the get_all_webviews command without any pre-configured scope.","commands":{"allow":["get_all_webviews"],"deny":[]}},"allow-internal-toggle-devtools":{"identifier":"allow-internal-toggle-devtools","description":"Enables the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":["internal_toggle_devtools"],"deny":[]}},"allow-print":{"identifier":"allow-print","description":"Enables the print command without any pre-configured scope.","commands":{"allow":["print"],"deny":[]}},"allow-reparent":{"identifier":"allow-reparent","description":"Enables the reparent command without any pre-configured scope.","commands":{"allow":["reparent"],"deny":[]}},"allow-set-webview-auto-resize":{"identifier":"allow-set-webview-auto-resize","description":"Enables the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":["set_webview_auto_resize"],"deny":[]}},"allow-set-webview-background-color":{"identifier":"allow-set-webview-background-color","description":"Enables the set_webview_background_color command without any pre-configured scope.","commands":{"allow":["set_webview_background_color"],"deny":[]}},"allow-set-webview-focus":{"identifier":"allow-set-webview-focus","description":"Enables the set_webview_focus command without any pre-configured scope.","commands":{"allow":["set_webview_focus"],"deny":[]}},"allow-set-webview-position":{"identifier":"allow-set-webview-position","description":"Enables the set_webview_position command without any pre-configured scope.","commands":{"allow":["set_webview_position"],"deny":[]}},"allow-set-webview-size":{"identifier":"allow-set-webview-size","description":"Enables the set_webview_size command without any pre-configured scope.","commands":{"allow":["set_webview_size"],"deny":[]}},"allow-set-webview-zoom":{"identifier":"allow-set-webview-zoom","description":"Enables the set_webview_zoom command without any pre-configured scope.","commands":{"allow":["set_webview_zoom"],"deny":[]}},"allow-webview-close":{"identifier":"allow-webview-close","description":"Enables the webview_close command without any pre-configured scope.","commands":{"allow":["webview_close"],"deny":[]}},"allow-webview-hide":{"identifier":"allow-webview-hide","description":"Enables the webview_hide command without any pre-configured scope.","commands":{"allow":["webview_hide"],"deny":[]}},"allow-webview-position":{"identifier":"allow-webview-position","description":"Enables the webview_position command without any pre-configured scope.","commands":{"allow":["webview_position"],"deny":[]}},"allow-webview-show":{"identifier":"allow-webview-show","description":"Enables the webview_show command without any pre-configured scope.","commands":{"allow":["webview_show"],"deny":[]}},"allow-webview-size":{"identifier":"allow-webview-size","description":"Enables the webview_size command without any pre-configured scope.","commands":{"allow":["webview_size"],"deny":[]}},"deny-clear-all-browsing-data":{"identifier":"deny-clear-all-browsing-data","description":"Denies the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":[],"deny":["clear_all_browsing_data"]}},"deny-create-webview":{"identifier":"deny-create-webview","description":"Denies the create_webview command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview"]}},"deny-create-webview-window":{"identifier":"deny-create-webview-window","description":"Denies the create_webview_window command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview_window"]}},"deny-get-all-webviews":{"identifier":"deny-get-all-webviews","description":"Denies the get_all_webviews command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_webviews"]}},"deny-internal-toggle-devtools":{"identifier":"deny-internal-toggle-devtools","description":"Denies the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_devtools"]}},"deny-print":{"identifier":"deny-print","description":"Denies the print command without any pre-configured scope.","commands":{"allow":[],"deny":["print"]}},"deny-reparent":{"identifier":"deny-reparent","description":"Denies the reparent command without any pre-configured scope.","commands":{"allow":[],"deny":["reparent"]}},"deny-set-webview-auto-resize":{"identifier":"deny-set-webview-auto-resize","description":"Denies the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_auto_resize"]}},"deny-set-webview-background-color":{"identifier":"deny-set-webview-background-color","description":"Denies the set_webview_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_background_color"]}},"deny-set-webview-focus":{"identifier":"deny-set-webview-focus","description":"Denies the set_webview_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_focus"]}},"deny-set-webview-position":{"identifier":"deny-set-webview-position","description":"Denies the set_webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_position"]}},"deny-set-webview-size":{"identifier":"deny-set-webview-size","description":"Denies the set_webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_size"]}},"deny-set-webview-zoom":{"identifier":"deny-set-webview-zoom","description":"Denies the set_webview_zoom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_zoom"]}},"deny-webview-close":{"identifier":"deny-webview-close","description":"Denies the webview_close command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_close"]}},"deny-webview-hide":{"identifier":"deny-webview-hide","description":"Denies the webview_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_hide"]}},"deny-webview-position":{"identifier":"deny-webview-position","description":"Denies the webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_position"]}},"deny-webview-show":{"identifier":"deny-webview-show","description":"Denies the webview_show command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_show"]}},"deny-webview-size":{"identifier":"deny-webview-size","description":"Denies the webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_size"]}}},"permission_sets":{},"global_scope_schema":null},"core:window":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-windows","allow-scale-factor","allow-inner-position","allow-outer-position","allow-inner-size","allow-outer-size","allow-is-fullscreen","allow-is-minimized","allow-is-maximized","allow-is-focused","allow-is-decorated","allow-is-resizable","allow-is-maximizable","allow-is-minimizable","allow-is-closable","allow-is-visible","allow-is-enabled","allow-title","allow-current-monitor","allow-primary-monitor","allow-monitor-from-point","allow-available-monitors","allow-cursor-position","allow-theme","allow-is-always-on-top","allow-activity-name","allow-scene-identifier","allow-internal-toggle-maximize"]},"permissions":{"allow-activity-name":{"identifier":"allow-activity-name","description":"Enables the activity_name command without any pre-configured scope.","commands":{"allow":["activity_name"],"deny":[]}},"allow-available-monitors":{"identifier":"allow-available-monitors","description":"Enables the available_monitors command without any pre-configured scope.","commands":{"allow":["available_monitors"],"deny":[]}},"allow-center":{"identifier":"allow-center","description":"Enables the center command without any pre-configured scope.","commands":{"allow":["center"],"deny":[]}},"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"allow-create":{"identifier":"allow-create","description":"Enables the create command without any pre-configured scope.","commands":{"allow":["create"],"deny":[]}},"allow-current-monitor":{"identifier":"allow-current-monitor","description":"Enables the current_monitor command without any pre-configured scope.","commands":{"allow":["current_monitor"],"deny":[]}},"allow-cursor-position":{"identifier":"allow-cursor-position","description":"Enables the cursor_position command without any pre-configured scope.","commands":{"allow":["cursor_position"],"deny":[]}},"allow-destroy":{"identifier":"allow-destroy","description":"Enables the destroy command without any pre-configured scope.","commands":{"allow":["destroy"],"deny":[]}},"allow-get-all-windows":{"identifier":"allow-get-all-windows","description":"Enables the get_all_windows command without any pre-configured scope.","commands":{"allow":["get_all_windows"],"deny":[]}},"allow-hide":{"identifier":"allow-hide","description":"Enables the hide command without any pre-configured scope.","commands":{"allow":["hide"],"deny":[]}},"allow-inner-position":{"identifier":"allow-inner-position","description":"Enables the inner_position command without any pre-configured scope.","commands":{"allow":["inner_position"],"deny":[]}},"allow-inner-size":{"identifier":"allow-inner-size","description":"Enables the inner_size command without any pre-configured scope.","commands":{"allow":["inner_size"],"deny":[]}},"allow-internal-toggle-maximize":{"identifier":"allow-internal-toggle-maximize","description":"Enables the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":["internal_toggle_maximize"],"deny":[]}},"allow-is-always-on-top":{"identifier":"allow-is-always-on-top","description":"Enables the is_always_on_top command without any pre-configured scope.","commands":{"allow":["is_always_on_top"],"deny":[]}},"allow-is-closable":{"identifier":"allow-is-closable","description":"Enables the is_closable command without any pre-configured scope.","commands":{"allow":["is_closable"],"deny":[]}},"allow-is-decorated":{"identifier":"allow-is-decorated","description":"Enables the is_decorated command without any pre-configured scope.","commands":{"allow":["is_decorated"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-is-focused":{"identifier":"allow-is-focused","description":"Enables the is_focused command without any pre-configured scope.","commands":{"allow":["is_focused"],"deny":[]}},"allow-is-fullscreen":{"identifier":"allow-is-fullscreen","description":"Enables the is_fullscreen command without any pre-configured scope.","commands":{"allow":["is_fullscreen"],"deny":[]}},"allow-is-maximizable":{"identifier":"allow-is-maximizable","description":"Enables the is_maximizable command without any pre-configured scope.","commands":{"allow":["is_maximizable"],"deny":[]}},"allow-is-maximized":{"identifier":"allow-is-maximized","description":"Enables the is_maximized command without any pre-configured scope.","commands":{"allow":["is_maximized"],"deny":[]}},"allow-is-minimizable":{"identifier":"allow-is-minimizable","description":"Enables the is_minimizable command without any pre-configured scope.","commands":{"allow":["is_minimizable"],"deny":[]}},"allow-is-minimized":{"identifier":"allow-is-minimized","description":"Enables the is_minimized command without any pre-configured scope.","commands":{"allow":["is_minimized"],"deny":[]}},"allow-is-resizable":{"identifier":"allow-is-resizable","description":"Enables the is_resizable command without any pre-configured scope.","commands":{"allow":["is_resizable"],"deny":[]}},"allow-is-visible":{"identifier":"allow-is-visible","description":"Enables the is_visible command without any pre-configured scope.","commands":{"allow":["is_visible"],"deny":[]}},"allow-maximize":{"identifier":"allow-maximize","description":"Enables the maximize command without any pre-configured scope.","commands":{"allow":["maximize"],"deny":[]}},"allow-minimize":{"identifier":"allow-minimize","description":"Enables the minimize command without any pre-configured scope.","commands":{"allow":["minimize"],"deny":[]}},"allow-monitor-from-point":{"identifier":"allow-monitor-from-point","description":"Enables the monitor_from_point command without any pre-configured scope.","commands":{"allow":["monitor_from_point"],"deny":[]}},"allow-outer-position":{"identifier":"allow-outer-position","description":"Enables the outer_position command without any pre-configured scope.","commands":{"allow":["outer_position"],"deny":[]}},"allow-outer-size":{"identifier":"allow-outer-size","description":"Enables the outer_size command without any pre-configured scope.","commands":{"allow":["outer_size"],"deny":[]}},"allow-primary-monitor":{"identifier":"allow-primary-monitor","description":"Enables the primary_monitor command without any pre-configured scope.","commands":{"allow":["primary_monitor"],"deny":[]}},"allow-request-user-attention":{"identifier":"allow-request-user-attention","description":"Enables the request_user_attention command without any pre-configured scope.","commands":{"allow":["request_user_attention"],"deny":[]}},"allow-scale-factor":{"identifier":"allow-scale-factor","description":"Enables the scale_factor command without any pre-configured scope.","commands":{"allow":["scale_factor"],"deny":[]}},"allow-scene-identifier":{"identifier":"allow-scene-identifier","description":"Enables the scene_identifier command without any pre-configured scope.","commands":{"allow":["scene_identifier"],"deny":[]}},"allow-set-always-on-bottom":{"identifier":"allow-set-always-on-bottom","description":"Enables the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":["set_always_on_bottom"],"deny":[]}},"allow-set-always-on-top":{"identifier":"allow-set-always-on-top","description":"Enables the set_always_on_top command without any pre-configured scope.","commands":{"allow":["set_always_on_top"],"deny":[]}},"allow-set-background-color":{"identifier":"allow-set-background-color","description":"Enables the set_background_color command without any pre-configured scope.","commands":{"allow":["set_background_color"],"deny":[]}},"allow-set-badge-count":{"identifier":"allow-set-badge-count","description":"Enables the set_badge_count command without any pre-configured scope.","commands":{"allow":["set_badge_count"],"deny":[]}},"allow-set-badge-label":{"identifier":"allow-set-badge-label","description":"Enables the set_badge_label command without any pre-configured scope.","commands":{"allow":["set_badge_label"],"deny":[]}},"allow-set-closable":{"identifier":"allow-set-closable","description":"Enables the set_closable command without any pre-configured scope.","commands":{"allow":["set_closable"],"deny":[]}},"allow-set-content-protected":{"identifier":"allow-set-content-protected","description":"Enables the set_content_protected command without any pre-configured scope.","commands":{"allow":["set_content_protected"],"deny":[]}},"allow-set-cursor-grab":{"identifier":"allow-set-cursor-grab","description":"Enables the set_cursor_grab command without any pre-configured scope.","commands":{"allow":["set_cursor_grab"],"deny":[]}},"allow-set-cursor-icon":{"identifier":"allow-set-cursor-icon","description":"Enables the set_cursor_icon command without any pre-configured scope.","commands":{"allow":["set_cursor_icon"],"deny":[]}},"allow-set-cursor-position":{"identifier":"allow-set-cursor-position","description":"Enables the set_cursor_position command without any pre-configured scope.","commands":{"allow":["set_cursor_position"],"deny":[]}},"allow-set-cursor-visible":{"identifier":"allow-set-cursor-visible","description":"Enables the set_cursor_visible command without any pre-configured scope.","commands":{"allow":["set_cursor_visible"],"deny":[]}},"allow-set-decorations":{"identifier":"allow-set-decorations","description":"Enables the set_decorations command without any pre-configured scope.","commands":{"allow":["set_decorations"],"deny":[]}},"allow-set-effects":{"identifier":"allow-set-effects","description":"Enables the set_effects command without any pre-configured scope.","commands":{"allow":["set_effects"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-focus":{"identifier":"allow-set-focus","description":"Enables the set_focus command without any pre-configured scope.","commands":{"allow":["set_focus"],"deny":[]}},"allow-set-focusable":{"identifier":"allow-set-focusable","description":"Enables the set_focusable command without any pre-configured scope.","commands":{"allow":["set_focusable"],"deny":[]}},"allow-set-fullscreen":{"identifier":"allow-set-fullscreen","description":"Enables the set_fullscreen command without any pre-configured scope.","commands":{"allow":["set_fullscreen"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-ignore-cursor-events":{"identifier":"allow-set-ignore-cursor-events","description":"Enables the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":["set_ignore_cursor_events"],"deny":[]}},"allow-set-max-size":{"identifier":"allow-set-max-size","description":"Enables the set_max_size command without any pre-configured scope.","commands":{"allow":["set_max_size"],"deny":[]}},"allow-set-maximizable":{"identifier":"allow-set-maximizable","description":"Enables the set_maximizable command without any pre-configured scope.","commands":{"allow":["set_maximizable"],"deny":[]}},"allow-set-min-size":{"identifier":"allow-set-min-size","description":"Enables the set_min_size command without any pre-configured scope.","commands":{"allow":["set_min_size"],"deny":[]}},"allow-set-minimizable":{"identifier":"allow-set-minimizable","description":"Enables the set_minimizable command without any pre-configured scope.","commands":{"allow":["set_minimizable"],"deny":[]}},"allow-set-overlay-icon":{"identifier":"allow-set-overlay-icon","description":"Enables the set_overlay_icon command without any pre-configured scope.","commands":{"allow":["set_overlay_icon"],"deny":[]}},"allow-set-position":{"identifier":"allow-set-position","description":"Enables the set_position command without any pre-configured scope.","commands":{"allow":["set_position"],"deny":[]}},"allow-set-progress-bar":{"identifier":"allow-set-progress-bar","description":"Enables the set_progress_bar command without any pre-configured scope.","commands":{"allow":["set_progress_bar"],"deny":[]}},"allow-set-resizable":{"identifier":"allow-set-resizable","description":"Enables the set_resizable command without any pre-configured scope.","commands":{"allow":["set_resizable"],"deny":[]}},"allow-set-shadow":{"identifier":"allow-set-shadow","description":"Enables the set_shadow command without any pre-configured scope.","commands":{"allow":["set_shadow"],"deny":[]}},"allow-set-simple-fullscreen":{"identifier":"allow-set-simple-fullscreen","description":"Enables the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":["set_simple_fullscreen"],"deny":[]}},"allow-set-size":{"identifier":"allow-set-size","description":"Enables the set_size command without any pre-configured scope.","commands":{"allow":["set_size"],"deny":[]}},"allow-set-size-constraints":{"identifier":"allow-set-size-constraints","description":"Enables the set_size_constraints command without any pre-configured scope.","commands":{"allow":["set_size_constraints"],"deny":[]}},"allow-set-skip-taskbar":{"identifier":"allow-set-skip-taskbar","description":"Enables the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":["set_skip_taskbar"],"deny":[]}},"allow-set-theme":{"identifier":"allow-set-theme","description":"Enables the set_theme command without any pre-configured scope.","commands":{"allow":["set_theme"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-title-bar-style":{"identifier":"allow-set-title-bar-style","description":"Enables the set_title_bar_style command without any pre-configured scope.","commands":{"allow":["set_title_bar_style"],"deny":[]}},"allow-set-visible-on-all-workspaces":{"identifier":"allow-set-visible-on-all-workspaces","description":"Enables the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":["set_visible_on_all_workspaces"],"deny":[]}},"allow-show":{"identifier":"allow-show","description":"Enables the show command without any pre-configured scope.","commands":{"allow":["show"],"deny":[]}},"allow-start-dragging":{"identifier":"allow-start-dragging","description":"Enables the start_dragging command without any pre-configured scope.","commands":{"allow":["start_dragging"],"deny":[]}},"allow-start-resize-dragging":{"identifier":"allow-start-resize-dragging","description":"Enables the start_resize_dragging command without any pre-configured scope.","commands":{"allow":["start_resize_dragging"],"deny":[]}},"allow-theme":{"identifier":"allow-theme","description":"Enables the theme command without any pre-configured scope.","commands":{"allow":["theme"],"deny":[]}},"allow-title":{"identifier":"allow-title","description":"Enables the title command without any pre-configured scope.","commands":{"allow":["title"],"deny":[]}},"allow-toggle-maximize":{"identifier":"allow-toggle-maximize","description":"Enables the toggle_maximize command without any pre-configured scope.","commands":{"allow":["toggle_maximize"],"deny":[]}},"allow-unmaximize":{"identifier":"allow-unmaximize","description":"Enables the unmaximize command without any pre-configured scope.","commands":{"allow":["unmaximize"],"deny":[]}},"allow-unminimize":{"identifier":"allow-unminimize","description":"Enables the unminimize command without any pre-configured scope.","commands":{"allow":["unminimize"],"deny":[]}},"deny-activity-name":{"identifier":"deny-activity-name","description":"Denies the activity_name command without any pre-configured scope.","commands":{"allow":[],"deny":["activity_name"]}},"deny-available-monitors":{"identifier":"deny-available-monitors","description":"Denies the available_monitors command without any pre-configured scope.","commands":{"allow":[],"deny":["available_monitors"]}},"deny-center":{"identifier":"deny-center","description":"Denies the center command without any pre-configured scope.","commands":{"allow":[],"deny":["center"]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}},"deny-create":{"identifier":"deny-create","description":"Denies the create command without any pre-configured scope.","commands":{"allow":[],"deny":["create"]}},"deny-current-monitor":{"identifier":"deny-current-monitor","description":"Denies the current_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["current_monitor"]}},"deny-cursor-position":{"identifier":"deny-cursor-position","description":"Denies the cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["cursor_position"]}},"deny-destroy":{"identifier":"deny-destroy","description":"Denies the destroy command without any pre-configured scope.","commands":{"allow":[],"deny":["destroy"]}},"deny-get-all-windows":{"identifier":"deny-get-all-windows","description":"Denies the get_all_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_windows"]}},"deny-hide":{"identifier":"deny-hide","description":"Denies the hide command without any pre-configured scope.","commands":{"allow":[],"deny":["hide"]}},"deny-inner-position":{"identifier":"deny-inner-position","description":"Denies the inner_position command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_position"]}},"deny-inner-size":{"identifier":"deny-inner-size","description":"Denies the inner_size command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_size"]}},"deny-internal-toggle-maximize":{"identifier":"deny-internal-toggle-maximize","description":"Denies the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_maximize"]}},"deny-is-always-on-top":{"identifier":"deny-is-always-on-top","description":"Denies the is_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["is_always_on_top"]}},"deny-is-closable":{"identifier":"deny-is-closable","description":"Denies the is_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_closable"]}},"deny-is-decorated":{"identifier":"deny-is-decorated","description":"Denies the is_decorated command without any pre-configured scope.","commands":{"allow":[],"deny":["is_decorated"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-is-focused":{"identifier":"deny-is-focused","description":"Denies the is_focused command without any pre-configured scope.","commands":{"allow":[],"deny":["is_focused"]}},"deny-is-fullscreen":{"identifier":"deny-is-fullscreen","description":"Denies the is_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["is_fullscreen"]}},"deny-is-maximizable":{"identifier":"deny-is-maximizable","description":"Denies the is_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximizable"]}},"deny-is-maximized":{"identifier":"deny-is-maximized","description":"Denies the is_maximized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximized"]}},"deny-is-minimizable":{"identifier":"deny-is-minimizable","description":"Denies the is_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimizable"]}},"deny-is-minimized":{"identifier":"deny-is-minimized","description":"Denies the is_minimized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimized"]}},"deny-is-resizable":{"identifier":"deny-is-resizable","description":"Denies the is_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_resizable"]}},"deny-is-visible":{"identifier":"deny-is-visible","description":"Denies the is_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["is_visible"]}},"deny-maximize":{"identifier":"deny-maximize","description":"Denies the maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["maximize"]}},"deny-minimize":{"identifier":"deny-minimize","description":"Denies the minimize command without any pre-configured scope.","commands":{"allow":[],"deny":["minimize"]}},"deny-monitor-from-point":{"identifier":"deny-monitor-from-point","description":"Denies the monitor_from_point command without any pre-configured scope.","commands":{"allow":[],"deny":["monitor_from_point"]}},"deny-outer-position":{"identifier":"deny-outer-position","description":"Denies the outer_position command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_position"]}},"deny-outer-size":{"identifier":"deny-outer-size","description":"Denies the outer_size command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_size"]}},"deny-primary-monitor":{"identifier":"deny-primary-monitor","description":"Denies the primary_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["primary_monitor"]}},"deny-request-user-attention":{"identifier":"deny-request-user-attention","description":"Denies the request_user_attention command without any pre-configured scope.","commands":{"allow":[],"deny":["request_user_attention"]}},"deny-scale-factor":{"identifier":"deny-scale-factor","description":"Denies the scale_factor command without any pre-configured scope.","commands":{"allow":[],"deny":["scale_factor"]}},"deny-scene-identifier":{"identifier":"deny-scene-identifier","description":"Denies the scene_identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["scene_identifier"]}},"deny-set-always-on-bottom":{"identifier":"deny-set-always-on-bottom","description":"Denies the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_bottom"]}},"deny-set-always-on-top":{"identifier":"deny-set-always-on-top","description":"Denies the set_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_top"]}},"deny-set-background-color":{"identifier":"deny-set-background-color","description":"Denies the set_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_background_color"]}},"deny-set-badge-count":{"identifier":"deny-set-badge-count","description":"Denies the set_badge_count command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_count"]}},"deny-set-badge-label":{"identifier":"deny-set-badge-label","description":"Denies the set_badge_label command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_label"]}},"deny-set-closable":{"identifier":"deny-set-closable","description":"Denies the set_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_closable"]}},"deny-set-content-protected":{"identifier":"deny-set-content-protected","description":"Denies the set_content_protected command without any pre-configured scope.","commands":{"allow":[],"deny":["set_content_protected"]}},"deny-set-cursor-grab":{"identifier":"deny-set-cursor-grab","description":"Denies the set_cursor_grab command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_grab"]}},"deny-set-cursor-icon":{"identifier":"deny-set-cursor-icon","description":"Denies the set_cursor_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_icon"]}},"deny-set-cursor-position":{"identifier":"deny-set-cursor-position","description":"Denies the set_cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_position"]}},"deny-set-cursor-visible":{"identifier":"deny-set-cursor-visible","description":"Denies the set_cursor_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_visible"]}},"deny-set-decorations":{"identifier":"deny-set-decorations","description":"Denies the set_decorations command without any pre-configured scope.","commands":{"allow":[],"deny":["set_decorations"]}},"deny-set-effects":{"identifier":"deny-set-effects","description":"Denies the set_effects command without any pre-configured scope.","commands":{"allow":[],"deny":["set_effects"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-focus":{"identifier":"deny-set-focus","description":"Denies the set_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focus"]}},"deny-set-focusable":{"identifier":"deny-set-focusable","description":"Denies the set_focusable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focusable"]}},"deny-set-fullscreen":{"identifier":"deny-set-fullscreen","description":"Denies the set_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_fullscreen"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-ignore-cursor-events":{"identifier":"deny-set-ignore-cursor-events","description":"Denies the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":[],"deny":["set_ignore_cursor_events"]}},"deny-set-max-size":{"identifier":"deny-set-max-size","description":"Denies the set_max_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_max_size"]}},"deny-set-maximizable":{"identifier":"deny-set-maximizable","description":"Denies the set_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_maximizable"]}},"deny-set-min-size":{"identifier":"deny-set-min-size","description":"Denies the set_min_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_min_size"]}},"deny-set-minimizable":{"identifier":"deny-set-minimizable","description":"Denies the set_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_minimizable"]}},"deny-set-overlay-icon":{"identifier":"deny-set-overlay-icon","description":"Denies the set_overlay_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_overlay_icon"]}},"deny-set-position":{"identifier":"deny-set-position","description":"Denies the set_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_position"]}},"deny-set-progress-bar":{"identifier":"deny-set-progress-bar","description":"Denies the set_progress_bar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_progress_bar"]}},"deny-set-resizable":{"identifier":"deny-set-resizable","description":"Denies the set_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_resizable"]}},"deny-set-shadow":{"identifier":"deny-set-shadow","description":"Denies the set_shadow command without any pre-configured scope.","commands":{"allow":[],"deny":["set_shadow"]}},"deny-set-simple-fullscreen":{"identifier":"deny-set-simple-fullscreen","description":"Denies the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_simple_fullscreen"]}},"deny-set-size":{"identifier":"deny-set-size","description":"Denies the set_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size"]}},"deny-set-size-constraints":{"identifier":"deny-set-size-constraints","description":"Denies the set_size_constraints command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size_constraints"]}},"deny-set-skip-taskbar":{"identifier":"deny-set-skip-taskbar","description":"Denies the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_skip_taskbar"]}},"deny-set-theme":{"identifier":"deny-set-theme","description":"Denies the set_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_theme"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-title-bar-style":{"identifier":"deny-set-title-bar-style","description":"Denies the set_title_bar_style command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title_bar_style"]}},"deny-set-visible-on-all-workspaces":{"identifier":"deny-set-visible-on-all-workspaces","description":"Denies the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible_on_all_workspaces"]}},"deny-show":{"identifier":"deny-show","description":"Denies the show command without any pre-configured scope.","commands":{"allow":[],"deny":["show"]}},"deny-start-dragging":{"identifier":"deny-start-dragging","description":"Denies the start_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_dragging"]}},"deny-start-resize-dragging":{"identifier":"deny-start-resize-dragging","description":"Denies the start_resize_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_resize_dragging"]}},"deny-theme":{"identifier":"deny-theme","description":"Denies the theme command without any pre-configured scope.","commands":{"allow":[],"deny":["theme"]}},"deny-title":{"identifier":"deny-title","description":"Denies the title command without any pre-configured scope.","commands":{"allow":[],"deny":["title"]}},"deny-toggle-maximize":{"identifier":"deny-toggle-maximize","description":"Denies the toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["toggle_maximize"]}},"deny-unmaximize":{"identifier":"deny-unmaximize","description":"Denies the unmaximize command without any pre-configured scope.","commands":{"allow":[],"deny":["unmaximize"]}},"deny-unminimize":{"identifier":"deny-unminimize","description":"Denies the unminimize command without any pre-configured scope.","commands":{"allow":[],"deny":["unminimize"]}}},"permission_sets":{},"global_scope_schema":null}}
\ No newline at end of file
diff --git a/gen/schemas/capabilities.json b/gen/schemas/capabilities.json
new file mode 100644
index 0000000..8b371fb
--- /dev/null
+++ b/gen/schemas/capabilities.json
@@ -0,0 +1 @@
+{"default":{"identifier":"default","description":"Default wallet window permissions","local":true,"windows":["main"],"permissions":["core:default"]}}
\ No newline at end of file
diff --git a/gen/schemas/desktop-schema.json b/gen/schemas/desktop-schema.json
new file mode 100644
index 0000000..3286645
--- /dev/null
+++ b/gen/schemas/desktop-schema.json
@@ -0,0 +1,2292 @@
+{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "CapabilityFile",
+ "description": "Capability formats accepted in a capability file.",
+ "anyOf": [
+ {
+ "description": "A single capability.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Capability"
+ }
+ ]
+ },
+ {
+ "description": "A list of capabilities.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Capability"
+ }
+ },
+ {
+ "description": "A list of capabilities.",
+ "type": "object",
+ "required": [
+ "capabilities"
+ ],
+ "properties": {
+ "capabilities": {
+ "description": "The list of capabilities.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Capability"
+ }
+ }
+ }
+ }
+ ],
+ "definitions": {
+ "Capability": {
+ "description": "A grouping and boundary mechanism developers can use to isolate access to the IPC layer.\n\nIt controls application windows' and webviews' fine grained access to the Tauri core, application, or plugin commands. If a webview or its window is not matching any capability then it has no access to the IPC layer at all.\n\nThis can be done to create groups of windows, based on their required system access, which can reduce impact of frontend vulnerabilities in less privileged windows. Windows can be added to a capability by exact name (e.g. `main-window`) or glob patterns like `*` or `admin-*`. A Window can have none, one, or multiple associated capabilities.\n\n## Example\n\n```json { \"identifier\": \"main-user-files-write\", \"description\": \"This capability allows the `main` window on macOS and Windows access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.\", \"windows\": [ \"main\" ], \"permissions\": [ \"core:default\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] }, ], \"platforms\": [\"macOS\",\"windows\"] } ```",
+ "type": "object",
+ "required": [
+ "identifier",
+ "permissions"
+ ],
+ "properties": {
+ "identifier": {
+ "description": "Identifier of the capability.\n\n## Example\n\n`main-user-files-write`",
+ "type": "string"
+ },
+ "description": {
+ "description": "Description of what the capability is intended to allow on associated windows.\n\nIt should contain a description of what the grouped permissions should allow.\n\n## Example\n\nThis capability allows the `main` window access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.",
+ "default": "",
+ "type": "string"
+ },
+ "remote": {
+ "description": "Configure remote URLs that can use the capability permissions.\n\nThis setting is optional and defaults to not being set, as our default use case is that the content is served from our local application.\n\n:::caution Make sure you understand the security implications of providing remote sources with local system access. :::\n\n## Example\n\n```json { \"urls\": [\"https://*.mydomain.dev\"] } ```",
+ "anyOf": [
+ {
+ "$ref": "#/definitions/CapabilityRemote"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "local": {
+ "description": "Whether this capability is enabled for local app URLs or not. Defaults to `true`.",
+ "default": true,
+ "type": "boolean"
+ },
+ "windows": {
+ "description": "List of windows that are affected by this capability. Can be a glob pattern.\n\nIf a window label matches any of the patterns in this list, the capability will be enabled on all the webviews of that window, regardless of the value of [`Self::webviews`].\n\nOn multiwebview windows, prefer specifying [`Self::webviews`] and omitting [`Self::windows`] for a fine grained access control.\n\n## Example\n\n`[\"main\"]`",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "webviews": {
+ "description": "List of webviews that are affected by this capability. Can be a glob pattern.\n\nThe capability will be enabled on all the webviews whose label matches any of the patterns in this list, regardless of whether the webview's window label matches a pattern in [`Self::windows`].\n\n## Example\n\n`[\"sub-webview-one\", \"sub-webview-two\"]`",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "permissions": {
+ "description": "List of permissions attached to this capability.\n\nMust include the plugin name as prefix in the form of `${plugin-name}:${permission-name}`. For commands directly implemented in the application itself only `${permission-name}` is required.\n\n## Example\n\n```json [ \"core:default\", \"shell:allow-open\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] } ] ```",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/PermissionEntry"
+ },
+ "uniqueItems": true
+ },
+ "platforms": {
+ "description": "Limit which target platforms this capability applies to.\n\nBy default all platforms are targeted.\n\n## Example\n\n`[\"macOS\",\"windows\"]`",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Target"
+ }
+ }
+ }
+ },
+ "CapabilityRemote": {
+ "description": "Configuration for remote URLs that are associated with the capability.",
+ "type": "object",
+ "required": [
+ "urls"
+ ],
+ "properties": {
+ "urls": {
+ "description": "Remote domains this capability refers to using the [URLPattern standard](https://urlpattern.spec.whatwg.org/).\n\n## Examples\n\n- \"https://*.mydomain.dev\": allows subdomains of mydomain.dev - \"https://mydomain.dev/api/*\": allows any subpath of mydomain.dev/api",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ }
+ }
+ },
+ "PermissionEntry": {
+ "description": "An entry for a permission value in a [`Capability`] can be either a raw permission [`Identifier`] or an object that references a permission and extends its scope.",
+ "anyOf": [
+ {
+ "description": "Reference a permission or permission set by identifier.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Identifier"
+ }
+ ]
+ },
+ {
+ "description": "Reference a permission or permission set by identifier and extends its scope.",
+ "type": "object",
+ "allOf": [
+ {
+ "properties": {
+ "identifier": {
+ "description": "Identifier of the permission or permission set.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Identifier"
+ }
+ ]
+ },
+ "allow": {
+ "description": "Data that defines what is allowed by the scope.",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ },
+ "deny": {
+ "description": "Data that defines what is denied by the scope. This should be prioritized by validation logic.",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ }
+ }
+ }
+ ],
+ "required": [
+ "identifier"
+ ]
+ }
+ ]
+ },
+ "Identifier": {
+ "description": "Permission identifier",
+ "oneOf": [
+ {
+ "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
+ "type": "string",
+ "const": "core:default",
+ "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`",
+ "type": "string",
+ "const": "core:app:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`"
+ },
+ {
+ "description": "Enables the app_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-app-hide",
+ "markdownDescription": "Enables the app_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the app_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-app-show",
+ "markdownDescription": "Enables the app_show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the bundle_type command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-bundle-type",
+ "markdownDescription": "Enables the bundle_type command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the default_window_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-default-window-icon",
+ "markdownDescription": "Enables the default_window_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the fetch_data_store_identifiers command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-fetch-data-store-identifiers",
+ "markdownDescription": "Enables the fetch_data_store_identifiers command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-identifier",
+ "markdownDescription": "Enables the identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-name",
+ "markdownDescription": "Enables the name command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the register_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-register-listener",
+ "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_data_store command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-remove-data-store",
+ "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-remove-listener",
+ "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_app_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-set-app-theme",
+ "markdownDescription": "Enables the set_app_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_dock_visibility command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-set-dock-visibility",
+ "markdownDescription": "Enables the set_dock_visibility command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the supports_multiple_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-supports-multiple-windows",
+ "markdownDescription": "Enables the supports_multiple_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the tauri_version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-tauri-version",
+ "markdownDescription": "Enables the tauri_version command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-version",
+ "markdownDescription": "Enables the version command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the app_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-app-hide",
+ "markdownDescription": "Denies the app_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the app_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-app-show",
+ "markdownDescription": "Denies the app_show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the bundle_type command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-bundle-type",
+ "markdownDescription": "Denies the bundle_type command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the default_window_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-default-window-icon",
+ "markdownDescription": "Denies the default_window_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the fetch_data_store_identifiers command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-fetch-data-store-identifiers",
+ "markdownDescription": "Denies the fetch_data_store_identifiers command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-identifier",
+ "markdownDescription": "Denies the identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-name",
+ "markdownDescription": "Denies the name command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the register_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-register-listener",
+ "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_data_store command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-remove-data-store",
+ "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-remove-listener",
+ "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_app_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-set-app-theme",
+ "markdownDescription": "Denies the set_app_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_dock_visibility command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-set-dock-visibility",
+ "markdownDescription": "Denies the set_dock_visibility command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the supports_multiple_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-supports-multiple-windows",
+ "markdownDescription": "Denies the supports_multiple_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the tauri_version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-tauri-version",
+ "markdownDescription": "Denies the tauri_version command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-version",
+ "markdownDescription": "Denies the version command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`",
+ "type": "string",
+ "const": "core:event:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`"
+ },
+ {
+ "description": "Enables the emit command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-emit",
+ "markdownDescription": "Enables the emit command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the emit_to command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-emit-to",
+ "markdownDescription": "Enables the emit_to command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the listen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-listen",
+ "markdownDescription": "Enables the listen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unlisten command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-unlisten",
+ "markdownDescription": "Enables the unlisten command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the emit command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-emit",
+ "markdownDescription": "Denies the emit command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the emit_to command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-emit-to",
+ "markdownDescription": "Denies the emit_to command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the listen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-listen",
+ "markdownDescription": "Denies the listen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unlisten command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-unlisten",
+ "markdownDescription": "Denies the unlisten command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`",
+ "type": "string",
+ "const": "core:image:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`"
+ },
+ {
+ "description": "Enables the from_bytes command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-from-bytes",
+ "markdownDescription": "Enables the from_bytes command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the from_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-from-path",
+ "markdownDescription": "Enables the from_path command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the rgba command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-rgba",
+ "markdownDescription": "Enables the rgba command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-size",
+ "markdownDescription": "Enables the size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the from_bytes command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-from-bytes",
+ "markdownDescription": "Denies the from_bytes command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the from_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-from-path",
+ "markdownDescription": "Denies the from_path command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the rgba command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-rgba",
+ "markdownDescription": "Denies the rgba command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-size",
+ "markdownDescription": "Denies the size command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`",
+ "type": "string",
+ "const": "core:menu:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`"
+ },
+ {
+ "description": "Enables the append command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-append",
+ "markdownDescription": "Enables the append command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_default command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-create-default",
+ "markdownDescription": "Enables the create_default command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-get",
+ "markdownDescription": "Enables the get command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the insert command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-insert",
+ "markdownDescription": "Enables the insert command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-is-checked",
+ "markdownDescription": "Enables the is_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-is-enabled",
+ "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the items command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-items",
+ "markdownDescription": "Enables the items command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the popup command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-popup",
+ "markdownDescription": "Enables the popup command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the prepend command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-prepend",
+ "markdownDescription": "Enables the prepend command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-remove",
+ "markdownDescription": "Enables the remove command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_at command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-remove-at",
+ "markdownDescription": "Enables the remove_at command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_accelerator command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-accelerator",
+ "markdownDescription": "Enables the set_accelerator command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_app_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-app-menu",
+ "markdownDescription": "Enables the set_as_app_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-help-menu-for-nsapp",
+ "markdownDescription": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_window_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-window-menu",
+ "markdownDescription": "Enables the set_as_window_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-windows-menu-for-nsapp",
+ "markdownDescription": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-checked",
+ "markdownDescription": "Enables the set_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-enabled",
+ "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-text",
+ "markdownDescription": "Enables the set_text command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-text",
+ "markdownDescription": "Enables the text command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the append command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-append",
+ "markdownDescription": "Denies the append command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_default command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-create-default",
+ "markdownDescription": "Denies the create_default command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-get",
+ "markdownDescription": "Denies the get command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the insert command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-insert",
+ "markdownDescription": "Denies the insert command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-is-checked",
+ "markdownDescription": "Denies the is_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-is-enabled",
+ "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the items command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-items",
+ "markdownDescription": "Denies the items command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the popup command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-popup",
+ "markdownDescription": "Denies the popup command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the prepend command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-prepend",
+ "markdownDescription": "Denies the prepend command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-remove",
+ "markdownDescription": "Denies the remove command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_at command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-remove-at",
+ "markdownDescription": "Denies the remove_at command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_accelerator command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-accelerator",
+ "markdownDescription": "Denies the set_accelerator command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_app_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-app-menu",
+ "markdownDescription": "Denies the set_as_app_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-help-menu-for-nsapp",
+ "markdownDescription": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_window_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-window-menu",
+ "markdownDescription": "Denies the set_as_window_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-windows-menu-for-nsapp",
+ "markdownDescription": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-checked",
+ "markdownDescription": "Denies the set_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-enabled",
+ "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-text",
+ "markdownDescription": "Denies the set_text command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-text",
+ "markdownDescription": "Denies the text command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`",
+ "type": "string",
+ "const": "core:path:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`"
+ },
+ {
+ "description": "Enables the basename command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-basename",
+ "markdownDescription": "Enables the basename command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the dirname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-dirname",
+ "markdownDescription": "Enables the dirname command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the extname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-extname",
+ "markdownDescription": "Enables the extname command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_absolute command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-is-absolute",
+ "markdownDescription": "Enables the is_absolute command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the join command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-join",
+ "markdownDescription": "Enables the join command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the normalize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-normalize",
+ "markdownDescription": "Enables the normalize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the resolve command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-resolve",
+ "markdownDescription": "Enables the resolve command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the resolve_directory command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-resolve-directory",
+ "markdownDescription": "Enables the resolve_directory command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the basename command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-basename",
+ "markdownDescription": "Denies the basename command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the dirname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-dirname",
+ "markdownDescription": "Denies the dirname command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the extname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-extname",
+ "markdownDescription": "Denies the extname command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_absolute command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-is-absolute",
+ "markdownDescription": "Denies the is_absolute command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the join command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-join",
+ "markdownDescription": "Denies the join command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the normalize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-normalize",
+ "markdownDescription": "Denies the normalize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the resolve command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-resolve",
+ "markdownDescription": "Denies the resolve command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the resolve_directory command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-resolve-directory",
+ "markdownDescription": "Denies the resolve_directory command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`",
+ "type": "string",
+ "const": "core:resources:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`"
+ },
+ {
+ "description": "Enables the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:resources:allow-close",
+ "markdownDescription": "Enables the close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:resources:deny-close",
+ "markdownDescription": "Denies the close command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`",
+ "type": "string",
+ "const": "core:tray:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`"
+ },
+ {
+ "description": "Enables the get_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-get-by-id",
+ "markdownDescription": "Enables the get_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-remove-by-id",
+ "markdownDescription": "Enables the remove_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon-as-template",
+ "markdownDescription": "Enables the set_icon_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon_with_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon-with-as-template",
+ "markdownDescription": "Enables the set_icon_with_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-menu",
+ "markdownDescription": "Enables the set_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_show_menu_on_left_click command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-show-menu-on-left-click",
+ "markdownDescription": "Enables the set_show_menu_on_left_click command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_temp_dir_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-temp-dir-path",
+ "markdownDescription": "Enables the set_temp_dir_path command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-title",
+ "markdownDescription": "Enables the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_tooltip command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-tooltip",
+ "markdownDescription": "Enables the set_tooltip command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-visible",
+ "markdownDescription": "Enables the set_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-get-by-id",
+ "markdownDescription": "Denies the get_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-remove-by-id",
+ "markdownDescription": "Denies the remove_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon-as-template",
+ "markdownDescription": "Denies the set_icon_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon_with_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon-with-as-template",
+ "markdownDescription": "Denies the set_icon_with_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-menu",
+ "markdownDescription": "Denies the set_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_show_menu_on_left_click command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-show-menu-on-left-click",
+ "markdownDescription": "Denies the set_show_menu_on_left_click command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_temp_dir_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-temp-dir-path",
+ "markdownDescription": "Denies the set_temp_dir_path command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-title",
+ "markdownDescription": "Denies the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_tooltip command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-tooltip",
+ "markdownDescription": "Denies the set_tooltip command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-visible",
+ "markdownDescription": "Denies the set_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`",
+ "type": "string",
+ "const": "core:webview:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`"
+ },
+ {
+ "description": "Enables the clear_all_browsing_data command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-clear-all-browsing-data",
+ "markdownDescription": "Enables the clear_all_browsing_data command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_webview command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-create-webview",
+ "markdownDescription": "Enables the create_webview command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_webview_window command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-create-webview-window",
+ "markdownDescription": "Enables the create_webview_window command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get_all_webviews command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-get-all-webviews",
+ "markdownDescription": "Enables the get_all_webviews command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the internal_toggle_devtools command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-internal-toggle-devtools",
+ "markdownDescription": "Enables the internal_toggle_devtools command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the print command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-print",
+ "markdownDescription": "Enables the print command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the reparent command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-reparent",
+ "markdownDescription": "Enables the reparent command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_auto_resize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-auto-resize",
+ "markdownDescription": "Enables the set_webview_auto_resize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-background-color",
+ "markdownDescription": "Enables the set_webview_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-focus",
+ "markdownDescription": "Enables the set_webview_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-position",
+ "markdownDescription": "Enables the set_webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-size",
+ "markdownDescription": "Enables the set_webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_zoom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-zoom",
+ "markdownDescription": "Enables the set_webview_zoom command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-close",
+ "markdownDescription": "Enables the webview_close command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-hide",
+ "markdownDescription": "Enables the webview_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-position",
+ "markdownDescription": "Enables the webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-show",
+ "markdownDescription": "Enables the webview_show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-size",
+ "markdownDescription": "Enables the webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the clear_all_browsing_data command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-clear-all-browsing-data",
+ "markdownDescription": "Denies the clear_all_browsing_data command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_webview command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-create-webview",
+ "markdownDescription": "Denies the create_webview command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_webview_window command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-create-webview-window",
+ "markdownDescription": "Denies the create_webview_window command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_all_webviews command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-get-all-webviews",
+ "markdownDescription": "Denies the get_all_webviews command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the internal_toggle_devtools command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-internal-toggle-devtools",
+ "markdownDescription": "Denies the internal_toggle_devtools command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the print command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-print",
+ "markdownDescription": "Denies the print command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the reparent command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-reparent",
+ "markdownDescription": "Denies the reparent command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_auto_resize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-auto-resize",
+ "markdownDescription": "Denies the set_webview_auto_resize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-background-color",
+ "markdownDescription": "Denies the set_webview_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-focus",
+ "markdownDescription": "Denies the set_webview_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-position",
+ "markdownDescription": "Denies the set_webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-size",
+ "markdownDescription": "Denies the set_webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_zoom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-zoom",
+ "markdownDescription": "Denies the set_webview_zoom command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-close",
+ "markdownDescription": "Denies the webview_close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-hide",
+ "markdownDescription": "Denies the webview_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-position",
+ "markdownDescription": "Denies the webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-show",
+ "markdownDescription": "Denies the webview_show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-size",
+ "markdownDescription": "Denies the webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`",
+ "type": "string",
+ "const": "core:window:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`"
+ },
+ {
+ "description": "Enables the activity_name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-activity-name",
+ "markdownDescription": "Enables the activity_name command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the available_monitors command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-available-monitors",
+ "markdownDescription": "Enables the available_monitors command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the center command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-center",
+ "markdownDescription": "Enables the center command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-close",
+ "markdownDescription": "Enables the close command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-create",
+ "markdownDescription": "Enables the create command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the current_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-current-monitor",
+ "markdownDescription": "Enables the current_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-cursor-position",
+ "markdownDescription": "Enables the cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the destroy command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-destroy",
+ "markdownDescription": "Enables the destroy command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get_all_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-get-all-windows",
+ "markdownDescription": "Enables the get_all_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-hide",
+ "markdownDescription": "Enables the hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the inner_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-inner-position",
+ "markdownDescription": "Enables the inner_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the inner_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-inner-size",
+ "markdownDescription": "Enables the inner_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the internal_toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-internal-toggle-maximize",
+ "markdownDescription": "Enables the internal_toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-always-on-top",
+ "markdownDescription": "Enables the is_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-closable",
+ "markdownDescription": "Enables the is_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_decorated command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-decorated",
+ "markdownDescription": "Enables the is_decorated command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-enabled",
+ "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_focused command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-focused",
+ "markdownDescription": "Enables the is_focused command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-fullscreen",
+ "markdownDescription": "Enables the is_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-maximizable",
+ "markdownDescription": "Enables the is_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_maximized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-maximized",
+ "markdownDescription": "Enables the is_maximized command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-minimizable",
+ "markdownDescription": "Enables the is_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_minimized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-minimized",
+ "markdownDescription": "Enables the is_minimized command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-resizable",
+ "markdownDescription": "Enables the is_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-visible",
+ "markdownDescription": "Enables the is_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-maximize",
+ "markdownDescription": "Enables the maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the minimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-minimize",
+ "markdownDescription": "Enables the minimize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the monitor_from_point command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-monitor-from-point",
+ "markdownDescription": "Enables the monitor_from_point command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the outer_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-outer-position",
+ "markdownDescription": "Enables the outer_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the outer_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-outer-size",
+ "markdownDescription": "Enables the outer_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the primary_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-primary-monitor",
+ "markdownDescription": "Enables the primary_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the request_user_attention command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-request-user-attention",
+ "markdownDescription": "Enables the request_user_attention command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the scale_factor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-scale-factor",
+ "markdownDescription": "Enables the scale_factor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the scene_identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-scene-identifier",
+ "markdownDescription": "Enables the scene_identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_always_on_bottom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-always-on-bottom",
+ "markdownDescription": "Enables the set_always_on_bottom command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-always-on-top",
+ "markdownDescription": "Enables the set_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-background-color",
+ "markdownDescription": "Enables the set_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_badge_count command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-badge-count",
+ "markdownDescription": "Enables the set_badge_count command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_badge_label command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-badge-label",
+ "markdownDescription": "Enables the set_badge_label command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-closable",
+ "markdownDescription": "Enables the set_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_content_protected command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-content-protected",
+ "markdownDescription": "Enables the set_content_protected command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_grab command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-grab",
+ "markdownDescription": "Enables the set_cursor_grab command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-icon",
+ "markdownDescription": "Enables the set_cursor_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-position",
+ "markdownDescription": "Enables the set_cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-visible",
+ "markdownDescription": "Enables the set_cursor_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_decorations command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-decorations",
+ "markdownDescription": "Enables the set_decorations command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_effects command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-effects",
+ "markdownDescription": "Enables the set_effects command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-enabled",
+ "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-focus",
+ "markdownDescription": "Enables the set_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_focusable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-focusable",
+ "markdownDescription": "Enables the set_focusable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-fullscreen",
+ "markdownDescription": "Enables the set_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_ignore_cursor_events command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-ignore-cursor-events",
+ "markdownDescription": "Enables the set_ignore_cursor_events command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_max_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-max-size",
+ "markdownDescription": "Enables the set_max_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-maximizable",
+ "markdownDescription": "Enables the set_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_min_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-min-size",
+ "markdownDescription": "Enables the set_min_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-minimizable",
+ "markdownDescription": "Enables the set_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_overlay_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-overlay-icon",
+ "markdownDescription": "Enables the set_overlay_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-position",
+ "markdownDescription": "Enables the set_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_progress_bar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-progress-bar",
+ "markdownDescription": "Enables the set_progress_bar command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-resizable",
+ "markdownDescription": "Enables the set_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_shadow command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-shadow",
+ "markdownDescription": "Enables the set_shadow command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_simple_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-simple-fullscreen",
+ "markdownDescription": "Enables the set_simple_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-size",
+ "markdownDescription": "Enables the set_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_size_constraints command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-size-constraints",
+ "markdownDescription": "Enables the set_size_constraints command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_skip_taskbar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-skip-taskbar",
+ "markdownDescription": "Enables the set_skip_taskbar command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-theme",
+ "markdownDescription": "Enables the set_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-title",
+ "markdownDescription": "Enables the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title_bar_style command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-title-bar-style",
+ "markdownDescription": "Enables the set_title_bar_style command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_visible_on_all_workspaces command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-visible-on-all-workspaces",
+ "markdownDescription": "Enables the set_visible_on_all_workspaces command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-show",
+ "markdownDescription": "Enables the show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the start_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-start-dragging",
+ "markdownDescription": "Enables the start_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the start_resize_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-start-resize-dragging",
+ "markdownDescription": "Enables the start_resize_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-theme",
+ "markdownDescription": "Enables the theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-title",
+ "markdownDescription": "Enables the title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-toggle-maximize",
+ "markdownDescription": "Enables the toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unmaximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-unmaximize",
+ "markdownDescription": "Enables the unmaximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unminimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-unminimize",
+ "markdownDescription": "Enables the unminimize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the activity_name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-activity-name",
+ "markdownDescription": "Denies the activity_name command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the available_monitors command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-available-monitors",
+ "markdownDescription": "Denies the available_monitors command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the center command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-center",
+ "markdownDescription": "Denies the center command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-close",
+ "markdownDescription": "Denies the close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-create",
+ "markdownDescription": "Denies the create command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the current_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-current-monitor",
+ "markdownDescription": "Denies the current_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-cursor-position",
+ "markdownDescription": "Denies the cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the destroy command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-destroy",
+ "markdownDescription": "Denies the destroy command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_all_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-get-all-windows",
+ "markdownDescription": "Denies the get_all_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-hide",
+ "markdownDescription": "Denies the hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the inner_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-inner-position",
+ "markdownDescription": "Denies the inner_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the inner_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-inner-size",
+ "markdownDescription": "Denies the inner_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the internal_toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-internal-toggle-maximize",
+ "markdownDescription": "Denies the internal_toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-always-on-top",
+ "markdownDescription": "Denies the is_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-closable",
+ "markdownDescription": "Denies the is_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_decorated command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-decorated",
+ "markdownDescription": "Denies the is_decorated command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-enabled",
+ "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_focused command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-focused",
+ "markdownDescription": "Denies the is_focused command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-fullscreen",
+ "markdownDescription": "Denies the is_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-maximizable",
+ "markdownDescription": "Denies the is_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_maximized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-maximized",
+ "markdownDescription": "Denies the is_maximized command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-minimizable",
+ "markdownDescription": "Denies the is_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_minimized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-minimized",
+ "markdownDescription": "Denies the is_minimized command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-resizable",
+ "markdownDescription": "Denies the is_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-visible",
+ "markdownDescription": "Denies the is_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-maximize",
+ "markdownDescription": "Denies the maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the minimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-minimize",
+ "markdownDescription": "Denies the minimize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the monitor_from_point command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-monitor-from-point",
+ "markdownDescription": "Denies the monitor_from_point command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the outer_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-outer-position",
+ "markdownDescription": "Denies the outer_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the outer_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-outer-size",
+ "markdownDescription": "Denies the outer_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the primary_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-primary-monitor",
+ "markdownDescription": "Denies the primary_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the request_user_attention command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-request-user-attention",
+ "markdownDescription": "Denies the request_user_attention command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the scale_factor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-scale-factor",
+ "markdownDescription": "Denies the scale_factor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the scene_identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-scene-identifier",
+ "markdownDescription": "Denies the scene_identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_always_on_bottom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-always-on-bottom",
+ "markdownDescription": "Denies the set_always_on_bottom command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-always-on-top",
+ "markdownDescription": "Denies the set_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-background-color",
+ "markdownDescription": "Denies the set_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_badge_count command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-badge-count",
+ "markdownDescription": "Denies the set_badge_count command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_badge_label command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-badge-label",
+ "markdownDescription": "Denies the set_badge_label command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-closable",
+ "markdownDescription": "Denies the set_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_content_protected command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-content-protected",
+ "markdownDescription": "Denies the set_content_protected command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_grab command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-grab",
+ "markdownDescription": "Denies the set_cursor_grab command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-icon",
+ "markdownDescription": "Denies the set_cursor_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-position",
+ "markdownDescription": "Denies the set_cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-visible",
+ "markdownDescription": "Denies the set_cursor_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_decorations command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-decorations",
+ "markdownDescription": "Denies the set_decorations command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_effects command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-effects",
+ "markdownDescription": "Denies the set_effects command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-enabled",
+ "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-focus",
+ "markdownDescription": "Denies the set_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_focusable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-focusable",
+ "markdownDescription": "Denies the set_focusable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-fullscreen",
+ "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_ignore_cursor_events command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-ignore-cursor-events",
+ "markdownDescription": "Denies the set_ignore_cursor_events command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_max_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-max-size",
+ "markdownDescription": "Denies the set_max_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-maximizable",
+ "markdownDescription": "Denies the set_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_min_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-min-size",
+ "markdownDescription": "Denies the set_min_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-minimizable",
+ "markdownDescription": "Denies the set_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_overlay_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-overlay-icon",
+ "markdownDescription": "Denies the set_overlay_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-position",
+ "markdownDescription": "Denies the set_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_progress_bar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-progress-bar",
+ "markdownDescription": "Denies the set_progress_bar command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-resizable",
+ "markdownDescription": "Denies the set_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_shadow command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-shadow",
+ "markdownDescription": "Denies the set_shadow command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_simple_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-simple-fullscreen",
+ "markdownDescription": "Denies the set_simple_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-size",
+ "markdownDescription": "Denies the set_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_size_constraints command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-size-constraints",
+ "markdownDescription": "Denies the set_size_constraints command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_skip_taskbar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-skip-taskbar",
+ "markdownDescription": "Denies the set_skip_taskbar command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-theme",
+ "markdownDescription": "Denies the set_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-title",
+ "markdownDescription": "Denies the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title_bar_style command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-title-bar-style",
+ "markdownDescription": "Denies the set_title_bar_style command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_visible_on_all_workspaces command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-visible-on-all-workspaces",
+ "markdownDescription": "Denies the set_visible_on_all_workspaces command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-show",
+ "markdownDescription": "Denies the show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the start_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-start-dragging",
+ "markdownDescription": "Denies the start_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the start_resize_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-start-resize-dragging",
+ "markdownDescription": "Denies the start_resize_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-theme",
+ "markdownDescription": "Denies the theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-title",
+ "markdownDescription": "Denies the title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-toggle-maximize",
+ "markdownDescription": "Denies the toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unmaximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-unmaximize",
+ "markdownDescription": "Denies the unmaximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unminimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-unminimize",
+ "markdownDescription": "Denies the unminimize command without any pre-configured scope."
+ }
+ ]
+ },
+ "Value": {
+ "description": "All supported ACL values.",
+ "anyOf": [
+ {
+ "description": "Represents a null JSON value.",
+ "type": "null"
+ },
+ {
+ "description": "Represents a [`bool`].",
+ "type": "boolean"
+ },
+ {
+ "description": "Represents a valid ACL [`Number`].",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Number"
+ }
+ ]
+ },
+ {
+ "description": "Represents a [`String`].",
+ "type": "string"
+ },
+ {
+ "description": "Represents a list of other [`Value`]s.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ },
+ {
+ "description": "Represents a map of [`String`] keys to [`Value`]s.",
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#/definitions/Value"
+ }
+ }
+ ]
+ },
+ "Number": {
+ "description": "A valid ACL number.",
+ "anyOf": [
+ {
+ "description": "Represents an [`i64`].",
+ "type": "integer",
+ "format": "int64"
+ },
+ {
+ "description": "Represents a [`f64`].",
+ "type": "number",
+ "format": "double"
+ }
+ ]
+ },
+ "Target": {
+ "description": "Platform target.",
+ "oneOf": [
+ {
+ "description": "MacOS.",
+ "type": "string",
+ "enum": [
+ "macOS"
+ ]
+ },
+ {
+ "description": "Windows.",
+ "type": "string",
+ "enum": [
+ "windows"
+ ]
+ },
+ {
+ "description": "Linux.",
+ "type": "string",
+ "enum": [
+ "linux"
+ ]
+ },
+ {
+ "description": "Android.",
+ "type": "string",
+ "enum": [
+ "android"
+ ]
+ },
+ {
+ "description": "iOS.",
+ "type": "string",
+ "enum": [
+ "iOS"
+ ]
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/gen/schemas/windows-schema.json b/gen/schemas/windows-schema.json
new file mode 100644
index 0000000..3286645
--- /dev/null
+++ b/gen/schemas/windows-schema.json
@@ -0,0 +1,2292 @@
+{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "CapabilityFile",
+ "description": "Capability formats accepted in a capability file.",
+ "anyOf": [
+ {
+ "description": "A single capability.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Capability"
+ }
+ ]
+ },
+ {
+ "description": "A list of capabilities.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Capability"
+ }
+ },
+ {
+ "description": "A list of capabilities.",
+ "type": "object",
+ "required": [
+ "capabilities"
+ ],
+ "properties": {
+ "capabilities": {
+ "description": "The list of capabilities.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Capability"
+ }
+ }
+ }
+ }
+ ],
+ "definitions": {
+ "Capability": {
+ "description": "A grouping and boundary mechanism developers can use to isolate access to the IPC layer.\n\nIt controls application windows' and webviews' fine grained access to the Tauri core, application, or plugin commands. If a webview or its window is not matching any capability then it has no access to the IPC layer at all.\n\nThis can be done to create groups of windows, based on their required system access, which can reduce impact of frontend vulnerabilities in less privileged windows. Windows can be added to a capability by exact name (e.g. `main-window`) or glob patterns like `*` or `admin-*`. A Window can have none, one, or multiple associated capabilities.\n\n## Example\n\n```json { \"identifier\": \"main-user-files-write\", \"description\": \"This capability allows the `main` window on macOS and Windows access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.\", \"windows\": [ \"main\" ], \"permissions\": [ \"core:default\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] }, ], \"platforms\": [\"macOS\",\"windows\"] } ```",
+ "type": "object",
+ "required": [
+ "identifier",
+ "permissions"
+ ],
+ "properties": {
+ "identifier": {
+ "description": "Identifier of the capability.\n\n## Example\n\n`main-user-files-write`",
+ "type": "string"
+ },
+ "description": {
+ "description": "Description of what the capability is intended to allow on associated windows.\n\nIt should contain a description of what the grouped permissions should allow.\n\n## Example\n\nThis capability allows the `main` window access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.",
+ "default": "",
+ "type": "string"
+ },
+ "remote": {
+ "description": "Configure remote URLs that can use the capability permissions.\n\nThis setting is optional and defaults to not being set, as our default use case is that the content is served from our local application.\n\n:::caution Make sure you understand the security implications of providing remote sources with local system access. :::\n\n## Example\n\n```json { \"urls\": [\"https://*.mydomain.dev\"] } ```",
+ "anyOf": [
+ {
+ "$ref": "#/definitions/CapabilityRemote"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "local": {
+ "description": "Whether this capability is enabled for local app URLs or not. Defaults to `true`.",
+ "default": true,
+ "type": "boolean"
+ },
+ "windows": {
+ "description": "List of windows that are affected by this capability. Can be a glob pattern.\n\nIf a window label matches any of the patterns in this list, the capability will be enabled on all the webviews of that window, regardless of the value of [`Self::webviews`].\n\nOn multiwebview windows, prefer specifying [`Self::webviews`] and omitting [`Self::windows`] for a fine grained access control.\n\n## Example\n\n`[\"main\"]`",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "webviews": {
+ "description": "List of webviews that are affected by this capability. Can be a glob pattern.\n\nThe capability will be enabled on all the webviews whose label matches any of the patterns in this list, regardless of whether the webview's window label matches a pattern in [`Self::windows`].\n\n## Example\n\n`[\"sub-webview-one\", \"sub-webview-two\"]`",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "permissions": {
+ "description": "List of permissions attached to this capability.\n\nMust include the plugin name as prefix in the form of `${plugin-name}:${permission-name}`. For commands directly implemented in the application itself only `${permission-name}` is required.\n\n## Example\n\n```json [ \"core:default\", \"shell:allow-open\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] } ] ```",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/PermissionEntry"
+ },
+ "uniqueItems": true
+ },
+ "platforms": {
+ "description": "Limit which target platforms this capability applies to.\n\nBy default all platforms are targeted.\n\n## Example\n\n`[\"macOS\",\"windows\"]`",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Target"
+ }
+ }
+ }
+ },
+ "CapabilityRemote": {
+ "description": "Configuration for remote URLs that are associated with the capability.",
+ "type": "object",
+ "required": [
+ "urls"
+ ],
+ "properties": {
+ "urls": {
+ "description": "Remote domains this capability refers to using the [URLPattern standard](https://urlpattern.spec.whatwg.org/).\n\n## Examples\n\n- \"https://*.mydomain.dev\": allows subdomains of mydomain.dev - \"https://mydomain.dev/api/*\": allows any subpath of mydomain.dev/api",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ }
+ }
+ },
+ "PermissionEntry": {
+ "description": "An entry for a permission value in a [`Capability`] can be either a raw permission [`Identifier`] or an object that references a permission and extends its scope.",
+ "anyOf": [
+ {
+ "description": "Reference a permission or permission set by identifier.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Identifier"
+ }
+ ]
+ },
+ {
+ "description": "Reference a permission or permission set by identifier and extends its scope.",
+ "type": "object",
+ "allOf": [
+ {
+ "properties": {
+ "identifier": {
+ "description": "Identifier of the permission or permission set.",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Identifier"
+ }
+ ]
+ },
+ "allow": {
+ "description": "Data that defines what is allowed by the scope.",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ },
+ "deny": {
+ "description": "Data that defines what is denied by the scope. This should be prioritized by validation logic.",
+ "type": [
+ "array",
+ "null"
+ ],
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ }
+ }
+ }
+ ],
+ "required": [
+ "identifier"
+ ]
+ }
+ ]
+ },
+ "Identifier": {
+ "description": "Permission identifier",
+ "oneOf": [
+ {
+ "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
+ "type": "string",
+ "const": "core:default",
+ "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`",
+ "type": "string",
+ "const": "core:app:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`"
+ },
+ {
+ "description": "Enables the app_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-app-hide",
+ "markdownDescription": "Enables the app_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the app_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-app-show",
+ "markdownDescription": "Enables the app_show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the bundle_type command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-bundle-type",
+ "markdownDescription": "Enables the bundle_type command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the default_window_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-default-window-icon",
+ "markdownDescription": "Enables the default_window_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the fetch_data_store_identifiers command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-fetch-data-store-identifiers",
+ "markdownDescription": "Enables the fetch_data_store_identifiers command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-identifier",
+ "markdownDescription": "Enables the identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-name",
+ "markdownDescription": "Enables the name command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the register_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-register-listener",
+ "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_data_store command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-remove-data-store",
+ "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-remove-listener",
+ "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_app_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-set-app-theme",
+ "markdownDescription": "Enables the set_app_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_dock_visibility command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-set-dock-visibility",
+ "markdownDescription": "Enables the set_dock_visibility command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the supports_multiple_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-supports-multiple-windows",
+ "markdownDescription": "Enables the supports_multiple_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the tauri_version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-tauri-version",
+ "markdownDescription": "Enables the tauri_version command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:allow-version",
+ "markdownDescription": "Enables the version command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the app_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-app-hide",
+ "markdownDescription": "Denies the app_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the app_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-app-show",
+ "markdownDescription": "Denies the app_show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the bundle_type command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-bundle-type",
+ "markdownDescription": "Denies the bundle_type command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the default_window_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-default-window-icon",
+ "markdownDescription": "Denies the default_window_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the fetch_data_store_identifiers command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-fetch-data-store-identifiers",
+ "markdownDescription": "Denies the fetch_data_store_identifiers command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-identifier",
+ "markdownDescription": "Denies the identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-name",
+ "markdownDescription": "Denies the name command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the register_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-register-listener",
+ "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_data_store command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-remove-data-store",
+ "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_listener command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-remove-listener",
+ "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_app_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-set-app-theme",
+ "markdownDescription": "Denies the set_app_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_dock_visibility command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-set-dock-visibility",
+ "markdownDescription": "Denies the set_dock_visibility command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the supports_multiple_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-supports-multiple-windows",
+ "markdownDescription": "Denies the supports_multiple_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the tauri_version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-tauri-version",
+ "markdownDescription": "Denies the tauri_version command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the version command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:app:deny-version",
+ "markdownDescription": "Denies the version command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`",
+ "type": "string",
+ "const": "core:event:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`"
+ },
+ {
+ "description": "Enables the emit command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-emit",
+ "markdownDescription": "Enables the emit command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the emit_to command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-emit-to",
+ "markdownDescription": "Enables the emit_to command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the listen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-listen",
+ "markdownDescription": "Enables the listen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unlisten command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:allow-unlisten",
+ "markdownDescription": "Enables the unlisten command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the emit command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-emit",
+ "markdownDescription": "Denies the emit command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the emit_to command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-emit-to",
+ "markdownDescription": "Denies the emit_to command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the listen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-listen",
+ "markdownDescription": "Denies the listen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unlisten command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:event:deny-unlisten",
+ "markdownDescription": "Denies the unlisten command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`",
+ "type": "string",
+ "const": "core:image:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`"
+ },
+ {
+ "description": "Enables the from_bytes command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-from-bytes",
+ "markdownDescription": "Enables the from_bytes command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the from_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-from-path",
+ "markdownDescription": "Enables the from_path command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the rgba command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-rgba",
+ "markdownDescription": "Enables the rgba command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:allow-size",
+ "markdownDescription": "Enables the size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the from_bytes command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-from-bytes",
+ "markdownDescription": "Denies the from_bytes command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the from_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-from-path",
+ "markdownDescription": "Denies the from_path command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the rgba command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-rgba",
+ "markdownDescription": "Denies the rgba command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:image:deny-size",
+ "markdownDescription": "Denies the size command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`",
+ "type": "string",
+ "const": "core:menu:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`"
+ },
+ {
+ "description": "Enables the append command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-append",
+ "markdownDescription": "Enables the append command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_default command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-create-default",
+ "markdownDescription": "Enables the create_default command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-get",
+ "markdownDescription": "Enables the get command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the insert command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-insert",
+ "markdownDescription": "Enables the insert command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-is-checked",
+ "markdownDescription": "Enables the is_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-is-enabled",
+ "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the items command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-items",
+ "markdownDescription": "Enables the items command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the popup command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-popup",
+ "markdownDescription": "Enables the popup command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the prepend command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-prepend",
+ "markdownDescription": "Enables the prepend command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-remove",
+ "markdownDescription": "Enables the remove command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_at command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-remove-at",
+ "markdownDescription": "Enables the remove_at command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_accelerator command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-accelerator",
+ "markdownDescription": "Enables the set_accelerator command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_app_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-app-menu",
+ "markdownDescription": "Enables the set_as_app_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-help-menu-for-nsapp",
+ "markdownDescription": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_window_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-window-menu",
+ "markdownDescription": "Enables the set_as_window_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-as-windows-menu-for-nsapp",
+ "markdownDescription": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-checked",
+ "markdownDescription": "Enables the set_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-enabled",
+ "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-set-text",
+ "markdownDescription": "Enables the set_text command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:allow-text",
+ "markdownDescription": "Enables the text command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the append command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-append",
+ "markdownDescription": "Denies the append command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_default command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-create-default",
+ "markdownDescription": "Denies the create_default command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-get",
+ "markdownDescription": "Denies the get command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the insert command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-insert",
+ "markdownDescription": "Denies the insert command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-is-checked",
+ "markdownDescription": "Denies the is_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-is-enabled",
+ "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the items command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-items",
+ "markdownDescription": "Denies the items command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the popup command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-popup",
+ "markdownDescription": "Denies the popup command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the prepend command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-prepend",
+ "markdownDescription": "Denies the prepend command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-remove",
+ "markdownDescription": "Denies the remove command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_at command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-remove-at",
+ "markdownDescription": "Denies the remove_at command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_accelerator command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-accelerator",
+ "markdownDescription": "Denies the set_accelerator command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_app_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-app-menu",
+ "markdownDescription": "Denies the set_as_app_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-help-menu-for-nsapp",
+ "markdownDescription": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_window_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-window-menu",
+ "markdownDescription": "Denies the set_as_window_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-as-windows-menu-for-nsapp",
+ "markdownDescription": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_checked command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-checked",
+ "markdownDescription": "Denies the set_checked command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-enabled",
+ "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-set-text",
+ "markdownDescription": "Denies the set_text command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the text command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:menu:deny-text",
+ "markdownDescription": "Denies the text command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`",
+ "type": "string",
+ "const": "core:path:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`"
+ },
+ {
+ "description": "Enables the basename command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-basename",
+ "markdownDescription": "Enables the basename command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the dirname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-dirname",
+ "markdownDescription": "Enables the dirname command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the extname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-extname",
+ "markdownDescription": "Enables the extname command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_absolute command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-is-absolute",
+ "markdownDescription": "Enables the is_absolute command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the join command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-join",
+ "markdownDescription": "Enables the join command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the normalize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-normalize",
+ "markdownDescription": "Enables the normalize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the resolve command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-resolve",
+ "markdownDescription": "Enables the resolve command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the resolve_directory command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:allow-resolve-directory",
+ "markdownDescription": "Enables the resolve_directory command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the basename command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-basename",
+ "markdownDescription": "Denies the basename command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the dirname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-dirname",
+ "markdownDescription": "Denies the dirname command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the extname command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-extname",
+ "markdownDescription": "Denies the extname command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_absolute command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-is-absolute",
+ "markdownDescription": "Denies the is_absolute command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the join command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-join",
+ "markdownDescription": "Denies the join command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the normalize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-normalize",
+ "markdownDescription": "Denies the normalize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the resolve command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-resolve",
+ "markdownDescription": "Denies the resolve command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the resolve_directory command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:path:deny-resolve-directory",
+ "markdownDescription": "Denies the resolve_directory command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`",
+ "type": "string",
+ "const": "core:resources:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`"
+ },
+ {
+ "description": "Enables the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:resources:allow-close",
+ "markdownDescription": "Enables the close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:resources:deny-close",
+ "markdownDescription": "Denies the close command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`",
+ "type": "string",
+ "const": "core:tray:default",
+ "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`"
+ },
+ {
+ "description": "Enables the get_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-get-by-id",
+ "markdownDescription": "Enables the get_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-new",
+ "markdownDescription": "Enables the new command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the remove_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-remove-by-id",
+ "markdownDescription": "Enables the remove_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon-as-template",
+ "markdownDescription": "Enables the set_icon_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon_with_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-icon-with-as-template",
+ "markdownDescription": "Enables the set_icon_with_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-menu",
+ "markdownDescription": "Enables the set_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_show_menu_on_left_click command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-show-menu-on-left-click",
+ "markdownDescription": "Enables the set_show_menu_on_left_click command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_temp_dir_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-temp-dir-path",
+ "markdownDescription": "Enables the set_temp_dir_path command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-title",
+ "markdownDescription": "Enables the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_tooltip command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-tooltip",
+ "markdownDescription": "Enables the set_tooltip command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:allow-set-visible",
+ "markdownDescription": "Enables the set_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-get-by-id",
+ "markdownDescription": "Denies the get_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the new command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-new",
+ "markdownDescription": "Denies the new command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the remove_by_id command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-remove-by-id",
+ "markdownDescription": "Denies the remove_by_id command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon-as-template",
+ "markdownDescription": "Denies the set_icon_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon_with_as_template command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-icon-with-as-template",
+ "markdownDescription": "Denies the set_icon_with_as_template command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_menu command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-menu",
+ "markdownDescription": "Denies the set_menu command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_show_menu_on_left_click command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-show-menu-on-left-click",
+ "markdownDescription": "Denies the set_show_menu_on_left_click command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_temp_dir_path command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-temp-dir-path",
+ "markdownDescription": "Denies the set_temp_dir_path command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-title",
+ "markdownDescription": "Denies the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_tooltip command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-tooltip",
+ "markdownDescription": "Denies the set_tooltip command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:tray:deny-set-visible",
+ "markdownDescription": "Denies the set_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`",
+ "type": "string",
+ "const": "core:webview:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`"
+ },
+ {
+ "description": "Enables the clear_all_browsing_data command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-clear-all-browsing-data",
+ "markdownDescription": "Enables the clear_all_browsing_data command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_webview command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-create-webview",
+ "markdownDescription": "Enables the create_webview command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create_webview_window command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-create-webview-window",
+ "markdownDescription": "Enables the create_webview_window command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get_all_webviews command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-get-all-webviews",
+ "markdownDescription": "Enables the get_all_webviews command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the internal_toggle_devtools command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-internal-toggle-devtools",
+ "markdownDescription": "Enables the internal_toggle_devtools command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the print command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-print",
+ "markdownDescription": "Enables the print command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the reparent command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-reparent",
+ "markdownDescription": "Enables the reparent command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_auto_resize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-auto-resize",
+ "markdownDescription": "Enables the set_webview_auto_resize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-background-color",
+ "markdownDescription": "Enables the set_webview_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-focus",
+ "markdownDescription": "Enables the set_webview_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-position",
+ "markdownDescription": "Enables the set_webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-size",
+ "markdownDescription": "Enables the set_webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_webview_zoom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-set-webview-zoom",
+ "markdownDescription": "Enables the set_webview_zoom command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-close",
+ "markdownDescription": "Enables the webview_close command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-hide",
+ "markdownDescription": "Enables the webview_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-position",
+ "markdownDescription": "Enables the webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-show",
+ "markdownDescription": "Enables the webview_show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:allow-webview-size",
+ "markdownDescription": "Enables the webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the clear_all_browsing_data command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-clear-all-browsing-data",
+ "markdownDescription": "Denies the clear_all_browsing_data command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_webview command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-create-webview",
+ "markdownDescription": "Denies the create_webview command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create_webview_window command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-create-webview-window",
+ "markdownDescription": "Denies the create_webview_window command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_all_webviews command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-get-all-webviews",
+ "markdownDescription": "Denies the get_all_webviews command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the internal_toggle_devtools command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-internal-toggle-devtools",
+ "markdownDescription": "Denies the internal_toggle_devtools command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the print command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-print",
+ "markdownDescription": "Denies the print command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the reparent command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-reparent",
+ "markdownDescription": "Denies the reparent command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_auto_resize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-auto-resize",
+ "markdownDescription": "Denies the set_webview_auto_resize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-background-color",
+ "markdownDescription": "Denies the set_webview_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-focus",
+ "markdownDescription": "Denies the set_webview_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-position",
+ "markdownDescription": "Denies the set_webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-size",
+ "markdownDescription": "Denies the set_webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_webview_zoom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-set-webview-zoom",
+ "markdownDescription": "Denies the set_webview_zoom command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-close",
+ "markdownDescription": "Denies the webview_close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-hide",
+ "markdownDescription": "Denies the webview_hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-position",
+ "markdownDescription": "Denies the webview_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-show",
+ "markdownDescription": "Denies the webview_show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the webview_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:webview:deny-webview-size",
+ "markdownDescription": "Denies the webview_size command without any pre-configured scope."
+ },
+ {
+ "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`",
+ "type": "string",
+ "const": "core:window:default",
+ "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`"
+ },
+ {
+ "description": "Enables the activity_name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-activity-name",
+ "markdownDescription": "Enables the activity_name command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the available_monitors command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-available-monitors",
+ "markdownDescription": "Enables the available_monitors command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the center command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-center",
+ "markdownDescription": "Enables the center command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-close",
+ "markdownDescription": "Enables the close command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the create command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-create",
+ "markdownDescription": "Enables the create command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the current_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-current-monitor",
+ "markdownDescription": "Enables the current_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-cursor-position",
+ "markdownDescription": "Enables the cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the destroy command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-destroy",
+ "markdownDescription": "Enables the destroy command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the get_all_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-get-all-windows",
+ "markdownDescription": "Enables the get_all_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-hide",
+ "markdownDescription": "Enables the hide command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the inner_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-inner-position",
+ "markdownDescription": "Enables the inner_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the inner_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-inner-size",
+ "markdownDescription": "Enables the inner_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the internal_toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-internal-toggle-maximize",
+ "markdownDescription": "Enables the internal_toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-always-on-top",
+ "markdownDescription": "Enables the is_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-closable",
+ "markdownDescription": "Enables the is_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_decorated command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-decorated",
+ "markdownDescription": "Enables the is_decorated command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-enabled",
+ "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_focused command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-focused",
+ "markdownDescription": "Enables the is_focused command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-fullscreen",
+ "markdownDescription": "Enables the is_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-maximizable",
+ "markdownDescription": "Enables the is_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_maximized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-maximized",
+ "markdownDescription": "Enables the is_maximized command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-minimizable",
+ "markdownDescription": "Enables the is_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_minimized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-minimized",
+ "markdownDescription": "Enables the is_minimized command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-resizable",
+ "markdownDescription": "Enables the is_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the is_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-is-visible",
+ "markdownDescription": "Enables the is_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-maximize",
+ "markdownDescription": "Enables the maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the minimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-minimize",
+ "markdownDescription": "Enables the minimize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the monitor_from_point command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-monitor-from-point",
+ "markdownDescription": "Enables the monitor_from_point command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the outer_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-outer-position",
+ "markdownDescription": "Enables the outer_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the outer_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-outer-size",
+ "markdownDescription": "Enables the outer_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the primary_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-primary-monitor",
+ "markdownDescription": "Enables the primary_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the request_user_attention command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-request-user-attention",
+ "markdownDescription": "Enables the request_user_attention command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the scale_factor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-scale-factor",
+ "markdownDescription": "Enables the scale_factor command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the scene_identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-scene-identifier",
+ "markdownDescription": "Enables the scene_identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_always_on_bottom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-always-on-bottom",
+ "markdownDescription": "Enables the set_always_on_bottom command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-always-on-top",
+ "markdownDescription": "Enables the set_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-background-color",
+ "markdownDescription": "Enables the set_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_badge_count command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-badge-count",
+ "markdownDescription": "Enables the set_badge_count command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_badge_label command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-badge-label",
+ "markdownDescription": "Enables the set_badge_label command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-closable",
+ "markdownDescription": "Enables the set_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_content_protected command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-content-protected",
+ "markdownDescription": "Enables the set_content_protected command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_grab command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-grab",
+ "markdownDescription": "Enables the set_cursor_grab command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-icon",
+ "markdownDescription": "Enables the set_cursor_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-position",
+ "markdownDescription": "Enables the set_cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_cursor_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-cursor-visible",
+ "markdownDescription": "Enables the set_cursor_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_decorations command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-decorations",
+ "markdownDescription": "Enables the set_decorations command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_effects command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-effects",
+ "markdownDescription": "Enables the set_effects command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-enabled",
+ "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-focus",
+ "markdownDescription": "Enables the set_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_focusable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-focusable",
+ "markdownDescription": "Enables the set_focusable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-fullscreen",
+ "markdownDescription": "Enables the set_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-icon",
+ "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_ignore_cursor_events command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-ignore-cursor-events",
+ "markdownDescription": "Enables the set_ignore_cursor_events command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_max_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-max-size",
+ "markdownDescription": "Enables the set_max_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-maximizable",
+ "markdownDescription": "Enables the set_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_min_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-min-size",
+ "markdownDescription": "Enables the set_min_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-minimizable",
+ "markdownDescription": "Enables the set_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_overlay_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-overlay-icon",
+ "markdownDescription": "Enables the set_overlay_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-position",
+ "markdownDescription": "Enables the set_position command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_progress_bar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-progress-bar",
+ "markdownDescription": "Enables the set_progress_bar command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-resizable",
+ "markdownDescription": "Enables the set_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_shadow command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-shadow",
+ "markdownDescription": "Enables the set_shadow command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_simple_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-simple-fullscreen",
+ "markdownDescription": "Enables the set_simple_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-size",
+ "markdownDescription": "Enables the set_size command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_size_constraints command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-size-constraints",
+ "markdownDescription": "Enables the set_size_constraints command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_skip_taskbar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-skip-taskbar",
+ "markdownDescription": "Enables the set_skip_taskbar command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-theme",
+ "markdownDescription": "Enables the set_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-title",
+ "markdownDescription": "Enables the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_title_bar_style command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-title-bar-style",
+ "markdownDescription": "Enables the set_title_bar_style command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the set_visible_on_all_workspaces command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-set-visible-on-all-workspaces",
+ "markdownDescription": "Enables the set_visible_on_all_workspaces command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-show",
+ "markdownDescription": "Enables the show command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the start_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-start-dragging",
+ "markdownDescription": "Enables the start_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the start_resize_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-start-resize-dragging",
+ "markdownDescription": "Enables the start_resize_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-theme",
+ "markdownDescription": "Enables the theme command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-title",
+ "markdownDescription": "Enables the title command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-toggle-maximize",
+ "markdownDescription": "Enables the toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unmaximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-unmaximize",
+ "markdownDescription": "Enables the unmaximize command without any pre-configured scope."
+ },
+ {
+ "description": "Enables the unminimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:allow-unminimize",
+ "markdownDescription": "Enables the unminimize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the activity_name command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-activity-name",
+ "markdownDescription": "Denies the activity_name command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the available_monitors command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-available-monitors",
+ "markdownDescription": "Denies the available_monitors command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the center command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-center",
+ "markdownDescription": "Denies the center command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the close command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-close",
+ "markdownDescription": "Denies the close command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the create command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-create",
+ "markdownDescription": "Denies the create command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the current_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-current-monitor",
+ "markdownDescription": "Denies the current_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-cursor-position",
+ "markdownDescription": "Denies the cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the destroy command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-destroy",
+ "markdownDescription": "Denies the destroy command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the get_all_windows command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-get-all-windows",
+ "markdownDescription": "Denies the get_all_windows command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the hide command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-hide",
+ "markdownDescription": "Denies the hide command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the inner_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-inner-position",
+ "markdownDescription": "Denies the inner_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the inner_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-inner-size",
+ "markdownDescription": "Denies the inner_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the internal_toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-internal-toggle-maximize",
+ "markdownDescription": "Denies the internal_toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-always-on-top",
+ "markdownDescription": "Denies the is_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-closable",
+ "markdownDescription": "Denies the is_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_decorated command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-decorated",
+ "markdownDescription": "Denies the is_decorated command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-enabled",
+ "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_focused command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-focused",
+ "markdownDescription": "Denies the is_focused command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-fullscreen",
+ "markdownDescription": "Denies the is_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-maximizable",
+ "markdownDescription": "Denies the is_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_maximized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-maximized",
+ "markdownDescription": "Denies the is_maximized command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-minimizable",
+ "markdownDescription": "Denies the is_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_minimized command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-minimized",
+ "markdownDescription": "Denies the is_minimized command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-resizable",
+ "markdownDescription": "Denies the is_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the is_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-is-visible",
+ "markdownDescription": "Denies the is_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-maximize",
+ "markdownDescription": "Denies the maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the minimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-minimize",
+ "markdownDescription": "Denies the minimize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the monitor_from_point command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-monitor-from-point",
+ "markdownDescription": "Denies the monitor_from_point command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the outer_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-outer-position",
+ "markdownDescription": "Denies the outer_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the outer_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-outer-size",
+ "markdownDescription": "Denies the outer_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the primary_monitor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-primary-monitor",
+ "markdownDescription": "Denies the primary_monitor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the request_user_attention command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-request-user-attention",
+ "markdownDescription": "Denies the request_user_attention command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the scale_factor command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-scale-factor",
+ "markdownDescription": "Denies the scale_factor command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the scene_identifier command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-scene-identifier",
+ "markdownDescription": "Denies the scene_identifier command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_always_on_bottom command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-always-on-bottom",
+ "markdownDescription": "Denies the set_always_on_bottom command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_always_on_top command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-always-on-top",
+ "markdownDescription": "Denies the set_always_on_top command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_background_color command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-background-color",
+ "markdownDescription": "Denies the set_background_color command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_badge_count command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-badge-count",
+ "markdownDescription": "Denies the set_badge_count command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_badge_label command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-badge-label",
+ "markdownDescription": "Denies the set_badge_label command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_closable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-closable",
+ "markdownDescription": "Denies the set_closable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_content_protected command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-content-protected",
+ "markdownDescription": "Denies the set_content_protected command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_grab command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-grab",
+ "markdownDescription": "Denies the set_cursor_grab command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-icon",
+ "markdownDescription": "Denies the set_cursor_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-position",
+ "markdownDescription": "Denies the set_cursor_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_cursor_visible command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-cursor-visible",
+ "markdownDescription": "Denies the set_cursor_visible command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_decorations command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-decorations",
+ "markdownDescription": "Denies the set_decorations command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_effects command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-effects",
+ "markdownDescription": "Denies the set_effects command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_enabled command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-enabled",
+ "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_focus command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-focus",
+ "markdownDescription": "Denies the set_focus command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_focusable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-focusable",
+ "markdownDescription": "Denies the set_focusable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-fullscreen",
+ "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-icon",
+ "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_ignore_cursor_events command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-ignore-cursor-events",
+ "markdownDescription": "Denies the set_ignore_cursor_events command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_max_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-max-size",
+ "markdownDescription": "Denies the set_max_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_maximizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-maximizable",
+ "markdownDescription": "Denies the set_maximizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_min_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-min-size",
+ "markdownDescription": "Denies the set_min_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_minimizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-minimizable",
+ "markdownDescription": "Denies the set_minimizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_overlay_icon command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-overlay-icon",
+ "markdownDescription": "Denies the set_overlay_icon command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_position command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-position",
+ "markdownDescription": "Denies the set_position command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_progress_bar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-progress-bar",
+ "markdownDescription": "Denies the set_progress_bar command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_resizable command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-resizable",
+ "markdownDescription": "Denies the set_resizable command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_shadow command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-shadow",
+ "markdownDescription": "Denies the set_shadow command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_simple_fullscreen command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-simple-fullscreen",
+ "markdownDescription": "Denies the set_simple_fullscreen command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_size command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-size",
+ "markdownDescription": "Denies the set_size command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_size_constraints command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-size-constraints",
+ "markdownDescription": "Denies the set_size_constraints command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_skip_taskbar command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-skip-taskbar",
+ "markdownDescription": "Denies the set_skip_taskbar command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-theme",
+ "markdownDescription": "Denies the set_theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-title",
+ "markdownDescription": "Denies the set_title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_title_bar_style command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-title-bar-style",
+ "markdownDescription": "Denies the set_title_bar_style command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the set_visible_on_all_workspaces command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-set-visible-on-all-workspaces",
+ "markdownDescription": "Denies the set_visible_on_all_workspaces command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the show command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-show",
+ "markdownDescription": "Denies the show command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the start_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-start-dragging",
+ "markdownDescription": "Denies the start_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the start_resize_dragging command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-start-resize-dragging",
+ "markdownDescription": "Denies the start_resize_dragging command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the theme command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-theme",
+ "markdownDescription": "Denies the theme command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the title command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-title",
+ "markdownDescription": "Denies the title command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the toggle_maximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-toggle-maximize",
+ "markdownDescription": "Denies the toggle_maximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unmaximize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-unmaximize",
+ "markdownDescription": "Denies the unmaximize command without any pre-configured scope."
+ },
+ {
+ "description": "Denies the unminimize command without any pre-configured scope.",
+ "type": "string",
+ "const": "core:window:deny-unminimize",
+ "markdownDescription": "Denies the unminimize command without any pre-configured scope."
+ }
+ ]
+ },
+ "Value": {
+ "description": "All supported ACL values.",
+ "anyOf": [
+ {
+ "description": "Represents a null JSON value.",
+ "type": "null"
+ },
+ {
+ "description": "Represents a [`bool`].",
+ "type": "boolean"
+ },
+ {
+ "description": "Represents a valid ACL [`Number`].",
+ "allOf": [
+ {
+ "$ref": "#/definitions/Number"
+ }
+ ]
+ },
+ {
+ "description": "Represents a [`String`].",
+ "type": "string"
+ },
+ {
+ "description": "Represents a list of other [`Value`]s.",
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/Value"
+ }
+ },
+ {
+ "description": "Represents a map of [`String`] keys to [`Value`]s.",
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#/definitions/Value"
+ }
+ }
+ ]
+ },
+ "Number": {
+ "description": "A valid ACL number.",
+ "anyOf": [
+ {
+ "description": "Represents an [`i64`].",
+ "type": "integer",
+ "format": "int64"
+ },
+ {
+ "description": "Represents a [`f64`].",
+ "type": "number",
+ "format": "double"
+ }
+ ]
+ },
+ "Target": {
+ "description": "Platform target.",
+ "oneOf": [
+ {
+ "description": "MacOS.",
+ "type": "string",
+ "enum": [
+ "macOS"
+ ]
+ },
+ {
+ "description": "Windows.",
+ "type": "string",
+ "enum": [
+ "windows"
+ ]
+ },
+ {
+ "description": "Linux.",
+ "type": "string",
+ "enum": [
+ "linux"
+ ]
+ },
+ {
+ "description": "Android.",
+ "type": "string",
+ "enum": [
+ "android"
+ ]
+ },
+ {
+ "description": "iOS.",
+ "type": "string",
+ "enum": [
+ "iOS"
+ ]
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
diff --git a/icons/icon.ico b/icons/icon.ico
new file mode 100644
index 0000000..1992e61
Binary files /dev/null and b/icons/icon.ico differ
diff --git a/icons/icon.png b/icons/icon.png
new file mode 100644
index 0000000..729e4d7
Binary files /dev/null and b/icons/icon.png differ
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..38447c4
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,221 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use base64::engine::general_purpose::STANDARD;
+use base64::Engine;
+use blockchain::blocks::burn::{BurnTransaction, UnsignedBurnTransaction};
+use blockchain::blocks::collateral::{
+ CollateralClaimTransaction, UnsignedCollateralClaimTransaction,
+};
+use blockchain::blocks::genesis::GenesisTransaction;
+use blockchain::blocks::issue_token::{IssueTokenTransaction, UnsignedIssueTokenTransaction};
+use blockchain::blocks::loan_payment::{
+ ContractPaymentTransaction, UnsignedContractPaymentTransaction,
+};
+use blockchain::blocks::loans::{LoanContractTransaction, UnsignedLoanContractTransaction};
+use blockchain::blocks::marketing::{MarketingTransaction, UnsignedMarketingTransaction};
+use blockchain::blocks::nft::{CreateNftTransaction, UnsignedCreateNftTransaction};
+use blockchain::blocks::rewards::RewardsTransaction;
+use blockchain::blocks::swap::{SwapTransaction, UnsignedSwapTransaction};
+use blockchain::blocks::token::{CreateTokenTransaction, UnsignedCreateTokenTransaction};
+use blockchain::blocks::transfer::{TransferTransaction, UnsignedTransferTransaction};
+use blockchain::blocks::vanity::{UnsignedVanityAddressTransaction, VanityAddressTransaction};
+use blockchain::common::skein::skein_256_hash_bytes;
+use blockchain::common::types::{
+ minimum_transfer_fee, BORROWER_FEE, BURN_FEE, COLLATERAL_FEE, CREATE_NFT_FEE, CREATE_TOKEN_FEE,
+ ISSUE_TOKEN_FEE, LENDER_FEE, MARKETING_FEE, SWAP_FEE, VANITY_ADDRESS_FEE,
+};
+use blockchain::records::memory::mempool::BASECOIN;
+use blockchain::records::memory::response_channels::generate_uid;
+use blockchain::rpc::command_maps::{
+ RPC_ADDRESS_HISTORY, RPC_ADDRESS_TOTAL_BALANCE, RPC_BLOCK_HEIGHT, RPC_CONTRACT_BY_ADDRESS,
+ RPC_LATEST_ADDRESS_TRANSACTIONS, RPC_LOAN_CONTRACT, RPC_MARKETING_CAMPAIGN_HISTORY,
+ RPC_NETWORK_INFO, RPC_NFT_DETAILS, RPC_NFT_LIST, RPC_REGISTER_WALLET, RPC_TIME,
+ RPC_TOKEN_CATALOG, RPC_TOKEN_DETAILS, RPC_TOKEN_LIST, RPC_TRANSACTION_BY_TXID,
+ RPC_VALIDATE_MESSAGE, RPC_VANITY_LOOKUP, RPC_VANITY_OWNER_LOOKUP,
+ RPC_WALLET_REGISTRATION_STATUS,
+};
+use blockchain::standalone_tools::connections::handshake::{self, HandshakeWallet};
+use blockchain::tokio::fs::{
+ create_dir_all, metadata, read, read_dir, read_to_string, remove_dir_all, remove_file,
+};
+use blockchain::tokio::sync::{oneshot, Mutex as AsyncMutex};
+use blockchain::tokio::time::sleep;
+use blockchain::wallets::structures::{SavedWallet, Wallet};
+use blockchain::{
+ create_img, decode_image_and_extract_text, decrypts, encode, encrypts, to_string_pretty,
+};
+use native_dialog::FileDialog;
+use reqwest;
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap};
+use std::env;
+use std::net::{SocketAddr, ToSocketAddrs};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering as AtomicOrdering};
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use tauri::State;
+
+include!("wallet_app/types.rs");
+include!("wallet_app/transaction_decode.rs");
+include!("wallet_app/state.rs");
+include!("wallet_app/rpc_scheduler.rs");
+include!("wallet_app/wallet_files.rs");
+include!("wallet_app/shared_rpc.rs");
+include!("wallet_app/commands_wallet.rs");
+include!("wallet_app/commands_balance_registration.rs");
+include!("wallet_app/commands_transactions.rs");
+include!("wallet_app/commands_network_cache.rs");
+
+fn clear_system_clipboard_now() {
+ #[cfg(windows)]
+ {
+ if let Err(err) = clipboard_win::set_clipboard_string("") {
+ eprintln!("Failed to clear system clipboard: {err}");
+ }
+ }
+}
+
+#[tauri::command]
+fn clear_system_clipboard() {
+ clear_system_clipboard_now();
+}
+
+#[tauri::command]
+fn open_external_url(url: String) -> Result<(), String> {
+ const ALLOWED_URLS: [&str; 4] = [
+ "https://www.pinata.cloud/",
+ "https://filebase.com/",
+ "https://thirdweb.com/storage",
+ "https://www.lighthouse.storage/",
+ ];
+
+ if !ALLOWED_URLS.contains(&url.as_str()) {
+ return Err("External URL is not allowed.".to_string());
+ }
+
+ #[cfg(target_os = "windows")]
+ let mut command = {
+ let mut command = Command::new("rundll32");
+ command.args(["url.dll,FileProtocolHandler", &url]);
+ command
+ };
+
+ #[cfg(target_os = "macos")]
+ let mut command = {
+ let mut command = Command::new("open");
+ command.arg(&url);
+ command
+ };
+
+ #[cfg(all(unix, not(target_os = "macos")))]
+ let mut command = {
+ let mut command = Command::new("xdg-open");
+ command.arg(&url);
+ command
+ };
+
+ command
+ .spawn()
+ .map(|_| ())
+ .map_err(|err| format!("Failed to open browser: {err}"))
+}
+
+fn main() {
+ tauri::Builder::default()
+ .manage(WalletState {
+ active_wallet: Mutex::new(None),
+ rpc_scheduler: WalletRpcScheduler::new(),
+ })
+ .on_window_event(|_, event| {
+ if matches!(event, tauri::WindowEvent::CloseRequested { .. }) {
+ clear_system_clipboard_now();
+ }
+ })
+ .invoke_handler(tauri::generate_handler![
+ get_app_status,
+ create_wallet,
+ list_wallets,
+ select_wallet_file,
+ select_private_key_image,
+ load_wallet,
+ import_private_key_wallet,
+ import_private_key_image_wallet,
+ lock_wallet,
+ list_broadcast_nodes,
+ read_gui_settings,
+ save_gui_settings,
+ select_settings_path,
+ backup_active_wallet_image,
+ backup_active_wallet_private_key,
+ printable_wallet_backup,
+ clear_system_clipboard,
+ open_external_url,
+ active_wallet,
+ get_active_wallet_balances,
+ check_wallet_registration,
+ register_active_wallet,
+ latest_address_transactions,
+ marketing_campaign_history,
+ paged_address_history,
+ transaction_by_txid,
+ token_list,
+ token_catalog,
+ nft_list,
+ nft_details,
+ fetch_ipfs_metadata,
+ issue_token_details,
+ current_block_height,
+ network_info,
+ read_local_transaction_cache,
+ write_local_transaction_cache,
+ read_local_transaction_index,
+ write_local_transaction_index,
+ read_local_transaction_record,
+ write_local_transaction_record,
+ read_nft_cache,
+ write_nft_cache,
+ prune_nft_cache,
+ test_broadcast_node_time,
+ clear_wallet_cache,
+ read_address_book,
+ write_address_book,
+ lookup_address_vanity,
+ check_vanity_address_availability,
+ save_history_export,
+ list_unbroadcast_transactions,
+ save_transfer_transaction,
+ broadcast_transfer_transaction,
+ save_create_token_transaction,
+ broadcast_create_token_transaction,
+ save_issue_token_transaction,
+ broadcast_issue_token_transaction,
+ save_create_nft_transaction,
+ broadcast_create_nft_transaction,
+ save_burn_transaction,
+ broadcast_burn_transaction,
+ save_marketing_transaction,
+ broadcast_marketing_transaction,
+ save_vanity_address_transaction,
+ broadcast_vanity_address_transaction,
+ save_swap_offer,
+ save_loan_offer,
+ active_loan_contracts,
+ loan_contracts,
+ save_loan_payment_transaction,
+ broadcast_loan_payment_transaction,
+ claimable_collateral_contracts,
+ save_collateral_claim_transaction,
+ broadcast_collateral_claim_transaction,
+ import_unbroadcast_transaction,
+ load_unbroadcast_transaction,
+ sign_unbroadcast_transaction,
+ broadcast_unbroadcast_transaction,
+ delete_unbroadcast_transaction
+ ])
+ .run(tauri::generate_context!())
+ .expect("error while running Contractless Wallet");
+}
diff --git a/src/wallet_app/commands_balance_registration.rs b/src/wallet_app/commands_balance_registration.rs
new file mode 100644
index 0000000..f42dad8
--- /dev/null
+++ b/src/wallet_app/commands_balance_registration.rs
@@ -0,0 +1,101 @@
+#[tauri::command]
+async fn get_active_wallet_balances(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ short_address,
+ RPC_ADDRESS_TOTAL_BALANCE as usize,
+ public_key,
+ private_key,
+ "Balance lookup failed",
+ )
+ .await?;
+
+ parse_balance_response(response)
+}
+
+#[tauri::command]
+async fn check_wallet_registration(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ short_address,
+ RPC_WALLET_REGISTRATION_STATUS as usize,
+ public_key,
+ private_key,
+ "Wallet registration status lookup failed",
+ )
+ .await?;
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ if response_text.starts_with("error:") {
+ return Err(response_text);
+ }
+
+ Ok(RegistrationStatusView {
+ registered: response_text == "1",
+ })
+}
+
+#[tauri::command]
+async fn register_active_wallet(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let short_address_bytes = Wallet::short_address_to_bytes(&short_address)
+ .ok_or_else(|| "Active wallet short address is invalid.".to_string())?;
+ let public_key_bytes = Wallet::normalize_saved_public_key_bytes(&public_key)
+ .ok_or_else(|| "Active wallet public key is invalid.".to_string())?;
+
+ let mut signed_payload =
+ Vec::with_capacity(1 + Wallet::SHORT_ADDRESS_BYTES_LENGTH + Wallet::PUBLIC_KEY_LENGTH);
+ signed_payload.push(RPC_REGISTER_WALLET);
+ signed_payload.extend_from_slice(&short_address_bytes);
+ signed_payload.extend_from_slice(&public_key_bytes);
+
+ let payload_hash = skein_256_hash_bytes(&signed_payload);
+ let signature = Wallet::sign_transaction(&payload_hash, &private_key).await;
+ let public_key_hex = encode(&public_key_bytes);
+ let command_input = format!("{short_address}|{public_key_hex}|{signature}");
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ RPC_REGISTER_WALLET as usize,
+ public_key,
+ private_key,
+ "Wallet registration failed",
+ )
+ .await?;
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ if response_text.starts_with("error:") {
+ return Err(response_text);
+ }
+
+ Ok(RegistrationStatusView {
+ registered: response_text == "1",
+ })
+}
+
diff --git a/src/wallet_app/commands_network_cache.rs b/src/wallet_app/commands_network_cache.rs
new file mode 100644
index 0000000..33ebda9
--- /dev/null
+++ b/src/wallet_app/commands_network_cache.rs
@@ -0,0 +1,603 @@
+#[tauri::command]
+async fn current_block_height(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_BLOCK_HEIGHT as usize,
+ public_key,
+ private_key,
+ "Block height lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.len() != 4 {
+ return Err("Block height response had an unexpected byte length.".to_string());
+ }
+
+ Ok(u32::from_le_bytes(response[0..4].try_into().map_err(
+ |_| "Failed to parse block height response.".to_string(),
+ )?))
+}
+
+#[tauri::command]
+async fn network_info(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_NETWORK_INFO as usize,
+ public_key,
+ private_key,
+ "Network info lookup failed",
+ )
+ .await?;
+
+ parse_network_info_response(response)
+}
+
+#[tauri::command]
+async fn test_broadcast_node_time(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_TIME as usize,
+ public_key,
+ private_key,
+ "Node time lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.len() != 4 {
+ return Err("Node time response had an unexpected byte length.".to_string());
+ }
+
+ Ok(u32::from_le_bytes(
+ response[0..4]
+ .try_into()
+ .map_err(|_| "Failed to parse node time response.".to_string())?,
+ ))
+}
+
+#[tauri::command]
+async fn read_local_transaction_cache(state: State<'_, WalletState>) -> Result {
+ let cache_path = active_wallet_cache_path(&state)?;
+ match read(&cache_path).await {
+ Ok(bytes) => String::from_utf8(bytes)
+ .map_err(|_| "Local transaction cache is not valid UTF-8.".to_string()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok("{}".to_string()),
+ Err(err) => Err(format!("Unable to read local transaction cache: {err}")),
+ }
+}
+
+#[tauri::command]
+async fn write_local_transaction_cache(
+ state: State<'_, WalletState>,
+ cache_json: String,
+) -> Result<(), String> {
+ let cache_path = active_wallet_cache_path(&state)?;
+ let parsed: JsonValue = serde_json::from_str(&cache_json)
+ .map_err(|err| format!("Transaction cache must be valid JSON: {err}"))?;
+ let normalized = serde_json::to_string_pretty(&parsed)
+ .map_err(|err| format!("Unable to serialize transaction cache: {err}"))?;
+
+ blockchain::tokio::fs::write(&cache_path, normalized)
+ .await
+ .map_err(|err| format!("Unable to write local transaction cache: {err}"))
+}
+
+#[tauri::command]
+async fn read_local_transaction_index(state: State<'_, WalletState>) -> Result {
+ let history_dir = active_wallet_history_dir(&state)?;
+ let index_path = history_dir.join("index.json");
+ match read(&index_path).await {
+ Ok(bytes) => String::from_utf8(bytes)
+ .map_err(|_| "Local transaction index is not valid UTF-8.".to_string()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok("{}".to_string()),
+ Err(err) => Err(format!("Unable to read local transaction index: {err}")),
+ }
+}
+
+#[tauri::command]
+async fn write_local_transaction_index(
+ state: State<'_, WalletState>,
+ index_json: String,
+) -> Result<(), String> {
+ let history_dir = active_wallet_history_dir(&state)?;
+ create_dir_all(&history_dir)
+ .await
+ .map_err(|err| format!("Unable to create transaction history directory: {err}"))?;
+ let parsed: JsonValue = serde_json::from_str(&index_json)
+ .map_err(|err| format!("Transaction index must be valid JSON: {err}"))?;
+ let normalized = serde_json::to_string_pretty(&parsed)
+ .map_err(|err| format!("Unable to serialize transaction index: {err}"))?;
+
+ blockchain::tokio::fs::write(history_dir.join("index.json"), normalized)
+ .await
+ .map_err(|err| format!("Unable to write local transaction index: {err}"))
+}
+
+#[tauri::command]
+async fn read_local_transaction_record(
+ state: State<'_, WalletState>,
+ file_name: String,
+) -> Result {
+ let history_dir = active_wallet_history_dir(&state)?;
+ let file_name = validate_transaction_record_file(&file_name)?;
+ match read(history_dir.join(file_name)).await {
+ Ok(bytes) => String::from_utf8(bytes)
+ .map_err(|_| "Local transaction record is not valid UTF-8.".to_string()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok("{}".to_string()),
+ Err(err) => Err(format!("Unable to read local transaction record: {err}")),
+ }
+}
+
+#[tauri::command]
+async fn write_local_transaction_record(
+ state: State<'_, WalletState>,
+ file_name: String,
+ record_json: String,
+) -> Result<(), String> {
+ let history_dir = active_wallet_history_dir(&state)?;
+ create_dir_all(&history_dir)
+ .await
+ .map_err(|err| format!("Unable to create transaction history directory: {err}"))?;
+ let file_name = validate_transaction_record_file(&file_name)?;
+ let parsed: JsonValue = serde_json::from_str(&record_json)
+ .map_err(|err| format!("Transaction record must be valid JSON: {err}"))?;
+ let normalized = serde_json::to_string_pretty(&parsed)
+ .map_err(|err| format!("Unable to serialize transaction record: {err}"))?;
+
+ blockchain::tokio::fs::write(history_dir.join(file_name), normalized)
+ .await
+ .map_err(|err| format!("Unable to write local transaction record: {err}"))
+}
+
+fn validate_nft_cache_key(nft_name: &str, series: u32) -> Result {
+ let name = nft_name.trim().to_ascii_lowercase();
+ if name.is_empty() {
+ return Err("NFT cache name cannot be empty.".to_string());
+ }
+ if !name
+ .bytes()
+ .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_' || byte == b'-')
+ {
+ return Err("NFT cache name contains unsupported characters.".to_string());
+ }
+ Ok(format!("{name}_{series}"))
+}
+
+fn nft_cache_record_from_parts(
+ detail: JsonValue,
+ metadata: JsonValue,
+ image_bytes: Option>,
+ image_mime: Option,
+) -> NftCacheRecordView {
+ let image_data_url = image_bytes.map(|bytes| {
+ let mime = image_mime
+ .filter(|value| value.starts_with("image/"))
+ .unwrap_or_else(|| "image/png".to_string());
+ format!("data:{mime};base64,{}", STANDARD.encode(bytes))
+ });
+
+ NftCacheRecordView {
+ detail,
+ metadata,
+ image_data_url,
+ }
+}
+
+async fn read_cached_nft_record(record_dir: &Path) -> Result {
+ let record_path = record_dir.join("record.json");
+ let record_bytes = read(&record_path)
+ .await
+ .map_err(|err| format!("Unable to read NFT cache record: {err}"))?;
+ let record: JsonValue = serde_json::from_slice(&record_bytes)
+ .map_err(|err| format!("NFT cache record is not valid JSON: {err}"))?;
+ let detail = record.get("detail").cloned().unwrap_or(JsonValue::Null);
+ let metadata = record.get("metadata").cloned().unwrap_or(JsonValue::Null);
+ let image_mime = record
+ .get("image_mime")
+ .and_then(|value| value.as_str())
+ .map(|value| value.to_string());
+ let image_bytes = match read(record_dir.join("image.bin")).await {
+ Ok(bytes) => Some(bytes),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
+ Err(err) => return Err(format!("Unable to read NFT cached image: {err}")),
+ };
+
+ Ok(nft_cache_record_from_parts(
+ detail,
+ metadata,
+ image_bytes,
+ image_mime,
+ ))
+}
+
+#[tauri::command]
+async fn read_nft_cache(
+ state: State<'_, WalletState>,
+ nft_name: String,
+ series: u32,
+) -> Result, String> {
+ let cache_dir = active_wallet_nft_dir(&state)?;
+ let key = validate_nft_cache_key(&nft_name, series)?;
+ let record_dir = cache_dir.join(key);
+ match read_cached_nft_record(&record_dir).await {
+ Ok(record) => Ok(Some(record)),
+ Err(err) if err.contains("os error 2") || err.contains("not find") => Ok(None),
+ Err(err) => Err(err),
+ }
+}
+
+#[tauri::command]
+async fn write_nft_cache(
+ state: State<'_, WalletState>,
+ nft_name: String,
+ series: u32,
+ detail_json: String,
+ metadata_json: String,
+ image_url: String,
+) -> Result {
+ let cache_dir = active_wallet_nft_dir(&state)?;
+ let key = validate_nft_cache_key(&nft_name, series)?;
+ let record_dir = cache_dir.join(key);
+ create_dir_all(&record_dir)
+ .await
+ .map_err(|err| format!("Unable to create NFT cache directory: {err}"))?;
+
+ let detail: JsonValue = serde_json::from_str(&detail_json)
+ .map_err(|err| format!("NFT detail cache must be valid JSON: {err}"))?;
+ let metadata: JsonValue = serde_json::from_str(&metadata_json)
+ .map_err(|err| format!("NFT metadata cache must be valid JSON: {err}"))?;
+
+ let mut image_mime = None;
+ let mut image_cached = false;
+ let image_url = image_url.trim();
+ if image_url.starts_with("http://")
+ || image_url.starts_with("https://")
+ || image_url.starts_with("data:image/")
+ {
+ if image_url.starts_with("data:image/") {
+ if let Some((header, encoded)) = image_url.split_once(',') {
+ image_mime = header
+ .strip_prefix("data:")
+ .and_then(|header| header.split_once(';').map(|(mime, _)| mime.to_string()));
+ if let Ok(bytes) = base64::Engine::decode(&STANDARD, encoded) {
+ if bytes.len() <= 10_000_000 {
+ blockchain::tokio::fs::write(record_dir.join("image.bin"), bytes)
+ .await
+ .map_err(|err| format!("Unable to write NFT cached image: {err}"))?;
+ image_cached = true;
+ }
+ }
+ }
+ } else {
+ let client = reqwest::Client::builder()
+ .timeout(Duration::from_secs(20))
+ .build()
+ .map_err(|err| format!("Failed to prepare NFT image request: {err}"))?;
+ let response = client
+ .get(image_url)
+ .send()
+ .await
+ .map_err(|err| format!("Failed to fetch NFT image: {err}"))?
+ .error_for_status()
+ .map_err(|err| format!("NFT image gateway returned an error: {err}"))?;
+ image_mime = response
+ .headers()
+ .get(reqwest::header::CONTENT_TYPE)
+ .and_then(|value| value.to_str().ok())
+ .map(|value| value.split(';').next().unwrap_or(value).to_string());
+ let bytes = response
+ .bytes()
+ .await
+ .map_err(|err| format!("Failed to read NFT image response: {err}"))?;
+ if bytes.len() <= 10_000_000 {
+ blockchain::tokio::fs::write(record_dir.join("image.bin"), &bytes)
+ .await
+ .map_err(|err| format!("Unable to write NFT cached image: {err}"))?;
+ image_cached = true;
+ }
+ }
+ }
+
+ let record = serde_json::json!({
+ "detail": detail,
+ "metadata": metadata,
+ "image_mime": image_mime,
+ "image_cached": image_cached,
+ });
+ let normalized = serde_json::to_string_pretty(&record)
+ .map_err(|err| format!("Unable to serialize NFT cache record: {err}"))?;
+ blockchain::tokio::fs::write(record_dir.join("record.json"), normalized)
+ .await
+ .map_err(|err| format!("Unable to write NFT cache record: {err}"))?;
+
+ read_cached_nft_record(&record_dir).await
+}
+
+#[tauri::command]
+async fn prune_nft_cache(
+ state: State<'_, WalletState>,
+ keep_keys: Vec,
+) -> Result<(), String> {
+ let cache_dir = active_wallet_nft_dir(&state)?;
+ let keep: std::collections::HashSet = keep_keys
+ .into_iter()
+ .map(|key| key.trim().to_ascii_lowercase())
+ .filter(|key| !key.is_empty())
+ .collect();
+
+ let mut entries = match read_dir(&cache_dir).await {
+ Ok(entries) => entries,
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+ Err(err) => return Err(format!("Unable to read NFT cache directory: {err}")),
+ };
+
+ while let Ok(Some(entry)) = entries.next_entry().await {
+ let file_type = match entry.file_type().await {
+ Ok(file_type) => file_type,
+ Err(_) => continue,
+ };
+ if !file_type.is_dir() {
+ continue;
+ }
+ let key = entry.file_name().to_string_lossy().to_ascii_lowercase();
+ if !keep.contains(&key) {
+ blockchain::tokio::fs::remove_dir_all(entry.path())
+ .await
+ .map_err(|err| format!("Unable to remove stale NFT cache entry: {err}"))?;
+ }
+ }
+
+ Ok(())
+}
+
+async fn remove_file_if_exists(path: &Path) -> Result<(), String> {
+ match remove_file(path).await {
+ Ok(_) => Ok(()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
+ Err(err) => Err(format!("Unable to remove {}: {err}", path.display())),
+ }
+}
+
+async fn remove_dir_if_exists(path: &Path) -> Result<(), String> {
+ match remove_dir_all(path).await {
+ Ok(_) => Ok(()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
+ Err(err) => Err(format!("Unable to remove {}: {err}", path.display())),
+ }
+}
+
+async fn clear_nft_cache_files(cache_dir: &Path, file_name: &str) -> Result<(), String> {
+ let mut entries = match read_dir(cache_dir).await {
+ Ok(entries) => entries,
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+ Err(err) => return Err(format!("Unable to read NFT cache directory: {err}")),
+ };
+
+ while let Ok(Some(entry)) = entries.next_entry().await {
+ let file_type = match entry.file_type().await {
+ Ok(file_type) => file_type,
+ Err(_) => continue,
+ };
+ if file_type.is_dir() {
+ remove_file_if_exists(&entry.path().join(file_name)).await?;
+ }
+ }
+
+ Ok(())
+}
+
+#[tauri::command]
+async fn clear_wallet_cache(state: State<'_, WalletState>, cache_kind: String) -> Result<(), String> {
+ match cache_kind.trim().to_ascii_lowercase().as_str() {
+ "history" => {
+ remove_file_if_exists(&active_wallet_cache_path(&state)?).await?;
+ remove_dir_if_exists(&active_wallet_history_dir(&state)?).await
+ }
+ "nft" | "nft_images" | "nft_media" => {
+ clear_nft_cache_files(&active_wallet_nft_dir(&state)?, "image.bin").await
+ }
+ "nft_details" => {
+ clear_nft_cache_files(&active_wallet_nft_dir(&state)?, "record.json").await
+ }
+ "address_book" => remove_file_if_exists(&active_wallet_address_book_path(&state)?).await,
+ _ => Err("Unknown cache type.".to_string()),
+ }
+}
+
+#[tauri::command]
+async fn read_address_book(state: State<'_, WalletState>) -> Result {
+ let address_book_path = active_wallet_address_book_path(&state)?;
+ match read(&address_book_path).await {
+ Ok(bytes) => String::from_utf8(bytes)
+ .map_err(|_| "Address book is not valid UTF-8.".to_string()),
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+ Ok("{\"entries\":{}}".to_string())
+ }
+ Err(err) => Err(format!("Unable to read address book: {err}")),
+ }
+}
+
+#[tauri::command]
+async fn write_address_book(
+ state: State<'_, WalletState>,
+ address_book_json: String,
+) -> Result<(), String> {
+ let address_book_path = active_wallet_address_book_path(&state)?;
+ let parsed: JsonValue = serde_json::from_str(&address_book_json)
+ .map_err(|err| format!("Address book must be valid JSON: {err}"))?;
+ let normalized = serde_json::to_string_pretty(&parsed)
+ .map_err(|err| format!("Unable to serialize address book: {err}"))?;
+
+ blockchain::tokio::fs::write(&address_book_path, normalized)
+ .await
+ .map_err(|err| format!("Unable to write address book: {err}"))
+}
+
+#[tauri::command]
+async fn lookup_address_vanity(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ address: String,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let owner_address = address.trim();
+ if owner_address.is_empty() {
+ return Err("Address cannot be empty.".to_string());
+ }
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ owner_address.to_string(),
+ RPC_VANITY_LOOKUP as usize,
+ public_key,
+ private_key,
+ "Vanity address lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ let vanity = String::from_utf8_lossy(&response).trim().to_string();
+ if vanity.is_empty() {
+ Ok(None)
+ } else {
+ Ok(Some(vanity))
+ }
+}
+
+#[tauri::command]
+async fn check_vanity_address_availability(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ vanity_name: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let vanity_address = vanity_address_for_wallet(&vanity_name, &short_address)?;
+ let display_vanity = display_vanity_address(&vanity_address)
+ .ok_or_else(|| "Failed to build vanity address display.".to_string())?;
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ vanity_address,
+ RPC_VANITY_OWNER_LOOKUP as usize,
+ public_key,
+ private_key,
+ "Vanity availability lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ let owner = String::from_utf8_lossy(&response).trim().to_string();
+ if owner.is_empty() {
+ Ok(VanityAvailabilityView {
+ vanity_address: display_vanity,
+ available: true,
+ owner: None,
+ })
+ } else {
+ Ok(VanityAvailabilityView {
+ vanity_address: display_vanity,
+ available: false,
+ owner: Some(owner),
+ })
+ }
+}
+
+#[tauri::command]
+async fn save_history_export(
+ default_file_name: String,
+ format: String,
+ contents: String,
+) -> Result, String> {
+ let extension = match format.trim().to_ascii_lowercase().as_str() {
+ "json" => "json",
+ "xml" => "xml",
+ "csv" => "csv",
+ _ => return Err("Export format must be json, xml, or csv.".to_string()),
+ };
+
+ let mut file_name = default_file_name.trim().to_string();
+ if file_name.is_empty() {
+ file_name = format!("contractless-history.{extension}");
+ }
+ if !file_name
+ .to_ascii_lowercase()
+ .ends_with(&format!(".{extension}"))
+ {
+ file_name.push('.');
+ file_name.push_str(extension);
+ }
+
+ let selected = FileDialog::new()
+ .set_filename(&file_name)
+ .add_filter(
+ match extension {
+ "json" => "JSON",
+ "xml" => "XML",
+ "csv" => "CSV",
+ _ => "Export",
+ },
+ &[extension],
+ )
+ .show_save_single_file()
+ .map_err(|err| format!("Unable to open export save dialog: {err}"))?;
+
+ let Some(mut path) = selected else {
+ return Ok(None);
+ };
+
+ if path.extension().is_none() {
+ path.set_extension(extension);
+ }
+
+ blockchain::tokio::fs::write(&path, contents)
+ .await
+ .map_err(|err| format!("Unable to save history export: {err}"))?;
+
+ Ok(Some(path.to_string_lossy().into_owned()))
+}
diff --git a/src/wallet_app/commands_transactions.rs b/src/wallet_app/commands_transactions.rs
new file mode 100644
index 0000000..28a2299
--- /dev/null
+++ b/src/wallet_app/commands_transactions.rs
@@ -0,0 +1,3976 @@
+#[tauri::command]
+async fn latest_address_transactions(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ limit: u32,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = format!("{short_address}|{limit}");
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ RPC_LATEST_ADDRESS_TRANSACTIONS as usize,
+ public_key,
+ private_key,
+ "Latest address transaction lookup failed",
+ )
+ .await?;
+
+ parse_latest_transaction_response(response)
+}
+
+#[tauri::command]
+async fn paged_address_history(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ skip: u32,
+ limit: u32,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = format!("{short_address}|{skip}|{limit}");
+
+ let response = background_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ RPC_ADDRESS_HISTORY as usize,
+ public_key,
+ private_key,
+ "Paged address history lookup failed",
+ )
+ .await?;
+
+ parse_latest_transaction_response(response)
+}
+
+fn parse_marketing_text(bytes: &[u8]) -> String {
+ String::from_utf8_lossy(bytes).trim().to_string()
+}
+
+fn parse_marketing_campaign_response(response: Vec) -> Result {
+ const ROW_BYTES: usize = 1 + 32 + 4 + 4 + 8 + 6 + 40 + 100 + 1 + 1 + 2 + 2;
+ const HEADER_BYTES: usize = 8 * 5 + 4;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.len() < HEADER_BYTES {
+ return Err("Marketing campaign response was truncated.".to_string());
+ }
+
+ let mut offset = 0usize;
+ let read_u64 = |bytes: &[u8], offset: &mut usize, label: &str| -> Result {
+ let value = u64::from_le_bytes(
+ bytes[*offset..*offset + 8]
+ .try_into()
+ .map_err(|_| format!("Failed to parse {label}."))?,
+ );
+ *offset += 8;
+ Ok(value)
+ };
+
+ let total_records = read_u64(&response, &mut offset, "campaign record count")?;
+ let total_impressions = read_u64(&response, &mut offset, "campaign impressions")?;
+ let total_clicks = read_u64(&response, &mut offset, "campaign clicks")?;
+ let total_impression_value = read_u64(&response, &mut offset, "campaign impression value")?;
+ let total_click_value = read_u64(&response, &mut offset, "campaign click value")?;
+ let row_count = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse campaign row count.".to_string())?,
+ ) as usize;
+ offset += 4;
+
+ let expected = HEADER_BYTES
+ .checked_add(
+ row_count
+ .checked_mul(ROW_BYTES)
+ .ok_or_else(|| "Marketing campaign response length overflowed.".to_string())?,
+ )
+ .ok_or_else(|| "Marketing campaign response length overflowed.".to_string())?;
+ if response.len() != expected {
+ return Err("Marketing campaign response had an unexpected byte length.".to_string());
+ }
+
+ let mut rows = Vec::with_capacity(row_count);
+ for _ in 0..row_count {
+ let status = match response[offset] {
+ 0 => "Pending",
+ 1 => "Mined",
+ _ => "Unknown",
+ }
+ .to_string();
+ offset += 1;
+
+ let txid = encode(&response[offset..offset + 32]);
+ offset += 32;
+ let block_height = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse campaign block height.".to_string())?,
+ );
+ offset += 4;
+ let time = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse campaign timestamp.".to_string())?,
+ );
+ offset += 4;
+ let campaign = u64::from_le_bytes(
+ response[offset..offset + 8]
+ .try_into()
+ .map_err(|_| "Failed to parse campaign id.".to_string())?,
+ );
+ offset += 8;
+ let ad_type = parse_marketing_text(&response[offset..offset + 6]);
+ offset += 6;
+ let keyword = parse_marketing_text(&response[offset..offset + 40]);
+ offset += 40;
+ let displayed = parse_marketing_text(&response[offset..offset + 100]);
+ offset += 100;
+ let impression = response[offset];
+ offset += 1;
+ let click = response[offset];
+ offset += 1;
+ let impression_value = u16::from_le_bytes(
+ response[offset..offset + 2]
+ .try_into()
+ .map_err(|_| "Failed to parse impression value.".to_string())?,
+ );
+ offset += 2;
+ let click_value = u16::from_le_bytes(
+ response[offset..offset + 2]
+ .try_into()
+ .map_err(|_| "Failed to parse click value.".to_string())?,
+ );
+ offset += 2;
+
+ rows.push(MarketingCampaignRowView {
+ status,
+ txid,
+ block_height: (block_height > 0).then_some(block_height),
+ time,
+ campaign: campaign.to_string(),
+ ad_type,
+ keyword,
+ displayed,
+ impression,
+ click,
+ impression_value,
+ click_value,
+ });
+ }
+
+ Ok(MarketingCampaignView {
+ total_records: total_records.to_string(),
+ total_impressions: total_impressions.to_string(),
+ total_clicks: total_clicks.to_string(),
+ total_impression_value: total_impression_value.to_string(),
+ total_click_value: total_click_value.to_string(),
+ rows,
+ })
+}
+
+#[tauri::command]
+async fn marketing_campaign_history(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ advertiser: String,
+ campaign: String,
+ skip: u32,
+ limit: u32,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let advertiser = advertiser.trim();
+ if advertiser.is_empty() {
+ return Err("Agency wallet address is required.".to_string());
+ }
+ let advertiser =
+ resolve_transaction_address(&state, &broadcast_node, advertiser, "Agency wallet").await?;
+ let campaign = campaign.trim();
+ if !campaign.bytes().all(|byte| byte.is_ascii_digit()) || campaign.is_empty() {
+ return Err("Campaign ID must be a whole number.".to_string());
+ }
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = format!("{advertiser}|{campaign}|{skip}|{limit}");
+
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ RPC_MARKETING_CAMPAIGN_HISTORY as usize,
+ public_key,
+ private_key,
+ "Marketing campaign lookup failed",
+ )
+ .await?;
+
+ parse_marketing_campaign_response(response)
+}
+
+#[tauri::command]
+async fn transaction_by_txid(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ txid: String,
+) -> Result {
+ transaction_by_txid_with_scheduler(state, broadcast_node, txid).await
+}
+
+async fn transaction_by_txid_with_scheduler(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ txid: String,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let normalized_txid = txid.trim().to_string();
+ let txid_bytes = blockchain::decode(&normalized_txid)
+ .map_err(|err| format!("Invalid transaction id: {err}"))?;
+ if txid_bytes.len() != 32 {
+ return Err("Transaction id must decode to 32 bytes.".to_string());
+ }
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+
+ let response = background_wallet_rpc(
+ &state,
+ socket_address,
+ normalized_txid.clone(),
+ RPC_TRANSACTION_BY_TXID as usize,
+ public_key,
+ private_key,
+ "Transaction lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.len() < 5 {
+ return Err("Transaction lookup response had an unexpected byte length.".to_string());
+ }
+
+ let block_height = u32::from_le_bytes(
+ response[0..4]
+ .try_into()
+ .map_err(|_| "Failed to read transaction block height.".to_string())?,
+ );
+ let transaction_bytes = response[4..].to_vec();
+ let transaction_type = *transaction_bytes
+ .first()
+ .ok_or_else(|| "Transaction lookup response did not include a transaction.".to_string())?;
+ let transaction = decode_transaction_json(&transaction_bytes).await?;
+
+ Ok(TransactionBytesView {
+ txid: normalized_txid,
+ block_height,
+ transaction_type,
+ transaction,
+ transaction_bytes,
+ })
+}
+
+#[tauri::command]
+async fn token_list(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_TOKEN_LIST as usize,
+ public_key,
+ private_key,
+ "Token list lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ const TOKEN_LIST_ROW_BYTES: usize = 15 + 64;
+ if response.len() % TOKEN_LIST_ROW_BYTES != 0 {
+ return Err("Token list response had an unexpected byte length.".to_string());
+ }
+
+ let mut tokens = Vec::new();
+ for chunk in response.chunks_exact(TOKEN_LIST_ROW_BYTES) {
+ let ticker = String::from_utf8_lossy(&chunk[0..15]).trim().to_string();
+ if ticker.is_empty() {
+ continue;
+ }
+ tokens.push(TokenListItemView {
+ ticker,
+ origin_txid: String::from_utf8_lossy(&chunk[15..79]).trim().to_string(),
+ });
+ }
+
+ tokens.sort_by(|left, right| {
+ left.ticker
+ .to_ascii_lowercase()
+ .cmp(&right.ticker.to_ascii_lowercase())
+ });
+ Ok(tokens)
+}
+
+#[tauri::command]
+async fn token_catalog(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_TOKEN_CATALOG as usize,
+ public_key,
+ private_key,
+ "Token catalog lookup failed",
+ )
+ .await?;
+
+ parse_token_catalog_response(&response)
+}
+
+fn parse_token_catalog_response(response: &[u8]) -> Result, String> {
+ if let Some(error) = parse_error_response(response) {
+ return Err(error);
+ }
+ if response.len() < 4 {
+ return Err("Token catalog response had an unexpected byte length.".to_string());
+ }
+ const TOKEN_CATALOG_ROW_BYTES: usize =
+ 15 + 32 + Wallet::SHORT_ADDRESS_BYTES_LENGTH + 4 + 8 + 8 + 8 + 4 + 1;
+ let count = u32::from_le_bytes(
+ response[0..4]
+ .try_into()
+ .map_err(|_| "Failed to parse token catalog count.".to_string())?,
+ ) as usize;
+ let expected_len = 4usize
+ .checked_add(
+ count
+ .checked_mul(TOKEN_CATALOG_ROW_BYTES)
+ .ok_or_else(|| "Token catalog response length overflowed.".to_string())?,
+ )
+ .ok_or_else(|| "Token catalog response length overflowed.".to_string())?;
+ if response.len() != expected_len {
+ return Err("Token catalog response row count did not match payload size.".to_string());
+ }
+
+ let mut offset = 4usize;
+ let mut tokens = Vec::with_capacity(count);
+ for _ in 0..count {
+ let ticker = String::from_utf8_lossy(&response[offset..offset + 15])
+ .trim()
+ .to_string();
+ offset += 15;
+
+ let origin_txid = encode(&response[offset..offset + 32]);
+ offset += 32;
+
+ let creator =
+ Wallet::bytes_to_short_address(&response[offset..offset + Wallet::SHORT_ADDRESS_BYTES_LENGTH])
+ .unwrap_or_default();
+ offset += Wallet::SHORT_ADDRESS_BYTES_LENGTH;
+
+ let created_timestamp = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse token created timestamp.".to_string())?,
+ );
+ offset += 4;
+
+ let initial_supply = u64::from_le_bytes(
+ response[offset..offset + 8]
+ .try_into()
+ .map_err(|_| "Failed to parse token initial supply.".to_string())?,
+ );
+ offset += 8;
+
+ let current_supply = u64::from_le_bytes(
+ response[offset..offset + 8]
+ .try_into()
+ .map_err(|_| "Failed to parse token current supply.".to_string())?,
+ );
+ offset += 8;
+
+ let total_burned = u64::from_le_bytes(
+ response[offset..offset + 8]
+ .try_into()
+ .map_err(|_| "Failed to parse token burned supply.".to_string())?,
+ );
+ offset += 8;
+
+ let holder_count = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse token holder count.".to_string())?,
+ );
+ offset += 4;
+
+ let hard_limit = response[offset] == 1;
+ offset += 1;
+
+ if !ticker.is_empty() {
+ tokens.push(TokenCatalogItemView {
+ ticker,
+ origin_txid,
+ creator,
+ created_timestamp,
+ initial_supply: initial_supply.to_string(),
+ current_supply: current_supply.to_string(),
+ total_burned: total_burned.to_string(),
+ holder_count,
+ hard_limit,
+ });
+ }
+ }
+
+ Ok(tokens)
+}
+
+#[tauri::command]
+async fn nft_list(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ ensure_gui_settings_file().await?;
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ String::new(),
+ RPC_NFT_LIST as usize,
+ public_key,
+ private_key,
+ "NFT list lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ const NFT_LIST_ROW_BYTES: usize = 32 + 15 + 4;
+ if response.len() % NFT_LIST_ROW_BYTES != 0 {
+ return Err("NFT list response had an unexpected byte length.".to_string());
+ }
+
+ let mut nfts = Vec::new();
+ for chunk in response.chunks_exact(NFT_LIST_ROW_BYTES) {
+ let origin_txid = encode(&chunk[0..32]);
+ let nft_name = String::from_utf8_lossy(&chunk[32..47]).trim().to_string();
+ let series = u32::from_le_bytes(
+ chunk[47..51]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT series.".to_string())?,
+ );
+ if nft_name.is_empty() {
+ continue;
+ }
+ nfts.push(NftListItemView {
+ nft_name,
+ series,
+ origin_txid,
+ });
+ }
+
+ nfts.sort_by(|left, right| {
+ left.nft_name
+ .to_ascii_lowercase()
+ .cmp(&right.nft_name.to_ascii_lowercase())
+ .then(left.series.cmp(&right.series))
+ });
+ Ok(nfts)
+}
+
+fn nft_history_action_name(action: u8) -> &'static str {
+ match action {
+ 1 => "Create",
+ 2 => "Transfer",
+ 3 => "Swap",
+ 4 => "Loan Locked",
+ 5 => "Loan Payment",
+ 6 => "Collateral Claimed",
+ 7 => "Loan Issued",
+ 8 => "Burned",
+ _ => "Unknown",
+ }
+}
+
+fn decode_nft_wallet_field(bytes: &[u8]) -> String {
+ if bytes.iter().all(|byte| *byte == 0) {
+ String::new()
+ } else {
+ Wallet::bytes_to_short_address(bytes).unwrap_or_default()
+ }
+}
+
+fn normalize_ipfs_path(value: &str) -> String {
+ let mut path = value.trim();
+ loop {
+ let next = path
+ .strip_prefix("ipfs://")
+ .or_else(|| path.strip_prefix("ipfs:/"))
+ .or_else(|| path.strip_prefix("ipfs:"))
+ .or_else(|| path.strip_prefix("/ipfs/"))
+ .or_else(|| path.strip_prefix("ipfs/"))
+ .unwrap_or(path)
+ .trim_start_matches('/');
+ if next == path {
+ return next.to_string();
+ }
+ path = next;
+ }
+}
+
+fn format_nft_metadata_uri(item_ipfs: &str, series: u32) -> String {
+ let item_ipfs = item_ipfs.trim();
+ if item_ipfs.starts_with("http://") || item_ipfs.starts_with("https://") {
+ return item_ipfs.to_string();
+ }
+
+ let path = normalize_ipfs_path(item_ipfs);
+ if path.is_empty() {
+ return String::new();
+ }
+
+ if series > 0 && !path.ends_with(".json") {
+ format!("ipfs://{}/metadata/{series}.json", path.trim_end_matches('/'))
+ } else {
+ format!("ipfs://{path}")
+ }
+}
+
+fn parse_nft_details_response(response: &[u8]) -> Result {
+ const NFT_NAME_BYTES: usize = 15;
+ const SERIES_BYTES: usize = 4;
+ const GENESIS_HASH_BYTES: usize = 32;
+ const CREATOR_BYTES: usize = Wallet::SHORT_ADDRESS_BYTES_LENGTH;
+ const IPFS_BYTES: usize = 100;
+ const HOLDER_BYTES: usize = Wallet::SHORT_ADDRESS_BYTES_LENGTH;
+ const HISTORY_COUNT_BYTES: usize = 4;
+ const HISTORY_ENTRY_SIZE: usize =
+ 32 + 4 + 1 + 1 + (2 * Wallet::SHORT_ADDRESS_BYTES_LENGTH) + 15 + 4 + 8;
+ const FIXED_BYTES: usize = NFT_NAME_BYTES
+ + SERIES_BYTES
+ + GENESIS_HASH_BYTES
+ + CREATOR_BYTES
+ + IPFS_BYTES
+ + HOLDER_BYTES
+ + HISTORY_COUNT_BYTES;
+
+ if response.len() < FIXED_BYTES {
+ return Err("NFT details response was too short.".to_string());
+ }
+
+ let mut offset = 0usize;
+ let nft_name = String::from_utf8_lossy(&response[offset..offset + NFT_NAME_BYTES])
+ .trim()
+ .to_string();
+ offset += NFT_NAME_BYTES;
+
+ let series = u32::from_le_bytes(
+ response[offset..offset + SERIES_BYTES]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT series.".to_string())?,
+ );
+ offset += SERIES_BYTES;
+
+ let genesis_txid = encode(&response[offset..offset + GENESIS_HASH_BYTES]);
+ offset += GENESIS_HASH_BYTES;
+
+ let creator = Wallet::bytes_to_short_address(&response[offset..offset + CREATOR_BYTES])
+ .unwrap_or_default();
+ offset += CREATOR_BYTES;
+
+ let item_ipfs = String::from_utf8_lossy(&response[offset..offset + IPFS_BYTES])
+ .trim()
+ .to_string();
+ offset += IPFS_BYTES;
+
+ let current_holder = decode_nft_wallet_field(&response[offset..offset + HOLDER_BYTES]);
+ offset += HOLDER_BYTES;
+
+ let history_count = u32::from_le_bytes(
+ response[offset..offset + HISTORY_COUNT_BYTES]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT history count.".to_string())?,
+ );
+ offset += HISTORY_COUNT_BYTES;
+
+ let mut history = Vec::new();
+ while offset + HISTORY_ENTRY_SIZE <= response.len() {
+ let entry = &response[offset..offset + HISTORY_ENTRY_SIZE];
+ let txid = encode(&entry[0..32]);
+ let block = u32::from_le_bytes(
+ entry[32..36]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT history block.".to_string())?,
+ );
+ let txtype = entry[36];
+ let action = nft_history_action_name(entry[37]).to_string();
+ let from = decode_nft_wallet_field(&entry[38..60]);
+ let to = decode_nft_wallet_field(&entry[60..82]);
+ let received_asset = String::from_utf8_lossy(&entry[82..97]).trim().to_string();
+ let received_series = u32::from_le_bytes(
+ entry[97..101]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT history received series.".to_string())?,
+ );
+ let received_value = u64::from_le_bytes(
+ entry[101..109]
+ .try_into()
+ .map_err(|_| "Failed to parse NFT history received value.".to_string())?,
+ )
+ .to_string();
+
+ history.push(NftHistoryEntryView {
+ txid,
+ block,
+ txtype,
+ action,
+ from,
+ to,
+ received_asset,
+ received_series,
+ received_value,
+ });
+ offset += HISTORY_ENTRY_SIZE;
+ }
+
+ let metadata_uri = format_nft_metadata_uri(&item_ipfs, series);
+ let asset_name = if series > 0 {
+ format!("{nft_name}_{series}")
+ } else {
+ nft_name.clone()
+ };
+
+ Ok(NftDetailsView {
+ nft_name,
+ series,
+ asset_name,
+ genesis_txid,
+ creator,
+ item_ipfs,
+ metadata_uri,
+ current_holder,
+ history_count,
+ history,
+ })
+}
+
+#[tauri::command]
+async fn nft_details(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ nft_name: String,
+ series: u32,
+) -> Result {
+ ensure_gui_settings_file().await?;
+
+ let nft_name = nft_name.trim();
+ if nft_name.is_empty() {
+ return Err("NFT name cannot be empty.".to_string());
+ }
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ format!("{nft_name}|{series}"),
+ RPC_NFT_DETAILS as usize,
+ public_key,
+ private_key,
+ "NFT details lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ parse_nft_details_response(&response)
+}
+
+fn gateway_url_for_ipfs_path(gateway: &str, ipfs_path: &str) -> Result {
+ let gateway = gateway.trim();
+ let gateway = if gateway.is_empty() {
+ "https://gateway.pinata.cloud/ipfs/"
+ } else {
+ gateway
+ };
+ if !gateway.starts_with("https://") && !gateway.starts_with("http://") {
+ return Err("IPFS gateway must start with http:// or https://.".to_string());
+ }
+
+ let path = ipfs_path.trim();
+ if path.starts_with("https://") || path.starts_with("http://") {
+ return Ok(path.to_string());
+ }
+
+ let path = normalize_ipfs_path(path);
+ if path.is_empty() {
+ return Err("IPFS metadata path cannot be empty.".to_string());
+ }
+
+ Ok(format!("{}/{}", gateway.trim_end_matches('/'), path))
+}
+
+#[tauri::command]
+async fn fetch_ipfs_metadata(ipfs_path: String, gateway: String) -> Result {
+ let url = gateway_url_for_ipfs_path(&gateway, &ipfs_path)?;
+ let client = reqwest::Client::builder()
+ .timeout(Duration::from_secs(15))
+ .build()
+ .map_err(|err| format!("Failed to prepare metadata request: {err}"))?;
+ let response = client
+ .get(&url)
+ .send()
+ .await
+ .map_err(|err| format!("Failed to fetch NFT metadata: {err}"))?
+ .error_for_status()
+ .map_err(|err| format!("NFT metadata gateway returned an error: {err}"))?;
+ let text = response
+ .text()
+ .await
+ .map_err(|err| format!("Failed to read NFT metadata response: {err}"))?;
+ if text.len() > 1_000_000 {
+ return Err("NFT metadata response is too large.".to_string());
+ }
+ serde_json::from_str(&text).map_err(|err| format!("NFT metadata was not valid JSON: {err}"))
+}
+
+async fn lookup_issue_token_details(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+ ticker: &str,
+) -> Result {
+ const TOKEN_NAME_BYTES: usize = 15;
+ const TOKEN_HASH_BYTES: usize = 32;
+ const TOKEN_COUNT_BYTES: usize = 8;
+ const TOKEN_SPREAD_BYTES: usize = 4;
+
+ let ticker = padded_token_ticker(ticker)?;
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (active_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ ticker.clone(),
+ RPC_TOKEN_DETAILS as usize,
+ public_key,
+ private_key,
+ "Token details lookup failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ let creator_offset = TOKEN_NAME_BYTES + TOKEN_HASH_BYTES;
+ let creator_end = creator_offset + Wallet::SHORT_ADDRESS_BYTES_LENGTH;
+ let hard_limit_offset = creator_end + TOKEN_COUNT_BYTES + TOKEN_SPREAD_BYTES;
+ let creator_bytes = response
+ .get(creator_offset..creator_end)
+ .ok_or_else(|| "Token details response was truncated before creator.".to_string())?;
+ let creator = Wallet::bytes_to_short_address(creator_bytes)
+ .ok_or_else(|| "Token details response contained an invalid creator.".to_string())?;
+ let hard_limit = *response
+ .get(hard_limit_offset)
+ .ok_or_else(|| "Token details response was truncated before cap policy.".to_string())?
+ == 1;
+
+ let (eligible, reason) = if creator.trim() != active_address.trim() {
+ (
+ false,
+ "Only the original token creator can issue more tokens.".to_string(),
+ )
+ } else if hard_limit {
+ (
+ false,
+ "This token has a hard cap and cannot issue more tokens.".to_string(),
+ )
+ } else {
+ (true, "Additional issuance is allowed.".to_string())
+ };
+
+ Ok(IssueTokenDetailsView {
+ ticker: ticker.trim().to_string(),
+ creator,
+ hard_limit,
+ eligible,
+ reason,
+ })
+}
+
+#[tauri::command]
+async fn issue_token_details(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ ticker: String,
+) -> Result {
+ lookup_issue_token_details(&state, &broadcast_node, &ticker).await
+}
+
+fn unbroadcast_type_name(txtype: u8) -> &'static str {
+ match txtype {
+ 2 => "Transfer",
+ 3 => "Create Token",
+ 4 => "Create NFT",
+ 5 => "Marketing",
+ 6 => "Swap",
+ 7 => "Loan",
+ 8 => "Loan Payment",
+ 9 => "Collateral Claim",
+ 10 => "Burn",
+ 11 => "Issue Token",
+ 12 => "Vanity Address",
+ _ => "Unknown",
+ }
+}
+
+fn json_u64(transaction: &JsonValue, field: &str) -> Result {
+ transaction
+ .get(field)
+ .and_then(|value| value.as_u64())
+ .ok_or_else(|| format!("Missing or invalid {field}."))
+}
+
+fn json_u32(transaction: &JsonValue, primary: &str, fallback: &str) -> Result {
+ transaction
+ .get(primary)
+ .and_then(|value| value.as_u64())
+ .or_else(|| transaction.get(fallback).and_then(|value| value.as_u64()))
+ .map(|value| value as u32)
+ .ok_or_else(|| format!("Missing or invalid {primary}."))
+}
+
+fn json_u8(transaction: &JsonValue, field: &str) -> Result {
+ json_u64(transaction, field).map(|value| value as u8)
+}
+
+fn json_u16(transaction: &JsonValue, field: &str) -> Result {
+ json_u64(transaction, field).map(|value| value as u16)
+}
+
+fn json_str(transaction: &JsonValue, field: &str) -> Result {
+ transaction
+ .get(field)
+ .and_then(|value| value.as_str())
+ .map(|value| value.to_string())
+ .ok_or_else(|| format!("Missing or invalid {field}."))
+}
+
+fn optional_string(transaction: &JsonValue, field: &str) -> String {
+ transaction
+ .get(field)
+ .and_then(|value| value.as_str())
+ .unwrap_or_default()
+ .trim()
+ .to_string()
+}
+
+fn valid_signature(signature: &str) -> bool {
+ blockchain::decode(signature).is_ok_and(|bytes| bytes.len() == Wallet::SIGNATURE_LENGTH)
+}
+
+fn parse_atomic_u64(value: &str, field: &str) -> Result {
+ value
+ .trim()
+ .parse::()
+ .map_err(|_| format!("{field} must be an unsigned atomic value."))
+}
+
+fn padded_coin_field(coin: &str) -> Result {
+ let trimmed = coin.trim();
+ if trimmed.is_empty() {
+ return Err("Transfer asset cannot be empty.".to_string());
+ }
+ if trimmed.eq_ignore_ascii_case(BASECOIN.trim()) {
+ return Ok(BASECOIN.clone());
+ }
+ blockchain::common::asset_names::padded_normalized_asset_input(trimmed)
+ .ok_or_else(|| "Transfer asset must normalize to 3-15 alphanumeric characters.".to_string())
+}
+
+fn padded_token_ticker(ticker: &str) -> Result {
+ let trimmed = ticker.trim();
+ blockchain::common::asset_names::padded_normalized_asset_input(trimmed)
+ .ok_or_else(|| "Token ticker must normalize to 3-15 alphanumeric characters.".to_string())
+}
+
+fn padded_fixed_field(value: &str, width: usize, field: &str) -> Result {
+ let trimmed = value.trim();
+ if trimmed.is_empty() {
+ return Err(format!("{field} cannot be empty."));
+ }
+ if !trimmed.is_ascii() {
+ return Err(format!("{field} must contain ASCII characters only."));
+ }
+ if trimmed.len() > width {
+ return Err(format!("{field} cannot exceed {width} characters."));
+ }
+ Ok(format!("{trimmed: Result {
+ let trimmed = value.trim();
+ if !trimmed.is_ascii() {
+ return Err(format!("{field} must contain ASCII characters only."));
+ }
+ if trimmed.len() > width {
+ return Err(format!("{field} cannot exceed {width} characters."));
+ }
+ Ok(format!("{trimmed: Result {
+ match value.trim().to_ascii_lowercase().as_str() {
+ "banner" => Ok("banner".to_string()),
+ "social" => Ok("social".to_string()),
+ "text" => Ok(format!("{:<6}", "text")),
+ _ => Err("Marketing ad type must be banner, social, or text.".to_string()),
+ }
+}
+
+fn vanity_address_for_wallet(vanity_name: &str, owner_address: &str) -> Result {
+ let trimmed = vanity_name.trim();
+ if trimmed.is_empty() || trimmed.len() > Wallet::SHORT_ADDRESS_HASH_BYTES_LENGTH {
+ return Err("Vanity name must be 1-20 letters.".to_string());
+ }
+ if !trimmed.chars().all(|ch| ch.is_ascii_alphabetic()) {
+ return Err("Vanity name can only contain letters.".to_string());
+ }
+ let address_bytes = Wallet::short_address_to_bytes(owner_address)
+ .ok_or_else(|| "Active wallet short address is invalid.".to_string())?;
+ let network_byte = address_bytes
+ .last()
+ .copied()
+ .ok_or_else(|| "Could not determine wallet network.".to_string())?;
+ let network_suffix = Wallet::map_byte_to_wallet(network_byte).to_ascii_lowercase();
+ if network_suffix.is_empty() {
+ return Err("Could not determine wallet network.".to_string());
+ }
+ let padded_payload = format!(
+ "{:>width$}",
+ trimmed.to_ascii_lowercase(),
+ width = Wallet::SHORT_ADDRESS_HASH_BYTES_LENGTH
+ );
+ let vanity_address = format!("{padded_payload}.{network_suffix}");
+ if Wallet::vanity_address_to_bytes(&vanity_address).is_none() {
+ return Err("Failed to build vanity address.".to_string());
+ }
+ Ok(vanity_address)
+}
+
+fn display_vanity_address(vanity_address: &str) -> Option {
+ let (payload, network_suffix) = vanity_address.rsplit_once('.')?;
+ let trimmed_payload = payload.trim_start();
+ if trimmed_payload.is_empty() {
+ return None;
+ }
+ Some(format!("{trimmed_payload}.{network_suffix}"))
+}
+
+async fn persist_active_wallet_vanity_address(
+ state: &State<'_, WalletState>,
+ transaction: &JsonValue,
+) {
+ let txtype = transaction
+ .get("txtype")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u8;
+ if txtype != 12 {
+ return;
+ }
+
+ let Some(vanity_address) = transaction.get("vanity_address").and_then(|value| value.as_str())
+ else {
+ return;
+ };
+ let Some(owner_address) = transaction.get("address").and_then(|value| value.as_str()) else {
+ return;
+ };
+ let Some(display_vanity) = display_vanity_address(vanity_address) else {
+ return;
+ };
+
+ let wallet_path = {
+ let Ok(mut guard) = state.active_wallet.lock() else {
+ return;
+ };
+ let Some(active_wallet) = guard.as_mut() else {
+ return;
+ };
+ if active_wallet.wallet.saved.short_address.trim() != owner_address.trim() {
+ return;
+ }
+ active_wallet.wallet.saved.vanity_address = Some(display_vanity.clone());
+ active_wallet.wallet_path.clone()
+ };
+
+ let Ok(wallet_bytes) = read(&wallet_path).await else {
+ return;
+ };
+ let Ok(mut saved_wallet) = blockchain::from_slice::(&wallet_bytes) else {
+ return;
+ };
+ if saved_wallet.short_address.trim() != owner_address.trim() {
+ return;
+ }
+ saved_wallet.vanity_address = Some(display_vanity);
+ saved_wallet.save_the_wallet(Path::new(&wallet_path)).await;
+}
+
+async fn resolve_transaction_address(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+ address: &str,
+ field: &str,
+) -> Result {
+ let trimmed = address.trim();
+ if let Some(normalized) = Wallet::normalize_to_short_address(trimmed) {
+ if Wallet::short_address_to_bytes(&normalized).is_some() {
+ return Ok(normalized);
+ }
+ }
+ let canonical_vanity =
+ blockchain::standalone_tools::vanity_resolver::canonical_vanity_address_input(trimmed)
+ .ok_or_else(|| format!("{field} must be a valid short or vanity address."))?;
+
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ canonical_vanity,
+ RPC_VANITY_OWNER_LOOKUP as usize,
+ public_key,
+ private_key,
+ "Vanity address lookup failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.is_empty() {
+ return Err(format!("{field} vanity address is not registered."));
+ }
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ Wallet::normalize_to_short_address(&response_text)
+ .filter(|resolved| Wallet::short_address_to_bytes(resolved).is_some())
+ .ok_or_else(|| format!("{field} vanity lookup returned an invalid short address."))
+}
+
+async fn active_wallet_signing_parts(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+) -> Result<(String, String), String> {
+ let settings = read_gui_settings().await?;
+ let (
+ _wallet_name,
+ _wallet_path,
+ active_short_address,
+ _vanity,
+ _public_key,
+ active_private_key,
+ ) = active_wallet_snapshot(state)?;
+
+ if !settings.require_key_before_signing {
+ return Ok((active_short_address, active_private_key));
+ }
+
+ let wallet_key = wallet_key.unwrap_or_default().trim().to_string();
+ if wallet_key.is_empty() {
+ return Err("Wallet encryption key is required before signing.".to_string());
+ }
+
+ let (_wallet_name, verified_short_address, _vanity, _public_key, verified_private_key) =
+ verified_private_key_from_active_wallet(state, wallet_key).await?;
+ if verified_short_address.trim() != active_short_address.trim() {
+ return Err("Wallet encryption key did not unlock the active wallet.".to_string());
+ }
+
+ Ok((active_short_address, verified_private_key))
+}
+
+async fn build_transfer_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ receiver: String,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let (sender, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let receiver =
+ resolve_transaction_address(state, &broadcast_node, &receiver, "Receiver").await?;
+ if receiver.trim().eq_ignore_ascii_case(sender.trim()) {
+ return Err("Receiver cannot be the active wallet address.".to_string());
+ }
+
+ let coin = padded_coin_field(&coin)?;
+ let mut value = parse_atomic_u64(&value, "Transfer value")?;
+ let txfee = parse_atomic_u64(&txfee, "Transfer fee")?;
+ if value == 0 {
+ return Err("Transfer value must be greater than zero.".to_string());
+ }
+ if nft_series > 0 {
+ value = 1;
+ }
+
+ let is_base_coin = coin.trim().eq_ignore_ascii_case(BASECOIN.trim());
+ let minimum_fee = minimum_transfer_fee(value, is_base_coin);
+ if txfee < minimum_fee {
+ return Err(format!(
+ "Transfer transaction fee is below the minimum required fee of {minimum_fee}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_transfer = UnsignedTransferTransaction::new(
+ 2, timestamp, value, &coin, nft_series, &sender, &receiver, txfee,
+ )
+ .await;
+ let transfer = TransferTransaction::new(unsigned_transfer.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign transfer transaction: {err}"))?;
+ let hash = unsigned_transfer.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 2,
+ "timestamp": timestamp,
+ "value": value,
+ "coin": coin,
+ "nft_series": nft_series,
+ "sender": sender,
+ "receiver": receiver,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": transfer.signature,
+ }))
+}
+
+async fn build_create_token_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ ticker: String,
+ number: String,
+ allow_more: bool,
+ txfee: String,
+) -> Result {
+ let (creator, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let ticker = padded_token_ticker(&ticker)?;
+ if ticker.trim().eq_ignore_ascii_case(BASECOIN.trim()) {
+ return Err("Token ticker is reserved for the base coin.".to_string());
+ }
+
+ let number = parse_atomic_u64(&number, "Token amount")?;
+ if number == 0 {
+ return Err("Token amount must be greater than zero.".to_string());
+ }
+
+ let txfee = parse_atomic_u64(&txfee, "Create token fee")?;
+ if txfee < CREATE_TOKEN_FEE {
+ return Err(format!(
+ "Create token fee is below the minimum required fee of {CREATE_TOKEN_FEE}."
+ ));
+ }
+
+ let hard_limit = if allow_more { 0 } else { 1 };
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_create_token = UnsignedCreateTokenTransaction::new(
+ 3, timestamp, &creator, &ticker, number, hard_limit, txfee,
+ )
+ .await;
+ let create_token = CreateTokenTransaction::new(unsigned_create_token.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign create-token transaction: {err}"))?;
+ let hash = unsigned_create_token.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 3,
+ "timestamp": timestamp,
+ "creator": creator,
+ "ticker": ticker,
+ "number": number,
+ "hard_limit": hard_limit,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": create_token.signature,
+ }))
+}
+
+async fn build_create_nft_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ series: u8,
+ nft_name: String,
+ item_ipfs: String,
+ count: u32,
+ description: String,
+ txfee: String,
+) -> Result {
+ let (creator, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ if series > 1 {
+ return Err("NFT type must be standalone or collection.".to_string());
+ }
+ if series == 0 && count != 1 {
+ return Err("A standalone NFT must have a count of 1.".to_string());
+ }
+ if series == 1 && count < 2 {
+ return Err("An NFT collection must contain at least 2 items.".to_string());
+ }
+
+ let nft_name = padded_token_ticker(&nft_name)
+ .map_err(|_| "NFT name must normalize to 3-15 alphanumeric characters.".to_string())?;
+ if nft_name.trim().eq_ignore_ascii_case(BASECOIN.trim()) {
+ return Err("NFT name is reserved for the base coin.".to_string());
+ }
+
+ let item_ipfs = item_ipfs.trim();
+ if blockchain::Cid::try_from(item_ipfs).is_err() {
+ return Err("Enter a valid IPFS CID.".to_string());
+ }
+ let item_ipfs = padded_fixed_field(item_ipfs, 100, "IPFS CID")?;
+ let description = padded_optional_fixed_field(&description, 100, "NFT description")?;
+
+ let txfee = parse_atomic_u64(&txfee, "Create NFT fee")?;
+ if txfee < CREATE_NFT_FEE {
+ return Err(format!(
+ "Create NFT fee is below the minimum required fee of {CREATE_NFT_FEE}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_create_nft = UnsignedCreateNftTransaction::new(
+ 4,
+ timestamp,
+ &creator,
+ series,
+ &nft_name,
+ &item_ipfs,
+ count,
+ &description,
+ txfee,
+ )
+ .await;
+ let create_nft = CreateNftTransaction::new(unsigned_create_nft.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign create-NFT transaction: {err}"))?;
+ let hash = unsigned_create_nft.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 4,
+ "timestamp": timestamp,
+ "creator": creator,
+ "series": series,
+ "nft_name": nft_name,
+ "item_ipfs": item_ipfs,
+ "count": count,
+ "desc": description,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": create_nft.signature,
+ }))
+}
+
+async fn build_burn_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let (address, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let coin = padded_token_ticker(&coin)
+ .map_err(|_| "Burn asset must normalize to 3-15 alphanumeric characters.".to_string())?;
+ if coin.trim().eq_ignore_ascii_case(BASECOIN.trim()) {
+ return Err("Base coin cannot be burned.".to_string());
+ }
+
+ let mut value = parse_atomic_u64(&value, "Burn amount")?;
+ if value == 0 {
+ return Err("Burn amount must be greater than zero.".to_string());
+ }
+ if nft_series > 0 {
+ value = 100_000_000;
+ }
+
+ let txfee = parse_atomic_u64(&txfee, "Burn fee")?;
+ if txfee < BURN_FEE {
+ return Err(format!(
+ "Burn transaction fee is below the minimum required fee of {BURN_FEE}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_burn =
+ UnsignedBurnTransaction::new(10, timestamp, &address, &coin, nft_series, value, txfee)
+ .await;
+ let burn = BurnTransaction::new(unsigned_burn.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign burn transaction: {err}"))?;
+ let hash = unsigned_burn.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 10,
+ "timestamp": timestamp,
+ "address": address,
+ "coin": coin,
+ "nft_series": nft_series,
+ "value": value,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": burn.signature,
+ }))
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn build_marketing_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ campaign: String,
+ ad_type: String,
+ keyword: String,
+ displayed: String,
+ impression: u8,
+ click: u8,
+ impression_value: u16,
+ click_value: u16,
+ txfee: String,
+) -> Result {
+ let (advertiser, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let campaign = parse_atomic_u64(&campaign, "Campaign id")?;
+ let ad_type = padded_marketing_ad_type(&ad_type)?;
+ let keyword = padded_fixed_field(&keyword, 40, "Keyword")?;
+ let displayed = padded_fixed_field(&displayed, 100, "Display location")?;
+ let txfee = parse_atomic_u64(&txfee, "Marketing fee")?;
+ if txfee < MARKETING_FEE {
+ return Err(format!(
+ "Marketing transaction fee is below the minimum required fee of {MARKETING_FEE}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_marketing = UnsignedMarketingTransaction::new(
+ 5,
+ timestamp,
+ campaign,
+ &ad_type,
+ &keyword,
+ &displayed,
+ impression,
+ click,
+ impression_value,
+ click_value,
+ &advertiser,
+ txfee,
+ )
+ .await;
+ let marketing = MarketingTransaction::new(unsigned_marketing.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign marketing transaction: {err}"))?;
+ let hash = unsigned_marketing.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 5,
+ "timestamp": timestamp,
+ "campaign": campaign,
+ "ad_type": ad_type,
+ "keyword": keyword,
+ "displayed": displayed,
+ "impression": impression,
+ "click": click,
+ "impression_value": impression_value,
+ "click_value": click_value,
+ "advertiser": advertiser,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": marketing.signature,
+ }))
+}
+
+async fn build_vanity_address_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ vanity_name: String,
+ txfee: String,
+) -> Result {
+ let (address, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let vanity_address = vanity_address_for_wallet(&vanity_name, &address)?;
+ let txfee = parse_atomic_u64(&txfee, "Vanity address fee")?;
+ if txfee < VANITY_ADDRESS_FEE {
+ return Err(format!(
+ "Vanity address transaction fee is below the minimum required fee of {VANITY_ADDRESS_FEE}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_vanity = UnsignedVanityAddressTransaction::new(
+ 12,
+ timestamp,
+ &address,
+ &vanity_address,
+ txfee,
+ )
+ .await;
+ let vanity = VanityAddressTransaction::new(unsigned_vanity.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign vanity address transaction: {err}"))?;
+ let hash = unsigned_vanity.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 12,
+ "timestamp": timestamp,
+ "address": address,
+ "vanity_address": vanity_address,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": vanity.signature,
+ }))
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn build_swap_offer_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ ticker1: String,
+ nft_series1: u32,
+ value1: String,
+ ticker2: String,
+ nft_series2: u32,
+ value2: String,
+ sender2: String,
+ tip1: String,
+ tip2: String,
+ expiration_hours: u32,
+) -> Result {
+ let (sender1, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let sender2 =
+ resolve_transaction_address(state, &broadcast_node, &sender2, "Counterparty").await?;
+ if sender1.trim() == sender2.trim() {
+ return Err("Counterparty cannot be the active wallet address.".to_string());
+ }
+
+ let ticker1 = padded_coin_field(&ticker1)?;
+ let ticker2 = padded_coin_field(&ticker2)?;
+ let value1 = parse_atomic_u64(&value1, "Offered amount")?;
+ let value2 = parse_atomic_u64(&value2, "Requested amount")?;
+ let tip1 = parse_atomic_u64(&tip1, "Sender1 tip")?;
+ let tip2 = parse_atomic_u64(&tip2, "Sender2 tip")?;
+ if value1 == 0 || value2 == 0 {
+ return Err("Both swap amounts must be greater than zero.".to_string());
+ }
+ if expiration_hours == 0 || expiration_hours > 30 * 24 {
+ return Err("Swap expiration must be between 1 and 720 hours.".to_string());
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let expiration_seconds = expiration_hours
+ .checked_mul(60 * 60)
+ .ok_or_else(|| "Swap expiration overflowed.".to_string())?;
+ let offer_expiration = timestamp
+ .checked_add(expiration_seconds)
+ .ok_or_else(|| "Swap expiration overflowed.".to_string())?;
+ let unsigned_swap = UnsignedSwapTransaction::new(
+ 6,
+ timestamp,
+ offer_expiration,
+ &ticker1,
+ nft_series1,
+ value1,
+ &ticker2,
+ nft_series2,
+ value2,
+ &sender1,
+ &sender2,
+ tip1,
+ tip2,
+ SWAP_FEE,
+ SWAP_FEE,
+ )
+ .await;
+ let hash = unsigned_swap.hash().await;
+ let signature1 = unsigned_swap
+ .hash_and_sign(&private_key)
+ .await
+ .map_err(|err| format!("Failed to sign swap offer: {err}"))?;
+
+ Ok(serde_json::json!({
+ "txtype": 6,
+ "timestamp": timestamp,
+ "offer_expiration": offer_expiration,
+ "ticker1": ticker1,
+ "nft_series1": nft_series1,
+ "value1": value1,
+ "ticker2": ticker2,
+ "nft_series2": nft_series2,
+ "value2": value2,
+ "sender1": sender1,
+ "sender2": sender2,
+ "tip1": tip1,
+ "tip2": tip2,
+ "txfee1": SWAP_FEE,
+ "txfee2": SWAP_FEE,
+ "hash": hash,
+ "signature1": signature1,
+ "signature2": "",
+ }))
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn build_loan_offer_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ loan_coin: String,
+ loan_amount: String,
+ borrower: String,
+ collateral: String,
+ collateral_amount: String,
+ payment_period: String,
+ payment_number: u8,
+ payment_amount: String,
+ grace_period: u8,
+ max_late_value: String,
+ start_timestamp: u32,
+) -> Result {
+ let (lender, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let borrower =
+ resolve_transaction_address(state, &broadcast_node, &borrower, "Borrower").await?;
+ if lender.trim() == borrower.trim() {
+ return Err("Borrower cannot be the active lender wallet.".to_string());
+ }
+
+ let loan_coin = padded_coin_field(&loan_coin)?;
+ let collateral =
+ blockchain::common::asset_names::padded_loan_collateral_input_or_base(
+ &collateral,
+ &BASECOIN,
+ )
+ .ok_or_else(|| {
+ "Collateral must be the base coin, a 3-15 character asset, or a numbered NFT ending in _xxxxx."
+ .to_string()
+ })?;
+ let loan_amount = parse_atomic_u64(&loan_amount, "Loan amount")?;
+ let collateral_amount = parse_atomic_u64(&collateral_amount, "Collateral amount")?;
+ let payment_amount = parse_atomic_u64(&payment_amount, "Payment amount")?;
+ let max_late_value = parse_atomic_u64(&max_late_value, "Maximum overdue value")?;
+
+ if loan_amount == 0 || collateral_amount == 0 || payment_amount == 0 {
+ return Err("Loan, collateral, and payment amounts must be greater than zero.".to_string());
+ }
+ if payment_number == 0 {
+ return Err("A loan must require at least one payment.".to_string());
+ }
+ if payment_amount > loan_amount {
+ return Err("A single payment cannot exceed the loan amount.".to_string());
+ }
+ let scheduled_total = payment_amount
+ .checked_mul(payment_number as u64)
+ .ok_or_else(|| "Loan repayment schedule overflowed.".to_string())?;
+ if scheduled_total < loan_amount {
+ return Err("Scheduled payments must repay at least the loan principal.".to_string());
+ }
+ if grace_period > payment_number {
+ return Err("Missed-payment allowance cannot exceed the payment count.".to_string());
+ }
+ if max_late_value > loan_amount {
+ return Err("Maximum overdue value cannot exceed the loan amount.".to_string());
+ }
+ if !matches!(payment_period.as_str(), "d" | "w" | "m") {
+ return Err("Payment period must be daily, weekly, or monthly.".to_string());
+ }
+
+ let unsigned_loan = UnsignedLoanContractTransaction::new(
+ 7,
+ start_timestamp,
+ &loan_coin,
+ loan_amount,
+ &lender,
+ &collateral,
+ collateral_amount,
+ &borrower,
+ &payment_period,
+ payment_number,
+ payment_amount,
+ grace_period,
+ max_late_value,
+ LENDER_FEE,
+ )
+ .await;
+ let (hash, signature1) = unsigned_loan
+ .hash_and_sign(&private_key)
+ .await
+ .map_err(|err| format!("Failed to sign loan offer: {err}"))?;
+
+ Ok(serde_json::json!({
+ "txtype": 7,
+ "timestamp": start_timestamp,
+ "loan_coin": loan_coin,
+ "loan_amount": loan_amount,
+ "lender": lender,
+ "collateral": collateral,
+ "collateral_amount": collateral_amount,
+ "borrower": borrower,
+ "payment_period": payment_period,
+ "payment_number": payment_number,
+ "payment_amount": payment_amount,
+ "grace_period": grace_period,
+ "max_late_value": max_late_value,
+ "txfee": LENDER_FEE,
+ "hash": hash,
+ "signature1": signature1,
+ "signature2": "",
+ }))
+}
+
+fn required_contract_field<'a>(
+ fields: &'a HashMap,
+ field: &str,
+) -> Result<&'a str, String> {
+ fields
+ .get(field)
+ .map(String::as_str)
+ .ok_or_else(|| format!("Loan contract response is missing {field}."))
+}
+
+fn parse_contract_u64(fields: &HashMap, field: &str) -> Result {
+ required_contract_field(fields, field)?
+ .parse::()
+ .map_err(|_| format!("Loan contract response has invalid {field}."))
+}
+
+fn loan_payment_history_views(fields: &HashMap) -> Vec {
+ let mut payments = Vec::new();
+ let mut index = 1;
+ loop {
+ let txid_key = format!("payment_{index}_txid");
+ let Some(txid) = fields.get(&txid_key) else {
+ break;
+ };
+ let amount = fields
+ .get(&format!("payment_{index}_amount"))
+ .cloned()
+ .unwrap_or_default();
+ let payer = fields
+ .get(&format!("payment_{index}_payee"))
+ .cloned()
+ .unwrap_or_default();
+ let date = fields
+ .get(&format!("payment_{index}_date"))
+ .cloned()
+ .unwrap_or_default();
+ payments.push(LoanPaymentHistoryView {
+ txid: txid.to_string(),
+ amount,
+ payer,
+ date,
+ });
+ index += 1;
+ }
+ payments
+}
+
+fn loan_contract_view(fields: HashMap) -> Result {
+ let payments = loan_payment_history_views(&fields);
+ Ok(LoanContractView {
+ contract: required_contract_field(&fields, "contract")?.to_string(),
+ status: required_contract_field(&fields, "status")?.to_string(),
+ start_timestamp: parse_contract_u64(&fields, "start_timestamp")? as u32,
+ lender: required_contract_field(&fields, "lender")?.to_string(),
+ borrower: required_contract_field(&fields, "borrower")?.to_string(),
+ loan_asset: required_contract_field(&fields, "coin_loaned")?.to_string(),
+ loan_amount: parse_contract_u64(&fields, "loaned_count_atomic")?.to_string(),
+ collateral: required_contract_field(&fields, "collateral")?.to_string(),
+ collateral_amount: parse_contract_u64(&fields, "collateral_count_atomic")?.to_string(),
+ payment_period: required_contract_field(&fields, "payment_type")?.to_string(),
+ payment_number: parse_contract_u64(&fields, "number_of_payments")? as u8,
+ payment_amount: parse_contract_u64(&fields, "payment_value_atomic")?.to_string(),
+ grace_period: parse_contract_u64(&fields, "max_late_payments")? as u8,
+ max_late_value: parse_contract_u64(&fields, "max_late_value_atomic")?.to_string(),
+ confirmed_paid: parse_contract_u64(&fields, "total_value_paid_atomic")?.to_string(),
+ pending_paid: parse_contract_u64(&fields, "pending_value_atomic")?.to_string(),
+ remaining_balance: parse_contract_u64(&fields, "remaining_balance_atomic")?.to_string(),
+ remaining_after_pending: parse_contract_u64(&fields, "remaining_after_pending_atomic")?
+ .to_string(),
+ payments,
+ })
+}
+
+fn parse_contract_list(response: Vec) -> Result, String> {
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ let text = String::from_utf8(response)
+ .map_err(|_| "Loan contract response was not valid UTF-8.".to_string())?;
+ let mut contracts = Vec::new();
+ let mut current: Option> = None;
+
+ for line in text.lines() {
+ let line = line.trim();
+ if line.starts_with("contract_") && line.ends_with(':') {
+ if let Some(fields) = current.take() {
+ contracts.push(loan_contract_view(fields)?);
+ }
+ current = Some(HashMap::new());
+ continue;
+ }
+ let Some(fields) = current.as_mut() else {
+ continue;
+ };
+ if let Some((key, value)) = line.split_once('=') {
+ fields.insert(key.trim().to_string(), value.trim().to_string());
+ }
+ }
+ if let Some(fields) = current {
+ contracts.push(loan_contract_view(fields)?);
+ }
+ Ok(contracts)
+}
+
+async fn load_active_loan_contracts(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+) -> Result, String> {
+ let mut contracts = load_loan_contracts_for_active_wallet(state, broadcast_node).await?;
+ let active_address = active_wallet_rpc_parts(state)?.0;
+ contracts.retain(|contract| {
+ contract.borrower.trim() == active_address.trim()
+ && contract.status != "inactive"
+ && contract
+ .remaining_after_pending
+ .parse::()
+ .unwrap_or_default()
+ > 0
+ });
+ Ok(contracts)
+}
+
+async fn load_loan_contracts_for_active_wallet(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+) -> Result, String> {
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (active_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ active_address.clone(),
+ RPC_CONTRACT_BY_ADDRESS as usize,
+ public_key,
+ private_key,
+ "Loan contract lookup failed",
+ )
+ .await?;
+ let mut contracts = parse_contract_list(response)?;
+ contracts.sort_by(|left, right| right.start_timestamp.cmp(&left.start_timestamp));
+ Ok(contracts)
+}
+
+fn compact_payment_period(period: &str) -> Result<&'static str, String> {
+ match period.trim().to_ascii_lowercase().as_str() {
+ "d" | "daily" => Ok("d"),
+ "w" | "weekly" => Ok("w"),
+ "m" | "monthly" => Ok("m"),
+ _ => Err("Loan contract response has an invalid payment period.".to_string()),
+ }
+}
+
+fn collateral_claim_view(
+ contract: LoanContractView,
+ active_address: &str,
+ reason: String,
+) -> CollateralClaimContractView {
+ let role = if contract.borrower.trim() == active_address.trim() {
+ "borrower"
+ } else {
+ "lender"
+ };
+
+ CollateralClaimContractView {
+ contract: contract.contract,
+ role: role.to_string(),
+ reason,
+ lender: contract.lender,
+ borrower: contract.borrower,
+ loan_asset: contract.loan_asset,
+ loan_amount: contract.loan_amount,
+ collateral: contract.collateral,
+ collateral_amount: contract.collateral_amount,
+ confirmed_paid: contract.confirmed_paid,
+ pending_paid: contract.pending_paid,
+ remaining_balance: contract.remaining_balance,
+ remaining_after_pending: contract.remaining_after_pending,
+ fee: COLLATERAL_FEE.to_string(),
+ }
+}
+
+fn collateral_claim_reason(
+ contract: &LoanContractView,
+ active_address: &str,
+) -> Result, String> {
+ if contract.status == "inactive" {
+ return Ok(None);
+ }
+ let is_borrower = contract.borrower.trim() == active_address.trim();
+ let is_lender = contract.lender.trim() == active_address.trim();
+ if !is_borrower && !is_lender {
+ return Ok(None);
+ }
+
+ let remaining_balance = contract
+ .remaining_balance
+ .parse::()
+ .map_err(|_| "Loan contract response has invalid remaining balance.".to_string())?;
+ if is_borrower {
+ return Ok((remaining_balance == 0).then(|| {
+ "Loan is fully repaid, so the borrower can reclaim collateral.".to_string()
+ }));
+ }
+
+ let payments_due = blockchain::common::loan_schedule::overdue_payment_count(
+ contract.start_timestamp,
+ compact_payment_period(&contract.payment_period)?,
+ contract.payment_number,
+ blockchain::Utc::now().timestamp() as u32,
+ )?;
+ if payments_due <= contract.grace_period as usize {
+ return Ok(None);
+ }
+
+ let confirmed_paid = contract
+ .confirmed_paid
+ .parse::()
+ .map_err(|_| "Loan contract response has invalid confirmed payment total.".to_string())?;
+ let payment_amount = contract
+ .payment_amount
+ .parse::()
+ .map_err(|_| "Loan contract response has invalid payment amount.".to_string())?;
+ let max_late_value = contract
+ .max_late_value
+ .parse::()
+ .map_err(|_| "Loan contract response has invalid max late value.".to_string())?;
+ let should_have_paid = (payments_due as u64)
+ .checked_mul(payment_amount)
+ .ok_or_else(|| "Loan delinquency calculation overflowed.".to_string())?;
+ let overdue_value = should_have_paid.saturating_sub(confirmed_paid);
+ Ok((overdue_value > max_late_value).then(|| {
+ format!(
+ "Borrower is late by {} atomic units beyond the allowed threshold.",
+ overdue_value.saturating_sub(max_late_value)
+ )
+ }))
+}
+
+async fn load_claimable_collateral_contracts(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+) -> Result, String> {
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (active_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ active_address.clone(),
+ RPC_CONTRACT_BY_ADDRESS as usize,
+ public_key,
+ private_key,
+ "Loan contract lookup failed",
+ )
+ .await?;
+
+ let contracts = parse_contract_list(response)?;
+ let mut claimable = Vec::new();
+ for contract in contracts {
+ if let Some(reason) = collateral_claim_reason(&contract, &active_address)? {
+ claimable.push(collateral_claim_view(contract, &active_address, reason));
+ }
+ }
+ claimable.sort_by(|left, right| left.contract.cmp(&right.contract));
+ Ok(claimable)
+}
+
+async fn load_loan_contract(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+ contract_hash: &str,
+) -> Result {
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (_active_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ contract_hash.to_string(),
+ RPC_LOAN_CONTRACT as usize,
+ public_key,
+ private_key,
+ "Loan contract lookup failed",
+ )
+ .await?;
+ let text = String::from_utf8(response)
+ .map_err(|_| "Loan contract response was not valid UTF-8.".to_string())?;
+ if text.trim_start().starts_with("error:") {
+ return Err(text.trim().to_string());
+ }
+ let mut fields = HashMap::new();
+ for line in text.lines() {
+ if let Some((key, value)) = line.trim().split_once('=') {
+ fields.insert(key.trim().to_string(), value.trim().to_string());
+ }
+ }
+ loan_contract_view(fields)
+}
+
+async fn build_loan_payment_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: &str,
+ contract_hash: String,
+ payback_amount: String,
+) -> Result {
+ let (address, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let contract = load_loan_contract(state, broadcast_node, contract_hash.trim()).await?;
+ if contract.borrower.trim() != address.trim() {
+ return Err("Only the borrower can make a payment on this loan.".to_string());
+ }
+ if contract.status == "inactive" {
+ return Err("This loan is no longer active.".to_string());
+ }
+
+ let payback_amount = parse_atomic_u64(&payback_amount, "Loan payment")?;
+ if payback_amount == 0 {
+ return Err("Loan payment must be greater than zero.".to_string());
+ }
+ let remaining = contract
+ .remaining_after_pending
+ .parse::()
+ .map_err(|_| "Loan contract returned an invalid remaining balance.".to_string())?;
+ if payback_amount > remaining {
+ return Err("Payment exceeds the remaining balance after pending payments.".to_string());
+ }
+ let tip = payback_amount.div_ceil(100);
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_payment = UnsignedContractPaymentTransaction::new(
+ 8,
+ timestamp,
+ payback_amount,
+ contract_hash.trim(),
+ &address,
+ tip,
+ BORROWER_FEE,
+ )
+ .await;
+ let payment = ContractPaymentTransaction::new(unsigned_payment.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign loan payment: {err}"))?;
+ let hash = unsigned_payment.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 8,
+ "timestamp": timestamp,
+ "payback_amount": payback_amount,
+ "contract_hash": contract_hash.trim(),
+ "address": address,
+ "tip": tip,
+ "txfee": BORROWER_FEE,
+ "hash": hash,
+ "signature": payment.signature,
+ }))
+}
+
+async fn build_collateral_claim_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: &str,
+ contract_hash: String,
+) -> Result {
+ let (address, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ let contract = load_loan_contract(state, broadcast_node, contract_hash.trim()).await?;
+ let Some(_reason) = collateral_claim_reason(&contract, &address)? else {
+ return Err("This loan is not currently eligible for a collateral claim.".to_string());
+ };
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_claim = UnsignedCollateralClaimTransaction::new(
+ 9,
+ timestamp,
+ contract_hash.trim(),
+ &address,
+ COLLATERAL_FEE,
+ )
+ .await;
+ let claim = CollateralClaimTransaction::new(unsigned_claim.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign collateral claim: {err}"))?;
+ let hash = unsigned_claim.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 9,
+ "timestamp": timestamp,
+ "contract_hash": contract_hash.trim(),
+ "address": address,
+ "txfee": COLLATERAL_FEE,
+ "hash": hash,
+ "signature": claim.signature,
+ }))
+}
+
+async fn build_issue_token_json(
+ state: &State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: &str,
+ ticker: String,
+ number: String,
+ txfee: String,
+) -> Result {
+ let details = lookup_issue_token_details(state, broadcast_node, &ticker).await?;
+ if !details.eligible {
+ return Err(details.reason);
+ }
+
+ let (creator, private_key) = active_wallet_signing_parts(state, wallet_key).await?;
+ if creator.trim() != details.creator.trim() {
+ return Err("Only the original token creator can issue more tokens.".to_string());
+ }
+
+ let ticker = padded_token_ticker(&details.ticker)?;
+ let number = parse_atomic_u64(&number, "Issue token amount")?;
+ if number == 0 {
+ return Err("Issue token amount must be greater than zero.".to_string());
+ }
+
+ let txfee = parse_atomic_u64(&txfee, "Issue token fee")?;
+ if txfee < ISSUE_TOKEN_FEE {
+ return Err(format!(
+ "Issue token fee is below the minimum required fee of {ISSUE_TOKEN_FEE}."
+ ));
+ }
+
+ let timestamp = blockchain::Utc::now().timestamp() as u32;
+ let unsigned_issue_token =
+ UnsignedIssueTokenTransaction::new(11, timestamp, &creator, &ticker, number, txfee).await;
+ let issue_token = IssueTokenTransaction::new(unsigned_issue_token.clone(), &private_key)
+ .await
+ .map_err(|err| format!("Failed to sign issue-token transaction: {err}"))?;
+ let hash = unsigned_issue_token.hash().await;
+
+ Ok(serde_json::json!({
+ "txtype": 11,
+ "timestamp": timestamp,
+ "creator": creator,
+ "ticker": ticker,
+ "number": number,
+ "txfee": txfee,
+ "hash": hash,
+ "signature": issue_token.signature,
+ }))
+}
+
+fn unbroadcast_summary(transaction: &JsonValue, txtype: u8) -> String {
+ match txtype {
+ 2 => format!(
+ "{} {} to {}",
+ json_u64(transaction, "value").unwrap_or_default(),
+ optional_string(transaction, "coin").trim(),
+ optional_string(transaction, "receiver")
+ ),
+ 3 => format!(
+ "Create {} {}",
+ json_u64(transaction, "number").unwrap_or_default(),
+ optional_string(transaction, "ticker").trim()
+ ),
+ 4 => {
+ let count = json_u64(transaction, "count").unwrap_or_default();
+ let name = optional_string(transaction, "nft_name");
+ if json_u64(transaction, "series").unwrap_or_default() == 1 {
+ format!("Create collection of {count} {}", name.trim())
+ } else {
+ format!("Create NFT {}", name.trim())
+ }
+ }
+ 11 => format!(
+ "Issue {} more {}",
+ json_u64(transaction, "number").unwrap_or_default(),
+ optional_string(transaction, "ticker").trim()
+ ),
+ 6 => format!(
+ "{} {} for {} {}",
+ json_u64(transaction, "value1").unwrap_or_default(),
+ optional_string(transaction, "ticker1").trim(),
+ json_u64(transaction, "value2").unwrap_or_default(),
+ optional_string(transaction, "ticker2").trim()
+ ),
+ 7 => format!(
+ "Loan {} {} from {} to {}",
+ json_u64(transaction, "loan_amount").unwrap_or_default(),
+ optional_string(transaction, "loan_coin").trim(),
+ optional_string(transaction, "lender"),
+ optional_string(transaction, "borrower")
+ ),
+ 8 => format!(
+ "Pay {} toward loan {}",
+ json_u64(transaction, "payback_amount").unwrap_or_default(),
+ optional_string(transaction, "contract_hash")
+ ),
+ 12 => format!("Vanity {}", optional_string(transaction, "vanity_address")),
+ _ => optional_string(transaction, "hash")
+ .chars()
+ .take(16)
+ .collect::(),
+ }
+}
+
+async fn unbroadcast_dir() -> Result {
+ let settings = read_gui_settings().await?;
+ let path = PathBuf::from(settings.unbroadcast_transactions_path);
+ create_dir_all(&path)
+ .await
+ .map_err(|err| format!("Unable to create unbroadcast transaction directory: {err}"))?;
+ Ok(path)
+}
+
+fn validate_unbroadcast_file_name(file_name: &str) -> Result {
+ let trimmed = file_name.trim();
+ if trimmed.is_empty() {
+ return Err("Transaction filename cannot be empty.".to_string());
+ }
+ if trimmed.contains('/') || trimmed.contains('\\') || trimmed.contains("..") {
+ return Err("Transaction filename cannot contain path separators.".to_string());
+ }
+ if !trimmed
+ .rsplit_once('.')
+ .is_some_and(|(_, extension)| extension.eq_ignore_ascii_case("json"))
+ {
+ return Err("Transaction filename must end with .json.".to_string());
+ }
+ Ok(trimmed.to_string())
+}
+
+async fn read_unbroadcast_json(file_name: &str) -> Result<(PathBuf, JsonValue), String> {
+ let file_name = validate_unbroadcast_file_name(file_name)?;
+ let dir = unbroadcast_dir().await?;
+ let path = dir.join(&file_name);
+ let contents = read_to_string(&path)
+ .await
+ .map_err(|err| format!("Unable to read unbroadcast transaction: {err}"))?;
+ let transaction = serde_json::from_str::(&contents)
+ .map_err(|err| format!("Unable to parse unbroadcast transaction JSON: {err}"))?;
+ Ok((path, transaction))
+}
+
+async fn rebuild_swap(transaction: &JsonValue) -> Result {
+ UnsignedSwapTransaction::new(
+ 6,
+ json_u32(transaction, "timestamp", "time")?,
+ json_u64(transaction, "offer_expiration")? as u32,
+ &json_str(transaction, "ticker1")?,
+ transaction
+ .get("nft_series1")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u32,
+ json_u64(transaction, "value1")?,
+ &json_str(transaction, "ticker2")?,
+ transaction
+ .get("nft_series2")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u32,
+ json_u64(transaction, "value2")?,
+ &json_str(transaction, "sender1")?,
+ &json_str(transaction, "sender2")?,
+ json_u64(transaction, "tip1")?,
+ json_u64(transaction, "tip2")?,
+ json_u64(transaction, "txfee1")?,
+ json_u64(transaction, "txfee2")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_transfer(transaction: &JsonValue) -> Result {
+ UnsignedTransferTransaction::new(
+ 2,
+ json_u32(transaction, "timestamp", "time")?,
+ json_u64(transaction, "value")?,
+ &json_str(transaction, "coin")?,
+ transaction
+ .get("nft_series")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u32,
+ &json_str(transaction, "sender")?,
+ &json_str(transaction, "receiver")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_create_token(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedCreateTokenTransaction::new(
+ 3,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "creator")?,
+ &json_str(transaction, "ticker")?,
+ json_u64(transaction, "number")?,
+ json_u8(transaction, "hard_limit")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_create_nft(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedCreateNftTransaction::new(
+ 4,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "creator")?,
+ json_u8(transaction, "series")?,
+ &json_str(transaction, "nft_name")?,
+ &json_str(transaction, "item_ipfs")?,
+ json_u64(transaction, "count")? as u32,
+ &json_str(transaction, "desc")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_issue_token(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedIssueTokenTransaction::new(
+ 11,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "creator")?,
+ &json_str(transaction, "ticker")?,
+ json_u64(transaction, "number")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn verify_registered_signature(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+ hash: &str,
+ signer: &str,
+ signature: &str,
+ label: &str,
+) -> Result<(), String> {
+ if !valid_signature(signature) {
+ return Err(format!("{label} is missing or malformed."));
+ }
+ let signer = Wallet::normalize_to_short_address(signer)
+ .filter(|address| Wallet::short_address_to_bytes(address).is_some())
+ .ok_or_else(|| format!("{label} signer address is invalid."))?;
+ let socket_address = active_broadcast_socket(broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(state)?;
+ let response = serialized_wallet_rpc(
+ state,
+ socket_address,
+ format!("{hash}|{signer}|{signature}"),
+ RPC_VALIDATE_MESSAGE as usize,
+ public_key,
+ private_key,
+ "Transaction signature verification failed",
+ )
+ .await?;
+ if String::from_utf8_lossy(&response).trim() != "valid" {
+ return Err(format!("{label} is not valid for {signer}."));
+ }
+ Ok(())
+}
+
+async fn validate_imported_transaction(
+ state: &State<'_, WalletState>,
+ broadcast_node: &str,
+ transaction: &JsonValue,
+) -> Result {
+ let txtype = json_u8(transaction, "txtype")?;
+ let (computed_hash, signatures) = match txtype {
+ 2 => {
+ let unsigned = rebuild_transfer(transaction).await?;
+ (
+ unsigned.hash().await,
+ vec![(
+ json_str(transaction, "sender")?,
+ json_str(transaction, "signature")?,
+ "Transfer signature",
+ )],
+ )
+ }
+ 3 => {
+ let unsigned = rebuild_create_token(transaction).await?;
+ (
+ unsigned.hash().await,
+ vec![(
+ json_str(transaction, "creator")?,
+ json_str(transaction, "signature")?,
+ "Create-token signature",
+ )],
+ )
+ }
+ 4 => {
+ let unsigned = rebuild_create_nft(transaction).await?;
+ (
+ unsigned.hash().await,
+ vec![(
+ json_str(transaction, "creator")?,
+ json_str(transaction, "signature")?,
+ "Create-NFT signature",
+ )],
+ )
+ }
+ 5 => {
+ let unsigned = rebuild_marketing(transaction).await?;
+ if !matches!(
+ unsigned.ad_type.trim().to_ascii_lowercase().as_str(),
+ "banner" | "social" | "text"
+ ) {
+ return Err("Marketing ad type must be banner, social, or text.".to_string());
+ }
+ if unsigned.keyword.len() != 40 {
+ return Err("Marketing keyword must use its 40-byte field.".to_string());
+ }
+ if unsigned.displayed.len() != 100 {
+ return Err("Marketing display location must use its 100-byte field.".to_string());
+ }
+ if unsigned.txfee < MARKETING_FEE {
+ return Err(format!(
+ "Marketing transaction fee is below the minimum required fee of {MARKETING_FEE}."
+ ));
+ }
+ (
+ unsigned.hash().await,
+ vec![(
+ unsigned.advertiser.clone(),
+ json_str(transaction, "signature")?,
+ "Marketing signature",
+ )],
+ )
+ }
+ 6 => {
+ let unsigned = rebuild_swap(transaction).await?;
+ let now = blockchain::Utc::now().timestamp() as u32;
+ if unsigned.offer_expiration < unsigned.timestamp
+ || unsigned.offer_expiration > unsigned.timestamp.saturating_add(30 * 24 * 60 * 60)
+ {
+ return Err("Swap expiration is outside the valid 30-day window.".to_string());
+ }
+ if now > unsigned.offer_expiration {
+ return Err("This swap offer has expired.".to_string());
+ }
+ if unsigned.txfee1 < SWAP_FEE || unsigned.txfee2 < SWAP_FEE {
+ return Err(format!("Each swap signer must pay at least {SWAP_FEE}."));
+ }
+
+ let signature1 = json_str(transaction, "signature1")?;
+ let signature2 = optional_string(transaction, "signature2");
+ let mut signatures = vec![(
+ unsigned.sender1.clone(),
+ signature1,
+ "Swap sender1 signature",
+ )];
+ if !signature2.is_empty() {
+ signatures.push((
+ unsigned.sender2.clone(),
+ signature2,
+ "Swap sender2 signature",
+ ));
+ }
+ (unsigned.hash().await, signatures)
+ }
+ 7 => {
+ let unsigned = rebuild_loan(transaction).await?;
+ if unsigned.loan_coin.len() != 15 {
+ return Err("Loan asset must use its canonical 15-byte field.".to_string());
+ }
+ if !blockchain::common::asset_names::is_canonical_loan_collateral_or_base(
+ &unsigned.collateral,
+ &BASECOIN,
+ ) {
+ return Err("Loan collateral must use its canonical 21-byte field.".to_string());
+ }
+ if unsigned.loan_amount == 0
+ || unsigned.collateral_amount == 0
+ || unsigned.payment_amount == 0
+ || unsigned.payment_number == 0
+ {
+ return Err(
+ "Loan, collateral, payment amount, and payment count must be greater than zero."
+ .to_string(),
+ );
+ }
+ if !matches!(unsigned.payment_period.as_str(), "d" | "w" | "m") {
+ return Err("Loan payment period must be daily, weekly, or monthly.".to_string());
+ }
+ if unsigned.payment_amount > unsigned.loan_amount {
+ return Err("A single payment cannot exceed the loan amount.".to_string());
+ }
+ let scheduled_total = unsigned
+ .payment_amount
+ .checked_mul(unsigned.payment_number as u64)
+ .ok_or_else(|| "Loan repayment schedule overflowed.".to_string())?;
+ if scheduled_total < unsigned.loan_amount {
+ return Err("Scheduled payments do not repay the loan principal.".to_string());
+ }
+ if unsigned.grace_period > unsigned.payment_number {
+ return Err("Missed-payment allowance cannot exceed the payment count.".to_string());
+ }
+ if unsigned.max_late_value > unsigned.loan_amount {
+ return Err("Maximum overdue value cannot exceed the loan amount.".to_string());
+ }
+ if unsigned.txfee < LENDER_FEE {
+ return Err(format!(
+ "Loan lender fee is below the minimum required fee of {LENDER_FEE}."
+ ));
+ }
+
+ let signature1 = json_str(transaction, "signature1")?;
+ let signature2 = optional_string(transaction, "signature2");
+ let mut signatures =
+ vec![(unsigned.lender.clone(), signature1, "Loan lender signature")];
+ if !signature2.is_empty() {
+ signatures.push((
+ unsigned.borrower.clone(),
+ signature2,
+ "Loan borrower signature",
+ ));
+ }
+ (unsigned.hash().await, signatures)
+ }
+ 8 => {
+ let unsigned = rebuild_loan_payment(transaction).await?;
+ if unsigned.payback_amount == 0 {
+ return Err("Loan payment must be greater than zero.".to_string());
+ }
+ if unsigned.txfee < BORROWER_FEE {
+ return Err(format!(
+ "Loan payment fee is below the minimum required fee of {BORROWER_FEE}."
+ ));
+ }
+ let minimum_tip = unsigned.payback_amount.div_ceil(100);
+ if unsigned.tip < minimum_tip {
+ return Err("Loan payment tip must be at least 1%.".to_string());
+ }
+ (
+ unsigned.hash().await,
+ vec![(
+ unsigned.address.clone(),
+ json_str(transaction, "signature")?,
+ "Loan-payment signature",
+ )],
+ )
+ }
+ 9 => {
+ let unsigned = rebuild_collateral_claim(transaction).await?;
+ if unsigned.txfee < COLLATERAL_FEE {
+ return Err(format!(
+ "Collateral claim fee is below the minimum required fee of {COLLATERAL_FEE}."
+ ));
+ }
+ (
+ unsigned.hash().await,
+ vec![(
+ unsigned.address.clone(),
+ json_str(transaction, "signature")?,
+ "Collateral-claim signature",
+ )],
+ )
+ }
+ 10 => {
+ let unsigned = rebuild_burn(transaction).await?;
+ if unsigned.coin.len() != 15
+ || !blockchain::common::asset_names::is_canonical_padded_asset_identifier(
+ &unsigned.coin,
+ )
+ {
+ return Err("Burn asset must use its canonical 15-byte field.".to_string());
+ }
+ if unsigned.coin.trim().eq_ignore_ascii_case(BASECOIN.trim()) {
+ return Err("Base coin cannot be burned.".to_string());
+ }
+ if unsigned.value == 0 {
+ return Err("Burn amount must be greater than zero.".to_string());
+ }
+ if unsigned.txfee < BURN_FEE {
+ return Err(format!(
+ "Burn transaction fee is below the minimum required fee of {BURN_FEE}."
+ ));
+ }
+ (
+ unsigned.hash().await,
+ vec![(
+ unsigned.address.clone(),
+ json_str(transaction, "signature")?,
+ "Burn signature",
+ )],
+ )
+ }
+ 11 => {
+ let unsigned = rebuild_issue_token(transaction).await?;
+ (
+ unsigned.hash().await,
+ vec![(
+ json_str(transaction, "creator")?,
+ json_str(transaction, "signature")?,
+ "Issue-token signature",
+ )],
+ )
+ }
+ 12 => {
+ let unsigned = rebuild_vanity_address(transaction).await?;
+ if unsigned.txfee < VANITY_ADDRESS_FEE {
+ return Err(format!(
+ "Vanity address transaction fee is below the minimum required fee of {VANITY_ADDRESS_FEE}."
+ ));
+ }
+ if Wallet::short_address_to_bytes(&unsigned.address).is_none() {
+ return Err("Vanity owner address is invalid.".to_string());
+ }
+ if Wallet::vanity_address_to_bytes(&unsigned.vanity_address).is_none() {
+ return Err("Vanity address is invalid.".to_string());
+ }
+ (
+ unsigned.hash().await,
+ vec![(
+ unsigned.address.clone(),
+ json_str(transaction, "signature")?,
+ "Vanity-address signature",
+ )],
+ )
+ }
+ _ => {
+ return Err(
+ "This wallet currently imports transfer, create-token, create-NFT, marketing, swap, loan, loan-payment, collateral-claim, burn, issue-token, and vanity-address transactions only."
+ .to_string(),
+ );
+ }
+ };
+
+ let supplied_hash = json_str(transaction, "hash")?.trim().to_string();
+ if supplied_hash != computed_hash {
+ return Err("Transaction hash does not match its fields.".to_string());
+ }
+ if !blockchain::decode(&supplied_hash).is_ok_and(|bytes| bytes.len() == 32) {
+ return Err("Transaction hash must be a 32-byte hexadecimal value.".to_string());
+ }
+
+ for (signer, signature, label) in signatures {
+ verify_registered_signature(
+ state,
+ broadcast_node,
+ &computed_hash,
+ &signer,
+ &signature,
+ label,
+ )
+ .await?;
+ }
+ Ok(computed_hash)
+}
+
+async fn rebuild_loan(transaction: &JsonValue) -> Result {
+ let collateral_amount = transaction
+ .get("collateral_amount")
+ .and_then(|value| value.as_u64())
+ .or_else(|| {
+ transaction
+ .get("collateral_value")
+ .and_then(|value| value.as_u64())
+ })
+ .ok_or_else(|| "Missing or invalid collateral amount.".to_string())?;
+
+ UnsignedLoanContractTransaction::new(
+ 7,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "loan_coin")?,
+ json_u64(transaction, "loan_amount")?,
+ &json_str(transaction, "lender")?,
+ &json_str(transaction, "collateral")?,
+ collateral_amount,
+ &json_str(transaction, "borrower")?,
+ &json_str(transaction, "payment_period")?,
+ json_u8(transaction, "payment_number")?,
+ json_u64(transaction, "payment_amount")?,
+ json_u8(transaction, "grace_period")?,
+ json_u64(transaction, "max_late_value")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_loan_payment(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedContractPaymentTransaction::new(
+ 8,
+ json_u32(transaction, "timestamp", "time")?,
+ json_u64(transaction, "payback_amount")?,
+ &json_str(transaction, "contract_hash")?,
+ &json_str(transaction, "address")?,
+ json_u64(transaction, "tip")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_collateral_claim(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedCollateralClaimTransaction::new(
+ 9,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "contract_hash")?,
+ &json_str(transaction, "address")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_burn(transaction: &JsonValue) -> Result {
+ UnsignedBurnTransaction::new(
+ 10,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "address")?,
+ &json_str(transaction, "coin")?,
+ json_u32(transaction, "nft_series", "nft_series")?,
+ json_u64(transaction, "value")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_marketing(transaction: &JsonValue) -> Result {
+ UnsignedMarketingTransaction::new(
+ 5,
+ json_u32(transaction, "timestamp", "time")?,
+ json_u64(transaction, "campaign")?,
+ &json_str(transaction, "ad_type")?,
+ &json_str(transaction, "keyword")?,
+ &json_str(transaction, "displayed")?,
+ json_u8(transaction, "impression")?,
+ json_u8(transaction, "click")?,
+ json_u16(transaction, "impression_value")?,
+ json_u16(transaction, "click_value")?,
+ &json_str(transaction, "advertiser")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+async fn rebuild_vanity_address(
+ transaction: &JsonValue,
+) -> Result {
+ UnsignedVanityAddressTransaction::new(
+ 12,
+ json_u32(transaction, "timestamp", "time")?,
+ &json_str(transaction, "address")?,
+ &json_str(transaction, "vanity_address")?,
+ json_u64(transaction, "txfee")?,
+ )
+ .await
+ .pipe(Ok)
+}
+
+trait Pipe: Sized {
+ fn pipe(self, f: impl FnOnce(Self) -> T) -> T {
+ f(self)
+ }
+}
+
+impl Pipe for T {}
+
+async fn unbroadcast_state(
+ transaction: &JsonValue,
+ active_short_address: Option<&str>,
+) -> (String, String, bool, bool) {
+ let txtype = transaction
+ .get("txtype")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u8;
+
+ match txtype {
+ 6 => {
+ let Ok(unsigned_swap) = rebuild_swap(transaction).await else {
+ return (
+ "invalid".to_string(),
+ "Swap transaction fields are incomplete.".to_string(),
+ false,
+ false,
+ );
+ };
+ let computed_hash = unsigned_swap.hash().await;
+ let json_hash = optional_string(transaction, "hash");
+ if !json_hash.is_empty() && json_hash != computed_hash {
+ return (
+ "invalid_hash".to_string(),
+ "Swap hash does not match the transaction fields.".to_string(),
+ false,
+ false,
+ );
+ }
+
+ let signature1 = optional_string(transaction, "signature1");
+ let signature2 = optional_string(transaction, "signature2");
+ if valid_signature(&signature1) && valid_signature(&signature2) {
+ return (
+ "ready".to_string(),
+ "Ready to broadcast.".to_string(),
+ false,
+ true,
+ );
+ }
+
+ let active = active_short_address.unwrap_or_default().trim();
+ if signature1.is_empty() {
+ let signer = optional_string(transaction, "sender1");
+ let can_sign = !active.is_empty() && active == signer.trim();
+ return (
+ if can_sign {
+ "needs_active_signature"
+ } else {
+ "needs_other_signature"
+ }
+ .to_string(),
+ format!("Needs sender1 signature from {}.", signer.trim()),
+ can_sign,
+ false,
+ );
+ }
+ if signature2.is_empty() {
+ let signer = optional_string(transaction, "sender2");
+ let can_sign = !active.is_empty() && active == signer.trim();
+ let sender1 = optional_string(transaction, "sender1");
+ let message = if can_sign {
+ "Review the swap terms, then sign and broadcast as sender2.".to_string()
+ } else if !active.is_empty() && active == sender1.trim() {
+ format!(
+ "Your sender1 signature is present. Awaiting sender2 signature from {}.",
+ signer.trim()
+ )
+ } else {
+ format!("Awaiting sender2 signature from {}.", signer.trim())
+ };
+ return (
+ if can_sign {
+ "needs_active_signature"
+ } else {
+ "needs_other_signature"
+ }
+ .to_string(),
+ message,
+ can_sign,
+ false,
+ );
+ }
+
+ (
+ "invalid_signature".to_string(),
+ "Swap has malformed signature data.".to_string(),
+ false,
+ false,
+ )
+ }
+ 7 => {
+ let Ok(unsigned_loan) = rebuild_loan(transaction).await else {
+ return (
+ "invalid".to_string(),
+ "Loan transaction fields are incomplete.".to_string(),
+ false,
+ false,
+ );
+ };
+ let computed_hash = unsigned_loan.hash().await;
+ let json_hash = optional_string(transaction, "hash");
+ if !json_hash.is_empty() && json_hash != computed_hash {
+ return (
+ "invalid_hash".to_string(),
+ "Loan hash does not match the transaction fields.".to_string(),
+ false,
+ false,
+ );
+ }
+
+ let signature1 = optional_string(transaction, "signature1");
+ let signature2 = optional_string(transaction, "signature2");
+ if valid_signature(&signature1) && valid_signature(&signature2) {
+ return (
+ "ready".to_string(),
+ "Ready to broadcast.".to_string(),
+ false,
+ true,
+ );
+ }
+
+ let active = active_short_address.unwrap_or_default().trim();
+ if signature1.is_empty() {
+ let signer = optional_string(transaction, "lender");
+ let can_sign = !active.is_empty() && active == signer.trim();
+ return (
+ if can_sign {
+ "needs_active_signature"
+ } else {
+ "needs_other_signature"
+ }
+ .to_string(),
+ format!("Needs lender signature from {}.", signer.trim()),
+ can_sign,
+ false,
+ );
+ }
+ if signature2.is_empty() {
+ let signer = optional_string(transaction, "borrower");
+ let can_sign = !active.is_empty() && active == signer.trim();
+ let lender = optional_string(transaction, "lender");
+ let message = if can_sign {
+ "Review the loan terms, then sign and broadcast as the borrower.".to_string()
+ } else if !active.is_empty() && active == lender.trim() {
+ format!(
+ "Your lender signature is present. Awaiting borrower signature from {}.",
+ signer.trim()
+ )
+ } else {
+ format!("Awaiting borrower signature from {}.", signer.trim())
+ };
+ return (
+ if can_sign {
+ "needs_active_signature"
+ } else {
+ "needs_other_signature"
+ }
+ .to_string(),
+ message,
+ can_sign,
+ false,
+ );
+ }
+
+ (
+ "invalid_signature".to_string(),
+ "Loan has malformed signature data.".to_string(),
+ false,
+ false,
+ )
+ }
+ _ => {
+ let signature = optional_string(transaction, "signature");
+ if signature.is_empty() || valid_signature(&signature) {
+ (
+ "ready".to_string(),
+ "Ready to broadcast.".to_string(),
+ false,
+ true,
+ )
+ } else {
+ (
+ "invalid_signature".to_string(),
+ "Transaction has malformed signature data.".to_string(),
+ false,
+ false,
+ )
+ }
+ }
+ }
+}
+
+async fn build_unbroadcast_review(
+ file_name: String,
+ transaction: JsonValue,
+ active_short_address: Option<&str>,
+) -> UnbroadcastTransactionReview {
+ let transaction_type = transaction
+ .get("txtype")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u8;
+ let type_name = unbroadcast_type_name(transaction_type).to_string();
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(|hash| hash.trim().to_string())
+ .filter(|hash| !hash.is_empty());
+ let summary = unbroadcast_summary(&transaction, transaction_type);
+ let (status, status_message, can_sign, can_broadcast) =
+ unbroadcast_state(&transaction, active_short_address).await;
+
+ UnbroadcastTransactionReview {
+ file_name,
+ transaction_type,
+ type_name,
+ txid,
+ summary,
+ status,
+ status_message,
+ can_sign,
+ can_broadcast,
+ transaction,
+ }
+}
+
+async fn save_json_unbroadcast_transaction(
+ transaction: JsonValue,
+ active_short_address: &str,
+) -> Result {
+ let txid = optional_string(&transaction, "hash");
+ if txid.is_empty() {
+ return Err("Transaction hash could not be created.".to_string());
+ }
+
+ let file_name = format!("{txid}.json");
+ let dir = unbroadcast_dir().await?;
+ let path = dir.join(&file_name);
+ let output = serde_json::to_string_pretty(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction: {err}"))?;
+ blockchain::tokio::fs::write(&path, output)
+ .await
+ .map_err(|err| format!("Failed to save transaction: {err}"))?;
+
+ build_unbroadcast_review(file_name, transaction, Some(active_short_address))
+ .await
+ .pipe(Ok)
+}
+
+#[tauri::command]
+async fn import_unbroadcast_transaction(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ let source_path = FileDialog::new()
+ .add_filter("Contractless Transaction", &["json"])
+ .show_open_single_file()
+ .map_err(|err| format!("Unable to open transaction file picker: {err}"))?;
+ let Some(source_path) = source_path else {
+ return Ok(None);
+ };
+ if !source_path
+ .extension()
+ .and_then(|extension| extension.to_str())
+ .is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
+ {
+ return Err("Imported transaction must be a JSON file.".to_string());
+ }
+
+ let contents = read_to_string(&source_path)
+ .await
+ .map_err(|err| format!("Unable to read imported transaction: {err}"))?;
+ let transaction = serde_json::from_str::(&contents)
+ .map_err(|err| format!("Unable to parse imported transaction JSON: {err}"))?;
+ let txid = validate_imported_transaction(&state, &broadcast_node, &transaction).await?;
+ let file_name = format!("{txid}.json");
+ let destination_dir = unbroadcast_dir().await?;
+ let destination_path = destination_dir.join(&file_name);
+
+ let source_canonical = std::fs::canonicalize(&source_path)
+ .map_err(|err| format!("Unable to resolve imported transaction path: {err}"))?;
+ let destination_exists = metadata(&destination_path).await.is_ok();
+ if destination_exists {
+ let destination_contents = read_to_string(&destination_path)
+ .await
+ .map_err(|err| format!("Unable to read existing unbroadcast transaction: {err}"))?;
+ let destination_transaction = serde_json::from_str::(&destination_contents)
+ .map_err(|err| format!("Existing unbroadcast transaction is invalid JSON: {err}"))?;
+ if destination_transaction != transaction {
+ return Err(format!(
+ "A different transaction already exists at {}.",
+ destination_path.display()
+ ));
+ }
+
+ let destination_canonical = std::fs::canonicalize(&destination_path)
+ .map_err(|err| format!("Unable to resolve existing transaction path: {err}"))?;
+ if source_canonical != destination_canonical {
+ blockchain::tokio::fs::remove_file(&source_path)
+ .await
+ .map_err(|err| {
+ format!(
+ "The transaction was already imported, but the duplicate source could not be removed: {err}"
+ )
+ })?;
+ }
+ } else if let Err(rename_error) =
+ blockchain::tokio::fs::rename(&source_path, &destination_path).await
+ {
+ blockchain::tokio::fs::copy(&source_path, &destination_path)
+ .await
+ .map_err(|copy_error| {
+ format!(
+ "Unable to move imported transaction ({rename_error}); copy fallback also failed: {copy_error}"
+ )
+ })?;
+ if let Err(remove_error) = blockchain::tokio::fs::remove_file(&source_path).await {
+ let _ = blockchain::tokio::fs::remove_file(&destination_path).await;
+ return Err(format!(
+ "Transaction copy succeeded, but its source could not be removed: {remove_error}"
+ ));
+ }
+ }
+
+ let active_short_address = active_wallet_rpc_parts(&state).ok().map(|parts| parts.0);
+ let review =
+ build_unbroadcast_review(file_name, transaction, active_short_address.as_deref()).await;
+ Ok(Some(review))
+}
+
+#[tauri::command]
+async fn save_transfer_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ receiver: String,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_transfer_json(
+ &state,
+ wallet_key,
+ broadcast_node,
+ receiver,
+ coin,
+ nft_series,
+ value,
+ txfee,
+ )
+ .await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_transfer_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ receiver: String,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let transaction = build_transfer_json(
+ &state,
+ wallet_key,
+ broadcast_node.clone(),
+ receiver,
+ coin,
+ nft_series,
+ value,
+ txfee,
+ )
+ .await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(|hash| hash.to_string());
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction for broadcast: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Transaction broadcast failed",
+ )
+ .await?;
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ Ok(BroadcastUnbroadcastResult {
+ response: response_text,
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn save_create_token_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ ticker: String,
+ number: String,
+ allow_more: bool,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction =
+ build_create_token_json(&state, wallet_key, ticker, number, allow_more, txfee).await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_create_token_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ ticker: String,
+ number: String,
+ allow_more: bool,
+ txfee: String,
+) -> Result {
+ let transaction =
+ build_create_token_json(&state, wallet_key, ticker, number, allow_more, txfee).await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(|hash| hash.to_string());
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction for broadcast: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Transaction broadcast failed",
+ )
+ .await?;
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ Ok(BroadcastUnbroadcastResult {
+ response: response_text,
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn save_create_nft_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ series: u8,
+ nft_name: String,
+ item_ipfs: String,
+ count: u32,
+ description: String,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_create_nft_json(
+ &state,
+ wallet_key,
+ series,
+ nft_name,
+ item_ipfs,
+ count,
+ description,
+ txfee,
+ )
+ .await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_create_nft_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ series: u8,
+ nft_name: String,
+ item_ipfs: String,
+ count: u32,
+ description: String,
+ txfee: String,
+) -> Result {
+ let transaction = build_create_nft_json(
+ &state,
+ wallet_key,
+ series,
+ nft_name,
+ item_ipfs,
+ count,
+ description,
+ txfee,
+ )
+ .await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction for broadcast: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Transaction broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn save_burn_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_burn_json(&state, wallet_key, coin, nft_series, value, txfee).await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_burn_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ coin: String,
+ nft_series: u32,
+ value: String,
+ txfee: String,
+) -> Result {
+ let transaction = build_burn_json(&state, wallet_key, coin, nft_series, value, txfee).await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize burn transaction: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Burn transaction broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+async fn save_marketing_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ campaign: String,
+ ad_type: String,
+ keyword: String,
+ displayed: String,
+ impression: u8,
+ click: u8,
+ impression_value: u16,
+ click_value: u16,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_marketing_json(
+ &state,
+ wallet_key,
+ campaign,
+ ad_type,
+ keyword,
+ displayed,
+ impression,
+ click,
+ impression_value,
+ click_value,
+ txfee,
+ )
+ .await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+async fn broadcast_marketing_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ campaign: String,
+ ad_type: String,
+ keyword: String,
+ displayed: String,
+ impression: u8,
+ click: u8,
+ impression_value: u16,
+ click_value: u16,
+ txfee: String,
+) -> Result {
+ let transaction = build_marketing_json(
+ &state,
+ wallet_key,
+ campaign,
+ ad_type,
+ keyword,
+ displayed,
+ impression,
+ click,
+ impression_value,
+ click_value,
+ txfee,
+ )
+ .await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize marketing transaction: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Marketing transaction broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn save_vanity_address_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ vanity_name: String,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_vanity_address_json(&state, wallet_key, vanity_name, txfee).await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_vanity_address_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ vanity_name: String,
+ txfee: String,
+) -> Result {
+ let transaction = build_vanity_address_json(&state, wallet_key, vanity_name, txfee).await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize vanity address transaction: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Vanity address transaction broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ persist_active_wallet_vanity_address(&state, &transaction).await;
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+async fn save_swap_offer(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ ticker1: String,
+ nft_series1: u32,
+ value1: String,
+ ticker2: String,
+ nft_series2: u32,
+ value2: String,
+ sender2: String,
+ tip1: String,
+ tip2: String,
+ expiration_hours: u32,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_swap_offer_json(
+ &state,
+ wallet_key,
+ broadcast_node,
+ ticker1,
+ nft_series1,
+ value1,
+ ticker2,
+ nft_series2,
+ value2,
+ sender2,
+ tip1,
+ tip2,
+ expiration_hours,
+ )
+ .await?;
+ let review = save_json_unbroadcast_transaction(transaction, &active_short_address).await?;
+ let file_path = unbroadcast_dir()
+ .await?
+ .join(&review.file_name)
+ .to_string_lossy()
+ .into_owned();
+ Ok(SavedSwapOfferView { review, file_path })
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+async fn save_loan_offer(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ loan_coin: String,
+ loan_amount: String,
+ borrower: String,
+ collateral: String,
+ collateral_amount: String,
+ payment_period: String,
+ payment_number: u8,
+ payment_amount: String,
+ grace_period: u8,
+ max_late_value: String,
+ start_timestamp: u32,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_loan_offer_json(
+ &state,
+ wallet_key,
+ broadcast_node,
+ loan_coin,
+ loan_amount,
+ borrower,
+ collateral,
+ collateral_amount,
+ payment_period,
+ payment_number,
+ payment_amount,
+ grace_period,
+ max_late_value,
+ start_timestamp,
+ )
+ .await?;
+ let review = save_json_unbroadcast_transaction(transaction, &active_short_address).await?;
+ let file_path = unbroadcast_dir()
+ .await?
+ .join(&review.file_name)
+ .to_string_lossy()
+ .into_owned();
+ Ok(SavedLoanOfferView { review, file_path })
+}
+
+#[tauri::command]
+async fn active_loan_contracts(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ load_active_loan_contracts(&state, &broadcast_node).await
+}
+
+#[tauri::command]
+async fn loan_contracts(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ load_loan_contracts_for_active_wallet(&state, &broadcast_node).await
+}
+
+#[tauri::command]
+async fn save_loan_payment_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ contract_hash: String,
+ payback_amount: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction = build_loan_payment_json(
+ &state,
+ wallet_key,
+ &broadcast_node,
+ contract_hash,
+ payback_amount,
+ )
+ .await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_loan_payment_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ contract_hash: String,
+ payback_amount: String,
+) -> Result {
+ let transaction = build_loan_payment_json(
+ &state,
+ wallet_key,
+ &broadcast_node,
+ contract_hash,
+ payback_amount,
+ )
+ .await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize loan payment: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Loan payment broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn claimable_collateral_contracts(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+) -> Result, String> {
+ load_claimable_collateral_contracts(&state, &broadcast_node).await
+}
+
+#[tauri::command]
+async fn save_collateral_claim_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ contract_hash: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction =
+ build_collateral_claim_json(&state, wallet_key, &broadcast_node, contract_hash).await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_collateral_claim_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ contract_hash: String,
+) -> Result {
+ let transaction =
+ build_collateral_claim_json(&state, wallet_key, &broadcast_node, contract_hash).await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(str::to_string);
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize collateral claim: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Collateral claim broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ Ok(BroadcastUnbroadcastResult {
+ response: String::from_utf8_lossy(&response).trim().to_string(),
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn save_issue_token_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ ticker: String,
+ number: String,
+ txfee: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state)?.0;
+ let transaction =
+ build_issue_token_json(&state, wallet_key, &broadcast_node, ticker, number, txfee).await?;
+ save_json_unbroadcast_transaction(transaction, &active_short_address).await
+}
+
+#[tauri::command]
+async fn broadcast_issue_token_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ ticker: String,
+ number: String,
+ txfee: String,
+) -> Result {
+ let transaction =
+ build_issue_token_json(&state, wallet_key, &broadcast_node, ticker, number, txfee).await?;
+ let txid = transaction
+ .get("hash")
+ .and_then(|value| value.as_str())
+ .map(|hash| hash.to_string());
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction for broadcast: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Transaction broadcast failed",
+ )
+ .await?;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ Ok(BroadcastUnbroadcastResult {
+ response: response_text,
+ txid,
+ })
+}
+
+#[tauri::command]
+async fn list_unbroadcast_transactions(
+ state: State<'_, WalletState>,
+) -> Result, String> {
+ let active_short_address = active_wallet_rpc_parts(&state).ok().map(|parts| parts.0);
+ let dir = unbroadcast_dir().await?;
+ let mut entries = read_dir(&dir)
+ .await
+ .map_err(|err| format!("Unable to read unbroadcast transaction directory: {err}"))?;
+ let mut transactions = Vec::new();
+
+ while let Some(entry) = entries
+ .next_entry()
+ .await
+ .map_err(|err| format!("Unable to read unbroadcast transaction entry: {err}"))?
+ {
+ let path = entry.path();
+ if !path
+ .extension()
+ .and_then(|extension| extension.to_str())
+ .is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
+ {
+ continue;
+ }
+ let Some(file_name) = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .map(|name| name.to_string())
+ else {
+ continue;
+ };
+ let Ok(contents) = read_to_string(&path).await else {
+ continue;
+ };
+ let Ok(transaction) = serde_json::from_str::(&contents) else {
+ continue;
+ };
+ let review =
+ build_unbroadcast_review(file_name, transaction, active_short_address.as_deref()).await;
+ transactions.push(UnbroadcastTransactionListItem {
+ file_name: review.file_name,
+ transaction_type: review.transaction_type,
+ type_name: review.type_name,
+ txid: review.txid,
+ summary: review.summary,
+ status: review.status,
+ status_message: review.status_message,
+ can_sign: review.can_sign,
+ can_broadcast: review.can_broadcast,
+ });
+ }
+
+ transactions.sort_by(|left, right| left.file_name.cmp(&right.file_name));
+ Ok(transactions)
+}
+
+#[tauri::command]
+async fn load_unbroadcast_transaction(
+ state: State<'_, WalletState>,
+ file_name: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state).ok().map(|parts| parts.0);
+ let (_, transaction) = read_unbroadcast_json(&file_name).await?;
+ build_unbroadcast_review(
+ validate_unbroadcast_file_name(&file_name)?,
+ transaction,
+ active_short_address.as_deref(),
+ )
+ .await
+ .pipe(Ok)
+}
+
+#[tauri::command]
+async fn sign_unbroadcast_transaction(
+ state: State<'_, WalletState>,
+ wallet_key: Option,
+ broadcast_node: String,
+ file_name: String,
+) -> Result {
+ let (active_short_address, private_key) =
+ active_wallet_signing_parts(&state, wallet_key).await?;
+ let (path, mut transaction) = read_unbroadcast_json(&file_name).await?;
+ let txtype = transaction
+ .get("txtype")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u8;
+
+ match txtype {
+ 6 => {
+ validate_imported_transaction(&state, &broadcast_node, &transaction).await?;
+ let unsigned_swap = rebuild_swap(&transaction).await?;
+ let computed_hash = unsigned_swap.hash().await;
+ let json_hash = optional_string(&transaction, "hash");
+ if !json_hash.is_empty() && json_hash != computed_hash {
+ return Err("Swap hash does not match the transaction fields.".to_string());
+ }
+
+ let signature = unsigned_swap
+ .hash_and_sign(&private_key)
+ .await
+ .map_err(|err| format!("Failed to sign swap: {err}"))?;
+ let signature1 = optional_string(&transaction, "signature1");
+ let signature2 = optional_string(&transaction, "signature2");
+ if signature1.is_empty() {
+ let signer = optional_string(&transaction, "sender1");
+ if active_short_address.trim() != signer.trim() {
+ return Err(format!("This swap needs sender1 signature from {signer}."));
+ }
+ transaction["signature1"] = JsonValue::String(signature);
+ } else if signature2.is_empty() {
+ let signer = optional_string(&transaction, "sender2");
+ if active_short_address.trim() != signer.trim() {
+ return Err(format!("This swap needs sender2 signature from {signer}."));
+ }
+ transaction["signature2"] = JsonValue::String(signature);
+ } else {
+ return Err("Swap already has both signatures.".to_string());
+ }
+ transaction["hash"] = JsonValue::String(computed_hash);
+ }
+ 7 => {
+ validate_imported_transaction(&state, &broadcast_node, &transaction).await?;
+ let unsigned_loan = rebuild_loan(&transaction).await?;
+ let (computed_hash, signature) = unsigned_loan
+ .hash_and_sign(&private_key)
+ .await
+ .map_err(|err| format!("Failed to sign loan: {err}"))?;
+ let json_hash = optional_string(&transaction, "hash");
+ if !json_hash.is_empty() && json_hash != computed_hash {
+ return Err("Loan hash does not match the transaction fields.".to_string());
+ }
+
+ let signature1 = optional_string(&transaction, "signature1");
+ let signature2 = optional_string(&transaction, "signature2");
+ if signature1.is_empty() {
+ let signer = optional_string(&transaction, "lender");
+ if active_short_address.trim() != signer.trim() {
+ return Err(format!("This loan needs lender signature from {signer}."));
+ }
+ transaction["signature1"] = JsonValue::String(signature);
+ } else if signature2.is_empty() {
+ let signer = optional_string(&transaction, "borrower");
+ if active_short_address.trim() != signer.trim() {
+ return Err(format!("This loan needs borrower signature from {signer}."));
+ }
+ transaction["signature2"] = JsonValue::String(signature);
+ } else {
+ return Err("Loan already has both signatures.".to_string());
+ }
+ transaction["hash"] = JsonValue::String(computed_hash);
+ }
+ _ => {
+ return Err("Only swaps and loans support adding a second signature.".to_string());
+ }
+ }
+
+ let output = serde_json::to_string_pretty(&transaction)
+ .map_err(|err| format!("Failed to serialize signed transaction: {err}"))?;
+ blockchain::tokio::fs::write(&path, output)
+ .await
+ .map_err(|err| format!("Failed to save signed transaction: {err}"))?;
+
+ build_unbroadcast_review(
+ validate_unbroadcast_file_name(&file_name)?,
+ transaction,
+ Some(&active_short_address),
+ )
+ .await
+ .pipe(Ok)
+}
+
+#[tauri::command]
+async fn broadcast_unbroadcast_transaction(
+ state: State<'_, WalletState>,
+ broadcast_node: String,
+ file_name: String,
+) -> Result {
+ let active_short_address = active_wallet_rpc_parts(&state).ok().map(|parts| parts.0);
+ let (_, transaction) = read_unbroadcast_json(&file_name).await?;
+ let txtype = transaction
+ .get("txtype")
+ .and_then(|value| value.as_u64())
+ .unwrap_or_default() as u8;
+ if matches!(txtype, 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12) {
+ validate_imported_transaction(&state, &broadcast_node, &transaction).await?;
+ }
+ let review = build_unbroadcast_review(
+ validate_unbroadcast_file_name(&file_name)?,
+ transaction.clone(),
+ active_short_address.as_deref(),
+ )
+ .await;
+ if !review.can_broadcast {
+ return Err(review.status_message);
+ }
+
+ let socket_address = active_broadcast_socket(&broadcast_node)?;
+ let (_short_address, public_key, private_key) = active_wallet_rpc_parts(&state)?;
+ let command_input = serde_json::to_string(&transaction)
+ .map_err(|err| format!("Failed to serialize transaction for broadcast: {err}"))?;
+ let response = serialized_wallet_rpc(
+ &state,
+ socket_address,
+ command_input,
+ 8,
+ public_key,
+ private_key,
+ "Transaction broadcast failed",
+ )
+ .await?;
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ persist_active_wallet_vanity_address(&state, &transaction).await;
+
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+ let dir = unbroadcast_dir().await?;
+ let path = dir.join(validate_unbroadcast_file_name(&file_name)?);
+ blockchain::tokio::fs::remove_file(&path)
+ .await
+ .map_err(|err| {
+ format!("Transaction broadcast completed, but local copy could not be deleted: {err}")
+ })?;
+
+ Ok(BroadcastUnbroadcastResult {
+ response: response_text,
+ txid: review.txid,
+ })
+}
+
+#[tauri::command]
+async fn delete_unbroadcast_transaction(file_name: String) -> Result<(), String> {
+ let file_name = validate_unbroadcast_file_name(&file_name)?;
+ let dir = unbroadcast_dir().await?;
+ let path = dir.join(file_name);
+ blockchain::tokio::fs::remove_file(&path)
+ .await
+ .map_err(|err| format!("Unable to delete unbroadcast transaction: {err}"))
+}
diff --git a/src/wallet_app/commands_wallet.rs b/src/wallet_app/commands_wallet.rs
new file mode 100644
index 0000000..7df3fcb
--- /dev/null
+++ b/src/wallet_app/commands_wallet.rs
@@ -0,0 +1,763 @@
+#[tauri::command]
+fn get_app_status() -> AppStatus {
+ AppStatus {
+ app_name: "Contractless Wallet",
+ network: "testnet",
+ bridge: "ready",
+ }
+}
+
+#[tauri::command]
+async fn create_wallet(
+ state: State<'_, WalletState>,
+ network: String,
+ wallet_name: String,
+ wallet_key: String,
+) -> Result {
+ let wallet_key = wallet_key.trim().to_string();
+ if wallet_key.is_empty() {
+ return Err("Wallet key cannot be empty.".to_string());
+ }
+ let wallet_filename = normalize_wallet_filename(&wallet_name)?;
+ let network = GuiNetwork::parse(&network)?;
+
+ let wallet_dir = app_wallet_dir(network)?;
+
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let wallet_path = wallet_dir.join(&wallet_filename);
+ if metadata(&wallet_path).await.is_ok() {
+ return Err(format!("A wallet named {wallet_filename} already exists."));
+ }
+
+ let wallet_path_string = wallet_path.to_string_lossy().into_owned();
+ let wallet = create_wallet_file(&wallet_path, wallet_key)
+ .await
+ .map_err(|err| format!("Wallet creation failed: {err}"))?;
+
+ let view = wallet_view(wallet_filename.clone(), wallet_path_string.clone(), &wallet).await;
+ state.set_active(ActiveWallet {
+ wallet_name: wallet_filename,
+ wallet_path: wallet_path_string,
+ wallet,
+ })?;
+
+ Ok(view)
+}
+
+#[tauri::command]
+async fn list_wallets(network: String) -> Result, String> {
+ let network = GuiNetwork::parse(&network)?;
+ let wallet_dir = app_wallet_dir(network)?;
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let mut entries = read_dir(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to read wallet directory: {err}"))?;
+ let mut wallets = Vec::new();
+
+ while let Some(entry) = entries
+ .next_entry()
+ .await
+ .map_err(|err| format!("Unable to read wallet entry: {err}"))?
+ {
+ let path = entry.path();
+ if path
+ .extension()
+ .and_then(|extension| extension.to_str())
+ .is_some_and(|extension| extension.eq_ignore_ascii_case("wallet"))
+ {
+ wallets.push(WalletListItem {
+ wallet_name: wallet_name_from_path(&path)?,
+ wallet_path: path.to_string_lossy().into_owned(),
+ });
+ }
+ }
+
+ wallets.sort_by(|left, right| {
+ left.wallet_name
+ .to_ascii_lowercase()
+ .cmp(&right.wallet_name.to_ascii_lowercase())
+ });
+ Ok(wallets)
+}
+
+#[tauri::command]
+async fn select_wallet_file(network: String) -> Result, String> {
+ let network = GuiNetwork::parse(&network)?;
+ let wallet_dir = app_wallet_dir(network)?;
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let selected = FileDialog::new()
+ .set_location(&wallet_dir)
+ .add_filter("Contractless Wallet", &["wallet"])
+ .show_open_single_file()
+ .map_err(|err| format!("Unable to open wallet file picker: {err}"))?;
+
+ selected
+ .map(|path| {
+ Ok(WalletListItem {
+ wallet_name: wallet_name_from_path(&path)?,
+ wallet_path: path.to_string_lossy().into_owned(),
+ })
+ })
+ .transpose()
+}
+
+#[tauri::command]
+async fn select_private_key_image(network: String) -> Result, String> {
+ let network = GuiNetwork::parse(&network)?;
+ let wallet_dir = app_wallet_dir(network)?;
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let selected = FileDialog::new()
+ .set_location(&wallet_dir)
+ .add_filter("PNG Image", &["png"])
+ .show_open_single_file()
+ .map_err(|err| format!("Unable to open private key image picker: {err}"))?;
+
+ selected
+ .map(|path| {
+ Ok(SelectedFile {
+ file_name: wallet_name_from_path(&path)?,
+ file_path: path.to_string_lossy().into_owned(),
+ })
+ })
+ .transpose()
+}
+
+#[tauri::command]
+async fn load_wallet(
+ state: State<'_, WalletState>,
+ wallet_path: String,
+ wallet_key: String,
+) -> Result {
+ let wallet_path = wallet_path.trim().to_string();
+ let wallet_key = wallet_key.trim().to_string();
+ if wallet_path.is_empty() {
+ return Err("Wallet path cannot be empty.".to_string());
+ }
+ if wallet_key.is_empty() {
+ return Err("Wallet key cannot be empty.".to_string());
+ }
+
+ let path = PathBuf::from(&wallet_path);
+ if metadata(&path).await.is_err() {
+ return Err("Wallet file was not found.".to_string());
+ }
+
+ let wallet = Wallet::private_key_from_wallet(&path, wallet_key)
+ .await
+ .map_err(|err| format!("Wallet loading failed: {err}"))?;
+ let wallet_name = wallet_name_from_path(&path)?;
+ let view = wallet_view(wallet_name.clone(), wallet_path.clone(), &wallet).await;
+ state.set_active(ActiveWallet {
+ wallet_name,
+ wallet_path,
+ wallet,
+ })?;
+
+ Ok(view)
+}
+
+#[tauri::command]
+async fn import_private_key_wallet(
+ state: State<'_, WalletState>,
+ network: String,
+ wallet_name: String,
+ wallet_key: String,
+ private_key: String,
+) -> Result {
+ let wallet_key = wallet_key.trim().to_string();
+ if wallet_key.is_empty() {
+ return Err("Wallet key cannot be empty.".to_string());
+ }
+ let wallet_filename = normalize_wallet_filename(&wallet_name)?;
+ let network = GuiNetwork::parse(&network)?;
+ let wallet_dir = app_wallet_dir(network)?;
+
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let wallet_path = wallet_dir.join(&wallet_filename);
+ if metadata(&wallet_path).await.is_ok() {
+ return Err(format!("A wallet named {wallet_filename} already exists."));
+ }
+
+ let wallet_path_string = wallet_path.to_string_lossy().into_owned();
+ let wallet = import_private_key_file(&wallet_path, wallet_key, private_key)
+ .await
+ .map_err(|err| format!("Private key import failed: {err}"))?;
+
+ let view = wallet_view(wallet_filename.clone(), wallet_path_string.clone(), &wallet).await;
+ state.set_active(ActiveWallet {
+ wallet_name: wallet_filename,
+ wallet_path: wallet_path_string,
+ wallet,
+ })?;
+
+ Ok(view)
+}
+
+#[tauri::command]
+async fn import_private_key_image_wallet(
+ state: State<'_, WalletState>,
+ network: String,
+ wallet_name: String,
+ wallet_key: String,
+ image_path: String,
+) -> Result {
+ let wallet_key = wallet_key.trim().to_string();
+ let image_path = image_path.trim().to_string();
+ if wallet_key.is_empty() {
+ return Err("Wallet key cannot be empty.".to_string());
+ }
+ if image_path.is_empty() {
+ return Err("Private key image path cannot be empty.".to_string());
+ }
+
+ let wallet_filename = normalize_wallet_filename(&wallet_name)?;
+ let network = GuiNetwork::parse(&network)?;
+ let wallet_dir = app_wallet_dir(network)?;
+
+ create_dir_all(&wallet_dir)
+ .await
+ .map_err(|err| format!("Unable to create wallet directory: {err}"))?;
+
+ let wallet_path = wallet_dir.join(&wallet_filename);
+ if metadata(&wallet_path).await.is_ok() {
+ return Err(format!("A wallet named {wallet_filename} already exists."));
+ }
+
+ let image_path = PathBuf::from(&image_path);
+ if metadata(&image_path).await.is_err() {
+ return Err("Private key image file was not found.".to_string());
+ }
+
+ let private_key = private_key_from_png_image(&image_path, &wallet_key).await?;
+ let wallet_path_string = wallet_path.to_string_lossy().into_owned();
+ let wallet = import_private_key_file(&wallet_path, wallet_key, private_key)
+ .await
+ .map_err(|err| format!("Private key image import failed: {err}"))?;
+
+ let view = wallet_view(wallet_filename.clone(), wallet_path_string.clone(), &wallet).await;
+ state.set_active(ActiveWallet {
+ wallet_name: wallet_filename,
+ wallet_path: wallet_path_string,
+ wallet,
+ })?;
+
+ Ok(view)
+}
+
+#[tauri::command]
+fn lock_wallet(state: State<'_, WalletState>) -> Result<(), String> {
+ state.clear()
+}
+
+#[tauri::command]
+async fn list_broadcast_nodes() -> Result, String> {
+ read_piggyback_nodes().await
+}
+
+fn active_wallet_snapshot(
+ state: &State<'_, WalletState>,
+) -> Result<(String, String, String, Option, String, String), String> {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+
+ Ok((
+ active_wallet.wallet_name.clone(),
+ active_wallet.wallet_path.clone(),
+ active_wallet.wallet.saved.short_address.clone(),
+ active_wallet.wallet.saved.vanity_address.clone(),
+ active_wallet.wallet.saved.public_key.clone(),
+ active_wallet.wallet.saved.private_key.clone(),
+ ))
+}
+
+async fn verified_private_key_from_active_wallet(
+ state: &State<'_, WalletState>,
+ wallet_key: String,
+) -> Result<(String, String, Option, String, String), String> {
+ let wallet_key = wallet_key.trim().to_string();
+ if wallet_key.is_empty() {
+ return Err("Wallet encryption key cannot be empty.".to_string());
+ }
+
+ let (wallet_name, wallet_path, short_address, vanity_address, public_key, _) =
+ active_wallet_snapshot(state)?;
+ let wallet = Wallet::private_key_from_wallet(&PathBuf::from(&wallet_path), wallet_key)
+ .await
+ .map_err(|_| "Wallet encryption key did not decrypt this wallet.".to_string())?;
+
+ Ok((
+ wallet_name,
+ short_address,
+ vanity_address,
+ public_key,
+ wallet.saved.private_key,
+ ))
+}
+
+#[tauri::command]
+async fn backup_active_wallet_image(state: State<'_, WalletState>) -> Result, String> {
+ let (wallet_name, wallet_path, _short_address, _vanity_address, _public_key, _private_key) =
+ active_wallet_snapshot(&state)?;
+ let image_base64 = saved_private_key_image(&wallet_path)
+ .await
+ .ok_or_else(|| "This wallet does not contain a private key image.".to_string())?;
+ let image_bytes = STANDARD
+ .decode(image_base64.as_bytes())
+ .map_err(|err| format!("Private key image data was not valid base64: {err}"))?;
+ let default_name = format!(
+ "{}-private-key-image.png",
+ wallet_name.trim_end_matches(".wallet")
+ );
+
+ let selected = FileDialog::new()
+ .set_filename(&default_name)
+ .add_filter("PNG Image", &["png"])
+ .show_save_single_file()
+ .map_err(|err| format!("Unable to open image backup save dialog: {err}"))?;
+
+ let Some(mut path) = selected else {
+ return Ok(None);
+ };
+ if path.extension().is_none() {
+ path.set_extension("png");
+ }
+
+ blockchain::tokio::fs::write(&path, image_bytes)
+ .await
+ .map_err(|err| format!("Unable to save wallet image backup: {err}"))?;
+ Ok(Some(path.to_string_lossy().into_owned()))
+}
+
+#[tauri::command]
+async fn backup_active_wallet_private_key(
+ state: State<'_, WalletState>,
+ wallet_key: String,
+) -> Result, String> {
+ let (wallet_name, short_address, vanity_address, public_key, private_key) =
+ verified_private_key_from_active_wallet(&state, wallet_key).await?;
+ let default_name = format!(
+ "{}-private-key.txt",
+ wallet_name.trim_end_matches(".wallet")
+ );
+ let contents = format!(
+ "Contractless Wallet Private Key Backup\n\nWallet: {wallet_name}\nAddress: {short_address}\nVanity Address: {}\nPublic Key: {public_key}\nPrivate Key: {private_key}\n",
+ vanity_address.unwrap_or_else(|| "N/A".to_string())
+ );
+
+ let selected = FileDialog::new()
+ .set_filename(&default_name)
+ .add_filter("Text", &["txt"])
+ .show_save_single_file()
+ .map_err(|err| format!("Unable to open private key backup save dialog: {err}"))?;
+
+ let Some(mut path) = selected else {
+ return Ok(None);
+ };
+ if path.extension().is_none() {
+ path.set_extension("txt");
+ }
+
+ blockchain::tokio::fs::write(&path, contents)
+ .await
+ .map_err(|err| format!("Unable to save private key backup: {err}"))?;
+ Ok(Some(path.to_string_lossy().into_owned()))
+}
+
+#[tauri::command]
+async fn printable_wallet_backup(
+ state: State<'_, WalletState>,
+ wallet_key: String,
+) -> Result {
+ let wallet_key = wallet_key.trim().to_string();
+ let (wallet_name, short_address, vanity_address, public_key, private_key) =
+ verified_private_key_from_active_wallet(&state, wallet_key.clone()).await?;
+
+ Ok(WalletPrintBackupView {
+ wallet_name,
+ short_address,
+ vanity_address,
+ public_key,
+ private_key,
+ encryption_key: wallet_key,
+ })
+}
+
+fn unquote_ini_value(value: &str) -> String {
+ value.trim().trim_matches('"').trim_matches('\'').to_string()
+}
+
+fn quote_ini_value(value: &str) -> String {
+ format!("\"{}\"", value.replace('\\', "/").replace('"', "\\\""))
+}
+
+fn ini_value(settings: &str, section: &str, key: &str) -> Option {
+ let mut in_section = false;
+ for line in settings.lines() {
+ let trimmed = line.trim();
+ if trimmed.starts_with('[') && trimmed.ends_with(']') {
+ in_section = trimmed[1..trimmed.len() - 1].eq_ignore_ascii_case(section);
+ continue;
+ }
+ if !in_section || trimmed.starts_with(';') || trimmed.starts_with('#') {
+ continue;
+ }
+ let Some((candidate_key, value)) = trimmed.split_once('=') else {
+ continue;
+ };
+ if candidate_key.trim().eq_ignore_ascii_case(key) {
+ return Some(unquote_ini_value(value));
+ }
+ }
+ None
+}
+
+fn bool_ini_value(settings: &str, section: &str, key: &str, default: bool) -> bool {
+ ini_value(settings, section, key)
+ .map(|value| matches!(value.to_ascii_lowercase().as_str(), "true" | "1" | "yes"))
+ .unwrap_or(default)
+}
+
+fn default_storage_path(wallet_path: &str, folder_name: &str) -> String {
+ let wallet_path = wallet_path.trim();
+ if wallet_path.is_empty() {
+ return folder_name.to_string();
+ }
+
+ let path = PathBuf::from(wallet_path);
+ let base = path
+ .parent()
+ .map(PathBuf::from)
+ .unwrap_or_else(|| path.clone());
+ base.join(folder_name).to_string_lossy().replace('\\', "/")
+}
+
+fn replace_ini_section(settings: &str, section: &str, entries: &[(String, String)]) -> String {
+ let mut output = Vec::new();
+ let mut in_section = false;
+ let mut found = false;
+ let mut wrote = false;
+
+ for line in settings.lines() {
+ let trimmed = line.trim();
+ let is_section = trimmed.starts_with('[') && trimmed.ends_with(']');
+ if is_section {
+ if in_section && !wrote {
+ for (key, value) in entries {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ wrote = true;
+ }
+ in_section = trimmed[1..trimmed.len() - 1].eq_ignore_ascii_case(section);
+ if in_section {
+ found = true;
+ output.push(format!("[{section}]"));
+ continue;
+ }
+ }
+
+ if in_section {
+ continue;
+ }
+ output.push(line.to_string());
+ }
+
+ if in_section && !wrote {
+ for (key, value) in entries {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ }
+
+ if !found {
+ if !output.last().is_some_and(|line| line.trim().is_empty()) {
+ output.push(String::new());
+ }
+ output.push(format!("[{section}]"));
+ for (key, value) in entries {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ }
+
+ output.join("\n") + "\n"
+}
+
+fn replace_ini_keys(settings: &str, section: &str, entries: &[(String, String)]) -> String {
+ let mut output = Vec::new();
+ let mut in_section = false;
+ let mut found_section = false;
+ let mut written = std::collections::HashSet::new();
+
+ for line in settings.lines() {
+ let trimmed = line.trim();
+ let is_section = trimmed.starts_with('[') && trimmed.ends_with(']');
+ if is_section {
+ if in_section {
+ for (key, value) in entries {
+ if !written.contains(&key.to_ascii_lowercase()) {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ }
+ }
+ in_section = trimmed[1..trimmed.len() - 1].eq_ignore_ascii_case(section);
+ found_section |= in_section;
+ output.push(line.to_string());
+ continue;
+ }
+
+ if in_section {
+ if let Some((candidate_key, _)) = trimmed.split_once('=') {
+ if let Some((key, value)) = entries
+ .iter()
+ .find(|(key, _)| key.eq_ignore_ascii_case(candidate_key.trim()))
+ {
+ output.push(format!("{key:<20} = {value}"));
+ written.insert(key.to_ascii_lowercase());
+ continue;
+ }
+ }
+ }
+ output.push(line.to_string());
+ }
+
+ if in_section {
+ for (key, value) in entries {
+ if !written.contains(&key.to_ascii_lowercase()) {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ }
+ }
+
+ if !found_section {
+ if !output.last().is_some_and(|line| line.trim().is_empty()) {
+ output.push(String::new());
+ }
+ output.push(format!("[{section}]"));
+ for (key, value) in entries {
+ output.push(format!("{key:<20} = {value}"));
+ }
+ }
+
+ output.join("\n") + "\n"
+}
+
+#[tauri::command]
+async fn read_gui_settings() -> Result {
+ ensure_gui_settings_file().await?;
+ let settings_path = gui_settings_path()?;
+ let settings = read_to_string(&settings_path)
+ .await
+ .map_err(|err| format!("Unable to read GUI settings.ini: {err}"))?;
+ let nodes = read_piggyback_nodes().await?;
+ let default_node = nodes
+ .first()
+ .map(|node| node.address.clone())
+ .unwrap_or_else(|| "contractless.dev:50050".to_string());
+
+ let wallet_path = ini_value(&settings, "Paths", "WALLET_PATH").unwrap_or_default();
+ let unbroadcast_transactions_path = ini_value(&settings, "Paths", "UNBROADCAST_TRANSACTIONS")
+ .filter(|path| !path.trim().is_empty())
+ .unwrap_or_else(|| default_storage_path(&wallet_path, "unbroadcast"));
+ let address_book_path = ini_value(&settings, "Paths", "ADDRESS_BOOK")
+ .filter(|path| !path.trim().is_empty())
+ .unwrap_or_else(|| default_storage_path(&wallet_path, "address_book"));
+
+ Ok(GuiSettingsView {
+ wallet_path,
+ unbroadcast_transactions_path,
+ address_book_path,
+ default_node,
+ saved_nodes: nodes.into_iter().map(|node| node.address).collect(),
+ ipfs_gateway: ini_value(&settings, "GUI", "IPFS_GATEWAY")
+ .or_else(|| ini_value(&settings, "GUI", "METADATA_GATEWAY"))
+ .or_else(|| ini_value(&settings, "GUI", "IMAGE_GATEWAY"))
+ .unwrap_or_else(|| "https://gateway.pinata.cloud/ipfs/".to_string()),
+ auto_load_trusted_nft_images: bool_ini_value(
+ &settings,
+ "GUI",
+ "AUTO_LOAD_TRUSTED_NFT_IMAGES",
+ false,
+ ),
+ auto_lock_timeout: ini_value(&settings, "GUI", "AUTO_LOCK_TIMEOUT")
+ .unwrap_or_else(|| "15 minutes".to_string()),
+ clipboard_clear_timeout: ini_value(&settings, "GUI", "CLIPBOARD_CLEAR_TIMEOUT")
+ .unwrap_or_else(|| "60 seconds".to_string()),
+ require_key_before_signing: bool_ini_value(
+ &settings,
+ "GUI",
+ "REQUIRE_KEY_BEFORE_SIGNING",
+ true,
+ ),
+ settings_path: settings_path.to_string_lossy().into_owned(),
+ })
+}
+
+#[tauri::command]
+async fn save_gui_settings(settings: GuiSettingsView) -> Result<(), String> {
+ ensure_gui_settings_file().await?;
+ let settings_path = gui_settings_path()?;
+ let current = read_to_string(&settings_path)
+ .await
+ .map_err(|err| format!("Unable to read GUI settings.ini: {err}"))?;
+
+ let mut nodes = Vec::new();
+ if !settings.default_node.trim().is_empty() {
+ nodes.push(settings.default_node.trim().to_string());
+ }
+ for node in settings.saved_nodes {
+ let node = node.trim();
+ if !node.is_empty() && !nodes.iter().any(|known| known.eq_ignore_ascii_case(node)) {
+ nodes.push(node.to_string());
+ }
+ }
+
+ let wallet_path = settings.wallet_path.trim().to_string();
+ let unbroadcast_transactions_path = if settings.unbroadcast_transactions_path.trim().is_empty()
+ {
+ default_storage_path(&wallet_path, "unbroadcast")
+ } else {
+ settings.unbroadcast_transactions_path.trim().to_string()
+ };
+ let address_book_path = if settings.address_book_path.trim().is_empty() {
+ default_storage_path(&wallet_path, "address_book")
+ } else {
+ settings.address_book_path.trim().to_string()
+ };
+
+ let path_entries = vec![
+ ("WALLET_PATH".to_string(), quote_ini_value(&wallet_path)),
+ (
+ "UNBROADCAST_TRANSACTIONS".to_string(),
+ quote_ini_value(&unbroadcast_transactions_path),
+ ),
+ (
+ "ADDRESS_BOOK".to_string(),
+ quote_ini_value(&address_book_path),
+ ),
+ ];
+ let piggyback_entries: Vec<(String, String)> = nodes
+ .iter()
+ .enumerate()
+ .map(|(index, node)| (format!("PIGGYBACK_{}", index + 1), quote_ini_value(node)))
+ .collect();
+ let gui_entries = vec![
+ (
+ "IPFS_GATEWAY".to_string(),
+ quote_ini_value(&settings.ipfs_gateway),
+ ),
+ (
+ "AUTO_LOAD_TRUSTED_NFT_IMAGES".to_string(),
+ quote_ini_value(if settings.auto_load_trusted_nft_images {
+ "true"
+ } else {
+ "false"
+ }),
+ ),
+ (
+ "AUTO_LOCK_TIMEOUT".to_string(),
+ quote_ini_value(&settings.auto_lock_timeout),
+ ),
+ (
+ "CLIPBOARD_CLEAR_TIMEOUT".to_string(),
+ quote_ini_value(&settings.clipboard_clear_timeout),
+ ),
+ (
+ "REQUIRE_KEY_BEFORE_SIGNING".to_string(),
+ quote_ini_value(if settings.require_key_before_signing {
+ "true"
+ } else {
+ "false"
+ }),
+ ),
+ ];
+
+ let updated = replace_ini_keys(¤t, "Paths", &path_entries);
+ let updated = replace_ini_section(&updated, "Piggyback", &piggyback_entries);
+ let updated = replace_ini_section(&updated, "GUI", &gui_entries);
+
+ blockchain::tokio::fs::write(&settings_path, updated)
+ .await
+ .map_err(|err| format!("Unable to write GUI settings.ini: {err}"))
+}
+
+#[tauri::command]
+fn select_settings_path(kind: String, current_path: String) -> Result, String> {
+ let mut dialog = FileDialog::new();
+ let current = PathBuf::from(current_path.trim());
+ let mut location_path: Option = None;
+ if current.exists() {
+ let location = if current.is_dir() {
+ current
+ } else {
+ current.parent().map(PathBuf::from).unwrap_or(current)
+ };
+ location_path = Some(location);
+ }
+ if let Some(location) = &location_path {
+ dialog = dialog.set_location(location);
+ }
+
+ let selected = match kind.trim().to_ascii_lowercase().as_str() {
+ "folder" => dialog
+ .show_open_single_dir()
+ .map_err(|err| format!("Unable to open folder picker: {err}"))?,
+ "file" => dialog
+ .show_open_single_file()
+ .map_err(|err| format!("Unable to open file picker: {err}"))?,
+ _ => return Err("Settings path picker kind must be folder or file.".to_string()),
+ };
+
+ Ok(selected.map(|path| path.to_string_lossy().into_owned()))
+}
+
+#[tauri::command]
+async fn active_wallet(state: State<'_, WalletState>) -> Result, String> {
+ let active_wallet = {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+
+ guard.as_ref().map(|active_wallet| {
+ (
+ active_wallet.wallet_name.clone(),
+ active_wallet.wallet_path.clone(),
+ active_wallet.wallet.saved.short_address.clone(),
+ active_wallet.wallet.saved.vanity_address.clone(),
+ )
+ })
+ };
+
+ match active_wallet {
+ Some((wallet_name, wallet_path, short_address, vanity_address)) => Ok(Some(WalletView {
+ short_address_hex: Wallet::short_address_to_bytes(&short_address)
+ .map(encode)
+ .unwrap_or_default(),
+ wallet_name,
+ short_address,
+ vanity_address,
+ private_key_image: saved_private_key_image(&wallet_path).await,
+ wallet_path,
+ })),
+ None => Ok(None),
+ }
+}
+
diff --git a/src/wallet_app/rpc_scheduler.rs b/src/wallet_app/rpc_scheduler.rs
new file mode 100644
index 0000000..8cb6b9b
--- /dev/null
+++ b/src/wallet_app/rpc_scheduler.rs
@@ -0,0 +1,298 @@
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum WalletRpcPriority {
+ Foreground,
+ Background,
+}
+
+impl WalletRpcPriority {
+ fn rank(self) -> u8 {
+ match self {
+ Self::Foreground => 2,
+ Self::Background => 1,
+ }
+ }
+
+ fn minimum_spacing(self) -> Duration {
+ match self {
+ Self::Foreground => Duration::from_millis(50),
+ Self::Background => Duration::from_secs(2),
+ }
+ }
+}
+
+struct WalletRpcRequest {
+ socket_address: SocketAddr,
+ command_input: String,
+ rpc_command: usize,
+ public_key: String,
+ private_key: String,
+ error_prefix: String,
+}
+
+struct QueuedWalletRpcRequest {
+ priority: WalletRpcPriority,
+ sequence: u64,
+ generation: u64,
+ request: WalletRpcRequest,
+ responder: oneshot::Sender, String>>,
+}
+
+impl PartialEq for QueuedWalletRpcRequest {
+ fn eq(&self, other: &Self) -> bool {
+ self.priority == other.priority && self.sequence == other.sequence
+ }
+}
+
+impl Eq for QueuedWalletRpcRequest {}
+
+impl PartialOrd for QueuedWalletRpcRequest {
+ fn partial_cmp(&self, other: &Self) -> Option {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for QueuedWalletRpcRequest {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.priority
+ .rank()
+ .cmp(&other.priority.rank())
+ .then_with(|| other.sequence.cmp(&self.sequence))
+ }
+}
+
+#[derive(Default)]
+struct WalletRpcQueueState {
+ queue: BinaryHeap,
+ last_completed: Option,
+ draining: bool,
+ node_health: HashMap,
+}
+
+struct WalletRpcScheduler {
+ queue_state: AsyncMutex,
+ sequence: AtomicU64,
+ generation: AtomicU64,
+}
+
+#[derive(Default)]
+struct NodeRpcHealth {
+ consecutive_failures: u32,
+ backoff_until: Option,
+}
+
+impl WalletRpcScheduler {
+ const BACKGROUND_YIELD_CHECK: Duration = Duration::from_millis(50);
+
+ fn new() -> Self {
+ Self {
+ queue_state: AsyncMutex::new(WalletRpcQueueState::default()),
+ sequence: AtomicU64::new(1),
+ generation: AtomicU64::new(1),
+ }
+ }
+
+ fn bump_generation(&self) {
+ self.generation.fetch_add(1, AtomicOrdering::SeqCst);
+ }
+
+ fn current_generation(&self) -> u64 {
+ self.generation.load(AtomicOrdering::SeqCst)
+ }
+
+ async fn enqueue(
+ &self,
+ priority: WalletRpcPriority,
+ request: WalletRpcRequest,
+ ) -> Result, String> {
+ let sequence = self.sequence.fetch_add(1, AtomicOrdering::SeqCst);
+ let generation = self.current_generation();
+ let (sender, receiver) = oneshot::channel();
+
+ let should_drain = {
+ let mut state = self.queue_state.lock().await;
+ state.queue.push(QueuedWalletRpcRequest {
+ priority,
+ sequence,
+ generation,
+ request,
+ responder: sender,
+ });
+ if state.draining {
+ false
+ } else {
+ state.draining = true;
+ true
+ }
+ };
+
+ if should_drain {
+ self.drain_queue().await;
+ }
+
+ receiver
+ .await
+ .map_err(|_| "Wallet RPC scheduler dropped the response channel.".to_string())?
+ }
+
+ async fn drain_queue(&self) {
+ loop {
+ let queued = {
+ let mut state = self.queue_state.lock().await;
+ match state.queue.pop() {
+ Some(queued) => Some(queued),
+ None => {
+ state.draining = false;
+ None
+ }
+ }
+ };
+
+ let Some(queued) = queued else {
+ break;
+ };
+
+ if queued.generation != self.current_generation() {
+ let _ = queued.responder.send(Err(
+ "Wallet RPC request was cancelled by wallet state change.".to_string(),
+ ));
+ continue;
+ }
+
+ if self.should_yield_background(queued.priority).await {
+ self.requeue(queued).await;
+ continue;
+ }
+ if !self.wait_for_spacing(queued.priority).await {
+ self.requeue(queued).await;
+ continue;
+ }
+ if !self
+ .wait_for_node_backoff(queued.priority, queued.request.socket_address)
+ .await
+ {
+ self.requeue(queued).await;
+ continue;
+ }
+ let result = run_wallet_rpc_request(&queued.request).await;
+
+ {
+ let mut state = self.queue_state.lock().await;
+ state.last_completed = Some(Instant::now());
+ state.record_node_result(queued.request.socket_address, result.is_ok());
+ }
+
+ let _ = queued.responder.send(result);
+ }
+ }
+
+ async fn requeue(&self, queued: QueuedWalletRpcRequest) {
+ let mut state = self.queue_state.lock().await;
+ state.queue.push(queued);
+ }
+
+ async fn should_yield_background(&self, priority: WalletRpcPriority) -> bool {
+ if priority != WalletRpcPriority::Background {
+ return false;
+ }
+
+ let state = self.queue_state.lock().await;
+ state
+ .queue
+ .iter()
+ .any(|queued| queued.priority == WalletRpcPriority::Foreground)
+ }
+
+ async fn wait_for_spacing(&self, priority: WalletRpcPriority) -> bool {
+ loop {
+ if self.should_yield_background(priority).await {
+ return false;
+ }
+
+ let delay = {
+ let state = self.queue_state.lock().await;
+ let Some(last_completed) = state.last_completed else {
+ return true;
+ };
+ priority
+ .minimum_spacing()
+ .checked_sub(last_completed.elapsed())
+ };
+
+ let Some(delay) = delay else {
+ return true;
+ };
+
+ if delay.is_zero() {
+ return true;
+ }
+
+ sleep(delay.min(Self::BACKGROUND_YIELD_CHECK)).await;
+ }
+ }
+
+ async fn wait_for_node_backoff(
+ &self,
+ priority: WalletRpcPriority,
+ socket_address: SocketAddr,
+ ) -> bool {
+ loop {
+ if self.should_yield_background(priority).await {
+ return false;
+ }
+
+ let delay = {
+ let state = self.queue_state.lock().await;
+ state
+ .node_health
+ .get(&socket_address)
+ .and_then(|health| health.backoff_until)
+ .and_then(|until| until.checked_duration_since(Instant::now()))
+ };
+
+ let Some(delay) = delay else {
+ return true;
+ };
+
+ if delay.is_zero() {
+ return true;
+ }
+
+ sleep(delay.min(Self::BACKGROUND_YIELD_CHECK)).await;
+ }
+ }
+}
+
+impl WalletRpcQueueState {
+ fn record_node_result(&mut self, socket_address: SocketAddr, success: bool) {
+ let health = self.node_health.entry(socket_address).or_default();
+ if success {
+ health.consecutive_failures = 0;
+ health.backoff_until = None;
+ return;
+ }
+
+ health.consecutive_failures = health.consecutive_failures.saturating_add(1);
+ let seconds = match health.consecutive_failures {
+ 0 | 1 => 2,
+ 2 => 5,
+ 3 => 10,
+ _ => 20,
+ };
+ health.backoff_until = Some(Instant::now() + Duration::from_secs(seconds));
+ }
+}
+
+async fn run_wallet_rpc_request(request: &WalletRpcRequest) -> Result, String> {
+ handshake::connect_and_handshake(
+ request.socket_address,
+ request.command_input.clone(),
+ request.rpc_command,
+ HandshakeWallet::WalletParts {
+ public_key: request.public_key.clone(),
+ private_key: request.private_key.clone(),
+ },
+ generate_uid(),
+ )
+ .await
+ .map_err(|err| format!("{}: {err}", request.error_prefix))
+}
diff --git a/src/wallet_app/shared_rpc.rs b/src/wallet_app/shared_rpc.rs
new file mode 100644
index 0000000..928b5eb
--- /dev/null
+++ b/src/wallet_app/shared_rpc.rs
@@ -0,0 +1,411 @@
+fn parse_balance_response(response: Vec) -> Result, String> {
+ if response.is_empty() {
+ return Ok(Vec::new());
+ }
+
+ if response.len() % 27 != 0 {
+ let response_text = String::from_utf8_lossy(&response).trim().to_string();
+
+ if !response_text.is_empty() {
+ return Err(response_text);
+ }
+
+ return Err(format!(
+ "Balance response had an unexpected byte length: {}",
+ response.len()
+ ));
+ }
+
+ let mut balances = Vec::new();
+
+ for entry in response.chunks_exact(27) {
+ let asset = String::from_utf8_lossy(&entry[..15])
+ .trim_matches(char::from(0))
+ .trim()
+ .to_string();
+
+ let nft_series = u32::from_le_bytes(
+ entry[15..19]
+ .try_into()
+ .map_err(|_| "Failed to read NFT series from balance response.".to_string())?,
+ );
+
+ let balance = u64::from_le_bytes(
+ entry[19..27]
+ .try_into()
+ .map_err(|_| "Failed to read amount from balance response.".to_string())?,
+ );
+
+ balances.push(BalanceView {
+ asset,
+ nft_series,
+ balance: balance.to_string(),
+ });
+ }
+
+ Ok(balances)
+}
+
+fn active_broadcast_socket(broadcast_node: &str) -> Result {
+ let broadcast_node = broadcast_node.trim();
+ if broadcast_node.is_empty() {
+ return Err("Broadcast node cannot be empty.".to_string());
+ }
+
+ if let Ok(socket_address) = broadcast_node.parse::() {
+ return Ok(socket_address);
+ }
+
+ let (host, port) = broadcast_node
+ .rsplit_once(':')
+ .ok_or_else(|| "Broadcast node must include host and port.".to_string())?;
+ let port = port
+ .trim()
+ .parse::()
+ .map_err(|err| format!("Invalid broadcast node port: {err}"))?;
+
+ (host.trim(), port)
+ .to_socket_addrs()
+ .map_err(|err| format!("Unable to resolve broadcast node: {err}"))?
+ .next()
+ .ok_or_else(|| "Broadcast node did not resolve to an address.".to_string())
+}
+
+fn active_wallet_rpc_parts(
+ state: &State<'_, WalletState>,
+) -> Result<(String, String, String), String> {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+
+ Ok((
+ active_wallet.wallet.saved.short_address.clone(),
+ active_wallet.wallet.saved.public_key.clone(),
+ active_wallet.wallet.saved.private_key.clone(),
+ ))
+}
+
+fn active_wallet_cache_path(state: &State<'_, WalletState>) -> Result {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+ let wallet_path = PathBuf::from(&active_wallet.wallet_path);
+ let short_address_bytes =
+ Wallet::short_address_to_bytes(&active_wallet.wallet.saved.short_address)
+ .ok_or_else(|| "Active wallet short address is invalid.".to_string())?;
+ let cache_name = format!("{}.address_transactions.json", encode(short_address_bytes));
+
+ Ok(wallet_path.with_file_name(cache_name))
+}
+
+fn active_wallet_history_dir(state: &State<'_, WalletState>) -> Result {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+ let wallet_path = PathBuf::from(&active_wallet.wallet_path);
+ let short_address_bytes =
+ Wallet::short_address_to_bytes(&active_wallet.wallet.saved.short_address)
+ .ok_or_else(|| "Active wallet short address is invalid.".to_string())?;
+ let dir_name = format!("{}.address_transactions", encode(short_address_bytes));
+
+ Ok(wallet_path.with_file_name(dir_name))
+}
+
+fn active_wallet_nft_dir(state: &State<'_, WalletState>) -> Result {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+ let wallet_path = PathBuf::from(&active_wallet.wallet_path);
+ let short_address_bytes =
+ Wallet::short_address_to_bytes(&active_wallet.wallet.saved.short_address)
+ .ok_or_else(|| "Active wallet short address is invalid.".to_string())?;
+ let dir_name = format!("{}_nfts", encode(short_address_bytes));
+
+ Ok(wallet_path.with_file_name(dir_name))
+}
+
+fn active_wallet_address_book_path(state: &State<'_, WalletState>) -> Result {
+ let guard = state
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ let active_wallet = guard
+ .as_ref()
+ .ok_or_else(|| "No wallet is loaded.".to_string())?;
+ let wallet_path = PathBuf::from(&active_wallet.wallet_path);
+
+ Ok(wallet_path.with_file_name("address_book.json"))
+}
+
+fn validate_transaction_record_file(file_name: &str) -> Result {
+ let trimmed = file_name.trim();
+ if trimmed.len() != 13 || !trimmed.ends_with(".json") {
+ return Err("Transaction record filename must look like 00000001.json.".to_string());
+ }
+
+ if !trimmed[..8].bytes().all(|byte| byte.is_ascii_digit()) {
+ return Err("Transaction record filename must start with 8 digits.".to_string());
+ }
+
+ Ok(trimmed.to_string())
+}
+
+fn parse_error_response(response: &[u8]) -> Option {
+ let response_text = String::from_utf8_lossy(response).trim().to_string();
+ response_text.starts_with("error:").then_some(response_text)
+}
+
+fn parse_latest_transaction_response(
+ response: Vec,
+) -> Result, String> {
+ const MINER_EARNING_ASSET_BYTES: usize = 15;
+ const MINER_EARNING_ENTRY_BYTES: usize = 1 + MINER_EARNING_ASSET_BYTES + 4 + 8;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+
+ if response.len() < 4 {
+ return Err("Latest transaction response had an unexpected byte length.".to_string());
+ }
+
+ let count = u32::from_le_bytes(
+ response[0..4]
+ .try_into()
+ .map_err(|_| "Failed to parse transaction count.".to_string())?,
+ ) as usize;
+ let mut offset = 4usize;
+ let mut transactions = Vec::with_capacity(count);
+
+ for _ in 0..count {
+ if response.len().saturating_sub(offset) < 40 {
+ return Err("Latest transaction response entry was truncated.".to_string());
+ }
+ let txid = encode(&response[offset..offset + 32]);
+ offset += 32;
+ let block_height = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse transaction block height.".to_string())?,
+ );
+ offset += 4;
+ let tx_len = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse transaction byte length.".to_string())?,
+ ) as usize;
+ offset += 4;
+
+ if response.len().saturating_sub(offset) < tx_len {
+ return Err("Latest transaction payload was truncated.".to_string());
+ }
+ let transaction_bytes = response[offset..offset + tx_len].to_vec();
+ offset += tx_len;
+ let transaction_type = *transaction_bytes
+ .first()
+ .ok_or_else(|| "Latest transaction payload was empty.".to_string())?;
+
+ if response.len().saturating_sub(offset) < 4 {
+ return Err("Latest transaction miner earnings count was truncated.".to_string());
+ }
+ let earnings_count = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse miner earnings count.".to_string())?,
+ ) as usize;
+ offset += 4;
+
+ let earnings_bytes = earnings_count
+ .checked_mul(MINER_EARNING_ENTRY_BYTES)
+ .ok_or_else(|| "Miner earnings response length overflowed.".to_string())?;
+ if response.len().saturating_sub(offset) < earnings_bytes {
+ return Err("Latest transaction miner earnings were truncated.".to_string());
+ }
+
+ let mut miner_earnings = Vec::with_capacity(earnings_count);
+ for _ in 0..earnings_count {
+ let earning_type = response[offset];
+ offset += 1;
+ let asset =
+ String::from_utf8_lossy(&response[offset..offset + MINER_EARNING_ASSET_BYTES])
+ .trim()
+ .to_string();
+ offset += MINER_EARNING_ASSET_BYTES;
+ let nft_series = u32::from_le_bytes(
+ response[offset..offset + 4]
+ .try_into()
+ .map_err(|_| "Failed to parse miner earning NFT series.".to_string())?,
+ );
+ offset += 4;
+ let amount = u64::from_le_bytes(
+ response[offset..offset + 8]
+ .try_into()
+ .map_err(|_| "Failed to parse miner earning amount.".to_string())?,
+ );
+ offset += 8;
+ miner_earnings.push(MinerEarningView {
+ earning_type,
+ asset,
+ nft_series,
+ amount: amount.to_string(),
+ });
+ }
+
+ transactions.push(LatestAddressTransactionView {
+ txid,
+ block_height,
+ transaction_type,
+ transaction_bytes,
+ miner_earnings,
+ });
+ }
+
+ if offset != response.len() {
+ return Err("Latest transaction response had trailing bytes.".to_string());
+ }
+
+ Ok(transactions)
+}
+
+#[cfg(test)]
+mod latest_transaction_response_tests {
+ use super::*;
+
+ #[test]
+ fn parses_reward_miner_earnings() {
+ let transaction = vec![1u8; 13];
+ let mut response = Vec::new();
+ response.extend_from_slice(&1u32.to_le_bytes());
+ response.extend_from_slice(&[3u8; 32]);
+ response.extend_from_slice(&123u32.to_le_bytes());
+ response.extend_from_slice(&(transaction.len() as u32).to_le_bytes());
+ response.extend_from_slice(&transaction);
+ response.extend_from_slice(&2u32.to_le_bytes());
+ response.push(0);
+ response.extend_from_slice(b"cltc ");
+ response.extend_from_slice(&0u32.to_le_bytes());
+ response.extend_from_slice(&500u64.to_le_bytes());
+ response.push(1);
+ response.extend_from_slice(b"example ");
+ response.extend_from_slice(&7u32.to_le_bytes());
+ response.extend_from_slice(&900u64.to_le_bytes());
+
+ let records = parse_latest_transaction_response(response).unwrap();
+ assert_eq!(records[0].miner_earnings.len(), 2);
+ assert_eq!(records[0].miner_earnings[0].amount, "500");
+ assert_eq!(records[0].miner_earnings[1].asset, "example");
+ }
+
+ #[test]
+ fn parses_transaction_without_miner_earnings() {
+ let transaction = vec![2u8; 84];
+ let mut response = Vec::new();
+ response.extend_from_slice(&1u32.to_le_bytes());
+ response.extend_from_slice(&[4u8; 32]);
+ response.extend_from_slice(&10u32.to_le_bytes());
+ response.extend_from_slice(&(transaction.len() as u32).to_le_bytes());
+ response.extend_from_slice(&transaction);
+ response.extend_from_slice(&0u32.to_le_bytes());
+
+ let records = parse_latest_transaction_response(response).unwrap();
+ assert!(records[0].miner_earnings.is_empty());
+ }
+}
+
+async fn serialized_wallet_rpc(
+ state: &State<'_, WalletState>,
+ socket_address: SocketAddr,
+ command_input: String,
+ rpc_command: usize,
+ public_key: String,
+ private_key: String,
+ error_prefix: &str,
+) -> Result, String> {
+ state
+ .rpc_scheduler
+ .enqueue(
+ WalletRpcPriority::Foreground,
+ WalletRpcRequest {
+ socket_address,
+ command_input,
+ rpc_command,
+ public_key,
+ private_key,
+ error_prefix: error_prefix.to_string(),
+ },
+ )
+ .await
+}
+
+async fn background_wallet_rpc(
+ state: &State<'_, WalletState>,
+ socket_address: SocketAddr,
+ command_input: String,
+ rpc_command: usize,
+ public_key: String,
+ private_key: String,
+ error_prefix: &str,
+) -> Result, String> {
+ state
+ .rpc_scheduler
+ .enqueue(
+ WalletRpcPriority::Background,
+ WalletRpcRequest {
+ socket_address,
+ command_input,
+ rpc_command,
+ public_key,
+ private_key,
+ error_prefix: error_prefix.to_string(),
+ },
+ )
+ .await
+}
+
+fn normalize_wallet_filename(wallet_name: &str) -> Result {
+ let trimmed = wallet_name.trim();
+ if trimmed.is_empty() {
+ return Err("Wallet name cannot be empty.".to_string());
+ }
+
+ if trimmed.contains('/') || trimmed.contains('\\') {
+ return Err("Wallet name cannot contain folders or path separators.".to_string());
+ }
+
+ let stem = trimmed.strip_suffix(".wallet").unwrap_or(trimmed).trim();
+ if stem.is_empty() {
+ return Err("Wallet name cannot be empty.".to_string());
+ }
+
+ let valid = stem.chars().all(|character| {
+ character.is_ascii_alphanumeric()
+ || character == ' '
+ || character == '-'
+ || character == '_'
+ || character == '.'
+ });
+ if !valid {
+ return Err(
+ "Wallet name can only use letters, numbers, spaces, dots, dashes, and underscores."
+ .to_string(),
+ );
+ }
+
+ Ok(format!("{stem}.wallet"))
+}
diff --git a/src/wallet_app/state.rs b/src/wallet_app/state.rs
new file mode 100644
index 0000000..8de8c52
--- /dev/null
+++ b/src/wallet_app/state.rs
@@ -0,0 +1,22 @@
+impl WalletState {
+ fn set_active(&self, active_wallet: ActiveWallet) -> Result<(), String> {
+ let mut guard = self
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ *guard = Some(active_wallet);
+ self.rpc_scheduler.bump_generation();
+ Ok(())
+ }
+
+ fn clear(&self) -> Result<(), String> {
+ let mut guard = self
+ .active_wallet
+ .lock()
+ .map_err(|_| "Wallet session lock was poisoned.".to_string())?;
+ *guard = None;
+ self.rpc_scheduler.bump_generation();
+ Ok(())
+ }
+}
+
diff --git a/src/wallet_app/transaction_decode.rs b/src/wallet_app/transaction_decode.rs
new file mode 100644
index 0000000..667415a
--- /dev/null
+++ b/src/wallet_app/transaction_decode.rs
@@ -0,0 +1,151 @@
+async fn decode_transaction_json(transaction: &[u8]) -> Result {
+ let (&txtype, body) = transaction
+ .split_first()
+ .ok_or_else(|| "Transaction payload was empty.".to_string())?;
+
+ match txtype {
+ 0 => serde_json::to_value(
+ GenesisTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode genesis transaction: {err}"))?,
+ ),
+ 1 => serde_json::to_value(
+ RewardsTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode rewards transaction: {err}"))?,
+ ),
+ 2 => serde_json::to_value(
+ TransferTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode transfer transaction: {err}"))?,
+ ),
+ 3 => serde_json::to_value(
+ CreateTokenTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode token creation transaction: {err}"))?,
+ ),
+ 4 => serde_json::to_value(
+ CreateNftTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode NFT creation transaction: {err}"))?,
+ ),
+ 5 => serde_json::to_value(
+ MarketingTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode marketing transaction: {err}"))?,
+ ),
+ 6 => serde_json::to_value(
+ SwapTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode swap transaction: {err}"))?,
+ ),
+ 7 => serde_json::to_value(
+ LoanContractTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode loan contract transaction: {err}"))?,
+ ),
+ 8 => serde_json::to_value(
+ ContractPaymentTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode loan payment transaction: {err}"))?,
+ ),
+ 9 => serde_json::to_value(
+ CollateralClaimTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode collateral claim transaction: {err}"))?,
+ ),
+ 10 => serde_json::to_value(
+ BurnTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode burn transaction: {err}"))?,
+ ),
+ 11 => serde_json::to_value(
+ IssueTokenTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode token issue transaction: {err}"))?,
+ ),
+ 12 => serde_json::to_value(
+ VanityAddressTransaction::from_bytes(txtype, body)
+ .await
+ .map_err(|err| format!("Failed to decode vanity transaction: {err}"))?,
+ ),
+ _ => return Err(format!("Unknown transaction type: {txtype}")),
+ }
+ .map_err(|err| format!("Failed to serialize decoded transaction: {err}"))
+}
+
+fn read_network_u32(response: &[u8], offset: &mut usize) -> Result {
+ let bytes = response
+ .get(*offset..*offset + 4)
+ .ok_or_else(|| "Network info response ended while reading u32.".to_string())?
+ .try_into()
+ .map_err(|_| "Failed to read network info u32.".to_string())?;
+ *offset += 4;
+ Ok(u32::from_le_bytes(bytes))
+}
+
+fn read_network_u64(response: &[u8], offset: &mut usize) -> Result {
+ let bytes = response
+ .get(*offset..*offset + 8)
+ .ok_or_else(|| "Network info response ended while reading u64.".to_string())?
+ .try_into()
+ .map_err(|_| "Failed to read network info u64.".to_string())?;
+ *offset += 8;
+ Ok(u64::from_le_bytes(bytes))
+}
+
+fn parse_network_info_response(response: Vec) -> Result {
+ const NETWORK_NAME_BYTES: usize = 7;
+ const FIXED_BYTES_WITHOUT_PREFIX: usize = 40;
+
+ if let Some(error) = parse_error_response(&response) {
+ return Err(error);
+ }
+ if response.len() <= FIXED_BYTES_WITHOUT_PREFIX {
+ let text = String::from_utf8_lossy(&response).trim().to_string();
+ if !text.is_empty() {
+ return Err(text);
+ }
+ return Err("Network info response had an unexpected byte length.".to_string());
+ }
+
+ let wallet_prefix_len = response.len() - FIXED_BYTES_WITHOUT_PREFIX;
+ let mut offset = 0;
+
+ let version = *response
+ .get(offset)
+ .ok_or_else(|| "Network info response did not include version.".to_string())?;
+ offset += 1;
+
+ let network = String::from_utf8_lossy(
+ response
+ .get(offset..offset + NETWORK_NAME_BYTES)
+ .ok_or_else(|| "Network info response did not include network name.".to_string())?,
+ )
+ .trim()
+ .to_string();
+ offset += NETWORK_NAME_BYTES;
+
+ let time = read_network_u32(&response, &mut offset)?;
+
+ let wallet_prefix = String::from_utf8_lossy(
+ response
+ .get(offset..offset + wallet_prefix_len)
+ .ok_or_else(|| "Network info response did not include wallet prefix.".to_string())?,
+ )
+ .trim()
+ .to_string();
+ offset += wallet_prefix_len;
+
+ Ok(NetworkInfoView {
+ version,
+ network,
+ time,
+ wallet_prefix,
+ height: read_network_u32(&response, &mut offset)?,
+ next_block_difficulty: read_network_u64(&response, &mut offset)?,
+ total_block_transactions: read_network_u32(&response, &mut offset)?,
+ total_mempool_transactions: read_network_u32(&response, &mut offset)?,
+ largest_tx_fee: read_network_u64(&response, &mut offset)?,
+ })
+}
diff --git a/src/wallet_app/types.rs b/src/wallet_app/types.rs
new file mode 100644
index 0000000..e92620a
--- /dev/null
+++ b/src/wallet_app/types.rs
@@ -0,0 +1,340 @@
+#[derive(Serialize)]
+struct AppStatus {
+ app_name: &'static str,
+ network: &'static str,
+ bridge: &'static str,
+}
+
+#[derive(Serialize)]
+struct WalletView {
+ wallet_name: String,
+ short_address: String,
+ short_address_hex: String,
+ vanity_address: Option,
+ wallet_path: String,
+ private_key_image: Option,
+}
+
+#[derive(Serialize)]
+struct WalletListItem {
+ wallet_name: String,
+ wallet_path: String,
+}
+
+#[derive(Serialize)]
+struct SelectedFile {
+ file_name: String,
+ file_path: String,
+}
+
+#[derive(Serialize)]
+struct BalanceView {
+ asset: String,
+ nft_series: u32,
+ balance: String,
+}
+
+#[derive(Serialize)]
+struct RegistrationStatusView {
+ registered: bool,
+}
+
+#[derive(Serialize)]
+struct VanityAvailabilityView {
+ vanity_address: String,
+ available: bool,
+ owner: Option,
+}
+
+#[derive(Serialize)]
+struct TransactionBytesView {
+ txid: String,
+ block_height: u32,
+ transaction_type: u8,
+ transaction: JsonValue,
+ transaction_bytes: Vec,
+}
+
+#[derive(Serialize)]
+struct LatestAddressTransactionView {
+ txid: String,
+ block_height: u32,
+ transaction_type: u8,
+ transaction_bytes: Vec,
+ miner_earnings: Vec,
+}
+
+#[derive(Serialize)]
+struct MinerEarningView {
+ earning_type: u8,
+ asset: String,
+ nft_series: u32,
+ amount: String,
+}
+
+#[derive(Serialize)]
+struct MarketingCampaignView {
+ total_records: String,
+ total_impressions: String,
+ total_clicks: String,
+ total_impression_value: String,
+ total_click_value: String,
+ rows: Vec,
+}
+
+#[derive(Serialize)]
+struct MarketingCampaignRowView {
+ status: String,
+ txid: String,
+ block_height: Option,
+ time: u32,
+ campaign: String,
+ ad_type: String,
+ keyword: String,
+ displayed: String,
+ impression: u8,
+ click: u8,
+ impression_value: u16,
+ click_value: u16,
+}
+
+#[derive(Serialize)]
+struct TokenListItemView {
+ ticker: String,
+ origin_txid: String,
+}
+
+#[derive(Serialize)]
+struct TokenCatalogItemView {
+ ticker: String,
+ origin_txid: String,
+ creator: String,
+ created_timestamp: u32,
+ initial_supply: String,
+ current_supply: String,
+ total_burned: String,
+ holder_count: u32,
+ hard_limit: bool,
+}
+
+#[derive(Serialize)]
+struct NftListItemView {
+ nft_name: String,
+ series: u32,
+ origin_txid: String,
+}
+
+#[derive(Serialize)]
+struct NftHistoryEntryView {
+ txid: String,
+ block: u32,
+ txtype: u8,
+ action: String,
+ from: String,
+ to: String,
+ received_asset: String,
+ received_series: u32,
+ received_value: String,
+}
+
+#[derive(Serialize)]
+struct NftDetailsView {
+ nft_name: String,
+ series: u32,
+ asset_name: String,
+ genesis_txid: String,
+ creator: String,
+ item_ipfs: String,
+ metadata_uri: String,
+ current_holder: String,
+ history_count: u32,
+ history: Vec,
+}
+
+#[derive(Serialize)]
+struct NftCacheRecordView {
+ detail: JsonValue,
+ metadata: JsonValue,
+ image_data_url: Option,
+}
+
+#[derive(Serialize)]
+struct IssueTokenDetailsView {
+ ticker: String,
+ creator: String,
+ hard_limit: bool,
+ eligible: bool,
+ reason: String,
+}
+
+#[derive(Serialize)]
+struct BroadcastNodeView {
+ label: String,
+ address: String,
+}
+
+#[derive(Serialize, Deserialize)]
+struct GuiSettingsView {
+ wallet_path: String,
+ unbroadcast_transactions_path: String,
+ address_book_path: String,
+ default_node: String,
+ saved_nodes: Vec,
+ ipfs_gateway: String,
+ auto_load_trusted_nft_images: bool,
+ auto_lock_timeout: String,
+ clipboard_clear_timeout: String,
+ require_key_before_signing: bool,
+ settings_path: String,
+}
+
+#[derive(Serialize)]
+struct WalletPrintBackupView {
+ wallet_name: String,
+ short_address: String,
+ vanity_address: Option,
+ public_key: String,
+ private_key: String,
+ encryption_key: String,
+}
+
+#[derive(Serialize)]
+struct NetworkInfoView {
+ version: u8,
+ network: String,
+ time: u32,
+ wallet_prefix: String,
+ height: u32,
+ next_block_difficulty: u64,
+ total_block_transactions: u32,
+ total_mempool_transactions: u32,
+ largest_tx_fee: u64,
+}
+
+#[derive(Serialize)]
+struct UnbroadcastTransactionListItem {
+ file_name: String,
+ transaction_type: u8,
+ type_name: String,
+ txid: Option,
+ summary: String,
+ status: String,
+ status_message: String,
+ can_sign: bool,
+ can_broadcast: bool,
+}
+
+#[derive(Serialize)]
+struct UnbroadcastTransactionReview {
+ file_name: String,
+ transaction_type: u8,
+ type_name: String,
+ txid: Option,
+ summary: String,
+ status: String,
+ status_message: String,
+ can_sign: bool,
+ can_broadcast: bool,
+ transaction: JsonValue,
+}
+
+#[derive(Serialize)]
+struct SavedSwapOfferView {
+ review: UnbroadcastTransactionReview,
+ file_path: String,
+}
+
+#[derive(Serialize)]
+struct SavedLoanOfferView {
+ review: UnbroadcastTransactionReview,
+ file_path: String,
+}
+
+#[derive(Serialize, Clone)]
+struct LoanContractView {
+ contract: String,
+ status: String,
+ start_timestamp: u32,
+ lender: String,
+ borrower: String,
+ loan_asset: String,
+ loan_amount: String,
+ collateral: String,
+ collateral_amount: String,
+ payment_period: String,
+ payment_number: u8,
+ payment_amount: String,
+ grace_period: u8,
+ max_late_value: String,
+ confirmed_paid: String,
+ pending_paid: String,
+ remaining_balance: String,
+ remaining_after_pending: String,
+ payments: Vec,
+}
+
+#[derive(Serialize, Clone)]
+struct LoanPaymentHistoryView {
+ txid: String,
+ amount: String,
+ payer: String,
+ date: String,
+}
+
+#[derive(Serialize, Clone)]
+struct CollateralClaimContractView {
+ contract: String,
+ role: String,
+ reason: String,
+ lender: String,
+ borrower: String,
+ loan_asset: String,
+ loan_amount: String,
+ collateral: String,
+ collateral_amount: String,
+ confirmed_paid: String,
+ pending_paid: String,
+ remaining_balance: String,
+ remaining_after_pending: String,
+ fee: String,
+}
+
+#[derive(Serialize)]
+struct BroadcastUnbroadcastResult {
+ response: String,
+ txid: Option,
+}
+
+#[derive(Clone, Copy)]
+enum GuiNetwork {
+ Mainnet,
+ Testnet,
+}
+
+impl GuiNetwork {
+ fn parse(network: &str) -> Result {
+ match network.trim().to_ascii_lowercase().as_str() {
+ "mainnet" => Ok(Self::Mainnet),
+ "testnet" => Ok(Self::Testnet),
+ _ => Err("Network must be testnet or mainnet.".to_string()),
+ }
+ }
+
+ fn folder_name(self) -> &'static str {
+ match self {
+ Self::Mainnet => "mainnet",
+ Self::Testnet => "testnet",
+ }
+ }
+}
+
+struct ActiveWallet {
+ wallet_name: String,
+ wallet_path: String,
+ wallet: Wallet,
+}
+
+struct WalletState {
+ active_wallet: Mutex>,
+ rpc_scheduler: WalletRpcScheduler,
+}
diff --git a/src/wallet_app/wallet_files.rs b/src/wallet_app/wallet_files.rs
new file mode 100644
index 0000000..845c161
--- /dev/null
+++ b/src/wallet_app/wallet_files.rs
@@ -0,0 +1,324 @@
+async fn saved_private_key_image(wallet_path: &str) -> Option {
+ let bytes = read(wallet_path).await.ok()?;
+ let saved_wallet: SavedWallet = blockchain::from_slice(&bytes).ok()?;
+ if saved_wallet.private_key.trim().is_empty() {
+ None
+ } else {
+ Some(saved_wallet.private_key)
+ }
+}
+
+async fn wallet_view(wallet_name: String, wallet_path: String, wallet: &Wallet) -> WalletView {
+ let private_key_image = saved_private_key_image(&wallet_path).await;
+ let short_address_hex = Wallet::short_address_to_bytes(&wallet.saved.short_address)
+ .map(encode)
+ .unwrap_or_default();
+
+ WalletView {
+ wallet_name,
+ short_address: wallet.saved.short_address.clone(),
+ short_address_hex,
+ vanity_address: wallet.saved.vanity_address.clone(),
+ wallet_path,
+ private_key_image,
+ }
+}
+
+fn wallet_name_from_path(wallet_path: &Path) -> Result {
+ wallet_path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .map(|name| name.to_string())
+ .ok_or_else(|| "Wallet path does not contain a valid filename.".to_string())
+}
+
+fn gui_wallet_root() -> Result {
+ let home = env::var_os("HOME")
+ .or_else(|| env::var_os("USERPROFILE"))
+ .map(PathBuf::from)
+ .ok_or_else(|| "Unable to resolve user home directory.".to_string())?;
+ Ok(home.join("gui-wallets"))
+}
+
+fn app_wallet_dir(network: GuiNetwork) -> Result {
+ Ok(gui_wallet_root()?.join(network.folder_name()))
+}
+
+async fn create_wallet_file(
+ wallet_path: &Path,
+ wallet_key: String,
+) -> Result {
+ let seed_wallet = Wallet {
+ saved: SavedWallet {
+ short_address: String::new(),
+ vanity_address: None,
+ public_key: String::new(),
+ private_key: String::new(),
+ },
+ encryption_key: wallet_key.clone(),
+ };
+
+ let wallet = seed_wallet.create_wallet();
+ wallet.saved.save_the_wallet(wallet_path).await;
+ Wallet::private_key_from_wallet(wallet_path, wallet_key).await
+}
+
+async fn import_private_key_file(
+ wallet_path: &Path,
+ wallet_key: String,
+ private_key: String,
+) -> Result {
+ let private_key = private_key.trim().to_string();
+ if private_key.is_empty() {
+ return Err("Private key cannot be empty.".to_string());
+ }
+
+ let public_key_bytes = Wallet::regenerate_public_key(&private_key)?;
+ let public_key = encode(public_key_bytes.clone());
+ let short_address_bytes = Wallet::public_key_bytes_to_short_address_bytes(&public_key_bytes)
+ .ok_or_else(|| "Failed to derive short address bytes.".to_string())?;
+ let short_address = Wallet::bytes_to_short_address(&short_address_bytes)
+ .ok_or_else(|| "Failed to encode short address.".to_string())?;
+
+ let encrypted_private_key = encrypts(&private_key, Some(&wallet_key), None)
+ .ok_or_else(|| "Failed to encrypt private key with the provided wallet key.".to_string())?;
+ let image_data = create_img(
+ &encrypted_private_key,
+ "h",
+ "empty",
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ )
+ .ok_or_else(|| "Failed to create encrypted private key image.".to_string())?;
+
+ let saved_wallet = SavedWallet {
+ short_address,
+ vanity_address: None,
+ public_key,
+ private_key: image_data,
+ };
+ let output = to_string_pretty(&saved_wallet)
+ .map_err(|err| format!("Failed to serialize imported wallet: {err}"))?;
+ blockchain::tokio::fs::write(wallet_path, output)
+ .await
+ .map_err(|err| format!("Failed to write imported wallet file: {err}"))?;
+
+ Wallet::private_key_from_wallet(wallet_path, wallet_key).await
+}
+
+async fn private_key_from_png_image(image_path: &Path, wallet_key: &str) -> Result {
+ let image_bytes = blockchain::tokio::fs::read(image_path)
+ .await
+ .map_err(|err| format!("Failed to read private key image: {err}"))?;
+ let image_base64 = STANDARD.encode(image_bytes);
+ let encrypted_text = decode_image_and_extract_text(&image_base64)
+ .ok_or_else(|| "Failed to decode private key image.".to_string())?;
+ decrypts(&encrypted_text, Some(wallet_key))
+ .ok_or_else(|| "Private key image decryption failed.".to_string())
+}
+
+async fn lookup_public_ip_from_services() -> Option {
+ let services = [
+ "https://api.ipify.org",
+ "https://icanhazip.com",
+ "https://checkip.amazonaws.com",
+ "https://ifconfig.me/ip",
+ "https://ident.me",
+ ];
+
+ let client = reqwest::Client::builder()
+ .timeout(Duration::from_secs(3))
+ .build()
+ .ok()?;
+
+ for service in services {
+ let response = match client.get(service).send().await {
+ Ok(response) => response,
+ Err(_) => continue,
+ };
+
+ let text = match response.text().await {
+ Ok(text) => text,
+ Err(_) => continue,
+ };
+
+ let ip = text.trim();
+
+ if ip.parse::().is_ok() {
+ return Some(ip.to_string());
+ }
+ }
+
+ None
+}
+
+async fn best_effort_local_ip() -> Result {
+ let public_ip = lookup_public_ip_from_services()
+ .await
+ .ok_or_else(|| "Unable to determine public IP from any service.".to_string());
+
+ return public_ip;
+}
+
+fn gui_settings_path() -> Result {
+ if let Ok(settings_path) = env::var("SETTINGS_PATH") {
+ let path = PathBuf::from(settings_path);
+ if path.exists() {
+ return Ok(path);
+ }
+ }
+
+ if let Ok(exe_path) = env::current_exe() {
+ if let Some(exe_dir) = exe_path.parent() {
+ return Ok(exe_dir.join("settings.ini"));
+ }
+ }
+
+ Ok(env::current_dir()
+ .map_err(|err| format!("Unable to resolve current directory: {err}"))?
+ .join("settings.ini"))
+}
+
+async fn ensure_gui_settings_file() -> Result<(), String> {
+ let settings_path = gui_settings_path()?;
+ if settings_path.exists() {
+ env::set_var("SETTINGS_PATH", &settings_path);
+ return Ok(());
+ }
+
+ let settings_dir = settings_path
+ .parent()
+ .ok_or_else(|| "Unable to resolve settings directory.".to_string())?;
+ create_dir_all(settings_dir)
+ .await
+ .map_err(|err| format!("Unable to create settings directory: {err}"))?;
+
+ let runtime_root = gui_wallet_root()?.join("gui-runtime");
+ create_dir_all(&runtime_root)
+ .await
+ .map_err(|err| format!("Unable to create GUI runtime directory: {err}"))?;
+
+ let public_ip = best_effort_local_ip().await?;
+
+ let settings = format!(
+ r#"; Auto-generated by Contractless Wallet GUI.
+
+[Paths]
+BLOCK_PATH = "{root}/blocks"
+TORRENT_PATH = "{root}/torrents"
+DB_PATH = "{root}/state"
+BALANCE_SHEET = "{root}/balance_sheet"
+LOG_PATH = "{root}/logs"
+WALLET_PATH = "{root}/wallets"
+UNBROADCAST_TRANSACTIONS = "{root}/unbroadcast"
+ADDRESS_BOOK = "{root}/address_book"
+WALLET_NAME = "gui.wallet"
+
+[Settings]
+LOG_LEVEL = "info"
+PUBLIC_IP = "{public_ip}"
+LISTEN_IP = "0.0.0.0"
+RPC_PORT = "50050"
+TESTNET_RPC_PORT = "50053"
+INCOMING_CONNECTIONS = "1"
+OUTGOING_CONNECTIONS = "1"
+VALIDATOR = "false"
+THREADS = "1"
+
+[Piggyback]
+PIGGYBACK_1 = "contractless.dev:50050"
+
+[Postgres-Testnet]
+host = 127.0.0.1
+port = 5432
+user = contractless_gui
+password = contractless_gui
+dbname = contractless_gui
+
+[Postgres]
+host = 127.0.0.1
+port = 5432
+user = contractless_gui
+password = contractless_gui
+dbname = contractless_gui
+"#,
+ root = runtime_root.to_string_lossy().replace('\\', "/"),
+ public_ip = public_ip
+ );
+
+ blockchain::tokio::fs::write(&settings_path, settings)
+ .await
+ .map_err(|err| format!("Unable to write GUI settings.ini: {err}"))?;
+ env::set_var("SETTINGS_PATH", &settings_path);
+ Ok(())
+}
+
+async fn read_piggyback_nodes() -> Result, String> {
+ ensure_gui_settings_file().await?;
+ let settings_path = gui_settings_path()?;
+ let settings = read_to_string(&settings_path)
+ .await
+ .map_err(|err| format!("Unable to read GUI settings.ini: {err}"))?;
+
+ let mut in_piggyback = false;
+ let mut nodes = Vec::new();
+
+ for line in settings.lines() {
+ let trimmed = line.trim();
+ if trimmed.is_empty() || trimmed.starts_with(';') || trimmed.starts_with('#') {
+ continue;
+ }
+
+ if trimmed.starts_with('[') && trimmed.ends_with(']') {
+ in_piggyback = trimmed.eq_ignore_ascii_case("[Piggyback]");
+ continue;
+ }
+
+ if !in_piggyback {
+ continue;
+ }
+
+ let Some((key, value)) = trimmed.split_once('=') else {
+ continue;
+ };
+ let key = key.trim();
+ if !key.to_ascii_uppercase().starts_with("PIGGYBACK_") {
+ continue;
+ }
+
+ let address = value
+ .trim()
+ .trim_matches('"')
+ .trim_matches('\'')
+ .trim()
+ .to_string();
+ if address.is_empty() {
+ continue;
+ }
+
+ nodes.push(BroadcastNodeView {
+ label: key.to_string(),
+ address,
+ });
+ }
+
+ nodes.sort_by(|left, right| {
+ piggyback_sort_index(&left.label)
+ .cmp(&piggyback_sort_index(&right.label))
+ .then_with(|| left.label.cmp(&right.label))
+ });
+ nodes.dedup_by(|left, right| left.address == right.address);
+ Ok(nodes)
+}
+
+fn piggyback_sort_index(label: &str) -> u32 {
+ label
+ .rsplit_once('_')
+ .and_then(|(_, index)| index.trim().parse::().ok())
+ .unwrap_or(u32::MAX)
+}
+
diff --git a/tauri.conf.json b/tauri.conf.json
new file mode 100644
index 0000000..c4cd3b4
--- /dev/null
+++ b/tauri.conf.json
@@ -0,0 +1,27 @@
+{
+ "$schema": "https://schema.tauri.app/config/2",
+ "productName": "Contractless Wallet",
+ "version": "0.1.0",
+ "identifier": "dev.contractless.wallet",
+ "build": {
+ "frontendDist": "frontend"
+ },
+ "bundle": {
+ "active": false
+ },
+ "app": {
+ "withGlobalTauri": true,
+ "windows": [
+ {
+ "title": "Contractless Wallet",
+ "width": 1180,
+ "height": 760,
+ "minWidth": 360,
+ "minHeight": 620
+ }
+ ],
+ "security": {
+ "csp": null
+ }
+ }
+}