jaelis-node 1.9.0 → 2.0.0

package/README.md

@@ -1,520 +1,234 @@
 # jaelis-node
 
-Official node software for the **JAELIS Blockchain** - the first unified multi-language smart contract platform with cross-chain settlement.
+Official external node software for the **JAELIS Blockchain** network. Run your own node to sync with the network, contribute to decentralization, and expose a local RPC endpoint for your dApps.
 
 [![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)
 
-## What is JAELIS?
+## What is This?
 
-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.
+`jaelis-node` is a **lightweight external node** that:
 
-**One chain. Six languages. Direct interoperability.**
+- Connects to the JAELIS network via WebSocket
+- Syncs and stores blocks locally (LevelDB)
+- Exposes a local JSON-RPC server for your dApps
+- Relays transactions to the network
 
-## Universal VM - Core Innovation
+This is similar to running `geth --syncmode light` for Ethereum.
 
-JAELIS provides **TWO deployment systems** for maximum flexibility:
-
-### Option 1: Unified VM (Cross-Language Magic)
-
-Compile **MULTIPLE contracts from MULTIPLE languages** into **ONE unified bytecode bundle** with **ONE ABI**:
-
-```javascript
-// Deploy unified bundle - ALL languages compile to ONE bytecode!
-const result = await jaelis.deployUnified({
-    from: '0x...',
-    sources: [
-        { code: solidityCode, language: 'solidity', name: 'Token' },
-        { code: rustCode, language: 'rust', name: 'DeFi' },
-        { code: moveCode, language: 'move', name: 'NFT' }
-    ]
-});
-// ALL contracts share memory and can call each other DIRECTLY!
-```
-
-### Option 2: Multi-VM (Native Compatibility)
-
-Deploy to **native VMs** for exact compatibility with original chain behavior:
-
-```javascript
-await jaelis.deploySolanaProgram({ bytecode, programId, owner });  // → SVM
-await jaelis.deployMoveModule({ bytecode, moduleName, owner });    // → MoveVM
-await jaelis.deployTonContract({ code, data, owner });             // → TVM
-```
-
-### Language Support Matrix
-
-| 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 |
-
-### Cross-Language Contract Calls (NO BRIDGES!)
-
-```javascript
-// Solidity → Rust call - DIRECT, no bridges needed!
-await jaelis.crossContractCall({
-    from: solidityContract,
-    to: rustProgram,
-    method: 'process_payment',
-    args: [amount, recipient]
-});
-```
-
-## Cross-Chain Settlement (30+ Chains)
-
-JAELIS nodes run light clients for 30+ external blockchains, enabling trustless state verification:
-
-- **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
-
-Read external chain state directly in your JAELIS contracts - no oracles needed.
-
-## Features
-
-- **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
+## Quick Start
 
-## Installation
+### Install Globally
 
 ```bash
 npm install -g jaelis-node
 ```
 
-## Quick Start
-
-```bash
-# Start a node (zero config - auto-connects to testnet)
-# Works without a reward address - add one anytime to start earning!
-jaelis-node start
-
-# Or 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
-
-# Add a reward wallet later (no restart needed for new nodes)
-jaelis-node wallet:set-recipient 0xYourAddress
-```
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `start` | Start a full JAELIS node |
-| `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 and network information |
-
-## Wallet Commands
-
-JAELIS supports **any chain address** for receiving rewards. No staking. No lockups. Your keys, your wallet.
+### Run the Node
 
 ```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
+# Start on testnet (default)
+jaelis-node
 
-# List configured wallets
-jaelis-node wallet:list
+# Start on mainnet
+jaelis-node --network mainnet
 
-# Add additional wallets
-jaelis-node wallet:add "trading" 0x456...
+# Custom RPC port
+jaelis-node --port 8546
 
-# View node identity
-jaelis-node wallet:identity
+# Custom data directory
+jaelis-node --data-dir ./my-jaelis-data
 ```
 
-**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)
+### Use with Your dApp
 
-## Start Options
+Once the node is running, connect your dApp to `http://localhost:8545`:
 
-```bash
-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)
-  --reward-recipient <address>   Wallet address for node rewards (ANY chain!)
-```
-
-## Block Sync & Node Status
+```javascript
+const Jaelis = require('jaelis.js');
 
-Your node automatically syncs with the JAELIS network using **WebSocket push notifications** (like Ethereum's `newHeads` subscription) for real-time updates:
+// Connect to your local node
+const jaelis = new Jaelis.Provider('http://localhost:8545');
 
-```
-[SYNC] Starting sync from https://rpc.jaelis.io
-[SYNC] Syncing 25 blocks (1 → 25)
-[SYNC] Local height: 25/139
-[SYNC] Syncing 25 blocks (26 → 50)
-...
-[SYNC] Local height: 139/139
-[SYNC] WebSocket connected! Subscribing to newHeads...
-[SYNC] ✓ Subscribed to newHeads (id: 0x1)
-[SYNC] Listening for new blocks via WebSocket...
+// Now all RPC calls go through your local node
+const blockNumber = await jaelis.getBlockNumber();
+const balance = await jaelis.getBalance('jae1qwertyuiop...'); // JAELIS native address
 ```
 
-**Sync Features:**
-- **Smart batching** - 25 blocks during initial sync, reduces as you get closer
-- **WebSocket subscriptions** - Real-time block notifications (no polling!)
-- **Automatic fallback** - Falls back to HTTP polling if WebSocket unavailable
+## Architecture
 
-```bash
-# Check sync status
-curl -X POST http://localhost:8545 \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","method":"jaelis_syncing","params":[],"id":1}'
-
-# Response when syncing:
-{
-  "currentBlock": "0x1a4",
-  "highestBlock": "0x2f8",
-  "syncedBlocks": 420,
-  "remainingBlocks": 340,
-  "percentComplete": "55.26%"
-}
-
-# Response when fully synced:
-false
+```
+┌─────────────────┐     WebSocket      ┌───────────────────┐
+│  JAELIS         │ ◄───────────────── │  Your Local Node  │
+│  Main Network   │                    │  (jaelis-node)    │
+│  rpc.jaelis.io  │ ───────────────► │                   │
+└─────────────────┘    newHeads        │  ┌─────────────┐  │
+                       subscription    │  │  LevelDB    │  │
+                                       │  │  Storage    │  │
+┌─────────────────┐     JSON-RPC       │  └─────────────┘  │
+│  Your dApp      │ ◄───────────────── │                   │
+│  (browser/node) │    localhost:8545  │  ┌─────────────┐  │
+└─────────────────┘                    │  │  RPC Server │  │
+                                       │  └─────────────┘  │
+                                       └───────────────────┘
 ```
 
-### Node Registry & Lifetime Tracking
+## CLI Options
 
-When your node connects, it registers with the JAELIS network. Your contributions are tracked **forever** - even across restarts:
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-n, --network <network>` | Network to connect to (`testnet` or `mainnet`) | `testnet` |
+| `-p, --port <port>` | Local RPC server port | `8545` |
+| `-d, --data-dir <dir>` | Data directory for block storage | `./jaelis-data/<network>` |
+| `--no-rpc` | Disable local RPC server | Enabled |
 
-```bash
-# See all connected nodes (run on main RPC)
-curl -X POST https://rpc.jaelis.io \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","method":"jaelis_node_getNodes","params":[],"id":1}'
+## Programmatic Usage
 
-# Get network-wide node stats
-curl -X POST https://rpc.jaelis.io \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","method":"jaelis_node_getStats","params":[],"id":1}'
-
-# Response:
-{
-  "lifetimeNodes": 142,      # All nodes that EVER connected
-  "activeNodes": 23,         # Currently online
-  "validators": 8,           # Opted-in validators
-  "totalUptime": "45d 12h",  # Cumulative network uptime
-  "byAddressType": { "evm": 89, "solana": 31, "bitcoin": 22 }
+```javascript
+const { JaelisNode } = require('jaelis-node');
+
+async function main() {
+    const node = new JaelisNode({
+        network: 'testnet',
+        rpcPort: 8545,
+        dataDir: './my-jaelis-data',
+        enableRpc: true
+    });
+
+    // Event listeners
+    node.on('connected', () => console.log('Connected to network'));
+    node.on('block', (block) => console.log('New block:', block.number));
+    node.on('synced', () => console.log('Fully synced!'));
+
+    // Start the node
+    await node.start();
+
+    // Get status
+    const status = node.getStatus();
+    console.log('Status:', status);
+
+    // Stop the node (graceful shutdown)
+    // await node.stop();
 }
-```
-
-## WebSocket Subscriptions
 
-Connect to the WebSocket endpoint for real-time updates:
-
-```javascript
-const WebSocket = require('ws');
-const ws = new WebSocket('wss://rpc.jaelis.io/ws');
-
-ws.on('open', () => {
-    // Subscribe to new block headers
-    ws.send(JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'jaelis_subscribe',
-        params: ['newHeads'],
-        id: 1
-    }));
-});
-
-ws.on('message', (data) => {
-    const msg = JSON.parse(data);
-    if (msg.method === 'jaelis_subscription') {
-        console.log('New block:', msg.params.result.number);
-    }
-});
+main();
 ```
 
-**Available Subscriptions:**
-| Subscription | Description |
-|--------------|-------------|
-| `newHeads` | New block headers as they're produced (real-time sync) |
-| `newPendingTransactions` | Transaction hashes entering mempool |
-| `logs` | Contract event logs (with filter options) |
-| `syncing` | Sync status changes |
-
-> **Note:** JAELIS uses Proof of Efficient Consensus (PoEC), not mining. Blocks are produced by validators, not mined. The `newHeads` subscription keeps your node synced in real-time.
-
-## RPC Methods
-
-Your node exposes standard JSON-RPC plus JAELIS-specific methods:
+## RPC Methods Supported
 
-### Universal VM Methods
-| Method | Description |
-|--------|-------------|
-| `jaelis_getSupportedLanguages` | Returns: `['solidity', 'rust', 'move', 'func', 'cairo', 'vyper']` |
-| `jaelis_deployUnified` | Deploy unified bundle (multiple languages → ONE bytecode!) |
-| `jaelis_deployContract` | Deploy single contract in any supported language |
-| `jaelis_executeContract` | Execute contract method |
-| `jaelis_crossContractCall` | Call between contracts of different languages (NO BRIDGES!) |
-
-### 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 |
-
-### Multi-Ecosystem Compatibility Layers
-
-JAELIS nodes support RPC methods from **every major blockchain ecosystem**. Developers can use their familiar method names - they all proxy to native `jaelis_*` methods under the hood.
-
-#### Ethereum (eth_*)
-| 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 |
+JAELIS uses the `jaelis_*` namespace for all RPC methods:
 
-#### Solana (solana_*)
+### Chain Info
 | Method | Description |
 |--------|-------------|
-| `solana_getBalance` | Get account balance (lamports format) |
-| `solana_getSlot` | Get current slot (block height) |
-| `solana_getLatestBlockhash` | Get recent blockhash |
-| `solana_getHealth` | Check node health |
+| `jaelis_chainId` | Get chain ID (4547 mainnet, 4545 testnet) |
+| `jaelis_blockNumber` | Get latest block number |
+| `jaelis_syncing` | Get sync status |
 
-#### Bitcoin (btc_*)
-| Method | Description |
-|--------|-------------|
-| `btc_getbalance` | Get balance (BTC decimals) |
-| `btc_getblockcount` | Get block height |
-| `btc_getblock` | Get block by hash |
-| `btc_gettransaction` | Get transaction |
-| `btc_getblockchaininfo` | Chain info |
-| `btc_estimatesmartfee` | Returns 0 (zero fees!) |
-
-#### Move/Aptos/Sui (move_*)
+### Block Queries
 | Method | Description |
 |--------|-------------|
-| `move_getLedgerInfo` | Get ledger info |
-| `move_getAccountResource` | Get account resource |
-| `move_getAccountModule` | Get account module |
+| `jaelis_getBlockByNumber` | Get block by number |
+| `jaelis_getBlockByHash` | Get block by hash |
 
-#### TON/Telegram (ton_*)
+### Transaction Queries
 | Method | Description |
 |--------|-------------|
-| `ton_getAddressBalance` | Get balance |
-| `ton_getMasterchainInfo` | Get masterchain info |
-| `ton_getAccountState` | Get account state |
-| `ton_runGetMethod` | Run get method |
+| `jaelis_getTransactionByHash` | Get transaction |
+| `jaelis_getTransactionReceipt` | Get receipt |
+| `jaelis_sendRawTransaction` | Submit signed tx (uses ENE, not nonces) |
 
-#### WASM/CosmWasm (wasm_*)
+### Account Queries (Relayed to Main Network)
 | Method | Description |
 |--------|-------------|
-| `wasm_call` | Call contract |
-| `wasm_query` | Query contract state |
-| `wasm_deploy` | Deploy WASM contract |
-| `wasm_execute` | Execute contract |
-| `wasm_getCode` | Get contract code |
+| `jaelis_getBalance` | Get account balance |
+| `jaelis_getENE` | Get ENE (Ephemeral Network Entropy) for transaction ordering |
+| `jaelis_getSigil` | Get account SIGIL allocation |
+| `jaelis_getCode` | Get contract code |
+| `jaelis_call` | Call contract (read-only) |
 
-#### StarkNet/Cairo (starknet_*)
+### SIGIL Compute (Zero Gas Fees!)
 | Method | Description |
 |--------|-------------|
-| `starknet_chainId` | Get chain ID |
-| `starknet_blockNumber` | Get block number |
-| `starknet_call` | Call contract |
-| `starknet_estimateFee` | Returns 0 (zero fees!) |
-| `starknet_getTransactionByHash` | Get transaction |
-| `starknet_addInvokeTransaction` | Send invoke transaction |
+| `jaelis_estimateSigil` | Estimate SIGIL compute for transaction |
+| `jaelis_getSigil` | Get available SIGIL allocation |
 
-## Programmatic Usage
+> **Note:** JAELIS has ZERO gas fees. SIGIL represents compute allocation from XAI Colossus exaflops - it's not purchased, it's allocated.
 
-```javascript
-const { JaelisNode, BootstrapNode } = require('jaelis-node');
-
-// Create and start a node
-const node = new JaelisNode({
-    network: 'testnet',
-    rpcPort: 8545,
-    p2pPort: 30303,
-    dataDir: './my-node-data',
-    rewardRecipient: '0xYourAddress'  // Any chain address
-});
-
-await node.start();
-
-// Get node status
-const status = node.getStatus();
-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(`Connected peers: ${peerCount}`);
-});
-
-node.on('block:new', (block) => {
-    console.log(`New block: ${block.number}`);
-});
-
-// Stop the node
-await node.stop();
-```
+## Network Info
 
-## Network Configuration
+| Network | Chain ID | Main RPC | WebSocket |
+|---------|----------|----------|-----------|
+| Testnet | 4545 | https://rpc.jaelis.io | wss://rpc.jaelis.io/ws |
+| Mainnet | 4547 | https://mainnet.jaelis.io | wss://mainnet.jaelis.io/ws |
 
-| Network | Chain ID | RPC URL | Status |
-|---------|----------|---------|--------|
-| Testnet | 4545 | https://rpc.jaelis.io | **Active** |
-| Mainnet | 4547 | https://mainnet.jaelis.io | Coming Soon |
+## Why Run Your Own Node?
 
-## Node Rewards
+1. **Privacy** - RPC requests don't go through public endpoints
+2. **Speed** - Local reads are instant (no network latency)
+3. **Decentralization** - More nodes = stronger network
+4. **Reliability** - No dependency on public RPC availability
 
-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
+## System Requirements
 
-**Reward wallet is optional.** Start your node anytime - add a wallet when you're ready to earn.
+- **Node.js** 18.0.0 or higher
+- **Disk Space** - ~1GB for testnet, ~10GB for mainnet (grows over time)
+- **Memory** - 512MB minimum, 1GB recommended
+- **Network** - Stable internet connection
 
-**No staking required.** JAELIS never holds your funds. Use any wallet from any chain.
+## Data Storage
 
-```bash
-# Set reward wallet (can do before or after starting node)
-jaelis-node wallet:set-recipient 0xYourAddress
+The node stores synced blocks in LevelDB:
 
-# Check your node's contribution stats
-jaelis-node status
+```
+./jaelis-data/
+  └── testnet/
+      └── blocks/     # LevelDB database
 ```
 
-## System Requirements
+To reset, simply delete the data directory and restart.
 
-| Requirement | Minimum | Recommended |
-|-------------|---------|-------------|
-| Node.js | v18.0.0 | v20.x LTS |
-| RAM | 4 GB | 8+ GB |
-| Storage | 50 GB SSD | 200+ GB SSD |
-| CPU | 2 cores | 4+ cores |
-| Network | 10 Mbps | 100+ Mbps |
+## Updates
 
-## Data Directory Structure
+The node checks for updates on startup. To update:
 
+```bash
+npm update -g jaelis-node
 ```
-jaelis-data/
-├── blockchain/       # Block and state data (LevelDB)
-│   ├── state/        # Account states, contract storage
-│   ├── blocks/       # Block headers and transactions
-│   └── index/        # Chain indexes
-├── node-registry/    # Node tracking and statistics
-├── wallet-config/    # Wallet configuration
-├── peers/            # Peer database
-├── keys/             # Node identity keys
-└── logs/             # Node logs
-```
-
-**State Persistence:** All VM state (accounts, contracts, storage) persists to LevelDB. Your node's state survives restarts - no data loss.
-
-## Environment Variables
 
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `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 | - |
+## Troubleshooting
 
-## Docker
+### Connection Issues
 
 ```bash
-# 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 if main network is reachable
+curl https://rpc.jaelis.io -X POST \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"jaelis_blockNumber","params":[]}'
 ```
 
-## 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
-
-### 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
+### Port Already in Use
 
-## AI Integration (MCP)
+```bash
+# Use a different port
+jaelis-node --port 8546
+```
 
-JAELIS is AI-native. Claude Desktop users can interact with the blockchain through MCP (Model Context Protocol):
+### Clear and Resync
 
-```json
-{
-  "mcpServers": {
-    "jaelis": {
-      "url": "https://mcp.jaelis.io/sse"
-    }
-  }
-}
+```bash
+# Delete data directory and restart
+rm -rf ./jaelis-data
+jaelis-node
 ```
 
-Add this to your Claude Desktop config and get 274+ JAELIS tools automatically - create wallets, send transactions, deploy contracts, query balances, and more.
-
 ## Links
 
-- SDK: [npmjs.com/package/jaelis.js](https://www.npmjs.com/package/jaelis.js)
-- Website: [jaelis.io](https://jaelis.io)
-- Documentation: [docs.jaelis.io](https://docs.jaelis.io)
-- GitHub: [github.com/jaelis-foundation](https://github.com/jaelis-foundation)
+- **SDK:** [npmjs.com/package/jaelis.js](https://www.npmjs.com/package/jaelis.js)
+- **Website:** [jaelis.io](https://jaelis.io)
+- **Documentation:** [docs.jaelis.io](https://docs.jaelis.io)
+- **Explorer:** [explorer.jaelis.io](https://explorer.jaelis.io)
+- **GitHub:** [github.com/jaelis-foundation](https://github.com/jaelis-foundation)
 
 ## License