Gun.js Blockchain Extension

// Esempio base di transazione stealth
const provider = new ethers.JsonRpcProvider("RPC_URL");
const chainId = "polygon"; // o altra chain supportata

// Crea una transazione stealth
const result = await GunEth.createStealthTransaction(
  provider,
  chainId,
  receiverViewingKey,
  receiverSpendingKey
);

console.log("Stealth Address:", result.stealthInfo.stealthAddress);
console.log("Transaction Hash:", result.transaction.hash);

// Recupera i pagamenti
const payments = await GunEth.getStealthPayments(
  provider,
  chainId,
  viewingKey
);

// Recupera i fondi
const recoveryTx = await GunEth.recoverStealthFunds(
  provider,
  chainId,
  stealthAddress,
  senderPublicKey,
  signature,
  spendingPublicKey
);

// Esempio avanzato con StealthChain
const stealthChain = new GunEth.StealthChain(provider, chainId);

// Verify chain support
const isSupported = await stealthChain.isOnSupportedChain();
if (!isSupported) {
  await stealthChain.requestChainSwitch();
}

// Generate stealth address
const stealthInfo = await stealthChain.generateStealthAddress(
  receiverViewingKey,
  receiverSpendingKey
);

// Annuncia il pagamento sulla blockchain
await stealthChain.announcePaymentOnChain(
  provider,
  chainId,
  stealthInfo.stealthAddress,
  stealthInfo.senderEphemeralKey,
  receiverViewingKey,
  receiverSpendingKey
);

// Monitora nuovi annunci
stealthChain.listenToNewAnnouncements((announcement) => {
  console.log("Nuovo annuncio:", announcement);
});

// Convert an Ethereum account to a Gun account
import { GunEth } from 'gun-eth';

// Create signature with Ethereum wallet
const signature = await GunEth.createSignature(GunEth.MESSAGE_TO_SIGN);

// Convert to Gun SEA keypair
const gunAccount = await GunEth.ethToGunAccount(signature);

// The account contains:
console.log({
  pub: gunAccount.pub,    // Gun public key
  priv: gunAccount.priv,  // Gun private key
  epub: gunAccount.epub,  // Encryption public key
  epriv: gunAccount.epriv // Encryption private key
});

// Option 1: Using existing Gun credentials
const gunUser = gun.user();
if (gunUser.is) {
  // Use existing Gun credentials
  const account = await gunToEthAccount(gunUser._.sea);
}

// Option 2: Using Ethereum signature
const gunKeyPair = await SEA.pair();
const signature = await createSignature(MESSAGE_TO_SIGN);
const account = await gunToEthAccount(gunKeyPair, signature);

// Returns
{
  pub: gunKeyPair.pub,                // Gun public key
  internalWalletAddress: string,      // Internal wallet address
  internalWalletPk: string,          // Internal wallet private key
  pair: gunKeyPair,                  // Original Gun keypair
  v_pair: SEA.pair(),                // Viewing keypair
  s_pair: SEA.pair(),                // Spending keypair
  viewingPublicKey: string,          // Viewing public key (v_pair.epub)
  spendingPublicKey: string,         // Spending public key (s_pair.epub)
  env_pair: string,                  // Encrypted original pair
  env_v_pair: string,                // Encrypted viewing pair
  env_s_pair: string                 // Encrypted spending pair
}

// Complete usage example
const signature = await createSignature(MESSAGE_TO_SIGN);
const gunAccount = await ethToGunAccount(signature);

// Save encrypted data
await gun.user(gunAccount.pub).get('myData').put({
    secret: "Data encrypted with Gun keys"
});

// Retrieve encrypted data
const data = await gun.user(gunAccount.pub).get('myData').then();

// Convert back to Ethereum if needed
const ethAccount = await gunToEthAccount(gunAccount);

// template-bubble-client.js
// Complete client implementation with:
// - Configuration management
// - File handling (text, JSON, binary)
// - Comprehensive error handling
// - Decrypted file storage

const CONFIG = {
    RPC_URL: process.env.RPC_URL,
    PRIVATE_KEY: process.env.PRIVATE_KEY,
    PROVIDER_URL: "http://localhost:3000/api",
    GUN_PEERS: ['http://localhost:8765/gun'],
    DECRYPTED_FILES_DIR: './decrypted-files'
};

// Initialize client with configuration
const client = await initializeClient();

// Example usage
const bubble = await client.createBubble("Test Bubble");
await client.writeBubble(bubble.id, "test.txt", "content");
const result = await client.readBubble(bubble.id, "test.txt");

// template-bubble-provider.js
// Complete provider implementation with:
// - Express server setup
// - GUN configuration
// - Directory management
// - Error handling
// - Optional external storage integration

const CONFIG = {
    RPC_URL: process.env.RPC_URL,
    PRIVATE_KEY: process.env.PRIVATE_KEY,
    GUN_PEERS: "http://localhost:8765/gun",
    GUN_DIR: "radata",
    BUBBLES_DIR: "bubbles"
};

// Initialize provider with configuration
const app = express();
const gun = Gun(gunOptions);
const provider = new HybridBubbleProvider(CONFIG);

// API endpoints
app.post('/bubble', handleCreateBubble);
app.post('/bubble/:id/write', handleWriteBubble);
app.get('/bubble/:id', handleReadBubble);