gun-eth 1.3.5 → 2.0.0

package/src/lib/authentication/index.js

@@ -0,0 +1,13 @@
+import { gun } from "../../state/gun";
+import { checkAuth, isAuthenticated } from "./isAuthenticated";
+import loginUser from "./login";
+import registerUser from "./register";
+
+let logout = () => {
+  gun.user().leave();
+
+  isAuthenticated.next(false);
+};
+
+export { checkAuth, isAuthenticated, loginUser, registerUser, logout };
+

package/src/lib/authentication/isAuthenticated.js

@@ -0,0 +1,20 @@
+import { Subject } from "rxjs";
+import { gun, user } from "../../state/gun";
+
+/**
+ * This contains a subscribable function that will return a boolean of whether or not the user is authenticated or not.
+ */
+let isAuthenticated = new Subject();
+
+/**
+ * This function will check and see whether the user is authenticated or not.
+ */
+let checkAuth = () => {
+  if (user.is) return isAuthenticated.next(true);
+  else return isAuthenticated.next(false);
+};
+
+gun.on("auth", () => isAuthenticated.next(true));
+
+export { isAuthenticated, checkAuth };
+

package/src/lib/authentication/login.js

@@ -0,0 +1,25 @@
+import { user } from "../../state/gun";
+
+/**
+ * This function will authenticate a user who has registered.
+ *
+ * @param {Object} credentials The users authentication credentials that they used when registering.
+ * @param credentials.username
+ * @param credentials.password
+ *
+ * @param {Function} callback The callback function returns error messages or a success message.
+ */
+let loginUser = (credentials = {}, callback = () => {}) => {
+  user.auth(credentials.username, credentials.password, ({ err, pub }) => {
+    if (err) return callback({ errMessage: err, errCode: "gun-auth-error" });
+    else
+      return callback({
+        errMessage: undefined,
+        errCode: undefined,
+        pub,
+        message: "Successfully authenticated user.",
+      });
+  });
+};
+
+export default loginUser;

package/src/lib/authentication/register.js

@@ -0,0 +1,58 @@
+import { gun, user } from "../../state/gun";
+
+/**
+ * This function will check to see if the email is already in use.
+ *
+ * @param {string} username
+ * @returns Promise<boolean>
+ */
+let checkUsernameInUse = async (username) => {
+  let user = await gun.get(`~@${username}`);
+
+  return user !== undefined;
+};
+
+/**
+ * This function will create a user.
+ *
+ * @param {Object} credentials The users authentication credentials that they want to use when logging in.
+ * @param credentials.username
+ * @param credentials.password
+ *
+ * @param {Function} callback The callback function returns error messages or a success message.
+ */
+let registerUser = (credentials = {}, callback = () => {}) => {
+  console.log("Credentials", credentials);
+  console.log("Registering user...");
+  (async () => {
+    if (await checkUsernameInUse(credentials.username))
+      return callback({
+        errMessage: "Username in use.",
+        errCode: "username-inuse",
+      });
+    else {
+      user.create(credentials.username, credentials.password, ({ err, pub }) => {
+        if (err)
+          return callback({ errMessage: err, errCode: "gun-auth-error" });
+        else
+          return callback({
+            errMessage: undefined,
+            errCode: undefined,
+            pub,
+            message: "Successfully created user.",
+          });
+      });
+    }
+  })();
+};
+
+function str2ab(str) {
+  var buf = new ArrayBuffer(str.length * 2); // 2 bytes for each char
+  var bufView = new Uint16Array(buf);
+  for (var i = 0, strLen = str.length; i < strLen; i++) {
+    bufView[i] = str.charCodeAt(i);
+  }
+  return buf;
+}
+
+export default registerUser;

package/src/lib/blockchain/ethereum.js

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

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

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

@@ -0,0 +1,44 @@
+/**
+ * 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

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

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