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:

Option 1: Unified VM (Cross-Language Magic)

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

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]
});

Option 2: Multi-VM (Native Compatibility)

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

// 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!

Language Support Matrix

| 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:

// 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:

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

npm install jaelis.js

Quick Start

Browser (CDN)

<script src="https://unpkg.com/jaelis.js"></script>
<script>
  const jaelis = new Jaelis.Provider('https://rpc.jaelis.io');
  const block = await jaelis.getBlockNumber();
</script>

Node.js

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):

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:

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...'
});

Cross-Chain Deployment with Wallet

Deploy to multiple chains with real cryptographic signatures:

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:

// 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:

// 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:

// 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:

// 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:

// 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:

// 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:

// 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.

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:

// 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:

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:

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:

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:

// 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

Wallet Class

| 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 |

Universal VM

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

Cross-Chain Settlement

| 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 |

ERC-5792 Wallet Capabilities

| 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 |

EIP-7702 Account Abstraction

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

Address Safety

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

Privacy (JZK)

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

Borsh Serialization

| 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.) |

Faucet (Testnet)

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

WebSocket Subscriptions

| 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.

Core Methods

| 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 |

Multi-VM Deployment

| 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:

// 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