gun-eth 2.0.1 → 3.0.1

package/src/lib/blockchain/ethereum.js

@@ -1,74 +0,0 @@
-import { ethers } from 'ethers';
-
-let rpcUrl = "";
-let privateKey = "";
-
-/**
- * @typedef {Object} Window
- * @property {any} ethereum
- */
-
-/**
- * Sets the configuration for standalone mode
- * @param {string} newRpcUrl - The new RPC URL
- * @param {string} newPrivateKey - The new private key
- */
-export function setStandaloneConfig(newRpcUrl, newPrivateKey) {
-  rpcUrl = newRpcUrl;
-  privateKey = newPrivateKey;
-}
-
-/**
- * Gets a signer for Ethereum transactions
- * @returns {Promise<ethers.Signer>} A signer object
- * @throws {Error} If no valid Ethereum provider is found
- */
-export async function getSigner() {
-  if (rpcUrl && privateKey) {
-    const provider = new ethers.JsonRpcProvider(rpcUrl);
-    return new ethers.Wallet(privateKey, provider);
-  } else if (typeof window !== "undefined" && typeof /** @type {any} */(window).ethereum !== "undefined") {
-    await window.ethereum.request({ method: "eth_requestAccounts" });
-    const provider = new ethers.BrowserProvider(window.ethereum);
-    return provider.getSigner();
-  } else {
-    throw new Error("No valid Ethereum provider found");
-  }
-}
-
-/**
- * Gets an Ethereum provider
- * @returns {Promise<ethers.Provider>} An Ethereum provider
- * @throws {Error} If no valid Ethereum provider is found
- */
-export async function getProvider() {
-  if (rpcUrl && privateKey) {
-    return new ethers.JsonRpcProvider(rpcUrl);
-  } else if (typeof window !== "undefined" && typeof window.ethereum !== "undefined") {
-    return new ethers.BrowserProvider(window.ethereum);
-  } else {
-    throw new Error("No valid Ethereum provider found");
-  }
-}
-
-/**
- * Gets the ENS name for a given Ethereum address
- * @param {string} address - The Ethereum address to look up
- * @returns {Promise<string|null>} The ENS name if found, null otherwise
- */
-export async function getEnsName(address) {
-  const provider = await getProvider();
-  try {
-    const ensName = await provider.lookupAddress(address);
-    if (ensName) {
-      console.log(`The ENS name for address ${address} is: ${ensName}`);
-      return ensName;
-    } else {
-      console.log(`No ENS name found for address ${address}`);
-      return null;
-    }
-  } catch (error) {
-    console.error("Error while looking up ENS name:", error);
-    return null;
-  }
-}

package/src/lib/blockchain/shine.js

@@ -1,204 +0,0 @@
-import { SHINE_ABI, SHINE_OPTIMISM_SEPOLIA } from "../utils/utils.js";
-
-/**
- * @typedef {Object} ShineResult
- * @property {boolean} ok - Indicates if the operation was successful
- * @property {string} message - A descriptive message about the operation result
- * @property {number} [timestamp] - The timestamp of the verified data (if applicable)
- * @property {string} [updater] - The address of the last updater (if applicable)
- * @property {Object} [latestRecord] - The latest record from the blockchain (if applicable)
- * @property {string} [nodeId] - The ID of the newly created node (for write operations)
- * @property {string} [txHash] - The transaction hash (for write operations)
- */
-
-/**
- * Creates a SHINE (Secure Hybrid Information and Node Ecosystem) plugin for Gun
- * @param {any} Gun - The Gun instance
- * @param {any} ethers - The ethers.js library
- * @param {Function} getSigner - Function to get the signer
- * @param {Function} getProvider - Function to get the provider
- * @returns {Function} The SHINE plugin function
- */
-export function shine(Gun, ethers, getSigner, getProvider) {
-  /**
-   * The SHINE plugin function
-   * @param {string} chain - The blockchain network to use
-   * @param {string} [nodeId] - The ID of the node to verify (for read operations)
-   * @param {Object} [data] - The data to write (for write operations)
-   * @param {Function} callback - The callback function to handle the result
-   * @returns {Object} The Gun instance
-   * @this {any}
-   */
-
-  return function (chain, nodeId, data = null, callback = () => {}) {
-    console.log("SHINE plugin called with:", { chain, nodeId, data });
-
-    if (typeof callback !== "function") {
-      callback = () => {};
-      console.error("Callback must be a function");
-      return this;
-    }
-
-    const gun = this;
-    let SHINE_CONTRACT_ADDRESS;
-
-    if (chain === "optimismSepolia") {
-      SHINE_CONTRACT_ADDRESS = SHINE_OPTIMISM_SEPOLIA;
-    } else {
-      throw new Error("Chain not supported");
-    }
-
-    /**
-     * Verifies data on-chain
-     * @param {string} nodeId - The ID of the node to verify
-     * @param {string} contentHash - The content hash to verify
-     * @returns {Promise<{isValid: boolean, timestamp: number, updater: string}>} The verification result
-     */
-    const verifyOnChain = async (nodeId, contentHash) => {
-      console.log("Verifying on chain:", { nodeId, contentHash });
-      const signer = await getSigner();
-      const contract = new ethers.Contract(
-        SHINE_CONTRACT_ADDRESS,
-        SHINE_ABI,
-        signer
-      );
-      const [isValid, timestamp, updater] = await contract.verifyData(
-        ethers.toUtf8Bytes(nodeId),
-        contentHash
-      );
-      console.log("Verification result:", { isValid, timestamp, updater });
-      return { isValid, timestamp, updater };
-    };
-
-    /**
-     * Writes data on-chain
-     * @param {string} nodeId - The ID of the node to write
-     * @param {string} contentHash - The content hash to write
-     * @returns {Promise<any>} The transaction object
-     */
-    const writeOnChain = async (nodeId, contentHash) => {
-      console.log("Writing on chain:", { nodeId, contentHash });
-      const signer = await getSigner();
-      const contract = new ethers.Contract(
-        SHINE_CONTRACT_ADDRESS,
-        SHINE_ABI,
-        signer
-      );
-      const tx = await contract.updateData(
-        ethers.toUtf8Bytes(nodeId),
-        contentHash
-      );
-      console.log("Transaction sent:", tx.hash);
-      const receipt = await tx.wait();
-      console.log("Transaction confirmed:", receipt);
-      return tx;
-    };
-
-    /**
-     * Gets the latest record from the blockchain
-     * @param {string} nodeId - The ID of the node to retrieve
-     * @returns {Promise<{contentHash: string, timestamp: number, updater: string}>} The latest record
-     */
-    const getLatestRecord = async (nodeId) => {
-      const signer = await getSigner();
-      const contract = new ethers.Contract(
-        SHINE_CONTRACT_ADDRESS,
-        SHINE_ABI,
-        signer
-      );
-      const [contentHash, timestamp, updater] = await contract.getLatestRecord(
-        ethers.toUtf8Bytes(nodeId)
-      );
-      console.log("Latest record from blockchain:", {
-        nodeId,
-        contentHash,
-        timestamp,
-        updater,
-      });
-      return { contentHash, timestamp, updater };
-    };
-
-    // SHINE process
-    if (nodeId && !data) {
-      gun.get(nodeId).once(async (existingData) => {
-        if (!existingData) {
-          if (callback) callback({ err: "Node not found in GunDB" });
-          return;
-        }
-
-        console.log("existingData", existingData);
-
-        const contentHash = existingData._contentHash;
-        console.log("contentHash", contentHash);
-
-        if (!contentHash) {
-          if (callback)
-            callback({ err: "No content hash found for this node" });
-          return;
-        }
-
-        try {
-          const { isValid, timestamp, updater } = await verifyOnChain(
-            nodeId,
-            contentHash
-          );
-          const latestRecord = await getLatestRecord(nodeId);
-
-          if (isValid) {
-            if (callback)
-              callback({
-                ok: true,
-                message: "Data verified on blockchain",
-                timestamp,
-                updater,
-                latestRecord,
-              });
-          } else {
-            if (callback)
-              callback({
-                ok: false,
-                message: "Data not verified on blockchain",
-                latestRecord,
-              });
-          }
-        } catch (error) {
-          if (callback) callback({ err: error.message });
-        }
-      });
-    } else if (data && !nodeId) {
-      const newNodeId = Gun.text.random();
-      const dataString = JSON.stringify(data);
-      const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
-
-      gun
-        .get(newNodeId)
-        .put({ ...data, _contentHash: contentHash }, async (ack) => {
-          console.log("ack", ack);
-          if (ack.err) {
-            if (callback) callback({ err: "Error saving data to GunDB" });
-            return;
-          }
-
-          try {
-            const tx = await writeOnChain(newNodeId, contentHash);
-            if (callback)
-              callback({
-                ok: true,
-                message: "Data written to GunDB and blockchain",
-                nodeId: newNodeId,
-                txHash: tx.hash,
-              });
-          } catch (error) {
-            if (callback) callback({ err: error.message });
-          }
-        });
-    } else {
-      if (callback)
-        callback({
-          err: "Invalid input. Provide either nodeId or data, not both.",
-        });
-    }
-
-    return gun;
-  };
-}

package/src/lib/certificates/friendsCertificates.js

@@ -1,92 +0,0 @@
-import { SEA } from "gun";
-import { gun } from "../../state/gun";
-
-/**
- * Genera un certificato per le richieste di amicizia.
- * @param {Function} callback - Funzione di callback chiamata al completamento dell'operazione.
- * @returns {Promise<void>}
- */
-let generateFriendRequestsCertificate = async (callback = () => {}) => {
-  let certificateExists = await gun
-    .user()
-    .get("certificates")
-    .get("friendRequests")
-    .once();
-
-  if (certificateExists) return;
-
-  let certificate = await SEA.certify(
-    ["*"],
-    [{ "*": "friendRequests" }],
-    await gun.user().pair(),
-    null
-  );
-  
-  gun
-    .user()
-    .get("certificates")
-    .get("friendRequests")
-    .put(certificate, ({ err }) => {
-      if (err)
-        return callback({
-          errMessage: err,
-          errCode: "gun-put-error",
-          success: undefined,
-        });
-      else
-        return callback({
-          errMessage: undefined,
-          errCode: undefined,
-          certificate,
-          success: "Generated new friend requests certificate.",
-        });
-    });
-};
-
-/**
- * Genera un certificato per aggiungere un amico.
- * @param {string} publicKey - Chiave pubblica dell'amico da aggiungere.
- * @param {Function} callback - Funzione di callback chiamata al completamento dell'operazione.
- * @returns {Promise<void>}
- */
-let generateAddFriendCertificate = async (publicKey, callback = () => {}) => {
-  let certificateExists = await gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("addFriend")
-    .once();
-
-  if (certificateExists) return;
-
-  let certificate = await SEA.certify(
-    [publicKey],
-    [{ "*": "friends" }],
-    await gun.user().pair(),
-    null
-  );
-
-  gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("addFriend")
-    .put(certificate, ({ err }) => {
-      if (err)
-        return callback({
-          errMessage: err,
-          errCode: "gun-put-error",
-          success: undefined,
-        });
-      else
-        return callback({
-          errMessage: undefined,
-          errCode: undefined,
-          certificate,
-          success:
-            "Generated certificate for requested friend to add user back.",
-        });
-    });
-};
-
-export { generateFriendRequestsCertificate, generateAddFriendCertificate };

package/src/lib/certificates/index.js

@@ -1,44 +0,0 @@
-/**
- * Modulo per la gestione dei certificati nell'applicazione.
- * @module certificates
- */
-
-import {
-    generateAddFriendCertificate,
-    generateFriendRequestsCertificate
-} from "./friendsCertificates";
-import {
-    createChatsCertificate,
-    createMessagesCertificate
-} from "./messagingCertificates";
-
-/**
- * Genera un certificato per aggiungere un amico.
- * @function
- * @param {string} publicKey - Chiave pubblica dell'amico da aggiungere.
- * @param {Function} [callback] - Funzione di callback opzionale.
- */
-export { generateAddFriendCertificate };
-
-/**
- * Genera un certificato per le richieste di amicizia.
- * @function
- * @param {Function} [callback] - Funzione di callback opzionale.
- */
-export { generateFriendRequestsCertificate };
-
-/**
- * Crea un certificato per le chat con un utente specifico.
- * @function
- * @param {string} publicKey - Chiave pubblica dell'utente.
- * @param {Function} [callback] - Funzione di callback opzionale.
- */
-export { createChatsCertificate };
-
-/**
- * Crea un certificato per i messaggi con un utente specifico.
- * @function
- * @param {string} publicKey - Chiave pubblica dell'utente.
- * @param {Function} [callback] - Funzione di callback opzionale.
- */
-export { createMessagesCertificate };

package/src/lib/certificates/messagingCertificates.js

@@ -1,94 +0,0 @@
-import { SEA } from "gun";
-import { gun } from "../../state/gun";
-
-/**
- * Crea un certificato per le chat con un utente specifico.
- * @param {string} publicKey - La chiave pubblica dell'utente per cui creare il certificato.
- * @param {function} [callback] - Funzione di callback opzionale chiamata al completamento dell'operazione.
- * @returns {Promise<void>}
- */
-let createChatsCertificate = async (publicKey, callback = () => {}) => {
-  let certificateExists = await gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("chats")
-    .once();
-
-  if (certificateExists) return;
-
-  let certificate = await SEA.certify(
-    [publicKey],
-    [{ "*": "chats" }],
-    await gun.user().pair(),
-    null
-  );
-
-  gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("chats")
-    .put(certificate, ({ err }) => {
-      if (err)
-        return callback({
-          errMessage: err,
-          errCode: "chats-certificate-creation-error",
-          success: undefined,
-        });
-      else
-        return callback({
-          errMessage: undefined,
-          errCode: undefined,
-          certificate,
-          success: "Generated new chats certificate.",
-        });
-    });
-};
-
-/**
- * Crea un certificato per i messaggi con un utente specifico.
- * @param {string} publicKey - La chiave pubblica dell'utente per cui creare il certificato.
- * @param {function} [callback] - Funzione di callback opzionale chiamata al completamento dell'operazione.
- * @returns {Promise<void>}
- */
-let createMessagesCertificate = async (publicKey, callback = () => {}) => {
-  let certificateExists = await gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("messages")
-    .once();
-
-  if (certificateExists) return;
-
-  let certificate = await SEA.certify(
-    [publicKey],
-    [{ "*": "messages" }],
-    await gun.user().pair(),
-    null
-  );
-
-  gun
-    .user()
-    .get("certificates")
-    .get(publicKey)
-    .get("messages")
-    .put(certificate, ({ err }) => {
-      if (err)
-        return callback({
-          errMessage: err,
-          errCode: "messages-certificate-creation-error",
-          success: undefined,
-        });
-      else
-        return callback({
-          errMessage: undefined,
-          errCode: undefined,
-          certificate,
-          success: "Generated new messages certificate.",
-        });
-    });
-};
-
-export { createChatsCertificate, createMessagesCertificate };

package/src/lib/friends/acceptFriendRequest.js

@@ -1,69 +0,0 @@
-import { gun, user } from "../../state/gun";
-
-/**
- * Accetta una richiesta di amicizia.
- * @param {Object} params - Parametri della funzione.
- * @param {string} params.key - Chiave della richiesta di amicizia.
- * @param {string} params.publicKey - Chiave pubblica dell'utente che ha inviato la richiesta.
- * @param {Function} [callback] - Funzione di callback opzionale.
- * @returns {void}
- */
-let acceptFriendRequest = ({ key, publicKey }, callback = () => {}) => {
-  gun
-    .user()
-    .get("friendRequests")
-    .get(key)
-    .put(null, async ({ err }) => {
-      if (err)
-        return callback({
-          errMessage: err,
-          errCode: "accept-friend-request-failed",
-          success: undefined,
-        });
-      else {
-        let addFriendCertificate = await gun
-          .user(publicKey)
-          .get("certificates")
-          .get(user.is.pub)
-          .get("addFriend");
-
-        gun
-          .user(publicKey)
-          .get("friends")
-          .set(
-            user.is.pub,
-            ({ err }) => {
-              if (err)
-                return callback({
-                  errMessage: err,
-                  errCode: "add-friend-failed",
-                  success: undefined,
-                });
-              else
-                gun
-                  .user()
-                  .get("friends")
-                  .set(publicKey, ({ err }) => {
-                    if (err)
-                      return callback({
-                        errMessage: err,
-                        errCode: "add-friend-failed",
-                        success: undefined,
-                      });
-                    else
-                      return callback({
-                        errMessage: undefined,
-                        errCode: undefined,
-                        success: "Added friend successfully.",
-                      });
-                  });
-            },
-            {
-              opt: { cert: addFriendCertificate },
-            }
-          );
-      }
-    });
-};
-
-export default acceptFriendRequest;

package/src/lib/friends/addFriendRequest.js

@@ -1,49 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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;