jaelis-node 1.10.0 → 2.0.0

package/lib/node.js

@@ -0,0 +1,271 @@
+/**
+ * JAELIS External Node
+ *
+ * Lightweight node that connects to the JAELIS network.
+ * Does NOT contain any internal JAELIS blockchain code.
+ * Only implements the network protocol for syncing and RPC.
+ *
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+const { SyncManager } = require('./sync');
+const { RPCServer } = require('./rpc');
+const { Storage } = require('./storage');
+
+// Network configurations
+const NETWORKS = {
+    testnet: {
+        name: 'JAELIS Testnet',
+        chainId: 4545,
+        symbol: 'tJAELIS',
+        rpcEndpoint: 'https://rpc.jaelis.io',
+        wsEndpoint: 'wss://rpc.jaelis.io/ws'
+    },
+    mainnet: {
+        name: 'JAELIS Mainnet',
+        chainId: 4547,
+        symbol: 'JAELIS',
+        rpcEndpoint: 'https://mainnet.jaelis.io',
+        wsEndpoint: 'wss://mainnet.jaelis.io/ws'
+    }
+};
+
+class JaelisNode extends EventEmitter {
+    /**
+     * Create a new JAELIS external node
+     * @param {Object} options - Node configuration
+     * @param {string} options.network - Network name ('testnet' or 'mainnet')
+     * @param {string} options.dataDir - Data directory for local storage
+     * @param {number} options.rpcPort - Local RPC port (default: 8545)
+     * @param {boolean} options.enableRpc - Enable local RPC server (default: true)
+     */
+    constructor(options = {}) {
+        super();
+
+        // Configuration
+        this.network = options.network || 'testnet';
+        this.networkConfig = NETWORKS[this.network];
+        if (!this.networkConfig) {
+            throw new Error(`Unknown network: ${this.network}. Use 'testnet' or 'mainnet'.`);
+        }
+
+        this.dataDir = options.dataDir || `./jaelis-data/${this.network}`;
+        this.rpcPort = options.rpcPort || 8545;
+        this.enableRpc = options.enableRpc !== false;
+
+        // Node state
+        this.nodeId = this._generateNodeId();
+        this.startTime = null;
+        this.isRunning = false;
+        this.isSyncing = false;
+
+        // Components (initialized on start)
+        this.storage = null;
+        this.sync = null;
+        this.rpc = null;
+
+        // Stats
+        this.stats = {
+            blocksReceived: 0,
+            transactionsRelayed: 0,
+            rpcRequests: 0,
+            peersConnected: 0
+        };
+    }
+
+    /**
+     * Generate unique node ID
+     */
+    _generateNodeId() {
+        const crypto = require('crypto');
+        return 'jaelis_' + crypto.randomBytes(8).toString('hex');
+    }
+
+    /**
+     * Start the node
+     */
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Node is already running');
+        }
+
+        console.log('');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('                    JAELIS EXTERNAL NODE v2.0.0');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log(`   Network:    ${this.networkConfig.name}`);
+        console.log(`   Chain ID:   ${this.networkConfig.chainId}`);
+        console.log(`   Node ID:    ${this.nodeId}`);
+        console.log(`   Data Dir:   ${this.dataDir}`);
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('');
+
+        try {
+            // Initialize storage
+            console.log('[NODE] Initializing local storage...');
+            this.storage = new Storage(this.dataDir);
+            await this.storage.initialize();
+
+            // Initialize sync manager
+            console.log('[NODE] Connecting to JAELIS network...');
+            this.sync = new SyncManager({
+                wsEndpoint: this.networkConfig.wsEndpoint,
+                rpcEndpoint: this.networkConfig.rpcEndpoint,
+                storage: this.storage,
+                chainId: this.networkConfig.chainId
+            });
+
+            // Forward sync events
+            this.sync.on('connected', () => {
+                console.log('[NODE] Connected to JAELIS network');
+                this.emit('connected');
+            });
+
+            this.sync.on('disconnected', () => {
+                console.log('[NODE] Disconnected from network');
+                this.emit('disconnected');
+            });
+
+            this.sync.on('block', (block) => {
+                this.stats.blocksReceived++;
+                this.emit('block', block);
+            });
+
+            this.sync.on('syncing', (status) => {
+                this.isSyncing = status.syncing;
+                this.emit('syncing', status);
+            });
+
+            this.sync.on('synced', () => {
+                this.isSyncing = false;
+                console.log('[NODE] Fully synced with network');
+                this.emit('synced');
+            });
+
+            // Start sync
+            await this.sync.start();
+
+            // Start RPC server if enabled
+            if (this.enableRpc) {
+                console.log(`[NODE] Starting local RPC server on port ${this.rpcPort}...`);
+                this.rpc = new RPCServer({
+                    port: this.rpcPort,
+                    storage: this.storage,
+                    sync: this.sync,
+                    chainId: this.networkConfig.chainId,
+                    networkName: this.networkConfig.name
+                });
+
+                this.rpc.on('request', () => {
+                    this.stats.rpcRequests++;
+                });
+
+                await this.rpc.start();
+                console.log(`[NODE] Local RPC available at http://localhost:${this.rpcPort}`);
+            }
+
+            this.startTime = Date.now();
+            this.isRunning = true;
+
+            console.log('');
+            console.log('[NODE] Node started successfully!');
+            console.log('');
+
+            this.emit('started');
+
+        } catch (error) {
+            console.error('[NODE] Failed to start:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Stop the node
+     */
+    async stop() {
+        if (!this.isRunning) return;
+
+        console.log('[NODE] Stopping node...');
+
+        if (this.rpc) {
+            await this.rpc.stop();
+        }
+
+        if (this.sync) {
+            await this.sync.stop();
+        }
+
+        if (this.storage) {
+            await this.storage.close();
+        }
+
+        this.isRunning = false;
+        console.log('[NODE] Node stopped');
+        this.emit('stopped');
+    }
+
+    /**
+     * Get node status
+     */
+    getStatus() {
+        const uptime = this.startTime ? Date.now() - this.startTime : 0;
+
+        return {
+            nodeId: this.nodeId,
+            network: this.network,
+            chainId: this.networkConfig.chainId,
+            isRunning: this.isRunning,
+            isSyncing: this.isSyncing,
+            uptime,
+            uptimeFormatted: this._formatUptime(uptime),
+            currentBlock: this.storage?.getLatestBlockNumber() || 0,
+            stats: this.stats,
+            version: '2.0.0',
+            rpcPort: this.enableRpc ? this.rpcPort : null
+        };
+    }
+
+    /**
+     * Format uptime as human-readable string
+     */
+    _formatUptime(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+
+        if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+        if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+        return `${seconds}s`;
+    }
+
+    /**
+     * Get latest block number
+     */
+    async getBlockNumber() {
+        return this.storage?.getLatestBlockNumber() || 0;
+    }
+
+    /**
+     * Get block by number
+     */
+    async getBlock(blockNumber) {
+        return this.storage?.getBlock(blockNumber);
+    }
+
+    /**
+     * Submit transaction to the network
+     */
+    async sendTransaction(signedTx) {
+        if (!this.sync?.isConnected) {
+            throw new Error('Not connected to network');
+        }
+        return this.sync.sendTransaction(signedTx);
+    }
+}
+
+module.exports = { JaelisNode, NETWORKS };

package/lib/rpc.js

@@ -0,0 +1,315 @@
+/**
+ * JAELIS Local RPC Server
+ *
+ * JSON-RPC server for local dApp access.
+ * Reads from local storage and relays transactions to network.
+ *
+ * JAELIS is a sovereign L1 blockchain - uses jaelis_* namespace ONLY.
+ * No eth_* aliasing. Like Solana uses native methods, so does JAELIS.
+ *
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+const http = require('http');
+
+class RPCServer extends EventEmitter {
+    constructor(options) {
+        super();
+
+        this.port = options.port || 8545;
+        this.storage = options.storage;
+        this.sync = options.sync;
+        this.chainId = options.chainId;
+        this.networkName = options.networkName;
+
+        this.server = null;
+        this.isRunning = false;
+
+        // Method handlers
+        this.methods = this._registerMethods();
+    }
+
+    /**
+     * Start RPC server
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                this._handleRequest(req, res);
+            });
+
+            this.server.listen(this.port, () => {
+                this.isRunning = true;
+                resolve();
+            });
+
+            this.server.on('error', reject);
+        });
+    }
+
+    /**
+     * Stop RPC server
+     */
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.isRunning = false;
+                    resolve();
+                });
+            } else {
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * Handle incoming HTTP request
+     */
+    async _handleRequest(req, res) {
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+        // Handle preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+
+        // Only accept POST
+        if (req.method !== 'POST') {
+            res.writeHead(405);
+            res.end('Method Not Allowed');
+            return;
+        }
+
+        // Read body
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+            try {
+                const request = JSON.parse(body);
+                this.emit('request', request);
+
+                // Handle batch or single
+                let response;
+                if (Array.isArray(request)) {
+                    response = await Promise.all(request.map(r => this._handleRpcCall(r)));
+                } else {
+                    response = await this._handleRpcCall(request);
+                }
+
+                res.setHeader('Content-Type', 'application/json');
+                res.writeHead(200);
+                res.end(JSON.stringify(response));
+
+            } catch (error) {
+                res.setHeader('Content-Type', 'application/json');
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: { code: -32700, message: 'Parse error' }
+                }));
+            }
+        });
+    }
+
+    /**
+     * Handle single RPC call
+     */
+    async _handleRpcCall(request) {
+        const { jsonrpc, id, method, params } = request;
+
+        if (jsonrpc !== '2.0') {
+            return { jsonrpc: '2.0', id, error: { code: -32600, message: 'Invalid Request' } };
+        }
+
+        // JAELIS is sovereign - use jaelis_* methods only
+        // No eth_* aliasing - we are our own chain
+        const handler = this.methods.get(method);
+        if (!handler) {
+            return { jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } };
+        }
+
+        try {
+            const result = await handler(params || []);
+            return { jsonrpc: '2.0', id, result };
+        } catch (error) {
+            return { jsonrpc: '2.0', id, error: { code: -32000, message: error.message } };
+        }
+    }
+
+    /**
+     * Register RPC methods
+     */
+    _registerMethods() {
+        const methods = new Map();
+
+        // Chain info
+        methods.set('jaelis_chainId', async () => {
+            return '0x' + this.chainId.toString(16);
+        });
+
+        methods.set('jaelis_networkId', async () => {
+            return this.chainId.toString();
+        });
+
+        methods.set('jaelis_blockNumber', async () => {
+            const blockNumber = this.storage.getLatestBlockNumber();
+            return '0x' + blockNumber.toString(16);
+        });
+
+        // Block queries
+        methods.set('jaelis_getBlockByNumber', async (params) => {
+            const [blockTag, includeTxs] = params;
+            let blockNumber;
+
+            if (blockTag === 'latest') {
+                blockNumber = this.storage.getLatestBlockNumber();
+            } else if (blockTag === 'earliest') {
+                blockNumber = 0;
+            } else {
+                blockNumber = parseInt(blockTag, 16);
+            }
+
+            const block = await this.storage.getBlock(blockNumber);
+            if (!block) return null;
+
+            // Strip full transactions if not requested
+            if (!includeTxs && block.transactions) {
+                return {
+                    ...block,
+                    transactions: block.transactions.map(tx =>
+                        typeof tx === 'object' ? tx.hash : tx
+                    )
+                };
+            }
+
+            return block;
+        });
+
+        methods.set('jaelis_getBlockByHash', async () => {
+            // Hash lookup not indexed yet - return null
+            return null;
+        });
+
+        // Transaction queries
+        methods.set('jaelis_getTransactionByHash', async (params) => {
+            const [txHash] = params;
+            return this.storage.getTransaction(txHash);
+        });
+
+        methods.set('jaelis_getTransactionReceipt', async (params) => {
+            const [txHash] = params;
+            const tx = await this.storage.getTransaction(txHash);
+            if (!tx) return null;
+
+            // Return basic receipt (actual receipt would come from network)
+            return {
+                transactionHash: txHash,
+                blockNumber: tx.blockNumber,
+                blockHash: tx.blockHash,
+                status: '0x1',
+                from: tx.from,
+                to: tx.to,
+                gasUsed: '0x0', // JAELIS has no gas
+                logs: []
+            };
+        });
+
+        // Transaction submission
+        methods.set('jaelis_sendRawTransaction', async (params) => {
+            const [signedTx] = params;
+            return this.sync.sendTransaction(signedTx);
+        });
+
+        // Account queries (relay to main network)
+        methods.set('jaelis_getBalance', async (params) => {
+            const [address, blockTag] = params;
+            return this.sync._httpRpc('jaelis_getBalance', [address, blockTag || 'latest']);
+        });
+
+        methods.set('jaelis_getTransactionCount', async (params) => {
+            const [address, blockTag] = params;
+            return this.sync._httpRpc('jaelis_getTransactionCount', [address, blockTag || 'latest']);
+        });
+
+        // ENE (Ephemeral Network Entropy) - replaces nonces in JAELIS
+        // Provides post-quantum safe transaction ordering
+        methods.set('jaelis_getENE', async (params) => {
+            const [address] = params;
+            return this.sync._httpRpc('jaelis_getENE', [address]);
+        });
+
+        // SIGIL compute estimation (NOT gas - JAELIS has zero fees!)
+        methods.set('jaelis_estimateSigil', async (params) => {
+            const [txObject] = params;
+            return this.sync._httpRpc('jaelis_estimateSigil', [txObject]);
+        });
+
+        // Get account SIGIL allocation
+        methods.set('jaelis_getSigil', async (params) => {
+            const [address] = params;
+            return this.sync._httpRpc('jaelis_getSigil', [address]);
+        });
+
+        methods.set('jaelis_getCode', async (params) => {
+            const [address, blockTag] = params;
+            return this.sync._httpRpc('jaelis_getCode', [address, blockTag || 'latest']);
+        });
+
+        methods.set('jaelis_call', async (params) => {
+            const [callObject, blockTag] = params;
+            return this.sync._httpRpc('jaelis_call', [callObject, blockTag || 'latest']);
+        });
+
+        // Gas (always returns 0 for JAELIS)
+        methods.set('jaelis_gasPrice', async () => {
+            return '0x0'; // Zero gas fees!
+        });
+
+        methods.set('jaelis_estimateGas', async () => {
+            return '0x0'; // Zero gas fees!
+        });
+
+        // Syncing status
+        methods.set('jaelis_syncing', async () => {
+            if (!this.sync.isSyncing) {
+                return false;
+            }
+            return {
+                startingBlock: '0x0',
+                currentBlock: '0x' + this.storage.getLatestBlockNumber().toString(16),
+                highestBlock: '0x' + this.sync.networkHeight.toString(16)
+            };
+        });
+
+        // Node info
+        methods.set('web3_clientVersion', async () => {
+            return `JAELIS-Node/v2.0.0/${this.networkName}`;
+        });
+
+        methods.set('net_version', async () => {
+            return this.chainId.toString();
+        });
+
+        methods.set('net_listening', async () => {
+            return this.sync.isConnected;
+        });
+
+        methods.set('net_peerCount', async () => {
+            return '0x1'; // Connected to main network
+        });
+
+        return methods;
+    }
+}
+
+module.exports = { RPCServer };