jaelis-node 1.2.0 → 1.3.0

package/bin/jaelis-node.js

@@ -76,6 +76,7 @@ program
     .option('--rpc-host <host>', 'RPC server host', '0.0.0.0')
     .option('--no-rpc', 'Disable RPC server')
     .option('--sync-mode <mode>', 'Sync mode: full, light, archive', 'full')
+    .option('--reward-recipient <address>', 'Wallet address to receive node rewards (ANY chain format!)')
     .action(async (options) => {
         console.log(chalk.cyan(BANNER));
         console.log(chalk.green('Starting JAELIS Node...'));
@@ -94,6 +95,9 @@ program
         console.log(chalk.gray(`  P2P Port:    ${options.p2pPort}`));
         console.log(chalk.gray(`  Data Dir:    ${options.dataDir}`));
         console.log(chalk.gray(`  Sync Mode:   ${options.syncMode}`));
+        if (options.rewardRecipient) {
+            console.log(chalk.gray(`  Rewards To:  ${options.rewardRecipient}`));
+        }
         console.log();
 
         const spinner = ora('Initializing node...').start();
@@ -111,7 +115,8 @@ program
                 dataDir: options.dataDir,
                 syncMode: options.syncMode,
                 enableRpc: options.rpc,
-                bootstrapNodes: network.bootstrapNodes
+                bootstrapNodes: network.bootstrapNodes,
+                rewardRecipient: options.rewardRecipient  // Like Geth's --suggested-fee-recipient
             });
 
             spinner.text = 'Connecting to network...';
@@ -311,5 +316,201 @@ program
         console.log(chalk.cyan('Website:       https://jaelis.io'));
     });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// WALLET COMMANDS - Manage node wallet configuration
+// Like Geth's account management, but supports ANY chain address!
+// NO STAKING REQUIRED - JAELIS doesn't hold your funds!
+// ═══════════════════════════════════════════════════════════════════════════
+
+// WALLET SET-RECIPIENT - Set reward recipient address (like Geth --suggested-fee-recipient)
+program
+    .command('wallet:set-recipient <address>')
+    .description('Set the wallet address to receive node rewards (accepts ANY chain format!)')
+    .option('-d, --data-dir <path>', 'Data directory', './jaelis-data')
+    .action((address, options) => {
+        console.log(chalk.cyan('Setting reward recipient...'));
+        console.log();
+
+        try {
+            const { NodeWalletConfig, validateAddress } = require('../lib/index.js');
+
+            // Validate address format
+            const validation = validateAddress(address);
+            if (!validation.valid) {
+                console.log(chalk.red('✗ Invalid address format'));
+                console.log(chalk.gray('  Supported formats:'));
+                console.log(chalk.gray('    • EVM (Ethereum, Polygon, etc.): 0x...'));
+                console.log(chalk.gray('    • Solana: base58 address'));
+                console.log(chalk.gray('    • Bitcoin: 1..., 3..., or bc1...'));
+                console.log(chalk.gray('    • TON: base64url address'));
+                console.log(chalk.gray('    • Move (Aptos/Sui): 0x... (64 chars)'));
+                process.exit(1);
+            }
+
+            const walletConfig = new NodeWalletConfig(options.dataDir);
+            walletConfig.load();
+            const result = walletConfig.setRewardRecipient(address);
+
+            console.log(chalk.green('✓ Reward recipient set successfully!'));
+            console.log();
+            console.log(chalk.white('  Address: ') + chalk.cyan(result.originalFormat));
+            console.log(chalk.white('  Type:    ') + chalk.gray(result.typeName));
+            console.log();
+            console.log(chalk.gray('  Node rewards will be sent to this address.'));
+            console.log(chalk.gray('  NO STAKING REQUIRED - you keep your own funds!'));
+
+        } catch (error) {
+            console.log(chalk.red('✗ Failed to set recipient'));
+            console.log(chalk.gray(error.message));
+            process.exit(1);
+        }
+    });
+
+// WALLET ADD - Add an additional wallet
+program
+    .command('wallet:add <name> <address>')
+    .description('Add a wallet to this node (accepts ANY chain format!)')
+    .option('-d, --data-dir <path>', 'Data directory', './jaelis-data')
+    .option('-p, --purpose <purpose>', 'Wallet purpose (general, validator, development)', 'general')
+    .action((name, address, options) => {
+        console.log(chalk.cyan('Adding wallet...'));
+        console.log();
+
+        try {
+            const { NodeWalletConfig, validateAddress } = require('../lib/index.js');
+
+            const validation = validateAddress(address);
+            if (!validation.valid) {
+                console.log(chalk.red('✗ Invalid address format'));
+                process.exit(1);
+            }
+
+            const walletConfig = new NodeWalletConfig(options.dataDir);
+            walletConfig.load();
+            const result = walletConfig.addWallet(name, address, { purpose: options.purpose });
+
+            console.log(chalk.green('✓ Wallet added successfully!'));
+            console.log();
+            console.log(chalk.white('  Name:    ') + chalk.cyan(result.name));
+            console.log(chalk.white('  Address: ') + chalk.gray(result.originalFormat));
+            console.log(chalk.white('  Type:    ') + chalk.gray(result.typeName));
+            console.log(chalk.white('  Purpose: ') + chalk.gray(result.purpose));
+
+        } catch (error) {
+            console.log(chalk.red('✗ Failed to add wallet'));
+            console.log(chalk.gray(error.message));
+            process.exit(1);
+        }
+    });
+
+// WALLET REMOVE - Remove a wallet
+program
+    .command('wallet:remove <name-or-address>')
+    .description('Remove a wallet from this node')
+    .option('-d, --data-dir <path>', 'Data directory', './jaelis-data')
+    .action((nameOrAddress, options) => {
+        console.log(chalk.cyan('Removing wallet...'));
+        console.log();
+
+        try {
+            const { NodeWalletConfig } = require('../lib/index.js');
+
+            const walletConfig = new NodeWalletConfig(options.dataDir);
+            walletConfig.load();
+            const result = walletConfig.removeWallet(nameOrAddress);
+
+            console.log(chalk.green('✓ Wallet removed!'));
+            console.log(chalk.gray(`  Removed: ${result.name} (${result.originalFormat})`));
+
+        } catch (error) {
+            console.log(chalk.red('✗ Failed to remove wallet'));
+            console.log(chalk.gray(error.message));
+            process.exit(1);
+        }
+    });
+
+// WALLET LIST - List all wallets
+program
+    .command('wallet:list')
+    .description('List all configured wallets')
+    .option('-d, --data-dir <path>', 'Data directory', './jaelis-data')
+    .action((options) => {
+        console.log(chalk.cyan('Node Wallet Configuration'));
+        console.log();
+
+        try {
+            const { NodeWalletConfig } = require('../lib/index.js');
+
+            const walletConfig = new NodeWalletConfig(options.dataDir);
+            const config = walletConfig.listWallets();
+
+            // Show reward recipient
+            if (config.rewardRecipient) {
+                console.log(chalk.white('Reward Recipient:'));
+                console.log(chalk.green(`  ★ ${config.rewardRecipient.originalFormat}`));
+                console.log(chalk.gray(`    Type: ${config.rewardRecipient.typeName}`));
+                console.log();
+            } else {
+                console.log(chalk.yellow('⚠ No reward recipient set!'));
+                console.log(chalk.gray('  Run: jaelis-node wallet:set-recipient <your-address>'));
+                console.log();
+            }
+
+            // Show additional wallets
+            if (config.wallets && config.wallets.length > 0) {
+                console.log(chalk.white('Additional Wallets:'));
+                config.wallets.forEach((wallet, i) => {
+                    console.log(chalk.cyan(`  ${i + 1}. ${wallet.name}`));
+                    console.log(chalk.gray(`     Address: ${wallet.originalFormat}`));
+                    console.log(chalk.gray(`     Type:    ${wallet.typeName}`));
+                    console.log(chalk.gray(`     Purpose: ${wallet.purpose}`));
+                });
+            } else {
+                console.log(chalk.gray('No additional wallets configured.'));
+            }
+
+            console.log();
+            console.log(chalk.gray('Supported address formats:'));
+            console.log(chalk.gray('  • EVM (Ethereum, Polygon, Arbitrum, Base, etc.)'));
+            console.log(chalk.gray('  • Solana (base58)'));
+            console.log(chalk.gray('  • Bitcoin (Legacy & SegWit)'));
+            console.log(chalk.gray('  • TON'));
+            console.log(chalk.gray('  • Move (Aptos/Sui)'));
+
+        } catch (error) {
+            console.log(chalk.red('Failed to list wallets'));
+            console.log(chalk.gray(error.message));
+        }
+    });
+
+// WALLET IDENTITY - Show or generate node identity
+program
+    .command('wallet:identity')
+    .description('Show or generate the node identity (like Solana identity keypair)')
+    .option('-d, --data-dir <path>', 'Data directory', './jaelis-data')
+    .action((options) => {
+        console.log(chalk.cyan('Node Identity'));
+        console.log();
+
+        try {
+            const { NodeWalletConfig } = require('../lib/index.js');
+
+            const walletConfig = new NodeWalletConfig(options.dataDir);
+            walletConfig.load();
+            const identity = walletConfig.getNodeIdentity();
+
+            console.log(chalk.white('Node Identity:'));
+            console.log(chalk.green(`  Public Key: ${identity.publicKey}`));
+            console.log(chalk.gray(`  Created:    ${new Date(identity.createdAt).toISOString()}`));
+            console.log();
+            console.log(chalk.gray('This identity is used to identify your node on the network.'));
+            console.log(chalk.gray('It is NOT a wallet - use wallet:set-recipient for rewards.'));
+
+        } catch (error) {
+            console.log(chalk.red('Failed to get node identity'));
+            console.log(chalk.gray(error.message));
+        }
+    });
+
 // Parse and execute
 program.parse();

package/lib/index.js

@@ -11,8 +11,310 @@
 
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 const EventEmitter = require('events');
 
+// ═══════════════════════════════════════════════════════════════════════════
+// MULTI-CHAIN ADDRESS UTILITIES
+// Supports: EVM (0x...), Solana (base58), Bitcoin (P2PKH/bech32), etc.
+// JAELIS accepts ANY chain's address format - TRUE multi-chain!
+// ═══════════════════════════════════════════════════════════════════════════
+
+const ADDRESS_FORMATS = {
+    // EVM chains (Ethereum, Polygon, Arbitrum, etc.)
+    evm: {
+        pattern: /^0x[a-fA-F0-9]{40}$/,
+        name: 'EVM (Ethereum, Polygon, etc.)',
+        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
+    },
+    // Solana (base58)
+    solana: {
+        pattern: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/,
+        name: 'Solana',
+        example: '7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZ...'
+    },
+    // Bitcoin P2PKH (starts with 1 or 3)
+    bitcoin_legacy: {
+        pattern: /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
+        name: 'Bitcoin (Legacy)',
+        example: '1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2'
+    },
+    // Bitcoin bech32 (starts with bc1)
+    bitcoin_bech32: {
+        pattern: /^bc1[a-z0-9]{39,59}$/,
+        name: 'Bitcoin (SegWit)',
+        example: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq'
+    },
+    // TON (base64url)
+    ton: {
+        pattern: /^[A-Za-z0-9_-]{48}$/,
+        name: 'TON',
+        example: 'EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N'
+    },
+    // Aptos/Sui (hex with 0x, 64 chars)
+    move: {
+        pattern: /^0x[a-fA-F0-9]{64}$/,
+        name: 'Move (Aptos/Sui)',
+        example: '0x1234567890abcdef...'
+    },
+    // JAELIS native (same as EVM for now, but could be extended)
+    jaelis: {
+        pattern: /^0x[a-fA-F0-9]{40}$/,
+        name: 'JAELIS Native',
+        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
+    }
+};
+
+/**
+ * Detect the chain type from an address
+ */
+function detectAddressType(address) {
+    if (!address || typeof address !== 'string') {
+        return null;
+    }
+
+    // Check each format
+    for (const [type, config] of Object.entries(ADDRESS_FORMATS)) {
+        if (config.pattern.test(address)) {
+            return { type, ...config };
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Validate any chain address
+ */
+function validateAddress(address) {
+    const detected = detectAddressType(address);
+    if (!detected) {
+        return {
+            valid: false,
+            error: 'Unknown address format',
+            supportedFormats: Object.keys(ADDRESS_FORMATS)
+        };
+    }
+    return {
+        valid: true,
+        type: detected.type,
+        name: detected.name
+    };
+}
+
+/**
+ * Convert any address to canonical form for internal storage
+ * EVM addresses are lowercased, others kept as-is
+ */
+function toCanonicalAddress(address) {
+    const detected = detectAddressType(address);
+    if (!detected) {
+        throw new Error('Invalid address format');
+    }
+
+    // EVM addresses are case-insensitive, normalize to lowercase
+    if (detected.type === 'evm' || detected.type === 'jaelis') {
+        return address.toLowerCase();
+    }
+
+    // Other formats are case-sensitive
+    return address;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NODE WALLET CONFIGURATION (Like Geth --suggested-fee-recipient)
+// Stores the node operator's wallet for receiving rewards
+// NO STAKING REQUIRED - JAELIS doesn't hold your funds!
+// ═══════════════════════════════════════════════════════════════════════════
+
+class NodeWalletConfig {
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.configPath = path.join(dataDir, 'node-wallet.json');
+        this.config = null;
+    }
+
+    /**
+     * Load wallet configuration from disk
+     */
+    load() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const data = fs.readFileSync(this.configPath, 'utf8');
+                this.config = JSON.parse(data);
+                return this.config;
+            }
+        } catch (e) {
+            console.warn('[WALLET] Failed to load wallet config:', e.message);
+        }
+        return null;
+    }
+
+    /**
+     * Save wallet configuration to disk
+     */
+    save() {
+        try {
+            // Ensure directory exists
+            if (!fs.existsSync(this.dataDir)) {
+                fs.mkdirSync(this.dataDir, { recursive: true });
+            }
+            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+            return true;
+        } catch (e) {
+            console.error('[WALLET] Failed to save wallet config:', e.message);
+            return false;
+        }
+    }
+
+    /**
+     * Set the reward recipient wallet (ANY chain address!)
+     * Like Geth's --suggested-fee-recipient
+     */
+    setRewardRecipient(address) {
+        const validation = validateAddress(address);
+        if (!validation.valid) {
+            throw new Error(`Invalid address: ${validation.error}`);
+        }
+
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        this.config.rewardRecipient = {
+            address: toCanonicalAddress(address),
+            originalFormat: address,
+            type: validation.type,
+            typeName: validation.name,
+            setAt: Date.now()
+        };
+
+        this.save();
+        console.log(`[WALLET] Reward recipient set: ${address} (${validation.name})`);
+        return this.config.rewardRecipient;
+    }
+
+    /**
+     * Get the reward recipient address
+     */
+    getRewardRecipient() {
+        if (!this.config) this.load();
+        return this.config?.rewardRecipient || null;
+    }
+
+    /**
+     * Add an additional wallet (for multi-wallet nodes)
+     */
+    addWallet(name, address, options = {}) {
+        const validation = validateAddress(address);
+        if (!validation.valid) {
+            throw new Error(`Invalid address: ${validation.error}`);
+        }
+
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        if (!this.config.wallets) {
+            this.config.wallets = [];
+        }
+
+        // Check for duplicates
+        const existing = this.config.wallets.find(w =>
+            toCanonicalAddress(w.address) === toCanonicalAddress(address)
+        );
+        if (existing) {
+            throw new Error(`Wallet already exists: ${existing.name}`);
+        }
+
+        const wallet = {
+            name,
+            address: toCanonicalAddress(address),
+            originalFormat: address,
+            type: validation.type,
+            typeName: validation.name,
+            purpose: options.purpose || 'general',
+            addedAt: Date.now()
+        };
+
+        this.config.wallets.push(wallet);
+        this.save();
+        console.log(`[WALLET] Added wallet: ${name} (${validation.name})`);
+        return wallet;
+    }
+
+    /**
+     * Remove a wallet by name or address
+     */
+    removeWallet(nameOrAddress) {
+        if (!this.config?.wallets) {
+            throw new Error('No wallets configured');
+        }
+
+        const canonical = nameOrAddress.startsWith('0x') || nameOrAddress.startsWith('bc1')
+            ? toCanonicalAddress(nameOrAddress)
+            : null;
+
+        const index = this.config.wallets.findIndex(w =>
+            w.name === nameOrAddress ||
+            (canonical && toCanonicalAddress(w.address) === canonical)
+        );
+
+        if (index === -1) {
+            throw new Error(`Wallet not found: ${nameOrAddress}`);
+        }
+
+        const removed = this.config.wallets.splice(index, 1)[0];
+        this.save();
+        console.log(`[WALLET] Removed wallet: ${removed.name}`);
+        return removed;
+    }
+
+    /**
+     * List all configured wallets
+     */
+    listWallets() {
+        if (!this.config) this.load();
+        return {
+            rewardRecipient: this.config?.rewardRecipient || null,
+            wallets: this.config?.wallets || []
+        };
+    }
+
+    /**
+     * Get node identity (generates one if not exists)
+     * Like Solana's identity keypair
+     */
+    getNodeIdentity() {
+        if (!this.config) this.load();
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        if (!this.config.nodeIdentity) {
+            // Generate a node identity (not a wallet, just an ID)
+            const nodeId = crypto.randomBytes(32).toString('hex');
+            this.config.nodeIdentity = {
+                id: nodeId,
+                publicKey: '0x' + crypto.createHash('sha256').update(nodeId).digest('hex').slice(0, 40),
+                createdAt: Date.now()
+            };
+            this.save();
+            console.log(`[WALLET] Generated node identity: ${this.config.nodeIdentity.publicKey}`);
+        }
+
+        return this.config.nodeIdentity;
+    }
+
+    /**
+     * Get full configuration
+     */
+    getConfig() {
+        if (!this.config) this.load();
+        return this.config;
+    }
+}
+
 // JAELIS Network Endpoints - users connect here automatically
 const JAELIS_NETWORKS = {
     testnet: {
@@ -73,6 +375,65 @@ class JaelisNode extends EventEmitter {
         this.isRunning = false;
         this.startTime = null;
         this.peerCount = 0;
+
+        // Initialize wallet configuration (like Geth's keystore)
+        this.walletConfig = new NodeWalletConfig(this.options.dataDir);
+        this.walletConfig.load();
+
+        // Set reward recipient if provided via options (like --suggested-fee-recipient)
+        if (options.rewardRecipient) {
+            this.walletConfig.setRewardRecipient(options.rewardRecipient);
+        }
+    }
+
+    /**
+     * Get the wallet configuration manager
+     */
+    getWalletConfig() {
+        return this.walletConfig;
+    }
+
+    /**
+     * Set the reward recipient address (ANY chain format!)
+     * Like Geth's --suggested-fee-recipient
+     */
+    setRewardRecipient(address) {
+        return this.walletConfig.setRewardRecipient(address);
+    }
+
+    /**
+     * Get the reward recipient address
+     */
+    getRewardRecipient() {
+        return this.walletConfig.getRewardRecipient();
+    }
+
+    /**
+     * Add a wallet to this node
+     */
+    addWallet(name, address, options = {}) {
+        return this.walletConfig.addWallet(name, address, options);
+    }
+
+    /**
+     * Remove a wallet from this node
+     */
+    removeWallet(nameOrAddress) {
+        return this.walletConfig.removeWallet(nameOrAddress);
+    }
+
+    /**
+     * List all configured wallets
+     */
+    listWallets() {
+        return this.walletConfig.listWallets();
+    }
+
+    /**
+     * Get node identity
+     */
+    getNodeIdentity() {
+        return this.walletConfig.getNodeIdentity();
     }
 
     /**
@@ -110,6 +471,12 @@ class JaelisNode extends EventEmitter {
             this.isRunning = true;
             this.startTime = Date.now();
 
+            // Register with the JAELIS network for tracking
+            await this._registerWithNetwork();
+
+            // Start heartbeat to keep registration alive
+            this._startHeartbeat();
+
             this.emit('started', {
                 network: this.options.network,
                 chainId: this.options.chainId,
@@ -135,6 +502,9 @@ class JaelisNode extends EventEmitter {
 
         console.log('[JAELIS] Stopping node...');
 
+        // Stop heartbeat first
+        this._stopHeartbeat();
+
         // Stop RPC server
         if (this.rpcServer) {
             await this._stopRpcServer();
@@ -275,6 +645,141 @@ class JaelisNode extends EventEmitter {
         }
     }
 
+    /**
+     * Register this node with the JAELIS network for tracking
+     * Mario can see all nodes that connect! Lifetime tracking!
+     */
+    async _registerWithNetwork() {
+        try {
+            const https = require('https');
+            const http = require('http');
+
+            const identity = this.walletConfig.getNodeIdentity();
+            const rewardRecipient = this.walletConfig.getRewardRecipient();
+
+            const nodeInfo = {
+                nodeId: identity.id,
+                publicKey: identity.publicKey,
+                network: this.options.network,
+                chainId: this.options.chainId,
+                version: '1.3.0',
+                rewardAddress: rewardRecipient?.address || null,
+                rewardChainType: rewardRecipient?.type || null,
+                capabilities: ['full-node', 'rpc'],
+                p2pPort: this.options.p2pPort,
+                rpcPort: this.options.rpcPort
+            };
+
+            // Store for heartbeat
+            this._nodeInfo = nodeInfo;
+
+            const data = JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'jaelis_node_register',
+                params: [nodeInfo],
+                id: 1
+            });
+
+            const url = new URL(this.options.remoteRpc);
+            const protocol = url.protocol === 'https:' ? https : http;
+
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname || '/',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data)
+                }
+            };
+
+            await new Promise((resolve) => {
+                const req = protocol.request(options, (res) => {
+                    let body = '';
+                    res.on('data', chunk => body += chunk);
+                    res.on('end', () => {
+                        try {
+                            const result = JSON.parse(body);
+                            if (result.result?.registered) {
+                                console.log(`[JAELIS] Node registered with network (ID: ${identity.publicKey.slice(0, 12)}...)`);
+                            }
+                        } catch (e) {
+                            // Silent - registration is best-effort
+                        }
+                        resolve();
+                    });
+                });
+
+                req.on('error', () => resolve()); // Silent fail - will retry on heartbeat
+                req.write(data);
+                req.end();
+            });
+
+        } catch (error) {
+            // Registration is best-effort, don't fail node startup
+            console.log('[JAELIS] Network registration pending (will retry)');
+        }
+    }
+
+    /**
+     * Start heartbeat to keep node registration alive
+     * Sends heartbeat every 60 seconds
+     */
+    _startHeartbeat() {
+        const HEARTBEAT_INTERVAL = 60000; // 60 seconds
+
+        this._heartbeatInterval = setInterval(async () => {
+            if (!this.isRunning || !this._nodeInfo) return;
+
+            try {
+                const https = require('https');
+                const http = require('http');
+
+                const data = JSON.stringify({
+                    jsonrpc: '2.0',
+                    method: 'jaelis_node_heartbeat',
+                    params: [this._nodeInfo.nodeId],
+                    id: 1
+                });
+
+                const url = new URL(this.options.remoteRpc);
+                const protocol = url.protocol === 'https:' ? https : http;
+
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname || '/',
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(data)
+                    }
+                };
+
+                const req = protocol.request(options, () => {});
+                req.on('error', () => {}); // Silent
+                req.write(data);
+                req.end();
+
+            } catch (e) {
+                // Silent - heartbeat is best-effort
+            }
+        }, HEARTBEAT_INTERVAL);
+
+        console.log('[JAELIS] Heartbeat started (60s interval)');
+    }
+
+    /**
+     * Stop heartbeat
+     */
+    _stopHeartbeat() {
+        if (this._heartbeatInterval) {
+            clearInterval(this._heartbeatInterval);
+            this._heartbeatInterval = null;
+        }
+    }
+
     /**
      * Get node status
      */
@@ -1020,6 +1525,15 @@ module.exports = {
     EmbeddedRpcServer,
     EmbeddedStorage,
 
+    // Wallet configuration (like Geth's keystore)
+    NodeWalletConfig,
+
+    // Multi-chain address utilities
+    ADDRESS_FORMATS,
+    detectAddressType,
+    validateAddress,
+    toCanonicalAddress,
+
     // Convenience factory
     createNode: (options) => new JaelisNode(options),
     createBootstrap: (options) => new BootstrapNode(options)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jaelis-node",
-  "version": "1.2.0",
-  "description": "Official JAELIS Blockchain Node - Run a full node, validator, or bootstrap node with Cross-Chain Settlement (30+ chains!)",
+  "version": "1.3.0",
+  "description": "Official JAELIS Blockchain Node - Run a full node, validator, or bootstrap node with Cross-Chain Settlement (30+ chains!), ERC-5792 wallet capabilities, EIP-7702 account abstraction",
   "main": "lib/index.js",
   "bin": {
     "jaelis-node": "./bin/jaelis-node.js"