gun-eth 1.1.5 → 1.2.1

package/index.js

@@ -101,11 +101,6 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
     return this;
   }
 
-  if (typeof data !== "object" || data === null) {
-    callback({ err: "Data must be a non-null object" });
-    return this;
-  }
-
   const gun = this;
 
   // Seleziona l'indirizzo basato sulla catena
@@ -126,22 +121,6 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
     }
   };
 
-  // Funzione per scrivere on-chain
-  const writeOnChain = async (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
-    );
-    await tx.wait();
-    return tx;
-  };
-
   // Funzione per verificare on-chain
   const verifyOnChain = async (nodeId, contentHash) => {
     const signer = await getSigner();
@@ -154,185 +133,97 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       ethers.toUtf8Bytes(nodeId),
       contentHash
     );
-    return isValid;
+    return { isValid, timestamp, updater };
   };
 
-  // Funzione per ottenere l'ultimo record on-chain
-  const getLatestRecord = async (nodeId) => {
+  // Funzione per scrivere on-chain
+  const writeOnChain = async (nodeId, contentHash) => {
     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)
+    const tx = await contract.updateData(
+      ethers.toUtf8Bytes(nodeId),
+      contentHash
     );
-    return { contentHash, timestamp, updater };
+    await tx.wait();
+    return tx;
   };
 
   // Processo SHINE
-  gun.get(nodeId).once(async (existingData) => {
-    try {
-      const dataToVerify = existingData || data;
-      const dataString = JSON.stringify(dataToVerify);
-      const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
-
-      // Ottieni l'ultimo record on-chain
-      const latestRecord = await getLatestRecord(nodeId);
-      console.log("Ultimo record on-chain:", latestRecord);
-
-      // Verifica se il contenuto corrisponde all'ultimo record on-chain
-      if (latestRecord.contentHash === contentHash) {
-        if (callback)
-          callback({
-            ok: true,
-            message: "Data already up-to-date on blockchain",
-          });
+  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;
       }
 
-      // Verifica on-chain prima di procedere
-      const isVerified = await verifyOnChain(nodeId, contentHash);
-
-      if (isVerified) {
-        // Il dato è già verificato on-chain
-        if (callback)
-          callback({
-            ok: true,
-            message: "Data already verified on blockchain",
-          });
-      } else {
-        // Il dato non è verificato on-chain, procedi alla scrittura
-        if (!existingData) {
-          gun.get(nodeId).put(dataToVerify);
-        }
-
-        await writeOnChain(nodeId, contentHash);
+      console.log("existingData", existingData);
 
-        // Verifica dopo la scrittura
-        const verifiedAfterWrite = await verifyOnChain(nodeId, contentHash);
+      const dataString = JSON.stringify(existingData);
+      console.log("dataString", dataString);
+      const contentHash = dataString;
+      console.log("contentHash", contentHash);
 
-        if (verifiedAfterWrite) {
+      try {
+        const { isValid, timestamp, updater } = await verifyOnChain(
+          nodeId,
+          contentHash
+        );
+        if (isValid) {
           if (callback)
             callback({
               ok: true,
-              message: "Data written and verified on GunDB and blockchain",
+              message: "Data verified on blockchain",
+              timestamp,
+              updater,
             });
         } else {
           if (callback)
-            callback({ err: "Data verification failed after writing" });
+            callback({
+              ok: false,
+              message: "Data not verified on blockchain",
+            });
         }
+      } catch (error) {
+        if (callback) callback({ err: error.message });
       }
-    } catch (error) {
-      if (callback) callback({ err: error.message });
-    }
-  });
-
-  // Aggiungi questa funzione all'interno di shine
-  gun.batchShine = async function (nodeIds, dataArray) {
-    if (nodeIds.length !== dataArray.length) {
-      throw new Error(
-        "Il numero di nodeIds deve corrispondere al numero di elementi dati"
-      );
-    }
-
-    const contentHashes = [];
-    for (let i = 0; i < nodeIds.length; i++) {
-      const dataString = JSON.stringify(dataArray[i]);
-      const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
-      contentHashes.push(contentHash);
-      gun.get(nodeIds[i]).put(dataArray[i]);
-    }
-
-    try {
-      const tx = await batchWriteOnChain(nodeIds, contentHashes);
-      console.log("Batch update completato:", tx.hash);
-      return tx;
-    } catch (error) {
-      console.error("Errore durante il batch update:", error);
-      throw error;
-    }
-  };
-
-  // Aggiungi un listener per l'evento DataUpdated
-  const provider = new ethers.BrowserProvider(window.ethereum);
-  const contract = new ethers.Contract(
-    SHINE_CONTRACT_ADDRESS,
-    SHINE_ABI,
-    provider
-  );
-  contract.on("DataUpdated", (nodeId, contentHash, updater) => {
-    console.log("Evento DataUpdated ricevuto:", {
-      nodeId: ethers.toUtf8String(nodeId),
-      contentHash,
-      updater,
     });
-    // Qui puoi aggiungere la logica per gestire l'evento, ad esempio aggiornare l'interfaccia utente
-  });
-
-  // Aggiungi questa funzione all'interno di shine
-  gun.getLatestRecordFromChain = async function (nodeId) {
-    try {
-      const latestRecord = await getLatestRecord(nodeId);
-      console.log("Ultimo record on-chain per", nodeId, ":", latestRecord);
-      return latestRecord;
-    } catch (error) {
-      console.error("Errore nel recupero dell'ultimo record:", error);
-      throw error;
-    }
-  };
-
-  return gun;
-};
-
-// Aggiungi questa funzione dopo writeOnChain
-const batchWriteOnChain = async (nodeIds, contentHashes) => {
-  const signer = await getSigner();
-  const contract = new ethers.Contract(
-    SHINE_CONTRACT_ADDRESS,
-    SHINE_ABI,
-    signer
-  );
-  const tx = await contract.batchUpdateData(
-    nodeIds.map((id) => ethers.toUtf8Bytes(id)),
-    contentHashes
-  );
-  await tx.wait();
-  return tx;
-};
+  } 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));
 
-// Aggiungi questa funzione per verificare i dati batch
-Gun.chain.batchVerify = async function (nodeIds, dataArray) {
-  if (nodeIds.length !== dataArray.length) {
-    throw new Error(
-      "Il numero di nodeIds deve corrispondere al numero di elementi dati"
-    );
-  }
+    gun.get(newNodeId).put(data, async (ack) => {
+      console.log("ack", ack);
+      if (ack.err) {
+        if (callback) callback({ err: "Error saving data to GunDB" });
+        return;
+      }
 
-  const results = [];
-  for (let i = 0; i < nodeIds.length; i++) {
-    const dataString = JSON.stringify(dataArray[i]);
-    const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
-    const isVerified = await verifyOnChain(nodeIds[i], contentHash);
-    results.push({
-      nodeId: nodeIds[i],
-      isVerified: isVerified,
+      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 results;
-};
-
-// Aggiungi questa funzione per la verifica singola
-Gun.chain.verifyOnly = async function (nodeId, data) {
-  try {
-    const dataString = JSON.stringify(data);
-    const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
-    const isVerified = await verifyOnChain(nodeId, contentHash);
-    return isVerified;
-  } catch (error) {
-    console.error("Errore durante la verifica:", error);
-    return null;
-  }
+  return gun;
 };

package/package.json

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