gun-eth 1.3.6 → 2.0.1

package/src/lib/messaging/sendVoiceMessage.js

@@ -0,0 +1,119 @@
+/**
+ * Invia un messaggio vocale a un amico in una chat specifica.
+ * 
+ * @param {string} roomId - L'ID della stanza di chat.
+ * @param {string} publicKey - La chiave pubblica dell'amico.
+ * @param {Object} voiceRecording - L'oggetto contenente i dati della registrazione vocale.
+ * @param {Function} [callback] - Funzione di callback opzionale per gestire il risultato dell'operazione.
+ * 
+ * @returns {void}
+ * 
+ * La funzione esegue le seguenti operazioni:
+ * 1. Verifica la presenza della chiave pubblica dell'utente corrente.
+ * 2. Controlla i certificati necessari per creare messaggi e aggiornare i metadati della chat.
+ * 3. Aggiorna il messaggio più recente nella chat per entrambi gli utenti.
+ * 4. Aggiunge il messaggio vocale alla lista dei messaggi per entrambi gli utenti.
+ * 
+ * In caso di errore, la funzione di callback viene chiamata con un oggetto contenente
+ * informazioni sull'errore. In caso di successo, la callback viene chiamata con un
+ * messaggio di conferma.
+ */
+import { gun } from "../../state/gun";
+
+let sendVoiceMessage = (
+  roomId,
+  publicKey,
+  voiceRecording,
+  callback = () => {}
+) => {
+  (async (callback = () => {}) => {
+    let userPub = await gun.user().pair().pub;
+    let userPair = await gun.user()._.sea;
+    let friend = await gun.user(publicKey);
+
+    if (!userPub)
+      return callback({
+        errMessage: "Could not find pub.",
+        errCode: "failed-to-find-pub",
+        success: undefined,
+      });
+
+    let createMessagesCertificate = await gun
+      .user(publicKey)
+      .get("certificates")
+      .get(userPub)
+      .get("messages");
+
+    if (!createMessagesCertificate)
+      return callback({
+        errMessage: "Could not find friend certificate to create message",
+        errCode: "failed-to-find-friend-messages-certificate",
+        success: undefined,
+      });
+
+    let updateMetaCertificate = await gun
+      .user(publicKey)
+      .get("certificates")
+      .get(userPub)
+      .get("chats");
+
+    if (!updateMetaCertificate)
+      return callback({
+        errMessage: "Could not find friend certificate to add meta to chat",
+        errCode: "failed-to-find-friend-chats-certificate",
+        success: undefined,
+      });
+
+    gun
+      .user()
+      .get("chats")
+      .get(roomId)
+      .get("latestMessage")
+      .put(voiceRecording);
+
+    gun
+      .user(publicKey)
+      .get("chats")
+      .get(roomId)
+      .get("latestMessage")
+      .put(voiceRecording, null, { opt: { cert: updateMetaCertificate } });
+
+    gun
+      .user()
+      .get("messages")
+      .get(roomId)
+      .set(voiceRecording, ({ err }) => {
+        if (err)
+          return callback({
+            errMessage: err,
+            errCode: "message-creation-error",
+            success: undefined,
+          });
+        else
+          gun
+            .user(publicKey)
+            .get("messages")
+            .get(roomId)
+            .set(
+              voiceRecording,
+              ({ err }) => {
+                if (err)
+                  return callback({
+                    errMessage: err,
+                    errCode: "message-creation-error",
+                    success: undefined,
+                  });
+                else
+                  return callback({
+                    errMessage: undefined,
+                    errCode: undefined,
+                    success: "Created a voice message with friend.",
+                  });
+              },
+              { opt: { cert: createMessagesCertificate } }
+            );
+      });
+  })(callback);
+};
+
+export default sendVoiceMessage;

package/src/lib/notes/createNote.js

@@ -0,0 +1,41 @@
+/**
+   * Creates a new note.
+   * @param {string} title - The title of the note.
+   * @param {string} author - The author of the note.
+   * @param {string} content - The content of the note.
+   * @param {boolean} isPublic - Whether the note is public or private.
+   * @param {string} [verification=''] - Verification data for public notes.
+   * @returns {Promise<string>} A promise that resolves to the note's hash.
+   */
+const createNote = async (title, author, content, isPublic, verification = '') => {
+    if (!isPublic && !user.is) {
+      console.log("L'utente deve essere autenticato per creare note private");
+      throw new Error("L'utente deve essere autenticato per creare note private");
+    }
+
+    const noteData = {
+      title: DOMPurify.sanitize(title),
+      author: DOMPurify.sanitize(author),
+      content: DOMPurify.sanitize(content),
+      verification: isPublic ? DOMPurify.sanitize(verification) : '',
+      lastUpdated: new Date().toISOString(),
+      isPublic: isPublic
+    };
+
+    const noteString = JSON.stringify(noteData);
+    const hash = await SEA.work(noteString, null, null, { name: "SHA-256" });
+
+    if (isPublic) {
+      await gun.get("gun-eth").get("public-notes").get(hash).put(noteString);
+    } else {
+      if (!user.is) {
+        throw new Error("L'utente deve essere autenticato per creare note private");
+      }
+      await user.get("gun-eth").get("private-notes").get(hash).put(noteData);
+    }
+
+    return hash;
+  };
+
+  export default createNote;
+

package/src/lib/notes/deleteNote.js

@@ -0,0 +1,12 @@
+ /**
+   * Deletes a note by its hash.
+   * @param {string} hash - The hash of the note to delete.
+   * @returns {Promise<void>}
+   */
+ export const deleteNote = async (hash, isPublic) => {
+    if (isPublic) {
+      await gun.get("gun-eth").get("public-notes").get(hash).put(null);
+    } else {
+      await user.get("gun-eth").get("private-notes").get(hash).put(null);
+    }
+  };

package/src/lib/notes/getNote.js

@@ -0,0 +1,25 @@
+  /**
+   * Retrieves a note by its hash.
+   * @param {string} hash - The hash of the note to retrieve.
+   * @returns {Promise<Object|null>} A promise that resolves to the note object or null if not found.
+   */
+  const getNote = async (hash) => {
+    const publicNote = await gun.get("gun-eth").get("public-notes").get(hash).then();
+    if (publicNote) {
+      return JSON.parse(publicNote);
+    }
+
+    if (!user.is) {
+      throw new Error("L'utente deve essere autenticato per accedere alle note private");
+    }
+
+    const privateNote = await user.get("gun-eth").get("private-notes").get(hash).then();
+    if (privateNote) {
+      const decryptedData = await SEA.decrypt(privateNote, user._.sea);
+      return JSON.parse(decryptedData);
+    }
+
+    return null;
+  };
+
+  export default getNote;

package/src/lib/notes/getUserNote.js

@@ -0,0 +1,59 @@
+
+  /**
+   * Retrieves all notes for the current user.
+   * @returns {Promise<Array>} A promise that resolves to an array of user's notes.
+   */
+  const getUserNotes = () => {
+    return new Promise((resolve) => {
+      const notes = [];
+
+      const loadPublicNotes = () => {
+        return new Promise((resolvePublic) => {
+          gun.get("gun-eth").get("public-notes").map().once((data, id) => {
+            if (data && id !== '_') {
+              try {
+                notes.push({ id, ...JSON.parse(data), isPublic: true });
+              } catch (error) {
+                console.error("Errore durante il parsing della nota pubblica:", error);
+                notes.push({ id, error: "Errore durante il parsing della nota", isPublic: true });
+              }
+            }
+          });
+          setTimeout(resolvePublic, 500);
+        });
+      };
+
+      const loadPrivateNotes = () => {
+        return new Promise((resolvePrivate) => {
+          if (user.is) {
+            user.get("gun-eth").get("private-notes").map().once(async (data, id) => {
+              if (data && id !== '_') {
+                try {
+                  const decryptedData = await SEA.decrypt(data, user._.sea);
+                  console.log("decryptedData:", decryptedData);
+                  if (typeof decryptedData === 'string' ) {
+                    notes.push({ id, ...JSON.parse(decryptedData), isPublic: false });
+                  } else if (typeof decryptedData === 'object' && decryptedData !== null) {
+                    notes.push({ id, ...decryptedData, isPublic: false });
+                  } else {
+                    console.error("Dati decriptati non validi:", decryptedData);
+                    notes.push({ id, error: "Dati decriptati non validi", isPublic: false });
+                  }
+                } catch (error) {
+                  console.error("Errore durante la decrittazione della nota privata:", error);
+                  notes.push({ id, error: "Errore durante la decrittazione della nota", isPublic: false });
+                }
+              }
+            });
+          }
+          setTimeout(resolvePrivate, 500);
+        });
+      };
+
+      Promise.all([loadPublicNotes(), loadPrivateNotes()]).then(() => {
+        resolve(notes);
+      });
+    });
+  };
+
+  export default getUserNotes;

package/src/lib/notes/index.js

@@ -0,0 +1,8 @@
+import createNote from "./createNote";
+import deleteNote from "./deleteNote";
+import getNote from "./getNote";
+import updateNote from "./updateNote";
+import getUserNotes from "./getUserNote";
+
+export { createNote, deleteNote, getNote, updateNote, getUserNotes };
+

package/src/lib/notes/updateNotes.js

@@ -0,0 +1,35 @@
+ /**
+   * Updates an existing note.
+   * @param {string} hash - The hash of the note to update.
+   * @param {string} title - The updated title of the note.
+   * @param {string} author - The updated author of the note.
+   * @param {string} content - The updated content of the note.
+   * @param {boolean} isPublic - Whether the note is public or private.
+   * @param {string} [verification=''] - Updated verification data for public notes.
+   * @returns {Promise<void>}
+   */
+ const updateNote = async (hash, title, author, content, isPublic, verification = '') => {
+    const noteData = {
+      title: DOMPurify.sanitize(title),
+      author: DOMPurify.sanitize(author),
+      content: DOMPurify.sanitize(content),
+      verification: isPublic ? DOMPurify.sanitize(verification) : '',
+      lastUpdated: new Date().toISOString(),
+      isPublic: isPublic
+    };
+
+    const noteString = JSON.stringify(noteData);
+
+    if (isPublic) {
+      await gun.get("gun-eth").get("public-notes").get(hash).put(noteString);
+    } else {
+      if (!user.is) {
+        throw new Error("L'utente deve essere autenticato per aggiornare note private");
+      }
+      const encryptedData = await SEA.encrypt(noteString, user._.sea);
+      await user.get("gun-eth").get("private-notes").get(hash).put(encryptedData);
+    }
+  };
+
+ 
+  export default updateNote;

package/src/lib/post/createPost.js

@@ -0,0 +1,17 @@
+import { gun } from "../../state/gun";
+/**
+     * Creates a new encrypted post.
+     * @param {Object} post - The post object to create.
+     * @param {string} token - The encryption token.
+     * @returns {Promise<string>} A promise that resolves to the new post's key.
+     */
+const createPost = async (post, token) => {
+    const dbPosts = gun.get('gun-eth').get('posts');
+
+    const encrypted = await encryptPost(post, token);
+    const key = Date.now().toString();
+    await dbPosts.get(key).put(encrypted);
+    return key;
+  };
+
+  export default createPost;

package/src/lib/post/decryptPost.js

@@ -0,0 +1,14 @@
+import SEA from "gun/sea";
+
+/**
+     * Decrypts a post's text content.
+     * @param {Object} post - The encrypted post object to decrypt.
+     * @param {string} token - The decryption token.
+     * @returns {Promise<Object>} A promise that resolves to the decrypted post object.
+     */
+const decryptPost = async (post, token) => {
+    const text = await SEA.decrypt(post.text, token);
+    return { ...post, text };
+  };
+
+  export default decryptPost;

package/src/lib/post/deletePost.js

@@ -0,0 +1,13 @@
+import { gun } from "../../state/gun";
+
+  /**
+   * Deletes a post by its key.
+   * @param {string} key - The key of the post to delete.
+   * @returns {Promise<void>}
+   */
+  const deletePost = async (key) => {
+    const dbPosts = gun.get('gun-eth').get('posts');
+    await dbPosts.get(key).put(null);
+  };
+
+  export default deletePost;

package/src/lib/post/encryptPost,js

@@ -0,0 +1,16 @@
+import SEA from "gun/sea";
+
+/**
+     * Encrypts a post's text content.
+     * @param {Object} post - The post object to encrypt.
+     * @param {string} token - The encryption token.
+     * @returns {Promise<Object>} A promise that resolves to the encrypted post object.
+     */
+    const encryptPost = async (post, token) => {
+      const text = await SEA.encrypt(post.text, token);
+      return { ...post, text };
+    };
+  
+
+    export default encryptPost;
+    

package/src/lib/post/getPost.js

@@ -0,0 +1,36 @@
+import { gun } from "../../state/gun";
+import decryptPost from "./decryptPost";
+
+ /**
+     * Retrieves and decrypts a post by its key.
+     * @param {string} key - The key of the post to retrieve.
+     * @param {string} token - The decryption token.
+     * @returns {Promise<Object|null>} A promise that resolves to the decrypted post object or null if not found.
+     */
+  export const getPost = async (key, token) => {
+    const dbPosts = gun.get('gun-eth').get('posts');
+
+    const post = await dbPosts.get(key).then();
+    if (post) {
+      return await decryptPost(post, token);
+    }
+    return null;
+  };
+
+  /**
+     * Retrieves and decrypts all posts.
+     * @param {string} token - The decryption token.
+     * @returns {Promise<Array>} A promise that resolves to an array of decrypted post objects.
+     */
+  exportconst getAllPosts = async (token) => {
+    return new Promise((resolve) => {
+      const posts = [];
+      dbPosts.map().once(async (data, key) => {
+        if (data) {
+          const decrypted = await decryptPost(data, token);
+          posts.push({ ...decrypted, id: key });
+        }
+        resolve(posts);
+      });
+    });
+  };

package/src/lib/post/index.js

@@ -0,0 +1,9 @@
+import createPost from "./createPost";
+import deletePost from "./deletePost";
+import getPost from "./getPost";
+import updatePost from "./updatePost";
+import decryptPost from "./decryptPost";
+import encryptPost from "./encryptPost";
+import getAllPosts from "./getPost";
+
+export { createPost, deletePost, getPost, updatePost, decryptPost, encryptPost, getAllPosts };

package/src/lib/post/updatePost.js

@@ -0,0 +1,16 @@
+import { gun } from "../../state/gun";
+import encryptPost from "./encryptPost";
+
+/**
+     * Updates an existing post with new encrypted content.
+     * @param {string} key - The key of the post to update.
+     * @param {Object} post - The updated post object.
+     * @param {string} token - The encryption token.
+     * @returns {Promise<void>}
+     */
+const updatePost = async (key, post, token) => {
+    const encrypted = await encryptPost(post, token);
+    await dbPosts.get(key).put(encrypted);
+  };
+
+  export default updatePost;

package/src/state/gun.js

@@ -0,0 +1,33 @@
+/**
+ * Modulo per l'inizializzazione e la configurazione di Gun.js
+ * @module gun
+ */
+
+// Importa il modulo principale di Gun
+import Gun from "gun/gun";
+// Importa i moduli aggiuntivi di Gun
+import "gun/sea";  // Per la crittografia
+import "gun/lib/radix";  // Per l'ottimizzazione delle prestazioni
+import "gun/lib/radisk";  // Per la persistenza dei dati
+import "gun/lib/store";  // Per il salvataggio dei dati
+import "gun/lib/rindexed";  // Per l'indicizzazione dei dati
+
+/**
+ * Inizializza un'istanza di Gun con configurazioni specifiche
+ * @type {Gun}
+ */
+let gun = new Gun({
+  peers: ["https://gun-relay.scobrudot.dev/gun"],  // Server peer per la sincronizzazione dei dati
+  axe: false,  // Disabilita il protocollo AXE
+  localStorage: false,  // Disabilita l'uso di localStorage
+  radisk: true,  // Abilita Radisk per la persistenza dei dati
+});
+
+/**
+ * Inizializza un utente Gun e richiama la sessione da sessionStorage
+ * @type {GunUser}
+ */
+let user = gun.user().recall({ sessionStorage: true });
+
+// Esporta le istanze gun e user per l'uso in altri moduli
+export { gun, user };