What Are ZKThreads and How Do They Work?

Decentralized Applications (dApps) hold immense promise for a future built on trustless interactions. However, achieving security, scalability, and interoperability within dApps has proven to be a complex challenge. Over the years, many solutions have emerged to solve this problem. In this blog, we are going to discuss one such solution: ZKThreads, a novel framework introduced by StarkWare in collaboration with Cartridge to solve this trilemma.

The Need for ZKThreads

Traditional zero-knowledge rollups (zk-rollups) process transactions off-chain but store data on-chain, leading to scalability bottlenecks. Additionally, the fragmentation of solutions with different virtual machines and verification mechanisms hinders interoperability between dApps.

ZKThreads addresses these issues by introducing a standardized environment for developing scalable and secure dApps. This framework leverages zero-knowledge proofs (ZKPs) to validate transactions without revealing the underlying data, ensuring privacy.

ZKThreads function as a framework for creating scalable and secure DApps. They utilize Starknet’s capabilities to provide a standardized development environment. This allows developers to build interoperable applications that can seamlessly interact with each other on the blockchain.

Here’s a breakdown of how ZKThreads works:

Application Logic Deployment

The process begins with deploying the application logic into ZKThreads’ app contracts. These contracts define the rules and procedures that govern how an application operates.

Batching Transactions

Instead of handling each transaction individually, ZKThreads groups multiple transactions into a single batch. This batching process significantly improves efficiency when processing large volumes of transactions.

Creating Proofs

Once a batch is formed, a cryptographic proof called a STARK proof is generated. This proof mathematically guarantees that all transactions within the batch are valid and have been processed according to the predefined contract rules.

Verification

The STARK proof is then sent to the Layer 2 sequencer, where it undergoes verification against the canonical record of the dApp. The canonical record represents the verified and accepted state of the application. This verification process involves two entities:

• ZKThread Verifier: This is a contract on Starknet that is responsible for checking the accuracy of the proof. It ensures there’s no double-spending, all transactions are authorized, and the resulting state aligns with the blockchain’s rules. If the proof is valid, the ZKThread Verifier updates the dApp’s canonical state record. On the other hand, if the proof is invalid, the changes are rejected, upholding the application’s integrity.
• State Update: If the verification is successful, the ZKThread Verifier updates the DApp’s canonical state record, reflecting the changes validated by the STARK proof. Conversely, if the verification fails, the changes are rejected, safeguarding the application’s integrity.

Image: ZKThreads Architecture

Benefits of ZKThreads

• Improved User Experience: Users can navigate between applications without switching networks by enabling seamless interaction between different dApps built on ZKThreads, This fosters a more cohesive and user-friendly dApp ecosystem.
• Lower Costs: Batching transactions and processing them together significantly reduces the number of interactions with the main blockchain, leading to lower transaction fees for users. Additionally, by storing both state and transaction data off-chain, ZKThreads minimizes the gas fees associated with on-chain data storage.
• Enhanced Security: ZKPs play a crucial role in ZKThreads’ security model. By validating transactions without revealing the underlying data, ZKThreads preserves user privacy. Furthermore, the verification process ensures that all transactions adhere to predefined rules, preventing unauthorized activities.

ZKThreads vs. Other ZK Solutions

While various ZK solutions exist, ZKThreads offer distinct advantages:

• Data Handling: Unlike many traditional zero-knowledge rollups that move computation off-chain but store transaction data on-chain, ZKThreads keep all data off-chain while utilizing ZKPs for validation. This significantly reduces the data burden on the main blockchain, leading to superior scalability and lower costs.
• Interoperability: ZKThreads prioritize interoperable applications, fostering a more cohesive ecosystem where different DApps can interact seamlessly. In contrast, other solutions like zkEVM focus more on compatibility with existing Ethereum Virtual Machine (EVM) infrastructure.
• Validation Mechanism: The verification process in ZKThreads involves creating STARK proofs that validate the correctness of batched transactions and state changes. These proofs are then verified against the canonical state of the dApp. This approach differs from some zk-rollups that use zk-SNARKs or zk-STARKs to create cryptographic proofs that are verified on-chain.

Potential Use Cases for ZKThreads

• L2 Decentralized Exchanges (DEXes): ZKThreads can significantly reduce transaction fees for DEXes on Starknet, making them more practical and user-friendly. Users would only incur fees when withdrawing funds, unlike current DEXes where fees apply to every trade.
• Session-based Games: In games like poker and chess, ZKThreads can aggregate fees, allowing players to pay a single fee at the game’s conclusion when the final results are recorded on Starknet. This empowers developers to create a wider range of fully on-chain games without worrying about high transaction costs.
• Zk-secured Middleware and Shared Liquidity Infrastructure: ZKThreads provide a secure and efficient framework for middleware applications like oracles and bridges. By building functionality directly within a ZKThread, these applications can leverage ZKPs to ensure security and interoperability.
• On-chain AI: ZKThreads offers the necessary computational power to run AI models directly on the blockchain. This allows for secure and transparent management of AI programs within a ZKThread. These models can then be integrated into various applications, such as games, social media platforms, and productivity tools.

Future outlook

ZKThreads offers a promising approach to scaling DApps while maintaining security and interoperability. Their focus on a standardized development environment and off-chain data storage with ZKP verification positions them well to address current limitations in the blockchain space. While the technology is still under development, its potential benefits for building dApps are significant. Its success is likely to depend on developer adoption, the integration with existing blockchain infrastructure, and the scalability of the underlying ZKP technology. As ZKThreads evolve, they have the potential to play a pivotal role in shaping the future of decentralized applications.