jaelis-node 1.9.0 → 2.0.0

package/lib/storage.js

@@ -0,0 +1,198 @@
+/**
+ * JAELIS Local Storage
+ *
+ * LevelDB-based storage for synced blocks and state.
+ * This is local storage only - no JAELIS internal code.
+ *
+ * Storage Keys:
+ * - block:{number} → Block data
+ * - tx:{hash} → Transaction data
+ * - meta:latestBlock → Latest synced block number
+ *
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const { Level } = require('level');
+const path = require('path');
+const fs = require('fs');
+
+class Storage {
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.dbPath = path.join(dataDir, 'blocks');
+        this.db = null;
+        this.initialized = false;
+
+        // In-memory cache for fast reads
+        this.blockCache = new Map();
+        this.txCache = new Map();
+        this.latestBlock = 0;
+
+        // Cache limits
+        this.maxCacheSize = 1000;
+    }
+
+    /**
+     * Initialize storage
+     */
+    async initialize() {
+        // Create data directory if it doesn't exist
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+
+        // Open LevelDB
+        this.db = new Level(this.dbPath, {
+            keyEncoding: 'utf8',
+            valueEncoding: 'json'
+        });
+
+        await this.db.open();
+
+        // Load latest block number
+        try {
+            this.latestBlock = await this.db.get('meta:latestBlock');
+        } catch (e) {
+            if (e.code === 'LEVEL_NOT_FOUND') {
+                this.latestBlock = 0;
+            } else {
+                throw e;
+            }
+        }
+
+        this.initialized = true;
+        console.log(`[STORAGE] Initialized at ${this.dbPath}`);
+        console.log(`[STORAGE] Latest block: ${this.latestBlock}`);
+    }
+
+    /**
+     * Close storage
+     */
+    async close() {
+        if (this.db) {
+            await this.db.close();
+            this.db = null;
+        }
+        this.initialized = false;
+    }
+
+    /**
+     * Save block to storage
+     */
+    async saveBlock(block) {
+        if (!block || !block.number) return;
+
+        const blockNumber = typeof block.number === 'string'
+            ? parseInt(block.number, 16)
+            : block.number;
+
+        // Save block
+        await this.db.put(`block:${blockNumber}`, block);
+
+        // Save transactions
+        if (block.transactions) {
+            for (const tx of block.transactions) {
+                if (typeof tx === 'object' && tx.hash) {
+                    await this.db.put(`tx:${tx.hash}`, tx);
+                    this._addToCache(this.txCache, tx.hash, tx);
+                }
+            }
+        }
+
+        // Update latest block
+        if (blockNumber > this.latestBlock) {
+            this.latestBlock = blockNumber;
+            await this.db.put('meta:latestBlock', this.latestBlock);
+        }
+
+        // Add to cache
+        this._addToCache(this.blockCache, blockNumber, block);
+    }
+
+    /**
+     * Get block by number
+     */
+    async getBlock(blockNumber) {
+        // Check cache first
+        if (this.blockCache.has(blockNumber)) {
+            return this.blockCache.get(blockNumber);
+        }
+
+        try {
+            const block = await this.db.get(`block:${blockNumber}`);
+            this._addToCache(this.blockCache, blockNumber, block);
+            return block;
+        } catch (e) {
+            if (e.code === 'LEVEL_NOT_FOUND') {
+                return null;
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * Get transaction by hash
+     */
+    async getTransaction(txHash) {
+        // Check cache first
+        if (this.txCache.has(txHash)) {
+            return this.txCache.get(txHash);
+        }
+
+        try {
+            const tx = await this.db.get(`tx:${txHash}`);
+            this._addToCache(this.txCache, txHash, tx);
+            return tx;
+        } catch (e) {
+            if (e.code === 'LEVEL_NOT_FOUND') {
+                return null;
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * Get latest block number
+     */
+    getLatestBlockNumber() {
+        return this.latestBlock;
+    }
+
+    /**
+     * Get storage stats
+     */
+    async getStats() {
+        return {
+            dataDir: this.dataDir,
+            latestBlock: this.latestBlock,
+            blockCacheSize: this.blockCache.size,
+            txCacheSize: this.txCache.size
+        };
+    }
+
+    /**
+     * Add item to cache with LRU eviction
+     */
+    _addToCache(cache, key, value) {
+        // Evict oldest if at capacity
+        if (cache.size >= this.maxCacheSize) {
+            const firstKey = cache.keys().next().value;
+            cache.delete(firstKey);
+        }
+        cache.set(key, value);
+    }
+
+    /**
+     * Clear all data (for testing)
+     */
+    async clear() {
+        await this.db.clear();
+        this.blockCache.clear();
+        this.txCache.clear();
+        this.latestBlock = 0;
+    }
+}
+
+module.exports = { Storage };

package/lib/sync.js

@@ -0,0 +1,366 @@
+/**
+ * JAELIS Sync Manager
+ *
+ * Handles WebSocket connection to JAELIS main network.
+ * Syncs blocks and relays transactions.
+ *
+ * Protocol:
+ * - Subscribe to newHeads for real-time blocks
+ * - Batch sync for catching up
+ * - Automatic reconnection
+ *
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+const WebSocket = require('ws');
+const https = require('https');
+const http = require('http');
+
+class SyncManager extends EventEmitter {
+    constructor(options) {
+        super();
+
+        this.wsEndpoint = options.wsEndpoint;
+        this.rpcEndpoint = options.rpcEndpoint;
+        this.storage = options.storage;
+        this.chainId = options.chainId;
+
+        // WebSocket state
+        this.ws = null;
+        this.isConnected = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.reconnectDelay = 1000;
+
+        // Sync state
+        this.subscriptionId = null;
+        this.isSyncing = false;
+        this.networkHeight = 0;
+        this.localHeight = 0;
+
+        // Request tracking
+        this.pendingRequests = new Map();
+        this.requestId = 1;
+    }
+
+    /**
+     * Start sync manager
+     */
+    async start() {
+        // Get local height
+        this.localHeight = await this.storage.getLatestBlockNumber();
+
+        // Connect WebSocket
+        await this._connect();
+
+        // Get network height and start sync
+        await this._initialSync();
+    }
+
+    /**
+     * Stop sync manager
+     */
+    async stop() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isConnected = false;
+    }
+
+    /**
+     * Connect to WebSocket
+     */
+    async _connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.wsEndpoint);
+
+                this.ws.on('open', () => {
+                    this.isConnected = true;
+                    this.reconnectAttempts = 0;
+                    this.emit('connected');
+                    this._subscribeToNewHeads();
+                    resolve();
+                });
+
+                this.ws.on('message', (data) => {
+                    this._handleMessage(JSON.parse(data.toString()));
+                });
+
+                this.ws.on('close', () => {
+                    this.isConnected = false;
+                    this.emit('disconnected');
+                    this._scheduleReconnect();
+                });
+
+                this.ws.on('error', (error) => {
+                    if (!this.isConnected) {
+                        reject(error);
+                    }
+                    this.emit('error', error);
+                });
+
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * Schedule reconnection
+     */
+    _scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('[SYNC] Max reconnection attempts reached');
+            this.emit('maxReconnectReached');
+            return;
+        }
+
+        this.reconnectAttempts++;
+        const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 30000);
+
+        console.log(`[SYNC] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+
+        setTimeout(async () => {
+            try {
+                await this._connect();
+                await this._initialSync();
+            } catch (error) {
+                console.error('[SYNC] Reconnection failed:', error.message);
+            }
+        }, delay);
+    }
+
+    /**
+     * Subscribe to new block headers
+     */
+    _subscribeToNewHeads() {
+        const id = this.requestId++;
+        this.ws.send(JSON.stringify({
+            jsonrpc: '2.0',
+            id,
+            method: 'jaelis_subscribe',
+            params: ['newHeads']
+        }));
+    }
+
+    /**
+     * Handle incoming WebSocket message
+     */
+    _handleMessage(data) {
+        // Subscription notification
+        if (data.method === 'jaelis_subscription') {
+            this._handleSubscription(data.params);
+            return;
+        }
+
+        // Response to request
+        if (data.id !== undefined) {
+            const pending = this.pendingRequests.get(data.id);
+            if (pending) {
+                this.pendingRequests.delete(data.id);
+                if (data.error) {
+                    pending.reject(new Error(data.error.message));
+                } else {
+                    pending.resolve(data.result);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handle subscription notification
+     */
+    async _handleSubscription(params) {
+        const { subscription, result } = params;
+
+        // New block header
+        if (result && result.number) {
+            const blockNumber = parseInt(result.number, 16);
+            this.networkHeight = blockNumber;
+
+            // Fetch full block and store
+            try {
+                const block = await this._fetchBlock(blockNumber);
+                if (block) {
+                    await this.storage.saveBlock(block);
+                    this.localHeight = blockNumber;
+                    this.emit('block', block);
+                }
+            } catch (error) {
+                console.error('[SYNC] Failed to fetch block:', error.message);
+            }
+        }
+    }
+
+    /**
+     * Initial sync - catch up to network height
+     */
+    async _initialSync() {
+        // Get network height
+        this.networkHeight = await this._getNetworkHeight();
+
+        if (this.localHeight >= this.networkHeight) {
+            console.log(`[SYNC] Already synced at block ${this.localHeight}`);
+            this.emit('synced');
+            return;
+        }
+
+        console.log(`[SYNC] Syncing from block ${this.localHeight} to ${this.networkHeight}`);
+        this.isSyncing = true;
+        this.emit('syncing', { syncing: true, currentBlock: this.localHeight, highestBlock: this.networkHeight });
+
+        // Batch sync
+        const BATCH_SIZE = 25;
+        let current = this.localHeight + 1;
+
+        while (current <= this.networkHeight) {
+            const batchEnd = Math.min(current + BATCH_SIZE - 1, this.networkHeight);
+
+            // Fetch batch
+            const promises = [];
+            for (let i = current; i <= batchEnd; i++) {
+                promises.push(this._fetchBlock(i));
+            }
+
+            const blocks = await Promise.all(promises);
+
+            // Store blocks
+            for (const block of blocks) {
+                if (block) {
+                    await this.storage.saveBlock(block);
+                    this.localHeight = parseInt(block.number, 16);
+                }
+            }
+
+            // Progress update
+            const progress = Math.round((this.localHeight / this.networkHeight) * 100);
+            console.log(`[SYNC] Progress: ${progress}% (block ${this.localHeight}/${this.networkHeight})`);
+            this.emit('syncing', { syncing: true, currentBlock: this.localHeight, highestBlock: this.networkHeight, progress });
+
+            current = batchEnd + 1;
+
+            // Small delay to avoid overwhelming the network
+            await new Promise(r => setTimeout(r, 100));
+        }
+
+        this.isSyncing = false;
+        console.log('[SYNC] Sync complete');
+        this.emit('synced');
+    }
+
+    /**
+     * Get current network height via HTTP RPC
+     */
+    async _getNetworkHeight() {
+        const result = await this._httpRpc('jaelis_blockNumber', []);
+        return parseInt(result, 16);
+    }
+
+    /**
+     * Fetch block by number via HTTP RPC
+     */
+    async _fetchBlock(blockNumber) {
+        const hexBlock = '0x' + blockNumber.toString(16);
+        return this._httpRpc('jaelis_getBlockByNumber', [hexBlock, true]);
+    }
+
+    /**
+     * Send transaction to network
+     */
+    async sendTransaction(signedTx) {
+        return this._httpRpc('jaelis_sendRawTransaction', [signedTx]);
+    }
+
+    /**
+     * Make HTTP RPC call
+     */
+    async _httpRpc(method, params) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.rpcEndpoint);
+            const isHttps = url.protocol === 'https:';
+
+            const body = JSON.stringify({
+                jsonrpc: '2.0',
+                id: this.requestId++,
+                method,
+                params
+            });
+
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: url.pathname,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body)
+                }
+            };
+
+            const client = isHttps ? https : http;
+
+            const req = client.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.error) {
+                            reject(new Error(parsed.error.message));
+                        } else {
+                            resolve(parsed.result);
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+
+    /**
+     * Make WebSocket RPC call
+     */
+    async _wsRpc(method, params) {
+        if (!this.isConnected) {
+            throw new Error('Not connected');
+        }
+
+        return new Promise((resolve, reject) => {
+            const id = this.requestId++;
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error('Request timeout'));
+            }, 30000);
+
+            this.pendingRequests.set(id, {
+                resolve: (result) => {
+                    clearTimeout(timeout);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                }
+            });
+
+            this.ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params
+            }));
+        });
+    }
+}
+
+module.exports = { SyncManager };

package/package.json

@@ -1,53 +1,37 @@
 {
   "name": "jaelis-node",
-  "version": "1.9.0",
-  "description": "Official JAELIS Blockchain Node - WebSocket real-time sync, Universal VM (6 languages), LevelDB state persistence, native jaelis_* RPC, multi-ecosystem compatibility (eth/solana/move/ton/btc/wasm/starknet), Cross-Chain Settlement (30+ chains!), AI-native MCP integration",
+  "version": "2.0.0",
+  "description": "Official JAELIS Blockchain External Node - Connect to the JAELIS network, sync blocks, and expose local RPC for your dApps. Zero gas fees, multi-chain interop.",
   "main": "lib/index.js",
   "bin": {
     "jaelis-node": "./bin/jaelis-node.js"
   },
+  "files": [
+    "lib/",
+    "bin/",
+    "README.md"
+  ],
   "scripts": {
-    "start": "node bin/jaelis-node.js start",
-    "start:testnet": "node bin/jaelis-node.js start --network testnet",
-    "start:mainnet": "node bin/jaelis-node.js start --network mainnet",
-    "validator": "node bin/jaelis-node.js validator",
-    "bootstrap": "node bin/jaelis-node.js bootstrap",
-    "status": "node bin/jaelis-node.js status",
-    "test": "node test/node.test.js"
+    "start": "node bin/jaelis-node.js",
+    "start:testnet": "node bin/jaelis-node.js --network testnet",
+    "start:mainnet": "node bin/jaelis-node.js --network mainnet"
   },
   "keywords": [
     "jaelis",
     "blockchain",
     "node",
-    "validator",
-    "p2p",
+    "rpc",
     "web3",
     "ethereum",
+    "solana",
+    "multi-chain",
     "zero-gas",
-    "zero-fee",
-    "proof-of-stake",
-    "poec",
-    "consensus",
-    "decentralized",
-    "crypto",
-    "cryptocurrency",
-    "ai-native",
-    "mcp",
-    "full-node",
-    "bootstrap-node",
-    "rpc-server",
-    "cross-chain",
-    "settlement",
-    "light-client",
     "interoperability",
-    "universal-state",
-    "solana",
-    "arbitrum",
-    "polygon",
-    "optimism"
+    "decentralized"
   ],
   "author": "JAELIS Foundation",
   "license": "MIT",
+  "homepage": "https://jaelis.io",
   "repository": {
     "type": "git",
     "url": "https://github.com/jaelis-foundation/jaelis-node"
@@ -55,30 +39,12 @@
   "bugs": {
     "url": "https://github.com/jaelis-foundation/jaelis-node/issues"
   },
-  "homepage": "https://jaelis.io",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@chainsafe/libp2p-noise": "^15.1.2",
-    "@chainsafe/libp2p-yamux": "^6.0.2",
-    "@libp2p/bootstrap": "^10.1.5",
-    "@libp2p/identify": "^1.0.21",
-    "@libp2p/tcp": "^9.1.6",
-    "@multiformats/multiaddr": "^13.0.1",
-    "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "cors": "^2.8.5",
-    "express": "^4.18.2",
-    "level": "^8.0.0",
-    "libp2p": "^1.2.0",
-    "ora": "^5.4.1",
-    "ws": "^8.18.3"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "config/",
-    "README.md"
-  ]
+    "ws": "^8.18.0",
+    "level": "^8.0.1",
+    "commander": "^12.1.0"
+  }
 }