Services Industries ADI Ecosystem Cases Company Careers Blog Contacts
Services
Industries
ADI Ecosystem
Company

Security and Performance Architecture of the ADI Chain Blockchain

ADI Chain (Mainnet Chain ID 36900, Testnet Chain ID 99999) is an institutional-grade Layer 2 blockchain built on Ethereum. It uses Zero-Knowledge Rollup (zkRollup) technology and is fully compatible with the Ethereum Virtual Machine (EVM), allowing developers to move existing Ethereum applications over without rewriting code.

Developed by the Abu Dhabi-based ADI Foundation, the network is designed specifically for governments, central banks, and regulated financial institutions. ADI Chain already powers several major real-world deployments:

  • Sovereign Currency. Exclusive settlement rail for the UAE Central Bank-licensed DDSC Dirham stablecoin.
  • Consumer & Sports. Settlement layer for Predictstreet, FIFA’s official prediction market partner.
  • Public Sector & Energy. Healthcare claims verification and carbon credit tokenization in Kenya (via Apeiro), plus UK renewable energy verification (via Good Energy).
  • Global Trade & Finance. Tokenized maritime real-world assets (via Shipfinex), intra-African digital trade infrastructure with the AfCFTA Secretariat, and ecosystem collaborations involving BlackRock, Mastercard, Franklin Templeton, and M-Pesa.

So, let’s dive deep into the security and performance reasons for ADI Chain development.

Build Secure, Scalable Solutions on ADI Chain

We help businesses build reliable blockchain applications

Table of contents:

  1. ADI Chain Has Multi-Tier Architecture and Execution Engine
  2. Dual-Target Compilation in ADI Chain: How zkSync OS Runs So Fast
  3. Inside a Block of ADI Chain: The Bootloader Lifecycle
  4. Network Nodes and Built-in MEV Protection
  5. Double Resource Accounting: Protecting the Provers
  6. The Airbender Prover Pipeline (STARK-in-SNARK)
  7. The Canonical Bridge of ADI Chain: 4 Built-In Security Guarantees
  8. Independent Smart Contract Audits and Account Abstraction
  9. Decentralization Trade-Offs: Why ADI Chain is “Stage 0”
  10. Summary

ADI Chain Has Multi-Tier Architecture and Execution Engine

Architectural TierCore RoleThroughput CapacityConfirmation & FinalityFee Structure & GasSecurity & Compliance Mechanism
Layer 1: Ethereum MainnetFinal settlement, proof verification, and data storage15 TPS~13 minutes (L1 finality)$0.01-$0.15 per tx (paid in ETH)Proof-of-Stake consensus, Diamond verifier contracts, and EIP-4844 blobs
Layer 2: ADI ChainHigh-speed execution, batching, and ZK proof generation2,000–10,000 TPS1s soft confirm; 2.0s L2 finality (~75 min L1 withdrawal)~$0.016 per tx; 90–95% cheaper than L1 (paid in $ADI)Validity proofs (STARK-in-SNARK), private mempool, and Double Resource Accounting
Layer 3: Enterprise RollupsCustom chains for payments, healthcare, registries, and DeFiScales horizontally per dedicated L3 chainSub-second confirmationCustomizable fee rules ($ADI base settlement)Inherits L2/L1 security; modular KYC/AML, DID, and FATF/ADGM Travel Rule controls

Layer 3 allows banks, ministries, and enterprises to launch their own custom mini-chains on top of ADI Chain. Each L3 can enforce local laws, such as Abu Dhabi Global Market (ADGM) rules or Financial Action Task Force (FATF) “Travel Rule” requirements. You don’t need to isolate your liquidity from the rest of the network. While the ADI Foundation provides the base L2 infrastructure and compliance tools without acting as a Virtual Asset Service Provider (VASP), L3 operators (such as exchanges and custodians) handle mandatory KYC and Travel Rule verification.

L3s also include Hyperledger FireFly middleware. It automatically turns smart contracts into standard REST APIs so legacy bank and government software can connect easily.

Dual-Target Compilation in ADI Chain: How zkSync OS Runs So Fast

Early zero-knowledge rollups were slow because they ran transactions inside custom virtual machines that standard computer processors could not execute efficiently. ADI Chain solves this with zkSync OS, a single Rust program that compiles into 2 different formats for 2 different jobs:

  1. Forward Running Mode (x86 for Speed). Compiled for standard x86 server processors, this mode runs inside the ADI Sequencer to process live user transactions. Because it runs on a normal operating system, it uses standard memory allocation and skips heavy cryptographic checks (like Merkle proof verification for storage reads or IS_PROVING_ENVIRONMENT checks). This lets the sequencer confirm transactions in just 1 second.
  2. Proving Running Mode (RISC-V for Math Proofs). The same Rust code is compiled into a bare-metal RISC-V format with no operating system. This binary is fed into the Airbender prover, where memory is managed manually, and every single step is verified deterministically to create an unforgeable zero-knowledge proof.

We recommend you read our article about

Step-by-Step Guide on How to Connect to ADI Testnet

Inside a Block of ADI Chain: The Bootloader Lifecycle

Within zkSync OS, 3 internal components work together:

  • Bootloader (the main entry point)
  • Execution Environments (EVM bytecode interpreters)
  • System Layer (which handles storage, memory, and L1 messages)

When a user submits a Layer 2 transaction, the Bootloader processes it through 5 clear steps:

  1. Resource Calculation. Checks that the transaction’s gas limit fits within the block limit and deducts upfront calldata and intrinsic costs.
  2. Validation. Checks that the account nonce is unused, verifies the user’s cryptographic signature and token balance, transfers gas_price * gas_limit to the Bootloader, and confirms the user can afford to publish state data (pubdata) to Ethereum.
  3. Execution. Runs the smart contract call (run_single_interaction) or deploys a new contract (run_till_completion) across the Execution Environments.
  4. Post-Execution Pubdata Check. Verifies that the transaction still has enough resources left to pay for the exact amount of state data (pubdata) it modified.
  5. Refunding. Refunds any unused gas back to the user.

To save even more time, ADI Chain simplifies the standard Ethereum block header. It keeps the same field layout so developer tools like Foundry, Hardhat, ethers, and viem work out of the box. But it sets heavy fields like state_root, receipts_root, and logs_bloom to 0, and replaces the complex transaction tree with a fast rolling hash.

Network Nodes and Built-in MEV Protection

As of Protocol v0.30.1 and Node v0.21.1-b4 (following the August 20, 2026 devp2p upgrade), the network splits operational duties across 3 node types:

  • ADI Sequencer (Main Node). Orders transactions, runs Forward Running Mode, exposes Ethereum and rollup JSON-RPC APIs (eth, zks, ots, debug), and runs L1 Watchers that constantly monitor Ethereum for bridge deposits and finalized batches.
  • GPU Prover Cluster. Runs in the background to turn completed transaction batches into zero-knowledge proofs without slowing down live transactions.
  • External Nodes (Self-Hosted Followers). Banks, exchanges, and developers can run their own External Nodes (general_node_role: external) using Docker Compose and an archive Ethereum L1 RPC. External Nodes do not produce blocks or generate proofs. Instead, they replay L2 blocks locally to verify the state and use a proof-sync sidecar to download proofs from Azure Blob storage. Version v0.21.1-b4 also includes an automatic 300-second watchdog (en_replay_inactivity_timeout) that reconnects the node if data streaming ever stalls. For public inspection, users can verify smart contracts on the BLS mainnet explorer (explorer-bls.adifoundation.ai) or the AB testnet explorer.

We recommend you read our article about

Why Startups Are Choosing ADI: A New Approach to Building and Scaling

Private Mempool (Anti-MEV)

On most public blockchains, pending transactions sit in a public waiting room (mempool). It allows predatory bots to front-run trades or execute “sandwich attacks” that cause worse pricing (Maximal Extractable Value, or MEV).

ADI Chain uses a private transaction pool by default. Because pending trades are hidden from public bots, mempool sniping and sandwich attacks are blocked at the protocol level. In addition, the official ADI Wallet includes built-in OneInch MEV protection when users swap tokens across the wider Ethereum ecosystem.

Double Resource Accounting: Protecting the Provers

In a zero-knowledge rollup, there is a hidden danger: an operation that is cheap in standard Ethereum gas might be extremely expensive to prove mathematically inside a ZK circuit. If the network only tracked standard EVM gas, an attacker could flood the chain with transactions that cost pennies in gas but overload the GPU provers. However, asking users to set two separate gas limits in their wallets would break standard tools like MetaMask.

ADI Chain solves this seamlessly with Double Resource Accounting, tracking two resources at the same time behind the scenes:

Resource TypeInternal UnitHow It Passes Between ContractsWhat Happens If It Runs OutWhat It Pays For
1. Execution Environment (EE) ResourceErgs (1:1 equal to EVM gas)A calling contract can cap how many Ergs it passes to a sub-contract, keeping the restReverts only that specific sub-call frame (standard EVM behavior)Normal smart contract execution inside the EVM
2. Native Computational ResourceNative Cycles (RISC-V proving cycles)Passed 100% in full from frame to frame; a caller cannot restrict what a sub-contract spendsIf exhausted during validation, the tx is invalid; during execution, the entire transaction revertsOff-chain Airbender ZK proof generation, Bootloader work, and L1 pubdata storage

The Airbender Prover Pipeline (STARK-in-SNARK)

Unlike Optimistic Rollups (which assume transactions are valid and require a 7-day waiting period to challenge fraud), ADI Chain uses Validity Proofs. Each batch of transactions includes a mathematical proof confirming that every state change is 100% valid. Ethereum will never accept an invalid batch.

ADI Chain generates these proofs using Airbender, the fastest open-source RISC-V zero-knowledge virtual machine (zkVM). Here is how Airbender turns a batch of transactions into an Ethereum-verified proof:

  1. Execution Trace Recording. The RISC-V simulator runs the batch and records every single clock cycle into a table (padded to a power-of-two length). Large runs are split into manageable chunks of ~4 million cycles linked together by memory consistency checks.
  2. Delegation & Degree-2 Optimization. Heavy cryptographic tasks (like hashing and signatures) are handed off to specialized Delegation Circuits. All polynomial equations (AIR constraints) are strictly limited to degree-2, which makes proof math much faster to compute.
  3. Hybrid CPU/GPU Proving. A CPU prepares the initial witness data, and high-speed GPUs generate the cryptographic STARK proofs. In real-world testing across 7,200 Ethereum blocks, a single-GPU Airbender Prime setup proved 99% of blocks in under 10 seconds and 100% of blocks in under 12 seconds.
  4. STARK-in-SNARK Wrapping. While STARK proofs are fast to generate and quantum-resistant, they are large and expensive to verify on Ethereum. Airbender uses Recursion Mode to combine all chunk proofs and wraps the final STARK inside a compact PLONK (Bellman) SNARK proof (which uses a trusted setup). This tiny proof is then verified cheaply on Ethereum by the ZKsyncOSVerifierPlonk and ZKsyncOSDualVerifier contracts.

You can hire ADI Chain developers from IdeaSoft, the official tech partner of ADI Chain.

Turn ADI Chain’s Technology Into Your Next Product

We help businesses develop ADI Chain applications for digital payments, asset tokenization, enterprise systems, and other use cases requiring security and scalability

The Canonical Bridge of ADI Chain: 4 Built-In Security Guarantees

Third-party crypto bridges often rely on multi-signature wallets or external validators, making them frequent targets for hacks. The ADI Canonical Bridge uses zero-knowledge proofs verified directly by Ethereum smart contracts, requiring zero trust in middlemen.

Bridge ContractLayer & LocationPrimary Security & Operational Role
BridgehubLayer 1 (Shared Singleton)Main entry point and registry for depositing $ADI and tokens across L2 chains
L1 Asset RouterLayer 1 (Shared Singleton)Routes deposit locking and withdrawal unlocking instructions to the vault
L1 Native Token Vault (NTV)Layer 1 (Shared Singleton)Holds locked L1 tokens, tracks per-chain balances (chainBalance), and deploys bridged tokens
L1 NullifierLayer 1 (Shared Singleton)Verifies withdrawal Merkle proofs and blocks double-spending via isWithdrawalFinalized
Mailbox & ExecutorLayer 1 (Per-Chain Diamond Proxies)Mailbox queues L1 L2 deposits; Executor runs the Commit, Prove, and Execute batch stages
L2 Asset Router & L2 NTVLayer 2 (0x0000…00010003 & 0x0000…00010004)Mints wrapped tokens on deposit, deploys new token contracts, and burns tokens on withdrawal
L2 Base Token & L1 MessengerLayer 2 (0x800A & System Contract)Mints/burns native $ADI on L2 (0x800A); L1 Messenger records withdrawals into the Merkle tree

Independent Smart Contract Audits and Account Abstraction

Because ADI Chain settles central-bank-supervised money like DDSC, its core contracts are built on OpenZeppelin standards and independently audited by Hacken (an ISO 27001:2022 certified security firm) using NIST SP 800-115 and PTES testing standards.

Audited ContractCompletion DateWhat the Contract DoesIssues FoundFinal Status
Certificate StorageJanuary 30, 2026Stores and verifies institutional compliance credentials on-chain4 findings100% Resolved
WADI (ERC-20)February 13, 2026Wrapped $ADI token contract for DeFi and ecosystem transfers7 findings100% Resolved
Gasless PaymasterFebruary 24, 2026Sponsors transaction fees so end users can transact without holding gas tokens16 findings100% Resolved

For user wallets, ADI Chain supports standard Ethereum accounts (EOAs) as well as ERC-4337 Account Abstraction. The official non-custodial ADI Wallet uses the ZeroDev Kernel v3.1 smart account and Pimlico Bundler, complemented by Tangem retail hardware wallets and institutional custody via Fireblocks and Ledger. To reduce security risks, ADI Chain disables ERC-7702 and requires enterprises deploying custom gas-sponsorship paymasters to use audited OpenZeppelin or eth-infinitism templates.

Decentralization Trade-Offs: Why ADI Chain is “Stage 0”

While ADI Chain’s zero-knowledge math is trustless, its governance is intentionally centralized to meet government regulations. On independent rollup tracker L2BEAT (where ADI Chain secures ~$12.09 million in Total Value Secured), the network is rated Stage 0 (“Full training wheels”).

Risk AreaHow ADI Chain Currently WorksPotential Impact on UsersWhy Institutions & Regulators Require This
Instant Code UpgradesOperators can upgrade core Diamond proxy contracts with 0 days’ notice (emergency path) or 3 days’ notice (regular path)Critical: A compromised admin key could theoretically push a malicious upgrade to drain bridged funds before users can exitCentral banks and regulators require an immediate “circuit breaker” (emergency stop) to patch bugs or pause compromised contracts instantly
Transaction Filtering & CensorshipOperators can pause the queue or turn on a TransactionFilterer contract without delayHigh: Users can submit transactions on L1, but cannot force them through if censored or filteredRequired by law to freeze sanctioned wallets, block illicit finance, and supervise central bank stablecoins like DDSC
Whitelisted ProposersOnly approved ADI proposers can submit batch state roots and proofs to Ethereum L1Medium-High: If the proposer goes offline, L2 L1 withdrawals freeze until it comes back onlinePrevents unauthorized actors from disrupting the deterministic GPU proving pipeline
Proof System BugRelies on Airbender STARKs wrapped in a PLONK SNARK (trusted setup)Medium: A math bug in the circuit or compromised setup could theoretically allow a fake state proofMitigated by using dual on-chain verifiers (ZKsyncOSDualVerifier) and simplified degree-2 math constraints
Sequencer OrderingA single operator runs the sequencer and orders the private mempoolLow-Medium: While outside bots are blocked, the operator theoretically has the power to reorder tradesNecessary to guarantee 0.2-second confirmations and keep institutional trades private from public bots

To reach L2BEAT Stage 1, ADI Chain would need to hand emergency control over to a broader Security Council (over 75% vote) and give users a mandatory 7-day exit window before any code upgrade or transaction filter takes effect.

However, partners like the Central Bank of the UAE, First Abu Dhabi Bank, and government ministries cannot legally wait 7 days to freeze a sanctioned terrorist wallet or halt an active exploit—giving criminals a full week to cash out to Ethereum. Similarly, while built-in identity and compliance rules deter anonymous DeFi speculators, they provide the exact legal certainty required by licensed operators like Predictstreet and global asset managers. What crypto purists view as a “Stage 0 centralization risk” is, for governments and banks, an essential safety feature.

Summary

ADI Chain provides a foundation for building blockchain applications that require high performance, Ethereum compatibility, and institutional-grade security. Its zero-knowledge rollup architecture, smart contract infrastructure, and support for enterprise use cases create opportunities for businesses developing DeFi platforms, payment systems, tokenization solutions, and other Web3 products.

IdeaSoft helps businesses turn ADI Chain’s capabilities into practical blockchain solutions. With a focus on custom blockchain development and Web3 engineering, IdeaSoft supports projects from technical planning and smart contract development to application integration and deployment. The goal is to build solutions that fit business requirements while accounting for performance, security, scalability, and long-term maintenance.

Build on ADI Chain with an Experienced Technology Partner

    Formats: pdf, doc, docx, rtf, ppt, pptx.
    Rostyslav Bortman
    Head of Blockchain and R&D
    With over 10 years of software engineering experience, Rostyslav specializes in Web3 architecture, smart contracts, decentralized applications, and blockchain infrastructure. He has contributed to more than 50 blockchain projects and leads research and development initiatives focused on innovative Web3 solutions.
    FAQ

    Frequently Asked Questions

    • What makes ADI Chain suitable for enterprise blockchain applications?
      Its architecture combines Ethereum settlement, validity proofs, and enterprise-focused infrastructure for use cases such as digital payments, asset tokenization, and decentralized finance.
    • How can businesses develop applications on ADI Chain?
      Businesses can build applications on ADI Chain using EVM-compatible smart contracts and familiar Ethereum development tools, including Hardhat, Foundry, ethers, and viem. Depending on the project, development may involve smart contract deployment, API integration, wallet connectivity, and security testing. An experienced blockchain development partner like IdeaSoft can help plan and implement these components.
    • How can IdeaSoft help companies build blockchain solutions on ADI Chain?
      IdeaSoft can support businesses with custom blockchain development, smart contract engineering, Web3 application integration, and technical implementation planning. By aligning the architecture with specific business requirements, IdeaSoft helps teams work toward secure, scalable, and maintainable blockchain solutions. The scope of services can be tailored to projects such as DeFi platforms, payment applications, and tokenization systems.
    Subscription

    Subscribe to Newsletter

    Subscribe to IdeaSoft newsletter — be the first to get blog updates and IdeaSoft news!

    Not subscribed, because of server error. Try again later...
    Successfully subscribed!