gun-eth 1.2.1 → 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,8 +1,14 @@
-const Gun = require("gun/gun");
+/* 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 = require("./SHINE.json");
 const SHINE_ABI = SHINE.abi;
 const SHINE_OPTIMISM_SEPOLIA = SHINE.address;
 
@@ -123,6 +129,7 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
 
   // 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,
@@ -133,11 +140,13 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       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,
@@ -148,10 +157,32 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       ethers.toUtf8Bytes(nodeId),
       contentHash
     );
-    await tx.wait();
+    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
@@ -163,16 +194,22 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
 
       console.log("existingData", existingData);
 
-      const dataString = JSON.stringify(existingData);
-      console.log("dataString", dataString);
-      const contentHash = dataString;
+      // 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({
@@ -180,12 +217,14 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
               message: "Data verified on blockchain",
               timestamp,
               updater,
+              latestRecord,
             });
         } else {
           if (callback)
             callback({
               ok: false,
               message: "Data not verified on blockchain",
+              latestRecord,
             });
         }
       } catch (error) {
@@ -198,26 +237,28 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
     const dataString = JSON.stringify(data);
     const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
 
-    gun.get(newNodeId).put(data, async (ack) => {
-      console.log("ack", ack);
-      if (ack.err) {
-        if (callback) callback({ err: "Error saving data to GunDB" });
-        return;
-      }
+    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 });
-      }
-    });
+        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({

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "gun-eth",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "A GunDB plugin for Ethereum, and Web3",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "gun": "^0.2020.1239",
-    "ethers": "^6.0.0"
+    "ethers": "^6.0.0",
+    "gun": "^0.2020.1239"
   },
   "author": "scobru",
   "repository": {
@@ -16,7 +16,6 @@
     "url": "git+https://github.com/scobru/gun-eth.git"
   },
   "license": "MIT",
-  "devDependencies": {},
   "keywords": [
     "gundb",
     "web3",