From 164109c46c627f4945da47f4be60278396b3a322 Mon Sep 17 00:00:00 2001 From: polibee <1244762327@qq.com> Date: Sun, 18 Feb 2024 20:55:01 +0800 Subject: [PATCH 1/4] initialize --- .idea/.gitignore | 5 +++++ .idea/kakarot-docs.iml | 12 ++++++++++++ .idea/modules.xml | 8 ++++++++ .idea/vcs.xml | 6 ++++++ README.md | 5 ++--- 5 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 .idea/.gitignore create mode 100644 .idea/kakarot-docs.iml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..b58b603 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,5 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/kakarot-docs.iml b/.idea/kakarot-docs.iml new file mode 100644 index 0000000..24643cc --- /dev/null +++ b/.idea/kakarot-docs.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..06a19c4 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/README.md b/README.md index 5a6c63e..9d97e83 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,6 @@ -# Website +# 网站 -This website is built using [Docusaurus](https://docusaurus.io/), a modern -static website generator. +该网站使用现代静态网站生成器[Docusaurus 3](https://docusaurus.io/)制作。 ### Installation From e615bb6c55307a1189afac40d94aa2e8d0caf95a Mon Sep 17 00:00:00 2001 From: polibee <1244762327@qq.com> Date: Sun, 18 Feb 2024 22:55:00 +0800 Subject: [PATCH 2/4] Translate to Chinese --- README.md | 22 +- docs/architecture/understanding-kakarot.md | 39 ++-- docs/architecture/understanding-zkevm.md | 236 +++++++-------------- docs/differences.md | 7 +- docs/quick-start.md | 76 ++----- docs/survival-guide.md | 36 ++-- 6 files changed, 142 insertions(+), 274 deletions(-) diff --git a/README.md b/README.md index 9d97e83..9841e1d 100644 --- a/README.md +++ b/README.md @@ -2,43 +2,41 @@ 该网站使用现代静态网站生成器[Docusaurus 3](https://docusaurus.io/)制作。 -### Installation +### 安装 ``` $ pnpm install ``` -### Local Development +### 本地开发 ``` $ pnpm run start ``` -This command starts a local development server and opens up a browser window. -Most changes are reflected live without having to restart the server. +该命令启动本地开发服务器并打开浏览器窗口。 +大多数更改都是实时反映的，而无需重新启动服务器。 -### Build +### 构建 ``` $ pnpm build ``` -This command generates static content into the `build` directory and can be -served using any static contents hosting service. +该命令生成静态内容到 `build`目录中，并且可以使用任何静态内容托管服务提供服务。 -### Deployment +### 开发 -Using SSH: +使用SSH: ``` $ USE_SSH=true pnpm deploy ``` -Not using SSH: +不使用SSH: ``` $ GIT_USER= pnpm deploy ``` -If you are using GitHub pages for hosting, this command is a convenient way to -build the website and push to the `gh-pages` branch. +如果您正在使用GitHub Pages进行托管，则此命令是一种方便的方法建立网站并推送到`gh-pages`分支。 \ No newline at end of file diff --git a/docs/architecture/understanding-kakarot.md b/docs/architecture/understanding-kakarot.md index 03a4866..ff8a50d 100644 --- a/docs/architecture/understanding-kakarot.md +++ b/docs/architecture/understanding-kakarot.md @@ -1,39 +1,28 @@ --- -title: Kakarot zkEVM under the hood +title: Kakarot zkEVM 在幕后运行 sidebar_position: 2 --- -## Kakarot, the zkEVM built in Cairo +## 在Cairo建造的zkEVM Kakarot -Kakarot is a zkEVM built in [Cairo](https://www.cairo-lang.org/), the provable -language that powers [Starknet](https://starkware.co/starknet/) and all the -StarknetOS chains (also called CairoVM chains, or Starknet appchains). Kakarot -is an Ethereum-compatible Layer 2, a -[so-called zkRollup](https://ethereum.org/developers/docs/scaling/zk-rollups). -Beyond compatibility, Kakarot strives to push more innovations to the L2 space, -and to add new features such as native account abstraction to the EVM. Kakarot's -driving ethos is to _Prove, Scale and Innovate_ 🥕. +Kakarot 是一个在 [Cairo](https://www.cairo-lang.org/) 中构建的 zkEVM，这是一个可证明的语言，为 [Starknet](https://starkware.co/starknet/) 和所有 StarknetOS 链（也称为 CairoVM 链或 Starknet 应用链）提供支持。Kakarot 是一个与以太坊兼容的 Layer 2，一个所谓的 [zkRollup](https://ethereum.org/developers/docs/scaling/zk-rollups)。除了兼容性外，Kakarot 还致力于向 L2 领域推动更多创新，并添加新功能，如原生账户抽象到 EVM。Kakarot 的主导理念是“证明、扩展和创新” 🥕。 -In concrete terms, Kakarot is an Ethereum-compatible zk-Rollup: -- Ethereum-compatible: use Kakarot and Ethereum in the same way. -- Zero-Knowledge (zk): no compromise on security, maximized integrity derived - from maths. -- Rollup: Enjoy lower costs than on Ethereum mainnet. +具体而言，Kakarot 是一个与以太坊兼容的 zk-Rollup： -For users: +- 与以太坊兼容：以与以太坊相同的方式使用 Kakarot 和以太坊。 +- 零知识（zk）：不妥协于安全性，通过数学实现最大化的数据完整性。 +- Rollup：享受比以太坊主网更低的成本。 -- For end users, use Kakarot in the same way as Ethereum mainnet: interact with - dApps using any EVM wallet, e.g. Metamask or Rabby. -- For developers and teams, you can build on Kakarot using the Ethereum - ecosystem's standard tools: Solidity or Vyper, Foundry, Hardhat, Etherjs etc. +对于用户： -Discover the Kakarot explorer and other useful links on the -[survival guide](../survival-guide) page. +- 对于终端用户，可以像使用以太坊主网一样使用 Kakarot：通过任何 EVM 钱包与 dApp 进行交互，例如 Metamask 或 Rabby。 +- 对于开发者和团队，您可以使用以太坊生态系统的标准工具构建 Kakarot：Solidity 或 Vyper、Foundry、Hardhat、Ether.js 等。 + +在 [survival guide](../survival-guide) 页面上发现 Kakarot 浏览器和其他有用的链接。 + +注意：Kakarot 不是一个隐私链。零知识技术可以用于两种（非排斥）目的，即扩展或隐私。Kakarot 使用前者来扩展以太坊。 -Note: Kakarot is not a privacy chain. Zero-knowledge technologies can be used -for two (non-excluding) purposes, Scaling or Privacy. Kakarot uses the former to -scale Ethereum. ## How does Kakarot work under the hood? diff --git a/docs/architecture/understanding-zkevm.md b/docs/architecture/understanding-zkevm.md index 12f904d..d35e4d8 100644 --- a/docs/architecture/understanding-zkevm.md +++ b/docs/architecture/understanding-zkevm.md @@ -1,180 +1,100 @@ --- -title: The concept of zkEVM +title: zkEVM的概念 sidebar_position: 1 --- -To grasp the concept of zkEVM, let's start by understanding what the Ethereum -Virtual Machine (EVM) is. +为了掌握zkEVM的概念，让我们首先了解什么是以太坊虚拟机(EVM)。 -## The Ethereum Virtual Machine (EVM) +## 以太坊虚拟机(EVM) -### EVM Overview +### EVM 概述 -Starting from the -[Ethereum Foundation definition](https://ethereum.org/developers/docs/evm#from-ledger-to-state-machine): +从[以太坊基金会的定义](https://ethereum.org/developers/docs/evm#from-ledger-to-state-machine)开始: -> Ethereum's state is a large data structure which holds not only all accounts -> and balances, but a machine state, which can change from block to block -> according to a pre-defined set of rules, and which can execute arbitrary -> machine code. The specific rules of changing state from block to block are -> defined by the EVM. +> 以太坊的状态是一个大型数据结构，它不仅保存了所有账户 +> 而平衡，只是一种机器状态，它可以从一个区块改变到另一个区块 +> 根据一组预定义的规则，可以任意执行 +> 机器代码。从块到块改变状态的具体规则是 +> 由EVM定义。 -From the above we get that the Ethereum blockchain is a distributed state -machine and that the -[Ethereum Virtual Machine](https://ethereum.org/developers/docs/evm) is a -software-based emulation of a physical computer (virtual machine) used to -operate (compute state transitions) this blockchain. +从上文我们可以看出，以太坊区块链是一个分布式状态机，而[以太坊虚拟机](https://ethereum.org/developers/docs/evm) 是对物理计算机（虚拟机）的基于软件的仿真，用于操作（计算状态转换）该区块链。 -Note that the EVM is a deterministic execution environment. +需要注意的是，EVM 是一个确定性的执行环境。 -- Deterministic meaning that a smart contract will produce the same output given - the same input, regardless of which node in the network executes it. This is - essential for maintaining consensus across the network. -- An execution environment i.e. where smart contracts are executed. Note that - each Ethereum node runs an EVM instance, allowing it to participate in - executing and validating smart contracts and transactions. - - For instance, Ethereum Validators run both a consensus client and an - execution client. This execution client is powered by an EVM implementation. - That way, validators _validate_ transactions by re-running them locally - before voting to ensure their correctness ✅! +- 确定性是指，无论网络中的哪个节点执行智能合约，只要输入相同，就会产生相同的输出。这对于维持整个网络的共识至关重要。 +- 执行环境，即执行智能合约的地方。请注意，每个以太坊节点都运行一个 EVM 实例，允许它参与执行和验证智能合约和交易。 + - 例如，以太坊验证器同时运行一个共识客户端和一个执行客户端。执行客户端由 EVM 实现提供支持。 + 这样，验证器就可以在本地重新运行交易，从而验证交易，以确保其正确性✅！ -TL;DR - the EVM is the common virtual computer used to run logic on the Ethereum -network. +TL;DR - EVM 是用于在以太坊网络上运行逻辑的通用虚拟计算机。 -### Architecture of the EVM +### EVM 的架构 --- -Diagram - The EVM Illustrated by Takenobu: +示意图 - Takenobu 绘制的 EVM 图： ![The EVM illustrated by Takenobu](../../static/diagrams/evm_takenobu.png) -Source: The EVM illustrated, +资料来源:EVM插图， https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf --- -Let's use the image above from Takenobu to describe the machine architecture of -the EVM. - -1. Virtual ROM: This contains the EVM code. Once smart contracts are deployed, - their code cannot be changed (proxy pattern notwithstanding 🧑‍🔬). Smart - contract code is said to be _immutable_ on Ethereum. - -2. Program counter (PC): This keeps track of the position in the code that the - EVM is currently executing. - -3. Gas available (Gas): Each operation in the EVM requires a certain amount of - "gas," which is a unit that measures the computational effort required. The - gas available field tracks how much gas is left for the transaction to - continue operating. - -4. Machine state (µ): This is the volatile state of the machine which includes - the program counter, memory, stack, and more. It is volatile because it is - reset between transactions. It is not shared between intra-transaction calls - (e.g. if there are 3 different contracts calls within one transaction), - though this will change with - [transient storage](https://eips.ethereum.org/EIPS/eip-1153). - -5. Stack: The EVM is a stack-based machine, which means that it uses a data - structure called a stack to store data. Operations in EVM code manipulate the - stack in various ways. - -6. Memory: This is a temporary place to store data during execution. It is - volatile because it is reset between transactions or intra-transaction calls. - -7. (Account) Storage: This is a long-term storage that each account in Ethereum - has. Unlike memory, storage is persistent and remains between transactions - and even between sessions. This includes both Account Contracts (smart - contracts) and Externally Owned Accounts or EOAs (user accounts, like the - account in your Metamask wallet!). - -8. World State (σ): This is the persistent state of the entire Ethereum system - which includes all accounts (no. 7) and their balances, storage, code, etc. - -It's called a "stack-based" architecture because the primary mode of computation -is through a data stack, which is a last-in, first-out (LIFO) structure. - -Kakarot is a zkEVM built in Cairo. Essentially, this means we've written number -1 to 8 in Cairo (by relying on existing StarknetOS clients as well). The -[Geth](https://geth.ethereum.org/) team has done it in Golang. The -[Reth](https://github.com/paradigmxyz/reth) team has done it in Rust. It just so -happens that Cairo is provable by design, and the EVM needs to be proven for -Ethereum to scale! How convenient 🥕. - -## The concept of zk-Rollup - -The zk in zk-Rollup and zkEVM means _zero-knowledge_. It refers to the -cryptographic method by which one party (the prover) can prove to another party -(the verifier) that a statement is true. In the case of an Kakarot zkEVM, the -prover (the rollup) proves to the verifier (Ethereum L1) that a batch of L2 -transactions are valid. Zk-Rollups help Ethereum mainnet scale through this -concept of batches: submit less transactions to Ethereum L1, have Ethereum L1 -compute less logic, lower the costs. - -The integrity of these so-called batches is mathematically guaranteed by -zero-knowledge proofs (also called validity proofs when they are not privacy -preserving). - -To dive deeper, you can refer to a -[high-level article about zero-knowledge proofs](https://medium.com/starkware/stark-math-the-journey-begins-51bd2b063c71), -written by the inventors of STARK proofs: Starkware. - -To grasp the value of zk-Rollups, it is important to understand that when a -transaction is executed on Ethereum, all the full nodes in the network run it -locally to verify its integrity. Therefore, each transaction is executed -hundreds of thousands of times in order to guarantee the network's state. The -idea behind zk-Rollups is to run a transaction once, compute that transaction's -proof of integrity and thereafter only verify this proof without re-running the -initial transaction. Luckily for us (and the Rollup centric roadmap of -Ethereum), the verification of a transaction's proof is way cheaper than -re-running that same transaction (it is asymptotically exponentially cheaper). - -From there is derived the protocols of zk-Rollups. As per the -[Ethereum website](https://ethereum.org/developers/docs/scaling/zk-rollups#what-are-zk-rollups): - -> Zero-knowledge rollups (ZK-rollups) bundle (or 'roll up') transactions into -> batches that are executed off-chain. Off-chain computation reduces the amount -> of data that has to be posted to the blockchain. ZK-rollup operators submit a -> summary of the changes required to represent all the transactions in a batch -> rather than sending each transaction individually. They also produce validity -> proofs to prove the correctness of their changes. - -TL;DR - execute off-chain, verify on-chain, save on costs. - -## What does it mean to prove the EVM: the transition from EVM to zkEVM? - -A zkEVM is simply a zk-Rollup that is compatible with Ethereum. This means that -users should be able to interact with it as if they were interacting with -Ethereum (or almost). For instance, users will use the same tools on a zkEVM -than on Ethereum L1, such as the same wallet (e.g. Metamask). Developers' smart -contracts should be deployable to a zkEVM without any (or little) changes. - -This is powerful in the sense that the cryptography part is abstracted away. -Users continue to interact with a high-level abstraction they're familiar with: -the EVM. In that sense, the iterative "build on existing work" aspect of -innovation is preserved in the Ethereum ecosystem. - -Other actors in the zk-Rollup ecosystem have decided to start over and break -compatibility with the EVM. This includes for instance -[Starknet](https://www.starknet.io/en), also powered by the CairoVM. Users and -developers on Starknet need to get used to using new tools and technologies, but -do not have to suffer from EVM legacy. Kakarot places a somewhat different bet: -the EVM will remain the dominant common abstraction layer in crypto and Cairo -will be the strongest zkVM. Therefore, it makes sense to both: - -- build an EVM in 2024, -- bet on the Cairo powerhouse for the years to come. - -Kakarot users stand to benefit both from the Ethereum network effect and the -innovations built on the most disruptive zk-toolbox: the CairoVM stack. - -Note that a zkEVM also designates the software used to prove Ethereum-compatible -transactions and blocks. It refers to code that is used to go from an EVM -transaction to a zero-knowledge (or validity) proof. The implementation of a -zkEVM can be either low-level (at the so-called "circuits" level) or high-level -(use an intermediary zkVM). [Scroll](https://scroll.io/) is an embodiment of the -former, and Kakarot of the latter. - -TL;DR: Execute Ethereum-compatible transactions on a Layer 2, prove them -off-chain, bundle and verify them on Ethereum L1. Save on costs, benefit from an -existing ecosystem: the Ethereum community. +让我们用 Takenobu 提供的上图来描述一下 EVM 的机器结构。 + +1. 虚拟 ROM：包含 EVM 代码。一旦部署了智能合约、 其代码不可更改（尽管有代理模式 🧑‍🔬）。智能 合约代码在以太坊上被称为_不可变_。 + +2. 程序计数器 (PC)： 它记录 EVM 当前执行代码的位置。 + +3. 可用燃料（Gas）： EVM 中的每个操作都需要一定量的 "燃料"。"燃料"，它是衡量所需计算能力的单位。可用燃料可用气体字段跟踪交易还剩多少燃料才能继续运行。 + +4. 机器状态（µ）：这是机器的易失性状态，包括程序计数器、内存、栈等。它是易失性的，因为在交易之间会被重置。它不在交易内调用之间共享（例如，在一个交易中有 3 个不同的合约调用），尽管这将随着[瞬态存储](https://eips.ethereum.org/EIPS/eip-1153)的引入而改变。 + +5. 栈：EVM 是一种基于栈的机器，这意味着它使用一种称为栈的数据结构来存储数据。EVM 代码中的操作以各种方式操作栈。 + +6. 内存： 这是执行过程中存储数据的临时位置。它是易失性的，因为它会在事务或事务内部调用之间重置。 + +7. (账户）存储： 这是以太坊每个账户都有的长期存储。拥有的长期存储。与内存不同，存储是持久的，在不同的交易 甚至会话之间。这包括账户合约（智能 合约）和外部拥有的账户或 EOA（用户账户，如 您 Metamask 钱包中的账户！）。 + +8. 世界状态 (σ)： 这是整个以太坊系统的持久状态 包括所有账户（no.7）及其余额、存储、代码等。 + +之所以称为 "基于堆栈 "的架构，是因为其主要计算模式是通过数据堆栈进行的，而数据堆栈是一种后进先出（LIFO）结构。 + +Kakarot 是使用 Cairo 构建的 zkEVM。从本质上讲，这意味着我们已经使用 Cairo 将数字 1 到 8 写入了代码（同时依赖现有的 StarknetOS 客户端）。[Geth](https://geth.ethereum.org/) 团队用 Golang 完成了这项任务。[Reth](https://github.com/paradigmxyz/reth) 团队则用 Rust 完成了。恰好，Cairo 是经过设计验证的，而要使以太坊能够扩展，EVM 需要被证明！ + +## zk-Rollup 的概念 + +zk-Rollup 和 zkEVM 中的 zk 意味着“零知识”。它指的是一种密码学方法，通过这种方法，一方（证明者）可以向另一方（验证者）证明一个陈述是真实的。在 Kakarot zkEVM 的情况下，证明者（Rollup）向验证者（以太坊 L1）证明一批 L2 交易是有效的。zk-Rollup 通过批处理的概念帮助以太坊主网扩展：向以太坊 L1 提交更少的交易，让以太坊 L1 计算更少的逻辑，从而降低成本。 + +这些所谓批次的完整性在数学上是由零知识证明保证的(当它们不保护隐私时也称为有效性证明)。 + +要深入了解，您可以参考[关于零知识证明的高级文章](https://medium.com/starkware/stark-math-the-journey-begins-51bd2b063c71)， 由STARK证明的发明者Starkware写的。 +要理解 zk-Rollups 的价值，重要的是要理解当在以太坊上执行交易时，网络中的所有完整节点都会在本地运行以验证其完整性。因此，为了保证网络的状态，每个交易都会被执行数十万次。zk-Rollups 的理念是只运行一次交易，计算该交易的完整性证明，然后仅验证该证明，而无需重新运行初始交易。幸运的是（对于我们和以太坊的 Rollup 中心化路线图而言），验证交易证明的成本远远低于重新运行相同交易的成本（渐近地呈指数级下降）。 + +由此产生了 zk-Rollups 协议。根据[以太坊网站](https://ethereum.org/developers/docs/scaling/zk-rollups#what-are-zk-rollups)： + +> 零知识rollups（ZK-rollups）将交易捆绑（或 'roll up'）为 +> 在链外执行的批次。链外计算减少了 +> 必须发布到区块链上的数据。ZK-rollup 操作员提交 +> 表示批处理中所有事务所需更改的摘要 +> 而不是单独发送每个交易。它们也产生有效性 +> 证明其更改正确性的证明。 + +TL;DR - 链下执行，链上验证，节省成本。 + +## 证明 EVM：从 EVM 到 zkEVM 的过渡意味着什么？ + +一个 zkEVM 简单来说就是与以太坊兼容的 zk-Rollup。这意味着用户应该能够与之交互，就像他们在与以太坊交互一样（或几乎一样）。例如，用户在 zkEVM 上将使用与以太坊 L1 上相同的工具，例如相同的钱包（如 Metamask）。开发者的智能合约应该能够在 zkEVM 上部署，而无需进行任何（或很少的）更改。 + +从加密学角度来看，这是非常强大的，因为加密部分被抽象化了。用户继续与他们熟悉的高级抽象层进行交互：即 EVM。在这个意义上，以太坊生态系统中创新的迭代式“基于现有工作”的方面得以保留。 + +在 zk-Rollup 生态系统中，其他参与者决定重新开始并与 EVM 断开兼容性。其中包括例如由 CairoVM 提供支持的 [Starknet](https://www.starknet.io/en)。Starknet 上的用户和开发者需要习惯使用新的工具和技术，但不必受到 EVM 遗留问题的困扰。Kakarot 则做出了略有不同的选择：EVM 将继续成为加密领域的主要公共抽象层，而 Cairo 将成为最强大的 zkVM。因此，同时进行以下操作是有意义的： + +- 2024年构建EVM， +- 在未来的岁月里，把赌注押在开罗这座强国身上。 + +Kakarot用户将同时受益于以太坊网络效应和的创新。 + +请注意，zkEVM 还指代用于证明与以太坊兼容的交易和区块的软件。它指的是用于从 EVM 交易转换为零知识（或有效性）证明的代码。zkEVM 的实现可以是低级的（在所谓的“circuits”级别）或高级的（使用中间 zkVM）。[Scroll](https://scroll.io/) 是前者的体现，而 Kakarot 是后者的体现。 + +TL;DR: 在 Layer 2 上执行与以太坊兼容的交易，进行链下证明，将其捆绑并在以太坊 L1 上验证。节省成本，获得现有生态系统的好处：以太坊社区。 diff --git a/docs/differences.md b/docs/differences.md index cedaa3d..b7f1dec 100644 --- a/docs/differences.md +++ b/docs/differences.md @@ -2,12 +2,9 @@ sidebar_position: 3 --- -# Differences between Kakarot and Ethereum +# Kakarot 与以太坊的区别 -Although Kakarot is Ethereum-compatible and aims to support the latest features -of Ethereum (e.g. -[Cancun new opcodes](https://blog.ethereum.org/2024/01/10/goerli-dencun-announcement)), -it still has some edge case behaviors. They are listed below: +尽管Kakarot兼容以太坊，并旨在支持以太坊的最新功能（例如[Cancun 新操作码](https://blog.ethereum.org/2024/01/10/goerli-dencun-announcement)），但它仍然具有一些特殊情况的行为。它们列举如下： | Item | Ethereum | Kakarot | | ---------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | diff --git a/docs/quick-start.md b/docs/quick-start.md index cfc4564..0a37918 100644 --- a/docs/quick-start.md +++ b/docs/quick-start.md @@ -1,45 +1,24 @@ --- -title: Quick start - 5 minutes overview +title: 快速开始- 5分钟概述 sidebar_position: 1 --- -## What is Kakarot zkEVM? +## Kakarot zkEVM是什么? -Kakarot is a zkEVM built in [Cairo](https://www.cairo-lang.org/), the provable -language that powers [Starknet](https://starkware.co/starknet/) and all the -StarknetOS chains (also called CairoVM chains, or Starknet appchains). Kakarot -is an Ethereum-compatible Layer 2, a -[so-called zkRollup](https://ethereum.org/developers/docs/scaling/zk-rollups). -Beyond compatibility, Kakarot strives to push more innovations to the L2 space, -and to add new features such as native account abstraction to the EVM. Kakarot's -driving ethos is to _Prove, Scale and Innovate_ 🥕. +Kakarot是用一种可证明的语言[Cairo](https://www.cairo-lang.org/)构建的zkEVM，为[Starknet](https://starkware.co/starknet/)和所有StarknetOS链（也称为CairoVM链或Starknet应用链）提供支持。Kakarot是与以太坊兼容的第2层，即[叫做zkRollup](https://ethereum.org/developers/docs/scaling/zk-rollups)。 +除了兼容性之外，Kakarot还努力推动L2领域的更多创新，并为 EVM 添加新功能，如原生账户抽象。Kakarot的驱动精神是**证明、扩大和创新**🥕。 -## How can I use Kakarot zkEVM? +## 如何使用Kakarot zkEVM? -Kakarot zkEVM is an Ethereum-compatible rollup, which means as a user and -developer, you can interact with Kakarot zkEVM in the same way you would -interact with Ethereum mainnet or any other Ethereum-based chain (use Metamask, -Rainbow, build with Foundry or Hardhat, etc.). **Change the RPC URL and it "just -works"**. That being said, Kakarot is still in alpha testnet phase 🚧 and -unexpected behavior may still occur. Reach out to us on -[discord](https://discord.gg/kakarotzkevm) to report bugs 🐛. +Kakarot zkEVM是一个以太坊兼容的rollup，这意味着作为用户和开发人员，您可以与Kakarot zkEVM进行交互，就像您与以太坊主网或任何其他基于以太坊的链进行交互一样(使用Metamask,Rainbow，用Foundry或Hardhat等构建)。**更改RPC URL，它就能“正常工作”了**。话虽如此，Kakarot仍然处于alpha testnet阶段🚧，仍然可能发生意外错误。通过[discord](https://discord.gg/kakarotzkevm)联系我们，报告错误🐛。 -Though we aim at no difference at all between Ethereum and Kakarot zkEVM — and -we actually work toward passing 100% of the -[official Ethereum Foundation test](https://github.com/ethereum/tests) — they -are currently some small difference recorded in the -[differences between Kakarot and Ethereum](differences) page in this -documentation website. +虽然我们的目标是在以太坊和Kakarot zkEVM之间实现零差异，而且我们实际上正在努力通过[官方以太坊基金会的100%测试](https://github.com/ethereum/tests)—— 但目前在这个文档网站的[Kakarot 与以太坊之间的差异](differences)页面中记录了一些小的差异。 -### As a user, how can I interact with Kakarot zkEVM? +### 作为用户，我如何与Kakarot zkEVM进行交互? -Head over to the [survival guide](survival-guide) section to find useful links -for our alpha testnet. Again, change the network to Kakarot in your wallet and -it should "just work". +前往[生存指南](survival-guide) 部分，查找alpha testnet的有用链接。同样，将钱包中的网络更改为Kakarot，它就会"正常工作"。 -Example tutorial - Adding a new network to Metamask: open the Metamask -extension. Click "Add Network". Choose "Add a Network Manually". Then fill the -fields: +示例教程 - 向Metamask添加新网络：打开Metamask扩展。点击"添加网络"。选择"手动添加网络"。然后填写字段： | Category | Value | | -------------- | ------------------------------- | @@ -49,36 +28,23 @@ fields: | Symbol | ETH | | Block Explorer | https://sepolia.kakarotscan.org | -🚧 Warning 🚧: Links are not up yet. +🚧警告🚧:链接尚未建立。 -### As a developer, how can I build on Kakarot zkEVM? +### 作为一名开发人员，我如何在Kakarot zkEVM上进行构建? -For developers as well, change the RPC URL, and it should "just work". +对于开发人员来说，更改RPC URL，它应该可以“正常工作”。 -In case you encounter some unknown bug or want to discuss new features, you can: +如果您遇到一些未知的错误或想要讨论新功能，您可以: -- Join our discord and get support: https://discord.gg/kakarotzkevm -- Ask us anything on Twitter: https://twitter.com/KakarotZkEvm +- 加入我们的discord并获得支持: https://discord.gg/kakarotzkevm +- 在推特上咨询: https://twitter.com/KakarotZkEvm -## What differentiates Kakarot zkEVM? +## Kakarot zkEVM有什么不同? -Kakarot is the only provable implementation of the EVM written in a Turing -complete zero-knowledge Domain Specific Language (zkDSL): Cairo. +Kakarot是使用图灵完备的零知识领域特定语言（zkDSL）Cairo编写的唯一可证明的EVM实现。 -In this sense, Kakarot is closer to an EVM client than other zkEVMs. This makes -our approach flexible. Lower-level approaches that rely on cryptographic -primitives (e.g. circuits) are tailor-made for a specific EVM version. They are -way harder to maintain and adapt. For instance, because our approach is -adaptable & sustainable, we can support all Ethereum hardforks from day 1 and -thus minimize EVM fragmentation. +在这方面，Kakarot更接近于一个EVM客户端，而不同于其他zkEVM。这使得我们的方法更加灵活。依赖于加密原语（例如circuits）的底层方法是为特定的EVM版本量身定制的。它们更难以维护和适应。例如，由于我们的方法是可适应和可持续的，我们可以从第一天开始支持所有以太坊的硬分叉，从而最大程度地减少了EVM的碎片化。 -In the upcoming years, as Ethereum undergoes more upgrades, a zkEVM needs to be -easily adaptable to be sustainable. That is, it needs to easily incorporate the -changes of Ethereum mainnet. Otherwise, the very point of zkEVMs would be -partially lost: use zk to improve Ethereum, but in the meantime block every -other future evolution of the protocol and stick to a given version. Developers -would have to be careful about their Solidity or Vyper compiler versions. Users -would need to consult a difference checklist. +在未来几年，随着以太坊进行更多的升级，zkEVM需要易于适应以保持可持续性。换句话说，它需要轻松地融合以太坊主网的变化。否则，zkEVM的根本目的将部分丧失：利用zk来改进以太坊，但同时阻止协议的任何其他未来演进，并坚持某个给定的版本。开发人员将不得不注意其Solidity或Vyper编译器的版本。用户需要查阅差异检查表。 -For a deep-dive into the Kakarot design, check out -[the architecture overview](architecture/understanding-zkevm). +要深入了解Kakarot设计，请查看[架构概述](architecture/understanding-zkevm)。 diff --git a/docs/survival-guide.md b/docs/survival-guide.md index 8b7d1ea..d022658 100644 --- a/docs/survival-guide.md +++ b/docs/survival-guide.md @@ -2,20 +2,18 @@ sidebar_position: 2 --- -# Kakarot Testnet Survival Guide +# Kakarot 测试网生存指南 -## Useful links +## 有用的链接 -🚧 Warning 🚧: RPC and Block Explorer links are not up yet. +警告 🚧： RPC 和 Block Explorer 链接尚未建立。 -- 🚧 Not Up Yet 🚧 | Registration Page (for invite-only phase of the Kakarot +- 🚧 尚未发布 🚧 | 注册页面（用于卡卡罗特邀请阶段） Alpha Testnet): https://sepolia-signup.kakarot.org - - You'll need a whitelist invite to be able to send transactions to the - Kakarot Alpha Testnet 📩. -- 🚧 Not Up Yet 🚧 | Faucet: https://sepolia-faucet.kakarot.org - - Head out to the faucet once a day to grab some testnet ETH 🚰💧! -- 🚧 Not Up Yet 🚧 | Block Explorer: https://sepolia.kakarotscan.org -- 🚧 Not Up Yet 🚧 | Public RPC: https://sepolia-rpc.kakarot.org + - 您需要白名单邀请才能将交易发送到 Kakarot Alpha 测试网📩。 +- 🚧每天前往龙头处获取一些 testnet ETH🚰💧！ +- 🚧 尚未发布 🚧 | Block Explorer: https://sepolia.kakarotscan.org +- 🚧 尚未发布 🚧 | Public RPC: https://sepolia-rpc.kakarot.org - Discord: https://discord.gg/kakarotzkevm - Twitter: https://twitter.com/kakarotzkevm - Official Website: https://kakarot.org @@ -23,21 +21,21 @@ sidebar_position: 2 - RPC Layer: - RPC Server: https://github.com/kkrt-labs/kakarot-rpc - - Indexer (to store EVM data structures): + - 索引器（用于存储 EVM 数据结构）： https://github.com/kkrt-labs/kakarot-indexer - - Core EVM written in Cairo (two different implementations): + - 用Cairo语言编写的核心 EVM（两种不同的实现方法）： - Cairo Zero Core EVM: https://github.com/kkrt-labs/kakarot - Cairo Core EVM: https://github.com/kkrt-labs/kakarot-ssj - - Official Ethereum Foundation test suite implementation: + - 以太坊基金会官方测试套件实现： - ef-tests: https://github.com/kkrt-labs/ef-tests - Documentation repository: https://github.com/kkrt-labs/kakarot-docs - [Kakarot zkEVM YouTube playlist](https://www.youtube.com/watch?v=5BndqgugKOU&list=PLF3T1714MyKDwjjA8oHizXAdLNx62ka5U) -## Contract address book +## 合约地址簿 -- AMMs: 🚧 Coming Soon 🚧 -- USDc: 🚧 Coming Soon 🚧 -- USDt: 🚧 Coming Soon 🚧 -- WBTC: 🚧 Coming Soon 🚧 -- Oracles: 🚧 Coming Soon 🚧 +- AMMs: 🚧 即将到来 🚧 +- USDc: 🚧 即将到来 🚧 +- USDt: 🚧 即将到来 🚧 +- WBTC: 🚧 即将到来 🚧 +- Oracles: 🚧 即将到来 🚧 From 12e91b8e0686e0bb3e66aea2f9d29f009f0796a9 Mon Sep 17 00:00:00 2001 From: polibee <1244762327@qq.com> Date: Mon, 19 Feb 2024 09:20:20 +0800 Subject: [PATCH 3/4] Translate to Chinese --- docs/architecture/_category_.json | 4 +- docs/architecture/understanding-kakarot.md | 132 ++++++--------------- 2 files changed, 39 insertions(+), 97 deletions(-) diff --git a/docs/architecture/_category_.json b/docs/architecture/_category_.json index 962e658..1ce3522 100644 --- a/docs/architecture/_category_.json +++ b/docs/architecture/_category_.json @@ -1,8 +1,8 @@ { - "label": "Architecture Deep Dive", + "label": "架构深入探讨", "position": 4, "link": { "type": "generated-index", - "description": "Deep Dive into all the concepts associated with Kakarot zkEVM: from what is a zkEVM to how it works under the hood" + "description": "深入探讨与Kakarot zkEVM相关的所有概念：从什么是zkEVM到它在幕后是如何工作的。" } } diff --git a/docs/architecture/understanding-kakarot.md b/docs/architecture/understanding-kakarot.md index ff8a50d..e314af5 100644 --- a/docs/architecture/understanding-kakarot.md +++ b/docs/architecture/understanding-kakarot.md @@ -24,128 +24,70 @@ Kakarot 是一个在 [Cairo](https://www.cairo-lang.org/) 中构建的 zkEVM， 注意：Kakarot 不是一个隐私链。零知识技术可以用于两种（非排斥）目的，即扩展或隐私。Kakarot 使用前者来扩展以太坊。 -## How does Kakarot work under the hood? +## Kakarot 在底层是如何工作的？ -### Kakarot is an implementation of the EVM in Cairo +### Kakarot 是在 Cairo 中实现的 EVM -Under the hood, Kakarot zkEVM is a Cairo program that implement the EVM -instruction set. The EVM is the blueprint, Kakarot implements it in Cairo. +在底层，Kakarot zkEVM 是一个实现了 EVM 指令集的 Cairo 程序。EVM 是蓝图，Kakarot 在 Cairo 中实现了它。 -> Cairo is the first Turing-complete language for creating provable programs for -> general computation. +> Cairo 是第一个用于创建可证明通用计算程序的图灵完备语言。 +> 通用计算。 -Cairo is like any a programming language, but made for writing provable -software. It means that whatever is written in Cairo is, by design, _zk_. Using -Cairo means that we leverage cryptography without having to think about it, it -sort of "comes for free" just by using this language and not, say, rust. +Cairo 跟其他任何编程语言都一样，但是专门用于编写可证明的软件。这意味着无论在 Cairo 中写什么，从设计上都是零知识的。使用 Cairo 意味着我们利用了密码学，而无需考虑它，使用这种语言而不是 Rust 等语言，这样的功能“免费”提供了。 --- -Diagram - Kakarot zkEVM high-level architecture: +图表 - Kakarot zkEVM 的高级架构： ![Kakarot zkEVM architecture diagram](../../static/diagrams/kakarot_zkevm.png) --- -Kakarot - the network - is composed of three parts: the Core EVM in Cairo, an -RPC layer (RPC server and EVM indexer) and an underlying CairoVM client (a -StarknetOS chain). +Kakarot - 网络 - 由三个部分组成：Cairo 中的核心 EVM、一个 RPC 层（RPC 服务器和 EVM 索引器）和一个底层 CairoVM 客户端（一个 StarknetOS 链）。 -### Kakarot runs on an underlying StarknetOS client +### Kakarot 运行在底层的 StarknetOS 客户端上 + +Kakarot 核心 EVM，即前面提到的我们的新 EVM 实现，部署在一个底层的 StarknetOS 链上。这意味着 Kakarot 作为一组 Cairo 智能合约在 CairoVM 驱动的链上运行。这个 CairoVM 链对用户来说是“不可见”的。用户只能通过以太坊兼容的方式通过 RPC 层与 Kakarot 进行交互。在 Kakarot zkEVM 中唯一暴露的接口是以太坊 JSON-RPC 规范。在未来，我们可以利用这一点，允许开发者编写自己的 Cairo 预编译合约，就像 [Arbitrum Stylus](https://arbitrum.io/stylus) 引入了 Rust、C 和 C++ 一样。 -The Kakarot core EVM, i.e. as said previously our new EVM implementation, is -deployed on an underlying StarknetOS chain. This means that Kakarot is running -as a set of Cairo smart contracts on a CairoVM-powered chain. This CairoVM chain -is "invisible" to the user. Users only interact with Kakarot through the RPC -layer in an Ethereum-compatible way. The only exposed interface in Kakarot zkEVM -is the Ethereum JSON-RPC specification. In the future, we could leverage this to -allow developers to write their own Cairo-precompiled contracts, as -[Arbitrum Stylus](https://arbitrum.io/stylus) introduced Rust, C, and C++ -together with the EVM. --- -Diagram - Kakarot RPC Layer +图表 - Kakarot RPC 层 ![Kakarot RPC Layer](../../static/diagrams/kakarot_rpc.png) --- +Kakarot L2由用Cairo编写的EVM和一个RPC层组成，以允许用户以以太坊格式与之交互。所有Cairo执行跟踪都是可证明的，这使得Kakarot能够批处理区块并使用[Starkware Shared prover](https://starkware.co/tech-stack/)(SHARP)提交证明到L1。由于Cairo是一个充满活力的生态系统，未来将出现其他证明器实现，比如[Stark Platinum Prover](https://github.com/lambdaclass/lambdaworks/tree/main/provers)。这将实现多重证明安全，并增加Kakarot网络的健壮性。 + +在Kakarot zkEVM中，关于EVM程序及其Cairo等价物的设计选择如下所述。它们可能随着时间的推移而发生架构变化。免责声明：所有这些设计选择对用户都是不可见的： + +- 每个EVM智能合约（称为Contract Account）都部署为一个唯一的Starknet智能合约。这个Starknet智能合约存储着自己的字节码和EVM存储槽。 +- 每个EVM用户拥有的账户（称为Externally Owned Account (EOA)）都部署为一个Starknet智能合约钱包。 + - 它具有一个Starknet格式的地址（31字节的十六进制字符串），该地址与用户EOA EVM地址（20字节的十六进制字符串）唯一映射。对于用户来说，这是不可见的。 + - 它的ETH（代币与通证）原生余额在Kakarot系统中是以ERC20原生通证的形式计价的。对于用户来说，这是不可见的。 + - 它的行为完全像一个EOA，使用与以太坊主网相同的签名和验证方案，未来可以扩展支持创新功能！ +- 用户发送的EVM交易被包装在Starknet交易中。衍生的EVM交易哈希与底层Starknet交易哈希一一对应。由于签名验证是在Cairo程序中完成的，因此交易在RPC层被打包（[despite being wrapped at the RPC level](https://github.com/kkrt-labs/kakarot-rpc/blob/bcadfc9b38ac934f73832b3a3485c15f08d66218/src/eth_rpc/servers/eth_rpc.rs#L236)）时仍然可以被证明地进行处理。对于用户来说，这是不可见的。 +- 新的状态根使用Pedersen哈希计算，而不是keccak，因为keccak在零知识友好性方面存在问题。这不会对EVM兼容性产生影响。 +- 状态trie使用Pedersen MPT计算，而不是[Keccak MPT](https://ethereum.org/developers/docs/data-structures-and-encoding/patricia-merkle-trie)。请注意，交易trie和收据trie都是作为keccak MPT进行计算的，用于区块浏览器，但作为证明承诺的Pedersen MPT进行计算。 + +总之，任何在Cairo中编写的东西都是可以证明的。Kakarot在Cairo中实现了EVM规范。这是设计上可证明的。所有Cairo的工作都是在幕后完成的。对于用户来说，这是不可见的。他们正在与一个EVM链进行交互。 + +Kakarot与其他zkEVM的区别 + +Kakarot zkEVM可能是最高级的zkEVM。在数学语言和多项式到人类可理解的语言之间的尺度上，Kakarot比其他zkEVM更接近于人类可读的语言。这对用户有两方面的影响： + +- 由于Kakarot是建立在Cairo之上的，因此Kakarot作为一个代码库非常精简（比其他zkEVM轻一个数量级），因此非常容易维护、适应以太坊的变化或添加新功能（例如本地账户抽象）。 +- Cairo（通过Starknet）是一个充满活力的生态系统，Kakarot可以轻松受益于其所有创新（相同的底层技术栈）。长期的想法可能包括并行执行、seed-less钱包（例如只依赖于面部识别）、Celestia DA集成等。 + +总之，通过在未来几年押注于CairoVM，Kakarot利用了整个Cairo（因此Starknet）生态系统。Cairo是生产中最先进的高级零知识工具箱，首先是[StarkEx](https://www.theblock.co/post/237064/starkex-layer-2-records-1-trillion-in-on-chain-trading-volume-since-june-2020)，现在是Starknet。 -To put it simply, Kakarot L2 is composed of an EVM written in Cairo and an RPC -layer to allow users to interact with it in an Ethereum format. All Cairo -execution traces are provable by design, which allows Kakarot to batch blocks -and submit proofs to L1 using the -[Starkware Shared prover](https://starkware.co/tech-stack/) (SHARP). Because -Cairo is a vibrant ecosystem, other prover implementations in the future will -emerge, such as Lambdaclass' -[Stark Platinum Prover](https://github.com/lambdaclass/lambdaworks/tree/main/provers). -This will enable multi-proof security and increase robustness of the Kakarot -network. - -In Kakarot zkEVM, the design choices regarding EVM programs and their Cairo -equivalents are explained below. They are subject to architecture changes over -time. **🎙️ Disclaimer 🎙️: all these designs choices are invisible to the user**: - -- each EVM smart contract (so-called _Contract Account_) is deployed as a unique - Starknet smart contract. This Starknet smart contract stores its own bytecode - and EVM storage slots. -- each EVM user-owned account (so-called _Externally Owned Account (EOA)_) is - deployed as a Starknet smart contract wallet. - - It has a Starknet formatted address (31 bytes hex string), which is uniquely - mapped to the user EOA EVM address (20 bytes hex string). For the user, this - is invisible. - - Its native balance in ETH (coin vs. token) is denominated in ERC20 native - token under the hood in the Kakarot system. For the user, this is invisible. - - It behaves exactly like an EOA, uses the same signature and validation - scheme as Ethereum mainnet, though it can be extended in the future to - support innovative features! -- EVM transactions that are sent by users are wrapped in Starknet transactions. - The derived EVM Transaction hashes are mapped 1-to-1 with underlying Starknet - transaction hashes. Since signature verification is done in a Cairo program, - transactions are provably processed with integrity - [despite being wrapped at the RPC level](https://github.com/kkrt-labs/kakarot-rpc/blob/bcadfc9b38ac934f73832b3a3485c15f08d66218/src/eth_rpc/servers/eth_rpc.rs#L236). - For the user, this is invisible. -- new state roots are computed using Pedersen hash and not keccak because of the - zk-unfriendliness of keccak. This does not hurt EVM compatibility at the - applicative level. -- the state trie is computed using Pedersen MPT and not - [Keccak MPT](https://ethereum.org/developers/docs/data-structures-and-encoding/patricia-merkle-trie). - Note that the transaction trie and receipt trie are both computed as keccak - MPTs, for block explorers, but as pedersen MPTs for the proof commitment. - -TL;DR - whatever is written in Cairo can be proven. Kakarot implements the EVM -specification in Cairo. It is provable by design. All the Cairo magic is done -under the hood. For the user, this is invisible. They are interacting with an -EVM chain. - -## The difference between Kakarot and other zkEVMs - -Kakarot zkEVM is probably the most high-level zkEVM. On the scale of maths -language and polynomials to human understandable language, Kakarot is closer to -human readable language than any other zkEVM. This matters to users in two ways: - -- Because Kakarot is built on Cairo, Kakarot as a codebase is extremely slim (an - order of magnitude lighter than other zkEVMs) and thus extremely easy to - maintain, adapt to Ethereum changes, or add new features to (e.g. native - account abstraction). -- Cairo (through Starknet) is a vibrant ecosystem and Kakarot can benefit from - all its innovations with ease (same underlying tech stack). Ideas on the long - term could include parallel execution, seed-less wallets (e.g. rely on face ID - only), Celestia DA integration and more. - -TL;DR - By betting on the CairoVM for the years to come, Kakarot leverages the -entire Cairo (and thus Starknet) ecosystem. Cairo is the most advanced -high-level zk-toolbox in production, first with -[StarkEx](https://www.theblock.co/post/237064/starkex-layer-2-records-1-trillion-in-on-chain-trading-volume-since-june-2020) -and now Starknet. --- -Diagram - How to build a zkEVM: +图表 - 如何构建 zkEVM： ![Different ways to build a zkEVM: low-level circuits or intermediary zkVM](../../static/diagrams/how_to_build_a_zkevm.png) -We believe that in focusing only on engineering, our approach is scalable and -sustainable. +我们相信，只专注于工程设计，我们的方法是可扩展和可持续的。 From a8dd179a59797028ffbb88d4cf0982f53d424d7a Mon Sep 17 00:00:00 2001 From: polibee <1244762327@qq.com> Date: Mon, 19 Feb 2024 09:26:33 +0800 Subject: [PATCH 4/4] Translattion review --- docs/architecture/understanding-zkevm.md | 2 +- docs/survival-guide.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/architecture/understanding-zkevm.md b/docs/architecture/understanding-zkevm.md index d35e4d8..e991893 100644 --- a/docs/architecture/understanding-zkevm.md +++ b/docs/architecture/understanding-zkevm.md @@ -91,7 +91,7 @@ TL;DR - 链下执行，链上验证，节省成本。 在 zk-Rollup 生态系统中，其他参与者决定重新开始并与 EVM 断开兼容性。其中包括例如由 CairoVM 提供支持的 [Starknet](https://www.starknet.io/en)。Starknet 上的用户和开发者需要习惯使用新的工具和技术，但不必受到 EVM 遗留问题的困扰。Kakarot 则做出了略有不同的选择：EVM 将继续成为加密领域的主要公共抽象层，而 Cairo 将成为最强大的 zkVM。因此，同时进行以下操作是有意义的： - 2024年构建EVM， -- 在未来的岁月里，把赌注押在开罗这座强国身上。 +- 在未来的岁月里，把赌注押在Cairo这个强大生态身上。 Kakarot用户将同时受益于以太坊网络效应和的创新。 diff --git a/docs/survival-guide.md b/docs/survival-guide.md index d022658..9d19c19 100644 --- a/docs/survival-guide.md +++ b/docs/survival-guide.md @@ -8,7 +8,7 @@ sidebar_position: 2 警告 🚧： RPC 和 Block Explorer 链接尚未建立。 -- 🚧 尚未发布 🚧 | 注册页面（用于卡卡罗特邀请阶段） +- 🚧 尚未发布 🚧 | 注册页面（用于Kakarot邀请阶段） Alpha Testnet): https://sepolia-signup.kakarot.org - 您需要白名单邀请才能将交易发送到 Kakarot Alpha 测试网📩。 - 🚧每天前往龙头处获取一些 testnet ETH🚰💧！