gun-eth 1.0.1 → 1.1.0

package/SHINE.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SHINE {
+    struct DataInfo {
+        bool exists;
+        address storer;
+        bytes nodeId;
+    }
+
+    mapping(bytes32 => DataInfo) public dataHashes;
+
+    event DataHashStored(
+        bytes32 indexed dataHash,
+        address indexed storer,
+        bytes nodeId
+    );
+
+    function storeDataHash(
+        bytes32 dataHash,
+        bytes memory nodeId
+    ) public returns (bytes memory, bytes32) {
+        require(!dataHashes[dataHash].exists, "Hash already stored");
+        dataHashes[dataHash] = DataInfo(true, msg.sender, nodeId);
+        emit DataHashStored(dataHash, msg.sender, nodeId);
+        return (nodeId, dataHash);
+    }
+
+    function verifyDataHash(
+        bytes32 dataHash
+    ) public view returns (bool exists, address storer, bytes memory nodeId) {
+        DataInfo memory info = dataHashes[dataHash];
+        return (info.exists, info.storer, info.nodeId);
+    }
+
+    function batchStoreDataHashes(
+        bytes32[] memory hashes,
+        bytes[] memory nodeIds
+    ) public {
+        require(hashes.length == nodeIds.length, "Arrays length mismatch");
+        for (uint i = 0; i < hashes.length; i++) {
+            if (!dataHashes[hashes[i]].exists) {
+                dataHashes[hashes[i]] = DataInfo(true, msg.sender, nodeIds[i]);
+                emit DataHashStored(hashes[i], msg.sender, nodeIds[i]);
+            }
+        }
+    }
+}

package/index.js

@@ -86,3 +86,227 @@ Gun.chain.getAndDecryptPair = async function (address, signature) {
     return null;
   }
 };
+
+const SHINE_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "dataHash",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "storer",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "nodeId",
+        type: "bytes",
+      },
+    ],
+    name: "DataHashStored",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32[]",
+        name: "hashes",
+        type: "bytes32[]",
+      },
+      {
+        internalType: "bytes[]",
+        name: "nodeIds",
+        type: "bytes[]",
+      },
+    ],
+    name: "batchStoreDataHashes",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    name: "dataHashes",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "exists",
+        type: "bool",
+      },
+      {
+        internalType: "address",
+        name: "storer",
+        type: "address",
+      },
+      {
+        internalType: "bytes",
+        name: "nodeId",
+        type: "bytes",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataHash",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes",
+        name: "nodeId",
+        type: "bytes",
+      },
+    ],
+    name: "storeDataHash",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes",
+      },
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataHash",
+        type: "bytes32",
+      },
+    ],
+    name: "verifyDataHash",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "exists",
+        type: "bool",
+      },
+      {
+        internalType: "address",
+        name: "storer",
+        type: "address",
+      },
+      {
+        internalType: "bytes",
+        name: "nodeId",
+        type: "bytes",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+];
+
+// Indirizzo del contratto SHINE deployato
+const SHINE_OPTIMISM_SEPOLIA = "0xb78E3E846FAf57Db15FfF17d8200a7736A7EDfBF"; // Inserisci qui l'indirizzo del contratto deployato
+
+let SHINE_CONTRACT_ADDRESS;
+
+Gun.chain.shine = function (chain, data, callback) {
+  const gun = this;
+  const sea = Gun.SEA;
+
+  // select address based on chain
+  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 scrivere on-chain
+  const writeOnChain = async (hash, nodeId) => {
+    const signer = await getSigner();
+    const contract = new ethers.Contract(
+      SHINE_CONTRACT_ADDRESS,
+      SHINE_ABI,
+      signer
+    );
+    const tx = await contract.storeDataHash(hash, ethers.toUtf8Bytes(nodeId));
+    await tx.wait();
+  };
+
+  // Funzione per verificare on-chain
+  const verifyOnChain = async (hash) => {
+    const signer = await getSigner();
+    const contract = new ethers.Contract(
+      SHINE_CONTRACT_ADDRESS,
+      SHINE_ABI,
+      signer
+    );
+    return await contract.verifyDataHash(hash);
+  };
+
+  // Processo SHINE
+  gun.put(data, async (ack) => {
+    if (ack.err) {
+      if (callback) callback({ err: ack.err });
+      return;
+    }
+
+    try {
+      // Calcola l'hash del dato
+      const dataString = JSON.stringify(data);
+      const dataHash = ethers.keccak256(ethers.toUtf8Bytes(dataString));
+
+      // Ottieni l'ID del nodo corrente
+      const nodeId = gun.back("opt.pid") || "unknown";
+
+      // Scrivi on-chain
+      await writeOnChain(dataHash, nodeId);
+
+      // Verifica GunDB e chain
+      const gunData = await gun.get(ack.get).then();
+      const [exists, storer, storedNodeId] = await verifyOnChain(dataHash);
+
+      if (JSON.stringify(gunData) === dataString && exists) {
+        if (callback)
+          callback({
+            ok: true,
+            message: "Data verified on GunDB and blockchain",
+            storer: storer,
+            nodeId: ethers.toUtf8String(storedNodeId),
+          });
+      } else {
+        if (callback) callback({ err: "Data verification failed" });
+      }
+    } catch (error) {
+      if (callback) callback({ err: error.message });
+    }
+  });
+
+  return gun;
+};

package/package.json

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