gun-eth 1.1.3 → 1.1.5

package/index.js

@@ -108,7 +108,7 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
 
   const gun = this;
 
-  // select address based on chain
+  // Seleziona l'indirizzo basato sulla catena
   if (chain === "optimismSepolia") {
     SHINE_CONTRACT_ADDRESS = SHINE_OPTIMISM_SEPOLIA;
   } else {
@@ -150,7 +150,11 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       SHINE_ABI,
       signer
     );
-    return await contract.verifyData(ethers.toUtf8Bytes(nodeId), contentHash);
+    const [isValid, timestamp, updater] = await contract.verifyData(
+      ethers.toUtf8Bytes(nodeId),
+      contentHash
+    );
+    return isValid;
   };
 
   // Funzione per ottenere l'ultimo record on-chain
@@ -161,7 +165,10 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       SHINE_ABI,
       signer
     );
-    return await contract.getLatestRecord(ethers.toUtf8Bytes(nodeId));
+    const [contentHash, timestamp, updater] = await contract.getLatestRecord(
+      ethers.toUtf8Bytes(nodeId)
+    );
+    return { contentHash, timestamp, updater };
   };
 
   // Processo SHINE
@@ -172,27 +179,31 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
       const contentHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
 
       // Ottieni l'ultimo record on-chain
-      const [lastContentHash, lastTimestamp, lastUpdater] =
-        await getLatestRecord(nodeId);
+      const latestRecord = await getLatestRecord(nodeId);
+      console.log("Ultimo record on-chain:", latestRecord);
 
-      if (lastContentHash !== ethers.ZeroHash) {
-        // Il dato esiste on-chain
-        if (lastContentHash === contentHash) {
-          // Il dato on-chain corrisponde al dato in GunDB
-          if (callback)
-            callback({
-              ok: true,
-              message: "Data verified on GunDB and blockchain",
-              updater: lastUpdater,
-              timestamp: lastTimestamp.toString(),
-            });
-        } else {
-          // Il dato on-chain è diverso dal dato in GunDB
-          if (callback)
-            callback({ err: "Data mismatch between GunDB and blockchain" });
-        }
+      // 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",
+          });
+        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 esiste on-chain, procedi alla scrittura
+        // Il dato non è verificato on-chain, procedi alla scrittura
         if (!existingData) {
           gun.get(nodeId).put(dataToVerify);
         }
@@ -200,16 +211,13 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
         await writeOnChain(nodeId, contentHash);
 
         // Verifica dopo la scrittura
-        const [newContentHash, newTimestamp, newUpdater] =
-          await getLatestRecord(nodeId);
+        const verifiedAfterWrite = await verifyOnChain(nodeId, contentHash);
 
-        if (newContentHash === contentHash) {
+        if (verifiedAfterWrite) {
           if (callback)
             callback({
               ok: true,
               message: "Data written and verified on GunDB and blockchain",
-              updater: newUpdater,
-              timestamp: newTimestamp.toString(),
             });
         } else {
           if (callback)
@@ -221,5 +229,110 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
     }
   });
 
+  // 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;
+};
+
+// 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"
+    );
+  }
+
+  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,
+    });
+  }
+
+  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;
+  }
+};

package/package.json

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