Fluent is a versatile Layer 2 zkWasm that transposes the preferred execution environment of web2 (Wasm) onto the most permissionless blockchain of web3. Fluent empowers developers with the freedom to build composable dApps in nearly any programming language on Ethereum.
ℹ️ Information: You might be wondering, “What is Wasm?” Let me try to answer that here:
WebAssembly (Wasm) is a computer technology that enables code execution on the web more efficiently. Typically, when you visit a website, your browser downloads and executes code written in languages like JavaScript. However, JavaScript can sometimes be slow, especially for complex web applications.
Wasm comes to the rescue by providing an alternative. It allows developers to write code in languages like C, C++, or Rust, and then compile it into a special format called WebAssembly. This compiled code can then be executed directly in your web browser.
The main advantage of Wasm is its speed. Since the code is pre-compiled into a compact and efficient binary format, it can run much faster than traditional JavaScript code. This means that games, graphic applications, physical simulations, and other resource-intensive applications can run more smoothly on the web.
➮ The use of Wasm has an impact on the web, affecting both web2 and web3. In the context of web2, Wasm expands possibilities by allowing the use of various programming languages, thus providing developers with flexibility in choosing tools for their applications.
➮ But where Wasm really shows its power (like, really) is in the world of web3, where decentralization is paramount. It plays a significant role in blockchains like Ethereum by enabling efficient and decentralized execution of smart contracts.
Wasm and Fluent
In the context of Fluent, Wasm enables developers to experience Ethereum programming similarly to web2. By using Wasm, Fluent offers the ability to write smart contracts in a multitude of programming languages such as Rust (the language used by Solana) or TypeScript… In short, with Wasm, you can develop in any programming language, opening up so many doors for developers, it’s incredible.
Additionally, Fluent ensures compatibility with the EVM, facilitating support for established standards such as native Account Abstraction and enabling seamless interaction with tools such as the MetaMask wallet. Some Ethereum-compatible features include: • Transaction encoding and signing • Block structure • 100% support for
WASM and EVM • Solidity compilation to Wasm
Fluent VM
🔹 The Fluent Virtual Machine is the Fluent zkWasm VM.
The Fluent virtual machine is a modified version of the Wasm binary instruction format, specifically designed to enhance efficiency and verification ease when executing smart contracts. Think of it as a simplified version of Wasm, which we call rWasm for Reduced WebAssembly. The goal of rWasm is to create a simplified binary representation of Wasm that is compatible with the original instruction set. This will facilitate accuracy verification of Wasm programs and improve overall efficiency by providing developers with a simpler and ZK-SNARK-compatible environment, while still maintaining compatibility with the original instruction set.
🔹 Simplified Execution
With rWasm, relative offsets within the Wasm binary are eliminated, making the execution flow more direct and predictable. This approach removes the need for a type mapping validator, simplifying validation.
🔹 Verification and Structure Improvement
- Functions are grouped into a single flat structure, simplifying the verification process and reducing binary format complexity.
- Function indices are replaced with bytecode positions, facilitating verification of the correctness of the program counter (PC).
🔹 Binary Optimization
- All sections are replaced by a loader inside rWasm that strictly follows the same standards as Wasm. This ensures compatibility with all sections. Simulated sections, such as memory, table, data, and element segments, simplify the binary structure without compromising functionality.
- Global section support is enhanced for mutable and immutable variables, ensuring static verification of their correct usage.
ℹ️ Information: If you’re having trouble understanding what was previously said, look at what’s marked below, then reread the preceding text.
➮ Relative offsets: This refers to the difference or displacement between memory addresses in binary code. Relative offsets are often used to access data or instructions in a computer program’s memory.
➮ Wasm binary: This is the binary code generated from the WebAssembly (Wasm) programming language. Wasm is a compact and portable binary format designed to be used as an intermediate language for web applications.
➮ Type mapping validator: This is a tool or process that verifies that the data types used in a computer program match the expected types. It ensures that data is correctly associated and used in the program.
➮ Functions combined into a flat structure: This means that the different functions of a program are grouped into a single continuous area of memory, without hierarchy or complex organization.
➮ Function indices replaced with bytecode positions: Function indices are numerical references to functions in the code. Bytecode is the low-level machine code that is executed by the virtual machine. This phrase indicates that numerical references are replaced with direct positions in the executable code.
➮ Simulated sections: These are memory or data sections that are artificially created to facilitate processing or management of data in the program. For example, a simulated memory section might be used to simulate dynamic memory allocation in an environment where it is not directly supported.
➮ Global section support for mutable and immutable variables: This means that management of global variables (variables accessible from any part of the program) is improved to allow both variables that can be modified (mutable) and those that cannot (immutable). This ensures that the correct usage of these variables can be statically verified, i.e., before program execution.
Fluentbase Framework
Fluent also has its own SDK: Fluentbase. This SDK supports three main languages: Rust, Solidity, and Vyper.
Fluentbase operates using Fluent’s rWasm virtual machine (Reduced WebAssembly). This virtual machine uses a 100% compatible WebAssembly binary representation, optimized for Zero-Knowledge Proof (ZK) operations. The instruction set is reduced, and sections are integrated into the binary to simplify the proof process.
Fluent and ZK
As mentioned earlier, Fluent is a layer 2 Zero-Knowledge Proof (ZKP) solution. They utilize ZK-SNARKs, which is a type of ZKP.
ℹ️ Information : “But what are ZK-SNARKs?” Read this: 👇
➮ ZK-SNARKs:
Zero-Knowledge Succinct Non-interactive ARgument of Knowledge (ZK-SNARKs) cryptographic proofs are a powerful tool used in cryptography, especially in blockchains and crypto. ZK-SNARK stands for “Zero-Knowledge Succinct Non-interactive ARgument of Knowledge”.
In practice, ZK-SNARKs allow a person to prove that they possess certain knowledge without revealing the details of that knowledge. These proofs are both succinct, meaning they are of small size, and non-interactive, meaning they do not require interaction between the prover and the verifier.
The process of ZK-SNARKs relies on three main algorithms:
- Key generator: This algorithm creates the keys necessary for proof generation and verification.
- Prover: This algorithm allows the prover to generate a proof from certain information without revealing that information in detail.
- Verifier: This algorithm allows the verifier to check the validity of the proof without needing to know the details of the proven information.
ZK-SNARKs are used in cryptocurrencies like Fluent to create confidential transactions, where network nodes can verify the validity of a transaction without knowing sensitive details such as the amount or addresses involved.
It is important to note that to ensure the security of ZK-SNARKs, it is necessary to establish a trust setup between the prover and the verifier, usually through a “trusted setup” where secret parameters are securely generated.
➮ UltraPlonk
Fluent doesn’t stop at just regular ZK; it also offers UltraPlonk. UltraPlonk is an extension or an enhanced version of the aPlonk algorithm, which itself is an improved version of Plonk. UltraPlonk is more efficient, capable of handling larger or more complex workloads, can include additional features, and has specific optimizations compared to aPlonk. we will explain what aPlonk is, and you’ll understand UltraPlonk.
Just before, we will give you some information we’ll use: ZKP uses mathematical polynomials to function.
aPlonk is a technology belonging to the Zero Knowledge Proof family. Its goal is to enhance the privacy and scalability of transactions on the blockchain by enabling the aggregation of multiple proofs efficiently. This technology is a variant of Plonk, a zero-knowledge proof system developed to address these specific needs.
The main advantage of aPlonk lies in its ability to aggregate multiple proofs into one, thereby reducing the size and verification time of the proofs. In practical terms, this means that a large number of proofs can be combined into a single aggregated proof, allowing for faster and less costly validation on the blockchain.
But now, you might be wondering how is that possible? Does it mean that multiple ZK proofs, and therefore multiple polynomials (since we’ve seen that ZK proofs work with polynomials), need to be gathered? Yes, that’s exactly it.
Proof aggregation is achieved by constructing a single polynomial that combines several polynomials used in different operations (or circuits) on the blockchain. Then, this polynomial is used to generate a succinct proof representing all the operations performed.
What distinguishes aPlonK from other similar solutions is its ability to aggregate proofs universally, meaning it’s not limited to a single type of circuit or operation. This makes it particularly suitable for blockchains, where many different operations need to be verified.
So aPlonK enables a significant optimization of ZK proofs = more scalability.
Useful Links
- Official website: https://fluentlabs.xyz
- Discord: https://discord.gg/WMHTbYASck
Conclusion
Fluent is an Ethereum Layer 2 zkWASM worth keeping an eye on. It fits into the L2 ZKP narrative, and with its multilingual capacity and numerous advantages, it’s a project to watch closely for 2024. By reading the documentation, it quickly becomes apparent that they’re here to innovate rather than just develop another L2 that doesn’t offer as many advantages as others. Moreover, it’s noticeable that they’re conducting a lot of research on new technical advancements, showing that the team is attentive to its market.
Related Posts
Artrade : The NFT Marketplace for Web2 & Web3 Artists
What is a modular blockchain?
