gun-eth 1.2.2 → 1.2.3

package/README.md

@@ -4,43 +4,123 @@
 
 gun-eth is a plugin for GunDB that integrates Ethereum and Web3 functionality. This plugin extends GunDB's capabilities by allowing interaction with the Ethereum blockchain and providing cryptographic and signature management features.
 
-## Key Features
+SHINE Smart Contract deployed on Optimism Sepolia: [0x43D838b683F772F08f321E5FA265ad3e333BE9C2](https://sepolia-optimism.etherscan.io/address/0x43D838b683F772F08f321E5FA265ad3e333BE9C2)
 
-- Ethereum signature verification
-- Signature-based password generation
-- Signature creation using Ethereum providers (e.g., MetaMask)
+Currently, the contract is deployed only on Optimism Sepolia. In the future, it will be deployed on multiple chains.
 
-## Example
+### Key Features
 
-[gun-eth dapp](https://gun-eth.vercel.app/)
+- **Ethereum Signature Verification**: Verify Ethereum signatures for messages.
+- **Password Generation**: Generate secure passwords from Ethereum signatures.
+- **Signature Creation**: Create Ethereum signatures for messages.
+- **Encrypted Key Pair Management**: Create, store, and retrieve encrypted key pairs.
+- **SHINE Implementation**: Implement the SHINE for data verification on the blockchain.
 
-## Installation
+### How to install
 
 ```bash
 npm install gun-eth
 ```
 
-## Usage
-
-```javascript
-const Gun = require("gun");
-require("gun-eth");
+```bash
+import gun from "gun";
+import "gun-eth";
 
-const gun = Gun();
+const gun = gun();
 
-// Now you can use the new features
+await gun.generatePassword("YOUR_SIGNATURE");
 ```
 
-## Main Functions
+### How to use
+
+Learn more about Gun.js [here](https://gun.eco/docs/Getting-Started).
+
+Learn more about plugin implementation [here](https://github.com/amark/gun/wiki/Adding-Methods-to-the-Gun-Chain#abstraction-layers).
+
+### Core Functions
+
+- `verifySignature(message, signature)`: Verifies an Ethereum signature for a given message.
+
+  ```js
+  const recoveredAddress = await gun.verifySignature(message, signature);
+  ```
+
+- `generatePassword(signature)`: Generates a password from an Ethereum signature.
+
+  ```js
+  const password = gun.generatePassword(signature);
+  ```
+
+- `createSignature(message)`: Creates an Ethereum signature for a message.
+
+  ```js
+  const signature = await gun.createSignature(message);
+  ```
+
+- `createAndStoreEncryptedPair(address, signature)`: Creates and stores an encrypted key pair.
 
-- `gun.verifySignature(message, signature)`: Verifies an Ethereum signature
-- `gun.generatePassword(signature)`: Generates a password based on a signature
-- `gun.createSignature(message)`: Creates a signature using an Ethereum provider
+  ```js
+  await gun.createAndStoreEncryptedPair(address, signature);
+  ```
+
+- `getAndDecryptPair(address, signature)`: Retrieves and decrypts a stored key pair.
+
+  ```js
+  const decryptedPair = await gun.getAndDecryptPair(address, signature);
+  ```
+
+- `shine(chain, nodeId, data, callback)`: Implements SHINE for data verification and storage on the blockchain.
+  ```js
+  gun.shine("optimismSepolia", nodeId, data, callback);
+  ```
+
+### SHINE
+
+SHINE (Secure Hash Integrity Network Ethereum) provides a mechanism for verifying data integrity using Ethereum and Gun.js.
+
+1. **Data Storage**: When saving data, a content hash is generated and stored in both Gun.js and on the Ethereum blockchain.
+2. **Data Verification**: To verify data, the stored hash is compared with a hash generated from the data retrieved from Gun.js.
+3. **Blockchain Interaction**: The plugin interacts with an Ethereum smart contract to store and verify data hashes.
+
+### Usage Examples
+
+#### Verifying Data by NodeId
+
+```js
+const nodeId = "your-node-id-here";
+gun.shine("optimismSepolia", nodeId, null, (ack) => {
+  if (ack.ok) {
+    console.log("Data verified on blockchain", ack);
+    console.log("Timestamp:", ack.timestamp);
+    console.log("Updater:", ack.updater);
+    console.log("Latest Record:", ack.latestRecord);
+  } else {
+    console.log("Data not verified or not found", ack);
+  }
+});
+```
+
+#### Storing New Data
+
+```js
+const data = { message: "Hello, blockchain!" };
+gun.shine("optimismSepolia", null, data, (ack) => {
+  if (ack.ok) {
+    console.log("Data stored on Gun.js and blockchain", ack);
+    console.log("New Node ID:", ack.nodeId);
+    console.log("Transaction Hash:", ack.txHash);
+  } else {
+    console.log("Error storing data", ack);
+  }
+});
+```
 
-## Dependencies
+### Security Considerations
 
-- gun: ^0.2020.1239
-- ethers: ^6.0.0
+- Use a secure Ethereum provider (e.g., MetaMask) when interacting with functions that require signatures.
+- Generated passwords and key pairs are sensitive. Handle them carefully and avoid exposing them.
+- Keep Gun.js and Ethereum dependencies up to date for security.
+- Be aware of gas costs associated with blockchain interactions when using SHINE.
 
 ## Contributing
 

package/index.js

@@ -1 +1,270 @@
-import "./gun-eth.js";
+/* const Gun = require("gun/gun");
+const SEA = require("gun/sea");
+const ethers = require("ethers");
+const SHINE = require("./SHINE.json"); */
+
+import Gun from "gun";
+import SEA from "gun/sea";
+import { ethers } from "ethers";
+
+import SHINE from "./SHINE.json";
+
+const SHINE_ABI = SHINE.abi;
+const SHINE_OPTIMISM_SEPOLIA = SHINE.address;
+
+let SHINE_CONTRACT_ADDRESS;
+
+// Aggiungi il metodo alla catena di Gun
+Gun.chain.verifySignature = async function (message, signature) {
+  try {
+    const recoveredAddress = ethers.verifyMessage(message, signature);
+    return recoveredAddress;
+  } catch (error) {
+    console.error("Errore durante la verifica della firma:", error);
+    return null;
+  }
+};
+
+Gun.chain.generatePassword = function (signature) {
+  try {
+    // Usa SHA-256 per derivare una password dalla firma
+    const hexSignature = ethers.hexlify(signature);
+    const hash = ethers.keccak256(hexSignature);
+
+    console.log("Password generata:", hash);
+    return hash;
+  } catch (error) {
+    console.error("Errore nella generazione della password:", error);
+    return null;
+  }
+};
+
+Gun.chain.createSignature = async function (message) {
+  try {
+    // Controlla se window.ethereum è disponibile (metamask o altro provider)
+    if (typeof window.ethereum !== "undefined") {
+      await window.ethereum.request({ method: "eth_requestAccounts" });
+      const provider = new ethers.BrowserProvider(window.ethereum);
+      const signer = await provider.getSigner();
+      const signature = await signer.signMessage(message);
+      console.log("Firma creata:", signature);
+      return signature;
+    } else {
+      throw new Error("Provider Ethereum non trovato");
+    }
+  } catch (error) {
+    console.error("Errore durante la creazione della firma:", error);
+    return null;
+  }
+};
+
+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("users").get(address).put({ encryptedPair });
+    console.log("Pair crittografato e archiviato per:", address);
+  } catch (error) {
+    console.error(
+      "Errore durante la creazione e l'archiviazione del pair crittografato:",
+      error
+    );
+  }
+};
+
+Gun.chain.getAndDecryptPair = async function (address, signature) {
+  try {
+    const gun = this;
+    const encryptedData = await gun
+      .get("users")
+      .get(address)
+      .get("encryptedPair")
+      .then();
+    if (!encryptedData) {
+      throw new Error("Nessun dato crittografato trovato per questo indirizzo");
+    }
+
+    const decryptedPair = await SEA.decrypt(encryptedData, signature);
+
+    console.log(decryptedPair);
+    return decryptedPair;
+  } catch (error) {
+    console.error(
+      "Errore durante il recupero e la decrittazione del pair:",
+      error
+    );
+    return null;
+  }
+};
+
+Gun.chain.shine = function (chain, nodeId, data, callback) {
+  console.log("SHINE plugin called with:", { chain, nodeId, data });
+
+  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 ottenere il signer
+  const getSigner = async () => {
+    if (typeof window.ethereum !== "undefined") {
+      await window.ethereum.request({ method: "eth_requestAccounts" });
+      const provider = new ethers.BrowserProvider(window.ethereum);
+      return provider.getSigner();
+    } else {
+      throw new Error("Ethereum provider not found");
+    }
+  };
+
+  // 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;
+      }
+
+      console.log("existingData", existingData);
+
+      // Usa il contentHash memorizzato invece di ricalcolarlo
+      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) {
+    // 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;
+        }
+
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gun-eth",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "A GunDB plugin for Ethereum, and Web3",
   "main": "index.js",
   "scripts": {

package/gun-eth.js

@@ -1,270 +0,0 @@
-/* const Gun = require("gun/gun");
-const SEA = require("gun/sea");
-const ethers = require("ethers");
-const SHINE = require("./SHINE.json"); */
-
-import Gun from "gun";
-import SEA from "gun/sea";
-import { ethers } from "ethers";
-
-import SHINE from "./SHINE.json";
-
-const SHINE_ABI = SHINE.abi;
-const SHINE_OPTIMISM_SEPOLIA = SHINE.address;
-
-let SHINE_CONTRACT_ADDRESS;
-
-// Aggiungi il metodo alla catena di Gun
-Gun.chain.verifySignature = async function (message, signature) {
-  try {
-    const recoveredAddress = ethers.verifyMessage(message, signature);
-    return recoveredAddress;
-  } catch (error) {
-    console.error("Errore durante la verifica della firma:", error);
-    return null;
-  }
-};
-
-Gun.chain.generatePassword = function (signature) {
-  try {
-    // Usa SHA-256 per derivare una password dalla firma
-    const hexSignature = ethers.hexlify(signature);
-    const hash = ethers.keccak256(hexSignature);
-
-    console.log("Password generata:", hash);
-    return hash;
-  } catch (error) {
-    console.error("Errore nella generazione della password:", error);
-    return null;
-  }
-};
-
-Gun.chain.createSignature = async function (message) {
-  try {
-    // Controlla se window.ethereum è disponibile (metamask o altro provider)
-    if (typeof window.ethereum !== "undefined") {
-      await window.ethereum.request({ method: "eth_requestAccounts" });
-      const provider = new ethers.BrowserProvider(window.ethereum);
-      const signer = await provider.getSigner();
-      const signature = await signer.signMessage(message);
-      console.log("Firma creata:", signature);
-      return signature;
-    } else {
-      throw new Error("Provider Ethereum non trovato");
-    }
-  } catch (error) {
-    console.error("Errore durante la creazione della firma:", error);
-    return null;
-  }
-};
-
-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("users").get(address).put({ encryptedPair });
-    console.log("Pair crittografato e archiviato per:", address);
-  } catch (error) {
-    console.error(
-      "Errore durante la creazione e l'archiviazione del pair crittografato:",
-      error
-    );
-  }
-};
-
-Gun.chain.getAndDecryptPair = async function (address, signature) {
-  try {
-    const gun = this;
-    const encryptedData = await gun
-      .get("users")
-      .get(address)
-      .get("encryptedPair")
-      .then();
-    if (!encryptedData) {
-      throw new Error("Nessun dato crittografato trovato per questo indirizzo");
-    }
-
-    const decryptedPair = await SEA.decrypt(encryptedData, signature);
-
-    console.log(decryptedPair);
-    return decryptedPair;
-  } catch (error) {
-    console.error(
-      "Errore durante il recupero e la decrittazione del pair:",
-      error
-    );
-    return null;
-  }
-};
-
-Gun.chain.shine = function (chain, nodeId, data, callback) {
-  console.log("SHINE plugin called with:", { chain, nodeId, data });
-
-  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 ottenere il signer
-  const getSigner = async () => {
-    if (typeof window.ethereum !== "undefined") {
-      await window.ethereum.request({ method: "eth_requestAccounts" });
-      const provider = new ethers.BrowserProvider(window.ethereum);
-      return provider.getSigner();
-    } else {
-      throw new Error("Ethereum provider not found");
-    }
-  };
-
-  // 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;
-      }
-
-      console.log("existingData", existingData);
-
-      // Usa il contentHash memorizzato invece di ricalcolarlo
-      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) {
-    // 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;
-        }
-
-        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;
-};