gun-eth 1.3.6 → 2.0.1

package/src/lib/friends/addFriendRequest.js

@@ -0,0 +1,49 @@
+import { gun, user } from "../../state/gun";
+import { generateAddFriendCertificate } from "../certificates";
+
+/**
+ * Invia una richiesta di amicizia a un utente specifico.
+ * 
+ * @async
+ * @param {string} publicKey - La chiave pubblica dell'utente a cui inviare la richiesta di amicizia.
+ * @param {Function} [callback] - Funzione di callback opzionale chiamata al completamento dell'operazione.
+ * @returns {Promise<void>}
+ */
+let addFriendRequest = async (publicKey, callback = () => {}) => {
+  let addFriendRequestCertificate = await gun
+    .user(publicKey)
+    .get("certificates")
+    .get("friendRequests");
+
+  gun
+    .user(publicKey)
+    .get("friendRequests")
+    .set(
+      user.is.pub,
+      ({ err }) => {
+        if (err)
+          return callback({
+            errMessage: err,
+            errCode: "friend-request-error",
+            success: undefined,
+          });
+        else {
+          generateAddFriendCertificate(
+            publicKey,
+            ({ errMessage, errCode, success }) => {
+              if (errMessage) return callback({ errMessage, errCode, success });
+              else
+                return callback({
+                  errMessage: undefined,
+                  errCode: undefined,
+                  success: "Friend request sent successfully.",
+                });
+            }
+          );
+        }
+      },
+      { opt: { cert: addFriendRequestCertificate } }
+    );
+};
+
+export default addFriendRequest;

package/src/lib/friends/friendRequests.js

@@ -0,0 +1,51 @@
+import { Observable } from "rxjs";
+import { gun } from "../../state/gun";
+
+/**
+ * Observable che gestisce le richieste di amicizia dell'utente corrente.
+ * 
+ * @type {Observable}
+ * @description Questo Observable emette oggetti contenenti informazioni sulle richieste di amicizia.
+ * Ogni oggetto emesso può avere le seguenti proprietà:
+ * - key: La chiave della richiesta di amicizia
+ * - pub: La chiave pubblica dell'utente che ha inviato la richiesta
+ * - alias: L'alias dell'utente che ha inviato la richiesta
+ * - displayName: Il nome visualizzato dell'utente (se disponibile)
+ * - about: Informazioni aggiuntive sull'utente (se disponibili)
+ * 
+ * Se non ci sono richieste di amicizia, l'Observable emetterà `undefined`.
+ */
+let friendRequests = new Observable((subscriber) => {
+  gun
+    .user()
+    .get("friendRequests")
+    .map(
+      (publicKey, key) => {
+        if (publicKey) {
+          gun.user(publicKey).once((_user) => {
+            if (_user && _user.info && _user.pub && _user.alias) {
+              gun.get(_user.info["#"]).on((data) => {
+                subscriber.next({
+                  key,
+                  pub: _user.pub,
+                  alias: _user.alias,
+                  displayName: data.displayName,
+                  about: data.about || undefined,
+                });
+              });
+            } else if (_user && _user.pub && _user.alias) {
+              subscriber.next({
+                key,
+                pub: _user.pub,
+                alias: _user.alias,
+              });
+            }
+          });
+        } else {
+          subscriber.next(undefined);
+        }
+      }
+    );
+});
+
+export default friendRequests;

package/src/lib/friends/friendsList.js

@@ -0,0 +1,57 @@
+import { Observable } from "rxjs";
+import { gun } from "../../state/gun";
+
+/**
+ * Modulo per la gestione della lista degli amici.
+ * @module friendsList
+ */
+
+/**
+ * Observable che gestisce la lista degli amici dell'utente corrente.
+ * 
+ * @type {Observable}
+ * @description Questo Observable emette oggetti contenenti informazioni sugli amici dell'utente.
+ * Ogni oggetto emesso può avere le seguenti proprietà:
+ * - key: La chiave dell'amico
+ * - pub: La chiave pubblica dell'amico
+ * - alias: L'alias dell'amico
+ * - displayName: Il nome visualizzato dell'amico (se disponibile)
+ * - about: Informazioni aggiuntive sull'amico (se disponibili)
+ * 
+ * Se non ci sono amici nella lista, l'Observable emetterà `undefined`.
+ */
+
+let friendsList = new Observable((subscriber) => {
+  gun
+    .user()
+    .get("friends")
+    .map(
+      (publicKey, key) => {
+        if (publicKey) {
+          gun.user(publicKey).once((_user) => {
+            if (_user && _user.info && _user.pub && _user.alias) {
+              gun.get(_user.info["#"]).on((data) => {
+                subscriber.next({
+                  key,
+                  pub: _user.pub,
+                  alias: _user.alias,
+                  displayName: data.displayName,
+                  about: data.about || undefined,
+                });
+              });
+            } else if (_user && _user.pub && _user.alias) {
+              subscriber.next({
+                key,
+                pub: _user.pub,
+                alias: _user.alias,
+              });
+            }
+          });
+        } else {
+          subscriber.next(undefined);
+        }
+      }
+    );
+});
+
+export default friendsList;

package/src/lib/friends/index.js

@@ -0,0 +1,36 @@
+/**
+ * Modulo per la gestione delle amicizie
+ * @module friends
+ */
+
+import acceptFriendRequest from "./acceptFriendRequest";
+import addFriendRequest from "./addFriendRequest";
+import friendRequests from "./friendRequests";
+import rejectFriendRequest from "./rejectFriendRequest";
+import friendsList from "./friendsList";
+
+/**
+ * Funzioni esportate per la gestione delle amicizie
+ */
+export {
+    /**
+     * Aggiunge una richiesta di amicizia
+     */
+    addFriendRequest,
+    /**
+     * Accetta una richiesta di amicizia
+     */
+    acceptFriendRequest,
+    /**
+     * Rifiuta una richiesta di amicizia
+     */
+    rejectFriendRequest,
+    /**
+     * Ottiene l'elenco delle richieste di amicizia
+     */
+    friendRequests,
+    /**
+     * Ottiene l'elenco degli amici
+     */
+    friendsList
+};

package/src/lib/friends/rejectFriendRequest.js

@@ -0,0 +1,31 @@
+import { gun } from "../../state/gun";
+
+/**
+ * Rifiuta una richiesta di amicizia.
+ * 
+ * @param {string} key - La chiave della richiesta di amicizia da rifiutare.
+ * @param {Function} [callback] - Funzione di callback opzionale chiamata al completamento dell'operazione.
+ * @returns {void}
+ */
+let rejectFriendRequest = (key, callback = () => {}) => {
+  gun
+    .user()
+    .get("friendRequests")
+    .get(key)
+    .put(null, async ({ err }) => {
+      if (err)
+        return callback({
+          errMessage: err,
+          errCode: "reject-friend-request-failed",
+          success: undefined,
+        });
+      else
+        return callback({
+          errMessage: undefined,
+          errCode: undefined,
+          success: "Friend request removed successfully.",
+        });
+    });
+};
+
+export default rejectFriendRequest;

package/src/lib/messaging/chatsList.js

@@ -0,0 +1,42 @@
+import { Observable } from "rxjs";
+import { gun } from "../../state/gun";
+
+/**
+ * Observable che fornisce una lista di chat aggiornata in tempo reale.
+ * 
+ * @type {Observable}
+ * @description Questo Observable si sottoscrive ai cambiamenti nella lista delle chat dell'utente
+ * e emette un nuovo oggetto per ogni chat aggiornata. Ogni oggetto chat contiene:
+ * - roomId: l'identificatore univoco della stanza di chat
+ * - pub: la chiave pubblica associata alla chat
+ * - latestMessage: l'ultimo messaggio nella chat
+ * 
+ * @example
+ * chatsList.subscribe(chat => {
+ *   console.log('Chat aggiornata:', chat);
+ * });
+ */
+let chatsList = new Observable((subscriber) => {
+  gun
+    .user()
+    .get("chats")
+    .on((chats, _) => {
+      for (let publicKey in chats) {
+        try {
+          let chatDetails = JSON.parse(chats[publicKey]);
+
+          if (chatDetails) {
+            subscriber.next({
+              roomId: chatDetails.roomId,
+              pub: chatDetails.pub,
+              latestMessage: chatDetails.latestMessage,
+            });
+          }
+        } catch (err) {
+          // Gestione silenziosa degli errori di parsing
+        }
+      }
+    });
+});
+
+export default chatsList;

package/src/lib/messaging/createChat.js

@@ -0,0 +1,132 @@
+/**
+ * Modulo per la creazione di una nuova chat.
+ * @module createChat
+ */
+
+import { v4 } from "uuid";
+import { gun } from "../../state/gun";
+
+/**
+ * Crea una nuova chat con un utente specificato.
+ * 
+ * @async
+ * @function createChat
+ * @param {string} publicKey - La chiave pubblica dell'utente con cui creare la chat.
+ * @param {Function} [callback] - Funzione di callback opzionale chiamata al completamento dell'operazione.
+ * @returns {Promise<void>}
+ * 
+ * @description
+ * Questa funzione crea una nuova chat tra l'utente corrente e un altro utente specificato dalla sua chiave pubblica.
+ * Verifica prima se la chat esiste già, poi controlla i certificati necessari e infine crea la chat per entrambi gli utenti.
+ * 
+ * @example
+ * createChat("chiavePubblicaUtente", (result) => {
+ *   if (result.success) {
+ *     console.log("Chat creata:", result.chat);
+ *   } else {
+ *     console.error("Errore:", result.errMessage);
+ *   }
+ * });
+ */
+let createChat = async (publicKey, callback = () => {}) => {
+  gun
+    .user()
+    .get("chats")
+    .get(publicKey)
+    .once(async (chatExists) => {
+      if (chatExists) {
+        return callback({
+          errMessage: "The chat already exists. Opening it now.",
+          errCode: "chat-already-exists",
+          chat: JSON.parse(chatExists),
+          success: undefined,
+        });
+      }
+
+      let friend = await gun.user(publicKey).once();
+
+      let userPub = await gun.user().pair().pub;
+
+      if (!userPub)
+        return callback({
+          errMessage: "Could not find pub.",
+          errCode: "failed-to-find-pub",
+          success: undefined,
+        });
+
+      if (!friend)
+        return callback({
+          errMessage: "Could not find friend.",
+          errCode: "failed-to-find-friend",
+          success: undefined,
+        });
+
+      let createChatsCertificate = await gun
+        .user(publicKey)
+        .get("certificates")
+        .get(userPub)
+        .get("chats");
+
+      if (!createChatsCertificate)
+        return callback({
+          errMessage: "Could not find friend certificate to create chat",
+          errCode: "failed-to-find-friend-chats-certificate",
+          success: undefined,
+        });
+
+      let roomId = v4();
+
+      gun
+        .user(publicKey)
+        .get("chats")
+        .get(userPub)
+        .put(
+          JSON.stringify({
+            pub: userPub,
+            roomId,
+            latestMessage: {},
+          }),
+          ({ err }) => {
+            if (err)
+              return callback({
+                errMessage: err,
+                errCode: "chat-creation-error",
+                success: undefined,
+              });
+            else
+              gun
+                .user()
+                .get("chats")
+                .get(publicKey)
+                .put(
+                  JSON.stringify({
+                    pub: friend.pub,
+                    roomId,
+                    latestMessage: {},
+                  }),
+                  ({ err }) => {
+                    if (err)
+                      return callback({
+                        errMessage: err,
+                        errCode: "chat-creation-error",
+                        success: undefined,
+                      });
+                    else
+                      return callback({
+                        errMessage: undefined,
+                        errCode: undefined,
+                        chat: {
+                          pub: friend.pub,
+                          roomId,
+                        },
+                        success: "Created a chat with friend.",
+                      });
+                  }
+                );
+          },
+          { opt: { cert: createChatsCertificate } }
+        );
+    });
+};
+
+export default createChat;

package/src/lib/messaging/index.js

@@ -0,0 +1,36 @@
+/**
+ * Modulo per la gestione dei messaggi e delle chat
+ * @module messaging
+ */
+
+import chatsList from "./chatsList";
+import createChat from "./createChat";
+import messageList from "./messageList";
+import sendMessage from "./sendMessage";
+import sendVoiceMessage from "./sendVoiceMessage";
+
+/**
+ * Funzioni esportate per la gestione dei messaggi e delle chat
+ */
+export {
+    /**
+     * Crea una nuova chat
+     */
+    createChat,
+    /**
+     * Ottiene la lista delle chat
+     */
+    chatsList,
+    /**
+     * Ottiene la lista dei messaggi di una chat
+     */
+    messageList,
+    /**
+     * Invia un messaggio di testo
+     */
+    sendMessage,
+    /**
+     * Invia un messaggio vocale
+     */
+    sendVoiceMessage
+};

package/src/lib/messaging/messageList.js

@@ -0,0 +1,106 @@
+import { Observable } from "rxjs";
+import { gun } from "../../state/gun";
+
+/**
+ * Crea un Observable che fornisce una lista di messaggi per una specifica chat.
+ * 
+ * @function messageList
+ * @param {string} roomId - L'identificatore univoco della stanza di chat.
+ * @param {string} pub - La chiave pubblica dell'altro utente nella chat.
+ * @returns {Observable} Un Observable che emette oggetti contenenti messaggi iniziali e individuali.
+ * 
+ * @description
+ * Questa funzione crea un Observable che si sottoscrive ai messaggi di una specifica chat.
+ * Decripta i messaggi utilizzando la chiave pubblica dell'altro utente e emette sia un array iniziale
+ * di messaggi che singoli messaggi man mano che vengono ricevuti.
+ * 
+ * @example
+ * const messages$ = messageList('room123', 'publicKey123');
+ * messages$.subscribe(({ initial, individual }) => {
+ *   if (initial) {
+ *     console.log('Messaggi iniziali:', initial);
+ *   } else if (individual) {
+ *     console.log('Nuovo messaggio:', individual);
+ *   }
+ * });
+ */
+let messageList = (roomId, pub) =>
+  new Observable(async (subscriber) => {
+    let userPair = await gun.user()._.sea;
+    let friend = await gun.user(pub);
+
+    gun
+      .user()
+      .get("messages")
+      .get(roomId)
+      .once((messages) => {
+        (async () => {
+          let initial = [];
+
+          for (let key in messages) {
+            let message = messages[key].toString();
+
+            let decryptSecretFriend = await SEA.secret(friend.epub, userPair);
+            let decryptedMessageFriend = await SEA.decrypt(
+              message,
+              decryptSecretFriend
+            );
+
+            if (decryptedMessageFriend) {
+              let individual = {
+                ...decryptedMessageFriend,
+                encrypted: true,
+              };
+
+              let exists =
+                initial.filter((current) => current.id === individual.id)[0] !==
+                undefined;
+
+              console.log(exists);
+
+              if (!exists) initial.push(individual);
+            }
+          }
+
+          subscriber.next({ initial, individual: undefined });
+
+          gun
+            .user()
+            .get("messages")
+            .get(roomId)
+            .map()
+            .once(async (message) => {
+              if (message.toString().startsWith("SEA")) {
+                let decryptSecretFriend = await SEA.secret(
+                  friend.epub,
+                  userPair
+                );
+                let decryptedMessageFriend = await SEA.decrypt(
+                  message,
+                  decryptSecretFriend
+                );
+
+                if (decryptedMessageFriend) {
+                  let individual = {
+                    ...decryptedMessageFriend,
+                    encrypted: true,
+                  };
+
+                  let exists =
+                    initial.filter(
+                      (current) => current.id === individual.id
+                    )[0] !== undefined;
+
+                  if (!exists)
+                    return subscriber.next({
+                      initial: undefined,
+                      individual,
+                    });
+                }
+              }
+            });
+        })();
+      });
+  });
+
+export default messageList;

package/src/lib/messaging/sendMessage.js

@@ -0,0 +1,132 @@
+/**
+ * Invia un messaggio crittografato a un amico.
+ * 
+ * @param {string} roomId - L'ID della stanza di chat.
+ * @param {string} publicKey - La chiave pubblica del destinatario.
+ * @param {string} message - Il contenuto del messaggio da inviare.
+ * @param {function} callback - Funzione di callback chiamata al completamento dell'operazione.
+ * @returns {void}
+ */
+import { SEA } from "gun";
+import { v4 } from "uuid";
+import { gun } from "../../state/gun";
+
+let sendMessage = (roomId, publicKey, message, callback = () => {}) => {
+  (async (callback = () => {}) => {
+    // Ottiene la chiave pubblica e la coppia di chiavi dell'utente corrente
+    let userPub = await gun.user().pair().pub;
+    let userPair = await gun.user()._.sea;
+    let friend = await gun.user(publicKey);
+
+    // Verifica se la chiave pubblica dell'utente è disponibile
+    if (!userPub)
+      return callback({
+        errMessage: "Impossibile trovare la chiave pubblica.",
+        errCode: "failed-to-find-pub",
+        success: undefined,
+      });
+
+    // Ottiene il certificato per creare messaggi
+    let createMessagesCertificate = await gun
+      .user(publicKey)
+      .get("certificates")
+      .get(userPub)
+      .get("messages");
+
+    // Verifica se il certificato per creare messaggi è disponibile
+    if (!createMessagesCertificate)
+      return callback({
+        errMessage: "Impossibile trovare il certificato dell'amico per creare il messaggio",
+        errCode: "failed-to-find-friend-messages-certificate",
+        success: undefined,
+      });
+
+    // Ottiene il certificato per aggiornare i metadati della chat
+    let updateMetaCertificate = await gun
+      .user(publicKey)
+      .get("certificates")
+      .get(userPub)
+      .get("chats");
+
+    // Verifica se il certificato per aggiornare i metadati della chat è disponibile
+    if (!updateMetaCertificate)
+      return callback({
+        errMessage: "Impossibile trovare il certificato dell'amico per aggiungere metadati alla chat",
+        errCode: "failed-to-find-friend-chats-certificate",
+        success: undefined,
+      });
+
+    // Genera un ID univoco per il messaggio e ottiene il timestamp corrente
+    let messageId = v4();
+    let timeSent = Date.now();
+
+    // Crea un segreto condiviso e crittografa il messaggio
+    let secret = await SEA.secret(friend.epub, userPair);
+    let encryptedMessage = await SEA.encrypt(
+      JSON.stringify({
+        id: messageId,
+        content: message,
+        timeSent,
+        sender: userPub,
+        type: "text",
+      }),
+      secret
+    );
+
+    // Aggiorna l'ultimo messaggio nella chat dell'utente corrente
+    gun
+      .user()
+      .get("chats")
+      .get(roomId)
+      .get("latestMessage")
+      .put(encryptedMessage);
+
+    // Aggiorna l'ultimo messaggio nella chat dell'amico
+    gun
+      .user(publicKey)
+      .get("chats")
+      .get(roomId)
+      .get("latestMessage")
+      .put(encryptedMessage, null, { opt: { cert: updateMetaCertificate } });
+
+    // Salva il messaggio crittografato per l'utente corrente
+    gun
+      .user()
+      .get("messages")
+      .get(roomId)
+      .set(encryptedMessage, ({ err }) => {
+        if (err)
+          return callback({
+            errMessage: err,
+            errCode: "message-creation-error",
+            success: undefined,
+          });
+        else
+          // Salva il messaggio crittografato per l'amico
+          gun
+            .user(publicKey)
+            .get("messages")
+            .get(roomId)
+            .set(
+              encryptedMessage,
+              ({ err }) => {
+                if (err)
+                  return callback({
+                    errMessage: err,
+                    errCode: "message-creation-error",
+                    success: undefined,
+                  });
+                else
+                  return callback({
+                    errMessage: undefined,
+                    errCode: undefined,
+                    success: "Messaggio creato con successo con l'amico.",
+                  });
+              },
+              { opt: { cert: createMessagesCertificate } }
+            );
+      });
+  })(callback);
+};
+
+export default sendMessage;