jaelis-node 1.4.1 → 1.5.0

package/README.md

@@ -13,7 +13,36 @@ JAELIS is a next-generation blockchain with a **Universal Virtual Machine** that
 
 ## Universal VM - Core Innovation
 
-The JAELIS Universal VM executes contracts from multiple ecosystems natively:
+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 |
 |----------|-----------|--------|
@@ -24,12 +53,10 @@ The JAELIS Universal VM executes contracts from multiple ecosystems natively:
 | **Cairo** | StarkNet | Production |
 | **Vyper** | Ethereum (Python-like) | Production |
 
-### Cross-Language Contract Calls
-
-A Solidity contract can call a Rust contract. A Move module can interact with FunC. All native, all on-chain:
+### Cross-Language Contract Calls (NO BRIDGES!)
 
 ```javascript
-// Solidity contract calling a Rust program
+// Solidity → Rust call - DIRECT, no bridges needed!
 await jaelis.crossContractCall({
     from: solidityContract,
     to: rustProgram,
@@ -148,9 +175,10 @@ Your node exposes standard JSON-RPC plus JAELIS-specific methods:
 | Method | Description |
 |--------|-------------|
 | `jaelis_getSupportedLanguages` | Returns: `['solidity', 'rust', 'move', 'func', 'cairo', 'vyper']` |
-| `jaelis_deployContract` | Deploy contract in any supported language |
+| `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 |
+| `jaelis_crossContractCall` | Call between contracts of different languages (NO BRIDGES!) |
 
 ### Cross-Chain Settlement Methods
 | Method | Description |

package/lib/index.js

@@ -1276,11 +1276,18 @@ class EmbeddedRpcServer {
                     vmActive: !!this.blockchain?.vmExecutor
                 };
 
+            case 'jaelis_deploy':
             case 'jaelis_deployContract':
                 // Deploy contract in ANY language!
                 // params: [source, language, options]
                 return this._deployContract(params[0], params[1], params[2] || {});
 
+            case 'jaelis_deployUnified':
+                // THE KEY INNOVATION: Deploy unified contract bundle!
+                // Compile MULTIPLE contracts from MULTIPLE languages into ONE bytecode!
+                // params: [{ from, sources: [{ code, language, name }...] }]
+                return this._deployUnified(params[0]);
+
             case 'jaelis_executeContract':
                 // Execute contract call
                 // params: [to, functionName, args, options]
@@ -1589,6 +1596,69 @@ class EmbeddedRpcServer {
         };
     }
 
+    /**
+     * Deploy unified contract bundle (THE KEY INNOVATION!)
+     *
+     * Compiles MULTIPLE contracts from MULTIPLE languages into ONE bytecode bundle.
+     * All contracts share memory and can call each other DIRECTLY - no bridges!
+     *
+     * @param {Object} params - { from, sources: [{ code, language, name }...] }
+     */
+    async _deployUnified(params) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        if (!this.blockchain.unifiedVM) throw new Error('Unified VM not available');
+
+        const { from, sources } = params;
+
+        if (!sources || !Array.isArray(sources) || sources.length === 0) {
+            throw new Error('sources array is required for unified deployment');
+        }
+
+        console.log(`[RPC] Deploying unified bundle with ${sources.length} contracts...`);
+        console.log(`[RPC] Languages: ${[...new Set(sources.map(s => s.language))].join(', ')}`);
+
+        // Compile all sources together using the Unified Compiler
+        const compiled = await this.blockchain.unifiedVM.compileBundle(sources);
+
+        // Deploy the unified bytecode
+        const address = '0x' + require('crypto').randomBytes(20).toString('hex');
+
+        // Store the unified contract
+        if (this.blockchain.contracts) {
+            this.blockchain.contracts.set(address, {
+                bytecode: compiled.bytecode,
+                abi: compiled.abi || [],
+                sources: sources.map(s => s.name),
+                languages: [...new Set(sources.map(s => s.language))],
+                deployedAt: Date.now(),
+                deployer: from
+            });
+        }
+
+        console.log(`[RPC] Unified bundle deployed at ${address}`);
+        console.log(`[RPC] Bytecode: ${compiled.bytecode?.length || 0} bytes`);
+        console.log(`[RPC] Cross-references: ${compiled.crossReferences?.size || 0}`);
+
+        // Build contracts map for response
+        const contractsMap = {};
+        for (const source of sources) {
+            contractsMap[source.name] = {
+                address: address,  // All share the same bundle address
+                language: source.language,
+                name: source.name
+            };
+        }
+
+        return {
+            address,
+            bytecode: compiled.bytecode?.toString('hex'),
+            abi: compiled.abi || [],
+            contracts: contractsMap,
+            metadata: compiled.metadata,
+            gasUsed: 0  // ZERO FEES!
+        };
+    }
+
     async _executeContract(to, functionName, args, options) {
         if (!this.blockchain) throw new Error('Blockchain not available');
         return this.blockchain.executeContract(to, functionName, args, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaelis-node",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Official JAELIS Blockchain Node - 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!)",
   "main": "lib/index.js",
   "bin": {