jaelis.js

Official SDK for the JAELIS Blockchain - The Mother Chain.


What is JAELIS?

JAELIS is The Mother Chain - a sovereign Layer 1 blockchain where external chains (Ethereum, Solana, Bitcoin, etc.) are treated as assets in your wallet, not separate namespaces. One wallet. All chains. No bridges.

The Mother Chain Philosophy:
- External chains are assets, not namespaces
- Intent-based architecture: tell JAELIS what you want, it figures out how
- Zero fees on JAELIS - external chains handle their own gas
- Universal VM compiles 6 languages to native JAELIS bytecode
- No bridges. No wrapped tokens. No middle man.

Universal VM - Core Innovation

JAELIS provides TWO deployment systems for maximum flexibility:

$3

Compile MULTIPLE contracts from MULTIPLE languages into ONE unified bytecode bundle with ONE ABI. All contracts share memory and can call each other directly!

``javascript
const jaelis = new Jaelis.Provider('https://rpc.jaelis.io');

// 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' }
]
});
// Returns: { address, bytecode, abi, contracts: [...] }
// ALL contracts share memory and can call each other DIRECTLY!

// Cross-language call: Solidity → Rust (NO BRIDGES!)
await jaelis.crossContractCall({
from: result.contracts.Token.address,
to: result.contracts.DeFi.address,
method: 'process_payment',
args: [amount, recipient]
});
`

$3

Deploy to native VMs for exact compatibility with original chain behavior:

`javascript
// Deploy to native VMs for maximum compatibility
await jaelis.deploySolanaProgram({ bytecode, programId, owner }); // → SVM
await jaelis.deployMoveModule({ bytecode, moduleName, owner }); // → MoveVM
await jaelis.deployTonContract({ code, data, owner }); // → TVM
await jaelis.deployWasmContract({ wasmBytecode, abi, owner }); // → WASM

// All VMs share the same state layer - they can still interact!
`

$3

| Language | Ecosystem | Use Case |
|----------|-----------|----------|
| Solidity | Ethereum, Polygon, Arbitrum | DeFi, NFTs, existing EVM contracts |
| Rust | Solana, NEAR, Polkadot | High-performance programs |
| Move | Aptos, Sui, Movement | Resource-oriented assets |
| FunC | TON (Telegram) | 900M+ user ecosystem |
| Cairo | StarkNet | ZK-provable computation |
| Vyper | Ethereum | Python-like contract development |

Cross-Chain Settlement (30+ Chains)

Read and verify state from 30+ external blockchains directly in your JAELIS contracts - no oracles needed:

`javascript
// Get all registered chains
const chains = await jaelis.crossChain.getChains();
// Returns: Ethereum, Polygon, Solana, Bitcoin, Cosmos, Aptos, TON, etc.

// Read Ethereum state from JAELIS
const ethBalance = await jaelis.crossChain.readState(
1, // Ethereum chain ID
'0xUSDC...', // Contract address
'balanceOf(address)', // Method
['0xUser...'] // Args
);

// Compare state across chains (arbitrage detection)
const diff = await jaelis.crossChain.getStateDiff(
1, 137, // Ethereum vs Polygon
'0xUSDC...', // Same contract
['totalSupply'] // Variables to compare
);

// Check light client sync status
const status = await jaelis.crossChain.getLightClientStatus(1);
console.log('Ethereum synced to block:', status.height);
`

Features

- JIR Native Bytecode - 251 opcodes + 93 Bitcoin sub-opcodes (more than EVM!)
- Universal VM - 6 languages, one chain, direct interop
- Cross-Chain Settlement - Read state from 30+ chains trustlessly
- Bitcoin Native - UTXO, Taproot, SegWit, PSBT, Ordinals, Lightning Network
- Borsh Serialization - Deterministic binary encoding for state proofs
- Zero Gas Fees - LODE-based computation (users pay $0)
- ERC-5792 - Atomic batch transactions
- EIP-7702 - Account abstraction (EOA → Smart Account)
- Address Safety - Anti-phishing and poisoning protection
- Passkey Wallets - Biometric authentication (Face ID, fingerprint)
- JZK Privacy - Zero-knowledge transactions with NO trusted setup
- MEV Protection - Built-in conditional transactions and TWAP oracle
- AI-Native - x402 payment protocol and MCP support
- Auto-Update Checker - Notifies when new versions are available (Node.js only)

JIR Opcodes (v1.15.0+)

Access JAELIS's native bytecode opcodes directly:

`javascript
const Jaelis = require('jaelis.js');

// JIR Opcodes - JAELIS native bytecode
console.log(Jaelis.JIR_OPCODES.BTCCALL); // 0x76 - Bitcoin operations
console.log(Jaelis.JIR_OPCODES.ENERANDOM); // 0x80 - ENE randomness
console.log(Jaelis.JIR_OPCODES.XDEPLOY); // 0xA0 - Cross-chain deploy

// Bitcoin sub-opcodes (used with BTCCALL)
console.log(Jaelis.BTC_OPCODES.TAPROOT_SIGN); // Schnorr signatures
console.log(Jaelis.BTC_OPCODES.LN_PAY); // Lightning payments
console.log(Jaelis.BTC_OPCODES.ORD_INSCRIBE); // Create Ordinals
`

Installation

`bash
npm install jaelis.js
`

Quick Start

$3


`html


`

$3

`javascript
const Jaelis = require('jaelis.js');

const jaelis = new Jaelis.Provider('https://rpc.jaelis.io');

// Check balance (always FREE to check)
const balance = await jaelis.getBalance('0x...');
console.log('Balance:', Jaelis.utils.fromLode(balance), 'JAELIS');

// Send transfer (zero fees!)
const tx = await jaelis.transfer({
from: '0x...',
to: '0x...',
value: Jaelis.utils.toLode('10')
});
`

BrowserWallet - Connect Any Wallet

Connect to ANY wallet in the browser - MetaMask (EVM), Phantom (Solana), Unisat (Bitcoin), Tonkeeper (TON):

`javascript
const wallet = new Jaelis.BrowserWallet();

// Auto-detect available wallets
const available = Jaelis.BrowserWallet.detectWallets();
// { available: true, wallets: [{ type: 'evm', name: 'MetaMask' }, { type: 'solana', name: 'Phantom' }] }

// Connect (user approves in their wallet)
const { address, chainType, walletName } = await wallet.connect();
// chainType: 'evm' | 'solana' | 'bitcoin' | 'ton'

// Or connect to specific chain type
await wallet.connect('solana'); // Connect Phantom specifically

// Get balance (works for any chain)
const balance = await wallet.getBalance();

// Sign message (works for any chain)
const signature = await wallet.signMessage('Hello JAELIS!');

// Send transaction (works for any chain)
const txHash = await wallet.sendTransaction({
to: recipientAddress,
value: amount
});

// Deploy contract (JAELIS compiles, your wallet signs)
const deployment = await wallet.deploy({
source: myContract,
language: 'rust' // or solidity, move, vyper, func, cairo
});
`

Supported Wallets:
| Type | Wallets |
|------|---------|
| EVM | MetaMask, Coinbase, Rabby, Rainbow, Brave |
| Solana | Phantom, Solflare, Backpack |
| Bitcoin | Unisat, OKX, Xverse |
| TON | Tonkeeper, TON Wallet |

Wallet Class (Programmatic)

The Wallet class provides programmatic signing - for server-side or scripts:

`javascript
const Jaelis = require('jaelis.js');

// Create provider
const provider = new Jaelis.Provider('https://rpc.jaelis.io');

// Create wallet from private key
const wallet = new Jaelis.Wallet(privateKey, provider);

// Or generate a random wallet
const randomWallet = Jaelis.Wallet.createRandom(provider);
console.log('Address:', randomWallet.address);
console.log('Private Key:', randomWallet.privateKey);

// Connect existing wallet to provider
const connectedWallet = wallet.connect(provider);

// Get balance
const balance = await wallet.getBalance();

// Transfer tokens
const tx = await wallet.transfer('0xRecipient...', '1000000000000000000');

// Deploy contract
const deployment = await wallet.deploy(bytecode, abi, constructorArgs);
console.log('Contract:', deployment.address);

// Sign message
const signature = await wallet.signMessage('Hello JAELIS!');

// Sign and send transaction
const result = await wallet.sendTransaction({
to: '0x...',
value: '1000000000000000000',
data: '0x...'
});
`

$3

Deploy to multiple chains with real cryptographic signatures:

`javascript
const wallet = new Jaelis.Wallet(privateKey, provider);

// Deploy to Ethereum, Polygon, Arbitrum, and Base
const result = await wallet.deployMultiChain({
bytecode: contractBytecode,
abi: contractAbi,
targetChains: [1, 137, 42161, 8453]
});

console.log('Deployed to chains:', result.deployments);
// Each chain gets a cryptographically signed deployment
`

ERC-5792 - Atomic Batch Transactions

Send multiple transactions as one atomic operation:

`javascript
// Get wallet capabilities
const caps = await jaelis.getCapabilities();
console.log('Supports atomic batching:', caps.atomicBatch.supported);

// Send atomic batch
const batchId = await jaelis.sendCalls([
{ to: '0xToken...', data: approveData },
{ to: '0xDEX...', data: swapData },
{ to: '0xStaking...', data: stakeData }
]);

// Check batch status
const status = await jaelis.getCallsStatus(batchId);
// 'pending' | 'confirmed' | 'failed'

// Grant session permissions (for dApps)
await jaelis.grantPermissions({
spend: { token: '0xUSDC...', limit: '1000' },
contracts: ['0xDEX...', '0xNFT...']
}, 3600); // 1 hour expiry
`

EIP-7702 - Account Abstraction

Transform your EOA into a smart account:

`javascript
// Authorize contract code for your EOA
const auth = await jaelis.authorizeAccountCode(
'0xSmartAccountImpl...', // Implementation contract
smartAccountBytecode
);

// Send transaction with delegation
const tx = await jaelis.sendTransactionWithDelegation(
{ to: '0x...', value: '1000000000000000000' },
[auth] // Authorization list
);
`

Address Safety - Anti-Phishing

Protect users from address poisoning and phishing attacks:

`javascript
// Validate address before sending
const safety = await jaelis.validateAddressSafety(
'0xRecipient...',
['0xKnownTrusted1...', '0xKnownTrusted2...'] // User's known addresses
);

console.log('Safe:', safety.safe); // true/false
console.log('Score:', safety.score); // 0-100
console.log('Issues:', safety.issues); // ['similar_to_known', 'dust_attack', etc.]
console.log('Warning:', safety.warning); // Human-readable warning

// Check for dust attacks (address poisoning)
const dustCheck = await jaelis.checkDustAttacks('0x...', recentAddresses);

// Whitelist trusted addresses
await jaelis.markAddressTrusted('0xPartner...', 'verified business partner');
`

Privacy (JZK Protocol)

Zero-knowledge transactions with NO trusted setup:

`javascript
// Shield tokens (move to private pool)
await jaelis.shieldTokens({
from: '0x...',
amount: '100'
});

// Private transfer
await jaelis.shieldedTransfer({
from: '0x...',
to: '0x...',
amount: '50',
memo: 'Private payment'
});

// Check shielded balance
const privateBalance = await jaelis.getShieldedBalance(viewingKey);
`

Borsh Serialization

Deterministic binary serialization for state proofs and cross-chain verification:

`javascript
// Serialize data using Borsh (deterministic - same data = same bytes)
const data = { amount: 1000n, recipient: new Uint8Array(20) };
const schema = {
struct: {
amount: 'u64',
recipient: { array: { type: 'u8', len: 20 } }
}
};
const bytes = Jaelis.borsh.serialize(schema, data);

// Deserialize back
const decoded = Jaelis.borsh.deserialize(schema, bytes);

// Use pre-defined schemas for common types
const proof = {
chainId: 1,
blockNumber: 18500000n,
contractAddress: Jaelis.borsh.hexToBytes('0x...'),
slot: new Uint8Array(32),
value: new Uint8Array(32),
proof: []
};
const proofBytes = Jaelis.borsh.serialize(Jaelis.borsh.SCHEMAS.SettlementProof, proof);

// Available schemas: StateSlot, SettlementProof, AccountState, StorageEntry
`

MEV Protection

Built-in protection against front-running:

`javascript
// Conditional transaction (executes only when condition met)
const tx = await jaelis.submitConditionalTransaction({
from: '0x...',
to: '0xDEX...',
data: swapData,
condition: {
type: 'price_above',
asset: '0xToken...',
value: '1.5'
}
});

// Analyze MEV risk before trading
const risk = await jaelis.analyzeMEVRisk(mySwapTx);
console.log('Risk Level:', risk.riskLevel); // 'low' | 'medium' | 'high'

// Get TWAP for fair pricing
const twap = await jaelis.getTWAP('0xToken...', 3600); // 1 hour average
`

Multi-VM Deployment

Deploy contracts from any ecosystem:

`javascript
// EVM (Solidity)
const evmContract = await jaelis.deploy({
from: '0x...',
bytecode: solidityBytecode,
abi: contractAbi,
args: ['Hello JAELIS']
});

// Solana (Rust)
const solanaProgram = await jaelis.deploySolanaProgram({
from: '0x...',
bytecode: rustBytecode,
programId: '...'
});

// Move (Aptos/Sui)
const moveModule = await jaelis.deployMoveModule({
from: '0x...',
bytecode: moveBytecode,
moduleName: 'my_module'
});

// TON (FunC)
const tonContract = await jaelis.deployTonContract({
from: '0x...',
code: funcCode,
data: initialData
});

// Cairo (StarkNet)
const cairoContract = await jaelis.deployCairoContract({
from: '0x...',
bytecode: cairoSierra,
classHash: '0x...'
});

// Vyper
const vyperContract = await jaelis.deployVyperContract({
from: '0x...',
bytecode: vyperBytecode
});
`

Cross-Chain Deployment

Deploy your JAELIS contracts to external chains. Write once in any language, compile to JIR bytecode on JAELIS, then deploy the EVM-compatible output to Ethereum, Polygon, etc.

`javascript
const deployer = new Jaelis.CrossChainDeployer();

// Compile your contract on JAELIS (any language!)
const compiled = await jaelis.compile({
source: myContract,
language: 'solidity' // or rust, move, vyper, func, cairo
});

// User clicks "Deploy to Ethereum" button
// MetaMask pops up, user confirms, wallet signs & pays gas
const result = await deployer.deployWithMetaMask({
chainId: 11155111, // Sepolia testnet
bytecode: compiled.evmBytecode,
abi: compiled.abi
});

console.log('Contract:', result.address);
console.log('Explorer:', result.explorer);
`

How it works:
1. User connects their wallet (MetaMask, WalletConnect, etc.)
2. dApp calls deployWithMetaMask()
3. Wallet prompts user to confirm & sign
4. User's wallet pays gas on target chain
5. Contract deployed!

Supported External Chains:
| Chain | ID | Gas Cost |
|-------|-----|----------|
| Ethereum | 1 | ~$20-100 |
| Polygon | 137 | ~$0.01 |
| Arbitrum | 42161 | ~$0.10 |
| Base | 8453 | ~$0.05 |
| Sepolia | 11155111 | FREE (testnet) |
| JAELIS | 4545 | ZERO |

> On JAELIS native: Zero fees, always. On external chains: User's wallet pays that chain's gas.

Multi-Chain Address Validation

Validate addresses from any blockchain:

`javascript
// Validate any chain address
const validation = jaelis.validateMultiChainAddress('0x742d35cc...');
// { valid: true, type: 'evm', chain: 'ethereum' }

const solValidation = jaelis.validateMultiChainAddress('9WzDX...');
// { valid: true, type: 'solana' }

const btcValidation = jaelis.validateMultiChainAddress('bc1q...');
// { valid: true, type: 'bitcoin_bech32' }

// Get address type
const type = jaelis.getAddressType('EQDrLq-X6jK...');
// 'ton'
`

WebSocket Subscriptions

Subscribe to real-time events using WebSocket:

`javascript
const jaelis = new Jaelis.Provider('https://rpc.jaelis.io');

// Subscribe to new blocks
const subId = await jaelis.onNewBlock((block) => {
console.log('New block:', block.number, block.hash);
});

// Subscribe to pending transactions
await jaelis.onPendingTransaction((txHash) => {
console.log('New pending tx:', txHash);
});

// Subscribe to contract events (logs)
await jaelis.onLogs({
address: '0xContractAddress...',
topics: ['0xEventSignature...']
}, (log) => {
console.log('Event:', log);
});

// Unsubscribe when done
await jaelis.unsubscribe(subId);
`

Low-level WebSocket access:
`javascript
const ws = new Jaelis.SubscriptionManager('wss://rpc.jaelis.io/ws');
await ws.connect();

// Subscribe to newHeads
const subId = await ws.subscribe('newHeads', (header) => {
console.log('Block #' + parseInt(header.number, 16));
});

// RPC calls over WebSocket
const blockNumber = await ws.send('jaelis_blockNumber');

// Disconnect
ws.disconnect();
`

Event System (v1.17.0+)

The SDK provides a built-in EventEmitter for monitoring SDK operations and debugging:

`javascript
const Jaelis = require('jaelis.js');
const jaelis = new Jaelis.Provider('https://rpc.jaelis.io');

// Listen for SDK events
jaelis.on(Jaelis.EVENTS.INFO, (data) => {
console.log('[INFO]', data.message);
});

jaelis.on(Jaelis.EVENTS.WALLET_CONNECTED, ({ ecosystem, address }) => {
console.log(Connected ${ecosystem} wallet: ${address});
});

jaelis.on(Jaelis.EVENTS.DEPLOY_PROGRESS, (data) => {
console.log(Deployment step: ${data.step});
});

jaelis.on(Jaelis.EVENTS.ERROR, (data) => {
console.error(Error: ${data.message});
});
`

Available Events (Jaelis.EVENTS):

| Category | Events |
|----------|--------|
| Connection | CONNECTED, DISCONNECTED, RECONNECTING, ERROR |
| WebSocket | WS_OPEN, WS_CLOSE, WS_ERROR, WS_MESSAGE |
| Wallet | WALLET_CONNECTED, WALLET_DISCONNECTED, WALLET_CHAIN_CHANGED, WALLET_ACCOUNTS_CHANGED |
| Transactions | TX_SENT, TX_CONFIRMED, TX_FAILED, TX_PENDING |
| Chain Approvals | CHAIN_APPROVED, CHAIN_REVOKED, CHAIN_APPROVAL_FAILED |
| Deployment | DEPLOY_STARTED, DEPLOY_PROGRESS, DEPLOY_COMPLETED, DEPLOY_FAILED |
| Device SIGIL | SIGIL_BENCHMARK_START, SIGIL_BENCHMARK_COMPLETE, SIGIL_OPERATION |
| Debug | DEBUG, INFO, WARN |

Custom EventEmitter:
`javascript
// Create your own EventEmitter
const emitter = new Jaelis.EventEmitter();

emitter.on('myEvent', (data) => console.log(data));
emitter.once('oneTime', (data) => console.log(data)); // Fires once
emitter.emit('myEvent', { foo: 'bar' });
emitter.off('myEvent', listenerFn); // Remove listener
`

API Reference

$3


| Method | Description |
|--------|-------------|
| new Wallet(privateKey, provider?) | Create wallet from private key |
| Wallet.createRandom(provider?) | Generate random wallet |
| wallet.connect(provider) | Connect to provider |
| wallet.getBalance() | Get wallet balance |
| wallet.transfer(to, amount) | Transfer native tokens |
| wallet.deploy(bytecode, abi?, args?) | Deploy contract |
| wallet.deployMultiChain(params) | Cross-chain deployment |
| wallet.signMessage(message) | Sign message |
| wallet.signTransaction(tx) | Sign transaction |
| wallet.sendTransaction(tx) | Sign and send transaction |

$3

| Method | Description |
|--------|-------------|
| getSupportedLanguages() | Get supported VM languages |
| deploy(params) | Deploy contract in any language |
| crossContractCall(params) | Call between different language contracts |

$3

| Method | Description |
|--------|-------------|
| crossChain.getChains() | List all 30+ registered chains |
| crossChain.getChainInfo(chainId) | Get chain metadata |
| crossChain.readState(chainId, contract, method, args) | Read external chain state |
| crossChain.settleState(chainId, contract, key, value, proof) | Settle state with proof |
| crossChain.getStateDiff(chainA, chainB, contract, keys) | Compare state across chains |
| crossChain.getLightClientStatus(chainId) | Get light client sync status |

$3

| Method | Description |
|--------|-------------|
| getCapabilities(address?) | Get wallet capabilities |
| sendCalls(calls) | Send atomic batch |
| getCallsStatus(batchId) | Check batch status |
| grantPermissions(permissions, expiry) | Grant session permissions |
| revokePermissions(sessionId) | Revoke session |

$3

| Method | Description |
|--------|-------------|
| authorizeAccountCode(address, code) | Authorize contract code for EOA |
| sendTransactionWithDelegation(tx, authList) | Send with delegation |

$3

| Method | Description |
|--------|-------------|
| validateAddressSafety(address, known) | Full safety analysis (score 0-100) |
| checkDustAttacks(address, recent) | Detect address poisoning |
| markAddressTrusted(address, reason) | Whitelist address |

$3

| Method | Description |
|--------|-------------|
| shieldedTransfer(params) | Private transaction |
| shieldTokens(params) | Move to shielded pool |
| unshieldTokens(params) | Move to public |
| getShieldedBalance(viewingKey) | Check private balance |

$3

| Method | Description |
|--------|-------------|
| Jaelis.borsh.serialize(schema, data) | Serialize data to deterministic bytes |
| Jaelis.borsh.deserialize(schema, buffer) | Deserialize bytes back to data |
| Jaelis.borsh.hexToBytes(hex) | Convert hex string to Uint8Array |
| Jaelis.borsh.bytesToHex(bytes) | Convert Uint8Array to hex string |
| Jaelis.borsh.SCHEMAS | Pre-defined schemas (StateSlot, SettlementProof, etc.) |

$3

| Method | Description |
|--------|-------------|
| requestFaucet(address) | Request testnet tokens (1000 tJAELIS) |
| getFaucetStatus() | Get faucet availability and limits |
| getFaucetCooldown(address) | Check cooldown before next request |

$3

| Method | Description |
|--------|-------------|
| onNewBlock(callback) | Subscribe to new block headers (real-time sync) |
| onPendingTransaction(callback) | Subscribe to pending transactions |
| onLogs(filter, callback) | Subscribe to contract events |
| unsubscribe(subscriptionId) | Unsubscribe from updates |

> Note: JAELIS uses PoEC (Proof of Efficient Consensus), not mining. onNewBlock notifies when validators produce new blocks - useful for syncing, tracking confirmations, and building real-time dApps.

$3


| Method | Description |
|--------|-------------|
| getBlockNumber() | Get latest block |
| getBalance(address) | Get balance |
| transfer(params) | Send JAELIS |
| transferWithMessage(params) | Send with memo/metadata |
| getLodeSignal() | Get network load signal |

$3

| Method | Description |
|--------|-------------|
| deploy(params) | Deploy EVM/Solidity |
| deploySolanaProgram(params) | Deploy Rust program |
| deployMoveModule(params) | Deploy Move module |
| deployTonContract(params) | Deploy FunC contract |
| deployCairoContract(params) | Deploy Cairo contract |
| deployVyperContract(params) | Deploy Vyper contract |

Mother Chain RPC Architecture

JAELIS uses a Mother Chain model where external chains are assets in your wallet:

`javascript
// Native JAELIS methods - the ONLY namespace for JAELIS blockchain
jaelis_chainId // Returns 4545 (testnet) or 4547 (mainnet)
jaelis_getBalance // Get JAELIS balance
jaelis_transfer // Transfer JAELIS tokens (zero fees!)
jaelis_deploy // Deploy to any chain via intent

// External chains return THEIR chain info (they're assets)
eth_chainId // Returns 0x1 (Ethereum's chain ID)
sol_chainId // Returns Solana's chain ID
btc_chainId // Returns Bitcoin's chain ID

// Intent-based cross-chain operations
jaelis_deploy({ chain: 'ethereum', bytecode: '...' }) // Deploy to ETH
jaelis_transfer({ asset: 'ETH', amount: '1.0', to: '...' }) // Send ETH
jaelis_swap({ from: { asset: 'ETH' }, to: { asset: 'SOL' } }) // Cross-chain swap
`

Key Difference from Other Chains:
- eth_chainId returns Ethereum's chain ID (1), not JAELIS
- External chains are assets you hold in your JAELIS wallet
- Use jaelis_* for native JAELIS operations
- Use intent-based methods for cross-chain operations

Note: All JAELIS operations have zero fees. External chain operations use that chain's gas.

Network Info

| Network | RPC URL | Chain ID | Currency |
|---------|---------|----------|----------|
| Testnet | https://rpc.jaelis.io | 4545 | tJAELIS |
| Mainnet | https://mainnet.jaelis.io` | 4547 | JAELIS |

Why JAELIS?

1. Universal VM - Deploy Solidity, Rust, Move, FunC, Cairo, or Vyper contracts. They all run natively and can call each other directly.

2. Cross-Chain Settlement - Read and verify state from 30+ external blockchains. No oracles. No bridges. Direct light client verification.

3. Zero Gas Fees - Users never pay transaction fees. The LODE system tracks computation without charging.

4. Modern Wallet Standards - ERC-5792 atomic batching, EIP-7702 account abstraction, passkey authentication.

5. Address Safety - Built-in protection against phishing, address poisoning, and dust attacks.

6. Privacy by Default - JZK protocol for zero-knowledge transactions with NO trusted setup.

7. MEV Protection - Conditional transactions and TWAP oracle prevent front-running.

8. AI-Native - Built-in x402 payment protocol and MCP server for AI agent monetization.

Links

- Node Software: npmjs.com/package/jaelis-node
- Website: jaelis.io
- Documentation: docs.jaelis.io
- GitHub: github.com/jaelis-foundation

License

MIT - JAELIS Foundation