From 1fdebf1eebae8229d6e0604db6a0c82c81a9cf85 Mon Sep 17 00:00:00 2001
From: Keep Creating Online <53631862+PR0M3TH3AN@users.noreply.github.com>
Date: Wed, 8 Jan 2025 22:52:25 -0500
Subject: [PATCH] update

---
 src/index.html          |   20 +-
 src/js/accessControl.js |  154 ++++++
 src/js/config.js        |    1 +
 src/js/lists.js         |   13 +
 src/js/nostr.js         | 1049 +++++++++++++++++++++------------------
 5 files changed, 740 insertions(+), 497 deletions(-)
 create mode 100644 src/js/accessControl.js
 create mode 100644 src/js/lists.js

diff --git a/src/index.html b/src/index.html
index 9099cdb..4dd0bfa 100644
--- a/src/index.html
+++ b/src/index.html
@@ -406,6 +406,15 @@
 
       <!-- Footer -->
       <footer class="mt-auto pb-8 text-center px-4">
+        <a
+          href="http://bitvid.network/"
+          class="text-gray-500 hover:text-gray-400 transition-colors duration-200"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          bitvid.network
+        </a>
+        |
         <a
           href="https://bitvid.btc.us"
           class="text-gray-500 hover:text-gray-400 transition-colors duration-200"
@@ -424,14 +433,6 @@
           bitvid.eth.limo
         </a>
         |
-        <a
-          href="https://bitvid.netlify.app"
-          class="text-gray-500 hover:text-gray-400 transition-colors duration-200"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          bitvid.netlify.app
-        </a>
         <div class="mt-2 space-x-4">
           <a
             href="https://github.com/PR0M3TH3AN/bitvid"
@@ -498,7 +499,10 @@
       <!-- Load Nostr library -->
       <script src="js/libs/nostr.bundle.js"></script>
       <!-- Load JavaScript Modules -->
+      <script src="js/libs/nostr.bundle.js"></script>
       <script type="module" src="js/config.js"></script>
+      <script type="module" src="js/lists.js"></script>
+      <script type="module" src="js/accessControl.js"></script>
       <script type="module" src="js/webtorrent.js"></script>
       <script type="module" src="js/nostr.js"></script>
       <script type="module" src="js/app.js"></script>
diff --git a/src/js/accessControl.js b/src/js/accessControl.js
new file mode 100644
index 0000000..15d68bf
--- /dev/null
+++ b/src/js/accessControl.js
@@ -0,0 +1,154 @@
+// js/accessControl.js
+
+import { isDevMode, isWhitelistEnabled } from "./config.js";
+import { initialWhitelist, initialBlacklist } from "./lists.js";
+
+class AccessControl {
+  constructor() {
+    // Debug logging for initialization
+    console.log("DEBUG: AccessControl constructor called");
+    console.log("DEBUG: initialWhitelist from import:", initialWhitelist);
+    console.log("DEBUG: typeof initialWhitelist:", typeof initialWhitelist);
+    console.log("DEBUG: initialWhitelist length:", initialWhitelist.length);
+
+    // Initialize empty sets
+    this.whitelist = new Set(initialWhitelist);
+    this.blacklist = new Set(initialBlacklist.filter((x) => x)); // Filter out empty strings
+
+    // Debug the sets
+    console.log("DEBUG: Whitelist after Set creation:", [...this.whitelist]);
+    console.log("DEBUG: Blacklist after Set creation:", [...this.blacklist]);
+
+    // Save to localStorage
+    this.saveWhitelist();
+    this.saveBlacklist();
+  }
+
+  // Rest of the class remains the same...
+  loadWhitelist() {
+    try {
+      const stored = localStorage.getItem("bitvid_whitelist");
+      return stored ? JSON.parse(stored) : [];
+    } catch (error) {
+      console.error("Error loading whitelist:", error);
+      return [];
+    }
+  }
+
+  loadBlacklist() {
+    try {
+      const stored = localStorage.getItem("bitvid_blacklist");
+      return stored ? JSON.parse(stored) : [];
+    } catch (error) {
+      console.error("Error loading blacklist:", error);
+      return [];
+    }
+  }
+
+  saveWhitelist() {
+    try {
+      localStorage.setItem(
+        "bitvid_whitelist",
+        JSON.stringify([...this.whitelist])
+      );
+    } catch (error) {
+      console.error("Error saving whitelist:", error);
+    }
+  }
+
+  saveBlacklist() {
+    try {
+      localStorage.setItem(
+        "bitvid_blacklist",
+        JSON.stringify([...this.blacklist])
+      );
+    } catch (error) {
+      console.error("Error saving blacklist:", error);
+    }
+  }
+
+  addToWhitelist(npub) {
+    if (!this.isValidNpub(npub)) {
+      throw new Error("Invalid npub format");
+    }
+    this.whitelist.add(npub);
+    this.saveWhitelist();
+    if (isDevMode) console.log(`Added ${npub} to whitelist`);
+  }
+
+  removeFromWhitelist(npub) {
+    this.whitelist.delete(npub);
+    this.saveWhitelist();
+    if (isDevMode) console.log(`Removed ${npub} from whitelist`);
+  }
+
+  addToBlacklist(npub) {
+    if (!this.isValidNpub(npub)) {
+      throw new Error("Invalid npub format");
+    }
+    this.blacklist.add(npub);
+    this.saveBlacklist();
+    if (isDevMode) console.log(`Added ${npub} to blacklist`);
+  }
+
+  removeFromBlacklist(npub) {
+    this.blacklist.delete(npub);
+    this.saveBlacklist();
+    if (isDevMode) console.log(`Removed ${npub} from blacklist`);
+  }
+
+  isWhitelisted(npub) {
+    const result = this.whitelist.has(npub);
+    if (isDevMode)
+      console.log(
+        `Checking if ${npub} is whitelisted:`,
+        result,
+        "Current whitelist:",
+        [...this.whitelist]
+      );
+    return result;
+  }
+
+  isBlacklisted(npub) {
+    return this.blacklist.has(npub);
+  }
+
+  canAccess(npub) {
+    if (this.isBlacklisted(npub)) {
+      return false;
+    }
+    const canAccess = !isWhitelistEnabled || this.isWhitelisted(npub);
+    if (isDevMode) console.log(`Checking access for ${npub}:`, canAccess);
+    return canAccess;
+  }
+
+  filterVideos(videos) {
+    return videos.filter((video) => {
+      try {
+        const npub = window.NostrTools.nip19.npubEncode(video.pubkey);
+        return !this.isBlacklisted(npub);
+      } catch (error) {
+        console.error("Error filtering video:", error);
+        return false;
+      }
+    });
+  }
+
+  isValidNpub(npub) {
+    try {
+      return npub.startsWith("npub1") && npub.length === 63;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  getWhitelist() {
+    return [...this.whitelist];
+  }
+
+  getBlacklist() {
+    return [...this.blacklist];
+  }
+}
+
+export const accessControl = new AccessControl();
diff --git a/src/js/config.js b/src/js/config.js
index b448397..7363993 100644
--- a/src/js/config.js
+++ b/src/js/config.js
@@ -1,3 +1,4 @@
 // js/config.js
 
 export const isDevMode = true; // Set to false for production
+export const isWhitelistEnabled = true; // Set to false to allow all non-blacklisted users
diff --git a/src/js/lists.js b/src/js/lists.js
new file mode 100644
index 0000000..51e65a0
--- /dev/null
+++ b/src/js/lists.js
@@ -0,0 +1,13 @@
+// js/lists.js
+
+const npubs = [
+  "npub13yarr7j6vjqjjkahd63dmr27curypehx45ucue286ac7sft27y0srnpmpe",
+  "npub15jnttpymeytm80hatjqcvhhqhzrhx6gxp8pq0wn93rhnu8s9h9dsha32lx",
+  "npub1j37gc05qpqzyrmdc5vetsc9h5qtstas7tr25j0n9sdpqxghz6m4q2ej6n8",
+  "npub1epvnvv3kskvpnmpqgnm2atevsmdferhp7dg2s0yc7uc0hdmqmgssx09tu2",
+];
+
+console.log("DEBUG: lists.js loaded, npubs:", npubs);
+
+export const initialWhitelist = npubs;
+export const initialBlacklist = [""];
diff --git a/src/js/nostr.js b/src/js/nostr.js
index d08c60a..71b24c4 100644
--- a/src/js/nostr.js
+++ b/src/js/nostr.js
@@ -1,12 +1,13 @@
 // js/nostr.js
 
-import { isDevMode } from './config.js';
+import { isDevMode } from "./config.js";
+import { accessControl } from "./accessControl.js";
 
 const RELAY_URLS = [
-    'wss://relay.damus.io',
-    'wss://nos.lol',
-    'wss://relay.snort.social',
-    'wss://nostr.wine'
+  "wss://relay.damus.io",
+  "wss://nos.lol",
+  "wss://relay.snort.social",
+  "wss://nostr.wine",
 ];
 
 // Rate limiting for error logs
@@ -14,16 +15,18 @@ let errorLogCount = 0;
 const MAX_ERROR_LOGS = 100; // Adjust as needed
 
 function logErrorOnce(message, eventContent = null) {
-    if (errorLogCount < MAX_ERROR_LOGS) {
-        console.error(message);
-        if (eventContent) {
-            console.log(`Event Content: ${eventContent}`);
-        }
-        errorLogCount++;
-    }
-    if (errorLogCount === MAX_ERROR_LOGS) {
-        console.error('Maximum error log limit reached. Further errors will be suppressed.');
+  if (errorLogCount < MAX_ERROR_LOGS) {
+    console.error(message);
+    if (eventContent) {
+      console.log(`Event Content: ${eventContent}`);
     }
+    errorLogCount++;
+  }
+  if (errorLogCount === MAX_ERROR_LOGS) {
+    console.error(
+      "Maximum error log limit reached. Further errors will be suppressed."
+    );
+  }
 }
 
 /**
@@ -31,523 +34,591 @@ function logErrorOnce(message, eventContent = null) {
  * In a real app, use a proper crypto library (AES-GCM, ECDH, etc.).
  */
 function fakeEncrypt(magnet) {
-    return magnet.split('').reverse().join('');
+  return magnet.split("").reverse().join("");
 }
 function fakeDecrypt(encrypted) {
-    return encrypted.split('').reverse().join('');
+  return encrypted.split("").reverse().join("");
 }
 
 class NostrClient {
-    constructor() {
-        this.pool = null; 
-        this.pubkey = null;
-        this.relays = RELAY_URLS;
+  constructor() {
+    this.pool = null;
+    this.pubkey = null;
+    this.relays = RELAY_URLS;
+  }
+
+  /**
+   * Initializes the Nostr client by connecting to relays.
+   */
+  async init() {
+    if (isDevMode) console.log("Connecting to relays...");
+
+    try {
+      this.pool = new window.NostrTools.SimplePool();
+      const results = await this.connectToRelays();
+      const successfulRelays = results
+        .filter((r) => r.success)
+        .map((r) => r.url);
+
+      if (successfulRelays.length === 0) throw new Error("No relays connected");
+
+      if (isDevMode)
+        console.log(`Connected to ${successfulRelays.length} relay(s)`);
+    } catch (err) {
+      console.error("Nostr init failed:", err);
+      throw err;
     }
+  }
 
-    /**
-     * Initializes the Nostr client by connecting to relays.
-     */
-    async init() {
-        if (isDevMode) console.log('Connecting to relays...');
-        
-        try {
-            this.pool = new window.NostrTools.SimplePool();
-            const results = await this.connectToRelays();
-            const successfulRelays = results.filter(r => r.success).map(r => r.url);
-            
-            if (successfulRelays.length === 0) throw new Error('No relays connected');
-            
-            if (isDevMode) console.log(`Connected to ${successfulRelays.length} relay(s)`);
-        } catch (err) {
-            console.error('Nostr init failed:', err);
-            throw err;
-        }
-    }
+  // Helper method to handle relay connections
+  async connectToRelays() {
+    return Promise.all(
+      this.relays.map(
+        (url) =>
+          new Promise((resolve) => {
+            const sub = this.pool.sub([url], [{ kinds: [0], limit: 1 }]);
+            const timeout = setTimeout(() => {
+              sub.unsub();
+              resolve({ url, success: false });
+            }, 5000);
 
-    // Helper method to handle relay connections
-    async connectToRelays() {
-        return Promise.all(this.relays.map(url => 
-            new Promise(resolve => {
-                const sub = this.pool.sub([url], [{ kinds: [0], limit: 1 }]);
-                const timeout = setTimeout(() => {
-                    sub.unsub();
-                    resolve({ url, success: false });
-                }, 5000);
+            const succeed = () => {
+              clearTimeout(timeout);
+              sub.unsub();
+              resolve({ url, success: true });
+            };
 
-                const succeed = () => {
-                    clearTimeout(timeout);
-                    sub.unsub();
-                    resolve({ url, success: true });
-                };
+            sub.on("event", succeed);
+            sub.on("eose", succeed);
+          })
+      )
+    );
+  }
 
-                sub.on('event', succeed);
-                sub.on('eose', succeed);
-            })
-        ));
-    }
+  /**
+   * Logs in the user using a Nostr extension or by entering an NSEC key.
+   */
+  async login() {
+    try {
+      if (!window.nostr) {
+        console.log("No Nostr extension found");
+        throw new Error(
+          "Please install a Nostr extension (like Alby or nos2x)."
+        );
+      }
 
-    /**
-     * Logs in the user using a Nostr extension or by entering an NSEC key.
-     */
-    async login() {
-        if (window.nostr) {
-            try {
-                const pubkey = await window.nostr.getPublicKey();
-                this.pubkey = pubkey;
-                if (isDevMode) console.log('Logged in with extension. Public key:', this.pubkey);
-                return this.pubkey;
-            } catch (e) {
-                if (isDevMode) console.warn('Failed to get public key from Nostr extension:', e.message);
-                throw new Error('Failed to get public key from Nostr extension.');
-            }
+      const pubkey = await window.nostr.getPublicKey();
+      const npub = window.NostrTools.nip19.npubEncode(pubkey);
+
+      // Debug logs
+      if (isDevMode) {
+        console.log("Got pubkey:", pubkey);
+        console.log("Converted to npub:", npub);
+        console.log("Whitelist:", accessControl.getWhitelist());
+        console.log("Blacklist:", accessControl.getBlacklist());
+        console.log("Is whitelisted?", accessControl.isWhitelisted(npub));
+        console.log("Is blacklisted?", accessControl.isBlacklisted(npub));
+      }
+
+      // Check access control
+      if (!accessControl.canAccess(npub)) {
+        if (accessControl.isBlacklisted(npub)) {
+          throw new Error(
+            "Your account has been blocked from accessing this platform."
+          );
         } else {
-            const nsec = prompt('Enter your NSEC key:');
-            if (nsec) {
-                try {
-                    this.pubkey = this.decodeNsec(nsec);
-                    if (isDevMode) console.log('Logged in with NSEC. Public key:', this.pubkey);
-                    return this.pubkey;
-                } catch (error) {
-                    if (isDevMode) console.error('Invalid NSEC key:', error.message);
-                    throw new Error('Invalid NSEC key.');
-                }
-            } else {
-                throw new Error('Login cancelled or NSEC key not provided.');
-            }
+          throw new Error(
+            "Access is currently restricted to whitelisted users only."
+          );
         }
+      }
+
+      this.pubkey = pubkey;
+      if (isDevMode)
+        console.log(
+          "Successfully logged in with extension. Public key:",
+          this.pubkey
+        );
+      return this.pubkey;
+    } catch (e) {
+      console.error("Login error:", e);
+      throw e;
+    }
+  }
+
+  /**
+   * Logs out the user.
+   */
+  logout() {
+    this.pubkey = null;
+    if (isDevMode) console.log("User logged out.");
+  }
+
+  /**
+   * Decodes an NSEC key.
+   */
+  decodeNsec(nsec) {
+    try {
+      const { data } = window.NostrTools.nip19.decode(nsec);
+      return data;
+    } catch (error) {
+      throw new Error("Invalid NSEC key.");
+    }
+  }
+
+  /**
+   * Publishes a new video event to all relays (creates a brand-new note).
+   */
+  async publishVideo(videoData, pubkey) {
+    if (!pubkey) {
+      throw new Error("User is not logged in.");
     }
 
-    /**
-     * Logs out the user.
-     */
-    logout() {
-        this.pubkey = null;
-        if (isDevMode) console.log('User logged out.');
+    if (isDevMode) {
+      console.log("Publishing video with data:", videoData);
     }
 
-    /**
-     * Decodes an NSEC key.
-     */
-    decodeNsec(nsec) {
-        try {
-            const { data } = window.NostrTools.nip19.decode(nsec);
-            return data;
-        } catch (error) {
-            throw new Error('Invalid NSEC key.');
-        }
+    // If user sets "isPrivate = true", encrypt the magnet
+    let finalMagnet = videoData.magnet;
+    if (videoData.isPrivate === true) {
+      finalMagnet = fakeEncrypt(finalMagnet);
     }
 
-    /**
-     * Publishes a new video event to all relays (creates a brand-new note).
-     */
-    async publishVideo(videoData, pubkey) {
-        if (!pubkey) {
-            throw new Error('User is not logged in.');
-        }
-    
-        if (isDevMode) {
-            console.log('Publishing video with data:', videoData);
-        }
+    // Default version is 1 if not specified
+    const version = videoData.version ?? 1;
 
-        // If user sets "isPrivate = true", encrypt the magnet
-        let finalMagnet = videoData.magnet;
-        if (videoData.isPrivate === true) {
-            finalMagnet = fakeEncrypt(finalMagnet);
-        }
+    const uniqueD = `${Date.now()}-${Math.random()
+      .toString(36)
+      .substring(2, 10)}`;
 
-        // Default version is 1 if not specified
-        const version = videoData.version ?? 1;
+    // Always mark "deleted" false for new posts
+    const contentObject = {
+      version,
+      deleted: false,
+      isPrivate: videoData.isPrivate || false,
+      title: videoData.title,
+      magnet: finalMagnet,
+      thumbnail: videoData.thumbnail,
+      description: videoData.description,
+      mode: videoData.mode,
+    };
 
-        const uniqueD = `${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
+    const event = {
+      kind: 30078,
+      pubkey,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ["t", "video"],
+        ["d", uniqueD],
+      ],
+      content: JSON.stringify(contentObject),
+    };
 
-        // Always mark "deleted" false for new posts
-        const contentObject = {
-            version,
-            deleted: false,
-            isPrivate: videoData.isPrivate || false,
-            title: videoData.title,
-            magnet: finalMagnet,
-            thumbnail: videoData.thumbnail,
-            description: videoData.description,
-            mode: videoData.mode
-        };
-
-        const event = {
-            kind: 30078,
-            pubkey,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [
-                ['t', 'video'],
-                ['d', uniqueD]
-            ],
-            content: JSON.stringify(contentObject)
-        };
-
-        if (isDevMode) {
-            console.log('Event content after stringify:', event.content);
-            console.log('Using d tag:', uniqueD);
-        }
-
-        try {
-            const signedEvent = await window.nostr.signEvent(event);
-            if (isDevMode) {
-                console.log('Signed event:', signedEvent);
-            }
-
-            await Promise.all(this.relays.map(async url => {
-                try {
-                    await this.pool.publish([url], signedEvent);
-                    if (isDevMode) {
-                        console.log(`Event published to ${url}`);
-                    }
-                } catch (err) {
-                    if (isDevMode) {
-                        console.error(`Failed to publish to ${url}:`, err.message);
-                    }
-                }
-            }));
-
-            return signedEvent;
-        } catch (error) {
-            if (isDevMode) {
-                console.error('Failed to sign event:', error.message);
-            }
-            throw new Error('Failed to sign event.');
-        }
+    if (isDevMode) {
+      console.log("Event content after stringify:", event.content);
+      console.log("Using d tag:", uniqueD);
     }
 
-    /**
-     * Edits an existing video event by reusing the same "d" tag.
-     * Allows toggling isPrivate on/off and re-encrypting or decrypting the magnet.
-     */
-    // Minimal fix: ensures we only ever encrypt once per edit operation
-    async editVideo(originalEvent, updatedVideoData, pubkey) {
-        if (!pubkey) {
-            throw new Error('User is not logged in.');
-        }
-        if (originalEvent.pubkey !== pubkey) {
-            throw new Error('You do not own this event (different pubkey).');
-        }
-    
-        if (isDevMode) {
-            console.log('Editing video event:', originalEvent);
-            console.log('New video data:', updatedVideoData);
-        }
-    
-        // Grab the d tag from the original event
-        const dTag = originalEvent.tags.find(tag => tag[0] === 'd');
-        if (!dTag) {
-            throw new Error('This event has no "d" tag, cannot edit as addressable kind=30078.');
-        }
-        const existingD = dTag[1];
-    
-        // Parse old content
-        const oldContent = JSON.parse(originalEvent.content || '{}');
-        if (isDevMode) {
-            console.log('Old content:', oldContent);
-        }
-    
-        // Keep old version & deleted status
-        const oldVersion = oldContent.version ?? 1;
-        const oldDeleted = (oldContent.deleted === true);
-        const newVersion = updatedVideoData.version ?? oldVersion;
-        
-        const oldWasPrivate = (oldContent.isPrivate === true);
-    
-        // 1) If old was private, decrypt the old magnet once => oldPlainMagnet
-        let oldPlainMagnet = oldContent.magnet || '';
-        if (oldWasPrivate && oldPlainMagnet) {
-            oldPlainMagnet = fakeDecrypt(oldPlainMagnet);
-        }
-    
-        // 2) If updatedVideoData.isPrivate is explicitly set, use that; else keep the old isPrivate
-        const newIsPrivate = 
-            typeof updatedVideoData.isPrivate === 'boolean'
-            ? updatedVideoData.isPrivate
-            : (oldContent.isPrivate ?? false);
-    
-        // 3) The user might type a new magnet or keep oldPlainMagnet
-        const userTypedMagnet = (updatedVideoData.magnet || '').trim();
-        const finalPlainMagnet = userTypedMagnet || oldPlainMagnet;
-    
-        // 4) If new is private => encrypt finalPlainMagnet once; otherwise store plaintext
-        let finalMagnet = finalPlainMagnet;
-        if (newIsPrivate) {
-            finalMagnet = fakeEncrypt(finalPlainMagnet);
-        }
-    
-        // Build updated content
-        const contentObject = {
-            version: newVersion,
-            deleted: oldDeleted,
-            isPrivate: newIsPrivate,
-            title: updatedVideoData.title,
-            magnet: finalMagnet,
-            thumbnail: updatedVideoData.thumbnail,
-            description: updatedVideoData.description,
-            mode: updatedVideoData.mode
-        };
-    
-        if (isDevMode) {
-            console.log('Building updated content object:', contentObject);
-        }
-    
-        const event = {
-            kind: 30078,
-            pubkey,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [
-                ['t', 'video'],
-                ['d', existingD]
-            ],
-            content: JSON.stringify(contentObject)
-        };
-    
-        if (isDevMode) {
-            console.log('Reusing d tag:', existingD);
-            console.log('Updated event content:', event.content);
-        }
-    
-        try {
-            const signedEvent = await window.nostr.signEvent(event);
+    try {
+      const signedEvent = await window.nostr.signEvent(event);
+      if (isDevMode) {
+        console.log("Signed event:", signedEvent);
+      }
+
+      await Promise.all(
+        this.relays.map(async (url) => {
+          try {
+            await this.pool.publish([url], signedEvent);
             if (isDevMode) {
-                console.log('Signed edited event:', signedEvent);
+              console.log(`Event published to ${url}`);
             }
-    
-            // Publish to all relays
-            await Promise.all(this.relays.map(async url => {
-                try {
-                    await this.pool.publish([url], signedEvent);
-                    if (isDevMode) {
-                        console.log(`Edited event published to ${url} (d="${existingD}")`);
-                    }
-                } catch (err) {
-                    if (isDevMode) {
-                        console.error(`Failed to publish edited event to ${url}:`, err.message);
-                    }
-                }
-            }));
-    
-            return signedEvent;
-        } catch (error) {
+          } catch (err) {
             if (isDevMode) {
-                console.error('Failed to sign edited event:', error.message);
+              console.error(`Failed to publish to ${url}:`, err.message);
             }
-            throw new Error('Failed to sign edited event.');
-        }
-    }    
+          }
+        })
+      );
 
-    /**
-     * Soft-delete or hide an existing video by marking content as "deleted: true"
-     * and republishing with same (kind=30078, pubkey, d) address.
-     */
-    async deleteVideo(originalEvent, pubkey) {
-        if (!pubkey) {
-            throw new Error('User is not logged in.');
-        }
-        if (originalEvent.pubkey !== pubkey) {
-            throw new Error('You do not own this event (different pubkey).');
-        }
+      return signedEvent;
+    } catch (error) {
+      if (isDevMode) {
+        console.error("Failed to sign event:", error.message);
+      }
+      throw new Error("Failed to sign event.");
+    }
+  }
 
-        if (isDevMode) {
-            console.log('Deleting video event:', originalEvent);
-        }
-
-        const dTag = originalEvent.tags.find(tag => tag[0] === 'd');
-        if (!dTag) {
-            throw new Error('This event has no "d" tag, cannot delete as addressable kind=30078.');
-        }
-        const existingD = dTag[1];
-
-        const oldContent = JSON.parse(originalEvent.content || '{}');
-        const oldVersion = oldContent.version ?? 1;
-
-        const contentObject = {
-            version: oldVersion,
-            deleted: true, 
-            title: oldContent.title || '',
-            magnet: '',
-            thumbnail: '',
-            description: 'This video has been deleted.',
-            mode: oldContent.mode || 'live',
-            isPrivate: oldContent.isPrivate || false
-        };
-
-        const event = {
-            kind: 30078,
-            pubkey,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [
-                ['t', 'video'],
-                ['d', existingD]
-            ],
-            content: JSON.stringify(contentObject)
-        };
-
-        if (isDevMode) {
-            console.log('Reusing d tag for delete:', existingD);
-            console.log('Deleted event content:', event.content);
-        }
-
-        try {
-            const signedEvent = await window.nostr.signEvent(event);
-            if (isDevMode) {
-                console.log('Signed deleted event:', signedEvent);
-            }
-
-            await Promise.all(this.relays.map(async url => {
-                try {
-                    await this.pool.publish([url], signedEvent);
-                    if (isDevMode) {
-                        console.log(`Deleted event published to ${url} (d="${existingD}")`);
-                    }
-                } catch (err) {
-                    if (isDevMode) {
-                        console.error(`Failed to publish deleted event to ${url}:`, err.message);
-                    }
-                }
-            }));
-
-            return signedEvent;
-        } catch (error) {
-            if (isDevMode) {
-                console.error('Failed to sign deleted event:', error.message);
-            }
-            throw new Error('Failed to sign deleted event.');
-        }
+  /**
+   * Edits an existing video event by reusing the same "d" tag.
+   * Allows toggling isPrivate on/off and re-encrypting or decrypting the magnet.
+   */
+  // Minimal fix: ensures we only ever encrypt once per edit operation
+  async editVideo(originalEvent, updatedVideoData, pubkey) {
+    if (!pubkey) {
+      throw new Error("User is not logged in.");
+    }
+    if (originalEvent.pubkey !== pubkey) {
+      throw new Error("You do not own this event (different pubkey).");
     }
 
-    /**
-     * Fetches videos from all configured relays.
-     */
-    async fetchVideos() {
-        const filter = {
-            kinds: [30078],
-            '#t': ['video'],
-            limit: 1000,
-            since: 0
-        };
-      
-        const videoEvents = new Map();
-
-        if (isDevMode) {
-            console.log('[fetchVideos] Starting fetch from all relays...');
-            console.log('[fetchVideos] Filter:', filter);
-        }
-
-        try {
-            await Promise.all(
-                this.relays.map(async (url) => {
-                    if (isDevMode) console.log(`[fetchVideos] Querying relay: ${url}`);
-                    
-                    try {
-                        const events = await this.pool.list([url], [filter]);
-                        
-                        if (isDevMode) {
-                            console.log(`Events from ${url}:`, events.length);
-                            if (events.length > 0) {
-                                events.forEach((evt, idx) => {
-                                    console.log(
-                                        `[fetchVideos] [${url}] Event[${idx}] ID: ${evt.id} | pubkey: ${evt.pubkey} | created_at: ${evt.created_at}`
-                                    );
-                                });
-                            }
-                        }
-                        
-                        events.forEach(event => {
-                            try {
-                                const content = JSON.parse(event.content);
-
-                                // If deleted == true, it overrides older notes
-                                if (content.deleted === true) {
-                                    videoEvents.delete(event.id);
-                                    return;
-                                }
-
-                                // If we haven't seen this event.id before, store it
-                                if (!videoEvents.has(event.id)) {
-                                    videoEvents.set(event.id, {
-                                        id: event.id,
-                                        version: content.version ?? 1,
-                                        isPrivate: content.isPrivate ?? false,
-                                        title: content.title || '',
-                                        magnet: content.magnet || '',
-                                        thumbnail: content.thumbnail || '',
-                                        description: content.description || '',
-                                        mode: content.mode || 'live',
-                                        pubkey: event.pubkey,
-                                        created_at: event.created_at,
-                                        tags: event.tags
-                                    });
-                                }
-                            } catch (parseError) {
-                                if (isDevMode) {
-                                    console.error('[fetchVideos] Event parsing error:', parseError);
-                                }
-                            }
-                        });
-                    } catch (relayError) {
-                        if (isDevMode) {
-                            console.error(`[fetchVideos] Error fetching from ${url}:`, relayError);
-                        }
-                    }
-                })
-            );
-
-            const videos = Array.from(videoEvents.values())
-                .sort((a, b) => b.created_at - a.created_at);
-
-            if (isDevMode) {
-                console.log('[fetchVideos] All relays have responded.');
-                console.log(`[fetchVideos] Total unique video events: ${videoEvents.size}`);
-            }
-
-            return videos;
-        } catch (error) {
-            if (isDevMode) {
-                console.error('FETCH VIDEOS ERROR:', error);
-            }
-            return [];
-        }
+    if (isDevMode) {
+      console.log("Editing video event:", originalEvent);
+      console.log("New video data:", updatedVideoData);
     }
 
-    /**
-     * Validates video content structure.
-     */
-    isValidVideo(content) {
-        try {
-            const isValid = (
-                content &&
-                typeof content === 'object' &&
-                typeof content.title === 'string' &&
-                content.title.length > 0 &&
-                typeof content.magnet === 'string' &&
-                content.magnet.length > 0 &&
-                typeof content.mode === 'string' &&
-                ['dev', 'live'].includes(content.mode) &&
-                (typeof content.thumbnail === 'string' || typeof content.thumbnail === 'undefined') &&
-                (typeof content.description === 'string' || typeof content.description === 'undefined')
-            );
+    // Grab the d tag from the original event
+    const dTag = originalEvent.tags.find((tag) => tag[0] === "d");
+    if (!dTag) {
+      throw new Error(
+        'This event has no "d" tag, cannot edit as addressable kind=30078.'
+      );
+    }
+    const existingD = dTag[1];
 
-            if (isDevMode && !isValid) {
-                console.log('Invalid video content:', content);
-                console.log('Validation details:', {
-                    hasTitle: typeof content.title === 'string',
-                    hasMagnet: typeof content.magnet === 'string',
-                    hasMode: typeof content.mode === 'string',
-                    validThumbnail: typeof content.thumbnail === 'string' || typeof content.thumbnail === 'undefined',
-                    validDescription: typeof content.description === 'string' || typeof content.description === 'undefined'
+    // Parse old content
+    const oldContent = JSON.parse(originalEvent.content || "{}");
+    if (isDevMode) {
+      console.log("Old content:", oldContent);
+    }
+
+    // Keep old version & deleted status
+    const oldVersion = oldContent.version ?? 1;
+    const oldDeleted = oldContent.deleted === true;
+    const newVersion = updatedVideoData.version ?? oldVersion;
+
+    const oldWasPrivate = oldContent.isPrivate === true;
+
+    // 1) If old was private, decrypt the old magnet once => oldPlainMagnet
+    let oldPlainMagnet = oldContent.magnet || "";
+    if (oldWasPrivate && oldPlainMagnet) {
+      oldPlainMagnet = fakeDecrypt(oldPlainMagnet);
+    }
+
+    // 2) If updatedVideoData.isPrivate is explicitly set, use that; else keep the old isPrivate
+    const newIsPrivate =
+      typeof updatedVideoData.isPrivate === "boolean"
+        ? updatedVideoData.isPrivate
+        : oldContent.isPrivate ?? false;
+
+    // 3) The user might type a new magnet or keep oldPlainMagnet
+    const userTypedMagnet = (updatedVideoData.magnet || "").trim();
+    const finalPlainMagnet = userTypedMagnet || oldPlainMagnet;
+
+    // 4) If new is private => encrypt finalPlainMagnet once; otherwise store plaintext
+    let finalMagnet = finalPlainMagnet;
+    if (newIsPrivate) {
+      finalMagnet = fakeEncrypt(finalPlainMagnet);
+    }
+
+    // Build updated content
+    const contentObject = {
+      version: newVersion,
+      deleted: oldDeleted,
+      isPrivate: newIsPrivate,
+      title: updatedVideoData.title,
+      magnet: finalMagnet,
+      thumbnail: updatedVideoData.thumbnail,
+      description: updatedVideoData.description,
+      mode: updatedVideoData.mode,
+    };
+
+    if (isDevMode) {
+      console.log("Building updated content object:", contentObject);
+    }
+
+    const event = {
+      kind: 30078,
+      pubkey,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ["t", "video"],
+        ["d", existingD],
+      ],
+      content: JSON.stringify(contentObject),
+    };
+
+    if (isDevMode) {
+      console.log("Reusing d tag:", existingD);
+      console.log("Updated event content:", event.content);
+    }
+
+    try {
+      const signedEvent = await window.nostr.signEvent(event);
+      if (isDevMode) {
+        console.log("Signed edited event:", signedEvent);
+      }
+
+      // Publish to all relays
+      await Promise.all(
+        this.relays.map(async (url) => {
+          try {
+            await this.pool.publish([url], signedEvent);
+            if (isDevMode) {
+              console.log(
+                `Edited event published to ${url} (d="${existingD}")`
+              );
+            }
+          } catch (err) {
+            if (isDevMode) {
+              console.error(
+                `Failed to publish edited event to ${url}:`,
+                err.message
+              );
+            }
+          }
+        })
+      );
+
+      return signedEvent;
+    } catch (error) {
+      if (isDevMode) {
+        console.error("Failed to sign edited event:", error.message);
+      }
+      throw new Error("Failed to sign edited event.");
+    }
+  }
+
+  /**
+   * Soft-delete or hide an existing video by marking content as "deleted: true"
+   * and republishing with same (kind=30078, pubkey, d) address.
+   */
+  async deleteVideo(originalEvent, pubkey) {
+    if (!pubkey) {
+      throw new Error("User is not logged in.");
+    }
+    if (originalEvent.pubkey !== pubkey) {
+      throw new Error("You do not own this event (different pubkey).");
+    }
+
+    if (isDevMode) {
+      console.log("Deleting video event:", originalEvent);
+    }
+
+    const dTag = originalEvent.tags.find((tag) => tag[0] === "d");
+    if (!dTag) {
+      throw new Error(
+        'This event has no "d" tag, cannot delete as addressable kind=30078.'
+      );
+    }
+    const existingD = dTag[1];
+
+    const oldContent = JSON.parse(originalEvent.content || "{}");
+    const oldVersion = oldContent.version ?? 1;
+
+    const contentObject = {
+      version: oldVersion,
+      deleted: true,
+      title: oldContent.title || "",
+      magnet: "",
+      thumbnail: "",
+      description: "This video has been deleted.",
+      mode: oldContent.mode || "live",
+      isPrivate: oldContent.isPrivate || false,
+    };
+
+    const event = {
+      kind: 30078,
+      pubkey,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ["t", "video"],
+        ["d", existingD],
+      ],
+      content: JSON.stringify(contentObject),
+    };
+
+    if (isDevMode) {
+      console.log("Reusing d tag for delete:", existingD);
+      console.log("Deleted event content:", event.content);
+    }
+
+    try {
+      const signedEvent = await window.nostr.signEvent(event);
+      if (isDevMode) {
+        console.log("Signed deleted event:", signedEvent);
+      }
+
+      await Promise.all(
+        this.relays.map(async (url) => {
+          try {
+            await this.pool.publish([url], signedEvent);
+            if (isDevMode) {
+              console.log(
+                `Deleted event published to ${url} (d="${existingD}")`
+              );
+            }
+          } catch (err) {
+            if (isDevMode) {
+              console.error(
+                `Failed to publish deleted event to ${url}:`,
+                err.message
+              );
+            }
+          }
+        })
+      );
+
+      return signedEvent;
+    } catch (error) {
+      if (isDevMode) {
+        console.error("Failed to sign deleted event:", error.message);
+      }
+      throw new Error("Failed to sign deleted event.");
+    }
+  }
+
+  /**
+   * Fetches videos from all configured relays.
+   */
+  async fetchVideos() {
+    const filter = {
+      kinds: [30078],
+      "#t": ["video"],
+      limit: 1000,
+      since: 0,
+    };
+
+    const videoEvents = new Map();
+
+    if (isDevMode) {
+      console.log("[fetchVideos] Starting fetch from all relays...");
+      console.log("[fetchVideos] Filter:", filter);
+    }
+
+    try {
+      await Promise.all(
+        this.relays.map(async (url) => {
+          if (isDevMode) console.log(`[fetchVideos] Querying relay: ${url}`);
+
+          try {
+            const events = await this.pool.list([url], [filter]);
+
+            if (isDevMode) {
+              console.log(`Events from ${url}:`, events.length);
+              if (events.length > 0) {
+                events.forEach((evt, idx) => {
+                  console.log(
+                    `[fetchVideos] [${url}] Event[${idx}] ID: ${evt.id} | pubkey: ${evt.pubkey} | created_at: ${evt.created_at}`
+                  );
                 });
+              }
             }
 
-            return isValid;
-        } catch (error) {
+            events.forEach((event) => {
+              try {
+                const content = JSON.parse(event.content);
+
+                // If deleted == true, it overrides older notes
+                if (content.deleted === true) {
+                  videoEvents.delete(event.id);
+                  return;
+                }
+
+                // If we haven't seen this event.id before, store it
+                if (!videoEvents.has(event.id)) {
+                  videoEvents.set(event.id, {
+                    id: event.id,
+                    version: content.version ?? 1,
+                    isPrivate: content.isPrivate ?? false,
+                    title: content.title || "",
+                    magnet: content.magnet || "",
+                    thumbnail: content.thumbnail || "",
+                    description: content.description || "",
+                    mode: content.mode || "live",
+                    pubkey: event.pubkey,
+                    created_at: event.created_at,
+                    tags: event.tags,
+                  });
+                }
+              } catch (parseError) {
+                if (isDevMode) {
+                  console.error(
+                    "[fetchVideos] Event parsing error:",
+                    parseError
+                  );
+                }
+              }
+            });
+          } catch (relayError) {
             if (isDevMode) {
-                console.error('Error validating video:', error);
+              console.error(
+                `[fetchVideos] Error fetching from ${url}:`,
+                relayError
+              );
             }
-            return false;
-        }
+          }
+        })
+      );
+
+      const videos = Array.from(videoEvents.values()).sort(
+        (a, b) => b.created_at - a.created_at
+      );
+
+      // Apply access control filtering
+      const filteredVideos = accessControl.filterVideos(videos);
+
+      if (isDevMode) {
+        console.log("[fetchVideos] All relays have responded.");
+        console.log(
+          `[fetchVideos] Total unique video events: ${videoEvents.size}`
+        );
+        console.log(
+          `[fetchVideos] Videos after filtering: ${filteredVideos.length}`
+        );
+      }
+
+      return filteredVideos;
+    } catch (error) {
+      if (isDevMode) {
+        console.error("FETCH VIDEOS ERROR:", error);
+      }
+      return [];
     }
+  }
+
+  /**
+   * Validates video content structure.
+   */
+  isValidVideo(content) {
+    try {
+      const isValid =
+        content &&
+        typeof content === "object" &&
+        typeof content.title === "string" &&
+        content.title.length > 0 &&
+        typeof content.magnet === "string" &&
+        content.magnet.length > 0 &&
+        typeof content.mode === "string" &&
+        ["dev", "live"].includes(content.mode) &&
+        (typeof content.thumbnail === "string" ||
+          typeof content.thumbnail === "undefined") &&
+        (typeof content.description === "string" ||
+          typeof content.description === "undefined");
+
+      if (isDevMode && !isValid) {
+        console.log("Invalid video content:", content);
+        console.log("Validation details:", {
+          hasTitle: typeof content.title === "string",
+          hasMagnet: typeof content.magnet === "string",
+          hasMode: typeof content.mode === "string",
+          validThumbnail:
+            typeof content.thumbnail === "string" ||
+            typeof content.thumbnail === "undefined",
+          validDescription:
+            typeof content.description === "string" ||
+            typeof content.description === "undefined",
+        });
+      }
+
+      return isValid;
+    } catch (error) {
+      if (isDevMode) {
+        console.error("Error validating video:", error);
+      }
+      return false;
+    }
+  }
 }
 
 export const nostrClient = new NostrClient();