npm - jaelis-node - Versions diffs - 1.2.0 → 1.3.1 - Mend

jaelis-node 1.2.0 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -1,65 +1,84 @@
-# @jaelis/node
+# jaelis-node
-Official node software for the **JAELIS Blockchain** - run a full node, validator, or bootstrap node on the JAELIS network.
+Official node software for the **JAELIS Blockchain** - the first unified multi-language smart contract platform with cross-chain settlement.
-[![npm version](https://badge.fury.io/js/@jaelis%2Fnode.svg)](https://www.npmjs.com/package/@jaelis/node)
+[![npm version](https://badge.fury.io/js/jaelis-node.svg)](https://www.npmjs.com/package/jaelis-node)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-## Features
+## What is JAELIS?
-- **Full Node** - Sync and validate the entire JAELIS blockchain
-- **Validator Node** - Participate in PoEC consensus and earn rewards
-- **Bootstrap Node** - Help with peer discovery on the network
-- **Zero Gas Fees** - LODE-based computational metering
-- **Multi-VM Support** - EVM, Solana, WASM, Bitcoin, Move, TON
-- **AI-Native** - Built-in MCP server and x402 payment protocol
-- **LevelDB Storage** - Fast, persistent blockchain storage
+JAELIS is a next-generation blockchain with a **Universal Virtual Machine** that natively executes smart contracts written in 6 different languages - all on the same chain, with direct cross-contract calls between them. No bridges. No wrapped tokens. No translation layers.
-## Installation
+**One chain. Six languages. Direct interoperability.**
-### Global Installation (Recommended)
+## Universal VM - Core Innovation
-```bash
-npm install -g @jaelis/node
-```
+The JAELIS Universal VM executes contracts from multiple ecosystems natively:
-### Local Installation
+| Language | Ecosystem | Status |
+|----------|-----------|--------|
+| **Solidity** | Ethereum, Polygon, Arbitrum, Base, etc. | Production |
+| **Rust** | Solana, NEAR, Polkadot | Production |
+| **Move** | Aptos, Sui, Movement | Production |
+| **FunC** | TON (Telegram's 900M+ users) | Production |
+| **Cairo** | StarkNet | Production |
+| **Vyper** | Ethereum (Python-like) | Production |
-```bash
-npm install @jaelis/node
-```
+### Cross-Language Contract Calls
-## Quick Start
+A Solidity contract can call a Rust contract. A Move module can interact with FunC. All native, all on-chain:
-### Start a Full Node
+```javascript
+// Solidity contract calling a Rust program
+await jaelis.crossContractCall({
+    from: solidityContract,
+    to: rustProgram,
+    method: 'process_payment',
+    args: [amount, recipient]
+});
+```
-```bash
-# Start on testnet (default)
-jaelis-node start
+## Cross-Chain Settlement (30+ Chains)
-# Start on testnet with custom ports
-jaelis-node start --rpc-port 8545 --p2p-port 30303
+JAELIS nodes run light clients for 30+ external blockchains, enabling trustless state verification:
-# Start on mainnet (when available)
-jaelis-node start --network mainnet
-```
+- **EVM Chains**: Ethereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche, Fantom
+- **Non-EVM**: Solana, Cosmos, NEAR, Polkadot, Cardano, Algorand
+- **Bitcoin L2**: Lightning, Liquid, Stacks
+- **Emerging**: Aptos, Sui, TON, StarkNet, zkSync
-### Check Node Status
+Read external chain state directly in your JAELIS contracts - no oracles needed.
-```bash
-jaelis-node status
-```
+## Features
-### View Connected Peers
+- **Universal VM** - 6 languages, one chain, direct interop
+- **Cross-Chain Settlement** - Read state from 30+ chains trustlessly
+- **Zero Gas Fees** - LODE-based computational metering (users pay $0)
+- **Multi-Chain Wallets** - Receive rewards to ANY chain address
+- **No Staking Required** - JAELIS never holds your funds
+- **AI-Native** - Built-in MCP server and x402 payment protocol
+- **ERC-5792** - Atomic batch transactions
+- **EIP-7702** - Account abstraction (EOA → Smart Account)
+- **Address Safety** - Anti-phishing and poisoning protection
+- **Real P2P** - libp2p networking (same as Ethereum 2.0, IPFS)
+- **Lifetime Node Tracking** - Your contributions are recorded forever
+## Installation
 ```bash
-jaelis-node peers
+npm install -g jaelis-node
 ```
-### Display Node Info
+## Quick Start
 ```bash
-jaelis-node info
+# Start a node (zero config - auto-connects to testnet)
+jaelis-node start
+# Start with your reward wallet (use ANY chain address!)
+jaelis-node start --reward-recipient 0xYourEthAddress
+jaelis-node start --reward-recipient 9WzDX...YourSolanaAddress
+jaelis-node start --reward-recipient bc1q...YourBitcoinAddress
 ```
 ## Commands
@@ -67,11 +86,39 @@ jaelis-node info
 | Command | Description |
 |---------|-------------|
 | `start` | Start a full JAELIS node |
-| `validator` | Run as a validator node (PoEC) |
+| `validator` | Run as a validator node (bonus rewards) |
 | `bootstrap` | Run as a bootstrap/seed node |
 | `status` | Check local node status |
 | `peers` | List connected peers |
-| `info` | Display node information |
+| `info` | Display node and network information |
+## Wallet Commands
+JAELIS supports **any chain address** for receiving rewards. No staking. No lockups. Your keys, your wallet.
+```bash
+# Set your reward wallet (accepts ANY chain format)
+jaelis-node wallet:set-recipient 0x742d35cc6634C0532925a3b844Bc454e4438f44e    # EVM
+jaelis-node wallet:set-recipient 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM  # Solana
+jaelis-node wallet:set-recipient bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh   # Bitcoin
+jaelis-node wallet:set-recipient EQDrLq-X6jKZNHAScgghh0h1iog3StK71zn8dcmrOj0n  # TON
+# List configured wallets
+jaelis-node wallet:list
+# Add additional wallets
+jaelis-node wallet:add "trading" 0x456...
+# View node identity
+jaelis-node wallet:identity
+```
+**Supported Address Formats:**
+- EVM (Ethereum, Polygon, Arbitrum, Base, Optimism, etc.)
+- Solana (base58)
+- Bitcoin (Legacy: 1..., SegWit: 3..., Native SegWit: bc1...)
+- TON (base64url)
+- Move (Aptos/Sui: 0x + 64 hex chars)
 ## Start Options
@@ -79,64 +126,114 @@ jaelis-node info
 jaelis-node start [options]
 Options:
-  -n, --network <network>   Network: testnet or mainnet (default: testnet)
-  -r, --rpc-port <port>     RPC server port (default: 8545)
-  -p, --p2p-port <port>     P2P network port (default: 30303)
-  -d, --data-dir <path>     Data directory (default: ./jaelis-data)
-  --rpc-host <host>         RPC host (default: 0.0.0.0)
-  --no-rpc                  Disable RPC server
-  --sync-mode <mode>        Sync mode: full, light, archive (default: full)
+  -n, --network <network>        Network: testnet or mainnet (default: testnet)
+  -r, --rpc-port <port>          RPC server port (default: 8545)
+  -p, --p2p-port <port>          P2P network port (default: 30303)
+  -d, --data-dir <path>          Data directory (default: ./jaelis-data)
+  --rpc-host <host>              RPC host (default: 0.0.0.0)
+  --no-rpc                       Disable RPC server
+  --sync-mode <mode>             Sync mode: full, light, archive (default: full)
+  --reward-recipient <address>   Wallet address for node rewards (ANY chain!)
 ```
+## RPC Methods
+Your node exposes standard JSON-RPC plus JAELIS-specific methods:
+### Universal VM Methods
+| Method | Description |
+|--------|-------------|
+| `jaelis_getSupportedLanguages` | Returns: `['solidity', 'rust', 'move', 'func', 'cairo', 'vyper']` |
+| `jaelis_deployContract` | Deploy contract in any supported language |
+| `jaelis_executeContract` | Execute contract method |
+| `jaelis_crossContractCall` | Call between contracts of different languages |
+### Cross-Chain Settlement Methods
+| Method | Description |
+|--------|-------------|
+| `jaelis_crossChain_getChains` | List all 30+ registered chains |
+| `jaelis_crossChain_getChainInfo` | Get chain metadata (name, RPC, block time) |
+| `jaelis_crossChain_readState` | Read settled external chain state |
+| `jaelis_crossChain_settleState` | Submit proof and settle state |
+| `jaelis_crossChain_getStateDiff` | Compare state across chains |
+| `jaelis_crossChain_getLightClientStatus` | Check light client sync status |
+### Wallet Standard Methods (ERC-5792, EIP-7702)
+| Method | Description |
+|--------|-------------|
+| `jaelis_wallet_getCapabilities` | Get wallet capabilities |
+| `jaelis_wallet_sendCalls` | Atomic batch transactions |
+| `jaelis_wallet_getCallsStatus` | Check batch status |
+| `jaelis_wallet_grantPermissions` | Grant session permissions |
+| `jaelis_validateAddressSafety` | Anti-phishing check |
+| `jaelis_checkDustAttacks` | Detect address poisoning |
+### Standard Ethereum-Compatible Methods
+| Method | Description |
+|--------|-------------|
+| `eth_blockNumber` | Get latest block number |
+| `eth_getBalance` | Get account balance |
+| `eth_sendTransaction` | Send transaction |
+| `eth_call` | Call contract (read-only) |
+| `eth_getTransactionReceipt` | Get transaction receipt |
 ## Programmatic Usage
 ```javascript
-const { JaelisNode, BootstrapNode } = require('@jaelis/node');
+const { JaelisNode, BootstrapNode } = require('jaelis-node');
-// Create and start a full node
+// Create and start a node
 const node = new JaelisNode({
     network: 'testnet',
     rpcPort: 8545,
     p2pPort: 30303,
-    dataDir: './my-node-data'
+    dataDir: './my-node-data',
+    rewardRecipient: '0xYourAddress'  // Any chain address
 });
 await node.start();
 // Get node status
 const status = node.getStatus();
-console.log(status);
+console.log('Chain ID:', status.chainId);      // 4545 (testnet) or 4547 (mainnet)
+console.log('Peers:', status.peerCount);
+console.log('Block:', status.blockNumber);
 // Listen for events
 node.on('peer:connect', (peerCount) => {
-    console.log(`Peers connected: ${peerCount}`);
+    console.log(`Connected peers: ${peerCount}`);
 });
-// Stop the node
-await node.stop();
-```
-### Bootstrap Node
-```javascript
-const { BootstrapNode } = require('@jaelis/node');
-const bootstrap = new BootstrapNode({
-    port: 30305,
-    network: 'testnet'
+node.on('block:new', (block) => {
+    console.log(`New block: ${block.number}`);
 });
-await bootstrap.start();
-console.log(`Bootstrap node running, ${bootstrap.getPeerCount()} peers`);
+// Stop the node
+await node.stop();
 ```
 ## Network Configuration
 | Network | Chain ID | RPC URL | Status |
 |---------|----------|---------|--------|
-| Testnet | 4545 | https://rpc.jaelis.io | Active |
+| Testnet | 4545 | https://rpc.jaelis.io | **Active** |
 | Mainnet | 4547 | https://mainnet.jaelis.io | Coming Soon |
+## Node Rewards
+JAELIS rewards node operators based on:
+- **Uptime** - Keep your node running
+- **Transactions Processed** - Help validate transactions
+- **Bandwidth Provided** - Serve data to the network
+- **Validator Mode** - Opt-in for bonus rewards
+**No staking required.** JAELIS never holds your funds. Use any wallet from any chain.
+```bash
+# Check your node's contribution stats
+jaelis-node status
+```
 ## System Requirements
 | Requirement | Minimum | Recommended |
@@ -151,11 +248,11 @@ console.log(`Bootstrap node running, ${bootstrap.getPeerCount()} peers`);
 ```
 jaelis-data/
-├── blockchain/       # Block and state data
-│   ├── blocks/       # Block storage (LevelDB)
-│   └── state/        # State trie (LevelDB)
+├── blockchain/       # Block and state data (LevelDB)
+├── node-registry/    # Node tracking and statistics
+├── wallet-config/    # Wallet configuration
 ├── peers/            # Peer database
-├── keys/             # Node keys (if validator)
+├── keys/             # Node identity keys
 └── logs/             # Node logs
 ```
@@ -163,38 +260,44 @@ jaelis-data/
 | Variable | Description | Default |
 |----------|-------------|---------|
-| `JAELIS_CORE_PATH` | Path to JAELIS core | Auto-detected |
-| `JAELIS_DATA_DIR` | Data directory | `./jaelis-data` |
 | `JAELIS_NETWORK` | Network (testnet/mainnet) | `testnet` |
+| `JAELIS_DATA_DIR` | Data directory | `./jaelis-data` |
 | `JAELIS_RPC_PORT` | RPC port | `8545` |
 | `JAELIS_P2P_PORT` | P2P port | `30303` |
+| `JAELIS_REWARD_ADDRESS` | Reward wallet address | - |
 ## Docker
 ```bash
-# Pull the image
-docker pull jaelis/node
 # Run a full node
 docker run -d \
   --name jaelis-node \
   -p 8545:8545 \
   -p 30303:30303 \
   -v jaelis-data:/data \
+  -e JAELIS_REWARD_ADDRESS=0xYourAddress \
   jaelis/node start --network testnet
-# Check logs
-docker logs -f jaelis-node
 ```
-## Contributing
+## Technical Highlights
+### Patent-Pending Technology
+JAELIS implements three patent-pending systems:
+1. **Universal VM Architecture** - Multi-language contract execution
+2. **Cross-Chain Light Client Protocol** - Trustless external state verification
+3. **LODE Computation Model** - Zero-fee transaction processing
-Contributions are welcome! Please see our contributing guidelines.
+### Security
+- Real libp2p P2P networking (same protocol as Ethereum 2.0, Filecoin, IPFS)
+- Automatic peer discovery and DHT routing
+- Built-in MEV protection
+- Address poisoning detection
+- No trusted setup for privacy features
 ## Links
+- SDK: [npmjs.com/package/jaelis.js](https://www.npmjs.com/package/jaelis.js)
 - Website: [jaelis.io](https://jaelis.io)
-- SDK: [npm/jaelis.js](https://www.npmjs.com/package/jaelis.js)
 - Documentation: [docs.jaelis.io](https://docs.jaelis.io)
 - GitHub: [github.com/jaelis-foundation](https://github.com/jaelis-foundation)

package/bin/jaelis-node.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.1",
+  "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"