gun-eth 1.4.22 → 1.4.23

package/dist/gun-eth.js

@@ -1,1382 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('gun'), require('gun/sea.js'), require('ethers')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'gun', 'gun/sea.js', 'ethers'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.GunEth = {}, global.Gun, global.SEA, global.ethers));
-})(this, (function (exports, Gun, SEA, ethers) { 'use strict';
-
-  var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-  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$1 = {
-    PROOF_OF_INTEGRITY_ADDRESS: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
-    STEALTH_ANNOUNCER_ADDRESS: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
-  };
-
-  if (typeof window === 'undefined') {
-    const { fileURLToPath } = require('url');
-    const { dirname } = require('path');
-    const { readFileSync } = require('fs');
-    const { join } = require('path');
-
-    try {
-      const __filename = fileURLToPath((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('gun-eth.js', document.baseURI).href)));
-      const __dirname = dirname(__filename);
-      const rawdata = readFileSync(join(__dirname, 'contract-address.json'), 'utf8');
-      contractAddresses$1 = JSON.parse(rawdata);
-      console.log("Loaded contract addresses:", contractAddresses$1);
-    } catch (error) {
-      console.warn("Warning: contract-address.json not found or invalid");
-    }
-  }
-
-  const LOCAL_CONFIG = {
-    CHAIN_ID: 1337,
-    PROOF_OF_INTEGRITY_ADDRESS: contractAddresses$1.PROOF_OF_INTEGRITY_ADDRESS,
-    STEALTH_ANNOUNCER_ADDRESS: contractAddresses$1.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: "",
-      PROOF_OF_INTEGRITY_ADDRESS: "",
-      RPC_URL: "https://sepolia.optimism.io",
-      CHAIN_ID: 11155420
-    },
-    arbitrumSepolia: {
-      STEALTH_ANNOUNCER_ADDRESS: "",
-      PROOF_OF_INTEGRITY_ADDRESS: "",
-      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"
-    }
-  ];
-
-  // Ottieni gli indirizzi corretti per la chain
-  const chainConfig = getAddressesForChain('optimismSepolia'); // o la chain desiderata
-  const STEALTH_ANNOUNCER_ADDRESS = chainConfig.STEALTH_ANNOUNCER_ADDRESS;
-  chainConfig.PROOF_OF_INTEGRITY_ADDRESS;
-
-  let PROOF_CONTRACT_ADDRESS;
-  let rpcUrl = "";
-  let privateKey = "";
-
-  const MESSAGE_TO_SIGN = "Access GunDB with Ethereum";
-
-  let contractAddresses = {
-    PROOF_OF_INTEGRITY_ADDRESS: null,
-    STEALTH_ANNOUNCER_ADDRESS: STEALTH_ANNOUNCER_ADDRESS
-  };
-
-  // Solo per Node.js
-  if (typeof window === 'undefined') {
-    const { fileURLToPath } = require('url');
-    const { dirname } = require('path');
-    const { readFileSync } = require('fs');
-    const path = require('path');
-    
-    const __filename = fileURLToPath((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('gun-eth.js', document.baseURI).href)));
-    const __dirname = dirname(__filename);
-
-    try {
-      const rawdata = readFileSync(path.join(__dirname, 'contract-address.json'), 'utf8');
-      contractAddresses = JSON.parse(rawdata);
-      console.log('Loaded contract addresses:', contractAddresses);
-    } catch (err) {
-      console.warn('Warning: contract-address.json not found or invalid');
-    }
-  }
-
-  // =============================================
-  // UTILITY FUNCTIONS
-  // =============================================
-  /**
-   * Generates a random node ID for GunDB
-   * @returns {string} A random hexadecimal string
-   */
-  function generateRandomId() {
-    return ethers.ethers.hexlify(ethers.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.ethers.hexlify(signature);
-      const hash = ethers.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.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.ethers.JsonRpcProvider(rpcUrl, {
-        chainId: LOCAL_CONFIG.CHAIN_ID,
-        name: "localhost"
-      });
-      return new ethers.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.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.ethers.keccak256(
-        ethers.ethers.concat([
-          sharedSecretBytes,
-          ethers.ethers.getBytes(spendingPublicKey)
-        ])
-      );
-      
-      // Create stealth wallet
-      const stealthWallet = new ethers.ethers.Wallet(stealthPrivateKey);
-
-      console.log("Debug deriveStealthAddress:", {
-        sharedSecretHex: ethers.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.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 {
-      // Se siamo in localhost e in development, usa automaticamente la chain locale
-      const targetChain = isLocalEnvironment() ? 'localhost' : chain;
-      const chainConfig = getAddressesForChain(targetChain);
-      
-      console.log(`Using ${targetChain} configuration:`, chainConfig);
-
-      // Usa gli indirizzi dalla configurazione
-      const contract = new ethers.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.ethers.Contract(
-          PROOF_CONTRACT_ADDRESS,
-          PROOF_OF_INTEGRITY_ABI,
-          signer
-        );
-        const [isValid, timestamp, updater] = await contract.verifyData(
-          ethers.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.ethers.Contract(
-          PROOF_CONTRACT_ADDRESS,
-          PROOF_OF_INTEGRITY_ABI,
-          signer
-        );
-        const tx = await contract.updateData(
-          ethers.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.ethers.Contract(
-          PROOF_CONTRACT_ADDRESS,
-          PROOF_OF_INTEGRITY_ABI,
-          signer
-        );
-        const [contentHash, timestamp, updater] = await contract.getLatestRecord(
-          ethers.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.ethers.keccak256(ethers.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) {
-        // On-chain announcement
-        const signer = await getSigner();
-        const chainAddresses = getAddressesForChain(options.chain);
-        const contractAddress = chainAddresses.STEALTH_ANNOUNCER_ADDRESS;
-
-        console.log("Using contract address:", contractAddress);
-
-        const contract = new ethers.ethers.Contract(
-          contractAddress,
-          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.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;
-  }
-
-  exports.default = Gun;
-  exports.GunEth = GunEth;
-  exports.MESSAGE_TO_SIGN = MESSAGE_TO_SIGN;
-  exports.deriveStealthAddress = deriveStealthAddress;
-  exports.generatePassword = generatePassword;
-  exports.generateRandomId = generateRandomId;
-  exports.getSigner = getSigner;
-  exports.gunToEthAccount = gunToEthAccount;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=gun-eth.js.map