Anubis Chain: Selective Privacy L1 with PLONK ZK Proofs

Anubis Chain is a Layer 1 blockchain built around PLONK zero-knowledge proofs, full EVM compatibility, and a programmable model the team calls selective privacy. Instead of hiding every transaction by default like Monero or Zcash, or exposing every byte by default like Ethereum, Anubis lets users and institutions choose, on a per-transaction or per-contract basis, exactly which data fields stay private and which become publicly auditable. The mainnet went live on April 7, 2026, and the network has since opened its ecosystem layer with the genesis project AWAKE, a $163 million liquidity deployment, and the activation of native infrastructure such as the RocketSwap DEX and the Capybara Launchpad. This guide explains the architecture, the AWAKE rollout, the ZK-KYC compliance design, and how Anubis Chain compares to other privacy-focused networks competing for institutional DeFi flow in 2026.

The pitch is conceptually simple but technically demanding: blockchains have spent a decade fighting a contradiction between transparency and confidentiality, and most projects have picked a side. Anubis Chain argues that the next wave of on-chain finance, particularly tokenized treasuries, regulated stablecoin rails, and institutional market making, will require both privacy and verifiability operating on the same execution layer. By packaging zero-knowledge primitives as EVM precompiles rather than rewriting the virtual machine, the network can support standard Solidity contracts while offering shielded balances, stealth addresses, and selective audit trails to applications that ask for them.

What is Anubis Chain?

Anubis Chain is an EVM-compatible Layer 1 network that uses zero-knowledge proofs to give users granular control over which transaction fields are revealed on chain. The network is governed by the ANUBI Foundation, an investment institution established in 2020, and incubated through Anubis Labs, a joint initiative between the foundation and the chain itself that operates as the ecosystem's incubation engine, capital coordinator, and growth amplifier.

The headline characteristics are:

• Selective privacy by default disabled, by user enabled. Smart contracts opt into shielded primitives; transparent execution remains the baseline.
• 100% EVM compatibility. The chain ships a modified Geth client that does not alter the EVM core instruction set, execution semantics, or the account state model. Solidity contracts and standard tooling like Hardhat, Foundry, and MetaMask work as on Ethereum.
• Hybrid state model. An account layer for EVM compatibility plus a UTXO-style layer for shielded balances, both coordinated through synchronized state transitions.
• Threshold-encrypted mempool. Pending transactions are encrypted and shuffled before validation, eliminating the standard front-running and sandwich-attack surface that plagues transparent DEXs.
• ZK-KYC compliance layer. Identity documents are verified off-chain; only an encrypted validity attestation is anchored on-chain, removing the need to publish personal data.
• Native currency: gasDAI. The mainnet, registered as Chain ID 6714, uses a DAI-pegged unit for gas, anchoring fees to a stable reference rather than a volatile native token.

The mainnet launched on April 7, 2026 at 20:00 EDT. Block explorer access is available at browser.anubispace.org and the canonical RPC endpoint is exposed via rpc.anubispace.org.

Selective privacy explained: solving the transparency contradiction

Public blockchains expose every input, output, balance, and contract call to the world. That property is essential for trust-minimized verification, but it is incompatible with how regulated finance and most enterprise workflows operate. A treasury desk cannot publish rebalancing orders before execution. A market maker cannot reveal inventory positions in real time. A payroll provider cannot dump employee compensation onto a permanent ledger. The standard response from the privacy-coin ecosystem (Monero, Zcash, Namada, Penumbra) has been to hide everything by default. That works for cash-like transfers but breaks down for smart-contract composability and for any application that needs to prove compliance to a third party.

Selective privacy is the middle path. On Anubis Chain, a developer can deploy a smart contract whose code is fully public and auditable while keeping the state inside that contract shielded. A user can transact while revealing only the fields needed for a counterparty or auditor and hiding the rest. The mechanism that makes this possible is the precompile layer: zero-knowledge verifiers, stealth-address generators, and private-state coordinators are exposed as gas-priced opcodes that any Solidity contract can call.

The practical difference matters. With a fully shielded chain, a DEX cannot publish a transparent order book because individual balances are unverifiable to other contracts. With Anubis Chain, the same DEX can run a transparent order book on the account layer while quoting LPs from a shielded UTXO pool. The same dynamic applies to Railgun-style application-layer privacy, except that on Anubis Chain the privacy primitives live in the base layer and inherit L1 security rather than depending on per-contract anonymity sets.

"Anubis Chain enables what was previously impossible on a single execution layer: selective transparency where institutions get verifiable compliance and users keep their counterparty data confidential." — ANUBI Foundation, architecture overview

The model also avoids the fully-transparent failure mode. Front-running, sandwich attacks, copy trading, and MEV extraction on Ethereum and most L2s exist because pending transactions sit in a public mempool long enough for searchers to react. Anubis pre-encrypts the mempool with threshold cryptography so that validators cannot read transaction contents until after ordering is fixed, removing the informational asymmetry that makes MEV profitable in the first place.

PLONK zero-knowledge proofs: the cryptographic engine

The proof system underlying Anubis Chain is PLONK, with what the team describes as Turbo PLONK-style optimizations for on-chain verification. PLONK (Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge) is a zk-SNARK construction that replaced the older Groth16 standard with a single universal and updatable trusted setup. That change matters in production for three reasons:

1. One setup ceremony for the whole network. Groth16 required a fresh ceremony for every new circuit. PLONK lets every contract on Anubis Chain reuse the same Structured Reference String, which is what makes it economical for the chain to expose generic ZK precompiles instead of bespoke circuits per dApp.
2. Constant-size proofs. A PLONK proof is roughly 500 bytes regardless of the circuit's complexity, so verification cost on the EVM stays predictable and gas budgets do not blow up as circuits grow.
3. Fast verification, slower proving. Verification runs in milliseconds, which is the operation that has to happen on chain at every block. Proving runs off chain on the user's wallet or a prover service, where slower performance is acceptable.

For developers, this means the cost of integrating privacy on Anubis Chain is close to the cost of a normal contract call, plus the gas required to verify a single PLONK proof. For end users, it means private transactions confirm in roughly the same time as transparent transactions, with no protocol-level batching delay.

The chain combines PLONK verification with EIP-5564 stealth addresses, exposed as precompiles, which gives every recipient a unique one-time address per transaction without requiring an extra round trip with the sender. Recipients scan announcements with a viewing key to discover incoming payments. The result is that even when transparent balances are used, the on-chain link between sender and recipient is broken at the address level.

EVM compatibility and developer experience

One of the most consequential design choices on Anubis Chain is the decision to not fork the EVM. The Geth-based client preserves the standard 160-bit address format, account state model, and complete opcode set. Solidity contracts compiled for Ethereum, Polygon, or any other EVM-equivalent chain can be deployed unchanged, and developer tooling such as Hardhat, Foundry, Remix, Wagmi, and Ethers.js works without modification.

Privacy is added around the EVM rather than inside it. Each ZK primitive is exposed as a precompiled contract at a fixed address. A Solidity contract that wants to verify a PLONK proof simply calls the precompile in the same way it would call ecrecover. The output is a boolean. This pattern keeps the surface area small, makes auditing tractable, and means existing audit tools and static analyzers can reason about Anubis contracts without protocol-specific extensions.

For teams already running on Ethereum or an L2, the migration path is concrete: redeploy contracts to chain ID 6714, point the frontend at the Anubis RPC, and replace any privacy workaround (off-chain mixers, third-party shielded pools) with a direct precompile call. Compatible wallets at launch include Bitget Wallet and OKX Wallet, with MetaMask supported through the standard custom network flow.

Architecture deep dive: how the hybrid state model actually works

Most public commentary on selective privacy stops at the marketing line. The mechanical question is harder: how can a single L1 simultaneously support EVM-native account state and UTXO-style shielded state without either layer corrupting the other? The Anubis Chain answer is that the two layers are kept structurally separate and connected only through a small, well-defined coordination interface.

The account layer is exactly what Ethereum developers expect. Every address holds a balance, a nonce, a code hash, and a storage trie. Transactions targeting the account layer behave like Ethereum transactions and produce transparent state transitions. The shielded layer, by contrast, behaves like a UTXO ledger. Notes are created and consumed; ownership is proven through cryptographic commitments and nullifiers; the set of currently spendable notes is represented by a Merkle tree whose root is anchored in each block.

Crossing between layers is the interesting part. A user can shield a transparent balance by burning tokens on the account layer and creating an equivalent note on the shielded layer through a precompile call. The reverse operation, unshielding, burns a note (publishing only its nullifier) and credits an account-layer balance. Both operations are atomic and validated by PLONK proofs. The Merkle root anchoring the shielded note set is updated each block in lockstep with the account-layer state root, which is what allows the chain to remain a single coherent state machine despite running two structurally different ledgers in parallel.

This design has direct consequences for application developers. A protocol that wants to expose shielded balances to its users does not need to implement any cryptography itself. It calls the shield, unshield, and transfer precompiles like it would call ecrecover. The protocol itself can stay in standard Solidity, which is what keeps the audit surface tractable.

Threshold encryption and the end of standard MEV

MEV is one of the largest tax surfaces in DeFi. On transparent chains, searchers monitor the pending mempool, identify profitable orderings, and pay validators to include their transactions in the optimal position. The classic attacks are sandwich (front-run the victim, then back-run the resulting price impact), generalized front-running (replay any profitable strategy a user is about to execute), and JIT liquidity (add and remove LP positions around a single large swap).

The Anubis Chain mempool defangs this by encrypting pending transactions with a threshold scheme before validators can see their contents. The decryption key is held collectively by a committee, and the key is reconstructed only after a block has been proposed and the ordering has been finalized. The practical effect is that the validator proposing a block does so over an opaque set of transactions. By the time the transactions are decrypted and executed, the ordering is no longer negotiable, and there is no economic surface left for sandwich or generalized front-running attacks.

The design does not eliminate every form of MEV. Statistical MEV, where searchers infer transaction intent from sources outside the mempool (failed pre-flight checks, frontend telemetry, mempool monitoring on bridged chains), can still exist around the edges. But it removes the dominant attack surface, and it does so at the protocol level rather than requiring each DEX to implement its own mitigation. For a chain that wants to host institutional flow at scale, that property is structurally important: institutions cannot trade on a venue where their order flow is routinely arbitraged out of profit.

What it looks like to build on Anubis Chain

From a builder's seat, deploying on Anubis Chain in 2026 is intentionally undramatic. The development environment is the same Hardhat or Foundry workspace already in use, with two changes: the deployment target's RPC URL points to Anubis, and the project's foundry.toml or Hardhat config registers chain ID 6714. Contracts compile and deploy as on any EVM chain. Existing audit reports, in most cases, carry over without re-certification because the EVM semantics are unchanged.

Adding privacy is a matter of calling the right precompile. A token contract that wants to expose shielded transfers imports a thin Solidity interface around the shield/unshield/transfer precompiles, gates the relevant entry points behind that interface, and lets the protocol's existing accounting handle the account-layer side. Stealth addresses for receive flows work the same way: an EIP-5564-compatible announcement is published as a log, the recipient scans logs with a viewing key, and the recipient's wallet UI surfaces incoming notes without further on-chain interaction.

The pieces that take new thinking are around which data to keep private. The default for most projects on Anubis is still transparent state, because most application logic does not benefit from privacy and gas is cheaper for transparent operations. The privacy surface is enabled selectively for the data fields where the value of confidentiality outweighs the cost of proof generation. This is why the team uses the term selective privacy rather than privacy-by-default: the architecture pushes the choice up to the application layer instead of taking it at the protocol layer.

The AWAKE ecosystem: $163M genesis liquidity

The first flagship project to complete full-stack migration onto Anubis Chain is AWAKE. Trading went live on May 13, 2026 at 20:00 SGT through the network's native DEX, RocketSwap, with the DAI/LGNS pair anchoring the launch.

The numbers and structure:

• Initial liquidity pool: $163 million in DAI and LGNS, described by the AWAKE DAO organizing committee as one of the largest single deployments in the Anubis Chain ecosystem.
• LGNS launch price: $5 per token.
• Liquidity origin: A community-driven Initial Liquidity Offering coordinated through the Capybara Launch Platform rather than a private allocation to market makers.
• Governance vehicle: AWAKE DAO, whose organizing committee structured the ILO and the post-launch liquidity policy.
• Wallet access: Bitget Wallet and OKX Wallet from day one through the RocketSwap official platform.

The strategic significance of the AWAKE launch is less about LGNS as an individual asset and more about what the deployment proves. A $163 million pool seeded from the community, transacted through a native DEX on a sub-three-month-old mainnet, settles the question of whether selective-privacy infrastructure can support real liquidity at scale. It also sets the template for subsequent genesis projects, which the foundation has signalled will follow a similar ILO-on-Capybara, listing-on-RocketSwap pattern.

RocketSwap: the native DEX

RocketSwap is the decentralized exchange that ships as part of the Anubis Chain core stack. Architecturally it sits closer to the chain than third-party DEXs on other L1s, with direct access to the threshold-encrypted mempool and to the shielded-balance precompiles. The combination has three downstream effects:

• Native MEV resistance. Because pending swaps are encrypted before ordering, the searcher infrastructure that profits from sandwich and back-running attacks on Ethereum DEXs has no readable order flow to act on.
• Shielded LP positions. Liquidity providers can choose to deposit into shielded pools, hiding the size of individual positions while keeping the pool's aggregate reserves verifiable.
• Dynamic fee adjustment. RocketSwap uses a fee matrix that responds to volatility and pool depth, built for insulate freshly listed tokens from speculative cascades while preserving capital efficiency for stable pairs.

The DEX also offers specialized staking incentives for liquidity providers in early-ecosystem pools, with the goal of encouraging long-duration commitments rather than mercenary capital. Traders can monitor markets and analytics via DEXTools once chain coverage is fully integrated.

Capybara Launchpad: ILO infrastructure for ecosystem projects

Capybara Launchpad is the official Initial Liquidity Offering platform for Anubis Chain. It functions as a community-fundraising framework that lets ecosystem projects pool public assets and establish deep liquidity reserves prior to listing on RocketSwap or any other DEX.

The Capybara design reflects two lessons from earlier launchpad cycles. First, raises that go directly into a centralized market maker tend to concentrate token control and amplify launch-day volatility. Capybara routes contributed capital into transparent on-chain liquidity pools where retail and institutional participants are equity holders rather than counterparties. Second, time-locked liquidity policies deliver durable trust by enforcing vesting and pool-lock schedules directly at the contract level, replacing promises with cryptographic guarantees that participants can verify on chain.

The first major deployment through Capybara was the AWAKE / LGNS launch, which validated the model under real liquidity conditions. Future ecosystem projects, including DeFi primitives, RWA tokenization platforms, and institutional-payment rails, are expected to use the same path.

ZK-KYC: compliance without doxxing

The most consequential feature for institutional adoption is the ZK-KYC framework. The mechanism works like this:

1. A user completes a standard KYC verification with an authorized off-chain provider. Documents and personal data never leave that provider's environment.
2. The provider issues a zero-knowledge attestation: a cryptographic proof that the user satisfies a defined compliance schema (age, jurisdiction, sanctions clearance, accredited-investor status, etc.) without revealing the underlying data.
3. The attestation is anchored on Anubis Chain as a credential that the user controls.
4. Smart contracts that require compliance can verify the attestation via a PLONK precompile call. The contract learns only the boolean answer to a specific predicate (for example, "is this user not on the OFAC SDN list?"), never the user's identity.

The framework also supports selective audit capabilities: authorized auditors and regulators can be granted view keys that decrypt specific transactions or balances without exposing the rest of the user's history. This is the mechanism that lets a regulated DeFi protocol satisfy AML and CFT reporting requirements while still preserving user-level privacy in the default case.

The design is structurally similar to credential systems being prototyped elsewhere in the privacy stack, including the Ethereum Foundation's Kohaku SDK, but with the difference that on Anubis Chain the verification primitives are protocol-level rather than living in an application library. That distinction matters for institutions: protocol-level guarantees survive smart-contract upgrades and are easier to defend to compliance teams.

Network parameters and economics

Anubis Chain mainnet operates with the following confirmed network parameters, sourced from official documentation and the chain registry on ChainList:

The decision to use a DAI-pegged unit (gasDAI) for gas pricing is structurally important. Volatile native tokens make gas costs unpredictable in fiat terms, which is a problem for any institution doing accounting on chain. Anchoring fees to a stable reference matches the model that Gnosis Chain pioneered with xDAI and makes Anubis easier to integrate into payment, payroll, and treasury workflows where predictable cost is a hard requirement.

The validator set is permissioned at launch with a published transition plan toward broader participation. The economic security of the network ties into the ANUBI Foundation's treasury, with validator slashing and reward parameters defined in the chain's governance documentation. The ecosystem token economics, including any planned native asset for governance or staking beyond gasDAI, are scheduled for disclosure in subsequent foundation publications.

Anubis Chain vs other privacy networks

How does Anubis Chain compare to the rest of the privacy-blockchain landscape? The table below highlights the key architectural differences across the major comparable projects in 2026:

The differentiating axis for Anubis Chain is the combination of opt-in privacy with full EVM compatibility and native compliance primitives. Most competitors pick one or two of those three. The trade-off is that opt-in privacy depends on the application layer using it correctly, where default-private chains protect users even when applications are careless.

Use cases: where selective privacy matters

The architecture is purpose-built for a specific cluster of applications:

• Institutional DeFi. Treasury desks, market makers, and asset managers can run on-chain strategies without broadcasting positions in real time, while still proving solvency or compliance through ZK attestations.
• Private DEX trading. Retail and professional traders can route orders through RocketSwap without leaking intent to MEV searchers, removing a structural tax that costs Ethereum users hundreds of millions per year.
• Compliant private transfers. Payroll, vendor settlement, and B2B payments can run on-chain with confidential amounts and counterparties while still satisfying jurisdictional reporting requirements through selective audit.
• RWA tokenization. Tokenized treasuries, equities, and private credit can settle on a chain that supports both transparent transferability and confidential cap-table data, addressing one of the major frictions in the institutional RWA stack.
• Identity-gated DeFi. Protocols that require accredited-investor or jurisdiction-specific access can enforce gating through ZK-KYC credentials without operating a KYB process per user.

Why Anubis Chain stands out

Roadmap 2026 and beyond

Based on the foundation's published communications, the post-mainnet trajectory for 2026 focuses on four areas:

The strategic positioning is consistent: the foundation is treating Anubis Chain as compliance-ready privacy infrastructure for institutional flow rather than as a consumer privacy product.

How to access Anubis Chain

Getting started on Anubis Chain in 2026 looks like getting started on any modern EVM network:

1. Add the network to your wallet. Use Bitget Wallet, OKX Wallet, or add Chain ID 6714 as a custom network in MetaMask. RPC: rpc.anubispace.org; explorer: browser.anubispace.org; native currency: gasDAI.
2. Bridge in stablecoins. Move DAI to Anubis through the official bridge documented at anubischain.ai. Stablecoin liquidity is the primary on-ramp because gas is denominated in gasDAI.
3. Trade through RocketSwap. The native DEX hosts the deepest pools, including the DAI/LGNS pair.
4. Track markets on DEXTools. Once chain coverage is fully integrated, DEXTools can be used to monitor pairs, liquidity, and trader flow across Anubis Chain.
5. Verify on-chain. Use the block explorer to confirm transaction inclusion. Transparent transactions resolve in roughly one second; shielded transactions add the PLONK proof generation time on the user's side.

Frequently asked questions

Related Guides

• What Is Railgun? The On-Chain Privacy Protocol for EVM DeFi Explained in 2026
• Top 5 Crypto Privacy Tools in 2026: Protecting Your On-Chain Anonymity
• What Is zkTLS? Privacy and Reputation for DeFi Explained
• What Is Zcash (ZEC)? The Privacy Cryptocurrency Powered by zk-SNARKs Explained in 2026
• What Is Monero (XMR): Complete Privacy Coin Guide (2026)