From bab50c6e058fd7058f282428e2bc9a913130a471 Mon Sep 17 00:00:00 2001 From: Sabrina Date: Mon, 22 Apr 2024 13:23:07 -0400 Subject: [PATCH] Zk stack components (#21) # What :computer: * Add zk-stack components section to docs --- .../05.concepts/99.l1_l2_communication.md | 2 +- .../10.zk-stack/10.components/10.overview.md | 31 + .../10.components/100.block-explorer.md | 20 + .../20.smart-contracts/10.smart-contracts.md | 289 +++++++ .../20.smart-contracts/20.system-contracts.md | 324 ++++++++ .../10.components/20.smart-contracts/_dir.yml | 1 + .../10.components/30.shared-bridges.md | 245 ++++++ .../10.components/40.sequencer-server.md | 51 ++ .../50.zksync-evm/00.overview.md | 54 ++ .../50.zksync-evm/10.bootloader.md | 343 ++++++++ .../50.zksync-evm/20.precompiles.md | 198 +++++ .../30.vm-specification/10.vm-primer.md | 637 +++++++++++++++ .../30.vm-specification/20.formal-spec.md | 9 + .../30.vm-specification/_dir.yml | 1 + .../10.components/50.zksync-evm/_dir.yml | 1 + .../10.components/60.prover/10.overview.md | 70 ++ .../60.prover/20.zk-terminology.md | 77 ++ .../60.prover/30.running-the-prover.md | 23 + .../60.prover/40.circuits/10.overview.md | 124 +++ .../40.circuits/100.sha256-round-function.md | 375 +++++++++ .../40.circuits/110.storage-application.md | 222 +++++ .../40.circuits/120.sorting/10.overview.md | 62 ++ .../120.sorting/20.sort-decommitments.md | 235 ++++++ .../120.sorting/30.storage-sorter.md | 292 +++++++ .../40.circuits/120.sorting/40.log-sorter.md | 354 ++++++++ .../40.circuits/120.sorting/_dir.yml | 1 + .../40.circuits/15.circuit-testing.md | 64 ++ .../40.circuits/20.code-decommitter.md | 217 +++++ .../40.circuits/30.demux-log-queue.md | 232 ++++++ .../60.prover/40.circuits/40.ecrecover.md | 326 ++++++++ .../40.circuits/50.keccak-round-function.md | 212 +++++ .../40.circuits/60.l1-messages-hasher.md | 157 ++++ .../60.prover/40.circuits/70.log-sorter.md | 357 ++++++++ .../60.prover/40.circuits/80.main-vm.md | 348 ++++++++ .../40.circuits/90.ram-permutation.md | 203 +++++ .../60.prover/40.circuits/_dir.yml | 1 + .../60.prover/50.boojum-gadgets.md | 196 +++++ .../60.boojum-function-check-if-satisfied.md | 100 +++ .../10.components/60.prover/_dir.yml | 1 + .../70.compiler/10.toolchain/10.overview.md | 85 ++ .../70.compiler/10.toolchain/20.solidity.md | 125 +++ .../70.compiler/10.toolchain/30.vyper.md | 53 ++ .../70.compiler/10.toolchain/40.llvm.md | 35 + .../20.specification/10.overview.md | 42 + .../20.specification/20.code-separation.md | 79 ++ .../20.specification/30.system-contracts.md | 139 ++++ .../20.specification/40.exception-handling.md | 132 +++ .../20.specification/50.evmla-translator.md | 759 ++++++++++++++++++ .../60.instructions/10.overview.md | 48 ++ .../60.instructions/20.evm/10.overview.md | 29 + .../60.instructions/20.evm/arithmetic.md | 369 +++++++++ .../60.instructions/20.evm/bitwise.md | 218 +++++ .../60.instructions/20.evm/block.md | 156 ++++ .../60.instructions/20.evm/calls.md | 42 + .../60.instructions/20.evm/create.md | 22 + .../60.instructions/20.evm/environment.md | 332 ++++++++ .../60.instructions/20.evm/events.md | 29 + .../60.instructions/20.evm/hashes.md | 54 ++ .../60.instructions/20.evm/logical.md | 205 +++++ .../60.instructions/20.evm/memory.md | 76 ++ .../60.instructions/20.evm/return.md | 78 ++ .../60.instructions/20.evm/stack.md | 56 ++ .../60.instructions/20.evm/storage.md | 46 ++ .../60.instructions/30.evmla.md | 91 +++ .../60.instructions/40.yul.md | 107 +++ .../10.components/70.compiler/_dir.yml | 1 + .../10.components/80.fee-withdrawer.md | 9 + .../10.components/90.portal-wallet-bridge.md | 17 + content/10.zk-stack/10.components/_dir.yml | 1 + .../20.running-a-hyperchain/10.locally.md | 246 ++++++ .../20.running-a-hyperchain/20.production.md | 25 + .../20.running-a-hyperchain/30.raas.md | 30 + .../99.dependencies.md | 289 +++++++ .../99.enabling-prover.md | 30 + .../99.using-hyperchain.md | 77 ++ content/_zksync.json | 12 + cspell-config/cspell-blockchain.txt | 16 +- cspell-config/cspell-dev.txt | 63 ++ cspell-config/cspell-misc.txt | 2 + cspell-config/cspell-zksync.txt | 1 + cspell.json | 6 + nuxt.config.ts | 15 +- package.json | 2 +- .../images/zk-stack/Check_if_satisfied-1.png | Bin 0 -> 26265 bytes .../images/zk-stack/Check_if_satisfied-11.png | Bin 0 -> 25623 bytes .../images/zk-stack/Check_if_satisfied-12.png | Bin 0 -> 30075 bytes .../images/zk-stack/Check_if_satisfied-13.png | Bin 0 -> 32512 bytes .../images/zk-stack/Check_if_satisfied-14.png | Bin 0 -> 18577 bytes .../images/zk-stack/Check_if_satisfied-16.png | Bin 0 -> 22773 bytes .../images/zk-stack/Check_if_satisfied-17.png | Bin 0 -> 29961 bytes .../images/zk-stack/Check_if_satisfied-2.png | Bin 0 -> 37159 bytes .../images/zk-stack/Check_if_satisfied-3.png | Bin 0 -> 70440 bytes .../images/zk-stack/Check_if_satisfied-4.png | Bin 0 -> 36604 bytes .../images/zk-stack/Check_if_satisfied-7.png | Bin 0 -> 47238 bytes .../images/zk-stack/Check_if_satisfied-8.png | Bin 0 -> 32661 bytes .../images/zk-stack/Check_if_satisfied-9.png | Bin 0 -> 23573 bytes public/images/zk-stack/Check_if_satisfied.png | Bin 0 -> 41064 bytes public/images/zk-stack/arithmetic_opcode.png | Bin 0 -> 4786 bytes .../zk-stack/base-layer-circuit-diagram.png | Bin 0 -> 78985 bytes public/images/zk-stack/circuit-allocate.png | Bin 0 -> 135392 bytes .../images/zk-stack/circuit-commitments.png | Bin 0 -> 58802 bytes .../zk-stack/circuit-compare-addresses.png | Bin 0 -> 41020 bytes .../zk-stack/circuit-ecrecover-precompile.png | Bin 0 -> 20995 bytes public/images/zk-stack/circuit-ecrecover.png | Bin 0 -> 24882 bytes .../images/zk-stack/circuit-finite-fields.png | Bin 0 -> 36595 bytes public/images/zk-stack/circuit-lookup.png | Bin 0 -> 58023 bytes public/images/zk-stack/circuit-pi-diagram.png | Bin 0 -> 5340 bytes public/images/zk-stack/circuit.png | Bin 0 -> 5206 bytes public/images/zk-stack/circuits-address.png | Bin 0 -> 25651 bytes .../zk-stack/circuits-configure-builder.png | Bin 0 -> 22674 bytes .../zk-stack/circuits-ecrecover-geometry.png | Bin 0 -> 70923 bytes public/images/zk-stack/compiler-toolchain.png | Bin 0 -> 46779 bytes public/images/zk-stack/contracts-external.png | Bin 0 -> 74938 bytes public/images/zk-stack/vm-mapping.png | Bin 0 -> 20398 bytes 114 files changed, 10693 insertions(+), 11 deletions(-) create mode 100644 content/10.zk-stack/10.components/10.overview.md create mode 100644 content/10.zk-stack/10.components/100.block-explorer.md create mode 100644 content/10.zk-stack/10.components/20.smart-contracts/10.smart-contracts.md create mode 100644 content/10.zk-stack/10.components/20.smart-contracts/20.system-contracts.md create mode 100644 content/10.zk-stack/10.components/20.smart-contracts/_dir.yml create mode 100644 content/10.zk-stack/10.components/30.shared-bridges.md create mode 100644 content/10.zk-stack/10.components/40.sequencer-server.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/00.overview.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/10.bootloader.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/20.precompiles.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/10.vm-primer.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/20.formal-spec.md create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/_dir.yml create mode 100644 content/10.zk-stack/10.components/50.zksync-evm/_dir.yml create mode 100644 content/10.zk-stack/10.components/60.prover/10.overview.md create mode 100644 content/10.zk-stack/10.components/60.prover/20.zk-terminology.md create mode 100644 content/10.zk-stack/10.components/60.prover/30.running-the-prover.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/10.overview.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/100.sha256-round-function.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/110.storage-application.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/10.overview.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/20.sort-decommitments.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/30.storage-sorter.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/40.log-sorter.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/_dir.yml create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/15.circuit-testing.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/20.code-decommitter.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/30.demux-log-queue.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/40.ecrecover.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/50.keccak-round-function.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/60.l1-messages-hasher.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/70.log-sorter.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/80.main-vm.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/90.ram-permutation.md create mode 100644 content/10.zk-stack/10.components/60.prover/40.circuits/_dir.yml create mode 100644 content/10.zk-stack/10.components/60.prover/50.boojum-gadgets.md create mode 100644 content/10.zk-stack/10.components/60.prover/60.boojum-function-check-if-satisfied.md create mode 100644 content/10.zk-stack/10.components/60.prover/_dir.yml create mode 100644 content/10.zk-stack/10.components/70.compiler/10.toolchain/10.overview.md create mode 100644 content/10.zk-stack/10.components/70.compiler/10.toolchain/20.solidity.md create mode 100644 content/10.zk-stack/10.components/70.compiler/10.toolchain/30.vyper.md create mode 100644 content/10.zk-stack/10.components/70.compiler/10.toolchain/40.llvm.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/10.overview.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/20.code-separation.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/30.system-contracts.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/40.exception-handling.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/50.evmla-translator.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/10.overview.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/10.overview.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/arithmetic.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/bitwise.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/block.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/calls.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/create.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/environment.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/events.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/hashes.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/logical.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/memory.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/return.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/stack.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/storage.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/30.evmla.md create mode 100644 content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/40.yul.md create mode 100644 content/10.zk-stack/10.components/70.compiler/_dir.yml create mode 100644 content/10.zk-stack/10.components/80.fee-withdrawer.md create mode 100644 content/10.zk-stack/10.components/90.portal-wallet-bridge.md create mode 100644 content/10.zk-stack/10.components/_dir.yml create mode 100644 content/10.zk-stack/20.running-a-hyperchain/10.locally.md create mode 100644 content/10.zk-stack/20.running-a-hyperchain/20.production.md create mode 100644 content/10.zk-stack/20.running-a-hyperchain/30.raas.md create mode 100644 content/10.zk-stack/20.running-a-hyperchain/99.dependencies.md create mode 100644 content/10.zk-stack/20.running-a-hyperchain/99.enabling-prover.md create mode 100644 content/10.zk-stack/20.running-a-hyperchain/99.using-hyperchain.md create mode 100644 public/images/zk-stack/Check_if_satisfied-1.png create mode 100644 public/images/zk-stack/Check_if_satisfied-11.png create mode 100644 public/images/zk-stack/Check_if_satisfied-12.png create mode 100644 public/images/zk-stack/Check_if_satisfied-13.png create mode 100644 public/images/zk-stack/Check_if_satisfied-14.png create mode 100644 public/images/zk-stack/Check_if_satisfied-16.png create mode 100644 public/images/zk-stack/Check_if_satisfied-17.png create mode 100644 public/images/zk-stack/Check_if_satisfied-2.png create mode 100644 public/images/zk-stack/Check_if_satisfied-3.png create mode 100644 public/images/zk-stack/Check_if_satisfied-4.png create mode 100644 public/images/zk-stack/Check_if_satisfied-7.png create mode 100644 public/images/zk-stack/Check_if_satisfied-8.png create mode 100644 public/images/zk-stack/Check_if_satisfied-9.png create mode 100644 public/images/zk-stack/Check_if_satisfied.png create mode 100644 public/images/zk-stack/arithmetic_opcode.png create mode 100644 public/images/zk-stack/base-layer-circuit-diagram.png create mode 100644 public/images/zk-stack/circuit-allocate.png create mode 100644 public/images/zk-stack/circuit-commitments.png create mode 100644 public/images/zk-stack/circuit-compare-addresses.png create mode 100644 public/images/zk-stack/circuit-ecrecover-precompile.png create mode 100644 public/images/zk-stack/circuit-ecrecover.png create mode 100644 public/images/zk-stack/circuit-finite-fields.png create mode 100644 public/images/zk-stack/circuit-lookup.png create mode 100644 public/images/zk-stack/circuit-pi-diagram.png create mode 100644 public/images/zk-stack/circuit.png create mode 100644 public/images/zk-stack/circuits-address.png create mode 100644 public/images/zk-stack/circuits-configure-builder.png create mode 100644 public/images/zk-stack/circuits-ecrecover-geometry.png create mode 100644 public/images/zk-stack/compiler-toolchain.png create mode 100644 public/images/zk-stack/contracts-external.png create mode 100644 public/images/zk-stack/vm-mapping.png diff --git a/content/10.zk-stack/05.concepts/99.l1_l2_communication.md b/content/10.zk-stack/05.concepts/99.l1_l2_communication.md index b40b8307..69205f1a 100644 --- a/content/10.zk-stack/05.concepts/99.l1_l2_communication.md +++ b/content/10.zk-stack/05.concepts/99.l1_l2_communication.md @@ -202,7 +202,7 @@ In a very rare event when the team needs to revert the batch with the upgrade on [reset](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/contracts/ethereum/contracts/zksync/facets/Executor.sol#L412). Note, however, that we do not “remember” that certain batches had a version before the upgrade, i.e. if the reverted -batches will have to be reexecuted, the upgrade transaction must still be present there, even if some of the deleted +batches will have to be re-executed, the upgrade transaction must still be present there, even if some of the deleted batches were committed before the upgrade and thus didn’t contain the transaction. ### Execute diff --git a/content/10.zk-stack/10.components/10.overview.md b/content/10.zk-stack/10.components/10.overview.md new file mode 100644 index 00000000..a394d76d --- /dev/null +++ b/content/10.zk-stack/10.components/10.overview.md @@ -0,0 +1,31 @@ +--- +title: Overview +description: Explore the ZK Stack, a flexible, open-source framework designed for creating sovereign ZK-powered Ethereum rollups, known as hyperchains, utilizing the foundational technology of zkSync Era. +--- + +The ZK Stack is a comprehensive framework aimed at revolutionizing the development of Ethereum rollups through its modular design and open-source nature. +Based on the pioneering work of zkSync Era, +the ZK Stack extends the core functionalities to enable developers +to build custom hyperchains—Layer 2 (L2) and Layer 3 (L3) solutions—that are tailored to specific needs +while ensuring compatibility and interoperability within the Ethereum ecosystem. + +## Core features of the ZK Stack + +### Sovereignty + +The ZK Stack is built on the principle of sovereignty, granting developers complete control over their hyperchains. +This means that developers can: + +- **Customize Chain Features**: Tailor aspects such as transaction rules, +data availability, and consensus mechanisms to suit specific use cases or performance requirements. +- **Own the Code**: Have full rights to the underlying code, providing the freedom to modify or enhance the chain as needed without external constraints. + +### Seamless connectivity + +Despite each hyperchain's independence, the ZK Stack ensures that they do not operate in isolation. +Instead, hyperchains are part of a cohesive network, linked by hyperbridges that facilitate seamless interactions: + +- **Trustless Interoperability**: Hyperbridges allow for secure and reliable communication between different hyperchains +without needing to trust a central authority, making interactions as trustless as those on Ethereum itself. +- **Fast and Cost-Effective**: Communication and asset transfers between hyperchains are designed to be both rapid (completed within minutes) +and economical (incurring costs equivalent to a single standard transaction). diff --git a/content/10.zk-stack/10.components/100.block-explorer.md b/content/10.zk-stack/10.components/100.block-explorer.md new file mode 100644 index 00000000..057ff09a --- /dev/null +++ b/content/10.zk-stack/10.components/100.block-explorer.md @@ -0,0 +1,20 @@ +--- +title: Block Explorer +description: Explore the functionality of Block Explorer, a comprehensive tool for monitoring activities on your hyperchain. +--- + +[The Block Explorer](https://github.com/matter-labs/block-explorer) +is a tool designed to provide comprehensive insights into all activities occurring on a hyperchain. +This tool is especially useful for users and developers who need to monitor or interact with the blockchain. Block Explorer consists of three main components: + +- **Block Explorer Worker:** + This indexer service manages hyperchain data. + Its main role is to collect data from the blockchain in real time, process this data, and populate a database that supports the API. + +- **Block Explorer API:** + This component offers an HTTP API to access structured data from the hyperchain. + It retrieves data from the database maintained by the Block Explorer Worker. + +- **Block Explorer App:** + This is the user interface that enables users and developers to navigate and examine transactions, + blocks, batches, contracts, tokens, and other elements within the hyperchain. diff --git a/content/10.zk-stack/10.components/20.smart-contracts/10.smart-contracts.md b/content/10.zk-stack/10.components/20.smart-contracts/10.smart-contracts.md new file mode 100644 index 00000000..86325d65 --- /dev/null +++ b/content/10.zk-stack/10.components/20.smart-contracts/10.smart-contracts.md @@ -0,0 +1,289 @@ +--- +title: Smart Contracts +description: Explore the architecture of Layer 2 smart contracts on Ethereum and their role in the hyperchain ecosystem. +--- + +Smart contracts on Ethereum are pivotal in enabling rollups to inherit security and decentralization. +These contracts manage the state changes of rollups by storing information on Ethereum and providing validity proofs for state transitions. +They also facilitate communication mechanisms among different layers and systems. + +In addition to the primary roles, some smart contracts also support the hyperchain ecosystem. +Detailed information on these contracts can be found in the [Shared Bridges](/zk-stack/components/shared-bridges) section. +The Shared Bridge utilizes these smart contracts to facilitate cross-chain interactions and enhance connectivity within the blockchain environment. + +--- +## Diamond + +Technically, this L1 smart contract acts as a connector between Ethereum (L1) and a single L2. It checks the validity +proof and data availability, handles L2 <-> L1 communication, finalizes L2 state transition, and more. + +### DiamondProxy + +The main contract uses [EIP-2535](https://eips.ethereum.org/EIPS/eip-2535) diamond proxy pattern. It is an in-house +implementation that is inspired by the [mudgen reference implementation](https://github.com/mudgen/Diamond). It has no +external functions, only the fallback that delegates a call to one of the facets (target/implementation contract). So +even an upgrade system is a separate facet that can be replaced. + +Each of the facets has an associated +parameter that indicates if it is possible to freeze access to the facet. Privileged actors can freeze the **diamond** +(not a specific facet!) and all facets with the marker `isFreezable` should be inaccessible until the governor or admin +unfreezes the diamond. Note that it is a very dangerous thing since the diamond proxy can freeze the upgrade system and +then the diamond will be frozen forever. + +The diamond proxy pattern is very flexible and extendable. For now, it allows splitting implementation contracts by +their logical meaning, removes the limit of bytecode size per contract and implements security features such as +freezing. In the future, it can also be viewed as [EIP-6900](https://eips.ethereum.org/EIPS/eip-6900) for +[zkStack](https://blog.matter-labs.io/introducing-the-zk-stack-c24240c2532a), where each hyperchain can implement a +sub-set of allowed implementation contracts. + +### GettersFacet + +Separate facet, whose only function is providing `view` and `pure` methods. It also implements +[diamond loupe](https://eips.ethereum.org/EIPS/eip-2535#diamond-loupe) which makes managing facets easier. This contract +must never be frozen. + +### AdminFacet + +Controls changing the privileged addresses such as governor and validators or one of the system parameters (L2 +bootloader bytecode hash, verifier address, verifier parameters, etc), and it also manages the freezing/unfreezing and +execution of upgrades in the diamond proxy. + +The admin facet is controlled by two entities: + +- Governance - Separate smart contract that can perform critical changes to the system as protocol upgrades. This + contract controlled by two multisigs, one managed by Matter Labs team and another will be multisig with well-respected + contributors in the crypto space. Only together they can perform an instant upgrade, the Matter Labs team can only + schedule an upgrade with delay. +- Admin - Multisig smart contract managed by Matter Labs that can perform non-critical changes to the system such as + granting validator permissions. Note, that the Admin is the same multisig as the owner of the governance. + +### MailboxFacet + + + + +The Mailbox performs three functions: + +- L1 <-> L2 communication. +- Bridging native Ether to the L2 (with the launch of the Shared Bridge this will be moved) +- Censorship resistance mechanism (in the research stage). + +L1 -> L2 communication is implemented as requesting an L2 transaction on L1 and executing it on L2. This means a user +can call the function on the L1 contract to save the data about the transaction in some queue. Later on, a validator can +process it on L2 and mark it as processed on the L1 priority queue. Currently, it is used for sending information from +L1 to L2 or implementing multi-layer protocols. + +_NOTE_: While user requests the transaction from L1, the initiated transaction on L2 will have such a `msg.sender`: + +```solidity + address sender = msg.sender; + if (sender != tx.origin) { + sender = AddressAliasHelper.applyL1ToL2Alias(msg.sender); + } +``` + +where + +```solidity +uint160 constant offset = uint160(0x1111000000000000000000000000000000001111); + +function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) { + unchecked { + l2Address = address(uint160(l1Address) + offset); + } +} + +``` + +For most of the rollups the address aliasing needs to prevent cross-chain exploits that would otherwise be possible if +we simply reused the same L1 addresses as the L2 sender. In zkEVM address derivation rule is different from the +Ethereum, so cross-chain exploits are already impossible. However, the zkEVM may add full EVM support in the future, so +applying address aliasing leaves room for future EVM compatibility. + +The L1 -> L2 communication is also used for bridging ether. The user should include a `msg.value` when initiating a +transaction request on the L1 contract. Before executing a transaction on L2, the specified address will be credited +with the funds. To withdraw funds user should call `withdraw` function on the `L2EtherToken` system contracts. This will +burn the funds on L2, allowing the user to reclaim them through the `finalizeEthWithdrawal` function on the +`MailboxFacet`. + +More about L1->L2 operations can be found +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1→L2%20ops%20on%20zkSync.md). + +L2 -> L1 communication, in contrast to L1 -> L2 communication, is based only on transferring the information, and not on +the transaction execution on L1. The full description of the mechanism for sending information from L2 to L1 can be +found +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20pubdata%20in%20Boojum.md). + +### ExecutorFacet + +A contract that accepts L2 batches, enforces data availability and checks the validity of zk-proofs. + +The state transition is divided into three stages: + +- `commitBatches` - check L2 batch timestamp, process the L2 logs, save data for a batch, and prepare data for zk-proof. +- `proveBatches` - validate zk-proof. +- `executeBatches` - finalize the state, marking L1 -> L2 communication processing, and saving Merkle tree with L2 logs. + +Each L2 -> L1 system log will have a key that is part of the following: + +```solidity +enum SystemLogKey { + L2_TO_L1_LOGS_TREE_ROOT_KEY, + TOTAL_L2_TO_L1_PUBDATA_KEY, + STATE_DIFF_HASH_KEY, + PACKED_BATCH_AND_L2_BLOCK_TIMESTAMP_KEY, + PREV_BATCH_HASH_KEY, + CHAINED_PRIORITY_TXN_HASH_KEY, + NUMBER_OF_LAYER_1_TXS_KEY, + EXPECTED_SYSTEM_CONTRACT_UPGRADE_TX_HASH_KEY +} + +``` + +When a batch is committed, we process L2 -> L1 system logs. Here are the invariants that are expected there: + +- In a given batch there will be either 7 or 8 system logs. The 8th log is only required for a protocol upgrade. +- There will be a single log for each key that is contained within `SystemLogKey` +- Three logs from the `L2_TO_L1_MESSENGER` with keys: +- `L2_TO_L1_LOGS_TREE_ROOT_KEY` +- `TOTAL_L2_TO_L1_PUBDATA_KEY` +- `STATE_DIFF_HASH_KEY` +- Two logs from `L2_SYSTEM_CONTEXT_SYSTEM_CONTRACT_ADDR` with keys: + - `PACKED_BATCH_AND_L2_BLOCK_TIMESTAMP_KEY` + - `PREV_BATCH_HASH_KEY` +- Two or three logs from `L2_BOOTLOADER_ADDRESS` with keys: + - `CHAINED_PRIORITY_TXN_HASH_KEY` + - `NUMBER_OF_LAYER_1_TXS_KEY` + - `EXPECTED_SYSTEM_CONTRACT_UPGRADE_TX_HASH_KEY` +- None logs from other addresses (may be changed in the future). + +### DiamondInit + +It is a one-function contract that implements the logic of initializing a diamond proxy. It is called only once on the +diamond constructor and is not saved in the diamond as a facet. + +Implementation detail - function returns a magic value just like it is designed in +[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271), but the magic value is 32 bytes in size. + +## Bridges + +Bridges are completely separate contracts from the Diamond. They are a wrapper for L1 <-> L2 communication on contracts +on both L1 and L2. Upon locking assets on L1, a request is sent to mint these bridged assets on L2. Upon burning assets +on L2, a request is sent to unlock them on L2. + +Unlike the native Ether bridging, all other assets can be bridged by the custom implementation relying on the trustless +L1 <-> L2 communication. + +### L1ERC20Bridge + +The "standard" implementation of the ERC20 token bridge. Works only with regular ERC20 tokens, i.e. not with +fee-on-transfer tokens or other custom logic for handling user balances. + +- `deposit` - lock funds inside the contract and send a request to mint bridged assets on L2. +- `claimFailedDeposit` - unlock funds if the deposit was initiated but then failed on L2. +- `finalizeWithdrawal` - unlock funds for the valid withdrawal request from L2. + +The owner of the L1ERC20Bridge is the Governance contract. + +### L2ERC20Bridge + +The L2 counterpart of the L1 ERC20 bridge. + +- `withdraw` - initiate a withdrawal by burning funds on the contract and sending a corresponding message to L1. +- `finalizeDeposit` - finalize the deposit and mint funds on L2. The function is only callable by L1 bridge. + +The owner of the L2ERC20Bridge and the contracts related to it is the Governance contract. + +### L1WethBridge + +The custom bridge exclusively handles transfers of WETH tokens between the two domains. It is designed to streamline and +enhance the user experience for bridging WETH tokens by minimizing the number of transactions required and reducing +liquidity fragmentation thus improving efficiency and user experience. + +This contract accepts WETH deposits on L1, unwraps them to ETH, and sends the ETH to the L2 WETH bridge contract, where +it is wrapped back into WETH and delivered to the L2 recipient. + +Thus, the deposit is made in one transaction, and the user receives L2 WETH that can be unwrapped to ETH. + +For withdrawals, the contract receives ETH from the L2 WETH bridge contract, wraps it into WETH, and sends the WETH to +the L1 recipient. + +The owner of the L1WethBridge contract is the Governance contract. + +### L2WethBridge + +The L2 counterpart of the L1 WETH bridge. + +The owner of the L2WethBridge and L2Weth contracts is the Governance contract. + +## Governance + +This contract manages calls for all governed zkEVM contracts on L1 and L2. Mostly, it is used for upgradability an +changing critical system parameters. The contract has minimum delay settings for the call execution. + +Each upgrade consists of two steps: + +- Scheduling - The owner can schedule upgrades in two different manners: + - Fully transparent data. All the targets, calldata, and upgrade conditions are known to the community before upgrade + execution. + - Shadow upgrade. The owner only shows the commitment to the upgrade. This upgrade type is mostly useful for fixing + critical issues in the production environment. +- Upgrade execution - the Owner or Security council can perform the upgrade with previously scheduled parameters. + - Upgrade with delay. Scheduled operations should elapse the delay period. Both the owner and Security Council can + execute this type of upgrade. + - Instant upgrade. Scheduled operations can be executed at any moment. Only the Security Council can perform this type + of upgrade. + +Please note, that both the Owner and Security council can cancel the upgrade before its execution. + +The diagram below outlines the complete journey from the initiation of an operation to its execution. + +## ValidatorTimelock + +An intermediate smart contract between the validator EOA account and the zkSync smart contract. Its primary purpose is +to provide a trustless means of delaying batch execution without modifying the main zkSync contract. zkSync actively +monitors the chain activity and reacts to any suspicious activity by freezing the chain. This allows time for +investigation and mitigation before resuming normal operations. + +It is a temporary solution to prevent any significant impact of the validator hot key leakage, while the network is in +the Alpha stage. + +This contract consists of four main functions `commitBatches`, `proveBatches`, `executeBatches`, and `revertBatches`, +which can be called only by the validator. + +When the validator calls `commitBatches`, the same calldata will be propagated to the zkSync contract (`DiamondProxy` +through `call` where it invokes the `ExecutorFacet` through `delegatecall`), and also a timestamp is assigned to these +batches to track the time these batches are committed by the validator to enforce a delay between committing and +execution of batches. Then, the validator can prove the already committed batches regardless of the mentioned timestamp, +and again the same calldata (related to the `proveBatches` function) will be propagated to the zkSync contract. After +the `delay` is elapsed, the validator is allowed to call `executeBatches` to propagate the same calldata to zkSync +contract. + +The owner of the ValidatorTimelock contract is the same as the owner of the Governance contract - Matter Labs multisig. + +## Allowlist + +The auxiliary contract controls the permission access list. It is used in bridges and diamond proxies to control which +addresses can interact with them in the Alpha release. Currently, it is supposed to set all permissions to public. + +The owner of the Allowlist contract is the Governance contract. + +## Deposit Limitation + +The amount of deposit can be limited. This limitation is applied on an account level and is not time-based. In other +words, each account cannot deposit more than the cap defined. The tokens and the cap can be set through governance +transactions. Moreover, there is an allow listing mechanism as well (only some allow listed accounts can call some +specific functions). So, the combination of deposit limitation and allow listing leads to limiting the deposit of the +allow listed account to be less than the defined cap. + +```solidity +struct Deposit { + bool depositLimitation; + uint256 depositCap; +} + +``` + +Currently, the limit is used only for blocking deposits of the specific token (turning on the limitation and setting the +limit to zero). And on the near future, this functionality will be completely removed. diff --git a/content/10.zk-stack/10.components/20.smart-contracts/20.system-contracts.md b/content/10.zk-stack/10.components/20.smart-contracts/20.system-contracts.md new file mode 100644 index 00000000..5c3d8fff --- /dev/null +++ b/content/10.zk-stack/10.components/20.smart-contracts/20.system-contracts.md @@ -0,0 +1,324 @@ +--- +title: System Contracts +description: An overview of system contracts in VM, detailing their unique privileges, locations, and update mechanisms. +--- + +## Introduction to system contracts + +System contracts are a specialized set of contracts in virtual machines (VM) that enhance the Ethereum Virtual Machine (EVM) +by supporting opcodes not available by default. +These contracts operate under unique conditions and have privileges not accessible to standard user contracts. + +## Location and privileges + +System contracts reside in a designated area known as _kernel space_, specifically within the address space ranging from `[0..2^16-1]`. +This limited address space sets them apart from regular user contracts and grants them special operating privileges. + +## Characteristics and deployment + +- **Pre-deployed:** System contracts are deployed at the genesis of the blockchain, ensuring they are in place from the very beginning. +- **Special Privileges:** Unlike user contracts, system contracts can perform operations that require higher security clearance or access to core VM functionalities. +- **Update Mechanism:** Modifying the code of system contracts is not a routine procedure. + Updates can only be executed through a system upgrade managed from Layer 1 (L1), ensuring controlled and secure changes. + +## Functionality and implementation + +While system contracts support a variety of operations, from simple arithmetic to complex memory and storage management, +their detailed functionalities and the exact execution requirements are documented extensively in the doc-comments within their codebases. +This documentation provides developers with insights into how these contracts operate and integrate with the broader system. + +## Role in the protocol + +System contracts form an essential part of the protocol architecture by enabling functionality that extends beyond the basic capabilities of the EVM. +The codes of all system contracts, including `DefaultAccount`, +are integral to the protocol and can only be altered through a system upgrade initiated from L1. + +--- +## SystemContext + +This contract is used to support various system parameters not included in the VM by default, i.e. `chainId`, `origin`, +`ergsPrice`, `blockErgsLimit`, `coinbase`, `difficulty`, `baseFee`, `blockhash`, `block.number`, `block.timestamp.` + +It is important to note that the constructor is **not** run for system contracts upon genesis, i.e. the constant context +values are set on genesis explicitly. Notably, if in the future we want to upgrade the contracts, we will do it via +`ContractDeployer` and so the constructor will be run. + +This contract is also responsible for ensuring validity and consistency of batches, L2 blocks and virtual blocks. The +implementation itself is rather straightforward, but to better understand this contract, please take a look at the +[page](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Batches%20&%20L2%20blocks%20on%20zkSync.md) +about the block processing on zkSync. + +## AccountCodeStorage + +The code hashes of accounts are stored inside the storage of this contract. Whenever a VM calls a contract with address +`address` it retrieves the value under storage slot `address` of this system contract, if this value is non-zero, it +uses this as the code hash of the account. + +Whenever a contract is called, the VM asks the operator to provide the preimage for the codehash of the account. That is +why data availability of the code hashes is paramount. + +### Constructing vs Non-Constructing Code Hash + +In order to prevent contracts from being able to call a contract during its construction, we set the marker (i.e. second +byte of the bytecode hash of the account) as `1`. This way, the VM will ensure that whenever a contract is called +without the `isConstructor` flag, the bytecode of the default account (i.e. EOA) will be substituted instead of the +original bytecode. + +## BootloaderUtilities + +This contract contains some of the methods which are needed purely for the bootloader functionality but were moved out +from the bootloader itself for the convenience of not writing this logic in Yul. + +## DefaultAccount + +Whenever a contract that does **not** both: + +- belong to kernel space +- have any code deployed on it (the value stored under the corresponding storage slot in `AccountCodeStorage` is zero) + +The code of the default account is used. The main purpose of this contract is to provide EOA-like experience for both +wallet users and contracts that call it, i.e. it should not be distinguishable (apart of spent gas) from EOA accounts on +Ethereum. + +## Ecrecover + +The implementation of the ecrecover precompile. It is expected to be used frequently, so written in pure yul with a +custom memory layout. + +The contract accepts the calldata in the same format as EVM precompile, i.e. the first 32 bytes are the hash, the next +32 bytes are the v, the next 32 bytes are the r, and the last 32 bytes are the s. + +It also validates the input by the same rules as the EVM precompile: + +- The v should be either 27 or 28, +- The r and s should be less than the curve order. + +After that, it makes a precompile call and returns empty bytes if the call failed, and the recovered address otherwise. + +## Empty contracts + +Some of the contracts are relied upon to have EOA-like behaviour, i.e. they can be always called and get the success +value in return. An example of such address is 0 address. We also require the bootloader to be callable so that the +users could transfer ETH to it. + +For these contracts, we insert the `EmptyContract` code upon genesis. It is basically a noop code, which does nothing +and returns `success=1`. + +## SHA256 & Keccak256 + +Note that, unlike Ethereum, keccak256 is a precompile (_not an opcode_) on zkSync. + +These system contracts act as wrappers for their respective crypto precompile implementations. They are expected to be +used frequently, especially keccak256, since Solidity computes storage slots for mapping and dynamic arrays with its +help. That's why we wrote contracts on pure yul with optimizing the short input case. + +The system contracts accept the input and transform it into the format that the zk-circuit expects. This way, some of +the work is shifted from the crypto to smart contracts, which are easier to audit and maintain. + +Both contracts should apply padding to the input according to their respective specifications, and then make a +precompile call with the padded data. All other hashing work will be done in the zk-circuit. It's important to note that +the crypto part of the precompiles expects to work with padded data. This means that a bug in applying padding may lead +to an unprovable transaction. + +## L2EthToken & MsgValueSimulator + +Unlike Ethereum, zkEVM does not have any notion of any special native token. That’s why we have to simulate operations +with Ether via two contracts: `L2EthToken` & `MsgValueSimulator`. + +`L2EthToken` is a contract that holds the balances of ETH for the users. This contract does NOT provide ERC20 interface. +The only method for transferring Ether is `transferFromTo`. It permits only some system contracts to transfer on behalf +of users. This is needed to ensure that the interface is as close to Ethereum as possible, i.e. the only way to transfer +ETH is by doing a call to a contract with some `msg.value`. This is what `MsgValueSimulator` system contract is for. + +Whenever anyone wants to do a non-zero value call, they need to call `MsgValueSimulator` with: + +- The calldata for the call equal to the original one. +- Pass `value` and whether the call should be marked with `isSystem` in the first extra abi params. +- Pass the address of the callee in the second extraAbiParam. + +## KnownCodeStorage + +This contract is used to store whether a certain code hash is “known”, i.e. can be used to deploy contracts. On zkSync, +the L2 stores the contract’s code _hashes_ and not the codes themselves. Therefore, it must be part of the protocol to +ensure that no contract with unknown bytecode (i.e. hash with an unknown preimage) is ever deployed. + +The factory dependencies field provided by the user for each transaction contains the list of the contract’s bytecode +hashes to be marked as known. We can not simply trust the operator to “know” these bytecodehashes as the operator might +be malicious and hide the preimage. We ensure the availability of the bytecode in the following way: + +- If the transaction comes from L1, i.e. all its factory dependencies have already been published on L1, we can simply + mark these dependencies as “known”. +- If the transaction comes from L2, i.e. (the factory dependencies are yet to publish on L1), we make the user pays by + burning ergs proportional to the bytecode’s length. After that, we send the L2→L1 log with the bytecode hash of the + contract. It is the responsibility of the L1 contracts to verify that the corresponding bytecode hash has been + published on L1. + +It is the responsibility of the `ContractDeployer` system contract to deploy only +those code hashes that are known. + +The KnownCodesStorage contract is also responsible for ensuring that all the “known” bytecode hashes are also valid. + +## ContractDeployer & ImmutableSimulator + +`ContractDeployer` is a system contract responsible for deploying contracts on zkSync. It is better to understand how it +works in the context of how the contract deployment works on zkSync. Unlike Ethereum, where `create`/`create2` are +opcodes, on zkSync these are implemented by the compiler via calls to the ContractDeployer system contract. + +For additional security, we also distinguish the deployment of normal contracts and accounts. That’s why the main +methods that will be used by the user are `create`, `create2`, `createAccount`, `create2Account`, which simulate the +CREATE-like and CREATE2-like behavior for deploying normal and account contracts respectively. + +### **Address derivation** + +Each rollup that supports L1→L2 communications needs to make sure that the addresses of contracts on L1 and L2 do not +overlap during such communication (otherwise it would be possible that some evil proxy on L1 could mutate the state of +the L2 contract). Generally, rollups solve this issue in two ways: + +- XOR/ADD some kind of constant to addresses during L1→L2 communication. That’s how rollups closer to full + EVM-equivalence solve it, since it allows them to maintain the same derivation rules on L1 at the expense of contract + accounts on L1 having to redeploy on L2. +- Have different derivation rules from Ethereum. That is the path that zkSync has chosen, mainly because since we have + different bytecode than on EVM, CREATE2 address derivation would be different in practice anyway. + +You can see the rules for our address derivation in `getNewAddressCreate2`/ `getNewAddressCreate` methods in the +ContractDeployer. + +Note, that we still add a certain constant to the addresses during L1→L2 communication in order to allow ourselves some +way to support EVM bytecodes in the future. + +### **Deployment nonce** + +On Ethereum, the same nonce is used for CREATE for accounts and EOA wallets. On zkSync this is not the case, we use a +separate nonce called “deploymentNonce” to track the nonces for accounts. This was done mostly for consistency with +custom accounts and for having multicalls feature in the future. + +### **General process of deployment** + +- After incrementing the deployment nonce, the contract deployer must ensure that the bytecode that is being deployed is + available. +- After that, it puts the bytecode hash with a + [special constructing marker](#constructing-vs-non-constructing-code-hash) as code for the address of the + to-be-deployed contract. +- Then, if there is any value passed with the call, the contract deployer passes it to the deployed account and sets the + `msg.value` for the next as equal to this value. +- Then, it uses `mimic_call` for calling the constructor of the contract out of the name of the account. +- It parses the array of immutables returned by the constructor (we’ll talk about immutables in more details later). +- Calls `ImmutableSimulator` to set the immutables that are to be used for the deployed contract. + +Note how it is different from the EVM approach: on EVM when the contract is deployed, it executes the initCode and +returns the deployedCode. On zkSync, contracts only have the deployed code and can set immutables as storage variables +returned by the constructor. + +### **Constructor** + +On Ethereum, the constructor is only part of the initCode that gets executed during the deployment of the contract and +returns the deployment code of the contract. On zkSync, there is no separation between deployed code and constructor +code. The constructor is always a part of the deployment code of the contract. In order to protect it from being called, +the compiler-generated contracts invoke constructor only if the `isConstructor` flag provided (it is only available for +the system contracts). + +After execution, the constructor must return an array of: + +```solidity +struct ImmutableData { + uint256 index; + bytes32 value; +} + +``` + +basically denoting an array of immutables passed to the contract. + +### **Immutables** + +Immutables are stored in the `ImmutableSimulator` system contract. The way how `index` of each immutable is defined is +part of the compiler specification. This contract treats it simply as mapping from index to value for each particular +address. + +Whenever a contract needs to access a value of some immutable, they call the +`ImmutableSimulator.getImmutable(getCodeAddress(), index)`. Note that on zkSync it is possible to get the current +execution address. + +### **Return value of the deployment methods** + +If the call succeeded, the address of the deployed contract is returned. If the deploy fails, the error bubbles up. + +## DefaultAccount + +The implementation of the default account abstraction. This is the code that is used by default for all addresses that +are not in kernel space and have no contract deployed on them. This address: + +- Contains minimal implementation of our account abstraction protocol. Note that it supports the + [built-in paymaster flows](https://v2-docs.zksync.io/dev/developer-guides/aa.html#paymasters). +- When anyone (except bootloader) calls it, it behaves in the same way as a call to an EOA, i.e. it always returns + `success = 1, returndatasize = 0` for calls from anyone except for the bootloader. + +## L1Messenger + +A contract used for sending arbitrary length L2→L1 messages from zkSync to L1. While zkSync natively supports a rather +limited number of L1→L2 logs, which can transfer only roughly 64 bytes of data a time, we allowed sending +nearly-arbitrary length L2→L1 messages with the following trick: + +The L1 messenger receives a message, hashes it and sends only its hash as well as the original sender via L2→L1 log. +Then, it is the duty of the L1 smart contracts to make sure that the operator has provided full preimage of this hash in +the commitment of the batch. + +The `L1Messenger` is also responsible for validating the total pubdata to be sent on L1. You can read more about it +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20pubdata%20in%20Boojum.md). + +## NonceHolder + +Serves as storage for nonces for our accounts. Besides making it easier for operator to order transactions (i.e. by +reading the current nonces of account), it also serves a separate purpose: making sure that the pair (address, nonce) is +always unique. + +It provides a function `validateNonceUsage` which the bootloader uses to check whether the nonce has been used for a +certain account or not. Bootloader enforces that the nonce is marked as non-used before validation step of the +transaction and marked as used one afterwards. The contract ensures that once marked as used, the nonce can not be set +back to the “unused” state. + +Note that nonces do not necessarily have to be monotonic (this is needed to support more interesting applications of +account abstractions, e.g. protocols that can start transactions on their own, tornado-cash like protocols, etc). That’s +why there are two ways to set a certain nonce as “used”: + +- By incrementing the `minNonce` for the account (thus making all nonces that are lower than `minNonce` as used). +- By setting some non-zero value under the nonce via `setValueUnderNonce`. This way, this key will be marked as used and + will no longer be allowed to be used as nonce for accounts. This way it is also rather efficient, since these 32 bytes + could be used to store some valuable information. + +The accounts upon creation can also provide which type of nonce ordering do they want: Sequential (i.e. it should be +expected that the nonces grow one by one, just like EOA) or Arbitrary, the nonces may have any values. This ordering is +not enforced in any way by system contracts, but it is more of a suggestion to the operator on how it should order the +transactions in the mempool. + +## EventWriter + +A system contract responsible for emitting events. + +It accepts in its 0-th extra abi data param the number of topics. In the rest of the extraAbiParams he accepts topics +for the event to emit. Note, that in reality the event the first topic of the event contains the address of the account. +Generally, the users should not interact with this contract directly, but only through Solidity syntax of `emit`-ing new +events. + +## Compressor + +One of the most expensive resource for a rollup is data availability, so in order to reduce costs for the users we +compress the published pubdata in several ways: + +- We compress published bytecodes. +- We compress state diffs. + +This contract contains utility methods that are used to verify the correctness of either bytecode or state diff +compression. You can read more on how we compress state diffs and bytecodes in the corresponding +[document](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1%E2%86%92L2%20ops%20on%20zkSync.md). + +## Known issues to be resolved + +The protocol, while conceptually complete, contains some known issues which will be resolved in the short to middle +term. + +- Fee modeling is yet to be improved. More on it in the + [document](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/zkSync%20fee%20model.md) + on the fee model. +- We may add some kind of default implementation for the contracts in the kernel space (i.e. if called, they wouldn’t + revert but behave like an EOA). diff --git a/content/10.zk-stack/10.components/20.smart-contracts/_dir.yml b/content/10.zk-stack/10.components/20.smart-contracts/_dir.yml new file mode 100644 index 00000000..84c7a8da --- /dev/null +++ b/content/10.zk-stack/10.components/20.smart-contracts/_dir.yml @@ -0,0 +1 @@ +title: Smart & System Contracts diff --git a/content/10.zk-stack/10.components/30.shared-bridges.md b/content/10.zk-stack/10.components/30.shared-bridges.md new file mode 100644 index 00000000..9c4dfd14 --- /dev/null +++ b/content/10.zk-stack/10.components/30.shared-bridges.md @@ -0,0 +1,245 @@ +--- +title: Shared Bridges +description: Explore the design and functionality of Shared Bridges within Ethereum's Hyperchain ecosystem, including future features and system upgrades. +--- + +Ethereum's evolving infrastructure is shifting towards a rollup-centric future, +focusing on an interconnected ecosystem of zero-knowledge Ethereum Virtual Machines (zkEVMs), collectively known as Hyperchains. +This transformation relies on robust Layer 1 (L1) smart contracts to maintain coherence and security across the ecosystem. + +## ZK Stack approach + +Our approach to developing this ecosystem involves specific architectures and interfaces of L1 smart contracts. +These contracts are designed to support the changing needs of the Ethereum landscape and facilitate the integration of new features as the technology advances. + +### High-level design goals + +- **Permissionless Hyperchain Launch:** + Enable the launch of new hyperchains within the ecosystem without requiring permissions, promoting an open and inclusive network. +- **Unified Liquidity through Hyperbridges:** + Establish bridges that allow seamless asset liquidity across the entire ecosystem, making asset management more straightforward and efficient. +- **Simplified Multi-chain Contract Development:** + Provide easy access to traditional bridges and supporting architecture, facilitating the development of multi-chain smart contracts. + +### Trust and verification + +Hyperchains must meet common trust and verification standards. +A single set of L1 smart contracts will manage the proof verification across all hyperchains. +Any upgrade to the proof system will necessitate a simultaneous upgrade across all chains to maintain uniformity and security. + +### Bridging and liquidity + +- **Bridgehub Contract on L1:** + This contract will link asset bridges to all hyperchains and manage the ecosystem's ETH reserves. It acts as the central node in the bridging architecture. +- **System Contracts on Hyperchains:** + Special system contracts will be added to hyperchains to enable bridging functionalities, + allowing them to interact smoothly with the Bridgehub and manage assets efficiently. + +## Modularity and future compatibility + +The design aims to be as modular as possible, providing developers with the flexibility to alter the architecture based on evolving needs, +such as changes in consensus mechanisms, staking models, and data availability requirements. + +### Anticipating future developments + +- **Layer 3 Integrations and Proof Aggregation:** + Future updates will consider Layer 3 technologies and proof aggregation methods to enhance scalability and efficiency. +- **Alternative State Transition Contracts and ZK IP:** + The design will accommodate alternative State Transition (ST) contracts and ZK IP, + which will ensure unified liquidity and interoperability among all state transitions when these features become available. + +The Shared Bridge and the associated smart contracts are foundational to the sustainable growth of the Hyperchain ecosystem. +For further details on Hyperchains and their operational dynamics, refer to our [blog post on Hyperchains](https://blog.matter-labs.io/introduction-to-hyperchains-fdb33414ead7) +or the section on [Hyperchains/Hyperscaling](/zk-stack/concepts/hyperchains-hyperscaling.md) +--- + +## Architecture + +![Contracts](/images/zk-stack/contracts-external.png) + +## Components: Bridgehub + +- Acts as a hub for bridges, so that they have a single point of communication with all hyperchain contracts. This + allows L1 assets to be locked in the same contract for all hyperchains, including L3s and validiums. The `Bridgehub` + also implements the following: +- `Registry` This is where hyperchains can register, starting in a permissioned manner, but with the goal to be + permissionless in the future. This is where their `chainID` is determined. L3s will also register here. This + `Registry` is also where State Transition contracts should register. Each chain has to specify its desired ST when + registering (Initially, only one will be available). + + ```solidity + function newChain( + uint256 _chainId, + address _stateTransition + ) external returns (uint256 chainId); + + function newStateTransition(address _stateTransition) external; + ``` + +- `BridgehubMailbox` routes messages to the Diamond proxy’s Mailbox facet based on chainID + + - Same as the current zkEVM + [Mailbox](https://github.com/matter-labs/era-contracts/blob/main/system-contracts/contracts/interfaces/IMailbox.sol), just + with chainId, + - Ether needs to be deposited and withdrawn from here. + - This is where L2 transactions can be requested. + + ```solidity + function requestL2Transaction( + uint256 _chainId, + address _contractL2, + uint256 _l2Value, + bytes calldata _calldata, + uint256 _l2GasLimit, + uint256 _l2GasPerPubdataByteLimit, + bytes[] calldata _factoryDeps, + address _refundRecipient + ) public payable override returns (bytes32 canonicalTxHash) { + address proofChain = bridgeheadStorage.proofChain[_chainId]; + canonicalTxHash = IProofChain(proofChain).requestL2TransactionBridgehead( + _chainId, + msg.value, + msg.sender, + _contractL2, + _l2Value, + _calldata, + _l2GasLimit, + _l2GasPerPubdataByteLimit, + _factoryDeps, + _refundRecipient + ); + } + ``` + +- `Hypermailbox` + - This will allow general message passing (L2<>L2, L2<>L3, etc). This is where the `Mailbox` sends the `Hyperlogs`. + `Hyperlogs` are commitments to these messages sent from a single hyperchain. `Hyperlogs` are aggregated into a + `HyperRoot` in the `HyperMailbox`. + - This component has not been implemented yet + +### Main Asset Shared Bridges + +- Some assets have to be natively supported (ETH, WETH) and it also makes sense to support some generally accepted token + standards (ERC20 tokens), as this makes it easy to bridge those tokens (and ensures a single version of them exists on + the hyperchain). These canonical asset contracts are deployed from L1 by a bridge shared by all hyperchains. This is + where assets are locked on L1. These bridges use the Bridgehub to communicate with all hyperchains. Currently, these + bridges are the `WETH` and `ERC20` bridges. + + - The pair on L2 is deployed from L1. The hash of the factory dependencies is stored on L1, and when a hyperchain + wants to register, it can passes it in for deployment, it is verified, and the contract is deployed on L2. The + actual token contracts on L2 are deployed by the L2 bridge. + + ```solidity + function initializeChain( + uint256 _chainId, + bytes[] calldata _factoryDeps, + uint256 _deployBridgeImplementationFee, + uint256 _deployBridgeProxyFee + ) external payable { + .... + // Deploy L2 bridge proxy contract + l2Bridge[_chainId] = BridgeInitializationHelper.requestDeployTransaction( + _chainId, + bridgehead, + _deployBridgeProxyFee, + l2WethBridgeProxyBytecodeHash, + l2WethBridgeProxyConstructorData, + // No factory deps are needed for L2 bridge proxy, because it is already passed in the previous step + new bytes[](0) + ); + ``` + +## Components: State Transition + +- `StateTransition` A state transition manages proof verification and DA for multiple chains. It also implements the + following functionalities: + - `StateTransitionRegistry` The ST is shared for multiple chains, so initialization and upgrades have to be the same + for all chains. Registration is not permissionless but happens based on the registrations in the bridgehub’s + `Registry`. At registration a `DiamondProxy` is deployed and initialized with the appropriate `Facets` for each + Hyperchain. + - `Facets` and `Verifier` are shared across chains that relies on the same ST: `Base`, `Executor` , `Getters`, `Admin` + , `Mailbox.`The `Verifier` is the contract that actually verifies the proof, and is called by the `Executor`. + - Upgrade Mechanism The system requires all chains to be up-to-date with the latest implementation, so whenever an + update is needed, we have to “force” each chain to update, but due to decentralization, we have to give each chain a + time frame (more information in the + [Upgrade Mechanism](https://www.notion.so/ZK-Stack-shared-bridge-alpha-version-a37c4746f8b54fb899d67e474bfac3bb?pvs=21) + section). This is done in the update mechanism contract, this is where the bootloader and system contracts are + published, and the `ProposedUpgrade` is stored. Then each chain can call this upgrade for themselves as needed. + After the deadline is over, the not-updated chains are frozen, that is, cannot post new proofs. Frozen chains can + unfreeze by updating their proof system. +- Each chain has a `DiamondProxy`. + - The [Diamond Proxy](https://eips.ethereum.org/EIPS/eip-2535) is the proxy pattern that is used for the chain + contracts. A diamond proxy points to multiple implementation contracts called facets. Each selector is saved in the + proxy, and the correct facet is selected and called. + - In the future the DiamondProxy can be configured by picking alternative facets e.g. Validiums will have their own + `Executor` + +## Components: Chain Specific Contracts + +- A chain might implement its own specific consensus mechanism. This needs its own contracts. Only this contract will be + able to submit proofs to the State Transition contract. +- Currently, the `ValidatorTimelock` is an example of such a contract. + +### Components interactions + +In this section, we will present some diagrams showing the interaction of different components. + +#### New Chain + +A chain registers in the Bridgehub, this is where the chain ID is determined. The chain’s governor specifies the State +Transition that they plan to use. In the first version only a single State Transition contract will be available for +use, our with Boojum proof verification. + +At initialization we prepare the `StateTransitionChain` contract. We store the genesis batch hash in the ST contract, +all chains start out with the same state. A diamond proxy is deployed and initialised with this initial value, along +with predefined facets which are made available by the ST contract. These facets contain the proof verification and +other features required to process proofs. The chain ID is set in the VM in a special system transaction sent from L1. + + + +## Components: WETH Contract + +Ether, the native gas token is part of the core system contracts, so deploying it is not necessary. But WETH is just a +smart contract, it needs to be deployed and initialised. This happens from the L1 WETH bridge. This deploys on L2 the +corresponding bridge and ERC20 contract. This is deployed from L1, but the L2 address is known at deployment time. + +![deployWeth.png](../../assets/images/deploy-weth.png) + +## Components: Deposit WETH + +The user can deposit WETH into the ecosystem using the WETH bridge on L1. The destination chain ID has to be specified. +The Bridgehub unwraps the WETH, and keeps the ETH, and send a message to the destination L2 to mint WETH to the +specified address. + +![depositWeth.png](../../assets/images/deposit-weth.png) + +--- + +## Common Standards and Upgrades + +In this initial phase, Hyperchains have to follow some common standards, so that they can trust each other. This means +all chains start out with the same empty state, they have the same VM implementations and proof systems, asset contracts +can trust each on different chains, and the chains are upgraded together. We elaborate on the shared upgrade mechanism +here. + +### Upgrade mechanism + +Currently, there are three types of upgrades for zkEVM. Normal upgrades (used for new features) are initiated by the +Governor (a multisig) and are public for a certain timeframe before they can be applied. Shadow upgrades are similar to +normal upgrades, but the data is not known at the moment the upgrade is proposed, but only when executed (they can be +executed with the delay, or instantly if approved by the security council). Instant upgrades (used for security issues), +on the other hand happen quickly and need to be approved by the Security Council in addition to the Governor. For +hyperchains the difference is that upgrades now happen on multiple chains. This is only a problem for shadow upgrades - +in this case, the chains have to tightly coordinate to make all the upgrades happen in a short time frame, as the +content of the upgrade becomes public once the first chain is upgraded. The actual upgrade process is as follows: + +1. Prepare Upgrade for all chains: + - The new facets and upgrade contracts have to be deployed, + - The upgrade’ calldata (diamondCut, initCalldata with ProposedUpgrade) is hashed on L1 and the hash is saved. +2. Upgrade specific chain + - The upgrade has to be called on the specific chain. The upgrade calldata is passed in as calldata and verified. The + protocol version is updated. + - Ideally, the upgrade will be very similar for all chains. If it is not, a smart contract can calculate the + differences. If this is also not possible, we have to set the `diamondCut` for each chain by hand. +3. Freeze not upgraded chains + - After a certain time the chains that are not upgraded are frozen. diff --git a/content/10.zk-stack/10.components/40.sequencer-server.md b/content/10.zk-stack/10.components/40.sequencer-server.md new file mode 100644 index 00000000..df296525 --- /dev/null +++ b/content/10.zk-stack/10.components/40.sequencer-server.md @@ -0,0 +1,51 @@ +--- +title: Sequencer / Server +description: Overview of the zkSync Sequencer, detailing its components and functionalities for monitoring and maintaining L1 and L2 operations. +--- + +The zkSync Sequencer is a complex system composed of several services and modules that work together to monitor Ethereum Layer 1 (L1), +maintain Layer 2 (L2) state, and manage the order of incoming transactions. +This system is critical for the operation and reliability of the zkSync protocol. + +For more detailed information about each module, visit the [zkSync Era GitHub repository](%%zk_git_repo_zksync-era%%). + +## RPC services + +RPC Services serve as the primary user interface for interacting with the zkSync server. They include: + +- **HttpApi**: + This is the HTTP public Web3 API that allows users to make requests via traditional HTTP methods. +- **WsApi**: + The WebSocket Web3 API supports real-time interactions and includes PubSub capabilities, enhancing user experience by providing faster, push-based updates. + +## ETH operator + +The ETH Operator module interfaces directly with L1, performing critical observations and transactions: + +- **EthWatcher**: + Monitors L1 for specific events such as deposits and system upgrades, ensuring the Sequencer remains synchronized with Ethereum's mainnet. +- **EthTxAggregator**: + Responsible for batching multiple L2 transactions and preparing them for L1 submission. + This includes crucial operations like committing blocks, proving blocks, and executing blocks. +- **EthTxManager**: + Handles the signing and dispatch of transactions to L1. + This module is also tasked with monitoring the transactions to address issues such as transaction failures or low gas prices + by resending transactions as necessary. + +## Sequencer + +The Sequencer module processes incoming transactions on zkSync, organizes them into blocks, +and ensures they comply with the constraints of the proving system. +It includes: + +- **Tree and TreeBackup**: + These components maintain a local instance of RocksDB that stores the complete L2 storage tree, + continuously updating to reflect the latest state root hash. +- **StateKeeper**: + Executes transactions and securely stores sealed blocks in the local RocksDB database, ensuring data integrity and state continuity. + +## Contract verification API + +This service handles requests for smart contract verification. +It validates contracts, ensures they meet specific standards, +and provides the necessary code and ABIs for verified contracts, fostering transparency and trust within the ecosystem. diff --git a/content/10.zk-stack/10.components/50.zksync-evm/00.overview.md b/content/10.zk-stack/10.components/50.zksync-evm/00.overview.md new file mode 100644 index 00000000..c5de01d3 --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/00.overview.md @@ -0,0 +1,54 @@ +--- +title: Overview +description: Learn about the zkSync VM's functionality, its role in the zkStack compared to the EVM in Ethereum, and how it handles smart contracts and transaction fees. +--- + +The zkSync VM (zero-knowledge Ethereum Virtual Machine) is an essential component of the ZK Stack, +designed to execute transactions similarly to the Ethereum Virtual Machine (EVM) but with a unique set of functionalities tailored to the needs of rollups. + +## zkSync VM and its role in ZK Stack + +Unlike the EVM that operates Ethereum's smart contracts directly, +the zkSync VM is specifically engineered to efficiently run the State Transition Function (STF), +which is vital for producing proofs of correct execution in a rollup context. +This STF is defined by the [Bootloader](/zk-stack/components/zksync-evm/bootloader), which implements and runs it. + +### Execution of transactions + +Transactions executed by the zkSync VM are primarily written in native zkSync VM bytecode, enabling straightforward execution. +In the future, the system will also accommodate EVM bytecode through an efficient interpreter built into the zkSync VM. + +--- +## Special features of zkSync VM + +The zkSync VM incorporates several specialized features to meet the demands of rollups, including: + +- **Storage and Gas Metering:** + Adaptations in storage handling and gas metering to suit the rollup model. +- **Precompiles and System Contracts:** + The zkSync VM supports predeployed contracts known as precompiles and system contracts. + While both are integral, system contracts have special permissions and are mainly invoked by the Bootloader, not by user transactions. + These system contracts are crucial for managing specialized operations and are outlined in more detail [here](/zk-stack/components/smart-contracts/system-contracts). + +--- +## User-facing features + +To enhance user experience, the zkSync VM supports account abstraction, allowing users to customize how transaction fees are paid. +This flexibility is part of the zkStack's efforts to improve usability and accessibility. + +--- +## Fee model + +The zkSync VM's fee model differs significantly from Ethereum's due to the unique requirements of running a rollup. +It considers the various costs associated with rollup operations, including: + +- **Data and Proof Execution Costs on L1:** + Ensures that the rollup's data and proof computations are financially sustainable when settled on Ethereum. +- **Sequencer and Prover Costs:** + Covers expenses related to sequencing transactions and generating zero-knowledge proofs. + +--- +The zkEVM plays a critical role in the zkStack by ensuring efficient execution of transactions within the unique operational environment of rollups. +Its specialized features and innovative fee model are designed to maintain functionality and scalability while providing a seamless experience for users. +For further exploration of these concepts, consider reading more about +[account abstraction](/zk-stack/concepts/account-abstraction) and the [fee mechanism](/zk-stack/concepts/fee-mechanism) in our documentation. diff --git a/content/10.zk-stack/10.components/50.zksync-evm/10.bootloader.md b/content/10.zk-stack/10.components/50.zksync-evm/10.bootloader.md new file mode 100644 index 00000000..de9eab73 --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/10.bootloader.md @@ -0,0 +1,343 @@ +--- +title: Bootloader +description: Overview of the bootloader in zkSync, which processes transactions in batch mode for efficiency, including its role and operational mechanics. +--- + +In standard Ethereum clients, the process of executing blocks involves selecting and validating transactions one by one, +executing them, and then applying the resulting state changes to the blockchain. +This method is suitable for Ethereum's architecture but would be inefficient +for zkSync due to the need for running a complete proving workflow for each transaction. + +### Why zkSync Uses a Bootloader + +To address this inefficiency, zkSync employs a bootloader. +This component allows for processing not just one transaction at a time but an entire batch of transactions as a single large operation. +This approach is similar to how an EntryPoint works under EIP4337, +which also manages transactions in arrays to support the Account Abstraction protocol. + +You can learn more about [Batches & L2 blocks on zkSync](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Batches%20%26%20L2%20blocks%20on%20zkSync.md). + +### Operational Mechanism of the Bootloader + +The bootloader's code is not stored on Layer 2 (L2) but its hash is stored on Layer 1 (L1) and can only be modified through a system upgrade. +This setup ensures that the bootloader functions as a kind of "formal" address that provides context and identity to `this`, `msg.sender`, +and similar references during transaction processing. +If someone interacts with this address, for instance, to handle transaction fees, it triggers the EmptyContract’s code. + +### Bootloader Variants: Playground vs Proved + +While the same bootloader implementation is used across both mainnet operations and for testing activities like emulating ethCalls, +only the **proved** bootloader is used for official batch processing. +This ensures reliability and security in batch-building on the mainnet. + +This section focuses on describing the **proved** bootloader. + +--- +## Batch Start + +The state of the bootloader is equivalent to the state of a contract transaction with empty calldata. +The only difference is that it starts with all the possible memory pre-allocated (to avoid costs for memory expansion). + +For additional efficiency, the bootloader receives its parameters inside its memory. +This is the only point of non-determinism: the bootloader _starts with its memory pre-filled with any data the operator wants_. +That’s why the operator is responsible for validating the correctness of the bootloader. +The operator should never rely on the initial contents of the memory to be correct & valid. + +For instance, for each transaction, we check that it is +[properly ABI-encoded](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3058) +and that the transactions +[go exactly one after another](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3736). +We also ensure that transactions do not exceed the limits of the memory space allowed for transactions. + +## Transaction Types and Validation + +While the main transaction format is the internal [`Transaction` +format](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/contracts/libraries/TransactionHelper.sol#L25), +it is a struct that is used to represent various kinds of transactions types. It contains a lot of `reserved` fields +that could be used depending in the future types of transactions without need for AA to change the interfaces of their +contracts. + +The exact type of the transaction is marked by the `txType` field of the transaction type. There are 6 types currently +supported: + +- `txType`: 0. It means that this transaction is of legacy transaction type. The following restrictions are enforced: +- `maxFeePerErgs=getMaxPriorityFeePerErg` since it is pre-EIP-1559 tx type. +- `reserved1..reserved4` as well as `paymaster` are 0. `paymasterInput` is zero. +- Note, that unlike type 1 and type 2 transactions, `reserved0` field can be set to a non-zero value, denoting that this + legacy transaction is EIP-155-compatible and its RLP encoding (as well as signature) should contain the `chainId` of + the system. +- `txType`: 1. It means that the transaction is of type 1, i.e. transactions access list. zkSync does not support access + lists in any way, so no benefits of fulfilling this list will be provided. The access list is assumed to be empty. The + same restrictions as for type 0 are enforced, but also `reserved0` must be 0. +- `txType`: 2. It is EIP1559 transactions. The same restrictions as for type 1 apply, but now `maxFeePerErgs` may not be + equal to `getMaxPriorityFeePerErg`. +- `txType`: 113. It is zkSync transaction type. This transaction type is intended for AA support. The only restriction + that applies to this transaction type: fields `reserved0..reserved4` must be equal to 0. +- `txType`: 254. It is a transaction type that is used for upgrading the L2 system. This is the only type of transaction + is allowed to start a transaction out of the name of the contracts in kernel space. +- `txType`: 255. It is a transaction that comes from L1. There are almost no restrictions explicitly imposed upon this + type of transaction, since the bootloader at the end of its execution sends the rolling hash of the executed priority + transactions. The L1 contract ensures that the hash did indeed match the + [hashes of the priority transactions on L1](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/contracts/ethereum/contracts/zksync/facets/Executor.sol#L282). + +You can also read more on L1->L2 transactions and upgrade transactions +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1%E2%86%92L2%20ops%20on%20zkSync.md). + +However, as already stated, the bootloader’s memory is not deterministic and the operator is free to put anything it +wants there. For all of the transaction types above the restrictions are imposed in the following +([method](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L2828)), +which is called before starting processing the transaction. + +## Bootloader Memory Structure + +The bootloader expects the following structure of the memory (here by word we denote 32-bytes, the same machine word as +on EVM): + +### Batch Information + +The first 8 words are reserved for the batch information provided by the operator. + +- `0` — The address of the operator (the beneficiary of the transactions). +- `1` — The hash of the previous batch. Its validation will be explained later on. +- `2` — The timestamp of the current batch. Its validation will be explained later on. +- `3` — The number of the new batch. +- `4` — The L1 gas price provided by the operator. +- `5` — The “fair” price for L2 gas, i.e. the price below which the `baseFee` of the batch should not fall. + For now, it is provided by the operator, but it in the future it may become hardcoded. +- `6` — The base fee for the batch that is expected by the operator. + While the base fee is deterministic, it is still provided to the bootloader just to make sure that the data + that the operator has coincides with the data provided by the bootloader. +- `7` — Reserved word. Unused on proved batch. + +The batch information slots +[are used at the beginning of the batch](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3629). +Once read, these slots can be used for temporary data. + +### Temporary Data Descriptions + +(This temporary data are used for debug and transaction processing purposes.) + +- `[8..39]` – reserved slots for debugging purposes +- `[40..72]` – slots for holding the paymaster context data for the current transaction. The role of the paymaster + context is similar to the [EIP4337](https://eips.ethereum.org/EIPS/eip-4337)’s one. You can read more about it in the + account abstraction documentation. +- `[73..74]` – slots for signed and explorer transaction hash of the currently processed L2 transaction. +- `[75..110]` – 36 slots for the calldata for the KnownCodesContract call. +- `[111..1134]` – 1024 slots for the refunds for the transactions. +- `[1135..2158]` – 1024 slots for the overhead for batch for the transactions. This overhead is suggested by the + operator, i.e. the bootloader will still double-check that the operator does not overcharge the user. +- `[2159..3182]` – slots for the “trusted” gas limits by the operator. The user’s transaction will have at its disposal + `min(MAX_TX_GAS(), trustedGasLimit)`, where `MAX_TX_GAS` is a constant guaranteed by the system. Currently, it is + equal to 80 million gas. In the future, this feature will be removed. +- `[3183..7282]` – slots for storing L2 block info for each transaction. You can read more on the difference L2 blocks + and batches + [here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Batches%20&%20L2%20blocks%20on%20zkSync.md). +- `[7283..40050]` – slots used for compressed bytecodes each in the following format: + - 32 bytecode hash + - 32 zeroes (but then it will be modified by the bootloader to contain 28 zeroes and then the 4-byte selector of the + `publishCompressedBytecode` function of the `BytecodeCompressor`) + - The calldata to the bytecode compressor (without the selector). +- `[40051..40052]` – slots where the hash and the number of current priority ops is stored. More on it in the priority + operations + [section](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1%E2%86%92L2%20ops%20on%20zkSync.md). + +### L1Messenger Pubdata + +- `[40053..248052]` – slots where the final batch pubdata is supplied to be verified by the L1Messenger. More on how the + L1Messenger system contracts handles the pubdata can be read + [here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20pubdata%20in%20Boojum.md). + +This `[40053..248052]` space is used for the calldata to the L1Messenger’s `publishPubdataAndClearState` function, which +accepts: + +- List of the user L2→L1 logs, +- Published L2→L1 messages +- Bytecodes +- List of full state diff entries, which describe how each storage slot has changed as well as compressed state diffs. + +This method will then check the correctness of the provided data and publish the hash of the correct pubdata to L1. + +Note, that while the realistic number of pubdata that can be published in a batch is 120kb, the size of the calldata to +L1Messenger may be significantly larger due to the fact that this method also accepts the original, uncompressed state diff +entries. + +These will not be published to L1, but will be used to verify the correctness of the compression. +In a worst-case scenario, the number of bytes that may be needed for this scratch space is if all the pubdata consists of repeated writes +(i.e. we’ll need only 4 bytes to include key) that turn into 0 (i.e. they’ll need only 1 byte to describe it). + +However, each of these writes in the uncompressed form will be represented as 272 byte state diff entry and so we get the number +of diffs is `120k / 5 = 24k`. This means that they will have accommodate `24k * 272 = 6528000` bytes of calldata for the +uncompressed state diffs. Adding 120k on top leaves us with roughly `6650000` bytes needed for calldata. `207813` slots +are needed to accommodate this amount of data. We round up to `208000` slots to give space for constant-size factors for +ABI-encoding, like offsets, lengths, etc. + +In theory, much more calldata could be used. +For instance, if one byte is used for `enum` index. +It is the responsibility of the operator to ensure that it can form the correct calldata for the L1Messenger. + +### Transaction Slot Descriptions + +- `[248053..250100]` words — 2048 slots for 1024 transaction’s meta descriptions (their structure is explained below). + +For internal reasons related to possible future integrations of zero-knowledge proofs about some of the contents of the +bootloader’s memory, the array of the transactions is not passed as the ABI-encoding of the array of transactions, but: + +- We have a constant maximum number of transactions. At the time of this writing, this number is 1024. +- Then, we have 1024 transaction descriptions, each ABI encoded as the following struct: + +```solidity +struct BootloaderTxDescription { + // The offset by which the ABI-encoded transaction's data is stored + uint256 txDataOffset; + // Auxiliary data on the transaction's execution. In our internal versions + // of the bootloader it may have some special meaning, but for the + // bootloader used on the mainnet it has only one meaning: whether to execute + // the transaction. If 0, no more transactions should be executed. If 1, then + // we should execute this transaction and possibly try to execute the next one. + uint256 txExecutionMeta; +} + +``` + +### **Reserved slots for the calldata for the paymaster’s postOp operation** + +- `[252149..252188]` words — 40 slots which could be used for encoding the calls for postOp methods of the paymaster. + +To avoid additional copying of transactions for calls for the account abstraction, we reserve some of the slots which +could be then used to form the calldata for the `postOp` call for the account abstraction without having to copy the +entire transaction’s data. + +### **The actual transaction’s descriptions** + +- `[252189..523261]` + +Starting from the 487312 word, the actual descriptions of the transactions start. (The struct can be found by this +[link](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/contracts/libraries/TransactionHelper.sol#L25)). +The bootloader enforces that: + +- They are correctly ABI encoded representations of the struct above. +- They are located without any gaps in memory (the first transaction starts at word 653 and each transaction goes right + after the next one). +- The contents of the currently processed transaction (and the ones that will be processed later on are untouched). + Note, that we do allow overriding data from the already processed transactions as it helps to preserve efficiency by + not having to copy the contents of the `Transaction` each time we need to encode a call to the account. + +### **VM Hook Pointers** + +- `[523261..523263]` + +These are memory slots that are used purely for debugging purposes (when the VM writes to these slots, the server side +can catch these calls and give important insight information for debugging issues). + +### **Result Pointer** + +- [523264..524287] + +These are memory slots that are used to track the success status of a transaction. If the transaction with number `i` +succeeded, the slot `2^19 - 1024 + i` will be marked as 1 and 0 otherwise. + +## Bootloader Execution Flow + +1. At the start of the batch it + [reads the initial batch information](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3629) + and + [sends the information](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3674) + about the current batch to the `SystemContext` system contract. +2. It goes through each of + [transaction’s descriptions](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3715) + and checks whether the `execute` field is set. If not, it ends processing of the transactions and ends execution of + the batch. If the execute field is non-zero, the transaction will be executed and it goes to step 3. +3. Based on the transaction’s type it decides whether the transaction is an L1 or L2 transaction and processes them + accordingly. More on the processing of the L1 transactions can be read [here](#l1-l2-transactions). More on L2 + transactions can be read [here](#l2-transactions). + +## L2 Transactions + +On zkSync, every address is a contract. Users can start transactions from their EOA accounts, because every address that +does not have any contract deployed on it implicitly contains the code defined in the +[DefaultAccount.sol](https://github.com/code-423n4/2023-10-zksync/blob/main/code/system-contracts/contracts/DefaultAccount.sol) +file. Whenever anyone calls a contract that is not in kernel space (i.e. the address is ≥ 2^16) and does not have any +contract code deployed on it, the code for `DefaultAccount` will be used as the contract’s code. + +Note, that if you call an account that is in kernel space and does not have any code deployed there, right now, the +transaction will revert. + +We process the L2 transactions according to our account abstraction protocol: +[https://v2-docs.zksync.io/dev/tutorials/custom-aa-tutorial.html#prerequisite](https://v2-docs.zksync.io/dev/tutorials/custom-aa-tutorial.html#prerequisite). + +1. We [deduct](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L1073) + the transaction’s upfront payment for the overhead for the block’s processing. + You can read more on how that works in the fee model [description](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/zkSync%20fee%20model.md). +2. Then we calculate the gasPrice for these transactions according to the EIP1559 rules. +3. We [conduct the validation step](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L1180) + of the AA protocol: + +- We calculate the hash of the transaction. +- If enough gas has been provided, we near_call the validation function in the bootloader. It sets the tx.origin to the + address of the bootloader, sets the ergsPrice. It also marks the factory dependencies provided by the transaction as + marked and then invokes the validation method of the account and verifies the returned magic. +- Calls the accounts and, if needed, the paymaster to receive the payment for the transaction. Note, that accounts may + not use `block.baseFee` context variable, so they have no way to know what exact sum to pay. That’s why the accounts + typically firstly send `tx.maxFeePerErg * tx.ergsLimit` and the bootloader + [refunds](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L730) + for any excess funds sent. + +1. [We perform the execution of the transaction](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L1234). + Note, that if the sender is an EOA, tx.origin is set equal to the `from` the value of the transaction. During the + execution of the transaction, the publishing of the compressed bytecodes happens: for each factory dependency if it + has not been published yet and its hash is currently pointed to in the compressed bytecodes area of the bootloader, a + call to the bytecode compressor is done. Also, at the end the call to the KnownCodeStorage is done to ensure all the + bytecodes have indeed been published. +2. We + [refund](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L1401) + the user for any excess funds he spent on the transaction. The process is as follows: + +3. The `postTransaction` operation is called to the `paymaster`. +4. The Bootloader asks the operator to provide a refund. + During the first VM run—without proofs—the operator directly inserts the refunds in the memory of the bootloader. + During the run for the proved batches, the operator already knows which values have to be inserted. + You can read more about the [fee model here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/zkSync%20fee%20model.md) +5. The Bootloader refunds the user. +6. We notify the operator about the + [refund that was granted to the user.](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L1112). + It will be used to correctly display the gas used for the transaction in the block explorer. + +## L1->L2 Transactions + +L1->L2 transactions are transactions that were initiated on L1. We assume that `from` has already authorized the L1→L2 +transactions. It also has its L1 pubdata price as well as ergsPrice set on L1. + +Most of the steps from the execution of L2 transactions are omitted and we set `tx.origin` to the `from`, and +`ergsPrice` to the one provided by transaction. +After that, we use [mimicCall](https://matter-labs.github.io/eravm-spec/spec.html#FarCalls) +to provide the operation itself from the name of the sender account. + +Note, that for L1→L2 transactions, `reserved0` field denotes the amount of ETH that should be minted on L2 as a result +of this transaction. `reserved1` is the refund receiver address, i.e. the address that would receive the refund for the +transaction as well as the msg.value if the transaction fails. + +There are two kinds of L1->L2 transactions: + +1. Priority operations, initiated by users (they have type `255`). +2. Upgrade transactions, that can be initiated during system upgrade (they have type `254`). + +[You can read more about differences between the different L1->L2 transaction types here.](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1%E2%86%92L2%20ops%20on%20zkSync.md) + +## End of the Batch + +At the end of the batch we set `tx.origin` and `tx.gasprice` context variables to zero to both save L1 gas on `calldata` and to +send the entire Bootloader balance to the operator. This effectively sends all the fees collected by the Bootloader to the operator. + +Also, we +[set](https://github.com/code-423n4/2023-10-zksync/blob/ef99273a8fdb19f5912ca38ba46d6bd02071363d/code/system-contracts/bootloader/bootloader.yul#L3812) +the fictive L2 block’s data. Then, we call the system context to ensure that it publishes the timestamp of the L2 block +as well as L1 batch. We also reset the `txNumberInBlock` counter to avoid its state diffs from being published on L1. +You can read more about block processing on zkSync +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Batches%20&%20L2%20blocks%20on%20zkSync.md). + +After that, we publish the hash as well as the number of priority operations in this batch. More on it +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20L1%E2%86%92L2%20ops%20on%20zkSync.md). + +Then, we call the L1Messenger system contract for it to compose the pubdata to be published on L1. You can read more +about the pubdata processing +[here](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Smart%20contract%20Section/Handling%20pubdata%20in%20Boojum.md). diff --git a/content/10.zk-stack/10.components/50.zksync-evm/20.precompiles.md b/content/10.zk-stack/10.components/50.zksync-evm/20.precompiles.md new file mode 100644 index 00000000..0797d7c3 --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/20.precompiles.md @@ -0,0 +1,198 @@ +--- +title: Precompiles +description: Explanation of precompiled contracts for elliptic curve operations essential for zkSNARK verification. +--- + +## Overview of Precompiled Contracts in Ethereum + +In Ethereum, precompiled contracts offer advanced functionalities not readily available in the standard set of opcodes. +These contracts simplify and optimize resource-intensive operations, such as those involving elliptic curves, which are crucial for zkSNARK verification. + +### Role of Precompiled Contracts + +Precompiled contracts are embedded within the Ethereum Virtual Machine (EVM) at predetermined addresses. +They facilitate operations like elliptic curve point addition, scalar multiplication, +and pairing—each essential for cryptographic processes in blockchain applications. + +### Understanding Elliptic Curve Operations + +Elliptic curve operations are fundamental to blockchain cryptography, providing the security necessary for transactions and smart contracts. +These operations include: + +- **Elliptic Curve Point Addition:** Combines two points on a curve to produce a third point. +- **Elliptic Curve Point Scalar Multiplication:** Multiplies a point on a curve by a scalar, producing another point. +- **Elliptic Curve Pairing:** A complex operation used in more advanced cryptographic constructs, such as zkSNARKs. + +The precompiled contracts designated for these tasks are essential for efficient and secure cryptographic verification. + +### How Precompiled Contracts Work + +These contracts are hardcoded into the EVM and can be accessed via fixed addresses starting from `1`. +Each contract comes with a set gas cost for execution, excluding the gas required for calling the contract and managing data in memory. +For instance, in the Go-Ethereum implementation, the execution logic and gas calculations are defined within the Go programming language, +following specifications like [EIP-196](https://eips.ethereum.org/EIPS/eip-196). + +### Evolving with Ethereum + +The Ethereum network occasionally introduces new precompiled contracts through network upgrades or hard forks. +These additions ensure that Ethereum can handle new cryptographic challenges and efficiency demands as they arise. + +Precompiled contracts thus play a crucial role in maintaining Ethereum's cryptographic integrity and performance, +especially in areas requiring intense computational resources, like those needed for zkSNARK verification. + +--- +## Field Arithmetic + +The BN254 (also known as alt-BN128) is an elliptic curve defined by the equation $y^2 = x^3 + 3$ over the finite field +$\mathbb{F}_p$, being $p = 218882428718392752222464057452572750886963111572978236626890378946452262$08583. The modulus +is less than 256 bits, which is why every element in the field is represented as a `uint256`. + +The arithmetic is carried out with the field elements encoded in the Montgomery form. This is done not only because +operating in the Montgomery form speeds up the computation but also because the native modular multiplication, which is +carried out by Yul's `mulmod` opcode, is very inefficient. + +Instructions set on zkSync and EVM are different, so the performance of the same Yul/Solidity code can be efficient on +EVM, but not on zkEVM and opposite. + +One such very inefficient command is `mulmod`. On EVM there is a native opcode that makes modulo multiplication and it +costs only 8 gas, which compared to the other opcodes costs is only 2-3 times more expensive. On zkEVM we don’t have +native `mulmod` opcode, instead, the compiler does full-with multiplication (e.g. it multiplies two `uint256`s and gets +as a result an `uint512`). Then the compiler performs long division for reduction (but only the remainder is kept), in +the generic form it is an expensive operation and costs many opcode executions, which can’t be compared to the cost of +one opcode execution. The worst thing is that `mulmod` is used a lot for the modulo inversion, so optimizing this one +opcode gives a huge benefit to the precompiles. + +### Multiplication + +As said before, multiplication was carried out by implementing the Montgomery reduction, which works with general moduli +and provides a significant speedup compared to the naïve approach. + +The squaring operation is obtained by multiplying a number by itself. However, this operation can have an additional +speedup by implementing the SOS Montgomery squaring. + +### Inversion + +Inversion was performed using the extended binary Euclidean algorithm (also known as extended binary greatest common +divisor). This algorithm is a modification of Algorithm 3 `MontInvbEEA` from +[Montgomery inversion](https://cetinkayakoc.net/docs/j82.pdf). + +### Exponentiation + +The exponentiation was carried out using the square and multiply algorithm, which is a standard technique for this +operation. + +--- +## Montgomery Form + +Let’s take a number `R`, such that `gcd(N, R) == 1` and `R` is a number by which we can efficiently divide and take +module over it (for example power of two or better machine word, aka 2^256). Then transform every number to the form of +`x * R mod N` / `y * R mod N` and then we get efficient modulo addition and multiplication. The only thing is that +before working with numbers we need to transform them to the form from `x mod N` to the `x * R mod N` and after +performing operations transform the form back. + +For the latter, we will assume that `N` is the module that we use in computations, and `R` is $2^{256}$, since we can +efficiently divide and take module over this number and it practically satisfies the property of `gcd(N, R) == 1`. + +### Montgomery Reduction Algorithm (REDC) + +> Reference: + +```solidity +/// @notice Implementation of the Montgomery reduction algorithm (a.k.a. REDC). +/// @dev See +/// @param lowestHalfOfT The lowest half of the value T. +/// @param higherHalfOfT The higher half of the value T. +/// @return S The result of the Montgomery reduction. +function REDC(lowestHalfOfT, higherHalfOfT) -> S { + let q := mul(lowestHalfOfT, N_PRIME()) + let aHi := add(higherHalfOfT, getHighestHalfOfMultiplication(q, P())) + let aLo, overflowed := overflowingAdd(lowestHalfOfT, mul(q, P())) + if overflowed { + aHi := add(aHi, 1) + } + S := aHi + if iszero(lt(aHi, P())) { + S := sub(aHi, P()) + } +} + +``` + +By choosing $R = 2^{256}$ we avoided 2 modulo operations and one division from the original algorithm. This is because +in Yul, native numbers are uint256 and the modulo operation is native, but for the division, as we work with a 512-bit +number split into two parts (high and low part) dividing by $R$ means shifting 256 bits to the right or what is the +same, discarding the low part. + +### Montgomery Addition/Subtraction + +Addition and subtraction in Montgomery form are the same as ordinary modular addition and subtraction because of the +distributive law + +$$ +\begin{align*} +aR+bR=(a+b)R,\\ +aR-bR=(a-b)R. +\end{align*} +$$ + +```solidity +/// @notice Computes the Montgomery addition. +/// @dev See for further details on the Montgomery multiplication. +/// @param augend The augend in Montgomery form. +/// @param addend The addend in Montgomery form. +/// @return ret The result of the Montgomery addition. +function montgomeryAdd(augend, addend) -> ret { + ret := add(augend, addend) + if iszero(lt(ret, P())) { + ret := sub(ret, P()) + } +} + +/// @notice Computes the Montgomery subtraction. +/// @dev See for further details on the Montgomery multiplication. +/// @param minuend The minuend in Montgomery form. +/// @param subtrahend The subtrahend in Montgomery form. +/// @return ret The result of the Montgomery addition. +function montgomerySub(minuend, subtrahend) -> ret { + ret := montgomeryAdd(minuend, sub(P(), subtrahend)) +} + +``` + +We do not use `addmod`. That's because in most cases the sum does not exceed the modulus. + +### Montgomery Multiplication + +The product of $aR \mod N$ and $bR \mod N$ is $REDC((aR \mod N)(bR \mod N))$. + +```solidity +/// @notice Computes the Montgomery multiplication using the Montgomery reduction algorithm (REDC). +/// @dev See for further details on the Montgomery multiplication. +/// @param multiplicand The multiplicand in Montgomery form. +/// @param multiplier The multiplier in Montgomery form. +/// @return ret The result of the Montgomery multiplication. +function montgomeryMul(multiplicand, multiplier) -> ret { + let hi := getHighestHalfOfMultiplication(multiplicand, multiplier) + let lo := mul(multiplicand, multiplier) + ret := REDC(lo, hi) +} + +``` + +### Montgomery Inversion + +```solidity +/// @notice Computes the Montgomery modular inverse skipping the Montgomery reduction step. +/// @dev The Montgomery reduction step is skipped because a modification in the binary extended Euclidean algorithm is used to compute the modular inverse. +/// @dev See the function `binaryExtendedEuclideanAlgorithm` for further details. +/// @param a The field element in Montgomery form to compute the modular inverse of. +/// @return invmod The result of the Montgomery modular inverse (in Montgomery form). +function montgomeryModularInverse(a) -> invmod { + invmod := binaryExtendedEuclideanAlgorithm(a) +} +``` + +As said before, we use a modified version of the bEE algorithm that lets us “skip” the Montgomery reduction step. + +The regular algorithm would be $REDC((aR \mod N)^{−1}(R^3 \mod N))$ which involves a regular inversion plus a +multiplication by a value that can be precomputed. diff --git a/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/10.vm-primer.md b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/10.vm-primer.md new file mode 100644 index 00000000..1d8d710e --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/10.vm-primer.md @@ -0,0 +1,637 @@ +--- +title: ZkSync Virtual Machine primer +description: +--- + +Unlike EVM, zkEVM is a register machine. EVM instructions operate on a stack. Instead, zkEVM operates primarily on +sixteen registers and memory like most modern computers. That simplifies zero-knowledge proofs, which largely rely on +building arithmetic circuits. + +This document describes zkEVM assembly language, then the aspects of VM related to smart-contracts. Its purpose is not +to be a complete reference, but to guide you through the main ideas. + +## VM architecture + +The native type for zkEVM is a 256-bits wide unsigned integer, we call it a _word_. + +Contracts are sequences of instructions. To support the execution of contracts, VM provides the following transient +state: + +- **registers**: 16 general-purpose registers: `r0`, `r1`, …, `r15`. + `r0` is a special constant register: reading it yields 0, storing to it is ignored. +- **flags**: three distinct boolean registers LT (less-than), EQ (equals, the result is zero) and GT (greater-than). + Instructions may set or clear flags depending on computation results. +- **data** **stack**: holds $2^{16}$ words, is free to use. +- **heap**: for data that we want to pass around between functions and contracts. Heap is bounded, accesses are only + free inside the bound, and we have to pay for growing the bound. +- **code memory**: stores code of currently running contracts. May also be used as a constant pool. + +VM is aware of two data types: + +- raw integers +- pointers (to fragments of other contracts’ heaps). + +Registers and data stack are tagged: VM keeps track of whether they hold pointers or raw integer values. Some +instructions will only accept operands tagged as pointers. + +Heap and storage are not tagged, so if we store a pointer to the heap, its tag is lost. + +Contracts have key-value storages, where keys and values are untagged 256-bit integers. Instructions can change +persistent contract storage. + +VM is capable of both near calls (to the code within the same contract) and far calls (to other contracts). + +Let us now gradually introduce the VM functionality guided by the instruction set. + +## Basic instructions + +Contract code consists of instructions, they are executed sequentially. + +Instructions usually operate with registers. For example, an instruction `add` may look like that: + +```asm +; this is a comment +add 5, r2, r8 ; store (5 + r2) to r8 +``` + +Or like that: + +```asm +add 5, r0, r8 ; store (5 + 0) to r8 +``` + +Notice that register `r0` is used to feed constant zero values to instructions; this allows to use `add X, r0, Y` to +copy a value `X` to `Y` . + +Commonly, instructions accept two inputs and one output operands, following the schema: + +![arithmetic opcode](/images/zk-stack/arithmetic_opcode.png) + +The first operand can be taken from: + +- registers +- an immediate 16-bit value, like in the example above `add 5, r2, r8`. To use bigger numbers put them as constants in + the code memory, see section **Code Addressing**. +- directly from the code memory +- stack in various ways, e.g. `add stack=[2], r2, r8` takes the first element from the stack memory area, by an absolute + address 2. +- code memory + +Only registers can be the source of the second operand. + +```asm +add r0, 5, r8 ; error: 5 is an immediate value, + ; but only register is allowed as second operand +``` + +There is usually at most one output operand. Similarly, the first output operand can be stored to registers or stack. If +there is a second output operand, it can only be stored to a register. + +Instructions are executed one after another, and every instruction has a gas cost measured in _gas_. A program that runs +out of gas panics and none of its side effects are performed. + +Every contract may have at most $2^{16}$ instructions. + +### Arithmetic instructions + +Besides `add`, zkEVM implements `sub` for subtraction, `and`/ `or` / `xor` for bitwise logics, `shl`/ `shr` for logical +shifts, `rol`/ `ror` for circular shifts. These instructions follow the same format, e.g.: + +```asm +shl r1, r4, r3 ; right shift r1 by value of r4, store result in r3 +``` + +Instructions `mul` and `div` are particular: they have two output operands: + +- `mul r1, r2, r3, r4` stores the low 256 bits of r1_r2 in r3, high 256 bits of r1_r2 in r4 +- `div r1, r2, r3, r4` stores the quotient in `r3` and remainder in `r4`. + +### Modifiers + +Most instructions support modifiers that alter their behaviour. The modifiers are appended to the name of the +instruction, separated by a dot e.g. `sub.s` . Three basic modifier types are: `set_flags` , predicates, and `swap`. + +#### Set flags + +By default, most instructions preserve flags. + +```asm +sub r1, r2, r3 ; r3 <- (r1 - r2), no flags are affected +``` + +The instruction `sub` is implemented so that it sets `EQ` if the result is zero (that is, if `r1` == `r2`). But in this +case, even if `r1-r2` is zero, the EQ flag is not set, because we did not allow it explicitly. We allow instruction to +set flags by appending a “set flags” modifier to them, like that: + +```asm +sub! r1, r2, r3 ; r3 <- (r1 - r2); EQ = 1 +``` + +You can learn more in the +[formal specification](/zk-stack/components/zksync-evm/vm-specification/formal-spec). + +#### Predicates + +Another type of modifiers allows transforming any instruction into a _predicated_, conditional instruction. Predicated +instructions are only executed if flags satisfy their condition. + +Recall the three flags: LT, EQ and GT. + +For example, this `sub` instruction is only executed if EQ is set: + +```asm +sub.if_eq r1, r2, r5 +``` + +Here is how we can execute `jump` to a label `.label_if_equals` only if `r1 == r2` : + +```asm +sub! r1, r2, r3 ; r3 <- (r1 - r2); EQ = 1 if r1 == r2 +jump.if_eq .label_if_equals +``` + +If the condition is not satisfied, we skip the instruction, but still pay its basic cost in gas. + +Here is a full list of available predicates: + +- `if_gt` +- `if_eq` +- `if_lt` +- `if_ge` (short for “GT or EQ”) +- `if_le` (short for “LT or EQ”) +- `if_not_eq` +- `if_gt_or_eq` + +You can learn more in the +[formal specification](/zk-stack/components/zksync-evm/vm-specification/formal-spec). + +#### Swap + +Recall that instructions may only accept data from stack as their first operand. What if we need the second operand from +stack? For commutative operation, like `add` , `mul`, or `and`, the order of operands does not matter and we can just +write `add x,y,z` instead of `add y,x,z`. However, for operations like `sub` or `div` we implement a special “swap” +modifier which exchanges the operand values before executing the instruction. This is useful to work around the +restriction that the second source operand has to be a register. + +For example: + +```asm +sub r1, r2, r3 ; r3 <- r1 - r2 +sub.s r1, r2, r3 ; r3 <- r2 - r1 + +``` + +Finally, here is an example of an instruction adorned with all possible modifiers: + +```asm +sub.s.if_lt! r8, r4, r12 +``` + +Here is a breakdown of modifiers: + +- `.if_lt` : is only executed if the LT flag is set +- `.s` : computes `r4 - r8` instead of `r8 - r4` +- `!` : sets flags + +$$ +\begin{aligned} +LT &\leftarrow r_4 < r_8 \\ +EQ &\leftarrow r_4 - r_8 = 0 \\ +GT &\leftarrow r_4 > r_8 +\end{aligned} +$$ + +Other modifiers are instruction-specific. They are described in full in the instruction reference. + +## Calls and returns + +The `jump` instruction allows to continue execution from a different place, but it does not allow to return back. An +alternative is using calls; zkEVM supports calling code inside the contract itself (near calls) as well as calling other +contracts (far calls). + +### Far calls + +Far calls are the equivalent of calls in EVM. + +Each call gets its own stack, heap, code memories, and allocated gas. + +It is impossible to allocate more than 63/64 of the currently available gas to a far call. + +Calls can revert or panic (on executing an illegal instruction for example), which undoes all the changes to storage and +events emitted during the call, and burns all remaining gas allocated to this call. + +Suppose we far called a contract $C$. After the execution of $C$, the register `r1` holds a pointer to the return value, +allowing a read-only access to a fragment of $C$’s heap. Alternatively, `r1` can hold a pointer to the heap of some +other contract that $C$ called internally. More on that in Pointers section. + +**Delegate calls.** Beside normal `far_call`, there is a variant `far_call.delegate`. Delegate calls are a variation of +far calls allowing to call a contract with the current storage space. + +For example, suppose we have contracts A,B,C. Contract A calls B normally, then B delegates to C. Then C’s code is +executed in a context of B’s storage, as if contract A called contract C. If C returns normally, the execution will +proceed from the next instruction of B after delegate call. In case of `revert` or `panic` in C, all the usual rules +apply. + +**Mimic calls.** The last variant of far calls is `far_call.mimic`; it is inaccessible to users and only allowed in +system contracts. + +Any of far call variants can be additionally marked as `.static` to call a contract in static mode — see section +**Static Mode**. + +### Return, revert, panic + +There are three types of situations where control returns to the caller: + +- Return: a normal way of returning to the caller when no errors occurred. The instruction is `ret`. +- Revert: a recoverable error happened. Unspent gas is returned to the caller, which will execute the exception handler. + The instruction is `revert`. +- Panic: an irrecoverable error happened. Same as revert, but unspent gas is burned. The instruction is `ret.panic`. + +### Near calls + +Instruction `near_call reg, address` passes the control to a different address inside the same contract, like `jump`. +Additionally, it remembers the context of execution in a special _call stack_ (it is different from data stack and not +accessible to assembly programmers). + +Here is an example of calling function `f` . + +```asm +.text + +; here will be the code of exception handler +eh: + +; caller function +main: +near_call r2, @f, @eh ; refer to labels in code using '@' symbol + +; callee function +f: +ret + +``` + +Additional two arguments: + +- label `@eh` is the address of exception handler. Functions, like contracts, may revert or panic, which leads to the + execution of the exception handler. +- register `r2` holds how much gas we allocate to the function. + +As we see, zkEVM supports allocating ergs not only for far calls, but also for near calls. Passing zero will allocate +all available gas. Unlike in far calls, near calls do not limit the amount of gas passed to 63/64 of available gas. + +- On revert, unspent gas of the function is **returned** +- On panic, unspent gas of the function is **lost** + +All near calls inside the contract are sharing the same memory space (heap, stack), and do not roll back the changes to +this memory if they fail. They do, however, roll back the changes to storage and events. + +Near calls cannot be used from Solidity to their full extent. Compiler generates them, but makes sure that if functions +revert or panic, the whole contract reverts of panics. Explicit exception handlers and allocating just a portion of +available gas are reserved for low-level code. + +## Accessing data outside registers + +### Stack addressing + +As we already know, instructions may accept data not only in registers or as immediate 16-bit values, but also on stack. + +Data stack is a collection of $2^{16}$ words with a pointer SP. This pointer contains the next address after the topmost +stack element, so the topmost element has the address SP-1. Stack grows towards maximal address, i.e. pushing an element +to stack increases SP. + +On far call, SP starts in a new stack memory at 1024. + +#### Reading from stack + +There are several ways of accessing stack cells: + +```asm +.text +main: + +; r0 <- stack word by absolute index (r1+42), unrelated to SP +add stack=[r1+42], r0, r2 + +; r0 <- stack word by index (SP - (r1 + 42)) +add stack[r1+42], r0, r2 + +; r2 <- stack word by index (SP - (r1 + 42)); additionally, SP += (r1+42) +add stack-=[r1+42], r0, r2 +``` + +As we see there are three stack address modes for input operands; all of them use (register + offset). + +Currently, the last mode is only used in a `nop` instruction as a way to rewind stack: + +```asm +; effectively, SP -= reg+imm +nop stack-=[reg+imm] +``` + +#### Writing to stack + +Storing results on stack is also possible: + +```asm +.text +main: + +; r1 -> word by absolute index (r2 + 42) +add r1, r0, stack=[r2 + 42] + +; r1 -> word by absolute index SP - (r2 + 42) +add r1, r0, stack[r2 + 42] + +; r1 -> word by absolute index SP + (r2 + 42) +; additionally, SP += r2 + 42 +add r1, r0, stack+=[r2 + 42] +``` + +Currently, the last mode is only used in a `nop` instruction as a way to forward stack pointer: + +```asm +; effectively, SP += reg+imm +nop r0, r0, stack+=[reg+imm] +``` + +### Code addressing + +Sometimes we might need to work with larger chunks that do not fit into 16-bit. In this case we can use the +(read-only) code memory as a constant pool and read 256-bit constants from there. + +```asm +.rodata + +datavar: + .cell 42 + .cell 999 +.text +somelabel: + +; r2 <- word by index (r0+0) code memory +add @datavar[0], r0, r2 +add @datavar[r2], r0, r2 +``` + +Note: instructions are 64-bit wide, but when accessing data in code memory, this memory is treated as word-addressable. +Therefore, e.g. reading the 0-th 256-bit word from this memory will yield a binary representation of the four first +64-bit instructions in the contract. + +There is no distinction between static data and code: code can be read, data can be executed, but instructions that are +not correctly encoded will trigger panic. + +Contracts always need to be divisible by 32 bytes (4 instructions) because of this addressing mode. + +### Using heap + +Heap is a bounded memory region to store data between near calls, and to communicate data between contracts. + +#### Heap boundary growth + +Accessing an address beyond the heap bound leads to heap growth: the bound is adjusted to accommodate this address. The +difference between old and new bounds is paid in gas. + +#### Instructions to access heap + +Most instructions can not use heap directly. Instructions `ld.1` and `st.1` are used to load and store data on heap: + +```asm +; take a 32-bit number from r1, use it as an offset in heap, +; load the word from heap by this offset to r4 +ld.1 r1, r4 + +; take a 32-bit number from r3, use it as an offset in heap, +; store the word from r5 to heap by this offset +st.1 r3, r5 +``` + +Heap is byte-addressable, but reads and writes operate in words. To read two consecutive words in heap starting at an +address A, first, read from A, and then read from A+32. Reading any addresses in between is valid too. + +One of the modifiers allows to immediately form a new offset like that: + +```asm +; same as ld, but additionally r5 <- r1 + 32 +ld.1.inc r1, r4, r5 +``` + +This allows reading several consecutive words in a row: + +```asm +; reads four consecutive words from heap starting at address in r8 +; into registers r1, r2, r3, r4 +ld.1.inc r8, r1, r8 +ld.1.inc r8, r2, r8 +ld.1.inc r8, r3, r8 +ld.1.inc r8, r4, r8 +``` + +In theory, heap can hold nearly $2^{32}$ bytes, but growing a heap so large is not affordable: the maximum gas allocated +is $2^{32}-1$. + +The topmost 32 bytes of heap are considered forbidden addresses, trying to access them results in panic no matter how +much gas is available. + +#### Heap and Auxheap + +In zkEVM, there are two heaps; every far call allocates memory for both of them. + +Heaps are selected with modifiers `.1` or `.2` : + +- `ld.1` reads from heap; +- `ld.2` reads from auxheap. + +The reason why we need two heaps is technical. Heap contains calldata and returndata for calls to user contracts, while +auxheap contains calldata and returndata for calls to system contracts. This ensures better compatibility with EVM as +users should be able to call zkEVM-specific system contracts without them affecting calldata or returndata. + +## Fat pointers + +A fat pointer is the second type of values in zkEVM, beside raw integers. + +As we noted, registers and stacks are internally tagged by VM to keep track of the cells containing pointers in their +low 128 bits. Only cells with a set pointer tag are considered fat pointers. + +Fat pointers are used to pass read-only data between contracts. When choosing how to pass data to a contract (whether +when calling or returning from a call) we have a choice: + +- pass an existing fat pointer, or +- create a new fat pointer from a fragment of heap/auxheap. + +Fat pointers combine two aspects: + +- Delimit a fragment accessible to other contract. Accesses outside this fragment through a pointer yield zero. +- Provide an offset inside this fragment. This offset can be increased or decreased. + +The restrictions on fat pointers provide allows to pass data between contracts safely and without excessive copying. + +**Implementation note.** Internally, fat pointers hold four 32-bit values: + +- bits 0..31 : offset +- bits 32..63: internal memory page ID +- bits 64…95 : starting address of the fragment +- bits 96…127 : length of the fragment + +#### Instructions to manipulate fat pointers + +Only special instructions can manipulate fat pointers without automatically clearing its pointer tag. + +- `ptr.add`, `ptr.sub` modify the offset inside pointer +- `ptr.shrink` reduces the associates fragment, so if we get a fat pointer from contract A, we can then shrink it and + pass to another contract B up the call chain, again without copying data. +- `ptr.pack` allows putting data in the top 128 bit of the pointer value without clearing the pointer tag. + +Doing e.g. `add r1, 0, r2` on a pointer in `r1` clears its tag, and it is now considered as a raw integer. + +Instructions `ld` and `[ld.inc](http://ld.inc)` (without indices 1 or 2) allow loading data by fat pointers, possibly +incrementing the pointer. It is impossible to write by a fat pointer. + +## Contracts and storage + +All accounts are associated with contracts. There are $2^{160}$ valid account addresses. + +In zkEVM, contracts may have multiple **functions** in them; a contract may execute its functions by using `near_call` ; +it may call other contracts by using `far_call` or its variations `delegate_call` / `mimic_call` (mimic is reserved for +system contracts). + +Size of a contract should be divisible by 32 bytes (4 instructions). + +### Storage of contracts + +Every account has a storage. Storage maps $2^{256}$ keys to values; both keys and values are 256-bit untagged words. + +Contracts may write to their own storage by using `sstore key, value` and read from storage using `sload key, dest`. + +### Static mode + +Static mode prevents contracts from modifying their storage and emitting events. In static mode, executing an +instruction like `sstore` sends VM into panic. + +To execute a contract C in static mode, use a `static` modifier: `far_call.static`. All contracts, called by C +recursively, will also be executed in static mode. VM exits static mode automatically when C terminates. + +### System contracts + +Part of Era’s functionality is implemented through system contracts. These contracts have addresses from 0 to $2^{64}$ +and are executed in kernel mode, where they have access to privileged instructions. An example of such instruction is +mimic call, a variant of far call where the caller can pretend to be another contract. This is useful for hiding the +fact that something is implemented via a system contract but in the hands of users it would mean being able to steal +anyone’s tokens. + +System contracts implement contract deployment, extensions such as keccak256, decommitting code etc. + +## Server and VM environment + +### Decommitter + +Decommitter is a module external to zkEVM allowing accessing deployed code by its hash. + +![Overview of VM modules](/images/zk-stack/vm-mapping.png) + +The system contracts at the address $2^{15}+2$ , called Deployer, keeps hashes of code of each contract in its storage. +Far calls to a contract with address $C$ perform as follows: + +- VM internally accesses the storage of `Deployer` contract by key $C$. This storage yields the hash value $H$**.** +- then VM queries the decommitter, providing $H$. Decommitter answers with the contract code. + +If decommitter does not have the code for the requested hash, one of two things happen: + +- if C is a system contract (i.e. address of $C < 2^{16}$), the call will fail +- otherwise, VM will call the `DefaultAccount` contract. + +### Server + +The VM is controlled by a _server._ When the server needs to build a new batch, it starts an instance of zkEVM and feeds +the transactions to the [Bootloader](#bootloader). + +zkEVM accepts three parameters: + +1. Bootloader’s hash. It is used to fetch the bootloader code from decommitter. +2. Code hash of `DefaultAccount` contract code. It is used to fetch the default code from Decommitter in case of a far + call to a contract without any associated code. +3. A boolean flag `is_porter_available`, to determine the number of shards (two if zkPorter is available, one + otherwise). + +zkEVM retrieves the code of bootloader from Decommitter and proceeds with sequential execution of instructions on the +bootloader’s code page. + +#### Failures and rollbacks + +There are three types of behaviour triggered by execution failures. + +1. Skipping a malformed transaction. It is a mechanism implemented by the server, external to zkEVM. Server makes a + snapshot of zkEVM state after completing every transaction. If the bootloader encounters a malformed transaction, it + fails, and the server restarts zkEVM from the most recent snapshot, skipping this transaction. + + This behaviour is specific to server/bootloader; the contract code has no ways of invoking it. + +2. Revert is triggered by the contract code explicitly by executing `revert`. zkEVM saves its persistent state on every + near or far call. If the contract code identifies a recoverable error, it may execute `revert`; then zkEVM rolls the + storage and event queues back to the last checkpoint and executes the exception handler. +3. Panic is triggered either explicitly by executing `panic` or internally when some execution invariants are violated + e.g. attempt to use raw integer in `ptr.add` instruction. + + On panic, the persistent state of zkEVM is rolled back in the same way as on revert. + +### Bootloader + +Bootloader is a system contract in charge of block construction +(**[sources](https://github.com/matter-labs/era-contracts/blob/main/system-contracts/bootloader/bootloader.yul)**). + +Formally, bootloader is assigned an address BOOTLOADER_SYSTEM_CONTRACT_ADDRESS = $2^{15}+1$, but zkEVM decommits its +code directly by its hash. + +The heap of the bootloader is special: it acts as an interface between server and zkEVM. Server gradually fills the +bootloader’s heap with transaction data, formatted according to an implementation-defined convention. + +The bootloader then acts roughly as the following code (not an actual implementation): + +```solidity +contract Bootloader { + function executeBlock(address operatorAddress, Transaction[2] memory transactions) { + for (uint256 i = 0; i < transactions.length; i++) { + validateTransaction(transactions[i]); + chargeFee(operatorAddress, transactions[i]); + executeTransaction(transactions[i]); + } + } + + function validateTransaction(Transaction memory tx) { + // validation logic + } + + function chargeFee(address operatorAddress, Transaction memory tx) { + // charge fee + } + + function executeTransaction(Transaction memory tx) { + // execution logic + } +} + +``` + +The bootloader is therefore responsible for: + +- validating transactions; +- executing transactions to form a new block; +- setting some of the transaction- or block-wide transaction parameters (e.g. `blockhash`, `tx.origin`). + +Server makes a snapshot of zkEVM state after completing every transaction. When the bootloader encounters a malformed +transaction, it fails, and the server restarts zkEVM from the most recent snapshot, skipping this transaction. If a +transaction is well-formed, zkEVM may still panic while handling it outside the bootloader code. This is a normal +situation and is handled by zkEVM in a regular way, through panics. + +The exact code of the bootloader is a part of a protocol; its hash is included in the block header. + +### Context value + +A part of the zkEVM state is a 128-bit _context value_. It implements `msg.value` standing for the amount of wei sent in +a transaction. In assembly, it is used as follows: + +1. Execute `context.set_context_u128 reg` to set the value; +2. Perform a far call — it captures the context value; +3. In a called contract, access the context value through `context.get_context_u128 reg`. + +Context value can not be set in static mode. diff --git a/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/20.formal-spec.md b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/20.formal-spec.md new file mode 100644 index 00000000..ea8528be --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/20.formal-spec.md @@ -0,0 +1,9 @@ +--- +title: VM Formal Specification +description: +--- + +This is the specification of the instruction set of EraVM 1.4.0, a language virtual machine for zkSync Era. +It describes the virtual machine's architecture, instruction syntax and semantics, and some elements of system protocol. + +[See the Formal Specification here.](https://matter-labs.github.io/eravm-spec/spec.html) diff --git a/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/_dir.yml b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/_dir.yml new file mode 100644 index 00000000..47392cc1 --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/30.vm-specification/_dir.yml @@ -0,0 +1 @@ +title: Virtual Machine Specification diff --git a/content/10.zk-stack/10.components/50.zksync-evm/_dir.yml b/content/10.zk-stack/10.components/50.zksync-evm/_dir.yml new file mode 100644 index 00000000..179d2b70 --- /dev/null +++ b/content/10.zk-stack/10.components/50.zksync-evm/_dir.yml @@ -0,0 +1 @@ +title: zkSync EVM diff --git a/content/10.zk-stack/10.components/60.prover/10.overview.md b/content/10.zk-stack/10.components/60.prover/10.overview.md new file mode 100644 index 00000000..7a65a7e5 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/10.overview.md @@ -0,0 +1,70 @@ +--- +title: Overview +description: Exploring the prover in zkSync, a ZK rollup technology, which ensures secure and efficient transaction verification through cryptographic proofs. +--- + +zkSync utilizes Zero-Knowledge (ZK) proofs to ensure secure and efficient transaction processing on the Ethereum blockchain. +This technology compresses transactions, significantly reducing fees for users while maintaining the robust security standards of Ethereum. + +### How zkSync Utilizes ZK Proofs + +Zero-Knowledge proofs enable a verifier to confirm that a prover has correctly executed a computation without revealing the specifics of the transaction. +This approach ensures both privacy and data security. +In zkSync, the prover is responsible for demonstrating the correct execution of zkSync’s Ethereum Virtual Machine (EVM), +and this proof is then verified by a smart contract on Ethereum. + +### The Proving Process + +The proving process in zkSync involves several crucial steps: + +1. **Witness Generation**: + This is the initial phase where, upon transaction initiation by a user, a witness is generated. + This witness acts as proof of the transaction's validity according to the network's consensus rules, without disclosing any transaction details. + Witnesses for new transactions are collected in batches and processed together. + +2. **Circuits**: + To generate accurate proofs, standard code logic must be converted into a format interpretable by the proof system. + This conversion involves organizing code into various circuits within a virtual machine, ensuring that every aspect of the code execution can be proven. + +3. **Proof System**: + The ZK circuit requires a robust proof system for processing. + In zkSync, this system is called Boojum. It comprises several components: + - **Boojum**: + This repository acts as a toolkit containing essential tools for proving and verifying circuit functionality, + along with backend components necessary for circuit construction. + - **zkevm_circuits**: + This repository is where the actual EVM-replicating circuits are built using tools from Boojum. + - **zkevm_test_harness**: + Serving as the testing ground, this repository contains various tests to ensure the circuits function correctly + and includes code essential for running these circuits. + +### Understanding Circuits in zkSync + +A ZK circuit functions similarly to an arithmetic circuit, +where inputs at the bottom pass through various computational steps, +resulting in a final output at the top. +The prover's job is to demonstrate that each step of the circuit is computed correctly, satisfying the circuit with the correct outputs. + +It's crucial that each circuit step is fully constrained to prevent any incorrect computations by a malicious prover. +In Zero-Knowledge terminology, an underconstrained circuit may result in a soundness error, allowing invalid proofs to pass verification. + +![Arithmetic Circuit Diagram](/images/zk-stack/circuit.png){class="bg-white m-auto"} + +### What zkSync’s Circuits Prove + +The primary purpose of zkSync's circuits is to ensure the correct execution of the VM, covering every opcode, +storage interaction, and the integration of precompiled contracts. +These elements are crucial for the holistic functioning and security of the system. +This is described in more detail in +[Circuits](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits.md) + +### Additional Resources + +For those interested in a deeper dive into the technology behind zkSync's proof system, +resources like Vitalik Buterin's blog on [Plonk](https://vitalik.eth.limo/general/2019/09/22/plonk.html) +and the [Plonky2](https://github.com/mir-protocol/plonky2/blob/main/plonky2/plonky2.pdf) +paper provide extensive information on the arithmetization process. +More comprehensive details can also be found in the [Redshift Paper](https://eprint.iacr.org/2019/1400.pdf). + +Through these sophisticated cryptographic processes, zkSync's prover efficiently secures and verifies transactions, +leveraging the power of ZK proofs to enhance blockchain scalability and security. diff --git a/content/10.zk-stack/10.components/60.prover/20.zk-terminology.md b/content/10.zk-stack/10.components/60.prover/20.zk-terminology.md new file mode 100644 index 00000000..999f37d2 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/20.zk-terminology.md @@ -0,0 +1,77 @@ +--- +title: ZK Terminology +description: This article provides definitions for key terms used in zkSync's zero-knowledge proof systems. +--- + +## Arithmetization + +Arithmetization is a technique in zero-knowledge proof systems that converts computations into polynomial equations +for efficient verification by a prover and a verifier. + +## Builder + +The builder sets up the constraint system, determining the placement and geometry of gates and providing essential information for system construction. + +## Circuit + +An arithmetic circuit is a cryptographic tool that encodes computational problems using gates, each performing operations like addition or multiplication. + +## Constraint + +A constraint is a rule that certain operations must follow to maintain validity and support proof generation in zkSync. + +## Constraint degree + +Constraint degree refers to the highest polynomial degree present in the gates of a constraint system, with zkSync allowing up to a degree of eight. + +## Constraint system + +A constraint system is a set of polynomial constraints representing the proofs to be verified. +It is satisfied when specific values assigned to its variables make all equations true. + +## Geometry + +In zkSync's PLONK arithmetization, geometry refers to the arrangement of witness data in a grid format across defined rows and columns. +Each row defines a gate (or a few gates), and the columns are as long as needed to hold all of the witness data. zkSync uses ~164 base witness columns. + +## Log + +A log in zkSync is similar to a database log, recording a list of changes within the system. + +## Lookup table + +A lookup table maps input values to outputs, streamlining the validation of computations and relationships in zero-knowledge proofs +by providing a quick reference. + +## Proof + +A proof can either indicate the entire proving process or specifically refer to the data that the prover sends to the verifier. + +## Prover + +In zkSync, a prover processes transactions by computing proofs that validate state transitions, which are then verified by a smart contract on Ethereum. + +## Satisfiable + +A circuit or constraint system is satisfiable if a provided witness meets all set conditions and constraints. + +## State Differentials + +State Diffs show the differences in account states before and after transaction processing, indicating changes like an increase in ETH balance. + +## Variables + +Variables serve as placeholders in a constraint system, holding space for witness data that will satisfy the defined constraints. + +## Verifier + +The Verifier, a smart contract on Ethereum, checks the validity of received proofs and updates the state root accordingly. + +## Witness + +A witness is the confidential input in a cryptographic circuit, representing the knowledge the prover wishes to demonstrate without full disclosure. + +## Worker + +A worker in zkSync is part of a multi-threaded proving system that allows for parallel execution of certain cryptographic computations, +such as polynomial addition. diff --git a/content/10.zk-stack/10.components/60.prover/30.running-the-prover.md b/content/10.zk-stack/10.components/60.prover/30.running-the-prover.md new file mode 100644 index 00000000..5b9bdc69 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/30.running-the-prover.md @@ -0,0 +1,23 @@ +--- +title: Running the Prover +--- + +Our ZK code is spread across three repositories: + +[Boojum](%%zk_git_repo_era-boojum%%/tree/main) contains the low level ZK details. + +[zkevm_circuits](%%zk_git_repo_era-zkevm_circuits%%/tree/main) contains the code for the circuits. + +[zkevm_test_harness](%%zk_git_repo_era-zkevm_test_harness%%/tree/v1.4.0) contains the tests for the +circuits. + +To get started, run the `basic_test` from the `era-zkevm_test_harness`: + +```bash +rustup default nightly-2023-08-23 +cargo update +cargo test basic_test --release -- --nocapture + +``` + +This test may take several minutes to run, but you will see lots of information along the way! diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/10.overview.md b/content/10.zk-stack/10.components/60.prover/40.circuits/10.overview.md new file mode 100644 index 00000000..e0b59108 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/10.overview.md @@ -0,0 +1,124 @@ +--- +title: Overview +description: +--- + +The main circuit is called `MainVM`. It is the one where all the main logic happens. + +It consists of multiple cycles, where on each iteration we take a next opcode and try to execute it the following way: + +```rust +if opcode == Add { + // do addition +} +if opcode == SRead { + // do storage read +} +... +``` + +You may notice that `Add` instruction is much simpler than the `SRead` one. When you work with circuits you still need +to execute every opcode. + +That’s why we can use the following approach: + +```rust +if opcode == Add { + // do addition +} +if opcode == SRead { + storage_queue.push((address, value)); + // proof storage read in other circuit +} +... +``` + +So instead of proving `SRead` we just push a proving request, that will be sent to another circuit, that will prove it. +That’s how we can make our prover structure more optimized and flexible. + +For now, we have 13 base layer circuits: + +- [MainVM](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Main%20Vm.md) +- [CodeDecommitmentsSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/SortDecommitments.md) +- [CodeDecommitter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/CodeDecommitter.md) +- [LogDemuxer](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/DemuxLogQueue.md) +- [KeccakRoundFunction](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/KeccakRoundFunction.md) +- [Sha256RoundFunction](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Sha256RoundFunction.md) +- [ECRecover](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Ecrecover.md) +- [RAMPermutation](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/RAMPermutation.md) +- [StorageSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/StorageSorter.md) +- [StorageApplication](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/StorageApplication.md) +- [EventsSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/LogSorter.md) +- [L1MessagesSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/LogSorter.md) +- [L1MessagesHasher](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/L1MessagesHasher.md) + +- + +They mostly communicate by queues (the diagram of communication is below). + +## Public Input Structure + +Public Input (PI) is some piece of data, that is revealed to the verifier. Usually, it consists of some inputs and +outputs. + +The main challenge for base layer circuits is the ability to prove unlimited amount of execution. For example, our +`MainVm` circuit can handle execution of $x$ opcodes. Then, if some transaction causes execution of more than $x$ +opcodes, we won’t be able to prove it. That’s why every circuit could be extended to multiple instances. So you can +always use $n$ `MainVm` instances to handle up to $nx$ opcode executions. + +All circuits have the following PI structure: + +![Diagram of Public Inputs for Circuits](/images/zk-stack/circuit-pi-diagram.png) + +| start flag | Boolean that shows if this is the first instance of corresponding circuit type | +| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| finished flag | Boolean that shows if this is the last instance of corresponding circuit type | +| Input | Structure that contains all inputs to this type of circuit (every instance of one circuit type has the same input) | +| FSM Input and FSM Output | The field has the same structure. It represents the inner state of circuit execution (the first fsm_input is empty, the second fsm_input equals the first fsm_output and so on…) | +| Output | Structure that contains all outputs of this type of circuit (the last instance contains the real output, the output field of the others is empty) | + +The code implementation can be found +[here](https://github.com/matter-labs/era-zkevm_circuits/blob/main/src/fsm_input_output/mod.rs#L32). + +In terms of Arithmetization we don’t allocate all these fields like public input variables. A more efficient approach +would be computing commitment of type `[Num; 4]` with poseidon2 and then allocating these 4 variables as public +inputs. + +![Diagram showing computing commitments for efficient arithmetization](/images/zk-stack/circuit-commitments.png) + +The equality of corresponding parts in different circuits is done during aggregating base layer circuits. Aggregating is +done by recursion level circuits that also verify base layer proofs. For now this is out of our scope, so we will focus +only on base layer. + +## Overall View of Base Layer Circuits + +![Diagram showing how all base layer circuits fit together](/images/zk-stack/base-layer-circuit-diagram.png) + +## Base Layer Circuits + +[Main Vm](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Main%20Vm.md) + +[SortDecommitments](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/SortDecommitments.md) + +[CodeDecommitter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/CodeDecommitter.md) + +[DemuxLogQueue](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/DemuxLogQueue.md) + +[KeccakRoundFunction](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/KeccakRoundFunction.md) + +[Sha256RoundFunction](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Sha256RoundFunction.md) + +[Ecrecover](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Ecrecover.md) + +[RAMPermutation](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/RAMPermutation.md) + +[StorageSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/StorageSorter.md) + +[StorageApplication](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/StorageApplication.md) + +[LogSorter](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/LogSorter.md) + +[L1MessagesHasher](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/L1MessagesHasher.md) + +There are a couple of circuits that do queue sorting. Here is the page that describes the algorithm: +[Sorting](https://github.com/code-423n4/2023-10-zksync/blob/main/docs/Circuits%20Section/Circuits/Sorting.md) diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/100.sha256-round-function.md b/content/10.zk-stack/10.components/60.prover/40.circuits/100.sha256-round-function.md new file mode 100644 index 00000000..01d4bbf2 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/100.sha256-round-function.md @@ -0,0 +1,375 @@ +--- +title: Sha256RoundFunction +description: +--- + +## Sha256RoundFunction PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L9) + +```rust +pub struct PrecompileFunctionInputData { + pub initial_log_queue_state: QueueState, + pub initial_memory_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/base_structures/precompile_input_outputs/mod.rs#L42) + +```rust +pub struct PrecompileFunctionOutputData { + pub final_memory_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/input.rs#L59) + +```rust +pub struct Sha256RoundFunctionFSMInputOutput { + pub internal_fsm: Sha256RoundFunctionFSM, + pub log_queue_state: QueueState, + pub memory_queue_state: QueueState, +} + +pub struct Sha256RoundFunctionFSM { + pub read_precompile_call: Boolean, + pub read_words_for_round: Boolean, + pub completed: Boolean, + pub sha256_inner_state: [UInt32; 8], + pub timestamp_to_use_for_read: UInt32, + pub timestamp_to_use_for_write: UInt32, + pub precompile_call_params: Sha256PrecompileCallParams, +} +``` + +## Main circuit logic + +This is a precompile for the SHA256 hash function’s round function. + +We start from witness allocation: + +```rust +let Sha256RoundFunctionCircuitInstanceWitness { + closed_form_input, + requests_queue_witness, + memory_reads_witness, + } = witness; + +let mut structured_input = Sha256RoundFunctionCircuitInputOutput::alloc_ignoring_outputs( + cs, + closed_form_input.clone(), +); + +let start_flag = structured_input.start_flag; + +let requests_queue_state_from_input = structured_input.observable_input.initial_log_queue_state; +``` + +Check if `requests_queue_state_from_input` is trivial ( we didn't pop elements yet) and choose between input and `fsm` +queue state: + +```rust +requests_queue_state_from_input.enforce_trivial_head(cs); + +let requests_queue_state_from_fsm = structured_input.hidden_fsm_input.log_queue_state; + +let requests_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &requests_queue_state_from_input, + &requests_queue_state_from_fsm, +); +``` + +the same procedure we do for `memory_queue`: + +```rust +let memory_queue_state_from_input = + structured_input.observable_input.initial_memory_queue_state; + +// it must be trivial +memory_queue_state_from_input.enforce_trivial_head(cs); + +let memory_queue_state_from_fsm = structured_input.hidden_fsm_input.memory_queue_state; + +let memory_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &memory_queue_state_from_input, + &memory_queue_state_from_fsm, +); +``` + +Call `inner` part where is main logic: + +```rust +let final_state = sha256_precompile_inner::( + cs, + &mut memory_queue, + &mut requests_queue, + read_queries_allocator, + initial_state, + round_function, + limit, + ); +``` + +Form the final state (depending on flag we choose between states): + +```rust + + let done = final_state.completed; + structured_input.completion_flag = done; + structured_input.observable_output = PrecompileFunctionOutputData::placeholder(cs); + + structured_input.observable_output.final_memory_state = QueueState::conditionally_select( + cs, + structured_input.completion_flag, + &final_memory_state, + &structured_input.observable_output.final_memory_state, + ); + + structured_input.hidden_fsm_output.internal_fsm = final_state; + structured_input.hidden_fsm_output.log_queue_state = final_request_state; + structured_input.hidden_fsm_output.memory_queue_state = final_memory_state; +``` + +Finally, we compute a commitment to PublicInput and allocate it as witness variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); + let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); + for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); + } +``` + +### Inner part + +Start for set up different flags: `precompile_address`, `aux_byte_for_precompile`, and plugs: + +```rust +let precompile_address = UInt160::allocated_constant( + cs, + *zkevm_opcode_defs::system_params::SHA256_ROUND_FUNCTION_PRECOMPILE_FORMAL_ADDRESS, + ); +let aux_byte_for_precompile = UInt8::allocated_constant(cs, PRECOMPILE_AUX_BYTE); + +let boolean_false = Boolean::allocated_constant(cs, false); +let boolean_true = Boolean::allocated_constant(cs, true); +let zero_u32 = UInt32::zero(cs); +let zero_u256 = UInt256::zero(cs); +``` + +We can have a degenerate case when the queue is empty, but it's the first circuit in the queue, so we take default `FSM` +state that has `state.read_precompile_call = true`, we can only skip the full circuit if we are not in any form of +progress: + +```rust +let input_queue_is_empty = precompile_calls_queue.is_empty(cs); +let can_finish_immediately = + Boolean::multi_and(cs, &[state.read_precompile_call, input_queue_is_empty]); +``` + +Main work cycle: + +Check income data with constants(precompile addresses aux byte for precompile and must match): + +```rust +Num::conditionally_enforce_equal( + cs, + state.read_precompile_call, + &Num::from_variable(precompile_call.aux_byte.get_variable()), + &Num::from_variable(aux_byte_for_precompile.get_variable()), + ); +for (a, b) in precompile_call + .address + .inner + .iter() + .zip(precompile_address.inner.iter()) +{ + Num::conditionally_enforce_equal( + cs, + state.read_precompile_call, + &Num::from_variable(a.get_variable()), + &Num::from_variable(b.get_variable()), + ); +} +``` + +Create parameters that describe the call itself: + +```rust +let params_encoding = precompile_call.key; +let call_params = Sha256PrecompileCallParams::from_encoding(cs, params_encoding); + +state.precompile_call_params = Sha256PrecompileCallParams::conditionally_select( + cs, + state.read_precompile_call, + &call_params, + &state.precompile_call_params, +); +``` + +- `input_page` – memory page for `read_queue` +- `input_offset` – page index`read_queue` +- `output_page` – memory page for `write_queue` +- `output_offset` – page index`write_queue` +- `num_rounds` – number of rounds for hash function + +```rust +pub struct Sha256PrecompileCallParams { + pub input_page: UInt32, + pub input_offset: UInt32, + pub output_page: UInt32, + pub output_offset: UInt32, + pub num_rounds: UInt32, +} +``` + +Setup `timestamp:` + +```rust +state.timestamp_to_use_for_read = UInt32::conditionally_select( + cs, + state.read_precompile_call, + &precompile_call.timestamp, + &state.timestamp_to_use_for_read, + ); + +// timestamps have large space, so this can be expected +let timestamp_to_use_for_write = + unsafe { state.timestamp_to_use_for_read.increment_unchecked(cs) }; +state.timestamp_to_use_for_write = UInt32::conditionally_select( + cs, + state.read_precompile_call, + ×tamp_to_use_for_write, + &state.timestamp_to_use_for_write, +); +``` + +Reset buffer if needed: + +```rust +let reset_buffer = Boolean::multi_or(cs, &[state.read_precompile_call, state.completed]); +state.read_words_for_round = Boolean::multi_or( + cs, + &[state.read_precompile_call, state.read_words_for_round], +); +state.read_precompile_call = boolean_false; +``` + +Now perform a few memory queries to read content: + +```rust +let zero_rounds_left = state.precompile_call_params.num_rounds.is_zero(cs); + +let mut memory_queries_as_u32_words = [zero_u32; 8 * MEMORY_READ_QUERIES_PER_CYCLE]; +let should_read = zero_rounds_left.negated(cs); +let mut bias_variable = should_read.get_variable(); +for dst in memory_queries_as_u32_words.array_chunks_mut::<8>() { + let read_query_value = + memory_read_witness.conditionally_allocate_biased(cs, should_read, bias_variable); + bias_variable = read_query_value.inner[0].get_variable(); + + let read_query = MemoryQuery { + timestamp: state.timestamp_to_use_for_read, + memory_page: state.precompile_call_params.input_page, + index: state.precompile_call_params.input_offset, + rw_flag: boolean_false, + is_ptr: boolean_false, + value: read_query_value, + }; + + let may_be_new_offset = unsafe { + state + .precompile_call_params + .input_offset + .increment_unchecked(cs) + }; + state.precompile_call_params.input_offset = UInt32::conditionally_select( + cs, + state.read_words_for_round, + &may_be_new_offset, + &state.precompile_call_params.input_offset, + ); + + // perform read + memory_queue.push(cs, read_query, should_read); +``` + +We need to change endianness. Memory is BE, and each of the 4-byte chunks should be interpreted as BE u32 for sha256: + +```rust +let be_bytes = read_query_value.to_be_bytes(cs); +for (dst, src) in dst.iter_mut().zip(be_bytes.array_chunks::<4>()) { + let as_u32 = UInt32::from_be_bytes(cs, *src); + *dst = as_u32; +} +``` + +get the initial state for `SHA256`: + +```rust +let sha256_empty_internal_state = sha256::ivs_as_uint32(cs); +let mut current_sha256_state = <[UInt32; 8]>::conditionally_select( + cs, + reset_buffer, + &sha256_empty_internal_state, + &state.sha256_inner_state, + ); +``` + +finally, compute sha256 and write into memory if we completed all hash rounds. BTW `SHA256` algorithm you can read +[here](https://eips.ethereum.org/assets/eip-2680/sha256-384-512.pdf): + +```rust +let sha256_output = sha256::round_function::round_function_over_uint32( + cs, + &mut current_sha256_state, + &memory_queries_as_u32_words, +); +state.sha256_inner_state = current_sha256_state; + +let no_rounds_left = state.precompile_call_params.num_rounds.is_zero(cs); +let write_result = Boolean::multi_and(cs, &[state.read_words_for_round, no_rounds_left]); + +let mut write_word = zero_u256; +// some endianness magic +for (dst, src) in write_word + .inner + .iter_mut() + .rev() + .zip(sha256_output.array_chunks::<4>()) +{ + *dst = UInt32::from_le_bytes(cs, *src); +} + +let write_query = MemoryQuery { + timestamp: state.timestamp_to_use_for_write, + memory_page: state.precompile_call_params.output_page, + index: state.precompile_call_params.output_offset, + rw_flag: boolean_true, + is_ptr: boolean_false, + value: write_word, +}; +``` + +Update state: + +```rust +let input_is_empty = precompile_calls_queue.is_empty(cs); +let input_is_not_empty = input_is_empty.negated(cs); +let nothing_left = Boolean::multi_and(cs, &[write_result, input_is_empty]); +let process_next = Boolean::multi_and(cs, &[write_result, input_is_not_empty]); + +state.read_precompile_call = process_next; +state.completed = Boolean::multi_or(cs, &[nothing_left, state.completed]); +let t = Boolean::multi_or(cs, &[state.read_precompile_call, state.completed]); +state.read_words_for_round = t.negated(cs); +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/110.storage-application.md b/content/10.zk-stack/10.components/60.prover/40.circuits/110.storage-application.md new file mode 100644 index 00000000..f3465d4a --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/110.storage-application.md @@ -0,0 +1,222 @@ +--- +title: StorageApplication +description: +--- + +## StorageApplication PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/input.rs#L56) + +```rust +pub struct StorageApplicationInputData { + pub shard: UInt8, + pub initial_root_hash: [UInt8; 32], + pub initial_next_enumeration_counter: [UInt32; 2], + pub storage_application_log_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/input.rs#L77) + +```rust +pub struct StorageApplicationOutputData { + pub new_root_hash: [UInt8; 32], + pub new_next_enumeration_counter: [UInt32; 2], + pub state_diffs_keccak256_hash: [UInt8; 32], +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/input.rs#L29) + +```rust +pub struct StorageApplicationFSMInputOutput { + pub current_root_hash: [UInt8; 32], + pub next_enumeration_counter: [UInt32; 2], + pub current_storage_application_log_state: QueueState, + pub current_diffs_keccak_accumulator_state: + [[[UInt8; keccak256::BYTES_PER_WORD]; keccak256::LANE_WIDTH]; keccak256::LANE_WIDTH], +} +``` + +## Main circuit logic + +This circuit takes storage requests from `storage_application_log_state`. Then for each query, it verifies the read +value and updates the `root_hash` is needed. Also, it outputs the hash of storage diffs. Shard_id if enforces to be 0 +for now, because we have only one shard. + +### First part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/mod.rs#L281) + +The circuit begins with allocating input part of the PI. + +```rust +let StorageApplicationCircuitInstanceWitness { + closed_form_input, + storage_queue_witness, + merkle_paths, + leaf_indexes_for_reads, +} = witness; + +let mut structured_input = + StorageApplicationInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); +``` + +We chose what `storage_application_log_state`, `root_hash` and other fields to continue to work with. + +```rust +let mut current_root_hash = UInt8::::parallel_select( + cs, + start_flag, + &structured_input.observable_input.initial_root_hash, + &structured_input.hidden_fsm_input.current_root_hash, +); + +let storage_accesses_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &storage_queue_state_from_input, + &storage_queue_state_from_fsm, +); + +... +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/mod.rs#L393) + +Here’s the part, where all the main logic is implemented. Firstly, we take a new storage request if needed. + +```rust +let (storage_log, _) = storage_accesses_queue.pop_front(cs, parse_next_queue_elem); +``` + +Now we can parse it and do some checks. + +```rust +let LogQuery { + address, + key, + read_value, + written_value, + rw_flag, + shard_id, + .. +} = storage_log; +``` + +We need a merkle path for executing query. + +```rust +for _ in 0..STORAGE_DEPTH { + let wit = merkle_path_witness_allocator.conditionally_allocate_biased( + cs, + parse_next_queue_elem, + bias_variable, + ); + bias_variable = wit.inner[0].get_variable(); + new_merkle_path_witness.push(wit); +} +``` + +Also, we update `state_diffs` data. + +```rust +state_diff_data.address = UInt8::parallel_select( + cs, + parse_next_queue_elem, + &address_bytes, + &state_diff_data.address, +); +state_diff_data.key = + UInt8::parallel_select(cs, parse_next_queue_elem, &key_bytes, &state_diff_data.key); +state_diff_data.derived_key = UInt8::parallel_select( + cs, + parse_next_queue_elem, + &derived_key, + &state_diff_data.derived_key, +); +... +``` + +Finally, we compute a new merkle path. + +```rust +let mut current_hash = blake2s(cs, &leaf_bytes); + +for (path_bit, path_witness) in path_selectors + .into_iter() + .zip(merkle_path_witness.into_iter()) +{ + let left = UInt8::parallel_select(cs, path_bit, &path_witness, ¤t_hash); + let right = UInt8::parallel_select(cs, path_bit, ¤t_hash, &path_witness); + let mut input = [zero_u8; 64]; + input[0..32].copy_from_slice(&left); + input[32..64].copy_from_slice(&right); + + current_hash = blake2s(cs, &input); +} +``` + +If it was a write request, then we update the `root_hash`. Otherwise, we enforce that it’s still the same. + +```rust +current_root_hash = UInt8::parallel_select( + cs, + write_stage_in_progress, + ¤t_hash, + ¤t_root_hash, +); + +for (a, b) in current_root_hash.iter().zip(current_hash.iter()) { + Num::conditionally_enforce_equal( + cs, + should_compare_roots, + &Num::from_variable(a.get_variable()), + &Num::from_variable(b.get_variable()), + ); +} +``` + +In the end, we update `state_diffs` state. + +```rust +for block in + extended_state_diff_encoding.array_chunks::<{ keccak256::KECCAK_RATE_BYTES }>() +{ + keccak256_conditionally_absorb_and_run_permutation( + cs, + write_stage_in_progress, + &mut diffs_keccak_accumulator_state, + block, + ); +} +``` + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_application/mod.rs#L643) + +We need to run padding and one more permutation for final output. + +```rust +keccak256_conditionally_absorb_and_run_permutation( + cs, + boolean_true, + &mut diffs_keccak_accumulator_state, + &padding_block, +); +``` + +Now we update PI output parts and compute a commitment. Then we allocate it as public variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/10.overview.md b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/10.overview.md new file mode 100644 index 00000000..d073b9c4 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/10.overview.md @@ -0,0 +1,62 @@ +--- +title: Overview +description: +--- + +We have four circuits, that receive some queue of elements and do sorting and deduplicating: + +- [SortDecommitments](/zk-stack/components/prover/circuits/sorting/sort-decommitments) +- [StorageSorter](/zk-stack/components/prover/circuits/sorting/storage-sorter), +- [LogSorter](/zk-stack/components/prover/circuits/sorting/log-sorter) - used by EventsSorter and L1MessageSorter. + +The main scenario is the following: we have an `input_queue` of elements, that + +1. could be compared between each other, + +2. could be represented (encoded) as `[Num; N]`. + +Then we create `sorted_queue`, that contains all the elements in sorted order. + +And we create an empty `result_queue` to store the results. + +In the end, we can compute `challenges` that is `[Num, N+1]` from states of `input_queue` and `sorted_queue`. + +Then the algorithm is the following: + +```rust +let mut lhs = 1; +let mut rhs = 1; + +assert!(input_queue.len() == sorted_queue.len()); +let previous_element = input_queue.pop(); +let previous_sorted_element = sorted_queue.pop(); +loop { + previous_encoding: [Num; N] = previous_element.to_encoding(); + previous_sorted_encoding: [Num; N] = previous_sorted_element.to_encoding(); + + lhs *= previous_encoding[0] * challenges[0] + + previous_encoding[1] * challenges[1] + + ... + + challenges[N]; + + rhs *= previous_sorted_encoding[0] * challenges[0] + + previous_sorted_encoding[1] * challenges[1] + + ... + + challenges[N]; + + if input_queue.is_empty() || sorted_queue.is_empty() { + break; + } + + let next_element = input_queue.pop(); + let next_sorted_element = sorted_queue.pop(); + + assert!(next_sorted_element >= previous_sorted_element); + + previous_element = next_element; + previous_sorted_element = next_sorted_element; +} +assert!(lhs == rhs); +``` + +You can read more about permutation argument [here](https://triton-vm.org/spec/permutation-argument.html). diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/20.sort-decommitments.md b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/20.sort-decommitments.md new file mode 100644 index 00000000..4c2babd8 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/20.sort-decommitments.md @@ -0,0 +1,235 @@ +--- +title: SortDecommitments +description: +--- + +## SortDecommitments PI + +[Input](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_Decommitment_requests/input.rs#L62) + +```rust +pub struct CodeDecommitmentsDeduplicatorInputData { + pub initial_queue_state: QueueState, + pub sorted_queue_initial_state: QueueState, +} +``` + +[Output](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_Decommitment_requests/input.rs#L81) + +```rust +pub struct CodeDecommittmentsDeduplicatorOutputData { + pub final_queue_state: QueueState, +} +``` + +[FSM Input and FSM Output](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_decommittment_requests/input.rs#L26) + +```rust +pub struct CodeDecommittmentsDeduplicatorFSMInputOutput { + pub initial_queue_state: QueueState, + pub sorted_queue_state: QueueState, + pub final_queue_state: QueueState, + + pub lhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub rhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + + pub previous_packed_key: [UInt32; PACKED_KEY_LENGTH], + pub first_encountered_timestamp: UInt32, + pub previous_record: DecommitQuery, +} +``` + +## Main circuit logic + +This circuit handles the sorting and deduplication of code cancellation requests. Before starting, during the pre-start +phase, the first decommitter queue is generated. To decommitter a code, the input will receive the hash root of the code, +the length of the code, the code hash of the opcode, the number of opcodes and the code of the page. Next, it sorts the +queue and, in the process, identifies and removes identical requests, serving as a filtering mechanism in case the same +contract is called several times. + +The detailed explanation of sorting and deduplicating can be found +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +[First part](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_decommittment_requests/mod.rs#L51) + +The circuit begins with allocating input part of the PI. + +```rust +let CodeDecommitmentsDeduplicatorInstanceWitness { + closed_form_input, + initial_queue_witness, + sorted_queue_witness, +} = witness; + +let mut structured_input = CodeDecommitmentsDeduplicatorInputOutput::alloc_ignoring_outputs( + cs, + closed_form_input.clone(), +); +``` + +In this part, we should decide what `initial_queue_state` to use (the one from `Input` or the other one from +`FSM Input`). We do the same for sorted queue. + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &initial_queue_from_passthrough_state, + &initial_log_queue_state_from_fsm_state, +); +``` + +Also, we decide to create a new result queue or use one from the previous circuit. + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &empty_state, + &final_sorted_queue_from_fsm_state, +); +``` + +Now we need to generate challenges for permutation argument. + +```rust +let challenges = crate::utils::produce_fs_challenges::< + F, + CS, + R, + FULL_SPONGE_QUEUE_STATE_WIDTH, + { DECOMMIT_QUERY_PACKED_WIDTH + 1 }, + DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS, +>( + cs, + structured_input.observable_input.initial_queue_state.tail, + structured_input + .observable_input + .sorted_queue_initial_state + .tail, + round_function, +); +``` + +And decide whether we generate new accumulators for permutation argument or use existing ones. + +```rust +let initial_lhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.lhs_accumulator, +); + +let initial_rhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.rhs_accumulator, +); +``` + +Also, we make other parts of FSM state based on `start_flag`. + +```rust +let mut previous_record = DecommitQuery::conditionally_select( + cs, + structured_input.start_flag, + &trivial_record, + &structured_input.hidden_fsm_input.previous_record, +); + +let mut previous_packed_key = <[UInt32; PACKED_KEY_LENGTH]>::conditionally_select( + cs, + structured_input.start_flag, + &[zero_u32; PACKED_KEY_LENGTH], + &structured_input.hidden_fsm_input.previous_packed_key, +); + +let mut first_encountered_timestamp = UInt32::conditionally_select( + cs, + structured_input.start_flag, + &zero_u32, + &structured_input + .hidden_fsm_input + .first_encountered_timestamp, +); +``` + +[Main part](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_Decommitment_requests/mod.rs#L234) + +Here we implement the main logic of the circuit. We run a cycle where on each iteration we try to pop a new element. + +```rust +let (_, original_encoding) = original_queue.pop_front(cs, should_pop); +let (sorted_item, sorted_encoding) = sorted_queue.pop_front(cs, should_pop); +``` + +We compute contribution to permutation argument accumulators. + +```rust +for ((challenges, lhs), rhs) in fs_challenges.iter().zip(lhs.iter_mut()).zip(rhs.iter_mut()) +{ + ... +} +``` + +After, we enforce that elements from sorted queue are actually sorted. + +```rust +new_key_is_greater.conditionally_enforce_true(cs, should_pop); +``` + +Also, we need to deduplicate some decommit requests if there are the same ones. + +```rust +// decide if we should add the PREVIOUS into the queue +let add_to_the_queue = Boolean::multi_and(cs, &[previous_is_non_trivial, different_hash]); + +result_queue.push(cs, record_to_add, add_to_the_queue); +``` + +Now we update inner variables. + +```rust +previous_item_is_trivial = is_trivial; +// may be update the timestamp +*first_encountered_timestamp = UInt32::conditionally_select( + cs, + same_hash, + &first_encountered_timestamp, + &sorted_item.timestamp, +); +*previous_record = sorted_item; +*previous_packed_key = packed_key; +``` + +In the end, if the queues are empty, and we have taken the last element, we push it immediately. + +```rust +let add_to_the_queue = Boolean::multi_and(cs, &[previous_is_non_trivial, completed]); + +result_queue.push(cs, record_to_add, add_to_the_queue); +``` + +[Final part](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/sort_Decommitment_requests/mod.rs#L191C1-L191C1) + +We check that permutation accumulators are equal, if the queues are already empty. + +```rust +for (lhs, rhs) in new_lhs.iter().zip(new_rhs.iter()) { + Num::conditionally_enforce_equal(cs, completed, lhs, rhs); +} +``` + +Now we update PI output parts and compute a commitment. Then we allocate it as public variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/30.storage-sorter.md b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/30.storage-sorter.md new file mode 100644 index 00000000..3be7f648 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/30.storage-sorter.md @@ -0,0 +1,292 @@ +--- +title: StorageSorter +--- + +## StorageSorter PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/input.rs#L84C57-L84C57) + +```rust +pub struct StorageDeduplicatorInputData { + pub shard_id_to_process: UInt8, + pub unsorted_log_queue_state: QueueState, + pub intermediate_sorted_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/input.rs#L103) + +```rust +pub struct StorageDeduplicatorOutputData { + pub final_sorted_queue_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/input.rs#L37) + +```rust +pub struct StorageDeduplicatorFSMInputOutput { + pub lhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub rhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub current_unsorted_queue_state: QueueState, + pub current_intermediate_sorted_queue_state: QueueState, + pub current_final_sorted_queue_state: QueueState, + pub cycle_idx: UInt32, + pub previous_packed_key: [UInt32; PACKED_KEY_LENGTH], + pub previous_key: UInt256, + pub previous_address: UInt160, + pub previous_timestamp: UInt32, + pub this_cell_has_explicit_read_and_rollback_depth_zero: Boolean, + pub this_cell_base_value: UInt256, + pub this_cell_current_value: UInt256, + pub this_cell_current_depth: UInt32, +} +``` + +--- +## Main circuit logic + +The main logic of this circuit is sorting and deduplicating storage requests from `unsorted_log_queue_state`. The result +storage requests are pushed to `final_sorted_queue_state`. + +### First part + +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/mod.rs#L177) + +We start, as usually, with allocating input fields from PI. + +```rust +let mut structured_input = StorageDeduplicatorInputOutput::alloc_ignoring_outputs( + cs, + structured_input_witness.clone(), +); +``` + +In this part, we should decide what `unsorted_queue_state` to use (the one from `Input` or the other one from +`FSM Input`). We do the same for sorted queue. + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &unsorted_queue_from_passthrough_state, + &unsorted_queue_from_fsm_input_state, +); + +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &intermediate_sorted_queue_from_passthrough.into_state(), + &intermediate_sorted_queue_from_fsm_input.into_state(), +); +``` + +Also, we decide to create a new queue for the output, or continue working with the existing one. + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &empty_final_sorted_queue.into_state(), + &final_sorted_queue_from_fsm_input.into_state(), +); +``` + +Now we need to generate challenges for permutation argument. + +```rust +let challenges = crate::utils::produce_fs_challenges::< + F, + CS, + R, + QUEUE_STATE_WIDTH, + { TIMESTAMPED_STORAGE_LOG_ENCODING_LEN + 1 }, + DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS, +>( + cs, + structured_input + .observable_input + .unsorted_log_queue_state + .tail, + structured_input + .observable_input + .intermediate_sorted_queue_state + .tail, + round_function, +); +``` + +And decide whether we generate new accumulators for permutation argument or use existing ones. + +```rust +let initial_lhs = + <[Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS]>::conditionally_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.lhs_accumulator, + ); + +let initial_rhs = + <[Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS]>::conditionally_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.rhs_accumulator, + ); +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/mod.rs#L558) + +Here we implement the main logic of the circuit. We run a cycle where on each iteration we try to pop a new element. + +```rust +let (_, original_encoding) = original_queue.pop_front(cs, should_pop); +let (sorted_item, sorted_encoding) = intermediate_sorted_queue.pop_front(cs, should_pop); +``` + +Then we accumulate encodings for permutation argument. You can read more about it +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +```rust +for (((lhs_dst, rhs_dst), challenges), additive_part) in lhs + .iter_mut() + .zip(rhs.iter_mut()) + .zip(fs_challenges.iter()) + .zip(additive_parts.iter()) +{ + lhs_lc.clear(); + rhs_lc.clear(); + + for ((original_el, sorted_el), challenge) in extended_original_encoding + .iter() + .zip(sorted_encoding.iter()) + .zip(challenges.iter()) + { + let lhs_contribution = original_el.mul(cs, &challenge); + let rhs_contribution = sorted_el.mul(cs, &challenge); + + lhs_lc.push((lhs_contribution.get_variable(), F::ONE)); + rhs_lc.push((rhs_contribution.get_variable(), F::ONE)); + } + + lhs_lc.push((additive_part.get_variable(), F::ONE)); + rhs_lc.push((additive_part.get_variable(), F::ONE)); + + let lhs_lc = Num::linear_combination(cs, &lhs_lc); + let rhs_lc = Num::linear_combination(cs, &rhs_lc); + + let lhs_candidate = lhs_dst.mul(cs, &lhs_lc); + let rhs_candidate = rhs_dst.mul(cs, &rhs_lc); + + *lhs_dst = Num::conditionally_select(cs, should_pop, &lhs_candidate, &*lhs_dst); + *rhs_dst = Num::conditionally_select(cs, should_pop, &rhs_candidate, &*rhs_dst); +} +``` + +Now we enforce sorting. + +```rust +previous_key_is_greater.conditionally_enforce_false(cs, not_item_is_trivial); +``` + +Maybe we should push the old query if the new key is different. So we push if at least one of these conditions holds: + +- there was a read at depth 0; +- the sell is changes; +- write that was declined, but not by a rollback. + +```rust +let query = LogQuery { + address: previous_address, + key: previous_key, + read_value: this_cell_base_value, + written_value: this_cell_current_value, + rw_flag: should_write, + aux_byte: UInt8::zero(cs), + rollback: Boolean::allocated_constant(cs, false), + is_service: Boolean::allocated_constant(cs, false), + shard_id: shard_id_to_process, + tx_number_in_block: UInt32::zero(cs), + timestamp: UInt32::zero(cs), +}; + +sorted_queue.push(cs, query, should_push); +``` + +After that, we update some inner variables. + +```rust +let meaningful_value = UInt256::conditionally_select( + cs, + record.rw_flag, + &record.written_value, + &record.read_value, +); + +this_cell_base_value = UInt256::conditionally_select( + cs, + new_non_trivial_cell, + &record.read_value, + &this_cell_base_value, +); + +... +``` + +Now we continue working with current query. We check that the read field is correct. + +```rust +let read_is_equal_to_current = + UInt256::equals(cs, &this_cell_current_value, &record.read_value); +read_is_equal_to_current.conditionally_enforce_true(cs, check_read_consistency); +``` + +After that, we do some other variable updates. + +After the main cycle, we do one more iteration if we took the last query from the queue during the last cycle. + +```rust +let query = LogQuery { + address: previous_address, + key: previous_key, + read_value: this_cell_base_value, + written_value: this_cell_current_value, + rw_flag: should_write, + aux_byte: UInt8::zero(cs), + rollback: Boolean::allocated_constant(cs, false), + is_service: Boolean::allocated_constant(cs, false), + shard_id: shard_id_to_process, + tx_number_in_block: UInt32::zero(cs), + timestamp: UInt32::zero(cs), +}; + +sorted_queue.push(cs, query, should_push); +``` + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/storage_validity_by_grand_product/mod.rs#L424) + +If the queues are empty, we check the permutation argument accumulators equality. + +```rust +let completed = unsorted_is_empty.and(cs, sorted_is_empty); +new_lhs.iter().zip(new_rhs).for_each(|(l, r)| { + Num::conditionally_enforce_equal(cs, completed, &l, &r); +}); +``` + +Now we update PI output parts and compute a commitment. Then we allocate it as public variables. + +```rust +let input_commitment = + commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/40.log-sorter.md b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/40.log-sorter.md new file mode 100644 index 00000000..974c3dbb --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/40.log-sorter.md @@ -0,0 +1,354 @@ +--- +title: LogSorter +description: +--- + +`LogSorter` is one circuit that is used as both `EventsSorter` and `L1MessagesSorter`. + +## LogSorter PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L57) + +```rust +pub struct EventsDeduplicatorInputData { + pub initial_log_queue_state: QueueState, + pub intermediate_sorted_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L74) + +```rust +pub struct EventsDeduplicatorOutputData { + pub final_queue_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L28) + +```rust +pub struct EventsDeduplicatorFSMInputOutput { + pub lhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub rhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub initial_unsorted_queue_state: QueueState, + pub intermediate_sorted_queue_state: QueueState, + pub final_result_queue_state: QueueState, + pub previous_key: UInt32, + pub previous_item: LogQuery, +} +``` + +--- +## Main circuit logic + +The main logic of this circuit is sorting and deduplicating logs from `initial_log_queue_state`. The result is pushed to `final_queue_state`. + +With sorting, we get 2 queues – a simple one, and a sorted one. + +We start with the witness allocation: + +```rust +let mut structured_input = + EventsDeduplicatorInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); +``` + +Now the scheme is familiar. + +Check if we didn't take elements from the queue: + +```rust +unsorted_queue_from_passthrough_state.enforce_trivial_head(cs); +``` + +Judging by the flag, we choose a queue: + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &unsorted_queue_from_passthrough_state, + &unsorted_queue_from_fsm_input_state, + ); +``` + +Wrap the state and witnesses for it in `StorageLogQueue`, thereby preparing the input data for `inner`: + +```rust +let mut unsorted_queue = StorageLogQueue::::from_state(cs, state); + + use std::sync::Arc; + let initial_queue_witness = CircuitQueueWitness::from_inner_witness(initial_queue_witness); + unsorted_queue.witness = Arc::new(initial_queue_witness); + + let intermediate_sorted_queue_from_passthrough_state = structured_input + .observable_input + .intermediate_sorted_queue_state; +``` + +For `sorted_queue`, it is the same procedure. + +We generate challenges and accumulators for the permutation argument. A detailed explanation can be found [here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +```rust +let challenges = crate::utils::produce_fs_challenges::< + F, + CS, + R, + QUEUE_STATE_WIDTH, + { MEMORY_QUERY_PACKED_WIDTH + 1 }, + DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS, + >( + cs, + structured_input + .observable_input + .initial_log_queue_state + .tail, + structured_input + .observable_input + .intermediate_sorted_queue_state + .tail, + round_function, + ); +``` + +Again, if it is not the rest cycle (`start_flag == false`), we should choose fsm: + +```rust +let one = Num::allocated_constant(cs, F::ONE); +let initial_lhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.lhs_accumulator, +); + +let initial_rhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.rhs_accumulator, +); +``` + +Depending on the flag, we prepare all the information for `inner` part: + +```rust +let zero_u32 = UInt32::zero(cs); +let previous_key = UInt32::conditionally_select( + cs, + structured_input.start_flag, + &zero_u32, + &structured_input.hidden_fsm_input.previous_key, +); +``` + +```rust +let empty_storage = LogQuery::placeholder(cs); +let previous_item = LogQuery::conditionally_select( + cs, + structured_input.start_flag, + &empty_storage, + &structured_input.hidden_fsm_input.previous_item, +); +``` + +After `inner` part we check `unsorted_queue` and `intermediate_sorted_queue`.: + +```rust +let unsorted_is_empty = unsorted_queue.is_empty(cs); +let sorted_is_empty = intermediate_sorted_queue.is_empty(cs); + +Boolean::enforce_equal(cs, &unsorted_is_empty, &sorted_is_empty); +``` + +We check that permutation accumulators are equal and if the queues are already empty: + +```rust +let completed = unsorted_queue.length.is_zero(cs); + for (lhs, rhs) in new_lhs.iter().zip(new_rhs.iter()) { + Num::conditionally_enforce_equal(cs, completed, lhs, rhs); + } +``` + +Finally, we compute a commitment to PublicInput and allocate it as witness variables. + +```rust +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` + +### Inner part + +Note: we have specific logic for rollback. +When we have an event of some function and then that function makes a return then we should cancel this event. +Inside the VM, we create exactly the same event: same key, block number, timestamp, etc. the only change is that the rollback flag is now true. +In the inner part, first sort and look for these pairs and self-destruct them. + +There are two cases: when `unsorted_queue` is empty, but it's the only circuit, in this case. Otherwise, we continue, and then it's not trivial. + +```rust +let no_work = unsorted_queue.is_empty(cs); +let mut previous_is_trivial = Boolean::multi_or(cs, &[no_work, is_start]); +``` + +Additional checks for length. We should always check whether the sorted queue and the normal queue are of the same length. + +```rust +let unsorted_queue_length = Num::from_variable(unsorted_queue.length.get_variable()); +let intermediate_sorted_queue_length = + Num::from_variable(intermediate_sorted_queue.length.get_variable()); + +Num::enforce_equal( + cs, + &unsorted_queue_length, + &intermediate_sorted_queue_length, +); +``` + +We can pop elements if unsorted_queue is empty. +That’s why every time we set up the flags `original_is_empty`, `sorted_is_empty`. +We also ensure that items are "write" unless it's a padding. + +```rust +let original_is_empty = unsorted_queue.is_empty(cs); +let sorted_is_empty = intermediate_sorted_queue.is_empty(cs); +Boolean::enforce_equal(cs, &original_is_empty, &sorted_is_empty); + +let should_pop = original_is_empty.negated(cs); +let is_trivial = original_is_empty; + +let (_, original_encoding) = unsorted_queue.pop_front(cs, should_pop); +let (sorted_item, sorted_encoding) = intermediate_sorted_queue.pop_front(cs, should_pop); +``` + +The next block of code is sorting. You can find the main idea [here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +Check if keys are equal and check a value. +We compare timestamps and then resolve logic over rollbacks, so the only way when keys are equal can be when we do a rollback. +Ensure sorting for uniqueness timestamp and rollback flag. +We know that timestamps are unique across logs, and are also the same between write and rollback. +Keys are always ordered no matter what, and are never equal unless it's padding: + +```rust +let sorting_key = sorted_item.timestamp; +let (keys_are_equal, new_key_is_smaller) = + unpacked_long_comparison(cs, &[previous_key], &[sorting_key]); +new_key_is_smaller.conditionally_enforce_false(cs, should_pop); +``` + +There are only two cases when keys are equal: + +- it's a padding element +- it's a rollback + +It's enough to compare timestamps, as the VM circuit guarantees uniqueness if it's not a padding. Now ensure sorting: + +```rust +let previous_is_not_rollback = previous_item.rollback.negated(cs); +let enforce_sequential_rollback = Boolean::multi_and( + cs, + &[previous_is_not_rollback, sorted_item.rollback, should_pop], +); +keys_are_equal.conditionally_enforce_true(cs, enforce_sequential_rollback); + +let same_log = UInt32::equals(cs, &sorted_item.timestamp, &previous_item.timestamp); + +let values_are_equal = + UInt256::equals(cs, &sorted_item.written_value, &previous_item.written_value); + +let negate_previous_is_trivial = previous_is_trivial.negated(cs); +let should_enforce = Boolean::multi_and(cs, &[same_log, negate_previous_is_trivial]); + +values_are_equal.conditionally_enforce_true(cs, should_enforce); + +let this_item_is_non_trivial_rollback = + Boolean::multi_and(cs, &[sorted_item.rollback, should_pop]); +let negate_previous_item_rollback = previous_item.rollback.negated(cs); +let previous_item_is_non_trivial_write = Boolean::multi_and( + cs, + &[negate_previous_item_rollback, negate_previous_is_trivial], +); +let is_sequential_rollback = Boolean::multi_and( + cs, + &[ + this_item_is_non_trivial_rollback, + previous_item_is_non_trivial_write, + ], +); +same_log.conditionally_enforce_true(cs, is_sequential_rollback); +``` + +Decide if we should add the previous into the queue. We add only if the previous one is not trivial, it had a different key, and it wasn't rolled back: + +```rust +let negate_same_log = same_log.and(cs, should_pop).negated(cs); +let add_to_the_queue = Boolean::multi_and( + cs, + &[ + negate_previous_is_trivial, + negate_same_log, + negate_previous_item_rollback, + ], +); +``` + +Further, we don't need in our `LogQueue` some fields, so we just clean up: + +```rust +let boolean_false = Boolean::allocated_constant(cs, false); +let query_to_add = LogQuery { + address: previous_item.address, + key: previous_item.key, + read_value: UInt256::zero(cs), + written_value: previous_item.written_value, + rw_flag: boolean_false, + aux_byte: UInt8::zero(cs), + rollback: boolean_false, + is_service: previous_item.is_service, + shard_id: previous_item.shard_id, + tx_number_in_block: previous_item.tx_number_in_block, + timestamp: UInt32::zero(cs), +}; +``` + +Finalization step - same way, check if the last item is not a rollback: + +```rust +let now_empty = unsorted_queue.is_empty(cs); + +let negate_previous_is_trivial = previous_is_trivial.negated(cs); +let negate_previous_item_rollback = previous_item.rollback.negated(cs); +let add_to_the_queue = Boolean::multi_and( + cs, + &[ + negate_previous_is_trivial, + negate_previous_item_rollback, + now_empty, + ], +); +let boolean_false = Boolean::allocated_constant(cs, false); +let query_to_add = LogQuery { + address: previous_item.address, + key: previous_item.key, + read_value: UInt256::zero(cs), + written_value: previous_item.written_value, + rw_flag: boolean_false, + aux_byte: UInt8::zero(cs), + rollback: boolean_false, + is_service: previous_item.is_service, + shard_id: previous_item.shard_id, + tx_number_in_block: previous_item.tx_number_in_block, + timestamp: UInt32::zero(cs), +}; + +result_queue.push(cs, query_to_add, add_to_the_queue); + +unsorted_queue.enforce_consistency(cs); +intermediate_sorted_queue.enforce_consistency(cs); +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/_dir.yml b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/_dir.yml new file mode 100644 index 00000000..51af68c7 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/120.sorting/_dir.yml @@ -0,0 +1 @@ +title: Sorting and Deduplicating diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/15.circuit-testing.md b/content/10.zk-stack/10.components/60.prover/40.circuits/15.circuit-testing.md new file mode 100644 index 00000000..7567f51a --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/15.circuit-testing.md @@ -0,0 +1,64 @@ +--- +title: Circuit Testing +description: +--- + + + +This page explains unit tests for circuits. Specifically, it goes through a unit test of +[ecrecover](https://github.com/matter-labs/era-zkevm_circuits/blob/main/src/ecrecover/mod.rs#L796). The tests for other +circuits are very similar. + +Many of the tests for different circuits are nearly identical, for example: + +- test_signature_for_address_verification (ecrecover) +- test_code_unpacker_inner +- test_demultiplex_storage_logs_inner +- and several others. + +If you understand one, you will quickly be able to understand them all. + +Let’s focus on ecrecover. Ecrecover is a precompile that, given your signature, can compute your address. If our circuit +works correctly, we should be able to recover the proper address, and be able to prove the computation was done +correctly. + +![ECRecover testing](/images/zk-stack/circuit-ecrecover.png) + +The test begins by defining `geometry`, `max_variables`, and `max_trace_len`. This data will be used to create the +constraint system. Next, we define a helper function: + +![ECRecover geometry](/images/zk-stack/circuits-ecrecover-geometry.png) + +To help run the test, we have a helper function called `configure` that returns a builder. The builder knows all of the +gates and gate placement strategy, which will be useful for setting up the constraint system. + +![Code block showing usage of `configure`](/images/zk-stack/circuits-configure-builder.png) + +The constraint system is almost ready! We still need to add the lookup tables for common boolean functions: + +![Code block showing creation of lookup tables](/images/zk-stack/circuit-lookup.png) + +Now the constraint system is ready! We can start the main part of the test! + +![Code block showing signature simulation](/images/zk-stack/circuits-address.png) + +Here we have hard coded a secret key with its associated public key, and generate a signature. We will test our circuit +on these inputs! Next we “allocate” these inputs as witnesses: + +![Code block showing witness allocation](/images/zk-stack/circuit-allocate.png) + +We have to use special integer types because we are working in a finite field. + +![Code block showing integer types](/images/zk-stack/circuit-finite-fields.png) + +The constants here are specific to the curve used, and are described in detail by code comments in the +ecrecover_precompile_inner_routine. + +Finally we can call the ecrecover_precompile_inner_routine: + +![Code block showing ecrecover precompile](/images/zk-stack/circuit-ecrecover-precompile.png) + +Lastly, we need to check to make sure that 1) we recovered the correct address, and 2) the constraint system can be +satisfied, meaning the proof works. + +![Code block comparing recovered address with original](/images/zk-stack/circuit-compare-addresses.png) diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/20.code-decommitter.md b/content/10.zk-stack/10.components/60.prover/40.circuits/20.code-decommitter.md new file mode 100644 index 00000000..dec75715 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/20.code-decommitter.md @@ -0,0 +1,217 @@ +--- +title: CodeDecommitter +description: +--- + +## CodeDecommitter PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/input.rs#L80) + +```rust +pub struct CodeDecommitterInputData { + pub memory_queue_initial_state: QueueState, + pub sorted_requests_queue_initial_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/input.rs#L100) + +```rust +pub struct CodeDecommitterOutputData { + pub memory_queue_final_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/input.rs#L61) + +```rust +pub struct CodeDecommitterFSMInputOutput { + pub internal_fsm: CodeDecommittmentFSM, + pub decommittment_requests_queue_state: QueueState, + pub memory_queue_state: QueueState, +} + +pub struct CodeDecommittmentFSM { + pub sha256_inner_state: [UInt32; 8], // 8 uint32 words of internal sha256 state + pub hash_to_compare_against: UInt256, + pub current_index: UInt32, + pub current_page: UInt32, + pub timestamp: UInt32, + pub num_rounds_left: UInt16, + pub length_in_bits: UInt32, + pub state_get_from_queue: Boolean, + pub state_decommit: Boolean, + pub finished: Boolean, +} +``` + +## Main circuit logic + +This circuit takes a queue of decommit requests for DecommitSorter circuit. For each decommit request, it checks that +the linear hash of all opcodes will be equal to this hash that is stored in the decommit request. Also, it writes code +to the corresponding memory page. Briefly, it unpacks the queue from the opcode and updates the memory queue and check +correctness. + +### First part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/mod.rs#L48) + +The circuit begins with allocating input part of the PI. + +```rust +let CodeDecommitterCircuitInstanceWitness { + closed_form_input, + sorted_requests_queue_witness, + code_words, +} = witness; + +let mut structured_input = + CodeDecommitterCycleInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); +``` + +We chose what `memory_queue` state and `decommitments_queue` state to continue to work with. + +```rust +let requests_queue_state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &structured_input + .observable_input + .sorted_requests_queue_initial_state, + &structured_input + .hidden_fsm_input + .decommittment_requests_queue_state, +); + +let memory_queue_state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &structured_input.observable_input.memory_queue_initial_state, + &structured_input.hidden_fsm_input.memory_queue_state, +); +``` + +We do the same with inner FSM part. + +```rust +let initial_state = CodeDecommittmentFSM::conditionally_select( + cs, + structured_input.start_flag, + &starting_fsm_state, + &structured_input.hidden_fsm_input.internal_fsm, +); +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/mod.rs#L168) + +Here’s the part, where all the main logic is implemented. Firstly, we take a new decommit request if the queue is not +empty yet. + +```rust +let (may_be_new_request, _) = + unpack_requests_queue.pop_front(cs, state.state_get_from_queue); +``` + +Then we update the state of the circuit. + +```rust +state.num_rounds_left = UInt16::conditionally_select( + cs, + state.state_get_from_queue, + &length_in_rounds, + &state.num_rounds_left, +); +... +``` + +Then we create two write memory queries and push them to memory queue. + +```rust +let mem_query_0 = MemoryQuery { + timestamp: state.timestamp, + memory_page: state.current_page, + index: state.current_index, + rw_flag: boolean_true, + value: code_word_0, + is_ptr: boolean_false, +}; + +let mem_query_1 = MemoryQuery { + timestamp: state.timestamp, + memory_page: state.current_page, + index: state.current_index, + rw_flag: boolean_true, + value: code_word_1, + is_ptr: boolean_false, +}; + +memory_queue.push(cs, mem_query_0, state.state_decommit); +memory_queue.push(cs, mem_query_1, process_second_word); +``` + +Now we create a new input for hash to be absorbed. + +```rust +let mut sha256_input = [zero_u32; 16]; +for (dst, src) in sha256_input.iter_mut().zip( + code_word_0_be_bytes + .array_chunks::<4>() + .chain(code_word_1_be_bytes.array_chunks::<4>()), +) { + *dst = UInt32::from_be_bytes(cs, *src); +} +``` + +And absorb it to current state. + +```rust +let mut new_internal_state = state.sha256_inner_state; +round_function_over_uint32(cs, &mut new_internal_state, &sha256_input); +``` + +Also, we update current state. + +```rust +state.sha256_inner_state = <[UInt32; 8]>::conditionally_select( + cs, + state.state_decommit, + &new_internal_state, + &state.sha256_inner_state, +); +``` + +Finally, we check the hash if necessary. + +```rust +for (part_of_first, part_of_second) in hash + .inner + .iter() + .zip(state.hash_to_compare_against.inner.iter()) +{ + Num::conditionally_enforce_equal( + cs, + finalize, + &part_of_first.into_num(), + &part_of_second.into_num(), + ); +} +``` + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/code_unpacker_sha256/mod.rs#L111) + +Now we update PI output parts and compute a commitment. Then we allocate it as public variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); + +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/30.demux-log-queue.md b/content/10.zk-stack/10.components/60.prover/40.circuits/30.demux-log-queue.md new file mode 100644 index 00000000..8abd4ec0 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/30.demux-log-queue.md @@ -0,0 +1,232 @@ +--- +title: DemuxLogQueue +description: +--- + +## DemuxLogQueue PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/demux_log_queue/input.rs#L49) + +```rust +pub struct LogDemuxerInputData { + pub initial_log_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L33) + +```rust +pub struct LogDemuxerOutputData { + pub storage_access_queue_state: QueueState, + pub events_access_queue_state: QueueState, + pub l1messages_access_queue_state: QueueState, + pub keccak256_access_queue_state: QueueState, + pub sha256_access_queue_state: QueueState, + pub ecrecover_access_queue_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/demux_log_queue/input.rs#L22) + +```rust +pub struct LogDemuxerFSMInputOutput { + pub initial_log_queue_state: QueueState, + pub storage_access_queue_state: QueueState, + pub events_access_queue_state: QueueState, + pub l1messages_access_queue_state: QueueState, + pub keccak256_access_queue_state: QueueState, + pub sha256_access_queue_state: QueueState, + pub ecrecover_access_queue_state: QueueState, +} +``` + +## Main circuit logic + +The input of Log_Demuxer receives log_queue, consisting of a request to storage, events, L1messages request, and a +request to the precompiles ecrecover, sha256, and keccak256. It divides this queue into six new queues. See our diagram. + +### Start + +The function of circuits is `demultiplex_storage_logs_enty_point`. We start for allocation of queue witnesses: + +```rust +let mut structured_input = + LogDemuxerInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); +``` + +Then we must verify that no elements have already been retrieved from the queue: + +```rust +structured_input + .observable_input + .initial_log_queue_state + .enforce_trivial_head(cs); +``` + +So long as `tail` is some equivalent of the merkle tree root and `head` is an equivalent of the current node hash, we +provide some path witness when we pop elements and require that we properly end up in the root. So we must prove that +element of head is zero: + +```rust +pub fn enforce_trivial_head>(&self, cs: &mut CS) { + let zero_num = Num::zero(cs); + for el in self.head.iter() { + Num::enforce_equal(cs, el, &zero_num); + } +} +``` + +Depends on `start_flag` we select which queue `observable_input` or `fsm_input`(internal intermediate queue) we took: + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &structured_input.observable_input.initial_log_queue_state, + &structured_input.hidden_fsm_input.initial_log_queue_state, +); +``` + +Wrap the state and witnesses in `StorageLogQueue`, thereby preparing the input data for `inner` part: + +```rust +let mut initial_queue = StorageLogQueue::::from_state(cs, state); +use std::sync::Arc; +let initial_queue_witness = CircuitQueueWitness::from_inner_witness(initial_queue_witness); +initial_queue.witness = Arc::new(initial_queue_witness); +``` + +For the rest, it selects between empty or from FSM: + +```rust +let queue_states_from_fsm = [ +&structured_input.hidden_fsm_input.storage_access_queue_state, +&structured_input.hidden_fsm_input.events_access_queue_state, +&structured_input + .hidden_fsm_input + .l1messages_access_queue_state, +&structured_input + .hidden_fsm_input + .keccak256_access_queue_state, +&structured_input.hidden_fsm_input.sha256_access_queue_state, +&structured_input + .hidden_fsm_input + .ecrecover_access_queue_state, +]; + +let empty_state = QueueState::empty(cs); +let [mut storage_access_queue, mut events_access_queue, mut l1messages_access_queue, mut keccak256_access_queue, mut sha256_access_queue, mut ecrecover_access_queue] = +queue_states_from_fsm.map(|el| { +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &empty_state, + &el, + ); + StorageLogQueue::::from_state(cs, state) +}); +``` + +Prepared all queues into `input_queues` and call `inner` part: + +```rust +demultiplex_storage_logs_inner(cs, &mut initial_queue, input_queues, limit); +``` + +The last step is to form the final state. The flag `completed` shows us if `initial_queue` is empty or not. If not, we +fill fsm_output. If it is empty, we select observable_output for the different queues. + +Finally, we compute a commitment to PublicInput and allocate it as witness variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); + +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` + +### Inner part + +This is the logic part of the circuit. It depends on the main queue `storage_log_queue`, which separates the other +queues. After we have dealt with the initial precompile, we need to allocate constant addresses for +`keccak_precompile_address`, `sha256_precompile_address`, `ecrecover_precompile_address` and allocate constants for +`STORAGE_AUX_BYTE`, `EVENT_AUX_BYTE`, `L1_MESSAGE_AUX_BYTE`, `PRECOMPILE_AUX_BYTE`. Execution happens when we pop all +elements from `storage_log_queue`. We have appropriate flags for this, which depend on each other: + +```rust +let queue_is_empty = storage_log_queue.is_empty(cs); +let execute = queue_is_empty.negated(cs); +``` + +Here, we choose flags depending on the popped element data: + +```rust +let is_storage_aux_byte = UInt8::equals(cs, &aux_byte_for_storage, &popped.0.aux_byte); +let is_event_aux_byte = UInt8::equals(cs, &aux_byte_for_event, &popped.0.aux_byte); +let is_l1_message_aux_byte = + UInt8::equals(cs, &aux_byte_for_l1_message, &popped.0.aux_byte); +let is_precompile_aux_byte = + UInt8::equals(cs, &aux_byte_for_precompile_call, &popped.0.aux_byte); + +let is_keccak_address = UInt160::equals(cs, &keccak_precompile_address, &popped.0.address); +let is_sha256_address = UInt160::equals(cs, &sha256_precompile_address, &popped.0.address); +let is_ecrecover_address = + UInt160::equals(cs, &ecrecover_precompile_address, &popped.0.address); +``` + +Put up the right flag for shards: + +```rust +let is_rollup_shard = popped.0.shard_id.is_zero(cs); +let is_porter_shard = is_rollup_shard.negated(cs); +``` + +Execute all and push them into output queues: + +```rust +let execute_rollup_storage = Boolean::multi_and(cs, &[is_storage_aux_byte, is_rollup_shard, execute]); +let execute_porter_storage = Boolean::multi_and(cs, &[is_storage_aux_byte, is_porter_shard, execute]); + +let execute_event = Boolean::multi_and(cs, &[is_event_aux_byte, execute]); +let execute_l1_message = Boolean::multi_and(cs, &[is_l1_message_aux_byte, execute]); +let execute_keccak_call = Boolean::multi_and(cs, &[is_precompile_aux_byte, is_keccak_address, execute]); +let execute_sha256_call = Boolean::multi_and(cs, &[is_precompile_aux_byte, is_sha256_address, execute]); +let execute_ecrecover_call = Boolean::multi_and(cs, &[is_precompile_aux_byte, is_ecrecover_address, execute]); + +let bitmask = [ + execute_rollup_storage, + execute_event, + execute_l1_message, + execute_keccak_call, + execute_sha256_call, + execute_ecrecover_call, +]; + +push_with_optimize( + cs, + [ + rollup_storage_queue, + events_queue, + l1_messages_queue, + keccak_calls_queue, + sha256_calls_queue, + ecdsa_calls_queue, + ], + bitmask, + popped.0, +); +``` + +Note: since we do not have a porter, the flag is automatically set to `false`: + +```rust +let boolean_false = Boolean::allocated_constant(cs, false); +Boolean::enforce_equal(cs, &execute_porter_storage, &boolean_false); +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/40.ecrecover.md b/content/10.zk-stack/10.components/60.prover/40.circuits/40.ecrecover.md new file mode 100644 index 00000000..bbae2322 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/40.ecrecover.md @@ -0,0 +1,326 @@ +--- +title: ECRecover +description: +--- + +## Ecrecover PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L9) + +```rust +pub struct PrecompileFunctionInputData { + pub initial_log_queue_state: QueueState, + pub initial_memory_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/base_structures/precompile_input_outputs/mod.rs#L42) + +```rust +pub struct PrecompileFunctionOutputData { + pub final_memory_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/input.rs#L59) + +```rust +pub struct EcrecoverCircuitFSMInputOutput { + pub log_queue_state: QueueState, + pub memory_queue_state: QueueState, +} +``` + +## Main circuit logic + +This circuit implements the ecrecover precompile described in the Ethereum yellow paper: + + +The purpose of ecrecover is to recover the signer’s public key from digital signature. + +A special note about this circuit is that there are hardcoded ‘valid’ field element values provided to the circuit. This +is to prevent the circuit from not satisfying in case the user-provided inputs are incorrect and, when the circuit +detects this, the bad values are swapped out for the hardcoded ones. In this event, exceptions are logged and pushed +into a vector which are returned to the caller, informing them that the provided inputs were incorrect and the result +should be discarded. + +Most of the relevant circuit logic resides in the `ecrecover_precompile_inner_routine` function. Let’s take the circuit +step by step. + +1. The circuit starts off by declaring a set of constants which are useful to have throughout the circuit. These include + the B parameter of the secp256k1 curve, the constant -1 in the curve’s base field, and the base field and scalar + field modulus. We also create the vector that should capture any exceptions. + +```rust +let curve_b = Secp256Affine::b_coeff(); + +let mut minus_one = Secp256Fq::one(); +minus_one.negate(); + +let mut curve_b_nn = + Secp256BaseNNField::::allocated_constant(cs, curve_b, &base_field_params); +let mut minus_one_nn = + Secp256BaseNNField::::allocated_constant(cs, minus_one, &base_field_params); + +let secp_n_u256 = U256([ + scalar_field_params.modulus_u1024.as_ref().as_words()[0], + scalar_field_params.modulus_u1024.as_ref().as_words()[1], + scalar_field_params.modulus_u1024.as_ref().as_words()[2], + scalar_field_params.modulus_u1024.as_ref().as_words()[3], +]); +let secp_n_u256 = UInt256::allocated_constant(cs, secp_n_u256); + +let secp_p_u256 = U256([ + base_field_params.modulus_u1024.as_ref().as_words()[0], + base_field_params.modulus_u1024.as_ref().as_words()[1], + base_field_params.modulus_u1024.as_ref().as_words()[2], + base_field_params.modulus_u1024.as_ref().as_words()[3], +]); +let secp_p_u256 = UInt256::allocated_constant(cs, secp_p_u256); + +let mut exception_flags = ArrayVec::<_, EXCEPTION_FLAGS_ARR_LEN>::new(); +``` + +1. Next, the circuit checks whether or not the given `x` input (which is the x-coordinate of the signature) falls within + the scalar field of the curve. Since, in ecrecover, `x = r + kn`, almost any `r` will encode a unique x-coordinate, + except for when `r > scalar_field_modulus`. If this is the case, `x = r + n`, otherwise, `x = r`. `x` is recovered + here from `r`. + +```rust +let [y_is_odd, x_overflow, ..] = + Num::::from_variable(recid.get_variable()).spread_into_bits::<_, 8>(cs); + +let (r_plus_n, of) = r.overflowing_add(cs, &secp_n_u256); +let mut x_as_u256 = UInt256::conditionally_select(cs, x_overflow, &r_plus_n, &r); +let error = Boolean::multi_and(cs, &[x_overflow, of]); +exception_flags.push(error); + +// we handle x separately as it is the only element of base field of a curve (not a scalar field element!) +// check that x < q - order of base point on Secp256 curve +// if it is not actually the case - mask x to be zero +let (_res, is_in_range) = x_as_u256.overflowing_sub(cs, &secp_p_u256); +x_as_u256 = x_as_u256.mask(cs, is_in_range); +let x_is_not_in_range = is_in_range.negated(cs); +exception_flags.push(x_is_not_in_range); +``` + +1. Then, all field elements are interpreted as such within the circuit. As they are passed in, they are simply byte + arrays which are interpreted initially as `UInt256` numbers. These get converted to field elements by using the + conversion functions defined near the top of the file. Additionally, checks are done to make sure none of the passed + in field elements are zero. + +```rust +let mut x_fe = convert_uint256_to_field_element(cs, &x_as_u256, &base_field_params); + +let (mut r_fe, r_is_zero) = + convert_uint256_to_field_element_masked(cs, &r, &scalar_field_params); +exception_flags.push(r_is_zero); +let (mut s_fe, s_is_zero) = + convert_uint256_to_field_element_masked(cs, &s, &scalar_field_params); +exception_flags.push(s_is_zero); + +// NB: although it is not strictly an exception we also assume that hash is never zero as field element +let (mut message_hash_fe, message_hash_is_zero) = + convert_uint256_to_field_element_masked(cs, &message_hash, &scalar_field_params); +exception_flags.push(message_hash_is_zero); +``` + +1. Now we are going to compute `t` and check whether or not it is quadratic residue in the base field. To start, we take + `x` which we calculated before, and calculate `t` by doing `x^3 + b`, where `b` is the B parameter of the secp256k1 + curve. We check to make sure that `t` is not zero. + +```rust +let mut t = x_fe.square(cs); // x^2 +t = t.mul(cs, &mut x_fe); // x^3 +t = t.add(cs, &mut curve_b_nn); // x^3 + b + +let t_is_zero = t.is_zero(cs); +exception_flags.push(t_is_zero); +``` + +1. The Legendre symbol for `t` is computed to do a quadratic residue check. We need to compute `t^b` which corresponds + to `t^{2^255} / ( t^{2^31} * t^{2^8} * t^{2^7} * t^{2^6} * t^{2^5} * t^{2^3} * t)`. First, an array of powers of `t` + is created (up to `t^255`). Then, we multiply together all the elements in the denominator of the equation, which are + `t^{2^31} * t^{2^8} * t^{2^7} * t^{2^6} * t^{2^5} * t^{2^3} * t`. Lastly, the division is performed and we end up + with `t^b`. + +```rust +let t_is_zero = t.is_zero(cs); // We first do a zero check +exception_flags.push(t_is_zero); + +// if t is zero then just mask +let t = Selectable::conditionally_select(cs, t_is_zero, &valid_t_in_external_field, &t); + +// array of powers of t of the form t^{2^i} starting from i = 0 to 255 +let mut t_powers = Vec::with_capacity(X_POWERS_ARR_LEN); +t_powers.push(t); + +for _ in 1..X_POWERS_ARR_LEN { + let prev = t_powers.last_mut().unwrap(); + let next = prev.square(cs); + t_powers.push(next); +} + +let mut acc = t_powers[0].clone(); +for idx in [3, 5, 6, 7, 8, 31].into_iter() { + let other = &mut t_powers[idx]; + acc = acc.mul(cs, other); +} +let mut legendre_symbol = t_powers[255].div_unchecked(cs, &mut acc); +``` + +1. Before we proceed to the quadratic residue check, we take advantage of the powers we just calculated to compute the + square root of `t`, in order to determine whether the y-coordinate of the signature we’ve passed is positive or + negative. + +```rust +let mut acc_2 = t_powers[2].clone(); +for idx in [4, 5, 6, 7, 30].into_iter() { + let other = &mut t_powers[idx]; + acc_2 = acc_2.mul(cs, other); +} + +let mut may_be_recovered_y = t_powers[254].div_unchecked(cs, &mut acc_2); +may_be_recovered_y.normalize(cs); +let mut may_be_recovered_y_negated = may_be_recovered_y.negated(cs); +may_be_recovered_y_negated.normalize(cs); + +let [lowest_bit, ..] = + Num::::from_variable(may_be_recovered_y.limbs[0]).spread_into_bits::<_, 16>(cs); + +// if lowest bit != parity bit, then we need conditionally select +let should_swap = lowest_bit.xor(cs, y_is_odd); +let may_be_recovered_y = Selectable::conditionally_select( + cs, + should_swap, + &may_be_recovered_y_negated, + &may_be_recovered_y, +); +``` + +1. Then, proceed with the quadratic residue check. In case `t` is nonresidue, we swap out our inputs for the hardcoded + ‘valid’ inputs. + +```rust +let t_is_nonresidue = + Secp256BaseNNField::::equals(cs, &mut legendre_symbol, &mut minus_one_nn); +exception_flags.push(t_is_nonresidue); +// unfortunately, if t is found to be a quadratic nonresidue, we can't simply let x to be zero, +// because then t_new = 7 is again a quadratic nonresidue. So, in this case we let x to be 9, then +// t = 16 is a quadratic residue +let x = + Selectable::conditionally_select(cs, t_is_nonresidue, &valid_x_in_external_field, &x_fe); +let y = Selectable::conditionally_select( + cs, + t_is_nonresidue, + &valid_y_in_external_field, + &may_be_recovered_y, +); +``` + +1. The next step is computing the public key. We compute the public key `Q` by calculating `Q = (s * X - hash * G) / r`. + We can simplify this in-circuit by calculating `s / r` and `hash / r` separately, and then doing an MSM to get the + combined output. First, we pre-compute these divided field elements, and then compute the point like so: + +```rust +let mut r_fe_inversed = r_fe.inverse_unchecked(cs); +let mut s_by_r_inv = s_fe.mul(cs, &mut r_fe_inversed); +let mut message_hash_by_r_inv = message_hash_fe.mul(cs, &mut r_fe_inversed); + +s_by_r_inv.normalize(cs); +message_hash_by_r_inv.normalize(cs); + +let mut gen_negated = Secp256Affine::one(); +gen_negated.negate(); +let (gen_negated_x, gen_negated_y) = gen_negated.into_xy_unchecked(); +let gen_negated_x = + Secp256BaseNNField::allocated_constant(cs, gen_negated_x, base_field_params); +let gen_negated_y = + Secp256BaseNNField::allocated_constant(cs, gen_negated_y, base_field_params); + +let s_by_r_inv_normalized_lsb_bits: Vec<_> = s_by_r_inv + .limbs + .iter() + .map(|el| Num::::from_variable(*el).spread_into_bits::<_, 16>(cs)) + .flatten() + .collect(); +let message_hash_by_r_inv_lsb_bits: Vec<_> = message_hash_by_r_inv + .limbs + .iter() + .map(|el| Num::::from_variable(*el).spread_into_bits::<_, 16>(cs)) + .flatten() + .collect(); + +let mut recovered_point = (x, y); +let mut generator_point = (gen_negated_x, gen_negated_y); +// now we do multiexponentiation +let mut q_acc = + SWProjectivePoint::>::zero(cs, base_field_params); + +// we should start from MSB, double the accumulator, then conditionally add +for (cycle, (x_bit, hash_bit)) in s_by_r_inv_normalized_lsb_bits + .into_iter() + .rev() + .zip(message_hash_by_r_inv_lsb_bits.into_iter().rev()) + .enumerate() +{ + if cycle != 0 { + q_acc = q_acc.double(cs); + } + let q_plus_x = q_acc.add_mixed(cs, &mut recovered_point); + let mut q_0: SWProjectivePoint> = + Selectable::conditionally_select(cs, x_bit, &q_plus_x, &q_acc); + + let q_plux_gen = q_0.add_mixed(cs, &mut generator_point); + let q_1 = Selectable::conditionally_select(cs, hash_bit, &q_plux_gen, &q_0); + + q_acc = q_1; +} + +let ((mut q_x, mut q_y), is_infinity) = + q_acc.convert_to_affine_or_default(cs, Secp256Affine::one()); +exception_flags.push(is_infinity); +let any_exception = Boolean::multi_or(cs, &exception_flags[..]); + +q_x.normalize(cs); +q_y.normalize(cs); +``` + +1. Now that we have our public key recovered, the last thing we will need to do is take the keccak hash of the public + key and then take the first 20 bytes to recover the address. + +```rust +let zero_u8 = UInt8::zero(cs); + +let mut bytes_to_hash = [zero_u8; 64]; +let it = q_x.limbs[..16] + .iter() + .rev() + .chain(q_y.limbs[..16].iter().rev()); + +for (dst, src) in bytes_to_hash.array_chunks_mut::<2>().zip(it) { + let limb = unsafe { UInt16::from_variable_unchecked(*src) }; + *dst = limb.to_be_bytes(cs); +} + +let mut digest_bytes = keccak256(cs, &bytes_to_hash); +// digest is 32 bytes, but we need only 20 to recover address +digest_bytes[0..12].copy_from_slice(&[zero_u8; 12]); // empty out top bytes +digest_bytes.reverse(); +``` + +1. At this point, we are basically done! What’s left now is to ensure we send a masked value in case of any exception, + and then we can output the resulting address and any exceptions which occurred for the caller to handle. This wraps + up the ecrecover circuit! + +```rust +let written_value_unmasked = UInt256::from_le_bytes(cs, digest_bytes); + +let written_value = written_value_unmasked.mask_negated(cs, any_exception); +let all_ok = any_exception.negated(cs); + +(all_ok, written_value) // Return any exceptions and the resulting address value +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/50.keccak-round-function.md b/content/10.zk-stack/10.components/60.prover/40.circuits/50.keccak-round-function.md new file mode 100644 index 00000000..883ef4f7 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/50.keccak-round-function.md @@ -0,0 +1,212 @@ +--- +title: KeccakRoundFunction +description: +--- + +## KeccakRoundFunction PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L9) + +```rust +pub struct PrecompileFunctionInputData { + pub initial_log_queue_state: QueueState, + pub initial_memory_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/base_structures/precompile_input_outputs/mod.rs#L42) + +```rust +pub struct PrecompileFunctionOutputData { + pub final_memory_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/input.rs#L59) + +```rust +pub struct Keccak256RoundFunctionFSMInputOutput { + pub internal_fsm: Keccak256RoundFunctionFSM, + pub log_queue_state: QueueState, + pub memory_queue_state: QueueState, +} + +pub struct Keccak256RoundFunctionFSM { + pub read_precompile_call: Boolean, + pub read_unaligned_words_for_round: Boolean, + pub completed: Boolean, + pub keccak_internal_state: [[[UInt8; BYTES_PER_WORD]; LANE_WIDTH]; LANE_WIDTH], + pub timestamp_to_use_for_read: UInt32, + pub timestamp_to_use_for_write: UInt32, + pub precompile_call_params: Keccak256PrecompileCallParams, + pub u8_words_buffer: [UInt8; BYTES_BUFFER_SIZE], + pub u64_words_buffer_markers: [Boolean; BUFFER_SIZE_IN_U64_WORDS], +} +``` + +## Main circuit logic + +Keccak is a precompile for the keccak hash function, and is responsible for hashing any input data sent in by contract +executions. Roughly speaking, the keccak circuit will receive metadata about queued up precompile calls, and ensure that +the first-in-line call is indeed a call to the keccak precompile. The circuit then collects some metadata about the call +itself, which tells the circuit at which memory position the input can be found, and at which memory position the output +should be written, along with some peripheral data like the timestamp of the hash. + +Next, the circuit will take data from another queue, which contains memory queries. This will give the circuit witnesses +to push into the keccak buffer. + +Learn more about Keccak here: . + +### First part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/mod.rs#L423) + +The circuit begins with allocating input part of the PI. + +```rust +let Keccak256RoundFunctionCircuitInstanceWitness { + closed_form_input, + requests_queue_witness, + memory_reads_witness, +} = witness; + +let mut structured_input = Keccak256RoundFunctionCircuitInputOutput::alloc_ignoring_outputs( + cs, + closed_form_input.clone(), +); +``` + +We chose what `memory_queue` state and `log_queue` state to continue to work with. + +```rust +let requests_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &requests_queue_state_from_input, + &requests_queue_state_from_fsm, +); + +let memory_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &memory_queue_state_from_input, + &memory_queue_state_from_fsm, +); +``` + +We do the same with inner FSM part. + +```rust +let initial_state = Keccak256RoundFunctionFSM::conditionally_select( + cs, + start_flag, + &starting_fsm_state, + &structured_input.hidden_fsm_input.internal_fsm, +); +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/mod.rs#L114) + +Our main cycle starts with getting a new precompile request from the queue. + +```rust +let (precompile_call, _) = precompile_calls_queue.pop_front(cs, state.read_precompile_call); +``` + +We check that fields are correct. + +```rust +Num::conditionally_enforce_equal( + cs, + state.read_precompile_call, + &Num::from_variable(precompile_call.aux_byte.get_variable()), + &Num::from_variable(aux_byte_for_precompile.get_variable()), +); +for (a, b) in precompile_call + .address + .inner + .iter() + .zip(precompile_address.inner.iter()) +{ + Num::conditionally_enforce_equal( + cs, + state.read_precompile_call, + &Num::from_variable(a.get_variable()), + &Num::from_variable(b.get_variable()), + ); +} +``` + +Also, we prepare some additional information for the call. + +```rust +state.precompile_call_params = Keccak256PrecompileCallParams::conditionally_select( + cs, + state.read_precompile_call, + &call_params, + &state.precompile_call_params, +); +... +``` + +Then we do some memory queries to read data that needed to be hashed. + +```rust +let read_query = MemoryQuery { + timestamp: state.timestamp_to_use_for_read, + memory_page: state.precompile_call_params.input_page, + index: state.precompile_call_params.input_offset, + rw_flag: boolean_false, + is_ptr: boolean_false, + value: read_query_value, +}; + +memory_queue.push(cs, read_query, should_read); +``` + +After some another preparations, we are ready to create a full input. + +```rust +let mut input = [zero_u8; keccak256::KECCAK_RATE_BYTES]; + input.copy_from_slice(&state.u8_words_buffer[..keccak256::KECCAK_RATE_BYTES]); +``` + +And run the round function. + +```rust +let squeezed = + keccak256_absorb_and_run_permutation(cs, &mut state.keccak_internal_state, &input); +``` + +Now, if it was the last round, we can make a write memory query of the result. + +```rust +let write_query = MemoryQuery { + timestamp: state.timestamp_to_use_for_write, + memory_page: state.precompile_call_params.output_page, + index: state.precompile_call_params.output_offset, + rw_flag: boolean_true, + is_ptr: boolean_false, + value: result, +}; + +memory_queue.push(cs, write_query, write_result); +``` + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/keccak256_round_function/mod.rs#L495) + +Now we update PI output parts and compute a commitment. Then we allocate it as public variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/60.l1-messages-hasher.md b/content/10.zk-stack/10.components/60.prover/40.circuits/60.l1-messages-hasher.md new file mode 100644 index 00000000..05cb7a90 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/60.l1-messages-hasher.md @@ -0,0 +1,157 @@ +--- +title: L1MessagesHasher +description: +--- + +## L1MessagesHasher PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/input.rs#L27) + +```rust +pub struct LinearHasherInputData { + pub queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/input.rs#L42) + +```rust +pub struct LinearHasherOutputData { + pub keccak256_hash: [UInt8; 32], +} +``` + +### FSM Input and FSM Output + +```rust +() // this circuit has big capacity, so we don't need several instances +``` + +## Main circuit logic + +It takes a queue of L1 messages and hash everything with keccak. + +The main logic is implemented in `linear_hasher_entry_point` function +[here](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/mod.rs#L35). + +It can be spited into 3 parts: + +### First part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/mod.rs#L54) + +Firstly, we allocate the “input” part of PI (`start flag`, `Input` and `FSM Input`): + +```rust +let mut structured_input = + LinearHasherInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); + +let start_flag = structured_input.start_flag; +let queue_state_from_input = structured_input.observable_input.queue_state; + +let mut queue = StorageLogQueue::::from_state(cs, queue_state_from_input); +let queue_witness = CircuitQueueWitness::from_inner_witness(queue_witness); +queue.witness = Arc::new(queue_witness); +``` + +Also, we do some checks for them and allocate empty hash state: + +```rust +let keccak_accumulator_state = + [[[zero_u8; keccak256::BYTES_PER_WORD]; keccak256::LANE_WIDTH]; keccak256::LANE_WIDTH]; + +let mut keccak_accumulator_state = + keccak_accumulator_state.map(|el| el.map(|el| el.map(|el| el.get_variable()))); +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/mod.rs#L105) + +This part is the main one. We run a loop with some limit, where on each iteration we try to pop the next element from +the queue, if it’s not empty. + +```rust +let queue_is_empty = queue.is_empty(cs); +let should_pop = queue_is_empty.negated(cs); + +let (storage_log, _) = queue.pop_front(cs, should_pop); +``` + +Then we absorb it to the buffer, and if it’s full we run a round function. + +```rust +if buffer.len() >= 136 { + let buffer_for_round: [UInt8; KECCAK_RATE_BYTES] = buffer[..136].try_into().unwrap(); + let buffer_for_round = buffer_for_round.map(|el| el.get_variable()); + let carry_on = buffer[136..].to_vec(); + + buffer = carry_on; + + // absorb if we are not done yet + keccak256_conditionally_absorb_and_run_permutation( + cs, + continue_to_absorb, + &mut keccak_accumulator_state, + &buffer_for_round, + ); +} +``` + +If this element was the last one, we create a padding and run a round function. + +```rust +if tail_len == KECCAK_RATE_BYTES - 1 { + // unreachable, but we set it for completeness + last_round_buffer[tail_len] = UInt8::allocated_constant(cs, 0x81); +} else { + last_round_buffer[tail_len] = UInt8::allocated_constant(cs, 0x01); + last_round_buffer[KECCAK_RATE_BYTES - 1] = UInt8::allocated_constant(cs, 0x80); +} + +let last_round_buffer = last_round_buffer.map(|el| el.get_variable()); + +// absorb if it's the last round +keccak256_conditionally_absorb_and_run_permutation( + cs, + absorb_as_last_round, + &mut keccak_accumulator_state, + &last_round_buffer, +); +``` + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/linear_hasher/mod.rs#L169) + +Firstly, we verify that the queue is empty now. + +```rust +let completed = queue.is_empty(cs); +Boolean::enforce_equal(cs, &completed, &boolean_true); +``` + +Then we compute the final hash and create an output. + +```rust +// squeeze +let mut keccak256_hash = [MaybeUninit::>::uninit(); keccak256::KECCAK256_DIGEST_SIZE]; +for (i, dst) in keccak256_hash.array_chunks_mut::<8>().enumerate() { + for (dst, src) in dst.iter_mut().zip(keccak_accumulator_state[i][0].iter()) { + let tmp = unsafe { UInt8::from_variable_unchecked(*src) }; + dst.write(tmp); + } +} + +let mut observable_output = LinearHasherOutputData::placeholder(cs); +observable_output.keccak256_hash = keccak256_hash; +``` + +Finally, we compute a commitment to PI and allocate it as witness variables. + +```rust +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/70.log-sorter.md b/content/10.zk-stack/10.components/60.prover/40.circuits/70.log-sorter.md new file mode 100644 index 00000000..742d5203 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/70.log-sorter.md @@ -0,0 +1,357 @@ +--- +title: LogSorter +description: +--- + +`LogSorter` is one circuit that is used as both `EventsSorter` and `L1MessagesSorter`. + +## LogSorter PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L57) + +```rust +pub struct EventsDeduplicatorInputData { + pub initial_log_queue_state: QueueState, + pub intermediate_sorted_queue_state: QueueState, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L74) + +```rust +pub struct EventsDeduplicatorOutputData { + pub final_queue_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/log_sorter/input.rs#L28) + +```rust +pub struct EventsDeduplicatorFSMInputOutput { + pub lhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub rhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub initial_unsorted_queue_state: QueueState, + pub intermediate_sorted_queue_state: QueueState, + pub final_result_queue_state: QueueState, + pub previous_key: UInt32, + pub previous_item: LogQuery, +} +``` + +## Main circuit logic + +The main logic of this circuit is sorting and deduplicating logs from `initial_log_queue_state`. The result is pushed to +`final_queue_state`. + +With sorting, we get 2 queues – a simple one, and a sorted one. + +We start with the witness allocation: + +```rust +let mut structured_input = + EventsDeduplicatorInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); +``` + +Now the scheme is familiar. + +Check if we didn't take elements from the queue: + +```rust +unsorted_queue_from_passthrough_state.enforce_trivial_head(cs); +``` + +Judging by the flag, we choose a queue: + +```rust +let state = QueueState::conditionally_select( + cs, + structured_input.start_flag, + &unsorted_queue_from_passthrough_state, + &unsorted_queue_from_fsm_input_state, + ); +``` + +Wrap the state and witnesses for it in `StorageLogQueue`, thereby preparing the input data for `inner`: + +```rust +let mut unsorted_queue = StorageLogQueue::::from_state(cs, state); + + use std::sync::Arc; + let initial_queue_witness = CircuitQueueWitness::from_inner_witness(initial_queue_witness); + unsorted_queue.witness = Arc::new(initial_queue_witness); + + let intermediate_sorted_queue_from_passthrough_state = structured_input + .observable_input + .intermediate_sorted_queue_state; +``` + +For `sorted_queue`, it is the same procedure. + +We generate challenges and accumulators for the permutation argument. A detailed explanation can be found +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +```rust +let challenges = crate::utils::produce_fs_challenges::< + F, + CS, + R, + QUEUE_STATE_WIDTH, + { MEMORY_QUERY_PACKED_WIDTH + 1 }, + DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS, + >( + cs, + structured_input + .observable_input + .initial_log_queue_state + .tail, + structured_input + .observable_input + .intermediate_sorted_queue_state + .tail, + round_function, + ); +``` + +Again, if it is not the rest cycle (`start_flag == false`), we should choose fsm: + +```rust +let one = Num::allocated_constant(cs, F::ONE); +let initial_lhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.lhs_accumulator, +); + +let initial_rhs = Num::parallel_select( + cs, + structured_input.start_flag, + &[one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &structured_input.hidden_fsm_input.rhs_accumulator, +); +``` + +Depending on the flag, we prepare all the information for `inner` part: + +```rust +let zero_u32 = UInt32::zero(cs); +let previous_key = UInt32::conditionally_select( + cs, + structured_input.start_flag, + &zero_u32, + &structured_input.hidden_fsm_input.previous_key, +); +``` + +```rust +let empty_storage = LogQuery::placeholder(cs); +let previous_item = LogQuery::conditionally_select( + cs, + structured_input.start_flag, + &empty_storage, + &structured_input.hidden_fsm_input.previous_item, +); +``` + +After `inner` part we check `unsorted_queue` and `intermediate_sorted_queue`.: + +```rust +let unsorted_is_empty = unsorted_queue.is_empty(cs); +let sorted_is_empty = intermediate_sorted_queue.is_empty(cs); + +Boolean::enforce_equal(cs, &unsorted_is_empty, &sorted_is_empty); +``` + +We check that permutation accumulators are equal and if the queues are already empty: + +```rust +let completed = unsorted_queue.length.is_zero(cs); + for (lhs, rhs) in new_lhs.iter().zip(new_rhs.iter()) { + Num::conditionally_enforce_equal(cs, completed, lhs, rhs); + } +``` + +Finally, we compute a commitment to PublicInput and allocate it as witness variables. + +```rust +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` + +### Inner part + +Note: we have specific logic for rollback. When we have an event of some function and then that function makes a return +then we should cancel this event. Inside the VM, we create exactly the same event: same key, block number, timestamp, +etc. the only change is that the rollback flag is now true. In the inner part, first sort and look for these pairs and +self-destruct them. + +There are two cases: when `unsorted_queue` is empty, but it's the only circuit, in this case. Otherwise, we continue, +and then it's not trivial. + +```rust +let no_work = unsorted_queue.is_empty(cs); +let mut previous_is_trivial = Boolean::multi_or(cs, &[no_work, is_start]); +``` + +Additional checks for length. We should always check whether the sorted queue and the normal queue are of the same +length. + +```rust +let unsorted_queue_length = Num::from_variable(unsorted_queue.length.get_variable()); +let intermediate_sorted_queue_length = + Num::from_variable(intermediate_sorted_queue.length.get_variable()); + +Num::enforce_equal( + cs, + &unsorted_queue_length, + &intermediate_sorted_queue_length, +); +``` + +We can pop elements if unsorted_queue is empty. That’s why every time we set up the flags `original_is_empty`, +`sorted_is_empty`. We also ensure that items are "write" unless it's a padding. + +```rust +let original_is_empty = unsorted_queue.is_empty(cs); +let sorted_is_empty = intermediate_sorted_queue.is_empty(cs); +Boolean::enforce_equal(cs, &original_is_empty, &sorted_is_empty); + +let should_pop = original_is_empty.negated(cs); +let is_trivial = original_is_empty; + +let (_, original_encoding) = unsorted_queue.pop_front(cs, should_pop); +let (sorted_item, sorted_encoding) = intermediate_sorted_queue.pop_front(cs, should_pop); +``` + +The next block of code is sorting. You can find the main idea +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +Check if keys are equal and check a value. We compare timestamps and then resolve logic over rollbacks, so the only way +when keys are equal can be when we do a rollback. Ensure sorting for uniqueness timestamp and rollback flag. We know +that timestamps are unique across logs, and are also the same between write and rollback. Keys are always ordered no +matter what, and are never equal unless it's padding: + +```rust +let sorting_key = sorted_item.timestamp; +let (keys_are_equal, new_key_is_smaller) = + unpacked_long_comparison(cs, &[previous_key], &[sorting_key]); +new_key_is_smaller.conditionally_enforce_false(cs, should_pop); +``` + +There are only two cases when keys are equal: + +- it's a padding element +- it's a rollback + +It's enough to compare timestamps, as the VM circuit guarantees uniqueness if it's not a padding. Now ensure sorting: + +```rust +let previous_is_not_rollback = previous_item.rollback.negated(cs); +let enforce_sequential_rollback = Boolean::multi_and( + cs, + &[previous_is_not_rollback, sorted_item.rollback, should_pop], +); +keys_are_equal.conditionally_enforce_true(cs, enforce_sequential_rollback); + +let same_log = UInt32::equals(cs, &sorted_item.timestamp, &previous_item.timestamp); + +let values_are_equal = + UInt256::equals(cs, &sorted_item.written_value, &previous_item.written_value); + +let negate_previous_is_trivial = previous_is_trivial.negated(cs); +let should_enforce = Boolean::multi_and(cs, &[same_log, negate_previous_is_trivial]); + +values_are_equal.conditionally_enforce_true(cs, should_enforce); + +let this_item_is_non_trivial_rollback = + Boolean::multi_and(cs, &[sorted_item.rollback, should_pop]); +let negate_previous_item_rollback = previous_item.rollback.negated(cs); +let previous_item_is_non_trivial_write = Boolean::multi_and( + cs, + &[negate_previous_item_rollback, negate_previous_is_trivial], +); +let is_sequential_rollback = Boolean::multi_and( + cs, + &[ + this_item_is_non_trivial_rollback, + previous_item_is_non_trivial_write, + ], +); +same_log.conditionally_enforce_true(cs, is_sequential_rollback); +``` + +Decide if we should add the previous into the queue. We add only if the previous one is not trivial, it had a different +key, and it wasn't rolled back: + +```rust +let negate_same_log = same_log.and(cs, should_pop).negated(cs); +let add_to_the_queue = Boolean::multi_and( + cs, + &[ + negate_previous_is_trivial, + negate_same_log, + negate_previous_item_rollback, + ], +); +``` + +Further, we don't need in our `LogQueue` some fields, so we just clean up: + +```rust +let boolean_false = Boolean::allocated_constant(cs, false); +let query_to_add = LogQuery { + address: previous_item.address, + key: previous_item.key, + read_value: UInt256::zero(cs), + written_value: previous_item.written_value, + rw_flag: boolean_false, + aux_byte: UInt8::zero(cs), + rollback: boolean_false, + is_service: previous_item.is_service, + shard_id: previous_item.shard_id, + tx_number_in_block: previous_item.tx_number_in_block, + timestamp: UInt32::zero(cs), +}; +``` + +Finalization step - same way, check if the last item is not a rollback: + +```rust +let now_empty = unsorted_queue.is_empty(cs); + +let negate_previous_is_trivial = previous_is_trivial.negated(cs); +let negate_previous_item_rollback = previous_item.rollback.negated(cs); +let add_to_the_queue = Boolean::multi_and( + cs, + &[ + negate_previous_is_trivial, + negate_previous_item_rollback, + now_empty, + ], +); +let boolean_false = Boolean::allocated_constant(cs, false); +let query_to_add = LogQuery { + address: previous_item.address, + key: previous_item.key, + read_value: UInt256::zero(cs), + written_value: previous_item.written_value, + rw_flag: boolean_false, + aux_byte: UInt8::zero(cs), + rollback: boolean_false, + is_service: previous_item.is_service, + shard_id: previous_item.shard_id, + tx_number_in_block: previous_item.tx_number_in_block, + timestamp: UInt32::zero(cs), +}; + +result_queue.push(cs, query_to_add, add_to_the_queue); + +unsorted_queue.enforce_consistency(cs); +intermediate_sorted_queue.enforce_consistency(cs); +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/80.main-vm.md b/content/10.zk-stack/10.components/60.prover/40.circuits/80.main-vm.md new file mode 100644 index 00000000..f51fe9cd --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/80.main-vm.md @@ -0,0 +1,348 @@ +--- +title: Main VM +description: +--- + +## MainVm PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L9) + +```rust +pub struct VmInputData { + pub rollback_queue_tail_for_block: [Num; QUEUE_STATE_WIDTH], + pub memory_queue_initial_state: QueueTailState, + pub decommitment_queue_initial_state: QueueTailState, + pub per_block_context: GlobalContext, +} +``` + +### Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/fsm_input_output/circuit_inputs/main_vm.rs#L33) + +```rust +pub struct VmOutputData { + pub log_queue_final_state: QueueState, + pub memory_queue_final_state: QueueState, + pub decommitment_queue_final_state: QueueState, +} +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/base_structures/vm_state/mod.rs#L92) + +```rust +pub struct VmLocalState { + pub previous_code_word: UInt256, + pub registers: [VMRegister; REGISTERS_COUNT], + pub flags: ArithmeticFlagsPort, + pub timestamp: UInt32, + pub memory_page_counter: UInt32, + pub tx_number_in_block: UInt32, + pub previous_code_page: UInt32, + pub previous_super_pc: UInt16, + pub pending_exception: Boolean, + pub ergs_per_pubdata_byte: UInt32, + pub callstack: Callstack, + pub memory_queue_state: [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + pub memory_queue_length: UInt32, + pub code_decommittment_queue_state: [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + pub code_decommittment_queue_length: UInt32, + pub context_composite_u128: [UInt32; 4], +} +``` + +## Main circuit logic + +Main_vm – is instruction handler. VM circuit only accumulated memory queries using WITNESS provided by (presumably +honest) prover. In this sense VM is “local” - it doesn’t have access to full memory space, but only to values of +particular queries that it encountered during the execution. RAM circuit sorts all accumulated queries from VM and +ENFORCES the general RAM validity as described above. Those two actions together guarantee RAM validity, so for all the +descriptions below when we will talk about particular opcodes in VM we will use a language like “Operand number 0 is +read from the stack at the offset X” that means that even though such “memory read” technically means using a witness +provided by the prover, in practice we can assume that such witness is correct and we can view it as just normal RAM +access as one would expect to happen on the standard machine. + +We start with the allocation witnesses: + +```rust +let VmCircuitWitness { + closed_form_input, + witness_oracle, + } = witness; + + let mut structured_input = + VmCircuitInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); + + let start_flag = structured_input.start_flag; + let observable_input = structured_input.observable_input.clone(); + let hidden_fsm_input = structured_input.hidden_fsm_input.clone(); + + let VmInputData { + rollback_queue_tail_for_block, + memory_queue_initial_state, + decommitment_queue_initial_state, + per_block_context, + } = observable_input; +``` + +We also need to create the state that reflects the "initial" state for boot process: + +```rust +let bootloader_state = initial_bootloader_state( + cs, + memory_queue_initial_state.length, + memory_queue_initial_state.tail, + decommitment_queue_initial_state.length, + decommitment_queue_initial_state.tail, + rollback_queue_tail_for_block, + round_function, + ); +``` + +but depending from `start_flag` we should select between states: + +```rust +let mut state = + VmLocalState::conditionally_select(cs, start_flag, &bootloader_state, &hidden_fsm_input); + +let synchronized_oracle = SynchronizedWitnessOracle::new(witness_oracle); +``` + +Here we run the `vm_cycle` : + +```rust +for _cycle_idx in 0..limit { + state = vm_cycle( + cs, + state, + &synchronized_oracle, + &per_block_context, + round_function, + ); + } +``` + +The VM runs in cycles. For each cycle, + +1. Start in a prestate - perform all common operations for every opcode, namely deal with exceptions, resources, edge + cases like end of execution, select opcodes, compute common values. Within the zkEVM framework, numerous entities + identified as "opcodes" in the EVM paradigm are elegantly manifested as mere function calls. This modification is + rooted in the succinct observation that, from the perspective of an external caller, an inlined function (analogous + to an opcode) is inherently indistinguishable from an internal function call. + +```rust +let (draft_next_state, common_opcode_state, opcode_carry_parts) = + create_prestate(cs, current_state, witness_oracle, round_function); +``` + +1. Compute state diffs for every opcode. List of opcodes: + +```rust +pub enum Opcode { + Invalid(InvalidOpcode), + Nop(NopOpcode), + Add(AddOpcode), + Sub(SubOpcode), + Mul(MulOpcode), + Div(DivOpcode), + Jump(JumpOpcode), + Context(ContextOpcode), + Shift(ShiftOpcode), + Binop(BinopOpcode), + Ptr(PtrOpcode), + NearCall(NearCallOpcode), + Log(LogOpcode), + FarCall(FarCallOpcode), + Ret(RetOpcode), + UMA(UMAOpcode), +} +``` + +VM cycle calls such functions for different class of opcodes: nop, add_sup, jump, bind, context, ptr, log, +calls_and_ret, mul_div. + +Here we briefly mention all opcodes defined in the system. Each logical "opcode" comes with modifiers, categorized into +"exclusive" modifiers (where only one can be applied) and "flags" or "non-exclusive" modifiers (where multiple can be +activated simultaneously). The number of permissible "flags" can vary depending on the specific "exclusive" modifier +chosen. All data from opcodes we write to StateDiffsAccumulator: + +```rust +pub struct StateDiffsAccumulator { + // dst0 candidates + pub dst_0_values: Vec<(bool, Boolean, VMRegister)>, + // dst1 candidates + pub dst_1_values: Vec<(Boolean, VMRegister)>, + // flags candidates + pub flags: Vec<(Boolean, ArithmeticFlagsPort)>, + // specific register updates + pub specific_registers_updates: [Vec<(Boolean, VMRegister)>; REGISTERS_COUNT], + // zero out specific registers + pub specific_registers_zeroing: [Vec>; REGISTERS_COUNT], + // remove ptr markers on specific registers + pub remove_ptr_on_specific_registers: [Vec>; REGISTERS_COUNT], + // pending exceptions, to be resolved next cycle. Should be masked by opcode applicability already + pub pending_exceptions: Vec>, + // ergs left, PC + // new ergs left if it's not one available after decoding + pub new_ergs_left_candidates: Vec<(Boolean, UInt32)>, + // new PC in case if it's not just PC+1 + pub new_pc_candidates: Vec<(Boolean, UInt16)>, + // other meta parameters of VM + pub new_tx_number: Option<(Boolean, UInt32)>, + pub new_ergs_per_pubdata: Option<(Boolean, UInt32)>, + // memory bounds + pub new_heap_bounds: Vec<(Boolean, UInt32)>, + pub new_aux_heap_bounds: Vec<(Boolean, UInt32)>, + // u128 special register, one from context, another from call/ret + pub context_u128_candidates: Vec<(Boolean, [UInt32; 4])>, + // internal machinery + pub callstacks: Vec<(Boolean, Callstack)>, + // memory page counter + pub memory_page_counters: Option>, + // decommittment queue + pub decommitment_queue_candidates: Option<( + Boolean, + UInt32, + [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + )>, + // memory queue + pub memory_queue_candidates: Vec<( + Boolean, + UInt32, + [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + )>, + // forward piece of log queue + pub log_queue_forward_candidates: Vec<(Boolean, UInt32, [Num; QUEUE_STATE_WIDTH])>, + // rollback piece of log queue + pub log_queue_rollback_candidates: Vec<(Boolean, UInt32, [Num; QUEUE_STATE_WIDTH])>, + // sponges to run. Should not include common sponges for src/dst operands + pub sponge_candidates_to_run: Vec<( + bool, + bool, + Boolean, + ArrayVec< + ( + Boolean, + [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + [Num; FULL_SPONGE_QUEUE_STATE_WIDTH], + ), + MAX_SPONGES_PER_CYCLE, + >, + )>, + // add/sub relations to enforce + pub add_sub_relations: Vec<( + Boolean, + ArrayVec, MAX_ADD_SUB_RELATIONS_PER_CYCLE>, + )>, + // mul/div relations to enforce + pub mul_div_relations: Vec<( + Boolean, + ArrayVec, MAX_MUL_DIV_RELATIONS_PER_CYCLE>, + )>, +} +``` + +There will be no implementation details here because the code is commented step by step and is understandable. Short +description: + +Apply opcodes, for DST0 it's possible to have opcode-constrainted updates only into registers, apply +`StateDiffsAccumulator`, update the memory, update the registers, apply changes to VM state, such as ergs left, etc. +push data to queues for other circuits. If an event has rollback then create the same event data but with `rollback` +flag, enforce sponges. There are only 2 outcomes: + +- we have dst0 write (and may be src0 read), that we taken care above +- opcode itself modified memory queue, based on outcome of src0 read in parallel opcodes either +- do not use sponges and only rely on src0/dst0 +- can not have src0/dst0 in memory, but use sponges (UMA, near_call, far call, ret) + +No longer in the cyclical part `VM` we Setup different queues: + +1. Memory: + +```rust +let memory_queue_current_tail = QueueTailState { + tail: final_state.memory_queue_state, + length: final_state.memory_queue_length, + }; +let memory_queue_final_tail = QueueTailState::conditionally_select( + cs, + structured_input.completion_flag, + &memory_queue_current_tail, + &full_empty_state_large.tail, +); +``` + +1. Code decommit: + +```rust +let decommitment_queue_current_tail = QueueTailState { + tail: final_state.code_decommittment_queue_state, + length: final_state.code_decommittment_queue_length, + }; +let decommitment_queue_final_tail = QueueTailState::conditionally_select( + cs, + structured_input.completion_flag, + &decommitment_queue_current_tail, + &full_empty_state_large.tail, +); +``` + +1. Log: + +```rust +let final_log_state_tail = final_state.callstack.current_context.log_queue_forward_tail; + let final_log_state_length = final_state + .callstack + .current_context + .log_queue_forward_part_length; + +// but we CAN still check that it's potentially mergeable, basically to check that witness generation is good +for (a, b) in final_log_state_tail.iter().zip( + final_state + .callstack + .current_context + .saved_context + .reverted_queue_head + .iter(), +) { + Num::conditionally_enforce_equal(cs, structured_input.completion_flag, a, b); +} +let full_empty_state_small = QueueState::::empty(cs); + +let log_queue_current_tail = QueueTailState { + tail: final_log_state_tail, + length: final_log_state_length, +}; +let log_queue_final_tail = QueueTailState::conditionally_select( + cs, + structured_input.completion_flag, + &log_queue_current_tail, + &full_empty_state_small.tail, +); +``` + +Wrap them: + +```rust +observable_output.log_queue_final_state.tail = log_queue_final_tail; +observable_output.memory_queue_final_state.tail = memory_queue_final_tail; +observable_output.decommitment_queue_final_state.tail = decommitment_queue_final_tail; + +structured_input.observable_output = observable_output; +structured_input.hidden_fsm_output = final_state; +``` + +Finally, we compute a commitment to PublicInput and allocate it as witness variables. + +```rust +let compact_form = + ClosedFormInputCompactForm::from_full_form(cs, &structured_input, round_function); + +let input_commitment: [_; INPUT_OUTPUT_COMMITMENT_LENGTH] = + commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/90.ram-permutation.md b/content/10.zk-stack/10.components/60.prover/40.circuits/90.ram-permutation.md new file mode 100644 index 00000000..d4eb427e --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/90.ram-permutation.md @@ -0,0 +1,203 @@ +--- +title: RAMPermutation +description: +--- + +## RAMPermutation PI + +### Input +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/input.rs#L27) + +```rust +pub struct RamPermutationInputData { + pub unsorted_queue_initial_state: QueueState, + pub sorted_queue_initial_state: QueueState, + pub non_deterministic_bootloader_memory_snapshot_length: UInt32, +} +``` + +### Output + +```rust +() +``` + +### FSM Input and FSM Output +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/input.rs#L52) + +```rust +pub struct RamPermutationFSMInputOutput { + pub lhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub rhs_accumulator: [Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + pub current_unsorted_queue_state: QueueState, + pub current_sorted_queue_state: QueueState, + pub previous_sorting_key: [UInt32; RAM_SORTING_KEY_LENGTH], + pub previous_full_key: [UInt32; RAM_FULL_KEY_LENGTH], + pub previous_value: UInt256, + pub previous_is_ptr: Boolean, + pub num_nondeterministic_writes: UInt32, +} +``` + +## Main circuit logic + +The circuit starts [here](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/mod.rs#L30). +This function allocate PI inputs that call the inner function, where all the main logic is implemented. In the end, it +forms the fsm output and compute PI commitment. The main purpose of this circuit is enforcing that memory queries are +executed correctly. + +### First part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/mod.rs#L43) + +We start, as usually, with allocating input fields from PI. + +```rust +let RamPermutationCircuitInstanceWitness { + closed_form_input, + unsorted_queue_witness, + sorted_queue_witness, +} = closed_form_input_witness; + +let mut structured_input = + RamPermutationCycleInputOutput::alloc_ignoring_outputs(cs, closed_form_input.clone()); + +let start_flag = structured_input.start_flag; +let observable_input = structured_input.observable_input.clone(); +let hidden_fsm_input = structured_input.hidden_fsm_input.clone(); +``` + +Some field, like `unsorted_queue_initial_state` and `current_unsorted_queue_state` represents the same value. So we +should decide whether we take a new queue from `Input` or continue working with current one from `FSM Input`. We use +`start_flag` for such purpose. + +```rust +let unsorted_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &observable_input.unsorted_queue_initial_state, + &hidden_fsm_input.current_unsorted_queue_state, +); + +let sorted_queue_state = QueueState::conditionally_select( + cs, + start_flag, + &observable_input.sorted_queue_initial_state, + &hidden_fsm_input.current_sorted_queue_state, +); +``` + +Also, we generate challenges and accumulators for permutation argument. The detailed explanation can be found +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +```rust +let fs_challenges = crate::utils::produce_fs_challenges( + cs, + observable_input.unsorted_queue_initial_state.tail, + observable_input.sorted_queue_initial_state.tail, + round_function, +); + +let mut lhs = <[Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS]>::conditionally_select( + cs, + start_flag, + &[num_one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &hidden_fsm_input.lhs_accumulator, +); +let mut rhs = <[Num; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS]>::conditionally_select( + cs, + start_flag, + &[num_one; DEFAULT_NUM_PERMUTATION_ARGUMENT_REPETITIONS], + &hidden_fsm_input.rhs_accumulator, +); +``` + +### Main part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/mod.rs#L211) + +We call the inner function, where the main logic is implemented. + +Firstly, we check non-deterministic writes. These should be in the beginning of `sorted_queue`. We also count the number +of such writes. + +```rust +let is_nondeterministic_write = Boolean::multi_and( + cs, + &[ + can_pop, + ts_is_zero, + page_is_bootloader_heap, + is_write, + not_ptr, + ], +); + +*num_nondeterministic_writes = UInt32::conditionally_select( + cs, + is_nondeterministic_write, + &num_nondeterministic_writes_incremented, + &num_nondeterministic_writes, +); +``` + +For every new memory query from `sorted_queue` we enforce sorting by (`memory_page`, `index` and `timestamp`). + +```rust +let sorting_key = [ + sorted_item.timestamp, + sorted_item.index, + sorted_item.memory_page, + ]; + +let (_keys_are_equal, previous_key_is_smaller) = + unpacked_long_comparison(cs, &sorting_key, previous_sorting_key); +``` + +Then, if the query is read one, we have two cases: + +- should enforce that the value is the same as in the previous value, if it has the same `memory_page` and `index` +- should enforce that the value is zero otherwise + +```rust +let value_equal = UInt256::equals(cs, &sorted_item.value, &previous_element_value); +let value_is_zero = UInt256::equals(cs, &sorted_item.value, &uint256_zero); +``` + +In the end, we compute permutation argument contributions to accumulators. The code is +[here](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/mod.rs#L363). The detailed +explanation can be found +[here](https://github.com/code-423n4/2023-10-zksync/blob/c3ff020df5d11fe91209bd99d7fb0ec1272dc387/docs/Circuits%20Section/Circuits/Sorting.md). + +### Final part +[GitHub](%%zk_git_repo_era-zkevm_circuits%%/blob/main/src/ram_permutation/mod.rs#L159) + +If the queues are empty now, that means that this instance should be the last one. + +```rust +let completed = unsorted_queue.length.is_zero(cs); +``` + +If so, we should check that permutation argument accumulators are equal and number of nondeterministic writes is +correct. + +```rust +for (lhs, rhs) in lhs.iter().zip(rhs.iter()) { + Num::conditionally_enforce_equal(cs, completed, lhs, rhs); +} + +let num_nondeterministic_writes_equal = UInt32::equals( + cs, + &num_nondeterministic_writes, + &observable_input.non_deterministic_bootloader_memory_snapshot_length, +); +num_nondeterministic_writes_equal.conditionally_enforce_true(cs, completed); +``` + +Finally, we form the output part of PI and compute a commitment to PI and allocate it as witness variables. + +```rust +let input_commitment = commit_variable_length_encodable_item(cs, &compact_form, round_function); +for el in input_commitment.iter() { + let gate = PublicInputGate::new(el.get_variable()); + gate.add_to_cs(cs); +} +``` diff --git a/content/10.zk-stack/10.components/60.prover/40.circuits/_dir.yml b/content/10.zk-stack/10.components/60.prover/40.circuits/_dir.yml new file mode 100644 index 00000000..6ea460e7 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/40.circuits/_dir.yml @@ -0,0 +1 @@ +title: Circuits diff --git a/content/10.zk-stack/10.components/60.prover/50.boojum-gadgets.md b/content/10.zk-stack/10.components/60.prover/50.boojum-gadgets.md new file mode 100644 index 00000000..214d155f --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/50.boojum-gadgets.md @@ -0,0 +1,196 @@ +--- +title: Boojum Gadgets +description: +--- + +Gadgets in ZK programming are common arrangement of circuits abstracted for ease of use. +Boojum gadgets are low-level implementations of tools for constraint systems. +They consist of various types such as curves, +hash functions, lookup tables, and different circuit types. + +These gadgets are mostly a reference from +[franklin-crypto](%%zk_git_repo_franklin-crypto%%), with additional hash functions added. These gadgets +have been changed to use the Goldilocks field (order 2^64 - 2^32 + 1), which is much smaller than bn256. This allows us +to reduce the proof system. + +## Circuits types + +We have next types with we use for circuits: + +**Num (Number):** + +```rust +pub struct Num { + pub(crate) variable: Variable, + pub(crate) _marker: std::marker::PhantomData, +} +``` + +**Boolean:** + +```rust +pub struct Boolean { + pub(crate) variable: Variable, + pub(crate) _marker: std::marker::PhantomData, +} +``` + +**U8:** + +```rust +pub struct UInt8 { + pub(crate) variable: Variable, + pub(crate) _marker: std::marker::PhantomData, +} +``` + +**U16:** + +```rust +pub struct UInt16 { + pub(crate) variable: Variable, + pub(crate) _marker: std::marker::PhantomData, +} +``` + +**U32:** + +```rust +pub struct UInt32 { + pub(crate) variable: Variable, + pub(crate) _marker: std::marker::PhantomData, +} +``` + +**U160:** + +```rust +pub struct UInt160 { + pub inner: [UInt32; 5], +} +``` + +**U256:** + +```rust +pub struct UInt256 { + pub inner: [UInt32; 8], +} +``` + +**U512:** + +```rust +pub struct UInt512 { + pub inner: [UInt32; 16], +} +``` + +Every type consists of a Variable (the number inside Variable is just the index): + +```rust +pub struct Variable(pub(crate) u64); +``` + +which is represented in the current Field. Variable is quite diverse. To have "good" alignment and size we manually +do encoding management to be able to represent it as both a variable (that can be copied) or witness. + +The implementation of this circuit type itself is similar. We can also divide them into classes as main and dependent: +Such type like U8-U512 decoding inside functions to Num<F> for using them in logical operations. As mentioned above, the +property of these types is to perform logical operations and allocate witnesses. + +Let's demonstrate this in a Boolean example: + +```rust +impl CSAllocatable for Boolean { + type Witness = bool; + fn placeholder_witness() -> Self::Witness { + false + } + + #[inline(always)] + fn allocate_without_value>(cs: &mut CS) -> Self { + let var = cs.alloc_variable_without_value(); + + Self::from_variable_checked(cs, var) + } + + fn allocate>(cs: &mut CS, witness: Self::Witness) -> Self { + let var = cs.alloc_single_variable_from_witness(F::from_u64_unchecked(witness as u64)); + + Self::from_variable_checked(cs, var) + } +} +``` + +As you see, you can allocate both with and without witnesses. + +## Hash function + +In gadgets we have a lot of hast implementation: + +- blake2s +- keccak256 +- poseidon/poseidon2 +- sha256 + +Each of them perform different functions in our proof system. + +## Queues + +One of the most important gadgets in our system is queue. It helps us to send data between circuits. Here is the quick +explanation how it works: + +```rust +Struct CircuitQueue{ + head: HashState, + tail: HashState, + length: UInt32, + witness: VecDeque, +} +``` + +The structure consists of `head` and `tail` commitments that basically are rolling hashes. Also, it has a `length` of +the queue. These three fields are allocated inside the constraint system. Also, there is a `witness`, that keeps actual +values that are now stored in the queue. + +And here is the main functions: + +```rust +fn push(&mut self, value: Element) { + // increment length + // head - hash(head, value) + // witness.push_back(value.witness) +} + +fn pop(&mut self) -> Element { + // check length > 0 + // decrement length + // value = witness.pop_front() + // tail = hash(tail, value) + // return value +} + +fn final_check(&self) -> Element { + // check that length == 0 + // check that head == tail +} +``` + +So the key point, of how the queue proofs that popped elements are the same as pushed ones, is equality of rolling +hashes that stored in fields `head` and `tail`. + +Also, we check that we can’t pop an element before it was pushed. This is done by checking that `length >= 0`. + +Very important is making the `final_check` that basically checks the equality of two hashes. So if the queue is never +empty, and we haven’t checked the equality of `head` and `tail` in the end, we also haven’t proven that the elements we +popped are correct. + +For now, we use poseidon2 hash. Here is the link to queue implementations: + +- [CircuitQueue](%%zk_git_repo_era-boojum%%/blob/main/src/gadgets/queue/mod.rs#L29) +- [FullStateCircuitQueue](%%zk_git_repo_era-boojum%%/blob/main/src/gadgets/queue/full_state_queue.rs#L20C12-L20C33) + +The difference is that we actually compute and store a hash inside CircuitQueue during `push` and `pop` operations. But +in FullStateCircuitQueue our `head` and `tail` are just states of sponges. So instead of computing a full hash, we just +absorb a pushed (popped) element. diff --git a/content/10.zk-stack/10.components/60.prover/60.boojum-function-check-if-satisfied.md b/content/10.zk-stack/10.components/60.prover/60.boojum-function-check-if-satisfied.md new file mode 100644 index 00000000..857fa954 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/60.boojum-function-check-if-satisfied.md @@ -0,0 +1,100 @@ +--- +title: Boojum Function - `check_if_satisfied` +description: +--- + +_Note: Please read our other documentation and tests first before reading this page._ + +Our circuits (and tests) depend on a function from Boojum called +[`check_if_satisfied`](%%zk_git_repo_era-boojum%%/blob/main/src/cs/implementations/satisfiability_test.rs#L11). +You don’t need to understand it to run circuit tests, but it can be informative to learn more about Boojum and our proof +system. + +First we prepare the constants, variables, and witness. As a reminder, the constants are just constant numbers, the +variables circuit columns that are under PLONK copy-permutation constraints (so they are close in semantics to variables +in programming languages), and the witness ephemeral values that can be used to prove certain constraints, for example +by providing an inverse if the variable must be non-zero. + +![Check_if_satisfied.png](/images/zk-stack/Check_if_satisfied.png) + +Next we prepare a view. Instead of working with all of the columns at once, it can be helpful to work with only a +subset. + +![Check_if_satisfied(1).png](/images/zk-stack/Check_if_satisfied-1.png) + +Next we create the paths_mappings. For each gate in the circuit, we create a vector of booleans in the correct shape. +Later, when we traverse the gates with actual inputs, we’ll be able to remember which gates should be satisfied at +particular rows by computing the corresponding selector using constant columns and the paths_mappings. + +![Check_if_satisfied(2).png](/images/zk-stack/Check_if_satisfied-2.png) + +Now, we have to actually check everything. The checks for the rows depend on whether they are under general purpose +columns, or under special purpose columns. + +**General purpose rows:** + +For each row and gate, we need several things. + +- Evaluator for the gate, to compute the result of the gate +- Path for the gate from the paths_mappings, to locate the gate +- Constants_placement_offset, to find the constants +- Num_terms in the evaluator + - If this is zero, we can skip the row since there is nothing to do +- Gate_debug_name +- num_constants_used +- this_view +- placement (described below) +- evaluation function + +![Check_if_satisfied(3).png](/images/zk-stack/Check_if_satisfied-3.png) + +Placement is either UniqueOnRow or MultipleOnRow. UniqueOnRow means there is only one gate on the row (typically because +the gate is larger / more complicated). MultipleOnRow means there are multiple gates within the same row (typically +because the gate is smaller). For example, if a gate only needs 30 columns, but we have 150 columns, we could include +five copies for that gate in the same row. + +Next, if the placement is UniqueOnRow, we call evaluate_over_general_purpose_columns. All of the evaluations should be +equal to zero, or we panic. + +![Check_if_satisfied(4).png](/images/zk-stack/Check_if_satisfied-4.png) + +If the placement is MultipleOnRow, we again call evaluate_over_general_purpose_columns. If any of the evaluations are +non-zero, we log some extra debug information, and then panic. + +![Check_if_satisfied(7).png](/images/zk-stack/Check_if_satisfied-7.png) + +This concludes evaluating and checking the generalized rows. Now we will check the specialized rows. + +![Check_if_satisfied(8).png](/images/zk-stack/Check_if_satisfied-8.png) + +We start by initializing vectors for specialized_placement_data, evaluation_functions, views, and evaluator_names. Then, +we iterate over each gate_type_id and evaluator. + +![Check_if_satisfied(9).png](/images/zk-stack/Check_if_satisfied-9.png) + +If gate_type_id is a LookupFormalGate, we don’t need to do anything in this loop because it is handled by the lookup +table. For all other cases, we need to check the evaluator’s total_quotient_terms_over_all_repetitions is non-zero. + +![Check_if_satisfied(11).png](/images/zk-stack/Check_if_satisfied-11.png) + +Next, we get num_terms, num_repetitions, and share_constants, total_terms, initial_offset, per_repetition_offset, and +total_constants_available. All of these together form our placement data. + +![Check_if_satisfied(12).png](/images/zk-stack/Check_if_satisfied-12.png) + +![Check_if_satisfied(13).png](/images/zk-stack/Check_if_satisfied-13.png) + +Once we know the placement_data, we can keep it for later, as well as the evaluator for this gate. + +![Check_if_satisfied(14).png](/images/zk-stack/Check_if_satisfied-14.png) + +We also will keep the view and evaluator name. This is all the data we need from our specialized columns. + +To complete the satisfaction test on the special columns, we just need to loop through and check that each of the +evaluations are zero. + +![Check_if_satisfied(16).png](/images/zk-stack/Check_if_satisfied-16.png) + +![Check_if_satisfied(17).png](/images/zk-stack/Check_if_satisfied-17.png) + +Now we have checked every value on every row, so the satisfaction test is passed, and we can return true. diff --git a/content/10.zk-stack/10.components/60.prover/_dir.yml b/content/10.zk-stack/10.components/60.prover/_dir.yml new file mode 100644 index 00000000..771aa598 --- /dev/null +++ b/content/10.zk-stack/10.components/60.prover/_dir.yml @@ -0,0 +1 @@ +title: Prover diff --git a/content/10.zk-stack/10.components/70.compiler/10.toolchain/10.overview.md b/content/10.zk-stack/10.components/70.compiler/10.toolchain/10.overview.md new file mode 100644 index 00000000..397245c5 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/10.toolchain/10.overview.md @@ -0,0 +1,85 @@ +--- +title: Compiler Toolchain Overview +description: +--- + +This section introduces the zkEVM LLVM-based compiler toolchain for smart contract languages with Ethereum Virtual Machine (EVM) support. +The toolchain works on top of existing compilers and requires their output, which typically includes intermediate representations (IRs), +abstract syntax trees (ASTs), and auxiliary contract metadata and documentation. + +::callout{icon="i-heroicons-information-circle" color="blue"} +At the time of writing, we support Solidity and Vyper. +:: + +The toolchain consists of the following: + +1. [High-level source code compilers](#high-level-source-code-compilers): `solc` and `vyper`. +2. [IR compilers, front ends to LLVM](#ir-compilers): `zksolc` and `zkvyper`. +3. [The LLVM framework](/zk-stack/components/compiler/toolchain/llvm) with a zkEVM back end which emits zkEVM text assembly. +4. [The assembler](#assembler) which produces the zkEVM bytecode from text assembly. +5. [Hardhat plugins](#hardhat-plugins) which set up the environment. + +![Compiler Toolchain Visualization](/images/zk-stack/compiler-toolchain.png "Compiler Toolchain") + +## High-level Source Code Compilers + +High-level source code is processed by third-party compilers. These compilers do the following: + +1. Process and validate the high-level source code. +2. Translate the source code into IR and metadata. +3. Pass the IR and metadata to our IR compilers via the standard I/O streams. + +We are using two high-level source code compilers at the time of writing: + +- [solc](https://github.com/ethereum/solc-bin): the official Solidity compiler. For more info, see the latest [Solidity documentation](https://docs.soliditylang.org/en/latest/). +- [vyper](https://github.com/vyperlang/vyper/releases): the official Vyper compiler. For more info, see the latest [Vyper documentation](https://docs.vyperlang.org/en/latest/index.html). + + + + + + + + +## IR Compilers + +Our toolchain includes LLVM front ends, written in Rust, that process the output of high-level source code compilers: + +- [zksolc](%%zk_git_repo_zksolc-bin%%) which calls `solc` as a child process. For more info, see the latest [zksolc documentation](/zk-stack/components/compiler/toolchain/solidity). +- [zkvyper](%%zk_git_repo_zkvyper-bin%%): which calls `vyper` as a child process. For more info, see the latest [zkvyper documentation](/zk-stack/components/compiler/toolchain/vyper). + +These IR compilers perform the following steps: + +1. Receive the input, which is usually standard or combined JSON passed by the Hardhat plugin via standard input. +2. Save the relevant data, modify the input with zkEVM settings, and pass it to the underlying high-level source code compiler +which is called as a child process. +3. Receive the IR and metadata from the underlying compiler. +4. Translate the IR into LLVM IR, resolving dependencies with the help of metadata. +5. Optimize the LLVM IR with the powerful LLVM framework optimizer and emit zkEVM text assembly. +6. Print the output matching the format of the input method the IR compiler is called with. + +Our IR compilers leverage I/O mechanisms which already exist in the high-level source code +compilers. They may modify the input and output to some extent, add data for features unique to zkEVM, +and remove unsupported feature artifacts. + +## Assembler + +The [assembler](%%zk_git_repo_era-zkEVM-assembly%%), which is written in Rust, compiles zkEVM assembly +to zkEVM bytecode. This tool is not a part of our LLVM back end as it uses several cryptographic libraries which are +easier to maintain outside of the framework. + +## Hardhat Plugins + +We recommend using our IR compilers via [their corresponding Hardhat plugins](/build/tooling/hardhat/getting-started). +Add these plugins to the Hardhat's config file to compile new projects or migrate +existing ones to zkSync Era. For a lower-level approach, download our compiler binaries via the +links above and use their CLI interfaces. + +### Installing and configuring plugins + +Add the plugins below to the Hardhat's config file to compile new projects or migrate +existing ones to zkSync Era. For a lower-level approach, download our compiler binaries +[links above](#ir-compilers) and use their CLI interfaces. + +- [hardhat-zksync-solc documentation](/build/tooling/hardhat/hardhat-zksync-solc) +- [hardhat-zksync-vyper documentation](/build/tooling/hardhat/hardhat-zksync-vyper) diff --git a/content/10.zk-stack/10.components/70.compiler/10.toolchain/20.solidity.md b/content/10.zk-stack/10.components/70.compiler/10.toolchain/20.solidity.md new file mode 100644 index 00000000..667cb001 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/10.toolchain/20.solidity.md @@ -0,0 +1,125 @@ +--- +head: + - - meta + - name: "twitter:title" + content: Solidity Compiler | zkSync Docs +--- + +# Solidity + +The compiler we provide as a part of our toolchain is called [zksolc](%%zk_git_repo_zksolc-bin%%). It +operates on IR and metadata received from the underlying [solc](https://docs.soliditylang.org/en/latest/) compiler, +which must be available in `$PATH`, or its path must be explicitly passed via the CLI (command-line interface). + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +To safeguard the security and efficiency of your application, always use the latest compiler version. +:: + +## Usage + +Make sure your machine satisfies the [system requirements](%%zk_git_repo_era-compiler-solidity%%/tree/main#system-requirements). + +Using our compiler via the Hardhat plugin usually suffices. However, knowledge of its interface and I/O (input/output) +methods are crucial for integration, debugging, or contribution purposes. + +The CLI supports several I/O modes: + +1. Standard JSON. +2. Combined JSON. +3. Free-form output. + +All three modes use the standard JSON `solc` interface internally. This reduces the complexity of the `zksolc` +interface and facilitates testing. + +### Standard JSON + +The `zksolc` standard JSON I/O workflow closely follows that of the official `solc` compiler. However, `zksolc` does not +support some configuration settings which are only relevant to the EVM architecture. + +Additional zkEVM data is supported by `zksolc` but is omitted when passed to `solc`: + +- `settings/optimizer/mode`: sets the optimization mode. Available values: `0`, `1`, `2`, `3`, `s`, `z`. The default + setting is `3`. See [LLVM optimizer](llvm#optimizer). +- `settings/optimizer/fallback_to_optimizing_for_size`: tries to compile again in `z` mode if the bytecode is too large for zkEVM. +- `settings/optimizer/disable_system_request_memoization`: disables the memoization of data received in requests to System Contracts. + +Unsupported sections of the input JSON, ignored by `zksolc`: + +- `sources//urls` +- `sources/destructible` +- `settings/stopAfter` +- `settings/evmVersion` +- `settings/debug` +- `settings/metadata`: for zkEVM you can only append `keccak256` metadata hash to the bytecode. +- `settings/modelChecker` + +Additional zkEVM data inserted by `zksolc`: + +- `long_version`: the full `solc` version output. +- `zk_version`: the `zksolc` version. +- `contract/hash`: the hash of the zkEVM bytecode. +- `contract/factory_dependencies`: bytecode hashes of contracts created in the current contract with `CREATE`. + + + +Unsupported sections of the output JSON, ignored by `zksolc`: + +- `contracts///evm/bytecode`: replaced with a JSON object with zkEVM build data. +- `contracts///ewasm` + +See the complete standard JSON data structures in [the zksolc repository](%%zk_git_repo_era-compiler-solidity%%/tree/main/src/solc/standard_json). + +### Combined JSON + +The `zksolc` standard JSON I/O workflow closely follows that of the official `solc` compiler. However, `zksolc` does not +support some configuration settings which are only relevant to the EVM architecture. + +Combined JSON is only an output format; there is no combined JSON input format. Instead, CLI arguments are +used for configuration. + +Additional zkEVM data, inserted by `zksolc`: + +- `zk_version`: the version of `zksolc`. +- `contract/factory_deps`: bytecode hashes of contracts created by the current contract with `CREATE`. + + + +Unsupported combined JSON flags, rejected by `zksolc`: + +- `function-debug` +- `function-debug-runtime` +- `generated-sources` +- `generated-sources-runtime` +- `opcodes` +- `srcmap` +- `srcmap-runtime` + +For more information, see the complete combined JSON data structures in [the zksolc repository](%%zk_git_repo_era-compiler-solidity%%/tree/main/src/solc/combined_json). + +### Free-form output + +This output format is utilized in Yul and LLVM IR compilation modes. These modes currently only support compiling a single +file. Only `--asm` and `--bin` output flags are supported, so this mode can be useful for debugging and prototyping. + +## Limitations + +Currently, Solidity versions as old as `0.4.12` are supported, although **we strongly recommend using** the latest +supported revision of `0.8`, as older versions contain known bugs and have limitations dictated by the absence of IR with +sufficient level of abstraction over EVM. + +Projects written in Solidity `>=0.8` are compiled by default through the Yul pipeline, whereas those written in `<=0.7` are compiled +via EVM legacy assembly which is a less friendly IR due to its obfuscation of control-flow and call graphs. +Due to this obfuscation, there are several limitations in zkSync for contracts written in Solidity `<=0.7`: + +1. Recursion on the stack is not supported. +2. Internal function pointers are not supported. +3. Contract size and performance may be affected. + +## Using libraries + +The usage of libraries in Solidity is supported in zkSync Era with the following considerations: + +- If a Solidity library can be inlined (i.e. it only contains `private` or `internal` methods), it can be used without + any additional configuration. +- However, if a library contains at least one `public` or `external` method, it cannot be inlined and its address needs + to be passed explicitly to the compiler; see [compiling non-inlinable libraries](/build/tooling/hardhat/compiling-libraries#compiling-non-inlinable-libraries). diff --git a/content/10.zk-stack/10.components/70.compiler/10.toolchain/30.vyper.md b/content/10.zk-stack/10.components/70.compiler/10.toolchain/30.vyper.md new file mode 100644 index 00000000..b6dfb3fd --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/10.toolchain/30.vyper.md @@ -0,0 +1,53 @@ +--- +head: + - - meta + - name: "twitter:title" + content: Vyper Compiler | zkSync Docs +--- + +# Vyper + +The Vyper compiler we provide as part of our toolchain is called [zkvyper](%%zk_git_repo_zkvyper-bin%%). It +operates on Vyper’s LLL IR, and metadata received from the underlying [vyper](https://docs.vyperlang.org/en/latest/index.html) compiler, +which must be available in `$PATH`, or its path must be explicitly passed via the CLI (command-line interface). + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +To safeguard the security and efficiency of your application, always use the latest compiler version. +:: + +## Usage + +Make sure your machine satisfies the [system requirements](%%zk_git_repo_era-compiler-vyper%%/tree/main#system-requirements). + +Using our compiler via the Hardhat plugin usually suffices. However, knowledge of its interface and I/O (input/output) +methods are crucial for integration, debugging, or contribution purposes. + +#### Combined JSON + +The `zkvyper` standard JSON I/O workflow closely follows that of the official `vyper` compiler. However, `zkvyper` does not +support some configuration settings which are only relevant to the EVM architecture. + +Combined JSON is only an output format; there is no combined JSON input format. Instead, CLI arguments are +used for configuration. + +Additional zkEVM data is inserted into the output combined JSON by `zksolc`: + +- `zk_version`: the `zksolc` version. +- `contract/factory_deps`: bytecode hashes of contracts created in the current contract with `CREATE`. + Since Vyper does not support `CREATE` directly, only the forwarder can be present in this mapping. + + + +Regardless of the requested output, only the `combined_json`, `abi`, `method_identifiers`, `bytecode`, `bytecode_runtime` +flags are supported, while the rest are ignored. + +Other output formats are available via the `-f` option. Check out `vyper --help` for more details. + +## Limitations + +Versions from 0.3.4 to 0.3.8 are not supported. The only supported versions are 0.3.3, 0.3.9, 0.3.10. + +Also, since there is no separation of deploy and runtime code on EraVM, the following Vyper built-ins are not supported: + +- `create_copy_of` +- `create_from_blueprint` diff --git a/content/10.zk-stack/10.components/70.compiler/10.toolchain/40.llvm.md b/content/10.zk-stack/10.components/70.compiler/10.toolchain/40.llvm.md new file mode 100644 index 00000000..131c0379 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/10.toolchain/40.llvm.md @@ -0,0 +1,35 @@ +--- +head: + - - meta + - name: "twitter:title" + content: LLVM Framework | zkSync Docs +--- + +# LLVM Framework + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +To safeguard the security and efficiency of your application, always use the latest compiler version. +:: + +[The LLVM framework](%%zk_git_repo_era-compiler-llvm%%) is a soundly-architected and well-tested framework +for developing toolchains for smart contract languages. Its powerful intermediate representation (IR) allows developers +to design, implement, and optimize efficient language-specific features while benefiting from the extensive LLVM ecosystem. +This ensures high-performance execution, improved portability, and seamless integration with existing LLVM-based tools. +Furthermore, the modularity and extensibility of LLVM make it easier to support new smart contract languages with LLVM front ends. + +Additionally, LLVM improves on the original EVM pipeline efficiency, as we can take advantage of the +numerous optimization passes, tools, and tests available in its mature ecosystem. + +In our toolchain, LLVM consumes the LLVM IR, applies extensive optimizations, and eventually passes the optimized IR +to the zkEVM back-end code generator in order to produce the zkEVM text assembly output. + +## Optimizer + +All our compilers utilize the state-of-the-art LLVM optimizer. +By default, they optimize for performance, which correlates with the number of VM cycles per transaction, +thus affecting gas usage. +The `z` option may reduce the contract size for large contracts, making deployments cheaper while increasing the average transaction price. + +## Diving deeper + +For more information on the LLVM framework, [see the official documentation](https://llvm.org/). diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/10.overview.md b/content/10.zk-stack/10.components/70.compiler/20.specification/10.overview.md new file mode 100644 index 00000000..ab2fd663 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/10.overview.md @@ -0,0 +1,42 @@ +--- +title: Overview +description: +--- + +This is a technical deep-dive into the specifics of how the compiler works. +If you're looking to just deploy a contract, +please visit [Toolchain](/zk-stack/components/compiler/toolchain/overview) to understand the specifics around our Solidity, Vyper and LLVM compilers. + + +## Glossary + +| Entity | Description | +| ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| zksolc | The Solidity compiler, developed by Matter Labs. | +| solc | The original Solidity compiler, developed by the Ethereum community. Called by zksolc as a subprocess to get the IRs of the source code of the project. | +| LLVM | The compiler framework, used for optimizations and assembly generation. | +| EraVM assembler/linker | The tool written in Rust. Translates the assembly emitted by LLVM to the target bytecode. | +| Virtual machine | The zkSync Era virtual machine called EraVM with a custom instruction set. | +| [EraVM specification](%%zk_git_repo_eravm-spec%%/spec.html) | A combination of a human readable documentation and a formal description of EraVM, including its structure and operation, instruction syntax, semantic, and encoding. | +| Intermediate representation (IR) | The data structure or code used internally by the compiler to represent source code. | +| Yul | One of the Solidity IRs. Is a superset of the assembly available in Solidity. Used by default for contracts written in Solidity ≥0.8. | +| EVMLA | One of the Solidity IRs called EVM legacy assembly. Is a predecessor of Yul, but must closer to the pure EVM bytecode. Used by default for contracts written in Solidity <0.8. | +| LLVM IR | The IR native to the LLVM framework. | +| EraVM assembly | The text representation of the EraVM bytecode. Emitted by the LLVM framework. Translated into the EraVM bytecode by the EraVM assembler/linker. | +| EraVM bytecode | The smart contract bytecode, executed by EraVM. | +| Stack | The segment of the non-persistent contract memory. Consists of two parts: global data and function stack frame. | +| Heap | The segment of the non-persistent contract memory. All the data is globally accessible by both the compiler and user code. The allocation is handled by the solc’s Yul/EVMLA allocator only. | +| Auxiliary heap | The segment of the non-persistent contract memory, introduced to avoid conflicts with the solc’s allocator. All the data is globally accessible by the compiler only. The allocation is handled by the zksolc’s compiler only. All contract calls specific to zkSync, including the system contracts, are made via the auxiliary heap. It is also used to return data (e.g. the array of immutables) from the constructor. | +| Calldata | The segment of the non-persistent contract memory. The heap or auxiliary heap of the parent/caller contract. | +| Return data | The segment of the non-persistent contract memory. The heap or auxiliary heap of the child/callee contract. | +| Contract storage | The persistent contract memory. No relevant differences from that of EVM. | +| System contracts | The special set of zkSync kernel contracts written in Solidity by Matter Labs. | +| Contract context | The special storage of VM that keeps data like the current address, the caller’s address, etc. | + +## Concepts + +- [Code Separation](code-separation) +- [System Contracts](system-contracts) +- [Exception Handling](exception-handling) +- [EVMLA translator](evmla-translator) diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/20.code-separation.md b/content/10.zk-stack/10.components/70.compiler/20.specification/20.code-separation.md new file mode 100644 index 00000000..760ad3c9 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/20.code-separation.md @@ -0,0 +1,79 @@ +--- +title: Code Separation +description: +--- + +On both EVM and EraVM the code is separated into two parts: deploy code and runtime code. The deploy code is executed +only once, when the contract is deployed. The runtime code is executed every time the contract is called. However, on +EraVM the deploy code and runtime code are deployed together, and they are not split into two separate chunks of +bytecode. + +The constructor is added to the contract as a regular public function which is called by System Contracts during +deployment. + +Just like on EVM, the deploy code on EraVM is represented by a single constructor, named differently in different +languages: + +| Language | Name | +| -------- | ----------------- | +| Solidity | `constructor` | +| Yul | `object ""` | +| Vyper | `__init__` | + +The constructor is merged with the runtime code by the LLVM IR generator of our compiler, and a minimal contract on +EraVM looks like on the examples below. + +### LLVM IR + +In the example below, contract `@__entry` arguments `%0`-`%11` correspond to registers `r1`-`r12` on EraVM. + +```txt +; Function Attrs: nofree noreturn null_pointer_is_valid +define i256 @__entry(ptr addrspace(3) nocapture readnone %0, i256 %1, i256 %2, i256 %3, i256 %4, i256 %5, i256 %6, i256 %7, i256 %8, i256 %9, i256 %10, i256 %11) local_unnamed_addr #1 personality ptr @__personality { +entry: + %is_deploy_code_call_flag_truncated = and i256 %1, 1 ; check if the call is a deploy code call + %is_deploy_code_call_flag.not = icmp eq i256 %is_deploy_code_call_flag_truncated, 0 ; invert the flag + br i1 %is_deploy_code_call_flag.not, label %runtime_code_call_block, label %deploy_code_call_block ; branch to the deploy code block if the flag is set + +deploy_code_call_block: ; preds = %entry + store i256 32, ptr addrspace(2) inttoptr (i256 256 to ptr addrspace(2)), align 256 ; store the offset of the array of immutables + store i256 0, ptr addrspace(2) inttoptr (i256 288 to ptr addrspace(2)), align 32 ; store the length of the array of immutables + tail call void @llvm.syncvm.return(i256 53919893334301279589334030174039261352344891250716429051063678533632) ; return the array of immutables using EraVM return ABI data encoding + unreachable + +runtime_code_call_block: ; preds = %entry + store i256 42, ptr addrspace(1) null, align 4294967296 ; store a value to return + tail call void @llvm.syncvm.return(i256 2535301200456458802993406410752) ; return the value using EraVM return ABI data encoding + unreachable +} +``` + +### EraVM Assembly + +```asm + .text + .file "default.yul" + .globl __entry +__entry: +.func_begin0: + and! 1, r2, r1 ; check if the call is a deploy code call + jump.ne @.BB0_1 ; branch to the deploy code block if the flag is set + add 42, r0, r1 ; move the value to return into r1 + st.1 0, r1 ; store the value to return + add @CPI0_1[0], r0, r1 ; move the return ABI data into r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN ; return the value +.BB0_1: + add 32, r0, r1 ; move the offset of the array of immutables into r1 + st.2 256, r1 ; store the offset of the array of immutables + st.2 288, r0 ; store the length of the array of immutables + add @CPI0_0[0], r0, r1 ; move the return ABI data into r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN ; return the array of immutables +.func_end0: + + .note.GNU-stack + .rodata +CPI0_0: + .cell 53919893334301279589334030174039261352344891250716429051063678533632 +CPI0_1: + .cell 2535301200456458802993406410752 +``` diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/30.system-contracts.md b/content/10.zk-stack/10.components/70.compiler/20.specification/30.system-contracts.md new file mode 100644 index 00000000..8903691f --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/30.system-contracts.md @@ -0,0 +1,139 @@ +--- +title: System Contracts +description: +--- + +Many EVM instructions require special handling by the System Contracts. Among them are: `ORIGIN`, +`CALLVALUE`, `BALANCE`, `CREATE`, `SHA3`, and others. To see the full detailed list of instructions that require special +handling, see +[the EVM instructions reference](instructions/evm/overview). + +There are several types of System Contracts from the perspective of how they are handled by the zkSync Era compilers: + +1. [Environmental data storage](#environmental-data-storage). +2. [KECCAK256 hash function](#keccak256-hash-function). +3. [Contract deployer](#contract-deployer). +4. [Ether value simulator](#ether-value-simulator). +5. [Simulator of immutables](#simulator-of-immutables). +6. [Event handler](#event-handler). + +### Environmental Data Storage + +Such storage contracts are accessed with static calls in order to retrieve values for the block, transaction, and other +environmental entities: `CHAINID`, `DIFFICULTY`, `BLOCKHASH`, etc. + +One good example of such contract is +[SystemContext](%%zk_git_repo_era-contracts%%/blob/main/system-contracts/contracts/SystemContext.sol) that provides +the majority of the environmental data. + +Since EVM is not using external calls for these instructions, we must use [the auxiliary heap](#auxiliary-heap) for +their calldata. + +Steps to handle such instructions: + +1. Store the calldata for the System Contract call on the auxiliary heap. +2. Call the System Contract with a static call. +3. Check the return status code of the call. +4. [Revert or throw](exception-handling) + if the status code is zero. +5. Read the ABI data and extract the result. All such System Contracts return a single 256-bit value. +6. Return the value as the result of the original instruction. + +For reference, see +[the LLVM IR codegen source code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/context/function/llvm_runtime.rs#L488). + +### KECCAK256 Hash Function + +Handling of this function is similar to [Environmental Data Storage](#environmental-data-storage) with one difference: + +Since EVM also uses heap to store the calldata for `KECCAK256`, the required memory chunk is allocated by the IR +generator, and zkSync Era compiler does not need to use [the auxiliary heap](#auxiliary-heap). + +For reference, see +[the LLVM IR codegen source code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/context/function/llvm_runtime.rs). + +### Contract Deployer + + + +For reference, see LLVM IR codegen for +[the deployer call](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/context/function/runtime/deployer_call.rs) +and +[CREATE-related instructions](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/create.rs). + +### Ether Value Simulator + +EraVM does not support passing Ether natively, so this is handled by a special System Contract called +[MsgValueSimulator](%%zk_git_repo_era-contracts%%/blob/main/system-contracts/contracts/MsgValueSimulator.sol). + +An external call is redirected through the simulator if the following conditions are met: + +1. The [call](instructions/evm/calls) has the Ether value parameter. +2. The Ether value is non-zero. + +Calls to the simulator require extra data passed via ABI using registers: + +1. Ether value. +2. The address of the contract to call. +3. The [system call bit](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#to_system), +which is only set if a call to the [ContractDeployer](#contract-deployer) is being redirected, that is `CREATE` or `CREATE2` is called with non-zero Ether. + +Passing Ether value in EraVM is implemented by using a combination of: + +- a special 128-bit register [`context_u128`](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#gs_context_u128) +which is a part of the EraVM [transient state](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#StateDefinitions); +- an [immutable value of `context_u128`](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#ecf_context_u128_value) +captured in the stack frame in a moment of a call. + +The process of setting up a value and capturing it is described in details in the section [Context Register of the EraVM specification](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#StateDefinitions). + +For reference, see [the LLVM IR codegen source code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/call.rs#L530). + +### Simulator of Immutables + + + + +For reference, see LLVM IR codegen for +[instructions for immutables](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/immutable.rs) +and +[RETURN from the deploy code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/return.rs#L28). + +### Event Handler + +Event payloads are sent to a special System Contract called +[EventWriter](%%zk_git_repo_era-contracts%%/blob/main/system-contracts/contracts/EventWriter.yul). +Like on EVM, the payload consists of topics and data: + +1. The topics with a length-prefix are passed via ABI using registers. +2. The data is passed via the default heap, like on EVM. + +For reference, see +[the LLVM IR codegen source code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/event.rs). + +## Auxiliary Heap + +Both [zksolc](../toolchain/solidity) and [zkvyper](../toolchain/vyper) compilers for EraVM operate on +[the IR level](../toolchain/overview#ir-compilers), so they cannot control the heap memory allocator which remains a responsibility of +[the high-level source code compilers](../toolchain/overview#high-level-source-code-compilers) emitting the IRs. + +However, there are several cases where EraVM needs to allocate memory on the heap and EVM does not. The auxiliary heap is +used for these cases: + + +1. Returning immutables from the constructor. +2. Allocating calldata and return data for calling the System Contracts. + +While the ordinary heap contains calldata and return data for calls to **user contracts**, auxiliary heap contains calldata +and return data for calls to **System Contracts**. This ensures better compatibility with EVM as users should be able to call +EraVM-specific System Contracts in a transparent way, without System Contracts affecting calldata or return data. +This prevents situations where calling System Contracts interferes with the heap layout expected by the contract developer. + +For more details on the heaps, refer to the EraVM specification, +which describes [types of heaps](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#data_page_params), +their connections to the [stack frames and memory growth](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#ctx_heap_page_id), +and their role in [communication between contracts](%%zk_git_repo_matter-labs-github-io%%/eravm-spec/spec.html#MemoryForwarding). diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/40.exception-handling.md b/content/10.zk-stack/10.components/70.compiler/20.specification/40.exception-handling.md new file mode 100644 index 00000000..0325271c --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/40.exception-handling.md @@ -0,0 +1,132 @@ +--- +title: Exception Handling +description: +--- + +This document explains some peculiarities of the exception handling (EH) in zkEVM architecture. + +In a nutshell, there are two EH mechanisms in zkEVM: contract-level and function-level. +The former was inherited from the EVM architecture, and the latter is more common to general-purpose languages. + +| | Contract Level | Function Level | +| ------------ | --------------- | ----------------------------------------------------------------------------------------------------- | +| Yul Example | revert(0, 0) | verbatim("throw") | +| Native to | EVM | General-purpose languages | +| Handled by | zkEVM | Compiler | +| Catchable by | Caller contract | Caller function | +| Efficient | Yes | Huge size impact due to numerous catch blocks. Extra cycles are needed for propagating the exception. | + +## Contract Level + +This type of exceptions is inherited from the EVM architecture. On EVM, such instructions as `REVERT` and `INVALID`, +immediately terminate the contract execution and return the control to the callee. It is impossible to catch them +within the contract, and it can be only done on the callee side with checking the call status code. + +```solidity +// callee +revert(0, 0) + +// caller +let success = call(...) +if iszero(success) { + // option 1: rethrow on the contract level + returndatacopy(...) + revert(...) + + // option 2: rethrow on the function level + verbatim("throw") // only available in the Yul mode and upcoming zkEVM solc +} +``` + +zkEVM behaves exactly the same. The VM automatically unwinds the call stack up to the uppermost function frame +of the contract, leaving no possibility to catch and handle it on the way. + +These types of exceptions are more efficient, as you can revert at any point of the execution without propagating +the control flow all the way up to the uppermost function frame. + +### Implementation + +In EraVM, contracts call each other using [`far_call` instruction](%%zk_git_repo_eravm-spec%%/spec.html#FarCalls). +It [accepts the address of the exception handler](%%zk_git_repo_eravm-spec%%/spec.html#OpFarCall) as one of its arguments. + +## Function Level + +This type of exceptions is more common to general-purpose languages like C++. That is why it was easy to support +within the LLVM framework, even though it is not supported by the smart contract languages we work with. +That is also one of the reasons why the two EH mechanisms are handled separately and barely interact in the high-level code. + +In general-purpose languages a set of EH tools is usually available, e.g. `try` , `throw`, and `catch` keywords that +define which piece of code may throw and how the exception must be handled. However, these tools are not available +in Solidity and its EVM Yul dialect, so some extensions have been added in the zkEVM Yul dialect compiled by zksolc, +but there are limitations, some of which are dictated by the nature of smart contracts: + +1. Every function beginning with `ZKSYNC_NEAR_CALL` is implicitly wrapped with `try`. If there is an exception handler defined, the following will happen: + - A panic will be caught by the caller of such function. + - The control will be transferred to EH function. + There can be only one EH function and it must be named `ZKSYNC_CATCH_NEAR_CALL`. + It is not very efficient, because all functions must have an LLVM IR `catch` block that will catch and propagate the exception and call the EH function. + - When the EH function has finished executing, the caller of `ZKSYNC_NEAR_CALL` receives the control back. +2. Every operation is `throw`. +Since any instruction can panic due to out-of-gas, all of them can throw. +It is another thing reducing the potential for optimizations. +3. The `catch` block is represented by the `ZKSYNC_CATCH_NEAR_CALL` function in Yul. +A panic in `ZKSYNC_NEAR_CALL` will make **their caller** catch the exception and call the EH function. +After the EH function is executed, the control is returned to the caller of `ZKSYNC_NEAR_CALL`. + +```solidity +// Follow the numbers for the order of execution. The call order is: +// caller -> ZKSYNC_NEAR_CALL_callee -> callee_even_deeper -> ZKSYNC_CATCH_NEAR_CALL -> caller + +function ZKSYNC_NEAR_CALL_callee() -> value { // 03 + value := callee_even_deeper() // 04 +} + +function callee_even_deeper() -> value { // 05 + verbatim("throw") // 06 +} + +// In every function an implicit 'catch' block in LLVM IR is created. +// This block will do the following: +// 1. Keep the return value ('zero') zero-initialized if one is expected +// 2. Call the EH function ('ZKSYNC_CATCH_NEAR_CALL') +// 3. Return the control flow to the next instruction ('value := 42') +function caller() -> value { // 01 + let zero := ZKSYNC_NEAR_CALL_callee() // 02 + value := 42 // 09 +} + +// This handler could also be doing a revert. +// Reverts in EH functions work in the same way as without EH at all. +// They immediately terminate the execution and the control is given to the contract callee. +function ZKSYNC_CATCH_NEAR_CALL() { // 07 + log0(...) // 08 +} +``` + +Having all the overhead above, the `catch` blocks are only generated if there is the EH function `ZKSYNC_CATCH_NEAR_CALL` +defined in the contract. Otherwise there is no need to catch panics and they will be propagated to the callee contract +automatically by the VM execution environment. + +### Implementation + +In EraVM, there are two ways of implementing contract-local function calls: + +1. Saving the return address and using a [`jump`](%%zk_git_repo_eravm-spec%%/spec.html#JumpDefinition) instruction to call; +using [`jump`](%%zk_git_repo_eravm-spec%%/spec.html#JumpDefinition) instruction with saved return address to return. +2. Using + [`call`](%%zk_git_repo_eravm-spec%%/spec.html#NearCallDefinition) + instruction to call; using one of `ret` instructions with modifiers + [`ok`](%%zk_git_repo_eravm-spec%%/spec.html#NearRetDefinition), + [`revert`](%%zk_git_repo_eravm-spec%%/spec.html#NearRevertDefinition), or + [`panic`](%%zk_git_repo_eravm-spec%%/spec.html#step_oppanic) to return. + +Using `jump` is more lightweight and cheaper, but using `call`/`ret` is more feature-rich: + +1. In case of panic or revert, the storage effects and queues of this function are rolled back. +2. It is possible to pass a portion of available gas; the unused gas will be returned to the caller, unless the function panicked. +3. It is possible to set up a custom exception handler. + +Prefixing Yul function name with `ZKSYNC_NEAR_CALL_` allows to use this +additional, platform-specific functionality, implemented by the `call` +instruction. For other functions, the choice between `call`/`ret` or `jump` is +up to the compiler. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/50.evmla-translator.md b/content/10.zk-stack/10.components/70.compiler/20.specification/50.evmla-translator.md new file mode 100644 index 00000000..3a147dc5 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/50.evmla-translator.md @@ -0,0 +1,759 @@ +--- +title: EVM Legacy Assembly Translator +description: +--- + +There are two Solidity IRs used in our pipeline: Yul and EVM legacy assembly. The former is used for older versions of +Solidity, more precisely <=0.7. + +EVM legacy assembly is very challenging to translate to LLVM IR, since it obfuscates the control flow of the program and +uses a lot of dynamic jumps. Most of the jumps can be translated to static ones by using a static analysis of EVM assembly, +but some of jumps are impossible to resolve statically. For example, internal function pointers can be written +to memory or storage, and then loaded and called. Recursion is another case we have skipped for now, as there is another +stack frame allocated on every iteration, preventing the static analyzer from resolving the jumps. + +Both issues are being worked on in our fork of the Solidity compiler, where we are changing the codegen to remove the +dynamic jumps and add the necessary metadata. + +Below you can see a minimal example of a Solidity contract and its EVM legacy assembly translated to LLVM IR which is +eventually compiled to EraVM assembly. + +## Source Code + +```solidity +contract Example { + function main() public pure returns (uint256 result) { + result = 42; + } +} +``` + +## EVM Legacy Assembly + +Produced by the upstream Solidity compiler v0.7.6. + +```txt +| Line | Instruction | Value/Tag | +| ---- | ------------ | --------- | +| 000 | PUSH | 80 | +| 001 | PUSH | 40 | +| 002 | MSTORE | | +| 003 | CALLVALUE | | +| 004 | DUP1 | | +| 005 | ISZERO | | +| 006 | PUSH | [tag] 1 | +| 007 | JUMPI | | +| 008 | PUSH | 0 | +| 009 | DUP1 | | +| 010 | REVERT | | +| 011 | Tag 1 | | +| 012 | JUMPDEST | | +| 013 | POP | | +| 014 | PUSH | 4 | +| 015 | CALLDATASIZE | | +| 016 | LT | | +| 017 | PUSH | [tag] 2 | +| 018 | JUMPI | | +| 019 | PUSH | 0 | +| 020 | CALLDATALOAD | | +| 021 | PUSH | E0 | +| 022 | SHR | | +| 023 | DUP1 | | +| 024 | PUSH | 5A8AC02D | +| 025 | EQ | | +| 026 | PUSH | [tag] 3 | +| 027 | JUMPI | | +| 028 | Tag 2 | | +| 029 | JUMPDEST | | +| 030 | PUSH | 0 | +| 031 | DUP1 | | +| 032 | REVERT | | +| 033 | Tag 3 | | +| 034 | JUMPDEST | | +| 035 | PUSH | [tag] 4 | +| 036 | PUSH | [tag] 5 | +| 037 | JUMP | [in] | +| 038 | Tag 4 | | +| 039 | JUMPDEST | | +| 040 | PUSH | 40 | +| 041 | DUP1 | | +| 042 | MLOAD | | +| 043 | SWAP2 | | +| 044 | DUP3 | | +| 045 | MSTORE | | +| 046 | MLOAD | | +| 047 | SWAP1 | | +| 048 | DUP2 | | +| 049 | SWAP1 | | +| 050 | SUB | | +| 051 | PUSH | 20 | +| 052 | ADD | | +| 053 | SWAP1 | | +| 054 | RETURN | | +| 055 | Tag 5 | | +| 056 | JUMPDEST | | +| 057 | PUSH | 2A | +| 058 | SWAP1 | | +| 059 | JUMP | [out] | +``` + +## EthIR + +EthIR (Ethereal IR) is a special IR used by our translator to represent EVM legacy assembly and prepare it for the +translation to LLVM IR. The IR solves several purposes: + +1. Tracking the stack state to extract jump destinations. +2. Duplicating blocks that are reachable with different stack states. +3. Restoring the complete control-flow graph of the contract using the abovementioned data. +4. Resolving dependencies and static data chunks. + +Data format: + +1. `V_` - value returned by an instruction ``. +2. `T_` - tag of a block ``. +3. `40` - hexadecimal constant. +4. `tests/solidity/simple/default.sol:Test` - contract definition. + +Stack format: `[ V_CALLVALUE ]` (current values) - `[ V_CALLVALUE ]` (popped values) + `[ V_ISZERO ]` (pushed values) + +```text +// The default entry function of the contract. +function main { +// The maximum stack size in the function. + stack_usage: 6 +block_dt_0/0: // Deploy Code Tag 0, Instance 0. +// PUSHed 0x80 onto the stack. + PUSH 80 [ ] + [ 80 ] +// PUSHed 0x40 onto the stack. + PUSH 40 [ 80 ] + [ 40 ] +// POPped 0x40 at 0x80 from the stack to store 0x80 at 0x40. + MSTORE [ ] - [ 80 | 40 ] +// PUSHed CALLVALUE onto the stack. + CALLVALUE [ ] + [ V_CALLVALUE ] + DUP1 [ V_CALLVALUE ] + [ V_CALLVALUE ] + ISZERO [ V_CALLVALUE ] - [ V_CALLVALUE ] + [ V_ISZERO ] + PUSH [tag] 1 [ V_CALLVALUE | V_ISZERO ] + [ T_1 ] +// JUMPI schedules rt_0/0 for analysis with the current stack state. + JUMPI [ V_CALLVALUE ] - [ V_ISZERO | T_1 ] + PUSH 0 [ V_CALLVALUE ] + [ 0 ] + DUP1 [ V_CALLVALUE | 0 ] + [ 0 ] + REVERT [ V_CALLVALUE ] - [ 0 | 0 ] +block_dt_1/0: (predecessors: dt_0/0) // Deploy Code Tag 1, Instance 0; the only predecessor of this block is dt_0/0. +// JUMPDESTs are ignored as we are only interested in the stack state and tag destinations. + JUMPDEST [ V_CALLVALUE ] + POP [ ] - [ V_CALLVALUE ] + PUSH #[$] tests/solidity/simple/default.sol:Test [ ] + [ tests/solidity/simple/default.sol:Test ] + DUP1 [ tests/solidity/simple/default.sol:Test ] + [ tests/solidity/simple/default.sol:Test ] + PUSH [$] tests/solidity/simple/default.sol:Test [ tests/solidity/simple/default.sol:Test | tests/solidity/simple/default.sol:Test ] + [ tests/solidity/simple/default.sol:Test ] + PUSH 0 [ tests/solidity/simple/default.sol:Test | tests/solidity/simple/default.sol:Test | tests/solidity/simple/default.sol:Test ] + [ 0 ] + CODECOPY [ tests/solidity/simple/default.sol:Test ] - [ tests/solidity/simple/default.sol:Test | tests/solidity/simple/default.sol:Test | 0 ] + PUSH 0 [ tests/solidity/simple/default.sol:Test ] + [ 0 ] + RETURN [ ] - [ tests/solidity/simple/default.sol:Test | 0 ] +// The runtime code is analyzed in the same control-flow graph as the deploy code, as it is possible to call its functions from the constructor. +block_rt_0/0: // Deploy Code Tag 0, Instance 0. + PUSH 80 [ ] + [ 80 ] + PUSH 40 [ 80 ] + [ 40 ] + MSTORE [ ] - [ 80 | 40 ] + CALLVALUE [ ] + [ V_CALLVALUE ] + DUP1 [ V_CALLVALUE ] + [ V_CALLVALUE ] + ISZERO [ V_CALLVALUE ] - [ V_CALLVALUE ] + [ V_ISZERO ] + PUSH [tag] 1 [ V_CALLVALUE | V_ISZERO ] + [ T_1 ] + JUMPI [ V_CALLVALUE ] - [ V_ISZERO | T_1 ] + PUSH 0 [ V_CALLVALUE ] + [ 0 ] + DUP1 [ V_CALLVALUE | 0 ] + [ 0 ] + REVERT [ V_CALLVALUE ] - [ 0 | 0 ] +block_rt_1/0: (predecessors: rt_0/0) // Runtime Code Tag 1, Instance 0; the only predecessor of this block is rt_0/0. + JUMPDEST [ V_CALLVALUE ] + POP [ ] - [ V_CALLVALUE ] + PUSH 4 [ ] + [ 4 ] + CALLDATASIZE [ 4 ] + [ V_CALLDATASIZE ] + LT [ ] - [ 4 | V_CALLDATASIZE ] + [ V_LT ] + PUSH [tag] 2 [ V_LT ] + [ T_2 ] + JUMPI [ ] - [ V_LT | T_2 ] + PUSH 0 [ ] + [ 0 ] + CALLDATALOAD [ ] - [ 0 ] + [ V_CALLDATALOAD ] + PUSH E0 [ V_CALLDATALOAD ] + [ E0 ] + SHR [ ] - [ V_CALLDATALOAD | E0 ] + [ V_SHR ] + DUP1 [ V_SHR ] + [ V_SHR ] + PUSH 5A8AC02D [ V_SHR | V_SHR ] + [ 5A8AC02D ] + EQ [ V_SHR ] - [ V_SHR | 5A8AC02D ] + [ V_EQ ] + PUSH [tag] 3 [ V_SHR | V_EQ ] + [ T_3 ] + JUMPI [ V_SHR ] - [ V_EQ | T_3 ] + Tag 2 [ V_SHR ] +// This instance is called with a different stack state using the JUMPI above. +block_rt_2/0: (predecessors: rt_1/0) // Runtime Code Tag 2, Instance 0. + JUMPDEST [ ] + PUSH 0 [ ] + [ 0 ] + DUP1 [ 0 ] + [ 0 ] + REVERT [ ] - [ 0 | 0 ] +// This instance is also called from rt_1/0, but using a fallthrough 'Tag 2'. +// Given different stack states, we create a new instance of the block operating on different data +// and potentially different tag destinations, although usually such blocks are merged back by LLVM. +block_rt_2/1: (predecessors: rt_1/0) // Runtime Code Tag 2, Instance 1. + JUMPDEST [ V_SHR ] + PUSH 0 [ V_SHR ] + [ 0 ] + DUP1 [ V_SHR | 0 ] + [ 0 ] + REVERT [ V_SHR ] - [ 0 | 0 ] +block_rt_3/0: (predecessors: rt_1/0) // Runtime Code Tag 3, Instance 0. + JUMPDEST [ V_SHR ] + PUSH [tag] 4 [ V_SHR ] + [ T_4 ] + PUSH [tag] 5 [ V_SHR | T_4 ] + [ T_5 ] + JUMP [in] [ V_SHR | T_4 ] - [ T_5 ] +block_rt_4/0: (predecessors: rt_5/0) // Runtime Code Tag 4, Instance 0. + JUMPDEST [ V_SHR | 2A ] + PUSH 40 [ V_SHR | 2A ] + [ 40 ] + DUP1 [ V_SHR | 2A | 40 ] + [ 40 ] + MLOAD [ V_SHR | 2A | 40 ] - [ 40 ] + [ V_MLOAD ] + SWAP2 [ V_SHR | V_MLOAD | 40 | 2A ] + DUP3 [ V_SHR | V_MLOAD | 40 | 2A ] + [ V_MLOAD ] + MSTORE [ V_SHR | V_MLOAD | 40 ] - [ 2A | V_MLOAD ] + MLOAD [ V_SHR | V_MLOAD ] - [ 40 ] + [ V_MLOAD ] + SWAP1 [ V_SHR | V_MLOAD | V_MLOAD ] + DUP2 [ V_SHR | V_MLOAD | V_MLOAD ] + [ V_MLOAD ] + SWAP1 [ V_SHR | V_MLOAD | V_MLOAD | V_MLOAD ] + SUB [ V_SHR | V_MLOAD ] - [ V_MLOAD | V_MLOAD ] + [ V_SUB ] + PUSH 20 [ V_SHR | V_MLOAD | V_SUB ] + [ 20 ] + ADD [ V_SHR | V_MLOAD ] - [ V_SUB | 20 ] + [ V_ADD ] + SWAP1 [ V_SHR | V_ADD | V_MLOAD ] + RETURN [ V_SHR ] - [ V_ADD | V_MLOAD ] +block_rt_5/0: (predecessors: rt_3/0) // Runtime Code Tag 5, Instance 0. + JUMPDEST [ V_SHR | T_4 ] + PUSH 2A [ V_SHR | T_4 ] + [ 2A ] + SWAP1 [ V_SHR | 2A | T_4 ] +// JUMP [out] is usually a return statement + JUMP [out] [ V_SHR | 2A ] - [ T_4 ] +``` + +### Unoptimized LLVM IR + +In LLVM IR, the necessary stack space is allocated at the beginning of the function. + +Every stack operation interacts with a statically known stack pointer with an offset from EthIR. + +```txt +; Function Attrs: nofree null_pointer_is_valid +define i256 @__entry(ptr addrspace(3) %0, i256 %1, i256 %2, i256 %3, i256 %4, i256 %5, i256 %6, i256 %7, i256 %8, i256 %9, i256 %10, i256 %11) #8 personality ptr @__personality { +entry: + store i256 0, ptr @memory_pointer, align 32 + store i256 0, ptr @calldatasize, align 32 + store i256 0, ptr @returndatasize, align 32 + store i256 0, ptr @call_flags, align 32 + store [10 x i256] zeroinitializer, ptr @extra_abi_data, align 32 + store ptr addrspace(3) %0, ptr @ptr_calldata, align 32 + %abi_pointer_value = ptrtoint ptr addrspace(3) %0 to i256 + %abi_pointer_value_shifted = lshr i256 %abi_pointer_value, 96 + %abi_length_value = and i256 %abi_pointer_value_shifted, 4294967295 + store i256 %abi_length_value, ptr @calldatasize, align 32 + %calldatasize = load i256, ptr @calldatasize, align 32 + %return_data_abi_initializer = getelementptr i8, ptr addrspace(3) %0, i256 %calldatasize + store ptr addrspace(3) %return_data_abi_initializer, ptr @ptr_return_data, align 32 + store ptr addrspace(3) %return_data_abi_initializer, ptr @ptr_active, align 32 + store i256 %1, ptr @call_flags, align 32 + store i256 %2, ptr @extra_abi_data, align 32 + store i256 %3, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 1), align 32 + store i256 %4, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 2), align 32 + store i256 %5, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 3), align 32 + store i256 %6, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 4), align 32 + store i256 %7, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 5), align 32 + store i256 %8, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 6), align 32 + store i256 %9, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 7), align 32 + store i256 %10, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 8), align 32 + store i256 %11, ptr getelementptr inbounds ([10 x i256], ptr @extra_abi_data, i256 0, i32 9), align 32 + %is_deploy_code_call_flag_truncated = and i256 %1, 1 + %is_deploy_code_call_flag = icmp eq i256 %is_deploy_code_call_flag_truncated, 1 + br i1 %is_deploy_code_call_flag, label %deploy_code_call_block, label %runtime_code_call_block + +return: ; preds = %runtime_code_call_block, %deploy_code_call_block + ret i256 0 + +deploy_code_call_block: ; preds = %entry + call void @__deploy() + br label %return + +runtime_code_call_block: ; preds = %entry + call void @__runtime() + br label %return +} + +; Function Attrs: nofree null_pointer_is_valid +define private void @__deploy() #8 personality ptr @__personality { +entry: + call void @main(i1 true) + br label %return + +return: ; preds = %entry + ret void +} + +; Function Attrs: nofree null_pointer_is_valid +define private void @__runtime() #8 personality ptr @__personality { +entry: + call void @main(i1 false) + br label %return + +return: ; preds = %entry + ret void +} + +; Function Attrs: nofree null_pointer_is_valid +define private void @main(i1 %0) #8 personality ptr @__personality { ; 6 cells are allocated at the beginning of the function. +entry: + %stack_var_000 = alloca i256, align 32 + store i256 0, ptr %stack_var_000, align 32 + %stack_var_001 = alloca i256, align 32 + store i256 0, ptr %stack_var_001, align 32 + %stack_var_002 = alloca i256, align 32 + store i256 0, ptr %stack_var_002, align 32 + %stack_var_003 = alloca i256, align 32 + store i256 0, ptr %stack_var_003, align 32 + %stack_var_004 = alloca i256, align 32 + store i256 0, ptr %stack_var_004, align 32 + %stack_var_005 = alloca i256, align 32 + store i256 0, ptr %stack_var_005, align 32 + br i1 %0, label %"block_dt_0/0", label %"block_rt_0/0" + +return: ; No predecessors! + ret void + +"block_dt_0/0": ; preds = %entry + store i256 128, ptr %stack_var_000, align 32 + store i256 64, ptr %stack_var_001, align 32 + %argument_0 = load i256, ptr %stack_var_001, align 32 + %argument_1 = load i256, ptr %stack_var_000, align 32 + %memory_store_pointer = inttoptr i256 %argument_0 to ptr addrspace(1) + store i256 %argument_1, ptr addrspace(1) %memory_store_pointer, align 1 + %get_u128_value = call i256 @llvm.syncvm.getu128() + store i256 %get_u128_value, ptr %stack_var_000, align 32 + %dup1 = load i256, ptr %stack_var_000, align 32 + store i256 %dup1, ptr %stack_var_001, align 32 + %argument_01 = load i256, ptr %stack_var_001, align 32 + %comparison_result = icmp eq i256 %argument_01, 0 + %comparison_result_extended = zext i1 %comparison_result to i256 + store i256 %comparison_result_extended, ptr %stack_var_001, align 32 + store i256 1, ptr %stack_var_002, align 32 + %conditional_dt_1_condition = load i256, ptr %stack_var_001, align 32 + %conditional_dt_1_condition_compared = icmp ne i256 %conditional_dt_1_condition, 0 + br i1 %conditional_dt_1_condition_compared, label %"block_dt_1/0", label %conditional_dt_1_join_block + +"block_dt_1/0": ; preds = %"block_dt_0/0" + store i256 0, ptr %stack_var_000, align 32 + %dup15 = load i256, ptr %stack_var_000, align 32 + store i256 %dup15, ptr %stack_var_001, align 32 + store i256 0, ptr %stack_var_002, align 32 + store i256 0, ptr %stack_var_003, align 32 + %argument_06 = load i256, ptr %stack_var_003, align 32 + %argument_17 = load i256, ptr %stack_var_002, align 32 + %argument_2 = load i256, ptr %stack_var_001, align 32 + %calldata_copy_destination_pointer = inttoptr i256 %argument_06 to ptr addrspace(1) + %calldata_pointer = load ptr addrspace(3), ptr @ptr_calldata, align 32 + %calldata_source_pointer = getelementptr i8, ptr addrspace(3) %calldata_pointer, i256 %argument_17 + call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) align 1 %calldata_copy_destination_pointer, ptr addrspace(3) align 1 %calldata_source_pointer, i256 %argument_2, i1 false) + store i256 0, ptr %stack_var_001, align 32 + %argument_08 = load i256, ptr %stack_var_001, align 32 + %argument_19 = load i256, ptr %stack_var_000, align 32 + store i256 32, ptr addrspace(2) inttoptr (i256 256 to ptr addrspace(2)), align 1 + store i256 0, ptr addrspace(2) inttoptr (i256 288 to ptr addrspace(2)), align 1 + call void @__return(i256 256, i256 64, i256 2) + unreachable + +"block_rt_0/0": ; preds = %entry + store i256 128, ptr %stack_var_000, align 32 + store i256 64, ptr %stack_var_001, align 32 + %argument_010 = load i256, ptr %stack_var_001, align 32 + %argument_111 = load i256, ptr %stack_var_000, align 32 + %memory_store_pointer12 = inttoptr i256 %argument_010 to ptr addrspace(1) + store i256 %argument_111, ptr addrspace(1) %memory_store_pointer12, align 1 + %get_u128_value13 = call i256 @llvm.syncvm.getu128() + store i256 %get_u128_value13, ptr %stack_var_000, align 32 + %dup114 = load i256, ptr %stack_var_000, align 32 + store i256 %dup114, ptr %stack_var_001, align 32 + %argument_015 = load i256, ptr %stack_var_001, align 32 + %comparison_result16 = icmp eq i256 %argument_015, 0 + %comparison_result_extended17 = zext i1 %comparison_result16 to i256 + store i256 %comparison_result_extended17, ptr %stack_var_001, align 32 + store i256 1, ptr %stack_var_002, align 32 + %conditional_rt_1_condition = load i256, ptr %stack_var_001, align 32 + %conditional_rt_1_condition_compared = icmp ne i256 %conditional_rt_1_condition, 0 + br i1 %conditional_rt_1_condition_compared, label %"block_rt_1/0", label %conditional_rt_1_join_block + +"block_rt_1/0": ; preds = %"block_rt_0/0" + store i256 4, ptr %stack_var_000, align 32 + %calldatasize = load i256, ptr @calldatasize, align 32 + store i256 %calldatasize, ptr %stack_var_001, align 32 + %argument_021 = load i256, ptr %stack_var_001, align 32 + %argument_122 = load i256, ptr %stack_var_000, align 32 + %comparison_result23 = icmp ult i256 %argument_021, %argument_122 + %comparison_result_extended24 = zext i1 %comparison_result23 to i256 + store i256 %comparison_result_extended24, ptr %stack_var_000, align 32 + store i256 2, ptr %stack_var_001, align 32 + %conditional_rt_2_condition = load i256, ptr %stack_var_000, align 32 + %conditional_rt_2_condition_compared = icmp ne i256 %conditional_rt_2_condition, 0 + br i1 %conditional_rt_2_condition_compared, label %"block_rt_2/0", label %conditional_rt_2_join_block + +"block_rt_2/0": ; preds = %"block_rt_1/0" + store i256 0, ptr %stack_var_000, align 32 + %dup134 = load i256, ptr %stack_var_000, align 32 + store i256 %dup134, ptr %stack_var_001, align 32 + %argument_035 = load i256, ptr %stack_var_001, align 32 + %argument_136 = load i256, ptr %stack_var_000, align 32 + call void @__revert(i256 %argument_035, i256 %argument_136, i256 0) + unreachable + +"block_rt_2/1": ; preds = %conditional_rt_3_join_block + store i256 0, ptr %stack_var_001, align 32 + %dup137 = load i256, ptr %stack_var_001, align 32 + store i256 %dup137, ptr %stack_var_002, align 32 + %argument_038 = load i256, ptr %stack_var_002, align 32 + %argument_139 = load i256, ptr %stack_var_001, align 32 + call void @__revert(i256 %argument_038, i256 %argument_139, i256 0) + unreachable + +"block_rt_3/0": ; preds = %conditional_rt_2_join_block + store i256 4, ptr %stack_var_001, align 32 + store i256 5, ptr %stack_var_002, align 32 + br label %"block_rt_5/0" + +"block_rt_4/0": ; preds = %"block_rt_5/0" + store i256 64, ptr %stack_var_002, align 32 + %dup140 = load i256, ptr %stack_var_002, align 32 + store i256 %dup140, ptr %stack_var_003, align 32 + %argument_041 = load i256, ptr %stack_var_003, align 32 + %memory_load_pointer = inttoptr i256 %argument_041 to ptr addrspace(1) + %memory_load_result = load i256, ptr addrspace(1) %memory_load_pointer, align 1 + store i256 %memory_load_result, ptr %stack_var_003, align 32 + %swap2_top_value = load i256, ptr %stack_var_003, align 32 + %swap2_swap_value = load i256, ptr %stack_var_001, align 32 + store i256 %swap2_swap_value, ptr %stack_var_003, align 32 + store i256 %swap2_top_value, ptr %stack_var_001, align 32 + %dup3 = load i256, ptr %stack_var_001, align 32 + store i256 %dup3, ptr %stack_var_004, align 32 + %argument_042 = load i256, ptr %stack_var_004, align 32 + %argument_143 = load i256, ptr %stack_var_003, align 32 + %memory_store_pointer44 = inttoptr i256 %argument_042 to ptr addrspace(1) + store i256 %argument_143, ptr addrspace(1) %memory_store_pointer44, align 1 + %argument_045 = load i256, ptr %stack_var_002, align 32 + %memory_load_pointer46 = inttoptr i256 %argument_045 to ptr addrspace(1) + %memory_load_result47 = load i256, ptr addrspace(1) %memory_load_pointer46, align 1 + store i256 %memory_load_result47, ptr %stack_var_002, align 32 + %swap1_top_value = load i256, ptr %stack_var_002, align 32 + %swap1_swap_value = load i256, ptr %stack_var_001, align 32 + store i256 %swap1_swap_value, ptr %stack_var_002, align 32 + store i256 %swap1_top_value, ptr %stack_var_001, align 32 + %dup2 = load i256, ptr %stack_var_001, align 32 + store i256 %dup2, ptr %stack_var_003, align 32 + %swap1_top_value48 = load i256, ptr %stack_var_003, align 32 + %swap1_swap_value49 = load i256, ptr %stack_var_002, align 32 + store i256 %swap1_swap_value49, ptr %stack_var_003, align 32 + store i256 %swap1_top_value48, ptr %stack_var_002, align 32 + %argument_050 = load i256, ptr %stack_var_003, align 32 + %argument_151 = load i256, ptr %stack_var_002, align 32 + %subtraction_result = sub i256 %argument_050, %argument_151 + store i256 %subtraction_result, ptr %stack_var_002, align 32 + store i256 32, ptr %stack_var_003, align 32 + %argument_052 = load i256, ptr %stack_var_003, align 32 + %argument_153 = load i256, ptr %stack_var_002, align 32 + %addition_result = add i256 %argument_052, %argument_153 + store i256 %addition_result, ptr %stack_var_002, align 32 + %swap1_top_value54 = load i256, ptr %stack_var_002, align 32 + %swap1_swap_value55 = load i256, ptr %stack_var_001, align 32 + store i256 %swap1_swap_value55, ptr %stack_var_002, align 32 + store i256 %swap1_top_value54, ptr %stack_var_001, align 32 + %argument_056 = load i256, ptr %stack_var_002, align 32 + %argument_157 = load i256, ptr %stack_var_001, align 32 + call void @__return(i256 %argument_056, i256 %argument_157, i256 0) + unreachable + +"block_rt_5/0": ; preds = %"block_rt_3/0" + store i256 42, ptr %stack_var_002, align 32 + %swap1_top_value58 = load i256, ptr %stack_var_002, align 32 + %swap1_swap_value59 = load i256, ptr %stack_var_001, align 32 + store i256 %swap1_swap_value59, ptr %stack_var_002, align 32 + store i256 %swap1_top_value58, ptr %stack_var_001, align 32 + br label %"block_rt_4/0" + +conditional_dt_1_join_block: ; preds = %"block_dt_0/0" + store i256 0, ptr %stack_var_001, align 32 + %dup12 = load i256, ptr %stack_var_001, align 32 + store i256 %dup12, ptr %stack_var_002, align 32 + %argument_03 = load i256, ptr %stack_var_002, align 32 + %argument_14 = load i256, ptr %stack_var_001, align 32 + call void @__revert(i256 %argument_03, i256 %argument_14, i256 0) + unreachable + +conditional_rt_1_join_block: ; preds = %"block_rt_0/0" + store i256 0, ptr %stack_var_001, align 32 + %dup118 = load i256, ptr %stack_var_001, align 32 + store i256 %dup118, ptr %stack_var_002, align 32 + %argument_019 = load i256, ptr %stack_var_002, align 32 + %argument_120 = load i256, ptr %stack_var_001, align 32 + call void @__revert(i256 %argument_019, i256 %argument_120, i256 0) + unreachable + +conditional_rt_2_join_block: ; preds = %"block_rt_1/0" + store i256 0, ptr %stack_var_000, align 32 + %argument_025 = load i256, ptr %stack_var_000, align 32 + %calldata_pointer26 = load ptr addrspace(3), ptr @ptr_calldata, align 32 + %calldata_pointer_with_offset = getelementptr i8, ptr addrspace(3) %calldata_pointer26, i256 %argument_025 + %calldata_value = load i256, ptr addrspace(3) %calldata_pointer_with_offset, align 32 + store i256 %calldata_value, ptr %stack_var_000, align 32 + store i256 224, ptr %stack_var_001, align 32 + %argument_027 = load i256, ptr %stack_var_001, align 32 + %argument_128 = load i256, ptr %stack_var_000, align 32 + %shr_call = call i256 @__shr(i256 %argument_027, i256 %argument_128) + store i256 %shr_call, ptr %stack_var_000, align 32 + %dup129 = load i256, ptr %stack_var_000, align 32 + store i256 %dup129, ptr %stack_var_001, align 32 + store i256 1519042605, ptr %stack_var_002, align 32 + %argument_030 = load i256, ptr %stack_var_002, align 32 + %argument_131 = load i256, ptr %stack_var_001, align 32 + %comparison_result32 = icmp eq i256 %argument_030, %argument_131 + %comparison_result_extended33 = zext i1 %comparison_result32 to i256 + store i256 %comparison_result_extended33, ptr %stack_var_001, align 32 + store i256 3, ptr %stack_var_002, align 32 + %conditional_rt_3_condition = load i256, ptr %stack_var_001, align 32 + %conditional_rt_3_condition_compared = icmp ne i256 %conditional_rt_3_condition, 0 + br i1 %conditional_rt_3_condition_compared, label %"block_rt_3/0", label %conditional_rt_3_join_block + +conditional_rt_3_join_block: ; preds = %conditional_rt_2_join_block + br label %"block_rt_2/1" +} + +attributes #0 = { nounwind } +attributes #1 = { nounwind readnone } +attributes #2 = { nounwind readonly } +attributes #3 = { writeonly } +attributes #4 = { argmemonly nocallback nofree nounwind willreturn } +attributes #5 = { noprofile } +attributes #6 = { mustprogress nofree nounwind null_pointer_is_valid readnone willreturn } +attributes #7 = { mustprogress nofree nounwind null_pointer_is_valid willreturn } +attributes #8 = { nofree null_pointer_is_valid } +``` + +### Optimized LLVM IR + +The redundancy is optimized by LLVM, resulting in the optimized LLVM IR below. + +```txt +; Function Attrs: nofree noreturn null_pointer_is_valid +define i256 @__entry(ptr addrspace(3) %0, i256 %1, i256 %2, i256 %3, i256 %4, i256 %5, i256 %6, i256 %7, i256 %8, i256 %9, i256 %10, i256 %11) local_unnamed_addr #1 personality ptr @__personality { +entry: + store ptr addrspace(3) %0, ptr @ptr_calldata, align 32 + %abi_pointer_value = ptrtoint ptr addrspace(3) %0 to i256 + %abi_pointer_value_shifted = lshr i256 %abi_pointer_value, 96 + %abi_length_value = and i256 %abi_pointer_value_shifted, 4294967295 + store i256 %abi_length_value, ptr @calldatasize, align 32 + %is_deploy_code_call_flag_truncated = and i256 %1, 1 + %is_deploy_code_call_flag.not = icmp eq i256 %is_deploy_code_call_flag_truncated, 0 + store i256 128, ptr addrspace(1) inttoptr (i256 64 to ptr addrspace(1)), align 64 + %get_u128_value.i.i1 = tail call i256 @llvm.syncvm.getu128() + br i1 %is_deploy_code_call_flag.not, label %runtime_code_call_block, label %deploy_code_call_block + +deploy_code_call_block: ; preds = %entry + %comparison_result.i.i = icmp eq i256 %get_u128_value.i.i1, 0 + br i1 %comparison_result.i.i, label %"block_dt_1/0.i.i", label %"block_rt_2/0.i.i" + +"block_dt_1/0.i.i": ; preds = %deploy_code_call_block + store i256 32, ptr addrspace(2) inttoptr (i256 256 to ptr addrspace(2)), align 256 + store i256 0, ptr addrspace(2) inttoptr (i256 288 to ptr addrspace(2)), align 32 + tail call void @llvm.syncvm.return(i256 53919893334301279589334030174039261352344891250716429051063678533632) + unreachable + +"block_rt_2/0.i.i": ; preds = %runtime_code_call_block, %conditional_rt_2_join_block.i.i, %deploy_code_call_block + tail call void @llvm.syncvm.revert(i256 0) + unreachable + +runtime_code_call_block: ; preds = %entry + %comparison_result.i.i2 = icmp ne i256 %get_u128_value.i.i1, 0 + %calldatasize.i.i = load i256, ptr @calldatasize, align 32 + %comparison_result23.i.i = icmp ult i256 %calldatasize.i.i, 4 + %or.cond.i.i = select i1 %comparison_result.i.i2, i1 true, i1 %comparison_result23.i.i + br i1 %or.cond.i.i, label %"block_rt_2/0.i.i", label %conditional_rt_2_join_block.i.i + +"block_rt_3/0.i.i": ; preds = %conditional_rt_2_join_block.i.i + %memory_load_result.i.i = load i256, ptr addrspace(1) inttoptr (i256 64 to ptr addrspace(1)), align 64 + %memory_store_pointer44.i.i = inttoptr i256 %memory_load_result.i.i to ptr addrspace(1) + store i256 42, ptr addrspace(1) %memory_store_pointer44.i.i, align 1 + %memory_load_result47.i.i = load i256, ptr addrspace(1) inttoptr (i256 64 to ptr addrspace(1)), align 64 + %subtraction_result.i.i = add i256 %memory_load_result.i.i, 32 + %addition_result.i.i = sub i256 %subtraction_result.i.i, %memory_load_result47.i.i + %12 = tail call i256 @llvm.umin.i256(i256 %memory_load_result47.i.i, i256 4294967295) + %13 = tail call i256 @llvm.umin.i256(i256 %addition_result.i.i, i256 4294967295) + %offset_shifted.i.i.i.i = shl nuw nsw i256 %12, 64 + %length_shifted.i.i.i.i = shl nuw nsw i256 %13, 96 + %tmp.i.i.i.i = or i256 %length_shifted.i.i.i.i, %offset_shifted.i.i.i.i + tail call void @llvm.syncvm.return(i256 %tmp.i.i.i.i) + unreachable + +conditional_rt_2_join_block.i.i: ; preds = %runtime_code_call_block + %calldata_pointer26.i.i = load ptr addrspace(3), ptr @ptr_calldata, align 32 + %calldata_value.i.i = load i256, ptr addrspace(3) %calldata_pointer26.i.i, align 32 + %shift_res.i.mask.i.i = and i256 %calldata_value.i.i, -26959946667150639794667015087019630673637144422540572481103610249216 + %comparison_result32.i.i = icmp eq i256 %shift_res.i.mask.i.i, 40953307615929575801107647705360601464619672688377251939886941387873771847680 + br i1 %comparison_result32.i.i, label %"block_rt_3/0.i.i", label %"block_rt_2/0.i.i" +} + +attributes #0 = { nounwind } +attributes #1 = { nofree noreturn null_pointer_is_valid } +attributes #2 = { noreturn nounwind } +attributes #3 = { nocallback nofree nosync nounwind readnone speculatable willreturn } +``` + +### EraVM Assembly + +The optimized LLVM IR is translated into EraVM assembly below, allowing the size comparable to the Yul pipeline. + +```asm + .text + .file "default.sol:Test" + .globl __entry +__entry: +.func_begin0: + ptr.add r1, r0, stack[@ptr_calldata] + shr.s 96, r1, r1 + and @CPI0_0[0], r1, stack[@calldatasize] + add 128, r0, r1 + st.1 64, r1 + context.get_context_u128 r1 + and! 1, r2, r2 + jump.ne @.BB0_1 + sub! r1, r0, r1 + jump.ne @.BB0_3 + add stack[@calldatasize], r0, r1 + sub.s! 4, r1, r1 + jump.lt @.BB0_3 + ptr.add stack[@ptr_calldata], r0, r1 + ld r1, r1 + and @CPI0_2[0], r1, r1 + sub.s! @CPI0_3[0], r1, r1 + jump.ne @.BB0_3 + ld.1 64, r1 + add 42, r0, r2 + st.1 r1, r2 + ld.1 64, r2 + sub r1, r2, r1 + add 32, r1, r1 + add @CPI0_0[0], r0, r3 + sub.s! @CPI0_0[0], r1, r4 + add.ge r3, r0, r1 + sub.s! @CPI0_0[0], r2, r4 + add.ge r3, r0, r2 + shl.s 64, r2, r2 + shl.s 96, r1, r1 + or r1, r2, r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN +.BB0_1: + sub! r1, r0, r1 + jump.ne @.BB0_3 + add 32, r0, r1 + st.2 256, r1 + st.2 288, r0 + add @CPI0_1[0], r0, r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN +.BB0_3: + add r0, r0, r1 + ret.revert.to_label r1, @DEFAULT_FAR_REVERT +.func_end0: + + .data + .p2align 5 +calldatasize: + .cell 0 + + .p2align 5 +ptr_calldata: +.cell 0 + + .note.GNU-stack + .rodata +CPI0_0: + .cell 4294967295 +CPI0_1: + .cell 53919893334301279589334030174039261352344891250716429051063678533632 +CPI0_2: + .cell -26959946667150639794667015087019630673637144422540572481103610249216 +CPI0_3: + .cell 40953307615929575801107647705360601464619672688377251939886941387873771847680 +``` + +For comparison, the Yul pipeline of solc v0.8.21 produces the following EraVM assembly: + +```asm + .text + .file "default.sol:Test" + .globl __entry +__entry: +.func_begin0: + ptr.add r1, r0, stack[@ptr_calldata] + shr.s 96, r1, r1 + and @CPI0_0[0], r1, stack[@calldatasize] + add 128, r0, r1 + st.1 64, r1 + and! 1, r2, r1 + jump.ne @.BB0_1 + add stack[@calldatasize], r0, r1 + sub.s! 4, r1, r1 + jump.lt @.BB0_2 + ptr.add stack[@ptr_calldata], r0, r1 + ld r1, r1 + and @CPI0_2[0], r1, r1 + sub.s! @CPI0_3[0], r1, r1 + jump.ne @.BB0_2 + context.get_context_u128 r1 + sub! r1, r0, r1 + jump.ne @.BB0_2 + sub.s 4, r0, r1 + add stack[@calldatasize], r1, r1 + add @CPI0_4[0], r0, r2 + sub! r1, r0, r3 + add r0, r0, r3 + add.lt r2, r0, r3 + and @CPI0_4[0], r1, r1 + sub! r1, r0, r4 + add.le r0, r0, r2 + sub.s! @CPI0_4[0], r1, r1 + add r3, r0, r1 + add.eq r2, r0, r1 + sub! r1, r0, r1 + jump.ne @.BB0_2 + add 42, r0, r1 + st.1 128, r1 + add @CPI0_5[0], r0, r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN +.BB0_1: + context.get_context_u128 r1 + sub! r1, r0, r1 + jump.ne @.BB0_2 + add 32, r0, r1 + st.2 256, r1 + st.2 288, r0 + add @CPI0_1[0], r0, r1 + ret.ok.to_label r1, @DEFAULT_FAR_RETURN +.BB0_2: + add r0, r0, r1 + ret.revert.to_label r1, @DEFAULT_FAR_REVERT +.func_end0: + + .data + .p2align 5 +calldatasize: + .cell 0 + + .p2align 5 +ptr_calldata: +.cell 0 + + .note.GNU-stack + .rodata +CPI0_0: + .cell 4294967295 +CPI0_1: + .cell 53919893334301279589334030174039261352344891250716429051063678533632 +CPI0_2: + .cell -26959946667150639794667015087019630673637144422540572481103610249216 +CPI0_3: + .cell 40953307615929575801107647705360601464619672688377251939886941387873771847680 +CPI0_4: + .cell -57896044618658097711785492504343953926634992332820282019728792003956564819968 +CPI0_5: + .cell 2535301202817642044428229017600 +``` diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/10.overview.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/10.overview.md new file mode 100644 index 00000000..60d8a250 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/10.overview.md @@ -0,0 +1,48 @@ +--- +title: Instruction Reference +description: +--- + +In this specification, instructions are grouped by their relevance to the EVM instruction set: + +- [Native EVM instructions](evm/overview). +- [Yul auxiliary instructions](yul). +- [EVM legacy assembly auxiliary instructions](evmla). + +Most of the EVM native instructions are represented in both Yul and EVM legacy assembly IRs. If they are not, it is +stated explicitly in the description of each instruction. + +## Addressing modes + +EraVM is a register-based virtual machine with different addressing modes. +It overrides all stack mechanics described in [the original EVM opcodes documentation](https://www.evm.codes/) including +errors they produce on EVM. + +## Solidity Intermediate Representations (IRs) + +Every instruction is translated via two IRs available in the Solidity compiler unless stated otherwise: + +1. Yul +2. EVM legacy assembly + +## Yul Extensions + +At the moment there is no way of adding zkSync-specific instructions to Yul as long as we use the official Solidity +compiler, which would produce an error on an unknown instruction. + +There are two ways of supporting such instructions: one for Solidity and one for Yul. + +### The Solidity Mode + +In Solidity we have introduced **call simulations**. They are not actual calls, as they are substituted by our Yul +translator with the needed instruction, depending on the constant address. This way the Solidity compiler is not +optimizing them out and is not emitting compilation errors. + +The reference of such extensions is coming soon. + +### The Yul Mode + +The non-call zkSync-specific instructions are only available in the Yul mode of **zksolc**. +To have better compatibility, they are implemented as `verbatim` instructions with some predefined keys. + +The reference of such extensions is coming soon. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/10.overview.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/10.overview.md new file mode 100644 index 00000000..0888a432 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/10.overview.md @@ -0,0 +1,29 @@ +--- +title: Overview +description: +--- + +## Native EVM Instructions + +Such instructions are grouped into the following categories according to [the original reference](https://www.evm.codes/): + +- [Arithmetic](arithmetic) +- [Logical](logical) +- [Bitwise](bitwise) +- [Hashes](hashes) +- [Environment](environment) +- [Block](block) +- [Stack](stack) +- [Memory](memory) +- [Storage](storage) +- [Events](events) +- [Calls](calls) +- [Create](create) +- [Return](return) + +### zkSync VM Assembly + +Assembly emitted for LLVM standard library functions depends on available optimizations which differ between versions. If there is no +assembly example under an instruction, compile a reproducing contract with the latest version of `zksolc`. + +zkSync VM specification contains a list of [all zkSync VM instructions (see the table of contents)](%%zk_git_repo_eravm-spec%%/spec.html). diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/arithmetic.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/arithmetic.md new file mode 100644 index 00000000..28bfedf9 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/arithmetic.md @@ -0,0 +1,369 @@ +--- +title: Arithmetic +description: +--- + +## ADD + +Original [EVM](https://www.evm.codes/#01?fork=shanghai) instruction. + +### LLVM IR + +```txt +%addition_result = add i256 %value1, %value2 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L15) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#add-instruction) + +### EraVM Assembly + +```asm +add r1, r2, r1 +``` + +For more detail, see the [EraVM specification reference](%%zk_git_repo_eravm-spec%%/spec.html#AddDefinition) + +## MUL + +Original [EVM](https://www.evm.codes/#02?fork=shanghai) instruction. + +### Differences from EVM + +1. The carry is written to the 2nd output register + +### LLVM IR + +```txt +%multiplication_result = mul i256 %value1, %value2 +``` + +EraVM can output the carry of the multiplication operation. +In this case, the result is a tuple of two values: the multiplication result and the carry. +The carry is written to the 2nd output register. +The snippet below returns the carry value. + +```txt +%value1_extended = zext i256 %value1 to i512 +%value2_extended = zext i256 %value2 to i512 +%result_extended = mul nuw i512 %value1_extended, %value2_extended +%result_shifted = lshr i512 %result_extended, 256 +%result = trunc i512 %result_shifted to i256 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L53) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#mul-instruction) + +### EraVM Assembly + +```asm +mul r1, r2, r1, r2 +``` + +For more detail, see the [EraVM specification reference](%%zk_git_repo_eravm-spec%%/spec.html#MulDefinition) + +## SUB + +Original [EVM](https://www.evm.codes/#03?fork=shanghai) instruction. + +### LLVM IR + +```txt +%subtraction_result = sub i256 %value1, %value2 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L34) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#sub-instruction) + +### EraVM Assembly + +```asm +sub r1, r2, r1 +``` + +For more detail, see the [EraVM specification reference](%%zk_git_repo_eravm-spec%%/spec.html#SubDefinition) + +## DIV + +Original [EVM](https://www.evm.codes/#04?fork=shanghai) instruction. + +### Differences from EVM + +1. The remainder is written to the 2nd output register + +### LLVM IR + +```text +define i256 @__div(i256 %arg1, i256 %arg2) #0 { +entry: + %is_divider_zero = icmp eq i256 %arg2, 0 + br i1 %is_divider_zero, label %return, label %division + +division: + %div_res = udiv i256 %arg1, %arg2 + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %div_res, %division ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L73) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#udiv-instruction) + +For more detail, see the [EraVM specification reference](%%zk_git_repo_eravm-spec%%/spec.html#DivDefinition) + +## SDIV + +Original [EVM](https://www.evm.codes/#05?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__sdiv(i256 %arg1, i256 %arg2) #0 { +entry: + %is_divider_zero = icmp eq i256 %arg2, 0 + br i1 %is_divider_zero, label %return, label %division_overflow + +division_overflow: + %is_divided_int_min = icmp eq i256 %arg1, -57896044618658097711785492504343953926634992332820282019728792003956564819968 + %is_minus_one = icmp eq i256 %arg2, -1 + %is_overflow = and i1 %is_divided_int_min, %is_minus_one + br i1 %is_overflow, label %return, label %division + +division: + %div_res = sdiv i256 %arg1, %arg2 + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %arg1, %division_overflow ], [ %div_res, %division ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L162) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#sdiv-instruction) + +EraVM does not have a similar instruction. + +## MOD + +Original [EVM](https://www.evm.codes/#06?fork=shanghai) instruction. + +### Differences from EVM + +1. The remainder is written to the 2nd output register + +### LLVM IR + +```txt +define i256 @__mod(i256 %arg1, i256 %arg2) #0 { +entry: + %is_divider_zero = icmp eq i256 %arg2, 0 + br i1 %is_divider_zero, label %return, label %remainder + +remainder: + %rem_res = urem i256 %arg1, %arg2 + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %rem_res, %remainder ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L117) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#urem-instruction) + +For more detail, see the [EraVM specification reference](%%zk_git_repo_eravm-spec%%/spec.html#DivDefinition) + +## SMOD + +Original [EVM](https://www.evm.codes/#07?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__smod(i256 %arg1, i256 %arg2) #0 { +entry: + %is_divider_zero = icmp eq i256 %arg2, 0 + br i1 %is_divider_zero, label %return, label %division_overflow + +division_overflow: + %is_divided_int_min = icmp eq i256 %arg1, -57896044618658097711785492504343953926634992332820282019728792003956564819968 + %is_minus_one = icmp eq i256 %arg2, -1 + %is_overflow = and i1 %is_divided_int_min, %is_minus_one + br i1 %is_overflow, label %return, label %remainder + +remainder: + %rem_res = srem i256 %arg1, %arg2 + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ 0, %division_overflow ], [ %rem_res, %remainder ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/arithmetic.rs#L236) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#srem-instruction) + +EraVM does not have a similar instruction. + +## ADDMOD + +Original [EVM](https://www.evm.codes/#08?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__addmod(i256 %arg1, i256 %arg2, i256 %modulo) #0 { +entry: + %is_zero = icmp eq i256 %modulo, 0 + br i1 %is_zero, label %return, label %addmod + +addmod: + %arg1m = urem i256 %arg1, %modulo + %arg2m = urem i256 %arg2, %modulo + %res = call {i256, i1} @llvm.uadd.with.overflow.i256(i256 %arg1m, i256 %arg2m) + %sum = extractvalue {i256, i1} %res, 0 + %obit = extractvalue {i256, i1} %res, 1 + %sum.mod = urem i256 %sum, %modulo + br i1 %obit, label %overflow, label %return + +overflow: + %mod.inv = xor i256 %modulo, -1 + %sum1 = add i256 %sum, %mod.inv + %sum.ovf = add i256 %sum1, 1 + br label %return + +return: + %value = phi i256 [0, %entry], [%sum.mod, %addmod], [%sum.ovf, %overflow] + ret i256 %value +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/math.rs#L16) is common for Yul and EVMLA representations. + +EraVM does not have a similar instruction. + +## MULMOD + +Original [EVM](https://www.evm.codes/#09?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__mulmod(i256 %arg1, i256 %arg2, i256 %modulo) #0 { +entry: + %cccond = icmp eq i256 %modulo, 0 + br i1 %cccond, label %ccret, label %entrycont + +ccret: + ret i256 0 + +entrycont: + %arg1m = urem i256 %arg1, %modulo + %arg2m = urem i256 %arg2, %modulo + %less_then_2_128 = icmp ult i256 %modulo, 340282366920938463463374607431768211456 + br i1 %less_then_2_128, label %fast, label %slow + +fast: + %prod = mul i256 %arg1m, %arg2m + %prodm = urem i256 %prod, %modulo + ret i256 %prodm + +slow: + %arg1e = zext i256 %arg1m to i512 + %arg2e = zext i256 %arg2m to i512 + %prode = mul i512 %arg1e, %arg2e + %prodl = trunc i512 %prode to i256 + %prodeh = lshr i512 %prode, 256 + %prodh = trunc i512 %prodeh to i256 + %res = call i256 @__ulongrem(i256 %prodl, i256 %prodh, i256 %modulo) + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/math.rs#L43) is common for Yul and EVMLA representations. + +EraVM does not have a similar instruction. + +## EXP + +Original [EVM](https://www.evm.codes/#0a?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__exp(i256 %value, i256 %exp) "noinline-oz" #0 { +entry: + %exp_is_non_zero = icmp eq i256 %exp, 0 + br i1 %exp_is_non_zero, label %return, label %exponent_loop_body + +return: + %exp_res = phi i256 [ 1, %entry ], [ %exp_res.1, %exponent_loop_body ] + ret i256 %exp_res + +exponent_loop_body: + %exp_res.2 = phi i256 [ %exp_res.1, %exponent_loop_body ], [ 1, %entry ] + %exp_val = phi i256 [ %exp_val_halved, %exponent_loop_body ], [ %exp, %entry ] + %val_squared.1 = phi i256 [ %val_squared, %exponent_loop_body ], [ %value, %entry ] + %odd_test = and i256 %exp_val, 1 + %is_exp_odd = icmp eq i256 %odd_test, 0 + %exp_res.1.interm = select i1 %is_exp_odd, i256 1, i256 %val_squared.1 + %exp_res.1 = mul i256 %exp_res.1.interm, %exp_res.2 + %val_squared = mul i256 %val_squared.1, %val_squared.1 + %exp_val_halved = lshr i256 %exp_val, 1 + %exp_val_is_less_2 = icmp ult i256 %exp_val, 2 + br i1 %exp_val_is_less_2, label %return, label %exponent_loop_body +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/math.rs#L70) is common for Yul and EVMLA representations. + +EraVM does not have a similar instruction. + +## SIGNEXTEND + +Original [EVM](https://www.evm.codes/#0b?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__signextend(i256 %numbyte, i256 %value) #0 { +entry: + %is_overflow = icmp uge i256 %numbyte, 31 + br i1 %is_overflow, label %return, label %signextend + +signextend: + %numbit_byte = mul nuw nsw i256 %numbyte, 8 + %numbit = add nsw nuw i256 %numbit_byte, 7 + %numbit_inv = sub i256 256, %numbit + %signmask = shl i256 1, %numbit + %valmask = lshr i256 -1, %numbit_inv + %ext1 = shl i256 -1, %numbit + %signv = and i256 %signmask, %value + %sign = icmp ne i256 %signv, 0 + %valclean = and i256 %value, %valmask + %sext = select i1 %sign, i256 %ext1, i256 0 + %result = or i256 %sext, %valclean + br label %return + +return: + %signext_res = phi i256 [%value, %entry], [%result, %signextend] + ret i256 %signext_res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/math.rs#L93) is common for Yul and EVMLA representations. + +EraVM does not have a similar instruction. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/bitwise.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/bitwise.md new file mode 100644 index 00000000..fa533b4f --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/bitwise.md @@ -0,0 +1,218 @@ +--- +title: Bitwise +description: +--- + +## AND + +Original [EVM](https://www.evm.codes/#16?fork=shanghai) instruction. + +### LLVM IR + +```txt +%and_result = and i256 %value1, %value2 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L47) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#and-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +and r1, r2, r1 +st.1 128, r1 +``` + +[EraVM instruction: `and`](%%zk_git_repo_eravm-spec%%/spec.html#AndDefinition) + +## OR + +Original [EVM](https://www.evm.codes/#17?fork=shanghai) instruction. + +### LLVM IR + +```txt +%or_result = or i256 %value1, %value2 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L13) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#or-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +or r1, r2, r1 +st.1 128, r1 +``` + +[EraVM instruction: `or`](%%zk_git_repo_eravm-spec%%/spec.html#AndDefinition) + +## XOR + +Original [EVM](https://www.evm.codes/#18?fork=shanghai) instruction. + +### LLVM IR + +```txt +%xor_result = or i256 %value1, %value2 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L30) is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#xor-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +xor r1, r2, r1 +st.1 128, r1 +``` + +[EraVM instruction: `xor`](%%zk_git_repo_eravm-spec%%/spec.html#XorDefinition) + +## NOT + +Original [EVM](https://www.evm.codes/#19?fork=shanghai) instruction. + +### LLVM IR + +```txt +%xor_result = xor i256 %value, -1 +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L30) is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r1, r1 +ld r1, r1 +sub.s 1, r0, r2 +xor r1, r2, r1 +st.1 128, r1 +``` + +[EraVM instruction: `xor`](%%zk_git_repo_eravm-spec%%/spec.html#XorDefinition) + +## BYTE + +Original [EVM](https://www.evm.codes/#1a?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__byte(i256 %index, i256 %value) #0 { +entry: + %is_overflow = icmp ugt i256 %index, 31 + br i1 %is_overflow, label %return, label %extract_byte + +extract_byte: + %bits_offset = shl i256 %index, 3 + %value_shifted_left = shl i256 %value, %bits_offset + %value_shifted_right = lshr i256 %value_shifted_left, 248 + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %value_shifted_right, %extract_byte ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L229) is common for Yul and EVMLA representations. + +## SHL + +Original [EVM](https://www.evm.codes/#1b?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__shl(i256 %shift, i256 %value) #0 { +entry: + %is_overflow = icmp ugt i256 %shift, 255 + br i1 %is_overflow, label %return, label %shift_value + +shift_value: + %shift_res = shl i256 %value, %shift + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %shift_res, %shift_value ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L67) is common for Yul and EVMLA representations. + +## SHR + +Original [EVM](https://www.evm.codes/#1c?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__shr(i256 %shift, i256 %value) #0 { +entry: + %is_overflow = icmp ugt i256 %shift, 255 + br i1 %is_overflow, label %return, label %shift_value + +shift_value: + %shift_res = lshr i256 %value, %shift + br label %return + +return: + %res = phi i256 [ 0, %entry ], [ %shift_res, %shift_value ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L111) is common for Yul and EVMLA representations. + +[EraVM instruction: `xor`](%%zk_git_repo_eravm-spec%%/spec.html#XorDefinition) + +## SAR + +Original [EVM](https://www.evm.codes/#1d?fork=shanghai) instruction. + +### LLVM IR + +```txt +define i256 @__sar(i256 %shift, i256 %value) #0 { +entry: + %is_overflow = icmp ugt i256 %shift, 255 + br i1 %is_overflow, label %arith_overflow, label %shift_value + +arith_overflow: + %is_val_positive = icmp sge i256 %value, 0 + %res_overflow = select i1 %is_val_positive, i256 0, i256 -1 + br label %return + +shift_value: + %shift_res = ashr i256 %value, %shift + br label %return + +return: + %res = phi i256 [ %res_overflow, %arith_overflow ], [ %shift_res, %shift_value ] + ret i256 %res +} +``` + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/bitwise.rs#L157) is common for Yul and EVMLA representations. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/block.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/block.md new file mode 100644 index 00000000..de6ad9eb --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/block.md @@ -0,0 +1,156 @@ +--- +title: Block +description: +--- + +## BLOCKHASH + +Original [EVM](https://www.evm.codes/#40?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L47) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## COINBASE + +Original [EVM](https://www.evm.codes/#41?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L150) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## TIMESTAMP + +Original [EVM](https://www.evm.codes/#42?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L98) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## NUMBER + +Original [EVM](https://www.evm.codes/#43?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L81) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## PREVRANDAO + +Original [EVM](https://www.evm.codes/#44?fork=shanghai) instruction. | DIFFICULTY + +Original [EVM](https://www.evm.codes/#44?fork=grayGlacier) + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L133) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## GASLIMIT + +Original [EVM](https://www.evm.codes/#45?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L13) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## CHAINID + +Original [EVM](https://www.evm.codes/#46?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L64) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## SELFBALANCE + +Original [EVM](https://www.evm.codes/#47?fork=shanghai) instruction. + +Implemented as [BALANCE](environment#balance) with an [ADDRESS](environment#address) as its argument. + +## BASEFEE + +Original [EVM](https://www.evm.codes/#48?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L167) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/calls.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/calls.md new file mode 100644 index 00000000..ac85433d --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/calls.md @@ -0,0 +1,42 @@ +--- +title: Calls +description: +--- + +All EVM call instructions are handled similarly. + +The call type is encoded on the assembly level, so we will describe the common handling workflow, mentioning distinctions if there are any. + + + + +## CALL + +Original [EVM](https://www.evm.codes/#f1?fork=shanghai) instruction. + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/call.rs#L530) +is common for Yul and EVMLA representations. + +The code checks if the call is non-static and the Ether value is non-zero. If so, the call is redirected to the [MsgValueSimulator](../../system-contracts#ether-value-simulator). + +- [EraVM instruction: `call` (near call)](https://matter-labs.github.io/eravm-spec/spec.html#NearCallDefinition) +- [EraVM instruction: `far_call`](https://matter-labs.github.io/eravm-spec/spec.html#FarCalls) + +## DELEGATECALL + +Original [EVM](https://www.evm.codes/#f4?fork=shanghai) instruction. + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/call.rs#L530) +is common for Yul and EVMLA representations. + +[EraVM instruction: `far_call`](https://matter-labs.github.io/eravm-spec/spec.html#FarCalls) + +## STATICCALL + +Original [EVM](https://www.evm.codes/#fa?fork=shanghai) instruction. + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/call.rs#L530) +is common for Yul and EVMLA representations. + +[EraVM instruction: `far_call`](https://matter-labs.github.io/eravm-spec/spec.html#FarCalls) diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/create.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/create.md new file mode 100644 index 00000000..fd809037 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/create.md @@ -0,0 +1,22 @@ +--- +title: Create +description: +--- + +The EVM CREATE instructions are handled similarly. + +For more information, see the [zkSync Era documentation](https://era.zksync.io/docs/reference/architecture/differences-with-ethereum.html#create-create2). + +## CREATE + +Original [EVM](https://www.evm.codes/#f0?fork=shanghai) instruction. + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/create.rs#L19) +is common for Yul and EVMLA representations. + +## CREATE2 + +Original [EVM](https://www.evm.codes/#f5?fork=shanghai) instruction. + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/create.rs#L57) +is common for Yul and EVMLA representations. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/environment.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/environment.md new file mode 100644 index 00000000..a00ce2fc --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/environment.md @@ -0,0 +1,332 @@ +--- +title: Environment +--- + +## ADDRESS + +Original [EVM](https://www.evm.codes/#30?fork=shanghai) instruction. + +This value is fetched with a native [EraVM instruction: `context.this`](https://matter-labs.github.io/eravm-spec/spec.html#ContextDefinitions). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L973) +is common for Yul and EVMLA representations. + +## BALANCE + +Original [EVM](https://www.evm.codes/#31?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [L2EthToken](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/L2EthToken.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/ether_gas.rs#L39) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## ORIGIN + +Original [EVM](https://www.evm.codes/#32?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L47) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## CALLER + +Original [EVM](https://www.evm.codes/#33?fork=shanghai) instruction. + +This value is fetched with a native [EraVM instruction: `context.caller`](https://matter-labs.github.io/eravm-spec/spec.html#ContextDefinitions). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L974) +is common for Yul and EVMLA representations. + +## CALLVALUE + +Original [EVM](https://www.evm.codes/#34?fork=shanghai) instruction. + +This value is fetched with a native [EraVM instruction: `context.get_context_u128`](https://matter-labs.github.io/eravm-spec/spec.html#ContextDefinitions). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/ether_gas.rs#L25) +is common for Yul and EVMLA representations. + +## CALLDATALOAD + +Original [EVM](https://www.evm.codes/#35?fork=shanghai) instruction. + +Calldata is accessed with a generic memory access instruction, but the memory chunk itself is a reference +to the calling contract's heap. +A fat pointer to the parent contract is passed via ABI using registers. + +Then, the pointer [is saved to a global stack variable](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/entry.rs#L129) +accessible from anywhere in the contract. + +### LLVM IR + +```txt +@ptr_calldata = private unnamed_addr global ptr addrspace(3) null ; global variable declaration +... +store ptr addrspace(3) %0, ptr @ptr_calldata, align 32 ; saving the pointer from `r1` to the global variable +... +%calldata_pointer = load ptr addrspace(3), ptr @ptr_calldata, align 32 ; loading the pointer from the global variable to `calldata_pointer` +%calldata_value = load i256, ptr addrspace(3) %calldata_pointer, align 32 ; loading the value from the calldata pointer +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/calldata.rs#L14) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +ptr.add r1, r0, stack[@ptr_calldata] ; saving the pointer from `r1` to the global variable +... +ptr.add stack[@ptr_calldata], r0, r1 ; loading the pointer from the global variable to `r1` +ld r1, r1 ; loading the value to `r1` +``` + +- [EraVM instruction: `ptr.add`](https://matter-labs.github.io/eravm-spec/spec.html#PtrAddDefinition) +- [EraVM fat pointers](https://matter-labs.github.io/eravm-spec/spec.html#PointerDefinitions) +- [EraVM memory forwarding mechanism](https://matter-labs.github.io/eravm-spec/spec.html#MemoryForwarding) + +## CALLDATASIZE + +Original [EVM](https://www.evm.codes/#36?fork=shanghai) instruction. + +Calldata size is stored in the fat pointer passed from the parent contract (see [CALLDATALOAD](#calldataload)). + +The size value can be extracted with bitwise operations as illustrated below. + +### LLVM IR + +```txt +@calldatasize = private unnamed_addr global i256 0 ; global variable declaration +... +%abi_pointer_value = ptrtoint ptr addrspace(3) %0 to i256 ; converting the pointer to an integer +%abi_pointer_value_shifted = lshr i256 %abi_pointer_value, 96 ; shifting the integer right 96 bits +%abi_length_value = and i256 %abi_pointer_value_shifted, 4294967295 ; keeping the lowest 32 bits of the integer +store i256 %abi_length_value, ptr @calldatasize, align 32 ; saving the value to the global variable +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/calldata.rs#L40) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +ptr.add r1, r0, stack[@ptr_calldata] ; saving the pointer from `r1` to the global variable +shr.s 96, r1, r1 ; shifting the integer right 96 bits +and @CPI0_0[0], r1, stack[@calldatasize] ; keeping the lowest 32 bits of the integer, saving the value to the global variable +... +CPI0_0: + .cell 4294967295 +``` + +- [EraVM instruction: `ptr.add`](https://matter-labs.github.io/eravm-spec/spec.html#PtrAddDefinition) +- [EraVM fat pointers](https://matter-labs.github.io/eravm-spec/spec.html#PointerDefinitions) +- [EraVM memory forwarding mechanism](https://matter-labs.github.io/eravm-spec/spec.html#MemoryForwarding) + +## CALLDATACOPY + +Original [EVM](https://www.evm.codes/#37?fork=shanghai) instruction. + +Unlike on EVM, on EraVM it is a simple loop over [CALLDATALOAD](#calldataload)). + +### LLVM IR + +```txt +; loading the pointer from the global variable to `calldata_pointer` +%calldata_pointer = load ptr addrspace(3), ptr @ptr_calldata, align 32 +; shifting the pointer by 122 bytes +%calldata_source_pointer = getelementptr i8, ptr addrspace(3) %calldata_pointer, i256 122 +; copying 64 bytes from calldata at offset 122 to the heap at offset 128 +call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) align 1 inttoptr (i256 128 to ptr addrspace(1)), ptr addrspace(3) align 1 %calldata_source_pointer, i256 64, i1 false) +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/calldata.rs#L54) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +.BB0_3: + shl.s 5, r2, r3 ; shifting the offset by 32 + ptr.add r1, r3, r4 ; adding the offset to the calldata pointer + ld r4, r4 ; reading the calldata value + add 128, r3, r3 ; adding the offset to the heap pointer + st.1 r3, r4 ; writing the calldata value to the heap + add 1, r2, r2 ; incrementing the offset + sub.s! 2, r2, r3 ; checking the bounds + jump.lt @.BB0_3 ; loop continuation branching +``` + +- [EraVM instruction: `ptr.add`](https://matter-labs.github.io/eravm-spec/spec.html#PtrAddDefinition) +- [EraVM fat pointers](https://matter-labs.github.io/eravm-spec/spec.html#PointerDefinitions) +- [EraVM memory forwarding mechanism](https://matter-labs.github.io/eravm-spec/spec.html#MemoryForwarding) + +## CODECOPY + +Original [EVM](https://www.evm.codes/#38?fork=shanghai) instruction. + +See [the EraVM docs](https://era.zksync.io/docs/reference/architecture/differences-with-ethereum.html#codecopy). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L856). + +## CODESIZE + +Original [EVM](https://www.evm.codes/#39?fork=shanghai) instruction. + +See [the EraVM docs](https://era.zksync.io/docs/reference/architecture/differences-with-ethereum.html#codesize). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L837). + +## GASPRICE + +Original [EVM](https://www.evm.codes/#3a?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [SystemContext](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/SystemContext.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/context.rs#L30) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## EXTCODESIZE + +Original [EVM](https://www.evm.codes/#3b?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [AccountCodeStorage](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/AccountCodeStorage.sol). + +On how the System Contract is called, see [this section](../../system-contracts#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/ext_code.rs#L11) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. + +## EXTCODECOPY + +Original [EVM](https://www.evm.codes/#3c?fork=shanghai) instruction. + +Not supported. Triggers a compile-time error. + +## RETURNDATASIZE + +Original [EVM](https://www.evm.codes/#3d?fork=shanghai) instruction. + +Return data size is read from the fat pointer returned from the child contract. + +The size value can be extracted with bitwise operations as illustrated below. + +### LLVM IR + +```txt +%contract_call_external = tail call { ptr addrspace(3), i1 } @__farcall(i256 0, i256 0, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef) +%contract_call_external_result_abi_data = extractvalue { ptr addrspace(3), i1 } %contract_call_external, 0 +%contract_call_memcpy_from_child_pointer_casted = ptrtoint ptr addrspace(3) %contract_call_external_result_abi_data to i256 +%contract_call_memcpy_from_child_return_data_size_shifted = lshr i256 %contract_call_memcpy_from_child_pointer_casted, 96 +%contract_call_memcpy_from_child_return_data_size_truncated = and i256 %contract_call_memcpy_from_child_return_data_size_shifted, 4294967295 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return_data.rs#L16) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +near_call r0, @__farcall, @DEFAULT_UNWIND ; calling a child contract +shr.s 96, r1, r1 ; shifting the pointer value right 96 bits +and @CPI0_1[0], r1, r1 ; keeping the lowest 32 bits of the pointer value +... +CPI0_1: + .cell 4294967295 +``` + +[EraVM instruction: `call`](https://matter-labs.github.io/eravm-spec/spec.html#NearCallDefinition) + +## RETURNDATACOPY + +Original [EVM](https://www.evm.codes/#3e?fork=shanghai) instruction. + +Unlike on EVM, on EraVM it is a simple loop over memory operations on 256-bit values. + +### LLVM IR + +```txt +; loading the pointer from the global variable to `return_data_pointer` +%return_data_pointer = load ptr addrspace(3), ptr @ptr_return_data, align 32 +; shifting the pointer by 122 bytes +%return_data_source_pointer = getelementptr i8, ptr addrspace(3) %return_data_pointer, i256 122 +; copying 64 bytes from return data at offset 122 to the heap at offset 128 +call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) align 1 inttoptr (i256 128 to ptr addrspace(1)), ptr addrspace(3) align 1 %return_data_source_pointer, i256 64, i1 false) +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return_data.rs#L31) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +.BB0_3: + shl.s 5, r2, r3 ; shifting the offset by 32 + ptr.add r1, r3, r4 ; adding the offset to the return data pointer + ld r4, r4 ; reading the return data value + add 128, r3, r3 ; adding the offset to the heap pointer + st.1 r3, r4 ; writing the return data value to the heap + add 1, r2, r2 ; incrementing the offset + sub.s! 2, r2, r3 ; checking the bounds + jump.lt @.BB0_3 ; loop continuation branching +``` + +- [EraVM instruction: `jump`](https://matter-labs.github.io/eravm-spec/spec.html#JumpDefinition) +- [EraVM instruction predication](https://matter-labs.github.io/eravm-spec/spec.html#Predication) + +## EXTCODEHASH + +Original [EVM](https://www.evm.codes/#3f?fork=shanghai) instruction. + +### System Contract + +This information is requested a System Contract called [AccountCodeStorage](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/AccountCodeStorage.sol). + +On how the System Contract is called, see [this section](../../system-contracts.md#environmental-data-storage). + +### LLVM IR + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/ext_code.rs#L29) +is common for Yul and EVMLA representations. + +The request to the System Contract is done via the +[SystemRequest](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/context/function/runtime/system_request.rs) runtime function. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/events.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/events.md new file mode 100644 index 00000000..ebf3d928 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/events.md @@ -0,0 +1,29 @@ +--- +title: Event +description: +--- + +The EraVM event instructions are more low-level. Each `LOG`-like instruction is unrolled into a loop, where each iteration writes two 256-bit words. + +The words must contain data in the following order: + +1. The initializer cell, describing the number of indexed words (e.g. `I`) and the size of non-indexed data in bytes (e.g. `D`) +2. `I` indexed 32-byte words +3. `D` bytes of data + +Each write operation can contain some subsequent data from its next step. If only one word remains, the second input is zero. + +See [EraVM instruction: `log.event`](https://matter-labs.github.io/eravm-spec/spec.html#EventDefinition) + +## LOG0 - LOG4 + +Original [EVM](https://www.evm.codes/#a0?fork=shanghai) instructions. + +### System Contract + +This information is requested a System Contract called [EventWriter](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/EventWriter.yul). + +On how the System Contract is called, see [this section](../../system-contracts#event-handler). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/event.rs#L20) +is common for Yul and EVMLA representations. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/hashes.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/hashes.md new file mode 100644 index 00000000..cd5312ea --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/hashes.md @@ -0,0 +1,54 @@ +--- +title: Hashes +description: +--- + +## SHA3 + +Original [EVM](https://www.evm.codes/#20?fork=shanghai) instruction. + +### System Contract + +This instruction is handled by a System Contract called [Keccak256](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/precompiles/Keccak256.yul), +which is a wrapper around the EraVM precompile. + +On how the System Contract is called, see [this section](../../system-contracts#keccak256-hash-function). + +### LLVM IR + +```txt +define i256 @__sha3(i8 addrspace(1)* nocapture nofree noundef %0, i256 %1, i1 %throw_at_failure) "noinline-oz" #1 personality i32()* @__personality { +entry: + %addr_int = ptrtoint i8 addrspace(1)* %0 to i256 + %2 = tail call i256 @llvm.umin.i256(i256 %addr_int, i256 4294967295) + %3 = tail call i256 @llvm.umin.i256(i256 %1, i256 4294967295) + %gas_left = tail call i256 @llvm.syncvm.gasleft() + %4 = tail call i256 @llvm.umin.i256(i256 %gas_left, i256 4294967295) + %abi_data_input_offset_shifted = shl nuw nsw i256 %2, 64 + %abi_data_input_length_shifted = shl nuw nsw i256 %3, 96 + %abi_data_gas_shifted = shl nuw nsw i256 %4, 192 + %abi_data_offset_and_length = add i256 %abi_data_input_length_shifted, %abi_data_input_offset_shifted + %abi_data_add_gas = add i256 %abi_data_gas_shifted, %abi_data_offset_and_length + %abi_data_add_system_call_marker = add i256 %abi_data_add_gas, 904625697166532776746648320380374280103671755200316906558262375061821325312 + %call_external = tail call { i8 addrspace(3)*, i1 } @__staticcall(i256 %abi_data_add_system_call_marker, i256 32784, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef, i256 undef) + %status_code = extractvalue { i8 addrspace(3)*, i1 } %call_external, 1 + br i1 %status_code, label %success_block, label %failure_block + +success_block: + %abi_data_pointer = extractvalue { i8 addrspace(3)*, i1 } %call_external, 0 + %data_pointer = bitcast i8 addrspace(3)* %abi_data_pointer to i256 addrspace(3)* + %keccak256_child_data = load i256, i256 addrspace(3)* %data_pointer, align 1 + ret i256 %keccak256_child_data + +failure_block: + br i1 %throw_at_failure, label %throw_block, label %revert_block + +revert_block: + call void @__revert(i256 0, i256 0, i256 0) + unreachable + +throw_block: + call void @__cxa_throw(i8* noalias nocapture nofree align 32 null, i8* noalias nocapture nofree align 32 undef, i8* noalias nocapture nofree align 32 undef) + unreachable +} +``` diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/logical.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/logical.md new file mode 100644 index 00000000..a0c3873c --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/logical.md @@ -0,0 +1,205 @@ +--- +title: Logical +description: +--- + +## LT + +Original [EVM](https://www.evm.codes/#10?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp ult i256 %value1, %value2 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +sub! r1, r2, r1 +add 0, r0, r1 +add.lt 1, r0, r1 +st.1 128, r1 +``` + +## GT + +Original [EVM](https://www.evm.codes/#11?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp ugt i256 %value1, %value2 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +sub! r1, r2, r1 +add 0, r0, r1 +add.gt 1, r0, r1 +st.1 128, r1 +``` + +## SLT + +Original [EVM](https://www.evm.codes/#12?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp slt i256 %value1, %value2 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +add @CPI0_4[0], r0, r3 +sub! r1, r2, r4 +add r0, r0, r4 +add.lt r3, r0, r4 +and @CPI0_4[0], r2, r2 +and @CPI0_4[0], r1, r1 +sub! r1, r2, r5 +add.le r0, r0, r3 +xor r1, r2, r1 +sub.s! @CPI0_4[0], r1, r1 +add r4, r0, r1 +add.eq r3, r0, r1 +sub! r1, r0, r1 +add 0, r0, r1 +add.ne 1, r0, r1 +st.1 128, r1 +``` + +## SGT + +Original [EVM](https://www.evm.codes/#13?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp sgt i256 %value1, %value2 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +add @CPI0_4[0], r0, r3 +sub! r1, r2, r4 +add r0, r0, r4 +add.gt r3, r0, r4 +and @CPI0_4[0], r2, r2 +and @CPI0_4[0], r1, r1 +sub! r1, r2, r5 +add.ge r0, r0, r3 +xor r1, r2, r1 +sub.s! @CPI0_4[0], r1, r1 +add r4, r0, r1 +add.eq r3, r0, r1 +sub! r1, r0, r1 +add 0, r0, r1 +add.ne 1, r0, r1 +st.1 128, r1 +``` + +## EQ + +Original [EVM](https://www.evm.codes/#14?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp eq i256 %value1, %value2 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r0, r1 +ptr.add.s 36, r1, r2 +ld r2, r2 +ptr.add.s 4, r1, r1 +ld r1, r1 +sub! r1, r2, r1 +add 0, r0, r1 +add.eq 1, r0, r1 +st.1 128, r1 +``` + +## ISZERO + +Original [EVM](https://www.evm.codes/#15?fork=shanghai) instruction. + +### LLVM IR + +```txt +%comparison_result = icmp eq i256 %value, 0 +%comparison_result_extended = zext i1 %comparison_result to i256 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/comparison.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#icmp-instruction) + +### EraVM Assembly + +```asm +ptr.add stack[@ptr_calldata], r1, r1 +ld r1, r1 +sub! r1, r0, r1 +add 0, r0, r1 +add.eq 1, r0, r1 +st.1 128, r1 +``` diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/memory.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/memory.md new file mode 100644 index 00000000..1642fc5d --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/memory.md @@ -0,0 +1,76 @@ +--- +title: Memory +description: +--- + +## MLOAD + +Original [EVM](https://www.evm.codes/#51?fork=shanghai) instruction. + +Heap memory load operation is modeled with a native EraVM instruction. + +### LLVM IR + +```txt +%value = load i256, ptr addrspace(1) %pointer, align 1 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/memory.rs#L15) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#load-instruction) + +### EraVM Assembly + +```asm +ld.1 r1, r2 +``` + +See [EraVM instruction: `st.1`](https://matter-labs.github.io/eravm-spec/spec.html#LoadDefinition) + +## MSTORE + +Original [EVM](https://www.evm.codes/#52?fork=shanghai) instruction. + +Heap memory load operation is modeled with a native EraVM instruction. + +### LLVM IR + +```txt +store i256 128, ptr addrspace(1) inttoptr (i256 64 to ptr addrspace(1)), align 1 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/memory.rs#L38) +is common for Yul and EVMLA representations. + +[LLVM IR instruction documentation](https://releases.llvm.org/15.0.0/docs/LangRef.html#store-instruction) + +### EraVM Assembly + +```asm +st.1 r1, r2 +``` + +See [EraVM instruction: `st.1`](https://matter-labs.github.io/eravm-spec/spec.html#StoreDefinition) + +## MSTORE8 + +Original [EVM](https://www.evm.codes/#53?fork=shanghai) instruction. + +### LLVM IR + +```txt +define void @__mstore8(i256 addrspace(1)* nocapture nofree noundef dereferenceable(32) %addr, i256 %val) #2 { +entry: + %orig_value = load i256, i256 addrspace(1)* %addr, align 1 + %orig_value_shifted_left = shl i256 %orig_value, 8 + %orig_value_shifted_right = lshr i256 %orig_value_shifted_left, 8 + %byte_value_shifted = shl i256 %val, 248 + %store_result = or i256 %orig_value_shifted_right, %byte_value_shifted + store i256 %store_result, i256 addrspace(1)* %addr, align 1 + ret void +} +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/memory.rs#L62) +is common for Yul and EVMLA representations. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/return.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/return.md new file mode 100644 index 00000000..45f87640 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/return.md @@ -0,0 +1,78 @@ +--- +title: Return +description: +--- + +## STOP + +Original [EVM](https://www.evm.codes/#00?fork=shanghai) instruction. + +This instruction is a [RETURN](#return) with an empty data payload. + +### LLVM IR + +The same as for [RETURN](#return). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return.rs#L103) +is common for Yul and EVMLA representations. + +## RETURN + +Original [EVM](https://www.evm.codes/#f3?fork=shanghai) instruction. + +This instruction works differently in deploy code. For more information, see [the zkSync Era documentation](https://era.zksync.io/docs/reference/architecture/differences-with-ethereum.html#return). + +### LLVM IR + +```txt +define void @__return(i256 %0, i256 %1, i256 %2) "noinline-oz" #5 personality i32()* @__personality { +entry: + %abi = call i256@__aux_pack_abi(i256 %0, i256 %1, i256 %2) + tail call void @llvm.syncvm.return(i256 %abi) + unreachable +} +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return.rs#L16) +is common for Yul and EVMLA representations. + +## REVERT + +Original [EVM](https://www.evm.codes/#fd?fork=shanghai) instruction. + +### LLVM IR + +```txt +define void @__revert(i256 %0, i256 %1, i256 %2) "noinline-oz" #5 personality i32()* @__personality { +entry: + %abi = call i256@__aux_pack_abi(i256 %0, i256 %1, i256 %2) + tail call void @llvm.syncvm.revert(i256 %abi) + unreachable +} +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return.rs#L86) +is common for Yul and EVMLA representations. + +### EraVM + +See also EraVM instruction `revert`: [when returning from near calls](https://matter-labs.github.io/eravm-spec/spec.html#NearRevertDefinition) +and [when returning from far calls](https://matter-labs.github.io/eravm-spec/spec.html#FarRevertDefinition). + +## INVALID + +Original [EVM](https://www.evm.codes/#fe?fork=shanghai) instruction. + +This instruction is a [REVERT](#revert) with an empty data payload, but it also burns all the available gas. + +### LLVM IR + +The same as for [REVERT](#revert). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/return.rs#L115) +is common for Yul and EVMLA representations. + +### EraVM + +See also EraVM instruction `revert`: [when returning from near calls](https://matter-labs.github.io/eravm-spec/spec.html#NearRevertDefinition) +and [when returning from far calls](https://matter-labs.github.io/eravm-spec/spec.html#FarRevertDefinition). diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/stack.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/stack.md new file mode 100644 index 00000000..ca1c6502 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/stack.md @@ -0,0 +1,56 @@ +--- +title: Stack +description: +--- + +## POP + +Original [EVM](https://www.evm.codes/#50?fork=shanghai) instruction. + +In Yul, only used to mark unused values, and is not translated to LLVM IR. + +```solidity +pop(staticcall(gas(), address(), 0, 64, 0, 32)) +``` + +For EVMLA, see [EVM Legacy Assembly Translator](../../evmla-translator). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/assembly/instruction/stack.rs#L108). + +## JUMPDEST + +Original [EVM](https://www.evm.codes/#5b?fork=shanghai) instruction. + +Is not available in Yul. + +Ignored in EVMLA. See [EVM Legacy Assembly Translator](../../evmla-translator) for more information. + +## PUSH - PUSH32 + +Original [EVM](https://www.evm.codes/#5f?fork=shanghai) instructions. + +Is not available in Yul. + +For EVMLA, see [EVM Legacy Assembly Translator](../../evmla-translator). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/assembly/instruction/stack.rs#L10). + +## DUP1 - DUP16 + +Original [EVM](https://www.evm.codes/#80?fork=shanghai) instructions. + +Is not available in Yul. + +For EVMLA, see [EVM Legacy Assembly Translator](../../evmla-translator). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/assembly/instruction/stack.rs#L48). + +## SWAP1 - SWAP16 + +Original [EVM](https://www.evm.codes/#90?fork=shanghai) instructions. + +Is not available in Yul. + +For EVMLA, see [EVM Legacy Assembly Translator](../../evmla-translator). + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-solidity/blob/main/src/evmla/assembly/instruction/stack.rs#L74). diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/storage.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/storage.md new file mode 100644 index 00000000..77f0e1c0 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/20.evm/storage.md @@ -0,0 +1,46 @@ +--- +title: Storage +description: +--- + +## SLOAD + +Original [EVM](https://www.evm.codes/#54?fork=shanghai) instruction. + +Storage load operation is modeled with a native EraVM instruction. + +### LLVM IR + +```txt +%value = load i256, ptr addrspace(5) %pointer, align 1 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/storage.rs#L13) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +sload r1, r2 +``` + +## SSTORE + +Original [EVM](https://www.evm.codes/#55?fork=shanghai) instruction. + +Storage store operation is modeled with a native EraVM instruction. + +### LLVM IR + +```txt +store i256 42, ptr addrspace(5) inttoptr (i256 1 to ptr addrspace(5)), align 1 +``` + +[The LLVM IR generator code](https://github.com/matter-labs/era-compiler-llvm-context/blob/main/src/eravm/evm/storage.rs#L34) +is common for Yul and EVMLA representations. + +### EraVM Assembly + +```asm +sstore r1, r2 +``` diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/30.evmla.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/30.evmla.md new file mode 100644 index 00000000..e47aa6fa --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/30.evmla.md @@ -0,0 +1,91 @@ +--- +title: EVM Legacy Assembly +description: +--- + +These instructions do not have a direct representation in EVM or zkSync VM. Instead, they perform auxiliary operations +required for generating the target bytecode. + +## PUSH [$] + +The same as [datasize](yul#datasize). + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L144) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/create.rs#L149) + +## PUSH #[$] + +The same as [dataoffset](yul#dataoffset). + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L135) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/create.rs#L97) + +## ASSIGNIMMUTABLE + +The same as [setimmutable](yul#setimmutable). + + + + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L760) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/immutable.rs#L79) + +## PUSHIMMUTABLE + +The same as [loadimmutable](yul#loadimmutable). + + + + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L747) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/immutable.rs#L17) + +## PUSHLIB + +The same as [linkersymbol](yul#linkersymbol). + + + + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L956). + +## PUSHDEPLOYADDRESS + +Returns the address the contract is deployed to. + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L956). + +## PUSHSIZE + +Can be only found in deploy code. On EVM, returns the total size of the runtime code and constructor arguments. + +On zkSync VM, it is always 0, since zkSync VM does not operate on runtime code in deploy code. + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L907). + +## PUSH data + +Pushes a data chunk onto the stack. Data chunks are resolved during the processing of input assembly JSON. + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/ethereal_ir/function/block/element/mod.rs#L164). + +## PUSH [tag] + +Pushes an EVM Legacy Assembly destination block identifier onto the stack. + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/evmla/assembly/instruction/stack.rs#L31). + +## Tag + +Starts a new EVM Legacy Assembly block. Tags are processed during the translation of EVM Legacy Assembly into EthIR. diff --git a/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/40.yul.md b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/40.yul.md new file mode 100644 index 00000000..6d19bae5 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/20.specification/60.instructions/40.yul.md @@ -0,0 +1,107 @@ +--- +title: Yul +description: +--- + +These instructions do not have a direct representation in EVM or zkSync VM. Instead, they perform auxiliary operations +required for generating the target bytecode. + +## datasize + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#datasize-dataoffset-datacopy) auxiliary instruction. + +Unlike on EVM, on zkSync VM target this instruction returns the size of the header part of the calldata sent to the +[ContractDeployer](../system-contracts#contract-deployer). +For more information, see [CREATE](evm/create). + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L928) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/create.rs#L149) + +## dataoffset + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#datasize-dataoffset-datacopy) auxiliary instruction. + +Unlike on EVM, on zkSync VM target this instruction has nothing to do with the offset. Instead, it returns the bytecode hash +of the contract referenced by the Yul object identifier. Since our compiler translates instructions without analyzing +the surrounding context, it is not possible to get the bytecode hash from anywhere else in [datacopy](#datacopy). For +more information, see [CREATE](evm/create). + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L918) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/zkSync VM/evm/create.rs#L97) + +## datacopy + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#datasize-dataoffset-datacopy) auxiliary instruction. + +Unlike on EVM, on zkSync VM target this instruction copies the bytecode hash passed as [dataoffset](#dataoffset) to the +destination. For more information, see [CREATE](evm/create). + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L938). + +## setimmutable + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#setimmutable-loadimmutable) auxiliary instruction. + +Writes immutables to the auxiliary heap. + + + + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L562) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/immutable.rs#L79) + +## loadimmutable + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#setimmutable-loadimmutable) auxiliary instruction. + +Reads immutables from the [ImmutableSimulator](../system-contracts.md#simulator-of-immutables). + + + + +LLVM IR codegen references: + +1. [zksolc compiler](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L540) +2. [Shared FE code](%%zk_git_repo_era-compiler-llvm-context%%/blob/main/src/eravm/evm/immutable.rs#L17) + +## linkersymbol + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#linkersymbol) auxiliary instruction. + +Returns the address of a deployable library. The address must be passed to `zksolc` with the `--libraries` option, +otherwise a compile-time error will be produced. + +There is a special `zksolc` execution mode that can be enabled with `--missing-libraries` flag. In this mode, the +compiler will return the list of deployable libraries not provided with `--libraries`. This mode allows package managers +like Hardhat to automatically deploy libraries. + + + + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L956). + +## memoryguard + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#memoryguard) auxiliary instruction. + +Is a Yul optimizer hint which is not used by our compiler. Instead, its only argument is simply unwrapped and returned. + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/mod.rs#L968). + +## verbatim + +Original [Yul](https://docs.soliditylang.org/en/latest/yul.html#verbatim) auxiliary instruction. + +Unlike on EVM, on zkSync VM target this instruction has nothing to do with inserting of EVM bytecode. Instead, it is used to implement +[zkSync VM Yul Extensions](../instructions/overview#yul-extensions) available in the system mode. In order to compile a Yul contract +with extensions, both Yul and system mode must be enabled (`zksolc --yul --system-mode ...`). + +[The LLVM IR generator code](%%zk_git_repo_era-compiler-solidity%%/blob/main/src/yul/parser/statement/expression/function_call/verbatim.rs). diff --git a/content/10.zk-stack/10.components/70.compiler/_dir.yml b/content/10.zk-stack/10.components/70.compiler/_dir.yml new file mode 100644 index 00000000..0e890cb2 --- /dev/null +++ b/content/10.zk-stack/10.components/70.compiler/_dir.yml @@ -0,0 +1 @@ +title: Compiler diff --git a/content/10.zk-stack/10.components/80.fee-withdrawer.md b/content/10.zk-stack/10.components/80.fee-withdrawer.md new file mode 100644 index 00000000..4c5d97be --- /dev/null +++ b/content/10.zk-stack/10.components/80.fee-withdrawer.md @@ -0,0 +1,9 @@ +--- +title: Fee Withdrawer +description: Learn about the Fee Withdrawer, a tool that automates the transfer of collected fees from a hyperchain to a base layer address. +--- + +[The Fee Withdrawer](https://github.com/matter-labs/era-fee-withdrawer) +is a specialized tool that automates the process of transferring collected fees from a hyperchain to a specified address on the base layer. +This functionality is crucial for maintaining the continuous operation of the ETH operator on the base layer, +ensuring there is always a sufficient supply of the gas token available for transactions. diff --git a/content/10.zk-stack/10.components/90.portal-wallet-bridge.md b/content/10.zk-stack/10.components/90.portal-wallet-bridge.md new file mode 100644 index 00000000..0876e0a2 --- /dev/null +++ b/content/10.zk-stack/10.components/90.portal-wallet-bridge.md @@ -0,0 +1,17 @@ +--- +title: Portal - Wallet + Bridge +description: Discover how the Portal dApp facilitates interaction with your hyperchain, including asset bridging, transaction tracking, and contract management. +--- + +[The Portal](https://github.com/matter-labs/dapp-portal) is a decentralized application (dApp) designed to enhance interaction with your hyperchain. +It serves as a versatile tool for both you and your users, simplifying various operations within the blockchain environment. + +### Key Features + +- **Bridging Assets:** The Portal enables the movement of assets between the Layer 1 (L1) network and your hyperchain, facilitating smooth asset transfers. +- **Internal Transactions:** Users can send assets within the hyperchain efficiently, utilizing the Portal's user-friendly interface. +- **Transaction History:** The Portal provides access to view and verify historical transactions, enhancing transparency and user trust in the platform. +- **Contract Management:** It supports users in managing smart contracts, including deployment and interaction functionalities. + +Enhancing the Portal's capabilities is possible by integrating it with the [Block Explorer Indexer/API](block-explorer), +which provides additional data and analytics support, further enriching the user experience. diff --git a/content/10.zk-stack/10.components/_dir.yml b/content/10.zk-stack/10.components/_dir.yml new file mode 100644 index 00000000..9937383b --- /dev/null +++ b/content/10.zk-stack/10.components/_dir.yml @@ -0,0 +1 @@ +title: Components diff --git a/content/10.zk-stack/20.running-a-hyperchain/10.locally.md b/content/10.zk-stack/20.running-a-hyperchain/10.locally.md new file mode 100644 index 00000000..c8f9c1ae --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/10.locally.md @@ -0,0 +1,246 @@ +--- +title: Locally +description: +--- + +## Getting Started with ZK Stack + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +ZK Stack is still under development. We advise you to only use for local and testnet deployments. +:: + +## Development dependencies + +Ensure you have followed [these instructions](https://github.com/matter-labs/zksync-era/blob/main/docs/guides/setup-dev.md) +to set up dependencies on your machine (don't worry about the Environment section for now). + +## Deploying locally + +1. Clone the zksync-era repo (or pull the latest if you've already cloned it) and go to the root of it: + + ```bash + git clone https://github.com/matter-labs/zksync-era + ``` + +1. Add `ZKSYNC_HOME` to your path (e.g. `~/.bash_profile`, `~/.zshrc` ) - don't forget to source your profile file again (or restart your terminal): + + ```bash + export ZKSYNC_HOME=/path/to/zksync/repo/you/cloned + export PATH=$ZKSYNC_HOME/bin:$PATH + ``` + +1. Build latest version of zk tools by just running `zk` on the root of the project. + + ```bash + zk + ``` + +1. Last, start the wizard and follow instructions to set up and deploy your new hyperchain by running `zk stack init` + + - Initially you want to `Configure new chain` + + - Give it a name and chain id. + + - Select localhost (default `matterlabs/geth`) and follow the wizard. + + - If you are doing this for the first time, several components need to be compiled/built, so do not worry if it takes a few minutes. + The console will show what is going on anyways. + + - If you don't want to configure any values for now and just want check the build process for a hyperchain, try out the `zk stack demo` command. + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +The commands above are not just running docker containers, but are actually building the code from the repo to spin up your hyperchain. +For this reason the process might take some time. +If you just want to run docker containers to play around with a zkSync chain, you can use `zksync-cli dev`. +Learn more [here](/build/tooling/zksync-cli). +:: + +### Your hyperchain is now deployed + +Your hyperchain is now deployed to the base chain (most likely a local geth docker container) and configured. +You can find all configuration in a new `.env` file created on `/etc/env/.env`, +and if you deployed test tokens, their addresses will be available at `/etc/tokens/.json` + +1. The wizard allows you to run the server in the end. If you chose not to, you’re still able to run it by executing + + ```bash + zk server --components "http_api,eth,state_keeper,housekeeper" + ``` + +1. You can now run transactions and start playing with your hyperchain by using the RPC available at . + + - Don't forget to deposit some ETH and fund your accounts on your hyperchain. To do so follow the instructions for [Funding accounts](#funding-accounts). + +## Using your hyperchain + +### Funding accounts + +During the `zk stack init` configurator, you have a choice of what base layer to deploy the hyperchain onto: +the local geth node, or an Ethereum network (e.g., Sepolia). +The first step to start interacting with your hyperchain is to fund an account (or a few). +This means you need some funds on the base layer. + +#### Base layer is the local geth node +[@matterlabs/geth:latest](https://hub.docker.com/r/matterlabs/geth) + +- If you chose to deploy on local geth node, you will have a set of addresses that have 100 ETH each. + You can find the list [here](https://github.com/matter-labs/local-setup/blob/main/rich-wallets.json) + and use these addresses to deposit into your hyperchain via the bridge. + +#### Base layer is an Ethereum network (e.g., Sepolia) + +- If you chose to deploy on an Ethereum network (e.g., Sepolia), you need to have an account on the base layer with ETH. + You can use the deployer, governor, or operator wallets setup during the the deployment process, + or any other one you have funds, to deposit into your hyperchain via the bridge. + +Once you have the accounts with funds on the L1 base layer, you can do a deposit via the bridge to your hyperchain, +and any further interactions with your hyperchain. + +### Using your hyperchain RPC + +Your server contains both HTTPS as well as WebSocket (WS) services that are fully web3 compatible (and contain some extra ZK Stack functionalities). +Learn more about it [here](/build/api-reference). + +### Using zksync-cli + +zkSync CLI allows you to easily interact and develop applications on your hyperchain. +When executing any command with zksync-cli, you can specify RPC urls for both L1 and L2. +Your local server contains RPCs for both. +An example deposit command via the bridge would look like: + +```bash +npx zksync-cli bridge deposit --rpc=http://localhost:3050 --l1-rpc=http://localhost:8545 +``` + +### Using Portal + +The dApp Portal module allows you to: + +- View balances, transfer and bridge tokens to your hyperchain. +- Add contacts for quick and easy access. + +You can run the Portal module locally, and point it to your hyperchain configuration. +It comes with scripts that help pulling the hyperchain configuration from your zksync-era repo and adapting to portal needs. +Learn more [here](https://github.com/matter-labs/dapp-portal). +An example command would look like: + +```bash +npm run hyperchain:configure ../zksync-era +npm run dev:node:hyperchain +``` + +You can now navigate to the displayed Portal URL (typically ). + +### Using Block Explorer + +A free open source block explorer is available for your hyperchain. +Block explorer contains three components [Worker](https://github.com/matter-labs/block-explorer/tree/main/packages/worker), +[API](https://github.com/matter-labs/block-explorer/tree/main/packages/api), +and [App](https://github.com/matter-labs/block-explorer/tree/main/packages/app), +which you can run all together locally and connect to your hyperchain. + +Make sure you have your [zksync-era](https://github.com/matter-labs/zksync-era) repo set up locally and the `zk server` is running. +The wizard in this guide allows you to run the server in the end. +If you chose not to, you’re still able to run it by executing: + +```bash +zk server --components "http_api,eth,state_keeper,housekeeper" +``` + +### Running block explorer locally + +#### Install block explorer + +Clone & install the block explorer repository: + +```bash +cd /path/to/where/you/clone/repos +git clone https://github.com/matter-labs/block-explorer.git +cd block-explorer +npm install +``` + +#### Setting up env variables + +Next you need to set up all the necessary environment and configuration files with your hyperchain settings. You can use a script to set them up: + +```bash +npm run hyperchain:configure +``` + +#### Run block explorer + +Afterwards you can run the block explorer: + +```bash +# if you are running block explorer for the first time +npm run db:create +``` + +```bash +npm run dev +``` + +#### Verify block explorer is up and running + +By default, you can access front-end `App` at in your browser. +`API` should be available at , `Worker` at and `Data Fetcher` at . + +## Enabling Boojum prover + +With the default configuration, your hyperchain is not running a prover, +and has a DummyExecutor contract, which mainly “accepts” that a batch is executed without proof. +This enables you to test it with much lower hardware requirements. + +To enable the prover, run the `zk stack prover-setup` command. It will guide through the necessary configuration. + +There are two options for running the Boojum prover: in GPU, or in CPU. + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +**Running a prover is not required** for deploying a testnet. The requirements below are only necessary if you want to enable the prover. +:: + +### Requirements for GPU Prover + +The docker compose file assumes you will be running all components in the same machine. The current minimum requirements for a low TPS scenario are: + +- 6 GB VRAM NVIDIA GPU +- 16 Core CPU +- 64 GB of RAM +- 300 GB of Disk Space (SSD preferred) + +### Requirements for CPU Prover + +The docker compose file assumes you will be running all components in the same machine. +The current minimum requirements for a low TPS scenario are: + +- 32 Core CPU +- 128 GB of RAM +- 700 of Disk Space (SSD preferred) + +## Addendum + +- If you make changes to any contract, you can always deploy a new hyperchain to easily test those changes. +- If you configure your hyperchain once, you don't need to do it again as the wizard allows you to use an existing config file. +- For now, it is only possible to deploy a hyperchain as an L2, but soon it will also work as L3s. +- When running the default matterlabs/geth, you have a set of rich wallets available to you. + ::drop-panel + ::panel{label="Rich Wallets"} + :display-partial{path="/_partials/_rich-wallets"} + :: + :: +- If you face an issue compiling rust code (example `: Error allocating TSD`) try removing the `rust-toolchain` file from the repo. +- If you want to have a custom local base chain, you must ensure you have a database for your hyperchain, as well as the local RPC for your L1. + - To run a Postgres 14 database for your hyperchain, execute the following: + + ```bash + docker-compose -f docker-compose-zkstack-common.yml up -d postgres + ``` + +In case you don't want to use the docker Postgres database above but another one you already have locally, +make sure its version is 14 and it is running and accepts connections at `postgres://postgres@localhost/zksync_local`. +You can test with: + +```bash +psql -h localhost -U postgres -d postgres -c 'SELECT 1;' +``` diff --git a/content/10.zk-stack/20.running-a-hyperchain/20.production.md b/content/10.zk-stack/20.running-a-hyperchain/20.production.md new file mode 100644 index 00000000..e120f12f --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/20.production.md @@ -0,0 +1,25 @@ +--- +title: In Production +--- + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +ZK Stack is still under development. We advise you to only use for local and testnet deployments. +:: + +## Deploying to a non-local environment + +The process to deploy to a non local environment is pretty similar to the local one. +The wizard allows you to set up URLs to external services (database, RPCs, etc). + +## Database + +The wizard allows you to provide a custom database url connector. +Make sure you provide it and that it accepts external connections if your server is not running in the same private network. + +## Server (Sequencer) & Prover + +After configuring your hyperchain, you can generate docker images for your server and prover. +To do that run `zk stack docker-setup`. + +This command will guide you to properly name and tag your image. +After building it, a docker compose file will be available so you can run the images on whichever cloud environment you desire. diff --git a/content/10.zk-stack/20.running-a-hyperchain/30.raas.md b/content/10.zk-stack/20.running-a-hyperchain/30.raas.md new file mode 100644 index 00000000..26b4a3c1 --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/30.raas.md @@ -0,0 +1,30 @@ +--- +title: Rollup as a Service +description: +--- + +::callout{icon="i-heroicons-exclamation-triangle" color="amber"} +ZK Stack is still under development. We advise you to only use for local and testnet deployments. +:: + +## Deploying and running using a Rollup as a Service provider + +Looking to deploy a ZK Stack chain but worried about complexities? +RaaS providers are here to simplify the process! +Providers offer scalable and secure nodes, and may provide quick and user-friendly interfaces, +allowing you to deploy your ZK Stack chain with ease and efficiency. +Experience the seamless integration of advanced blockchain technology without the hassle. +Get started today and revolutionize your product with the power of RaaS and ZK Stack! + +Use RaaS in to improve scalability, reduce costs, access specialized services, speed up development, enhance interoperability, +and maintain flexibility in an ever-evolving technological landscape. + +The list of RaaS providers you can use to deploy and customise their your hyperchain: + + + +- [Zeeve](https://www.zeeve.io/appchains/zksync-hyperchains-zkrollups/) +- [Ankr](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/ankrpbc1684783099666.ankr_appchains?tab=Overview/) +- [AltLayer](https://altlayer.io/raas) +- [Magic](https://magic.link/docs/blockchains/other-chains/evm/zksync) +- [Luganodes](https://www.luganodes.com/product/zkraas/) diff --git a/content/10.zk-stack/20.running-a-hyperchain/99.dependencies.md b/content/10.zk-stack/20.running-a-hyperchain/99.dependencies.md new file mode 100644 index 00000000..7bdb5197 --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/99.dependencies.md @@ -0,0 +1,289 @@ +--- +title: Dependencies +--- + +## TL;DR + +If you run on 'clean' Debian on GCP: + +```bash +# Rust +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh +# NVM +curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash +# All necessary stuff +sudo apt-get install build-essential pkg-config cmake clang lldb lld libssl-dev postgresql docker-compose +# Docker +sudo usermod -aG docker YOUR_USER + +## You might need to re-connect (due to usermod change). + +# Node & yarn +nvm install node +npm install -g yarn +yarn set version 1.22.19 + +# SQL tools +cargo install sqlx-cli --version 0.5.13 +# Stop default postgres (as we'll use the docker one) +sudo systemctl stop postgresql +# Start docker. +sudo systemctl start docker +``` + +## Supported operating systems + +zkSync currently can be launched on any \*nix operating system (e.g. any linux distribution or MacOS). + +If you're using Windows, then make sure to use WSL 2, since WSL 1 is known to cause troubles. + +Additionally, if you are going to use WSL 2, make sure that your project is located in the _linux filesystem_, since +accessing NTFS partitions from inside of WSL is very slow. + +If you're using MacOS with an ARM processor (e.g. M1/M2), make sure that you are working in the _native_ environment +(e.g. your terminal and IDE don't run in Rosetta, and your toolchain is native). Trying to work with zkSync code via +Rosetta may cause problems that are hard to spot and debug, so make sure to check everything before you start. + +If you are a NixOS user or would like to have a reproducible environment, skip to the section about `nix`. + +## `Docker` + +Install `docker`. It is recommended to follow the instructions from the +[official site](https://docs.docker.com/install/). + +Note: currently official site proposes using Docker Desktop for Linux, which is a GUI tool with plenty of quirks. If you +want to only have CLI tool, you need the `docker-ce` package and you can follow +[this guide](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04) for Ubuntu. + +Installing `docker` via `snap` or from the default repository can cause troubles. + +You need to install both `docker` and `docker-compose`. + +**Note:** `docker-compose` is installed automatically with `Docker Desktop`. + +**Note:** On linux you may encounter the following error when you’ll try to work with `zksync`: + +```sh +ERROR: Couldn't connect to Docker daemon - you might need to run `docker-machine start default`. +``` + +If so, you **do not need** to install `docker-machine`. Most probably, it means that your user is not added to +the`docker` group. You can check it as follows: + +```bash +docker-compose up # Should raise the same error. +sudo docker-compose up # Should start doing things. +``` + +If the first command fails, but the second succeeds, then you need to add your user to the `docker` group: + +```bash +sudo usermod -a -G docker your_user_name +``` + +After that, you should logout and login again (user groups are refreshed after the login). The problem should be solved +at this step. + +If logging out does not help, restarting the computer should. + +## `Node` & `Yarn` + +1. Install `Node` (requires version `v18.18.0`). Since our team attempts to always use the latest LTS version of + `Node.js`, we suggest you to install [nvm](https://github.com/nvm-sh/nvm). It will allow you to update `Node.js` + version easily in the future (by running `nvm use` in the root of the repository) +2. Install `yarn` (make sure to get version 1.22.19 - you can change the version by running `yarn set version 1.22.19`). + Instructions can be found on the [official site](https://classic.yarnpkg.com/en/docs/install/). + Check if `yarn` is installed by running `yarn -v`. If you face any problems when installing `yarn`, it might be the + case that your package manager installed the wrong package.Make sure to thoroughly follow the instructions above on + the official website. It contains a lot of troubleshooting guides in it. + +## `Axel` + +Install `axel` for downloading keys: + +On mac: + +```bash +brew install axel +``` + +On debian-based linux: + +```bash +sudo apt-get install axel +``` + +Check the version of `axel` with the following command: + +```sh +axel --version +``` + +Make sure the version is higher than `2.17.10`. + +## `clang` + +In order to compile RocksDB, you must have LLVM available. On debian-based linux it can be installed as follows: + +On linux: + +```bash +sudo apt-get install build-essential pkg-config cmake clang lldb lld +``` + +On mac: + +You need to have an up-to-date `Xcode`. You can install it directly from `App Store`. With Xcode command line tools, you +get the Clang compiler installed by default. Thus, having XCode you don't need to install `clang`. + +## `OpenSSL` + +Install OpenSSL: + +On mac: + +```bash +brew install openssl +``` + +On linux: + +```bash +sudo apt-get install libssl-dev +``` + +## `Rust` + +Install the latest `rust` version. + +Instructions can be found on the [official site](https://www.rust-lang.org/tools/install). + +Verify the `rust` installation: + +```bash +rustc --version +rustc 1.xx.y (xxxxxx 20xx-yy-zz) # Output may vary depending on actual version of rust +``` + +If you are using MacOS with ARM processor (e.g. M1/M2), make sure that you use an `aarch64` toolchain. For example, when +you run `rustup show`, you should see a similar input: + +```bash +rustup show +Default host: aarch64-apple-darwin +rustup home: /Users/user/.rustup + +installed toolchains +-------------------- + +... + +active toolchain +---------------- + +1.67.1-aarch64-apple-darwin (overridden by '/Users/user/workspace/zksync-era/rust-toolchain') +``` + +If you see `x86_64` mentioned in the output, probably you're running (or used to run) your IDE/terminal in Rosetta. If +that's the case, you should probably change the way you run terminal, and/or reinstall your IDE, and then reinstall the +Rust toolchain as well. + +## Postgres + +Install the latest postgres: + +On mac: + +```bash +brew install postgresql@14 +``` + +On linux: + +```bash +sudo apt-get install postgresql +``` + +### Cargo nextest + +[cargo-nextest](https://nexte.st/) is the next-generation test runner for Rust projects. `zk test rust` uses +`cargo nextest` by default. + +```bash +cargo install cargo-nextest +``` + +### SQLx CLI + +SQLx is a Rust library we use to interact with Postgres, and its CLI is used to manage DB migrations and support several +features of the library. + +```bash +cargo install sqlx-cli --version 0.5.13 +``` + +## Solidity compiler `solc` + +Install the latest solidity compiler. + +```bash +brew install solidity +``` + +Alternatively, download a [precompiled version](https://github.com/ethereum/solc-bin) and add it to your PATH. + +## Python + +Most environments will have this preinstalled but if not, install Python. + +## Easier method using `nix` + +Nix is a tool that can fetch _exactly_ the right dependencies specified via hashes. The current config is Linux-only but +it is likely that it can be adapted to Mac. + +Install `nix`. Enable the nix command and flakes. + +Install docker, rustup and use rust to install SQLx CLI like described above. If you are on NixOS, you also need to +enable nix-ld. + +Go to the zksync folder and run `nix develop --impure`. After it finishes, you are in a shell that has all the +dependencies. + +## Environment + +Edit the lines below and add them to your shell profile file (e.g. `~/.bash_profile`, `~/.zshrc`): + +```bash +# Add path here: +export ZKSYNC_HOME=/path/to/zksync + +export PATH=$ZKSYNC_HOME/bin:$PATH + +# If you're like me, uncomment: +# cd $ZKSYNC_HOME +``` + +### Tip: `mold` + +Optionally, you may want to optimize the build time with the modern linker, [`mold`](https://github.com/rui314/mold). + +This linker will speed up the build times, which can be pretty big for Rust binaries. + +Follow the instructions in the repo in order to install it and enable for Rust. + +## Tip: Speeding up building `RocksDB` + +By default, each time you compile `rocksdb` crate, it will compile required C++ sources from scratch. It can be avoided +by using precompiled versions of library, and it will significantly improve your build times. + +In order to do so, you can put compiled libraries to some persistent location, and add the following to your shell +configuration file (e.g. `.zshrc` or `.bashrc`): + +```sh +export ROCKSDB_LIB_DIR= +export SNAPPY_LIB_DIR= +``` + +Make sure that compiled libraries match the current version of RocksDB. One way to obtain them, is to compile the +project in the usual way once, and then take built libraries from +`target/{debug,release}/build/librocksdb-sys-{some random value}/out`. diff --git a/content/10.zk-stack/20.running-a-hyperchain/99.enabling-prover.md b/content/10.zk-stack/20.running-a-hyperchain/99.enabling-prover.md new file mode 100644 index 00000000..0b7a195f --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/99.enabling-prover.md @@ -0,0 +1,30 @@ +--- +title: Enabling Prover +description: +--- + +With the default configuration, your hyperchain is not running a prover, +and has a `DummyExecutor` contract, which mainly “accepts” that a batch is executed without proof. +This enables you to test it with much lower hardware requirements. + +To enable the prover, run the `zk stack prover-setup` command. +It will guide through the necessary configuration. + +> :warning: Running a prover is not required for deploying a testnet. The requirements below are only necessary if you want to enable the prover. + +## Requirements for CPU Prover + +The docker compose file assumes you will be running all components in the same machine. The current minimum requirements for a low TPS scenario are: + +- 32 Core CPU +- 128 GB of RAM +- 700 of Disk Space (SSD preferred) + +## Requirements for GPU Prover + +The docker compose file assumes you will be running all components in the same machine. The current minimum requirements for a low TPS scenario are: + +- 16 GB VRAM NVIDIA GPU +- 16 Core CPU +- 64 GB of RAM +- 300 GB of Disk Space (SSD preferred) diff --git a/content/10.zk-stack/20.running-a-hyperchain/99.using-hyperchain.md b/content/10.zk-stack/20.running-a-hyperchain/99.using-hyperchain.md new file mode 100644 index 00000000..8a7e71eb --- /dev/null +++ b/content/10.zk-stack/20.running-a-hyperchain/99.using-hyperchain.md @@ -0,0 +1,77 @@ +--- +title: Using Your Hyperchain RPC +description: +--- + +Your server contains both HTTPS as well as WS services that are fully web3 compatible (and contain some extra ZK Stack functionalities). + +By default your server is available at - but if you deployed the server into some cloud provider, +you will have a different URL to interact with. + +## Using zksync-cli + +When executing any command with zksync-cli, +you can specify RPC urls for both L1 and L2 if you choose “localnet” as your network. +An example deposit command would look like: + +```bash +npx zksync-cli bridge deposit --rpc=http://localhost:3050 --l1-rpc=http://localhost:8545 +``` + +## Using dApp Portal + +You can run the Portal module locally, and point it to your hyperchain configuration. +It comes with scripts that help pulling the hyperchain configuration from your zksync-era repo and adapting to portal needs. +Learn more here. An example command would look like: + +```bash +npm run hyperchain:migrate ../zksync-era +npm run dev:node:hyperchain +``` + +## Using Block Explorer + +Block explorer contains three components (Worker, API, and App), which you can run all together locally and connect to your hyperchain. +For that, you need to set up all the necessary environment and configuration files with your hyperchain settings. +You can use a script to build them. See setting up env variables. + +Once you have your zksync-era repo set up locally, you can run the following command to +build environment and configuration files for block explorer based on your **[zksync-era](https://github.com/matter-labs/zksync-era)** repo configuration: + +```bash +npm run hyperchain:configure +``` + +The script generates all the necessary configuration files for block-explorer, which you can edit if you need any changes. + +## Addendum + +- If you make changes to any contract, you can always deploy a new hyperchain to easily test those changes. + +- If you configure your hyperchain once, you don't need to do it again as the wizard allows you to use an existing config file. + +- For now, it is only possible to deploy a hyperchain as an L2, but soon it will also work as L3s. + +- When running the default matterlabs/geth, you have a set of rich wallets available to you. + ::drop-panel + ::panel{label="Rich Wallets"} + :display-partial{path="/_partials/_rich-wallets"} + :: + :: +- If you want to have a custom local base chain, you must ensure you have a database for your hyperchain, as well as the local RPC for your L1. + +- To run a Postgres 14 database for your hyperchain, execute the following: + +```bash +docker-compose -f docker-compose-zkstack-common.yml up -d postgres +``` + +In case you don't want to use the docker Postgres database above but another one you already have locally, +make sure its version is 14 and it is running and accepts connections at postgres://postgres@localhost/zksync_local. +You can test with: + +```bash +psql -h localhost -U postgres -d postgres -c 'SELECT 1;' +``` + +If you face an issue compiling rust code (example `: Error allocating TSD`) try removing the `rust-toolchain` file from the repo. diff --git a/content/_zksync.json b/content/_zksync.json index 6b1ca563..968972f8 100644 --- a/content/_zksync.json +++ b/content/_zksync.json @@ -22,18 +22,30 @@ }, "git_repo": { "block-explorer": "https://github.com/matter-labs/block-explorer", + "era-boojum": "https://github.com/matter-labs/era-boojum", + "era-compiler-llvm": "https://github.com/matter-labs/era-compiler-llvm", + "era-compiler-llvm-context": "https://github.com/matter-labs/era-compiler-llvm-context", "era-compiler-solidity": "https://github.com/matter-labs/era-compiler-solidity", + "era-compiler-vyper": "https://github.com/matter-labs/era-compiler-vyper", + "era-contracts": "https://github.com/matter-labs/era-contracts", "era-hardhat-with-plugins": "https://github.com/matter-labs/era-hardhat-with-plugins", "era-test-node": "https://github.com/matter-labs/era-test-node", "era-solidity": "https://github.com/matter-labs/era-solidity", + "era-zkEVM-assembly": "https://github.com/matter-labs/era-zkEVM-assembly", + "era-zkevm_circuits": "https://github.com/matter-labs/era-zkevm_circuits", + "era-zkevm_test_harness": "https://github.com/matter-labs/era-zkevm_test_harness", + "eravm-spec": "https://matter-labs.github.io/eravm-spec", "foundry-zksync": "https://github.com/matter-labs/foundry-zksync", + "franklin-crypto": "https://github.com/matter-labs/franklin-crypto", "hardhat-zksync": "https://github.com/matter-labs/hardhat-zksync", "local-setup": "https://github.com/matter-labs/local-setup", + "matter-labs-github-io": "https://matter-labs.github.io", "zksolc-bin": "https://github.com/matter-labs/zksolc-bin", "zksync-cli": "https://github.com/matter-labs/zksync-cli", "zksync-contract-templates": "https://github.com/matter-labs/zksync-contract-templates", "zksync-developers": "https://github.com/zkSync-Community-Hub/zksync-developers", "zksync-docs": "https://github.com/matter-labs/zksync-docs", + "zksync-era": "https://github.com/matter-labs/zksync-era", "zksync-frontend-templates": "https://github.com/matter-labs/zksync-frontend-templates", "zksync-scripting-templates": "https://github.com/matter-labs/zksync-scripting-templates", "zkvyper-bin": "https://github.com/matter-labs/zkvyper-bin" diff --git a/cspell-config/cspell-blockchain.txt b/cspell-config/cspell-blockchain.txt index 00081e34..52d59646 100644 --- a/cspell-config/cspell-blockchain.txt +++ b/cspell-config/cspell-blockchain.txt @@ -1,14 +1,22 @@ -blake2s256 +arithmetization BoxUups +Buterin +Eigen ethereum EVM evmla -Geth +geth gwei +IERC +inversed keccak merkle +Merklized nomicfoundation nomiclabs +Plonky +poseidon +PREVRANDAO satoshi Sepolia sepolia @@ -19,5 +27,9 @@ UUPS uups validium validiums +viem +Vitalik vyper Weth +Yul +Zeeve diff --git a/cspell-config/cspell-dev.txt b/cspell-config/cspell-dev.txt index db5996a6..0dc84883 100644 --- a/cspell-config/cspell-dev.txt +++ b/cspell-config/cspell-dev.txt @@ -1,7 +1,44 @@ +Ankr +binop +blake2s +blake2s256 +cccond +ccret +CHAINID +debian +decommit +decommits +decommitter +decommitting +decommittment +decommitment +decommitments +decommittments +deduplicator +demultiplex +Demuxer Dockerized dockerized Diataxis +ewasm fontaine +.getu128 +.interm +inttoptr +iszero +jemalloc +JUMPI +legendre +librocksdb +mload +MontInvbEEA +montgomery +mstore +noalias +nocallback +nocapture +noprofile +nosync Nuxt nuxi nuxt @@ -10,10 +47,36 @@ nuxtjs !NuxtUI !NuxtContent NVMe +plux postgres +postgresql +preds +prode +prodeh +prodh +prodm +prodl +psql +ptrtoint +recid. +REDC rocksdb +rodata +rustc +rustup +secp +signv +sload +smod +sstore +sqlx-cli +syncvm +tlsv1 +.uadd. +.umin. Vue vue +zext // devs dutterbutter diff --git a/cspell-config/cspell-misc.txt b/cspell-config/cspell-misc.txt index 9d58c689..a6426e68 100644 --- a/cspell-config/cspell-misc.txt +++ b/cspell-config/cspell-misc.txt @@ -2,3 +2,5 @@ Hola Initializable initializable mundo +permissioned +mathbb diff --git a/cspell-config/cspell-zksync.txt b/cspell-config/cspell-zksync.txt index 53fcf0c7..1cee5f54 100644 --- a/cspell-config/cspell-zksync.txt +++ b/cspell-config/cspell-zksync.txt @@ -8,6 +8,7 @@ zkevm zkforge zkout zksolc +zkstack zkSync zksync zksync-cli diff --git a/cspell.json b/cspell.json index f68c98e7..0977f9c9 100644 --- a/cspell.json +++ b/cspell.json @@ -1,6 +1,9 @@ { "language": "en", "ignorePaths": [ + "bun.lockb", + "*.css", + "*.config.*", "node_modules/**", ".github/**", ".firebase/**", @@ -18,14 +21,17 @@ "cryptocurrencies", "docker", "css", + "csharp", "en_GB", "en_US", "filetypes", "fullstack", "git", "golang", + "go", "html", "java", + "latext", "misc", "node", "npm", diff --git a/nuxt.config.ts b/nuxt.config.ts index 87d53bbb..38be7e58 100644 --- a/nuxt.config.ts +++ b/nuxt.config.ts @@ -1,5 +1,6 @@ import { getIconCollections } from '@egoist/tailwindcss-icons'; import { zksyncIcons } from './assets/zksync-icons'; +import { readFileSync } from 'node:fs'; // https://nuxt.com/docs/api/configuration/nuxt-config export default defineNuxtConfig({ extends: ['@nuxt/ui-pro'], @@ -54,19 +55,19 @@ export default defineNuxtConfig({ }, highlight: { langs: [ - 'solidity', + 'asm', + 'c++', 'go', + 'graphql', + 'groovy', + 'java', 'jsx', - 'swift', 'python', 'rust', + 'solidity', + 'swift', 'toml', - 'java', 'xml', - 'graphql', - 'groovy', - 'asm', - 'c++', ], theme: { default: 'github-light', diff --git a/package.json b/package.json index 5f6e77dd..413f62ab 100644 --- a/package.json +++ b/package.json @@ -52,7 +52,7 @@ "dev": "nuxt dev", "generate": "nuxt generate", "preview": "nuxt preview", - "lint:spelling": "cspell content/**/*.md --config=./cspell.json", + "lint:spelling": "cspell **/*.md --config=./cspell.json", "lint:markdown": "markdownlint-cli2 \"content/**/*.md\" --config \".markdownlint.json\"", "lint:eslint": "eslint .", "lint:prettier": "prettier --check .", diff --git a/public/images/zk-stack/Check_if_satisfied-1.png b/public/images/zk-stack/Check_if_satisfied-1.png new file mode 100644 index 0000000000000000000000000000000000000000..7a7cca20422478572286ec7db73e00958daa8a5b GIT binary patch literal 26265 zcmaI+Wl$X77c~mwB)AXmE`w{Z;O@>qf?I$vxCRMM2tK$I+$A$uAUK0-&>({a0t9zn z{=a(OTXm~$J-e#=L-+a8`|P#WUi);cj+Qbm79|!E5)!Veih>>z5(Wqf3EArv>dO-k z9NR%8B$SUj8U~7_0CL0DmECbCQgTXm6+_*cDUHHjwh@`Zao|3VIFmQbFmgiaLsk)c_iL zRyi#}Yad~UKoOTv2C=s^T>L;IdjKtiZr!X>N`p@2I4!Rzz2F;eJu4BXV2$E_at0Q; z*fOz?QM_g@Kx0QLb{^UATqX$xf%jl$8CB`vjJHumGNIYxo^fo-`jP>u+7)o+v}PI} zA^C&~)hrmjh>Vb(zY3&Ht8`E$qg6exThcd)59F#*+X!=6r9Y0I? zxJdQ%{Y*(u|LEz-Z{glwZ!Rbzx-;e|At|-2Ag#y5T2xYEU}WUM$?X#moF1jxE+G@k z$0tEc&reO;*xa0%lWphZ9FvmMC?*xk!ylcJeWatp*ds>wUGS=f^RR|(F_)3tl`+-UiT2W#=ZM1}{Deoc-ZWhUEl0m}r0$<2V;Oo@tAgo>1fLQ!4Y z>7ySfke@Q0P2(M(HQAdEBr(i)SpPoA8puYSm9{ZGvLB zNRB-R8}C5&$Vj+ZuG_^tNJ0lgAE+R2kz^wOI`nt0jCeSbwN5&;bo@>V9jQ%e2rvlBVL_i59bs3 zk)gWiPk!r13JkbJK5L9K)B{B(-Ar{Fk z#6YB50w9tklnixa+itwQ^(2qFQIX_Ym>x3{YV0BpxVW1yPN5UkdC#zO=Y@r%;4MqYc0HFcSH8S6~oW1 zga(HHxA+x-iu}K&^v{b*I{)v5R`r%=d)AP!bcQR9n`4VO1W5^|! zME^>zA-%=Rj-IE=;<*TpzptDz`vK%Ph>WTC+aZ|j#8*5>;r}ZTRRQkulZpo9&$^b1 z8?2P|Ty{T`b>5=VXjV0K--I@?2=RBW7<%}T7*qVZvzZEO(4)X9{<@o5z*C^liJs$z zOcUIQg<8Dufs&llok;{*v9K{+HTHRZcEZE0fS zAWJoGh~kI05b{{eeRObS*X&N7dCQnOB`wdekvU4W9h0%hbQu*quFuMBp`suH@7-{{ z(~azJ@Uzqpjo@C?`cGUeO~^U+$ie|xTn0)7aSEG;v;l+Hb4*dAE+x}`zHfl@gAVie z#Us=~tzeE%g97`AKa%kxQNyekiHeC6aRa7e3kqph(Ea#Hh+0{kiVjtuWX#%I7k<{Z z*y(j@fIhYQ2vU0rK>TwFFy+EyO6Dlf)N{pvWN7kt(_^8S5%Ey$kS6tzh=ZT&er~{*=PH!FuP?0`{ES9vZ&(>e|!>J=u8yrgB(PZ;j}- zwhDw&{!Co*0z(225RX(4Lh%_;25VI{ih!2kjkRx7u;)*i&AHqk(i>7w*ImKV+`G*iYR}TXN(4g<%g# zAL|Z^F;;%4)%chFmEi@}Tk7$2KJx;ffpsZRNxy@D74O>;Xl~%nBAv8f-VUOzv(1A9VD3A;X_+G?uMw9jNZ7Ms>tW1iyc&d}TPb}PV z)+g%O5{);|d}mPS5|R@}Ra>&VD1!FJ;(4;>47o6#+61J>V{u4zj^N8C&&}HZz#6?f zviTSMO)(Cx$Cv3Di(N)DUU(i`m*sU&V7^=7&!?^bJ&|A89vEX%M&(WXI3r%Q!vfB% z3)!s66QPYt%fjK&<#ZsT^eB$H#^=3A)w~QGQqSTR7OgG!M1*DRJG;K2hN+4p1pJ%~ z?enKu*|ajus$w0TSSdPNMjyu5>Or7c$|Wyz)nuhoD)6w~(wnUrnbmB!>COQ~7xHyp z+%c}Z9{lrOrzWdK{Lk;2?xBC8*(tecEXmJ&n0yVKa}Kul2atb=*-e&8u-OZAunq6_ zKyT4vHm<={{S>DIZzTgs^3?jQtt`qzWUA+SJAl9^p z5ve`=_^EN^62nU7ZzJ)uggUSqNXc9QwWOEh*_W55?KnR4+Q4kNhJ%I`p|3U*Nvb5W zf3@!TJ}DI-b~0^_e!>V@^M)u*Lp7lTgpi?>ilzl+=5XWdHZLY@fIXd0<3CQ~9wNf= zUZ{2){Fblk2t9U5<)-%WoKH4v&`b1GU2}xhh&0E8c z5?7-<=xx&7=2S1VliA)?Bxleuoph;b5aE595FYfqX4DvM6D2h{GLI6buSE@L`*0T$ zp4Rf&D%A)VhGS{=l6O6uD^U?7@swWm>aoCM!^XAkCMdEAk&=PiFayMHaw{cDwQNNl z1eW5Pp3N@Cf68?#tl$0K{FB%4S}|;h6{at_8uR^6!>ck9%m)T|zSc@2i?Y}_-xe_+ zhYwdoK@Y#npZu>@4d3oL#q57Gop%Ds{NWbYzb)>oZCkg%_ZDHk1^#~`AgEz<6{Bm{ zzdwC4bj^qT7{x4Q#I>2@*t7`T<%Iy&a6dBQtTv@`pfp0W-XVrJGvMY{Fp6Ov+z1t) znsQ&VP`R|KngU6Gfv=~ksUGHAqdVXdb5OYK_GW*72=eR|$ntTP?`%PNB6UO-*116j zAtSHesq5vS8BryJm~?+%HJqM)qs{2&?XE5gHng#k{c7huOwEHDVcQ&ISVbhKfpzy2 zd}82){K}%myX#erYk{*m<7921Ej_FuwQ`JclMEs#F}THC2NF4|B&<+sN{^;((U?r? zvyqjV2FPYaSQ_?ouAXXKU?-~}*uek%FMIa-TWHJwPG!A|(0{cCBNgO^L}STn@A6?> zIJQB_qq8KhQnF}hob-|pYwd-D4a^1-ormpCXQ~9wmw9@uD@o*&`$)tIjCg2+hPujg zmiwfayy#iKu&*Y`1L64tc6ghA$EX{qjREiPX)kK)W&|4Q_9N~Zv~ZyJb;frr9baV( zup-Uf6Od_W-O@sL#sCLxQeIqmH}V;eezXB)F5d`qBhaQIVSNjlh3XVRf%BVh!gyx? z(Rfb|H5kqYE7v(~+uQAC)iWM@H#+=|1qH;`c{um)te2x|%cv>rt>XkeR@6&Ds6Q%@ zt^86aO!X1%A-NDVqV@hjpvZ%3y`@T>j0pSc?5AjT*)7Q@QaR1fM64@K*PnP@brNn4 zl4$Um?vDEF%ac!55ry#`nn1UFJ{a`M^8+&1Zjl8|Eps?vi*faI9f{p~0FT?H-UJsJ zTMtC=#;U+R_$_OnEQgkY1NJY*RB0M3_1Ah9Zy`_+pU%QC4{%waLE&3^Qt+&78^9$y zYm6L*g5{(TESoL3UKV2r-OSoQsWLmW{JRDt%=gSfv3JIF(2}tW2o4CZ%555V5$vHb z2bt9-4-=&O6*5~)-T!^itd0U<@YZq)79g1k7w=+)=HjgP{fSN<_VpUW3D~w3aHi+^ z!X6I!Z(q=9c0oa}ggCJI3}qQyeuq19`(L~bw*KV<0W02=9d)yZHj?OeqHuGpIW9~q zv93{Z=+RVsZ9jUG(s_OG2Js* z6ypX?@Lny9!gx_9Z&s#GHu=9!S}Td~X-K3_OWSWNxUj*g*uUr0U_s=3>V zsioj?-;qG1AWYr;0~XRTO;DVMP*&yoBq(za8GbS~V{u3!cYDrrvHybGk0Q&{gAJzD zc17}F+Y*|1cte=?cvn$x?*TVe{M8yQUh;YSo-#`7 zw~3%2Z;rDAbMFCkV#G)O{zc7yn(D8FHt>qcTof<}SV>8_7ni0WFJ$y*tloM7>!A}5 zLDE}Y6Jpr`oO#{SY=|KFKVr}fCBKR^U?Q_a2G=~qlgTSygvnfu5iYGdcq&a|p#+vh?q88n?aqvm6FZxVC ze9U}L+VxM<1yCGM&gC#IJJcF^ZSl1^2i7gE<|1pw!@gTF)rnwGUrA|k7ZP!>#weWO zDkx5!mlMJTe4Q`*bJ&+y`L`E(f23jimuK@`!@nsc5T$(Gsou37X_1vc7I}hX^DP07 z2SpBgSkp`e>WE(MB;ic}N0rSWxH6T!m0Ym=hiU2UZED)3VRJU)^bGE#f(vgar(4PG zsbv)x@JnSjg@6B&FWhvCh}o>^jPT-D4^^N2s5!{?^k8r<)cDeFOIc+ zfWRnbPzmRKLbFs$918x?D_)->MGW2n#XSF|U_H>>_W%ykgkYk) z=E2{}%1Uyaf-UR(R#Bm6VUOu=U)5ao^=V`yT&qHQ&ET~QZ$+3CMvR|^!c_ATFCl6k5tMZS#veVD(oc= z2JKkPcz|{iyLh1%(l)r&_VaV58#R@u5|x=q0parNTZ|D9BfDJ}B{9_hYOR|tHkS#& z638HqiBtXmq)y!H+c1W1D0eW$l_%0ZS@1?Y_0;=;HCrsrrloSI?XWf3y_#sYLo(gb zVhkZ>P$B!hK*|I~9ieYMRxSoDVQMG|z{w=|m9ez^2Mm#!1NrmVrq87KRVTuz3Di&G&k7@rqj}ATmr0w}~;v zr4dg&vpn>S@XIhP-PgCI#mYA`&Ej7Zyyam3;gt36Y``ulk)ov~PSLlA2%-fyn9!5? zLLxMY%tvNko?|Evi~tzTXZ=QB&g39=sOD(1D#R*^N4zpg1_iMoW5IO%t*Z>PS*wRGCO$ zn(T6BF@yZ=R^4}(ikz==c^|F`Ob#hC^Yh(Mx1RbVi_1_nzUjSi0`f(MQuyqw(+2;_ zPx2*Ze($pWND00nF z4Gy(7u0#Wr>SCHK4UarEL^N;d^jOW>8Hj^#w*=&dKA?V(#-=viI?MbH<@*=<%dV@*X=0U)V&)xdYCx0mB;h=K(d0I0>^kTjR71f8U_WWpD z8Jl^6lroHF+T>*pRXY2+P(LodQQeeA z%IphNhmE(yvAy|8AUd;aE00Rig)OlHQ&QTuCq|Eu=8uB9sBQ6!g=*;aXFKnB!I$_e zw`&xsI0i^B_6x83qI3xF^}lre>7p0!7)8sIj=s(IP&oBNpu_*8C@`(;Yfdaa%n%f# zHO%f`vSAbN-xDmQC0@aa0IgL2j;7_2mb>s({y-kXXT>QtI!OQ&FIN_c%od{{ugFC~ z>0x{oR8qG8fyi$*8v1JVmA)@gxib~LqK2;4zOqS)T*8c_Sft@y&K7uK{c7c-eZ94m z2Zwbcvx6xAArEl7ZpISjTi%U?D>iqfDDu0CaEIW4nmQ^ykX{%2v;gPC6TR7=ICV-T zwd2Ud3d?5!WZT4nNQ-IDAg)Zo?|{E6p|r421wEa??6alZqs>#8G|ErRq0#D2*=_KM8xjWPM;!Vo&FO0=V*5>%~ z|7Y(dUs`l?J(9u<5+cSI=VQ9DQA$Xo+>Sh$bP6wk`gJtAydS*}Ee%=vF1Hsh7R&tN z)qAl$bnVv5p~GW>+DhGJhw*kb)&h$%6+3ZA~*u>z5rQ^lN2aE1bZ3k~ePOjHirr+5W_#FFMz8%wl(b3tS6o=jU zEj_skt=%l+fe4<(hc0V{dNh=JSR}&R+626>`-H09Vwx70dEV~6tw3vMJ)xiON2{no zR690q4FSgg^RZre2)#h#8&&)%W4I(|lIjpVsF}Eu-JILJ6}(f-!oMwH6ZpA0YDE|a zhv@ehr7`+sHSmzujgO&aRKFqfaJPf;LK&)jZ@5#-!7$(bh* z4fqmN!Olb2)ZD-l0e3muMpq?~uV1e2d?$`7vI_ zgn!!lj9KLyVsy%b^JqKW!5r zx0eHn1Q!!1%QtR~`u=eVyQFuW z+xQjvGH@z|vahLRI$7|^=ufM7^z52zPwQtq?lUIkuArU0){BjoxWPqIlKxSl_Ttm* zu|xAG=>q1cu&=0E0Y{5{<|*&|j{(Y{{Z%$z3=PYmr)is8*xo?>ZSAo0Pgz~JyGv%+ zRN}MdmM#BgcVG3J*idjv2Ld0#}ZW&<_TiKdfGl#bm$s;+BSv8Nk(N!TkBam}{s2F`FHGlw}iT$%saj*4P zqfa*HcXD?-b(L_Bz4iL&p^20F$!qE3xk-zJ;p%qj;7#p%drfC`VBBbEvj5 zX(c--@{s9jL(6zMHNHFk`rAs1x@ibTryxb610UO0I)q0SeO*hCZ-lbfUZhdSX7`jp zDm&(aI?$Q_aFgCU8x*(qD?>ZAR0}5I*J|j!le4R3xe?#ISu!Rb-TUTydzEEl$r$LP zlfvI9i5)E~cY$*GlJPGLlb)}7WT)Mtl(ox8TgF2Qf_>_x%2>cEz`6)+=4hs|H`HVUJg|OVO<{-NWtMfs zk0bSqMLmmG{5Rgov2J6NljaID4{N^H1=XUH-00+8W`kHGnAa#>Xl4X*ci4?zsq|6v()YLSDDzTH2pLVU%Jlw zQPIiup^`t8(C>F@b3A|Q2(LMOaRYfSOG|A{S&-ZZn|j4>*?{*OU4E^-Iy$}uYJZgq zNyhRiXJgV(ox|!B!5frU{~E!=9JKSjTw75^zA*N7E635%=R=NCBX9WQ5qjr)(XWVC z4;$nKWr=Ghm+Fl_hb~3)A4K#GgBafhJnC}e4(s$x?ne1#7qZ#BD1T9izieA915j_z zx%fEVoMEBKgaO|yh`|}5UNGR$nppO3-La=fg)K4Re2O7Fp9D5fa;g5L&{mog808Nt z0d~6IY;KvDlNNND82vL|tDh|TPWff=4=TB(BU(e&*%-CB+7y-GoO8+@%k%fTi;Y{e zXHt56Gs{bP=i~k@?SIzENFwu>o+FRwC|~2pwOqd@>|GxSh0+GL1k|(1VEh^QLRZXx ziZ70V6sq}+hw#5+vH!2z#adp6$XPLnb9V%bBp9M4j4P*`{Bd-5{BELA`dVGROyiEO z#yK77VYg3YrCofu_)EY=TDw>NErqKhCX7S%3G&`NL2_U0-0BZo>MhbGy^T%>=`=mk z5C4vahEvxr1lVEoo@Tj_mzPcta>ZZn$ki?(DClWVp8`iLtGM|K!TK|=Q-7k4*lj7; zhA(%9FzIlhg*5xtX}TI%QGa?eO#xt!$jPA)%MGKeqNu8%Fr$qMX9PM`%9^+MA%Ae` zn!C6A6La^oQP5fW@bOAc`Q3r>6vdCsrRK>GKPO%T|A-aecIl}2Op1$7Zr=VCcMz4z z>%370`>$-?z`_2@9@enZ#Z|!mv)aigIiSS$vmOkmeUY}b_oQ#DpXTvV-0~2yibq+*5A~m zD&yhd9g9={pf&JMv!$k9mF)E0ORDR7+>ReqjsAMJ`&g@tKR{^c_J&qw%0HhOr&WW) zmTzii#=Wz2yGR1#PHi^J?cWRtPC{`i4pCKt1}Ghc`4EBXxPWs+Y+*BIzb4A}Vlo{r zm*X43PmNa2J(0;h0nw1SJP_L#ABS)1!IlF1AH=mcC-z7GfYvw;9(;;SR$`}IPQIeG zsXsD1p2XCpozu{+fDc??Z$)QTrgbuL%;c{bxRs1)*O8LOLe?A48*x4<}De zVp8>79ZTzq9y@O94jhNo*%WF0|D{Zj@n;nAjj?6!f#^AElP^d9>VYUxGvGQ51P2Dr z>0ZjH7H^pL>{^NP>f1Q*6ZTyXnIl{Zp5HvfHd!^bfDmO%@BP)sv0pL1bAH*jV$=m| zwX`8O3YRgE&u_YYIyJ)C67;WVgx6VL`5@@mGs^ZCET?h1f(tOp+iPyjAInV-&lQojik$TYD`*^gwvRW z!ihG)mq+c7=qMs)8WbRj5>6oK`=RQ168Tn(2sJ|;O@bJ;U&*_dp0P5$;xi@O_SD1E zux8|7rvgN~=DQkvI}qqDMlBO(Iz+53soOdZ*EWDH$^w6{cQl{;dfu7H>qwlm1>ZIX z9CvRYuzBIB%J~tm*y~*;Yqf*&Wf&pNlzLJQ#$-j_G1Td-sW^JfMVX-zgn2%wRHcGn z?Y5cM@5bUGK~x&j1TP}>ca zf=+zkMh2a7>hNrVP&myS&_AA}sjZl5sJ4Sfp~RWBA$NAU{AVA@R0e&5Wc3<30Ne@z zVdJ*Uv6?@U)I|z+&r;u>w@5Y++;h&f#v)6IpA8Secbbe+HA*y3g$=!ZClYFpK(oVN&XxhETK+Z8Z7Y{4@loYo=TE5vvW0o zid$E)+5p87Co9Q;^O^QSz4CKZYG8 zLmheeQ1kcb7BvL-U55wh9qECFTo*g|dz|6KeddT!+r>i*r#;X{iHt^talerZV7nJn zA>SAEUkZ`NqGKJYqTWR1eLPqr(zY_)Lg1&oHnXP_s1y@xF@IPzPyv5O z%knz4&@hKfiVTO*bMF2reku85IBj<^S=B;184N}{Y_DcMOBe+w<3xJj3^SvYGj^qC zu?dMPQI4W_wd4CDl|YJhzSQw(sXC{hz=D2VF$g<>)vREdKgi9wASQ$&h%>zDlC2hB zoUB|BFjzK*w|ts6U7goHp?`&LF7-+zBZhn+HpPo6i}>V`Z&z_KBIX~qiYMohklJb3 zB?9GnE>u!X(=b6GO8@<9$-a{t==?f`mxo|6^RK~#f^+Fr)HAPnS7TsqC));f#^`|A z2z6mAHp5sUMCO6SR~*v%nyjh?Zl@4BG%QOfb%bcRS^V61G(4cGpv|DFVCwY>_A!ms z&rSfZMaL$sFZ%1Lv}vQ#IwxR62l`6Wi%XPQnaBtEJW~lgeW#e^W&kZkw`Oh~-8p-^ zqC8hR!l5`^#u{ck9)0b;k_Jbf=84`Wn-23B9oZ>{PRmO)tE6ZE|MCg;=I6J}>hvin z7EH>wpp)!in?x|1$Ytyin1-M2r(&(6<#{59Elga1KgtTs$gNl(LCm*3gYAD4aLwbuHM0NKWwc^#pW zN(1u6N=m%S_dPxaHLjRl4_?Kh*q_m%L^OS#1+;GkJR24M`$$KC6|Qj*17r5v&&)L_ z|723s>zAnHUM6(JR;de|5O}Jq>xo_}Yk67#Z1rKmBN}+H8Z@*CwburIC6e0vC|N%F z?l|87s6m@!#rOvkOAqFS!l1ZOFjynjV0cp^573Oau?M%oO?o;7c)p9gp-LA^T7sLN7c4Cv5sKebqnwpy0W7+}E z5*Dq%#@!L{H2_lW@(=?Q2*m|HdKePRYF9%jy5`RZnDt*&m4RbR_ zff7VWLgA9=8n#g+cg-eD?&$Hg9kNYv;vqmGmwj6_FS4e`yQxD0Jn;qXkd z6B9t8a4WE!Lv%l(*uDH)PD(!4v7p!niqc;Z5@tu_o$xQ}DVd}>iZa&(mHUl8Pasn2 z3u^OiaZvdyK{e@P$Q|~@xUv0YeAT0r#o5RNt1Ikk9iX4M8AYlXj-umfZEO&!>3v#$ z$mlDWm?|F%@CcbymJ=YZ{RztjQ43DSiv)H>oU3pXNudg_I>wR=Cra%*aYJInO9GXI zY{){5UTgTS5ildH+u*<_!e(-`0JEW7A!H%g&XU|5^tU{0v>uL zqM%(A-`CIrzeRb5<+r2o*L<5ovCSaX1M=N5uXa1zNlQnqRDRVsT_LnQ*6RMizXn78 zY~ed{*K>1ouMv8zVJJ01t5e@w9{2@MsIFIb#-$=PCmwFOy;%EFfDi%){mdHFzFqT< zD+G9+6Hv+xE-F$j_xJ%EfnGfk0+Z4I&sU)=!~`8n0(EFrQ)UI~vHnF-jz-G35I&^- zXhF&w^;fOcgLN(~1dWxA9F(yF7-D@Z2H&N@;a59gvR>qNBv2Zh1^2?-sI%FN@BnAa zij*OR58v1IdIxJy{35w&@LK8`6+amr(7sRJNx2|yM+weS%Frm~V2!73BG|~_7Z;26 zv$TB&6c;pgNSu?vfV8BD)9XF!Bo`NJU^Jf+@<-rnR>_Vn?|>y69Hp#*1CgPai4gVC z3=sLJplc3US_dksyNqFT1S1ueyzDbOO7O2TW;#}zLcwj6Tw@io2wi$->6m%Fz+z7+ zbY_;94FXrz!is()F7(pjnvA=Ep}Zg55K-zM$s30E;4D-L_6UVcjW}7At7dvU(DAgS zqJmiwZt7Td%xqqtBPq4?I*6 zzI%NQynu}2s1X?kfGUCl?}ryVyO!iRL3>xM|0e={FB~;mat2czC1jta2uW}Ir~;I> z7oJ4O@wNmjzeuNE)tl?dRN0tK+$L~O2d~f0nE=G&ye$bEaxXvw=LRF>vYZo8oUEe^ z5tXzoVPx0b9F^s26-fy({snuCLA%t02e|a`8PlIBU^y5fiG25OK|WIff)WoF21IrdE&7MyA14gDhrK@7WPaCwld>unjSt`vmQ7j;t=n zm}G8@5~QKx53r}#$P7-k)(VX=nO~Qs%U>E)j_AvGqhOuyz`@ZX^Po@**uy^bUeY{% z=O>r#P$O3Q^KPjqQ(joR;zRoov}JOWTh}yiNMZz9bhZ#6s#8_#Be_8W3;pevkjZt0 zAlfQRJbx<>R70=hYeec2fVHsch;TLT1}`Amtgu@|k6Ex8@iQ zfqobjIio$T^9NbphsH>!KyVQYy@(ir8EBiD5AP;Up|t-y@#D)$R8;;$smF=JhUpC$BBC(*< z&86}jjCX>jbXZ?Hq)eoC$@aICM+8*Wi}G_n#;UEkxx5uVCzmVgMs`vNI~oJm0%`6@ zTt4Or{(GIQoKMxUc6@zbCT~S8J3`Q}wnk)Vz7p7fq;Yi{o3^Dtg<;1}uva$_E7@G* zuC{xrI?^*oN%k@!#46u#uEoATbak!Q`JcW_8^80bwU7Gaa)0ms zD<%HdwD0O;!0&(CUD=?zE(4xz$m8Rnej)XZ#4lSf3_~$fUm!~F=nSh^wXfVN5@I@( zirKCO1k$c~l;06Qqn%~mz?X148kY+RTp@g#}$u5*ssn2bZ)*Bt3q)E z$<_$jG4}J)LP2)U|I{nG{>geY5*X~WQsjBxYA*aJ8FFuKx!uGB*{co*A3ggWG`H*L z|1h2(_c(N+3B6Rkhud)I1BIwnWQRzpNY&RK-rv%aRU&U*(pPa?RCq>UC=4rbP{i^I z(|qRuw09rRu3G$i>)CAAV5~^$>SNr*&H9Q*o-Ok*V>g%+SU75p=^gXMa<|v+FF6ct z`BH9P5X-~(FY+%O_Od~+>a{qs*ld5xwKLLOqt$V3x?)MzVTr~1GNq2PMLB=9`p}0P2Px-nF3Ral7xWh0+;uPGM}cdhzSMl z`f0i`RcK!nV?7&XgPI{i4?P?Nl0eGRsW(Rj^#}dF>OGu8yv$HHTAlcCP;buvR@2sa zxjI?NY0fQZtf(o-Raz%6qa;;ptf%9o?Z7q(#bZt8ZjhreNuv0SC&lf3!5 zR2C+}a){G!?>%`!d3JWT6A^uV8eA0HI`u*1@R8mmr1=cThw3tb=F{JQY7WTc3p|a; zzH(87;fmj|k`>5-{erE9iOFO(OFhA_MO)T43?f;wE64XPlid-Ft)=0Q!(N3MspQ|t zqZqES0mB-w~VV^fID7-He z;H^TSGC*J-I`7IU1BiO1kl%l3 zI&xS>)vBZyyV+U?*}}o?liHtvr*JXdNNmftO?jwT+gqEa$K>dX*q{=0SLV*7=J~nt zkAzY~O&@z_MS@-dhD2gwhPe(r%iT5Jf!e8}3fwY)y?K{P4yW@FIcrzX;i z5vNA}$B9>1-)FBCQ%=t~JHataCVAdA@BF`i?RQfvCns0_{ysJQx9mkoTn?%<$RG!9 z`|K?kCX|8-f?wq{%T>@ba+!yOtlipwi;p&n?%R2stJk~%GWJVpl)n6>ed|u8NHX-> zckv28XIbk*Zl5>x3cp7#+y}4RV`8`4X_;9Q#h|QciYO7R&t6VYPQVl0kGn=vDk@0F8lhQ}{@Ji;p`L)V4CPEkRBy2*)Usol|?g2CvL7T(rSO`rw*i5Ri9ReY|X zKZ{=;d)4jY9B}NO4(A=^y*Sw(9Y}}2;|9D0$GbmzRwJFK-$!?Xcku46J$ANUUdG46 zWqQ`(nlecn@!w8{Im#zxZfO2I|Ib zxwSMVQpuf6EI6y*FVCu_Y0bIgeY-X80K&u!DzK9Z`(~FGI{a*?yjhJ;7{1loeXQw7 zzJ~U0|04;N{+ei5eoxgggkdh%KNn!F00=N1N>LQhrAocTeG@#N)?!DUbZn*}T*dq= z<{!+(hJU+7IKS4*x?i4ztJJxIv(~}|mx--bY%5@+QonT`(L@v9nsq;5Z9ao|bGe{b z4*5e&x~NgWA(X(PXdvKhJJ8w`^D+hGeJh3l2gpz(A zn*AnfY8A86r&?!lw6+SXOohS|1oy-6!5he5%NHbc+&{bqNb!)sfH1#DjO4Dp9S?uW zWNU_bwW9U`1+(lR4LWAH;}!V@T*+4J)27mUg(Jc(5z$vV=rk6Q17$XZ0uPQ1~sw^^Nacs-PRpoZml5W5Uu1r>@&j5h%k!W~>rN7i&Typ$}5^ z5qcFK?;%jBobN_tKJZDeMytm*I2NLJo{D7jO%N%ihFb<_a6CmQMgZHki6pZ3L$q*n ztX??)V=?El2Qw8-)k%TRI$z8^v1UtDxyO1rsH#Se%Ip}bo#wr7Z!h=Kc>g=ae+lncl{-{S&#<;qjMc{vg;0JAty1G zj?Mw$)E-xH;6obsuFJvHQ7Y~n^Ym(bnTqF{ARq+3=ez1LR6DxnyWgp+2|S-Z(h;Eh z{QE(%3mbl$*RMrBY!1$H|AG-*w##icZZ6mzHaBKXMlQ4yzN8@7u%7QY6!6*0K75!q z&oozFXRh(rbcwQWSbB+si*4arL0d1;KkT(sB6>p7TYl8qH0pCy7d!-`W(bU*CpRQ~(O8BEBinSK2OR7xxZ4Ykt(7-dC9@Axtd0qc+FY}EjY+eceTclQ zucZ9Fnj2zqqqMNwYiyyg8=ijoG6eiJKiRm%bl0=+UwWabqwl4%&1RF5SbkLCr{DxB z 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-12.png b/public/images/zk-stack/Check_if_satisfied-12.png new file mode 100644 index 0000000000000000000000000000000000000000..3eee1a4c8966e612fe23b186639287034f740b9e GIT binary patch literal 30075 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

6E1qt0Di{*dDaTFkV5pJVcJ|ksQuYs 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 BUR?kH literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-14.png b/public/images/zk-stack/Check_if_satisfied-14.png new file mode 100644 index 0000000000000000000000000000000000000000..0bc9db0ad07e57b033efc0b1ed02c3345c288c2d GIT binary patch literal 18577 zcmb5UWl)?!(=NO~kYEde;4Ch|T^HTp7Tn$4WpRQmuEE_cxJz*N-~glfOh%bs#7^p<30000(M*6b~0Pqe30KmDSAiVu)U`5RU z0N^{m$g4?w#3xX1TKz~sG(G#1ZdBy;2g|FWhVu6rdTDhgWuuQoBx(&Ss`X2x%v?gg z$%@4zEb10S)bzCC3UrdnG@^1UwF|^_On4+9xx8K~up~Z+f<@DcNyV6ikqyMkE1S^) z_DbNf2_T@LX4SQoh^^!_^%V9`k%+IxCnY226x^S*=Cbgn68QW{P8;l_`GiP71|cP_bV?JyQv4I*E&*mUjbAWGbp zJ`4&v3ic6}$sqM@PD5t;OMSYl>ZZ!ZHg3lS~j*yMzaoIE)tReNU#L{f^Cor9MC z)0groQwvK*MZHhb8tlAOBxFQ+g@xly2AR=vM5PSN*;E->SxG6$zxvJe3=BAVcuLC4 zeEt2KT3T`{8e@$i(!NRfrH1CuMDYeL!$1pMYS1 ztLTcj5M>V^Sqmpvg8t+?9f3V1B@HP(84)?RP*z!eWK4{Wo!z~LqNq6Jsg<$fd!@Rj zR$zhDpfJCN61$uM8&N7j#<R8d8^h)q1F9)K$_Z^sNg>h^zMsE!eu?E^jbdlT*CxZ) zB8#yG;mMKW$&fn7iFw%zCI3(kauihM<_8iwzftG^9h>97f1L24 zzEdWs26#Co%W-mFH%Uf_-=&=&rDCPJedhqy)2pp#elE)ZfaM`bNc#k zlGd0l=8o(r$aGj+R`+y-8{2afmy!Xsdfq5Qg3V+_fSzCa!}|@ z&7gL%p`0QEpcMy|qRi@KJAW+EXt^Q{oqk3%%7yHIs^^8eeA1Ip9!sKj!=+e7?hzK- zP`yQfn&>Gw>_%La`NA2c4=$_5;H%W-bX5G&VbH*l;?58FP&;Y2TQ132u0^D2o}%Jx z|4V4?U7&u+8-=rE2YEcyuYl!z60r;dXn>A?u3)pSB`@TnZq3PRP@MnJHuV6Nk>EIi;cDf>ygoFNjPud~_bo5|poI5(RN)BCTC z)F_@R7^pT{A>7s;!9<^TnSBwELsfl{a%V+2f3PS651e{0e1e*^qn`g0RsVmFz#K3c z7h?hu&v2OYm`a0lm5f3I?!idu)OX|hAb+rJ&QPOB(rdzsoub{)cLDEBS-p+lyP7kh zcPhf4k4^cTiAukxg#Kx5Z&LwDQKtXu<~7{;usBvKJsA+|z?_QDZr^hLd0(BMJ-oVc zeJJl6GIMOb;VV+rE)0rW?pgTr@XQS~_5<@eUjA%uJ2iB$8S3@tOoqCBqF-zsBxSK< zm2c~}Pq87H1H+U0bJcK;Nb2QfdE%gVc()SwM@ zDC$}LmvEt9JjOmk3^K1e4S|S}4V+DU%3y zpTjVZEC@#6--&A_eF?$3r|Ai4>f`9?sg2}h3!Y+2nc8+pX4N^?VktIHezLRHekyqh zE^+kSpw4oeXjO}m=)$LCALW0@^66e%CG}ShD3be*{8Z$97xZ(@72Nzom`(mGzfxLX z)#^8)D?j-BCtB&uz<)@@M)>dboY1)o#-So@+<08Z{w-99-bmyH; zoMEiH6|h>%*v^-(q)JOBo3>6Q9nG5QwFwcN(+!zwZmqasA%7h{1E4C~-0zRu(1^Of z6BCL8PgTA1`(fPg8@*gws|&AQCU-o^_U|?osy3o>ZuxVM#(#K{$$^r{-wOx{aW2Ji z+I{W7e6gE~73ShSKzI1_va40E1a7>;n*LF|3F%f_7^Z#?1yc}>HrDV0JC2RZEMBMu zv^f=_Hu(F6bozI@m)C1LE~Oj(r&nG$4+2PKb^Aq@>B(yYCs%H>kJ+O!_=5VCy@Vr; zH8i;S$ct8sxEd~_g2#m|WwLOP_1ZLAF;Z_|xLq%rQ~4whlp%pp+JrFjbvfE+wxf~N zT^^>4e-3Ee@Jas)I#EY+S9l?e2m^0@F>;i0T7hGQjeJIFTWw|2 zl1=t2p3#U7))~?}owc9+>$F#om@8m)vLB*}I^=bxF->)ipl{k*R)qBt8*|1V(x{`t z1S)%kEl(@~L!!7nf4)Q{stV1-qlRBMwW$T?+x1Yd0Jv@>Z%Qr`50vn8RdeV9Iwezy zFIaAmx+bO?g|`lkDcOj!H|CTr+XTQU0~&%QLE)+IP6XhQD@j{4W*o}}iDHfsy)PlT z;Zqk`L?}gix3xqu4j+$u18msMPlBW-0e?qh9pqb2;Mh+c99ZFRm@4E9K4GK@op%U_ z6LKh*1l>AsXaS_`w=tG;mEeEH4N!V$UC^}XF@36vL1KskQ~b`TRC^r^k<`{Sj}Kg#Lu*JRB3<=?Lw%k*CP(WoYnE{Tv)-QsN}W@Tb2TS%i25{KEWg^^Q;%fP`!e6VsJY#?m!SqG!x zTocY)c6}KfcFsu1%@yf3lW}(Fs!Kr$o6>%FtUaFyh0e{`jF=h2&&I^k{j8AxM`SQDcw1E?%kT211PnQAGjDd=?- z;vynw;Q32v`4A|b7QPtxm)h%y_|CcxPm#i%+kUNC>R$Vy^n^CJK zHn_vWV6H3*O{fv4DoT&ex#!IZfws<+7tBUQ^|rwGMq_eCpW%wM{?eoNxXCV&WTdLB8Cwkm#bZz^+6;hwP+!no3- z!ym58z%|^PHe1p|QgvMNv=@5gs|IGyN>-YskMCX8XfAss54(Nw;6g z{z1eB8WsL$bJ2hcWeRK~MK4ptrM+UPj~lHR}n}yQ%sA1j(gI} zpLve}q7(?irW6Zq0toba@0Gv=dqx@#jmZOTO{y=;khPRYikhN9-dPbMy#*-~wrC2! z(KK6#rDw`AUFTTW(t{*FC-Ln;BN&?a7zYd!K;D4{9Pc@W>_q=YAzq<6sQ(AB21d_c zLC2>bx91Ph)SsKQfOFJoa027U#%sTWAR5`zwe3zo2zh1 zZ$2K0v9n2h^&lT4n#}BzWBH?_E5YL`E-%=Rz*%ie z9Ycz5R++@aj)HvZSmj3gZ&**q$0K9nc5!%xuk`u9H#5> z9H>C~3pQ{qQF$6v3DU{j+^o?9{wCn63sk{|uCcP&1}gKEXL@g{@N&NO738nJz#4hyr0xK3BYTvu0U`gj zaB%~*6ME-#w!LDQbm}Tpn}{alCX@-<-^EZOdn3gD8zEBv6=}SlZc|bO43p=rH)V1t zeD$u}i^3P215P9_1Z(yWjGNV8GI@I`gL360NZq?m`pj?R<8!X+%fPH{amm!7DAamD zaE;|sKR5K(5BnnuxGZ$th>k;Jg`9)gaCIK9a#(dInj;1zzV(jy&-DZh#aJCMp>wSNGqG3*R87^Hjv0K9u8qf04c0B4st33Op>*T{nfN8$Kjgg1;Q@_>&+ZU#gNh1Q($HuRzOWrpb|FYmQR6N=D~&%Dep2TPQR-#5f?yKkj&X@^M?AA;2e6v*WhpNQX>*jJE4Ib-d^&PG) zmm?}`+wST%nE<%$wAyK&&;v8W{XRt{T{Ow$C61}U%#>6_BgnsF_0J$TvjH=KQ}x#0 zFKnq#Mj7H^PD$Xf6o6Is6fu%HBih$j3sf|dtj7)V>y#*}$p zjx0g~zL(6&-w?DOm%v2S?j}uy=3}rBTk^;fAs-~iTi2Tq2=)^!iry2IWV^SRFH*S$ zEV*oZZL`383wU7e-sKG#ao8A|aTy#f8ci^73-Esz zpOM5AhWrKRo5L&V2#`Qnb0<0Ra5dcdF z(@`g4@o;%$r1r`($1M{CQUuZ3-g%6o9v+l|?ccuCle=M(JGnKA@^4!kbqiMQi8( zvgLjzP4{Yn>mZ0}F`dAy*4j5*T6)DfO{VTH&xA62bP0)Hu&?k+j% zqX!eG&@SUB?MOfC4?HJVO3-!w;v$stN%?Bp)Lq?dt?9BX;cXxm+a8dzD%9I23aM; zk(Q`DFcpUz4Z(Sgv-7n43RadjWi)dy;cK>~s2lO6*XT<={I@k63X|5)RS(?w=7V>l zV$<0asbvn(^}Cj*bCsN--=Uf1&L*{;V>=k3;^*8-e+0?{ul9*HASS!QeR6mZ3|`j7 zzoW#g-$;FDcr|Y^_h#mfkL-&$I{(Bxxh8<!zuR{F=SNaf30ZgOrz5pkdiWW}S=iQjT9hqZvp422K8jj~^t9wEPbKT zS%4JK|8!0S=X#TS{|4fJzj^(rlq2lzw!$jUf!XYF7$Ebys1eV?_&T`Rud54cALzWF zWED|OW>ByAmghZJAp4({TDeN`|GT)R^Ldz^`-~gr{10j|_bVle*}izM;0{R&w>Dh* zBkShJVgm*SFGx(rBV6?CH-!gkNqiRhNBH)T5DXu@T4y+0(|<%$Sx1fYig3y@^1nB} zPTYP=U%8x4=j8e*jzSTF^;)HUhVUZDEruZ;9zb2$7^k)INX-*(HFPhl%6XZ|0)}Ck za1I^F6Ym@I^M<-NWfN5n-`gBtTqr$zfNVfdw&WqpjTkras>Hin^nU=W7c-6r#>k(b zSmM{@|7R-LB|9*Fx_KyfY|ysKRe(0#u5e)Bzpq)+Rm!>6DOj!_+0vB?3s&}7Jz0lLBU=i?KCTaW z`vGej3CIsM4IK~R&H5hb)%8Whzph~O4w6v~QEb128s{M>$~mwrnqn75veK@K&h!4U z`FS;iy%MI}&4RY(=H}c^eOnnL+vp^-^`IT!hq?pWuPj~3Ig+BM{U+J_5vv(1tfDEGAxb8#0|o1tr9xi5P8?b zCvFkBgE0L2IE^F>tAGi}32l03FIKJ;Km%NfGVjWpy)p&ohU~?xhkj18KG1#0tkuv> zqsknEjPhT%>ViIi?t8a8`oC>OH{ghekAV;AC&b5DD)zcLeY_0!ll~%vk~fy+I;YX{ z75OAs@C9+yJYMqNT!x%Fk3-_4Asym8f;-Px;;s8z9XeTrEqn9F9zx5VgQ9&izHwfN zB`s!DfxB3AU!3w^*3N(b{w>(qu>vN@ucWKKyFaHQUcdfgnDxnQ1j$D)g*vn>1NNzD zXw75K_^WMJ*r%tAQh-~$W4;9DJ1r-tB&gLd38`RR(0%;m4ABU!Whb0C$`Y8Ve9-r& z;aES6LtE{aRCnni7ZWdZ1t9q-fGXz}2oB)JK@HX6O+|k0tHZf!$)EA(I81^4HG|io z`!h=zfJE^*c?E(=v)aT34dK0vV&Op9!E_WSW?@k-;TeN;WFzOo{HBcwzbC?;2eYyG z52IT|QIs3Y{Clnxm@QgFfc>{E`B~1v9oW{MjK#I8Y&!DeM{1t316QQaBu(b7a@3O%NB5|W)8hSX5|p_Q~bN3A$m z#}#t)$*F^@3Qp*vBBpm*nEki%BL4&XdSXO<4HOc=QPn5XxKmBRQQj%LuY|b3U+-WE zCfUNa)Dz0mpb)3Jy!o-lKh!uW+Qs`K+S!kdiLYNecfM54X-&(7akAU#p5(L z9>LqyXh}7vo>R>V8y(1a6Yv<_xHqs6-26Fxh6{uAT>WGh1hNBR=WwGFG(diI-BWH) z?x!#D6c1r&66(IzG8*fI$MO$BU2f3H3q8!u3pI9o%L$!FHRa|bI$FSB zuacr$XuoBv)QS@fUdDw{$(ZoLJ{sI(s3_Foy0Fb;`|G>mX?~wfv|Wo-MQ$+Lsmd3B zOM;W>&1#)rT1oxc{FUkvH z2?BqmP!|kBE4t3?M=^K`ZY@M1B;8m&8GMtVpK?XMzOZYE4P3XUJA15jufMBSuOZC- zy6_?+*`^DY?{eZmtu$6~CI~wd6w=EyrwtJqG~jlh^+1w&8s6D*G#(1}F;Cgb2}eer zx+4EK>h-07q(^8Vn0nO9$v&v+HNq=AA#Tho{>7y?d2dbK5GCw<{%&DA?HCuRFSh|9 z&>=$ja_w%kXF?aVY@%cc&s{N{DsdFic3h}E|JirlivFoF#zc5hwN@*@!@l0=_ zr`&2GG8F~i2~lg>%El+f0+thEug(0ZLGokDCR92-oMe;0s0x!Lh5NrYDdcXCT&VKL z%Tw;>Hmyc6u>7tZ`t+ z)Rft$z|<)_S0faOW+`3doc7`hw%xgq88&U{b4@Z*_~<0;&t0aEHp*eLb0da-%Oj@5 zzF;1=Ak&d-Q}iQKfCm%-q__8pzD(H^Z6yGdgsnPy+o2A)2^S=Rn?)4vA8h49aHzk* z$9?wmc9NS$1-b6#C<_3@S9MSZ1`i3mLxrTZ4JW1s4lI9gy#2+U6NFUOCjS;EU3YPT z_r|BS#(Let1a@E^#12Yg7w@0KDE6m8ewZOrKX4bXn=ASd=0l7b^i`JQi0O7VM-`ph za{}ja#nE=X93CsSr$y7~hFQJ;j!rg?du@(h(;xYH8HF*;r|xI9G#mt>uK@GL)YGov z>SCkX^rjr`=WShT9#(>2o${gtm#*#ZkH`E^x=xID;V;*h+hQvsXvXn$!wW$+Vc@X+ zil(N!tn8``_{|aFm!F;Jm;hUR=xj4hz#NSLs7HqPwDUliFggZEYcEEu}xtb0;`G|aYCpK{iPd5j_ zP|+W_(|(M*No;Nr9U+0m$~$n2<01`dFpH6CRr^Z2bbIJ>M7xaDtPF}Pb3s%x1EF*0 z{ifc+C4rQ4e;_v~ah1kOV}w}<)S3dItu#YJFP*wFA`5$F5M6oX+4;or9@&}$u@?{6 z%s*2!QZL<@dhlj&%F%mWDIs)GLK@&*x+N`!QKm1R3J(2aIwTu@lBkfzYM)TLBN|5T zBpLuBFjw-k&PgSz6qI~2@=7rnT%_1`>_V>ecL>YVjuT)SB;|-&-7WksFc|Er?s;WI zx{2lueq2&6Y`h8`^@)UGyS&d}C|nW20^aij>N9=iC9<~}K=lSw;)OX*Vs?o?hd*xY zLgF)eNS@bg!~e#l$Hjk2y^2S~JNoG3qsOG+M;2*lxAaMeBK4=gf7afrfLZuj(BQjC zWMtBmZA$HdDud19N-r$+S1YjE(ZWtXSsxz1v(iMoy`6?1*i09R#YTeT_QbN>=3Zw> zXb{2Uq=qPmeE8)Hc=-UZy8E=goxeV@0jY;fbUJIrxx%U7cttoZ+dXvATk0G@{pM*B)5niFk90tiCoHWWJ3d?OH6N>v<3` zpN2ar(55C8sTc%A*iZL)=-STjcp2~;y&4sHqa}Y2J;KYWD~ z0qlW+eo$6rdlU>F%5BXR=e@(M6>__-3Jzbj)G{OYIPgmI2!|n${9E5P z?(yXkuO9KTlDq*2ExhALH_l!Qo0>*QV*oD(I1vI{cV7g^M4?pvW3~hZYlAgakNkx# zTOah4_ead0r7bAvl@Gj}s*g#4t0_Y|MX!V?=A58=3b3rAn5MUo;`}|)v z;WHjkb6cv}yC`%Ye)xVqDPz@gk&6`gtYE?S0YBzAeAj$S!D!i4{UntF!~GQLVdq~n zv1AQ6D7JfBh2slF(AGba1*=C!Kku{o?&5y0SYt{QZn*-~_;*DrUSZL;@BfNYoFoDJXeq$tcjt>&AugbS<3jyNCg#{_khyV3VYft!f*f|Ldc%+~Lg(8m#Va=LElDDAo^!R2 zvW?ESV_#obXHAqrkReFYsE2xCy) z{e$~)YaQBOwvd6<(^C~=Wr{YmrK?&w7RGS0cLkVNfd#pl!iZmT2!Q+=gC7w_6NP6W z^&;=Sv&JJ50w=fUbikbm!R<=dXT2)`POKb^_{yeCJ-MDd5@pwd*Loa|+RZ)n1$(ej zt^YJhRaGfEk8m>y#dG@HfwTbwmVga!0qcafOo>w_@`#oBq}+}E13YxLd-K3L@l;Y@ zeAWE+pYNcAda0KvwWvbw%W0=_dQ822wEW_Z@znSN{y*N#w$wf>w=Mv;%wIOQDC*~f z10S}=B;PSV@Ib*Xl(uIcP4Oyl7l|;t%4;;-Wu* ztrd!8*(gbYgIyLk@i;2c_R@6vRbVQzjJMA>(*HQ4q)B$S(CSMIh(}Ni2nIhhpg?|MXaRz#KzT+wE176#`KAPtx=Ejvb_Ey35dLz;_o>_m!c`TdBQNX=dNDE5u}jIHw+dS$KEc{|2P zCYD%4+bH49>Eoj$`Y^(q}{QMvhqn5Jrc6?o>{Ip4(kOnZ%5#4l^vgTpzIGwx+?I*X{zc%oBbliR^uI?78GNTa}0)FQ-5!E-d)H z;k%K0{b)@5JVCk1vj@VKufn;GvGPwgvt@sKZrJ_L67Yp`MH7nxDjSBimR5oUn&?D( zGl$P~2nOR*V}P_Dgm5kDXHIMLN&9RKef+~FfjRgTGPB+4$j=RJd%?p9(XnE!v=837 zq+TQAA*Nt9p{eHUD~1+j)sEiYs^1*x%E~y__Vz-Q2fDUH6A#!mefy+mq%dlkSCvp3 zUM?|K#+dS_)X%HT zNi_5F2^V4qBtWJFFc4}rO-_BqAjF5ACAp1)?EIBRzBRVr4w(`ck(9=Sp}j)@B5 zCHieQms|(^;U^VORMav8N7ae?($*9Qs0YTIo2AWRD5KV!%;0=<;UTxz16=M;aA zX6&51z-r{C+1kfU(2=DezdQanZTUK*=P#Eyxivvdu$kE%qex30C6I@)%G#}LSw?eH z8$d>{RMZ!y6YyM|OmGhM(p};kq^<24A`!yvlgwe`2t*@64S)YzK|#UqrhDzE$UbUP{k+$p6ZJC*#x7 z9O2%ikZ$&E+;=?P#s~th*Vhu=DrlfR82{`aa)tiB(>4(DDSzY99HW|hVAjn47$N>o z+3&bi13cg1LmVGR;0uZzMur1nCjDnavq;CuG1^0aHMS<+0E0Efp z@W*;MLbLxDG72hj_(8LeFF|!(tEFtfgrK0HUenQj^rJEZy-rkpL~XQn!7<1;J7ku6 zI6{%JY4Ie?3bXf^UPb4;-DlwW%k57S!TS@=yZKA~lKAxlvP2?Aqvp!|AX%b#((jzAA_4$!6vj zZwfns>>tv^uCc|hk(5N*0vBk#xK{cOnasdGT)Uc82febxkf8%NfhA~f`FrxS@+Xpe zXqgLA0Y<-)0Q+Kh{L9$67Gg+)sp*h+1yQq4%6{TeGPNq&hEa>^oJlS$r9EQ>6%nbp z!l7J51)W%bie;eY{z2pgrM*Fs4C_t4V3MegC1od9z>1dn$Ps$JZKFkX1y0GN^s9jYT<4W0P0-s1$V0`P+ZEYO5&NDm7DTRh^K+hm(Myg?dw>2Gwt_(+ zpA))oCp7m~%9#!&+JlJ7R@ldQ+GJxaHN+HSNHRJ{z9})rYkU^bA(;Tf&2$vjaH1%% zr)!mz&{^RYhKa{v2g^6$ieqCiPPO5~R5+ehdpB;zTC*CF|{DK6avm*S$L-4Bd%T<>qr z_lBW2J=tNHPeL)4EH3m1ZO1yrK8F*B*YO>!Kc?pU1o_kp+U!zc*cuM3(eY6%RzoDW z=vfzr)HTa{`Hiy;u3f|V60-D^g``ZRZ`~+ND%%%Hm1s8$-p9bu2)!N=nm{uKp>is$vHEhz^f1NpyLB5O!UXH6mjKt+qj-> zd8+@2v%8v9=xJ(O`F@ZO5lgh2z2^Ej;a;r~Z){bt)o zNj+!}7AwPyTY~ZKHc=6k{>7E~E>T$OZkt6<6U0MXxO`%FbPUonEzBB-^lP`b{wjrv z?0DZu^q;6V9~O-3-2l&zk^8eCB_sc;iet}s#UO7*pZxUO8$7ORY>$veX=>wLW5f(n zfo*_y2Q(iiWB93@@3SYmb)*6)r^53lt^nI9Vzrqb%CpoaAT<={YdtIU2}ylSF#CvK z9WF*?lC%TNB<33Roy`IziEWV7n^*6IL~R!86m`{BqFvK{dk7ApQS7+&>uvH)rPUo} zx7t67qe@+wP}iV2VC&p1HYjBK&;3P3?P+&ywBj|MK*pV@#d>XY(O&U_GIyf}@(*&m z&Mt=baa{?aC?m`H?$Sqt`7&Y}meYkT$0**dZ>vQo(S+u-z1{BdBEV+=NheK8bNY!M zDNT~p6htT_{gy+ZHL_7B<<}ksT+Gs>ziAjcd0`fM=6H0;4cj|ozV#Z$+mMM@;<<;= zjzM8y0h7?vM$CwHLNd!PaaiipPt`SWKr0x%9@wYX1xD{N6S^kO(un5H788D$w`B8c zC_N8=KiaJ%_lw-L*^%B~v}15J_(o(Hm*5UaIf^(DxfZqrP>)FGgHJ1S_on;d1Kq=d zEI1NQ^b`_twhpmx*c@|~)VH$?W{^P?5FRKBp|0Q5<4+E=Z|Mm-6pXXbH1_VMPYfLu zHAQK+M}N0@uJ_>3j(jjQM?H269#@dwj9i-d$CZki3{!MX@A8Gx2akI1BFDTm3p7T4=7M8Hb*-$gpP^DL_uI`d~=ypoizHenw;cht>l|g!IvSo5kuzXa}N@#FW`X@ zwm?!3H_FtqG`~M#TQpKJ{pzk|U_B~)a<{$l;I=nZvZBr*Y!!+_mo;-C0`5~um~-BX z{j;&e>0mDLFC&a53>~Dj%s|&&i+u3EysoKS*xpxY&jLnV`111B%@YlMu*V#5#WPFlWQqt{ZuskS?-0KsqbEYsIv*zOU z-djfY>bRdjHGzOtQFca7x`dexyTS4;!bziMrRtXS7NAgT7)_&KH{*&Q+~*h`Wa8Yv z_43}tVX8ZidO+RHmu5Vr7lPAD2a;Z6>>NT-+S@Slv!i?J$E%1Pg|630M!I}V9p%&w z#Rc3y@R!{0macuGJedHm1oCm?6m*IJ`}u`f@fm-#of z@3uHrXh6NJxDyCIF`V5$1t0?=tCQxmZwJFmr_LToQ4OL5VichfPUc?IKD8ncW8MRr z`}ur9jY3AynO1R0qm{kIm=@3XqKB_z+=d6!p1ysB zT5%_~WZ8zP5gJMXq0HGZ8Y(r1Wt&^O=~$pPf*n zP^&zV=P%{lCsH*ld&d3C?+4o~!a2&iy_q%-h-RTi$y#|Z8WUetJ1$L=OqfSK3T;B6 zO$tNp78NYUTnFa-2u8Ptec>$;xo5af!q)O=bKj|w@|QQPtSo#pS?xj}b`<4z7wQ|e zD0BCpygL6R+rl#e-spPbEL<3tk}$i+YpAB6q)hjf#%!6dsS*e9t-82erf7}6*s_^W z)TQuaJCe&#R5bpvrqmeZ;+xllsN68kvtIVaCr>!pf{1ehxA!h(TBE73JL*kRiliC4 z8CBw0JcGq0i&W&Pj=Yd{O8P~@uOI7wqse0?zNZ2f>x&vCoGX})BR696{#|6Szb2GqpCf3IT_N8`$ze# zNZ!~F5B2ijjHtA%=)`q)@hh%4rXpZ)NO}?U!%R%L)veFK-6?^pb#txso@0yfH`07V52lM^G|;%ceS54UJ}qS6J6Ob z;&1iZxg1kr{>XIat&`ZVjwl_%6^*G|slO+?7r{ON+gG326-_TXLgTkyR6)w4|t zl$2|^#Jt?PPeE~cA5Ia-ZG1Q;ecq>$m$N%qBIdHp5lyu#W>BdhOF81(;n2&MXr%wk6OLDe+K=&|sm2FtOU#Qc0e7SP%{+3?c-{4?qA6BMO=N z4)r3}28QZbf9!vJc@=Fw>8|jJf5B-4cOsJgR_z{?p}TgXrUW{QVU%t^dd??Mbjk$~ zbr-(1Yx!XuiEJ_N!FA_;#h-e%g)ZM+qQ+{kb;`Dfd0L-@?rB$+9#cubzIS8v%FH~vFjJmYPsWwi)h^j-+TX>R(*_KV22ox=(T_yL#`|9fyOUrPiRWyw zt4wnw*d&!OrG;l${0lJ;Ug}jqU2SVvVFU|{z!i|0d2xx>>C^=6ZtncNjew6wGTrBL5 zU|sLLUhiuAJ4uA9x=7}#`=J3YZUs4$SsvOhXyy_#)mY81lua zd;IO=N2!YxupaB z7TYW2jwAlPpnZRTzux?S;@OIv^i$+0y+%oM%qb}e$%LWUDbdEz*uj(FwUd;-RNo%w z7+VlEXIwS;;Iq_CY%h^-KYHDwovsJSAj6Yb#4Ybj|5(V#q*i*&T9kU)NzHWs?e~nZ zoqIxVsO9n2qzp9__b>b>;aB$r(?A~=N`d^p4|~QRPmQ&7L&5)6-x^{{+9N~alG{<% zkLJO?;keyGhNlF2YRB*)kF5K~;XYR)qy5F4HmL8HzH1eE5p~4j<_-?w2_lh=76MJg z5-R+3AIv0;FH4JmV9L4cpoA4PCTbcAt|go&!&I{uePZ@KJS2_Eszz2D9Zp2)QB}Ql zbaZgiQ%f4Um>4JXDDs;*9Lrv%5sjvmL&B02o~0r;t5sf~f=?AVciUr?6ErZYs!eTW zFh9(8czgqGWWhn2+9J-Z!%%D5#svR1I~+6t4D)MmucxBmk z5$OI}Uf@d1#7_e|fjw2&W`qAh>3|FAuF{V>>k{?pUZ5N}g3P*rUcFPeKt`ZmY|vS~ zz)ej+H}lnW`5DR_n-%~<5rtj)W3q7O4%r%&gw=Bz@=+TO66Bsy0vRSq%|?Wf;n*0R z4Pk{AZqX}1lzl?Y95|6HKLu7|(-w8aUNMX}K5Fpxs=QbPhB?jU^0M!;FXiJA^+7K) zY#ZWAHhEeZ%x$L)j(?BWKm5d;vz-V#N;Vm45`flvY&SmXx_|sssiXh7FZm!Y*EgK5 zPRjH_W z{8}B2Ecqn&gf^N$vriEfG&D>4SMePoPpZ7tdb_*1*^R)uLz+iw3MMUUe}U=l3!Ew4 zUvAq_u0Qp>T{_Zu{pz`0bwuYnmVA2&u=AMSMP8+lY-3KHk&Id9;Z^w1fZqey4{Z#d z?0og6C*Cf+YX`DaOAilcgvS;mjKGtIU@6b}zXYdl)4>5E2vxcQ_f1GdXW4f0>+h!~ zD=reud{y-2ruqwq>y}yLOydG#2lsQ}(x3$aMXwI$rOQg)eupmTBuU2>V}hL(aTFou zoPSEldQR5u!dP;B(MtMnlOapDD!2kwx#-Nyz~pB{wxYkw`+nUm)KEePiWb03b7KD@ zs<99Mrikof@3@9X|84^EQ+>2EJlN*-xyM1o&He6EoRHVF`h-4(X_h3C&)NZlg#xyl zj(VsjhyW9=jIT%X0c@54W!pXI-Ra9!KgLU3Z*;gLo!&PQXh2kCcM}mw*M7XpwLSJ7 zv$kId$UB5HQEWJbTx)f{|YOuT<^VN6Vht#mhn`8?t=ek#2zEcW8O`SZ z%?fZ_4Bphf4=dCI4hSko^4VKMmn{O8Eptp7QvNZ@j*E5w`NQ@;?DLd8>B%F!6g! zl8ehjjvJ@M@46}=j%@eZ%!#;~_$8wm__eETD19x%$4lMP5tcynH|=JQ@G+-hCwdpo zWpgTMhOE`*3Z?7r93i1Y-@O$Or~+j>`Zb)`*c ztAKd;(9HO{_RtTm1`IHNc!3IPBk_Z(lh?HjK(d6AYtBOK)vht|CoTnO2Nd`vcXpnW z5bl-iRAAIe=&MdSJ0A-@cc`Pq!qU~p=fXRteVmEGoWA?b)Md`+?!QsHTS@bp!oF0F zk4*n776TltsQAUm+dN>0e(s z4?dXktkb_9WAQTcP{!=U{iGh(xe9tohRb$Wdgoyjaf57g%>$aK>ux{N0KomiUsq?4 za7|r{-|kPD&uM%Ue@)cfn4W~6K7{3SJr}tD)8i`(=V3~zvk<~fF#|qFyM6n82&l4e z&!cVR&c5MLC{(!AJXDd}oAN#gg-XcGCFS9;bML#Fe9L-nZ{>N|o|=a++n1S#LN+3< zkF0Z_E2C*I4JUFvpSf`Uv1{D(fRhK!1aI#I+;?(MsdKQ6EAy7sA8Vd8-4tqud0vvj(O;&MBK(7Ry6Ld|mo|Y{?+SD!lSg$o7UZb2i=xa|=w(Y=lV*C-RU(X2KRCtL+b7ia*L9a?;|RhdpFD5}(}$(-E?AS$S|7 z!z&NXJm8uK@3}TIsKK<3;o61fdi?-PP#DhC83C>o7b3tpBHeaAgb&=HZSyGX^2tq>*WGB-UBtnpDUW&Z7d2u=J3_u+`by z=!>t*F7gmeWn?I^qdKG*Ci9bWvk#_v^3<~O;4+3+9`-roB)mxfkjI`H+%;9Ds$$3kj?fzmp!g?X__<3+ptYd z%-%`P!$DZjtD4C@%wPn%Bee41xA#VFn70$R7dKv4RujfPQhF&C<$4U9mt+2r`i!Z( zYEn41k%g52w7Q{PJ&5aPZ;%~{8_)qikkLvX!&+it2J;&Hehr2;hC@KZ$Y^|B=K9!u z2&f(2t#;YUQE7KGP3q zm1PVRcwP8A>O35mCe_5lF<^XZQmJptu^9JbVBbIa299Z^lONF%j*c+tYby+r>`5#c z22UZbyoEea+!ElyJhA|m{9YRB?VDEi)&zXptaW*W48Bur{ER_2Uvu_DGB7$i2uCPL z(pm}H2{KSvLvlA>G!M=go_X*Ok$kVLF~~yLnn?ynNBiC9io8RH+YXSss^FdnlHJAc zkUW+F%h;q+YC4gJz0LYId}MYH47Kl&!4@Bn_gi^*)!4^QAIUz?3x7Lh8K0d{>dd!S z^wK-M6kdViSCO33q3xBetvI1h<2yz&5K7Sd2S44c2B zaXZQ59&?o+4pY~7$YZYZ<9lfcACAEBa8_MIA`i!+MuP%7?S8ylM$)%Y>$CEZRve5^ z)wRHdzpL&b;nMY4rMvqb?kRN(i}5@L;}hy~>I0SXGg%^4w4!TxTLV13k~y4}i+M64 z5&MgZa!#H?lJdH)lLeT^pPQSy9W4@x*nd)+|3N5%6-kWY?TyNp=8aaKn;Z3<%U{uz zQ-lTdbiUM8U4&$(ZzDMm!0TO^MQ~{8Rn=O`0M%75XQpddz?7OCN0RZ|Ki;~CrSU!n zQ)=Q|>f|@oLkJ=MdQKizZtU(~ux`h0%-iTybqhkQDHR)%ox~clN_oIp{qg^|;K^O*uFnT*NQ@UT4A^{^%rSUl4jwltv z9w5bgLwwC0000000000000000006+{hn6yfb08B=u z>IlG}qbj8jz^V?FIt}Y4@S}}7r7nGc`9}e#?X&l~d;#YvMK%uFSBwAv002ovPDHLk FV1ggFbiM!p literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-16.png b/public/images/zk-stack/Check_if_satisfied-16.png new file mode 100644 index 0000000000000000000000000000000000000000..3b52f8f791e092436c0a5232605203b4b7311247 GIT binary patch literal 22773 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�NqG(X0+H6p=GSLqDrl}8WjG|QP`|H* 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-3.png b/public/images/zk-stack/Check_if_satisfied-3.png new file mode 100644 index 0000000000000000000000000000000000000000..666694d60004a950b1be12df8721b0e93b8bcf47 GIT binary patch literal 70440 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

&UzuEh!f<#c%Pxqbpp`By&{iIq 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%0A(j3`5Q9^PvK~2CFa@DYpjHL3Dqm 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

5keE}NtJZ`IHdD{iQUaa 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 M&s!Q5opX--2MF`!O8@`> literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-7.png b/public/images/zk-stack/Check_if_satisfied-7.png new file mode 100644 index 0000000000000000000000000000000000000000..9e3d335f90558bf418229e0d02b3a6163f431f65 GIT binary patch literal 47238 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 p4;9HAgvjKm|2i}JZn~a; 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-8.png b/public/images/zk-stack/Check_if_satisfied-8.png new file mode 100644 index 0000000000000000000000000000000000000000..8c59e29a66f2648717003a0c6e79ab37bcb56f5d GIT binary patch literal 32661 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 E1Mh{eyZ`_I literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/Check_if_satisfied-9.png b/public/images/zk-stack/Check_if_satisfied-9.png new file mode 100644 index 0000000000000000000000000000000000000000..f1cbfbe9f7fcf6ba06ea713e4d5e3a1ca8695c6c GIT binary patch literal 23573 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%0DY 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/arithmetic_opcode.png b/public/images/zk-stack/arithmetic_opcode.png new file mode 100644 index 0000000000000000000000000000000000000000..5fc835dee15168ddbe4b0c83062aa471238d58b0 GIT binary patch literal 4786 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

U0k8_@8~XhsK^7&qahr-}S93 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 z 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�o%C3v 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 JQqdy(zW|SJaJ&Ej literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/circuit-compare-addresses.png b/public/images/zk-stack/circuit-compare-addresses.png new file mode 100644 index 0000000000000000000000000000000000000000..62cbadc590789e4845c7fea222434f9a8cbbb8e6 GIT binary patch literal 41020 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 PZB$iB^B<^!RoMRmKL?D{ literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/circuit-ecrecover-precompile.png b/public/images/zk-stack/circuit-ecrecover-precompile.png new file mode 100644 index 0000000000000000000000000000000000000000..4d548a9cb3d1a53908f4c2c91df2d9944bbe02ac GIT binary patch literal 20995 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 BvxEQu literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/circuit-ecrecover.png b/public/images/zk-stack/circuit-ecrecover.png new file mode 100644 index 0000000000000000000000000000000000000000..5daaf07f9dca45e30edc12bec8d1d30fd983c3bd GIT binary patch literal 24882 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¢sB{+sHckrmVYKnxrtnsYgU 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/circuit-lookup.png b/public/images/zk-stack/circuit-lookup.png new file mode 100644 index 0000000000000000000000000000000000000000..99aa7c1317fbf330dab3ffbeb3257103e28c7a93 GIT binary patch literal 58023 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

8O5;)fG-M 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 bOxrtT==y$FH%U>{-ASSHDspAA#_#_FM-D5= literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/circuit-pi-diagram.png b/public/images/zk-stack/circuit-pi-diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..9b0e7d15e77a054211cb504d97531d0a4d9c1b65 GIT binary patch literal 5340 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 literal 0 HcmV?d00001 diff --git a/public/images/zk-stack/contracts-external.png b/public/images/zk-stack/contracts-external.png new file mode 100644 index 0000000000000000000000000000000000000000..364d41fe486d76cc0b958492149099ac5dd39fa9 GIT binary patch literal 74938 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 ZqlBq4=HU{aww#4Xaa-REQl|Sb{6C?gGcEuC literal 0 HcmV?d00001