Build on the Most Advanced Settlement Protocol Ever Engineered
Five production APIs, self-healing smart contracts, zero-knowledge compliance, post-quantum cryptography, and 190+ microservices. JIL Sovereign is the infrastructure layer the industry has been waiting for.
Every blockchain forces developers to choose. Speed or security. Compliance or decentralization. Usability or self-custody. We engineered a platform where you never have to choose.
Most blockchain developer experiences are painful. You cobble together third-party oracles, write custom compliance logic, pray your bridge contract doesn't get exploited, and hope that your users can figure out MetaMask. We built JIL because we were tired of watching brilliant developers waste months on infrastructure problems that should have been solved at the protocol level.
The result is a developer platform with five production-ready APIs, a Rust-based consensus engine that finalizes blocks in 1.5 seconds, smart contracts that detect and fix their own bugs, and a compliance layer that proves KYC/AML without exposing private data. Every service is documented, every endpoint is typed, and every integration path has been tested under load.
You don't need to build compliance infrastructure, bridge security, key management, or insurance wrappers. It's all already here. Focus on your application logic. We handle the hard parts.
1.5s Finality
Rust-based ledger engine (jil5600-core) with BFT-style Proof-of-Stake consensus and BPoH timestamps. No waiting for confirmations. Your transactions are final in one block.
Post-Quantum Ready
Dilithium signatures and Kyber key encapsulation across the entire stack. Your application is quantum-safe from day one.
13 Jurisdictions
20 validators across 13 countries. Built-in compliance corridors for every major regulatory framework. Deploy once, comply everywhere.
RESTful endpoints with full OpenAPI specs. WebSocket streams for real-time data. Client libraries for TypeScript and Python.
We built the SDK we wished existed when we started. Zod-validated request/response schemas on every endpoint. Pino structured logging on every service. If you've used Stripe's API, you'll feel right at home.
The JIL SDK provides unified access to the entire platform through a single authentication flow. JWT-based auth with WebAuthn passkey support means your users never touch a seed phrase, and your application never handles raw private keys. Every API call is auditable, rate-limited, and fully documented.
Authentication: All API access uses JWT tokens with a 7-day expiration. For server-to-server integrations, API keys are available with configurable scopes. WebAuthn passkey authentication is supported for user-facing flows, eliminating passwords entirely.
// Authenticate and get a JWT
const response = await fetch('https://api.jilsovereign.com/v1/auth/token', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
grant_type: 'api_key',
api_key: process.env.JIL_API_KEY
})
});
const { access_token } = await response.json();
// Use the token for all subsequent calls
const wallet = await fetch('https://api.jilsovereign.com/v1/wallets', {
method: 'POST',
headers: {
'Authorization': `Bearer ${access_token}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ label: 'Treasury Wallet' })
});Real-Time Streams: Every API supports WebSocket subscriptions for real-time updates. Subscribe to block confirmations, transaction status changes, settlement events, or pool price movements. No polling required.
Every API is versioned, rate-limited, and returns consistent JSON responses with standard error codes.
All endpoints accept and return application/json. Pagination follows cursor-based patterns for scalability. Every request is validated with Zod schemas before processing.
Wallet API
The Wallet API handles everything from MPC key generation to threshold signing to guardian recovery ceremonies. Users get MPC 2-of-3 threshold signing (they always hold a key shard), passkey authentication (no seed phrases), and guardian-based recovery - all through a single API.
Create a new MPC wallet. Generates 2-of-3 key shards: user shard, platform shard, recovery shard.
Submit a transaction for threshold signing. Requires user shard + one other shard.
Start a guardian recovery ceremony. 24-hour timelock enforced on-chain.
Ledger API
The Ledger API is the gateway to the jil5600-core Rust engine. The API abstracts the complexity while exposing the full power of the settlement engine. Developers shouldn't need to understand PoS consensus internals to query account balances or submit transactions.
Submit a transaction to the ledger. Routed through compliance checks, then committed to L1.
Query block by height. Includes all transactions, state roots, and validator signatures.
Account state including balance, nonce, token holdings, and transaction history.
Settlement API
Settlement is the beating heart of JIL Sovereign. Institutional adoption requires T+0 atomic finality with provable compliance, and no existing platform offered both. Every settlement is routed through jurisdiction-specific compliance zones, validated by authorized validators, and generates a cryptographic proof of finality.
Submit a settlement. Auto-routed to the correct compliance zone based on jurisdiction.
Retrieve the cryptographic finality proof. Verifiable on-chain by any third party.
Compliance status including zone, checks passed, and jurisdiction-specific details.
Launchpad API
Launching a token should be as straightforward as deploying a web app. Configure your parameters, set your compliance corridors, and launch. The platform handles bonding curves, vesting enforcement, and regulatory compliance automatically.
Create a token launch with LBP bonding curve, vesting schedule, and compliance corridors.
Real-time raise progress, participant count, current price, and liquidity depth.
Register webhooks for launch events: milestone reached, price threshold, raise complete.
ISO 20022 Gateway
The financial world runs on SWIFT messages, not JSON-RPC. The gateway translates between SWIFT message types (pacs.008, pacs.009, camt.053) and JIL's native settlement protocol. Banks and payment processors can integrate without changing their existing infrastructure.
Translate a SWIFT message (pacs.008/009, camt.053) to a JIL settlement instruction.
Submit a SWIFT-formatted settlement. Gateway handles translation, compliance, and finality proof generation.
API Comparison
| API | Port | Purpose | Key Features |
|---|---|---|---|
| Wallet | 8002 | Key management & custody | MPC signing, guardian recovery, passkeys |
| Ledger | 8001 | Settlement ledger access | Tx submission, block queries, state reads |
| Settlement | 8084 | Institutional settlement | T+0 finality, compliance zones, proofs |
| Launchpad | 8004 | Token launches | LBP curves, vesting, raise monitoring |
| ISO 20022 | 8090 | SWIFT integration | pacs/camt translation, fiat bridging |
Smart contracts that detect anomalies, pause affected functions, roll back to known-good state, and adjust parameters - all without human intervention.
In 2016, The DAO hack drained $60 million. In 2022, Wormhole lost $320 million. In 2023, Euler Finance lost $197 million. Every year, billions are lost to bugs that could have been caught automatically. We fixed this at the protocol level.
Autonomous Bug Detection
Runtime invariant checking monitors contract state after every execution. If a state transition violates defined invariants (balance sum changes, unauthorized role escalation, reentrancy depth exceeded), the contract pauses the affected function within the same block.
State Rollback
Every contract maintains checkpoints at configurable intervals. When an anomaly is detected, the contract can roll back to the last valid checkpoint without affecting unrelated state. Rollbacks are atomic and auditable on-chain.
Parameter Auto-Adjustment
Contracts can self-tune numerical parameters (fee rates, slippage bounds, rate limits) based on observed usage patterns. Adjustments are bounded by governance-defined ranges and logged on-chain for transparency.
Zero-Downtime Upgrades
Proxy-based upgrade pattern with built-in state migration. Deploy a new implementation, the proxy routes calls to the new version, and the old version remains available as a fallback. No migration downtime. No stuck funds.
Self-healing is opt-in per function. Add the @selfHealing annotation to your contract, define your invariants, and the runtime handles the rest. Your existing Solidity code works unchanged. Self-healing is an upgrade, not a rewrite.
JIL supports both Solidity (EVM-compatible) and Anchor (Solana-compatible) smart contract development. Deploy your existing contracts with zero modifications, or take advantage of JIL-specific extensions like self-healing, ZK compliance hooks, and cross-chain messaging.
Prove regulatory compliance without exposing private data. The proof is cryptographically verifiable. The data stays private.
Compliance has always been the enemy of privacy in crypto. To prove you're not a sanctioned entity, you typically have to hand over your passport, tax returns, and bank statements to a third party who stores them in a database that will eventually get breached. We built ZK Compliance because developers and users deserve a better option.
JIL's ZK Compliance layer uses zero-knowledge proofs to verify regulatory requirements without exposing the underlying data. Your application can verify that a user has passed KYC, is not on a sanctions list, meets jurisdictional requirements, and qualifies for specific trading corridors - all without ever seeing the user's personal information.
KYC/AML Verification
Prove identity verification status without revealing identity documents. The ZK proof attests that a licensed KYC provider has verified the user. Your application receives a boolean and a proof hash, not a passport scan.
Sanctions Screening
Real-time screening against OFAC, EU, UN, and national sanctions lists. The proof confirms "not on any active sanctions list" without revealing which lists were checked or any matching criteria.
Jurisdiction Checks
Verify that a user is eligible to transact in a specific compliance zone (US/FinCEN, EU/ESMA, SG/MAS, etc.) without revealing their country of residence or citizenship.
ATCE Corridors
The Automatic Token Compliance Engine enforces jurisdiction-specific rules on every transaction. Developers set the corridor, ATCE handles the rest: velocity limits, transaction caps, asset restrictions, and cross-border rules.
13 Compliance Zones
| Zone | Jurisdiction | Regulator | Key Rules |
|---|---|---|---|
US_FINCEN | United States | FinCEN | $10K reporting, SAR filing, travel rule |
EU_ESMA | European Union | ESMA | MiCA compliance, GDPR data handling |
SG_MAS | Singapore | MAS | Payment Services Act, AML/CFT |
CH_FINMA | Switzerland | FINMA | VQF SRO membership, DLT Act |
GB_FCA | United Kingdom | FCA | Financial promotions, AML registration |
DE_BAFIN | Germany | BaFin | KWG licensing, crypto custody rules |
JP_JFSA | Japan | JFSA | PSA registration, segregated custody |
AE_FSRA | UAE | FSRA | ADGM framework, VARA compliance |
BR_CVM | Brazil | CVM | Virtual asset provider registration |
GLOBAL_FATF | Global | FATF | Travel rule, beneficial ownership |
14-of-20 validator bridge architecture that could survive a nation-state attack.
Bridge hacks have cost the industry over $2.5 billion since 2021. Ronin: $625M. Wormhole: $320M. Nomad: $190M. Harmony: $100M. Nearly every bridge exploit follows the same pattern: too few signers, compromised keys, or centralized custody of locked assets.
JIL's bridge requires 14 out of 20 validators to sign every cross-chain transfer. These validators are distributed across 13 jurisdictions on 4 continents. Compromising the bridge requires simultaneously compromising organizations in 7+ countries with different legal systems, different hosting providers, and different operational security practices. That's not a practical attack vector. That's a geopolitical impossibility.
Ethereum Bridge
Lock-and-mint architecture with 14-of-20 threshold signing. Bridge JIL, USDC, USDT, ETH, and ERC-20 tokens between Ethereum and JIL Sovereign. Full Solidity bridge contract verified on Etherscan.
Solana Bridge
Anchor-based bridge program for SPL token transfers. Same 14-of-20 security model. Sub-second finality on the JIL side means bridge transfers complete faster than Solana's own confirmation time.
XDC Bridge
Purpose-built for XDC Network interoperability. XRC-20 token support with compliance-aware routing through ATCE corridors. Designed for trade finance and supply chain settlement use cases.
Cosmos IBC
IBC-compatible light client for Cosmos ecosystem interop. Transfer IBC-enabled assets to JIL with the same compliance guarantees that apply to native transactions.
Beyond the core APIs - the innovations that make the platform production-ready for institutional use cases.
BPoH Consensus
Combines cryptographic timestamping with a verifiable delay function to produce provable ordering of events. 1.5-second block finality with mathematical guarantees. Validators can't reorder transactions because the proof of ordering is embedded in the block itself.
AI Token Managers
ML models trained on historical market data for real-time allocation decisions within governance-defined parameters. Rebalance liquidity pools, adjust hedging positions, and optimize yield strategies - but never exceed the risk bounds set by the token holder.
Predictive Liquidity Engine
ML demand forecasting predicts liquidity needs before they become critical, proactively repositioning capital across pools to prevent slippage spikes and failed settlements. Reactive liquidity management fails during the exact moments it's needed most.
Secure Document Vault
AES-256-GCM encryption with post-quantum Kyber key encapsulation. Documents stored across validators with configurable access control lists. Even if every validator were compromised, the documents remain encrypted.
Horizontal Scaling
Every one of JIL's 190+ microservices is designed for horizontal scaling from day one. Each service uses a NODE_ID for node-aware routing, Kafka consumer groups for partitioned processing, and configurable connection pools. Adding capacity requires no downtime.
Open Architecture
Every service communicates via REST or Kafka. Add your own microservice, subscribe to settlement events, or build a custom frontend. The platform is a toolkit, not a walled garden.
Every tool is browser-based, real-time, and connected to the live network.
Developing against a blockchain shouldn't require a terminal and a prayer.
Block Explorer
Real-time block and transaction explorer. Search by address, tx hash, or block height. View decoded contract calls, event logs, and state changes. Full provenance tracking for every asset.
DEX Monitor
Live AMM v5 dashboard showing pool depths, batch auction results, circuit breaker states, and RFQ activity. Monitor the dual-lane system in real time.
Smart Contract IDE
Browser-based Solidity editor with syntax highlighting, compilation, deployment, and interaction. Test self-healing features, ZK hooks, and cross-chain messaging without leaving your browser.
Build & Launch MemeCoins
Visual token creation tool. Configure supply, decimals, compliance corridors, and launch parameters. Deploy to testnet or mainnet with one click. No code required.
LBP Simulator
Interactive Liquidity Bootstrapping Pool simulator. Model bonding curves, weight shifts, and price discovery before deploying a real launch. Visualize how your parameters affect the raise.
DB Explorer
Direct database query tool for the JIL ledger. Run SQL-like queries against account state, transaction history, and compliance records. Export results as JSON or CSV.
Settlement Demo
Submit a cross-jurisdictional settlement, watch it route through compliance zones, and receive a cryptographic finality proof. End-to-end in under 3 seconds.
Bridge Transfer Demo
Bridge tokens between Ethereum and JIL Sovereign. Watch the 14-of-20 validator signing process in real time as your transfer crosses chains.
190+ containerized microservices. Classical + post-quantum dual signatures. 12 user-facing applications.
| Layer | Technology | Details |
|---|---|---|
| L1 Engine | Rust (jil5600-core) | BFT PoS consensus with BPoH timestamps, 1.5s blocks, Ed25519 + Dilithium signatures |
| Smart Contracts | Solidity + Anchor | EVM-compatible with self-healing extensions |
| API Layer | Express.js / TypeScript | Zod validation, Pino logging, JWT auth |
| Messaging | RedPanda (Kafka-compatible) | P2P zone-based settlement routing |
| Database | PostgreSQL 16 | Per-validator storage, configurable pool sizing |
| Cryptography | Ed25519, secp256k1, Dilithium, Kyber | Classical + post-quantum dual signatures |
| Auth | JWT + WebAuthn | Passkey-first, 7-day token expiry |
| Bridges | Solidity + Anchor + Go | 14-of-20 multisig across 13 jurisdictions |
| Frontend | React + Vite + TypeScript | 12 user-facing applications |
| Deployment | Docker + Kubernetes | 190+ containerized microservices |
JIL is designed for extensibility. Every service communicates via REST or Kafka. Add your own microservice, subscribe to settlement events, or build a custom frontend. The platform is a toolkit, not a walled garden.
JIL L1 Blockchain - ERC-20 Bridge Contract on Ethereum
Contract: 0x9347efffa3e8985e0d35536b408cab48599971e8
Converts 1:1 to native JIL at mainnet migration - Buy at $0.09
Start Building on the Most Advanced Settlement Protocol Ever Engineered
JIL Sovereign mainnet is live with 20 validators across 13 compliance zones. Developer access is available now.