Skip to main content

System Overview

Orbinum is a privacy-focused blockchain that combines Zero-Knowledge cryptography with full Ethereum compatibility. Built on Substrate's FRAME framework with Frontier integration, it enables confidential transactions while maintaining interoperability with the Ethereum ecosystem.

The Privacy-Transparency Paradox

Traditional blockchains expose all transaction details on-chain, creating permanent public records that can be analyzed, traced, and linked across time. While transparency is essential for distributed consensus, it conflicts with the growing demand for financial privacy in institutional and personal use cases.

At its core, Orbinum addresses this fundamental tension by embedding privacy at the protocol level through cryptographic commitments and zero-knowledge proofs, allowing users to transact confidentially while maintaining the verifiability and integrity that blockchains provide.

Architecture Overview​

The architecture is built on a foundation of modular layers, each serving a distinct purpose while working together to enable both private and public computation. Understanding how these layers interact reveals how Orbinum achieves its dual mandate of privacy and programmability.

The application layer sits at the top, providing multiple interfaces for interaction. Developers can work with native Substrate APIs when building privacy-focused applications, or use familiar Ethereum JSON-RPC endpoints when deploying smart contracts. This dual-interface approach recognizes that privacy and programmability serve different use cases, and both deserve first-class support in the architecture. The Building on Orbinum section details the tooling available for both approaches.

Dual Execution Environments

The runtime is split into distinct execution environments that operate on the same state but follow different rules. This separation allows privacy operations and smart contract execution to coexist without compromising either.

Beneath this interface layer lives the runtime—the heart of the blockchain where all computation happens. The privacy runtime handles confidential transactions through a UTXO-based model inspired by Zcash Sapling, where value is represented by cryptographic commitments stored in a multi-tree Merkle forest. When users want to transact privately, they interact with the shielded pool, generating zero-knowledge proofs that validate the transaction without revealing its details. The Privacy Architecture section explores this model in depth, explaining how commitments, nullifiers, and Merkle proofs work together to create a system where privacy is the default, not an afterthought.

Running parallel to the privacy runtime is the EVM runtime, which provides full Ethereum compatibility through Frontier. This isn't a compromise or a second-class feature—it's a deliberate architectural choice that recognizes the value of the existing Ethereum ecosystem. Smart contracts written in Solidity deploy without modification, standard precompiles work as expected, and tools like MetaMask, Hardhat, and Remix integrate seamlessly. The EVM Compatibility section details how this integration works, including the address derivation that unifies Substrate and Ethereum address spaces.

Consensus Independence

Block production and finality operate independently of whether a transaction is private or public. This separation ensures consistent performance regardless of transaction type.

The consensus layer operates independently of whether a transaction is private or public. Block production follows Aura's time-based authority rotation with six-second intervals, while GRANDPA provides deterministic finality in approximately twelve seconds. This separation between block production and finality allows the network to continue making progress even during temporary network partitions, ensuring both liveness and safety. The Consensus documentation explains these mechanisms and their trade-offs in detail.

Supporting all of this is the cryptographic foundation that makes privacy possible. Zero-knowledge proofs in Orbinum use Groth16 over the BN254 curve, chosen for its compact proof size and fast verification time. The Poseidon hash function, optimized for use in zero-knowledge circuits, provides the cryptographic commitments that hide transaction details while remaining verifiable. These aren't abstract concepts—they're concrete implementations that power every private transaction on the network.

Privacy​

The shielded pool represents Orbinum's approach to private value transfer. Unlike account-based models where balances are visible on-chain, the shielded pool uses a UTXO model where value exists as cryptographic commitments. When you shield assets, you're creating a note—an off-chain data structure containing an amount, asset identifier, owner public key, and random blinding factor.

How a private transaction flows through the system:

Your note sits alongside everyone else's, indistinguishable from hundreds of thousands of other commitments. Observers can see that some note was consumed and some new notes were created, but cannot determine ownership or link inputs to outputs. The proof reveals a nullifier—a unique value derived from the commitment and your spending key—which prevents the same note from being spent twice. This nullifier is publicly recorded on-chain, but it cannot be linked back to the original commitment without knowledge of the spending key.

Reading and spending are separate capabilities. A wallet's secrets are independent branches of one master rather than a chain, so the key that finds your notes is not derived from the key that spends them. That separation is what allows a watch-only credential — an auditor or a second device can be given the ability to see balances, and optionally payment history, with no ability to move funds. It also lets a restored wallet recover what it sent, not only what it received, without publishing anything additional on chain.

Multi-Asset Privacy​

Privacy becomes more powerful when it extends beyond a single asset type. Orbinum's shielded pool supports any registered fungible asset, and critically, commitments are asset-agnostic: notes of every asset live side by side in the same trees.

Design ChoicePrivacy Impact
Separate trees per assetObservers narrow anonymity set by asset type. A 100 ORB transaction is distinguishable from a 50 USDT transaction.
Asset-agnostic trees (Orbinum's approach)All commitments are indistinguishable 32-byte hashes. Every note in a tree joins the same anonymity set, regardless of asset.

The asset type information is only revealed within the zero-knowledge proof itself, which is validated without exposing the underlying data.

Assets have their own lifecycle: register_asset adds one, verify_asset marks it usable, and unverify_asset blocks further shielding. An unverified asset cannot be shielded — the pallet rejects it with AssetNotVerified. This gate lets governance vet new assets without touching the privacy machinery.

Explore the privacy implications of this design in the Privacy Architecture documentation.

Implementation Status and Future Direction​

Orbinum has implemented core confidential transaction functionality, multi-asset privacy support, EVM compatibility through Frontier, and consensus through Aura and GRANDPA. The shielded pool operates with shield (single and batched), private transfer, and unshield — the last supporting partial withdrawals with a change note. Commitments are asset-agnostic, so notes of every asset share the same anonymity set within a tree.

Note disclosure is implemented as lightweight off-chain disclosure keys (orbdisc:…) rather than a dedicated ZK circuit. A key encodes the plaintext preimage of a note commitment and allows any holder to cryptographically verify the note's value and asset — without granting spending capability. The architecture described here isn't static. Substrate's modular design allows runtime upgrades without hard forks, meaning the protocol can evolve as cryptographic techniques advance and new use cases emerge. The goal is not to create a perfect system frozen in time, but to build a foundation flexible enough to adapt while maintaining the core privacy guarantees that define Orbinum's purpose.

Learn More​