Fix post-feed.html: recursive reply fetching for nested replies

Replies to replies don't carry the root post ID in their e tags, only their
immediate parent's ID. The old single-level #e filter missed nested replies.

Added fetchRepliesRecursive() which does breadth-first recursive fetching:
- Starts with root post ID, fetches direct replies
- For each reply found, fetches replies to THAT reply
- Continues up to 5 levels deep (REPLY_FETCH_MAX_DEPTH)
- Deduplicates by event ID
- Per-level timeout (8s) to guard against slow relays
- Real-time handler also triggers 1-level recursive fetch for new replies

This matches Amethyst's ThreadFilterAssemblerSubscription approach.

plans/feed-upgrade.md

@@ -0,0 +1,368 @@
+# Feed Upgrade — Implementation Plan
+
+## Overview
+
+A series of improvements to the feed page and post interaction bar, centered on:
+1. **Simplified feed** — show posts without inline replies, just counts
+2. **Post thread page** — click comment button to open post with full comment thread in a new tab
+3. **Zap capability indicators** — show what the recipient can receive (nutzap, Lightning)
+4. **Zap rail selector** — let users choose between nutzap and Lightning melt
+5. **Balance check and error handling** — pre-flight checks and better error messages
+
+The project uses **Cashu as the only payment rail** — nutzaps (NIP-61) for ecash transfers, and Cashu melt for Lightning zaps (NIP-57). No NWC, CLINK, or onchain needed.
+
+### Current state
+
+- [`www/feed.html`](www/feed.html) — shows posts with inline replies (toggled by "Comments" button). Replies appear under the post as they occur. This is unreliable.
+- [`www/feed2.html`](www/feed2.html) — copy of feed.html, to be modified per this plan
+- [`www/post.html`](www/post.html) — posting/composer page (NOT a thread viewer). Accepts `?event=`, `?npub=`, `?profile=` params.
+- [`www/note.html`](www/note.html) — long-form note editor (kind 30023/30024), NOT for kind 1 threads
+- [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) — renders the interaction bar (like, comment, quote, zap buttons) and handles zap routing
+- [`www/js/zaps.mjs`](www/js/zaps.mjs) — NIP-57 Lightning zap protocol
+
+### URL schema (existing convention)
+
+The project uses `URLSearchParams` with query parameters:
+- `?npub=<npub1...>` — Nostr public key (bech32)
+- `?pubkey=<hex>` — Nostr public key (hex)
+- `?event=<hex|nevent|note>` — Event identifier
+- `?auth=required|optional|none` — Auth mode
+
+The new `post-feed.html` page will follow this schema: `post-feed.html?event=<hex|nevent|note>`
+
+### CSS theme
+
+The project uses CSS variables (never hardcode colors):
+- `--primary-color` (black in light mode, white in dark mode) — main text/icons
+- `--secondary-color` (white in light mode, black in dark mode) — background
+- `--accent-color` (#ff0000 red, both modes) — the **only** highlight color
+- `--muted-color` (#dddddd light / #777777 dark) — dimmed/disabled
+
+All indicators must use these variables. "Colored" = `var(--accent-color)`, "dimmed" = `var(--muted-color)`.
+
+---
+
+## Phase 1: Simplified Feed (feed2.html)
+
+Remove inline replies from the feed. Show only the original post with interaction counts (likes, comments, zaps, nutzaps). Clicking the comment button opens the post thread page in a **new tab**.
+
+### Tasks
+
+- [ ] **1.1** In `feed2.html`, remove the inline comment rendering and the "Comments" toggle button. The feed should only show top-level posts.
+
+- [ ] **1.2** Change the comment button behavior — instead of calling `onCommentIntentFn` to show inline comments, open `post-feed.html?event=<eventId>` in a **new tab** using `window.open('./post-feed.html?event=' + encodeURIComponent(postId), '_blank')`.
+
+- [ ] **1.3** Keep the interaction bar functional in the feed:
+  - ✅ Like button — works inline (no navigation)
+  - ✅ Zap button — works inline (opens zap dialog, sends nutzap or Lightning melt)
+  - ✅ Nutzap count display — shows total nutzaps received
+  - 🔄 Comment button — opens `post-feed.html?event=<eventId>` in a new tab
+  - 🔄 Quote button — opens quote composer (no navigation)
+
+- [ ] **1.4** Keep real-time updates for counts (likes, zaps, comments, nutzaps) — the feed should still update these counts as events arrive, just not render the reply content inline.
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/feed2.html`](www/feed2.html) | Remove inline comment rendering, comment button opens post-feed.html in new tab |
+
+---
+
+## Phase 2: Post Thread Page (post-feed.html)
+
+Create a new `www/post-feed.html` page that shows a post with its full comment thread — all replies, with the ability to reply inline.
+
+### URL schema
+
+```
+post-feed.html?event=<hex|nevent|note>
+```
+
+Accepts the same event identifier formats as the rest of the project:
+- Hex event ID: `post-feed.html?event=abc123...`
+- nevent: `post-feed.html?event=nevent1q...`
+- note: `post-feed.html?event=note1...`
+
+### Tasks
+
+- [ ] **2.1** Create `www/post-feed.html` based on the [`www/template.html`](www/template.html) pattern — standard header, hamburger, sidenav, footer.
+
+- [ ] **2.2** Parse the `event` URL parameter using `URLSearchParams` (same pattern as `post.html` line 248). Decode nevent/note to hex if needed.
+
+- [ ] **2.3** Fetch the original post event via the worker's `ndkFetchEvents` or `queryCache` function. Display it using `renderPostItem` from `post-interactions.mjs`.
+
+- [ ] **2.4** Fetch all replies — kind 1 events with an `e` tag pointing to the post ID. Use `ndkFetchEvents` with a filter like `{ kinds: [1], '#e': [postId] }`.
+
+- [ ] **2.5** Render the comment thread below the original post:
+  - Flat thread (all replies in chronological order) — simplest, most reliable
+  - Each reply rendered using `renderPostItem` from `post-interactions.mjs`
+  - Start with flat; can add nesting/threading later
+
+- [ ] **2.6** Add an inline composer at the bottom for posting replies. The composer should:
+  - Tag the original post: `['e', postId, '', 'reply']`
+  - Tag the original author: `['p', postPubkey]`
+  - Use the existing post composer component (`post-composer.mjs`)
+
+- [ ] **2.7** Real-time updates — subscribe to new replies via the worker's subscription system. Append new replies to the thread as they arrive.
+
+- [ ] **2.8** Each reply should have its own interaction bar (like, zap, quote) via `post-interactions.mjs`. The comment button on a reply opens `post-feed.html?event=<replyId>` in a new tab for that reply's sub-thread.
+
+### Files to create
+
+| File | Purpose |
+|------|---------|
+| `www/post-feed.html` | New post thread page — shows post + all replies + inline composer |
+
+---
+
+## Phase 2.5: Threaded Replies with Vertical Lines (post-feed.html)
+
+Upgrade the flat reply list in `post-feed.html` to show **threaded replies with vertical indent lines**, matching Amethyst's thread view.
+
+### How Amethyst does it
+
+Amethyst uses two key components:
+
+1. **`ThreadLevelCalculator.replyLevel(note, cachedLevels)`** — computes the depth of each reply recursively:
+   - Root post (no `e` tag reply) → level 0
+   - A reply's level = `max(parent's level for each parent) + 1`
+   - Parents are determined by NIP-10 `e` tags in the event
+
+2. **`Modifier.drawReplyLevel(level, color, selected)`** — draws vertical lines to the left of each post:
+   - Draws `level` vertical lines, each 2px wide, spaced 3px apart
+   - The last line (closest to the post) uses the "selected" color
+   - All other lines use the "muted" color
+   - The post content is padded left by `2 + (level * 3)px`
+
+### Visual design
+
+```
+Original post (level 0)
+│ Reply A (level 1) — direct reply to original
+│ │ Reply A1 (level 2) — reply to Reply A
+│ │ Reply A2 (level 2) — another reply to Reply A
+│ Reply B (level 1) — another direct reply to original
+│ │ Reply B1 (level 2) — reply to Reply B
+│ │ │ Reply B1a (level 3) — reply to Reply B1
+│ Reply C (level 1) — yet another direct reply
+```
+
+Each `│` is a vertical line drawn with CSS `border-left` on a container div. The lines use:
+- `var(--muted-color)` for non-selected levels
+- `var(--accent-color)` for the current post's level (the post being viewed)
+
+### Tasks
+
+- [ ] **2.5.1** Add a `computeReplyLevels(events, rootEventId)` function to `post-feed.html` (or a shared module):
+  - Build a map of `eventId → parentEventId` from the `e` tags (NIP-10 marked reply tags)
+  - For each event, compute its level by walking up the parent chain to the root
+  - Root post = level 0, direct reply = level 1, reply to reply = level 2, etc.
+  - Handle missing parents gracefully (if a parent isn't in the fetched set, treat as level 1)
+  - Return a `Map<eventId, level>`
+
+- [ ] **2.5.2** Sort replies in depth-first order (like Amethyst's `replyLevelSignature`):
+  - Root post first
+  - Then replies grouped by parent, in chronological order within each group
+  - This makes the vertical lines visually contiguous — a reply's children appear right below it
+
+- [ ] **2.5.3** Render each reply with vertical indent lines:
+  - Wrap each reply in a container div with `padding-left: calc(level * 12px)` (or similar)
+  - For each level 0..N-1, add a vertical line using `border-left: 2px solid var(--muted-color)` on a positioned div
+  - The last line (level N-1) uses `var(--accent-color)` if this is the focused post, otherwise `var(--muted-color)`
+  - Use CSS pseudo-elements or nested divs for the lines
+
+- [ ] **2.5.4** Add collapse/expand functionality:
+  - Each reply has a collapse toggle (small button or click on the vertical line)
+  - Collapsing a reply hides all of its descendants
+  - Show a count of hidden replies when collapsed (e.g., "3 replies hidden")
+  - Collapsed state stored in a Set in memory
+
+- [ ] **2.5.5** Highlight the focused post:
+  - If the URL has a `#<eventId>` hash or a `focus=<eventId>` param, scroll to and highlight that post
+  - The highlighted post's vertical line uses `var(--accent-color)`
+
+### CSS approach (CSS variables only)
+
+```css
+.reply-thread-line {
+    position: absolute;
+    left: 0;
+    top: 0;
+    bottom: 0;
+    width: 2px;
+    background: var(--muted-color);
+}
+
+.reply-thread-line.selected {
+    background: var(--accent-color);
+}
+
+.reply-item {
+    position: relative;
+    padding-left: 12px; /* per level */
+}
+```
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/post-feed.html`](www/post-feed.html) | Add level computation, depth-first sorting, vertical line rendering, collapse/expand |
+
+---
+
+## Phase 3: Zap Capability Indicators in the Feed
+
+Show zap capability badges on each post's interaction bar so users can see at a glance whether the recipient can receive nutzaps, Lightning zaps, or both.
+
+### Design
+
+Compact indicators next to the existing zap button, using the project's CSS variables:
+
+| Indicator | CSS | Meaning |
+|-----------|-----|---------|
+| 🥜 (accent color) | `color: var(--accent-color)` | Recipient can receive nutzaps — has kind 10019 with a shared mint |
+| 🥜 (muted) | `color: var(--muted-color)` | Recipient has kind 10019 but no shared mint with your wallet |
+| ⚡ (accent color) | `color: var(--accent-color)` | Recipient can receive Lightning zaps — has lud16 |
+| ⚡ (muted) | `color: var(--muted-color)` | Recipient has no lud16 — cannot receive Lightning zaps |
+
+Tooltip on hover shows details: "Can nutzap via mint.minibits.cash/Bitcoin" or "No shared mints — Lightning only" or "No zap capability".
+
+### When and where to fetch the data
+
+Two-tier strategy based on whether the author is a followed user or not:
+
+**Tier 1: Followed users (proactive fetch on startup)**
+- The worker already fetches the user's kind 3 (contact list) on startup (line 1799 of `ndk-worker.js`)
+- After the kind 3 is loaded, proactively fetch kind 10019 for all followed pubkeys in a batch
+- This happens once on startup, results cached in the worker's Dexie/IndexedDB
+- Followed users are the most likely zap recipients, and their 10019 rarely changes
+- Add a subscription for kind 10019 updates for followed pubkeys (so changes are picked up)
+
+**Tier 2: Non-followed users (lazy fetch on first encounter)**
+- When a post by a non-followed user appears in the feed, lazily fetch their kind 10019
+- Use the existing `walletFetchMintList` worker function
+- Cache the result per pubkey in an in-memory Map with TTL (5 minutes)
+- Only fetch once per pubkey per session (unless cache expires)
+
+**What's already available (no fetch needed):**
+- lud16 (Lightning address) — already cached in `profile-cache.mjs` when post headers are rendered. The profile fetch already happens for every post in the feed.
+- The sender's own wallet mints — already in the worker's `directProofStore`, accessible via `walletGetMints`
+
+### Tasks
+
+- [ ] **3.1** Create a `resolveZapCapabilities(pubkey)` function in [`www/js/zaps.mjs`](www/js/zaps.mjs) that checks:
+  - Does the recipient have a lud16 (Lightning address)? → check `profile-cache.mjs` cache (already fetched for post rendering) → `canLightning: true`
+  - Does the recipient have a kind 10019 (nutzap mint list)? → check local cache first, then fetch via `walletFetchMintList` if not cached
+  - If yes to 10019, which mints? Do any overlap with the sender's wallet mints (from `walletGetMints`)? → `canNutzap: true`, `sharedMints: [...]`
+  - Return `{ canLightning, canNutzap, sharedMints, nutzapMints, lud16 }`
+
+- [ ] **3.2** Add a proactive kind 10019 batch fetch for followed users in the worker:
+  - After the kind 3 (contact list) is loaded on startup, collect all followed pubkeys
+  - Fetch kind 10019 for all followed pubkeys: `ndk.fetchEvents({ kinds: [10019], authors: [...followedPubkeys] })`
+  - Cache the results in the worker's IndexedDB so they persist across sessions
+  - Add a subscription for kind 10019 updates for followed pubkeys
+
+- [ ] **3.3** For non-followed users, lazily fetch kind 10019 via `walletFetchMintList`:
+  - Cache results in an in-memory Map with TTL (5 minutes) in `zaps.mjs`
+  - Only fetch if not already in the worker's IndexedDB cache or the in-memory cache
+  - Non-blocking: render the interaction bar without badges, then update when the fetch completes
+
+- [ ] **3.4** Update the zap button rendering in `post-interactions.mjs` to show capability indicators:
+  - Add a small badge element next to the zap button
+  - Show 🥜 in `var(--accent-color)` if `canNutzap` is true
+  - Show 🥜 in `var(--muted-color)` if recipient has 10019 but no shared mint
+  - Show ⚡ in `var(--accent-color)` if `canLightning` is true
+  - Add tooltip with shared mint details
+
+- [ ] **3.5** Make the capability check async and non-blocking — render the interaction bar immediately, then update the badges when the capability check completes. The lud16 check is instant (from profile cache); the 10019 check may take a moment for non-followed users.
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/js/zaps.mjs`](www/js/zaps.mjs) | Add `resolveZapCapabilities()` with caching, lazy fetch for non-followed users |
+| [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) | Add capability badges to zap button rendering |
+| [`www/ndk-worker.js`](www/ndk-worker.js) | Add proactive kind 10019 batch fetch for followed users on startup |
+
+---
+
+## Phase 4: Zap Rail Selector in the Zap Dialog
+
+When the user taps the zap button, show which rails are available and let them choose.
+
+```mermaid
+flowchart TD
+    A[User taps zap button] --> B[Show zap dialog with amount input]
+    B --> C{What rails are available?}
+    C -->|Nutzap + Lightning| D[Show rail toggle: 🥜 Nutzap | ⚡ Lightning]
+    C -->|Lightning only| E[Show Lightning only]
+    C -->|Nutzap only| F[Show Nutzap only]
+    C -->|Neither| G[Show error: recipient cannot receive zaps]
+    D --> H[User selects rail + amount]
+    H --> I{Rail selected}
+    I -->|Nutzap| J[Send NIP-61 nutzap via walletSendNutzap]
+    I -->|Lightning| K[Create LN invoice, melt Cashu via walletPayInvoice]
+    E --> K
+    F --> J
+```
+
+### Tasks
+
+- [ ] **4.1** Update `promptZapDetails` in [`www/js/zaps.mjs`](www/js/zaps.mjs) to accept and display rail options:
+  - If nutzap is available → show "🥜 Nutzap" option
+  - If Lightning is available → show "⚡ Lightning" option
+  - Let the user pick which rail to use via a toggle/selector
+  - Selected rail uses `var(--accent-color)`, unselected uses `var(--muted-color)`
+
+- [ ] **4.2** Show balance info in the dialog: "Cashu balance: 261 sats". If amount > balance → show warning in `var(--accent-color)`.
+
+- [ ] **4.3** Default rail selection:
+  - If nutzap is available and amount < 1000 sats → default to nutzap (lower fees)
+  - If nutzap is available and amount ≥ 1000 sats → default to Lightning
+  - If nutzap is not available → default to Lightning
+
+- [ ] **4.4** Pass the selected rail back to `handleZapClick` in `post-interactions.mjs` so it uses the right send function.
+
+- [ ] **4.5** Show shared mint info when nutzap is selected: "Will send via mint.minibits.cash/Bitcoin"
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/js/zaps.mjs`](www/js/zaps.mjs) | Update `promptZapDetails` with rail selector UI |
+| [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) | Update `handleZapClick` to respect user's rail choice |
+
+---
+
+## Phase 5: Balance Check and Error Handling
+
+- [ ] **5.1** Before sending a zap, check the user's Cashu balance (via `walletGetBalance`):
+  - If balance < zap amount → show "Insufficient balance. Current: X sats, needed: Y sats" in `var(--accent-color)`
+  - If balance is sufficient but barely → show confirmation "This will use most of your balance. Continue?"
+
+- [ ] **5.2** Improve error messages for melt failures:
+  - "Mint couldn't route Lightning payment" (mint liquidity issue)
+  - "Mint returned an error: [details]" (mint API error)
+  - "Proofs were spent but payment failed — try again or contact the mint"
+
+- [ ] **5.3** After a successful zap, refresh the balance display.
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) | Add balance check before zap, improve error handling |
+
+---
+
+## Implementation Order
+
+1. **Phase 1** (simplified feed) — remove inline replies from feed2.html, comment button opens post-feed.html in new tab
+2. **Phase 2** (post thread page) — create post-feed.html to show full post + comment thread
+3. **Phase 3** (zap capability indicators) — show what the recipient can receive
+4. **Phase 4** (rail selector) — let users choose nutzap vs Lightning melt
+5. **Phase 5** (balance + errors) — pre-flight checks and better error messages
+
+Phases 1-2 are the feed restructuring. Phases 3-5 are zap improvements.

plans/wallet-page.md

@@ -0,0 +1,178 @@
+# Cashu Wallet Enhancements — Implementation Plan
+
+## Overview
+
+Enhance the existing `www/cashu.html` page and zap flow, centered on **Cashu as the primary (and only) payment rail**. The core functionality is already implemented — this plan adds UI improvements to show zap capabilities in the feed and let users choose their zap rail.
+
+### Design philosophy: Cashu-only
+
+The project uses **Cashu for everything** — no NWC, CLINK, onchain, or Lightning channels to maintain:
+
+| Payment type | How it works | Already implemented? |
+|-------------|-------------|---------------------|
+| **Nutzap (NIP-61)** | Send ecash proofs locked to recipient's p2pk via kind 9321 | ✅ Yes — `walletSendNutzap` |
+| **Lightning zap (NIP-57)** | Melt Cashu ecash at a mint to pay a BOLT11 invoice | ✅ Yes — `walletPayInvoice` |
+| **P2P ecash transfer** | Send cashuB token directly to another user | ✅ Yes — `walletSendToken` |
+| **Lightning deposit** | Pay a BOLT11 invoice, mint issues ecash proofs | ✅ Yes — `walletCreateDeposit` |
+| **Lightning withdrawal** | Melt ecash to pay an external BOLT11 invoice | ✅ Yes — `walletPayInvoice` |
+
+---
+
+## Phase 1: NIP-60 Compliance Fix (DONE ✅)
+
+Already completed and deployed (v0.7.19–v0.7.24):
+- Fixed kind 17375 content format from proprietary `{mints, nutzap}` object to NIP-60 tag-array `[["mint",url],["privkey",hex]]`
+- Removed non-standard `pubkey` tag from 17375 public tags
+- Added `parseWalletContent()` backwards-compat shim for reading both formats
+- Added auto-migration for legacy 17375 events on startup
+- Added "Republish Wallet (kind 17375)" button with lightweight 17375-only republish
+- Added `ensureDirectNutzapP2pk()` call in `publishDirectProofs` so privkey is always included
+
+---
+
+## Phase 2: Zap Capability Indicators in the Feed
+
+Show zap capability badges on each post's interaction bar so users can see at a glance whether the recipient can receive nutzaps, Lightning zaps, or both.
+
+### Current state
+
+The interaction bar in [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) already renders:
+- ⚡ Zap button with count
+- 🥜 Nutzap count display (separate element showing total nutzaps received)
+
+### What to add
+
+Small capability icons/badges next to the zap button showing what the recipient can receive:
+
+```
+┌──────────────────────────────────────────────────┐
+│  ⚡ 5  🥜 2  🥜✅  ⚡✅     💬 3  🔄 1    2h ago │
+│  └─ zap ─┘  └─ nutzap ─┘  └─ capability badges ─┘ │
+└──────────────────────────────────────────────────┘
+```
+
+Or a more compact design — color the zap icon differently based on capabilities:
+
+| Visual | Meaning |
+|--------|---------|
+| ⚡ (default color) | Recipient can receive Lightning zaps (has lud16) |
+| ⚡ + 🥜 (nut badge) | Recipient can also receive nutzaps (has kind 10019 with shared mint) |
+| ⚡ (dimmed) | Recipient cannot receive any zaps (no lud16, no 10019) |
+
+### Implementation
+
+- [ ] **2.1** Create a `resolveZapCapabilities(pubkey)` function that checks:
+  - Does the recipient have a lud16 (Lightning address)? → can receive Lightning zaps
+  - Does the recipient have a kind 10019 (nutzap mint list)? → can receive nutzaps
+  - If yes to 10019, which mints? Do any overlap with the sender's wallet mints?
+
+- [ ] **2.2** Cache the results per pubkey (the kind 10019 and lud16 don't change often). Use a simple in-memory Map with TTL.
+
+- [ ] **2.3** Update `createInteractionItem` for the zap type to show capability indicators:
+  - Add a small 🥜 badge on the zap button if the recipient can receive nutzaps
+  - Add a tooltip showing the shared mints
+  - Dim the zap button if the recipient can't receive any zaps
+
+- [ ] **2.4** Fetch kind 10019 events for post authors as the feed loads. The worker already fetches kind 10019 for nutzap sending — extend this to cache the results for feed display. Use the existing `walletFetchMintList` worker function.
+
+- [ ] **2.5** Show shared mint info on hover/tooltip: "Can nutzap via mint.minibits.cash/Bitcoin" or "No shared mints — Lightning only" or "No zap capability"
+
+### Where the code lives
+
+| File | What to change |
+|------|---------------|
+| [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) | Add capability badges to zap button rendering |
+| [`www/js/zaps.mjs`](www/js/zaps.mjs) | Add `resolveZapCapabilities()` function (or extend existing `resolveZapSpecForPubkey`) |
+| [`www/ndk-worker.js`](www/ndk-worker.js) | May need a lightweight "fetch 10019 for display" message (or reuse `walletFetchMintList`) |
+
+---
+
+## Phase 3: Zap Rail Selector in the Zap Dialog
+
+When the user taps the zap button, show which rails are available and let them choose.
+
+```mermaid
+flowchart TD
+    A[User taps zap button] --> B[Show zap dialog with amount input]
+    B --> C{What rails are available?}
+    C -->|Nutzap + Lightning| D[Show rail toggle: 🥜 Nutzap | ⚡ Lightning]
+    C -->|Lightning only| E[Show Lightning only]
+    C -->|Nutzap only| F[Show Nutzap only]
+    C -->|Neither| G[Show error: recipient cannot receive zaps]
+    D --> H[User selects rail + amount]
+    H --> I{Rail selected}
+    I -->|Nutzap| J[Send NIP-61 nutzap via walletSendNutzap]
+    I -->|Lightning| K[Create LN invoice, melt Cashu via walletPayInvoice]
+    E --> K
+    F --> J
+```
+
+- [ ] **3.1** Update `promptZapDetails` in `zaps.mjs` to accept and display rail options:
+  - If nutzap is available (recipient has 10019 with shared mint) → show "🥜 Nutzap" option
+  - If Lightning is available (recipient has lud16) → show "⚡ Lightning" option
+  - Let the user pick which rail to use via a toggle/selector
+
+- [ ] **3.2** Show balance info in the dialog:
+  - "Cashu balance: 261 sats" 
+  - If amount > balance → show warning "Insufficient balance"
+
+- [ ] **3.3** Default rail selection:
+  - If nutzap is available and amount < 1000 sats → default to nutzap (lower fees)
+  - If nutzap is available and amount ≥ 1000 sats → default to Lightning (more reliable for larger amounts)
+  - If nutzap is not available → default to Lightning
+
+- [ ] **3.4** Pass the selected rail back to `handleZapClick` in `post-interactions.mjs` so it uses the right send function.
+
+---
+
+## Phase 4: cashu.html UI Polish
+
+Minor UI improvements to the existing cashu.html page:
+
+- [ ] **4.1** Consider renaming the page title from "CASHU" to "WALLET" since it's the project's unified wallet.
+
+- [ ] **4.2** Update the sidenav entry in `index.html` from "CASHU" to "WALLET" (keeping the same `cashu.html` URL).
+
+- [ ] **4.3** Add a "Zap via Lightning" info note in the Withdraw panel explaining that this melts ecash to pay a Lightning invoice — same mechanism used for Lightning zaps.
+
+---
+
+## NIP Compliance Reference
+
+| Rail | NIP | Kind(s) | Status |
+|------|-----|---------|--------|
+| Cashu Wallet | NIP-60 | 17375, 7375, 7376, 375 | ✅ Fixed and working |
+| Cashu Nutzap | NIP-61 | 10019, 9321 | ✅ Working |
+| Lightning Zap | NIP-57 | 9734, 9735 | ✅ Working (via Cashu melt) |
+
+---
+
+## Key Files
+
+### Files to modify
+
+| File | Changes |
+|------|---------|
+| [`www/js/post-interactions.mjs`](www/js/post-interactions.mjs) | Add zap capability badges to interaction bar, pass selected rail to zap handler |
+| [`www/js/zaps.mjs`](www/js/zaps.mjs) | Add `resolveZapCapabilities()`, update `promptZapDetails` with rail selector |
+| [`www/cashu.html`](www/cashu.html) | Minor UI polish (title, info notes) |
+| [`www/index.html`](www/index.html) | Sidenav label: "CASHU" → "WALLET" |
+
+### Files reused as-is
+
+| File | Why no changes needed |
+|------|----------------------|
+| [`www/js/cashu-wallet.mjs`](www/js/cashu-wallet.mjs) | Controller already wraps all worker functions |
+| [`www/ndk-worker.js`](www/ndk-worker.js) | All wallet functions already exist (payInvoice, sendNutzap, fetchMintList) |
+| [`www/js/init-ndk.mjs`](www/js/init-ndk.mjs) | All wallet exports already exist |
+
+---
+
+## Implementation Order
+
+1. **Phase 1** (DONE) — NIP-60 compliance fix
+2. **Phase 2** (zap capability indicators) — show what the recipient can receive in the feed
+3. **Phase 3** (rail selector) — let users choose nutzap vs Lightning melt in the zap dialog
+4. **Phase 4** (UI polish) — minor label/info changes
+
+No new files needed. No new infrastructure. Just UI improvements on top of the existing working zap flow.

www/cashu.html

@@ -637,6 +637,7 @@
         <button id="btnCheckProofs" class="btn cashuBtn" type="button" style="margin-bottom: 10px;">Check Proofs with Mints</button>
         <div id="divCheckProofsResult">No proof check run yet.</div>
         <button id="btnRefreshWallet" class="btn cashuBtn" type="button">Refresh Wallet State</button>
+        <button id="btnRepublishWallet" class="btn cashuBtn" type="button" style="margin-top: 5px;">Republish Wallet (kind 17375)</button>
       </div>
 
       <div id="divZapsSection" class="sidenavSection">
@@ -728,7 +729,7 @@
     import { initBlossomSection, updateBlossomSection } from './js/blossom-ui.mjs';
     
     import { initAiSectionWithLocalConfig } from './js/ai-ui.mjs';
-    import { createCashuWalletController } from './js/cashu-wallet.mjs?v=mint-discovery-3';
+    import { createCashuWalletController } from './js/cashu-wallet.mjs?v=nip60-republish-1';
 
     const versionInfo = await getVersion();
     const VERSION = versionInfo.VERSION;
@@ -2348,6 +2349,23 @@
         }
       });
 
+      const btnRepublishWallet = document.getElementById('btnRepublishWallet');
+      btnRepublishWallet?.addEventListener('click', async () => {
+        try {
+          if (!walletController?.hasWallet?.()) {
+            setStatus('No wallet to republish', true);
+            return;
+          }
+          setStatus('Republishing wallet event (kind 17375)...');
+          await walletController.republishWallet();
+          await refreshAllWalletViews();
+          setStatus('Wallet republished successfully');
+        } catch (error) {
+          console.error('[cashu.html] Republish wallet failed:', error);
+          setStatus(error.message || 'Republish failed', true);
+        }
+      });
+
       btnSaveZapsSettings?.addEventListener('click', async () => {
         try {
           const amount = Number(inpZapDefaultAmount?.value || 0);

www/event-management.html

@@ -693,6 +693,7 @@
     const eventRelayPresence = new Map(); // eventKey -> Map(relayUrl, boolean)
     const eventRelayPublishState = new Map(); // eventKey -> Map(relayUrl, 'idle'|'checking'|'publishing'|'failed')
     let subscribedRelayUrls = [];
+    let readableRelayUrls = []; // read/both relays only (excludes write-only) for Refresh Kind queries
     let refreshKindDebugInFlight = false;
     const autoRefreshedKinds = new Set();
     const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -1027,12 +1028,26 @@
         ? rows.filter((r) => r?.fromRelayList === true)
         : rows;
 
+      // subscribedRelayUrls includes all relays (read, write, both) so that
+      // write-only relays still appear as publish-target chips and are valid
+      // targets for the "publish to missing relays" flow.
       const urls = [...new Set(scopedRows
         .map((r) => String(r?.url || '').trim())
         .filter(Boolean))];
 
       subscribedRelayUrls = urls;
 
+      // readableRelayUrls excludes write-only relays (NIP-65 type === 'write')
+      // so the Refresh Kind query loop never tries to READ from a write-only
+      // relay. Falls back to the full list when type info is unavailable.
+      const hasTypeinfo = scopedRows.some((r) => r?.type);
+      readableRelayUrls = hasTypeinfo
+        ? [...new Set(scopedRows
+            .filter((r) => r?.type !== 'write')
+            .map((r) => String(r?.url || '').trim())
+            .filter(Boolean))]
+        : [...urls];
+
       for (const relayMap of eventRelayPresence.values()) {
         for (const url of subscribedRelayUrls) {
           if (!relayMap.has(url)) relayMap.set(url, false);
@@ -1815,8 +1830,13 @@
         });
 
         setSubscribedRelayUrlsFromRelayData(relayData);
-        const relayUrls = [...subscribedRelayUrls];
-        console.log('[event-management] refresh:relayUrls scoped for query', relayUrls);
+        // Use readableRelayUrls (excludes write-only relays) so Refresh Kind
+        // never tries to READ from a write-only relay like sendit.nosflare.com.
+        const relayUrls = [...readableRelayUrls];
+        console.log('[event-management] refresh:relayUrls scoped for query (read-only)', relayUrls, {
+          subscribedRelayUrls: subscribedRelayUrls,
+          readableRelayUrls: readableRelayUrls
+        });
 
         if (!relayUrls.length) {
           divKindsStatus.textContent = `Kind ${targetKind}: no relays found in kind 10002 relay list`;

www/feed2.html

@@ -0,0 +1,714 @@
+<!DOCTYPE html>
+<?xml version="1.0" encoding="UTF-8"?>
+<html lang="en" dir="ltr">
+
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>FEED</title>
+
+  <link rel="stylesheet" href="./css/client.css" />
+  <link rel="stylesheet" href="./css/post-composer.css" />
+  <link rel="stylesheet" href="./css/dot-menu.css" />
+
+  <script>
+    (function () {
+      const savedTheme = localStorage.getItem('theme');
+      if (savedTheme === 'dark') {
+        document.documentElement.classList.add('dark-mode');
+        if (document.body) document.body.classList.add('dark-mode');
+      }
+    })();
+  </script>
+
+  <link rel="shortcut icon" type="image/x-icon" href="./favicon/favicon-dots2.ico" />
+  <script src="./js/vendor/svg.min.js"></script>
+
+  <style>
+    #divBody {
+      flex-direction: column !important;
+      flex-wrap: nowrap !important;
+      align-items: center !important;
+      justify-content: flex-start !important;
+      align-content: flex-start !important;
+      gap: 10px;
+      overflow-y: auto;
+      overflow-anchor: none;
+    }
+
+    #divHint,
+    #divFeed,
+    #btnSeeMore {
+      width: 80%;
+      min-width: 300px;
+      max-width: 700px;
+    }
+
+    #divHint {
+      text-align: center;
+      color: var(--muted-color);
+      font-size: 80%;
+      margin-top: 5px;
+    }
+
+    #divFeed {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      margin-bottom: 10px;
+    }
+
+    #btnSeeMore {
+      display: none;
+      margin-bottom: 20px;
+    }
+    .divPostItem .post-composer-wrapper {
+      width: 100%;
+    }
+  </style>
+</head>
+
+<body>
+  <div id="divSvgHam" class="divHeaderButtons"></div>
+
+  <div id="divHeader">
+    <div id="divHeaderFlexLeft"></div>
+    <div id="divHeaderFlexCenter">
+      <div class="divHeaderText">FEED</div>
+    </div>
+    <div id="divHeaderFlexRight"></div>
+  </div>
+
+  <div id="divBody">
+    <div id="divHint">Loading follows…</div>
+    <div id="divFeed"></div>
+    <button id="btnSeeMore" class="btn">See More</button>
+  </div>
+
+  <div id="divFooter">
+    <div id="divFooterLeft" class="divFooterBox"></div>
+    <div id="divFooterCenter" class="divFooterBox"></div>
+    <div id="divFooterRight" class="divFooterBox"></div>
+    <div id="divFooterBalance" class="divFooterBox">0 sats</div>
+  </div>
+
+  <div id="divSideNav">
+    <div id="divSideNavHeader"></div>
+    <div id="divSideNavBody">
+      <div id="divFiles"></div>
+      <div id="divFeedSettings" class="sidenavSection">
+        <div class="sidenavSectionTitle">Feed</div>
+        <label class="sidenavRowToggle" for="chkAutoplayVideos">
+          <span>Autoplay videos</span>
+          <input id="chkAutoplayVideos" type="checkbox" />
+        </label>
+      </div>
+    </div>
+
+    <div id="divAiSection" class="sidenavSection"> 
+      <div id="divAiSectionTitle" class="sidenavSectionTitle">AI</div>
+      <div id="divAiList" class="sidenavSectionList">
+        <div id="divAiProvidersList">No saved providers yet.</div>
+      </div>
+    </div>
+
+
+    <div id="divRelaySection">
+      <div id="divRelaySectionTitle">リレー</div>
+      <div id="divRelayList">Loading relays...</div>
+    </div>
+
+    <div id="divBlossomSection">
+      <div id="divBlossomSectionTitle">ブロッサム</div>
+      <div id="divBlossomList">Loading blossom servers...</div>
+    </div>
+
+    <div id="divVersionBar">
+      <span id="versionDisplay">loading...</span>
+      <div id="divVersionBarButtons">
+        <button id="themeToggleButton" title="Toggle Dark/Light Mode">
+          <div id="themeToggleHamburgerContainer"></div>
+        </button>
+        <button id="logoutButton" title="Logout">
+          <div id="logoutHamburgerContainer"></div>
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <script src="./nostr.bundle.js"></script>
+  <script src="/nostr-login-lite/nostr-lite.js"></script>
+
+  <script type="module">
+    import {
+      initNDKPage,
+      getPubkey,
+      injectHeaderAvatar,
+      subscribe,
+      disconnect,
+      getVersion,
+      queryCache,
+      ndkFetchEvents,
+      fetchCachedProfile,
+      storeProfile,
+      publishEvent,
+      walletPayInvoice,
+      walletSendNutzap,
+      walletFetchMintList,
+      getRelayData,
+      getUserSettings,
+      patchUserSettings,
+      onUserSettings,
+      ensureMuteListLoaded,
+      isEventMuted,
+      addMute
+    } from './js/init-ndk.mjs';
+    import { HamburgerMorphing } from './hamburger_morphing/hamburger.mjs';
+    import { initFooterRelayStatus, updateFooterRelayStatus, initSidenavRelaySection, updateSidenavRelaySection, setRelayActivityState } from './js/relay-ui.mjs';
+    import { initBlossomSection, updateBlossomSection } from './js/blossom-ui.mjs';
+    
+    import { initAiSectionWithLocalConfig } from './js/ai-ui.mjs';
+import { initPostCards } from './js/post-interactions2.mjs';
+    import { mountComposer } from './js/post-composer.mjs';
+
+    const INITIAL_POSTS_LOAD = 10;
+    const SEE_MORE_INCREMENT = 20;
+    const MIN_BOOTSTRAP_POSTS = 10;
+    const FEED_BOOTSTRAP_WINDOWS_SECONDS = [3600, 6 * 3600, 24 * 3600, 7 * 24 * 3600, 30 * 24 * 3600];
+    const FEED_BOOTSTRAP_WINDOW_LIMIT = 120;
+
+    let currentPubkey = null;
+    let updateIntervalId = null;
+
+    let unsubscribeUserSettings = null;
+
+    let hamburgerInstance = null;
+    let logoutHamburger = null;
+    let themeToggleHamburger = null;
+    let isDarkMode = false;
+    let isNavOpen = false;
+
+    const posts = [];
+    const postIds = new Set();
+    const renderedPostIds = new Set();
+    let displayCount = INITIAL_POSTS_LOAD;
+
+    let followedPubkeys = [];
+    const feedPubkeys = new Set();
+
+    const divBody = document.getElementById('divBody');
+    const divSideNav = document.getElementById('divSideNav');
+    const divFooterRight = document.getElementById('divFooterRight');
+    const divFeed = document.getElementById('divFeed');
+    const divHint = document.getElementById('divHint');
+    const btnSeeMore = document.getElementById('btnSeeMore');
+    const chkAutoplayVideos = document.getElementById('chkAutoplayVideos');
+
+    let autoplayVideosEnabled = false;
+    let liveFeedSubscriptionKey = '';
+
+    const inlineComposerInstances = new Map(); // postId -> { hostEl, instance, tags }
+
+    let isBootstrappingFeed = false;
+    let hasBootstrappedFeed = false;
+    const bufferedFeedEvents = [];
+
+    function toNostrNoteRef(postId) {
+      try {
+        return window?.NostrTools?.nip19?.noteEncode
+          ? window.NostrTools.nip19.noteEncode(postId)
+          : postId;
+      } catch (_) {
+        return postId;
+      }
+    }
+
+    function focusInlineComposer(hostEl, content = '') {
+      if (!hostEl) return false;
+      hostEl.innerText = content || '';
+      hostEl.focus();
+      document.dispatchEvent(new Event('selectionchange'));
+      hostEl.dispatchEvent(new Event('input', { bubbles: true }));
+      window.requestAnimationFrame(() => {
+        hostEl.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      });
+      return true;
+    }
+
+    function getOrCreateInlineComposer(postId, postEl) {
+      if (!postId || !postEl) return null;
+
+      const existing = inlineComposerInstances.get(postId);
+      if (existing?.hostEl?.isConnected && existing?.instance) {
+        return existing;
+      }
+
+      const hostEl = document.createElement('div');
+      hostEl.className = 'inlinePostComposerInput';
+      hostEl.dataset.inlineComposerFor = postId;
+      postEl.appendChild(hostEl);
+
+      const entry = {
+        hostEl,
+        tags: [],
+        instance: null
+      };
+
+      const instance = mountComposer(hostEl, {
+        currentPubkey,
+        followedProfiles: [],
+        showUploadIcon: true,
+        showPreview: true,
+        autoHideOnSubmit: true,
+        hideOnEscape: true,
+        onSubmit: async (content) => {
+          const text = String(content || '').trim();
+          if (!text) return;
+
+          await publishEvent({
+            kind: 1,
+            content: text,
+            tags: entry.tags,
+            created_at: Math.floor(Date.now() / 1000)
+          });
+        }
+      });
+
+      entry.instance = instance;
+      inlineComposerInstances.set(postId, entry);
+      return entry;
+    }
+
+    function handleComposerCommentIntent({ postId }) {
+      if (!postId) return false;
+      window.open('./post-feed.html?event=' + encodeURIComponent(postId), '_blank');
+      return true;
+    }
+
+    function handleComposerQuoteIntent({ postId, postPubkey }) {
+      const postEl = document.querySelector(`.divPostItem[data-post-id="${postId}"]`);
+      if (!postEl) return false;
+
+      const noteRef = toNostrNoteRef(postId);
+      const entry = getOrCreateInlineComposer(postId, postEl);
+      if (!entry) return false;
+      entry.tags = [
+        ['e', postId, '', 'mention'],
+        ['p', postPubkey],
+        ['q', postId]
+      ];
+      if (entry.instance?.show) entry.instance.show();
+      return focusInlineComposer(entry.hostEl, `nostr:${noteRef}`);
+    }
+
+    async function handleMuteIntent({ eventData }) {
+      const targetPubkey = String(eventData?.pubkey || '').trim();
+      if (!targetPubkey || targetPubkey === currentPubkey) return;
+
+      const ok = window.confirm(`Mute ${targetPubkey.slice(0, 8)}…${targetPubkey.slice(-4)}?`);
+      if (!ok) return;
+
+      await addMute('p', targetPubkey, false);
+
+      for (let i = posts.length - 1; i >= 0; i -= 1) {
+        if (posts[i]?.pubkey === targetPubkey) {
+          postIds.delete(posts[i]?.id);
+          posts.splice(i, 1);
+        }
+      }
+
+      renderFeed();
+    }
+
+    const cards = initPostCards({
+      subscribe,
+      publishEvent,
+      getPubkey,
+      ndkFetchEvents,
+      queryCache,
+      fetchCachedProfile,
+      storeProfile,
+      walletPayInvoice,
+      walletSendNutzap,
+      walletFetchMintList,
+      getRelayData,
+      getUserSettings,
+      patchUserSettings,
+      onCommentIntent: handleComposerCommentIntent,
+      onQuoteIntent: handleComposerQuoteIntent,
+      onMuteIntent: handleMuteIntent
+    });
+
+    function initHamburgerMenu() {
+      hamburgerInstance = new HamburgerMorphing('#divSvgHam', {
+        foreground: 'var(--primary-color)',
+        background: 'var(--secondary-color)',
+        hover: 'var(--accent-color)'
+      });
+      hamburgerInstance.animateTo('burger');
+    }
+
+    function openNav() {
+      divSideNav.style.zIndex = 3;
+      divSideNav.style.width = 'clamp(400px, 50vw, 600px)';
+      isNavOpen = true;
+      if (hamburgerInstance) hamburgerInstance.animateTo('arrow_left');
+
+      if (!logoutHamburger) {
+        logoutHamburger = new HamburgerMorphing('#logoutHamburgerContainer', {
+          size: 24,
+          foreground: 'var(--primary-color)',
+          background: 'var(--secondary-color)',
+          hover: 'var(--accent-color)'
+        });
+        logoutHamburger.animateTo('x');
+      }
+
+      if (!themeToggleHamburger) {
+        themeToggleHamburger = new HamburgerMorphing('#themeToggleHamburgerContainer', {
+          size: 24,
+          foreground: 'var(--primary-color)',
+          background: 'var(--secondary-color)',
+          hover: 'var(--accent-color)'
+        });
+        const savedTheme = localStorage.getItem('theme');
+        isDarkMode = savedTheme === 'dark' || document.body.classList.contains('dark-mode');
+        themeToggleHamburger.animateTo(isDarkMode ? 'moon' : 'circle');
+      }
+    }
+
+    function closeNav() {
+      divSideNav.style.width = '0vw';
+      divSideNav.style.zIndex = -1;
+      isNavOpen = false;
+      if (hamburgerInstance) hamburgerInstance.animateTo('burger');
+    }
+
+    function toggleNav() {
+      isNavOpen ? closeNav() : openNav();
+    }
+
+    function isOriginalPost(event) {
+      const eTags = event.tags?.filter(t => t[0] === 'e') || [];
+      if (eTags.length === 0) return true;
+      return eTags.every(t => t[3] === 'mention');
+    }
+
+    function applyVideoAutoplaySetting(enabled) {
+      autoplayVideosEnabled = !!enabled;
+      if (chkAutoplayVideos) chkAutoplayVideos.checked = autoplayVideosEnabled;
+
+      const videoEls = Array.from(divFeed.querySelectorAll('video'));
+      videoEls.forEach((videoEl) => {
+        videoEl.controls = true;
+        videoEl.playsInline = true;
+        videoEl.setAttribute('playsinline', '');
+        videoEl.preload = 'metadata';
+
+        if (autoplayVideosEnabled) {
+          videoEl.autoplay = true;
+          videoEl.muted = true;
+          videoEl.setAttribute('autoplay', '');
+          videoEl.setAttribute('muted', '');
+          const playPromise = videoEl.play?.();
+          if (playPromise?.catch) playPromise.catch(() => {});
+        } else {
+          videoEl.autoplay = false;
+          videoEl.muted = false;
+          videoEl.removeAttribute('autoplay');
+          videoEl.removeAttribute('muted');
+        }
+      });
+    }
+
+    function applySettings(settings) {
+      const nextAutoplayEnabled = !!settings?.feed?.videoAutoplay;
+      applyVideoAutoplaySetting(nextAutoplayEnabled);
+    }
+
+    async function persistAutoplaySetting(enabled) {
+      try {
+        await patchUserSettings({
+          feed: {
+            videoAutoplay: !!enabled
+          }
+        });
+      } catch (error) {
+        console.warn('[feed.html] Failed to persist feed autoplay setting:', error?.message || error);
+      }
+    }
+
+    function upsertFeedPost(evt) {
+      if (!evt?.id || postIds.has(evt.id) || !isOriginalPost(evt)) return false;
+      if (isEventMuted(evt)) return false;
+      postIds.add(evt.id);
+      posts.push(evt);
+      return true;
+    }
+
+    function renderFeed() {
+      posts.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
+      const toShow = posts.slice(0, displayCount);
+
+      divFeed.innerHTML = '';
+      renderedPostIds.clear();
+
+      toShow.forEach((post) => {
+        const postEl = cards.createCard(post, { currentPubkey, autoWire: false, autoplayVideo: autoplayVideosEnabled });
+        divFeed.appendChild(postEl);
+        renderedPostIds.add(post.id);
+      });
+
+      cards.wireInteractions(toShow.map(p => p.id), { currentPubkey });
+
+      btnSeeMore.style.display = posts.length > displayCount ? 'block' : 'none';
+      divHint.textContent = followedPubkeys.length > 0
+        ? `${posts.length} posts from ${followedPubkeys.length} follows`
+        : 'Follow users to populate your feed.';
+      divFooterRight.textContent = `${posts.length} posts`;
+    }
+
+    async function fetchFeedWindow(authors, { since, limit = FEED_BOOTSTRAP_WINDOW_LIMIT, renderAfterCache = false } = {}) {
+      if (!Array.isArray(authors) || authors.length === 0) return;
+      const filters = { kinds: [1], authors, limit };
+      if (typeof since === 'number' && Number.isFinite(since) && since > 0) {
+        filters.since = since;
+      }
+
+      const cached = await queryCache(filters).catch(() => []);
+      cached.forEach((evt1) => {
+        upsertFeedPost(evt1);
+      });
+
+      if (renderAfterCache && posts.length > 0) {
+        renderFeed();
+      }
+
+      void ndkFetchEvents(filters).then((fresh) => {
+        (Array.isArray(fresh) ? fresh : []).forEach((evt1) => {
+          upsertFeedPost(evt1);
+        });
+        if (posts.length > 0) {
+          renderFeed();
+        }
+      }).catch(() => {});
+    }
+
+    async function bootstrapFeedPosts(authors) {
+      if (!Array.isArray(authors) || authors.length === 0) {
+        hasBootstrappedFeed = true;
+        renderFeed();
+        return;
+      }
+
+      isBootstrappingFeed = true;
+      const now = Math.floor(Date.now() / 1000);
+
+      await Promise.allSettled(
+        FEED_BOOTSTRAP_WINDOWS_SECONDS.map((windowSeconds) =>
+          fetchFeedWindow(authors, {
+            since: now - windowSeconds,
+            limit: FEED_BOOTSTRAP_WINDOW_LIMIT,
+            renderAfterCache: true
+          })
+        )
+      );
+
+      if (posts.length < MIN_BOOTSTRAP_POSTS) {
+        await fetchFeedWindow(authors, {
+          since: 0,
+          limit: FEED_BOOTSTRAP_WINDOW_LIMIT * 2,
+          renderAfterCache: true
+        });
+      }
+
+      bufferedFeedEvents.forEach((evt1) => {
+        if (feedPubkeys.has(evt1.pubkey)) {
+          upsertFeedPost(evt1);
+        }
+      });
+      bufferedFeedEvents.length = 0;
+
+      isBootstrappingFeed = false;
+      hasBootstrappedFeed = true;
+      renderFeed();
+    }
+
+    function ensureLiveFeedSubscription() {
+      const authors = Array.from(feedPubkeys).filter(Boolean);
+      if (authors.length === 0) return;
+
+      const key = authors.slice().sort().join(',');
+      if (key === liveFeedSubscriptionKey) return;
+
+      const newestKnown = posts.reduce((max, p) => Math.max(max, p?.created_at || 0), 0);
+      const now = Math.floor(Date.now() / 1000);
+      const since = newestKnown > 0 ? Math.max(0, newestKnown - 30) : (now - 3600);
+
+      subscribe(
+        { kinds: [1], authors, since },
+        { closeOnEose: false, cacheUsage: 'CACHE_FIRST' }
+      );
+
+      liveFeedSubscriptionKey = key;
+      console.log('[feed.html] Live feed subscription active', { authors: authors.length, since });
+    }
+
+    async function ingestContactList(evt) {
+      if (!evt || evt.kind !== 3 || evt.pubkey !== currentPubkey) return;
+      const pTags = evt.tags?.filter(tag => tag[0] === 'p' && tag[1]) || [];
+      followedPubkeys = pTags.map(tag => tag[1]);
+
+      const newAuthors = followedPubkeys.filter((pk) => !feedPubkeys.has(pk));
+      newAuthors.forEach((pk) => feedPubkeys.add(pk));
+
+      ensureLiveFeedSubscription();
+
+      const allAuthors = Array.from(feedPubkeys);
+
+      if (!hasBootstrappedFeed) {
+        await bootstrapFeedPosts(allAuthors);
+        return;
+      }
+
+      if (newAuthors.length > 0) {
+        try {
+          await fetchFeedWindow(newAuthors, { limit: INITIAL_POSTS_LOAD });
+          renderFeed();
+        } catch (_) {
+          renderFeed();
+        }
+      } else {
+        renderFeed();
+      }
+    }
+
+    async function logout() {
+      if (updateIntervalId) {
+        clearInterval(updateIntervalId);
+        updateIntervalId = null;
+      }
+      cards.destroy();
+      disconnect();
+      if (window.NOSTR_LOGIN_LITE?.logout) {
+        await window.NOSTR_LOGIN_LITE.logout();
+      }
+      if (unsubscribeUserSettings) {
+        unsubscribeUserSettings();
+        unsubscribeUserSettings = null;
+      }
+      localStorage.clear();
+      sessionStorage.clear();
+      location.reload(true);
+    }
+
+    async function updateFooter() {
+      try {
+        await updateFooterRelayStatus();
+        await updateSidenavRelaySection();
+        await updateBlossomSection();
+      } catch (_) {}
+    }
+
+    (async function main() {
+      try {
+        const versionInfo = await getVersion();
+        document.getElementById('versionDisplay').textContent = versionInfo.VERSION;
+
+        initHamburgerMenu();
+        document.getElementById('divSvgHam')?.addEventListener('click', toggleNav);
+
+        document.getElementById('themeToggleButton')?.addEventListener('click', () => {
+          isDarkMode = !isDarkMode;
+          localStorage.setItem('theme', isDarkMode ? 'dark' : 'light');
+          document.documentElement.classList.toggle('dark-mode', isDarkMode);
+          document.body.classList.toggle('dark-mode', isDarkMode);
+          if (themeToggleHamburger) {
+            themeToggleHamburger.animateTo(isDarkMode ? 'moon' : 'circle');
+          }
+        });
+
+        document.getElementById('logoutButton')?.addEventListener('click', logout);
+
+        btnSeeMore.addEventListener('click', () => {
+          displayCount += SEE_MORE_INCREMENT;
+          renderFeed();
+        });
+
+        chkAutoplayVideos?.addEventListener('change', async () => {
+          const nextEnabled = !!chkAutoplayVideos.checked;
+          applyVideoAutoplaySetting(nextEnabled);
+          await persistAutoplaySetting(nextEnabled);
+        });
+
+        await initNDKPage();
+        currentPubkey = await getPubkey();
+        await injectHeaderAvatar(currentPubkey);
+
+        await ensureMuteListLoaded();
+
+        try {
+          const settings = await getUserSettings();
+          applySettings(settings || {});
+        } catch (error) {
+          console.warn('[feed.html] Failed to load user settings:', error?.message || error);
+          applySettings({});
+        }
+
+        if (!unsubscribeUserSettings) {
+          unsubscribeUserSettings = onUserSettings((settings) => {
+            applySettings(settings || {});
+          });
+        }
+
+        initFooterRelayStatus();
+        initSidenavRelaySection();
+        await initBlossomSection();
+        initAiSectionWithLocalConfig();
+        await updateFooter();
+        updateIntervalId = setInterval(updateFooter, 1000);
+
+        window.addEventListener('ndkRelayActivity', (e) => {
+          setRelayActivityState(e.detail.relayUrl, e.detail.activity);
+        });
+
+        window.addEventListener('ndkEvent', async (e) => {
+          const evt = e.detail;
+          if (!evt) return;
+
+          if (evt.kind === 3 && evt.pubkey === currentPubkey) {
+            await ingestContactList(evt);
+            return;
+          }
+
+          if (evt.kind === 1 && feedPubkeys.has(evt.pubkey) && isOriginalPost(evt)) {
+            if (isBootstrappingFeed) {
+              bufferedFeedEvents.push(evt);
+              return;
+            }
+            if (!upsertFeedPost(evt)) return;
+            renderFeed();
+          }
+        });
+
+        subscribe({ kinds: [3], authors: [currentPubkey], limit: 1 }, { closeOnEose: false, cacheUsage: 'CACHE_FIRST' });
+
+        const cachedContactEvents = await queryCache({ kinds: [3], authors: [currentPubkey], limit: 1 }).catch(() => []);
+        if (cachedContactEvents.length > 0) {
+          const latest = cachedContactEvents.sort((a, b) => (b.created_at || 0) - (a.created_at || 0))[0];
+          await ingestContactList(latest);
+        }
+
+        if (feedPubkeys.size === 0) {
+          divHint.textContent = 'Follow users to populate your feed.';
+        }
+
+      } catch (error) {
+        console.error('[feed.html] Initialization failed:', error);
+        divBody.innerHTML = `<div style="text-align:center;padding:50px;"><div style="font-size:24px;margin-bottom:20px;color:var(--primary-color);">❌ Error</div><div style="font-size:16px;color:var(--muted-color);">${error.message}</div></div>`;
+      }
+    })();
+  </script>
+</body>
+
+</html>

www/js/cashu-wallet.mjs

@@ -15,6 +15,7 @@ import {
   walletRemoveMint,
   walletGetTransactions,
   walletShutdown,
+  walletRepublish,
   walletPublishMintList,
   walletFetchMintList,
   onWalletStatus,
@@ -397,6 +398,16 @@ export async function createCashuWalletController({ pubkey, relayUrls = [] } = {
     }
   }
 
+  async function republishWallet() {
+    await ensureWallet();
+    const result = await walletRepublish();
+    if (Array.isArray(result?.mints)) {
+      mintsCache = uniqueMints(result.mints);
+    }
+    applyBalancePayload(result || {});
+    return { mints: [...mintsCache] };
+  }
+
   cleanupFns.push(onWalletStatus((payload) => {
     if (typeof payload?.hasWallet === 'boolean') {
       hasWalletCache = payload.hasWallet;
@@ -431,6 +442,7 @@ export async function createCashuWalletController({ pubkey, relayUrls = [] } = {
     waitForDeposit,
     getTransactionHistory,
     publishMintList,
+    republishWallet,
     fetchRecipientMintList,
     onWalletEvent,
     subscribeTransactions,

www/js/init-ndk.mjs

@@ -184,7 +184,7 @@ export async function initNDKPage(options = {}) {
 
     // All pages in www/ directory, so worker path is always the same.
     // Include explicit worker revision token so updated SharedWorker code is guaranteed to restart.
-    const WORKER_REVISION = 'relay-events-db-6';
+    const WORKER_REVISION = 'nip60-lightweight-republish-1';
     const workerPath = `./ndk-worker.js?v=${encodeURIComponent(VERSION)}&wr=${encodeURIComponent(WORKER_REVISION)}`;
 
     // Initialize NDK SharedWorker (shared across all tabs/pages)
@@ -1425,6 +1425,10 @@ export function walletShutdown() {
     return sendWorkerRequest('walletShutdown', {}, 10000, 'walletShutdown timeout');
 }
 
+export function walletRepublish() {
+    return sendWorkerRequest('walletRepublish', {}, 30000, 'walletRepublish timeout');
+}
+
 export function walletPublishMintList(relays = [], receiveMints = []) {
     return sendWorkerRequest('walletPublishMintList', { relays, receiveMints }, 25000, 'walletPublishMintList timeout');
 }

www/js/version.json

@@ -1,5 +1,5 @@
 {
-  "VERSION": "v0.7.18",
-  "VERSION_NUMBER": "0.7.18",
-  "BUILD_DATE": "2026-06-14T12:07:35.533Z"
+  "VERSION": "v0.7.28",
+  "VERSION_NUMBER": "0.7.28",
+  "BUILD_DATE": "2026-06-26T00:20:10.087Z"
 }

www/ndk-worker.js

@@ -1723,6 +1723,51 @@ async function processLightwalletTokenEvent(tokenEvent, pubkey) {
     }
 }
 
+let legacyWalletMigrationAttempted = false;
+
+/**
+ * One-time migration: if the user has an old-format kind 17375 wallet event
+ * (proprietary {mints, nutzap} object instead of NIP-60 tag-array), republish
+ * it in the standard format so other NIP-60 clients (Amethyst, NDK) can read it.
+ * The migration is fire-and-forget — publishDirectProofs() writes the new
+ * tag-array format and NIP-09 deletes the old event.
+ */
+async function migrateLegacyWalletEventIfNeeded(pubkey, walletEvents = []) {
+    if (legacyWalletMigrationAttempted) return;
+    if (!pubkey || !messageSigner) return;
+    const events = Array.isArray(walletEvents) ? walletEvents : [];
+    if (events.length === 0) return;
+
+    for (const evt of events) {
+        if (!evt?.content) continue;
+        try {
+            const decrypted = await messageSigner.requestFromPage('nip44Decrypt', {
+                senderPubkey: pubkey,
+                ciphertext: evt.content
+            });
+            const plaintext = typeof decrypted === 'string' ? decrypted : decrypted?.plaintext;
+            if (!plaintext) continue;
+            const parsed = JSON.parse(plaintext);
+            // Legacy format is an object; NIP-60 standard is an array.
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                console.log('[Worker] NIP-60 migration: detected legacy wallet event, republishing in tag-array format');
+                legacyWalletMigrationAttempted = true;
+                try {
+                    await publishDirectProofs({ traceId: 'nip60-migration' });
+                    console.log('[Worker] NIP-60 migration: republish complete');
+                } catch (err) {
+                    console.warn('[Worker] NIP-60 migration: republish failed:', err?.message || err);
+                }
+                return;
+            }
+        } catch (_error) {
+            // Ignore decrypt/parse failures — might be a different encryption scheme
+        }
+    }
+    // No legacy events found; mark as checked so we don't re-scan every startup.
+    legacyWalletMigrationAttempted = true;
+}
+
 async function hydrateLightwalletFromFetchedEvents(pubkey, walletEvents = [], tokenEvents = [], deletionEvents = []) {
     lightwalletHasWallet = Array.isArray(walletEvents) && walletEvents.length > 0;
     await hydrateNutzapKeyFromWalletEvents(pubkey, walletEvents);
@@ -1737,6 +1782,12 @@ async function hydrateLightwalletFromFetchedEvents(pubkey, walletEvents = [], to
 
     hydrateDirectProofStore();
     broadcastLightwalletBalance('startup-fetch');
+
+    // Fire-and-forget: migrate legacy {mints,nutzap} wallet events to NIP-60
+    // tag-array format so other clients (Amethyst, NDK) can read our wallet.
+    void migrateLegacyWalletEventIfNeeded(pubkey, walletEvents).catch((err) => {
+        console.warn('[Worker] NIP-60 migration check failed:', err?.message || err);
+    });
 }
 
 async function fetchStartupEventDownloads(pubkey) {
@@ -2184,6 +2235,59 @@ function ensureDirectNutzapP2pk() {
     };
 }
 
+/**
+ * Parse the decrypted content of a kind 17375 Cashu wallet event.
+ *
+ * NIP-60 standard format (what we now write and what Amethyst/NDK expect):
+ *   [["mint","https://mint.example.com"],["privkey","<hex>"]]
+ *
+ * Legacy format (what this project previously wrote — kept for backwards compat):
+ *   {"mints":["https://mint.example.com"],"nutzap":{"privkey":"<hex>","p2pk":"<pubkey>"}}
+ *
+ * Returns { mints: string[], privkey: string|null, p2pk: string|null, isLegacy: boolean }
+ */
+function parseWalletContent(plaintext) {
+    if (!plaintext) return { mints: [], privkey: null, p2pk: null, isLegacy: false };
+    const parsed = JSON.parse(plaintext);
+    if (!parsed || typeof parsed !== 'object') {
+        return { mints: [], privkey: null, p2pk: null, isLegacy: false };
+    }
+
+    // Standard NIP-60 tag-array format: [["mint",url],["privkey",hex]]
+    if (Array.isArray(parsed)) {
+        const mints = [];
+        let privkey = null;
+        let p2pk = null;
+        for (const tag of parsed) {
+            if (!Array.isArray(tag) || tag.length < 2) continue;
+            if (tag[0] === 'mint' && typeof tag[1] === 'string') {
+                mints.push(normalizeMintUrl(tag[1]));
+            } else if (tag[0] === 'privkey' && typeof tag[1] === 'string') {
+                privkey = normalizeHexKey(tag[1]);
+            } else if (tag[0] === 'p2pk' && typeof tag[1] === 'string') {
+                p2pk = normalizeCashuP2pk(tag[1]);
+            }
+        }
+        return { mints: mints.filter(Boolean), privkey, p2pk, isLegacy: false };
+    }
+
+    // Legacy object format: { mints: [...], nutzap: { privkey, p2pk } }
+    const mints = Array.isArray(parsed.mints)
+        ? parsed.mints.map(normalizeMintUrl).filter(Boolean)
+        : [];
+    const privkey = normalizeHexKey([
+        parsed?.nutzap?.privkey,
+        parsed?.nutzapPrivkey,
+        parsed?.nutzap_private_key
+    ].find(Boolean) || '');
+    const p2pk = normalizeCashuP2pk([
+        parsed?.nutzap?.p2pk,
+        parsed?.nutzapP2pk,
+        parsed?.nutzap_p2pk
+    ].find(Boolean) || '');
+    return { mints, privkey: privkey || null, p2pk: p2pk || null, isLegacy: true };
+}
+
 async function hydrateNutzapKeyFromWalletEvents(pubkey, walletEvents = []) {
     if (!messageSigner || !pubkey) return;
 
@@ -2200,20 +2304,9 @@ async function hydrateNutzapKeyFromWalletEvents(pubkey, walletEvents = []) {
             const plaintext = typeof decrypted === 'string' ? decrypted : decrypted?.plaintext;
             if (!plaintext) continue;
 
-            const parsed = JSON.parse(plaintext);
-            if (!parsed || typeof parsed !== 'object') continue;
-
-            const candidatePrivkey = normalizeHexKey([
-                parsed?.nutzap?.privkey,
-                parsed?.nutzapPrivkey,
-                parsed?.nutzap_private_key
-            ].find(Boolean) || '');
-
-            const candidateP2pk = normalizeCashuP2pk([
-                parsed?.nutzap?.p2pk,
-                parsed?.nutzapP2pk,
-                parsed?.nutzap_p2pk
-            ].find(Boolean) || '');
+            const parsed = parseWalletContent(plaintext);
+            const candidatePrivkey = parsed.privkey;
+            const candidateP2pk = parsed.p2pk;
 
             if (!candidatePrivkey && !candidateP2pk) continue;
 
@@ -2750,22 +2843,29 @@ async function publishDirectProofs(debugContext = null) {
     }
     log('delete old 7375 done');
 
-    const mintTags = getDirectWalletMints().map((mintUrl) => ['mint', mintUrl]);
-    if (directNutzapP2pk) {
-        mintTags.push(['pubkey', directNutzapP2pk]);
+    // Ensure a nutzap privkey exists before building the wallet payload.
+    // If the user's old 17375 didn't have one (or hydration failed),
+    // this auto-generates one so it's always included in the republish.
+    try {
+        ensureDirectNutzapP2pk();
+    } catch (err) {
+        log('ensureDirectNutzapP2pk failed during publish', { error: err?.message || String(err) });
     }
 
-    const walletPayloadObj = {
-        mints: getDirectWalletMints(),
-        ...(directNutzapPrivateKeyHex
-            ? {
-                nutzap: {
-                    privkey: directNutzapPrivateKeyHex,
-                    p2pk: directNutzapP2pk || null
-                }
-            }
-            : {})
-    };
+    // NIP-60 standard: public "mint" tags are visible on the event;
+    // the privkey lives in the encrypted content as a "privkey" tag.
+    // The "pubkey" tag does NOT belong on kind 17375 (it belongs on
+    // kind 10019 NutzapInfoEvent). Removed for NIP-60 compliance.
+    const mintTags = getDirectWalletMints().map((mintUrl) => ['mint', mintUrl]);
+
+    // NIP-60 standard content format: a JSON array of tag arrays.
+    //   [["mint","https://..."],["privkey","<hex>"]]
+    // This matches NDK's payloadForEvent() and Amethyst's
+    // CashuWalletEvent.build() so other NIP-60 clients can read our wallet.
+    const walletPayloadObj = [
+        ...getDirectWalletMints().map((url) => ['mint', url]),
+        ...(directNutzapPrivateKeyHex ? [['privkey', directNutzapPrivateKeyHex]] : [])
+    ];
     const walletPayload = JSON.stringify(walletPayloadObj);
     log('encrypt wallet payload start', { mintTagCount: mintTags.length });
     const encryptedWalletResp = await messageSigner.requestFromPage('nip44Encrypt', {
@@ -4213,6 +4313,97 @@ async function handleWalletCheckProofs(requestId, port) {
     }
 }
 
+/**
+ * Lightweight republish of ONLY the kind 17375 wallet event.
+ *
+ * Kind 17375 is a replaceable event (NIP-60, d-tag = ""), so publishing a
+ * new one automatically supersedes the old one on relays — no NIP-09
+ * deletions needed. This skips the heavy publishDirectProofs() which
+ * rewrites all 7375 token events too (100+ signing round-trips).
+ *
+ * Just: ensure privkey → build tag-array payload → encrypt → sign → publish.
+ */
+async function handleWalletRepublish(requestId, port) {
+    try {
+        if (!ndk || !currentPubkey) {
+            port.postMessage({ type: 'response', requestId, error: 'NDK not ready' });
+            return;
+        }
+        await ensureDirectWalletLoaded();
+
+        // Ensure a nutzap privkey exists (auto-generate if missing)
+        try {
+            ensureDirectNutzapP2pk();
+        } catch (err) {
+            console.warn('[Worker] handleWalletRepublish: ensureDirectNutzapP2pk failed:', err?.message || err);
+        }
+
+        const NDKEvent = getNDKEventCtor();
+        if (!NDKEvent) {
+            port.postMessage({ type: 'response', requestId, error: 'NDKEvent constructor not available' });
+            return;
+        }
+
+        // Build NIP-60 tag-array payload: [["mint",url],["privkey",hex]]
+        const mintTags = getDirectWalletMints().map((mintUrl) => ['mint', mintUrl]);
+        const walletPayloadObj = [
+            ...getDirectWalletMints().map((url) => ['mint', url]),
+            ...(directNutzapPrivateKeyHex ? [['privkey', directNutzapPrivateKeyHex]] : [])
+        ];
+        const walletPayload = JSON.stringify(walletPayloadObj);
+
+        // NIP-44 encrypt the payload
+        const encryptedWalletResp = await messageSigner.requestFromPage('nip44Encrypt', {
+            recipientPubkey: currentPubkey,
+            plaintext: walletPayload
+        });
+        const encryptedWallet = typeof encryptedWalletResp === 'string' ? encryptedWalletResp : encryptedWalletResp?.ciphertext;
+
+        if (!encryptedWallet) {
+            port.postMessage({ type: 'response', requestId, error: 'Failed to encrypt wallet payload' });
+            return;
+        }
+
+        // Build and publish the new 17375 event (replaceable — supersedes old one)
+        const walletEvent = new NDKEvent(ndk, {
+            kind: 17375,
+            tags: mintTags,
+            content: encryptedWallet,
+            created_at: Math.floor(Date.now() / 1000)
+        });
+
+        await signEventWithMessageSigner(walletEvent);
+        const relaySet = await walletEvent.publish();
+
+        if (relaySet && relaySet.size > 0) {
+            for (const relay of relaySet) {
+                trackRelayWrite(relay.url);
+            }
+        }
+
+        console.log('[Worker] handleWalletRepublish: 17375 published', {
+            relayCount: relaySet ? relaySet.size : 0,
+            mintCount: mintTags.length,
+            hasPrivkey: Boolean(directNutzapPrivateKeyHex)
+        });
+
+        const payload = getWalletBalancePayload();
+        port.postMessage({
+            type: 'response',
+            requestId,
+            data: {
+                success: true,
+                mints: getDirectWalletMints(),
+                relayCount: relaySet ? relaySet.size : 0,
+                ...payload
+            }
+        });
+    } catch (error) {
+        console.warn('[Worker] handleWalletRepublish failed:', error?.message || error);
+        port.postMessage({ type: 'response', requestId, error: error.message || 'Republish failed' });
+    }
+}
+
 function handleWalletShutdown(requestId, port) {
     try {
         clearWalletListeners();
@@ -4226,6 +4417,7 @@ function handleWalletShutdown(requestId, port) {
         directNutzapP2pk = null;
         directMintLocalUpdatedAt.clear();
         spendingHistoryLastFetchAtMs = 0;
+        legacyWalletMigrationAttempted = false;
         spendingHistoryFetchPromise = null;
         broadcastWalletStatus();
         port.postMessage({ type: 'response', requestId, data: { success: true } });
@@ -5942,6 +6134,7 @@ function handleDisconnect() {
     directNutzapP2pk = null;
     spendingHistoryLastFetchAtMs = 0;
     spendingHistoryFetchPromise = null;
+    legacyWalletMigrationAttempted = false;
 }
 
 // Get relay data for relays page
@@ -6407,7 +6600,11 @@ self.onconnect = (event) => {
             case 'walletCheckProofs':
                 await handleWalletCheckProofs(requestId, port);
                 break;
-                
+
+            case 'walletRepublish':
+                await handleWalletRepublish(requestId, port);
+                break;
+
             default:
                 console.warn('[Worker] Unknown message type:', type);
         }