gun-eth 1.4.23 → 1.4.24

package/dist/gun-eth.node.mjs

@@ -0,0 +1,1340 @@
+import Gun from 'gun';
+export { default } from 'gun';
+import SEA from 'gun/sea.js';
+import { ethers } from 'ethers';
+import require$$0$1 from 'url';
+import require$$1 from 'path';
+import require$$2 from 'fs';
+
+var STEALTH_ANNOUNCER_ADDRESS$1 = "";
+var PROOF_OF_INTEGRITY_ADDRESS = "";
+var require$$0 = {
+	STEALTH_ANNOUNCER_ADDRESS: STEALTH_ANNOUNCER_ADDRESS$1,
+	PROOF_OF_INTEGRITY_ADDRESS: PROOF_OF_INTEGRITY_ADDRESS
+};
+
+let contractAddresses = {
+  PROOF_OF_INTEGRITY_ADDRESS: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+  STEALTH_ANNOUNCER_ADDRESS: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+};
+
+if (typeof window === 'undefined') {
+  const { fileURLToPath } = require$$0$1;
+  const { dirname } = require$$1;
+  const { readFileSync } = require$$2;
+  const { join } = require$$1;
+
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const rawdata = readFileSync(join(__dirname, 'contract-address.json'), 'utf8');
+    contractAddresses = JSON.parse(rawdata);
+    console.log("Loaded contract addresses:", contractAddresses);
+  } catch (error) {
+    console.warn("Warning: contract-address.json not found or invalid");
+  }
+}
+
+const LOCAL_CONFIG = {
+  CHAIN_ID: 1337,
+  PROOF_OF_INTEGRITY_ADDRESS: contractAddresses.PROOF_OF_INTEGRITY_ADDRESS,
+  STEALTH_ANNOUNCER_ADDRESS: contractAddresses.STEALTH_ANNOUNCER_ADDRESS,
+  RPC_URL: "http://127.0.0.1:8545",
+  GUN_PEER: "http://localhost:8765/gun"
+};
+
+// Indirizzi di produzione per diverse chain
+const CHAIN_CONFIG = {
+  optimismSepolia: {
+    STEALTH_ANNOUNCER_ADDRESS: "0xD0F2e9DA59d2DFECFdE67CcF17300BB6093A72f8",
+    PROOF_OF_INTEGRITY_ADDRESS: "0x...",
+    RPC_URL: "https://sepolia.optimism.io",
+    CHAIN_ID: 11155420
+  },
+  arbitrumSepolia: {
+    STEALTH_ANNOUNCER_ADDRESS: "0x...",
+    PROOF_OF_INTEGRITY_ADDRESS: "0x...",
+    RPC_URL: "https://sepolia-rollup.arbitrum.io/rpc",
+    CHAIN_ID: 421614
+  },
+  localhost: {
+    RPC_URL: "http://127.0.0.1:8545",
+    CHAIN_ID: 1337
+  }
+};
+
+// Funzione per ottenere gli indirizzi corretti
+function getAddressesForChain(chainName) {
+  let config;
+
+  // Se è localhost, prova a caricare gli indirizzi locali
+  if (chainName === 'localhost') {
+    try {
+      // Carica gli indirizzi dal file generato dal deploy locale
+      const localAddresses = require$$0;
+      config = {
+        ...CHAIN_CONFIG.localhost,
+        ...localAddresses
+      };
+      console.log("Using local addresses:", config);
+      return config;
+    } catch (err) {
+      console.warn('No local addresses found');
+      throw new Error('No local addresses found. Did you run local deployment?');
+    }
+  }
+
+  // Altrimenti usa gli indirizzi di produzione
+  config = CHAIN_CONFIG[chainName];
+  if (!config) {
+    throw new Error(`Chain ${chainName} not supported. Supported chains: ${Object.keys(CHAIN_CONFIG).join(', ')}`);
+  }
+
+  return config;
+}
+
+const STEALTH_ANNOUNCER_ABI = [
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_devAddress",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "internalType": "string",
+        "name": "senderPublicKey",
+        "type": "string"
+      },
+      {
+        "internalType": "string",
+        "name": "spendingPublicKey",
+        "type": "string"
+      },
+      {
+        "internalType": "address",
+        "name": "stealthAddress",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "timestamp",
+        "type": "uint256"
+      }
+    ],
+    "name": "StealthPaymentAnnounced",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newAddress",
+        "type": "address"
+      }
+    ],
+    "name": "DevAddressUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "newFee",
+        "type": "uint256"
+      }
+    ],
+    "name": "DevFeeUpdated",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "string",
+        "name": "senderPublicKey",
+        "type": "string"
+      },
+      {
+        "internalType": "string",
+        "name": "spendingPublicKey",
+        "type": "string"
+      },
+      {
+        "internalType": "address",
+        "name": "stealthAddress",
+        "type": "address"
+      }
+    ],
+    "name": "announcePayment",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "devAddress",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "devFee",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getAnnouncementsCount",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "fromIndex",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "toIndex",
+        "type": "uint256"
+      }
+    ],
+    "name": "getAnnouncementsInRange",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "string",
+            "name": "senderPublicKey",
+            "type": "string"
+          },
+          {
+            "internalType": "string",
+            "name": "spendingPublicKey",
+            "type": "string"
+          },
+          {
+            "internalType": "address",
+            "name": "stealthAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "timestamp",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct StealthAnnouncer.StealthAnnouncement[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_newFee",
+        "type": "uint256"
+      }
+    ],
+    "name": "updateDevFee",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_newAddress",
+        "type": "address"
+      }
+    ],
+    "name": "updateDevAddress",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "withdrawStuckETH",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+];
+
+const PROOF_OF_INTEGRITY_ABI = [
+  {
+    "inputs": [
+      {
+        "internalType": "bytes[]",
+        "name": "nodeIds",
+        "type": "bytes[]"
+      },
+      {
+        "internalType": "bytes32[]",
+        "name": "contentHashes",
+        "type": "bytes32[]"
+      }
+    ],
+    "name": "batchUpdateData",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "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": "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": "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"
+  }
+];
+
+// =============================================
+// IMPORTS AND GLOBAL VARIABLES
+// =============================================
+
+let rpcUrl = "";
+let privateKey = "";
+
+const MESSAGE_TO_SIGN = "Access GunDB with Ethereum";
+
+// =============================================
+// UTILITY FUNCTIONS
+// =============================================
+/**
+ * Generates a random node ID for GunDB
+ * @returns {string} A random hexadecimal string
+ */
+function generateRandomId() {
+  return ethers.hexlify(ethers.randomBytes(32)).slice(2);
+}
+
+/**
+ * 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.
+ */
+function generatePassword(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;
+  }
+}
+
+/**
+ * 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.
+ */
+function gunToEthAccount(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,
+    privateKey: hexPrivateKey,
+  };
+}
+
+/**
+ * Gets an Ethereum signer based on current configuration
+ * @returns {Promise<ethers.Signer>} The configured signer
+ * @throws {Error} If no valid provider is found
+ */
+const getSigner = async () => {
+  if (rpcUrl && privateKey) {
+    // Standalone mode with local provider
+    const provider = new ethers.JsonRpcProvider(rpcUrl, {
+      chainId: LOCAL_CONFIG.CHAIN_ID,
+      name: "localhost"
+    });
+    return new ethers.Wallet(privateKey, provider);
+  } else if (
+    typeof window !== "undefined" &&
+    typeof window.ethereum !== "undefined"
+  ) {
+    // Browser mode
+    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");
+  }
+};
+
+/**
+ * Utility function to generate stealth address
+ * @param {string} sharedSecret - The shared secret
+ * @param {string} spendingPublicKey - The spending public key
+ * @returns {Object} The stealth address and private key
+ */
+function deriveStealthAddress(sharedSecret, spendingPublicKey) {
+  try {
+    // Convert shared secret to bytes
+    const sharedSecretBytes = Buffer.from(sharedSecret, 'base64');
+    
+    // Generate stealth private key using shared secret and spending public key
+    const stealthPrivateKey = ethers.keccak256(
+      ethers.concat([
+        sharedSecretBytes,
+        ethers.getBytes(spendingPublicKey)
+      ])
+    );
+    
+    // Create stealth wallet
+    const stealthWallet = new ethers.Wallet(stealthPrivateKey);
+
+    console.log("Debug deriveStealthAddress:", {
+      sharedSecretHex: ethers.hexlify(sharedSecretBytes),
+      spendingPublicKey,
+      stealthPrivateKey,
+      stealthAddress: stealthWallet.address
+    });
+
+    return {
+      stealthPrivateKey,
+      stealthAddress: stealthWallet.address,
+      wallet: stealthWallet
+    };
+  } catch (error) {
+    console.error("Error in deriveStealthAddress:", error);
+    throw error;
+  }
+}
+
+// =============================================
+// BASIC GUN-ETH CHAIN METHODS
+// =============================================
+
+// Set the message to sign
+Gun.chain.MESSAGE_TO_SIGN = MESSAGE_TO_SIGN;
+
+/**
+ * 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.setSigner = function (newRpcUrl, newPrivateKey) {
+  rpcUrl = newRpcUrl;
+  privateKey = newPrivateKey;
+  console.log("Standalone configuration set");
+  return this;
+};
+
+Gun.chain.getSigner = getSigner();
+
+/**
+ * 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) {
+  return generatePassword(signature);
+};
+
+/**
+ * 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 {
+    // Check if message matches MESSAGE_TO_SIGN
+    if (message !== MESSAGE_TO_SIGN) {
+      throw new Error("Invalid message, valid message is: " + MESSAGE_TO_SIGN);
+    }
+    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;
+  }
+};
+
+// =============================================
+// KEY PAIR MANAGEMENT
+// =============================================
+/**
+ * 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 v_pair = await SEA.pair();
+    const s_pair = await SEA.pair();
+    const password = generatePassword(signature);
+
+    // Save original SEA pairs
+    const encryptedPair = await SEA.encrypt(JSON.stringify(pair), password);
+    const encryptedV_pair = await SEA.encrypt(JSON.stringify(v_pair), password);
+    const encryptedS_pair = await SEA.encrypt(JSON.stringify(s_pair), password);
+
+    // Convert only to get Ethereum addresses
+    const viewingAccount = gunToEthAccount(v_pair.priv);
+    const spendingAccount = gunToEthAccount(s_pair.priv);
+
+    gun.get("gun-eth").get("users").get(address).put({
+      pair: encryptedPair,
+      v_pair: encryptedV_pair,
+      s_pair: encryptedS_pair,
+      publicKeys: {
+        viewingPublicKey: v_pair.epub, // Use SEA encryption public key
+        viewingPublicKey: v_pair.epub, // Use SEA encryption public key
+        spendingPublicKey: spendingAccount.publicKey, // Use Ethereum address
+        ethViewingAddress: viewingAccount.publicKey // Also save Ethereum address
+      }
+    });
+
+    console.log("Encrypted pairs and public keys stored for:", address);
+  } catch (error) {
+    console.error("Error creating and storing encrypted pair:", error);
+    throw 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("pair")
+      .then();
+    if (!encryptedData) {
+      throw new Error("No encrypted data found for this address");
+    }
+    const password = generatePassword(signature);
+    const decryptedPair = await SEA.decrypt(encryptedData, password);
+    console.log(decryptedPair);
+    return decryptedPair;
+  } catch (error) {
+    console.error("Error retrieving and decrypting pair:", error);
+    return null;
+  }
+};
+
+// =============================================
+// PROOF OF INTEGRITY
+// =============================================
+/**
+ * Proof of Integrity
+ * @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.proof = function (chain, nodeId, data, callback) {
+  console.log("Proof plugin called with:", { chain, nodeId, data });
+
+  if (typeof callback !== "function") {
+    console.error("Callback must be a function");
+    return this;
+  }
+
+  try {
+    // Usa getAddressesForChain per ottenere la configurazione corretta
+    const chainConfig = getAddressesForChain(chain);
+    console.log(`Using ${chain} configuration:`, chainConfig);
+
+    // Usa gli indirizzi dalla configurazione
+    const contract = new ethers.Contract(
+      chainConfig.PROOF_OF_INTEGRITY_ADDRESS,
+      PROOF_OF_INTEGRITY_ABI,
+      signer
+    );
+
+    // 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(
+        PROOF_CONTRACT_ADDRESS,
+        PROOF_OF_INTEGRITY_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(
+        PROOF_CONTRACT_ADDRESS,
+        PROOF_OF_INTEGRITY_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;
+    };
+
+    // Funzione per ottenere l'ultimo record
+    const getLatestRecord = async (nodeId) => {
+      const signer = await getSigner();
+      const contract = new ethers.Contract(
+        PROOF_CONTRACT_ADDRESS,
+        PROOF_OF_INTEGRITY_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 };
+    };
+
+    
+    if (nodeId && !data) {
+      // Case 1: User passes only node
+      gun.get(nodeId).once(async (existingData) => {
+        if (!existingData) {
+          if (callback) callback({ err: "Node not found in GunDB" });
+          return;
+        }
+
+        console.log("existingData", existingData);
+
+        // Use stored contentHash instead of recalculating
+        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) {
+      // Case 2: User passes only text (data)
+      const newNodeId = generateRandomId();
+      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;
+  } catch (error) {
+    callback({ err: error.message });
+    return this;
+  }
+};
+
+// =============================================
+// STEALTH ADDRESS CORE FUNCTIONS
+// =============================================
+/**
+ * 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) {
+  return gunToEthAccount(gunPrivateKey);
+};
+
+/**
+ * Generate a stealth key and related key pairs
+ * @param {string} recipientAddress - The recipient's Ethereum address
+ * @param {string} signature - The sender's signature to access their keys
+ * @returns {Promise<Object>} Object containing stealth addresses and keys
+ */
+Gun.chain.generateStealthAddress = async function (recipientAddress, signature) {
+  try {
+    const gun = this;
+    
+    // Get recipient's public keys
+    const recipientData = await gun
+      .get("gun-eth")
+      .get("users")
+      .get(recipientAddress)
+      .get("publicKeys")
+      .then();
+
+    if (!recipientData || !recipientData.viewingPublicKey || !recipientData.spendingPublicKey) {
+      throw new Error("Recipient's public keys not found");
+    }
+
+    // Get sender's keys
+    const senderAddress = await this.verifySignature(MESSAGE_TO_SIGN, signature);
+    const password = generatePassword(signature);
+    
+    const senderData = await gun
+      .get("gun-eth")
+      .get("users")
+      .get(senderAddress)
+      .then();
+
+    if (!senderData || !senderData.s_pair) {
+      throw new Error("Sender's keys not found");
+    }
+
+    // Decrypt sender's spending pair
+    let spendingKeyPair;
+    try {
+      const decryptedData = await SEA.decrypt(senderData.s_pair, password);
+      spendingKeyPair = typeof decryptedData === 'string' ? 
+        JSON.parse(decryptedData) : 
+        decryptedData;
+    } catch (error) {
+      console.error("Error decrypting spending pair:", error);
+      throw new Error("Unable to decrypt spending pair");
+    }
+
+    // Generate shared secret using SEA ECDH with encryption public key
+    const sharedSecret = await SEA.secret(recipientData.viewingPublicKey, spendingKeyPair);
+
+    if (!sharedSecret) {
+      throw new Error("Unable to generate shared secret");
+    }
+
+    console.log("Generate shared secret:", sharedSecret);
+
+    const { stealthAddress } = deriveStealthAddress(
+      sharedSecret,
+      recipientData.spendingPublicKey
+    );
+
+    return {
+      stealthAddress,
+      senderPublicKey: spendingKeyPair.epub, // Use encryption public key
+      spendingPublicKey: recipientData.spendingPublicKey
+    };
+
+  } catch (error) {
+    console.error("Error generating stealth address:", error);
+    throw error;
+  }
+};
+
+/**
+ * Publish public keys needed to receive stealth payments
+ * @param {string} signature - The signature to authenticate the user
+ * @returns {Promise<void>}
+ */
+Gun.chain.publishStealthKeys = async function (signature) {
+  try {
+    const gun = this;
+    const address = await this.verifySignature(MESSAGE_TO_SIGN, signature);
+    const password = generatePassword(signature);
+
+    // Get encrypted key pairs
+    const encryptedData = await gun
+      .get("gun-eth")
+      .get("users")
+      .get(address)
+      .then();
+
+    if (!encryptedData || !encryptedData.v_pair || !encryptedData.s_pair) {
+      throw new Error("Keys not found");
+    }
+
+    // Decrypt viewing and spending pairs
+    const viewingKeyPair = JSON.parse(
+      await SEA.decrypt(encryptedData.v_pair, password)
+    );
+    const spendingKeyPair = JSON.parse(
+      await SEA.decrypt(encryptedData.s_pair, password)
+    );
+
+    const viewingAccount = gunToEthAccount(viewingKeyPair.priv);
+    const spendingAccount = gunToEthAccount(spendingKeyPair.priv);
+
+    // Publish only public keys
+    gun.get("gun-eth").get("users").get(address).get("publicKeys").put({
+      viewingPublicKey: viewingAccount.publicKey,
+      spendingPublicKey: spendingAccount.publicKey,
+    });
+
+    console.log("Stealth public keys published successfully");
+  } catch (error) {
+    console.error("Error publishing stealth keys:", error);
+    throw error;
+  }
+};
+
+// =============================================
+// STEALTH PAYMENT FUNCTIONS
+// =============================================
+/**
+ * Recover funds from a stealth address
+ * @param {string} stealthAddress - The stealth address to recover funds from
+ * @param {string} senderPublicKey - The sender's public key used to generate the address
+ * @param {string} signature - The signature to decrypt private keys
+ * @returns {Promise<Object>} Object containing wallet to access funds
+ */
+Gun.chain.recoverStealthFunds = async function (
+  stealthAddress,
+  senderPublicKey,
+  signature,
+  spendingPublicKey
+) {
+  try {
+    const gun = this;
+    const password = generatePassword(signature);
+
+    // Get own key pairs
+    const myAddress = await this.verifySignature(MESSAGE_TO_SIGN, signature);
+    const encryptedData = await gun
+      .get("gun-eth")
+      .get("users")
+      .get(myAddress)
+      .then();
+
+    if (!encryptedData || !encryptedData.v_pair || !encryptedData.s_pair) {
+      throw new Error("Keys not found");
+    }
+
+    // Decrypt viewing and spending pairs
+    let viewingKeyPair;
+    try {
+      const decryptedViewingData = await SEA.decrypt(encryptedData.v_pair, password);
+      viewingKeyPair = typeof decryptedViewingData === 'string' ? 
+        JSON.parse(decryptedViewingData) : 
+        decryptedViewingData;
+    } catch (error) {
+      console.error("Error decrypting keys:", error);
+      throw new Error("Unable to decrypt keys");
+    }
+
+    // Generate shared secret using SEA ECDH
+    const sharedSecret = await SEA.secret(senderPublicKey, viewingKeyPair);
+
+    if (!sharedSecret) {
+      throw new Error("Unable to generate shared secret");
+    }
+
+    console.log("Recover shared secret:", sharedSecret);
+
+    const { wallet, stealthAddress: recoveredAddress } = deriveStealthAddress(
+      sharedSecret,
+      spendingPublicKey
+    );
+
+    // Verify address matches
+    if (recoveredAddress.toLowerCase() !== stealthAddress.toLowerCase()) {
+      console.error("Mismatch:", {
+        recovered: recoveredAddress,
+        expected: stealthAddress,
+        sharedSecret
+      });
+      throw new Error("Recovered stealth address does not match");
+    }
+
+    return {
+      wallet,
+      address: recoveredAddress,
+    };
+  } catch (error) {
+    console.error("Error recovering stealth funds:", error);
+    throw error;
+  }
+};
+
+/**
+ * Announce a stealth payment
+ * @param {string} stealthAddress - The generated stealth address
+ * @param {string} senderPublicKey - The sender's public key
+ * @param {string} spendingPublicKey - The spending public key
+ * @param {string} signature - The sender's signature
+ * @returns {Promise<void>}
+ */
+Gun.chain.announceStealthPayment = async function (
+  stealthAddress,
+  senderPublicKey,
+  spendingPublicKey,
+  signature,
+  options = { onChain: false, chain: 'optimismSepolia' }
+) {
+  try {
+    const gun = this;
+    const senderAddress = await this.verifySignature(MESSAGE_TO_SIGN, signature);
+
+    if (options.onChain) {
+      const signer = await getSigner();
+      const chainConfig = getAddressesForChain(options.chain);
+      
+      const contract = new ethers.Contract(
+        chainConfig.STEALTH_ANNOUNCER_ADDRESS,
+        STEALTH_ANNOUNCER_ABI,
+        signer
+      );
+
+      // Get dev fee from contract
+      const devFee = await contract.devFee();
+      console.log("Dev fee:", devFee.toString());
+
+      // Call contract
+      const tx = await contract.announcePayment(
+        senderPublicKey,
+        spendingPublicKey,
+        stealthAddress,
+        { value: devFee }
+      );
+      
+      console.log("Transaction sent:", tx.hash);
+      const receipt = await tx.wait();
+      console.log("Transaction confirmed:", receipt.hash);
+      
+      console.log("Stealth payment announced on-chain (dev fee paid)");
+    } else {
+      // Off-chain announcement (GunDB)
+      gun
+        .get("gun-eth")
+        .get("stealth-payments")
+        .set({
+          stealthAddress,
+          senderAddress,
+          senderPublicKey,
+          spendingPublicKey,
+          timestamp: Date.now(),
+        });
+      console.log("Stealth payment announced off-chain");
+    }
+  } catch (error) {
+    console.error("Error announcing stealth payment:", error);
+    console.error("Error details:", error.stack);
+    throw error;
+  }
+};
+
+/**
+ * Get all stealth payments for an address
+ * @param {string} signature - The signature to authenticate the user
+ * @returns {Promise<Array>} List of stealth payments
+ */
+Gun.chain.getStealthPayments = async function (signature, options = { source: 'both' }) {
+  try {
+    const payments = [];
+
+    if (options.source === 'onChain' || options.source === 'both') {
+      // Get on-chain payments
+      const signer = await getSigner();
+      const contractAddress = process.env.NODE_ENV === 'development' 
+        ? LOCAL_CONFIG.STEALTH_ANNOUNCER_ADDRESS 
+        : STEALTH_ANNOUNCER_ADDRESS;
+
+      const contract = new ethers.Contract(
+        contractAddress,
+        STEALTH_ANNOUNCER_ABI,
+        signer
+      );
+      
+      try {
+        // Get total number of announcements
+        const totalAnnouncements = await contract.getAnnouncementsCount();
+        const totalCount = Number(totalAnnouncements.toString());
+        console.log("Total on-chain announcements:", totalCount);
+        
+        if (totalCount > 0) {
+          // Get announcements in batches of 100
+          const batchSize = 100;
+          const lastIndex = totalCount - 1;
+          
+          for(let i = 0; i <= lastIndex; i += batchSize) {
+            const toIndex = Math.min(i + batchSize - 1, lastIndex);
+            const batch = await contract.getAnnouncementsInRange(i, toIndex);
+            
+            // For each announcement, try to decrypt
+            for(const announcement of batch) {
+              try {
+                // Verify announcement is valid
+                if (!announcement || !announcement.stealthAddress || 
+                    !announcement.senderPublicKey || !announcement.spendingPublicKey) {
+                  console.log("Invalid announcement:", announcement);
+                  continue;
+                }
+
+                // Try to recover funds to verify if announcement is for us
+                const recoveredWallet = await this.recoverStealthFunds(
+                  announcement.stealthAddress,
+                  announcement.senderPublicKey,
+                  signature,
+                  announcement.spendingPublicKey
+                );
+                
+                // If no errors thrown, announcement is for us
+                payments.push({
+                  stealthAddress: announcement.stealthAddress,
+                  senderPublicKey: announcement.senderPublicKey,
+                  spendingPublicKey: announcement.spendingPublicKey,
+                  timestamp: Number(announcement.timestamp),
+                  source: 'onChain',
+                  wallet: recoveredWallet
+                });
+
+              } catch (e) {
+                // Not for us, continue
+                console.log(`Announcement not for us: ${announcement.stealthAddress}`);
+                continue;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        console.error("Error retrieving on-chain announcements:", error);
+      }
+    }
+
+    if (options.source === 'offChain' || options.source === 'both') {
+      // Get off-chain payments
+      const gun = this;
+      const offChainPayments = await new Promise((resolve) => {
+        const p = [];
+        gun
+          .get("gun-eth")
+          .get("stealth-payments")
+          .get(recipientAddress)
+          .map()
+          .once((payment, id) => {
+            if (payment?.stealthAddress) {
+              p.push({ ...payment, id, source: 'offChain' });
+            }
+          });
+        setTimeout(() => resolve(p), 2000);
+      });
+      
+      payments.push(...offChainPayments);
+    }
+
+    console.log(`Found ${payments.length} stealth payments`);
+    return payments;
+  } catch (error) {
+    console.error("Error retrieving stealth payments:", error);
+    throw error;
+  }
+};
+
+/**
+ * Clean up old stealth payments
+ * @param {string} recipientAddress - The recipient's address
+ * @returns {Promise<void>}
+ */
+Gun.chain.cleanStealthPayments = async function(recipientAddress) {
+  try {
+    const gun = this;
+    const payments = await gun
+      .get("gun-eth")
+      .get("stealth-payments")
+      .get(recipientAddress)
+      .map()
+      .once()
+      .then();
+
+    // Remove empty or invalid nodes
+    if (payments) {
+      Object.keys(payments).forEach(async (key) => {
+        const payment = payments[key];
+        if (!payment || !payment.stealthAddress || !payment.senderPublicKey || !payment.spendingPublicKey) {
+          await gun
+            .get("gun-eth")
+            .get("stealth-payments")
+            .get(recipientAddress)
+            .get(key)
+            .put(null);
+        }
+      });
+    }
+  } catch (error) {
+    console.error("Error cleaning stealth payments:", error);
+  }
+};
+
+// =============================================
+// EXPORTS
+// =============================================
+
+// Crea una classe GunEth che contiene tutti i metodi e le utility
+class GunEth {
+  // Static utility methods
+  static generateRandomId = generateRandomId;
+  static generatePassword = generatePassword;
+  static gunToEthAccount = gunToEthAccount;
+  static getSigner = getSigner;
+  static deriveStealthAddress = deriveStealthAddress;
+  
+  // Chain methods
+  static chainMethods = {
+    setSigner: Gun.chain.setSigner,
+    getSigner: Gun.chain.getSigner,
+    verifySignature: Gun.chain.verifySignature,
+    generatePassword: Gun.chain.generatePassword,
+    createSignature: Gun.chain.createSignature,
+    createAndStoreEncryptedPair: Gun.chain.createAndStoreEncryptedPair,
+    getAndDecryptPair: Gun.chain.getAndDecryptPair,
+    proof: Gun.chain.proof,
+    gunToEthAccount: Gun.chain.gunToEthAccount,
+    generateStealthAddress: Gun.chain.generateStealthAddress,
+    publishStealthKeys: Gun.chain.publishStealthKeys,
+    recoverStealthFunds: Gun.chain.recoverStealthFunds,
+    announceStealthPayment: Gun.chain.announceStealthPayment,
+    getStealthPayments: Gun.chain.getStealthPayments,
+    cleanStealthPayments: Gun.chain.cleanStealthPayments
+  };
+
+  // Constants
+  static MESSAGE_TO_SIGN = MESSAGE_TO_SIGN;
+  static PROOF_CONTRACT_ADDRESS = PROOF_CONTRACT_ADDRESS;
+  static LOCAL_CONFIG = LOCAL_CONFIG;
+}
+
+export { GunEth, MESSAGE_TO_SIGN, deriveStealthAddress, generatePassword, generateRandomId, getSigner, gunToEthAccount };
+//# sourceMappingURL=gun-eth.node.mjs.map