jaelis-node 1.9.0 → 2.0.0

package/config/default.json

@@ -1,74 +0,0 @@
-{
-  "node": {
-    "name": "my-jaelis-node",
-    "type": "full",
-    "version": "1.0.0"
-  },
-  "network": {
-    "name": "testnet",
-    "chainId": 4545,
-    "bootstrapNodes": [
-      "/dns4/rpc.jaelis.io/tcp/30303"
-    ]
-  },
-  "rpc": {
-    "enabled": true,
-    "host": "0.0.0.0",
-    "port": 8545,
-    "cors": "*",
-    "methods": {
-      "eth": true,
-      "jaelis": true,
-      "net": true,
-      "web3": true
-    }
-  },
-  "p2p": {
-    "enabled": true,
-    "port": 30303,
-    "maxPeers": 50,
-    "discovery": true
-  },
-  "storage": {
-    "dataDir": "./jaelis-data",
-    "engine": "leveldb",
-    "cache": {
-      "blocks": 512,
-      "states": 256
-    }
-  },
-  "sync": {
-    "mode": "full",
-    "fastSync": true,
-    "pruning": false
-  },
-  "validator": {
-    "enabled": false,
-    "stake": "1000",
-    "keyFile": null,
-    "autoCompound": true
-  },
-  "metrics": {
-    "enabled": true,
-    "port": 9090,
-    "path": "/metrics"
-  },
-  "logging": {
-    "level": "info",
-    "console": true,
-    "file": {
-      "enabled": true,
-      "path": "./jaelis-data/logs/node.log",
-      "maxSize": "100MB",
-      "maxFiles": 10
-    }
-  },
-  "security": {
-    "maxRequestSize": "1MB",
-    "rateLimit": {
-      "enabled": true,
-      "windowMs": 60000,
-      "maxRequests": 1000
-    }
-  }
-}

package/config/mainnet.json

@@ -1,30 +0,0 @@
-{
-  "extends": "default",
-  "network": {
-    "name": "mainnet",
-    "chainId": 4547,
-    "symbol": "JAELIS",
-    "rpcEndpoints": [
-      "https://mainnet.jaelis.io"
-    ],
-    "bootstrapNodes": [],
-    "genesis": {
-      "timestamp": null,
-      "difficulty": 1,
-      "gasLimit": "0x0",
-      "extraData": "0x4a41454c495320426c6f636b636861696e202d204d61696e6e6574"
-    }
-  },
-  "storage": {
-    "dataDir": "./jaelis-data/mainnet"
-  },
-  "logging": {
-    "level": "info"
-  },
-  "validator": {
-    "enabled": false,
-    "stake": "10000",
-    "autoCompound": true
-  },
-  "_status": "coming-soon"
-}

package/config/testnet.json

@@ -1,26 +0,0 @@
-{
-  "extends": "default",
-  "network": {
-    "name": "testnet",
-    "chainId": 4545,
-    "symbol": "tJAELIS",
-    "rpcEndpoints": [
-      "https://rpc.jaelis.io"
-    ],
-    "bootstrapNodes": [
-      "/dns4/rpc.jaelis.io/tcp/30303"
-    ],
-    "genesis": {
-      "timestamp": 1731398400000,
-      "difficulty": 1,
-      "gasLimit": "0x0",
-      "extraData": "0x4a41454c495320426c6f636b636861696e202d2054657374676e6573697320426c6f636b"
-    }
-  },
-  "storage": {
-    "dataDir": "./jaelis-data/testnet"
-  },
-  "logging": {
-    "level": "debug"
-  }
-}

package/lib/JAELIS-VM/lib/adapters/evm-adapter.js

@@ -1,454 +0,0 @@
-/**
- * EVM ADAPTER
- *
- * Provides EVM-compatible interface for JAELIS Universal VM
- * Supports: Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Avalanche
- *
- * Features:
- * - Solidity ABI encoding/decoding
- * - EIP-2718 transaction types
- * - EIP-1559 gas pricing
- * - Precompiled contracts
- *
- * @version 0.1.0
- * @author Mario Papaleo - JAELIS Foundation
- */
-
-const crypto = require('crypto');
-
-// Solidity ABI type encodings
-const ABI_TYPES = {
-    uint256: { size: 32, dynamic: false },
-    int256: { size: 32, dynamic: false },
-    address: { size: 32, dynamic: false },
-    bool: { size: 32, dynamic: false },
-    bytes32: { size: 32, dynamic: false },
-    bytes: { size: null, dynamic: true },
-    string: { size: null, dynamic: true },
-    'uint256[]': { size: null, dynamic: true },
-    'address[]': { size: null, dynamic: true }
-};
-
-// EVM Precompiled contract addresses
-const PRECOMPILES = {
-    '0x0000000000000000000000000000000000000001': 'ecrecover',
-    '0x0000000000000000000000000000000000000002': 'sha256',
-    '0x0000000000000000000000000000000000000003': 'ripemd160',
-    '0x0000000000000000000000000000000000000004': 'identity',
-    '0x0000000000000000000000000000000000000005': 'modexp',
-    '0x0000000000000000000000000000000000000006': 'ecadd',
-    '0x0000000000000000000000000000000000000007': 'ecmul',
-    '0x0000000000000000000000000000000000000008': 'ecpairing',
-    '0x0000000000000000000000000000000000000009': 'blake2f'
-};
-
-class EVMAdapter {
-    constructor(vm) {
-        this.vm = vm;
-        this.chainId = 4545;  // JAELIS testnet
-
-        // Function signature cache
-        this.signatureCache = new Map();
-    }
-
-    /**
-     * Deploy EVM contract
-     */
-    async deploy(bytecode, constructorArgs = [], options = {}) {
-        // Encode constructor arguments
-        const encodedArgs = this.encodeParameters(
-            options.constructorTypes || [],
-            constructorArgs
-        );
-
-        const deployBytecode = Buffer.concat([
-            Buffer.from(bytecode.replace('0x', ''), 'hex'),
-            encodedArgs
-        ]);
-
-        return this.vm.deployBytecode(deployBytecode, 'evm', options);
-    }
-
-    /**
-     * Call EVM contract function
-     */
-    async call(address, functionSignature, args = [], options = {}) {
-        // Parse function signature
-        const { name, types } = this.parseFunctionSignature(functionSignature);
-
-        // Encode function call
-        const selector = this.getFunctionSelector(functionSignature);
-        const encodedArgs = this.encodeParameters(types, args);
-
-        const callData = Buffer.concat([selector, encodedArgs]);
-
-        // Execute
-        const result = await this.vm.execute(address, name, callData, {
-            ...options,
-            callData
-        });
-
-        // Decode result if return types specified
-        if (options.returnTypes) {
-            result.decoded = this.decodeParameters(options.returnTypes, result.returnValue);
-        }
-
-        return result;
-    }
-
-    /**
-     * Get function selector (4 bytes)
-     */
-    getFunctionSelector(signature) {
-        // Check cache
-        if (this.signatureCache.has(signature)) {
-            return this.signatureCache.get(signature);
-        }
-
-        // Normalize signature
-        const normalized = signature.replace(/\s/g, '');
-
-        // Keccak256 hash and take first 4 bytes
-        const hash = this.keccak256(Buffer.from(normalized));
-        const selector = hash.slice(0, 4);
-
-        this.signatureCache.set(signature, selector);
-        return selector;
-    }
-
-    /**
-     * Parse function signature
-     */
-    parseFunctionSignature(signature) {
-        const match = signature.match(/^(\w+)\((.*)\)$/);
-        if (!match) {
-            throw new Error(`Invalid function signature: ${signature}`);
-        }
-
-        const name = match[1];
-        const types = match[2] ? match[2].split(',').map(t => t.trim()) : [];
-
-        return { name, types };
-    }
-
-    /**
-     * Encode function parameters (ABI encoding)
-     */
-    encodeParameters(types, values) {
-        if (types.length !== values.length) {
-            throw new Error('Types and values length mismatch');
-        }
-
-        const heads = [];
-        const tails = [];
-        let tailOffset = types.length * 32;  // Start of dynamic data
-
-        for (let i = 0; i < types.length; i++) {
-            const type = types[i];
-            const value = values[i];
-            const typeInfo = ABI_TYPES[type];
-
-            if (!typeInfo || !typeInfo.dynamic) {
-                // Static type - encode directly in head
-                heads.push(this.encodeValue(type, value));
-            } else {
-                // Dynamic type - encode offset in head, data in tail
-                heads.push(this.encodeUint256(tailOffset));
-                const encoded = this.encodeValue(type, value);
-                tails.push(encoded);
-                tailOffset += encoded.length;
-            }
-        }
-
-        return Buffer.concat([...heads, ...tails]);
-    }
-
-    /**
-     * Decode function parameters
-     */
-    decodeParameters(types, data) {
-        const results = [];
-        let offset = 0;
-
-        for (const type of types) {
-            const typeInfo = ABI_TYPES[type];
-
-            if (!typeInfo || !typeInfo.dynamic) {
-                // Static type
-                results.push(this.decodeValue(type, data, offset));
-                offset += 32;
-            } else {
-                // Dynamic type - read offset first
-                const dataOffset = Number(this.decodeUint256(data, offset));
-                results.push(this.decodeValue(type, data, dataOffset));
-                offset += 32;
-            }
-        }
-
-        return results;
-    }
-
-    /**
-     * Encode a single value
-     */
-    encodeValue(type, value) {
-        switch (type) {
-            case 'uint256':
-            case 'int256':
-                return this.encodeUint256(value);
-
-            case 'address':
-                return this.encodeAddress(value);
-
-            case 'bool':
-                return this.encodeUint256(value ? 1 : 0);
-
-            case 'bytes32':
-                return this.encodeBytes32(value);
-
-            case 'bytes':
-                return this.encodeBytes(value);
-
-            case 'string':
-                return this.encodeString(value);
-
-            case 'uint256[]':
-            case 'address[]':
-                return this.encodeArray(type.replace('[]', ''), value);
-
-            default:
-                throw new Error(`Unsupported type: ${type}`);
-        }
-    }
-
-    /**
-     * Decode a single value
-     */
-    decodeValue(type, data, offset) {
-        switch (type) {
-            case 'uint256':
-                return this.decodeUint256(data, offset);
-
-            case 'int256':
-                return this.decodeInt256(data, offset);
-
-            case 'address':
-                return this.decodeAddress(data, offset);
-
-            case 'bool':
-                return this.decodeUint256(data, offset) !== 0n;
-
-            case 'bytes32':
-                return '0x' + data.slice(offset, offset + 32).toString('hex');
-
-            case 'bytes':
-                return this.decodeBytes(data, offset);
-
-            case 'string':
-                return this.decodeString(data, offset);
-
-            default:
-                throw new Error(`Unsupported type: ${type}`);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // ENCODING HELPERS
-    // ═══════════════════════════════════════════════════════════════
-
-    encodeUint256(value) {
-        const buf = Buffer.alloc(32);
-        let v = BigInt(value);
-        for (let i = 31; i >= 0 && v > 0n; i--) {
-            buf[i] = Number(v & 0xffn);
-            v >>= 8n;
-        }
-        return buf;
-    }
-
-    decodeUint256(data, offset = 0) {
-        let result = 0n;
-        for (let i = 0; i < 32; i++) {
-            result = (result << 8n) | BigInt(data[offset + i] || 0);
-        }
-        return result;
-    }
-
-    decodeInt256(data, offset = 0) {
-        const unsigned = this.decodeUint256(data, offset);
-        // Check sign bit
-        if (unsigned >= 2n ** 255n) {
-            return unsigned - 2n ** 256n;
-        }
-        return unsigned;
-    }
-
-    encodeAddress(address) {
-        const buf = Buffer.alloc(32);
-        const hex = address.startsWith('0x') ? address.slice(2) : address;
-        Buffer.from(hex.padStart(40, '0'), 'hex').copy(buf, 12);
-        return buf;
-    }
-
-    decodeAddress(data, offset = 0) {
-        return '0x' + data.slice(offset + 12, offset + 32).toString('hex');
-    }
-
-    encodeBytes32(value) {
-        const buf = Buffer.alloc(32);
-        const hex = value.startsWith('0x') ? value.slice(2) : value;
-        Buffer.from(hex.padEnd(64, '0'), 'hex').copy(buf);
-        return buf;
-    }
-
-    encodeBytes(value) {
-        const data = Buffer.isBuffer(value) ? value : Buffer.from(value.replace('0x', ''), 'hex');
-        const length = this.encodeUint256(data.length);
-
-        // Pad to 32-byte boundary
-        const padded = Buffer.alloc(Math.ceil(data.length / 32) * 32);
-        data.copy(padded);
-
-        return Buffer.concat([length, padded]);
-    }
-
-    decodeBytes(data, offset = 0) {
-        const length = Number(this.decodeUint256(data, offset));
-        return data.slice(offset + 32, offset + 32 + length);
-    }
-
-    encodeString(value) {
-        return this.encodeBytes(Buffer.from(value, 'utf8'));
-    }
-
-    decodeString(data, offset = 0) {
-        return this.decodeBytes(data, offset).toString('utf8');
-    }
-
-    encodeArray(elementType, values) {
-        const length = this.encodeUint256(values.length);
-        const elements = values.map(v => this.encodeValue(elementType, v));
-        return Buffer.concat([length, ...elements]);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // CRYPTO
-    // ═══════════════════════════════════════════════════════════════
-
-    keccak256(data) {
-        // Using sha3-256 as approximation
-        // Real implementation would use keccak
-        return crypto.createHash('sha3-256').update(data).digest();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // TRANSACTION ENCODING (EIP-2718, EIP-1559)
-    // ═══════════════════════════════════════════════════════════════
-
-    encodeTransaction(tx) {
-        // EIP-1559 transaction
-        const fields = [
-            tx.chainId || this.chainId,
-            tx.nonce || 0,
-            tx.maxPriorityFeePerGas || 0,
-            tx.maxFeePerGas || 0,
-            tx.gasLimit || 21000,
-            tx.to || '',
-            tx.value || 0,
-            tx.data || Buffer.alloc(0),
-            tx.accessList || []
-        ];
-
-        // RLP encode (simplified)
-        const encoded = this.rlpEncode(fields);
-
-        // Prepend transaction type (0x02 for EIP-1559)
-        return Buffer.concat([Buffer.from([0x02]), encoded]);
-    }
-
-    rlpEncode(input) {
-        if (Array.isArray(input)) {
-            const encoded = input.map(item => this.rlpEncode(item));
-            const concat = Buffer.concat(encoded);
-            return Buffer.concat([this.rlpEncodeLength(concat.length, 0xc0), concat]);
-        }
-
-        if (Buffer.isBuffer(input)) {
-            if (input.length === 1 && input[0] < 0x80) {
-                return input;
-            }
-            return Buffer.concat([this.rlpEncodeLength(input.length, 0x80), input]);
-        }
-
-        if (typeof input === 'number' || typeof input === 'bigint') {
-            if (input === 0 || input === 0n) {
-                return Buffer.from([0x80]);
-            }
-            const hex = input.toString(16);
-            const buf = Buffer.from(hex.length % 2 ? '0' + hex : hex, 'hex');
-            return this.rlpEncode(buf);
-        }
-
-        if (typeof input === 'string') {
-            if (input.startsWith('0x')) {
-                return this.rlpEncode(Buffer.from(input.slice(2), 'hex'));
-            }
-            return this.rlpEncode(Buffer.from(input));
-        }
-
-        return Buffer.from([0x80]);
-    }
-
-    rlpEncodeLength(length, offset) {
-        if (length < 56) {
-            return Buffer.from([offset + length]);
-        }
-        const hexLength = length.toString(16);
-        const lenOfLen = Math.ceil(hexLength.length / 2);
-        return Buffer.concat([
-            Buffer.from([offset + 55 + lenOfLen]),
-            Buffer.from(hexLength.padStart(lenOfLen * 2, '0'), 'hex')
-        ]);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PRECOMPILES
-    // ═══════════════════════════════════════════════════════════════
-
-    async executePrecompile(address, input) {
-        const name = PRECOMPILES[address.toLowerCase()];
-        if (!name) {
-            throw new Error(`Unknown precompile: ${address}`);
-        }
-
-        switch (name) {
-            case 'ecrecover':
-                return this._ecrecover(input);
-            case 'sha256':
-                return crypto.createHash('sha256').update(input).digest();
-            case 'ripemd160':
-                const ripemd = crypto.createHash('ripemd160').update(input).digest();
-                return Buffer.concat([Buffer.alloc(12), ripemd]);
-            case 'identity':
-                return input;
-            case 'modexp':
-                return this._modexp(input);
-            default:
-                throw new Error(`Precompile not implemented: ${name}`);
-        }
-    }
-
-    _ecrecover(input) {
-        // Extract components from input
-        // Would need actual EC recovery implementation
-        return Buffer.alloc(32);
-    }
-
-    _modexp(input) {
-        // Modular exponentiation
-        // Would need big integer implementation
-        return Buffer.alloc(32);
-    }
-}
-
-module.exports = EVMAdapter;