gun-eth 1.2.14 → 1.3.0

package/README.md

@@ -5,18 +5,19 @@
 
 ## Table of Contents
 
-1. [Description](#description)
-2. [Smart Contract](#smart-contract)
-3. [Key Features](#key-features)
-4. [How to Install](#how-to-install)
-5. [How to Use](#how-to-use)
-6. [Core Functions](#core-functions)
-7. [SHINE](#shine)
-8. [Standalone Mode](#standalone-mode)
-9. [Security Considerations](#security-considerations)
-10. [Contributing](#contributing)
-11. [License](#license)
-12. [Contact](#contact)
+1. [DESCRIPTION](#description)
+2. [SMART CONTRACT](#smart-contract)
+3. [KEY FEATURES](#key-features)
+4. [HOW TO INSTALL](#how-to-install)
+5. [HOW TO USE](#how-to-use)
+6. [HOW IT WORKS](#how-it-works)  
+7. [CORE FUNCTIONS](#core-functions)
+8. [SHINE](#shine)
+9. [STANDALONE MODE](#standalone-mode)
+10. [SECURITY CONSIDERATIONS](#security-considerations)
+11. [CONTRIBUTING](#contributing)
+12. [LICENSE](#license)
+13. [CONTACT](#contact)
 
 ## DESCRIPTION
 
@@ -60,6 +61,19 @@ 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).
 
+
+## HOW IT WORKS
+
+### Create KeyPair
+
+
+[![](https://mermaid.ink/img/pako:eNpdUUtuwjAQvcrIGzZwgSwqJSRQhEorwqZNWLjxkFgkduSPEAJu1Fv0Yp0khaj1wh6P3s_jCyu0QBawQ61PRcWNg12cKxhWmK2T97dwtYVlskm24W71utnDbPYE0SWVpUIDJdLOHQIHSx3uvEE4SVdBJS2ceF2juz0Eo458Tb-_rjDPlnfqGs8tl2agpUm4f-DnvVmcJaow59aBq_6hR09vpSqh9OqvQtwrJGQ2sBU9F7TqgHEEEzpm6KoJEGjiLRrbl1wIg9aOMkkvs8hSp8kLhzgo4PgbRnaKn3E0MhY945miiz2bsgZNw6WgSV86SM4oTIM5C6gU3Bxz1rfVjbDcO52eVcECZzxOmdG-rFhw4LWlm28FDS2WvDS8eXRRSIr2Mnxm_6dT1nL1ofUdc_sBNpWchQ?type=png)](https://mermaid.live/edit#pako:eNpdUUtuwjAQvcrIGzZwgSwqJSRQhEorwqZNWLjxkFgkduSPEAJu1Fv0Yp0khaj1wh6P3s_jCyu0QBawQ61PRcWNg12cKxhWmK2T97dwtYVlskm24W71utnDbPYE0SWVpUIDJdLOHQIHSx3uvEE4SVdBJS2ceF2juz0Eo458Tb-_rjDPlnfqGs8tl2agpUm4f-DnvVmcJaow59aBq_6hR09vpSqh9OqvQtwrJGQ2sBU9F7TqgHEEEzpm6KoJEGjiLRrbl1wIg9aOMkkvs8hSp8kLhzgo4PgbRnaKn3E0MhY945miiz2bsgZNw6WgSV86SM4oTIM5C6gU3Bxz1rfVjbDcO52eVcECZzxOmdG-rFhw4LWlm28FDS2WvDS8eXRRSIr2Mnxm_6dT1nL1ofUdc_sBNpWchQ)
+
+### Retrive KeyPair
+----
+
+[![](https://mermaid.ink/img/pako:eNplUsluwjAQ_ZWRz_ADObQCEiggOLAc2iQHN56ABbGjsU2FAv_erBBBLs7Yb5lnT8ESLZB5LD3rv-TIycLOjxSU3yjc7kabnQcbtCTxgrDEa84lxTAcfsC42BskyElfpEADXAhCU65KgJEHxa0j_Lw3WuOKcvtGc4NJ-NBDldA1tyjg1ChDSjqDmVP-OG6Ik9rLL4J3qHZKdPr-Uz8IfayxD6QzUh26RnvNtRZBbTEtWprUCoxLkjJL6s6dwfRpMKsCOFIg8KWnuI9d6xt8dVAk0uTBXvHfM4LVHTfut18x5i-M9spBadskjvsXWjEWL4yVNHXe7j00vSWe1YmXYbD2nw7Uvkrn8NWAmmLeLxZNwQYsQ8q4FOX4FNVRxOwRM4yYV_4KTqeI1dvqXmK5s3p7VQnzLDkcMNLucGReys-mrFwuuEVf8gPx7LGLQlpNq2ZC60EdsJyrH607zP0f6c7pXw?type=png)](https://mermaid.live/edit#pako:eNplUsluwjAQ_ZWRz_ADObQCEiggOLAc2iQHN56ABbGjsU2FAv_erBBBLs7Yb5lnT8ESLZB5LD3rv-TIycLOjxSU3yjc7kabnQcbtCTxgrDEa84lxTAcfsC42BskyElfpEADXAhCU65KgJEHxa0j_Lw3WuOKcvtGc4NJ-NBDldA1tyjg1ChDSjqDmVP-OG6Ik9rLL4J3qHZKdPr-Uz8IfayxD6QzUh26RnvNtRZBbTEtWprUCoxLkjJL6s6dwfRpMKsCOFIg8KWnuI9d6xt8dVAk0uTBXvHfM4LVHTfut18x5i-M9spBadskjvsXWjEWL4yVNHXe7j00vSWe1YmXYbD2nw7Uvkrn8NWAmmLeLxZNwQYsQ8q4FOX4FNVRxOwRM4yYV_4KTqeI1dvqXmK5s3p7VQnzLDkcMNLucGReys-mrFwuuEVf8gPx7LGLQlpNq2ZC60EdsJyrH607zP0f6c7pXw)
+
 ## CORE FUNCTIONS
 
 - `verifySignature(message, signature)`: Verifies an Ethereum signature for a given message.
@@ -114,6 +128,11 @@ Learn more about plugin implementation [here](https://github.com/amark/gun/wiki/
 
 SHINE (Secure Hash Integrity Network Ethereum) provides a mechanism for verifying data integrity using Ethereum and Gun.js.
 
+
+[![](https://mermaid.ink/img/pako:eNplk1GTmjAQx79KJs_oICAiD9epQoX25Dq1006LPqRkPTMHiRODdx763S8Ez7N3PCXZ__73txvS4EJQwCFel-Kx2BCp0M9oyZH-PucL1e4XSZrF6BdItmYFUUzwFer1btCkSfm2ViHi2iGln05d2qQNHv_A7oim-Q9QksEeECWKoLUUFZrVPJqsOu3UGEVNZKKi5heX6M0lzuMnJUmhUCG4Aq4SstusrmWZOKIvecxpiIwTF6pzO6tiU2aWmx4OHYvgPd0u42fJzEiSjmRPSkYvilek5A0pzWegUEkU7BSSUAhJu-b-laJ4uPZNLoBf3wHuzUDhlTE1AN-uRO8E19Nt_W41AwepGRCHx_MlnLW3xmyeTyW08Y9zmxtBpm9YSECM_3crmQne5b8l08mCf-zqzii-d7CZrm5GumvN6ApbuAJZEUb1b9W0CUusNlDBEod6SYl8WGJzzE9aS2olFgde4FDJGiwsRX2_weGalDu9q7faGiJG7iWpLqdbwnHY4Ccc9pxxf-wEA9exPc92A384tPABh8NB33WDwdCxfcfxAy84WfhZCG0x6HuuZ49HI98PRjpojywMlGn2efcSzIMwNf6ahBbr9AJRuPoz?type=png)](https://mermaid.live/edit#pako:eNplk1GTmjAQx79KJs_oICAiD9epQoX25Dq1006LPqRkPTMHiRODdx763S8Ez7N3PCXZ__73txvS4EJQwCFel-Kx2BCp0M9oyZH-PucL1e4XSZrF6BdItmYFUUzwFer1btCkSfm2ViHi2iGln05d2qQNHv_A7oim-Q9QksEeECWKoLUUFZrVPJqsOu3UGEVNZKKi5heX6M0lzuMnJUmhUCG4Aq4SstusrmWZOKIvecxpiIwTF6pzO6tiU2aWmx4OHYvgPd0u42fJzEiSjmRPSkYvilek5A0pzWegUEkU7BSSUAhJu-b-laJ4uPZNLoBf3wHuzUDhlTE1AN-uRO8E19Nt_W41AwepGRCHx_MlnLW3xmyeTyW08Y9zmxtBpm9YSECM_3crmQne5b8l08mCf-zqzii-d7CZrm5GumvN6ApbuAJZEUb1b9W0CUusNlDBEod6SYl8WGJzzE9aS2olFgde4FDJGiwsRX2_weGalDu9q7faGiJG7iWpLqdbwnHY4Ccc9pxxf-wEA9exPc92A384tPABh8NB33WDwdCxfcfxAy84WfhZCG0x6HuuZ49HI98PRjpojywMlGn2efcSzIMwNf6ahBbr9AJRuPoz)
+
+
+
 #### SHINE Contract Configuration
 
 Currently, SHINE supports only the Optimism Sepolia network. The contract address is managed internally:

package/package.json

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

package/src/examples/eth2gun.html

@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>💎 Ethereum to 🔫 Gun Key Pair Demo</title>
+    <!-- Include Gun -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/gun.js"></script>
+    <!-- Include SEA (part of Gun) -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/sea.js"></script>
+    <!-- Include Ethers.js -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/ethers/6.7.0/ethers.umd.min.js"></script>
+    <!-- Include the Gun-Eth plugin -->
+    <script src="../gun-eth.js"></script>
+    <style>
+        body {
+          font-family: Arial, sans-serif;
+          margin: 0;
+          padding: 20px;
+          background-color: #f0f0f0;
+        }
+        .container {
+          max-width: 400px;
+          background-color: white;
+          border: 1px solid #000;
+          padding: 10px;
+        }
+        h1,
+        h2 {
+          margin: 0 0 10px 0;
+          font-size: 16px;
+        }
+        form, div {
+          margin-bottom: 15px;
+        }
+        input,
+        button {
+          display: inline-block;
+          margin: 2px 0;
+          padding: 2px;
+          font-size: 12px;
+        }
+        input {
+          width: 150px;
+        }
+        button {
+          width: 100px;
+        }
+        label {
+          display: inline-block;
+          width: 70px;
+          font-size: 12px;
+        }
+        #configStatus,
+        .result {
+          font-weight: bold;
+          margin-bottom: 10px;
+        }
+        .result {
+          color: blue;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>💎 Ethereum to 🔫 Gun Key Pair Demo</h1>
+        
+        <form id="configForm">
+            <h2>🔧 Configuration</h2>
+            <label for="rpcUrl">🌐 RPC URL:</label>
+            <br>
+            <input type="text" id="rpcUrl" name="rpcUrl" required>
+            <br>
+            <label for="privateKey">🔑 Private Key:</label>
+            <br>
+            <input type="password" id="privateKey" name="privateKey" required>
+            <br>
+            <button type="submit">⚙️ Configure</button>
+        </form>
+
+        <div id="createPairSection">
+            <h2>🔒 Create and Store Encrypted Pair</h2>
+            <button id="createPairBtn">🔐 Create Pair</button>
+        </div>
+
+        <div id="retrievePairSection">
+            <h2>🔓 Retrieve and Decrypt Pair</h2>
+            <button id="retrievePairBtn">🔎 Retrieve Pair</button>
+        </div>
+
+        <div id="resultSection">
+            <h2>📊 Result</h2>
+            <p id="resultText"></p>
+        </div>
+    </div>
+
+    <script>
+        let gun;
+        const MESSAGE_TO_SIGN = "GunDB access with Ethereum";
+
+        document.getElementById('configForm').addEventListener('submit', function(event) {
+            event.preventDefault();
+            const rpcUrl = document.getElementById('rpcUrl').value;
+            const privateKey = document.getElementById('privateKey').value;
+
+            gun = Gun();
+            gun.setStandaloneConfig(rpcUrl, privateKey);
+
+            console.log('Standalone configuration set');
+            document.getElementById('resultText').innerText = '✅ Configuration set successfully';
+        });
+
+        document.getElementById('createPairBtn').addEventListener('click', async function() {
+            if (!gun) {
+                alert('⚠️ Please configure Gun first');
+                return;
+            }
+
+            try {
+                const signature = await gun.createSignature(MESSAGE_TO_SIGN);
+                if (!signature) {
+                    throw new Error('Failed to create signature');
+                }
+
+                const signer = new ethers.Wallet(document.getElementById('privateKey').value);
+                const address = await signer.getAddress();
+
+                await gun.createAndStoreEncryptedPair(address, signature);
+                
+                document.getElementById('resultText').innerText = '✅ Encrypted pair created and stored successfully';
+            } catch (error) {
+                document.getElementById('resultText').innerText = '❌ Error: ' + error.message;
+            }
+        });
+
+        document.getElementById('retrievePairBtn').addEventListener('click', async function() {
+            if (!gun) {
+                alert('⚠️ Please configure Gun first');
+                return;
+            }
+
+            try {
+                const signature = await gun.createSignature(MESSAGE_TO_SIGN);
+                if (!signature) {
+                    throw new Error('Failed to create signature');
+                }
+
+                const signer = new ethers.Wallet(document.getElementById('privateKey').value);
+                const address = await signer.getAddress();
+
+                const pair = await gun.getAndDecryptPair(address, signature);
+                
+                document.getElementById('resultText').innerHTML = `
+                    <strong>🔑 Retrieved pair:</strong> 
+                    <br>
+                    ${JSON.stringify(pair, null, 2)}
+                `;
+            } catch (error) {
+                document.getElementById('resultText').innerText = '❌ Error: ' + error.message;
+            }
+        });
+    </script>
+</body>
+</html>

package/src/examples/gun2eth.html

@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Gun to Ethereum Address Demo</title>
+    <!-- Include Gun -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/gun.js"></script>
+    <!-- Include SEA (part of Gun) -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/sea.js"></script>
+    <!-- Include Ethers.js -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/ethers/6.7.0/ethers.umd.min.js"></script>
+    <!-- Include the Gun-Eth plugin -->
+    <script src="../gun-eth.js"></script>
+    <style>
+        body {
+          font-family: Arial, sans-serif;
+          margin: 0;
+          padding: 20px;
+          background-color: #f0f0f0;
+        }
+        .container {
+          max-width: 400px;
+          background-color: white;
+          border: 1px solid #000;
+          padding: 10px;
+        }
+        h1,
+        h2 {
+          margin: 0 0 10px 0;
+          font-size: 16px;
+        }
+        form {
+          margin-bottom: 15px;
+        }
+        input,
+        button {
+          display: inline-block;
+          margin: 2px 0;
+          padding: 2px;
+          font-size: 12px;
+        }
+        input {
+          width: 150px;
+        }
+        button {
+          width: 100px;
+        }
+        label {
+          display: inline-block;
+          width: 70px;
+          font-size: 12px;
+        }
+        #configStatus,
+        .result {
+          font-weight: bold;
+          margin-bottom: 10px;
+        }
+        .result {
+          color: blue;
+        }
+        .disclaimer {
+          background-color: #ffffd0;
+          border: 1px solid #e6e600;
+          padding: 10px;
+          margin-bottom: 15px;
+          font-size: 14px;
+        }
+      </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🔫 Gun to 💎 Ethereum Address Demo</h1>
+        
+        <form id="gunUserForm">
+            <h2>👤 User Login/Registration</h2>
+            <label for="gunAlias">👤 Alias:</label>
+            <br>
+            <input type="text" id="gunAlias" name="gunAlias" required>
+            <br>
+            <label for="gunPassword">🔑 Password:</label>
+            <br>
+            <input type="password" id="gunPassword" name="gunPassword" required>
+            <br>
+            <button type="submit">🚀 Create/Login</button>
+        </form>
+
+        <div id="conversionSection" style="display:none;">
+            <h2>🔄 Convert Gun User to Ethereum Address</h2>
+            <button id="convertBtn">🔄 Convert
+        </div>
+
+        <div id="resultSection">
+            <h2>Result</h2>
+            <p id="resultText"></p>
+        </div>
+    </div>
+
+    <script>
+        let gun = Gun();
+        let currentUser = null;
+
+        document.getElementById('gunUserForm').addEventListener('submit', function(event) {
+            event.preventDefault();
+            const alias = document.getElementById('gunAlias').value;
+            const password = document.getElementById('gunPassword').value;
+
+            console.log('Attempting to create or login user:', alias);
+
+            gun.user().create(alias, password, function(ack) {
+                if (ack.err) {
+                    console.log('User creation failed, trying to login:', ack.err);
+                    gun.user().auth(alias, password, function(authAck) {
+                        if (authAck.err) {
+                            document.getElementById('resultText').innerText = 'Error logging in: ' + authAck.err;
+                        } else {
+                            currentUser = gun.user();
+                            document.getElementById('resultText').innerText = 'User logged in successfully.';
+                            document.getElementById('conversionSection').style.display = 'block';
+                        }
+                    });
+                } else {
+                    console.log('User created successfully:', ack);
+                    currentUser = gun.user();
+                    document.getElementById('resultText').innerText = 'User created and logged in successfully.';
+                    document.getElementById('conversionSection').style.display = 'block';
+                }
+            });
+        });
+
+        document.getElementById('convertBtn').addEventListener('click', function() {
+            if (!currentUser) {
+                alert('Please login first');
+                return;
+            }
+
+            console.log('Current user:', currentUser);
+            console.log('User pair:', currentUser._.sea);
+
+            try {
+                const pair = currentUser._.sea;
+                if (!pair || !pair.priv) {
+                    throw new Error('Unable to retrieve Gun user private key');
+                }
+
+                const ethAccount = gun.gunToEthAccount(pair.priv);
+                
+                document.getElementById('resultText').innerHTML = `
+                    <strong>Gun User</strong> 
+                    <br>
+                    ${currentUser.is.alias}
+                    <br>
+                    <br>
+                    <strong>Ethereum Address:</strong>
+                    <br>
+                    ${ethAccount.publicKey}
+                `;
+            } catch (error) {
+                document.getElementById('resultText').innerText = 'Error: ' + error.message;
+                console.error('Conversion error:', error);
+            }
+        });
+    </script>
+</body>
+</html>

package/src/examples/shine.html

@@ -0,0 +1,256 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Demo Gun-Eth Plugin</title>
+    <!-- Include Gun -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/gun.js"></script>
+    <!-- Include SEA (part of Gun) -->
+    <script src="https://cdn.jsdelivr.net/npm/gun/sea.js"></script>
+    <!-- Include Ethers.js -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/ethers/6.7.0/ethers.umd.min.js"></script>
+    <!-- Include the Gun-Eth plugin -->
+    <script src="https://cdn.jsdelivr.net/npm/gun-eth/src/gun-eth.js""></script>
+    <style>
+      body {
+        font-family: Arial, sans-serif;
+        margin: 0;
+        padding: 20px;
+        background-color: #f0f0f0;
+      }
+      .container {
+        max-width: 400px;
+        background-color: white;
+        border: 1px solid #000;
+        padding: 10px;
+      }
+      h1,
+      h2 {
+        margin: 0 0 10px 0;
+        font-size: 16px;
+      }
+      form {
+        margin-bottom: 15px;
+      }
+      input,
+      button {
+        display: inline-block;
+        margin: 2px 0;
+        padding: 2px;
+        font-size: 12px;
+      }
+      input {
+        width: 150px;
+      }
+      button {
+        width: 70px;
+      }
+      label {
+        display: inline-block;
+        width: 70px;
+        font-size: 12px;
+      }
+      #configStatus,
+      .result {
+        font-weight: bold;
+        margin-bottom: 10px;
+      }
+      .result {
+        color: blue;
+      }
+      .disclaimer {
+        background-color: #ffffd0;
+        border: 1px solid #e6e600;
+        padding: 10px;
+        margin-bottom: 15px;
+        font-size: 14px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="disclaimer">
+        <strong>⚠️</strong> This example is available only on the
+        <strong>Optimism Sepolia</strong> chain.
+      </div>
+      <h1>💎 SHINE (Secure Hash Integriry Network Ethereum)</h1>
+      <hr />
+      <h2>🔧 Configuration</h2>
+      <form id="configForm">
+        <label for="rpcUrl">RPC URL:</label>
+        <input type="text" id="rpcUrl" name="rpcUrl" required />
+        <br />
+        <label for="privateKey">Private Key:</label>
+        <input type="password" id="privateKey" name="privateKey" required />
+        <br />
+        <button type="submit">Configure</button>
+      </form>
+      <div id="configStatus">Status: Not Configured</div>
+      <hr />
+
+      <h2>🔴 Write Data to Blockchain</h2>
+      <form id="writeForm">
+        <label for="data">Data</label>
+        <br />
+        <input type="text" id="data" name="data" required />
+        <br />
+        <button type="submit">Write</button>
+      </form>
+      <div id="writeResult" class="result"></div>
+      <hr />
+
+      <h2>🔍 Verify Data on Blockchain</h2>
+      <form id="verifyForm">
+        <label for="nodeId">Node ID</label>
+        <br />
+        <input type="text" id="nodeId" name="nodeId" required />
+        <br />
+        <button type="submit">Verify</button>
+      </form>
+      <div id="verifyResult" class="result"></div>
+      <hr />
+
+      <h2>🔄 Update Node Data in Gun</h2>
+      <form id="updateForm">
+        <label for="updateNodeId">Node ID</label>
+        <br />
+        <input type="text" id="updateNodeId" name="updateNodeId" required />
+        <br />
+        <label for="editMessage">New Data</label>
+        <br />
+        <input type="text" id="editMessage" name="editMessage" required />
+        <br />
+        <button type="submit">Update</button>
+      </form>
+      <div id="updateResult" class="result"></div>
+    </div>
+
+    <script>
+      let gun;
+      let isConfigured = false;
+
+      function updateConfigStatus() {
+        const statusElement = document.getElementById("configStatus");
+        statusElement.textContent = isConfigured
+          ? "Status: Configured"
+          : "Status: Not Configured";
+        statusElement.style.color = isConfigured ? "green" : "red";
+      }
+
+      document
+        .getElementById("configForm")
+        .addEventListener("submit", function (event) {
+          event.preventDefault();
+          const rpcUrl = document.getElementById("rpcUrl").value;
+          const privateKey = document.getElementById("privateKey").value;
+
+          // Configure Gun with the provided details
+          gun = Gun();
+          gun.setStandaloneConfig(rpcUrl, privateKey);
+
+          console.log("Standalone configuration set");
+          isConfigured = true;
+          updateConfigStatus();
+        });
+
+      document
+        .getElementById("writeForm")
+        .addEventListener("submit", function (event) {
+          event.preventDefault();
+          if (!isConfigured) {
+            document.getElementById("writeResult").textContent =
+              "Please configure Gun first.";
+            return;
+          }
+          const data = document.getElementById("data").value;
+          const resultElement = document.getElementById("writeResult");
+          resultElement.textContent = "Writing data...";
+
+          // Assicurati che `data` sia un oggetto JSON valido
+
+          gun.shine("optimismSepolia", null, data, function (result) {
+            console.log("Shine result:", result);
+            if (result.ok) {
+              resultElement.textContent =
+                "Data successfully written: " + result.nodeId;
+            } else {
+              resultElement.textContent = "Error writing data: " + result.err;
+            }
+          });
+        });
+
+      document
+        .getElementById("verifyForm")
+        .addEventListener("submit", function (event) {
+          event.preventDefault();
+          if (!isConfigured) {
+            document.getElementById("verifyResult").textContent =
+              "Please configure Gun first.";
+            return;
+          }
+          const nodeId = document.getElementById("nodeId").value;
+          const resultElement = document.getElementById("verifyResult");
+          resultElement.textContent = "Verifying data...";
+
+          gun.shine("optimismSepolia", nodeId, null, function (result) {
+            console.log("Verification result:", result);
+            if (result.ok) {
+              resultElement.textContent =
+                "Data successfully verified: " + result.message;
+            } else {
+              resultElement.textContent =
+                "Error verifying data: " + result.message;
+            }
+          });
+        });
+
+      document
+        .getElementById("updateForm")
+        .addEventListener("submit", function (event) {
+          event.preventDefault();
+          if (!isConfigured) {
+            document.getElementById("updateResult").textContent =
+              "Please configure Gun first.";
+            return;
+          }
+          const nodeId = document.getElementById("updateNodeId").value;
+          const editMessage = document.getElementById("editMessage").value;
+          const resultElement = document.getElementById("updateResult");
+          resultElement.textContent = "Updating data...";
+
+          gun.get(nodeId).once(function (existingData) {
+            // Prepara i nuovi dati
+            const newData = {
+              message: editMessage,
+              _contentHash: existingData._contentHash, // Manteniamo il contentHash precedente per il calcolo
+            };
+
+            // Calcola il nuovo contentHash
+            const dataString = JSON.stringify(editMessage);
+            const newContentHash = ethers.keccak256(
+              ethers.toUtf8Bytes(dataString)
+            );
+
+            // Aggiorna i dati con il nuovo contentHash
+            newData._contentHash = newContentHash;
+
+            // Update data in Gun
+            gun.get(nodeId).put(newData, function (ack) {
+              if (ack.err) {
+                console.error("Error updating data in Gun:", ack.err);
+                resultElement.textContent =
+                  "Error updating data in Gun: " + ack.err;
+              } else {
+                console.log("Data successfully updated in Gun:", nodeId);
+                resultElement.textContent =
+                  "Data successfully updated in Gun: " + nodeId;
+              }
+            });
+          });
+        });
+
+      // Inizializza lo stato di configurazione
+      updateConfigStatus();
+    </script>
+  </body>
+</html>

package/src/gun-eth.js

@@ -0,0 +1,566 @@
+(function (root, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(["gun", "gun/sea", "ethers"], factory);
+    } else if (typeof module === "object" && module.exports) {
+        module.exports = factory(require("gun/gun"), require("gun/sea"), require("ethers"));
+    } else {
+        factory(root.Gun, root.SEA, root.ethers);
+    }
+})(typeof self !== "undefined" ? self : this, function (Gun, SEA, ethers) {
+    console.log('Factory del plugin Gun-Eth chiamata');
+
+
+
+    // Funzione per verificare se ethers è disponibile
+    function checkEthers() {
+        if (typeof ethers === 'undefined') {
+            console.error('Ethers.js non è disponibile. Assicurati che sia caricato prima di questo script.');
+            return false;
+        }
+        console.log('Ethers version:', ethers.version);
+        return true;
+    }
+
+    // Variabili globali
+    let SHINE_ABI = [
+        {
+          "anonymous": false,
+          "inputs": [
+            {
+              "indexed": true,
+              "internalType": "bytes",
+              "name": "nodeId",
+              "type": "bytes"
+            },
+            {
+              "indexed": false,
+              "internalType": "bytes32",
+              "name": "contentHash",
+              "type": "bytes32"
+            },
+            {
+              "indexed": false,
+              "internalType": "address",
+              "name": "updater",
+              "type": "address"
+            }
+          ],
+          "name": "DataUpdated",
+          "type": "event"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes[]",
+              "name": "nodeIds",
+              "type": "bytes[]"
+            },
+            {
+              "internalType": "bytes32[]",
+              "name": "contentHashes",
+              "type": "bytes32[]"
+            }
+          ],
+          "name": "batchUpdateData",
+          "outputs": [],
+          "stateMutability": "nonpayable",
+          "type": "function"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes",
+              "name": "nodeId",
+              "type": "bytes"
+            }
+          ],
+          "name": "getLatestRecord",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint256",
+              "name": "",
+              "type": "uint256"
+            },
+            {
+              "internalType": "address",
+              "name": "",
+              "type": "address"
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes",
+              "name": "",
+              "type": "bytes"
+            }
+          ],
+          "name": "nodeData",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "contentHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint256",
+              "name": "timestamp",
+              "type": "uint256"
+            },
+            {
+              "internalType": "address",
+              "name": "updater",
+              "type": "address"
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes",
+              "name": "nodeId",
+              "type": "bytes"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "contentHash",
+              "type": "bytes32"
+            }
+          ],
+          "name": "updateData",
+          "outputs": [],
+          "stateMutability": "nonpayable",
+          "type": "function"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes",
+              "name": "nodeId",
+              "type": "bytes"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "contentHash",
+              "type": "bytes32"
+            }
+          ],
+          "name": "verifyData",
+          "outputs": [
+            {
+              "internalType": "bool",
+              "name": "",
+              "type": "bool"
+            },
+            {
+              "internalType": "uint256",
+              "name": "",
+              "type": "uint256"
+            },
+            {
+              "internalType": "address",
+              "name": "",
+              "type": "address"
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function"
+        }
+      ]
+
+    let SHINE_OPTIMISM_SEPOLIA = "0x43D838b683F772F08f321E5FA265ad3e333BE9C2";
+    let SHINE_CONTRACT_ADDRESS;
+    let customToken = "";
+    let rpcUrl = "";
+    let privateKey = "";
+
+    /**
+     * Funzione per ottenere il signer
+     * @returns {Promise<ethers.Signer>} Il signer.
+     */
+    const getSigner = async () => {
+        if (rpcUrl && privateKey) {
+            // Modalità standalone
+            const provider = new ethers.JsonRpcProvider(rpcUrl);
+            return new ethers.Wallet(privateKey, provider);
+        } else if (
+            typeof window !== "undefined" &&
+            typeof window.ethereum !== "undefined"
+        ) {
+            // Modalità browser
+            await window.ethereum.request({ method: "eth_requestAccounts" });
+            const provider = new ethers.BrowserProvider(window.ethereum);
+            return provider.getSigner();
+        } else {
+            throw new Error("No valid Ethereum provider found");
+        }
+    };
+
+    /**
+     * Sets standalone configuration for Gun.
+     * @param {string} newRpcUrl - The new RPC URL.
+     * @param {string} newPrivateKey - The new private key.
+     * @returns {Gun} The Gun instance for chaining.
+     */
+    Gun.chain.setStandaloneConfig = function (newRpcUrl, newPrivateKey) {
+        rpcUrl = newRpcUrl;
+        privateKey = newPrivateKey;
+        console.log("Standalone configuration set");
+        return this;
+    };
+
+    /**
+     * Sets a custom token for Gun operations.
+     * @param {string} token - The token to be set.
+     * @returns {Gun} The Gun instance for chaining.
+     */
+    Gun.chain.setToken = function (token) {
+        if (typeof token === "string" && token.length > 0) {
+            customToken = token;
+            console.log("Token set successfully:", token);
+        } else {
+            console.error("Invalid token. Must be a non-empty string.");
+        }
+        return this;
+    };
+
+    /**
+     * Retrieves the current custom token.
+     * @returns {string} The current custom token.
+     */
+    Gun.chain.getToken = function () {
+        return customToken;
+    };
+
+    // Add custom token to all 'put' operations
+    Gun.on("put", function (msg) {
+        const to = this.to;
+        msg.headers = {
+            token: customToken,
+        };
+        to.next(msg);
+    });
+
+    /**
+     * Verifies an Ethereum signature.
+     * @param {string} message - The original message that was signed.
+     * @param {string} signature - The signature to verify.
+     * @returns {Promise<string|null>} The recovered address or null if verification fails.
+     */
+    Gun.chain.verifySignature = async function (message, signature) {
+        try {
+            const recoveredAddress = ethers.verifyMessage(message, signature);
+            return recoveredAddress;
+        } catch (error) {
+            console.error("Error verifying signature:", error);
+            return null;
+        }
+    };
+
+    /**
+     * Generates a password from a signature.
+     * @param {string} signature - The signature to derive the password from.
+     * @returns {string|null} The generated password or null if generation fails.
+     */
+    Gun.chain.generatePassword = function (signature) {
+        try {
+            const hexSignature = ethers.hexlify(signature);
+            const hash = ethers.keccak256(hexSignature);
+            console.log("Generated password:", hash);
+            return hash;
+        } catch (error) {
+            console.error("Error generating password:", error);
+            return null;
+        }
+    };
+
+    /**
+     * Creates an Ethereum signature for a given message.
+     * @param {string} message - The message to sign.
+     * @returns {Promise<string|null>} The signature or null if signing fails.
+     */
+    Gun.chain.createSignature = async function (message) {
+        try {
+            const signer = await getSigner();
+            const signature = await signer.signMessage(message);
+            console.log("Signature created:", signature);
+            return signature;
+        } catch (error) {
+            console.error("Error creating signature:", error);
+            return null;
+        }
+    };
+
+    /**
+     * Creates and stores an encrypted key pair for a given address.
+     * @param {string} address - The Ethereum address to associate with the key pair.
+     * @param {string} signature - The signature to use for encryption.
+     * @returns {Promise<void>}
+     */
+    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("gun-eth").get("users").get(address).put({ encryptedPair });
+            console.log("Encrypted pair stored for:", address);
+        } catch (error) {
+            console.error("Error creating and storing encrypted pair:", error);
+        }
+    };
+
+    /**
+     * Retrieves and decrypts a stored key pair for a given address.
+     * @param {string} address - The Ethereum address associated with the key pair.
+     * @param {string} signature - The signature to use for decryption.
+     * @returns {Promise<Object|null>} The decrypted key pair or null if retrieval fails.
+     */
+    Gun.chain.getAndDecryptPair = async function (address, signature) {
+        try {
+            const gun = this;
+            const encryptedData = await gun
+                .get("gun-eth")
+                .get("users")
+                .get(address)
+                .get("encryptedPair")
+                .then();
+            if (!encryptedData) {
+                throw new Error("No encrypted data found for this address");
+            }
+            const decryptedPair = await SEA.decrypt(encryptedData, signature);
+            console.log(decryptedPair);
+            return decryptedPair;
+        } catch (error) {
+            console.error("Error retrieving and decrypting pair:", error);
+            return null;
+        }
+    };
+
+    /**
+     * SHINE (Secure Hybrid Information and Network Environment) functionality.
+     * @param {string} chain - The blockchain to use (e.g., "optimismSepolia").
+     * @param {string} nodeId - The ID of the node to verify or write.
+     * @param {Object} data - The data to write (if writing).
+     * @param {Function} callback - Callback function to handle the result.
+     * @returns {Gun} The Gun instance for chaining.
+     */
+    Gun.chain.shine = function (chain, nodeId, data, callback) {
+        console.log("SHINE plugin called with:", { chain, nodeId, data });
+
+        if (!checkEthers()) {
+            if (callback) callback({ err: "Ethers.js non è disponibile" });
+            return this;
+        }
+
+        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 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;
+    };
+
+    /**
+     * Converts a Gun private key to an Ethereum account.
+     * @param {string} gunPrivateKey - The Gun private key in base64url format.
+     * @returns {Object} An object containing the Ethereum account and public key.
+     */
+    Gun.chain.gunToEthAccount = function (gunPrivateKey) {
+        // Function to convert base64url to hex
+        const base64UrlToHex = (base64url) => {
+            const padding = "=".repeat((4 - (base64url.length % 4)) % 4);
+            const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+            const binary = atob(base64);
+            return Array.from(binary, (char) =>
+                char.charCodeAt(0).toString(16).padStart(2, "0")
+            ).join("");
+        };
+
+        // Convert Gun private key to hex format
+        const hexPrivateKey = "0x" + base64UrlToHex(gunPrivateKey);
+
+        // Create an Ethereum wallet from the private key
+        const wallet = new ethers.Wallet(hexPrivateKey);
+
+        // Get the public address (public key)
+        const publicKey = wallet.address;
+
+        return {
+            account: wallet,
+            publicKey: publicKey,
+        };
+    };
+
+    /**
+     * Sets SHINE configuration.
+     * @param {Object} abi - The ABI of the SHINE contract.
+     * @param {string} optimismSepoliaAddress - The contract address on Optimism Sepolia.
+     * @returns {Gun} The Gun instance for chaining.
+     */
+    Gun.chain.setShineConfig = function (abi, optimismSepoliaAddress) {
+        SHINE_ABI = abi;
+        SHINE_OPTIMISM_SEPOLIA = optimismSepoliaAddress;
+        console.log("SHINE configuration set");
+        return this;
+    };
+
+    console.log('Plugin Gun-Eth caricato con successo');
+});

package/src/index.js

@@ -340,4 +340,34 @@ Gun.chain.shine = function (chain, nodeId, data, callback) {
   return gun;
 };
 
+
+/**
+ * Converts a Gun private key to an Ethereum account.
+ * @param {string} gunPrivateKey - The Gun private key in base64url format.
+ * @returns {Object} An object containing the Ethereum account and public key.
+ */
+Gun.chain.gunToEthAccount = function(gunPrivateKey) {
+  // Function to convert base64url to hex
+  const base64UrlToHex = (base64url) => {
+    const padding = "=".repeat((4 - (base64url.length % 4)) % 4);
+    const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+    const binary = atob(base64);
+    return Array.from(binary, (char) => char.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+  };
+
+  // Convert Gun private key to hex format
+  const hexPrivateKey = "0x" + base64UrlToHex(gunPrivateKey);
+
+  // Create an Ethereum wallet from the private key
+  const wallet = new ethers.Wallet(hexPrivateKey);
+
+  // Get the public address (public key)
+  const publicKey = wallet.address;
+
+  return {
+    account: wallet,
+    publicKey: publicKey
+  };
+};
+
 module.exports = Gun;