gun-eth 1.3.5 → 2.0.0

package/src/index.js

@@ -1,533 +1,181 @@
-(function (root, factory) {
-  if (typeof define === "function" && define.amd) {
-    define(["gun", "gun/sea", "ethers"], factory);
-  } else if (typeof module === "object" && module.exports) {
-    module.exports = factory(
-      require("gun/gun"),
-      require("gun/sea"),
-      require("ethers")
-    );
-  } else {
-    factory(root.Gun, root.SEA, root.ethers);
-  }
-})(typeof self !== "undefined" ? self : this, function (Gun, SEA, ethers) {
-  console.log("Factory del plugin Gun-Eth chiamata");
-
-  const MESSAGE_TO_SIGN = "Accesso a GunDB con Ethereum";
-
-  // Funzione per verificare se ethers è disponibile
-  function checkEthers() {
-    if (typeof ethers === "undefined") {
-      console.error(
-        "Ethers.js non è disponibile. Assicurati che sia caricato prima di questo script."
+import * as authentication from "./lib/authentication";
+import * as certificates from "./lib/certificates";
+import * as friends from "./lib/friends";
+import * as messaging from "./lib/messaging";
+import { gun, user } from "./state/gun";
+import Gun from "gun";
+
+import {
+  getEnsName,
+  getSigner,
+  getProvider,
+  setStandaloneConfig,
+} from "./lib/blockchain/ethereum";
+
+Gun.chain.GunEth = function (gun, SEA, ethers) {
+  console.log("gunEth called");
+  console.log("gun in gunEth:", gun);
+
+  return {
+    shine: (chain, nodeId, data, callback) =>
+      Gun.chain.shine.call(gun, chain, nodeId, data, callback),
+
+    setStandaloneConfig: (newRpcUrl, newPrivateKey) => {
+      console.log(
+        "setStandaloneConfig called with:",
+        newRpcUrl,
+        newPrivateKey
       );
-      return false;
-    }
-    console.log("Ethers version:", ethers.version);
-    return true;
-  }
-
-  // Global variables
-  let SHINE_ABI = [
-    {
-      anonymous: false,
-      inputs: [
-        {
-          indexed: true,
-          internalType: "bytes",
-          name: "nodeId",
-          type: "bytes",
-        },
-        {
-          indexed: false,
-          internalType: "bytes32",
-          name: "contentHash",
-          type: "bytes32",
-        },
-        {
-          indexed: false,
-          internalType: "address",
-          name: "updater",
-          type: "address",
-        },
-      ],
-      name: "DataUpdated",
-      type: "event",
-    },
-    {
-      inputs: [
-        {
-          internalType: "bytes[]",
-          name: "nodeIds",
-          type: "bytes[]",
-        },
-        {
-          internalType: "bytes32[]",
-          name: "contentHashes",
-          type: "bytes32[]",
-        },
-      ],
-      name: "batchUpdateData",
-      outputs: [],
-      stateMutability: "nonpayable",
-      type: "function",
-    },
-    {
-      inputs: [
-        {
-          internalType: "bytes",
-          name: "nodeId",
-          type: "bytes",
-        },
-      ],
-      name: "getLatestRecord",
-      outputs: [
-        {
-          internalType: "bytes32",
-          name: "",
-          type: "bytes32",
-        },
-        {
-          internalType: "uint256",
-          name: "",
-          type: "uint256",
-        },
-        {
-          internalType: "address",
-          name: "",
-          type: "address",
-        },
-      ],
-      stateMutability: "view",
-      type: "function",
-    },
-    {
-      inputs: [
-        {
-          internalType: "bytes",
-          name: "",
-          type: "bytes",
-        },
-      ],
-      name: "nodeData",
-      outputs: [
-        {
-          internalType: "bytes32",
-          name: "contentHash",
-          type: "bytes32",
-        },
-        {
-          internalType: "uint256",
-          name: "timestamp",
-          type: "uint256",
-        },
-        {
-          internalType: "address",
-          name: "updater",
-          type: "address",
-        },
-      ],
-      stateMutability: "view",
-      type: "function",
+      setStandaloneConfig(newRpcUrl, newPrivateKey);
+      console.log("Standalone configuration set");
+      return this.gun;
     },
-    {
-      inputs: [
-        {
-          internalType: "bytes",
-          name: "nodeId",
-          type: "bytes",
-        },
-        {
-          internalType: "bytes32",
-          name: "contentHash",
-          type: "bytes32",
-        },
-      ],
-      name: "updateData",
-      outputs: [],
-      stateMutability: "nonpayable",
-      type: "function",
-    },
-    {
-      inputs: [
-        {
-          internalType: "bytes",
-          name: "nodeId",
-          type: "bytes",
-        },
-        {
-          internalType: "bytes32",
-          name: "contentHash",
-          type: "bytes32",
-        },
-      ],
-      name: "verifyData",
-      outputs: [
-        {
-          internalType: "bool",
-          name: "",
-          type: "bool",
-        },
-        {
-          internalType: "uint256",
-          name: "",
-          type: "uint256",
-        },
-        {
-          internalType: "address",
-          name: "",
-          type: "address",
-        },
-      ],
-      stateMutability: "view",
-      type: "function",
-    },
-  ];
-
-  let SHINE_OPTIMISM_SEPOLIA = "0x43D838b683F772F08f321E5FA265ad3e333BE9C2";
-  let SHINE_CONTRACT_ADDRESS;
-  let rpcUrl = "";
-  let privateKey = "";
-
-  /**
-   * Funzione per ottenere il signer
-   * @returns {Promise<ethers.Signer>} Il signer.
-   */
-  const getSigner = async () => {
-    if (rpcUrl && privateKey) {
-      // Modalità standalone
-      const provider = new ethers.JsonRpcProvider(rpcUrl);
-      return new ethers.Wallet(privateKey, provider);
-    } else if (
-      typeof window !== "undefined" &&
-      typeof window.ethereum !== "undefined"
-    ) {
-      // Modalità browser
-      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");
-    }
-  };
-
-  /**
-   * Sets standalone configuration for Gun.
-   * @param {string} newRpcUrl - The new RPC URL.
-   * @param {string} newPrivateKey - The new private key.
-   * @returns {Gun} The Gun instance for chaining.
-   */
-  Gun.chain.setStandaloneConfig = function (newRpcUrl, newPrivateKey) {
-    rpcUrl = newRpcUrl;
-    privateKey = newPrivateKey;
-    console.log("Standalone configuration set");
-    return this;
-  };
 
-  /**
-   * Verifies an Ethereum signature.
-   * @param {string} message - The original message that was signed.
-   * @param {string} signature - The signature to verify.
-   * @returns {Promise<string|null>} The recovered address or null if verification fails.
-   */
-  Gun.chain.verifySignature = async function (message, signature) {
-    try {
-      const recoveredAddress = ethers.verifyMessage(message, signature);
-      return recoveredAddress;
-    } catch (error) {
-      console.error("Error verifying signature:", error);
-      return null;
-    }
-  };
-
-  /**
-   * Generates a password from a signature.
-   * @param {string} signature - The signature to derive the password from.
-   * @returns {string|null} The generated password or null if generation fails.
-   */
-  Gun.chain.generatePassword = function (signature) {
-    try {
-      const hexSignature = ethers.hexlify(signature);
-      const hash = ethers.keccak256(hexSignature);
-      console.log("Generated password:", hash);
-      return hash;
-    } catch (error) {
-      console.error("Error generating password:", error);
-      return null;
-    }
-  };
-
-  /**
-   * Creates an Ethereum signature for a given message.
-   * @param {string} message - The message to sign.
-   * @returns {Promise<string|null>} The signature or null if signing fails.
-   */
-  Gun.chain.createSignature = async function (message) {
-    try {
-      // Verifica se il messaggio è uguale a MESSAGE_TO_SIGN
-      if (message !== MESSAGE_TO_SIGN) {
-        throw new Error(
-          "Invalid message, valid message is: " + MESSAGE_TO_SIGN
-        );
+    verifySignature: async (message, signature) => {
+      try {
+        return ethers.verifyMessage(message, signature);
+      } catch (error) {
+        console.error("Error verifying signature:", error);
+        return null;
       }
-      const signer = await getSigner();
-      const signature = await signer.signMessage(message);
-      console.log("Signature created:", signature);
-      return signature;
-    } catch (error) {
-      console.error("Error creating signature:", error);
-      return null;
-    }
-  };
-
-  /**
-   * Creates and stores an encrypted key pair for a given address.
-   * @param {string} address - The Ethereum address to associate with the key pair.
-   * @param {string} signature - The signature to use for encryption.
-   * @returns {Promise<void>}
-   */
-  Gun.chain.createAndStoreEncryptedPair = async function (address, signature) {
-    try {
-      const gun = this;
-      const pair = await SEA.pair();
-      const encryptedPair = await SEA.encrypt(JSON.stringify(pair), signature);
-      await gun.get("gun-eth").get("users").get(address).put({ encryptedPair });
-      console.log("Encrypted pair stored for:", address);
-    } catch (error) {
-      console.error("Error creating and storing encrypted pair:", error);
-    }
-  };
+    },
 
-  /**
-   * Retrieves and decrypts a stored key pair for a given address.
-   * @param {string} address - The Ethereum address associated with the key pair.
-   * @param {string} signature - The signature to use for decryption.
-   * @returns {Promise<Object|null>} The decrypted key pair or null if retrieval fails.
-   */
-  Gun.chain.getAndDecryptPair = async function (address, signature) {
-    try {
-      const gun = this;
-      const encryptedData = await gun
-        .get("gun-eth")
-        .get("users")
-        .get(address)
-        .get("encryptedPair")
-        .then();
-      if (!encryptedData) {
-        throw new Error("No encrypted data found for this address");
+    generatePassword: (signature) => {
+      try {
+        const hexSignature = ethers.hexlify(signature);
+        const hash = ethers.keccak256(hexSignature);
+        console.log("Generated password:", hash);
+        return hash;
+      } catch (error) {
+        console.error("Error generating password:", error);
+        return null;
       }
-      const decryptedPair = await SEA.decrypt(encryptedData, signature);
-      console.log(decryptedPair);
-      return decryptedPair;
-    } catch (error) {
-      console.error("Error retrieving and decrypting pair:", error);
-      return null;
-    }
-  };
-
-  /**
-   * SHINE (Secure Hybrid Information and Network Environment) functionality.
-   * @param {string} chain - The blockchain to use (e.g., "optimismSepolia").
-   * @param {string} nodeId - The ID of the node to verify or write.
-   * @param {Object} data - The data to write (if writing).
-   * @param {Function} callback - Callback function to handle the result.
-   * @returns {Gun} The Gun instance for chaining.
-   */
-  Gun.chain.shine = function (chain, nodeId, data, callback) {
-    console.log("SHINE plugin called with:", { chain, nodeId, data });
-
-    if (!checkEthers()) {
-      if (callback) callback({ err: "Ethers.js non è disponibile" });
-      return this;
-    }
-
-    if (typeof callback !== "function") {
-      console.error("Callback must be a function");
-      return this;
-    }
-
-    const gun = this;
-
-    // Seleziona l'indirizzo basato sulla catena
-    if (chain === "optimismSepolia") {
-      SHINE_CONTRACT_ADDRESS = SHINE_OPTIMISM_SEPOLIA;
-    } else {
-      throw new Error("Chain not supported");
-    }
-
-    // Funzione per verificare on-chain
-    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 };
-    };
-
-    // Funzione per scrivere on-chain
-    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;
-    };
-
-    // Nuova funzione per ottenere l'ultimo record dalla blockchain
-    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 };
-    };
+    },
 
-    // Processo SHINE
-    if (nodeId && !data) {
-      // Caso 1: Utente passa solo il nodo
-      gun.get(nodeId).once(async (existingData) => {
-        if (!existingData) {
-          if (callback) callback({ err: "Node not found in GunDB" });
-          return;
-        }
+    createSignature: async () => {
+      try {
+        const signer = await getSigner();
+        const signature = await signer.signMessage(
+          "GunDB access with Ethereum"
+        );
+        console.log("Signature created:", signature);
+        return signature;
+      } catch (error) {
+        console.error("Error creating signature:", error);
+        return null;
+      }
+    },
 
-        console.log("existingData", existingData);
+    createAndStoreEncryptedPair: async (address, password) => {
+      try {
+        const pair = await user._.sea;
+        const encryptedPair = await SEA.encrypt(
+          JSON.stringify(pair),
+          password
+        );
 
-        // Usa il contentHash memorizzato invece di ricalcolarlo
-        const contentHash = existingData._contentHash;
-        console.log("contentHash", contentHash);
+        // TODO: Add spending and viewing pairs implementation
+        // const encryptedSpendingPair = await SEA.encrypt(JSON.stringify(pair), password + "_spending");
+        // const encryptedViewingPair = await SEA.encrypt(JSON.stringify(pair), password + "_viewing");
 
-        if (!contentHash) {
-          if (callback)
-            callback({ err: "No content hash found for this node" });
-          return;
-        }
+        let ethAccount;
 
         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,
-              });
-          }
+          const ensName = await getEnsName(address);
+          ethAccount = ensName ? ensName : address;
         } catch (error) {
-          if (callback) callback({ err: error.message });
+          console.error("Error getting ENS name:", error);
+          ethAccount = address;
         }
-      });
-    } else if (data && !nodeId) {
-      // Caso 2: Utente passa solo il testo (data)
-      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;
-          }
+        const data = {
+          pub: encryptedPair.pub,
+          address: address,
+          ensName: ethAccount,
+        };
+
+        await gun
+          .get("gun-eth")
+          .get("users")
+          .get(address)
+          .put({ encryptedPair });
+        await gun
+          .get("gun-eth")
+          .get("usersData")
+          .get(encryptedPair.pub)
+          .put({ data });
+
+        await gun
+          .get(`~${encryptedPair.pub}`)
+          .get("safe")
+          .get("enc")
+          .put({ encryptedPair });
+
+        console.log("Encrypted pair stored for:", address);
+      } catch (error) {
+        console.error("Error creating and storing encrypted pair:", error);
+      }
+    },
 
-          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.",
-        });
-    }
+    getAndDecryptPair: async (address, password) => {
+      try {
+        const encryptedData = await gun
+          .get("gun-eth")
+          .get("users")
+          .get(address)
+          .get("encryptedPair")
+          .then();
+        if (!encryptedData) {
+          throw new Error("No encrypted data found for this address");
+        }
+        const decryptedPair = await SEA.decrypt(encryptedData, password);
+        console.log(decryptedPair);
+        return decryptedPair;
+      } catch (error) {
+        console.error("Error retrieving and decrypting pair:", error);
+        return null;
+      }
+    },
 
-    return gun;
+    gunToEthAccount: (gunPrivateKey) => {
+      const base64UrlToHex = (base64url) => {
+        const padding = "=".repeat((4 - (base64url.length % 4)) % 4);
+        const base64 =
+          base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+        const binaryString = atob(base64);
+        return Array.from(binaryString, (char) =>
+          char.charCodeAt(0).toString(16).padStart(2, "0")
+        ).join("");
+      };
+
+      const hexPrivateKey = "0x" + base64UrlToHex(gunPrivateKey);
+      const wallet = new ethers.Wallet(hexPrivateKey);
+      const publicKey = wallet.address;
+
+      return {
+        account: wallet,
+        publicKey: publicKey,
+      };
+    },
   };
+};
+
+const GunEthProtocol = () => {
+  return {
+    authentication,
+    certificates,
+    friends,
+    messaging,
+    gun,
+    user
+  }
+}
 
-  /**
-   * Converts a Gun private key to an Ethereum account.
-   * @param {string} gunPrivateKey - The Gun private key in base64url format.
-   * @returns {Object} An object containing the Ethereum account and public key.
-   */
-  Gun.chain.gunToEthAccount = function (gunPrivateKey) {
-    // Function to convert base64url to hex
-    const base64UrlToHex = (base64url) => {
-      const padding = "=".repeat((4 - (base64url.length % 4)) % 4);
-      const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
-      const binary = atob(base64);
-      return Array.from(binary, (char) =>
-        char.charCodeAt(0).toString(16).padStart(2, "0")
-      ).join("");
-    };
-
-    // Convert Gun private key to hex format
-    const hexPrivateKey = "0x" + base64UrlToHex(gunPrivateKey);
-
-    // Create an Ethereum wallet from the private key
-    const wallet = new ethers.Wallet(hexPrivateKey);
-
-    // Get the public address (public key)
-    const publicKey = wallet.address;
+if (typeof window !== "undefined") {
+  window.Gun = gun;
+  window.GunEthProtocol = GunEthProtocol();
+  window.User = user;
+}
 
-    return {
-      account: wallet,
-      publicKey: publicKey,
-    };
-  };
+export { authentication, certificates, friends, messaging, gun, user };
 
-  console.log("Plugin Gun-Eth successfully loaded");
-});