Ethereum requires you to write code. JIL lets you configure. Every token on JIL is a smart contract with built-in compliance.
Ethereum tokens are compiled bytecode deployed on a permissionless chain. JIL tokens are configured via parameters and deployed through a KYB-gated Token Factory with automatic compliance.
Compare what it takes to create a token, handle transfers, and enforce compliance on each platform.
// Ethereum: 193+ lines across 3 contracts pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/access/AccessControl.sol"; interface IComplianceHook { function checkTransfer( address from, address to, uint256 amount ) external view returns ( bool allowed, string memory reason ); } contract MyToken is ERC20, AccessControl { IComplianceHook public complianceHook; mapping(address => bool) public blocklist; bool public paused; constructor() ERC20("MyToken", "MTK") { _mint(msg.sender, 1_000_000 * 10**18); } function _update( address from, address to, uint256 amount ) internal override { require(!paused, "Paused"); require(!blocklist[from], "Sender blocked"); require(!blocklist[to], "Recipient blocked"); if (address(complianceHook) != address(0)) { (bool ok, string memory reason) = complianceHook.checkTransfer(from, to, amount); require(ok, reason); } super._update(from, to, amount); } // + setComplianceHook() ........... 12 lines // + setBlocklist() ................ 8 lines // + setPaused() ................... 6 lines // + AccessControl setup ........... 15 lines // + ComplianceHookImpl.sol ........ 87 lines // + IComplianceHook.sol ........... 20 lines // Total: 193+ lines, 3 contracts // Then: audit, test, deploy, manage... }
// JIL Sovereign: A configuration. Zero code. // Submit to Token Factory. That's it. { "name": "MyToken", "symbol": "MTK", "decimals": 18, "initial_supply": 1000000, "issuer_id": "corp-acme-001", "zone_restrictions": ["protected"], "humanity_fee_bps": 100, "transferable": true, "certification_id": "CERT-2026-0042" } // What you get automatically: // // Compliance ......... ATCE trust scoring // Freeze/Unfreeze .... Built into JIL20 // Zone isolation ..... Protected, Unprotected, // Quarantine, Internal, External // Humanity fee ....... 1% to humanitarian fund // Anti-dump .......... 10%/day sell limit, 30 days // KYB gating ......... Issuer verified before deploy // Mint/Burn .......... Admin-controlled // // No Solidity. No bytecode. No audits needed. // Source: TokenConfig struct, jil20.rs:121-143
// Ethereum: You write every check yourself function _update( address from, address to, uint256 amount ) internal override { // 1. Check pause state require(!paused, "Paused"); // 2. Check blocklist (both sides) require(!blocklist[from], "Sender blocked"); require(!blocklist[to], "Recipient blocked"); // 3. External compliance call (gas cost) if (address(complianceHook) != address(0)) { (bool ok, string memory reason) = complianceHook.checkTransfer(from, to, amount); require(ok, reason); } // 4. No zone concept exists // 5. No humanitarian fee concept // 6. No anti-dump protection super._update(from, to, amount); } // If a blocked user tries to send: // - Tx enters mempool // - Miner includes it in block // - EVM executes, hits require() // - REVERTS inside the contract // - Gas STILL consumed (wasted) // - User pays for a failed tx
// JIL: All checks built into JIL20 standard // Source: jil20.rs:316-371 fn do_transfer(&mut self, from: &Address, to: &Address, amount: u128 ) -> Result<(), TokenError> { // 1. Check transferability if !self.config.transferable { return Err(TokenError::NotTransferable); } // 2. Check frozen (BOTH accounts) if self.frozen_accounts.contains(from) { return Err(TokenError::AccountFrozen); } if self.frozen_accounts.contains(to) { return Err(TokenError::AccountFrozen); } // 3. Check zone restrictions self.check_zone_restrictions(from, to)?; // 4. Calculate humanity fee automatically let fee = amount * self.config.humanity_fee_bps / 10_000; let net = amount - fee; // 5. Transfer net + fee to humanity pool self.transfer_internal(from, to, net)?; if fee > 0 { self.transfer_internal( from, &self.humanity_pool, fee )?; } Ok(()) } // Frozen account tries to send? // - REJECTED before execution // - Never enters a block // - Gas used: 0 // - Instant error feedback
// Ethereum: Write a separate compliance contract // Deploy it. Link it. Manage it. Audit it. contract ComplianceHookImpl is IComplianceHook { mapping(address => bool) public sanctioned; mapping(address => uint256) public kycExpiry; mapping(address => bool) public accredited; function checkTransfer( address from, address to, uint256 /* amount */ ) external view returns ( bool, string memory ) { if (sanctioned[from]) return (false, "Sender sanctioned"); if (sanctioned[to]) return (false, "Recipient sanctioned"); if (kycExpiry[from] < block.timestamp) return (false, "KYC expired"); return (true, ""); } // + setSanctioned() .......... 8 lines // + setKycExpiry() ........... 8 lines // + setAccredited() .......... 8 lines // + Admin role management .... 20 lines // + Oracle integration ....... 30 lines // // Total: 87+ lines, separate deploy // Must be linked to EACH token contract // No anti-dump. No zone isolation. // No humanitarian fund support. }
// JIL: ATCE evaluates every identity automatically // Source: ate_integration.rs + ATCE anti-dump tables // Trust levels (auto-assigned by ATCE): enum TrustLevel { Blocked, // Sanctioned, prohibited HighRisk, // PEP, high-risk jurisdiction MediumRisk, // Enhanced due diligence LowRisk, // Standard verified Trusted, // Fully verified, fast-track } // Anti-dump protection (per vesting unlock): // Tier 1: 30-day enforcement, 1.5x multiplier // Tier 2: 60-day enforcement, 2x multiplier // Tier 3: 90-day enforcement, 3x multiplier // All tiers: 10% daily sell limit // Zone enforcement (5 zones): // Protected → Regulated tokens, full KYC // Unprotected → Standard tokens // Quarantine → Flagged/frozen assets // Internal → System-only tokens // External → Bridged assets // // Cross-zone transfer? Automatically BLOCKED. // Protected → Unprotected = DENIED // KYB for issuers (mandatory): // - Business verification required // - Certification must be active // - Token Factory checks automatically // - No code. No contract. No audit. // ATCE decision log: // APPROVED | BLOCKED | PARTIAL // Full audit trail with reason codes // 10 jurisdiction-specific rule sets // (CH/FINMA, US/FinCEN, SG/MAS, ...)
Click the buttons below to simulate token deployment and transfer scenarios on both platforms.
Every feature you need for institutional-grade token management, compared side by side.
| Feature | Ethereum | JIL Sovereign |
|---|---|---|
| Token creation | Write Solidity, compile, deploy bytecode | Submit JSON config to Token Factory Zero code |
| Compliance | Add manually per contract DIY | ATCE built-in trust scoring Automatic |
| Account freeze | Implement blocklist mapping yourself | Built-in freeze() / unfreeze() on every token |
| Zone isolation | Not supported | 5 zones: Protected, Unprotected, Quarantine, Internal, External |
| Humanitarian fee | Write custom transfer hook Manual | humanity_fee_bps config parameter Built-in |
| Anti-dump protection | Custom vesting + timelock contracts Complex | ATCE: 10%/day sell limit, 30-day enforcement Automatic |
| KYB for issuers | Not required , anyone can deploy None | Mandatory , Token Factory checks KYB |
| Frozen acct transfer | Fails in contract (gas wasted) Wasteful | Rejected pre-execution (zero gas) Efficient |
| Token standard | ERC-20 (many variants, inconsistent) | JIL20 (single standard, all features built-in) |
| Ecosystem model | Open / permissionless | Walled garden , curated, institutional-grade |
| Post-quantum security | Not available | Dilithium / Kyber built-in 3-5yr head start |
| Protection | Not available | $250K+ automatic (Premium tier) Included |
Key metrics that matter for institutional token operations.
JIL is not permissionless by design. Here's why that's a feature, not a limitation.
Every token issuer must pass KYB verification. No scam tokens, no rug pulls, no anonymous deploys. The Token Factory gates entry, so every token in the ecosystem meets institutional standards.
ATCE anti-dump enforcement, zone isolation, freeze capabilities, and humanitarian fees protect all participants automatically. No token issuer can opt out of safety features.
$250K+ automatic protection coverage, post-quantum Dilithium/Kyber security, 14-of-20 validator consensus across 13 jurisdictions, and 13 jurisdiction-specific compliance rule sets.
Zero code. Built-in compliance. Institutional-grade security.