Nord—Changing the Game for On-chain Exchanges
Despite developer’s efforts to introduce users to DeFi, over 85% of all crypto trading volume continues to remain on centralized exchanges.
Decentralized solutions are simply not robust enough to handle the performance, volume, and UX requirements that today’s traditional financial markets demand. They have a herculean challenge ahead of them to meet those demands, leaving billions of untapped assets in the current centralized system.
This situation is what led us to build Nord, the first rollup specifically designed to scale on-chain exchanges. Nord’s goal is to empower developers and traders to enjoy the centralized exchange experience fully on-chain, and to go even further by enabling full composability of the exchange’s liquidity with smart contract layers: Imagine the endless possibilities if we can bring Binance on-chain, and then allow developers to build smart contracts around it. Nord is built to provide the high performance necessary for scaling exchanges and eventually bring that missing 85% of volume into DeFi.
Before diving into Nord itself, we need to understand what foundations Nord is built on—the building is only as strong as the foundations it rests on.
Nord's foundation is Layer N, a network of hyperperformant rollups for the financial ecosystem on Ethereum.
Rollups on Layer N bundle transactions away from the mainchain, reducing congestion and fees and translating to faster, more cost-effective, and secure applications.
Traditional layer 2s and rollups however are very limited in their compute capabilities and execution environments. Layer N enables app-specific rollup-infrastructure with their own custom execution environments, meaning applications can now build without computational constraints. Starting with Nord’s custom rust based exchange VM, exchanges can utilize Nord’s high-throughput, low-latency infrastructure to build premium on-chain orderbook experiences. What’s especially powerful and unique about Layer N is that all of these instances can seamlessly compose with each other, leading to a network of unified liquidity, which enables powerful composability between the liquidity on Nord, and smart contracts on an EVM rollup.
Why does Nord matter, and why do we even need dedicated infrastructure for DeFi and on-chain exchanges?
To address this question, let’s dive into the current state of decentralized exchanges, which we can categorize into three primary designs: AMMs, Staked Pools, and CLOBs.
Automated market making (AMMs) protocols like Uniswap leverage smart contracts to enable decentralized trading between users. By utilizing liquidity pools and algorithmic pricing, AMMs eliminate the need for traditional intermediaries and enable trading with passive liquidity. They provide an innovative solution for swapping assets on a chain that is prohibitively expensive to actively market make. However, this also means that the lack of active market making leads to losses for liquidity providers, slippage costs for traders, and a much more expensive trading experience compared to centralized exchanges.
Staked pools protocols like GMX and Gains Network introduce staked pools that merge liquidity provisioning with trading incentives. Users contribute crypto assets to a shared liquidity pool, which underpins various trading activities, including market making, liquidity for swaps, leverage trading, and asset rebalancing. Protocols using staked pools structure also suffer from high-latency and high operation costs.
Finally, central-limit orderbook (CLOB) protocols like dYdX offer the closest trading experience to centralized exchanges, providing traders with precise control over their assets, and best possible execution prices. However, most existing CLOB solutions process order matching fully off-chain, meaning they have no way to compose with on-chain smart contracts, and also inherit high degrees of centralization risks.
By looking at the existing solutions, we realize that all solutions either compromise on performance and user experience, or on decentralization and composability. Nord is built exactly to solve this problem.
To provide a venue for exchange protocols to provide CEX-like performance, dedicated compute space, all while maintaining the composability needed to build applications that can tap into the exchange’s liquidity, Nord has a unique modular design that is fully integrated into the Layer N network.
To solve performance, Nord is fully built in Rust for ground-up maximum horsepower. This is made possible by leveraging RiscZero for ZKFPs, which supports the RISC-V instruction set. Nord only generates ZK proofs when necessary (i.e. in the event of validator fraud)—unlike typical zk-rollups that require constant proof generation which is an extremely costly overhead. Event-driven usage of ZK proofs offer two key benefits: web2-like performance and shorter fraud-proof windows than traditional optimistic rollups.
Additionally, Nord has a custom orderbook VM that is optimized for trading and mirrors the architecture of the world's leading financial exchanges. This execution environment specialization enables developers to build on top of infrastructure tailor made for their purpose, as opposed to trying to fit a complex exchange within the constraints of a generalizable VM.
To solve throughput, Layer N leverages EigenDA, a novel solution providing megabytes of blockspace per second. What sets EigenDA apart from other off-chain DA solutions, is that the data continues to be secured by Ethereum validators through restaking, meaning the "off-chain DA risk" is mitigated. Unlike existing blockchains, which have fixed capacity regardless of the number of validators, EigenDA expands its capacity in tandem with the number of validators. This innovation effectively overcomes the conventional bandwidth constraints inherent to blockchains, enabling Nord to scale horizontally and maintain significantly lower transaction fees.
Additionally, Nord also employs signature aggregation techniques that compress data by a factor of 8-10 times, resulting in even lower transaction fees. This further reduces Nord’s dependence on expensive blockspace.
Finally, the final key to making everything function seamlessly is a unified messaging layer that enables full composability of applications with the liquidity on Nord: Layer N’s Inter-Rollup Communication protocol (IRC). IRC enables Nord to seamlessly transmit messages to other rollups on Layer N, and to instantly bridge liquidity back and forth. To the end user, it becomes imperceptible on which Layer N rollup they are operating on. They will be able to use applications on or off Nord without being concerned about the intricacies of bridging. IRC is powered by a shared sequencer. In essence, Layer N rollups, including Nord, submit their state updates to the same contract. As such, all Layer N rollups can be viewed as components of one aggregated state machine, unconstrained by computational limits or space restrictions.
With this design, Nord is able to achieve CEX-like performance, all while maintaining seamless composability with other applications, a feat that currently cannot be achieved elsewhere.
In addition to being strongly secured by Ethereum for both state settlement and data availability, Nord is also the first rollup to introduce a novel zero-knowledge based fraud proving mechanism: zero-knowledge fraud proofs (ZKFPs).
Traditional optimistic rollups make use of interactive fraud proofs that simulate state transitions directly on-chain. This is both inefficient, and unsafe. Inefficient because the process of submitting interactions between prover and verifier is extremely time and compute costly on Ethereum. This method of proving leads to the long 7 day withdrawal periods. Second, the engineering overhead of making sure that the simulated execution on-chain is exactly the same as the off-chain execution environment is extremely burdensome, and can introduce subtle attack vectors.
On the other hand, full zk-rollups need to generate zk proofs on every single or bundle of transactions, which has high hardware requirements, and lead to costly proof generation overhead, which becomes prohibitively expensive if trying to run an exchange with 10,000 trades per second.
ZKFPs is a hybrid solution that leverages the best of both worlds: cheap and fast optimistic transaction settling with the succinctness and security of zero-knowledge for fraud proving. Read here to learn more.
The final aspect that sets Nord apart from alternatives is that it’s integrated into an extensive network of rollups in the Layer N network. By leveraging the native inter-rollup communication protocol of Layer N, other rollups and applications can seamlessly communicate with Nord without the bridging risks, unlocking massive possibilities.
Here’s just two examples of applications that can leverage Nord:
Market-Making Rollup: This rollup could autonomously deploy supplied liquidity onto Nord's order book, seamlessly provide liquidity to trading pairs and help maintain stable markets. Leveraging a custom execution environment, the market making model can even make use of AI models.
Yield Generation Rollup: This rollup specializes in helping users generate yield on their assets and offers various strategies to achieve this goal. Without computational constraints, these yield vaults can now make use of more complex models and strategies to derive the best yield for their users, and execute orders directly on Nord-enabled exchanges.
This seamless composability exists without the risks associated with typical asset bridging, a challenge faced by other networks.
Generally, there are 3 main categories of alternative solutions to Nord: application-specific Layer 1s, generalizable Layer 2 solutions, and app-specific Layer 2 solutions.
App-specific L1s are currently the most popular choice for DEXs when they decide not to launch on a general-purpose blockchain like Ethereum or Solana, or layer 2 solutions like Arbitrum or Optimism.
Among the App-specific L1 options, launching on Cosmos is the easiest and most popular choice because it provides an accessible sdk to launch
|Nord||Sei (Cosmos)||Dydx v4 (Cosmos)|
|Consensus & Security||Secured by Ethereum||Secured by own centralized set of ~40 validators||Secured by own centralized set of ~60 validators|
|Transactions per second (TPS)||~100,000||~20,000||?|
|Composable with smart contracts||Yes||Yes||?|
|Composable with custom execution environment||Yes||No||No|
Many decentralized exchanges are launching on generalizable Layer 2 solutions because they provide more security and decentralization than the app-specific L1s we discussed earlier, as well as better scalability than the default L1s.
|Transactions per second (TPS)||~100,000||~800||~800||~800|
|Built for exchanges||Yes||No (expensive compute and gas)||No (expensive compute and gas)||No (expensive compute and gas)|
|Security||ZKFPs||No publicly available fraud proofs (whitelisted)||None||ZK Proofs|
|Data Availability||EigenDA||Centralized DA Committee||Ethereum||Ethereum|
|Composable with smart contracts||Yes||Yes||?||Yes|
|Composable with custom execution environment||Yes||No||No||No|
When comparing Nord to existing generalizable layer 2 solutions, we notice that Nord out-performs existing solutions significantly when it comes to throughput, cost, and composability with custom execution environments.
Additionally, in terms of security, it is also the only to leverage zero-knowledge fraud proofs, which are less expensive than the zk-proofs used by zkSync Era and more robust than the whitelisted fraud proofs Arbitrum employs.
Finally, Nord also enables direct composability with custom execution environments, which is something lacking from Optimism’s superchain implementation.
App-specific layer 2 solutions are the closest alternative to Nord.
StarkEx, for instance, allows developers to build their app-specific chains similarly to Nord, but let's examine some of the differences when comparing the two.
|Built for on-chain orderbooks||Yes||No|
|Data Availability||EigenDA||Centralized DA Committee|
|Composable with smart contracts||Yes||No|
|Composable with custom execution environment||Yes||No|
The most important distinction is that StarkEx is a fully isolated rollup infrastructure, meaning applications that build using StarkEx will be completely isolated from the rest of the on-chain world, whereas building on Nord enables a whole suite of ecosystem applications to compose.
Nord built on Layer N uniquely empowers exchange developers with tailor-made infrastructure for their specific needs.
Nord’s goal is to be the infrastructure that helps DeFi onboard the remaining 85% of users who still trade on centralized exchanges, and enable a whole suite of powerfully composable applications around on-chain decentralized liquidity.