The Ethereum co-founder is typing…
- Vitalik, the co-founder of Ethereum, warned about the potential risks of restaking in a 2021 blog post called Don't Overload Consensus. + Vitalik, the co-founder of Ethereum, warned about the potential risks of restaking in a 2021 blog post called Don't Overload Consensus.
最好知道
+AI智能体和相关工具仍处于早期开发阶段且尚处于实验阶段，请谨慎使用。
+`nonce``
-`` - _开始标签，其中包含一段代码_
+`` - _开始标签，包含代码片段_
-nonce - _不可翻译的文本_
+nonce - _不可翻译文本_
`` - _结束标签_
-
+
源文本还包含缩短的标签，这些标签只包含数字，这意味着它们的功能不是很明显。 你可以将鼠标悬停在这些标签上，以准确查看它们提供的功能。
-在下面的示例中，你可以看到，将鼠标悬停在 \<0> 标签显示，它代表 `` 并包含代码片段，因此不应翻译这些标签内的内容。
+在下例中，当您将鼠标悬停在 `<0>` 标签上时，可以看到它代表 `` 且包含一个代码片段，因此不应翻译这些标签内的内容。
-
+
-## 简短与完整形式/缩写 {#short-vs-full-forms}
+## 缩写与完整形式 {#short-vs-full-forms}
-网站上使用了很多缩写，例如 dApp、NFT、DAO、DeFi 等。 这些缩写通常用于英语，并且大多数网站访问者都熟悉它们。
+网站上使用了很多缩写，例如 dapps、NFT、DAO、DeFi 等。 这些缩写通常用于英语，并且大多数网站访问者都熟悉它们。
由于它们通常没有其他语言的既定翻译，处理这些和类似术语的最佳方法是提供完整形式的描述性翻译，并在括号中添加英文缩写。
@@ -168,9 +174,9 @@ nonce - _不可翻译的文本_
如何翻译 dApp 的示例：
-- Decentralized applications (dapps) → _完整的翻译形式 (括号中为英文缩写)_
+- Decentralized applications (dapps) → _翻译后的完整形式（括号中为英文缩写）_
-## 没有既定翻译的术语 {#terms-without-established-translations}
+## 尚无既定译法的术语 {#terms-without-established-translations}
某些术语在其他语言中可能没有既定翻译，并且以原始英语术语而广为人知。 这些术语主要包括较新的概念，如工作量证明、权益证明、信标链、质押等。
@@ -178,19 +184,19 @@ nonce - _不可翻译的文本_
翻译它们时，请随意发挥创意，使用描述性翻译，或直接按字面翻译。
-**大多数术语应该翻译而不是将其中一些保留英文的原因是，随着越来越多的人开始使用以太坊和相关技术，这种新术语将在未来变得更加普遍。 如果我们想让来自世界各地的更多人加入这个领域，我们需要以尽可能多的语言提供易于理解的术语，即使我们需要自行创建它。**
+**大多数术语应该翻译而不是将其中一些保留为英文，其原因是，随着越来越多的人开始使用以太坊和相关技术，这些新术语将在未来变得更加普遍。** 如果我们想让来自世界各地的更多人加入这个领域，我们需要以尽可能多的语言提供易于理解的术语，即使我们需要自行创建。\*\*
-## 按钮与行动号召 {#buttons-and-ctas}
+## 按钮和号召性用语 {#buttons-and-ctas}
网站包含许多按钮，其翻译方式应与其他内容不同。
可以通过查看上下文屏幕截图、与大多数字符串连接或通过检查编辑器中的上下文（包括短语“button”）来识别按钮文本。
-按钮的翻译应尽可能简短，以防止格式不匹配。 此外，按钮翻译应该是必要的，即呈现命令或请求。
+按钮的翻译应尽可能简短，以防止格式不匹配。 此外，按钮的译文应使用祈使语气，即表达命令或请求。
-
+
-## 翻译包容性 {#translating-for-inclusivity}
+## 包容性翻译 {#translating-for-inclusivity}
Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站上的语言应该是中立的，欢迎所有人而不是排他性的。
@@ -200,7 +206,7 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
最后，语言应该适合所有大众和年龄段的读者。
-## 特定语言的翻译 {#language-specific-translations}
+## 特定于语言的翻译 {#language-specific-translations}
翻译时，重要的是要遵循你的语言中使用的语法规则、约定和格式，而不是从源复制。 源文本遵循英语语法规则和约定，而这不适用于许多其他语言。
@@ -208,7 +214,7 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
一些需要特别注意的例子：
-### 标点、格式 {#punctuation-and-formatting}
+### 标点和格式 {#punctuation-and-formatting}
**大写**
@@ -220,8 +226,8 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
- 正字法规则定义了每种语言的空格使用。 因为到处都使用空格，所以这些规则是最独特的，而空格是最容易误译的元素。
- 英语和其他语言之间的一些常见间距差异：
- - 计量单位和货币前的空格（例如 USD、EUR、kB、MB）
- - 度数符号前的空格（例如°C、℉）
+ - 计量单位和货币符号前的空格（例如：USD、EUR、kB、MB）
+ - 度数符号前的空格（例如：°C、℉）
- 一些标点符号前的空格，尤其是省略号 (...)
- 斜杠前后的空格 (/)
@@ -229,7 +235,7 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
- 每种语言都有一套多样化和复杂的规则来编写列表。 这些可能与英语有很大不同。
- 在某些语言中，每个新行的第一个单词需要大写，而在其他语言中，新行应该以小写字母开头。 许多语言对列表中的大小写也有不同的规则，具体取决于每行的长度。
-- 这同样适用于行项目的标点符号。 列表中的结束标点可以是句点 (**.**)、逗号 (**,**) 或分号 (**；**)具体取决于语言
+- 这同样适用于行项目的标点符号。 列表中的结束标点可以是句点 (.)、逗号 (,) 或分号 (;)，具体取决于语言。
**引号**
@@ -240,7 +246,7 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
- »示例文本«
- “示例文本”
- ‘示例文本’
- - «示例文本»
+ - «示例 文本»
**连字符和破折号**
@@ -253,10 +259,10 @@ Ethereum.org 的访问者来自世界各地和不同的背景。 因此，网站
- 用不同语言书写数字的主要区别在于用于小数和千位的分隔符。 对于千数来说，这可以是句号、逗号或空格。 同样，一些语言使用小数点，而另一些语言使用小数点逗号。
- 一些大数的例子：
- - 英语 - **1,000.50**
- - 西班牙语 - **1.000,50**
- - 法语 - **1 000,50**
-- 翻译数字时的另一个重要考虑因素是百分号。 它可以用不同的方式编写：**100%**、**100 %** 或 **%100**。
+ - 英语 – **1,000.50**
+ - 西班牙语 – **1.000,50**
+ - 法语 – **1 000,50**
+- 翻译数字时的另一个重要考虑因素是百分号。 可以写成不同形式：**100%**、**100 %** 或 **%100**。
- 最后，负数可以不同地显示，具体取决于语言：-100、100-、(100) 或 [100]。
**日期**
diff --git a/public/content/translations/zh/dao/index.md b/public/content/translations/zh/dao/index.md
index 83a24731f20..503e26bf2a7 100644
--- a/public/content/translations/zh/dao/index.md
+++ b/public/content/translations/zh/dao/index.md
@@ -1,16 +1,16 @@
---
-title: 什么是去中心化自治组织 (DAO)？
-metaTitle: 什么是去中心化自治组织 (DAO)？ | 去中心化自治组织
-description: 以太坊上的去中心化自治组织简介
+title: "什么是去中心化自治组织 (DAO)？"
+metaTitle: "什么是去中心化自治组织 (DAO)？ | 去中心化自治组织"
+description: "以太坊上的去中心化自治组织简介"
lang: zh
template: use-cases
emoji: ":handshake:"
sidebarDepth: 2
image: /images/use-cases/dao-2.png
-alt: 表示去中心化自治组织在对提案投票。
-summaryPoint1: 没有集中领导的、成员共同拥有的社区。
-summaryPoint2: 一种与互联网上的陌生人合作的安全方式。
-summaryPoint3: 一个为特定事业投入资金的安全场所。
+alt: "表示去中心化自治组织在对提案投票。"
+summaryPoint1: "没有集中领导的、成员共同拥有的社区。"
+summaryPoint2: "一种与互联网上的陌生人合作的安全方式。"
+summaryPoint3: "一个为特定事业投入资金的安全场所。"
---
## 什么是去中心化自治组织？ {#what-are-daos}
@@ -19,15 +19,15 @@ summaryPoint3: 一个为特定事业投入资金的安全场所。
去中心化自治组织让全世界志同道合之士开展合作，而无需信赖一位宅心仁厚的领导来管理资金和运营。 没有可以随意花钱的首席执行官，也没有能够做假账的首席财务官。 取而代之的是，融入代码的基于区块链的规则规定组织如何运作以及资金如何使用。
-去中心化自治组织拥有内部资产，未经该组织批准，任何人都无权动用。 决策通过提案和投票监管，确保组织中的每位成员都有发言权，并且一切都发生在[链上](/glossary/#on-chain)，公开透明。
+去中心化自治组织拥有内部资产，未经该组织批准，任何人都无权动用。 决策通过提案和投票进行治理，以确保组织中的每个人都有发言权，并且一切都透明地[在链上](/glossary/#onchain)进行。
## 我们为什么需要去中心化自治组织？ {#why-dao}
-与他人创办涉及资金和金钱的组织，需要对与合作对象高度信任。 不过，显然很难相信互联网上素不相识的人。 通过去中心化自治组织，你不需要相信组织中的其他人，只需要相信去中心化自治组织的代码就够了，它是 100% 公开透明的，任何人都可以验证。
+与他人创办涉及资金和金钱的组织，需要对合作对象高度信任。 不过，显然很难相信互联网上素不相识的人。 通过去中心化自治组织，你不需要相信组织中的其他人，只需要相信去中心化自治组织的代码就够了，它是 100% 公开透明的，任何人都可以验证。
这为全球合作和协调提供了许多新机会。
-### 对比 {#dao-comparison}
+### 比较 {#dao-comparison}
| 去中心化自治组织 | 传统组织 |
| ------------------------- | ------------------------------ |
@@ -37,23 +37,23 @@ summaryPoint3: 一个为特定事业投入资金的安全场所。
| 以去中心化方式自动提供服务（例如慈善基金的分配）。 | 需要人工处理或自动集中控制，易受操纵。 |
| 所有活动公开透明。 | 活动通常是私密进行，不向公众开放。 |
-### 去中心化自治组织示例 {#dao-examples}
+### DAO 示例 {#dao-examples}
为了帮助你更好地理解，这里有一些去中心化自治组织的应用示例：
-- **慈善机构** – 可以接受全世界任何人的捐赠，并投票决定要资助的项目。
-- **集体所有权** – 可以购买实体或数字资产，组织成员可以投票决定如何使用它们。
-- **风险投资和赠款** – 可以成立一个风险基金，汇集投资资本并投票进行商业投资。 后续收益可以分配给相应 DAO 成员。
+- **慈善机构** – 您可以接受来自世界各地任何人的捐赠，并投票决定要资助哪些事业。
+- **集体所有权** – 您可以购买实体或数字资产，成员可以投票决定如何使用它们。
+- **风险投资和拨款** – 您可以创建一个风险基金，汇集投资资本并对要支持的风险项目进行投票。 后续收益可以分配给相应 DAO 成员。
+
如果你不熟悉以太坊，请尝试我们推荐的去中心化金融应用程序。
探索去中心化金融应用程序
@@ -78,15 +78,15 @@ summaryPoint3: 基于开源技术，任何人都可以来编程。
大多数金融服务都有去中心化的替代方案。 但以太坊也为打造全新的金融产品开辟了机会。 这个清单还在不断增长。
-- [向世界各地汇款](#send-money)
+- [向全球汇款](#send-money)
- [在全球范围内流转资金](#stream-money)
- [获取稳定货币](#stablecoins)
- [抵押借款](#lending)
- [无抵押借款](#flash-loans)
-- [开始加密货币存款](#saving)
+- [开始加密货币储蓄](#saving)
- [交易代币](#swaps)
- [扩充你的投资组合](#investing)
-- [为你的想法提供资金](#crowdfunding)
+- [为你的想法募资](#crowdfunding)
- [购买保险](#insurance)
- [管理你的投资组合](#aggregators)
@@ -94,17 +94,17 @@ summaryPoint3: 基于开源技术，任何人都可以来编程。
### 向世界各地快速汇款 {#send-money}
-作为一个区块链，以太坊设计用于让用户在全球范围内安全地发送交易。 与比特币一样，以太坊使得向世界各地发送资金就像发送电子邮件一样容易。 只需从钱包中输入收款人的[以太坊域名服务名称](/glossary/#ens)（如 bob.eth）或他们的帐户地址，你的付款（通常）将在几分钟内直接到达对方帐户。 要发送或接收付款，你将需要一个[钱包](/wallets/)。
+作为一个区块链，以太坊设计用于让用户在全球范围内安全地发送交易。 与比特币一样，以太坊使得向世界各地发送资金就像发送电子邮件一样容易。 只需在你的钱包中输入收款人的 [ENS 名称](/glossary/#ens)（如 bob.eth）或其账户地址，你的付款（通常）将在几分钟内直接到账。 要发送或接收付款，你将需要一个[钱包](/wallets/)。
- 查看支付 dapp
+ 查看支付去中心化应用程序
#### 在全球范围内流转资金... {#stream-money}
你也可以通过以太坊汇款。 这可以让你秒速支付某人的工资，让他们可以在需要时获得资金。 或者立刻租用一些物品，如储物柜或电动滑板车。
-而且，如果你因为以太币的价值波动过大而不想发送或流式传输[以太币](/glossary/#ether)，以太坊上还有其他可供选择的货币：[稳定币](/glossary/#stablecoin)。
+而且，如果你因为 [ETH](/glossary/#ether) 的价值波动过大而不想发送或流式传输它，以太坊上还有其他可供选择的货币：[稳定币](/glossary/#stablecoin)。
- 查看借款 dapp
+ 查看借款去中心化应用程序
选择去中心化贷款人具有许多优势...
-#### 隐私借贷 {#borrowing-privacy}
+#### 私密借款 {#borrowing-privacy}
今天，贷款和借钱都围绕着相关个人进行。 在放贷前，银行需要了解你是否有能力偿还贷款。
-去中心化借贷无需任何一方表明自己的身份即可进行。 但是，借款人必须提供抵押品，如果他们没有偿还贷款，贷款人将自动获得抵押品。 有的贷款人甚至接受[非同质化代币](/glossary/#nft)作为抵押品。 非同质化代币是指绘画等独特资产。 [关于非同质化代币的更多信息](/nft/)
+去中心化借贷无需任何一方表明自己的身份即可进行。 但是，借款人必须提供抵押品，如果他们没有偿还贷款，贷款人将自动获得抵押品。 有些贷款人甚至接受 [NFT](/glossary/#nft) 作为抵押品。 非同质化代币是指绘画等独特资产。 [关于 NFT 的更多信息](/nft/)
这允许你在不进行征信调查或透露私人信息的情况下借钱。
-#### 获得全球资金 {#access-global-funds}
+#### 获取全球资金 {#access-global-funds}
当你选择去中心化贷款人时，可以使用来自全球各地的存款，而不仅仅是选定银行或机构保管的资金。 这使人们更容易获得贷款，并提高利率。
-#### 税收优惠 {#tax-efficiencies}
+#### 税收效率 {#tax-efficiencies}
借贷可以让你获得所需资金，而无需出售你的以太币（该行为需要征税）。 然而，你可以使用以太币作为抵押品，借入稳定币。 这不仅为你提供所需的现金流，你还可以继续持有自己的以太币。 当你需要现金时，稳定币是更好的代币，因为它们不会像以太币一样波动。 [关于稳定币的更多信息](#stablecoins)
@@ -178,19 +178,19 @@ Dai 或 USDC 等代币的价值和美元的差距通常保持在几美分以内
- 查看借款 dapp
+ 查看出借去中心化应用程序
#### 无损彩票 {#no-loss-lotteries}
@@ -218,7 +218,7 @@ Dai 或 USDC 等代币的价值和美元的差距通常保持在几美分以内
例如，如果你想使用无损彩票 PoolTogether（如上所述），则需要类似 Dai 或 USDC 的代币。 DEX 允许你将以太币换成这些代币，并在完成交易后再换回来。
- 查看代币兑换
+ 查看代币交易所
- 查看更多交易 dapp
+ 查看交易去中心化应用程序
查看投资去中心化应用程序
@@ -247,7 +247,7 @@ Dai 或 USDC 等代币的价值和美元的差距通常保持在几美分以内
- 查看更多众筹去中心化应用程序
+ 查看众筹去中心化应用程序
-#### 二次方融资 {#quadratic-funding}
+#### 二次方募资 {#quadratic-funding}
以太坊是开源软件，到目前为止，很多工作都由社区资助。 这催生了一种有趣的新型募资模式：二次方融资。 这有可能改进我们在未来为各种公共产品募资的方式。
@@ -273,7 +273,7 @@ Dai 或 USDC 等代币的价值和美元的差距通常保持在几美分以内
这意味着获得 100 笔 1 美元捐款的项目 A 最终可能比获得 1 笔 1 万美元捐款的项目 B 获得更多资金（取决于匹配池的大小）。
- 关于二次方融资的更多信息
+ 关于二次方募资的更多信息
查看保险去中心化应用程序
@@ -290,7 +290,7 @@ Dai 或 USDC 等代币的价值和美元的差距通常保持在几美分以内
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-### 去中心化金融数据 {#defi-data}
+### DeFi 数据 {#defi-data}
- [DeFi Prime](https://defiprime.com/)
- [DeFi Llama](https://defillama.com/)
-### 去中心化金融相关文章 {#defi-articles}
+### DeFi 文章 {#defi-articles}
-- [去中心化金融 (DeFi) 初学者指南](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu，2020 年 1 月 6 日_
+- [DeFi 新手指南](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu，2020 年 1 月 6 日_
+- [EEA DeFi 风险评估指南](https://entethalliance.org/specs/defi-risks/) – 一份行业支持的概述，介绍了如何识别和评估 DeFi 协议中的关键风险。
### 视频 {#videos}
-- [Finematics - 去中心化金融教育](https://finematics.com/) - _关于去中心化金融的视频_
-- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _去中心化金融基础：在这个偶尔令人困惑的空间里，你开始需要了解的一切。_
-- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _ - 什么是去中心化金融？_
+- [Finematics - 去中心化金融教育](https://finematics.com/) – _关于 DeFi 的视频_
+- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _DeFi 基础知识：在这个时而令人费解的领域，入门所需了解的一切。_
+- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _什么是 DeFi？_
### 社区 {#communities}
-- [去中心化金融 Llama Discord 服务器](https://discord.defillama.com/)
-- [去中心化金融 Pulse Discord 服务器](https://discord.gg/Gx4TCTk)
+- [DeFi Llama Discord 服务器](https://discord.defillama.com/)
+- [DeFi Pulse Discord 服务器](https://discord.gg/Gx4TCTk)
+> clef newaccount --keystore <路径>
-Please enter a password for the new account to be created:
->
+请输入要创建的新账户的密码：
+> <密码>
------------
-INFO [10-28|16:19:09.156] Your new key was generated address=0x5e97870f263700f46aa00d967821199b9bc5a120
-WARN [10-28|16:19:09.306] Please backup your key file path=/home/user/go-ethereum/data/keystore/UTC--2022-10-28T15-19-08.000825927Z--5e97870f263700f46aa00d967821199b9bc5a120
-WARN [10-28|16:19:09.306] Please remember your password!
-生成帐户 0x5e97870f263700f46aa00d967821199b9bc5a120
+INFO [10-28|16:19:09.156] 您的新密钥已生成 address=0x5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] 请备份您的密钥文件 path=/home/user/go-ethereum/data/keystore/UTC--2022-10-28T15-19-08.000825927Z--5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] 请记住您的密码！
+已生成账户 0x5e97870f263700f46aa00d967821199b9bc5a120
```
-[Geth 相关文档](https://geth.ethereum.org/docs)
+[Geth 文档](https://geth.ethereum.org/docs)
-可以通过你的私钥获取公钥，但你不能通过公钥获取私钥。 确保私钥的安全性，以及顾名思义，**私密性**，至关重要。
+可以通过你的私钥获取公钥，但你不能通过公钥获取私钥。 保护好私钥的安全至关重要，并且顾名思义，一定要保持**私密**。
你需要一个私钥来签署消息和交易并输出签名。 然后其他人可以使用签名获取你的公钥，证明信息的作者。 在你的应用程序中，你可以使用 JavaScript 程序库向网络发送交易。
-## 合约帐户 {#contract-accounts}
+## 合约账户 {#contract-accounts}
合约帐户也有一个 42 个字符组成的十六进制地址：
@@ -110,13 +111,13 @@ WARN [10-28|16:19:09.306] Please remember your password!
以太坊还有一另种类型的密钥，它们是在以太坊从工作量证明过渡到权益证明共识时引入的。 它们是“BLS”密钥，用来识别验证者。 这些密钥可以有效地聚合，减少网络达成共识所需要的带宽。 没有这种密钥集合，验证者的最小质押金额将会高出许多。
-[更多关于验证者密钥的信息](/developers/docs/consensus-mechanisms/pos/keys/)。
+[关于验证者密钥的更多信息](/developers/docs/consensus-mechanisms/pos/keys/)。
## 关于钱包的说明 {#a-note-on-wallets}
帐户和钱包不同。 钱包是一个界面或应用程序，可让你与以太坊帐户（外部帐户或合约帐户）进行交互。
-## 视频演示 {#a-visual-demo}
+## 可视化演示 {#a-visual-demo}
跟随 Austin 了解哈希函数和密钥对。
@@ -124,13 +125,13 @@ WARN [10-28|16:19:09.306] Please remember your password!
+ 在 playground 中尝试端点
+
**参数**
@@ -310,11 +314,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[]
准确的返回数据因客户端实现而异。 节点未进行同步时，所有客户端返回 `False`，并且所有客户端返回以下字段。
-`Object|Boolean`，具有同步状态数据的对象，或 `FALSE`（不进行同步时）：
+`Object|Boolean`，一个包含同步状态数据的对象；如果未同步，则为 `FALSE`：
-- `startingBlock`: `QUANTITY` - 导入开始进行的区块（只有当同步进行到其区块头时才会被重置）
-- `currentBlock`: `QUANTITY` - 当前区块，同 eth_blockNumber
-- `highestBlock`: `QUANTITY` - 估计的最高区块
+- `startingBlock`：`QUANTITY` - 导入开始时的区块（仅在同步达到其头部后才会重置）
+- `currentBlock`：`QUANTITY` - 当前区块，与 eth_blockNumber 相同
+- `highestBlock`：`QUANTITY` - 估算的最高区块
然而，各个客户端还可能提供额外数据。 例如 Geth 返回以下字段：
@@ -362,9 +366,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[]
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -374,7 +378,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
highestBlock: '0x454'
}
}
-// Or when not syncing
+// 或者在未同步时
{
"id":1,
"jsonrpc": "2.0",
@@ -386,7 +390,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
返回客户端的 coinbase 地址。
-> **注意：**该方法已于 **v1.14.0** 版本被弃用，并不再受支持。 试图使用该方法会触发“Method not supported（不支持该方法）”错误。
+
+ 在 playground 中尝试端点
+
+
+> \*\*注意：\*\*该方法已于 **v1.14.0** 版本被弃用，并不再受支持。 试图使用该方法会触发“Method not supported（不支持该方法）”错误。
**参数**
@@ -399,9 +407,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":64}'
-// Result
+// 结果
{
"id":64,
"jsonrpc": "2.0",
@@ -413,20 +421,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6
返回链 ID，用于签署受重放攻击保护的交易。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`chainId`，十六进制字符串值，代表当前链 ID 的整数。
+`chainId`，十六进制字符串值，表示当前链 ID 的整数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}'
-// Result
+// 结果
{
"id":67,
"jsonrpc": "2.0",
@@ -438,18 +450,22 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67
如果客户端正在积极挖掘新区块，则返回 `true`。 此方法只能在工作量证明网络中返回 `true`，并且在[合并](/roadmap/merge/)后可能无法用于某些客户端。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`Boolean` - 如果客户端正在挖矿，则返回 `true`，否则返回 `false`。
+`布尔值` - 如果客户端正在挖矿，则返回 `true`，否则返回 `false`。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}'
//
{
@@ -463,20 +479,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}
返回节点挖矿时使用的每秒哈希数。 此方法只能在工作量证明网络中返回 `true`，并且在[合并](/roadmap/merge/)后可能无法用于某些客户端。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`QUANTITY` - 每秒哈希数。
+`QUANTITY` - 每秒的哈希数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":71}'
-// Result
+// 结果
{
"id":71,
"jsonrpc": "2.0",
@@ -488,20 +508,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":7
返回当前燃料价格的估计值，以 wei 为单位。 例如，Besu 客户端检查最后 100 个区块，并默认返回燃料单价中位数。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`QUANTITY` - 表示当前燃料价格（以 wei 为单位）的整数。
+`QUANTITY` - 以 wei 为单位的当前燃料价格的整数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
-// Result
+// 结果
{
"id":73,
"jsonrpc": "2.0",
@@ -513,20 +537,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":7
返回客户端拥有的地址列表。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`Array of DATA`，20 字节 - 客户端拥有的地址。
+`DATA 数组`，20 字节 - 客户端拥有的地址。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -538,20 +566,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1
返回最新区块的编号。
+
+ 在 playground 中尝试端点
+
+
**参数**
无
**返回值**
-`QUANTITY` - 表示客户端所在的当前区块编号的整数。
+`QUANTITY` - 客户端所在的当前区块编号的整数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":83}'
-// Result
+// 结果
{
"id":83,
"jsonrpc": "2.0",
@@ -563,10 +595,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id
返回给定地址的帐户余额。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `DATA`，20 字节 - 需要检查余额的地址。
-2. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`，20 字节 - 要查询余额的地址。
+2. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]
@@ -574,14 +610,14 @@ params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]
**返回值**
-`QUANTITY` - 表示当前余额的整数（以 wei 为单位）。
+`QUANTITY` - 以 wei 为单位的当前余额的整数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -593,30 +629,35 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407
从给定地址的存储位置返回值。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `DATA`，20 字节 - 存储地址。
-2. `QUANTITY` - 表示存储位置的整数。
-3. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `DATA`，20 字节 - 存储的地址。
+2. `QUANTITY` - 存储中位置的整数。
+3. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
**返回值**
-`DATA` - 此存储位置处的值。
+`DATA` - 此存储位置的值。
-**示例** 正确位置的计算取决于要检索的存储。 考虑通过地址 `0x391694e7e0b0cce554cb130d723a9d27458f9298` 部署在 `0x295a70b2de5e3953354a6a8344e616ed314d7251` 的以下合约。
+**示例**
+正确位置的计算取决于要检索的存储。 考虑通过地址 `0x391694e7e0b0cce554cb130d723a9d27458f9298` 部署在 `0x295a70b2de5e3953354a6a8344e616ed314d7251` 的以下合约。
```
contract Storage {
uint pos0;
mapping(address => uint) pos1;
- function Storage() {
+ constructor() {
pos0 = 1234;
pos1[msg.sender] = 5678;
}
}
```
-检索 pos0 的值比较简单：
+检索 pos0 的值很简单：
```js
curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545
@@ -658,30 +699,34 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [
### eth_getTransactionCount {#eth_gettransactioncount}
-返回从一个地址_发送_的交易数量。
+返回从某个地址_发送_的交易数量。
+
+
+ 在 playground 中尝试端点
+
**参数**
1. `DATA`，20 字节 - 地址。
-2. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+2. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
- "latest", // state at the latest block
+ "latest", // 最新区块的状态
]
```
**返回值**
-`QUANTITY` - 表示从该地址发送的交易数量的整数。
+`QUANTITY` - 从此地址发送的交易数量的整数。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1","latest"],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -693,6 +738,10 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params
返回匹配给定区块哈希的区块中的交易数量。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，32 字节 - 区块的哈希
@@ -703,7 +752,7 @@ params: ["0xd03ededb7415d22ae8bac30f96b2d1de83119632693b963642318d87d1bece5b"]
**返回值**
-`QUANTITY` - 表示此区块中的交易数量的整数。
+`QUANTITY` - 此区块中交易数量的整数。
**示例**
@@ -722,9 +771,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHa
返回匹配给定区块编号的区块中的交易数量。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `QUANTITY|TAG` - 整数区块号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITY|TAG` - 整数区块编号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)。
```js
params: [
@@ -734,7 +787,7 @@ params: [
**返回值**
-`QUANTITY` - 表示此区块中的交易数量的整数。
+`QUANTITY` - 此区块中交易数量的整数。
**示例**
@@ -753,6 +806,10 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNu
返回匹配给定区块哈希的区块中的叔块数量。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，32 字节 - 区块的哈希
@@ -763,7 +820,7 @@ params: ["0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2"]
**返回值**
-`QUANTITY` - 表示此区块中的叔块数量的整数。
+`QUANTITY` - 此区块中叔块数量的整数。
**示例**
@@ -782,9 +839,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","p
返回匹配给定区块编号的区块中的叔块数量。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
@@ -794,7 +855,7 @@ params: [
**返回值**
-`QUANTITY` - 表示此区块中的叔块数量的整数。
+`QUANTITY` - 此区块中叔块数量的整数。
**示例**
@@ -813,10 +874,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockNumber",
返回位于给定地址的代码。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，20 字节 - 地址
-2. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+2. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
```js
params: [
@@ -827,7 +892,7 @@ params: [
**返回值**
-`DATA` - 给定地址处的代码。
+`DATA` - 来自给定地址的代码。
**示例**
@@ -844,9 +909,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xC02aaA
### eth_sign {#eth_sign}
-Sign 方法如下计算以太坊特定的签名：`sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`。
+sign 方法通过 `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))` 计算以太坊专用签名。
-通过在消息中添加前缀，计算出的签名就可以识别为以太坊特定签名。 这可以防止滥用行为，如恶意去中心化应用程序可以签署任意数据（例如交易）并使用签名冒充受害者。
+通过在消息中添加前缀，计算出的签名就可以识别为以太坊特定签名。 这可以防止滥用，因为恶意去中心化应用程序可以签署任意数据（例如交易）并使用签名冒充受害者。
注意：签名时使用的地址必须已解锁。
@@ -862,9 +927,9 @@ Sign 方法如下计算以太坊特定的签名：`sign(keccak256("\x19Ethereum
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d370f73ec7d8a03e965129118dc8f5bf83", "0xdeadbeaf"],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -878,27 +943,27 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d37
**参数**
-1. `Object` - 交易对象
+1. `对象` - 交易对象
- `type`：
-- `from`: `DATA`，20 字节 - 发送交易的地址。
-- `to`: `DATA`，20 字节 -（创建新合约时可选）将交易定向到的地址。
-- `gas`: `QUANTITY` -（可选，默认值：90000）表示为交易执行提供的燃料的整数。 它将返回未使用的燃料。
-- `gasPrice`: `QUANTITY` -（可选，默认值：待确定）表示用于每笔已支付燃料的 gasPrice 的整数，以 Wei 为单位。
-- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数，以 Wei 为单位。
-- `data`: `DATA` - 合约的编译代码或调用的方法签名和编码参数的哈希。
-- `nonce`: `QUANTITY` -（可选）表示随机数的整数。 它允许覆盖你自己的使用相同随机数的待处理交易。
+- `from`：`DATA`，20 字节 - 交易发送方地址。
+- `to`：`DATA`，20 字节 -（创建新合约时可选）交易接收方地址。
+- `gas`：`QUANTITY` -（可选，默认值：90000）为交易执行提供的燃料整数。 它将返回未使用的燃料。
+- `gasPrice`：`QUANTITY` -（可选，默认值：待定）用于每单位已支付燃料的 gasPrice 整数，以 Wei 为单位。
+- `value`：`QUANTITY` -（可选）随此交易发送的价值的整数，以 Wei 为单位。
+- `data`：`DATA` - 合约的已编译代码或所调用方法签名和编码参数的哈希。
+- `nonce`：`QUANTITY` -（可选）nonce 的整数。 它允许覆盖你自己的使用相同随机数的待处理交易。
**返回值**
-`DATA`，由指定帐户签名的 RLP 编码的交易对象。
+`DATA`，由指定账户签名的 RLP 编码交易对象。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","params": [{"data":"0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675","from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155","gas": "0x76c0","gasPrice": "0x9184e72a000","to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567","value": "0x9184e72a"}]}'
-// Result
+// 结果
{
"id": 1,
"jsonrpc": "2.0",
@@ -908,19 +973,19 @@ curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","
### eth_sendTransaction {#eth_sendtransaction}
-创建新的消息调用交易或创建合约（如果数据字段包含代码），然后使用 `from` 中指定的帐户签名。
+如果数据字段包含代码，则创建新的消息调用交易或合约，并使用 `from` 中指定的帐户进行签名。
**参数**
-1. `Object` - 交易对象
+1. `对象` - 交易对象
-- `from`: `DATA`，20 字节 - 发送交易的地址。
-- `to`: `DATA`，20 字节 -（创建新合约时可选）将交易定向到的地址。
-- `gas`: `QUANTITY` -（可选，默认值：90000）表示为交易执行提供的燃料的整数。 它将返回未使用的燃料。
-- `gasPrice`: `QUANTITY` -（可选，默认值：待确定）表示用于每个已支付燃料的 gasPrice 的整数。
-- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数。
-- `input`: `DATA` - 合约的编译代码或调用的方法签名和编码参数的哈希。
-- `nonce`: `QUANTITY` -（可选）表示随机数的整数。 它允许覆盖你自己的使用相同随机数的待处理交易。
+- `from`：`DATA`，20 字节 - 交易发送方地址。
+- `to`：`DATA`，20 字节 -（创建新合约时可选）交易接收方地址。
+- `gas`：`QUANTITY` -（可选，默认值：90000）为交易执行提供的燃料整数。 它将返回未使用的燃料。
+- `gasPrice`：`QUANTITY` -（可选，默认值：待定）用于每单位已支付燃料的 gasPrice 整数。
+- `value`：`QUANTITY` -（可选）随此交易发送的价值的整数。
+- `input`：`DATA` - 合约的已编译代码或所调用方法签名和编码参数的哈希。
+- `nonce`：`QUANTITY` -（可选）nonce 的整数。 它允许覆盖你自己的使用相同随机数的待处理交易。
```js
params: [
@@ -938,16 +1003,16 @@ params: [
**返回值**
-`DATA`，32 字节 - 交易哈希，或者如果交易尚不可用，则为零哈希。
+`DATA`，32 字节 - 交易哈希；如果交易尚不可用，则为零哈希。
创建合约时，在交易被提议到区块后，使用 [eth_getTransactionReceipt](#eth_gettransactionreceipt) 获取合约地址。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{see above}],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -961,7 +1026,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{
**参数**
-1. `DATA`，签名的交易数据。
+1. `DATA`，已签名的交易数据。
```js
params: [
@@ -971,16 +1036,16 @@ params: [
**返回值**
-`DATA`，32 字节 - 交易哈希，或者如果交易尚不可用，则为零哈希。
+`DATA`，32 字节 - 交易哈希；如果交易尚不可用，则为零哈希。
创建合约时，在交易被提议到区块后，使用 [eth_getTransactionReceipt](#eth_gettransactionreceipt) 获取合约地址。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[{see above}],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -990,20 +1055,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params"
### eth_call {#eth_call}
-立即执行新的消息调用，但不在区块链上创建交易。 通常用来执行只读智能合约的函数，例如 ERC-20 合约的 `balanceOf` 函数。
+立即执行新的消息调用，但不在区块链上创建交易。 通常用于执行只读智能合约函数，例如 ERC-20 合约的 `balanceOf`。
+
+
+ 在 playground 中尝试端点
+
**参数**
-1. `Object` - 交易调用对象
+1. `对象` - 交易调用对象
-- `from`: `DATA`，20 字节 -（可选）发送交易的地址。
-- `to`: `DATA`，20 字节 - 将交易定向到的地址。
-- `gas`: `QUANTITY` -（可选）表示为交易执行提供的燃料的整数。 eth_call 消耗零燃料，但某些执行可能需要此参数。
-- `gasPrice`: `QUANTITY` -（可选）表示用于每个已支付燃料的 gasPrice 的整数
-- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数
-- `input`: `DATA` -（可选）方法签名和编码参数的哈希。 有关详细信息，参见 [Solidity 文档中的以太坊合约应用程序二进制接口](https://docs.soliditylang.org/en/latest/abi-spec.html)。
+- `from`：`DATA`，20 字节 -（可选）交易发送方地址。
+- `to`：`DATA`，20 字节 - 交易接收方地址。
+- `gas`：`QUANTITY` -（可选）为交易执行提供的燃料整数。 eth_call 消耗零燃料，但某些执行可能需要此参数。
+- `gasPrice`：`QUANTITY` -（可选）用于每单位已支付燃料的 gasPrice 整数
+- `value`：`QUANTITY` -（可选）随此交易发送的价值的整数
+- `input`：`DATA` -（可选）方法签名和编码参数的哈希。 详情请参阅 [Solidity 文档中的以太坊合约 ABI](https://docs.soliditylang.org/en/latest/abi-spec.html)。
-2. `QUANTITY|TAG` - 整数区块号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+2. `QUANTITY|TAG` - 整数区块编号，或字符串 `"latest"`、`"earliest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)
**返回值**
@@ -1012,9 +1081,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params"
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1026,20 +1095,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}]
生成并返回允许交易完成所需燃料数量的估算值。 交易不会添加到区块链中。 请注意，出于各种原因，包括以太坊虚拟机的机制和节点性能，估算值可能远远超过交易实际使用的燃料数量。
+
+ 在 playground 中尝试端点
+
+
**参数**
-参见 [eth_call](#eth_call) 的参数，但所有属性都是可选的。 如果没有指定燃料限制，geth 将使用待处理区块的区块燃料限制作为上限。 因此，当所需燃料数量高于待处理区块的燃料限制时，返回的估算值可能不足以执行调用/交易。
+参见 [eth_call](#eth_call) 参数，但所有属性都是可选的。 如果没有指定燃料限制，geth 将使用待处理区块的区块燃料限制作为上限。 因此，当燃料数量高于待处理区块的燃料限制时，返回的估算值可能不足以执行调用/交易。
**返回值**
-`QUANTITY` - 使用的燃料数量。
+`QUANTITY` - 已使用的燃料数量。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see above}],"id":1}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1051,10 +1124,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see
根据哈希返回关于区块的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，32 字节 - 区块的哈希。
-2. `Boolean` - 如果为 `true` 则返回完整的交易对象，如果为 `false` 则仅返回交易的哈希。
+2. `布尔值` - 如果为 `true`，则返回完整的交易对象；如果为 `false`，则仅返回交易的哈希。
```js
params: [
@@ -1065,39 +1142,38 @@ params: [
**返回值**
-`Object` - 区块对象，或 `null`（当没有找到区块时）：
-
-- `number`: `QUANTITY` - 区块编号。 如果是待处理区块，则为 `null`。
-- `hash`: `DATA`，32 字节 - 区块的哈希。 如果是待处理区块，则为 `null`。
-- `parentHash`: `DATA`，32 字节 - 父块的哈希。
-- `nonce`: `DATA`，8 字节 - 已生成的工作量证明的哈希。 如果是待处理区块，则为 `null`。
-- `sha3Uncles`: `DATA`，32 字节 - 区块中的叔块数据的 SHA3。
-- `logsBloom`: `DATA`，256 字节 - 区块日志的布隆过滤器。 如果是待处理区块，则为 `null`。
-- `transactionsRoot`: `DATA`，32 字节 - 区块交易树的根。
-- `stateRoot`: `DATA`，32 字节 - 区块最终状态树的根。
-- `receiptsRoot`: `DATA`，32 字节 - 区块收据树的根。
-- `miner`: `DATA`，20 字节 - 获得挖矿奖励的受益人的地址。
-- `difficulty`: `QUANTITY` - 表示此区块难度的整数。
-- `totalDifficulty`: `QUANTITY` - 表示到此区块为止链的总难度的整数。
-- `extraData`: `DATA` - 此区块的“额外数据”字段。
-- `size`: `QUANTITY` - 表示此区块大小的整数，以字节为单位。
-- `gasLimit`: `QUANTITY` - 此区块允许的最大燃料数量。
-- `gasUsed`: `QUANTITY` - 此区块中所有交易使用的总燃料数量。
-- `timestamp`: `QUANTITY` - 整理区块时的 unix 时间戳。
-- `transactions`: `Array` - 交易对象数组，或 32 字节交易哈希，取决于最后一个给定的参数。
-- `uncles`: `Array` - 叔块哈希数组。
+`对象` - 区块对象；如果未找到区块，则为 `null`：
+
+- `number`：`QUANTITY` - 区块编号。 如果是待处理区块，则为 null。
+- `hash`：`DATA`，32 字节 - 区块的哈希。 如果是待处理区块，则为 null。
+- `parentHash`：`DATA`，32 字节 - 父块的哈希。
+- `nonce`：`DATA`，8 字节 - 生成的工作量证明的哈希。 如果是待处理区块时，则为 `null`，如果是权益证明区块（自合并起），则为 `0x0`。
+- `sha3Uncles`：`DATA`，32 字节 - 区块中叔块数据的 SHA3。
+- `logsBloom`：`DATA`，256 字节 - 区块日志的布隆过滤器。 如果是待处理区块，则为 null。
+- `transactionsRoot`：`DATA`，32 字节 - 区块交易树的根。
+- `stateRoot`：`DATA`，32 字节 - 区块最终状态树的根。
+- `receiptsRoot`：`DATA`，32 字节 - 区块收据树的根。
+- `miner`：`DATA`，20 字节 - 获得区块奖励的受益人的地址。
+- `difficulty`：`QUANTITY` - 此区块难度的整数。
+- `totalDifficulty`：`QUANTITY` - 截至此区块的链总难度的整数。
+- `extraData`：`DATA` - 此区块的“额外数据”字段。
+- `size`：`QUANTITY` - 此区块大小的整数，以字节为单位。
+- `gasLimit`：`QUANTITY` - 此区块允许的最大燃料数量。
+- `gasUsed`：`QUANTITY` - 此区块中所有交易使用的总燃料数量。
+- `timestamp`：`QUANTITY` - 整理区块时的 unix 时间戳。
+- `transactions`：`数组` - 交易对象数组或 32 字节交易哈希，具体取决于最后一个给定参数。
+- `uncles`：`数组` - 叔块哈希数组。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],"id":1}'
-// Result
-{
+// 结果
{
-"jsonrpc": "2.0",
-"id": 1,
-"result": {
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
"difficulty": "0x4ea3f27bc",
"extraData": "0x476574682f4c5649562f76312e302e302f6c696e75782f676f312e342e32",
"gasLimit": "0x1388",
@@ -1120,7 +1196,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"uncles": [
]
-}
+ }
}
```
@@ -1128,10 +1204,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0
根据区块编号返回关于区块的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `QUANTITY|TAG` - 整数区块号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
-2. `Boolean` - 如果为 `true` 则返回完整的交易对象，如果为 `false` 则仅返回交易的哈希。
+1. `QUANTITY|TAG` - 整数区块编号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)。
+2. `布尔值` - 如果为 `true`，则返回完整的交易对象；如果为 `false`，则仅返回交易的哈希。
```js
params: [
@@ -1140,24 +1220,29 @@ params: [
]
```
-**返回值** 参见 [eth_getBlockByHash](#eth_getblockbyhash)
+**返回值**
+请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x1b4", true],"id":1}'
```
-结果参见 [eth_getBlockByHash](#eth_getblockbyhash)
+结果请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
### eth_getTransactionByHash {#eth_gettransactionbyhash}
根据交易哈希返回关于所请求交易的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `DATA`，32 字节- 交易的哈希
+1. `DATA`，32 字节 - 交易的哈希
```js
params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"]
@@ -1165,29 +1250,29 @@ params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"]
**返回值**
-`Object` - 交易对象，或者如果没有找到交易，则为 `null`：
-
-- `blockHash`: `DATA`，32 字节 - 此交易所在区块的哈希。 如果是待处理区块，则为 `null`。
-- `blockNumber`: `QUANTITY` - 此交易所在区块的区块编号。 如果是待处理区块，则为 `null`。
-- `from`: `DATA`，20 字节 - 发送者的地址。
-- `gas`: `QUANTITY` - 发送者提供的燃料。
-- `gasPrice`: `QUANTITY` - 发送者提供的燃料价格，以 Wei 为单位。
-- `hash`: `DATA`，32 字节 - 交易的哈希。
-- `input`: `DATA` - 与交易一起发送的数据。
-- `nonce`: `QUANTITY` - 发送者在此交易之前进行的交易数量。
-- `to`: `DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 `null`。
-- `transactionIndex`: `QUANTITY` - 表示区块中的交易索引位置的整数。 如果是待处理区块，则为 `null`。
-- `value`: `QUANTITY` - 传输的值，以 Wei 为单位。
-- `v`: `QUANTITY` - 椭圆曲线加密法恢复 ID
-- `r`: `QUANTITY` - 椭圆曲线加密法签名 r
-- `s`: `QUANTITY` - 椭圆曲线加密法签名 s
+`对象` - 交易对象；如果未找到交易，则为 `null`：
+
+- `blockHash`：`DATA`，32 字节 - 此交易所在区块的哈希。 如果交易待处理，则为 `null`。
+- `blockNumber`：`QUANTITY` - 此交易所在区块的区块编号。 如果交易待处理，则为 `null`。
+- `from`：`DATA`，20 字节 - 发送者的地址。
+- `gas`：`QUANTITY` - 发送者提供的燃料。
+- `gasPrice`：`QUANTITY` - 发送者提供的燃料价格，以 Wei 为单位。
+- `hash`：`DATA`，32 字节 - 交易的哈希。
+- `input`：`DATA` - 随交易发送的数据。
+- `nonce`：`QUANTITY` - 发送者在此交易之前进行的交易数量。
+- `to`：`DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 null。
+- `transactionIndex`：`QUANTITY` - 区块中交易索引位置的整数。 如果交易待处理，则为 `null`。
+- `value`：`QUANTITY` - 以 Wei 为单位的转账价值。
+- `v`：`QUANTITY` - ECDSA 恢复 ID
+- `r`：`QUANTITY` - ECDSA 签名 r
+- `s`：`QUANTITY` - ECDSA 签名 s
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"],"id":1}'
-// Result
+// 结果
{
"jsonrpc":"2.0",
"id":1,
@@ -1214,10 +1299,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","param
根据区块哈希和交易索引位置返回关于交易的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，32 字节 - 区块的哈希。
-2. `QUANTITY` - 表示交易索引位置的整数。
+2. `QUANTITY` - 交易索引位置的整数。
```js
params: [
@@ -1226,7 +1315,8 @@ params: [
]
```
-**返回值** 参见 [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**返回值**
+请参阅 [eth_getTransactionByHash](#eth_gettransactionbyhash)
**示例**
@@ -1235,15 +1325,19 @@ params: [
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockHashAndIndex","params":["0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2", "0x0"],"id":1}'
```
-结果参见 [eth_getTransactionByHash](#eth_gettransactionbyhash)
+结果请参阅 [eth_getTransactionByHash](#eth_gettransactionbyhash)
### eth_getTransactionByBlockNumberAndIndex {#eth_gettransactionbyblocknumberandindex}
根据区块编号和交易索引位置返回关于交易的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `QUANTITY|TAG` - 整数区块号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITY|TAG` - 区块编号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)。
2. `QUANTITY` - 交易索引位置。
```js
@@ -1253,51 +1347,53 @@ params: [
]
```
-**返回值** 参见 [eth_getTransactionByHash](#eth_gettransactionbyhash)
+**返回值**
+请参阅 [eth_getTransactionByHash](#eth_gettransactionbyhash)
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockNumberAndIndex","params":["0x9c47cf", "0x24"],"id":1}'
```
-结果参见 [eth_getTransactionByHash](#eth_gettransactionbyhash)
+结果请参阅 [eth_getTransactionByHash](#eth_gettransactionbyhash)
### eth_getTransactionReceipt {#eth_gettransactionreceipt}
根据交易哈希返回交易的收据。
-**注意**：收据不可用于待处理的交易。
+**注意**待处理的交易没有收据。
**参数**
-1. `DATA`，32 字节- 交易的哈希
+1. `DATA`，32 字节 - 交易的哈希
```js
params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"]
```
-**返回值** `Object` - 交易收据对象，或者如果没有找到收据，则为 `null`：
-
-- `transactionHash`: `DATA`，32 字节- 交易的哈希。
-- `transactionIndex`: `QUANTITY` - 表示区块中的交易索引位置的整数。
-- `blockHash`: `DATA`，32 字节 - 此交易所在区块的哈希。
-- `blockNumber`: `QUANTITY` - 此交易所在区块的区块编号。
-- `from`: `DATA`，20 字节 - 发送者的地址。
-- `to`: `DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 null。
-- `cumulativeGasUsed` : `QUANTITY` - 当在区块中执行此交易时使用的燃料总量。
-- `effectiveGasPrice` : `QUANTITY` - 为每单位燃料支付的基础费和小费的总和。
-- `gasUsed`: `QUANTITY` - 仅此特定交易使用的燃料数量。
-- `contractAddress`: `DATA`，20 字节 - 如果交易是创建合约的，则为创建的合约地址，否则为 `null`。
-- `logs`: `Array` - 此交易生成的日志对象数组。
-- `logsBloom`: `DATA`，256 字节 - 轻客户端用于快速检索相关日志的布隆过滤器。
-- `type`: `QUANTITY` - 表示交易类型的整数，`0x0` 表示传统交易，`0x1` 表示访问列表类型，`0x2` 表示动态费用。
-
-它还返回_以下两者之一_：
-
-- `root` : `DATA`，32 字节的交易后状态根（拜占庭升级之前）
-- `status`: `QUANTITY`，`1`（成功）或 `0`（失败）
+**返回值**
+`对象` - 交易收据对象；如果未找到收据，则为 `null`：
+
+- `transactionHash `：`DATA`，32 字节 - 交易的哈希。
+- `transactionIndex`：`QUANTITY` - 区块中交易索引位置的整数。
+- `blockHash`：`DATA`，32 字节 - 此交易所在区块的哈希。
+- `blockNumber`：`QUANTITY` - 此交易所在区块的区块编号。
+- `from`：`DATA`，20 字节 - 发送者的地址。
+- `to`：`DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 null。
+- `cumulativeGasUsed` : `QUANTITY ` - 在区块中执行此交易时使用的燃料总量。
+- `effectiveGasPrice`：`QUANTITY` - 为每单位燃料支付的基础费和小费的总和。
+- `gasUsed `：`QUANTITY ` - 仅此特定交易使用的燃料数量。
+- `contractAddress `：`DATA`，20 字节 - 如果交易是创建合约的，则为创建的合约地址，否则为 `null`。
+- `logs`：`数组` - 此交易生成的日志对象数组。
+- `logsBloom`：`DATA`，256 字节 - 布隆过滤器，供轻客户端快速检索相关日志。
+- `type`：`QUANTITY` - 交易类型的整数，`0x0` 表示传统交易，`0x1` 表示访问列表类型，`0x2` 表示动态费用。
+
+它还返回以下任一者：
+
+- `root` : `DATA` 32 字节的交易后状态根（拜占庭之前）
+- `status`：`QUANTITY`，`1`（成功）或 `0`（失败）
**示例**
@@ -1335,6 +1431,10 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","para
根据哈希和叔块索引位置返回关于区块的叔块的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
1. `DATA`，32 字节 - 区块的哈希。
@@ -1347,7 +1447,8 @@ params: [
]
```
-**返回值** 参见 [eth_getBlockByHash](#eth_getblockbyhash)
+**返回值**
+请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
**示例**
@@ -1356,7 +1457,7 @@ params: [
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex","params":["0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2", "0x0"],"id":1}'
```
-结果参见 [eth_getBlockByHash](#eth_getblockbyhash)
+结果请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
**注意**：叔块不包含个人交易。
@@ -1364,9 +1465,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex"
根据编号和叔块索引位置返回关于区块的叔块的信息。
+
+ 在 playground 中尝试端点
+
+
**参数**
-1. `QUANTITY|TAG` - 整数区块号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"` 或 `"finalized"`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block)
+1. `QUANTITY|TAG` - 区块编号，或字符串 `"earliest"`、`"latest"`、`"pending"`、`"safe"`、`"finalized"`，请参阅[区块参数](/developers/docs/apis/json-rpc/#block-parameter)。
2. `QUANTITY` - 叔块的索引位置。
```js
@@ -1376,38 +1481,41 @@ params: [
]
```
-**返回值** 参见 [eth_getBlockByHash](#eth_getblockbyhash)
+**返回值**
+请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
**注意**：叔块不包含个人交易。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockNumberAndIndex","params":["0x29c", "0x0"],"id":1}'
```
-结果参见 [eth_getBlockByHash](#eth_getblockbyhash)
+结果请参阅 [eth_getBlockByHash](#eth_getblockbyhash)
### eth_newFilter {#eth_newfilter}
-基于筛选器选项创建一个筛选器对象，以在状态更改（日志）时发出通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
+基于筛选器选项创建一个筛选器对象，以在状态更改（日志）时发出通知。
+要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
-**关于指定主题筛选器的说明：** 主题是顺序相关的。 以下主题过滤器将匹配日志中包含主题 [A, B] 的交易：
+**关于指定主题筛选器的说明：**
+主题是顺序相关的。 以下主题过滤器将匹配日志中包含主题 [A, B] 的交易：
- `[]`“任意值”
- `[A]`“第一个位置为 A（之后的位置为任意值）”
- `[null, B]`“第一个位置为任意值，且第二个位置为 B（之后的位置为任意值）”
- `[A, B]`“第一个位置为 A，且第二个位置为 B（之后的位置为任意值）”
-- `[[A, B], [A, B]]`“第一个位置为（A OR B），且第二个位置为（A OR B）（之后的位置为任意值）”
+- `[[A, B], [A, B]]`“第一个位置为（A 或 B），且第二个位置为（A 或 B）（之后的位置为任意值）”
- **参数**
-1. `Object` - 筛选器选项：
+1. `对象` - 筛选器选项：
-- `fromBlock`: `QUANTITY|TAG` -（可选，默认值：`"latest"`）整型区块编号，或者`"latest"`表示最近提议的区块，`"safe"`表示最新的安全区块，`"finalized"`表示最近最终化的区块，或者`"pending"`、`"earliest"`表示尚未在区块中的交易。
-- `toBlock`: `QUANTITY|TAG` - (可选，默认值：`"latest"`）整型区块编号，或者`"latest"`表示最近提议的区块，`"safe"`表示最新的安全区块，`"finalized"`表示最近最终化的区块，或者`"pending"`、`"earliest"`表示尚未在区块中的交易。
-- `address`: `DATA|Array`，20 字节 -（可选）日志起源的合约地址或地址列表。
-- `topics`: `Array of DATA` -（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“或”选项的 DATA 数组。
+- `fromBlock`：`QUANTITY|TAG` - （可选，默认：`"latest"`）整数区块编号，或 `"latest"` 表示最新提议的区块，`"safe"` 表示最新的安全区块，`"finalized"` 表示最新最终确定的区块，或 `"pending"`、`"earliest"` 表示尚未进入区块的交易。
+- `toBlock`：`QUANTITY|TAG` - （可选，默认：`"latest"`）整数区块编号，或 `"latest"` 表示最新提议的区块，`"safe"` 表示最新的安全区块，`"finalized"` 表示最新最终确定的区块，或 `"pending"`、`"earliest"` 表示尚未进入区块的交易。
+- `address`：`DATA|数组`，20 字节 -（可选）日志起源的合约地址或地址列表。
+- `topics`：`DATA 数组`，-（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“or”选项的 DATA 数组。
```js
params: [
@@ -1427,14 +1535,15 @@ params: [
]
```
-**返回值** `QUANTITY` - 筛选器 ID。
+**返回值**
+`QUANTITY` - 筛选器 ID。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topics":["0x12341234"]}],"id":73}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1444,18 +1553,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topic
### eth_newBlockFilter {#eth_newblockfilter}
-在节点中创建一个筛选器，以在新区块到达时发出通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
+在节点中创建一个筛选器，以在新区块到达时发出通知。
+要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
-**参数** 无
+**参数**
+无
-**返回值** `QUANTITY` - 筛选器 ID。
+**返回值**
+`QUANTITY` - 筛选器 ID。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],"id":73}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1465,18 +1577,21 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],
### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter}
-在节点中创建一个筛选器，以在新的待处理交易到达时发出通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
+在节点中创建一个筛选器，以在新的待处理交易到达时发出通知。
+要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。
-**参数** 无
+**参数**
+无
-**返回值** `QUANTITY` - 筛选器 ID。
+**返回值**
+`QUANTITY` - 筛选器 ID。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter","params":[],"id":73}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1486,7 +1601,8 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter"
### eth_uninstallFilter {#eth_uninstallfilter}
-卸载具有给定 ID 的筛选器。 当不再需要监控时应始终调用该方法。 此外，在一段时间内未使用 [eth_getFilterChanges](#eth_getfilterchanges) 请求筛选器时，筛选器便会超时。
+卸载具有给定 ID 的筛选器。 当不再需要监控时应始终调用该方法。
+此外，在一段时间内未使用 [eth_getFilterChanges](#eth_getfilterchanges) 请求筛选器时，筛选器便会超时。
**参数**
@@ -1498,14 +1614,15 @@ params: [
]
```
-**返回值** `Boolean` - 如果成功卸载筛选器，则为 `true`，否则为 `false`。
+**返回值**
+`布尔值` - 如果成功卸载筛选器，则为 `true`，否则为 `false`。
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_uninstallFilter","params":["0xb"],"id":73}'
-// Result
+// 结果
{
"id":1,
"jsonrpc": "2.0",
@@ -1527,26 +1644,30 @@ params: [
]
```
-**返回值** `Array` - 日志对象数组，或者如果自上次轮询以来没有任何更改，则为空数组。
+**返回值**
+`数组` - 日志对象数组；如果自上次轮询以来没有任何更改，则为空数组。
- 对于使用 `eth_newBlockFilter` 创建的过滤器，返回值是区块哈希（`DATA`，32 字节），例如 `["0x3454645634534..."]`。
+
- 对于使用 `eth_newPendingTransactionFilter` 创建的筛选器，返回值是交易哈希（`DATA`，32 字节），例如 `["0x6345343454645..."]`。
+
- 对于使用 `eth_newFilter` 创建的过滤器，日志是具有以下参数的对象：
- - `removed`: `TAG` - 当日志由于链重组被删除时，为 `true`。 如果是有效日志，则为 `false`。
- - `logIndex`: `QUANTITY` - 表示区块中的日志索引位置的整数。 如果是待处理日志，则为 `null`。
- - `transactionIndex`: `QUANTITY` -表示从中创建日志的交易索引位置的整数。 如果是待处理日志，则为 `null`。
- - `transactionHash`: `DATA`，32 字节 - 从中创建此日志的交易的哈希。 如果是待处理日志，则为 `null`。
- - `blockHash`: `DATA`，32 字节 - 此日志所在区块的哈希。 如果是待处理区块，则为 `null`。 如果是待处理日志，则为 `null`。
- - `blockNumber`: `QUANTITY` - 此日志所在区块的区块编号。 如果是待处理区块，则为 `null`。 如果是待处理日志，则为 `null`。
- - `address`: `DATA`，20 字节 - 此日志的来源地址。
- - `data`: `DATA` - 包含日志的零个或多个 32 字节非索引参数。
- - `topics`: `Array of DATA` - 0 到 4 个 32 字节 `DATA` 类型的索引日志参数的数组。 （在 _Solidity_ 中：第一个主题是事件签名的_哈希_（例如 `Deposit(address,bytes32,uint256)`），除非你使用 `anonymous` 说明符声明了该事件。）
+ - `removed`：`TAG` - 如果日志因链重组而被删除，则为 `true`。 如果是有效日志，则为 `false`。
+ - `logIndex`：`QUANTITY` - 区块中日志索引位置的整数。 如果是待处理日志，则为 `null`。
+ - `transactionIndex`：`QUANTITY` - 创建日志的交易索引位置的整数。 如果是待处理日志，则为 `null`。
+ - `transactionHash`：`DATA`，32 字节 - 创建此日志的交易的哈希。 如果是待处理日志，则为 `null`。
+ - `blockHash`：`DATA`，32 字节 - 此日志所在区块的哈希。 如果交易待处理，则为 `null`。 如果是待处理日志，则为 `null`。
+ - `blockNumber`：`QUANTITY` - 此日志所在区块的区块编号。 如果交易待处理，则为 `null`。 如果是待处理日志，则为 `null`。
+ - `address`：`DATA`，20 字节 - 此日志的来源地址。
+ - `data`：`DATA` - 可变长度的非索引日志数据。 （在 _solidity_ 中：零个或多个 32 字节的非索引日志参数。）
+ - `topics`：`DATA 数组` - 0 到 4 个 32 字节 `DATA` 类型的索引日志参数的数组。 （在 _solidity_ 中：第一个主题是事件签名的_哈希_（例如 `Deposit(address,bytes32,uint256)`），除非你使用 `anonymous` 说明符声明了该事件。）
+
- **示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":["0x16"],"id":73}'
-// Result
+// 结果
{
"id":1,
"jsonrpc":"2.0",
@@ -1579,16 +1700,17 @@ params: [
]
```
-**返回值** 参见 [eth_getFilterChanges](#eth_getfilterchanges)
+**返回值**
+请参阅 [eth_getFilterChanges](#eth_getfilterchanges)
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x16"],"id":74}'
```
-结果参见 [eth_getFilterChanges](#eth_getfilterchanges)
+结果请参阅 [eth_getFilterChanges](#eth_getfilterchanges)
### eth_getLogs {#eth_getlogs}
@@ -1596,13 +1718,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x
**参数**
-1. `Object` - 筛选器选项：
+1. `对象` - 筛选器选项：
-- `fromBlock`: `QUANTITY|TAG` -（可选，默认值：`"latest"`）整型区块编号，或者`"latest"`表示最近提议的区块，`"safe"`表示最新的安全区块，`"finalized"`表示最近最终化的区块，或者`"pending"`、`"earliest"`表示尚未在区块中的交易。
-- `toBlock`: `QUANTITY|TAG` - (可选，默认值：`"latest"`）整型区块编号，或者`"latest"`表示最近提议的区块，`"safe"`表示最新的安全区块，`"finalized"`表示最近最终化的区块，或者`"pending"`、`"earliest"`表示尚未在区块中的交易。
-- `address`: `DATA|Array`，20 字节 -（可选）日志起源的合约地址或地址列表。
-- `topics`: `Array of DATA` -（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“或”选项的 DATA 数组。
-- `blockhash`: `DATA`，32 字节 -（可选，**future**），添加 EIP-234 后，`blockHash` 将是一个新的过滤器选项，它会将返回的日志限制为具有 32 字节哈希 `blockHash` 的单一区块。 使用 `blockHash` 相当于 `fromBlock` = `toBlock` = 具有哈希 `blockHash` 的区块编号。 如果 `blockHash` 出现在筛选条件中，则 `fromBlock` 和 `toBlock` 都不允许。
+- `fromBlock`：`QUANTITY|TAG` - （可选，默认：`"latest"`）整数区块编号，或 `"latest"` 表示最新提议的区块，`"safe"` 表示最新的安全区块，`"finalized"` 表示最新最终确定的区块，或 `"pending"`、`"earliest"` 表示尚未进入区块的交易。
+- `toBlock`：`QUANTITY|TAG` - （可选，默认：`"latest"`）整数区块编号，或 `"latest"` 表示最新提议的区块，`"safe"` 表示最新的安全区块，`"finalized"` 表示最新最终确定的区块，或 `"pending"`、`"earliest"` 表示尚未进入区块的交易。
+- `address`：`DATA|数组`，20 字节 -（可选）日志起源的合约地址或地址列表。
+- `topics`：`DATA 数组`，-（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“or”选项的 DATA 数组。
+- `blockHash`：`DATA`，32 字节 -（可选，**未来**）添加 EIP-234 后，`blockHash` 将是一个新的过滤器选项，它会将返回的日志限制为具有 32 字节哈希 `blockHash` 的单一区块。 使用 `blockHash` 相当于 `fromBlock` = `toBlock` = 哈希为 `blockHash` 的区块编号。 如果 `blockHash` 出现在筛选条件中，则 `fromBlock` 和 `toBlock` 都不允许使用。
```js
params: [
@@ -1614,24 +1736,25 @@ params: [
]
```
-**返回值** 参见 [eth_getFilterChanges](#eth_getfilterchanges)
+**返回值**
+请参阅 [eth_getFilterChanges](#eth_getfilterchanges)
**示例**
```js
-// Request
+// 请求
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}'
```
-结果参见 [eth_getFilterChanges](#eth_getfilterchanges)
+结果请参阅 [eth_getFilterChanges](#eth_getfilterchanges)
-## 使用示例 {#usage-example}
+## 用法示例 {#usage-example}
### 使用 JSON_RPC 部署合约 {#deploying-contract}
-本节演示如何仅使用远程过程调用接口部署合约。 一些其他部署合约的途径可以消除这种复杂性 — 例如，使用在远程过程调用接口之上构建的库，如 [web3.js](https://web3js.readthedocs.io/) 和 [web3.py](https://github.com/ethereum/web3.py)。 这些简化通常更容易理解且不易出错，但了解幕后发生的操作仍然很有帮助。
+本节演示如何仅使用远程过程调用接口部署合约。 部署合约还有其他途径，可以省去这些复杂的步骤，例如使用构建在 RPC 接口之上的程序库，如 [web3.js](https://web3js.readthedocs.io/) 和 [web3.py](https://github.com/ethereum/web3.py)。 这些简化通常更容易理解且不易出错，但了解幕后发生的操作仍然很有帮助。
-以下是一个名为 `Multiply7` 的简单智能合约，将使用 JSON-RPC 接口将其部署到以太坊节点。 本教程假设读者已经在运行 Geth 节点。 [此处](/developers/docs/nodes-and-clients/run-a-node)提供了更多关于节点和客户端的信息。 请参阅单独的[客户端](/developers/docs/nodes-and-clients/)文档，了解如何为非 Geth 客户端启动超文本传输协议 JSON-RPC。 大多数客户端默认在 `localhost:8545` 上提供服务。
+以下是一个名为 `Multiply7` 的简单智能合约，将使用 JSON-RPC 接口将其部署到以太坊节点。 本教程假设读者已经在运行 Geth 节点。 更多关于节点和客户端的信息请见[此处](/developers/docs/nodes-and-clients/run-a-node)。 请参阅各个[客户端](/developers/docs/nodes-and-clients/)文档，了解如何为非 Geth 客户端启动 HTTP JSON-RPC。 大多数客户端默认在 `localhost:8545` 上提供服务。
```javascript
contract Multiply7 {
@@ -1649,12 +1772,12 @@ contract Multiply7 {
geth --http --dev console 2>>geth.log
```
-这将在 `http://localhost:8545` 上启动超文本传输协议远程过程调用接口。
+这将在 `http://localhost:8545` 上启动 HTTP RPC 接口。
-我们可以使用 [curl](https://curl.se) 检索 coinbase 地址（获取帐户数组的第一个地址）和余额来验证接口是否正常运行。 请注意，这些示例中的数据在你的本地节点上会有所不同。 如果你想尝试这些命令，请将第二个 curl 请求中的请求参数替换为第一个 curl 请求返回的结果。
+我们可以使用 [curl](https://curl.se) 检索 coinbase 地址（通过获取帐户数组的第一个地址）和余额来验证接口是否正在运行。 请注意，这些示例中的数据在你的本地节点上会有所不同。 如果你想尝试这些命令，请将第二个 curl 请求中的请求参数替换为第一个 curl 请求返回的结果。
```bash
-curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[]", "id":1}' -H "Content-Type: application/json" localhost:8545
+curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[], "id":1}' -H "Content-Type: application/json" localhost:8545
{"id":1,"jsonrpc":"2.0","result":["0x9b1d35635cc34752ca54713bb99d38614f63c955"]}
curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635cc34752ca54713bb99d38614f63c955", "latest"], "id":2}' -H "Content-Type: application/json" localhost:8545
@@ -1668,9 +1791,9 @@ web3.fromWei("0x1639e49bba16280000", "ether")
// "410"
```
-现在我们的私有开发链上有一些以太币，我们可以部署合约了。 第一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。 要安装 Solidity 编译器 solc，请遵循 [Solidity 文档](https://docs.soliditylang.org/en/latest/installing-solidity.html)。 （你可能希望使用较旧的 `solc` 版本来匹配[我们的示例中使用的编译器版本](https://github.com/ethereum/solidity/releases/tag/v0.4.20)。）
+现在我们的私有开发链上有一些以太币，我们可以部署合约了。 第一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。 要安装 Solidity 编译器 solc，请遵照 [Solidity 文档](https://docs.soliditylang.org/en/latest/installing-solidity.html)。 （你可能希望使用较旧的 `solc` 版本来匹配[我们示例中使用的编译器版本](https://github.com/ethereum/solidity/releases/tag/v0.4.20)。）
-下一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。
+下一步是将 Multiply7 合约编译成可以发送给以太坊虚拟机的字节码。
```bash
echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin
@@ -1680,7 +1803,7 @@ Binary:
6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029
```
-现在我们有了编译后的代码，我们需要确定部署它需要花费多少燃料。 远程过程调用接口有一个 `eth_estimateGas` 方法，可以给我们一个估算值。
+现在我们有了编译后的代码，我们需要确定部署它需要花费多少燃料。 RPC 接口有一个 `eth_estimateGas` 方法，可以给我们一个估算值。
```bash
curl --data '{"jsonrpc":"2.0","method": "eth_estimateGas", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 5}' -H "Content-Type: application/json" localhost:8545
@@ -1694,7 +1817,8 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from
{"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"}
```
-交易被节点接受并返回交易哈希。 此哈希可用于跟踪交易。 下一步是确定我们的合约部署到的地址。 每个已执行的交易都将创建一个收据。 此收据包含有关交易的各种信息，例如交易包含在哪个区块中以及以太坊虚拟机使用了多少燃料。 如果交易 创建了合约，它还将包含合约地址。 我们可以使用远程过程调用方法 `eth_getTransactionReceipt` 检索收据。
+交易被节点接受并返回交易哈希。 此哈希可用于跟踪交易。 下一步是确定我们的合约部署到的地址。 每个已执行的交易都将创建一个收据。 此收据包含有关交易的各种信息，例如交易包含在哪个区块中以及以太坊虚拟机使用了多少燃料。 如果交易
+创建了合约，它还将包含合约地址。 我们可以使用 `eth_getTransactionReceipt` RPC 方法检索收据。
```bash
curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545
@@ -1707,7 +1831,7 @@ curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": [
在本示例中，我们将使用 `eth_sendTransaction` 将交易发送到合约的 `multiply` 方法。
-`eth_sendTransaction` 需要几个参数，具体而言，`from`、`to` 和 `data`。 `From` 是我们帐户的公共地址，`to` 是合约地址。 `data` 参数包含有效载荷，它定义了必须调用哪个方法以及使用哪些参数。 这就是 [ABI（应用程序二进制接口）](https://docs.soliditylang.org/en/latest/abi-spec.html)的用武之地。 应用程序二进制接口是一个 JSON 文件，它定义了如何为以太坊虚拟机定义和编码数据。
+`eth_sendTransaction` 需要几个参数，具体而言，`from`、`to` 和 `data`。 `From` 是我们帐户的公共地址，`to` 是合约地址。 `data` 参数包含有效载荷，它定义了必须调用哪个方法以及使用哪些参数。 这就是 [ABI（应用程序二进制接口）](https://docs.soliditylang.org/en/latest/abi-spec.html)发挥作用的地方。 应用程序二进制接口是一个 JSON 文件，它定义了如何为以太坊虚拟机定义和编码数据。
有效载荷的字节定义了调用合约中的哪个方法。 这是函数名称及其参数类型的 Keccak 哈希的前 4 个字节（十六进制编码）。 Multiply 函数接受 uint，它是 uint256 的别名。 这为我们提供了：
@@ -1718,7 +1842,7 @@ web3.sha3("multiply(uint256)").substring(0, 10)
下一步是对参数进行编码。 只有一个 uint256，比如值 6。 应用程序二进制接口有一个部分指定了如何编码 uint256 类型。
-`int: enc(X)` 是 X 的大端序二进制补码编码，对于负 X 在高位（左侧）填充 0xff，对于正 X 填充零 > 字节，使得长度为 32 字节的倍数。
+`int: enc(X)` 是 X 的大端序二进制补码编码，对于负 X 在高位（左侧）填充 0xff，对于正 X 填充零字节，使得长度为 32 字节的倍数。
此编码为 `0000000000000000000000000000000000000000000000000000000000000006`。
@@ -1755,7 +1879,7 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from
}
```
-收据中包含一个日志。 此日志由以太坊虚拟机在交易执行时生成并包含在收据中。 `multiply` 函数显示 `Print` 事件在输入乘以 7 时触发。 由于 `Print` 事件的参数是 uint256，我们可以根据应用程序二进制接口规则对其进行解码，这将为我们提供预期的十进制数 42。 除了数据之外，值得注意的是，主题可用于确定哪个事件创建了日志：
+收据中包含一个日志。 此日志由以太坊虚拟机在交易执行时生成并包含在收据中。 `multiply` 函数显示 `Print` 事件在输入乘以 7 时触发。 由于 `Print` 事件的参数是 uint256，我们可以根据 ABI 规则对其进行解码，这将为我们提供预期的十进制数 42。 除了数据之外，值得注意的是，主题可用于确定哪个事件创建了日志：
```javascript
web3.sha3("Print(uint256)")
@@ -1764,10 +1888,10 @@ web3.sha3("Print(uint256)")
以上只是对一些最常见任务的简要介绍，展示了 JSON-RPC 的直接用法。
-## 相关主题 {#related-topics}
+## 相关话题 {#related-topics}
- [JSON-RPC 规范](http://www.jsonrpc.org/specification)
- [节点和客户端](/developers/docs/nodes-and-clients/)
- [JavaScript API](/developers/docs/apis/javascript/)
-- [后端应用程序接口](/developers/docs/apis/backend/)
+- [后端 API](/developers/docs/apis/backend/)
- [执行客户端](/developers/docs/nodes-and-clients/#execution-clients)
diff --git a/public/content/translations/zh/developers/docs/blocks/index.md b/public/content/translations/zh/developers/docs/blocks/index.md
index cb59f2c7d6f..977d27be294 100644
--- a/public/content/translations/zh/developers/docs/blocks/index.md
+++ b/public/content/translations/zh/developers/docs/blocks/index.md
@@ -1,6 +1,6 @@
---
-title: 区块
-description: 以太坊区块链中区块的概述 – 其数据结构、存在的意义以及区块如何生成
+title: "区块"
+description: "以太坊区块链中区块的概述 – 其数据结构、存在的意义以及区块如何生成"
lang: zh
---
@@ -8,55 +8,55 @@ lang: zh
## 前提条件 {#prerequisites}
-区块是一个对初学者非常友好的主题。 为了帮助你更好地理解这个页面，我们建议你先阅读[帐户](/developers/docs/accounts/)、[交易](/developers/docs/transactions/)和我们的[以太坊简介](/developers/docs/intro-to-ethereum/)。
+区块是一个对初学者非常友好的主题。 为了更好地理解本页内容，我们建议您先阅读[帐户](/developers/docs/accounts/)、[交易](/developers/docs/transactions/)以及我们的[以太坊简介](/developers/docs/intro-to-ethereum/)。
## 为什么要有区块？ {#why-blocks}
为了确保以太坊网络上的所有参与者保持同步状态并就交易的确切历史达成共识，我们将交易分为多个区块。 这意味着同时有数十个（甚至数百个）交易被提交、达成一致并同步。
- _示意图节选自[以太坊虚拟机图解](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+\n_示意图改编自 [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
通过间隔提交，所有网络参与者有足够时间达成共识：即使交易请求每秒发生数十次，但以太坊上的区块仅仅大约每十二秒创建并提交一次。
-## 区块如何工作 {#how-blocks-work}
+## 区块如何运作 {#how-blocks-work}
为了保存交易历史，区块被严格排序（创建的每个新区块都包含一个其父块的引用），区块内的交易也严格排序。 除极少数情况外，在任何特定时间，网络上的所有参与者都同意区块的确切数目和历史， 并且正在努力将当前的活动交易请求分批到下一个区块。
随机选择的验证者在网络上构建完区块后，该区块将传播到整个网络；所有节点都将该区块添加至其区块链的末尾，然后挑选新的验证者来创建下一个区块。 目前，确切的区块构建过程和提交/共识过程由以太坊的“权益证明”协议规定。
-## 权益证明协议 {#proof-of-work-protocol}
+## 权益证明协议 {#proof-of-stake-protocol}
权益证明是指：
- 验证节点必须向存款合约中质押 32 个以太币，作为抵押品防止发生不良行为。 这有助于保护网络，因为如果发生不诚实活动且可以证实，部分甚至全部质押金额将被销毁。
- 在每个时隙（12 秒的时间间隔）中，会随机选择一个验证者作为区块提议者。 他们将交易打包并执行，然后确定一个新的“状态”。 他们将这些信息包装到一个区块中并传送给其他验证者。
-- 其他获悉新区块的验证者再次执行区块中包含的交易，确定他们同意对全局状态提出的修改。 假设该区块是有效的，验证者就将该区块添加进各自的数据库。
+- 其他获悉新区块的验证者会重新执行这些交易，以确保他们同意对全局状态的提议更改。 假设该区块有效，他们就会将其添加到自己的数据库中。
- 如果验证者获悉在同一时隙内有两个冲突区块，他们会使用自己的分叉选择算法选择获得最多质押以太币支持的那一个区块。
-[有关权益证明的更多信息](/developers/docs/consensus-mechanisms/pos)
+[关于权益证明的更多信息](/developers/docs/consensus-mechanisms/pos)
## 区块包含什么？ {#block-anatomy}
一个区块中包含很多信息。 区块的最高层包含以下字段：
-| 字段 | 简介 |
-|:---------------- |:-------------- |
+| 字段 | 描述 |
+| :--------------- | :------------- |
| `时隙` | 区块所属的时隙 |
| `proposer_index` | 提出区块的验证者的 ID |
| `parent_root` | 上一个区块的哈希 |
| `state_root` | 状态对象的根哈希 |
| `正文` | 包含多个字段的对象，定义如下 |
-区块的 `body` 包含一些自有字段：
+区块 `body` 本身包含几个字段：
-| 栏目 | 简介 |
-|:-------------------- |:-------------- |
+| 字段 | 描述 |
+| :------------------- | :------------- |
| `randao_reveal` | 用于选择下一个区块提议者的值 |
| `eth1_data` | 关于存款合约的信息 |
-| `涂鸦` | 用于标记区块的任意数据 |
+| `graffiti` | 用于标记区块的任意数据 |
| `proposer_slashings` | 将要惩罚的验证者列表 |
| `attester_slashings` | 将要受到惩没的证明者列表 |
-| `认证` | 支持当前区块的认证列表 |
+| `认证` | 针对之前时隙所做认证的列表 |
| `存款` | 存款合约新增存款的列表 |
| `voluntary_exits` | 退出网络的验证者列表 |
| `sync_aggregate` | 用于服务轻客户端的验证者子集 |
@@ -64,29 +64,29 @@ lang: zh
`attestations` 字段包含区块中所有认证的列表。 认证有自己的数据类型，其中包含多条数据。 每个认证包含：
-| 栏目 | 简介 |
-|:------------------ |:------------ |
-| `aggregation_bits` | 参与此认证的验证者列表 |
-| `数据` | 具有多个子字段的容器 |
-| `签名` | 所有证明验证者的聚合签名 |
+| 字段 | 描述 |
+| :----------------- | :--------------------- |
+| `aggregation_bits` | 参与此认证的验证者列表 |
+| `数据` | 具有多个子字段的容器 |
+| `签名` | 一组验证者针对 `data` 部分的聚合签名 |
`attestation` 中的 `data` 字段包含以下内容：
-| 栏目 | 简介 |
-|:------------------- |:-------------- |
+| 字段 | 描述 |
+| :------------------ | :------------- |
| `时隙` | 认证所涉及的时隙 |
| `索引` | 证明验证者的索引 |
-| `beacon_block_root` | 包含此对象的信标区块的根哈希 |
+| `beacon_block_root` | 被视为链头的信标区块的根哈希 |
| `来源` | 最后一个合理的检查点 |
| `target` | 最新的时段边界区块 |
-执行 `execution_payload` 中的交易会更新全局状态。 所有客户端重新执行 `execution_payload` 中的交易，以确保新状态与新区块 `state_root` 字段中的状态相符。 这就是客户端如何判断新区块是否有效且可以安全添加到其区块链的方式。 `execution payload` 本身是一个包含多个字段的对象。 还有一个 `execution_payload_header`，包含有关执行数据的重要摘要信息。 这些数据结构如下组织：
+执行 `execution_payload` 中的交易会更新全局状态。 所有客户端都会重新执行 `execution_payload` 中的交易，以确保新状态与新区块 `state_root` 字段中的状态相符。 这就是客户端如何判断新区块是否有效且可以安全添加到其区块链的方式。 `execution payload` 本身是一个包含多个字段的对象。 还有一个 `execution_payload_header`，其中包含关于执行数据的重要摘要信息。 这些数据结构如下组织：
`execution_payload_header` 包含以下字段：
-| 领域 | 简介 |
-|:------------------- |:------------------- |
-| `父_哈希值` | 父块的哈希值 |
+| 字段 | 描述 |
+| :------------------ | :------------------ |
+| `parent_hash` | 父块的哈希值 |
| `fee_recipient` | 向其支付交易费的帐户地址 |
| `state_root` | 应用此区块中的更改后，全局状态的根哈希 |
| `receipts_root` | 交易收据树的哈希 |
@@ -95,39 +95,39 @@ lang: zh
| `block_number` | 当前区块的编号 |
| `gas_limit` | 此区块允许的最大燃料量 |
| `gas_used` | 此区块中使用的实际燃料量 |
-| `时间戳` | 区块时间 |
+| `timestamp` | 区块时间 |
| `extra_data` | 作为原始字节的任意附加数据 |
| `base_fee_per_gas` | 基础费值 |
| `block_hash` | 执行区块的哈希 |
| `transactions_root` | 有效载荷中交易的根哈希 |
| `withdrawal_root` | 有效负载中提款的根哈希 |
-`execution_payload` 本身包含以下字段（请注意这与 header 相同，只是它包含的不是交易的根哈希，而是实际的交易列表和提款信息列表）：
-
-| 栏目 | 简介 |
-|:------------------ |:------------------ |
-| `父_哈希值` | 父块的哈希值 |
-| `fee_recipient` | 支付交易费用的帐户地址 |
-| `state_root` | 应用此区块中的更改后，全局的根哈希值 |
-| `receipts_root` | 交易收据的哈希值 |
-| `logs_bloom` | 包含事件日志的数据结构 |
-| `prev_randao` | 在随机验证者选择中使用的值 |
-| `block_number` | 当前区块的编号 |
-| `gas_limit` | 此区块允许的最大的燃料量 |
-| `gas_used` | 此区块中使用的燃料实际量 |
-| `时间戳` | 区块时间 |
-| `extra_data` | 作为原始字节任意附加数据 |
-| `base_fee_per_gas` | 基本费用值 |
-| `block_hash` | 执行区块的哈希值 |
-| `交易` | 要执行交易的列表 |
-| `提款` | 提款对象列表 |
-
-`Withdrawals` 列表包含了 `withdrawal` 对象，结构如下：
+`execution_payload` 本身包含以下内容（请注意，这与标头相同，只是它不包含交易的根哈希，而是包含实际的交易列表和提款信息列表）：
+
+| 字段 | 描述 |
+| :----------------- | :------------------ |
+| `parent_hash` | 父块的哈希值 |
+| `fee_recipient` | 向其支付交易费的帐户地址 |
+| `state_root` | 应用此区块中的更改后，全局状态的根哈希 |
+| `receipts_root` | 交易收据树的哈希 |
+| `logs_bloom` | 包含事件日志的数据结构 |
+| `prev_randao` | 在随机选择验证者时使用的值 |
+| `block_number` | 当前区块的编号 |
+| `gas_limit` | 此区块允许的最大燃料量 |
+| `gas_used` | 此区块中使用的实际燃料量 |
+| `timestamp` | 区块时间 |
+| `extra_data` | 作为原始字节的任意附加数据 |
+| `base_fee_per_gas` | 基础费值 |
+| `block_hash` | 执行区块的哈希 |
+| `交易` | 要执行交易的列表 |
+| `取款` | 提款对象列表 |
+
+`withdrawals` 列表包含按以下方式结构的 `withdrawal` 对象：
| 字段 | 描述 |
-|:---------------- |:------ |
+| :--------------- | :----- |
| `地址` | 提款帐户地址 |
-| `amount` | 提款金额 |
+| `金额` | 提款金额 |
| `索引` | 提款索引值 |
| `validatorIndex` | 验证者索引值 |
@@ -135,17 +135,17 @@ lang: zh
区块时间是指两个区块之间的时间间隔。 在以太坊中，时间划分为每 12 秒一个单位，称为“时隙”。 在每个时隙内，选择一个单独的验证者提议区块。 假设所有验证者都在线且完全正常运行，则每个时隙内都会有一个区块产生，意味着区块时间是 12 秒。 但是，偶尔验证者在被要求提议区块时不在线，导致有时候一些时隙是空的。
-这种实现与基于工作量证明的系统不同。在工作量证明系统中，区块时间是带有概率性的，并由协议的目标挖矿难度调节。 以太坊的[平均区块时间](https://etherscan.io/chart/blocktime)是一个很好的例子，根据不变的新的 12 秒区块时间，可以清楚地推断出从工作量证明到权益证明的过渡。
+这种实现与基于工作量证明的系统不同。在工作量证明系统中，区块时间是带有概率性的，并由协议的目标挖矿难度调节。 以太坊的[平均区块时间](https://etherscan.io/chart/blocktime)就是一个很好的例子，基于新的 12 秒区块时间的一致性，可以清楚地推断出从工作量证明到权益证明的过渡。
## 区块大小 {#block-size}
-最后一条重要提示是，区块本身的大小是有界限的。 每个区块的目标大小为 3000 万单位燃料，但区块的大小将根据网络需求而增加或减少，直至达到 6000 万单位燃料的区块限制（目标区块大小的 2 倍）。 区块的燃料限制可以相对于上一个区块的燃料限制上调或下调 1/1024 的比例。 因此，验证者可以通过共识来改变区块的燃料限制。 区块中所有交易消耗的总燃料量必须低于区块的燃料限制。 这很重要，因为它可以确保区块不能任意扩大。 如果区块可以任意扩大，由于空间和速度方面的要求，性能较差的全节点将逐渐无法跟上网络。 区块越大，在下一个时隙中及时处理它们需要的算力就越强大。 这是一种集中化的因素，可以通过限制区块大小来抵制。
+最后一条重要提示是，区块本身的大小是有界限的。 每个区块的目标大小为 3000 万单位燃料，但区块的大小会根据网络需求增加或减少，直到达到 6000 万单位燃料的区块限制（目标区块大小的 2 倍）。 区块的燃料限制可以相对于上一个区块的燃料限制上调或下调 1/1024 的比例。 因此，验证者可以通过共识来改变区块的燃料限制。 区块中所有交易消耗的总燃料量必须低于区块的燃料限制。 这很重要，因为它可以确保区块不能任意扩大。 如果区块可以任意扩大，由于空间和速度方面的要求，性能较差的全节点将逐渐无法跟上网络。 区块越大，在下一个时隙中及时处理它们需要的算力就越强大。 这是一种集中化的因素，可以通过限制区块大小来抵制。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
-## 相关主题 {#related-topics}
+## 相关话题 {#related-topics}
- [交易](/developers/docs/transactions/)
- [燃料](/developers/docs/gas/)
diff --git a/public/content/translations/zh/developers/docs/bridges/index.md b/public/content/translations/zh/developers/docs/bridges/index.md
index 2b94f0f5edc..150c59f9d2b 100644
--- a/public/content/translations/zh/developers/docs/bridges/index.md
+++ b/public/content/translations/zh/developers/docs/bridges/index.md
@@ -1,10 +1,10 @@
---
-title: 链桥
-description: 面向开发者的桥接概述
+title: "链桥"
+description: "面向开发者的桥接概述"
lang: zh
---
-随着一层网络区块链和二层网络[扩容](/developers/docs/scaling/)解决方案的激增，以及越来越多的去中心化应用程序跨链，跨链通信和资产转移需求已成为网络基础设施的重要组成部分。 存在不同类型的链桥就是为了帮助解决这种需求。
+随着 L1 区块链和 L2 [扩容](/developers/docs/scaling/)解决方案的激增，以及越来越多的去中心化应用程序走向跨链，跨链通信和资产转移的需求已成为网络基础设施的重要组成部分。 存在不同类型的链桥就是为了帮助解决这种需求。
## 对链桥的需求 {#need-for-bridges}
@@ -12,9 +12,9 @@ lang: zh
区块链存在于孤立的环境中，这意味着区块链之间本来就无法进行交易和通信。 因此，虽然某个生态系统内可能存在大量的活动和创新，但它会由于缺乏与其他生态系统的连通性和互操作性而受到限制。
-链桥提供了一种让孤立的区块链环境相互连通的途径。 它们在区块链之间建立了一条传输路线，让代币、信息、任意数据甚至[智能合约](/developers/docs/smart-contracts/)调用都可以从一条区块链转移到另一条。
+链桥提供了一种让孤立的区块链环境相互连通的途径。 它们在区块链之间建立了一条传输路线，让代币、消息、任意数据，甚至[智能合约](/developers/docs/smart-contracts/)调用都可以从一条链转移到另一条链。
-## 链桥的优点 {#benefits-of-bridges}
+## 链桥的优势 {#benefits-of-bridges}
简而言之，链桥解锁了大量应用场景，它允许区块链网络之间交换数据和转移资产。
@@ -30,63 +30,63 @@ lang: zh
## 链桥是如何工作的？ {#how-do-bridges-work}
-虽然[链桥设计](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/)多种多样，但以下三种方便资产跨链转移的方法脱颖而出：
+虽然有许多[链桥设计类型](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/)，但有三种促进资产跨链转移的方法脱颖而出：
-- **锁定并铸币 – **锁定源链上的资产并在目标链上铸币。
-- **销毁并铸币 – **销毁源链上的资产并在目标链上铸币。
-- **原子交换 – **通过第三方将源链上的资产与目标链上的资产交换。
+- **锁定并铸币 –** 在源链上锁定资产，并在目标链上铸造资产。
+- **销毁并铸币 –** 在源链上销毁资产，并在目标链上铸造资产。
+- **原子交换 –** 与另一方将源链上的资产交换为目标链上的资产。
## 链桥类型 {#bridge-types}
链桥通常可以分为以下几类之一：
-- **原生链桥 –** 这些链桥通常用于加强特定区块链上的流动性，使用户更容易将资金转移到生态系统。 例如，[Arbitrum 链桥](https://bridge.arbitrum.io/)的目的就是为了方便用户从以太坊主网桥接到 Arbitrum。 其他此链类桥包括 Polygon PoS 链桥、[Optimism 网关](https://app.optimism.io/bridge)等。
-- **基于验证者或预言机的链桥 –** 这些链桥依赖于外部验证者组或预言机来验证跨链转移。 例如：Multichain 与 Across。
-- **通用信息传递链桥 – **这些链桥可以跨链传输资产、信息和任意数据。 例如：Axelar、LayerZero 与 Nomad。
-- **流动性网络 –** 这些链桥主要是通过原子交换将资产从一条链转移到另一条链。 一般来讲，它们不支持跨链信息传递。 例如：Connext 与 Hop。
+- **原生链桥 –** 此类链桥通常旨在引导特定区块链上的流动性，方便用户将资金转移到生态系统。 例如，[Arbitrum 链桥](https://bridge.arbitrum.io/)的构建就是为了方便用户从以太坊主网桥接到 Arbitrum。 其他类似的链桥包括 Polygon PoS 链桥、[Optimism Gateway](https://app.optimism.io/bridge) 等。
+- **基于验证者或预言机的链桥 –** 此类链桥依赖于外部验证者集或预言机来验证跨链转账。 例如：Multichain 与 Across。
+- **通用消息传递链桥 –** 此类链桥可以跨链转移资产、消息和任意数据。 例如：Axelar、LayerZero 与 Nomad。
+- **流动性网络 –** 此类链桥主要通过原子交换将资产从一条链转移到另一条链。 一般来讲，它们不支持跨链信息传递。 例如：Connext 与 Hop。
-## 权衡利弊 {#trade-offs}
+## 需要考虑的权衡因素 {#trade-offs}
没有完美的链桥解决方案。 有的只是为了实现目的而进行的权衡利弊。 开发者和用户可以根据以下因素评估链桥：
- **安全性 –** 谁来验证系统？ 通常，由外部验证者保护的链桥不如由区块链验证者在本地保护的链桥安全。
-- **便利性 –** 完成一笔交易需要多长时间，用户需要签署多少笔交易? 对于开发者来说，集成一个链桥需要多长时间，这个过程有多复杂?
-- **连通性 –** 一个链桥可以连接哪些不同的目标链（卷叠、侧链、其他一层网络区块链等），集成一条新区块链有多难?
-- **传递更复杂数据的能力 –** 链桥能够跨链传输信息和更复杂的任意数据，还是只支持跨链资产转移？
+- **便利性 –** 完成一笔交易需要多长时间？用户需要签署多少笔交易？ 对于开发者来说，集成一个链桥需要多长时间，这个过程有多复杂?
+- **连通性 –** 链桥可以连接哪些不同的目标链（即 Rollup、侧链、其他 L1 区块链等）？集成一条新的区块链有多难？
+- **传递更复杂数据的能力 –** 链桥能够实现跨链传递消息和更复杂的任意数据，还是只支持跨链资产转移？
- **成本效益 –** 通过链桥跨链转移资产的成本是多少？ 通常情况下，链桥收取固定或变动的费用，具体取决于燃料成本和特定路线的流动性。 根据确保链桥安全所需的资本来评估链桥的成本效益也是至关重要的。
在较高层面上，链桥可以分为需信任链桥和去信任链桥。
-- **需信任链桥 –** 需信任链桥由外部验证。 它们使用一组外部验证者（具有多重签名的联盟、多方计算系统、预言机网络）跨链发送数据。 因此，它们可以提供出色的连通性，并完全支持跨链通用信息传递。 在速度和成本效益方面它们通常也表现良好。 但这些是以安全性为代价的，因为用户必须依赖链桥的安全性。
-- **去信任 –** 这类链桥依靠它们连接的区块链及其验证者来传输信息和代币。 它们是“去信任”的，因为它们没有增加新的信任假设（区块链除外）。 因此，我们认为去信任链桥比可信链桥更安全。
+- **需信任 –** 需信任链桥由外部验证。 它们使用一组外部验证者（具有多重签名的联盟、多方计算系统、预言机网络）跨链发送数据。 因此，它们可以提供出色的连通性，并完全支持跨链通用信息传递。 在速度和成本效益方面它们通常也表现良好。 但这些是以安全性为代价的，因为用户必须依赖链桥的安全性。
+- **无需信任 –** 此类链桥依赖其连接的区块链及其验证者来转移消息和代币。 它们是“去信任”的，因为它们没有增加新的信任假设（区块链除外）。 因此，我们认为去信任链桥比可信链桥更安全。
为了根据其他因素评估去信任链桥，我们须将其分为通用信息传递链桥和流动性网络。
-- **通用信息传递链桥 –** 这些链桥在安全性和跨链传输更复杂数据的能力方面表现卓越。 通常，它们还具有良好的成本效益。 然而，这些优点通常以轻客户端链桥（例如 IBC）的连通性以及使用欺诈证明的乐观链桥（例如 Nomad）的速度劣势作为代价。
-- **流动性网络 –** 这些链桥使用原子交换转移资产，并且是本地验证系统(即，它们使用底层区块链的验证者验证交易）。 因此，它们在安全性和速度方面表现出色。 此外，流动性网络具有不错的成本效益和良好的连通性。 然而，最大的折衷之处是它们无法传递更复杂的数据 — 因为它们不支持跨链信息传递。
+- **通用消息传递链桥 –** 此类链桥在安全性和跨链传递更复杂数据的能力方面表现出色。 通常，它们还具有良好的成本效益。 然而，这些优点通常以轻客户端链桥（例如 IBC）的连通性以及使用欺诈证明的乐观链桥（例如 Nomad）的速度劣势作为代价。
+- **流动性网络 –** 此类链桥使用原子交换来转移资产，是本地验证的系统（即它们使用底层区块链的验证者来验证交易）。 因此，它们在安全性和速度方面表现出色。 此外，流动性网络具有不错的成本效益和良好的连通性。 然而，最大的折衷之处是它们无法传递更复杂的数据 — 因为它们不支持跨链信息传递。
-## 链桥相关风险 {#risk-with-bridges}
+## 链桥的风险 {#risk-with-bridges}
-去中心化金融领域中[最大的三次黑客攻击](https://rekt.news/leaderboard/)都是链桥造成的，而且链桥目前仍处于开发阶段早期。 使用任何链桥都有以下风险：
+在 [DeFi 领域最大的几起黑客攻击](https://rekt.news/leaderboard/)中，排名前三的都与链桥有关，而且链桥仍处于早期开发阶段。 使用任何链桥都有以下风险：
-- **智能合约风险 –** 虽然许多链桥已经成功通过了审计，但只需智能合约中的一个缺陷就会使资产暴露在黑客攻击中（例如：[Solana 的 Wormhole 链桥](https://rekt.news/wormhole-rekt/)）。
-- **系统性金融风险** – 许多链桥使用包装资产在新的链上铸造规范化的原始资产。 这使生态系统面临系统性风险，正如我们所看到的那样，包装代币遭到利用。
-- **交易对手风险 –** 一些链桥采用可信设计，这要求用户依靠一种假设，即验证者不会串通起来窃取用户的资金。 用户需要信任这些第三方参与者，这使他们面临一些风险，比如跑路、审查和其他恶意活动。
-- **未解决的问题 –** 考虑到链桥处于发展阶段初期，还有许多关于链桥在不同市场条件下如何表现的问题都尚未解决，如网络拥塞期和在发生网络级攻击或状态回滚等不可预见的事件时。 这种不确定性带来了一定的风险，且风险程度目前仍然未知。
+- **智能合约风险 –** 虽然许多链桥已成功通过审计，但智能合约中的一个漏洞就足以让资产面临被黑客攻击的风险（例如：[Solana 的 Wormhole 链桥](https://rekt.news/wormhole-rekt/)）。
+- **系统性金融风险 –** 许多链桥使用封装资产在新的链上铸造原始资产的规范版本。 这使生态系统面临系统性风险，正如我们所看到的那样，包装代币遭到利用。
+- **交易对手风险 –** 一些链桥采用需信任的设计，要求用户依赖“验证者不会合谋窃取用户资金”这一假设。 用户需要信任这些第三方参与者，这使他们面临一些风险，比如跑路、审查和其他恶意活动。
+- **未决问题 –** 鉴于链桥仍处于起步阶段，关于它们在不同市场条件下的表现，仍有许多悬而未决的问题，例如在网络拥堵、网络级攻击或状态回滚等意外事件期间。 这种不确定性带来了一定的风险，且风险程度目前仍然未知。
## 去中心化应用程序如何使用链桥？ {#how-can-dapps-use-bridges}
下面介绍一些实际应用，在这些应用中，开发者可以考虑链桥并让他们的去中心化应用程序跨链：
-### 集成桥接 {#integrating-bridges}
+### 集成链桥 {#integrating-bridges}
对于开发者来说，有很多方法可以添加对链桥的支持：
-1. **构建自己的链桥 –** 构建安全可靠的链桥并不容易，特别是在选择一种进一步将信任最小化的方式时。 此外，还需要与可伸缩性和互操作性研究相关的多年经验和技术专长。 另外，还需要一支亲力亲为的团队来维护链桥，并吸引足够的流动性使其可行。
+1. **构建自己的链桥 –** 构建安全可靠的链桥并非易事，尤其是在采用更加信任最小化的路线时。 此外，还需要与可伸缩性和互操作性研究相关的多年经验和技术专长。 另外，还需要一支亲力亲为的团队来维护链桥，并吸引足够的流动性使其可行。
-2. **向用户展示多种链桥选项 –** 很多[去中心化应用程序](/developers/docs/dapps/)要求用户拥有原生代币才可与它们交互。 为了使用户能够访问他们的代币，去中心化应用程序在其网站上提供了不同的链桥选项。 然而，这种方法是权宜之计，因为它使用户离开去中心化应用程序界面但仍需要用户与其他去中心化应用程序和链桥交互。 这是一种繁琐的上手体验，会增加出错的范围。
+2. **向用户显示多种链桥选项 –** 许多[去中心化应用程序](/developers/docs/dapps/)都要求用户持有其原生代币才能进行交互。 为了使用户能够访问他们的代币，去中心化应用程序在其网站上提供了不同的链桥选项。 然而，这种方法是权宜之计，因为它使用户离开去中心化应用程序界面但仍需要用户与其他去中心化应用程序和链桥交互。 这是一种繁琐的上手体验，会增加出错的范围。
-3. **集成一个链桥 –**该解决方案不需要去中心化应用程序将用户发送到外部链桥和去中心化交易所接口。 这让去中心化应用程序能够改善用户的上手体验。 然而，这种方法有其局限性：
+3. **集成一个链桥 –** 此解决方案不需要去中心化应用程序将用户引导至外部链桥和 DEX 界面。 这让去中心化应用程序能够改善用户的上手体验。 然而，这种方法有其局限性：
- 链桥的评估和维护既困难又耗时。
- 选用一个链桥将造成单点故障和依赖性。
@@ -95,41 +95,44 @@ lang: zh
4. **集成多个链桥 –** 该解决方案解决了许多与集成单个链桥相关的问题。 然而，它也有局限性，因为集成多个链桥会消耗资源，并给开发者带来技术和通信开销 — 这是加密货币领域最稀缺的资源。
-5. **集成链桥聚合器 –** 去中心化应用程序另一个选择是集成链桥聚合解决方案，使它们能够访问多个链桥。 链桥聚合器继承了所有链桥的优点，因此不受任何单一链桥能力的限制。 值得注意的是，链桥聚合器通常维护链桥集成，这使去中心化应用程序避免了管控链桥集成技术和操作方面的麻烦。
+5. **集成链桥聚合器 –** 去中心化应用程序的另一个选择是集成链桥聚合解决方案，从而访问多个链桥。 链桥聚合器继承了所有链桥的优点，因此不受任何单一链桥能力的限制。 值得注意的是，链桥聚合器通常维护链桥集成，这使去中心化应用程序避免了管控链桥集成技术和操作方面的麻烦。
尽管如此，链桥聚合器也有其局限性。 比如说，虽然它们可以提供较多的链桥选择，但除了聚合器平台上提供的链桥外，市场上通常还有更多的链桥。 此外，像链桥一样，链桥聚合器也面临智能合约和技术风险（更多的智能合约 = 更多的风险）。
如果去中心化应用程序计划集成链桥或聚合器，那么根据集成的深度会有不同的选择。 例如，如果只是进行前端集成以改善用户上手体验，去中心化应用程序将集成小组件。 然而，如果整合是为了探索更深层次的跨链策略，如质押、流动性矿池等，去中心化应用程序就集成软件开发工具包或应用程序接口。
-### 在多条链上部署去中心化应用程序 {#deploying-a-dapp-on-multiple-chains}
+### 在多个链上部署去中心化应用程序 {#deploying-a-dapp-on-multiple-chains}
-要在多条链上部署去中心化应用程序 (dapp)，开发者可以使用 [Alchemy](https://www.alchemy.com/)、[安全帽](https://hardhat.org/)和 [Moralis](https://moralis.io/) 等开发平台。 这些平台通常提供可组合的插件，能够支持去中心化应用程序跨链。 例如，开发者可以使用[安全帽部署插件](https://github.com/wighawag/hardhat-deploy)提供的确定性部署代理。
+要在多个链上部署去中心化应用程序，开发者可以使用 [Alchemy](https://www.alchemy.com/)、[Hardhat](https://hardhat.org/)、[Moralis](https://moralis.io/) 等开发平台。 这些平台通常提供可组合的插件，能够支持去中心化应用程序跨链。 例如，开发者可以使用 [Hardhat部署插件](https://github.com/wighawag/hardhat-deploy) 提供的确定性部署代理。
#### 例子：
- [如何构建跨链去中心化应用程序](https://moralis.io/how-to-build-cross-chain-dapps/)
-- [构建跨链非同质化代币市场](https://youtu.be/WZWCzsB1xUE)
-- [Moralis：构建跨链非同质化代币去中心化应用程序](https://www.youtube.com/watch?v=ehv70kE1QYo)
+- [构建跨链 NFT 市场](https://youtu.be/WZWCzsB1xUE)
+- [Moralis：构建跨链 NFT 去中心化应用程序](https://www.youtube.com/watch?v=ehv70kE1QYo)
### 监控跨链合约活动 {#monitoring-contract-activity-across-chains}
-要监控跨链合约活动，开发者可以使用子图和 Tenderly 等开发者平台实时观察智能合约。 这类平台上还有一些工具，提供更强大的跨链活动数据监控功能，例如，检查有没有[合约触发的事件](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events)等。
+要监控跨链合约活动，开发者可以使用子图和 Tenderly 等开发者平台实时观察智能合约。 此类平台也有工具可以为跨链活动提供更强大的数据监控功能，例如检查[合约发出的事件](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events)等。
#### 工具
-- [图表](https://thegraph.com/en/)
+- [The Graph](https://thegraph.com/en/)
- [Tenderly](https://tenderly.co/)
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-- [区块链链桥](/bridges/) — ethereum.org
-- [区块链链桥：构建加密网络的网络](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) 2021 年 9 月 8 日 - Dmitriy Berenzon
-- [互操作性的三难困境](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) 2021 年 10 月 1 日 – Arjun Bhuptani
-- [群集：可信链桥和信任最小化链桥如何打造多链格局](https://blog.celestia.org/clusters/) 2021 年 10 月 4 日 – Mustafa Al-Bassam
-- [LI.FI：有了链桥，信任就是一种范围](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) 2022 年 4 月 28 日 – Arjun Chand
+- [区块链链桥](/bridges/) – ethereum.org
+- [L2Beat 链桥风险框架](https://l2beat.com/bridges/summary)
+- [区块链链桥：构建加密网络之网](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) - 2021 年 9 月 8 日 – Dmitriy Berenzon
+- [互操作性三难困境](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) - 2021 年 10 月 1 日 – Arjun Bhuptani
+- [集群：需信任链桥和信任最小化链桥如何塑造多链格局](https://blog.celestia.org/clusters/) - 2021 年 10 月 4 日 – Mustafa Al-Bassam
+- [LI.FI：对于链桥，信任是一个谱系](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) - 2022 年 4 月 28 日 – Arjun Chand
+- [Rollup 互操作性解决方案现状](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - 2024 年 6 月 20 日 – Alex Hook
+- [利用共享安全实现安全的跨链互操作性：拉格朗日状态委员会及其他](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - 2024 年 6 月 12 日 – Emmanuel Awosika
-此外，以下是 [James Prestwich](https://twitter.com/_prestwich) 的一些有颇有见解的讲解，可以帮助我们更深入地理解链桥：
+此外，以下是 [James Prestwich](https://twitter.com/_prestwich) 的一些富有洞察力的演讲，可帮助您更深入地了解链桥：
-- [构建链桥，而非构建有围墙的花园](https://youtu.be/ZQJWMiX4hT0)
-- [破坏链桥](https://youtu.be/b0mC-ZqN8Oo)
-- [为何链桥在销毁？](https://youtu.be/c7cm2kd20j8)
+- [搭建桥梁，而非围墙花园](https://youtu.be/ZQJWMiX4hT0)
+- [剖析链桥](https://youtu.be/b0mC-ZqN8Oo)
+- [链桥为何在燃烧](https://youtu.be/c7cm2kd20j8)
diff --git a/public/content/translations/zh/developers/docs/consensus-mechanisms/index.md b/public/content/translations/zh/developers/docs/consensus-mechanisms/index.md
index 401a2d5fc06..9ccdddf6c10 100644
--- a/public/content/translations/zh/developers/docs/consensus-mechanisms/index.md
+++ b/public/content/translations/zh/developers/docs/consensus-mechanisms/index.md
@@ -1,20 +1,20 @@
---
-title: 共识机制
-description: 解释分布式系统中的协商一致协议及其在以太坊中扮演的角色。
+title: "共识机制"
+description: "解释分布式系统中的协商一致协议及其在以太坊中扮演的角色。"
lang: zh
---
-“共识机制”一词常常泛指“权益证明”、“工作量证明”或“权威证明”协议。 不过，这些协议只是共识机制的组成部分，用于防范[女巫攻击](/glossary/#sybil-attack)。 共识机制是由一整套想法、协议和激励构成的体系，使得一系列分布式节点能够就区块链状态达成一致。
+“共识机制”一词常常泛指“权益证明”、“工作量证明”或“权威证明”协议。 但是，它们只是共识机制中用于防御[女巫攻击](/glossary/#sybil-attack)的部分。 共识机制是由一整套想法、协议和激励构成的体系，使得一系列分布式节点能够就区块链状态达成一致。
## 前提条件 {#prerequisites}
-为了更好地理解此页面，我们建议你先阅读[以太坊简介](/developers/docs/intro-to-ethereum/)。
+为了更好地理解本页面，我们建议您先阅读我们的[以太坊简介](/developers/docs/intro-to-ethereum/)。
## 什么是共识？ {#what-is-consensus}
我们所说的共识，是指达成了广泛的一致。 比如，一群人去看电影， 如果他们对于提议“看某部电影”没有任何异议，那么就可以说共识达成了。 如果存在异议，那么他们就必须通过某种方法决定看哪一部电影。 在极端情况下，这群人就会分开。
-对于以太坊区块链来说，达成共识的过程是标准化的，达成共识意味着全网络中至少 66% 的节点就网络的全局状态达成一致。
+对于以太坊区块链来说，该过程是标准化的，达成共识意味着全网络中至少 66% 的节点就网络的全局状态达成一致。
## 什么是共识机制？ {#what-is-a-consensus-mechanism}
@@ -28,21 +28,21 @@ lang: zh
这些部分共同组成了共识机制。
-## 共识机制类型 {#types-of-consensus-mechanisms}
+## 共识机制的类型 {#types-of-consensus-mechanisms}
### 基于工作量证明 {#proof-of-work}
-和比特币类似，以太坊也曾经使用基于**工作量证明 (PoW)** 的共识协议。
+与比特币类似，以太坊曾一度使用基于**工作量证明 (PoW)** 的共识协议。
#### 区块创建 {#pow-block-creation}
矿工相互竞争以创建新的包括已处理交易的区块。 优胜者将与网络中的其他矿工分享该新区块，以获得新铸造的以太币。 数学问题解决速度最快的计算机可以在比赛中获胜。 这将生成当前区块和之前的区块之间的加密链接。 解决此问题就是要在“工作量证明”中开展的工作了。 规范链随后由一条叉选择规则确定，该规则选择了一组区块，这些区块在挖矿方面做得最多。
-#### 安全性 {#pow-security}
+#### 安全 {#pow-security}
因为用户需要拥有网络中 51% 的算力才能够欺骗整条链，因此网络的安全得以保证。 这将需要巨大的设备与能源投入，支出很有可能超过收益。
-关于[工作量证明](/developers/docs/consensus-mechanisms/pow/)的更多信息
+更多关于[工作量证明](/developers/docs/consensus-mechanisms/pow/)
### 基于权益证明 {#proof-of-stake}
@@ -52,41 +52,41 @@ lang: zh
验证者创建区块。 每个时隙中都会随机选择一个验证者成为区块提议者。 区块提议者的共识客户端请求配对执行客户端对交易打包，作为“执行负载”。 然后它们将“执行负载”包装成共识数据并形成一个区块，再把这个区块发送给以太坊网络上的其他节点。 这样的区块生产会得到以太币奖励。 在极少数情况下，一个时隙中产生了多个可能的区块，或节点在不同时间收到区块，分叉选择算法就会选择使形成的链具有最大认证权重的那个区块（认证权重是指为该区块提供认证的验证者数量，并根据验证者质押的以太币余额调整）。
-#### 安全性 {#pos-security}
+#### 安全 {#pos-security}
权益证明体系保障加密经济的安全，因为攻击者若试图控制整条链，就必须销毁大量以太币。 奖励机制会奖励诚实的质押人，而惩罚机制则阻止质押人作出恶意行为。
-有关[权益证明](/developers/docs/consensus-mechanisms/pos/)的更多信息
+更多关于[权益证明](/developers/docs/consensus-mechanisms/pos/)
-### 直观指南 {#types-of-consensus-video}
+### 视频指南 {#types-of-consensus-video}
观看视频，详细了解以太坊采用的不同类型共识机制：
- 工作量证明现已弃用。 以太坊不再使用工作量证明作为其部分共识机制。 它改用权益证明。 阅读有关[权益证明](/developers/docs/consensus-mechanisms/pos/)和[质押](/staking/)的更多信息。
+ 工作量证明现已弃用。 以太坊不再使用工作量证明作为其部分共识机制。 它改用权益证明。 阅读更多关于[权益证明](/developers/docs/consensus-mechanisms/pos/)和[质押](/staking/)的信息。
## 前提条件 {#prerequisites}
-为了更好地理解此页面，建议提前阅读[交易](/developers/docs/transactions/)、[区块](/developers/docs/blocks/)和[共识机制](/developers/docs/consensus-mechanisms/)。
+为了更好地理解本页内容，建议您先阅读有关[交易](/developers/docs/transactions/)、[区块](/developers/docs/blocks/)和[共识机制](/developers/docs/consensus-mechanisms/)的相关信息。
-## 什么是工作量证明 (POW) {#what-is-pow}
+## 什么是工作量证明 (PoW)？ {#what-is-pow}
-中本聪共识采用工作量证明，一度允许去中心化的以太坊网络对帐户余额和交易顺序等达成共识（即所有节点都同意）。 这种机制防止用户“重复支付”他们的货币，同时确保极难攻击或操作以太坊区块链。 这些安全特性现在由权益证明提供，后者采用称为 [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) 的共识机制。
+采用工作量证明的中本聪共识，是曾允许去中心化以太坊网络就帐户余额和交易顺序等达成共识（即所有节点都同意）的机制。 这种机制防止用户“重复支付”他们的货币，同时确保极难攻击或操作以太坊区块链。 这些安全特性现在由权益证明提供，后者采用称为 [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) 的共识机制。
-## 工作量证明和挖矿 {#pow-and-mining}
+## 工作量证明与挖矿 {#pow-and-mining}
工作量证明是一种基础性算法，它为矿工在工作量证明区块链上进行的工作设置难度和规则。 挖矿就是“工作”本身。 挖矿是向区块链中添加有效区块。 这很重要，因为链的长度有助于网络跟随区块链的正确分叉。 “工作”完成得越多，链越长，区块编号就越大，就更能确定网络达到最新状态。
-[有关挖矿的更多信息](/developers/docs/consensus-mechanisms/pow/mining/)
+[深入了解挖矿](/developers/docs/consensus-mechanisms/pow/mining/)
## 以太坊的工作量证明机制如何运作？ {#how-it-works}
以太坊交易处理到区块中。 在现已弃用的工作量证明以太坊中，每个区块包含：
- 区块的难度，例如：3,324,092,183,262,715
-- 混合哈希（mixHash），例如：`0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
-- nonce--例如：`0xd3ee432b4fb3d26b`
+- 混合哈希 (mixHash)——例如：`0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
+- 随机数 (nonce)——例如：`0xd3ee432b4fb3d26b`
这些区块数据与工作量证明直接相关。
-### 工作量证明机制 {#the-work}
+### 工作量证明中的“工作” {#the-work}
工作量证明协议 Ethash 要求矿工经过激烈的试错竞赛，找到一个区块的随机数。 只有具备有效随机数的区块才能加入区块链中。
-当矿工们争相创建区块时，他们会反复通过一个数学函数放置一个数据集，此数据集只能通过下载和运行整条区块链获得（矿工们都是这样做的）。 该数据集用来产生一个低于目标随机数的混合哈希，而此目标随机数由区块难度决定。 做到这些最好的方式是试错。
+当矿工们争相创建区块时，他们会反复通过一个数学函数放置一个数据集，此数据集只能通过下载和运行整条区块链获得（矿工们都是这样做的）。 该数据集用来产生一个低于目标随机数的混合哈希，而此目标随机数由区块难度决定。 找到这个满足条件的哈希值的最好的方式是试错。
难度决定了哈希的目标值。 目标值越小，有效哈希的集合就越小。 一旦生成哈希，其他矿工和客户端就很容易验证哈希。 即使一条交易记录出现改变，整个哈希就会变得完全不同，表示出现欺诈。
哈希使得欺诈更容易被发现。 此外，工作量证明作为一个流程，同样有效威慑了对区块链的攻击。
-### 工作量证明和安全性 {#security}
+### 工作量证明与安全性 {#security}
激励矿工在以太坊主链上挖矿。 对于一小部分矿工而言，没有任何激励措施让他们去开辟一条自己的新链 - 因为这破坏了体系。 区块链依赖于唯一状态来判断真实性。
@@ -57,11 +57,11 @@ lang: zh
要持续创建恶意但有效的区块，恶意矿工将需要超过 51% 的网络挖矿算力才能击败其他人。 这种海量的“工作”需要大量昂贵的算力，而且消耗的能源甚至可能超过攻击所得的收益。
-### 工作量证明的经济模型 {#economics}
+### 工作量证明的经济学 {#economics}
工作量证明还负责向系统中发行新货币并激励矿工完成工作。
-自[君士坦丁堡升级](/ethereum-forks/#constantinople)以来，成功创建区块的矿工将获得两个新铸造的以太币及部分交易费作为奖励。 叔块也会获得 1.75 个以太币的补偿。 叔块是由一个矿工创建的有效区块，几乎与此同时另一个矿工创建了规范区块。要确定规范区块，最终取决于哪条链构建于第一个区块之上。 叔块通常是由于网络延迟而出现。
+自 [君士坦丁堡升级](/ethereum-forks/#constantinople) 以来，成功创建区块的矿工会获得两个新铸造的 ETH 和部分交易费作为奖励。 叔块也会获得 1.75 个以太币的补偿。 叔块是由一个矿工创建的有效区块，几乎与此同时另一个矿工创建了规范区块。要确定规范区块，最终取决于哪条链构建于第一个区块之上。 叔块通常是由于网络延迟而出现。
## 最终确定性 {#finality}
@@ -69,21 +69,21 @@ lang: zh
由于矿工以去中心化的方式工作，有可能同时开采出两个有效区块。 这就产生了一个临时分叉。 最后，在后续区块被开采出并添加到其中一条链使其更长时，这条链就会成为被接受的链。
-但更复杂的是，在临时分叉上被拒绝的交易可能没有包含在被接受的主链上。 这意味着区块是可逆的。 因此，最终确定性是指你在认为交易不可逆之前需要等待的一段时间。 在以前的工作量证明以太坊中，一个特定区块 `N` 之后开采出的区块越多，就更加确信区块 `N` 内的交易是成功的且不可回滚。 现在，基于权益证明机制，最终确定是区块的明确属性，而不再是概率性的。
+但更复杂的是，在临时分叉上被拒绝的交易可能没有包含在被接受的主链上。 这意味着区块可逆。 因此，最终确定性是指你在认为交易不可逆之前需要等待的一段时间。 在以前采用工作量证明的以太坊中，在特定区块 `N` 之上挖出的区块越多，`N` 区块中的交易成功且不会被回滚的确定性就越高。 现在，基于权益证明机制，最终确定是区块的明确属性，而不再是概率性的。
-## 工作量证明能源消耗 {#energy}
+## 工作量证明的能源消耗 {#energy}
-对工作量证明提出的一项主要批评是保证网络安全所需的能源消耗。 为了维持安全和去中心化，采用工作量证明的以太坊每年消耗大量能源。 在即将过渡到权益证明之际，以太坊矿工的总能源消耗大约为 70 亿千瓦时/年（大约与捷克共和国相当 - 数据来自 2022 年 7 月 18 日 [digiconomist](https://digiconomist.net/)）。
+对工作量证明提出的一项主要批评是保证网络安全所需的能源消耗。 为了维持安全和去中心化，采用工作量证明的以太坊每年消耗大量能源。 在切换到权益证明前不久，以太坊矿工每年总共消耗约 70 TWh/年（与捷克共和国大致相同——根据 [digiconomist](https://digiconomist.net/) 于 2022 年 7 月 18 日发布的数据）。
## 优点和缺点 {#pros-and-cons}
-| 优点 | 缺点 |
-| -------------------------------------------------------------------------------------------------------------------- | --------------------------------- |
-| 工作量证明并无对错。 你不需要以太币来启动，出块奖励允许你从 0 ETH 获得正的收益。 而在[权益证明](/developers/docs/consensus-mechanisms/pos/)中，你需要以太币来启动获取收益的过程。 | 工作量证明消耗了大量能源，对环境不利。 |
-| 工作量证明是一个经过考验和测试的共识机制，多年来一直保持了比特币和以太坊的安全性和去中心化。 | 如果你想要挖矿，需要花大量的启动资金去购买专业设备。 |
-| 与权益证明方式相比，工作量证明是比较容易实施的。 | 因为算力的不断增加，矿池可能会主导挖矿过程，导致中心化和安全风险。 |
+| 优点 | 缺点 |
+| ------------------------------------------------------------------------------------------------------------- | --------------------------------- |
+| 工作量证明并无对错。 你不需要以太币来启动，出块奖励允许你从 0 ETH 获得正的收益。 使用[权益证明](/developers/docs/consensus-mechanisms/pos/)，你需要先拥有 ETH。 | 工作量证明消耗了大量能源，对环境不利。 |
+| 工作量证明是一个经过考验和测试的共识机制，多年来一直保持了比特币和以太坊的安全性和去中心化。 | 如果你想要挖矿，需要花大量的启动资金去购买专业设备。 |
+| 与权益证明方式相比，工作量证明是比较容易实施的。 | 因为算力的不断增加，矿池可能会主导挖矿过程，导致中心化和安全风险。 |
-## 与权益证明对比 {#compared-to-pos}
+## 与权益证明的比较 {#compared-to-pos}
从更高层面上看，权益证明和工作量证明的最终目标相同，即帮助去中心化网络安全地达成共识。 但它们在实现方式和人员上有些不同：
@@ -92,23 +92,23 @@ lang: zh
- 验证者不会竞争创建区块，而是由算法随机选择。
- 终局性是很清晰的：在特定的检查节点，如果 2/3 验证者确定了区块，这个区块将被视为最终状态。 验证者必须在区块压上自己全部质押，因此如果他们试图串通更改区块链，他们就会失去他们的全部质押。
-[有关权益证明的更多信息](/developers/docs/consensus-mechanisms/pos/)
+[深入了解权益证明](/developers/docs/consensus-mechanisms/pos/)
## 更愿意通过视频学习？ {#visual-learner}
-工作量证明不再是以太坊共识机制的基础，这意味着挖矿已终结。 取而代之的是，以太坊将由质押了以太币的验证者保护。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅展示历史内容。
+工作量证明不再是以太坊共识机制的基础，这意味着挖矿已被关闭。 取而代之的是，以太坊由质押以太币的验证者来保证安全。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅展示历史内容。
## 前提条件 {#prerequisites}
-为了更好地了解此页面，推荐先阅读[交易](/developers/docs/transactions/)、[区块](/developers/docs/blocks/)和[工作量证明](/developers/docs/consensus-mechanisms/pow/)。
+为了更好地理解本页内容，建议您先阅读有关[交易](/developers/docs/transactions/)、[区块](/developers/docs/blocks/)和[工作量证明](/developers/docs/consensus-mechanisms/pow/)的内容。
## 以太坊挖矿是什么？ {#what-is-ethereum-mining}
@@ -31,7 +31,7 @@ lang: zh
在以太坊这样的去中心化系统中，需要确保每个人都同意交易的顺序。 矿工通过解决计算难题来产生区块并保护网络免受攻击，从而帮助实现这一目标。
-[关于工作量证明的更多信息](/developers/docs/consensus-mechanisms/pow/)
+[更多关于工作量证明](/developers/docs/consensus-mechanisms/pow/)
以前任何人都能使用他们的计算机在以太坊网络上挖矿。 然而，并非每个人都可以通过挖矿实现以太币 (ETH) 获利。 在大多数情况下，矿工必须购买专用计算机硬件，并且能够获得廉价能源。 普通计算机不太可能获得足够的区块奖励来支付相关的挖矿成本。
@@ -42,32 +42,32 @@ lang: zh
- 如果你在矿池中挖矿，这些矿池通常对矿池生成的每个区块收取固定百分比的费用
- 支持矿机的潜在成本（通风、能源监测、电线等）
-要进一步探索挖矿收益，请使用挖矿收益计算器，例如 [Etherscan](https://etherscan.io/ether-mining-calculator) 提供的挖矿收益计算器。
+要进一步探索挖矿收益，请使用挖矿计算器，例如 [Etherscan](https://etherscan.io/ether-mining-calculator) 提供的计算器。
-## 如何挖掘以太坊交易 {#how-ethereum-transactions-were-mined}
+## 以太坊交易是如何被挖出的 {#how-ethereum-transactions-were-mined}
-以下内容将简要介绍如何在以太坊工作量证明中挖掘交易。 在[这里](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos)可以找到对以太坊权益证明中该过程的类比介绍。
+以下内容将简要介绍如何在以太坊工作量证明中挖掘交易。 以太坊权益证明流程的类似描述可以在[这里](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos)找到。
-1. 用户编写和通过一些[帐户](/developers/docs/accounts/)私钥来签署[交易](/developers/docs/transactions/)请求。
-2. 用户通过一些[节点](/developers/docs/nodes-and-clients/)将自己的交易请求广播到整个以太坊网络。
+1. 用户用某个[帐户](/developers/docs/accounts/)的私钥编写并签署一项[交易](/developers/docs/transactions/)请求。
+2. 用户通过某个[节点](/developers/docs/nodes-and-clients/)将交易请求广播到整个以太坊网络。
3. 在听到新的转账请求时，每个以太坊网络节点会添加这笔交易到本地的内存池，这些内存池包括他们收到的没有被添加到区块链以承认的所有转账请求。
-4. 在这个时候，一个挖矿节点将几十或上百个交易请求汇总到潜在[区块](/developers/docs/blocks/)中，从而尽量多收取[交易](/developers/docs/gas/)手续费，同时保证不超出区块燃料限制。 采矿节点将：
- 1. 验证每个交易请求的有效性（例如没有人试图将以太币从他们没有签名的帐户中转移出来，请求是否有格式错误等），然后执行请求的本地代码，改变本地副本 EVM 的状态。 矿工获得每个交易请求的转账的手续费到他们的帐户。
- 2. 一旦在本地 EVM 副本上验证并执行了块中的所有转账请求，就开始为潜在块生成工作证明“合法性证书”。
+4. 在某个时间点，一个挖矿节点会将数十或数百个交易请求聚合成一个潜在的[区块](/developers/docs/blocks/)，以便在不超过区块燃料限制的情况下，最大化其赚取的[交易费](/developers/docs/gas/)。 采矿节点将：
+ 1. 验证每个交易请求的有效性（即，没有人试图从自己没有签名的帐户转出以太币，请求格式无误等），然后执行请求中的代码，更改其本地 EVM 副本的状态。 矿工获得每个交易请求的转账的手续费到他们的帐户。
+ 2. 一旦在本地 EVM 副本上验证并执行了区块中的所有交易请求，就开始为该潜在区块生成工作量证明“合法性证书”。
5. 最终，矿工将完成为包含我们特定交易请求的区块生成的证书。 然后，矿工广播完成的区块，其中包括证书和校验新 EVM 状态。
6. 其他节点将收到新的区块。 他们将验证证书，执行区块上所有的转账（包括最初由用户广播的交易），然后校验新 EVM 状态，之后执行所有满足 EVM 校验和的转账。 只有这样，这些节点才会将该块附加到区块链的尾部，并接受新的 EVM 状态作为新的规范状态。
7. 每个节点将从其未完成的本地内存池的转账请求中删除新区块中已经存在的转账请求。
8. 加入网络的新节点将按顺序下载所有块，包括未被打包的交易块。 初始化本地 EVM 副本（作为空白状态的 EVM 开始），在本地 EVM 副本上执行每个块中的每个转账，校验各块的校验和。
-每个交易都只会被挖掘（首次包含在新区块中并传播）一次，但在推进规范以太坊虚拟机状态的过程中，每个参与者都会执行和验证交易。 这凸显出区块链的核心准则之一：**不信任，就验证**。
+每个交易都只会被挖掘（首次包含在新区块中并传播）一次，但在推进规范以太坊虚拟机状态的过程中，每个参与者都会执行和验证交易。 这凸显了区块链的核心准则之一：**不信任，就验证**。
-## 叔块 {#ommer-blocks}
+## 叔块 (Ommer) {#ommer-blocks}
-基于工作量证明的区块挖掘是概率性的，这意味着有时由于网络延迟而同时公布了两个有效的区块。 在这种情况下，协议必须确定最长链(因此大多数即是最“有效的”)，同时针对已提交但未被包含的有效区块，给予矿工部分奖励以确保公平。 这促使网络进一步去中心化，因为小矿工群体可能面临更大的延迟，但仍然可以通过[叔块](/glossary/#ommer)奖励获得收益。
+基于工作量证明的区块挖掘是概率性的，这意味着有时由于网络延迟而同时公布了两个有效的区块。 在这种情况下，协议必须确定最长链(因此大多数即是最“有效的”)，同时针对已提交但未被包含的有效区块，给予矿工部分奖励以确保公平。 这促进了网络的进一步去中心化，因为规模较小的矿工（他们可能面临更大的延迟）仍然可以通过[叔块](/glossary/#ommer)区块奖励来获得回报。
-对于父区块的同级区块来说，“ommer”一词不分性别，因而为首选，但有时也被称为“uncle”（叔）。 **因为以太坊切换到权益证明机制后，叔块就不会被挖掘了**，因为每个时隙中只选择了一名提议者。 通过查看被挖掘叔块的[历史图表](https://ycharts.com/indicators/ethereum_uncle_rate)，你可以看到这种变化。
+对于父块的同级区块来说，“叔块”一词不分性别，因而为首选，但有时也被称为“uncle”（叔块）。 **自从以太坊转向权益证明后，便不再挖出叔块了**，因为每个时隙只会选出一位提议者。 你可以通过查看已挖出叔块的[历史图表](https://ycharts.com/indicators/ethereum_uncle_rate)来了解这一变化。
-## 直观演示 {#a-visual-demo}
+## 可视化演示 {#a-visual-demo}
跟随 Austin 了解挖矿和工作量证明区块链。
@@ -75,12 +75,12 @@ lang: zh
## 挖矿算法 {#mining-algorithm}
-以太坊主网只使用过一种挖矿算法：[“Ethash”](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/)。 Ethash 是一种初始研发算法[“Dagger-Hashimoto”](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/)的后续版本。
+以太坊主网只使用过一种挖矿算法——['Ethash'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/)。 Ethash 是最初研发算法 ['Dagger-Hashimoto'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/) 的后继算法。
-[有关挖矿算法的更多信息](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/)。
+[更多关于挖矿算法](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/)。
-## 相关主题 {#related-topics}
+## 相关话题 {#related-topics}
- [燃料](/developers/docs/gas/)
-- [以太坊虚拟机](/developers/docs/evm/)
+- [以太坊虚拟机 (EVM)](/developers/docs/evm/)
- [工作量证明](/developers/docs/consensus-mechanisms/pow/)
diff --git a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
index faa0ed58c54..bc07e2aea13 100644
--- a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
+++ b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md
@@ -1,35 +1,35 @@
---
title: Dagger-Hashimoto
-description: 详细了解 Dagger-Hashimoto 算法。
+description: "详细了解 Dagger-Hashimoto 算法。"
lang: zh
---
-Dagger-Hashimoto 是以太坊挖矿算法的原始研究实现和规范。 但是，Dagger-Hashimoto 已被 [Ethash](#ethash) 取代。 在 2022 年 9 月 15 日实施[合并](/roadmap/merge/)后，挖矿完全关闭。 此后，以太坊采用[权益证明](/developers/docs/consensus-mechanisms/pos)机制保护安全。 本页面展示与历史有关的内容，其中的信息不再与合并后的以太坊相关。
+Dagger-Hashimoto 是以太坊挖矿算法的原始研究实现和规范。 Dagger-Hashimoto 已被 [Ethash](#ethash) 取代。 2022 年 9 月 15 日[合并](/roadmap/merge/)后，挖矿已完全停止。 此后，以太坊转而使用[权益证明](/developers/docs/consensus-mechanisms/pos)机制来保障安全。 本页面展示与历史有关的内容，其中的信息不再与合并后的以太坊相关。
## 前提条件 {#prerequisites}
-为了更好地了解此页面，建议提前阅读[工作量证明共识](/developers/docs/consensus-mechanisms/pow)、[挖矿](/developers/docs/consensus-mechanisms/pow/mining)和[挖矿算法](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms)。
+为了更好地理解本页内容，我们建议您首先阅读有关[工作量证明共识](/developers/docs/consensus-mechanisms/pow)、[挖矿](/developers/docs/consensus-mechanisms/pow/mining)和[挖矿算法](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms)的资料。
-## Dagger-Hashimoto 算法 {#dagger-hashimoto}
+## Dagger-Hashimoto {#dagger-hashimoto}
Dagger-Hashimoto 旨在实现两个目标：
-1. **ASIC 抗性**：为算法打造专用硬件的益处应尽可能小。
-2. **轻量级客户端可验证性**：区块应能被轻量级客户端高效验证。
+1. **抗 ASIC 性**：为该算法创建专用硬件的好处应尽可能小
+2. **轻客户端可验证性**：区块应能由轻客户端高效验证。
在作出进一步修改后，我们还要具体说明如何在必要时实现第三个目标，但要以增加复杂性为代价：
-**完整链存储**：挖矿需要存储完整的区块链状态（因为以太坊状态子树的不规则结构，我们预计将有可能进行一些修改，特别是一些经常用到的合约，但我们希望尽量减少这种情况）。
+**全链存储**：挖矿应要求存储完整的区块链状态（由于以太坊状态树的结构不规则，我们预计可以进行一些修剪，特别是一些常用合约，但我们希望将其最小化）。
-## 有向无环图世代 {#dag-generation}
+## DAG 生成 {#dag-generation}
-以下算法代码将在 Python 中定义。 首先，我们定义了 `encode_int`，用于将指定精度的无符号整数封送为字符串。 同时还定义了它的逆函数。
+以下算法代码将在 Python 中定义。 首先，我们给出 `encode_int`，用于将指定精度的无符号整数封送为字符串。 同时还定义了它的逆函数。
```python
NUM_BITS = 512
def encode_int(x):
- "Encode an integer x as a string of 64 characters using a big-endian scheme"
+ "使用大端方案将整数 x 编码为 64 个字符的字符串"
o = ''
for _ in range(NUM_BITS / 8):
o = chr(x % 256) + o
@@ -37,7 +37,7 @@ def encode_int(x):
return o
def decode_int(s):
- "Unencode an integer x from a string using a big-endian scheme"
+ "使用大端方案从字符串中解码整数 x"
x = 0
for c in s:
x *= 256
@@ -45,7 +45,7 @@ def decode_int(s):
return x
```
-接下来我们假设 `sha3` 是一个需要输入整数，然后输出整数的函数，而 `dbl_sha3` 是一个 double-sha3 函数；如果将此引用代码转换为实现，使用以下代码：
+接下来我们假设 `sha3` 是一个接收整数并输出整数的函数，而 `dbl_sha3` 是一个 double-sha3 函数；如果要将此参考代码转换为实现，请使用：
```python
from pyethereum import utils
@@ -65,26 +65,26 @@ def dbl_sha3(x):
该算法使用的参数有：
```python
-SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512
+SAFE_PRIME_512 = 2**512 - 38117 # 小于 2**512 的最大安全素数
params = {
- "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536
- "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536
- # with epochtime=20000 gives 882 MB growth per year
- "cache_size": 2500, # Size of the light client's cache (can be chosen by light
- # client; not part of the algo spec)
- "diff": 2**14, # Difficulty (adjusted during block evaluation)
- "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated)
- "k": 1, # Number of parents of a node
- "w": w, # Used for modular exponentiation hashing
- "accesses": 200, # Number of dataset accesses during hashimoto
- "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation
+ "n": 4000055296 * 8 // NUM_BITS, # 数据集的大小（4 GB）；必须是 65536 的倍数
+ "n_inc": 65536, # 每个时段的 n 值增量；必须是 65536 的倍数
+ # epochtime=20000 时，每年增长 882 MB
+ "cache_size": 2500, # 轻客户端的缓存大小（可由轻客户端选择；
+ # 不属于算法规范）
+ "diff": 2**14, # 难度（在区块评估期间调整）
+ "epochtime": 100000, # 一个时段的区块长度（数据集的更新频率）
+ "k": 1, # 节点的父节点数量
+ "w": w, # 用于模幂哈希
+ "accesses": 200, # hashimoto 期间的数据集访问次数
+ "P": SAFE_PRIME_512 # 用于哈希和随机数生成的安全素数
}
```
-`P` 在这种情况下为优先选择，因此 `log₂(P)` 仅略小于 512。512 对应于我们用来代表我们数目的 512 字节。 请注意，实际上只需要存储有向无环图的后半部分，因此，实际内存要求最初为 1 GB，每年增长 441 MB。
+在这种情况下，`P` 是一个质数，其选择要使 `log₂(P)` 略小于 512，这对应于我们一直用来表示数字的 512 位。 请注意，实际上只需要存储有向无环图的后半部分，因此，实际内存要求最初为 1 GB，每年增长 441 MB。
-### Dagger 建图 {#dagger-graph-building}
+### Dagger 图构建 {#dagger-graph-building}
Dagger 建图基本式的定义如下：
@@ -101,11 +101,11 @@ def produce_dag(params, seed, length):
return o
```
-基本上，建图从单个节点 `sha3(seed)` 开始，然后根据随机的先前节点按顺序添加到其他节点上。 创建一个新的节点后，将计算种子的模块化能力，以随机选择一些小于 `i` 的索引（使用上述 `x % i`），并且使用这些索引上的节点值进行计算，以产生新的 `x` 值，随后该值被提供给一个小的工作量证明函数（基于 XOR），最终在索引 `i` 生成图值。 这种特殊设计背后的基本原理是强制按顺序访问有向无环图。如果当前值未知，则无法确定要访问的下一个有向无环图的值。 最后，模幂运算会使结果更加恶化。
+本质上，它以单个节点 `sha3(seed)` 启动一个图，然后从那里开始，根据随机的先前节点顺序添加其他节点。 当创建一个新节点时，会计算种子的模幂，以随机选择一些小于 `i` 的索引（使用上面的 `x % i`），然后使用这些索引处节点的值进行计算，以生成新的 `x` 值，该值再被送入一个小的（基于 XOR 的）工作量证明函数，最终生成索引为 `i` 的图值。 这种特殊设计背后的基本原理是强制按顺序访问有向无环图。如果当前值未知，则无法确定要访问的下一个有向无环图的值。 最后，模幂运算会使结果更加恶化。
这种算法依赖于数字理论的若干结果。 讨论情况见下文附录。
-## 轻量级客户端评估 {#light-client-evaluation}
+## 轻客户端评估 {#light-client-evaluation}
上述构图旨在实现图中每个节点的重构，只计算少量节点的子树，并且仅需少量的辅助内存。 请注意，当 k=1 时，子树只是一个上升到有向无环图第一个元素的值链。
@@ -131,11 +131,11 @@ def quick_calc(params, seed, p):
return quick_calc_cached(p)
```
-本质上，它只是对上述算法的重写，删除了计算整个有向无环图值的循环，并用递归调用或缓存查找替换了早期的节点查找。 请注意，对于 `k=1` 的情况，缓存是不必要的，尽管进一步的优化实际上预先计算了有向无环图的前几千个值，并将其作为静态缓存进行计算；有关此代码实现，请参见附录。
+本质上，它只是对上述算法的重写，删除了计算整个有向无环图值的循环，并用递归调用或缓存查找替换了早期的节点查找。 请注意，对于 `k=1` 的情况，缓存是不必要的，尽管进一步的优化实际上预先计算了 DAG 的前几千个值，并将其作为静态缓存进行计算；有关此代码的实现，请参见附录。
-## 有向无环图的双倍缓冲 {#double-buffer}
+## DAG 的双缓冲 {#double-buffer}
-在完整客户端中，使用了上述公式生成的 2 个有向无环图的[_双倍缓冲_](https://wikipedia.org/wiki/Multiple_buffering)。 具体概念是，根据上述参数，每个 `epochtime` 生成一个有向无环图。 但客户端使用的并非是最新生成的有向无环图，而是前一个。 这样做的好处是，有向无环图可以随着时间的推移而被替换掉，无需包含矿工必须突然重新计算所有数据的步骤。 否则，定期的链处理可能会突然暂时放缓，并大幅提高中心化程度。 因此，在重新计算所有数据之前的几分钟时间内，存在 51% 的攻击风险。
+在全客户端中，会使用由上述公式生成的 2 个 DAG 的[_双缓冲_](https://wikipedia.org/wiki/Multiple_buffering)。 其思想是，根据上述参数，每隔 `epochtime` 个区块就会生成一个 DAG。 但客户端使用的并非是最新生成的有向无环图，而是前一个。 这样做的好处是，有向无环图可以随着时间的推移而被替换掉，无需包含矿工必须突然重新计算所有数据的步骤。 否则，定期的链处理可能会突然暂时放缓，并大幅提高中心化程度。 因此，在重新计算所有数据之前的几分钟时间内，存在 51% 的攻击风险。
要生成用于块工作计算的有向无环图集，算法如下：
@@ -164,7 +164,7 @@ def get_daggerset(params, block):
dagsz = get_dagsize(params, block)
seedset = get_seedset(params, block)
if seedset["front_hash"] <= 0:
- # No back buffer is possible, just make front buffer
+ # 无法使用后向缓冲，仅创建前向缓冲
return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz),
"block_number": 0}}
else:
@@ -211,7 +211,7 @@ def quick_hashimoto(seed, dagsize, params, header, nonce):
return dbl_sha3(mix)
```
-## 挖矿与验证 {#mining-and-verifying}
+## 挖矿和验证 {#mining-and-verifying}
现在，将它们全部整合到挖矿算法中：
@@ -254,56 +254,52 @@ def light_verify(params, header, nonce):
- 为了使双层验证起效，区块头必须同时具有随机数和中间值 pre-sha3
- 在某处，区块头必须存储当前种子集的 sha3
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
## 附录 {#appendix}
-如前所述，用于生成有向无环图的随机数生成依赖于数论的一些结果。 Lehmer 随机数生成程序是 `picker` 变量的基础，因此我们首先确保它具有很宽的周期。 其次，只要一开始 `x ∈ [2,P-2]`，我们便能证明 `pow(x,3,P)` 不会将 `x` 映射到 `1` 或 `P-1`。 最后，我们证明 `pow(x,3,P)` 在被视为散列函数时具有较低的冲突率。
+如前所述，用于生成有向无环图的随机数生成依赖于数论的一些结果。 首先，我们保证作为 `picker` 变量基础的 Lehmer RNG 具有很长的周期。 其次，我们证明只要 `x ∈ [2,P-2]`，`pow(x,3,P)` 就不会将 `x` 映射到 `1` 或 `P-1`。 最后，我们证明当 `pow(x,3,P)` 被当作哈希函数时，其冲突率很低。
-### Lehmer 随机数生成程序 {#lehmer-random-number}
+### Lehmer 随机数生成器 {#lehmer-random-number}
-虽然 `produce_dag` 函数不需要生成无偏随机数，但潜在的威胁是 `seed**i % P` 只取少数几个值。 这可以为矿工识别模式提供优势。
+虽然 `produce_dag` 函数不需要生成无偏随机数，但一个潜在的威胁是 `seed**i % P` 只会取少数几个值。 这可以为矿工识别模式提供优势。
-为了避免这种情况，可采用数论结果。 [_安全素数_](https://en.wikipedia.org/wiki/Safe_prime)定义为素数 `P`，从而 `(P-1)/2` 也是素数。 [乘数组](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n)中 `x` 的_顺序_ （乘数组 `ℤ/nℤ`）定义为最小 `m`，以使 xᵐ mod P ≡ 1
-鉴于这些定义，我们得到：
+为了避免这种情况，可采用数论结果。 [_安全素数_](https://en.wikipedia.org/wiki/Safe_prime) 定义为素数 `P`，其中 `(P-1)/2` 也是素数。 [乘法群](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` 的成员 `x` 的_阶_定义为最小的 `m`，使得 xᵐ mod P ≡ 1
+根据这些定义，我们有：
-> 观察 1。 令 `x` 成为乘法组 `ℤ/Pℤ` 的一员，以获得安全素数 `P`。 如果 `x mod P ≠ 1 mod P` 和 `x mod P ≠ P-1 mod P`，那么 `x` 的顺序是 ` P-1` 或 `(P-1)/2`。
+> 观察 1。 设 `x` 是乘法群 `ℤ/Pℤ` 的一个成员，其中 `P` 是一个安全素数。 如果 `x mod P ≠ 1 mod P` 且 `x mod P ≠ P-1 mod P`，那么 `x` 的阶是 `P-1` 或 `(P-1)/2`。
-_证明_。 由于 `P` 是一个安全素数，那么根据 \[Lagrange's Theorem\]\[lagrange\]，我们得到 `x` 的顺序为 `1`、`2`、`(P-1)/2` 或 `P-1`。
+_证明_。 由于 `P` 是一个安全素数，那么根据[拉格朗日定理][lagrange]，我们可知 `x` 的阶是 `1`、`2`、`(P-1)/2` 或 `P-1`。
-`x` 的顺序不能是 `1`，因为根据费马小定理，我们得出：
+`x` 的阶不可能是 `1`，因为根据费马小定理，我们有：
xP-1 mod P ≡ 1
-因此，`x` 必须是 `ℤ/nℤ` 的乘法单位，并且是唯一的乘法单位。 由于我们假设 `x ≠ 1`，所以这是不可能的。
+因此，`x` 必须是 `ℤ/nℤ` 的乘法单位元，而乘法单位元是唯一的。 由于我们已经假设 `x ≠ 1`，所以这是不可能的。
-`x` 的顺序不能是 `2`，除非 `x = P-1`，因为这将违反 `P` 是素数的事实。
+`x` 的阶不可能是 `2`，除非 `x = P-1`，因为这将违背 `P` 是素数这一事实。
-从以上命题中，我们可以知道，迭代 `(picker * init) % P` 的循环长度至少为 `(P-1)/2`。 这是因为我们选择 `P` 作为安全素数，强度几乎翻倍，且 `init` 处于 `[2,2**256+1]` 区间内。 考虑到 `P` 的量级，我们不应期待模幂运算具有周期性。
+从以上命题中，我们可以认识到，迭代 `(picker * init) % P` 的循环长度至少为 `(P-1)/2`。 这是因为我们选择的 `P` 是一个安全素数，约等于 2 的一个较高次幂，并且 `init` 在区间 `[2,2**256+1]` 内。 考虑到 `P` 的数量级，我们不应该期望模幂运算会出现循环。
-在有向无环图中分配第一个单元时（变量标签为 `init`），我们会计算 `pow(sha3(seed) + 2, 3, P)`。 初看起来，这并不能保证结果既不是 `1` 也不是 `P-1`。 然而，既然 `P-1` 是一个安全素数，我们还提供以下额外保证，这是观察 1 的必然结果：
+在分配 DAG 中的第一个单元格（标记为 `init` 的变量）时，我们计算 `pow(sha3(seed) + 2, 3, P)`。 乍一看，这并不能保证结果既不是 `1` 也不是 `P-1`。 然而，由于 `P-1` 是一个安全素数，我们有以下额外的保证，这是观察 1 的一个推论：
-> 观察 2。 令 `x` 成为乘法组 `ℤ/Pℤ` 的一员，以获得安全素数 `P`，并让 `w` 成为自然数。 如果 `x mod P ≠ 1 mod P`、`x mod P ≠ P-1 mod P`，且 `w mod P ≠ P-1 mod P`、`w mod P ≠ 0 mod P`，那么 `xʷ mod P ≠ 1 mod P` 且 `xʷ mod P ≠ P-1 mod P`
+> 观察 2。 设 `x` 是乘法群 `ℤ/Pℤ` 的一个成员（其中 `P` 是一个安全素数），并设 `w` 是一个自然数。 如果 `x mod P ≠ 1 mod P` 且 `x mod P ≠ P-1 mod P`，并且 `w mod P ≠ P-1 mod P` 且 `w mod P ≠ 0 mod P`，那么 `xʷ mod P ≠ 1 mod P` 且 `xʷ mod P ≠ P-1 mod P`
-### 模幂运算用作散列函数 {#modular-exponentiation}
+### 作为哈希函数的模幂运算 {#modular-exponentiation}
-对于特定的 `P` 值和 `w` 值，函数 `pow(x, w, P)` 可能存在许多冲突。 例如，`pow(x,9,19)` 的值只能接受 `{1,18}`。
+对于 `P` 和 `w` 的某些值，函数 `pow(x, w, P)` 可能会有很多冲突。 例如，`pow(x,9,19)` 只取 `{1,18}` 这几个值。
-鉴于 `P` 为素数，可以使用以下结果，选择一个用于模幂运算哈希函数的适当 `w` 值：
+鉴于 `P` 是素数，可以使用以下结果为模幂哈希函数选择一个合适的 `w`：
-> 观察 3。 令 `P` 为素数；当且仅当用于 `ℤ/Pℤ` 中所有 `a` 和 `b` 满足以下条件时，`w` 和 `P-1` 才能为互素。
->
->
-> `aʷ mod P ≡ bʷ mod P`，当且仅当 `a mod P ≡ b mod P`
->
+> 观察 3。 设 `P` 是一个素数；`w` 和 `P-1` 互素，当且仅当对于 `ℤ/Pℤ` 中的所有 `a` 和 `b`：`aʷ mod P ≡ bʷ mod P` 当且仅当 `a mod P ≡ b mod P`
-因此，鉴于 `P` 为素数，且 `w` 与 `P-1` 为互素，我们得出 `|{pow(x, w, P) : x ∈ ℤ}| = P`，表示散列函数具有尽可能小的冲突率。
+因此，鉴于 `P` 是素数且 `w` 与 `P-1` 互素，我们有 `|{pow(x, w, P) : x ∈ ℤ}| = P`，这意味着该哈希函数具有最小的可能冲突率。
-在特殊情况下，`P` 是我们选择的安全素数，那么 `P-1` 仅有系数 1、2、`(P-1)/2` 和 `P-1`。 由于 `P` > 7，我们知道 3 与 `P-1` 互素，因此 `w=3` 满足上述命题。
+在我们所选的 `P` 是安全素数的特殊情况下，`P-1` 仅有因子 1、2、`(P-1)/2` 和 `P-1`。 由于 `P` > 7，我们知道 3 与 `P-1` 互素，因此 `w=3` 满足上述命题。
-## 更有效的缓存评估算法 {#cache-based-evaluation}
+## 更高效的基于缓存的评估算法 {#cache-based-evaluation}
```python
def quick_calc(params, seed, p):
diff --git a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
index 44ebb9a5e50..8132b5af7e4 100644
--- a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
+++ b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -1,6 +1,6 @@
---
title: Ethash
-description: Ethash 算法详细介绍。
+description: "Ethash 算法详细介绍。"
lang: zh
---
@@ -8,12 +8,12 @@ lang: zh
- Ethash 是以太坊的工作量证明挖矿算法。 工作量证明现在已经被**完全关闭**，取而代之，以太坊现在使用[权益证明](/developers/docs/consensus-mechanisms/pos/)来保证安全。 阅读更多关于[合并](/roadmap/merge/)、[权益证明](/developers/docs/consensus-mechanisms/pos/)和[质押](/staking/)的信息。 此页面是为了满足对历史的兴趣！
+ Ethash 是以太坊的工作量证明挖矿算法。 工作量证明现在已经被**完全关闭**，取而代之，以太坊现在使用[权益证明](/developers/docs/consensus-mechanisms/pos/)来保证安全。 阅读更多关于[合并](/roadmap/merge/)、[权益证明](/developers/docs/consensus-mechanisms/pos/)和[质押](/staking/)的信息。 此页面是为了满足对历史的兴趣！
-Ethash 是 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) 算法的修改版本。 Ethash 工作量证明是[内存密集型](https://wikipedia.org/wiki/Memory-hard_function)算法，这被认为使算法可抵御专用集成电路。 Ethash 专用集成电路最终被开发出来，但在工作量证明被关闭之前，图形处理单元挖矿仍然是一个可行的选择。 Ethash 仍然用于在其他非以太坊工作量证明网络上挖掘其他币。
+Ethash 是 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) 算法的修改版本。 Ethash 工作量证明是[内存困难](https://wikipedia.org/wiki/Memory-hard_function)的，这被认为使该算法具有抗 ASIC 的特性。 Ethash 专用集成电路最终被开发出来，但在工作量证明被关闭之前，图形处理单元挖矿仍然是一个可行的选择。 Ethash 仍然用于在其他非以太坊工作量证明网络上挖掘其他币。
## Ethash 是如何工作的？ {#how-does-ethash-work}
@@ -21,9 +21,9 @@ Ethash 是 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/m
该算法采取的一般路线如下：
-1. 有一个**种子**，可以通过扫描区块头直到该点来为每个区块计算种子。
-2. 从种子中可以计算出 **16 MB 的伪随机缓存**。 轻量级客户端存储缓存。
-3. 我们可以从缓存中生成一个 **1 GB 数据集**，数据集中每个项目仅依赖于一小部分缓存中的项目。 全客户端和矿工存储数据集。 数据集随着时间的流逝而呈线性增长。
+1. 存在一个**种子**，它可以通过扫描截止到该区块的区块头来计算得出。
+2. 从种子可以计算出一个 **16 MB 的伪随机缓存**。 轻量级客户端存储缓存。
+3. 从缓存中，我们可以生成一个 **1 GB 的数据集**，其特性是，数据集中的每个项目仅依赖于缓存中的少量项目。 全客户端和矿工存储数据集。 数据集随着时间的流逝而呈线性增长。
4. 采矿会抢走数据集的随机片段并将它们散列在一起。 可以通过使用缓存来重新生成你需要的数据集中的特定区块，以较低的内存进行验证，以使你只需要存储缓存。
每隔 30000 个区块更新一次大数据集，因此，矿工的绝大部分工作都是读取数据集，而不是对其进行修改。
@@ -33,23 +33,26 @@ Ethash 是 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/m
我们采用以下定义：
```
-WORD_BYTES = 4 # bytes in word
-DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis
-DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch
-CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis
-CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch
-CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache
-EPOCH_LENGTH = 30000 # blocks per epoch
-MIX_BYTES = 128 # width of mix
-HASH_BYTES = 64 # hash length in bytes
-DATASET_PARENTS = 256 # number of parents of each dataset element
-CACHE_ROUNDS = 3 # number of rounds in cache production
-ACCESSES = 64 # number of accesses in hashimoto loop
+WORD_BYTES = 4 # 字中的字节数
+DATASET_BYTES_INIT = 2**30 # 创世时数据集字节数
+DATASET_BYTES_GROWTH = 2**23 # 每个时段的数据集增长量
+CACHE_BYTES_INIT = 2**24 # 创世时缓存字节数
+CACHE_BYTES_GROWTH = 2**17 # 每个时段的缓存增长量
+CACHE_MULTIPLIER=1024 # DAG 相对于缓存的大小
+EPOCH_LENGTH = 30000 # 每个时段的区块数
+MIX_BYTES = 128 # mix 宽度
+HASH_BYTES = 64 # 哈希长度（以字节为单位）
+DATASET_PARENTS = 256 # 每个数据集元素的父项数
+CACHE_ROUNDS = 3 # 缓存生成中的轮数
+ACCESSES = 64 # hashimoto 循环中的访问次数
```
### 使用“SHA3” {#sha3}
-以太坊的开发恰逢 SHA3 标准的制定， 标准进程对最终确定的哈希算法的填充做了后期改动，使得以太坊的 “sha3_256”和“sha3_512”哈希值不是标准的 sha3 哈希值，而是在其他情况下 常被称为“Keccak-256”和“Keccak-512”的变量。 讨论请见[此处](https://eips.ethereum.org/EIPS/eip-1803)、[此处](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use)或[此处](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057)。
+以太坊的开发恰逢 SHA3 标准的制定，
+标准进程对最终确定的哈希算法的填充做了后期改动，使得以太坊的
+“sha3_256”和“sha3_512”哈希值不是标准的 sha3 哈希值，而是在其他情况下
+常被称为“Keccak-256”和“Keccak-512”的变量。 例如，请参阅[此处](https://eips.ethereum.org/EIPS/eip-1803)、[此处](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use)或[此处](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057)的讨论。
请记住这一点，因为下面的算法描述中提到了“sha3”哈希值。
@@ -83,12 +86,12 @@ def get_full_size(block_number):
def mkcache(cache_size, seed):
n = cache_size // HASH_BYTES
- # Sequentially produce the initial dataset
+ # 顺序生成初始数据集
o = [sha3_512(seed)]
for i in range(1, n):
o.append(sha3_512(o[-1]))
- # Use a low-round version of randmemohash
+ # 使用低轮数版本的 randmemohash
for _ in range(CACHE_ROUNDS):
for i in range(n):
v = o[i][0] % n
@@ -97,11 +100,11 @@ def mkcache(cache_size, seed):
return o
```
-缓存生成过程中，先按顺序填充 32 MB 内存，然后从 [_严格内存硬哈希函数 _(2014)](http://www.hashcash.org/papers/memohash.pdf) 执行两次 Sergio Demian Lerner 的 _RandMemoHash_ 算法。 输出一组 524288 个 64 字节值。
+缓存生成过程首先需要按顺序填满 32 MB 内存，然后执行两轮 Sergio Demian Lerner 的 _RandMemoHash_ 算法，该算法出自 [_Strict Memory Hard Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf)。 输出一组 524288 个 64 字节值。
## 数据聚合函数 {#date-aggregation-function}
-我们使用灵感来自 [FNV 哈希](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function)的算法，在部分情况下，这种算法可用作逻辑异或的不相关替代。 请注意，我们使用全 32 位输入乘以素数，与之相对地，FNV-1 spec 用 1 个字节（8 个字节）依次乘以素数。
+在某些情况下，我们使用一种受 [FNV 哈希](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) 启发的算法，作为异或运算 (XOR) 的非关联替代。 请注意，我们使用全 32 位输入乘以素数，与之相对地，FNV-1 spec 用 1 个字节（8 个字节）依次乘以素数。
```python
FNV_PRIME = 0x01000193
@@ -120,11 +123,11 @@ def fnv(v1, v2):
def calc_dataset_item(cache, i):
n = len(cache)
r = HASH_BYTES // WORD_BYTES
- # initialize the mix
+ # 初始化 mix
mix = copy.copy(cache[i % n])
mix[0] ^= i
mix = sha3_512(mix)
- # fnv it with a lot of random cache nodes based on i
+ # 根据 i，用大量随机缓存节点对其进行 fnv 运算
for j in range(DATASET_PARENTS):
cache_index = fnv(i ^ j, mix[j % r])
mix = map(fnv, mix, cache[cache_index % n])
@@ -140,27 +143,27 @@ def calc_dataset(full_size, cache):
## 主循环 {#main-loop}
-现在，我们指定了类似“hashimoto”的主要循环。在此循环中，我们聚合整个数据集的数据，以生成特定区块头和随机数的最终值。 在下面的代码中，`header` 代表一个_被截断_区块头的递归长度前缀表示的 SHA3-256 _哈希值_。被截断是指区块头被截去了 **mixHash** 和**随机数**字段。 `nonce` 是指一个 64 位无符号整数的八个字节，按大端序排列。 因此 `nonce[::-1]` 是上述值的八字节小端序表示：
+现在，我们指定了类似“hashimoto”的主要循环。在此循环中，我们聚合整个数据集的数据，以生成特定区块头和随机数的最终值。 在下面的代码中，`header` 代表一个_截断_区块头的 RLP 编码的 SHA3-256 _哈希_，也就是移除了 **mixHash** 和 **nonce** 字段的区块头。 `nonce` 是一个 64 位无符号整数的八个字节，采用大端序。 因此 `nonce[::-1]` 是该值的八字节小端序表示：
```python
def hashimoto(header, nonce, full_size, dataset_lookup):
n = full_size / HASH_BYTES
w = MIX_BYTES // WORD_BYTES
mixhashes = MIX_BYTES / HASH_BYTES
- # combine header+nonce into a 64 byte seed
+ # 将 header 和 nonce 组合成一个 64 字节的种子
s = sha3_512(header + nonce[::-1])
- # start the mix with replicated s
+ # 用复制的 s 开始混合
mix = []
for _ in range(MIX_BYTES / HASH_BYTES):
mix.extend(s)
- # mix in random dataset nodes
+ # 混入随机数据集节点
for i in range(ACCESSES):
p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
newdata = []
for j in range(MIX_BYTES / HASH_BYTES):
newdata.extend(dataset_lookup(p + j))
mix = map(fnv, mix, newdata)
- # compress mix
+ # 压缩 mix
cmix = []
for i in range(0, len(mix), 4):
cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
@@ -176,9 +179,9 @@ def hashimoto_full(full_size, dataset, header, nonce):
return hashimoto(header, nonce, full_size, lambda x: dataset[x])
```
-基本上，我们保持着一个宽 128 字节的“混合物”，并多次按顺序从整个数据集中获取 128 字节，并使用 `fnv` 函数将其与混合物结合起来。 使用 128 字节的序列访问，以便每轮算法总是能从随机访问内存获取完整的页面，从而尽量减少转译后备缓冲区的疏忽，而专用集成电路在理论上能够避免这些疏忽。
+从本质上讲，我们维护一个 128 字节宽的 "mix"，并从完整数据集中重复顺序获取 128 字节，然后使用 `fnv` 函数将其与 mix 合并。 使用 128 字节的序列访问，以便每轮算法总是能从随机访问内存获取完整的页面，从而尽量减少转译后备缓冲区的疏忽，而专用集成电路在理论上能够避免这些疏忽。
-如果此算法的输出低于所需目标，即证明随机数是有效的。 请注意，在最后额外应用 `sha3_256` 将确保中间随机数的存在。提供此证据可以证明至少做了少量工作；而且此快速外部工作量证明验证可以用于反分布式拒绝服务目的。 也可提供统计保证，说明结果是一个无偏 256 位数字。
+如果此算法的输出低于所需目标，即证明随机数是有效的。 请注意，末尾额外应用的 `sha3_256` 确保了中间随机数的存在，可以提供该随机数来证明至少完成了少量的工作；这种快速的外部 PoW 验证可用于抵御 DDoS 攻击。 也可提供统计保证，说明结果是一个无偏 256 位数字。
## 挖矿 {#mining}
@@ -186,7 +189,7 @@ def hashimoto_full(full_size, dataset, header, nonce):
```python
def mine(full_size, dataset, header, difficulty):
- # zero-pad target to compare with hash on the same digit
+ # 将目标补零，以便与相同位数的哈希进行比较
target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
from random import randint
nonce = randint(0, 2**64)
@@ -209,9 +212,9 @@ def mine(full_size, dataset, header, difficulty):
请注意，为了顺利挖矿和验证，我们建议在单个线程中预先计算未来的种子哈希值和数据集。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
## 附录 {#appendix}
@@ -220,7 +223,7 @@ _还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
```python
import sha3, copy
-# Assumes little endian bit ordering (same as Intel architectures)
+# 假设为小端字节序（与 Intel 架构相同）
def decode_int(s):
return int(s[::-1].encode('hex'), 16) if s else 0
@@ -248,7 +251,7 @@ def serialize_cache(ds):
serialize_dataset = serialize_cache
-# sha3 hash function, outputs 64 bytes
+# sha3 哈希函数，输出 64 字节
def sha3_512(x):
return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x)
@@ -868,7 +871,7 @@ cache_sizes = [
166985408, 167116736, 167246656, 167378368, 167508416, 167641024,
167771584, 167903168, 168034112, 168164032, 168295744, 168427456,
168557632, 168688448, 168819136, 168951616, 169082176, 169213504,
-169344832, 169475648, 169605952, 169738048, 169866304, 169999552,
+169344832, 169475648, 169605952, 169738048, 169866304, 16999552,
170131264, 170262464, 170393536, 170524352, 170655424, 170782016,
170917696, 171048896, 171179072, 171310784, 171439936, 171573184,
171702976, 171835072, 171966272, 172097216, 172228288, 172359232,
diff --git a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
index 4621f4bda46..a1bf6583e7e 100644
--- a/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
+++ b/public/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -1,6 +1,6 @@
---
-title: 挖矿算法
-description: 以太坊挖矿所用的算法的详细介绍
+title: "挖矿算法"
+description: "以太坊挖矿所用的算法的详细介绍"
lang: zh
---
@@ -8,7 +8,7 @@ lang: zh
-工作量证明不再是以太坊共识机制的基础，这意味着挖矿已终结。 取而代之的是，以太坊将由质押了以太币的验证者保护。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅为满足对历史的兴趣。
+工作量证明不再是以太坊共识机制的基础，这意味着挖矿已被关闭。 取而代之的是，以太坊由质押以太币的验证者来保证安全。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅展示历史内容。
@@ -17,26 +17,26 @@ lang: zh
## 前提条件 {#prerequisites}
-为了更好地理解本页内容，推荐你先阅读[工作量证明共识](/developers/docs/consensus-mechanisms/pow)和[挖矿](/developers/docs/consensus-mechanisms/pow/mining)。
+为了更好地理解本页内容，我们建议您先阅读有关[工作量证明共识](/developers/docs/consensus-mechanisms/pow)和[挖矿](/developers/docs/consensus-mechanisms/pow/mining)的内容。
## Dagger Hashimoto {#dagger-hashimoto}
Dagger Hashimoto 是以太坊挖矿的先导研究算法，现已被 Ethash 取代。 它是两种不同算法：Dagger 和 Hashimoto的融合。 它只是一个研究实现，并在以太坊主网启动时被 Ethash 取代。
-[Dagger](http://www.hashcash.org/papers/dagger.html) 会生成一个[有向无环图](https://en.wikipedia.org/wiki/Directed_acyclic_graph)，将共同取哈希值的内容随机划分。 其核心原理是，每个随机数只取总数据树的一小部分。 挖矿禁止为每个随机数重新计算子树，因此需要总存储树，但若为验证某个随机数的价值，则可以重新计算。 Dagger 的设计目的是替代诸如Scrypt的已有算法。后者是“内存困难算法”，但当它们的内存困难程度增加到可信的安全水平时将很难验证。 然而，Dagger 容易受到共享内存硬件加速的影响，因此我们放弃了这种算法，转而采用了其他研究途径。
+[Dagger](http://www.hashcash.org/papers/dagger.html) 涉及生成一个[有向无环图](https://en.wikipedia.org/wiki/Directed_acyclic_graph)，它的随机切片会被一起哈希。 其核心原理是，每个随机数只取总数据树的一小部分。 挖矿禁止为每个随机数重新计算子树，因此需要总存储树，但若为验证某个随机数的价值，则可以重新计算。 Dagger 的设计目的是替代诸如Scrypt的已有算法。后者是“内存困难算法”，但当它们的内存困难程度增加到可信的安全水平时将很难验证。 然而，Dagger 容易受到共享内存硬件加速的影响，因此我们放弃了这种算法，转而采用了其他研究途径。
-[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) 算法通过实现输入/输出密集的特性(即，内存读取速度是挖矿过程中的限制因素)来增加对专用集成电路的抵抗性。 理论上来说使用内存比使用计算能力更容易；已有价值数十亿美元的经费投入被用于研究针对不同应用场景的内存优化，通常涉及近随机访问模式(即“随机存取存储器”)。 因此，现有的内存对评价算法效率的能力更接近最优。 Hashimoto 使用区块链作为数据源，同时满足上述第 (1) 和第 (3) 条。
+[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) 是一种通过受 I/O 限制（即，内存读取是挖矿过程中的限制因素）来增加抗 ASIC 性的算法。 理论上来说使用内存比使用计算能力更容易；已有价值数十亿美元的经费投入被用于研究针对不同应用场景的内存优化，通常涉及近随机访问模式(即“随机存取存储器”)。 因此，现有的内存对评价算法效率的能力更接近最优。 Hashimoto 使用区块链作为数据源，同时满足上述第 (1) 和第 (3) 条。
-Dagger-Hashimoto 是在 Dagger 和 Hashimoto 的基础上改进而来的以太币挖矿算法。 Dagger Hashimoto 和 Hashimoto 的差别在于，Dagger Hashimoto 的数据来源并非是区块链，而是自定义生成的数据集，这些数据集将基于所有 N 区块上的区块数据进行更新。 这些数据集采用 Dagger 算法生成，可为轻量级客户端的验证算法高效计算特定于每个随机数的子集。 Dagger Hashimoto 算法和 Dagger 算法的差别在于，与原来的 Dagger 不同，用于查询区块的数据集只是暂时的，只会偶尔更新（例如每周更新一次）。 这意味着生成数据集的工作量接近于零，所以 Sergio Lerner 关于共享内存加速的论据变得微不足道。
+Dagger-Hashimoto 是在 Dagger 和 Hashimoto 的基础上改进而来的以太币挖矿算法。 Dagger Hashimoto 和 Hashimoto 的差别在于，Dagger Hashimoto 的数据来源并非是区块链，而是自定义生成的数据集，这些数据集将基于所有 N 区块上的区块数据进行更新。 这些数据集采用 Dagger 算法生成，可为轻量级客户端的验证算法高效计算特定于每个随机数的子集。 Dagger Hashimoto 和 Dagger 的区别在于，与原来的 Dagger 不同，用于查询区块的数据集是半永久性的，只会偶尔更新（例如，每周更新一次）。 这意味着生成数据集的工作量接近于零，所以 Sergio Lerner 关于共享内存加速的论据变得微不足道。
-有关 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) 的更多信息。
+更多关于 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) 的内容。
## Ethash {#ethash}
Ethash 是在现已弃用的工作量证明架构下，实际用于真正的以太坊主网的挖矿算法。 Ethash 实际上是为 Dagger Hashimoto 算法进行重要更新后的一个特殊版本命名的新名称，但它仍然继承了其前身的基本原理。 以太坊主网只采用过 Ethash——Dagger Hashimoto 是挖矿算法的研发版本，在以太坊主网开始挖矿前被取代。
-[有关 Ethash 的更多信息](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash)。
+更多关于 [Ethash](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash) 的内容。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
diff --git a/public/content/translations/zh/developers/docs/dapps/index.md b/public/content/translations/zh/developers/docs/dapps/index.md
index bbe1be5f053..f3b0ac33a3e 100644
--- a/public/content/translations/zh/developers/docs/dapps/index.md
+++ b/public/content/translations/zh/developers/docs/dapps/index.md
@@ -1,94 +1,94 @@
---
-title: 去中心化应用程序简介
+title: "去中心化应用程序技术介绍"
description:
lang: zh
---
-去中心化应用程序 (dapp) 是在去中心化网络上构建的应用程序，结合了[智能合约](/developers/docs/smart-contracts/)和前端用户界面。 请注意，就像开放 API 一样，以太坊智能合约具有可访问性和透明性，所以你的 dapp 里甚至可以包含其他人写过的智能合约。
+去中心化应用程序 (dapp) 是在去中心化网络上构建的应用程序，它结合了[智能合约](/developers/docs/smart-contracts/)和前端用户界面。 请注意，就像开放 API 一样，以太坊智能合约具有可访问性和透明性，所以你的 dapp 里甚至可以包含其他人写过的智能合约。
## 前提条件 {#prerequisites}
-在学习 dapp 之前，你应该了解[区块链基础知识](/developers/docs/intro-to-ethereum/)，并了解以太坊网络及其去中心化方式。
+在学习去中心化应用程序之前，您应该先了解[区块链基础知识](/developers/docs/intro-to-ethereum/)，并阅读有关以太坊网络及其去中心化方式的资料。
-## dapp 的定义 {#definition-of-a-dapp}
+## 去中心化应用程序的定义 {#definition-of-a-dapp}
一个 dapp 的后端代码在一个去中心化 P2P 网络上运行。 与此相对应的，是在中心化服务器上运行后端代码的应用程序。
-dapp 可以用任何语言编写（就像是一个 app）。它有前端代码和用户界面，能调用其后端。 此外，它的前端可以托管在去中心化存储上，例如 [IPFS](https://ipfs.io/)。
+一个去中心化应用程序可以用任何语言编写前端代码和用户界面（就像一个应用程序一样），来调用其后端。 此外，其前端可以托管在 [IPFS](https://ipfs.io/) 等去中心化存储上。
-- **去中心化** - dapp 在以太坊上运行，这是一个开放的公共去中心化平台，没有任何一个人或团体可以控制
-- **确定性** ，无论执行的环境如何，都执行相同的功能
-- **图灵完备** - dapp 可以根据所需资源执行任何操作
-- **隔离性** - 它们在称为 EVM 的虚拟环境中执行。即使智能合约出现问题，也不会妨碍区块链网络的正常运行
+- **去中心化** - 去中心化应用程序在以太坊上运行，这是一个开放的公共去中心化平台，没有任何个人或团体可以控制
+- **确定性** - 无论在何种环境中执行，去中心化应用程序都会执行相同的功能
+- **图灵完备** - 只要有必需的资源，去中心化应用程序就能执行任何操作
+- **隔离性** - 去中心化应用程序在称为以太坊虚拟机的虚拟环境中执行，因此，即使智能合约存在漏洞，也不会妨碍区块链网络的正常运作
-### 智能合约 {#on-smart-contracts}
+### 关于智能合约 {#on-smart-contracts}
-要引入 dapp，我们需要引入智能合约 —— dapp 的后端，因为缺少更好的术语。 有关详细概述，请访问我们的[智能合约](/developers/docs/smart-contracts/)部分。
+要引入 dapp，我们需要引入智能合约 —— dapp 的后端，因为缺少更好的术语。 要了解详细概览，请前往我们的[智能合约](/developers/docs/smart-contracts/)部分。
智能合约是一种在以太坊网络上的计算机程序，它严格按照事先编写的代码来运行。 智能合约一旦部署到以太坊网络中，就无法更改。 Dapps 可以是去中心化的，就是由于它们受智能合约的既定逻辑控制，而不是个人或公司。 这也意味着你需要非常仔细地设计合约，并进行全面测试。
-## Dapp 开发的好处 {#benefits-of-dapp-development}
+## 去中心化应用程序开发的好处 {#benefits-of-dapp-development}
-- **零停机时间** – 一旦将某 dapp 的智能合约部署到区块链上，整个网络都能为那些希望与合约互动的客户提供服务。 因此，恶意参与者无法针对单个 dapp 发起 DoS 攻击。
-- **隐私** – 你不需要提供真实世界的身份来部署或与 dapp 进行交互。
-- **抵制审查** – 网络上没有任何一个实体可以阻止用户提交交易、部署 dapp 或读取区块链上的数据。
-- **数据完整性** – 由于采用了加密基元，存储在区块链上的数据是不可更改和无可争议的。 恶意行为者无法伪造已经公开的交易或其他数据。
-- **去信任的计算/可验证的行为** – 智能合约可以分析并保证以可预测的方式执行，而去信任中心化组织。 这在传统模式下是不存在的，比如我们使用网上银行系统时，我们要相信金融机构不会滥用我们的金融数据，不会篡改记录，也不会被黑客攻击。
+- **零停机时间** – 一旦智能合约部署在区块链上，整个网络将始终能够为希望与合约交互的客户端提供服务。 因此，恶意参与者无法针对单个 dapp 发起 DoS 攻击。
+- **隐私** – 您无需提供真实身份即可部署去中心化应用程序或与之交互。
+- **抗审查** – 网络上没有任何单个实体可以阻止用户提交交易、部署去中心化应用程序或从区块链读取数据。
+- **完整的数据完整性** – 得益于加密基元，存储在区块链上的数据是不可变且无可争议的。 恶意行为者无法伪造已经公开的交易或其他数据。
+- **无需信任的计算/可验证的行为** – 智能合约可以被分析并保证以可预测的方式执行，而无需信任一个中心化的权威机构。 这在传统模式下并非如此；例如，当我们使用网上银行系统时，我们必须相信金融机构不会滥用我们的金融数据、篡改记录或遭到黑客攻击。
-## Dapp 开发的缺陷 {#drawbacks-of-dapp-development}
+## 去中心化应用程序开发的缺点 {#drawbacks-of-dapp-development}
-- **维护** – dapp 可能更难维护，因为发布到区块链的代码和数据更难修改。 在部署后，开发人员很难对去中心化应用程序（或其存储的底层数据）进行更新，即使在旧版本中发现了漏洞或安全风险。
-- **性能开销** – 巨大的性能开销，而且难以扩展更多性能。 为了达到以太坊所追求的安全、完整、透明和可靠的水平，每个节点都会运行和存储每一笔交易。 除此之外，达成权益证明共识也需要时间。
-- **网络拥塞** – 至少在当前模型中，如果一个 dapp 使用了太多的计算资源，整个网络都会承担影响。 目前，该网络每秒只能处理约 10-15 笔交易；如果交易发送的速度超过这个速度，未确认的交易池会迅速膨胀。
-- **用户体验** – 设计用户友好的体验可能更难。普通终端用户可能会发现，很难以真正安全的方式设置与区块链互动所需的工具堆栈。
-- **集中化** — 无论如何，建立在以太坊基础层之上的用户友好型和开发人员友好型解决方案最终看起来都像集中式服务。 例如，这种服务可以在服务器端存储密钥或其他敏感信息，使用中心化服务器为前端服务，或在写到区块链之前在中心化服务器上运行重要的业务逻辑。 这消除了区块链与传统模式相比的许多（并不是全部）优势。
+- **维护** – 去中心化应用程序可能更难维护，因为发布到区块链的代码和数据更难修改。 在部署后，开发人员很难对去中心化应用程序（或其存储的底层数据）进行更新，即使在旧版本中发现了漏洞或安全风险。
+- **性能开销** – 存在巨大的性能开销，并且扩容非常困难。 为了达到以太坊所追求的安全、完整、透明和可靠的水平，每个节点都会运行和存储每一笔交易。 除此之外，达成权益证明共识也需要时间。
+- **网络拥堵** – 当一个去中心化应用程序使用过多的计算资源时，整个网络都会堵塞。 目前，该网络每秒只能处理约 10-15 笔交易；如果交易发送的速度超过这个速度，未确认的交易池会迅速膨胀。
+- **用户体验** – 设计用户友好的体验可能更难，因为普通最终用户可能会发现，要以真正安全的方式设置与区块链交互所需的工具栈非常困难。
+- **中心化** – 无论如何，在以太坊基础层之上构建的用户友好型和开发者友好型解决方案，最终可能看起来都像中心化服务。 例如，这种服务可以在服务器端存储密钥或其他敏感信息，使用中心化服务器为前端服务，或在写到区块链之前在中心化服务器上运行重要的业务逻辑。 这消除了区块链与传统模式相比的许多（并不是全部）优势。
## 更愿意通过视频学习？ {#visual-learner}
.json`，其中 `` 是分配给密钥的 128 位 UUID（密钥地址的隐私保护代理）。
+
+所有这些文件都有一个关联的密码。 要派生给定 `.json` 文件的密钥，首先派生该文件的加密密钥；此操作通过获取该文件的密码，并将其传递到由 `kdf` 键描述的密钥派生函数来完成。 KDF 函数中依赖于 KDF 的静态和动态参数在 `kdfparams` 键中描述。
+
+PBKDF2 必须得到所有符合最低标准的实现的支持，表示为：
+
+- `kdf`：`pbkdf2`
+
+对于 PBKDF2，kdfparams 包括：
+
+- `prf`：必须是 `hmac-sha256`（将来可能会扩展）；
+- `c`：迭代次数；
+- `salt`：传递给 PBKDF 的盐；
+- `dklen`：派生密钥的长度。 必须 >= 32。
+
+派生出文件的密钥后，应该通过派生 MAC 来验证它。 MAC 的计算方法是：将派生密钥的次左边 16 个字节与 `ciphertext` 键的内容拼接，形成一个字节数组，然后计算该数组的 SHA3 (keccak-256) 哈希值，即：
+
+```js
+KECCAK(DK[16..31] ++ )
+```
+
+（其中 `++` 是拼接运算符）
+
+应将此值与 `mac` 键的内容进行比较；如果二者不同，则应请求输入其他密码（或取消操作）。
+
+文件密钥验证通过后，即可使用由 `cipher` 键指定、并由 `cipherparams` 键参数化的对称加密算法，来解密密文（即文件中 `ciphertext` 键的值）。 如果派生密钥的大小和算法密钥的大小不匹配，则用零来填充。派生密钥的最右边字节应该作为算法的密钥。
+
+所有符合最低标准的实现必须支持 AES-128-CTR 算法，表示为：
+
+- `cipher: aes-128-ctr`
+
+该密码需要以下参数，作为 cipherparams 密钥的密钥：
+
+- `iv`：加密算法的 128 位初始化向量。
+
+加密算法的密钥是派生密钥最左边的 16 字节，即 `DK[0..15]`。
+
+密钥的创建/加密本质上应是这些指令的逆向操作。 确保 `uuid`、`salt` 和 `iv` 确实是随机的。
+
+除了作为版本“硬”标识符的 `version` 字段外，实现方也可以使用 `minorversion` 来跟踪对格式的较小的、非破坏性的更改。
+
+## 测试向量 {#test-vectors}
+
+详细信息：
+
+- `地址`：`008aeeda4d805471df9b2a5b0f38a0c3bcba786b`
+- `ICAP`：`XE542A5PZHH8PYIZUBEJEO0MFWRAPPIL67`
+- `UUID`：`3198bc9c-6672-5ab3-d9954942343ae5b6`
+- `密码`：`testpassword`
+- `机密`：`7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d`
+
+### PBKDF2-SHA-256 {#PBKDF2-SHA-256}
+
+使用 `AES-128-CTR` 和 `PBKDF2-SHA-256` 的测试向量：
+
+`~/.web3/keystore/3198bc9c-6672-5ab3-d9954942343ae5b6.json` 的文件内容：
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "6087dab2f9fdbbfaddc31a909735c1e6"
+ },
+ "ciphertext": "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
+ "kdf": "pbkdf2",
+ "kdfparams": {
+ "c": 262144,
+ "dklen": 32,
+ "prf": "hmac-sha256",
+ "salt": "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
+ },
+ "mac": "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**中间值**：
+
+`派生密钥`：`f06d69cdc7da0faffb1008270bca38f5e31891a3a773950e6d0fea48a7188551`
+`MAC 正文`：`e31891a3a773950e6d0fea48a71885515318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46`
+`MAC`：`517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2`
+`加密密钥`：`f06d69cdc7da0faffb1008270bca38f5`
+
+### Scrypt {#scrypt}
+
+使用 AES-128-CTR 和 Scrypt 的测试向量：
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "740770fce12ce862af21264dab25f1da"
+ },
+ "ciphertext": "dd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2",
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "25710c2ccd7c610b24d068af83b959b7a0e5f40641f0c82daeb1345766191034"
+ },
+ "mac": "337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**中间值**：
+
+`派生密钥`：`7446f59ecc301d2d79bc3302650d8a5cedc185ccbb4bf3ca1ebd2c163eaa6c2d`
+`MAC 正文`：`edc185ccbb4bf3ca1ebd2c163eaa6c2ddd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2`
+`MAC`：`337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c`
+`加密密钥`：`7446f59ecc301d2d79bc3302650d8a5c`
+
+## 与版本 1 的改动 {#alterations-from-v2}
+
+此版本修复了与[此处](https://github.com/ethereum/homestead-guide/blob/master/old-docs-for-reference/go-ethereum-wiki.rst/Passphrase-protected-key-store-spec.rst)发布的版本 1 的几处不一致。 简短来说，它们是：
+
+- 大小写不合理和不一致（scrypt 小写，Kdf 大小写混合，MAC 大写）。
+- 地址不必要并损害了隐私。
+- `Salt` 本质上是密钥派生函数的一个参数，因此应与该函数相关联，而不是与整个加密机制相关联。
+- _SaltLen_ 是不必要的（直接从 Salt 派生即可）。
+- 给出了密钥派生函数，但加密算法是硬性指定的。
+- `Version` 本质上是一个数字，然而却是一个字符串（结构化版本管理可以用一个字符串来实现，但对于一个很少变化的配置文件格式来说，可以认为是超出了范围）。
+- `KDF` 和 `cipher` 在概念上是同级关系，但组织方式却不同。
+- `MAC` 是通过一段与空白字符无关的数据计算的（!）
+
+我们对格式进行了修改，得到了以下文件，其功能和之前链接页面上的示例一样：
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-cbc",
+ "ciphertext": "07533e172414bfa50e99dba4a0ce603f654ebfa1ff46277c3e0c577fdc87f6bb4e4fe16c5a94ce6ce14cfa069821ef9b",
+ "cipherparams": {
+ "iv": "16d67ba0ce5a339ff2f07951253e6ba8"
+ },
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "06870e5e6a24e183a5c807bd1c43afd86d573f7db303ff4853d135cd0fd3fe91"
+ },
+ "mac": "8ccded24da2e99a11d48cda146f9cc8213eb423e2ea0d8427f41c3be414424dd",
+ "version": 1
+ },
+ "id": "0498f19a-59db-4d54-ac95-33901b4f1870",
+ "version": 2
+}
+```
+
+## 与版本 2 的改动 {#alterations-from-v2}
+
+第 2 版是早期 C++ 实现的版本，有很多漏洞。 所有重要内容保持不变。
diff --git a/public/content/translations/zh/developers/docs/design-and-ux/dex-design-best-practice/index.md b/public/content/translations/zh/developers/docs/design-and-ux/dex-design-best-practice/index.md
index 92e6b7c2c7f..cac3cb52dc1 100644
--- a/public/content/translations/zh/developers/docs/design-and-ux/dex-design-best-practice/index.md
+++ b/public/content/translations/zh/developers/docs/design-and-ux/dex-design-best-practice/index.md
@@ -1,6 +1,6 @@
---
-title: 去中心化交易所 (DEX) 设计最佳做法
-description: 说明代币交换用户体验/用户界面决策的指南
+title: "去中心化交易所 (DEX) 设计最佳做法"
+description: "说明代币交换用户体验/用户界面决策的指南"
lang: zh
---
@@ -206,7 +206,7 @@ Figma 工具包也附于本文底部 - 请随意使用，快速制作你自己
-### 使用此 figma 文件构建你自己的设计 {#build-your-own-with-this-figma-file}
+## 使用此 figma 文件构建你自己的设计 {#build-your-own-with-this-figma-file}
得益于多个协议的共同作用，去中心化交易所设计已经有了显著改进。 我们知道用户需要哪些信息，应该如何展示这些信息，以及如何使流程尽可能流畅。
希望这篇文章提供了关于用户体验原则的全面概述。
diff --git a/public/content/translations/zh/developers/docs/design-and-ux/heuristics-for-web3/index.md b/public/content/translations/zh/developers/docs/design-and-ux/heuristics-for-web3/index.md
index 71f9c3cd9fc..98961cff158 100644
--- a/public/content/translations/zh/developers/docs/design-and-ux/heuristics-for-web3/index.md
+++ b/public/content/translations/zh/developers/docs/design-and-ux/heuristics-for-web3/index.md
@@ -1,11 +1,11 @@
---
-title: Web3 界面设计的 7 个启发法
-description: 改进 Web3 可用性的原则
+title: "Web3 界面设计的 7 个启发法"
+description: "改进 Web3 可用性的原则"
lang: zh
---
可用性启发法包含广泛的“经验法则”，你可以用它来衡量网站的可用性。
-这 7 种启发法是为 Web3 量身定制的，并且应该与 Jakob Nielsen 的 [界面设计的 10 条基本原则] (https://www.nngroup.com/articles/ten-usability-heuristics/) 一起使用。
+这 7 种启发法是为 Web3 量身定制的，并且应该与 Jakob Nielsen 的 [界面设计的 10 条基本原则](https://www.nngroup.com/articles/ten-usability-heuristics/) 一起使用。
## Web3 的 7 个可用性启发法 {#seven-usability-heuristics-for-web3}
@@ -54,7 +54,7 @@ lang: zh
**示例：**
在页脚以显眼的尺寸包含你的审计内容。
-
+
### 3. 突显最重要的信息 {#the-most-important-info-is-obvious}
diff --git a/public/content/translations/zh/developers/docs/design-and-ux/index.md b/public/content/translations/zh/developers/docs/design-and-ux/index.md
index bce01f31939..1e06acd29cc 100644
--- a/public/content/translations/zh/developers/docs/design-and-ux/index.md
+++ b/public/content/translations/zh/developers/docs/design-and-ux/index.md
@@ -1,91 +1,86 @@
---
-title: Web3 中的设计和用户体验
-description: 介绍 Web3 领域和以太坊中的用户体验设计和研究
+title: "Web3 中的设计和用户体验"
+description: "介绍 Web3 领域和以太坊中的用户体验设计和研究"
lang: zh
---
你不熟悉用以太坊进行设计吗？ 如果是的话，那么这个地方你来对了。 以太坊社区已经编写了很多资源，介绍 Web3 的设计和研究基础知识。 你将学习一些核心概念，它们可能与你熟悉的其他应用程序设计不同。
-需要先对 Web3 有更基本的了解吗？ 请浏览[**学习中心**](/learn/)。
+需要先对 Web3 有更基本的了解吗？ 查看[**学习中心**](/learn/)。
## 从用户研究开始 {#start-with-user-research}
-有效的设计不仅仅是创建赏心悦目的用户界面。 还涉及到深入了解用户的需求、目标以及驱动因素。 因此，我们强烈建议所有设计师采用一种设计流程，例如[**双钻流程**](https://en.wikipedia.org/wiki/Double_Diamond_(design_process_model))，以确保其设计经过深思熟虑且有意为之。
+有效的设计不仅仅是创建赏心悦目的用户界面。 还涉及到深入了解用户的需求、目标以及驱动因素。 因此，我们强烈建议所有设计师采用一种设计流程，例如[**双钻流程**](https://en.wikipedia.org/wiki/Double_Diamond_\(design_process_model\))，以确保其设计经过深思熟虑且有意为之。
-- [Web3 需要更多用户体验研究人员和设计师](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) - 当前设计成熟度概述
-- [在 Web3 中进行用户体验研究的简明指南](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) - 研究方法简明指南
-- [如何在 Web3 中进行用户体验决策](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) - 定量和定性研究简要概述及两者之间的区别（6 分钟视频）
-- [在 Web3 中担任用户体验研究人员](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) - 在 Web3 中担任用户体验研究人员的感受之个人看法
+- [Web3 需要更多的用户体验研究员和设计师](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) - 当前设计成熟度概述
+- [web3 用户体验研究简明指南](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) - 如何开展研究的简明指南
+- [如何在 Web3 中进行用户体验决策](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) - 定量和定性研究简要概述及两者之间的区别（视频，6 分钟）
+- [在 web3 中担任用户体验研究员](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) - 关于在 web3 中担任用户体验研究员的个人观点
-## 针对 Web3 中的研究的调查 {#research-in-web3}
+## Web3 研究 {#research-in-web3}
下面是一份已在 Web3 中进行的用户研究的精选清单，可能对设计和产品决策有所裨益，也可为自行进行研究提供灵感。
-| 关注领域 | 姓名 |
-|:----------------------------------------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 加密货币入门 | [WalletConnect Pulse 2024：加密货币消费者的情绪及使用情况](https://walletconnect.com/pulse-2024-crypto-consumer-report) |
-| 加密货币入门 | [CRADL：加密货币中的用户体验](https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing) |
-| 加密货币入门 | [CRADL：加密货币入门](https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing) |
-| 加密货币入门 | [比特币用户体验报告](https://github.com/patestevao/BitcoinUX-report/blob/master/report.md) |
-| 加密货币入门 | [ConSensys：2023 年全球 Web3 认知度状况](https://consensys.io/insight-report/web3-and-crypto-global-survey-2023) |
-| 加密货币入门 | [NEAR：加速采用之路](https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view) |
-| 权益质押 | [OpenUX：Rocket Pool 节点运营商的用户体验](https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf) |
-| 权益质押 | [质押：主要趋势、要点与预测 - Eth Staker](https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo) |
-| 权益质押 | [多重应用程序质押](https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20(MAS)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf) |
-| 去中心化自治组织 | [2022 年去中心化自治组织研究更新：去中心化自治组织构建者需要什么？](https://blog.aragon.org/2022-dao-research-update/) |
-| 去中心化金融 | [2024 年去中心化金融状况](https://stateofdefi.org/)（调查进行中） |
-| 去中心化金融 | [保险池](https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool) |
-| 去中心化金融 | [ConSensys：2022 年去中心化金融用户研究报告](https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf) |
-| 元宇宙 | [元宇宙：用户研究报告](https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000) |
-| 元宇宙 | [野外冒险：对元宇宙用户的研究](https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube)（27 分钟视频） |
-| Ethereum.org 用户体验数据 | [可用性与用户满意度调查仪表板 - Ethereum.org](https://lookerstudio.google.com/reporting/0a189a7c-a890-40db-a5c6-009db52c81c9) |
-
-## Web3 相关设计 {#design-for-web3}
-
-- [Web3 用户体验设计手册](https://web3ux.design/) - 设计 Web3 应用程序实用指南
-- [Web3 设计原则](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) - 区块链去中心化应用程序的用户体验规则构架
+| 关注领域 | 名称 |
+| :------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 加密货币入门 | [The Reown Pulse 2024：加密货币消费者情绪和使用情况](https://reown.com/blog/unveiling-walletconnects-consumer-crypto-report) |
+| 加密货币入门 | [CRADL：加密货币的用户体验](https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing) |
+| 加密货币入门 | [CRADL：加密货币入门](https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing) |
+| 加密货币入门 | [比特币用户体验报告](https://github.com/patestevao/BitcoinUX-report/blob/master/report.md) |
+| 加密货币入门 | [Consensys：2023 年全球 Web3 认知状况](https://consensys.io/insight-report/web3-and-crypto-global-survey-2023) |
+| 加密货币入门 | [NEAR：加速采用之旅](https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view) |
+| 质押 | [OpenUX：Rocket Pool 节点运营商用户体验](https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf) |
+| 质押 | [质押：主要趋势、要点和预测 - Eth Staker](https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo) |
+| 质押 | [多应用质押](https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20\(MAS\)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf) |
+| DAO | [2022 年 DAO 研究更新：DAO 构建者需要什么？](https://blog.aragon.org/2022-dao-research-update/) |
+| DeFi | [保险池](https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool) |
+| DeFi | [Consensys：2022 年 DeFi 用户研究报告](https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf) |
+| 元宇宙 | [元宇宙：用户研究报告](https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000) |
+| 元宇宙 | [Safari 之旅：在元宇宙中研究用户](https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube)（视频，27 分钟） |
+
+## Web3 设计 {#design-for-web3}
+
+- [Web3 用户体验设计手册](https://web3ux.design/) - 设计 Web3 应用程序的实用指南
+- [Web3 设计原则](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) - 基于区块链的去中心化应用程序的用户体验规则框架
- [区块链设计原则](https://medium.com/design-ibm/blockchain-design-principles-599c5c067b6e) - IBM 区块链设计团队的经验教训
-- [Web3 设计模式](https://www.web3designpatterns.io/) - 真实 Web3 产品的精选设计模式库
-- [W3design.io](https://w3design.io/) - 生态系统中不同项目的精选用户界面流程库
-- [Neueux](https://neueux.com/apps) - 具有多种过滤选项的用户界面流程库
-- [Web3 的可用性危机：你需要知道的一切！](https://www.youtube.com/watch?v=oBSXT_6YDzg) - 关于以开发者为中心的项目建设中漏洞的小组讨论（34 分钟视频）
+- [Neueux.com](https://neueux.com/apps) - 具有多种筛选选项的用户流程界面库
+- [Web3 的可用性危机：你需要知道什么！](https://www.youtube.com/watch?v=oBSXT_6YDzg) - 关于以开发者为中心的项目建设中陷阱的小组讨论（视频，34 分钟）
-## 入门指南 {#getting-started}
+## 入门 {#getting-started}
-- [Web3 启发法](/developers/docs/design-and-ux/heuristics-for-web3/) - Web3 界面设计的 7 个启发法
-- [去中心化交易所 (DEX) 设计最佳实践](/developers/docs/design-and-ux/dex-design-best-practice/) - 去中心化交易所设计指南
+- [Web3 启发式方法](/developers/docs/design-and-ux/heuristics-for-web3/) - Web3 界面设计的 7 种启发式方法
+- [DEX 设计最佳实践](/developers/docs/design-and-ux/dex-design-best-practice/) - 去中心化交易所设计指南
## Web3 设计案例研究 {#design-case-studies}
-- [Deep Work Studio](https://deepwork.studio/case-studies/)
-- [加密货币用户体验手册](https://www.cryptouxhandbook.com/)
-- [在 OpenSea 售卖非同质化代币](https://builtformars.com/case-studies/opensea)
-- [钱包用户体验分解：钱包需要怎样改变](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver)（20 分钟视频）
+- [Deep Work Studio](https://www.deepwork.studio/case-studies)
+- [在 OpenSea 上出售 NFT](https://builtformars.com/case-studies/opensea)
+- [钱包用户体验分析：钱包需要如何改变](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver)（视频，20 分钟）
-## 设计奖励 {#bounties}
+## 设计赏金 {#bounties}
- [Dework](https://app.dework.xyz/bounties)
-- [Buildbox 黑客马拉松](https://app.buidlbox.io/)
-- [ETHGlobal 骇客松](https://ethglobal.com/)
+- [Buildbox 黑客松](https://app.buidlbox.io/)
+- [ETHGlobal 黑客松](https://ethglobal.com/)
-## 设计去中心化自治组织和社区 {#design-daos-and-communities}
+## 设计 DAO 和社区 {#design-daos-and-communities}
加入专业的社区主导型组织或设计小组，与其他成员讨论设计和研究相关的主题和趋势。
- [Vectordao.com](https://vectordao.com/)
- [Deepwork.studio](https://www.deepwork.studio/)
-- [Designer-dao.xyz](https://www.designer-dao.xyz/)
- [We3.co](https://we3.co/)
- [Openux.xyz](https://openux.xyz/)
-## 设计体系 {#design-systems}
+## 设计系统和其他设计资源 {#design-systems-and-resources}
-- [乐观设计](https://www.figma.com/@optimism) (Figma)
-- [Ethereum.org 设计体系](https://www.figma.com/@ethdotorg) (Figma)
-- [Finity，来自 Polygon 的设计体系](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
-- [Kleros 设计体系](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
-- [安全设计体系](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
-- [ENS 设计体系](https://thorin.ens.domains/)
-- [Mirror 设计体系](https://degen-xyz.vercel.app/)
+- [Optimism 设计](https://www.figma.com/@optimism) (Figma)
+- [Ethereum.org 设计系统](https://www.figma.com/@ethdotorg) (Figma)
+- [Finity，Polygon 的一个设计系统](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
+- [Kleros 设计系统](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
+- [Safe 设计系统](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
+- [ENS 设计系统](https://thorin.ens.domains/)
+- [Mirror 设计系统](https://degen-xyz.vercel.app/)
-**本页所列文章和项目并非官方认可，**仅供参考。 我们根据我们[上线政策](/contributing/design/adding-design-resources)中的条件添加本页的链接。 如果你希望我们添加某个项目/某篇文章，请在 [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md) 上编辑本页。
+**本页所列文章和项目并非官方认可**，仅供参考。
+我们根据[上榜政策](/contributing/design/adding-design-resources)中的标准将链接添加到此页面。 如果你希望我们添加项目/文章，请在 [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md) 上编辑此页面。
diff --git a/public/content/translations/zh/developers/docs/development-networks/index.md b/public/content/translations/zh/developers/docs/development-networks/index.md
index 1c26e6d3cd0..7158a9bc13f 100644
--- a/public/content/translations/zh/developers/docs/development-networks/index.md
+++ b/public/content/translations/zh/developers/docs/development-networks/index.md
@@ -1,6 +1,6 @@
---
-title: 开发网络
-description: 对以太坊应用的开发网络环境与开发工具的概览。
+title: "开发网络"
+description: "对以太坊应用的开发网络环境与开发工具的概览。"
lang: zh
---
@@ -8,9 +8,9 @@ lang: zh
这和在本地运行一个本地网页服务器相似。为了测试你的去中心化应用程序，你可以使用开发网络创建一个本地的区块链。 这些以太坊开发网络提供了能够比公共测试网更快的迭代功能（例如你不需要从测试网获取以太币）。
-## 前置要求 {#prerequisites}
+## 前提条件 {#prerequisites}
-你应该先理解[以太坊堆栈](/developers/docs/ethereum-stack/)和[以太坊网络](/developers/docs/networks/)基础知识才能进入开发网络。
+在深入研究开发网络之前，你应该先了解[以太坊技术栈](/developers/docs/ethereum-stack/)和[以太坊网络](/developers/docs/networks/)的基础知识。
## 什么是开发网络？ {#what-is-a-development-network}
@@ -18,39 +18,37 @@ lang: zh
**为什么不在本地运行一个标准的以太坊节点？**
-你_可以_[运行节点](/developers/docs/nodes-and-clients/#running-your-own-node)，但由于开发网络是以开发为目的而建立的，它们往往会打包一些快捷方便的功能，例如：
+你_可以_[运行一个节点](/developers/docs/nodes-and-clients/#running-your-own-node)，但由于开发网络是专为开发目的而构建的，它们通常会附带一些方便的功能，例如：
-- 为本地区块链提供数据，这个功能很重要（例如使用以太币余额的帐户）
+- 确定性地为你的本地区块链填充数据（例如，带有 ETH 余额的帐户）
- 用接收的每笔交易，按照顺序即时产生区块，毫不延迟。
- 增强调试和日志功能
## 可用工具 {#available-projects}
-**注意**：大多数[开发框架](/developers/docs/frameworks/)包含一个内置的开发网络。 我们建议从一个框架开始[设置你的本地开发环境](/developers/local-environment/)。
+**注意**：大多数[开发框架](/developers/docs/frameworks/)都包含一个内置的开发网络。 我们建议从一个框架开始[设置你的本地开发环境](/developers/local-environment/)。
-### 安全帽网络 {#hardhat-network}
+### Hardhat 网络 {#hardhat-network}
一个专门用于开发的本地以太坊网络。 该网络允许你部署合约，运行测试并调试代码。
-安全帽网络内置了安全帽，安全帽是专业人员的以太坊开发环境。
+Hardhat网络内置了Hardhat，Hardhat是专业人员的以太坊开发环境。
- [网站](https://hardhat.org/)
-- [GitHub](https://github.com/nomiclabs/hardhat)
+- [GitHub](https://github.com/NomicFoundation/hardhat)
### 本地信标链 {#local-beacon-chains}
一些共识客户端具有内置工具，用于启动本地信标链以进行测试。 提供了 Lighthouse、Nimbus 和 Lodestar 的说明：
- [使用 Lodestar 的本地测试网](https://chainsafe.github.io/lodestar/contribution/advanced-topics/setting-up-a-testnet#post-merge-local-testnet/)
-- [使用 Lightthouse 的本地测试网](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
+- [使用 Lighthouse 的本地测试网](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
### 公共以太坊测试链 {#public-beacon-testchains}
-以太坊还有两个维护中的公共测试网实现：Sepolia 和 Hoodi。 Sepolia 是推荐的应用程序开发标准测试网，具有封闭的验证器集以实现快速同步。 Hoodi 是一个用于验证和质押的测试网，它使用开放的验证器集，并允许任何人进行验证。
+以太坊还有两个维护中的公共测试网实现：Sepolia 和 Hoodi。 推荐使用获得长期支持的测试网 Hoodi，任何人都可以自由地在其上验证。 Sepolia 采用许可制的验证者集合，这意味着在该测试网中没有面向公众的新验证者访问权限。
-- [Hoodi 质押启动板](https://hoodi.launchpad.ethereum.org/en/)
-- [Sepolia 网站](https://sepolia.dev/)
-- [Hoodi 网站](https://hoodi.ethpandaops.io/)
+- [Hoodi 质押启动板](https://hoodi.launchpad.ethereum.org/)
### Kurtosis 以太坊包 {#kurtosis}
@@ -63,11 +61,11 @@ Kurtosis 是一个用于多容器测试环境的构建系统，让开发者能
- [GitHub](https://github.com/kurtosis-tech/kurtosis)
- [相关文档](https://docs.kurtosis.com/)
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
-## 相关主题 {#related-topics}
+## 相关话题 {#related-topics}
- [开发框架](/developers/docs/frameworks/)
- [设置本地开发环境](/developers/local-environment/)
diff --git a/public/content/translations/zh/developers/docs/ethereum-stack/index.md b/public/content/translations/zh/developers/docs/ethereum-stack/index.md
index d58c9f614aa..99c61b33b09 100644
--- a/public/content/translations/zh/developers/docs/ethereum-stack/index.md
+++ b/public/content/translations/zh/developers/docs/ethereum-stack/index.md
@@ -1,6 +1,6 @@
---
-title: 以太坊堆栈简介
-description: 一次从不同层面对以太坊堆栈原理的浏览，并且了解如何让不同的以太坊堆栈融为一体。
+title: "以太坊堆栈简介"
+description: "一次从不同层面对以太坊堆栈原理的浏览，并且了解如何让不同的以太坊堆栈融为一体。"
lang: zh
---
@@ -10,11 +10,11 @@ lang: zh
## 级别 1：以太坊虚拟机 {#ethereum-virtual-machine}
-[以太坊虚拟机 (EVM)](/developers/docs/evm/) 是智能合约在以太坊上的运行环境。 以太坊区块链上的所有智能合约和状态更改都由[交易](/developers/docs/transactions/)执行。 以太坊虚拟机处理以在太坊网络上执行的所有交易。
+[以太坊虚拟机 (EVM)](/developers/docs/evm/) 是智能合约在以太坊上的运行环境。 以太坊区块链上的所有智能合约和状态变更都由[交易](/developers/docs/transactions/)执行。 以太坊虚拟机处理以在太坊网络上执行的所有交易。
-与任何虚拟机一样，以太坊虚拟机在执行代码和执行机器（以太坊节点）之间创建一个抽象级别。 目前，在世界各地散布着成千上万的正在执行的以太坊虚拟机节点。
+与任何虚拟机一样，以太坊虚拟机在执行代码和执行机器（以太坊节点）之间创建一个抽象级别。 目前，EVM 正在全球分布的数千个节点上运行。
-在后台，那些以太坊虚拟机会使用操作码执行一些特殊的任务。 这些（140 个惟一的）操作码使以太坊虚拟机具有 [图灵完备](https://en.wikipedia.org/wiki/Turing_completeness)，这意味着只要提供足够的资源，以太坊虚拟机几乎可以计算任何东西。
+在后台，那些以太坊虚拟机会使用操作码执行一些特殊的任务。 这些（140 个惟一的）操作码使 EVM 能够实现[图灵完备](https://en.wikipedia.org/wiki/Turing_completeness)，这意味着只要有足够的资源，EVM 几乎可以计算任何东西。
作为去中心化应用程序的开发者，除了了解以太坊虚拟机的存在之外，你不需要了解更多关于以太坊虚拟机的信息，并且可以在以太坊上畅通无阻地授权所有应用程序。
@@ -22,40 +22,40 @@ lang: zh
[智能合约](/developers/docs/smart-contracts/)是在以太坊区块链上运行的可执行程序。
-智能合约使用了特定的[编程语言](/developers/docs/smart-contracts/languages/)来编译到以太坊虚拟机字节码（调用操作码的低级机器说明）。
+智能合约使用特定的[编程语言](/developers/docs/smart-contracts/languages/)编写，这些语言可以编译成 EVM 字节码（称为操作码的低级机器指令）。
-智能合约不仅是开放源码库，而且它们基本上是运行 24/7 的开放应用程序接口服务，不能被取消。 智能合约提供了为用户和应用程序（[去中心化应用程序](/developers/docs/dapps/)）之间交互的公开方法，无需许可。 任何应用程序都可能会与已部署的智能合约集成组成功能，如添加[数据源](/developers/docs/oracles/)或支持代币交换。 任何人都可以在以太坊上部署智能合约，以便添加自定义功能来满足其应用程序的需要。
+智能合约不仅是开放源码库，而且它们基本上是运行 24/7 的开放应用程序接口服务，不能被取消。 智能合约提供公共函数，用户和应用程序（[去中心化应用程序](/developers/docs/dapps/)）无需许可即可与之交互。 任何应用程序都可以与已部署的智能合约集成以组合功能，例如添加[数据馈送](/developers/docs/oracles/)或支持代币交换。 此外，任何人都可以在以太坊上部署新的智能合约，以添加自定义功能来满足其应用程序的需求。
作为一个去中心化应用程序开发者，如果你需要在以太坊区块链上添加自定义功能，需要通过写智能合约来实现。 你可能会发现你可以仅仅通过与现有智能合约进行整合来满足你项目的大部分或全部的需要。例如，如果你想要支持支付稳定币或启用分散交换代币。
## 级别 3：以太坊节点 {#ethereum-nodes}
-为了让应用程序与以太坊区块链交互，它必须连接到 [以太坊节点](/developers/docs/nodes-and-clients/)。 正在连接到一个节点，你可以读取区块链数据和/或将交易发送到网络。
+为了使应用程序能与以太坊区块链交互，它必须连接到[以太坊节点](/developers/docs/nodes-and-clients/)。 正在连接到一个节点，你可以读取区块链数据和/或将交易发送到网络。
-以太坊节点是运行着软件的电脑，这些软件也就是一个以太坊客户端。 客户端是一种以太坊的实现，它可以验证每个区块中的所有交易，从而确保网络安全和数据准确。 **以太坊节点是以太坊区块链**。 他们集体存储以太坊区块链的状态，并根据改变区块链状态的交易达成共识。
+以太坊节点是运行着软件的电脑，这些软件也就是一个以太坊客户端。 客户端是一种以太坊实现，它验证每个区块中的所有交易，从而确保网络安全和数据准确。 **以太坊节点就是以太坊区块链**。 他们集体存储以太坊区块链的状态，并根据改变区块链状态的交易达成共识。
-通过将应用程序连接到以太坊节点（通过 [JSON RPC 应用程序接口](/developers/docs/apis/json-rpc/)），应用程序可以从区块链（例如用户帐户余额）读取数据，并向网络广播新交易（例如在用户帐户之间传输以太币或执行智能合约的功能）。
+通过将你的应用程序连接到以太坊节点（通过 [JSON-RPC API](/developers/docs/apis/json-rpc/)），你的应用程序就能够从区块链读取数据（例如用户帐户余额），以及向网络广播新的交易（例如在用户帐户之间转移 ETH 或执行智能合约的函数）。
-## 级别 4：以太坊客户端应用程序接口 {#ethereum-client-apis}
+## 级别 4：以太坊客户端 API {#ethereum-client-apis}
许多方便的库（由以太坊开源社区建立和维护）允许你的终端用户应用程序连接到以太坊区块链并进行通信。
-如果你的面向用户应用程序是一个 web 应用程序，你可以直接选择在你的前端使用 `npm 安装`一个 [JavaScript 应用程序接口](/developers/docs/apis/javascript/)。 或许你会选择使用 [Python](/developers/docs/programming-languages/python/) 或 [Java](/developers/docs/programming-languages/java/) 的应用程序接口在后端实现此功能。
+如果你的面向用户的应用程序是网页应用，你可以选择直接在前端 `npm install` 一个 [JavaScript API](/developers/docs/apis/javascript/)。 或者，你也可以选择使用 [Python](/developers/docs/programming-languages/python/) 或 [Java](/developers/docs/programming-languages/java/) API，在服务器端实现此功能。
-虽然这些应用程序接口不是栈必须的一部分，但它们抽象并消减了与以太坊节点直接互动的大部分复杂性。 它们还提供好用的函数（例如：将 ETH 转化为 Gwei），而作为开发者，你可以花费更少的时间处理以太坊客户端的复杂问题，从而将更多的时间集中于处理你的应用程序的独特功能。
+虽然这些应用程序接口不是栈必须的一部分，但它们抽象并消减了与以太坊节点直接互动的大部分复杂性。 它们还提供实用函数（例如将 ETH 转换为 Gwei），因此作为开发者，你可以花更少的时间处理以太坊客户端的复杂细节，将更多时间专注于应用程序的特定功能。
-## 级别 5：终端用户应用程序 {#end-user-applications}
+## 级别 5：最终用户应用程序 {#end-user-applications}
在栈的顶层是面向用户的应用程序。 这些是你今天经常用和构建的标准应用程序：主要是网络程序和移动应用程序。
开发这些用户界面的方式基本上保持不变。 用户常常不需要知道他们所使用的应用程序是使用区块链构建的。
-## 准备好选择技术栈了吗？ {#ready-to-choose-your-stack}
+## 准备好选择技术栈了吗？ 准备好选择你的技术栈了吗？{#ready-to-choose-your-stack}
-查看我们的指南为你的以太坊应用程序 [设置本地开发环境](/developers/local-environment/)。
+查看我们的指南，为你的以太坊应用程序[设置本地开发环境](/developers/local-environment/)。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-- [一个 Web 3.0 应用的架构](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
+- [Web 3.0 应用程序的架构](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _Preethi Kasireddy_
-_还有哪些社区资源对你有所帮助？ 编辑并添加本页面！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
diff --git a/public/content/translations/zh/developers/docs/evm/index.md b/public/content/translations/zh/developers/docs/evm/index.md
index 58389f2286d..344cfeb7d8b 100644
--- a/public/content/translations/zh/developers/docs/evm/index.md
+++ b/public/content/translations/zh/developers/docs/evm/index.md
@@ -1,78 +1,88 @@
---
-title: 以太坊虚拟机 (EVM)
-description: 介绍以太坊虚拟机及其与状态、交易和智能合约的关系。
+title: "以太坊虚拟机 (EVM)"
+description: "介绍以太坊虚拟机及其与状态、交易和智能合约的关系。"
lang: zh
---
-以太坊虚拟机 (EVM) 是一个去中心化虚拟环境，它在所有以太坊节点上一种安全一致地方式执行代码。 节点运行以太坊虚拟机，以执行智能合约，利用“[燃料](/gas/)”度量执行[操作](/developers/docs/evm/opcodes/)所需的计算工作，从而确保高效的资源分配和网络安全性。
+以太坊虚拟机 (EVM) 是一个去中心化虚拟环境，它在所有以太坊节点上一种安全一致地方式执行代码。 节点运行 EVM 执行智能合约，使用“[燃料](/developers/docs/gas/)”衡量执行[操作](/developers/docs/evm/opcodes/)所需的计算工作，从而确保高效的资源分配和网络安全。
## 前提条件 {#prerequisites}
-对计算机科学中常见术语的基本了解，如[字节](https://wikipedia.org/wiki/Byte)、[内存](https://wikipedia.org/wiki/Computer_memory)和[堆栈](https://wikipedia.org/wiki/Stack_(abstract_data_type))是理解 EVM 的前提。 熟悉[哈希函数](https://wikipedia.org/wiki/Cryptographic_hash_function)和[默克尔树](https://wikipedia.org/wiki/Merkle_tree)等密码学/区块链概念也会很有帮助。
+若要理解 EVM，需要对计算机科学中的一些常见术语有基本的了解，例如[字节](https://wikipedia.org/wiki/Byte)、[内存](https://wikipedia.org/wiki/Computer_memory)和[堆栈](https://wikipedia.org/wiki/Stack_\(abstract_data_type\))。 熟悉[哈希函数](https://wikipedia.org/wiki/Cryptographic_hash_function)和[默克尔树](https://wikipedia.org/wiki/Merkle_tree)等加密/区块链概念也会有所帮助。
## 从账本到状态机 {#from-ledger-to-state-machine}
通常使用“分布式账本”的类比来描述像比特币这样的区块链，它使用密码学的基本工具来实现去中心化的货币。 账本保存着活动记录，而活动必须遵守一套规则，这些规则限制用户在修改账本时可以做什么和不可以做什么。 例如，比特币地址不能花费比之前收到的更多的比特币。 这些规则是比特币和许多其他区块链上所有交易的基础。
-虽然以太坊有自己的本机加密货币 (ETH)，遵循几乎完全相同的直观规则，但它也支持更强大的功能：[智能合约](/developers/docs/smart-contracts/)。 对于此更复杂的功能，需要一个更复杂的类比。 以太坊不是分布式账本，而是分布式[状态机器](https://wikipedia.org/wiki/Finite-state_machine)。 以太坊的状态是一个大型数据结构，它不仅保存所有帐户和余额，而且还保存一个_机器状态_，它可以根据预定义的一组规则在不同的区块之间进行更改，并且可以执行任意的机器代码。 在区块中更改状态的具体规则由 EVM 定义。
+以太坊有自己的原生加密货币（以太币），其规则非常直观，但它也实现了一个更强大的功能：[智能合约](/developers/docs/smart-contracts/)。 对于此更复杂的功能，需要一个更复杂的类比。 以太坊不是一个分布式账本，而是一个分布式[状态机](https://wikipedia.org/wiki/Finite-state_machine)。 以太坊的状态是一个大型数据结构，它不仅保存了所有的账户和余额，还保存了一个_机器状态_，它可以根据一组预定义的规则在区块之间发生变化，并且可以执行任意的机器代码。 在区块中更改状态的具体规则由 EVM 定义。
- _示意图节选自[以太坊虚拟机图解](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+
+_图表改编自 [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
## 以太坊状态转换函数 {#the-ethereum-state-transition-function}
-EVM 的行为就像一个数学函数：在给定输入的情况下，它会产生确定性的输出。 因此，将以太坊更正式地描述为具有**状态转换函数**非常有帮助：
+EVM 的行为就像一个数学函数：在给定输入的情况下，它会产生确定性的输出。 因此，将以太坊更正式地描述为具有**状态转换函数**会很有帮助：
```
Y(S, T)= S'
```
-给定一个旧的有效状态 `（S）`> 和一组新的有效交易 `（T）`，以太坊状态转换函数 ` Y（S，T）` 产生新的有效输出状态` S'`
+给定一个旧的有效状态 `(S)` 和一组新的有效交易 `(T)`，以太坊状态转换函数 `Y(S, T)` 会生成一个新的有效输出状态 `S'`
### 状态 {#state}
-在以太坊环境中，状态是一种称为[改进版默克尔帕特里夏树](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/)的巨大数据结构，它保存所有通过哈希关联在一起的[帐户](/developers/docs/accounts/)并可回溯到存储在区块链上的单个根哈希。
+在以太坊中，状态是一个被称为[改良默克尔帕特里夏树](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/)的巨大数据结构，它保存了所有通过哈希链接的[帐户](/developers/docs/accounts/)，并可归约为存储在区块链上的单个根哈希。
### 交易 {#transactions}
-交易是来自帐户的密码学签名指令。 交易分为两种：一种是消息调用交易，另一种是合约创建交易。
+交易是由帐户发出，带密码学签名的指令。 交易分为两种：一种是消息调用交易，另一种是合约创建交易。
-合约创建交易会创建一个新的合约帐户，其中包含已编译的 [智能合约](/developers/docs/smart-contracts/anatomy/) 字节码。 每当另一个帐户对该合约进行消息调用时，它都会执行其字节码。
+创建合约会创建一个新的合约帐户，其中包含已编译的[智能合约](/developers/docs/smart-contracts/anatomy/)字节码。 每当另一个帐户对该合约进行消息调用时，它都会执行其字节码。
-## EVM 说明 {#evm-instructions}
+## EVM 指令 {#evm-instructions}
-EVM 作为一个[堆栈机](https://wikipedia.org/wiki/Stack_machine)运行，其栈的深度为 1024 个项。 每个项目都是 256 位字，为了便于使用，选择了 256 位加密技术（如 Keccak-256 哈希或 secp256k1 签名）。
+EVM 作为[堆栈机](https://wikipedia.org/wiki/Stack_machine)执行，堆栈深度为 1024 个项。 每个项目都是 256 位字，为了便于使用，选择了 256 位加密技术（如 Keccak-256 哈希或 secp256k1 签名）。
-在执行期间，EVM 会维护一个瞬态_内存_（作为字可寻址的字节数组），该内存不会在交易之间持久存在。
+在执行期间，EVM 维护一个瞬态_内存_（一个字可寻址的字节数组），该内存不会在交易之间持久存在。
-然而，合约确实包含一个 Merkle Patricia _存储_ trie（作为可字寻址的字数组），该 trie 与帐户和部分全局状态关联。
+### 瞬态存储
-已编译的智能合约字节码作为许多 EVM [opcodes](/developers/docs/evm/opcodes)执行，它们执行标准的堆栈操作，例如 `XOR`、`AND`、`ADD`、`SUB`等。 EVM 还实现了一些区块链特定的堆栈操作，如 `ADDRESS`、`BALANCE`、`BLOCKHASH` 等。
+瞬态存储是每笔交易的键值存储，可通过 `TSTORE` 和 `TLOAD` 操作码访问。 它在同一笔交易的所有内部调用中都会持续存在，但在交易结束时会被清除。 与内存不同，瞬态存储被建模为 EVM 状态的一部分，而不是执行框架的一部分，但它不会提交到全局状态。 瞬态存储可以在一笔交易的内部调用之间实现燃料高效的临时状态共享。
- _示意图节选自[以太坊虚拟机图解](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+### 存储
+
+合约包含一个与相关帐户关联的默克尔帕特里夏_存储_树（作为字可寻址字数组），是全局状态的一部分。 这种持久化存储与瞬态存储不同，后者仅在单笔交易期间可用，并且不构成帐户持久化存储树的一部分。
+
+### 操作码
+
+编译后的智能合约字节码作为多个 EVM [操作码](/developers/docs/evm/opcodes)执行，这些操作码执行 `XOR`、`AND`、`ADD`、`SUB` 等标准堆栈操作。 EVM 还实现了一些区块链特有的堆栈操作，例如 `ADDRESS`、`BALANCE`、`BLOCKHASH` 等。 操作码集还包括 `TSTORE` 和 `TLOAD`，它们提供对瞬态存储的访问。
+
+
+_图表改编自 [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
## EVM 实现 {#evm-implementations}
EVM 的所有实现都必须遵守以太坊黄皮书中描述的规范。
-在以太坊九年的历程中，以太坊虚拟机经过了几次修订，并且存在不同编程语言实现的以太坊虚拟机版本。
+在以太坊十年的历史中，EVM 经历了数次修订，并且有多种编程语言的 EVM 实现。
-[以太坊执行客户端](/developers/docs/nodes-and-clients/#execution-clients)都包含一个以太坊虚拟机实现。 此外，还有多个独立的实现，包括：
+[以太坊执行客户端](/developers/docs/nodes-and-clients/#execution-clients)包括一个 EVM 实现。 此外，还有多个独立的实现，包括：
- [Py-EVM](https://github.com/ethereum/py-evm) - _Python_
- [evmone](https://github.com/ethereum/evmone) - _C++_
- [ethereumjs-vm](https://github.com/ethereumjs/ethereumjs-vm) - _JavaScript_
- [revm](https://github.com/bluealloy/revm) - _Rust_
-## 延伸阅读 {#further-reading}
+## 扩展阅读 {#further-reading}
- [以太坊黄皮书](https://ethereum.github.io/yellowpaper/paper.pdf)
-- [Jellopaper aka KEVM：K 中的 EVM 语法](https://jellopaper.org/)
-- [The Beigepaper](https://github.com/chronaeon/beigepaper)
+- [Jellopaper 又名 KEVM：K 框架中的 EVM 语义](https://jellopaper.org/)
+- [米色皮书](https://github.com/chronaeon/beigepaper)
- [以太坊虚拟机操作码](https://www.ethervm.io/)
-- [以太坊虚拟机操作码交互参考](https://www.evm.codes/)
-- [Solidity 文档的简短介绍](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
+- [以太坊虚拟机操作码交互式参考](https://www.evm.codes/)
+- [Solidity 文档中的简短介绍](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
- [精通以太坊 - 以太坊虚拟机](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
## 相关主题 {#related-topics}
-- [Gas](/developers/docs/gas/)
+- [燃料](/developers/docs/gas/)
diff --git a/public/content/translations/zh/developers/docs/evm/opcodes/index.md b/public/content/translations/zh/developers/docs/evm/opcodes/index.md
index 7936185fd88..d4b7f68b9c0 100644
--- a/public/content/translations/zh/developers/docs/evm/opcodes/index.md
+++ b/public/content/translations/zh/developers/docs/evm/opcodes/index.md
@@ -1,174 +1,177 @@
---
-title: 以太坊虚拟机的操作码
-description: 以下是以太坊虚拟机可用的所有操作码的列表。
+title: "以太坊虚拟机的操作码"
+description: "以下是以太坊虚拟机可用的所有操作码的列表。"
lang: zh
---
## 概述 {#overview}
-本文是位于 [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes) 的以太坊虚拟机参考页面的更新版本。 本文亦节选自[黄皮书](https://ethereum.github.io/yellowpaper/paper.pdf)、[Jello Paper](https://jellopaper.org/evm/)及 [geth](https://github.com/ethereum/go-ethereum) 实现。 本文旨在作为一份易于理解的参考资料，但并不十分严谨。 如果想确保正确性并了解每种边缘情况，建议使用 Jello Paper 或客户端实现。
+这是 [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes) 上的 EVM 参考页面的更新版本。
+内容也源自[《黄皮书》](https://ethereum.github.io/yellowpaper/paper.pdf)、[《Jello Paper》](https://jellopaper.org/evm/)和 [geth](https://github.com/ethereum/go-ethereum) 实现。
+本文旨在作为一份易于理解的参考资料，但并不十分严谨。
+如果想确保正确性并了解每种边缘情况，建议使用 Jello Paper 或客户端实现。
-在寻找交互式参考？ 请查看 [evm.codes](https://www.evm.codes/)。
+在寻找交互式参考？ 查看 [evm.codes](https://www.evm.codes/)。
-对于具有动态燃料成本的操作，请参考 [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md)。
+有关具有动态燃料费用的操作，请参阅 [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md)。
-💡温馨提示：要查看完整行，请在电脑上使用 `[shift] + scroll` 水平滚动浏览。
+💡 快速提示：要在桌面设备上查看整行，请使用 `[shift] + scroll` 水平滚动。
-| 堆栈 | 名称 | 燃料 | 起始堆栈 | 最终堆栈 | 内存 / 存储 | 注释 |
-|:-----:|:-------------- |:-----------------------------------------------------------------------------------------------:|:------------------------------------------------ |:-------------------------------------------- |:----------------------------------------------------------------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 00 | 停止 | 0 | | | | halt execution |
-| 01 | ADD | 3 | `a, b` | `a + b` | | (u)int256 addition modulo 2\*\*256 |
-| 02 | MUL | 5 | `a, b` | `a * b` | | (u)int256 multiplication modulo 2\*\*256 |
-| 03 | SUB | 3 | `a, b` | `a - b` | | (u)int256 addition modulo 2\*\*256 |
-| 04 | DIV | 5 | `a, b` | `a // b` | | uint256 division |
-| 05 | SDIV | 5 | `a, b` | `a // b` | | int256 division |
-| 06 | MOD | 5 | `a, b` | `a % b` | | uint256 modulus |
-| 07 | SMOD | 5 | `a, b` | `a % b` | | int256 modulus |
-| 08 | ADDMOD | 8 | `a, b, N` | `(a + b) % N` | | (u)int256 addition modulo N |
-| 09 | MULMOD | 8 | `a, b, N` | `(a * b) % N` | | (u)int256 multiplication modulo N |
-| 0A | EXP | [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp) | `a, b` | `a ** b` | | uint256 exponentiation modulo 2\*\*256 |
-| 0B | SIGNEXTEND | 5 | `b, x` | `SIGNEXTEND(x, b)` | | [sign extend](https://wikipedia.org/wiki/Sign_extension) `x` from `(b+1)` bytes to 32 bytes |
-| 0C-0F | _invalid_ | | | | | |
-| 10 | LT | 3 | `a, b` | `a < b` | | uint256 less-than |
-| 11 | GT | 3 | `a, b` | `a > b` | | uint256 greater-than |
-| 12 | SLT | 3 | `a, b` | `a < b` | | int256 less-than |
-| 13 | SGT | 3 | `a, b` | `a > b` | | int256 greater-than |
-| 14 | EQ | 3 | `a, b` | `a == b` | | (u)int256 equality |
-| 15 | ISZERO | 3 | `a` | `a == 0` | | (u)int256 iszero |
-| 16 | AND | 3 | `a, b` | `a && b` | | bitwise AND |
-| 17 | OR | 3 | `a, b` | `a \|\| b` | | bitwise OR |
-| 18 | XOR | 3 | `a, b` | `a ^ b` | | bitwise XOR |
-| 19 | NOT | 3 | `a` | `~a` | | bitwise NOT |
-| 1A | BYTE | 3 | `i, x` | `(x >> (248 - i * 8)) && 0xFF` | | `i`th byte of (u)int256 `x`, from the left |
-| 1B | SHL | 3 | `shift, val` | `val << shift` | | shift left |
-| 1C | SHR | 3 | `shift, val` | `val >> shift` | | logical shift right |
-| 1D | SAR | 3 | `shift, val` | `val >> shift` | | arithmetic shift right |
-| 1E-1F | _invalid_ | | | | | |
-| 20 | KECCAK256 | [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3) | `ost, len` | `keccak256(mem[ost:ost+len-1])` | | keccak256 |
-| 21-2F | _invalid_ | | | | | |
-| 30 | ADDRESS | 2 | `.` | `address(this)` | | address of executing contract |
-| 31 | BALANCE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `addr.balance` | | balance, in wei |
-| 32 | ORIGIN | 2 | `.` | `tx.origin` | | address that originated the tx |
-| 33 | CALLER | 2 | `.` | `msg.sender` | | address of msg sender |
-| 34 | CALLVALUE | 2 | `.` | `msg.value` | | msg value, in wei |
-| 35 | CALLDATALOAD | 3 | `idx` | `msg.data[idx:idx+32]` | | read word from msg data at index `idx` |
-| 36 | CALLDATASIZE | 2 | `.` | `len(msg.data)` | | length of msg data, in bytes |
-| 37 | CALLDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | copy msg data |
-| 38 | CODESIZE | 2 | `.` | `len(this.code)` | | length of executing contract's code, in bytes |
-| 39 | CODECOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | copy executing contract's bytecode |
-| 3A | GASPRICE | 2 | `.` | `tx.gasprice` | | gas price of tx, in wei per unit gas [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice) |
-| 3B | EXTCODESIZE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `len(addr.code)` | | size of code at addr, in bytes |
-| 3C | EXTCODECOPY | [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy) | `addr, dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | copy code from `addr` |
-| 3D | RETURNDATASIZE | 2 | `.` | `size` | | size of returned data from last external call, in bytes |
-| 3E | RETURNDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | copy returned data from last external call |
-| 3F | EXTCODEHASH | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `哈希值` | | hash = addr.exists ? keccak256(addr.code) : 0 |
-| 40 | BLOCKHASH | 20 | `blockNum` | `blockHash(blockNum)` | | |
-| 41 | COINBASE | 2 | `.` | `block.coinbase` | | 当前区块提议者地址 |
-| 42 | TIMESTAMP | 2 | `.` | `block.timestamp` | | timestamp of current block |
-| 43 | NUMBER | 2 | `.` | `block.number` | | number of current block |
-| 44 | PREVRANDAO | 2 | `.` | `randomness beacon` | | randomness beacon |
-| 45 | GASLIMIT | 2 | `.` | `block.gaslimit` | | gas limit of current block |
-| 46 | CHAINID | 2 | `.` | `chain_id` | | push current [chain id](https://eips.ethereum.org/EIPS/eip-155) onto stack |
-| 47 | SELFBALANCE | 5 | `.` | `address(this).balance` | | balance of executing contract, in wei |
-| 48 | BASEFEE | 2 | `.` | `block.basefee` | | base fee of current block |
-| 49 | BLOBHASH | 3 | `idx` | `tx.blob_versioned_hashes[idx]` | | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) |
-| 4A | BLOBBASEFEE | 2 | `.` | `block.blobbasefee` | | 当前区块的二进制大对象基础费（[EIP-7516](https://eips.ethereum.org/EIPS/eip-7516)） |
-| 4B-4F | _invalid_ | | | | | |
-| 50 | POP | 2 | `_anon` | `.` | | remove item from top of stack and discard it |
-| 51 | MLOAD | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost` | `mem[ost:ost+32]` | | read word from memory at offset `ost` |
-| 52 | MSTORE | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost:ost+32] := val | write a word to memory |
-| 53 | MSTORE8 | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost] := val && 0xFF | write a single byte to memory |
-| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | read word from storage |
-| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | write word to storage |
-| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` mark that `pc` is only assigned if `dst` is a valid jumpdest |
-| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ? dst : $pc + 1` |
-| 58 | PC | 2 | `.` | `$pc` | | program counter |
-| 59 | MSIZE | 2 | `.` | `len(mem)` | | size of memory in current execution context, in bytes |
-| 5A | GAS | 2 | `.` | `gasRemaining` | | |
-| 5B | JUMPDEST | 1 | | | mark valid jump destination | a valid jump destination for example a jump destination not inside the push data |
-| 5C | TLOAD | 100 | `key` | `tstorage[key]` | | 从瞬态存储中读取字 ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) |
-| 5D | TSTORE | 100 | `key, val` | `.` | tstorage[key] := val | 向瞬态存储中写入字 ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) |
-| 5E | MCOPY | 3+3\*字+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len` | `.` | mem[dstOst] := mem[ost:ost+len] | 将内存从一个区域复制到另一个区域 ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)) |
-| 5F | PUSH0 | 2 | `.` | `uint8` | | push the constant value 0 onto stack |
-| 60 | PUSH1 | 3 | `.` | `uint8` | | push 1-byte value onto stack |
-| 61 | PUSH2 | 3 | `.` | `uint16` | | push 2-byte value onto stack |
-| 62 | PUSH3 | 3 | `.` | `uint24` | | push 3-byte value onto stack |
-| 63 | PUSH4 | 3 | `.` | `uint32` | | push 4-byte value onto stack |
-| 64 | PUSH5 | 3 | `.` | `uint40` | | push 5-byte value onto stack |
-| 65 | PUSH6 | 3 | `.` | `uint48` | | push 6-byte value onto stack |
-| 66 | PUSH7 | 3 | `.` | `uint56` | | push 7-byte value onto stack |
-| 67 | PUSH8 | 3 | `.` | `uint64` | | push 8-byte value onto stack |
-| 68 | PUSH9 | 3 | `.` | `uint72` | | push 9-byte value onto stack |
-| 69 | PUSH10 | 3 | `.` | `uint80` | | push 10-byte value onto stack |
-| 6A | PUSH11 | 3 | `.` | `uint88` | | push 11-byte value onto stack |
-| 6B | PUSH12 | 3 | `.` | `uint96` | | push 12-byte value onto stack |
-| 6C | PUSH13 | 3 | `.` | `uint104` | | push 13-byte value onto stack |
-| 6D | PUSH14 | 3 | `.` | `uint112` | | push 14-byte value onto stack |
-| 6E | PUSH15 | 3 | `.` | `uint120` | | push 15-byte value onto stack |
-| 6F | PUSH16 | 3 | `.` | `uint128` | | push 16-byte value onto stack |
-| 70 | PUSH17 | 3 | `.` | `uint136` | | push 17-byte value onto stack |
-| 71 | PUSH18 | 3 | `.` | `uint144` | | push 18-byte value onto stack |
-| 72 | PUSH19 | 3 | `.` | `uint152` | | push 19-byte value onto stack |
-| 73 | PUSH20 | 3 | `.` | `uint160` | | push 20-byte value onto stack |
-| 74 | PUSH21 | 3 | `.` | `uint168` | | push 21-byte value onto stack |
-| 75 | PUSH22 | 3 | `.` | `uint176` | | push 22-byte value onto stack |
-| 76 | PUSH23 | 3 | `.` | `uint184` | | push 23-byte value onto stack |
-| 77 | PUSH24 | 3 | `.` | `uint192` | | push 24-byte value onto stack |
-| 78 | PUSH25 | 3 | `.` | `uint200` | | push 25-byte value onto stack |
-| 79 | PUSH26 | 3 | `.` | `uint208` | | push 26-byte value onto stack |
-| 7A | PUSH27 | 3 | `.` | `uint216` | | push 27-byte value onto stack |
-| 7B | PUSH28 | 3 | `.` | `uint224` | | push 28-byte value onto stack |
-| 7C | PUSH29 | 3 | `.` | `uint232` | | push 29-byte value onto stack |
-| 7D | PUSH30 | 3 | `.` | `uint240` | | push 30-byte value onto stack |
-| 7E | PUSH31 | 3 | `.` | `uint248` | | push 31-byte value onto stack |
-| 7F | PUSH32 | 3 | `.` | `uint256` | | push 32-byte value onto stack |
-| 80 | DUP1 | 3 | `a` | `a, a` | | clone 1st value on stack |
-| 81 | DUP2 | 3 | `_, a` | `a, _, a` | | clone 2nd value on stack |
-| 82 | DUP3 | 3 | `_, _, a` | `a, _, _, a` | | clone 3rd value on stack |
-| 83 | DUP4 | 3 | `_, _, _, a` | `a, _, _, _, a` | | clone 4th value on stack |
-| 84 | DUP5 | 3 | `..., a` | `a, ..., a` | | clone 5th value on stack |
-| 85 | DUP6 | 3 | `..., a` | `a, ..., a` | | clone 6th value on stack |
-| 86 | DUP7 | 3 | `..., a` | `a, ..., a` | | clone 7th value on stack |
-| 87 | DUP8 | 3 | `..., a` | `a, ..., a` | | clone 8th value on stack |
-| 88 | DUP9 | 3 | `..., a` | `a, ..., a` | | clone 9th value on stack |
-| 89 | DUP10 | 3 | `..., a` | `a, ..., a` | | clone 10th value on stack |
-| 8A | DUP11 | 3 | `..., a` | `a, ..., a` | | clone 11th value on stack |
-| 8B | DUP12 | 3 | `..., a` | `a, ..., a` | | clone 12th value on stack |
-| 8C | DUP13 | 3 | `..., a` | `a, ..., a` | | clone 13th value on stack |
-| 8D | DUP14 | 3 | `..., a` | `a, ..., a` | | clone 14th value on stack |
-| 8E | DUP15 | 3 | `..., a` | `a, ..., a` | | clone 15th value on stack |
-| 8F | DUP16 | 3 | `..., a` | `a, ..., a` | | clone 16th value on stack |
-| 90 | SWAP1 | 3 | `a, b` | `b, a` | | |
-| 91 | SWAP2 | 3 | `a, _, b` | `b, _, a` | | |
-| 92 | SWAP3 | 3 | `a, _, _, b` | `b, _, _, a` | | |
-| 93 | SWAP4 | 3 | `a, _, _, _, b` | `b, _, _, _, a` | | |
-| 94 | SWAP5 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 95 | SWAP6 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 96 | SWAP7 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 97 | SWAP8 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 98 | SWAP9 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 99 | SWAP10 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9A | SWAP11 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9B | SWAP12 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9C | SWAP13 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9D | SWAP14 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9E | SWAP15 | 3 | `a, ..., b` | `b, ..., a` | | |
-| 9F | SWAP16 | 3 | `a, ..., b` | `b, ..., a` | | |
-| A0 | LOG0 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len` | `.` | | LOG0(memory[ost:ost+len-1]) |
-| A1 | LOG1 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0` | `.` | | LOG1(memory[ost:ost+len-1], topic0) |
-| A2 | LOG2 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1` | `.` | | LOG2(memory[ost:ost+len-1], topic0, topic1) |
-| A3 | LOG3 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2` | `.` | | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) |
-| A4 | LOG4 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2, topic3` | `.` | | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) |
-| A5-EF | _invalid_ | | | | | |
-| F0 | CREATE | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len` | `addr` | | addr = keccak256(rlp([address(this), this.nonce])) |
-| F1 | CALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | gas, addr, val, argOst, argLen, retOst, retLen | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| F2 | CALLCODE | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, val, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] = returndata | same as DELEGATECALL, but does not propagate original msg.sender and msg.value |
-| F3 | 返回 | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | return mem[ost:ost+len-1] |
-| F4 | DELEGATECALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| F5 | CREATE2 | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len, salt` | `addr` | | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] |
-| F6-F9 | _invalid_ | | | | | |
-| FA | STATICCALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | |
-| FB-FC | _invalid_ | | | | | |
-| FD | 撤销 | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | revert(mem[ost:ost+len-1]) |
-| FE | INVALID | [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid) | | | designated invalid opcode - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) | |
-| FF | SELFDESTRUCT | [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct) | `addr` | `.` | | 将所有以太币发送到 `addr`；如果在创建合约的同一交易中执行，它会销毁该合约 |
+| 堆栈 | 名称 | 燃料 | 起始堆栈 | 最终堆栈 | 内存 / 存储 | 注释 | |
+| :---: | :------------- | :---------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| 00 | STOP | 0 | | | | 中止执行 | |
+| 01 | ADD | 3 | `a, b` | `a + b` | | (u)int256 加法，模 2\*\*256 | |
+| 02 | MUL | 5 | `a, b` | `a * b` | | (u)int256 乘法，模 2\*\*256 | |
+| 03 | SUB | 3 | `a, b` | `a - b` | | (u)int256 减法，模 2\*\*256 | |
+| 04 | DIV | 5 | `a, b` | `a // b` | | uint256 除法 | |
+| 05 | SDIV | 5 | `a, b` | `a // b` | | int256 除法 | |
+| 06 | MOD | 5 | `a, b` | `a % b` | | uint256 模数 | |
+| 07 | SMOD | 5 | `a, b` | `a % b` | | int256 模数 | |
+| 08 | ADDMOD | 8 | `a, b, N` | `(a + b) % N` | | (u)int256 加法，模 N | |
+| 09 | MULMOD | 8 | `a, b, N` | `(a * b) % N` | | (u)int256 乘法，模 N | |
+| 0A | EXP | [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp) | `a, b` | `a ** b` | | uint256 乘方，模 2\*\*256 | |
+| 0B | SIGNEXTEND | 5 | `b, x` | `SIGNEXTEND(x, b)` | | 将 `x` 从 `(b+1)` 字节[符号扩展](https://wikipedia.org/wiki/Sign_extension)到 32 字节 | |
+| 0C-0F | _无效_ | | | | | | |
+| 10 | LT | 3 | `a, b` | `a < b` | | uint256 小于 | |
+| 11 | GT | 3 | `a, b` | `a > b` | | uint256 大于 | |
+| 12 | SLT | 3 | `a, b` | `a < b` | | int256 小于 | |
+| 13 | SGT | 3 | `a, b` | `a > b` | | int256 大于 | |
+| 14 | EQ | 3 | `a, b` | `a == b` | | (u)int256 相等 | |
+| 15 | ISZERO | 3 | `a` | `a == 0` | | (u)int256 是否为零 | |
+| 16 | AND | 3 | `a, b` | `a && b` | | 按位与 | |
+| 17 | OR | 3 | `a, b` | `a \\|\\| b` | | 按位或 | |
+| 18 | XOR | 3 | `a, b` | `a ^ b` | | 按位异或 | |
+| 19 | NOT | 3 | `a` | `~a` | | 按位非 | |
+| 1A | BYTE | 3 | `i, x` | `(x >> (248 - i * 8)) && 0xFF` | | 从左起，(u)int256 `x` 的第 `i` 个字节 | |
+| 1B | SHL | 3 | `shift, val` | `val << shift` | | 左移 | |
+| 1C | SHR | 3 | `shift, val` | `val >> shift` | | 逻辑右移 | |
+| 1D | SAR | 3 | `shift, val` | `val >> shift` | | 算术右移 | |
+| 1E-1F | _无效_ | | | | | | |
+| 20 | KECCAK256 | [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3) | `ost, len` | `keccak256(mem[ost:ost+len-1])` | | keccak256 | |
+| 21-2F | _无效_ | | | | | | |
+| 30 | ADDRESS | 2 | `.` | `address(this)` | | 执行合约的地址 | |
+| 31 | BALANCE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `addr.balance` | | 余额，以 wei 为单位 | |
+| 32 | ORIGIN | 2 | `.` | `tx.origin` | | 发起交易的地址 | |
+| 33 | CALLER | 2 | `.` | `发送者` | | 消息发送者的地址 | |
+| 34 | CALLVALUE | 2 | `.` | `msg.value` | | 消息值，以 wei 为单位 | |
+| 35 | CALLDATALOAD | 3 | `idx` | `msg.data[idx:idx+32]` | | 从索引 `idx` 处的消息数据中读取字 | |
+| 36 | CALLDATASIZE | 2 | `.` | `len(msg.data)` | | 消息数据的长度，以字节为单位 | |
+| 37 | CALLDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | 复制消息数据 | |
+| 38 | CODESIZE | 2 | `.` | `len(this.code)` | | 执行合约代码的长度，以字节为单位 | |
+| 39 | CODECOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | 复制执行合约的字节码 |
+| 3A | GASPRICE | 2 | `.` | `tx.gasprice` | | 交易的燃料价格，以 wei/单位燃料计 [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice) | |
+| 3B | EXTCODESIZE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `len(addr.code)` | | 地址处代码的大小，以字节为单位 | |
+| 3C | EXTCODECOPY | [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy) | `addr, dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | 从 `addr` 复制代码 | |
+| 3D | RETURNDATASIZE | 2 | `.` | `size` | | 上次外部调用的返回数据的大小，以字节为单位 | |
+| 3E | RETURNDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | 复制上次外部调用的返回数据 | |
+| 3F | EXTCODEHASH | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `哈希` | | 哈希 = addr.exists ? keccak256(addr.code) : 0 | |
+| 40 | BLOCKHASH | 20 | `blockNum` | `blockHash(blockNum)` | | | |
+| 41 | COINBASE | 2 | `.` | `block.coinbase` | | 当前区块提议者地址 | |
+| 42 | TIMESTAMP | 2 | `.` | `区块时间戳` | | 当前区块的时间戳 | |
+| 43 | NUMBER | 2 | `.` | `block.number` | | 当前区块的编号 | |
+| 44 | PREVRANDAO | 2 | `.` | `randomness beacon` | | 随机信标 | |
+| 45 | GASLIMIT | 2 | `.` | `block.gaslimit` | | 当前区块的燃料限制 | |
+| 46 | CHAINID | 2 | `.` | `chain_id` | | 将当前[链 id](https://eips.ethereum.org/EIPS/eip-155) 推入堆栈 | |
+| 47 | SELFBALANCE | 5 | `.` | `address(this).balance` | | 执行合约的余额，以 wei 为单位 | |
+| 48 | BASEFEE | 2 | `.` | `block.basefee` | | 当前区块的基本费用 | |
+| 49 | BLOBHASH | 3 | `idx` | `tx.blob_versioned_hashes[idx]` | | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) | |
+| 4A | BLOBBASEFEE | 2 | `.` | `block.blobbasefee` | | 当前区块的 blob 基本费用 ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516)) | |
+| 4B-4F | _无效_ | | | | | | |
+| 50 | POP | 2 | `_anon` | `.` | | 从堆栈顶部移除一项并丢弃 | |
+| 51 | MLOAD | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost` | `mem[ost:ost+32]` | | 从内存偏移量 `ost` 处读取字 | |
+| 52 | MSTORE | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost:ost+32] := val | 向内存写入一个字 | |
+| 53 | MSTORE8 | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost] := val && 0xFF | 向内存写入单个字节 | |
+| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | 从存储中读取字 | |
+| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | 向存储中写入字 | |
+| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` 标记 `pc` 仅在 `dst` 是一个有效的 jumpdest 时才被赋值。 | |
+| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ?` dst : $pc + 1` | |
+| 58 | PC | 2 | `.` | `$pc` | | 程序计数器 | |
+| 59 | MSIZE | 2 | `.` | `len(mem)` | | 当前执行上下文中内存的大小，以字节为单位 | |
+| 5A | GAS | 2 | `.` | `gasRemaining` | | | |
+| 5B | JUMPDEST | 1 | | | 标记有效的跳转目标 | 一个有效的跳转目标，例如一个不在推送数据内的跳转目标 | |
+| 5C | TLOAD | 100 | `key` | `tstorage[key]` | | 从瞬时存储中读取字 ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5D | TSTORE | 100 | `key, val` | `.` | tstorage[key] := val | 向瞬时存储中写入字 ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5E | MCOPY | 3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len` | `.` | mem[dstOst] := mem[ost:ost+len] | 将内存从一个区域复制到另一个区域 ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)) | |
+| 5F | PUSH0 | 2 | `.` | `uint8` | | push the constant value 0 onto stack | |
+| 60 | PUSH1 | 3 | `.` | `uint8` | | 将 1 字节值推入堆栈 | |
+| 61 | PUSH2 | 3 | `.` | `uint16` | | 将 2 字节值推入堆栈 | |
+| 62 | PUSH3 | 3 | `.` | `uint24` | | 将 3 字节值推入堆栈 | |
+| 63 | PUSH4 | 3 | `.` | `uint32` | | 将 4 字节值推入堆栈 | |
+| 64 | PUSH5 | 3 | `.` | `uint40` | | 将 5 字节值推入堆栈 | |
+| 65 | PUSH6 | 3 | `.` | `uint48` | | 将 6 字节值推入堆栈 | |
+| 66 | PUSH7 | 3 | `.` | `uint56` | | 将 7 字节值推入堆栈 | |
+| 67 | PUSH8 | 3 | `.` | `uint64` | | 将 8 字节值推入堆栈 | |
+| 68 | PUSH9 | 3 | `.` | `uint72` | | 将 9 字节值推入堆栈 | |
+| 69 | PUSH10 | 3 | `.` | `uint80` | | 将 10 字节值推入堆栈 | |
+| 6A | PUSH11 | 3 | `.` | `uint88` | | 将 11 字节值推入堆栈 | |
+| 6B | PUSH12 | 3 | `.` | `uint96` | | 将 12 字节值推入堆栈 | |
+| 6C | PUSH13 | 3 | `.` | `uint104` | | 将 13 字节值推入堆栈 | |
+| 6D | PUSH14 | 3 | `.` | `uint112` | | 将 14 字节值推入堆栈 | |
+| 6E | PUSH15 | 3 | `.` | `uint120` | | 将 15 字节值推入堆栈 | |
+| 6F | PUSH16 | 3 | `.` | `uint128` | | 将 16 字节值推入堆栈 | |
+| 70 | PUSH17 | 3 | `.` | `uint136` | | 将 17 字节值推入堆栈 | |
+| 71 | PUSH18 | 3 | `.` | `uint144` | | 将 18 字节值推入堆栈 | |
+| 72 | PUSH19 | 3 | `.` | `uint152` | | 将 19 字节值推入堆栈 | |
+| 73 | PUSH20 | 3 | `.` | `uint160` | | 将 20 字节值推入堆栈 | |
+| 74 | PUSH21 | 3 | `.` | `uint168` | | 将 21 字节值推入堆栈 | |
+| 75 | PUSH22 | 3 | `.` | `uint176` | | 将 22 字节值推入堆栈 | |
+| 76 | PUSH23 | 3 | `.` | `uint184` | | 将 23 字节值推入堆栈 | |
+| 77 | PUSH24 | 3 | `.` | `uint192` | | 将 24 字节值推入堆栈 | |
+| 78 | PUSH25 | 3 | `.` | `uint200` | | 将 25 字节值推入堆栈 | |
+| 79 | PUSH26 | 3 | `.` | `uint208` | | 将 26 字节值推入堆栈 | |
+| 7A | PUSH27 | 3 | `.` | `uint216` | | 将 27 字节值推入堆栈 | |
+| 7B | PUSH28 | 3 | `.` | `uint224` | | 将 28 字节值推入堆栈 | |
+| 7C | PUSH29 | 3 | `.` | `uint232` | | 将 29 字节值推入堆栈 | |
+| 7D | PUSH30 | 3 | `.` | `uint240` | | 将 30 字节值推入堆栈 | |
+| 7E | PUSH31 | 3 | `.` | `uint248` | | 将 31 字节值推入堆栈 | |
+| 7F | PUSH32 | 3 | `.` | `uint256` | | 将 32 字节值推入堆栈 | |
+| 80 | DUP1 | 3 | `a` | `a, a` | | 克隆堆栈上的第 1 个值 | |
+| 81 | DUP2 | 3 | `_, a` | `a, _, a` | | 克隆堆栈上的第 2 个值 | |
+| 82 | DUP3 | 3 | `_, _, a` | `a, _, _, a` | | 克隆堆栈上的第 3 个值 | |
+| 83 | DUP4 | 3 | `_, _, _, a` | `a, _, _, _, a` | | 克隆堆栈上的第 4 个值 | |
+| 84 | DUP5 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 5 个值 | |
+| 85 | DUP6 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 6 个值 | |
+| 86 | DUP7 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 7 个值 | |
+| 87 | DUP8 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 8 个值 | |
+| 88 | DUP9 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 9 个值 | |
+| 89 | DUP10 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 10 个值 | |
+| 8A | DUP11 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 11 个值 | |
+| 8B | DUP12 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 12 个值 | |
+| 8C | DUP13 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 13 个值 | |
+| 8D | DUP14 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 14 个值 | |
+| 8E | DUP15 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 15 个值 | |
+| 8F | DUP16 | 3 | `..., a` | `a, ..., a` | | 克隆堆栈上的第 16 个值 | |
+| 90 | SWAP1 | 3 | `a, b` | `b, a` | | | |
+| 91 | SWAP2 | 3 | `a, _, b` | `b, _, a` | | | |
+| 92 | SWAP3 | 3 | `a, _, _, b` | `b, _, _, a` | | | |
+| 93 | SWAP4 | 3 | `a, _, _, _, b` | `b, _, _, _, a` | | | |
+| 94 | SWAP5 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 95 | SWAP6 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 96 | SWAP7 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 97 | SWAP8 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 98 | SWAP9 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 99 | SWAP10 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9A | SWAP11 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9B | SWAP12 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9C | SWAP13 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9D | SWAP14 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9E | SWAP15 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9F | SWAP16 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| A0 | LOG0 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len` | `.` | | LOG0(memory[ost:ost+len-1]) | |
+| A1 | LOG1 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0` | `.` | | LOG1(memory[ost:ost+len-1], topic0) | |
+| A2 | LOG2 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1` | `.` | | LOG2(memory[ost:ost+len-1], topic0, topic1) | |
+| A3 | LOG3 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2` | `.` | | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) | |
+| A4 | LOG4 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2, topic3` | `.` | | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) | |
+| A5-EF | _无效_ | | | | | | |
+| F0 | CREATE | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len` | `addr` | | addr = keccak256(rlp([address(this), this.nonce])) | |
+| F1 | CALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | 燃料, addr, val, argOst, argLen, retOst, retLen | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F2 | CALLCODE | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `燃料, addr, val, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] = returndata | 与 DELEGATECALL 相同，但不传播原始的 msg.sender 和 msg.value | |
+| F3 | RETURN | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | return mem[ost:ost+len-1] | |
+| F4 | DELEGATECALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `燃料, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F5 | CREATE2 | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len, salt` | `addr` | | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] | |
+| F6-F9 | _无效_ | | | | | | |
+| FA | STATICCALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `燃料, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| FB-FC | _无效_ | | | | | | |
+| FD | REVERT | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | revert(mem[ost:ost+len-1]) | |
+| FE | INVALID | [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid) | | | 指定的无效操作码 - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) | | |
+| FF | SELFDESTRUCT | [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct) | `addr` | `.` | | 将所有 ETH 发送到 `addr`；如果在创建合约的同一交易中执行，它会销毁该合约 | |
diff --git a/public/content/translations/zh/developers/docs/frameworks/index.md b/public/content/translations/zh/developers/docs/frameworks/index.md
index f30fefc21f1..65d4a324fef 100644
--- a/public/content/translations/zh/developers/docs/frameworks/index.md
+++ b/public/content/translations/zh/developers/docs/frameworks/index.md
@@ -1,76 +1,76 @@
---
-title: 去中心化应用程序开发框架
-description: 探索框架的优势并比较现有的选项。
+title: "去中心化应用程序开发框架"
+description: "探索框架的优势并比较现有的选项。"
lang: zh
---
-## 框架介绍 {#introduction-to-frameworks}
+## 框架简介 {#introduction-to-frameworks}
构建一个完整的去中心化应用程序需要不同的技术。 软件框架包括许多需要的功能，或提供简单的插件系统来选择你需要的工具。
这些框架带有很多非常规的功能，比如：
-- 编一个本地区块链的程序功能。
+- 编写一个本地区块链程序的功能。
- 编辑和测试你智能合约的实用工具。
-- 客户端开发附加组件，以在同一项目/仓库中构建你的面向用户的应用。
-- 无论是在本地运行的实例，还是在以太坊的公共网络之一，可以连接到以太网并且部署合约的配置。
-- 去中心化的应用分发 - 与诸如 IPFS 之类的存储选项集成。
+- 客户端开发附加组件，用于在同一项目/代码库中构建面向用户的应用程序。
+- 用于连接以太坊网络和部署合约的配置，无论是连接到本地运行的实例，还是以太坊的某个公共网络。
+- 去中心化应用程序分发——与 IPFS 等存储方案集成。
-## 前置要求 {#prerequisites}
+## 前提条件 {#prerequisites}
-在更深入介绍这个框架之前，我们推荐你先阅读下面对于[去中心化应用程序](/developers/docs/dapps/)的简介以及[以太坊堆栈](/developers/docs/ethereum-stack/)。
+在深入了解框架之前，我们建议你先阅读我们对[去中心化应用程序](/developers/docs/dapps/)和[以太坊堆栈](/developers/docs/ethereum-stack/)的介绍。
-## 可用的框架 {#available-frameworks}
+## 可用框架 {#available-frameworks}
-**Foundry** - **_Foundry 是一款快速、便携、模块化的以太坊应用程序开发工具包_**
+**Foundry** - **_Foundry 是一款极其快速、可移植的模块化工具包，用于以太坊应用程序开发_**
- [安装 Foundry](https://book.getfoundry.sh/)
-- [Foundry 手册](https://book.getfoundry.sh/)
+- [Foundry 指南](https://book.getfoundry.sh/)
- [Telegram 上的 Foundry 社区聊天](https://t.me/foundry_support)
-- [强大的 Foundry](https://github.com/crisgarner/awesome-foundry)
+- [Awesome Foundry](https://github.com/crisgarner/awesome-foundry)
-**安全帽 -** **_ 面向专业人员的以太坊开发环境。_**
+**Hardhat -** **_面向专业人士的以太坊开发环境。_**
- [hardhat.org](https://hardhat.org)
- [GitHub](https://github.com/nomiclabs/hardhat)
-**Ape -** **_ 面向 Pythonista、数据科学家和安全专业人员的智能合约开发工具。_**
+**Ape -** **_面向 Python 爱好者、数据科学家和安全专业人士的智能合约开发工具。_**
-- [相关文档](https://docs.apeworx.io/ape/stable/)
+- [文档](https://docs.apeworx.io/ape/stable/)
- [GitHub](https://github.com/ApeWorX/ape)
-**Web3j -** **_ Java 虚拟机上的区块链应用程序开发平台。_ **
+**Web3j -** **_一个用于在 JVM 上开发区块链应用程序的平台。_**
- [主页](https://www.web3labs.com/web3j-sdk)
-- [相关文档](https://docs.web3j.io)
+- [文档](https://docs.web3j.io)
- [GitHub](https://github.com/web3j/web3j)
-**Ethers-kt - ****_ 面向基于以太坊虚拟机区块链的高性能异步 Kotlin/Java/Android 库。_**
+**ethers-kt -** **_用于基于 EVM 的区块链的异步、高性能 Kotlin/Java/Android 库。_**
- [GitHub](https://github.com/Kr1ptal/ethers-kt)
- [示例](https://github.com/Kr1ptal/ethers-kt/tree/master/examples)
- [Discord](https://discord.gg/rx35NzQGSb)
-**Create Eth App -** **_ 使用一个命令创建以太坊支持的应用程序。 提供众多 UI 框架和去中心化金融模板供选择。_**
+**Create Eth App -** **_通过一个命令创建以太坊赋能的应用程序。 提供多种 UI 框架和 DeFi 模板供您选择。_**
- [GitHub](https://github.com/paulrberg/create-eth-app)
- [模板](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
-**Scaffold-Eth -** **_Ethers.js + 安全帽 + React 组件和 web3 钩子函数：构建智能合约支持的去中心化应用程序所需的一切资源，这里都有。_**
+**Scaffold-Eth -** **_Ethers.js + Hardhat + 用于 web3 的 React 组件和钩子：开始构建由智能合约驱动的去中心化应用程序所需的一切。_**
- [GitHub](https://github.com/scaffold-eth/scaffold-eth-2)
-**Tenderly -** **_Web3 开发平台，可帮助区块链开发者构建、测试、调试、监测和操作智能合约并改善去中心化应用程序的用户体验。_**
+**Tenderly -** **_Web3 开发平台，区块链开发者能够用它来构建、测试、调试、监控和运营智能合约，并改善去中心化应用程序的用户体验。_**
- [网站](https://tenderly.co/)
-- [相关文档](https://docs.tenderly.co/)
+- [文档](https://docs.tenderly.co/)
-**The Graph -** **_ 用于高效查询区块链数据的图表。_**
+**The Graph -** **_用于高效查询区块链数据的 The Graph。_**
- [网站](https://thegraph.com/)
- [教程](/developers/tutorials/the-graph-fixing-web3-data-querying/)
-**Alchemy -** **_以太坊开发平台_**
+**Alchemy -** **_以太坊开发平台。_**
- [alchemy.com](https://www.alchemy.com/)
- [GitHub](https://github.com/alchemyplatform)
@@ -82,68 +82,68 @@ lang: zh
- [GitHub](https://github.com/node-real)
- [Discord](https://discord.gg/V5k5gsuE)
-**thirdweb SDK -** **_使用我们强大的软件开发工具包和命令行接口，构建能够与你的智能合约交互的 web3 应用程序。_**
+**thirdweb SDK -** **_使用我们强大的软件开发工具包和命令行界面，构建能够与你的智能合约交互的 web3 应用程序。_**
-- [相关文档](https://portal.thirdweb.com/sdk/)
+- [文档](https://portal.thirdweb.com/sdk/)
- [GitHub](https://github.com/thirdweb-dev/)
-**Chainstack -** **_Web3（以太坊和其他区块链）开发平台。_**
+**Chainstack -** **_Web3（以太坊及其他）开发平台。_**
- [chainstack.com](https://www.chainstack.com/)
- [GitHub](https://github.com/chainstack)
- [Discord](https://discord.gg/BSb5zfp9AT)
-**Crossmint -** **_企业级 Web3 开发平台，允许你在各大链以太坊虚拟机链（及其他链）上构建非同质化代币应用程序。_**
+**Crossmint -** **_企业级 web3 开发平台，允许你在所有主流 EVM 链（及其他链）上构建 NFT 应用程序。_**
- [网站](https://www.crossmint.com)
-- [相关文档](https://docs.crossmint.com)
+- [文档](https://docs.crossmint.com)
- [Discord](https://discord.com/invite/crossmint)
-**Brownie -** **_ 基于 Python 的开发环境和测试框架。_**
+**Brownie -** **_基于 Python 的开发环境和测试框架。_**
-- [相关文档](https://eth-brownie.readthedocs.io/en/latest/)
+- [文档](https://eth-brownie.readthedocs.io/en/latest/)
- [GitHub](https://github.com/eth-brownie/brownie)
- **Brownie 当前未维护**
-**OpenZeppelin SDK -** **_终极智能合约工具包：一套帮助你开发、编译、升级、部署智能合约并与之交互的工具。_**
+**OpenZeppelin SDK -** **_终极智能合约工具包：一套可帮助你开发、编译、升级、部署智能合约并与之交互的工具。_**
-- [OpenZeppelin SDK](https://openzeppelin.com/sdk/)
+- [OpenZeppelin Defender SDK](https://docs.openzeppelin.com/defender/sdk)
- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk)
- [社区论坛](https://forum.openzeppelin.com/c/support/17)
- **OpenZeppelin SDK 开发已结束**
-**Catapulta -** **_多链智能合约部署工具，在区块浏览器中自动执行验证，追踪已部署的智能合约并分享部署报告，使 Foundry 和 Hardhat 项目即插即用。_**
+**Catapulta -** **_多链智能合约部署工具，可在区块浏览器中自动验证，跟踪已部署的智能合约并共享部署报告，为 Foundry 和 Hardhat 项目提供即插即用功能。_**
- [网站](https://catapulta.sh/)
-- [相关文档](https://catapulta.sh/docs)
+- [文档](https://catapulta.sh/docs)
- [Github](https://github.com/catapulta-sh)
-**Covalent - ****_适用于 200 多条链的丰富区块链应用程序接口。_**
+**GoldRush (由 Covalent 提供支持) -** **_GoldRush 为开发者、分析师和企业提供最全面的区块链数据 API 套件。 无论你是在构建 DeFi 看板、钱包、交易机器人、人工智能代理还是合规平台，数据 API 都能让你快速、准确且对开发者友好地访问所需的基本链上数据_**
-- [covalenthq.com](https://www.covalenthq.com/)
-- [相关文档](https://www.covalenthq.com/docs/api/)
+- [网站](https://goldrush.dev/)
+- [文档](https://goldrush.dev/docs/chains/ethereum)
- [GitHub](https://github.com/covalenthq)
- [Discord](https://www.covalenthq.com/discord/)
-**Wake -** **_用于合约测试、模糊测试、部署、漏洞扫描和代码导航的一体化 Python 框架。_**
+**Wake -** **_集合约测试、模糊测试、部署、漏洞扫描和代码导航于一体的 Python 框架。_**
- [主页](https://getwake.io/)
-- [相关文档](https://ackeeblockchain.com/wake/docs/latest/)
+- [文档](https://ackeeblockchain.com/wake/docs/latest/)
- [GitHub](https://github.com/Ackee-Blockchain/wake)
-- [VS Code 扩展程序](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)
+- [VS Code 扩展](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)
-**Veramo -** **_开源、模块化且不受限的框架，使去中心化应用程序开发者能够轻松在其应用程序内构建去中心化身份和可验证凭证。_**
+**Veramo -** **_一个开源、模块化、不限平台的框架，可让去中心化应用程序的开发者轻松地在其应用程序中构建去中心化身份和可验证凭证。_**
- [主页](https://veramo.io/)
-- [相关文档](https://veramo.io/docs/basics/introduction)
+- [文档](https://veramo.io/docs/basics/introduction)
- [GitHub](https://github.com/uport-project/veramo)
- [Discord](https://discord.com/invite/FRRBdjemHV)
-- [NPM 软件包](https://www.npmjs.com/package/@veramo/core)
+- [NPM 包](https://www.npmjs.com/package/@veramo/core)
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
-## 相关主题 {#related-topics}
+## 相关话题 {#related-topics}
- [设置本地开发环境](/developers/local-environment/)
diff --git a/public/content/translations/zh/developers/docs/gas/index.md b/public/content/translations/zh/developers/docs/gas/index.md
index 8e2cf056a6b..49cb35281f0 100644
--- a/public/content/translations/zh/developers/docs/gas/index.md
+++ b/public/content/translations/zh/developers/docs/gas/index.md
@@ -1,7 +1,7 @@
---
-title: 燃料和费用
+title: "燃料和费用"
metaTitle: "以太坊燃料和费用：技术概览"
-description:
+description: "了解以太坊燃料费用，包括它们的计算方式，以及它们在网络安全和交易处理中所扮演的角色。"
lang: zh
---
@@ -9,7 +9,7 @@ Gas 对以太坊网络至关重要。 正是这种燃料使它能够运行，正
## 前提条件 {#prerequisites}
-为了更好地理解此页面，推荐先阅读[交易](/developers/docs/transactions/)和 [EVM](/developers/docs/evm/)。
+为了更好地理解本页内容，建议您先阅读有关[交易](/developers/docs/transactions/)和 [EVM](/developers/docs/evm/) 的内容。
## 什么是燃料？ {#what-is-gas}
@@ -17,80 +17,85 @@ Gas 对以太坊网络至关重要。 正是这种燃料使它能够运行，正
由于每笔以太坊交易都需要使用计算资源来执行，因此必须为这些资源付费，以确保以太坊不容易受到垃圾信息的攻击，并且不会陷入无限的计算循环。 计算费用以燃料费的形式支付。
-燃料费是**用于执行某些操作的燃料数量，乘以每单位燃料的成本**。 无论交易成功与否，都要支付燃料费。
+燃料费是**指执行某项操作所用的燃料量，乘以每单位燃料的成本**。 无论交易成功与否，都要支付燃料费。
- _示意图节选自[以太坊虚拟机图解](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+！[一张图表，显示 EVM 操作中哪里需要燃料](./gas.png)
+_图表改编自 [《图解以太坊虚拟机》](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
燃料费必须用以太坊的本币支付，即以太币 (ETH)。 燃料通常以 gwei 计价，gwei 是以太币的一种计量单位。 一个 gwei 等于一个以太币的十亿分之一（0.000000001 个以太币，或 10-9 个以太币）。
比如，你可以说你的燃料费是 1 gwei，而不说 0.000000001 个以太币。
-"Gwei" 是 "giga-wei" 的缩写，意思是 “十亿个 wei”。 一个 gwei 等于十亿个 wei。 Wei 本身（以 [b-money](https://www.investopedia.com/terms/b/bmoney.asp) 的发明者 [Wei Dai](https://wikipedia.org/wiki/Wei_Dai) 的名字命名）是以太币的最小单位。
+"Gwei" 是 "giga-wei" 的缩写，意思是 “十亿个 wei”。 一个 gwei 等于十亿个 wei。 Wei（得名于 [b-money](https://www.investopedia.com/terms/b/bmoney.asp) 的创建者[戴伟](https://wikipedia.org/wiki/Wei_Dai)）是以太币 (ETH) 的最小单位。
## 如何计算燃料费？ {#how-are-gas-fees-calculated}
当提交交易时，你可以设置你愿意支付的燃料数量。 通过提供一定数量的燃料，你出价将你的交易添加到下一个区块中。 如果你提供的燃料太少，验证者就不太可能选择添加你的交易，这意味着你的交易可能会延迟执行或不会被执行。 如果提供太多，你可能浪费一些以太币。 那么，怎么知道你应该支付多少燃料费呢？
-你支付的总燃料费分为两部分：`base fee` 和 `priority fee`（小费）。
+你支付的总燃料费分为两个部分：`基本费用`和`优先费`（小费）。
-`Base fee` 由协议设定——你必须至少支付这些金额，然后你的交易才会被视为有效。 `Priority fee` 是基础费以外的小费，它可以吸引验证者选择将你的交易添加到下一个区块。
+`基本费用`由协议设置——你必须至少支付这笔费用，你的交易才会被视为有效。 `优先费`是你添加到基本费用中的小费，用于激励验证者，以便他们将你的交易打包到下一个区块中。
-只支付 `base fee` 的交易从技术上讲是有效的，但不太可能被添加到区块，因为它没有激励验证者优先选择它而不是其他交易。 “合适的” `priority` 费由发送交易时的网络使用情况决定——如果有大量需求，那么你可能不得不将你的 `priority` 费设置得更高；但当需求较少时，你也可以减少该费用。
+只支付`基本费用`的交易在技术上是有效的，但不太可能被打包，因为它没有激励验证者优先选择它，而不是其他任何交易。 “正确的”`优先`费由你发送交易时的网络使用情况决定——如果需求量大，你可能需要设置更高的`优先`费，但当需求量较少时，你可以支付更少的费用。
例如，假设 Jordan 要向 Taylor 支付 1 个以太币。 一笔以太币转账需要 21,000 单位的燃料，基础费是10 gwei。 Jordan 支付了 2 gwei 作为小费。
总费用等于：
-`使用的燃料单位数 *（基础费 + 优先费）`
+`使用的燃料单位 * (基本费用 + 优先费)`
-其中 `base fee` 由协议设置，`priority fee` 是用户设置的支付给验证者的小费。
+其中 `基本费用` 是协议设定的值，`优先费`是用户设定给验证者的小费。
-即 `21,000 * (10 + 2) = 252,000 gwei`（0.000252 个以太币）。
+例如，`21,000 * (10 + 2) = 252,000 gwei` (0.000252 ETH)。
-当 Jordan 转账时，将从 Jordan 帐户中扣除 1.000252 个以太币。 Taylor 的帐户增加 1.0000 个以太币。 验证者收到价值 0.000042 个以太币的小费。 0.00021 个以太币的 `base fee` 被销毁。
+当 Jordan 转账时，将从 Jordan 帐户中扣除 1.000252 个以太币。 Taylor 的帐户增加 1.0000 个以太币。 验证者收到价值 0.000042 个以太币的小费。 0.00021 ETH 的`基本费用`被销毁。
-### 基础费 {#base-fee}
+### 基本费用 {#base-fee}
-每个区块都有一个基础费作为底价。 要想有资格添加到区块中，燃料费出价必须至少等于基础费。 基础费独立于当前区块计算，是由当前区块之前的区块决定的，这使得用户更容易预测交易费。 在创建区块时，它的**基础费将被“销毁”**并退出流通。
+每个区块都有一个基础费作为底价。 要想有资格添加到区块中，燃料费出价必须至少等于基础费。 基本费用的计算独立于当前区块，而是由它之前的区块决定，这使得用户更容易预测交易费。 创建区块时，这笔**基本费用将被“销毁”**，并退出流通。
-基础费由一个公式计算得出，该公式将上一个区块的大小（所有交易中使用的燃料数量）与目标大小进行比较。 如果超过目标区块大小，每个区块的基础费将最多增加 12.5%。 这种指数级增长使得区块大小无限期保持高位在经济上不可行。
+`基本费用`由一个公式计算得出，该公式将上一个区块的大小（所有交易使用的燃料总量）与目标大小（燃料限制的一半）进行比较。 如果区块大小分别高于或低于目标区块大小，则每个区块的基本费用将最多增加或减少 12.5%。 这种指数级增长使得区块大小无限期保持高位在经济上不可行。
-| 区块编号 | 已包含燃料 | 费用增加 | 当前基本费用 |
-| ---- | -----:| -----:| ----------:|
-| 1 | 15M | 0% | 100 gwei |
-| 2 | 30M | 0% | 100 gwei |
-| 3 | 30M | 12.5% | 112.5 gwei |
-| 4 | 30M | 12.5% | 126.6 gwei |
-| 5 | 30M | 12.5% | 142.4 gwei |
-| 6 | 30M | 12.5% | 160.2 gwei |
-| 7 | 30M | 12.5% | 180.2 gwei |
-| 8 | 30M | 12.5% | 202.7 gwei |
+| 区块编号 | 已包含燃料 | 费用增加 | 当前基本费用 |
+| ---- | ----: | --------------------: | -------------------------: |
+| 1 | 18M | 0% | 100 gwei |
+| 2 | 36M | 0% | 100 gwei |
+| 3 | 36M | 12.5% | 112.5 gwei |
+| 4 | 36M | 12.5% | 126.6 gwei |
+| 5 | 36M | 12.5% | 142.4 gwei |
+| 6 | 36M | 12.5% | 160.2 gwei |
+| 7 | 36M | 12.5% | 180.2 gwei |
+| 8 | 36M | 12.5% | 202.7 gwei |
-根据以上表格，要在 9 号区块创建交易，钱包会让用户明确知晓：要将交易添加到下一个区块的**最高基础费**等于 `current base fee * 112.5%` 或 `202.7 gwei * 112.5% = 228.1 gwei`。
+上表中使用 3600 万作为燃料限制来举例说明。 根据这个例子，要在第 9 号区块上创建交易，钱包会明确告知用户，要添加到下一个区块的**最高基本费用**是`当前基本费用 * 112.5%` 或 `202.7 gwei * 112.5% = 228.1 gwei`。
还请注意，考虑到完整区块前的基础费增加速度很快，我们不大可能看到它长时间处于峰值状态。
-| 区块编号 | 已包含燃料 | 费用增加 | 当前基本费用 |
-| ---- | -----:| -----:| ---------------:|
-| 30 | 30M | 12.5% | 2705.6 gwei |
-| ... | ... | 12.5% | ... |
-| 50 | 30M | 12.5% | 28531.3 gwei |
-| ... | ... | 12.5% | ... |
-| 100 | 30M | 12.5% | 10302608.6 gwei |
+| 区块编号 | 已包含燃料 | 费用增加 | 当前基本费用 |
+| --------------------------------------------------- | --------------------------------------------------: | --------------------: | --------------------------------------------------: |
+| 30 | 36M | 12.5% | 2705.6 gwei |
+| ... | ... | 12.5% | ... |
+| 50 | 36M | 12.5% | 28531.3 gwei |
+| ... | ... | 12.5% | ... |
+| 100 | 36M | 12.5% | 10302608.6 gwei |
-### 优先费（小费） {#priority-fee}
+### 优先费（小费）{#priority-fee}
-优先费（小费）激励验证者将交易添加到区块中。 如果没有小费，验证者会发现开采空区块在经济上可行，因为它们会获得相同的区块奖励。 小额小费是对验证者将交易添加到区块的最小激励。 在相同区块中，对于要优先于其他交易执行的交易，可以添加更高的小费来尝试使出价高于竞争性交易。
+优先费（小费）激励验证者在区块燃料限制的约束下，将一个区块中的交易数量最大化。 如果没有小费，理性的验证者可能会打包更少甚至零交易，而不会受到任何直接的执行层或共识层惩罚，因为质押奖励与区块中的交易数量无关。 此外，小费允许用户通过出价高于他人来获得同一区块内的优先处理权，从而有效地表明其紧迫性。
### 最高费用 {#maxfee}
-要在网络上执行交易，用户可以为他们愿意支付的交易执行费用指定最高限额。 此可选参数称为 `maxFeePerGas`。 为了执行交易，最高费用必须超过基础费和小费的总和。 交易完成后，会将最高费用与基础费和小费总和之间的差额退还给交易发送人。
+要在网络上执行交易，用户可以为他们愿意支付的交易执行费用指定最高限额。 这个可选参数被称为 `maxFeePerGas`。 为了执行交易，最高费用必须超过基础费和小费的总和。 交易完成后，会将最高费用与基础费和小费总和之间的差额退还给交易发送人。
### 区块大小 {#block-size}
-每个区块的目标大小为 3000 万单位燃料，但区块的大小将根据网络需求增减，最大不得超过 6000 万单位燃料的区块大小上限（目标区块大小的 2 倍）。 协议通过 _tâtonnement_ 过程使均衡区块大小平均达到 1,500 万单位燃料。 这意味着如果区块大小超出目标区块大小，协议将增加下一个区块的基础费。 同样，如果区块大小小于目标区块大小，协议将减少基础费。 基础费的调整金额与当前区块大小和目标区块大小的差距成比例。 [关于区块的更多信息](/developers/docs/blocks/)。
+每个区块都有一个目标大小，即当前燃料限制的一半，但区块的大小会根据网络需求增减，直至达到区块上限（目标区块大小的 2 倍）。 协议通过_试探_过程在目标处实现均衡的平均区块大小。 这意味着如果区块大小超出目标区块大小，协议将增加下一个区块的基础费。 同样，如果区块大小小于目标区块大小，协议将减少基础费。
-### 实践中的燃料费计算 {#calculating-fees-in-practice}
+基础费的调整金额与当前区块大小和目标区块大小的差距成比例。 这是一个线性计算：空区块为 -12.5%，达到目标大小时为 0%，达到燃料限制的区块为 +12.5%。 燃料限制会随着时间的推移，根据验证者信号以及网络升级而波动。 你可以在[此处查看燃料限制随时间的变化](https://eth.blockscout.com/stats/averageGasLimit?interval=threeMonths)。
+
+[关于区块的更多信息](/developers/docs/blocks/)
+
+### 在实践中计算燃料费 {#calculating-fees-in-practice}
你可以明确说明自己愿意支付多少交易执行费。 然而，大多数钱包提供商会自动设置推荐的交易费（基础费 + 推荐的优先费）来降低用户操作的复杂程度。
@@ -98,43 +103,49 @@ Gas 对以太坊网络至关重要。 正是这种燃料使它能够运行，正
简而言之，燃料费有助于确保以太坊网络的安全。 在网络上执行的每次计算都需要收费，这样可以防止不良行为者给网络带来垃圾信息。 为了防止代码中出现无意或恶意的无限循环或其他计算浪费，要求每笔交易对可以采用的代码执行计算步骤设置一个限制。 基本计算单位是“燃料”。
-尽管交易中包含费用限制，但交易中未使用的所有燃料将退还给用户（即退还 `max fee - (base fee + tip)`）。
+尽管交易包含限制，但交易中任何未使用的燃料都会返还给用户（例如，返还`最高费用 - (基本费用 + 小费)`）。
- _示意图节选自[以太坊虚拟机图解](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
+！[显示未使用的燃料如何退款的图表](../transactions/gas-tx.png)
+_图表改编自 [《图解以太坊虚拟机》](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf)_
## 什么是燃料限额？ {#what-is-gas-limit}
-燃料限额是指你愿意在交易中消耗的最大燃料数量。 涉及[智能合约](/developers/docs/smart-contracts/)的更复杂交易需要进行更多的计算工作，因此相比简单的支付，它们需要更高的燃料限额。 标准以太币转账要求燃料限额为 21,000 单位燃料。
+燃料限额是指你愿意在交易中消耗的最大燃料数量。 涉及[智能合约](/developers/docs/smart-contracts/)的更复杂交易需要更多的计算工作，因此它们比简单的支付需要更高的燃料限制。 标准以太币转账要求燃料限额为 21,000 单位燃料。
-例如，如果你对简单的以太币转账设置 50,000 单位燃料限额，以太坊虚拟机将消耗 21,000 单位，你将收到剩余的 29,000 单位。 然而，如果你设置的燃料太少，比如说，对于简单的以太币转账，设置燃料限额为 20,000 单位，以太坊虚拟机将消耗 20,000 单位燃料并尝试执行交易，但最后不会完成。 然后，以太坊虚拟机回滚所有变化，但由于验证者已经完成了价值 20k 单位燃料的工作，这些燃料就被消耗了。
+例如，如果你对简单的以太币转账设置 50,000 单位燃料限额，以太坊虚拟机将消耗 21,000 单位，你将收到剩余的 29,000 单位。 然而，如果你指定的燃料量过少，例如，对于一个简单的 ETH 转账，燃料限制设置为 20,000，则交易将在验证阶段失败。 该交易在被打包进区块之前会被拒绝，且不会消耗任何燃料。 反之，如果交易在执行过程中耗尽了燃料（例如，智能合约执行到一半时，耗尽了所有燃料），EVM 将回滚所有更改，但为执行该交易已完成的计算工作，仍会消耗提供的全部燃料。
## 为什么燃料费会变得如此高？ {#why-can-gas-fees-get-so-high}
燃料费高是由于以太坊广受欢迎。 如果需求量太大，用户必须提供更高的小费，力争使出价高于其他用户的交易。 小费越高，交易进入下一个区块的可能性就越大。 此外，更复杂的智能合约应用可能会执行许多操作来支持其功能，使它们消耗大量的燃料。
-## 减少燃料成本的举措 {#initiatives-to-reduce-gas-costs}
+## 降低燃料成本的举措 {#initiatives-to-reduce-gas-costs}
+
+以太坊[可扩展性升级](/roadmap/)最终应能解决一些燃料费问题，从而使该平台能够每秒处理数千笔交易并实现全球扩展。
-以太坊[可扩展性升级](/roadmap/)最终应该可以解决部分燃料费问题，并让以太坊平台有能力每秒处理数千笔交易，从而实现全面扩容。
+二层网络扩容是一项主要举措，可大大优化燃料成本、用户体验和可扩展性。
-二层网络扩容是一项主要举措，可大大优化燃料成本、用户体验和可扩展性。 [关于二层网络扩容的更多信息](/developers/docs/scaling/#layer-2-scaling)。
+[关于二层网络扩容的更多信息](/developers/docs/scaling/#layer-2-scaling)
## 监控燃料费 {#monitoring-gas-fees}
如果想要监控燃料价格，用较少的费用发送以太币，你可以使用多种不同的工具，例如：
-- [Etherscan 区块浏览器](https://etherscan.io/gastracker)_交易燃料价格估算器。_
-- [ETH Gas Tracker](https://www.ethgastracker.com/) _监控与追踪以太坊和二层网络燃料价格，降低交易费用并节省开支_
-- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _支持类型 0 传统交易和类型 2 EIP-1559 交易的燃料估算 Chrome 插件。_
-- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _按照你的当地货币计算主网、Arbitrum 和 Polygon 上进行的各类交易的燃料费。_
+- [Etherscan](https://etherscan.io/gastracker) _交易燃料价格估算工具_
+- [Blockscout](https://eth.blockscout.com/gas-tracker) _开源交易燃料价格估算工具_
+- [ETH Gas Tracker](https://www.ethgastracker.com/) _监控和跟踪以太坊和 L2 的燃料价格，以降低交易费用并节省资金_
+- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _一款燃料估算 Chrome 扩展程序，支持 0 类传统交易和 2 类 EIP-1559 交易。_
+- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _在主网、Arbitrum 和 Polygon 上，以你的本地货币计算不同交易类型的燃料费。_
## 相关工具 {#related-tools}
-- [Blocknative 的燃料平台](https://www.blocknative.com/gas)_由 Blocknative 的全局内存池数据平台提供支持的燃料估算应用程序接口_
+- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _由 Blocknative 的全球内存池数据平台提供支持的燃料估算 API_
+- [Gas Network](https://gas.network) 链上燃料预言机。 支持超过 35 条链。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-- [以太坊 Gas 详解](https://defiprime.com/gas)
-- [减少智能合约的燃料消耗](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
-- [面向开发者的燃料优化策略](https://www.alchemy.com/overviews/solidity-gas-optimization)
-- [EIP-1559 文档](https://eips.ethereum.org/EIPS/eip-1559)
-- [Tim Beiko 的 EIP-1559 资源](https://hackmd.io/@timbeiko/1559-resources)。
+- [以太坊燃料详解](https://defiprime.com/gas)
+- [降低智能合约的燃料消耗](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
+- [开发人员的燃料优化策略](https://www.alchemy.com/overviews/solidity-gas-optimization)
+- [EIP-1559 文档](https://eips.ethereum.org/EIPS/eip-1559)。
+- [Tim Beiko 的 EIP-1559 资源](https://hackmd.io/@timbeiko/1559-resources)
+- [EIP-1559：机制与模因分离](https://web.archive.org/web/20241126205908/https://research.2077.xyz/eip-1559-separating-mechanisms-from-memes)
diff --git a/public/content/translations/zh/developers/docs/ides/index.md b/public/content/translations/zh/developers/docs/ides/index.md
index 6ce4572d03b..3397e00af03 100644
--- a/public/content/translations/zh/developers/docs/ides/index.md
+++ b/public/content/translations/zh/developers/docs/ides/index.md
@@ -1,64 +1,64 @@
---
-title: 集成开发环境
-description:
+title: "集成开发环境"
+description: "了解更多用于以太坊开发的网页和桌面 IDE，包括 Remix、VS Code 和流行的插件。"
lang: zh
---
-当建立一个[集成开发环境](https://wikipedia.org/wiki/Integrated_development_environment)时，以太坊上的应用编程类似于任何其他软件项目编程。 这里有许多选项可供选择，最后，请选择一个最适合你偏好的集成开发环境或代码编辑器。 对你的以太坊开发来说，最好的集成开发环境很可能就是你在传统软件开发中使用过的集成开发环境。
+在设置[集成开发环境 (IDE)](https://wikipedia.org/wiki/Integrated_development_environment) 方面，在以太坊上进行应用编程与任何其他软件项目的编程类似。 这里有许多选项可供选择，最后，请选择一个最适合你偏好的集成开发环境或代码编辑器。 对你的以太坊开发来说，最好的集成开发环境很可能就是你在传统软件开发中使用过的集成开发环境。
-## 基于网络的集成开发环境 {#web-based-ides}
+## 基于 Web 的 IDE {#web-based-ides}
-如果你想在[设置本地开发环境](/developers/local-environment/)之前摆弄一下代码，这些网络应用是为以太坊智能合约开发定制的。
+如果您想在[设置本地开发环境](/developers/local-environment/)之前摆弄一下代码，这些网络应用是专为以太坊智能合约开发而定制的。
-**[Remix](https://remix.ethereum.org/)** - **_基于 Web 的集成开发环境，内置静态分析和区块链测试虚拟机_**
+**[Remix](https://remix.ethereum.org/)** - **_基于 Web 的 IDE，内置静态分析功能和测试区块链虚拟机_**
-- [相关文档](https://remix-ide.readthedocs.io/en/latest/#)
+- [文档](https://remix-ide.readthedocs.io/en/latest/#)
- [Gitter](https://gitter.im/ethereum/remix)
-**[ChainIDE](https://chainide.com/)** - **_一个支持多链的云端集成开发环境_**
+**[ChainIDE](https://chainide.com/)** - **_基于云的多链 IDE_**
-- [相关文档](https://chainide.gitbook.io/chainide-english-1/)
+- [文档](https://chainide.gitbook.io/chainide-english-1/)
- [帮助论坛](https://forum.chainide.com/)
-**[Replit（Solidity 新手教程 - Beta）](https://replit.com/@replit/Solidity-starter-beta)** - **_一种可定制的以太坊开发环境，提供热重载、错误检查和一流的测试网支持_**
+**[Replit (Solidity 入门 - Beta 版)](https://replit.com/@replit/Solidity-starter-beta)** - **_一个可自定义的以太坊开发环境，具有热重载、错误检查和一流的测试网支持_**
-- [相关文档](https://docs.replit.com/)
+- [文档](https://docs.replit.com/)
-**[Tenderly Sandbox](https://sandbox.tenderly.co/)** - **_一种快捷的原型构建环境，让你可以使用 Solidity 和 JavaScript 在浏览器中编写、执行并调试智能合约_**
+**[Tenderly Sandbox](https://sandbox.tenderly.co/)** - **_一种快速的原型设计环境，您可以在浏览器中使用 Solidity 和 JavaScript 编写、执行和调试智能合约_**
-**[EthFiddle](https://ethfiddle.com/)** - **_基于 Web 的集成开发环境 ( IDE )，可让你编写、编译和调试智能合约_**
+**[EthFiddle](https://ethfiddle.com/)** - **_一个基于 Web 的 IDE，可让您编写、编译和调试您的智能合约_**
- [Gitter](https://gitter.im/loomnetwork/ethfiddle)
## 桌面 IDE {#desktop-ides}
-大多数成熟的集成开发环境都包含增强以太坊开发体验的插件。 至少，它们能为[智能合约语言](/developers/docs/smart-contracts/languages/)提供语法突出显示。
+大多数成熟的集成开发环境都包含增强以太坊开发体验的插件。 它们至少为[智能合约语言](/developers/docs/smart-contracts/languages/)提供语法高亮。
-**Visual Studio Code -** **_专业跨平台集成开发环境，获得以太坊官方支持_**
+**Visual Studio Code -** **_具有官方以太坊支持的专业跨平台 IDE_**
- [Visual Studio Code](https://code.visualstudio.com/)
- [代码示例](https://github.com/Azure-Samples/blockchain/blob/master/blockchain-workbench/application-and-smart-contract-samples/readme.md)
- [GitHub](https://github.com/microsoft/vscode)
-**JetBrains 集成开发环境（IntelliJ IDEA 等） -** **_面向软件开发者和团队的基本工具_**
+**JetBrains IDE（IntelliJ IDEA 等） -** **_面向软件开发者和团队的基本工具_**
- [JetBrains](https://www.jetbrains.com/)
- [GitHub](https://github.com/JetBrains)
- [IntelliJ Solidity](https://github.com/intellij-solidity/intellij-solidity/)
-**Remix Desktop -** **_在本地计算机上体验 Remix 集成开发环境_**
+**Remix Desktop -** **_在您的本地计算机上体验 Remix IDE_**
- [下载](https://github.com/ethereum/remix-desktop/releases)
- [GitHub](https://github.com/ethereum/remix-desktop)
-## 插件与扩展 {#plugins-extensions}
+## 插件和扩展 {#plugins-extensions}
-- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - 面向 Visual Studio Code 的以太坊 Solidity 语言
-- [面向 VS Code 的 Solidity + 安全帽](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - 安全帽团队提供 Solidity 和安全帽支持
-- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - 使用 Prettier 的代码格式化工具
+- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - 适用于 Visual Studio Code 的以太坊 Solidity 语言
+- [Solidity + Hardhat for VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - 由 Hardhat 团队提供的 Solidity 和 Hardhat 支持
+- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - 使用 prettier 的代码格式化工具
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-- [以太坊集成开发环境 (IDE)](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _- Alchemy 提供的以太坊集成开发环境列表_
+- [Ethereum IDEs](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _- Alchemy 整理的以太坊 IDE 列表_
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
diff --git a/public/content/translations/zh/developers/docs/index.md b/public/content/translations/zh/developers/docs/index.md
index 47c7c2e0023..2141a651e43 100644
--- a/public/content/translations/zh/developers/docs/index.md
+++ b/public/content/translations/zh/developers/docs/index.md
@@ -1,14 +1,14 @@
---
-title: 以太坊开发文档
-description: ethereum.org 开发者相关文档简介。
+title: "以太坊开发文档"
+description: "ethereum.org 开发者相关文档简介。"
lang: zh
---
本文档旨在帮助你构建以太坊。 它介绍了以太坊概念，解释了以太坊技术栈，并记录了以太坊更复杂的应用和使用案例的高级主题。
-基于开源社区的努力，你可以随时提出新的主题，添加新内容，并在认为可能有用的地方提供示例。 所有文档都可以通过 GitHub 编辑 — 如果不确定如何操作，[请遵循这些说明](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/editing-markdown.md)。
+基于开源社区的努力，你可以随时提出新的主题，添加新内容，并在认为可能有用的地方提供示例。 所有相关文档均可通过 GitHub 进行编辑 – 如果您不确定如何操作，[请遵循这些说明](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/editing-markdown.md)。
-## 开发单元 {#development-modules}
+## 开发模块 {#development-modules}
如果这是你首次尝试以太坊开发，我们建议从头开始，有始有终，从头到尾。
diff --git a/public/content/translations/zh/developers/docs/intro-to-ether/index.md b/public/content/translations/zh/developers/docs/intro-to-ether/index.md
index c1854ac145d..d64503aa3d9 100644
--- a/public/content/translations/zh/developers/docs/intro-to-ether/index.md
+++ b/public/content/translations/zh/developers/docs/intro-to-ether/index.md
@@ -1,12 +1,12 @@
---
-title: 以太币简介
-description: 开发者讲解以太币加密货币
+title: "以太币技术介绍"
+description: "开发者讲解以太币加密货币"
lang: zh
---
## 前提条件 {#prerequisites}
-为了更好地理解此页面，推荐先阅读：[以太坊简介](/developers/docs/intro-to-ethereum/)。
+为了帮助你更好地理解本页面，我们建议你先阅读[以太坊简介](/developers/docs/intro-to-ethereum/)。
## 什么是加密货币？ {#what-is-a-cryptocurrency}
@@ -16,37 +16,37 @@ lang: zh
第一个加密货币是由 Satoshi Nakamoto 创建的比特币。 自 2009 年比特币发行以来，人们已经在许多不同的区块链上制作了数以千计的加密货币。
-## 什么是以太币 (ETH)？ {#what-is-ether}
+## 什么是以太币？ {#what-is-ether}
-**以太币 (ETH)** 是用于以太坊网络上许多事物的加密货币。 从根本上讲，以太币是唯一可接受的交易费支付方式，并且在[合并](/roadmap/merge)之后，在主网上验证和提出区块需要以太币。 以太币还被用作 [去中心化金融](/defi) 借贷市场的主要抵押形式，非同质化代币市场的主要记账单位以及提供服务、销售实体商品赚取的付款等。
+**以太币 (ETH)** 是用于以太坊网络上许多事物的加密货币。 从根本上讲，它是唯一可接受的交易费支付方式，并且在[合并](/roadmap/merge)之后，在主网上验证和提出区块需要以太币。 以太币也被用作 [DeFi](/defi) 借贷市场的主要抵押品、NFT 市场的记账单位、因提供服务或销售实体商品而获得的报酬等等。
-以太坊允许开发者创建 [**去中心化应用程序 (dapp)**](/developers/docs/dapps)，它们共享算力池。 这个共享池是有限的，因此以太坊需要一种机制来确定谁可以使用它。 否则，某个 dapp 可能会意外或恶意地消耗所有网络资源，从而导致其他应用程序无法访问算力池。
+以太坊允许开发者创建[**去中心化应用程序 (dapps)**](/developers/docs/dapps)，它们都共享一个算力池。 这个共享池是有限的，因此以太坊需要一种机制来确定谁可以使用它。 否则，某个 dapp 可能会意外或恶意地消耗所有网络资源，从而导致其他应用程序无法访问算力池。
-ETH 加密货币支持以太坊算力的定价机制。 当用户想要完成一笔交易时，他们必须支付以太币，使他们的交易被区块链识别。 这些使用成本被称为 [gas 费用](/developers/docs/gas/)，gas 费用的多少取决于执行交易所需的算力和全网当时的算力需求。
+ETH 加密货币支持以太坊算力的定价机制。 当用户想要完成一笔交易时，他们必须支付以太币，使他们的交易被区块链识别。 这些使用成本被称为[燃料费](/developers/docs/gas/)，燃料费的多少取决于执行交易所需的算力以及当时全网对算力的需求。
因此，即使某恶意 dapp 无限循环提交，交易最终也会耗尽 ETH 并终止，从而使网络恢复正常。
-人们[经常会混淆](https://abcnews.go.com/Business/bitcoin-slumps-week-low-amid-renewed-worries-chinese/story?id=78399845)以太坊和以太币 — 当人们谈及“以太坊的价格”时，他们指的是以太币的价格。
+人们[常常混淆](https://abcnews.go.com/Business/bitcoin-slumps-week-low-amid-renewed-worries-chinese/story?id=78399845)以太坊和以太币——当人们提到“以太坊的价格”时，他们描述的是以太币的价格。
-## 铸造 ETH {#minting-ether}
+## 铸造以太币 {#minting-ether}
铸造是指在以太坊分类账上创造新以太币的过程。 底层以太坊协议创造出新以太币，单一用户不可能创造。
以太币铸造出来，用来奖励提议的每个区块，以及在每个时段的检查点奖励验证者执行的和达成共识有关的其他活动。 总发行量取决于验证者的数量和它们质押的以太币数量。 在所有验证者都诚实且在线的理想情况下，以太币总发行量会在所有验证者中等分，但现实中分配情况会因验证者的表现而异。 总发行量的大约 1/8 会奖励给区块提议者，剩余部分在其它验证者中分配。 区块提议者还会获得交易费小费和矿工可提取价值，但这些都来自流通中的以太币，而非新发行的以太币。
-## 燃烧 ETH {#burning-ether}
+## 销毁以太币 {#burning-ether}
除了通过区块奖励创建以太币，以太币也能通过“燃烧”过程销毁。 当 ETH 被燃烧掉，它也就永久退出流通。
-以太坊上的每一笔交易都会发生以太币销毁。 当用户为他们的交易支付费用时，网络根据交易需求设置的基础燃料费会被销毁。 以太币销毁再加上可变区块大小和最高燃料费，简化了以太坊上的交易费估算。 网络需求量高时，[区块](https://etherscan.io/block/12965263)燃烧的以太币数量可以多于铸造的以太币数量，有效地抵消了以太币的发行。
+以太坊上的每一笔交易都会发生以太币销毁。 当用户为他们的交易支付费用时，网络根据交易需求设置的基础燃料费会被销毁。 以太币销毁再加上可变区块大小和最高燃料费，简化了以太坊上的交易费估算。 当网络需求高时，[区块](https://eth.blockscout.com/block/22580057)销毁的以太币可以多于铸造的以太币，从而有效地抵消以太币发行。
-销毁基础费抑制区块生产者操纵交易的能力。 例如，如果区块生产者获得了基础费，他们可以免费添加自己的交易，并提高其他所有人的基础费。 或者，矿工可以将基础费退还给一些链下用户，造成交易费市场更加不透明和复杂。
+销毁基本费用会妨碍区块生产者操纵交易的能力。 例如，如果区块生产者获得了基础费，他们可以免费添加自己的交易，并提高其他所有人的基础费。 反之，他们也可以通过链下方式向部分用户退还基础费用，但这会导致交易费市场更加不透明和复杂。
-## ETH 面额 {#denominations}
+## 以太币的面额 {#denominations}
由于以太坊上很多交易数额都比较小，因此以太币有几种面额，可以作为较小的记账单位。 在这些面额中，Wei 与 Gwei 特别重要。
-Wei 是最小的以太币面额，因此在[以太坊黄皮书](https://ethereum.github.io/yellowpaper/paper.pdf)等众多技术实现中，都以 Wei 为单位进行计算。
+Wei 是以太币的最小单位，因此，许多技术实现（例如[《以太坊黄皮书》](https://ethereum.github.io/yellowpaper/paper.pdf)）都会以 Wei 为单位进行所有计算。
Gwei（giga-wei 的缩写），常用于描述以太坊上的燃料费用。
@@ -55,24 +55,24 @@ Gwei（giga-wei 的缩写），常用于描述以太坊上的燃料费用。
| Wei | 10-18 | 技术实施 |
| Gwei | 10-9 | 可读燃料费用 |
-## 传输 ETH {#transferring-ether}
+## 转账以太币 {#transferring-ether}
-以太坊上的每笔交易都包含一个 `value` 字段，指定从发送者地址发送到接收者地址的以太币转账金额（以 Wei 为单位）。
+以太坊上的每笔交易都包含一个 `value` 字段，该字段指定了从发送者地址发送到接收者地址的以太币转账金额（以 wei 为单位）。
-当接收者地址是[智能合约](/developers/docs/smart-contracts/)时，在智能合约执行其代码后，这些转账的以太币可用于支付燃料费用。
+当接收者地址是[智能合约](/developers/docs/smart-contracts/)时，当智能合约执行其代码时，这笔转账的以太币可用于支付燃料费。
-[有关交易的更多信息](/developers/docs/transactions/)
+[关于交易的更多信息](/developers/docs/transactions/)
-## 查询 ETH {#querying-ether}
+## 查询以太币 {#querying-ether}
-用户可以通过检查帐户的 `balance` 字段来查询任何[帐户](/developers/docs/accounts/)的以太币余额，该字段显示以太币持有数量（以 Wei 为单位）。
+用户可通过检查[帐户](/developers/docs/accounts/)的 `balance` 字段，查询任意帐户的以太币余额。该字段以 wei 为单位显示以太币持有量。
-[Etherscan](https://etherscan.io) 是一种常用工具，用于通过基于 Web 的应用程序检查地址余额。 例如，[此 Etherscan 页面](https://etherscan.io/address/0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae)显示以太坊基金会的余额。 也可以通过使用钱包或直接向节点提出请求来查询帐户余额。
+[Etherscan](https://etherscan.io) 和 [Blockscout](https://eth.blockscout.com) 是常用的工具，用于通过网页应用程序检查地址余额。 例如，[此 Blockscout 页面](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)显示了以太坊基金会的余额。 也可以通过使用钱包或直接向节点提出请求来查询帐户余额。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-- [定义 ETH 和以太坊](https://www.cmegroup.com/education/courses/introduction-to-ether/defining-ether-and-ethereum.html) – _CME Group_
-- [以太坊白皮书](/whitepaper/)：以太坊原始提案 这份资料包括了对 ETH 及其创建动机的整体描述。
-- [Gwei 计算器](https://www.alchemy.com/gwei-calculator)：使用这个 Gwei 计算器可以轻松地换算 wei、Gwei 和 ETH。 只需输入任何数量的 wei、Gwei 或 ETH，就能够自动换算。
+- [定义以太币和以太坊](https://www.cmegroup.com/education/courses/introduction-to-ether/defining-ether-and-ethereum.html) – _CME Group_
+- [以太坊白皮书](/whitepaper/)：以太坊原始提案。 这份资料包括了对 ETH 及其创建动机的整体描述。
+- [Gwei 计算器](https://www.alchemy.com/gwei-calculator)：使用此 Gwei 计算器可轻松换算 wei、Gwei 和 ETH。 只需输入任何数量的 wei、Gwei 或 ETH，就能够自动换算。
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
diff --git a/public/content/translations/zh/developers/docs/intro-to-ethereum/index.md b/public/content/translations/zh/developers/docs/intro-to-ethereum/index.md
index 5a85a4e2768..514fde47851 100644
--- a/public/content/translations/zh/developers/docs/intro-to-ethereum/index.md
+++ b/public/content/translations/zh/developers/docs/intro-to-ethereum/index.md
@@ -1,28 +1,28 @@
---
-title: 以太坊简介
-description: 面向 dapp 开发者介绍以太坊的核心概念。
+title: "以太币技术介绍"
+description: "面向 dapp 开发者介绍以太坊的核心概念。"
lang: zh
---
## 什么是区块链？ {#what-is-a-blockchain}
-对区块链最好的描述是将其描述为一个公共数据库，它由网络中的许多计算机更新和共享。
+区块链是一个公共数据库，由网络中的多台计算机进行更新和共享。
-"区块"指的是数据和状态是按顺序批量或"区块"存储的。 如果你向别人发送 ETH，需要将交易数据添加到一个区块中才算成功。
+“区块”指的是数据和状态存储在称为“区块”的连续群组中。 如果你向别人发送 ETH，需要将交易数据添加到一个区块中才算成功。
"链"指的是每个区块加密引用其父块。 换句话说，区块被链接在一起。 在不改变所有后续区块的情况下，区块内数据是无法改变，但改变后续区块需要整个网络的共识。
网络中的每台计算机都必须就每个新区块和链达成一致。 这些计算机被称为“节点”。 节点保证所有与区块链交互的人都有相同的数据。 要完成此分布式协议，区块链需要一个共识机制。
-以太坊采用[权益证明共识机制](/developers/docs/consensus-mechanisms/pos/)。 任何想在链上添加新区块的人都必须质押以太币（以太坊原生货币）做为抵押品并运行验证者软件。 接着，可以随机选择这些“验证者”来提出区块，再由其他验证者检查并添加到区块链中。 存在一种奖励和惩罚体系，有力地激励参与者尽可能地诚实和保持在线。
+以太坊使用一种[基于权益证明的共识机制](/developers/docs/consensus-mechanisms/pos/)。 任何想在链上添加新区块的人都必须质押以太币（以太坊原生货币）做为抵押品并运行验证者软件。 接着，可以随机选择这些“验证者”来提出区块，再由其他验证者检查并添加到区块链中。 存在一种奖励和惩罚体系，有力地激励参与者尽可能地诚实和保持在线。
-如果你想了解如何对区块链数据进行哈希运算并随后附加到区块引用的历史记录中，请务必查看Anders Brownworth 进行的[这个演示](https://andersbrownworth.com/blockchain/blockchain)并观看下方的相关视频。
+如果你想了解如何对区块链数据进行哈希运算并随后附加到区块引用的历史记录中，请务必查看 Anders Brownworth 制作的[这个演示](https://andersbrownworth.com/blockchain/blockchain)并观看下方的相关视频。
观看 Anders 介绍区块链中的哈希：
@:"
## 运行引导节点 {#run-a-bootnode}
-引导节点是不在 NAT（[网络地址转换](https://www.geeksforgeeks.org/network-address-translation-nat/)）后面的全节点。 只要全节点可以公开访问，它就可以充当引导节点。
+引导节点是不位于 NAT（[网络地址转换](https://www.geeksforgeeks.org/network-address-translation-nat/)）之后的全节点。 只要全节点可以公开访问，它就可以充当引导节点。
在启动节点时，它应该记录你的 [enode](/developers/docs/networking-layer/network-addresses/#enode)，也就是其他人用来连接该节点的公开标识符。
@@ -26,6 +26,6 @@ geth --bootnodes "enode://@:"
## 可用的引导节点 {#available-bootnodes}
-请在[此处](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23)查看 go-ethereum 中内建的引导节点列表。 这些引导节点由以太坊基金会和 go-ethereum 团队负责维护。
+go-ethereum 的内置引导节点列表可[在此处](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23)找到。 这些引导节点由以太坊基金会和 go-ethereum 团队负责维护。
你还可以找到一些由志愿者维护的其他引导节点列表。 请务必始终包含至少一个官方引导节点，否则你可能会受到日蚀攻击。
diff --git a/public/content/translations/zh/developers/docs/nodes-and-clients/client-diversity/index.md b/public/content/translations/zh/developers/docs/nodes-and-clients/client-diversity/index.md
index 899b267a6c6..f8540e1dfe4 100644
--- a/public/content/translations/zh/developers/docs/nodes-and-clients/client-diversity/index.md
+++ b/public/content/translations/zh/developers/docs/nodes-and-clients/client-diversity/index.md
@@ -1,6 +1,6 @@
---
-title: 客户端多样性
-description: 概括解释以太坊客户端多样性的重要性。
+title: "客户端多样性"
+description: "概括解释以太坊客户端多样性的重要性。"
lang: zh
sidebarDepth: 2
---
@@ -9,7 +9,7 @@ sidebarDepth: 2
## 前提条件 {#prerequisites}
-如果你还不了解什么是节点和客户端，请查看[节点和客户端](/developers/docs/nodes-and-clients/)。 [执行层](/glossary/#execution-layer)和[共识层](/glossary/#consensus-layer)的定义见词汇表。
+如果您还不了解什么是节点和客户端，请查阅[节点和客户端](/developers/docs/nodes-and-clients/)。 术语表中对[执行层](/glossary/#execution-layer)和[共识层](/glossary/#consensus-layer)进行了定义。
## 为什么会有多种客户端？ {#why-multiple-clients}
@@ -23,11 +23,11 @@ sidebarDepth: 2
当代表少数以太坊节点时，一种客户端中的漏洞对网络的风险较小。 由于许多客户端的节点分布大致均匀，大多数客户端出现同一问题的可能性很小，因此网络更加稳健。
-### 抵御攻击 {#resilience}
+### 抗攻击能力 {#resilience}
-客户端多样性还提供了抵御攻击的能力。 例如，要[欺骗特定客户端](https://twitter.com/vdWijden/status/1437712249926393858)让其接受链的某条分支，这种攻击不太可能成功，因为不大可能以相同方式利用其他客户端，并且规范链未损坏。 客户端多样性程度低增加了主要客户端受到黑客攻击的风险。 已经证实，客户端多样性是抵御网络受到恶意攻击的重要防御手段，例如，由于攻击者能够欺骗主要客户端 (Geth) 对每个区块执行数万次慢速磁盘输入/输出操作，2016 年的上海拒绝服务攻击得以实施。 由于有其他客户端在线且没有同样的漏洞，因此以太坊能够抵抗那次攻击并继续运行，同时修复了 Geth 中的漏洞。
+客户端多样性还提供了抵御攻击的能力。 例如，一种[欺骗特定客户端](https://twitter.com/vdWijden/status/1437712249926393858)使其接受链的特定分叉的攻击不太可能成功，因为其他客户端不太可能以同样的方式被利用，并且规范链仍未损坏。 客户端多样性程度低增加了主要客户端受到黑客攻击的风险。 已经证实，客户端多样性是抵御网络受到恶意攻击的重要防御手段，例如，由于攻击者能够欺骗主要客户端 (Geth) 对每个区块执行数万次慢速磁盘输入/输出操作，2016 年的上海拒绝服务攻击得以实施。 由于有其他客户端在线且没有同样的漏洞，因此以太坊能够抵抗那次攻击并继续运行，同时修复了 Geth 中的漏洞。
-### 权益证明的最终确定性 {#finality}
+### 权益证明的确定性 {#finality}
超过 33% 的以太坊节点的共识客户端中有一个漏洞，它可能会阻止共识层的最终确定，这意味着用户无法相信交易不会在某些时候被回滚或更改。 对于许多建立在以太坊之上的应用程序，尤其是去中心化金融，这将是一个很大的问题。
@@ -35,19 +35,45 @@ sidebarDepth: 2
尽管这些情况不太可能发生，但为了降低这类风险，以太坊生态系统可以使客户端均衡分布在活跃节点上。 理想情况下，任何共识客户端任何时候都不会达到总节点数的 33%。
-### 共担责任 {#responsibility}
+### 共同责任 {#responsibility}
采用主流客户端也需要人力成本。 这给小型开发团队带来了过多的压力和责任。 客户端多样性程度越低，维护主流客户端的开发者的责任负担就越大。 将这一责任分摊到多个团队，既有利于以太坊节点网络的健康，也有益于相关人员的健康。
-## 客户端多样性现状 {#current-client-diversity}
+## 当前客户端多样性 {#current-client-diversity}
- _图表数据来自 [ethernodes.org](https://ethernodes.org) 和 [ clientdiversity.org](https://clientdiversity.org/)_
+### 执行客户端 {#execution-clients-breakdown}
-上面的两个饼图显示了执行层和共识层客户端多样性现状的快照（在 2022 年 1 月撰写本文时）。 在执行层，[Geth](https://geth.ethereum.org/) 占据绝对主导地位，[Open Ethereum ](https://openethereum.github.io/) 以极大的差距位居第二，[Erigon](https://github.com/ledgerwatch/erigon) 和 [Nethermind](https://nethermind.io/) 分别占据第三和第四，其他客户端加起来占网络的比例不到 1%。 共识层最常用的客户端 [Prysm](https://prysmaticlabs.com/#projects) 不像 Geth 那样占据绝对主导地位，但仍占有网络的 60% 以上。 [Lighthouse](https://lighthouse.sigmaprime.io/) 和 [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) 分别占据约 20% 和约 14%，其他客户端很少使用。
+学习如何使用并通过基于 .NET 的项目及工具参与以太坊的开发
+了解如何使用基于 .NET 的项目和工具为以太坊进行开发
-使用以太坊来创建去中心化应用程序（或称“dapp”），发挥加密货币和区块链技术的优势。 这些去中心化应用程序可以是值得信赖的，也即一旦被部署到以太坊上，它们将总是按程序运行。 这些应用程序可以控制数字资产，以便创造新的金融应用； 它们可以是去中心化的，也即没有任何单一实体或个人能够控制它们，而且它们几乎是不可能被审查的。
+使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可被信任，意味着一旦被部署到以太坊上，它们将总是按既定程序运行。 这些应用程序可以控制数字资产并构建新的金融应用。 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
使用 Microsoft 技术堆栈中的工具和语言在以太坊上搭建去中心化应用程序和与智能合约交互 —— .NET Framework/.NET Core/.NET Standard 支持 VSCode 和 Visual Studio 等工具上的 C#、# Visual Basic .NET、F#。 使用 Microsoft Azure 区块链在 Azure 上部署一条以太坊区块链，几分钟即可完成。 将人们对 .NET 的喜爱带到以太坊上！
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-the-solidity-language}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-the-solidity-language}
**迈出集成 .NET 与以太坊的第一步**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或者 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-## 初学者参考文献和链接 {#beginner-references-and-links}
+## 入门参考资料和链接 {#beginner-references-and-links}
**介绍 Nethereum 库和 VS Code Solidity**
-- [开始了解 Nethereum](https://docs.nethereum.com/en/latest/getting-started/)
-- [安装 VS Code Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
-- [.NET 开发者创建和调用以太坊智能合约的工作流](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
-- [智能合约与 Nethereum 的集成](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
-- [使用 Nethereum 连接 .NET 和以太坊区块链智能合约](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933)，也可参考此[中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
-- [Nethereum——开源的区块链 .NET 集成库](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
+- [Nethereum，入门](https://docs.nethereum.com/en/latest/getting-started/)
+- [安装 VS Code Solidity 插件](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
+- [.NET 开发者创建和调用以太坊智能合约的工作流程](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
+- [使用 Nethereum 集成智能合约](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
+- [使用 Nethereum 连接 .NET、以太坊区块链和智能合约](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933)，另有 [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1)
+- [Nethereum - 一个用于区块链的开源 .NET 集成库](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
- [使用 Nethereum 将以太坊交易写入 SQL 数据库](https://medium.com/coinmonks/writing-ethereum-transactions-to-sql-database-using-nethereum-fd94e0e4fa36)
-- [查看如何使用 C# 和 VisualStudio 轻松地部署以太坊智能合约](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
+- [了解如何使用 C# 和 VisualStudio 轻松部署以太坊智能合约](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
-**现在想要跳过设置，直接跳转到样本？**
+**想要立即跳过设置，直接查看示例吗？**
-- [训练场](http://playground.nethereum.com/) - 与以太坊进行交互，学习如何通过浏览器使用 Nethereum。
- - 查询帐户余额[C#](http://playground.nethereum.com/csharp/id/1001)[VB.NET](http://playground.nethereum.com/vb/id/2001)
- - 查询 ERC20 智能合约余额[C#](http://playground.nethereum.com/csharp/id/1005)[VB.NET](http://playground.nethereum.com/vb/id/2004)
- - 转账以太币至帐户 [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
+- [演练场](http://playground.nethereum.com/) - 在浏览器中与以太坊交互并学习如何使用 Nethereum。
+ - 查询帐户余额 [C#](http://playground.nethereum.com/csharp/id/1001) [VB.NET](http://playground.nethereum.com/vb/id/2001)
+ - 查询 ERC20 智能合约余额 [C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
+ - 向帐户转账以太币 [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
- ... 以及更多！
-## 面向中等程度用户的文章 {#intermediate-articles}
+## 中级文章 {#intermediate-articles}
-- [Nethereum 练习册/样本列表](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
+- [Nethereum 工作簿/示例列表](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
- [部署你自己的开发测试链](https://github.com/Nethereum/Testchains)
-- [Solidity 的 VSCode Codegen 插件](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
-- [Unity 和以太坊：为何以及如何？](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
-- [为以太坊 dapp 创建 ASP.NET Core Web API](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
-- [使用 Nethereum Web3 来实现一个供应链追踪系统](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
-- [Nethereum 区块处理](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/)，包含了[C# 操作样本](http://playground.nethereum.com/csharp/id/1025)
-- [Nethereum Websocket Streaming](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
+- [适用于 Solidity 的 VSCode 代码生成插件](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
+- [Unity 和以太坊：缘由与方法](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
+- [为以太坊去中心化应用程序创建 ASP.NET Core Web 应用程序接口](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
+- [使用 Nethereum Web3 实现供应链追踪系统](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
+- [Nethereum 区块处理](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/)，附 [C# 演练场示例](http://playground.nethereum.com/csharp/id/1025)
+- [Nethereum Websocket 流式传输](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
- [Kaleido 和 Nethereum](https://kaleido.io/kaleido-and-nethereum/)
- [Quorum 和 Nethereum](https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Quorum/README.md)
-## 面向高等程度用户的使用模式 {#advanced-use-patterns}
+## 高级使用模式 {#advanced-use-patterns}
- [Azure Key Vault 和 Nethereum](https://github.com/Azure-Samples/bc-community-samples/tree/master/akv-nethereum)
- [Nethereum.DappHybrid](https://github.com/Nethereum/Nethereum.DappHybrid)
- [Ujo Nethereum 后端参考架构](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
-## .NET 项目、工具和其他有趣内容 {#dot-net-projects-tools-and-other-fun-stuff}
+## .NET 项目、工具及其他有趣内容 {#dot-net-projects-tools-and-other-fun-stuff}
-- [Nethereum 训练场](http://playground.nethereum.com/) - _在浏览器中编译、创建和运行 Nethereum 代码片段_
-- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _在 Blazor 中具有 UI 的 Nethereum 代码生成_
-- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _.NET Wasm SPA 轻区块链浏览器和简单钱包_
-- [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) - _业务规则引擎（同时适用于 .NET 平台和以太坊平台），本质上是由元数据驱动的_
-- [Nethermind](https://github.com/NethermindEth/nethermind) - _面向 Linux、Windows、MacOS 操作系统的 .NET Core 以太坊客户端_
-- [eth-utils](https://github.com/ethereum/eth-utils/) - _使用以太坊相关代码库的实用函数工具_
-- [TestChains](https://github.com/Nethereum/TestChains) - _预先配置的 .NET devchains，用于快速回应 (PoA)_
+- [Nethereum 演练场](http://playground.nethereum.com/) - _在浏览器中编译、创建并运行 Nethereum 代码片段_
+- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _带 Blazor 用户界面的 Nethereum 代码生成器_
+- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _一个 .NET Wasm SPA 轻量级区块链浏览器和简易钱包_
+- [Wonka 业务规则引擎](https://docs.nethereum.com/en/latest/wonka/) - _一种业务规则引擎（适用于 .NET 平台和以太坊平台），本质上是由元数据驱动的_
+- [Nethermind](https://github.com/NethermindEth/nethermind) - _一个适用于 Linux、Windows、MacOS 的 .NET Core 以太坊客户端_
+- [eth-utils](https://github.com/ethereum/eth-utils/) - _用于处理以太坊相关代码库的实用函数_
+- [TestChains](https://github.com/Nethereum/TestChains) - _预配置的 .NET 开发链，可实现快速响应 (PoA)_
-想要获取更多的资源？ 请查看 [ethereum.org/developers](/developers/)。
+正在寻找更多资源？ 请访问 [ethereum.org/developers](/developers/)。
## .NET 社区贡献者 {#dot-net-community-contributors}
-在 Nethereum，我们主要活跃于 [Gitter](https://gitter.im/Nethereum/Nethereum) 上，任何人都可以前来提问/回答问题，获得帮助或者前来逛逛。 可以随意在 [Nethereum GitHub 存储库](https://github.com/Nethereum)上提交拉取请求或者打开一个问题，或者仅仅浏览我们提供的许多小项目/示例项目。 你可以在 [Discord](https://discord.gg/jQPrR58FxX) 上找到我们！
+在 Nethereum，我们主要在 [Gitter](https://gitter.im/Nethereum/Nethereum) 上交流，欢迎大家来提问、回答问题、获取帮助或者随便聊聊。 欢迎在 [Nethereum GitHub 代码库](https://github.com/Nethereum)提交 PR 或问题，或者浏览我们众多的附属/示例项目。 你也可以在 [Discord](https://discord.gg/jQPrR58FxX) 上找到我们！
-如果你是 Nethermind 的新手并且需要入门帮助，请加入我们的 [Discord](http://discord.gg/PaCMRFdvWT)。 我们的开发人员随时准备回答你的问题。 不要犹豫，在 [Nethermind GitHub 存储库](https://github.com/NethermindEth/nethermind)上打开一个拉取请求或提出任何问题。
+如果你是 Nethermind 新手，需要入门帮助，请加入我们的 [Discord](http://discord.gg/PaCMRFdvWT)。 我们的开发人员随时准备回答你的问题。 欢迎在 [Nethermind GitHub 代码库](https://github.com/NethermindEth/nethermind)提交 PR 或问题。
## 其他汇总列表 {#other-aggregated-lists}
diff --git a/public/content/translations/zh/developers/docs/programming-languages/elixir/index.md b/public/content/translations/zh/developers/docs/programming-languages/elixir/index.md
index 3300b4a247b..c1cd0ce994d 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/elixir/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/elixir/index.md
@@ -1,19 +1,19 @@
---
-title: 面向 Elixir 开发者的以太坊
-description: 了解如何使用基于 Elixir 的项目和工具为以太坊开发。
+title: "面向 Elixir 开发者的以太坊"
+description: "了解如何使用基于 Elixir 的项目和工具为以太坊开发。"
lang: zh
incomplete: false
---
了解如何使用基于 Elixir 的项目和工具为以太坊开发。
-使用以太坊来创建去中心化应用程序（或称“dapp”），发挥加密货币和区块链技术的优势。 这些去中心化应用程序可以去信任，这意味着在部署到以太坊后，它们将始终按程序设定运行。 去中心化应用程序可以控制数字资产，从而创建新类型的金融应用程序。 它们可以是去中心化的，也即没有任何单一实体或个人能够控制它们，而且它们几乎是不可能被审查的。
+使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可以去信任，这意味着在部署到以太坊后，它们将始终按程序设定运行。 去中心化应用程序可以控制数字资产，从而创建新类型的金融应用程序。 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出将 Elixir 与以太坊集成的第一步**
-需要更基础的入门知识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
@@ -49,7 +49,7 @@ incomplete: false
- [exw3](https://github.com/hswick/exw3) - _用于 Elixir 的高级以太坊远程过程调用 (RPC) 客户端_
- [mana](https://github.com/mana-ethereum/mana) - _一个用 Elixir 编写的以太坊全节点实现_
-想要获取更多的资源？ 访问[我们的开发者首页](/developers/)。
+正在寻找更多资源？ 访问[我们的开发者首页](/developers/)。
## Elixir 社区贡献者 {#elixir-community-contributors}
diff --git a/public/content/translations/zh/developers/docs/programming-languages/golang/index.md b/public/content/translations/zh/developers/docs/programming-languages/golang/index.md
index 0e2e3d57cd9..44cce44cc77 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/golang/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/golang/index.md
@@ -1,84 +1,84 @@
---
-title: 面向 Go 开发者的以太坊
-description: 学习如何使用基于 Go 的项目和工具参与以太坊的开发
+title: "面向 Go 开发者的以太坊"
+description: "学习如何使用基于 Go 的项目和工具参与以太坊的开发"
lang: zh
incomplete: true
---
-学习如何使用基于 Go 的项目和工具参与以太坊的开发
+了解如何使用基于 Go 的项目和工具为以太坊进行开发
使用以太坊创建去中心化应用程序（即"dapps"）。 这些去中心化应用程序可被信任，意味着一旦被部署到以太坊上，它们将总是按既定程序运行。 它们是去中心化的，意味着它们运行在一个点对点网络中并且不存在单点故障。 不存在单一实体或者个人可以控制它们，它们也几乎不可能被审查。 它们可以通过控制数字资产来创建新的应用。
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-solidity}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出集成 Go 与以太坊的第一步**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或者 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
-- [智能合约教程](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [合约教程](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
## 初学者文章和书籍 {#beginner-articles-and-books}
-- [开始使用 Geth](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
+- [Geth 入门](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
- [使用 Golang 连接到以太坊](https://www.youtube.com/watch?v=-7uChuO_VzM)
- [使用 Golang 部署以太坊智能合约](https://www.youtube.com/watch?v=pytGqQmDslE)
-- [一步步教你测试和部署以太坊 Go 语言智能合约](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
-- [电子书：使用 Go 开发以太坊](https://goethereumbook.org/) - _使用 Go 开发以太坊应用程序_
+- [在 Go 中测试和部署以太坊智能合约的分步指南](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
+- [电子书：使用 Go 进行以太坊开发](https://goethereumbook.org/) - _使用 Go 开发以太坊应用_
-## 面向中等程度用户的文章和文档 {#intermediate-articles-and-docs}
+## 中级文章和文档 {#intermediate-articles-and-docs}
-- [Go 以太坊相关文档](https://geth.ethereum.org/docs/) - _官方以太坊 Golang 相关文档_
-- [Erigon 程序员指南](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _图文指南，包括状态树、多重证明和交易处理_
+- [Go Ethereum 文档](https://geth.ethereum.org/docs/) - _以太坊官方 Golang 实现的文档_
+- [Erigon 程序员指南](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _附图指南，包括状态树、多重证明和交易处理_
- [Erigon 和无状态以太坊](https://youtu.be/3-Mn7OckSus?t=394) - _2020 年以太坊社区会议 (EthCC 3)_
-- [Erigon：优化以太坊客户端](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 年开发者大会 4_
-- [Go 以太坊 GoDoc](https://godoc.org/github.com/ethereum/go-ethereum)
-- [在 Go 上使用 Geth 创建去中心化应用程序](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
-- [用 Golang 和 Geth 使用以太坊专用网络](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
+- [Erigon：优化以太坊客户端](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 年以太坊开发者大会 4_
+- [Go Ethereum GoDoc](https://godoc.org/github.com/ethereum/go-ethereum)
+- [使用 Geth 在 Go 中创建去中心化应用程序](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
+- [使用 Golang 和 Geth 在以太坊私有网络上工作](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
- [使用 Go 对以太坊上的 Solidity 合约进行单元测试](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
-- [使用 Geth 作为库的快速参考](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
+- [将 Geth 用作程序库的快速参考](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
-## 面向高等程度用户的使用模式 {#advanced-use-patterns}
+## 高级使用模式 {#advanced-use-patterns}
-- [使用 GETH 模拟后端搭建](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
-- [基于以太坊和 Quorum 的区块链即服务应用程序](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
-- [以太坊区块链应用程序中的分布式存储星际文件系统和 Swarm](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
-- [移动客户端：各种库和 Inproc 以太坊节点](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
-- [原生去中心化应用程序：到以太坊合约的 Go 绑定](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
+- [GETH 模拟后端](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
+- [使用以太坊和 Quorum 的区块链即服务应用程序](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
+- [以太坊区块链应用程序中的分布式存储 IPFS 和 Swarm](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
+- [移动客户端：程序库和 Inproc 以太坊节点](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
+- [原生去中心化应用程序：以太坊合约的 Go 绑定](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
## Go 项目和工具 {#go-projects-and-tools}
- [Geth / Go Ethereum](https://github.com/ethereum/go-ethereum) - _以太坊协议的官方 Go 实现_
-- [Go Ethereum Code Analysis](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _审查和分析 Go 以太坊源代码_
-- [Erigon](https://github.com/ledgerwatch/erigon) - _Go 以太坊的更快衍生品，专注于归档节点_
-- [Golem](https://github.com/golemfactory/golem) - _Golem 正在创建一个算力全球市场_
-- [Quorum](https://github.com/jpmorganchase/quorum) - _支持数据隐私的许可型以太坊实现_
-- [Prysm](https://github.com/prysmaticlabs/prysm) - _以太坊 'Serenity' 2.0 Go 实现_
-- [Eth Tweet](https://github.com/yep/eth-tweet) - _去中心化 Twitter：运行在以太坊区块链上的微博客服务_
-- [Plasma MVP Golang](https://github.com/kyokan/plasma) — _Golang 实现以及最小可执行 Plasma 规范拓展_
-- [Open Ethereum Mining Pool](https://github.com/sammy007/open-ethereum-pool) - _以太坊开源矿池_
-- [Ethereum HD Wallet](https://github.com/miguelmota/go-ethereum-hdwallet) - _使用 Go 的以太坊硬件钱包衍生品_
+- [Go Ethereum 代码分析](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _Go Ethereum 源代码的审查和分析_
+- [Erigon](https://github.com/ledgerwatch/erigon) - _Go Ethereum 的更快衍生版本，专注于归档节点_
+- [Golem](https://github.com/golemfactory/golem) - _Golem 正在创建一个全球算力市场_
+- [Quorum](https://github.com/jpmorganchase/quorum) - _一种支持数据隐私的以太坊许可型实现_
+- [Prysm](https://github.com/prysmaticlabs/prysm) - _以太坊“宁静”2.0 Go 实现_
+- [Eth Tweet](https://github.com/yep/eth-tweet) - _去中心化推特：一个运行在以太坊区块链上的微博客服务_
+- [Plasma MVP Golang](https://github.com/kyokan/plasma) — _最小可行 Plasma 规范的 Golang 实现和扩展_
+- [开源以太坊矿池](https://github.com/sammy007/open-ethereum-pool) - _一个开源的以太坊矿池_
+- [以太坊 HD 钱包](https://github.com/miguelmota/go-ethereum-hdwallet) - _以太坊 HD 钱包的 Go 派生实现_
- [Multi Geth](https://github.com/multi-geth/multi-geth) - _支持多种以太坊网络_
-- [Geth Light Client](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _轻量级以太坊子协议的 Geth 实现_
-- [以太坊 Golang 软件开发工具包](https://github.com/everFinance/goether) - _Golang 中的简单以太坊钱包实现和实用程序_
-- [Covalent Golang 软件开发工具包](https://github.com/covalenthq/covalent-api-sdk-go) - _通过 Go 软件开发工具包高效访问多达 200 个区块链的区块链数据_
+- [Geth 轻客户端](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _轻以太坊子协议的 Geth 实现_
+- [以太坊 Golang 软件开发工具包](https://github.com/everFinance/goether) - _用 Golang 实现的一个简单以太坊钱包和实用工具_
+- [Covalent Golang 软件开发工具包](https://github.com/covalenthq/covalent-api-sdk-go) - _通过 Go 软件开发工具包高效访问 200 多个区块链的区块链数据_
-想要获取更多的资源？ 请查看 [ethereum.org/developers](/developers/)。
+正在寻找更多资源？ 查看 [ethereum.org/developers](/developers/)
## Go 社区贡献者 {#go-community-contributors}
- [Geth Discord](https://discordapp.com/invite/nthXNEv)
-- [Geth Gist](https://gitter.im/ethereum/go-ethereum)
+- [Geth Gitter](https://gitter.im/ethereum/go-ethereum)
- [Gophers Slack](https://invite.slack.golangbridge.org/) - [#ethereum 频道](https://gophers.slack.com/messages/C9HP1S9V2)
- [StackExchange - 以太坊](https://ethereum.stackexchange.com/)
- [Multi Geth Gitter](https://gitter.im/ethoxy/multi-geth)
- [Ethereum Gitter](https://gitter.im/ethereum/home)
-- [Geth light Client Gitter](https://gitter.im/ethereum/light-client)
+- [Geth 轻客户端 Gitter](https://gitter.im/ethereum/light-client)
## 其他汇总列表 {#other-aggregated-lists}
-- [强大的以太坊](https://github.com/btomashvili/awesome-ethereum)
-- [Consensys：以太坊开发工具的权威清单](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [GitHub 源](https://github.com/ConsenSys/ethereum-developer-tools-list)
+- [以太坊精选资源](https://github.com/btomashvili/awesome-ethereum)
+- [Consensys：以太坊开发者工具权威列表](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [GitHub 源代码](https://github.com/ConsenSys/ethereum-developer-tools-list)
diff --git a/public/content/translations/zh/developers/docs/programming-languages/index.md b/public/content/translations/zh/developers/docs/programming-languages/index.md
index 0765816e715..8be865783c9 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/index.md
@@ -1,10 +1,11 @@
---
-title: 编程语言
-description:
+title: "编程语言"
+description: "探索各种编程语言的以太坊开发资源，包括 JavaScript、Python、Go、Rust 等等。"
lang: zh
---
-一个常见的误解是开发者必须编写[智能合约](/developers/docs/smart-contracts/)才能在以太坊上构建。 这是错误的。 以太坊网络及其社区的一个美好之处是你可以使用任意编程语言[参与](/community/)其中。
+一个常见的误解是开发者必须编写智能合约才能在以太坊上构建。 这是错误的。
+以太坊网络及其社区的一个美好之处是你可以使用任意编程语言参与其中。
以太坊及其社区拥抱开源。 你可以找到各种语言的社区项目 - 客户端实现、API、开发框架、测试工具。
@@ -12,19 +13,21 @@ lang: zh
选择你使用的编程语言以便查找项目、资源和虚拟社区：
-- [面向 Dart 开发者的以太坊资源](/developers/docs/programming-languages/dart/)
-- [面向 Delphi 开发者的以太坊资源](/developers/docs/programming-languages/delphi/)
-- [面向 .NET 开发者的以太坊资源](/developers/docs/programming-languages/dot-net/)
+- [面向 Dart 开发者的以太坊](/developers/docs/programming-languages/dart/)
+- [面向 Delphi 开发者的以太坊](/developers/docs/programming-languages/delphi/)
+- [面向 .NET 开发者的以太坊](/developers/docs/programming-languages/dot-net/)
- [面向 Elixir 开发者的以太坊](/developers/docs/programming-languages/elixir/)
-- [面向 Go 开发者的以太坊资源](/developers/docs/programming-languages/golang/)
-- [面向 Java 开发者的以太坊资源](/developers/docs/programming-languages/java/)
-- [面向 JavaScript 开发者的以太坊资源](/developers/docs/programming-languages/javascript/)
-- [面向 Python 开发者的以太坊资源](/developers/docs/programming-languages/python/)
-- [面向 Ruby 开发者的以太坊资源](/developers/docs/programming-languages/ruby/)
-- [面向 Rust 开发者的以太坊资源](/developers/docs/programming-languages/rust/)
+- [面向 Go 开发者的以太坊](/developers/docs/programming-languages/golang/)
+- [面向 Java 开发者的以太坊](/developers/docs/programming-languages/java/)
+- [面向 JavaScript 开发者的以太坊](/developers/docs/programming-languages/javascript/)
+- [面向 Python 开发者的以太坊](/developers/docs/programming-languages/python/)
+- [面向 Ruby 开发者的以太坊](/developers/docs/programming-languages/ruby/)
+- [面向 Rust 开发者的以太坊](/developers/docs/programming-languages/rust/)
### 如果不支持我的语言怎么办 {#other-lang}
-如果你想链接到资源或指向额外编程语言的虚拟社区，你可以通过[提出问题](https://github.com/ethereum/ethereum-org-website/issues/new/choose) 来申请新页面。
+如果你想为其他编程语言添加资源链接或指向某个虚拟社区，可以通过[提交问题](https://github.com/ethereum/ethereum-org-website/issues/new/choose)来申请新页面。
-如果只想使用当前不支持的语言 编写与区块链对接的代码，你可以使用 [JSON-RPC 接口](/developers/docs/apis/json-rpc/)连接以太坊网络。 任何可以使用 TCP/IP 的编程 语言都可以使用此接口。
+如果只想使用当前不支持的语言
+编写与区块链对接的代码，你可以使用 [JSON-RPC 接口](/developers/docs/apis/json-rpc/) 连接到以太坊网络。 任何可以使用 TCP/IP 的编程
+语言都可以使用此接口。
diff --git a/public/content/translations/zh/developers/docs/programming-languages/java/index.md b/public/content/translations/zh/developers/docs/programming-languages/java/index.md
index 61f53467d81..3924d95609d 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/java/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/java/index.md
@@ -1,61 +1,62 @@
---
-title: 面向 Java 开发者的以太坊资源
-description: 学习如何使用并通过基于 Java 的项目及工具参与以太坊的开发
+title: "面向 Java 开发者的以太坊资源"
+description: "学习如何使用并通过基于 Java 的项目及工具参与以太坊的开发"
lang: zh
incomplete: true
---
-学习如何使用并通过基于 Java 的项目及工具参与以太坊的开发
+了解如何使用基于 Java 的项目和工具为以太坊开发
-使用以太坊来创建去中心化应用程序（或称“dapp”），发挥加密货币和区块链技术的优势。 这些去中心化应用程序可以是值得信赖的，也即一旦被部署到以太坊上，它们将总是按程序运行。 这些应用程序可以控制数字资产，以便创造新的金融应用； 它们可以是去中心化的，也即没有任何单一实体或个人能够控制它们，而且它们几乎是不可能被审查的。
+使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可被信任，意味着一旦被部署到以太坊上，它们将总是按既定程序运行。 这些应用程序可以控制数字资产并构建新的金融应用。 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-solidity}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出第一步，将 Java 与以太坊进行集成**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或者 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers.](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
## 使用以太坊客户端 {#working-with-ethereum-clients}
了解如何使用 [Web3J](https://github.com/web3j/web3j) 和 Hyperledger Besu 这两个领先的 Java 以太坊客户端。
-- [使用 Java 、Eclipse 和 Web3J 连接以太坊客户端](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
+- [使用 Java、Eclipse 和 Web3J 连接到以太坊客户端](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
- [使用 Java 和 Web3j 管理以太坊帐户](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j)
-- [从智能合约中生成 Java 包装器](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
-- [与以太坊智能合约互动](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
+- [从您的智能合约生成 Java 包装器](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
+- [与以太坊智能合约交互](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
- [监听以太坊智能合约事件](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
-- [使用 Besu (Pantheon)， Linux 下的 Java 以太坊客户端](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
-- [在 Java 集成测试中运行一个 Hyperledger Besu (Pantheon) 节点](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
-- [Web3j 备忘单](https://kauri.io/web3j-cheat-sheet-(java-ethereum)/5dfa1ea941ac3d0001ce1d90/c)
+- [在 Linux 上使用 Java 以太坊客户端 Besu (Pantheon)](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
+- [在 Java 集成测试中运行 Hyperledger Besu (Pantheon) 节点](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
+- [Web3j 备忘单](https://kauri.io/web3j-cheat-sheet-\(java-ethereum\)/5dfa1ea941ac3d0001ce1d90/c)
+
+了解如何使用 [ethers-kt](https://github.com/Kr1ptal/ethers-kt)，一个与基于 EVM 的区块链交互的异步、高性能 Kotlin 程序库。 面向 Java 虚拟机和 Android 平台。
-学习如何使用 [ethers-kt](https://github.com/Kr1ptal/ethers-kt)，一个用来同基于以太坊虚拟机的区块链互动的高性能异步 Kotlin 库。 面向 Java 虚拟机和 Android 平台。
- [转移 ERC20 代币](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
-- [带事件监听的 UniswapV2 Swap](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
-- [以太币 / ERC20 余额追踪器](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
+- [带事件监听的 UniswapV2 交换](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
+- [ETH / ERC20 余额跟踪器](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
-## 面向中等程度用户的文章 {#intermediate-articles}
+## 中级文章 {#intermediate-articles}
-- [使用星际文件系统在 Java 应用程序中管理存储](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
+- [使用 IPFS 在 Java 应用中管理存储](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
- [使用 Web3j 在 Java 中管理 ERC20 代币](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
- [Web3j 交易管理器](https://kauri.io/article/4cb780bb4d0846438d11885a25b6d7e7/web3j-transaction-managers)
-## 面向高等程度用户的使用模式 {#advanced-use-patterns}
+## 高级使用模式 {#advanced-use-patterns}
- [使用 Eventeum 构建 Java 智能合约数据缓存](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
## Java 项目和工具 {#java-projects-and-tools}
-- [Web3J（与以太坊客户端交互的库）](https://github.com/web3j/web3j)
-- [ethers-kt（面向基于以太坊虚拟机区块链的高性能异步 Kotlin/Java/Android 库）](https://github.com/Kr1ptal/ethers-kt)
-- [Eventeum（事件侦听器）](https://github.com/ConsenSys/eventeum)
-- [Mahuta（IPFS 开发者工具）](https://github.com/ConsenSys/mahuta)
+- [Web3J（与以太坊客户端交互的程序库）](https://github.com/web3j/web3j)
+- [ethers-kt（面向基于 EVM 的区块链的异步、高性能 Kotlin/Java/Android 程序库。）](https://github.com/Kr1ptal/ethers-kt)
+- [Eventeum（事件监听器）](https://github.com/ConsenSys/eventeum)
+- [Mahuta（IPFS 开发工具）](https://github.com/ConsenSys/mahuta)
-想要获取更多的资源？ 请浏览 [ethereum.org/developers](/developers/)。
+正在寻找更多资源？ 请查看 [ethereum.org/developers.](/developers/)
## Java 社区贡献者 {#java-community-contributors}
diff --git a/public/content/translations/zh/developers/docs/programming-languages/javascript/index.md b/public/content/translations/zh/developers/docs/programming-languages/javascript/index.md
index 37a56e5829a..b9817c80cc5 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/javascript/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/javascript/index.md
@@ -1,34 +1,35 @@
---
-title: 面向 JavaScript 开发者的以太坊资源
-description: 学习如何使用并通过基于 JavaScript 的项目及工具参与以太坊的开发。
+title: "面向 JavaScript 开发者的以太坊资源"
+description: "学习如何使用并通过基于 JavaScript 的项目及工具参与以太坊的开发。"
lang: zh
---
-JavaScript是以太坊生态中最受欢迎的语言之一。 事实上，有一个 [团队](https://github.com/ethereumjs) 致力于尽可能多地在以太坊引入 JavaScript。
+JavaScript是以太坊生态中最受欢迎的语言之一。 事实上，有一个[团队](https://github.com/ethereumjs)致力于将尽可能多的以太坊功能引入 JavaScript。
-有机会在[堆栈的所有级别](/developers/docs/ethereum-stack/)使用 JavaScript（或接近）。
+你将有机会在[堆栈的各个层面](/developers/docs/ethereum-stack/)编写 JavaScript（或类似语言）。
-## Javascript 和以太坊的交互 {#interact-with-ethereum}
+## 与以太坊交互 {#interact-with-ethereum}
### JavaScript API 库 {#javascript-api-libraries}
-如果你想要写入 JavaScript 来查询区块链、发送交易等，则最方便的方法是使用 [JavaScript API 库](/developers/docs/apis/javascript/)。 这些 API 允许开发者轻松与[以太坊网络节点](/developers/docs/nodes-and-clients/)交互。
+如果你想要写入 JavaScript 来查询区块链、发送交易等，最方便的方法是使用 [JavaScript API 库](/developers/docs/apis/javascript/)。 这些 API 允许开发者轻松与[以太坊网络中的节点](/developers/docs/nodes-and-clients/)交互。
你可以使用这些库与以太坊上的智能合约交互，因此只需要使用 JavaScript 与既有合约交互就可以构建一个 dapp。
-**参阅：**
+**参阅**
-- [Web3.js](https://web3js.readthedocs.io/)
-- [Ethers.js](https://docs.ethers.io/) _– 包含 JavaScript 和 TypeScript 的完整以太坊钱包的实现和工具。_
-- [viem](https://viem.sh) – 一个用于以太坊的 TypeScript 接口，提供与以太坊交互的底层无状态基元。
+- [Web3.js](https://web3js.readthedocs.io)
+- [Ethers.js](https://ethers.org) – _包含用 JavaScript 和 TypeScript 实现的以太坊钱包和实用工具。_
+- [viem](https://viem.sh) – _一个用于以太坊的 TypeScript 接口，提供与以太坊交互的底层无状态基元。_
+- [Drift](https://ryangoree.github.io/drift/) – _一个 TypeScript 元库，内置缓存、挂钩和测试模拟功能，可跨多个 Web3 库轻松进行以太坊开发。_
### 智能合约 {#smart-contracts}
-作为 JavaScript 开发者，如果希望编写自己的智能合约，你可能想要了解 [Solidity](https://solidity.readthedocs.io)。 这是最受欢迎的智能合约语言，它在语法上类似于 JavaScript，可能会更容易学习。
+如果你是 JavaScript 开发者，并且想编写自己的智能合约，你可能需要熟悉 [Solidity](https://solidity.readthedocs.io)。 这是最受欢迎的智能合约语言，它在语法上类似于 JavaScript，可能会更容易学习。
-关于[智能合约](/developers/docs/smart-contracts/)的更多信息。
+更多关于[智能合约](/developers/docs/smart-contracts/)。
-## 理解协议 {#understand-the-protocol}
+## 了解协议 {#understand-the-protocol}
### 以太坊虚拟机 {#the-ethereum-virtual-machine}
@@ -40,34 +41,32 @@ JavaScript是以太坊生态中最受欢迎的语言之一。 事实上，有一
- 区块
- 区块链本身
- 交易
-- 更多...
+- 以及更多...
这将有助于你理解像“一个帐户的数据结构是什么？”这样的问题。
如果你倾向于阅读代码，下面的 JavaScript 代码可以很好地成为通读文档的替代方案。
-**参阅 monorepo**
-[`ethereumjs`](https://github.com/ethereumjs/ethereumjs-vm)
+**查阅 EVM**
+[`@ethereumjs/evm`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/evm)
### 节点和客户端 {#nodes-and-clients}
目前正在开发的 Ethereumjs 客户端允许你发掘以太坊客户端如何使用你能理解的语言 (JavaScript) 工作！
-它曾经在独立的[`存储库`](https://github.com/ethereumjs/ethereumjs-client)中托管，然而，后来作为一个包整合进了 EthereumVM monorepo。
+**查阅客户端**
+[`@ethereumjs/client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
-**参阅客户端**
-[`ethereumjs-client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
-
-## 其它项目 {#other-projects}
+## 其他项目 {#other-projects}
以太坊的 JavaScript 领域内还有许多其它东西：
- 钱包工具库。
- 生成、导入和导出以太坊密钥的工具。
-- 一个 `merkle-patricia-tree` 的实现 - 一种在以太坊黄皮书中描述的数据结构。
+- `merkle-patricia-tree` 的一个实现 – 一种在以太坊黄皮书中描述的数据结构。
-可以在 [EthereumJS 存储库](https://github.com/ethereumjs)中深入了解你最感兴趣的内容
+前往 [EthereumJS 代码库](https://github.com/ethereumjs)，深入研究你最感兴趣的内容。
-## 延伸阅读 {#further-reading}
+## 扩展阅读{#further-reading}
-_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_
+_你还知道哪些对你有帮助的社区资源？ 请编辑本页面并添加进来！_
diff --git a/public/content/translations/zh/developers/docs/programming-languages/python/index.md b/public/content/translations/zh/developers/docs/programming-languages/python/index.md
index f82619eca24..302f61aa41c 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/python/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/python/index.md
@@ -1,90 +1,99 @@
---
-title: 面向 Python 开发者的以太坊资源
-description: 学习如何使用并通过基于 Python 的项目及工具参与以太坊的开发
+title: "面向 Python 开发者的以太坊资源"
+description: "学习如何使用并通过基于 Python 的项目及工具参与以太坊的开发"
lang: zh
incomplete: true
---
-学习如何通过基于 Python 的项目和工具参与以太坊的开发
+了解如何使用基于 Python 的项目和工具为以太坊进行开发
-使用以太坊来创建去中心化应用程序 (或称“dapp”)，发挥加密货币和区块链技术的优势。 这些 dapp 可以是值得信赖的，也即一旦被部署到以太坊上，它们将总是按程序运行。 这些应用程序可以控制数字资产，以便创造新的金融应用； 它们可以是去中心化的，也即没有任何单一实体或个人能够控制它们，而且它们几乎是不可能被审查的。
+使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可被信任，意味着一旦被部署到以太坊上，它们将总是按既定程序运行。 这些应用程序可以控制数字资产并构建新的金融应用。 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-solidity}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出第一步，将 Python 与以太坊集成**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或者 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [2023 年 Python 在区块链领域的现状报告](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
## 初学者文章 {#beginner-articles}
-- [以太坊开发者指南 (Python)](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
-- [2023 区块链报告中的 Python 状态](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
-- [基于 Vyper 的智能合约简介](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
-- [使用 Python 和 Brownie 部署你自己的 ERC20 代币](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
-- [如何使用 Python Flask 开发 Ethereum 合约？](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
-- [Web3.py 简介 · 面向 Python 开发者的以太坊资源](https://www.dappuniversity.com/articles/web3-py-intro)
-- [如何通过 Python 和 web3.py 调用智能合约函数？](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
+- [web3.py 概述](https://web3py.readthedocs.io/en/latest/overview.html)
+- [以太坊 Python 生态系统概览](https://snakecharmers.ethereum.org/python-ecosystem/)
+- [以太坊 (Python) 开发者指南](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
+- [值得获奖：以太坊 Python 黑客松指南](https://snakecharmers.ethereum.org/prize-worthy/)
+- [Vyper 智能合约简介](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
+- [如何使用 Python Flask 开发以太坊合约？](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
+- [Web3.py 简介 · 面向 Python 开发者的以太坊教程](https://www.dappuniversity.com/articles/web3-py-intro)
+- [如何使用 Python 和 web3.py 调用智能合约函数](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
-## 面向中等程度用户的文章 {#intermediate-articles}
+## 中级文章 {#intermediate-articles}
+- [web3.py 之友：Ape 简介](https://snakecharmers.ethereum.org/intro-to-ape/)
- [面向 Python 程序员的去中心化应用程序开发](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28)
- [创建 Python 以太坊接口：第 1 部分](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
-- [基于 Python 的以太坊智能合约开发：完整（入门）教程](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
-- [使用 Brownie 和 Python 部署智能合约](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
-- [使用 Brownie 在 OpenSea 上创建非同质化代币](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
+- [Python 中的以太坊智能合约：一份（较）全面的指南](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
-## 面向高等程度用户的使用模式 {#advanced-use-patterns}
+## 高级使用模式 {#advanced-use-patterns}
+- [web3.py 模式：实时事件订阅](https://snakecharmers.ethereum.org/subscriptions/)
+- [web3.py 模式：WebSocketProvider](https://snakecharmers.ethereum.org/websocketprovider/)
- [使用 Python 编译、部署和调用以太坊智能合约](https://yohanes.gultom.id/2018/11/28/compiling-deploying-and-calling-ethereum-smartcontract-using-python/)
- [使用 Slither 分析 Solidity 智能合约](https://kauri.io/#collections/DevOps/analyze-solidity-smart-contracts-with-slither/#analyze-solidity-smart-contracts-with-slither)
-- [Blockchain Fintech 教程：使用 Python 借贷和借贷](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+- [区块链金融科技教程：使用 Python 实现借贷](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+
+## 已存档的文章
+
+- [使用 Python 和 Brownie 部署你自己的 ERC20 代币](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
+- [使用 Brownie 和 Python 部署智能合约](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
+- [使用 Brownie 在 OpenSea 上创建 NFT](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
## Python 项目和工具 {#python-projects-and-tools}
### 活跃： {#active}
-- [Web3.py](https://github.com/ethereum/web3.py) - _用于与以太坊交互的 Python 库_
-- [Vyper](https://github.com/ethereum/vyper/) - _一种适用于以太坊虚拟机的 Python 智能合约语言_
-- [Ape](https://github.com/ApeWorX/ape) - _面向 Pythonista、数据科学家和安全专业人员的智能合约开发工具_
+- [Web3.py](https://github.com/ethereum/web3.py) - _用于与以太坊交互的 Python 程序库_
+- [Vyper](https://github.com/ethereum/vyper/) - _适用于 EVM 的 Python 风格智能合约语言_
+- [Ape](https://github.com/ApeWorX/ape) - _面向 Python 爱好者、数据科学家和安全专业人士的智能合约开发工具_
- [py-evm](https://github.com/ethereum/py-evm) - _以太坊虚拟机的实现_
-- [eth-tester](https://github.com/ethereum/eth-tester) - _用于测试以太坊应用程序的工具_
-- [eth-utils](https://github.com/ethereum/eth-utils/) - _使用以太坊相关代码库的实用程序函数_
-- [py-solc-x](https://pypi.org/project/py-solc-x/) - _适用于 solc Solidity 编译器（支持 0.5.x）的 Python 装饰器_
-- [pymaker](https://github.com/makerdao/pymaker) - _面向 Maker 合约的 Python 应用程序接口_
-- [siwe](https://github.com/signinwithethereum/siwe-py) - _面向 Python 的以太坊登录服务 (siwe)_
-- [用于以太坊集成的 Web3 去中心化金融](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _一个 Python 包，具有适用于 ERC-20、Uniswap 和其他流行项目的现成集成_
-- [Wake](https://getwake.io) - _用于合约测试、模糊测试、部署、漏洞扫描和代码导航的一体化 Python 框架（语言服务器 - [Solidity 工具](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)）_
+- [eth-tester](https://github.com/ethereum/eth-tester) - _用于测试基于以太坊的应用程序的工具_
+- [eth-utils](https://github.com/ethereum/eth-utils/) - _用于处理以太坊相关代码库的实用函数_
+- [py-solc-x](https://pypi.org/project/py-solc-x/) - _solc solidity 编译器的 Python 包装器，支持 0.5.x 版本_
+- [pymaker](https://github.com/makerdao/pymaker) - _用于 Maker 合约的 Python API_
+- [siwe](https://github.com/signinwithethereum/siwe-py) - _Python 版通过以太坊登录 (siwe)_
+- [用于以太坊集成的 Web3 DeFi](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _一个 Python 包，为 ERC-20、Uniswap 和其他热门项目提供了现成的集成_
+- [Wake](https://getwake.io) - _用于合约测试、模糊测试、部署、漏洞扫描和代码导航的一体化 Python 框架（语言服务器 - [Solidity 工具](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
-### 已归档/不再维护： {#archived--no-longer-maintained}
+### 已存档/不再维护： {#archived--no-longer-maintained}
-- [Trinity](https://github.com/ethereum/trinity) - _以太坊的 Python 客户端_
-- [Mamba](https://github.com/arjunaskykok/mamba) - _一个用 Vyper 语言编写、编译和部署智能合约的框架_
-- [Brownie](https://github.com/eth-brownie/brownie) - _一个用于部署、测试以太坊智能合约并与之交互的 Python 框架_
-- [pydevp2p](https://github.com/ethereum/pydevp2p) - _使用 Python 实现 P2P 协议栈_
-- [py-wasm](https://github.com/ethereum/py-wasm) - _使用 Python 实现的 Web 汇编解释器_
+- [Trinity](https://github.com/ethereum/trinity) - _以太坊 Python 客户端_
+- [Mamba](https://github.com/arjunaskykok/mamba) - _用于编写、编译和部署以 Vyper 语言编写的智能合约的框架_
+- [Brownie](https://github.com/eth-brownie/brownie) - _用于部署、测试以太坊智能合约并与之交互的 Python 框架_
+- [pydevp2p](https://github.com/ethereum/pydevp2p) - _以太坊 P2P 堆栈的实现_
+- [py-wasm](https://github.com/ethereum/py-wasm) - _web assembly 解释器的 Python 实现_
-想要获取更多的资源？ 请查看 [ethereum.org/developers](/developers/)。
+正在寻找更多资源？ 请访问 [ethereum.org/developers](/developers/)。
## 使用 Python 工具的项目 {#projects-using-python-tooling}
以下基于以太坊的项目使用本页提到的工具。 相关的开源代码库可作为一个很好的参考，例如代码和最佳做法。
-- [Yearn Finance](https://yearn.finance/) 和 [Yearn Vault Contracts 库](https://github.com/yearn/yearn-vaults)
-- [Curve](https://curve.fi/) 和 [Curve 智能合约库](https://github.com/curvefi/curve-contract)
-- [BadgerDAO](https://badger.com/) 和 [使用 Brownie 工具链的智能合约](https://github.com/Badger-Finance/badger-system)
-- [Sushiswap](https://sushi.com/) 使用 [Python 来管理和部署他们的归属合约](https://github.com/sushiswap/sushi-vesting-protocols)
-- 因 Alpha Homora 而知名的 [Alpha Finance](https://alphafinance.io/) 使用 [Brownie 来测试和部署他们的智能合约](https://github.com/AlphaFinanceLab/alpha-staking-contract)
+- [Yearn Finance](https://yearn.finance/) 和 [Yearn Vault 合约代码库](https://github.com/yearn/yearn-vaults)
+- [Curve](https://www.curve.finance/) 和 [Curve 智能合约代码库](https://github.com/curvefi/curve-contract)
+- [BadgerDAO](https://badger.com/) 和[使用 Brownie 工具链的智能合约](https://github.com/Badger-Finance/badger-system)
+- [Sushi](https://sushi.com/) 使用 [Python 管理和部署其归属合约](https://github.com/sushiswap/sushi-vesting-protocols)
+- [Alpha Finance](https://alphafinance.io/)（因 Alpha Homora 而闻名）使用 [Brownie 来测试和部署智能合约](https://github.com/AlphaFinanceLab/alpha-staking-contract)
## Python 社区讨论 {#python-community-contributors}
-- [以太坊 Python 社区 Discord](https://discord.gg/9zk7snTfWe)，适合讨论 Web3.py 和其他 Python 框架
-- [Vyper Discord](https://discord.gg/SdvKC79cJk)，适合讨论 Vyper 智能合约编程
+- [以太坊 Python 社区 Discord](https://discord.gg/9zk7snTfWe)，用于讨论 Web3.py 和其他 Python 框架
+- [Vyper Discord](https://discord.gg/SdvKC79cJk)，用于讨论 Vyper 智能合约编程
## 其他汇总列表 {#other-aggregated-lists}
-Vyper 维基百科包含[丰富的 Vyper 资源列表](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
+Vyper Wiki 有一个[非常棒的 Vyper 资源列表](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources)
\ No newline at end of file
diff --git a/public/content/translations/zh/developers/docs/programming-languages/ruby/index.md b/public/content/translations/zh/developers/docs/programming-languages/ruby/index.md
index f8f4e4a6b25..ea7ff59d907 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/ruby/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/ruby/index.md
@@ -1,60 +1,60 @@
---
-title: 面向 Ruby 开发者的以太坊资源
-description: 了解如何使用基于 Ruby 的项目和工具为以太坊进行开发。
+title: "面向 Ruby 开发者的以太坊资源"
+description: "了解如何使用基于 Ruby 的项目和工具为以太坊进行开发。"
lang: zh
incomplete: false
---
-了解如何使用基于 Ruby 的项目和工具为以太坊进行开发。
+了解如何使用基于 Ruby 的项目和工具为以太坊开发。
使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可以去信任，这意味着在部署到以太坊后，它们将始终按程序设定运行。 去中心化应用程序可以控制数字资产，从而创建新类型的金融应用程序。 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-solidity}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出将 Ruby 与以太坊集成的第一步**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
## 初学者文章 {#beginner-articles}
-- [终于明白以太坊帐户了](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
-- [使用 MetaMask 对 Rails 用户进行最终身份验证](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
+- [透彻理解以太坊帐户](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [使用 MetaMask 对 Rails 用户进行身份验证](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
- [如何使用 Ruby 连接到以太坊网络](https://www.quicknode.com/guides/web3-sdks/how-to-connect-to-the-ethereum-network-using-ruby)
-- [如何使用 Ruby 生成新的以太坊地址](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
+- [如何在 Ruby 中生成新的以太坊地址](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
-## 面向中等程度用户的文章 {#intermediate-articles}
+## 中级文章 {#intermediate-articles}
-- [用 Ruby 编写的区块链应用程序](https://www.nopio.com/blog/blockchain-app-ruby/)
-- [使用 Ruby 连接到以太坊并执行智能合约](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
+- [使用 Ruby 开发的区块链应用程序](https://www.nopio.com/blog/blockchain-app-ruby/)
+- [使用连接到以太坊的 Ruby 来执行智能合约](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
## Ruby 项目和工具 {#ruby-projects-and-tools}
-### 活跃资源 {#active}
+### 激活 {#active}
-- [eth.rb](https://github.com/q9f/eth.rb) - _Ruby 库和远程过程调用客户端，用于处理以太坊帐户、消息和交易_
+- [eth.rb](https://github.com/q9f/eth.rb) - _用于处理以太坊帐户、消息和交易的 Ruby 程序库和 RPC 客户端_
- [keccak.rb](https://github.com/q9f/keccak.rb) - _以太坊使用的 Keccak (SHA3) 哈希_
-- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) - _使用 Ruby 实现 Sign-In with Ethereum_
-- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) - _添加 SIWE 本地登录路由的 Rails gem_
-- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) - _使用 Ruby on Rails 的 SIWE 示例（含自定义控制器）_
-- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) - _面向 Sign In With Ethereum (SIWE) 的 OmniAuth 策略_
-- [omniauth-nft](https://github.com/valthon/omniauth-nft) - _面向通过非同质化代币所有权进行身份验证的 OmniAuth 策略_
-- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) - _Ethereum on Rails 模板，允许连接 MetaMask 到 Ruby on Rails_
+- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) - _“通过以太坊登录”的 Ruby 实现_
+- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) - _添加 SIWE 本地登录路由的 Rails Gem_
+- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) - _使用带自定义控制器的 Ruby on Rails 的 SIWE 示例_
+- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) - _用于“通过以太坊登录 (SIWE)”的 OmniAuth 策略_
+- [omniauth-nft](https://github.com/valthon/omniauth-nft) - _通过 NFT 所有权进行身份验证的 OmniAuth 策略_
+- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) - _允许将 MetaMask 连接到 Ruby on Rails 的 Ethereum on Rails 模板_
-### 已存档/停止维护的资源 {#archived--no-longer-maintained}
+### 存档/已不再维护 {#archived--no-longer-maintained}
-- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) - _用 Ruby 调用以太坊节点的远程过程调用方法_
-- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) - _用于根据 BIP32 标准从分层确定性钱包生成以太币地址的 Ruby 库_
-- [etherlite](https://github.com/budacom/etherlite) - _Ruby on Rails 的以太坊集成_
-- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) - _使用 JSON-RPC 接口发送交易、创建合约并与之交互的 Ruby 以太坊客户端以及可使用以太坊节点的有用工具包_
-- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) - _实现面向 OmniAuth 的以太坊提供商策略_
+- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) - _使用 Ruby 调用以太坊节点的 RPC 方法_
+- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) - _根据 BIP32 标准从分层确定性钱包生成 ETH 地址的 Ruby 程序库_
+- [etherlite](https://github.com/budacom/etherlite) - _用于 Ruby on Rails 的以太坊集成_
+- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) - _使用 JSON-RPC 接口发送交易、创建合约并与之交互的 Ruby 以太坊客户端，以及与以太坊节点协作的实用工具包_
+- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) - _为 OmniAuth 实现以太坊提供商策略_
-正在寻找更多资源？ 请查看[我们的开发者之家](/developers/)。
+正在寻找更多资源？ 访问[我们的开发者首页](/developers/)。
## Ruby 社区贡献者 {#ruby-community-contributors}
-[Ethereum Ruby Telegram 组](https://t.me/ruby_eth)主持着一个快速发展的社区，是讨论上述任何项目和相关主题的专用资源。
+[以太坊 Ruby Telegram 小组](https://t.me/ruby_eth) 是一个快速发展的社区，也是专门讨论上述任何项目及相关主题的专用资源。
diff --git a/public/content/translations/zh/developers/docs/programming-languages/rust/index.md b/public/content/translations/zh/developers/docs/programming-languages/rust/index.md
index f00082189c4..8678e998e21 100644
--- a/public/content/translations/zh/developers/docs/programming-languages/rust/index.md
+++ b/public/content/translations/zh/developers/docs/programming-languages/rust/index.md
@@ -1,63 +1,65 @@
---
-title: 面向 Rust 开发者的以太坊
-description: 学习如何使用并通过基于 rust 的项目及工具参与以太坊的开发
+title: "面向 Rust 开发者的以太坊"
+description: "学习如何使用并通过基于 rust 的项目及工具参与以太坊的开发"
lang: zh
incomplete: true
---
-学习如何通过基于 Rust 的项目和工具参与以太坊的开发
+了解如何使用基于 Rust 的项目和工具为以太坊进行开发
-使用以太坊来创建去中心化应用程序（或称“dapp”），发挥加密货币和区块链技术的优势。 这些 dapp 可以是值得信赖的，也即一旦被部署到以太坊上，它们将总是按程序运行。 这些应用程序可以控制数字资产，以便创造新的金融应用； 它们可以是去中心化的，也即没有任何单一实体或个人能够控制它们，而且它们几乎是不可能被审查的。
+使用以太坊来创建去中心化应用程序，发挥加密货币和区块链技术的优势。 这些去中心化应用程序可被信任，意味着一旦被部署到以太坊上，它们将总是按既定程序运行。 这些应用程序可以控制数字资产，以便创造新的金融应用； 它们可以是去中心化的，即没有任何单一实体或个人控制它们，而且它们几乎不可能被审查。
-## 智能合约和 Solidity 语言入门 {#getting-started-with-smart-contracts-and-solidity}
+## 从学习智能合约和 Solidity 语言入手 {#getting-started-with-smart-contracts-and-solidity}
**迈出第一步，将 Rust 与以太坊进行集成**
-需要更基础的入门知识？ 请查看 [ethereum.org/learn](/learn/) 或者 [ethereum.org/developers](/developers/)。
+想对以太坊有更加全面的认识？ 查看 [ethereum.org/learn](/learn/) 或 [ethereum.org/developers](/developers/)。
-- [区块链详解](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
-- [理解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [区块链解析](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [了解智能合约](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
- [编写你的第一个智能合约](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
-- [学习如何编写和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [学习如何编译和部署 Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
## 初学者文章 {#beginner-articles}
-- [Rust 以太坊客户端](https://openethereum.github.io/) \* **注意 OpenEthereum [已被废弃](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd)并已停止维护。** 请谨慎使用，最好切换至其他客户端实现。
+- [Rust 以太坊客户端](https://openethereum.github.io/) \* \*\*请注意，OpenEthereum [已被弃用](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd)且不再进行维护。\*\*请谨慎使用，最好切换到另一个客户端实现。
- [使用 Rust 向以太坊发送交易](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
-- [如何用 Rust Wasm 为 Kovan 编写合约的分步教程](https://github.com/paritytech/pwasm-tutorial)
+- [关于如何用 Rust Wasm 为 Kovan 编写合约的详细教程](https://github.com/paritytech/pwasm-tutorial)
-## 面向中等程度用户的文章 {#intermediate-articles}
+## 中级文章 {#intermediate-articles}
-## 面向高等程度用户的使用模式 {#advanced-use-patterns}
+## 高级使用模式 {#advanced-use-patterns}
-- [pwasm_ethereum 外部库与类以太坊网络交互](https://github.com/openethereum/pwasm-ethereum)
-- [使用 JavaScript 和 Rust 搭建去中心化聊天室](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
-- [使用 Vue.js 和 Rust 构建一个去中心化待办事项应用程序](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+- [pwasm_ethereum 外部函数程序库，用于和类以太坊网络交互](https://github.com/openethereum/pwasm-ethereum)
-- [使用 Rust 构建区块链](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
+- [使用 JavaScript 和 Rust 构建去中心化聊天应用](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
+
+- [使用 Vue.js 和 Rust 构建去中心化待办事项应用程序](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+
+- [用 Rust 构建区块链](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
## Rust 项目和工具 {#rust-projects-and-tools}
-- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _与类似以太坊的网络交互的外部帐户集合_
-- [Lighthouse](https://github.com/sigp/lighthouse) - _以太坊快速共识层客户端_
-- [ Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _使用 WebAssembly 的确定性子集对以太坊智能合约执行层建议的重新设计_
-- [oasis_std](https://docs.rs/oasis-std/latest/oasis_std/index.html) - _OASIS 应用程序接口参考_
-- [Solaris](https://github.com/paritytech/sol-rs) - _使用本机 Parity 客户端以太坊虚拟机的 Solidity 智能合约单元测试工具。_
-- [SputnikVM](https://github.com/rust-blockchain/evm) - _以太坊虚拟机的 Rust 实现_
-- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Rust 语言的 Wavelet 智能合约_
-- [Foundry](https://github.com/foundry-rs/foundry) - _以太坊应用程序开发工具包_
-- [Alloy](https://alloy.rs) - _高性能、严格测试且文档完备的程序库，用于与以太坊和其他基于以太坊虚拟机的链交互。_
-- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _以太坊库和钱包的实现_
-- [SewUp](https://github.com/second-state/SewUp) - _一个帮助用户用 Rust 语言构建以太坊 Webassembly 合约的库，正如在公共后端中开发一样_
+- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _用于和类以太坊网络交互的外部函数集合_
+- [Lighthouse](https://github.com/sigp/lighthouse) - _快速的以太坊共识层客户端_
+- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _使用 WebAssembly 的确定性子集对以太坊智能合约执行层进行的重新设计提案_
+- [oasis_std](https://docs.rs/oasis-std/latest/oasis_std/index.html) - _OASIS API 参考_
+- [Solaris](https://github.com/paritytech/sol-rs) - _使用原生 Parity 客户端 EVM 的 Solidity 智能合约单元测试工具。_
+- [SputnikVM](https://github.com/rust-blockchain/evm) - _Rust 实现的以太坊虚拟机_
+- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _用 Rust 编写的 Wavelet 智能合约_
+- [Foundry](https://github.com/foundry-rs/foundry) - _用于开发以太坊应用的工具包_
+- [Alloy](https://alloy.rs) - _用于与以太坊和其他基于 EVM 的链进行交互的高性能、经过良好测试且文档齐全的程序库。_
+- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _以太坊程序库和钱包实现_
+- [SewUp](https://github.com/second-state/SewUp) - _一个可帮助你使用 Rust 构建以太坊 WebAssembly 合约的库，就像在通用后端中开发一样_
- [Substreams](https://github.com/streamingfast/substreams) - _并行化区块链数据索引技术_
-- [Reth](https://github.com/paradigmxyz/reth) - Reth 即 Rust 以太坊的简称，是新的以太坊全节点实现
-- [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) - _ 以太坊生态系统中用 Rust 编写的项目精选集合_
+- [Reth](https://github.com/paradigmxyz/reth) Reth (Rust Ethereum 的简称) 是一个新的以太坊全节点实现
+- [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) - _以太坊生态系统中用 Rust 编写的项目精选集合_
-想要获取更多的资源？ 请查看 [ethereum.org/developers](/developers/)。
+正在寻找更多资源？ 请查看 [ethereum.org/developers.](/developers/)
## Rust 社区贡献者 {#rust-community-contributors}
-- [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby)
+- [以太坊 WebAssembly](https://gitter.im/ewasm/Lobby)
- [Oasis Gitter](https://gitter.im/Oasis-official/Lobby)
- [Parity Gitter](https://gitter.im/paritytech/parity)
- [Enigma](https://discord.gg/SJK32GY)
diff --git a/public/content/translations/zh/developers/docs/scaling/index.md b/public/content/translations/zh/developers/docs/scaling/index.md
index 30bd8ce377e..bce2406d1c6 100644
--- a/public/content/translations/zh/developers/docs/scaling/index.md
+++ b/public/content/translations/zh/developers/docs/scaling/index.md
@@ -1,6 +1,6 @@
---
-title: 扩容
-description: 介绍以太坊社区目前正在开发的不同扩容选择。
+title: "扩容"
+description: "介绍以太坊社区目前正在开发的不同扩容选择。"
lang: zh
sidebarDepth: 3
---
@@ -9,105 +9,105 @@ sidebarDepth: 3
随着以太坊使用人数增加，区块链已经达到了一定的容量限制。 这提高了网络使用成本，从而导致需要“扩容解决方案”。 目前正在研究、测试和执行多种解决方案，这些方案采取不同的办法来实现类似的目标。
-可扩展性的主要目标是，在不牺牲去中心化或安全性的情况下提高交易速度（更快的最终确定性）和交易吞吐量（每秒更高的交易数量）（详情请参阅[以太坊愿景](/roadmap/vision/)）。 在第一层以太坊区块链上，高需求导致交易速度减慢和[燃料价格](/developers/docs/gas/)难以持续。 提高网络速度和吞吐量是有意义地大规模采用以太坊的基础。
+可扩展性的主要目标是在不牺牲去中心化或安全性的前提下，提高交易速度（更快的最终确定性）和交易吞吐量（更高的每秒交易笔数）。 在 Layer 1 以太坊区块链上，高需求会导致交易速度减慢和难以承受的[燃料价格](/developers/docs/gas/)。 提高网络速度和吞吐量是有意义地大规模采用以太坊的基础。
虽然速度和吞吐量很重要，但实现这些目标的扩容解决方案必须保持去中心化和安全性。 降低节点运营商的进入门槛，对于防止向不安全的中心化计算能力发展至关重要。
-从概念上说，我们首先将扩容分为链上扩容和链外扩容两类。
+从概念上，我们首先将扩容分为链上扩容和链外扩容两类。
## 前提条件 {#prerequisites}
你应对所有基础性课题有很好的了解。 实施扩容解决方案是一项先进的任务，因为该技术没有经过多少实践检验，还在进一步研发中。
-## 链上扩容 {#on-chain-scaling}
+## 链上扩容 {#onchain-scaling}
-链上扩容需要更改以太坊协议（一层网络[主网](/glossary/#mainnet)）。 长期以来，区块链分片有望扩展以太坊。 分片就是将区块链拆分成单独的部分（分片），并由部分验证者进行验证。 然而，二层网络卷叠扩容方案已取而代之，成为主要的扩容技术。 更加经济的向以太坊区块添加数据的新方式旨在让卷叠方案对用户经济划算，它的出现无疑为这一形势增添了助力。
+链上扩容需要更改以太坊协议（Layer 1 [主网](/glossary/#mainnet)）。 长期以来，区块链分片有望扩展以太坊。 分片就是将区块链拆分成单独的部分（分片），并由部分验证者进行验证。 然而，二层网络卷叠扩容方案已取而代之，成为主要的扩容技术。 更加经济的向以太坊区块添加数据的新方式旨在让卷叠方案对用户经济划算，它的出现无疑为这一形势增添了助力。
### 分片 {#sharding}
-分片是拆分数据库的过程。 部分验证者将负责单独的分片，而不是跟踪整个以太坊。 分片包含在以太坊[路线图](/roadmap/)上由来已久，并且曾计划于合并到权益证明之前上线。 然而，[二层网络卷叠](#layer-2-scaling)的快速发展和 [Danksharding](/roadmap/danksharding) 的发明（将卷叠数据的二进制大对象添加以太坊区块中，并且验证者可以非常高效地进行验证），让以太坊社区青睐以卷叠为中心的扩容方案，而不是分片扩容方案。 这也将有助于保持以太坊的共识逻辑更简单。
+分片是拆分数据库的过程。 部分验证者将负责单独的分片，而不是跟踪整个以太坊。 分片在以太坊的[路线图](/roadmap/)上已存在很长时间，并且曾计划在转向权益证明的合并之前发布。 然而，[Layer 2 卷叠](#layer-2-scaling)的快速发展和 [Danksharding](/roadmap/danksharding)（将卷叠数据的二进制大对象添加到以太坊区块，可由验证者高效验证）的发明，已使以太坊社区更青睐以卷叠为中心的扩容方案，而非分片扩容。 这也将有助于保持以太坊的共识逻辑更简单。
-## 链下扩容 {#off-chain-scaling}
+## 链下扩容 {#offchain-scaling}
-链下解决方案与一层网络主网分开实现，它们无需更改现有以太坊协议。 部分解决方案称为“二层网络”解决方案，它们直接从一层网络以太坊共识中获得安全性，例如[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)、[零知识卷叠](/developers/docs/scaling/zk-rollups/)或[状态通道](/developers/docs/scaling/state-channels/)。 其他解决方案涉及创建独立于主网获取安全性的各种形式的新链，例如[侧链](#sidechains)、[Validium](#validium) 或 [Plasma 链](#plasma)。 这些解决方案与主网进行通信，但为了实现各种不同目标，它们获得安全性的方式也有所不同。
+链下解决方案与第一阶段主网分开，无需更改现有以太坊协议。 一些被称为“Layer 2”的解决方案直接从 Layer 1 以太坊共识中获得安全性，例如[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)、[零知识卷叠](/developers/docs/scaling/zk-rollups/)或[状态通道](/developers/docs/scaling/state-channels/)。 其他解决方案涉及创建独立于主网获取安全性的各种形式的新链，例如[侧链](#sidechains)、[validium](#validium) 或 [Plasma 链](#plasma)。 这些解决方案与主网进行通信，但为了实现各种不同目标，它们获得安全性的方式也有所不同。
-### 二层扩容 {#layer-2-scaling}
+### Layer 2 扩容 {#layer-2-scaling}
-此类链下解决方案的安全性来自以太坊主网。
+以太坊主网负责确保此类链下解决方案的安全。
二层网络是一种统称，用来描述那些通过在以太坊主网（一层网络）下处理交易，同时利用主网强大的去中心化安全模型来帮助扩展你的应用程序的解决方案。 当网络繁忙时，交易速度会受到影响，这可能使某些类型的去中心化应用程序的用户体验变差。 而且，随着网络越来越繁忙，由于交易发送者的目标是超出对方的出价，燃料价格也随之上升。 这可能会让以太坊的使用成本非常高。
-大多数二层网络解决方案均围绕着一个服务器或服务器群集，其中每一种都可以称为节点、验证者、运营商、排序者、区块生产者或类似术语。 根据实现情况，这些二层网络的节点可由使用它们的个人、企业或实体运行，或者由第三方运营商或一大群个人（与主网相似）运行。 一般而言，交易会提交给二层网络节点，而非直接提交给一层网络（主网）。 对于部分解决方案，二层网络实例会将它们分组,然后锚定到一层网络，之后它们受一层网络保护且不能更改。 对于不同的二层网络技术和实现而言，如何做到这一点，细节方面差异很大。
+大多数二层网络解决方案均围绕着一个服务器或服务器群集，其中每一种都可以称为节点、验证者、运营商、排序者、区块生产者或类似术语。 根据实现情况，这些二层网络的节点可由使用它们的个人、企业或实体运行，或者由第三方运营商或一大群个人（与主网相似）运行。 一般而言，交易会提交给二层网络节点，而非直接提交给一层网络（主网）。 对于部分解决方案，第二阶段网络会通过实例将它们分组,然后锚定到第一阶段网络，之后它们受第一阶段网络保护且不能更改。 对于不同的二层网络技术和实现而言，如何做到这一点，细节方面差异很大。
某个特定的二层网络实例可能是开放的，由许多应用程序共享，也可能由一个项目部署，专供支持该项目的应用程序。
#### 为什么需要第二层？ {#why-is-layer-2-needed}
- 每秒增加交易量会大大提高用户体验，并减少以太坊主网上的网络拥塞情况。
-- 卷叠就是将多个交易打包到一个交易中，然后发到以太坊主网上，这为用户减少了燃料费用。以太坊将更具包容性，任何人都可以用得起以太坊。
+- 交易被汇总到发送至以太坊主网的单笔交易中，从而为用户降低了燃料费，使以太坊更具包容性，让世界各地的人们都可以访问。
- 关于可扩容性的任何更新都不应以分散安全性为代价 - 第二层建立在以太坊的基础上。
-- 有一些特定应用的第二层网络，在大规模处理资产时有它们自己的效率。
+- 有一些特定于应用程序的 Layer 2 网络，它们在处理大规模资产时能够发挥其独特的效率优势。
-[关于二层网络的更多信息](/layer-2/)。
+[关于 Layer 2 的更多信息](/layer-2/)
-#### 卷叠 {#rollups}
+#### Rollup {#rollups}
卷叠在一层网络外执行交易，并在达成共识时，在一层网络公开数据。 由于交易数据包含在一层网络区块中，因此可以通过原生的以太坊安全性来保证卷叠的安全性。
有两种具有不同安全模型的卷叠：
-- **乐观卷叠**：假设交易在默认情况下有效，并且在遇到挑战的情况下只通过[**欺诈证明**](/glossary/#fraud-proof)运行计算。 [关于乐观卷叠的更多信息](/developers/docs/scaling/optimistic-rollups/)。
-- **零知识卷叠**：在链下运行计算并向链上提交[**有效性证明**](/glossary/#validity-proof)。 [关于零知识卷叠的更多信息](/developers/docs/scaling/zk-rollups/)。
+- **乐观卷叠**：默认假定交易有效，仅在有质疑时才通过[**欺诈证明**](/glossary/#fraud-proof)运行计算。 [关于乐观卷叠的更多信息](/developers/docs/scaling/optimistic-rollups/)
+- **零知识卷叠**：在链下运行计算，并向主链提交[**有效性证明**](/glossary/#validity-proof)。 [关于零知识卷叠的更多信息](/developers/docs/scaling/zk-rollups/)
#### 状态通道 {#channels}
-状态通道采用多签合约，使参与者能够在链下快速自由地进行交易，然后再与主网落实最终确定性。 这将最大限度地减少网络拥塞、费用和延迟。 现在有两种通道：状态通道和支付通道。
+状态通道采用多签合约，使参与者能够在链下快速自由地进行交易，然后再和主网落实并最终确定。 这将最大限度减少网络拥塞、费用和延迟。 目前有两种通道：状态通道和支付通道。
了解更多关于[状态通道](/developers/docs/scaling/state-channels/)的信息。
### 侧链 {#sidechains}
-侧链是与主网并行运行且兼容以太坊虚拟机的独立区块链。 它们通过双向桥接与以太坊兼容，按照自行选择的共识规则和区块参数运行。
+侧链是与主网并行运行的、兼容 EVM 的独立区块链。 它们通过双向链桥与以太坊兼容，并按照自行选择的共识规则和区块参数运行。
-了解更多有关[侧链](/developers/docs/scaling/sidechains/)的信息。
+了解更多关于[侧链](/developers/docs/scaling/sidechains/)的信息。
-### 以太坊 Plasma 扩容解决方案 {#plasma}
+### Plasma {#plasma}
-Plasma 是一条独立的区块链，锚定至以太坊主链，并使用欺诈证明（如[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)）来仲裁争议。
+Plasma 链是一条独立的区块链，锚定在以太坊主链上，并使用欺诈证明（类似[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)）来仲裁争议。
了解更多关于 [Plasma](/developers/docs/scaling/plasma/) 的信息。
### Validium {#validium}
-Validium 链使用诸如零知识卷叠之类的有效性证明，但数据未存储在一层网络以太坊主链上。 这会导致每条 Validium 链每秒处理 10000 笔交易，并且可以并行运行多条链。
+Validium 链使用诸如零知识卷叠之类的有效性证明，但数据未存储在一层网络以太坊主链上。 这让每条 Validium 链每秒可以处理 10,000 笔交易，并且可以并行运行多条链。
-了解关于 [Validium](/developers/docs/scaling/validium/) 的更多信息。
+了解更多关于 [Validium](/developers/docs/scaling/validium/) 的信息。
## 为何需要如此多扩容解决方案？ {#why-do-we-need-these}
-- 多重解决方案有助于减少网络任意部分的总体阻塞情况，也可防止单点故障。
+- 多种解决方案有助于减少网络任何部分的总体拥堵情况，并可防止单点故障。
- 整体大于各部分的总和。 不同的解决方案可以同时存在，并且可以协同工作，对未来的交易速度和吞吐量产生指数效应。
- 并非所有解决方案都需要直接利用以太坊共识算法，替代办法或许能带来难以获得的好处。
-- 一种扩容方案不足以完全满足[以太坊愿景](/roadmap/vision/)。
## 更愿意通过视频学习？ {#visual-learner}
注：以太坊广泛使用哈希函数来生成固定大小的值（“哈希”）。 哈希值在以太坊中发挥着重要作用，但您现在可以放心地将其视为是唯一的 ID 值。
+注：以太坊广泛使用哈希函数来生成固定大小的值（“哈希”）。 哈希在以太坊中扮演着重要角色，但暂时你可以放心地把它们看作是唯一 ID。
_区块链本质上是一个链表；每个区块都有一个对前一个区块的引用。_
-这种数据结构并不新颖，但治理网络的规则（即点对点协议）却很新颖。 区块链没有中央机构；网络中的对等节点必需协作以维持网络，并且通过竞争决定将哪些交易纳入下一个区块。 因此，当您想给朋友转账时，您需要将这笔交易广播到网络上，然后等待它被纳入即将产生的区块。
+这种数据结构并不新颖，但治理网络的规则（即点对点协议）却很新颖。 区块链没有中央机构；网络中的对等节点必需协作以维持网络，并且通过竞争决定将哪些交易纳入下一个区块。 因此，当你想给朋友转账时，你需要将这笔交易广播到网络上，然后等待它被纳入即将产生的区块。
-区块链验证资金确实从一个用户发送给另一个用户的唯一方法是使用该区块链原生货币（即，由该区块链创建和管理的货币）。 在以太坊，这种货币被称为 ETH，以太坊区块链是账户余额的唯一正式记录。
+区块链验证资金确实从一个用户发送给另一个用户的唯一方法是使用该区块链原生货币（即，由该区块链创建和管理的货币）。 在以太坊，这种货币被称为以太币，以太坊区块链包含账户余额的唯一官方记录。
-## 一种新范式 {#a-new-paradigm}
+## 新范式 {#a-new-paradigm}
-这种新的去中心化技术栈催生了新的开发者工具。 许多编程语言都有这样的工具，但我们将通过 Python 的视角来观察。 重申一下：即使 Python 不是您的首选语言，跟上文章也不会有什么太大的问题。
+这种新的去中心化技术栈催生了新的开发者工具。 许多编程语言都有这样的工具，但我们将通过 Python 的视角来观察。 重申一下：即使 Python 不是你的首选语言，跟上文章也不会有什么太大的问题。
-想要与以太坊进行互动的 Python 开发人员可能会接触到 [Web3.py](https://web3py.readthedocs.io/)。 Web3.py 是一个库，可以帮助我们简化连接以太坊节点，以及发送和接收数据。
+想要与以太坊进行交互的 Python 开发者可能会用到 [Web3.py](https://web3py.readthedocs.io/)。 Web3.py 是一个程序库，可以极大简化连接以太坊节点以及收发数据的过程。
注：“以太坊节点”和“以太坊客户端”可互换使用。 这两种说法都是指以太坊网络中参与者所运行的软件。 该软件可以读取区块数据，在新区块添加到链中时接收更新，广播新交易等等。 从技术角度讲，客户端是软件，节点是运行软件的计算机。
-[以太坊客户端](/developers/docs/nodes-and-clients/)可以配置为通过[进程间通信 (IPC)](https://wikipedia.org/wiki/Inter-process_communication)、超文本传输协议 (HTTP) 或网络套接字 (Websockets) 进行访问，因此 Web3.py 也需要完成这个配置。 Web3.py 将这些连接选项称为**提供者**。 您需要从三个提供者中选择一个来连接 Web3.py 实例和您的节点。
+[以太坊客户端](/developers/docs/nodes-and-clients/)可配置为通过 [IPC](https://wikipedia.org/wiki/Inter-process_communication)、HTTP 或 Websockets 访问，因此 Web3.py 也需要进行相应配置。 Web3.py 将这些连接选项称为**提供者**。 你需要从三个提供者中选择一个来连接 Web3.py 实例和你的节点。
-
+
-_将以太坊节点和 Web3.py 配置为通过相同通信的协议（例如，本图中的 IPC）进行通信。_
+_配置以太坊节点和 Web3.py 通过相同协议（例如本图中的 IPC）进行通信。_
-正确配置了 Web3.py 之后，您就可以开始与区块链交互了。 下面是一些 Web3.py 使用示例，算是抛砖引玉：
+正确配置了 Web3.py 之后，你就可以开始与区块链交互了。 下面是一些 Web3.py 使用示例，算是抛砖引玉：
```python
-# read block data:
+# 读取区块数据：
w3.eth.get_block('latest')
-# send a transaction:
+# 发送一笔交易：
w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
```
@@ -83,112 +80,115 @@ w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
注：在下面的例子中，以“$”开头的命令是要在终端中运行的。 （不要输入 `$`，它只是表示行的开始。）
-首先，安装 [IPython](https://ipython.org/)，以方便用户在其中进行探索。 IPython 提供了 tab 补全等功能，使得我们更容易看到 Web3.py 中有哪些可用方法。
+首先，安装 [IPython](https://ipython.org/)，以获得一个便于探索的用户友好环境。 IPython 提供了 tab 补全等功能，使得我们更容易看到 Web3.py 中有哪些可用方法。
```bash
-$ pip install ipython
+pip install ipython
```
Web3.py 以 `web3` 的名称发布。 安装方式如下：
```bash
-$ pip install web3
+pip install web3
```
另外，我们后面要模拟一个区块链，这就需要更多依赖项。 可以通过下面的命令安装这些依赖项：
```bash
-$ pip install 'web3[tester]'
+pip install 'web3[tester]'
```
-您已经设置完毕！
+你已经设置完毕！
-## 开启沙盒环境 {#spin-up-a-sandbox}
+请注意：`web3[tester]` 软件包最高支持 Python 3.10.xx
-在终端中运行 `ipython`，打开一个新的 Python 环境。 这与运行 `python` 类似，但更友好。
+## 启动一个沙盒 {#spin-up-a-sandbox}
+
+在终端中运行 `ipython`，打开一个新的 Python 环境。 这与运行 `python` 类似，但功能更丰富。
```bash
-$ ipython
+ipython
```
-这将打印出一些关于您正在运行的 Python 和 IPython 版本的信息，然后您应该会看到一个等待输入的提示：
+这将打印出一些关于你正在运行的 Python 和 IPython 版本的信息，然后你应该会看到一个等待输入的提示：
```python
In [1]:
```
-您现在看到的是一个交互式的 Python shell， 实际上，它是一个沙盒。 如果您已经做到了这一点，现在可以导入 Web3.py 了：
+你现在看到的是一个交互式的 Python shell， 从根本上说，这是一个沙盒。 如果你已经走到这一步，那么现在就可以导入Web3.py了：
```python
In [1]: from web3 import Web3
```
-## Web3 模块介绍 {#introducing-the-web3-module}
+## Web3 模块简介 {#introducing-the-web3-module}
-除了作为以太坊的网关， [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api) 模块还提供了一些便利的功能。 让我们来探究探究。
+除了作为以太坊的网关，[Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api) 模块还提供了一些便捷函数。 让我们来探究探究。
-在以太坊应用中，您通常需要转换货币面额。 Web3 模块为此提供几个辅助方法： [fromWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.fromWei) 和 [toWei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toWei)。
+在以太坊应用中，你通常需要转换货币面额。 Web3 模块为此提供了几个辅助方法：[from_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.from_wei) 和 [to_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.to_wei)。
注：计算机不擅长处理十进制数学。 为了规避这个问题，开发者通常会以美分存储美元。 例如，价格为 5.99 美元的物品在数据库中存储为 599。
-在以 ETH 处理交易时，也使用了类似的模式。 但是，ETH 不是只有两个小数位，而是有 18 位。 ether 的最小单位是 wei，所以发送交易时指定的就是这个值。
+在以 ETH 处理交易时，也使用了类似的模式。 但是，ETH 不是只有两个小数位，而是有 18 位。 以太币的最小单位是 wei，因此发送交易时指定的是该值。
-1 ETH = 1000000000000000000 wei
+1 以太币 = 1000000000000000000 wei
-1 wei = 0.000000000000000001 ETH
+1 wei = 0.000000000000000001 以太币
-试一下将一些数值转换为 wei 或反向转换。 请注意， [ETH 和 wei 之间还有其他面额](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations)名称。 其中比较有名的是 **gwei**，因为它通常用于表示交易费用。
+试一下将一些数值转换为 wei 或反向转换。 请注意，在以太币和 wei 之间[还有许多其他面额单位的名称](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations)。 其中比较有名的是**gwei**，因为它通常用于表示交易费用。
```python
-In [2]: Web3.toWei(1, 'ether')
+In [2]: Web3.to_wei(1, 'ether')
Out[2]: 1000000000000000000
-In [3]: Web3.fromWei(500000000, 'gwei')
+In [3]: Web3.from_wei(500000000, 'gwei')
Out[3]: Decimal('0.5')
```
-Web3 模块上的其他实用方法包括数据格式转换器（例如 [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)），地址助手，（例如 [`is address`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)），以及哈希函数（例如 [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)）。 其中许多内容将在后面的系列文章中介绍。 要查看所有可用的方法和属性，可以利用 IPython 的自动补全功能，输入 `Web3`。 然后在点号后面按两次 tab 键。
+Web3 模块上的其他实用方法包括数据格式转换器（例如 [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)）、地址辅助工具（例如 [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)）和哈希函数（例如 [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)）。 其中许多内容将在后面的系列文章中介绍。 要查看所有可用的方法和属性，可以利用 IPython 的自动补全功能，输入 `Web3`。 然后在点号后面按两次 tab 键。
-## 与链交互 {#talk-to-the-chain}
+## 与链对话 {#talk-to-the-chain}
-方便的方法很受欢迎，但让我们继续来说区块链。 接下来配置 Web3.py 与以太坊节点通信。 在这里，我们可以选择使用 IPC、HTTP 或 Websocket 提供者。
+这些便捷方法很棒，但我们还是继续来了解区块链吧。 接下来配置 Web3.py 与以太坊节点通信。 在这里，我们可以选择使用 IPC、HTTP 或 Websocket 提供者。
我们不会完整地进行这个步骤，但一个使用 HTTP 提供者的完整工作流程的例子可能如下所示：
- 下载一个以太坊节点，例如 [Geth](https://geth.ethereum.org/)。
-- 在一个终端窗口启动 Geth，等待它同步网络。 默认的 HTTP 端口是 `8545`，但可以配置成其它端口。
-- 告诉 Web3.py 通过 HTTP 连接到节点，使用 `localhost:8545`。 `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
+- 在一个终端窗口启动 Geth，等待它同步网络。 默认的 HTTP 端口是 `8545`，但可以配置。
+- 让 Web3.py 通过 HTTP 连接到 `localhost:8545` 上的节点。
+ `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
- 使用 `w3` 实例与节点交互。
-虽然这是一种“正式”的方式，但同步过程需要几个小时，如果您只是想要一个开发环境，则没有必要同步过程。 Web3.py 为此公开了第四个提供者，即 **EthereumTesterProvider**。 这个测试器提供者连接到一个模拟的以太坊节点，它有更宽松的权限，还有虚拟以太币可供操作。
+虽然这是一种“真实”的方式，但同步过程需要几个小时，如果你只是想要一个开发环境，则没必要进行同步。 Web3.py 为此公开了第四个提供者，即 **EthereumTesterProvider**。 这个测试器提供者连接到一个模拟的以太坊节点，它有更宽松的权限，还有虚拟以太币可供操作。
-
+
_EthereumTesterProvider 连接到一个模拟节点，对于快速开发环境来说非常方便。_
-这个模拟节点叫做 [eth-tester](https://github.com/ethereum/eth-tester)，我们把它作为 `pip install web3[tester]` 命令的一部分进行安装。 配置 Web3.py 来使用这个测试器提供者很简单：
+这个模拟节点叫做 [eth-tester](https://github.com/ethereum/eth-tester)，我们已通过 `pip install web3[tester]` 命令将其安装。 配置 Web3.py 来使用这个测试器提供者很简单：
```python
In [4]: w3 = Web3(Web3.EthereumTesterProvider())
```
-现在，您已经准备好在链上冲浪了！ 这不是人们常说的以太链。 我只是虚构了它。 我们来快速了解一下。
+现在，你已经准备好在链上冲浪了！ 人们一般不这么说。 我刚编的。 我们来快速了解一下。
-## 快速了解 {#the-quick-tour}
+## 快速概览 {#the-quick-tour}
-第一件事，先进行连接检查。
+首先，我们来检查一下是否一切正常：
```python
-In [5]: w3.isConnected()
+In [5]: w3.is_connected()
Out[5]: True
```
-由于我们使用的是测试器提供者，这不是一个非常有价值的测试，但如果它确实失败了，很可能是在实例化 `w3` 变量时发生了输入错误。 仔细检查您是否包含了内括号，即 `Web3.EthereumTesterProvider()`。
+由于我们使用的是测试器提供者，这不是一个非常有价值的测试，但如果它确实失败了，很可能是在实例化 `w3` 变量时发生了输入错误。 仔细检查你是否包含了内括号，即 `Web3.EthereumTesterProvider()`。
-## 第一站：[帐户 ](/developers/docs/accounts/) {#tour-stop-1-accounts}
+## 概览第一站：[账户](/developers/docs/accounts/) {#tour-stop-1-accounts}
为了方便起见，测试器提供者创建了一些帐户，并预先分配了测试以太币。
@@ -201,27 +201,27 @@ Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
```
-如果运行这个命令，您应该会看到一个以 `0x` 开头的十个字符串的列表。 每一个字符串都是一个的**公共地址**，在某些方面，类似于支票帐户上的帐号。 如果有人要给您转 ETH，您可以把这个地址给他。
+如果运行这个命令，你应该会看到一个以 `0x` 开头的十个字符串的列表。 每个都是一个**公共地址**，在某些方面类似于银行支票账户的账号。 如果有人要给你转 ETH，你可以把这个地址给他。
-如前所述，测试提供者已经为这些账户中的每一个账户预分配了一些测试以太币。 我们来看看第一个帐户上有多少 ETH。
+如前所述，测试提供者已经为这些帐户中的每一个帐户预分配了一些测试以太币。 我们来看看第一个帐户上有多少 ETH。
```python
In [7]: w3.eth.get_balance(w3.eth.accounts[0])
Out[7]: 1000000000000000000000000
```
-好多零啊！ 在你一路笑醒之前，先回忆一下之前关于货币面额的介绍。 ETH 币值用最小的面额 wei 来表示。 将其转换为 ETH：
+好多零啊！ 在你偷着乐之前，先回忆一下之前关于货币面额的介绍。 以太币值用最小的面额 wei 来表示。 将其转换为 ETH：
```python
-In [8]: w3.fromWei(1000000000000000000000000, 'ether')
+In [8]: w3.from_wei(1000000000000000000000000, 'ether')
Out[8]: Decimal('1000000')
```
100 万测试以太币，也不算太寒酸。
-## 第二站：区块数据 {#tour-stop-2-block-data}
+## 概览第二站：区块数据 {#tour-stop-2-block-data}
-我们来看看这个模拟区块链的状态。
+我们来看看这个模拟区块链的状态：
```python
In [9]: w3.eth.get_block('latest')
@@ -236,28 +236,31 @@ Out[9]: AttributeDict({
这里返回了大量关于区块的信息，但这里只介绍以下几点：
-- 该区块编号是零 —无论您在多久以前配置了测试器提供者。 与每 12 秒添加一个新区块的真实以太坊网络不同，此模拟区块链则需要你给它一些工作去做才添加区块。
+- 该区块编号是零 —无论你在多久以前配置了测试器提供者。 与每 12 秒添加一个新区块的真实以太坊网络不同，此模拟区块链则需要你给它一些工作去做才添加区块。
- `transactions` 是一个空列表，原因相同：我们还没有做任何事情。 第一个区块是一个**空区块**，只是为了开个头。
- 注意，`parentHash` 只是一堆空的字节。 这标志着它是链条上的第一个区块，也就是所谓的**创世区块**。
-## 第三站：[ 交易 ](/developers/docs/transactions/) {#tour-stop-3-transactions}
+## 概览第三站：[交易](/developers/docs/transactions/) {#tour-stop-3-transactions}
-在没有待处理交易之前，我们停留在零区块处，所以我们给它一个交易。 从一个账户向另一个账户发送一些测试 ETH：
+在没有待处理交易之前，我们停留在零区块处，所以我们给它一个交易。 从一个帐户向另一个帐户发送一些测试 ETH：
```python
In [10]: tx_hash = w3.eth.send_transaction({
'from': w3.eth.accounts[0],
'to': w3.eth.accounts[1],
- 'value': w3.toWei(3, 'ether'),
+ 'value': w3.to_wei(3, 'ether'),
'gas': 21000
})
```
这时你通常会等上几秒钟，等待交易添加到新区块中。 完整的流程是这样的：
-1. 提交交易并持有交易哈希。 在包含交易的区块被创建并广播之前，交易一直处于“待处理”状态。 `tx_hash = w3.eth.send_transaction({ … })`
-2. 等待交易添加到区块中： `w3.eth.wait_for_transaction_receipt(tx_hash)`
-3. 继续应用逻辑。 查看成功的交易：`w3.eth.get_transaction(tx_hash)`
+1. 提交交易并持有交易哈希。 在包含交易的区块被创建并广播之前，交易一直处于“待处理”状态。
+ `tx_hash = w3.eth.send_transaction({ … })`
+2. 等待交易被纳入区块：
+ `w3.eth.wait_for_transaction_receipt(tx_hash)`
+3. 继续应用逻辑。 要查看成功交易：
+ `w3.eth.get_transaction(tx_hash)`
我们的模拟环境会在一个新的区块中即时添加交易，所以我们可以立即查看交易：
@@ -274,22 +277,24 @@ Out[11]: AttributeDict({
})
```
-您将在这里看到一些熟悉的细节：`from`、`to `和 `value `字段应该与 `send_transaction `调用的输入相匹配。 另一个令人欣慰的是，这项交易被列为 1 号区块内的第一笔交易（`'transactionIndex': 0`）。
+你将在这里看到一些熟悉的细节：`from`、`to` 和 `value` 字段应该与我们 `send_transaction` 调用的输入相匹配。 另一个令人欣慰的是，这项交易被列为 1 号区块内的第一笔交易（`'transactionIndex': 0`）。
我们也可以通过检查两个相关帐户的余额，轻松验证此次交易是否成功。 三个 ETH 应从一个帐户转移到另一个帐户。
```python
In [12]: w3.eth.get_balance(w3.eth.accounts[0])
-Out[12]: 999996999999999999969000
+Out[12]: 999996999979000000000000
In [13]: w3.eth.get_balance(w3.eth.accounts[1])
Out[13]: 1000003000000000000000000
```
-后者看起来不错！ 余额从 1000000 增加到 1000003 个 ETH。 但第一个账户发生了什么情况？ 它减少的数量看起来略大于三个 ETH？ 是的，没有免费的午餐，使用以太坊公网需要支付矿工手续费， 一笔小额交易费从进行交易的帐户中扣除，金额为 31000 wei。
+后者看起来不错！ 余额从 1,000,000 增加到 1,000,003 个 ETH。 但第一个帐户发生了什么情况？ 它减少的数量看起来略大于三个 ETH？ 是的，没有免费的午餐，使用以太坊公网需要向为你提供支持的对等节点支付报酬。 从提交交易的帐户中扣除一小笔交易费用——这笔费用是燃料消耗量（ETH 转账需消耗 21000 单位燃料）乘以根据网络活动而变化的基本费用，再加上给将交易打包到区块中的验证者的小费。
+
+更多关于[燃料](/developers/docs/gas/#post-london)的信息
-注：在公共网络上，交易费用根据网络需求和您希望交易处理的速度而变化。 如果您对费用的计算方式感兴趣，请查看我之前关于如何将交易包含在一个区块中的文章。
+注：在公共网络上，交易费用根据网络需求和你希望交易处理的速度而变化。 如果你对费用的计算方式感兴趣，请查看我之前关于如何将交易包含在一个区块中的文章。
-## 结尾 {#and-breathe}
+## 喘口气 {#and-breathe}
-我们已经学习一段时间，现在可以休息一下。 要学习的内容还有很多，我们将在本系列的第二部分继续进行探索。 探索这些概念：连接真实节点、智能合约和代币， 仍有后续问题？ 请告诉我！ 您的反馈对我们今后的学习至关重要！ 欢迎通过 [Twitter](https://twitter.com/wolovim) 与我联系。
+我们已经学习一段时间，现在可以休息一下。 要学习的内容还有很多，我们将在本系列的第二部分继续进行探索。 即将介绍的概念：连接真实节点、智能合约和代币。 仍有后续问题？ 请告诉我！ 你的反馈对我们今后的学习至关重要！ 欢迎通过 [Twitter](https://twitter.com/wolovim) 提出请求。
diff --git a/public/content/translations/zh/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/zh/developers/tutorials/all-you-can-cache/index.md
index 0b52fe029ed..627d4d72026 100644
--- a/public/content/translations/zh/developers/tutorials/all-you-can-cache/index.md
+++ b/public/content/translations/zh/developers/tutorials/all-you-can-cache/index.md
@@ -1,34 +1,31 @@
---
title: "一切皆可缓存"
-description: 学习如何创建和使用缓存合约，以便进行更实惠的卷叠交易
+description: "学习如何创建和使用缓存合约，以便进行更实惠的卷叠交易"
author: Ori Pomerantz
-tags:
- - "二层网络"
- - "缓存"
- - "storage"
+tags: [ "二层网络", "缓存", "存储" ]
skill: intermediate
published: 2022-09-15
lang: zh
---
-当使用卷叠时，交易中一个字节的成本比一个存储插槽的成本要高得多。 因此，在链上缓存尽可能多的信息是有意义的。
+使用卷叠时，交易中一个字节的成本比一个存储插槽的成本高得多。 因此，在链上缓存尽可能多的信息是有意义的。
在本文中，你将学习如何创建和使用缓存合约，使得任何可能被多次使用的参数值都会被缓存，并且（在第一次使用之后）可通过更少的字节数来使用，并学习如何编写使用此缓存的链下代码。
-如果你想跳过这篇文章，直接查看源代码，[参见此处](https://github.com/qbzzt/20220915-all-you-can-cache)。 开发堆栈是 [Foundry](https://book.getfoundry.sh/getting-started/installation)。
+如果你想跳过本文，直接查看源代码，请点击[此处](https://github.com/qbzzt/20220915-all-you-can-cache)。 开发堆栈为 [Foundry](https://getfoundry.sh/introduction/installation/)。
## 总体设计 {#overall-design}
-为了简单起见，我们将假定所有交易参数是 `uint256`，长度为 32 个字节。 当我们收到交易时，将对每个参数进行解析，如下所示：
+为简单起见，我们假设所有交易参数均为 `uint256` 类型，长度为 32 字节。 收到交易时，我们将按如下方式解析每个参数：
-1. 如果第一个字节是 `0xFF`，则将接下来的 32 个字节作为参数值并将其写入缓存。
+1. 如果第一个字节是 `0xFF`，则取接下来的 32 个字节作为参数值并将其写入缓存。
-2. 如果第一个字节是 `0xFE`，则将接下来的 32 个字节作为参数值，但_不_将其写入缓存。
+2. 如果第一个字节是 `0xFE`，则取接下来的 32 个字节作为参数值，但_不_将其写入缓存。
-3. 对于任何其他值，将前四位作为额外字节的数量，将后四位作为缓存键的最高有效位。 以下是一些示例：
+3. 对于任何其他值，取高四位作为附加字节数，低四位作为缓存键的最高有效位。 以下是一些示例：
| calldata 中的字节 | 缓存键 |
- |:--------------- | --------:|
+ | :-------------- | -------: |
| 0x0F | 0x0F |
| 0x10,0x10 | 0x10 |
| 0x12,0xAC | 0x02AC |
@@ -36,7 +33,7 @@ lang: zh
## 缓存操作 {#cache-manipulation}
-缓存是在 [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol) 中实现的。 我们逐行学习它。
+缓存在 [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol) 中实现。 我们逐行来过一遍。
```solidity
// SPDX-License-Identifier: UNLICENSED
@@ -49,26 +46,26 @@ contract Cache {
bytes1 public constant DONT_CACHE = 0xFE;
```
-这些常量用于解释特殊情况，其中我们提供了所有信息，但是是否希望将其写入缓存是可选的。 写入缓存需要对之前未使用的存储插槽执行两次 [`SSTORE`](https://www.evm.codes/#55) 操作，每次操作花费 22100 燃料，这样我们将此操作变为可选操作。
+这些常量用于解释我们提供所有信息，并选择是否将其写入缓存的特殊情况。 写入缓存需要对之前未使用的存储插槽执行两次 [`SSTORE`](https://www.evm.codes/#55) 操作，每次操作花费 22100 燃料，因此我们将其设为可选。
```solidity
mapping(uint => uint) public val2key;
```
-一个在值和其键之间的[映射](https://www.geeksforgeeks.org/solidity-mappings/)。 在发送交易之前，对值进行编码时需要这些信息。
+值与其键之间的[映射](https://www.geeksforgeeks.org/solidity/solidity-mappings/)。 在发送交易之前，对值进行编码时需要这些信息。
```solidity
- // Location n has the value for key n+1, because we need to preserve
- // zero as "not in the cache".
+ // 位置 n 存储键 n+1 的值，因为我们需要保留
+ // 零值来表示“不在缓存中”。
uint[] public key2val;
```
-我们可以使用数组来进行从键到值的映射，出于简单起见，我们按顺序分配键。
+我们可以使用数组来进行从键到值的映射，因为我们分配键，为简单起见，我们按顺序分配。
```solidity
function cacheRead(uint _key) public view returns (uint) {
- require(_key <= key2val.length, "Reading uninitialize cache entry");
+ require(_key <= key2val.length, "正在读取未初始化的缓存条目");
return key2val[_key-1];
} // cacheRead
```
@@ -76,30 +73,30 @@ contract Cache {
从缓存中读取一个值。
```solidity
- // Write a value to the cache if it's not there already
- // Only public to enable the test to work
+ // 如果值尚不存在，则将其写入缓存
+ // 仅设为 public 以便测试能够正常工作
function cacheWrite(uint _value) public returns (uint) {
- // If the value is already in the cache, return the current key
+ // 如果值已在缓存中，则返回当前键
if (val2key[_value] != 0) {
return val2key[_value];
}
```
-在缓存中多次存储相同的值是没有意义的。 如果值已经存在，只需返回现有的键。
+在缓存中多次存储相同的值是没有意义的。 如果该值已存在，则只返回现有键。
```solidity
- // Since 0xFE is a special case, the largest key the cache can
- // hold is 0x0D followed by 15 0xFF's. If the cache length is already that
- // large, fail.
+ // 由于 0xFE 是一个特殊情况，缓存可容纳的最大键
+ // 是 0x0D 后跟 15 个 0xFF。如果缓存长度已达
+ // 该值，则失败。
// 1 2 3 4 5 6 7 8 9 A B C D E F
require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
- "cache overflow");
+ "缓存溢出");
```
-我认为我们永远无法获得如此庞大的缓存（大约 1.8\*1037 个条目，需要大约 1027 TB 的存储空间）。 然而，我知道[“640kB 始终足够了”](https://quoteinvestigator.com/2011/09/08/640k-enough/)。 这一测试非常实惠。
+我认为我们永远不会有这么大的缓存（大约 1.8\*1037 个条目，需要大约 1027 TB 的存储空间）。 然而，我年纪大了，还记得 [“640kB 永远够用”](https://quoteinvestigator.com/2011/09/08/640k-enough/) 这句话。 这个测试的成本非常低。
```solidity
- // Write the value using the next key
+ // 使用下一个键写入值
val2key[_value] = key2val.length+1;
```
@@ -109,33 +106,33 @@ contract Cache {
key2val.push(_value);
```
-添加正向查找（从键到值）。 因为我们按顺序分配值，所以我们可以将其添加在最后一个数组值之后。
+添加正向查找（从键到值）。 因为我们按顺序分配值，所以只需将其添加到最后一个数组值之后即可。
```solidity
return key2val.length;
} // cacheWrite
```
-返回 `key2val` 的新长度，该长度表示存储新值的单元格位置。
+返回 `key2val` 的新长度，即存储新值的单元格。
```solidity
function _calldataVal(uint startByte, uint length)
private pure returns (uint)
```
-这个函数从任意长度的 calldata（最多 32 个字节，即一个字的大小）中读取一个值。
+该函数从任意长度（最多 32 字节，即一个字的大小）的 calldata 中读取一个值。
```solidity
{
uint _retVal;
require(length < 0x21,
- "_calldataVal length limit is 32 bytes");
+ "_calldataVal 长度限制为 32 字节");
require(length + startByte <= msg.data.length,
- "_calldataVal trying to read beyond calldatasize");
+ "_calldataVal 尝试读取超出 calldatasize 的内容");
```
-这个函数是内部函数，因此如果其余的代码编写正确，则不需要这些测试。 然而，它们的成本不高，所以不妨拥有它们。
+此函数是内部函数，因此如果其余代码编写正确，则不需要这些测试。 不过，它们的成本不高，所以我们不妨保留它们。
```solidity
assembly {
@@ -143,56 +140,56 @@ contract Cache {
}
```
-此代码采用 [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html) 语言。 它从 calldata 中读取一个 32 字节的值。 即使该 calldata 在 `startByte+32` 之前停止，这种方法仍然有效，因为在以太坊虚拟机中，未初始化的空间被视为零。
+此代码使用 [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html) 编写。 它从 calldata 中读取一个 32 字节的值。 即使该 calldata 在 `startByte+32` 之前停止，这种方法仍然有效，因为在以太坊虚拟机中，未初始化的空间被视为零。
```solidity
_retVal = _retVal >> (256-length*8);
```
-我们并不一定需要一个 32 字节的值。 这将消除多余的字节。
+我们不一定需要一个 32 字节的值。 这将消除多余的字节。
```solidity
return _retVal;
} // _calldataVal
- // Read a single parameter from the calldata, starting at _fromByte
+ // 从 calldata 读取单个参数，从 _fromByte 开始
function _readParam(uint _fromByte) internal
returns (uint _nextByte, uint _parameterValue)
{
```
-从 calldata 中读取单个参数。 请注意，我们需要返回的不仅仅是我们读取的值，还包括下一个字节的位置，因为参数的长度可以从 1 个字节到 33 个字节不等。
+从 calldata 中读取单个参数。 请注意，我们不仅需要返回我们读取的值，还需要返回下一个字节的位置，因为参数的长度可以从 1 字节到 33 字节不等。
```solidity
- // The first byte tells us how to interpret the rest
+ // 第一个字节告诉我们如何解释其余部分
uint8 _firstByte;
_firstByte = uint8(_calldataVal(_fromByte, 1));
```
-Solidity 试图通过禁止可能危险的[隐式类型转换](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions)来减少错误的数量。 降级操作，例如从 256 位降级为 8 位，需要为显式。
+Solidity 试图通过禁止有潜在危险的[隐式类型转换](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions)来减少漏洞数量。 降级操作，例如从 256 位降级为 8 位，需要为显式。
```solidity
- // Read the value, but do not write it to the cache
+ // 读取值，但不将其写入缓存
if (_firstByte == uint8(DONT_CACHE))
return(_fromByte+33, _calldataVal(_fromByte+1, 32));
- // Read the value, and write it to the cache
+ // 读取值并将其写入缓存
if (_firstByte == uint8(INTO_CACHE)) {
uint _param = _calldataVal(_fromByte+1, 32);
cacheWrite(_param);
return(_fromByte+33, _param);
}
- // If we got here it means that we need to read from the cache
+ // 如果到了这里，意味着我们需要从缓存中读取
- // Number of extra bytes to read
+ // 要读取的额外字节数
uint8 _extraBytes = _firstByte / 16;
```
-取出低位四位（[半字节](https://en.wikipedia.org/wiki/Nibble)），并将其与其他字节组合以从缓存中读取值。
+取低位[半字节](https://en.wikipedia.org/wiki/Nibble)并将其与其他字节组合以从缓存中读取值。
```solidity
uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
@@ -203,17 +200,17 @@ Solidity 试图通过禁止可能危险的[隐式类型转换](https://docs.soli
} // _readParam
- // Read n parameters (functions know how many parameters they expect)
+ // 读取 n 个参数（函数知道它们需要多少个参数）
function _readParams(uint _paramNum) internal returns (uint[] memory) {
```
-我们可以从 calldata 中获取我们拥有的参数数量，但是调用我们的函数知道它们期望的参数数量。 让这些函数告诉我们会更容易一些。
+我们可以从 calldata 本身获取参数数量，但是调用我们的函数知道它们需要多少个参数。 让这些函数告诉我们会更容易一些。
```solidity
- // The parameters we read
+ // 我们读取的参数
uint[] memory params = new uint[](_paramNum);
- // Parameters start at byte 4, before that it's the function signature
+ // 参数从第 4 个字节开始，在此之前是函数签名
uint _atByte = 4;
for(uint i=0; i<_paramNum; i++) {
@@ -228,7 +225,7 @@ Solidity 试图通过禁止可能危险的[隐式类型转换](https://docs.soli
return(params);
} // readParams
- // For testing _readParams, test reading four parameters
+ // 用于测试 _readParams，测试读取四个参数
function fourParam() public
returns (uint256,uint256,uint256,uint256)
{
@@ -238,10 +235,10 @@ Solidity 试图通过禁止可能危险的[隐式类型转换](https://docs.soli
} // fourParam
```
-Foundry 的一个重大优势是允许用 Solidity 编写测试（[见下文的“测试缓存”](#testing-the-cache)）。 这使得单元测试变得更加容易。 这个函数读取四个参数并返回这些参数，以便测试可以验证它们是否正确。
+Foundry 的一个重大优势是允许用 Solidity 编写测试（见下文的[测试缓存](#testing-the-cache)）。 这使得单元测试变得更加容易。 这个函数读取四个参数并返回这些参数，以便测试可以验证它们是否正确。
```solidity
- // Get a value, return bytes that will encode it (using the cache if possible)
+ // 获取一个值，返回将对其进行编码的字节（如有可能，使用缓存）
function encodeVal(uint _val) public view returns(bytes memory) {
```
@@ -250,33 +247,33 @@ Foundry 的一个重大优势是允许用 Solidity 编写测试（[见下文的
```solidity
uint _key = val2key[_val];
- // The value isn't in the cache yet, add it
+ // 该值尚不在缓存中，将其添加
if (_key == 0)
return bytes.concat(INTO_CACHE, bytes32(_val));
```
-在[以太坊虚拟机](/developers/docs/evm/)中，所有未初始化的存储被假定为零。 因此，如果我们在查找一个不存在的值的键时，会得到一个零。 在这种情况下，对其进行编码的字节为 `INTO_CACHE`（这样下次将被缓存），接着是实际的值。
+在[以太坊虚拟机](/developers/docs/evm/)中，所有未初始化的存储都被假定为零。 因此，如果我们在查找一个不存在的值的键时，会得到一个零。 在这种情况下，对其进行编码的字节为 `INTO_CACHE`（这样下次将被缓存），接着是实际的值。
```solidity
- // If the key is <0x10, return it as a single byte
+ // 如果键 <0x10，将其作为单个字节返回
if (_key < 0x10)
return bytes.concat(bytes1(uint8(_key)));
```
-单字节是最简单的。 我们使用 [`bytes.concat`](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat) 函数将 `bytes` 类型转换为可以是任意长度的字节数组。 尽管名称如此，但当只提供一个参数时，它仍能正常工作。
+单字节是最简单的。 我们只使用 [`bytes.concat`](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat) 将 `bytes` 类型转换为任意长度的字节数组。 尽管名称如此，但当只提供一个参数时，它仍能正常工作。
```solidity
- // Two byte value, encoded as 0x1vvv
+ // 两个字节的值，编码为 0x1vvv
if (_key < 0x1000)
return bytes.concat(bytes2(uint16(_key) | 0x1000));
```
-当我们有一个小于 163 的键时，我们可以用两个字节来表示它。 我们首先将一个 256 位的值 ` _key` 转换为一个 16 位的值，并使用逻辑“或”将额外字节数添加到第一个字节。 然后我们将其转换为 `bytes2` 值，继而可以转换为 `bytes`。
+当我们有一个小于 163 的键时，我们可以用两个字节来表示它。 我们首先将一个 256 位的值 `_key` 转换为一个 16 位的值，并使用逻辑“或”将额外字节数添加到第一个字节。 然后我们将其转换为 `bytes2` 值，继而可以转换为 `bytes`。
```solidity
- // There is probably a clever way to do the following lines as a loop,
- // but it's a view function so I'm optimizing for programmer time and
- // simplicity.
+ // 也许有更巧妙的方法以循环方式实现以下代码行，
+ // 但这是一个 view 函数，因此我以节省程序员时间和
+ // 追求简洁为优化目标。
if (_key < 16*256**2)
return bytes.concat(bytes3(uint24(_key) | (0x2 * 16 * 256**2)));
@@ -291,14 +288,14 @@ Foundry 的一个重大优势是允许用 Solidity 编写测试（[见下文的
return bytes.concat(bytes16(uint128(_key) | (0xF * 16 * 256**15)));
```
-其他的值（例如 3 字节、4 字节等）的处理方式相同，只是字段大小不同。
+其他值（3 字节、4 字节等） 处理方式相同，只是字段大小不同。
```solidity
- // If we get here, something is wrong.
- revert("Error in encodeVal, should not happen");
+ // 如果到了这一步，说明出错了。
+ revert("encodeVal 中出错，不应发生");
```
-如果到了这一步，意味着我们得到了一个键，其值不小于 16*25615。 但是 `cacheWrite` 对键进行了限制，因此我们甚至无法达到 14\*25616（其首字节为 0xFE，因此看起来像 `DONT_CACHE`）。 添加一个测试来防止未来的开发者引入错误，并不需要太多成本。
+如果到了这一步，意味着我们得到了一个键，其值不小于 16\*25615。 但是 `cacheWrite` 对键进行了限制，因此我们甚至无法达到 14\*25616（其首字节为 0xFE，因此看起来像 `DONT_CACHE`）。 添加一个测试来防止未来的开发者引入错误，并不需要太多成本。
```solidity
} // encodeVal
@@ -308,7 +305,7 @@ Foundry 的一个重大优势是允许用 Solidity 编写测试（[见下文的
### 测试缓存 {#testing-the-cache}
-Foundry 的一个优势是[允许你使用 Solidity 编写测试](https://book.getfoundry.sh/forge/tests)，这使得编写单元测试更加容易。 `Cache` 类的测试可以在[此处](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol)找到。 由于测试代码通常会有很多重复的部分，本文仅说明有趣的部分。
+Foundry 的一个优点是[它允许你用 Solidity 编写测试](https://getfoundry.sh/forge/tests/overview/)，这让单元测试的编写变得更容易。 `Cache` 类的测试[在此处](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol)。 由于测试代码通常会有很多重复的部分，本文仅说明有趣的部分。
```solidity
// SPDX-License-Identifier: UNLICENSED
@@ -317,7 +314,7 @@ pragma solidity ^0.8.13;
import "forge-std/Test.sol";
-// Need to run `forge test -vv` for the console.
+// 需要运行 `forge test -vv` 以便使用控制台。
import "forge-std/console.sol";
```
@@ -344,7 +341,7 @@ contract CacheTest is Test {
function testCaching() public {
```
-测试是以 `test` 开头的函数。 该函数检查基本的缓存功能，写入值并再次读取这些值。
+测试是名称以 `test` 开头的函数。 该函数检查基本的缓存功能，写入值并再次读取这些值。
```solidity
for(uint i=1; i<5000; i++) {
@@ -355,15 +352,15 @@ contract CacheTest is Test {
assertEq(cache.cacheRead(i), i*i);
```
-这是你进行实际测试时使用的方法，使用 [`assert...` 函数](https://book.getfoundry.sh/reference/forge-std/std-assertions)。 在这种情况下，我们检查我们写入的值是否是我们读取的值。 我们可以忽略 `cache.cacheWrite` 的结果，因为我们知道缓存键是按线性分配的。
+这是你使用 [`assert...` 函数](https://getfoundry.sh/reference/forge-std/std-assertions/)进行实际测试的方式。 在这种情况下，我们检查我们写入的值是否是我们读取的值。 我们可以忽略 `cache.cacheWrite` 的结果，因为我们知道缓存键是按线性分配的。
```solidity
}
} // testCaching
- // Cache the same value multiple times, ensure that the key stays
- // the same
+ // 多次缓存相同的值，确保键保持
+ // 相同
function testRepeatCaching() public {
for(uint i=1; i<100; i++) {
uint _key1 = cache.cacheWrite(i);
@@ -385,8 +382,8 @@ contract CacheTest is Test {
理论上，这是一种不会影响连续缓存写入的错误。 所以在这里，我们进行一些非连续的写入操作，并看到值仍然没有被重新写入。
```solidity
- // Read a uint from a memory buffer (to make sure we get back the parameters
- // we sent out)
+ // 从内存缓冲区中读取一个 uint（以确保我们得到
+ // 我们发出的参数）
function toUint256(bytes memory _bytes, uint256 _start) internal pure
returns (uint256)
```
@@ -403,18 +400,18 @@ contract CacheTest is Test {
}
```
-Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的数据结构，例如内存缓冲区 `_bytes` 时，你会得到该结构的地址。 Solidity 将 `bytes memory` 类型的值存储为一个 32 字节的字，其中包含长度信息，后跟实际的字节。因此，要获取字节数量 `_start`，我们需要计算 `_bytes+32+_start`。
+Yul 不支持 `uint256` 以外的数据结构，因此当你引用更复杂的数据结构（例如内存缓冲区 `_bytes`）时，你会得到该结构的地址。 Solidity 将 `bytes memory` 类型的值存储为一个 32 字节的字，其中包含长度信息，后跟实际的字节。因此，要获取字节数量 `_start`，我们需要计算 `_bytes+32+_start`。
```solidity
return tempUint;
} // toUint256
- // Function signature for fourParams(), courtesy of
- // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
+ // fourParams() 的函数签名，由
+ // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d 提供
bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
- // Just some constant values to see we're getting the correct values back
+ // 仅是一些常量值，用于查看我们是否收到了正确的值
uint256 constant VAL_A = 0xDEAD60A7;
uint256 constant VAL_B = 0xBEEF;
uint256 constant VAL_C = 0x600D;
@@ -439,15 +436,15 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
我们无法使用普通的应用程序二进制接口机制来调用使用缓存的函数，因此我们需要使用低级别的 [`.call()`](https://docs.soliditylang.org/en/v0.8.16/types.html#members-of-addresses) 机制。 该机制接受一个 `bytes memory` 类型的输入，并将其作为输出返回（同时返回一个布尔值）。
```solidity
- // First call, the cache is empty
+ // 第一次调用，缓存为空
_callInput = bytes.concat(
FOUR_PARAMS,
```
-对于同一个合约来说，支持缓存函数（用于从交易直接调用）和非缓存函数（用于从其他智能合约调用）是很有用的。 为了做到这一点，我们需要继续依赖 Solidity 机制来调用正确的函数，而不是将所有内容放在一个 [`feedback` 函数](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function)中。 这样做可以大大简化可组合性的实现。 在大多数情况下，一个字节就足够标识函数了，所以我们浪费了三个字节（16\*3= 48 单位燃料）。 然而，就我撰写此文时而言，这 48 单位燃料的成本为 0.07 美分，对于更简单、错误更少的代码而言，这是合理的成本。
+对于同一个合约来说，支持缓存函数（用于从交易直接调用）和非缓存函数（用于从其他智能合约调用）是很有用的。 为了做到这一点，我们需要继续依赖 Solidity 机制来调用正确的函数，而不是将所有内容放在一个[“回退”函数](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function)中。 这样做可以大大简化可组合性的实现。 在大多数情况下，一个字节就足够标识函数了，所以我们浪费了三个字节（16\*3= 48 单位燃料）。 然而，就我撰写此文时而言，这 48 单位燃料的成本为 0.07 美分，对于更简单、错误更少的代码而言，这是合理的成本。
```solidity
- // First value, add it to the cache
+ // 第一个值，将其添加到缓存
cache.INTO_CACHE(),
bytes32(VAL_A),
```
@@ -487,22 +484,22 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
输出为四个参数。 在这里，我们验证其是否正确。
```solidity
- // Second call, we can use the cache
+ // 第二次调用，我们可以使用缓存
_callInput = bytes.concat(
FOUR_PARAMS,
- // First value in the Cache
+ // 缓存中的第一个值
bytes1(0x01),
```
小于 16 的缓存键只占用一个字节。
```solidity
- // Second value, don't add it to the cache
+ // 第二个值，不将其添加到缓存
cache.DONT_CACHE(),
bytes32(VAL_B),
- // Third and fourth values, same value
+ // 第三和第四个值，值相同
bytes1(0x02),
bytes1(0x02)
);
@@ -541,18 +538,18 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
`testEncodeVal()` 中唯一的附加测试是验证 `_callInput` 的长度是否正确。 对于第一次调用，长度为 4+33\*4。 对于第二次调用，其中每个值已经存在于缓存中，长度为 4+1\*4。
```solidity
- // Test encodeVal when the key is more than a single byte
- // Maximum three bytes because filling the cache to four bytes takes
- // too long.
+ // 当键超过一个字节时测试 encodeVal
+ // 最多三个字节，因为填满缓存到四个字节需要
+ // 太长时间。
function testEncodeValBig() public {
- // Put a number of values in the cache.
- // To keep things simple, use key n for value n.
+ // 在缓存中放入一些值。
+ // 为简单起见，对值 n 使用键 n。
for(uint i=1; i<0x1FFF; i++) {
cache.cacheWrite(i);
}
```
-上述 `testEncodeVal` 函数只将四个值写入缓存中，因此并未检查[处理多字节值的函数部分](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171)。 但是那段代码很复杂且容易出错。
+上述 `testEncodeVal` 函数只将四个值写入缓存中，因此[处理多字节值的函数部分](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171)并未得到检查。 但是那段代码很复杂且容易出错。
该函数的第一部分是一个循环，这个循环将从 1 到 0x1FFF 的所有值按顺序写入缓存，因此我们将能够对这些值进行编码并知道这些值的去向。
@@ -563,10 +560,10 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
_callInput = bytes.concat(
FOUR_PARAMS,
- cache.encodeVal(0x000F), // One byte 0x0F
- cache.encodeVal(0x0010), // Two bytes 0x1010
- cache.encodeVal(0x0100), // Two bytes 0x1100
- cache.encodeVal(0x1000) // Three bytes 0x201000
+ cache.encodeVal(0x000F), // 一字节 0x0F
+ cache.encodeVal(0x0010), // 两字节 0x1010
+ cache.encodeVal(0x0100), // 两字节 0x1100
+ cache.encodeVal(0x1000) // 三字节 0x201000
);
```
@@ -580,7 +577,7 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
} // testEncodeValBig
- // Test what with an excessively small buffer we get a revert
+ // 测试使用过小的缓冲区时，我们会得到一个回滚
function testShortCalldata() public {
```
@@ -598,7 +595,7 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
由于发生了回滚，我们应该得到的结果是 `false`。
```
- // Call with cache keys that aren't there
+ // 使用不存在的缓存键调用
function testNoCacheKey() public {
.
.
@@ -606,11 +603,11 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
_callInput = bytes.concat(
FOUR_PARAMS,
- // First value, add it to the cache
+ // 第一个值，将其添加到缓存
cache.INTO_CACHE(),
bytes32(VAL_A),
- // Second value
+ // 第二个值
bytes1(0x0F),
bytes2(0x1234),
bytes11(0xA10102030405060708090A)
@@ -623,30 +620,30 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
.
.
.
- // Test what with an excessively long buffer everything works file
+ // 测试缓冲区过长时，所有操作都能正常工作
function testLongCalldata() public {
address _cacheAddr = address(cache);
bool _success;
bytes memory _callInput;
bytes memory _callOutput;
- // First call, the cache is empty
+ // 第一次调用，缓存为空
_callInput = bytes.concat(
FOUR_PARAMS,
- // First value, add it to the cache
+ // 第一个值，将其添加到缓存
cache.INTO_CACHE(), bytes32(VAL_A),
- // Second value, add it to the cache
+ // 第二个值，将其添加到缓存
cache.INTO_CACHE(), bytes32(VAL_B),
- // Third value, add it to the cache
+ // 第三个值，将其添加到缓存
cache.INTO_CACHE(), bytes32(VAL_C),
- // Fourth value, add it to the cache
+ // 第四个值，将其添加到缓存
cache.INTO_CACHE(), bytes32(VAL_D),
- // And another value for "good luck"
+ // 另外一个值用于“祝你好运”
bytes4(0x31112233)
);
```
@@ -665,13 +662,13 @@ Yul 不支持超出 `uint256` 的数据结构，因此当你引用更复杂的
```
-## 一个应用示例 {#a-sample-app}
+## 示例应用程序 {#a-sample-app}
-使用 Solidity 语言来编写测试非常重要，但最终，一个去中心化应用程序需要能够处理来自链外的请求才能发挥其实用性。 本文演示了如何在去中心化应用程序中使用缓存，其中使用了 `WORM`（Write Once, Read Many，写入一次，读取多次）的概念。 如果一个键尚未被写入，你可以向其写入一个值。 如果该键已被写入，你可以进行回滚。
+用 Solidity 编写测试固然很好，但归根结底，一个去中心化应用程序需要能够处理来自链外的请求才算有用。 本文演示了如何在去中心化应用程序中使用缓存，其中使用了 WORM（Write Once, Read Many，写入一次，读取多次）的概念。 如果一个键尚未被写入，你可以向其写入一个值。 如果该键已被写入，你可以进行回滚。
### 合约 {#the-contract}
-[这就是合约](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol)。 这主要重复了我们已经完成的 `Cache` 和 `CacheTest` 部分内容，因此我们只涵盖有趣的部分。
+[这是合约](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol)。 这主要重复了我们已经完成的 `Cache` 和 `CacheTest` 部分内容，因此我们只涵盖有趣的部分。
```solidity
import "./Cache.sol";
@@ -688,12 +685,12 @@ contract WORM is Cache {
} // writeEntryCached
```
-此函数与上面的 `CacheTest` 中的 `fourParam` 函数类似。 由于我们并未遵循 ABI 规范，最好不要在函数中声明任何参数。
+此函数与上面的 `CacheTest` 中的 `fourParam` 函数类似。 由于我们并未遵循应用程序二进制接口规范，最好不要在函数中声明任何参数。
```solidity
- // Make it easier to call us
- // Function signature for writeEntryCached(), courtesy of
- // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
+ // 使我们更易于调用
+ // writeEntryCached() 的函数签名，由
+ // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3 提供
bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
```
@@ -720,7 +717,7 @@ Read 函数是一个 `view` 函数，因此它不需要进行交易，并且不
worm.writeEntry(0xDEAD, 0xBEEF);
```
-[此 (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) 是我们如何在 Foundry 测试中指定下一次调用应该失败，以及报告的失败原因。 这适用于我们使用语法 `.()` 而不是构建 calldata 并使用低级别接口来调用合约（`.call()` 等）的情况。
+在 Foundry 测试中，我们通过[此 (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) 来指定下一次调用应该失败，以及报告的失败原因。 这适用于我们使用语法 `.()` 而不是构建 calldata 并使用低级别接口来调用合约（`.call()` 等）的情况。
```solidity
function testReadWriteCached() public {
@@ -756,13 +753,13 @@ Read 函数是一个 `view` 函数，因此它不需要进行交易，并且不
(_success,) = address(worm).call(_callInput);
```
-这是我们在 Foundry 中验证代码[正确触发事件](https://book.getfoundry.sh/cheatcodes/expect-emit)的方式。
+在 Foundry 中，我们以这种方式来验证代码是否[正确触发了事件](https://getfoundry.sh/reference/cheatcodes/expect-emit/)。
### 客户端 {#the-client}
-在 Solidity 测试中，你无法得到可以复制粘贴到你自己应用程序中的 JavaScript 代码。 为了编写那段代码，我将 WORM 部署到 [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli)，这是 [Optimism](https://www.optimism.io/) 的新测试网络。 地址为 [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a)。
+在 Solidity 测试中，你无法得到可以复制粘贴到你自己应用程序中的 JavaScript 代码。 为了编写该代码，我将 WORM 部署到 [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli)（[Optimism](https://www.optimism.io/) 的新测试网）。 其地址为 [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a)。
-[你可以在这里看到客户端的 JavaScript 代码](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js)。 要使用该代码：
+[你可在此处查看客户端的 JavaScript 代码](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js)。 要使用该代码：
1. 克隆 git 存储库：
@@ -785,10 +782,10 @@ Read 函数是一个 `view` 函数，因此它不需要进行交易，并且不
4. 编辑 `.env` 文件以进行配置：
- | 参数 | 值 |
- | --------------------- | ---------------------------------------------------------------------------------------- |
- | MNEMONIC | 持有足够以太币来支付交易费用的帐户的助记词。 [你可以在此处免费获取 Optimism Goerli 网络的以太币](https://optimismfaucet.xyz/)。 |
- | OPTIMISM_GOERLI_URL | Optimism Goerli 的 URL。 公共端点 `https://goerli.optimism.io` 存在速率限制，但能够满足我们此处的需求 |
+ | 参数 | Value |
+ | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+ | MNEMONIC | 拥有足够 ETH 支付交易费用的帐户的助记词。 [你可以在此处免费获取 Optimism Goerli 网络的 ETH](https://optimismfaucet.xyz/)。 |
+ | OPTIMISM_GOERLI_URL | Optimism Goerli 的 URL。 公共端点 `https://goerli.optimism.io` 存在速率限制，但能够满足我们此处的需求 |
5. 运行 `index.js`。
@@ -807,7 +804,7 @@ Read 函数是一个 `view` 函数，因此它不需要进行交易，并且不
const main = async () => {
const func = await worm.WRITE_ENTRY_CACHED()
- // Need a new key every time
+ // 每次都需要一个新键
const key = await worm.encodeVal(Number(new Date()))
```
@@ -816,11 +813,11 @@ const main = async () => {
```javascript
const val = await worm.encodeVal("0x600D")
-// Write an entry
+// 写入一个条目
const calldata = func + key.slice(2) + val.slice(2)
```
-Ethers 期望调用数据是一个十六进制字符串，即以 `0x` 开头，后跟偶数个十六进制数字。 由于 `key` 和 `val` 都以 `0x` 开头，我们需要去除这些头部信息。
+Ethers 期望调用数据是一个十六进制字符串，即 `0x` 后跟偶数个十六进制数字。 由于 `key` 和 `val` 都以 `0x` 开头，我们需要去除这些头部信息。
```javascript
const tx = await worm.populateTransaction.writeEntryCached()
@@ -835,8 +832,8 @@ sentTx = await wallet.sendTransaction(tx)
.
.
.
- // Read the entry just written
- const realKey = '0x' + key.slice(4) // remove the FF flag
+ // 读取刚写入的条目
+ const realKey = '0x' + key.slice(4) // 移除 FF 标志
const entryRead = await worm.readEntry(realKey)
.
.
@@ -856,12 +853,15 @@ sentTx = await wallet.sendTransaction(tx)
然而，这是一个潜在的危险操作。 设想以下事件序列：
- 1. Noam Naive 调用 `encodeVal` 函数来对他想要向其中发送代币的地址进行编码。 该地址是应用程序中使用的最早一批地址之一，因此编码值为 0x06。 这是一个 `view` 函数，而不是一个交易，发生于 Noam 和他使用的节点之间，而其他人则对此毫不知情。
+ 1. Noam Naive 调用 `encodeVal` 来对他想发送代币的目标地址进行编码。 该地址是应用程序中使用的最早一批地址之一，因此编码值为 0x06。 这是一个 `view` 函数，而不是一个交易，发生于 Noam 和他使用的节点之间，而其他人则对此毫不知情。
2. Owen Owner 运行缓存重排序操作。 实际上，很少有人会使用那个地址，所以现在它被编码为 0x201122。 另一个数值，1018，被赋值为 0x06。
- 3. Noam Naive 将他的代币发送到了 0x06 地址。 它们被发送到地址 `0x0000000000000000000000000de0b6b3a7640000`，由于没有人知道该地址的私钥，这些代币将永远留在那里。 Noam _不开心_。
+ 3. Noam Naive 将他的代币发送到了 0x06。 代币被发送到地址 `0x0000000000000000000000000de0b6b3a7640000`，由于没人知道该地址的私钥，这些代币就被困在那里了。 Noam _很不开心_。
- 虽然有多种方法可以解决此问题，以及解决与缓存重新排序期间内存池中的交易相关的问题，但你必须对此有所了解。
+ 有办法可以解决这个问题，以及在缓存重新排序期间交易位于内存池中的相关问题，但你必须意识到这一点。
由于我是 Optimism 的员工，这是我最熟悉的卷叠，所以这里我展示了使用 Optimism 进行缓存。 但是，对于任何内部处理费用较低的卷叠方案，这个方法应该是有效的，因为相比之下，将交易数据写入一层网络是主要费用。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
+
diff --git a/public/content/translations/zh/developers/tutorials/app-plasma/index.md b/public/content/translations/zh/developers/tutorials/app-plasma/index.md
new file mode 100644
index 00000000000..1b07e2fa457
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/app-plasma/index.md
@@ -0,0 +1,1255 @@
+---
+title: "编写一个保护隐私的应用程序专用 Plasma"
+description: "在本教程中，我们将构建一个用于存款的半保密银行。 该银行是一个中心化组件，它知道每个用户的余额。 但是，此信息不会存储在链上。 银行会发布状态的哈希值。 每当发生交易时，银行都会发布新的哈希值，以及一个零知识证明，证明其拥有一个已签名的交易，可将哈希状态更改为新状态。 阅读本教程后，您不仅会了解如何使用零知识证明，还会了解为什么要使用它们以及如何安全地使用。"
+author: Ori Pomerantz
+tags: [ "零知识", "服务器", "链下", "隐私" ]
+skill: advanced
+lang: zh
+published: 2025-10-15
+---
+
+## 简介 {#introduction}
+
+与 [Rollup](/developers/docs/scaling/zk-rollups/) 相反，[Plasma](/developers/docs/scaling/plasma) 使用以太坊主网保证完整性，但不保证可用性。 在本文中，我们编写了一个行为类似于 Plasma 的应用程序，其中以太坊保证完整性（未经授权的更改），但不保证可用性（中心化组件可能宕机并禁用整个系统）。
+
+我们在此编写的应用程序是一个保护隐私的银行。 不同的地址拥有带余额的帐户，它们可以向其他帐户发送资金 (ETH)。 银行会发布状态（帐户及其余额）和交易的哈希值，但会将实际余额保留在链下，以保持隐私。
+
+## 设计 {#design}
+
+这不是一个生产就绪的系统，而是一个教学工具。 因此，它是基于几个简化的假设编写的。
+
+- 固定帐户池。 帐户数量是特定的，每个帐户都属于一个预定地址。 这使得系统更加简单，因为在零知识证明中处理可变大小的数据结构很困难。 对于生产就绪系统，我们可以使用 [Merkle 根](/developers/tutorials/merkle-proofs-for-offline-data-integrity/)作为状态哈希，并为所需余额提供 Merkle 证明。
+
+- 内存存储。 在生产系统中，我们需要将所有帐户余额写入磁盘，以在重启时保留它们。 在这里，如果信息丢失了也没关系。
+
+- 仅限转账。 生产系统需要一种将资产存入银行和取款的方式。 但这里的目的只是为了说明概念，所以这家银行仅限于转账。
+
+### 零知识证明 {#zero-knowledge-proofs}
+
+在基本层面上，零知识证明表明证明者知道一些数据 _Dataprivate_，使得一些公共数据 _Datapublic_ 和 _Dataprivate_ 之间存在关系 _Relationship_。 验证者知道 _Relationship_ 和 _Datapublic_。
+
+为了保护隐私，我们需要将状态和交易设为私有。 但为了确保完整性，我们需要将状态的[加密哈希](https://en.wikipedia.org/wiki/Cryptographic_hash_function)设为公开。 为了向提交交易的人证明这些交易确实发生过，我们还需要发布交易哈希。
+
+在大多数情况下，_Dataprivate_ 是零知识证明程序的输入，而 _Datapublic_ 是输出。
+
+_Dataprivate_ 中的这些字段：
+
+- _Staten_，旧状态
+- _Staten+1_，新状态
+- _Transaction_，一个将旧状态更改为新状态的交易。 此交易需要包含以下字段：
+ - _目标地址_，接收转账的地址
+ - _金额_，正在转账的金额
+ - _Nonce_，用于确保每笔交易只能处理一次。
+ 源地址不需要在交易中，因为可以从签名中恢复。
+- _签名_，一个被授权执行交易的签名。 在我们的案例中，唯一被授权执行交易的地址是源地址。 因为我们的零知识系统的工作方式，除了以太坊签名之外，我们还需要帐户的公钥。
+
+_Datapublic_ 中的字段如下：
+
+- _Hash(Staten)_，旧状态的哈希
+- _Hash(Staten+1)_，新状态的哈希
+- _Hash(Transaction)_，将状态从 _Staten_ 更改为 _Staten+1_ 的交易哈希。
+
+该关系检查了几个条件：
+
+- 公共哈希确实是私有字段的正确哈希。
+- 当交易应用于旧状态时，会产生新状态。
+- 签名来自交易的源地址。
+
+由于加密哈希函数的特性，证明这些条件足以确保完整性。
+
+### 数据结构 {#data-structures}
+
+主要的数据结构是服务器持有的状态。 对于每个帐户，服务器会跟踪帐户余额和一个 [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce)，用于防止[重放攻击](https://en.wikipedia.org/wiki/Replay_attack)。
+
+### 组件 {#components}
+
+该系统需要两个组件：
+
+- 接收交易、处理交易并将哈希与零知识证明一起发布到链上的_服务器_。
+- 一个存储哈希并验证零知识证明以确保状态转换合法的_智能合约_。
+
+### 数据和控制流 {#flows}
+
+这些是各种组件之间进行通信以实现从一个帐户到另一个帐户的转账的方式。
+
+1. Web 浏览器提交一个已签名的交易，请求从签名者的帐户向另一个帐户转账。
+
+2. 服务器验证交易是否有效：
+
+ - 签名者在银行中拥有一个有足够余额的帐户。
+ - 收款人在银行中拥有一个帐户。
+
+3. 服务器通过从签名者的余额中减去转账金额并将其加到收款人的余额中来计算新状态。
+
+4. 服务器计算一个零知识证明，证明状态变更是有效的。
+
+5. 服务器向以太坊提交一笔交易，其中包括：
+
+ - 新状态哈希
+ - 交易哈希（以便交易发送者知道它已被处理）
+ - 证明向新状态的转换有效的零知识证明
+
+6. 智能合约验证零知识证明。
+
+7. 如果零知识证明通过验证，智能合约将执行以下操作：
+ - 将当前状态哈希更新为新状态哈希
+ - 发出一个包含新状态哈希和交易哈希的日志条目
+
+### 工具 {#tools}
+
+对于客户端代码，我们将使用 [Vite](https://vite.dev/)、[React](https://react.dev/)、[Viem](https://viem.sh/) 和 [Wagmi](https://wagmi.sh/)。 这些是行业标准工具；如果你不熟悉它们，可以使用[本教程](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/)。
+
+服务器的大部分是使用 [Node](https://nodejs.org/en) 以 JavaScript 编写的。 零知识部分是用 [Noir](https://noir-lang.org/) 编写的。 我们需要 `1.0.0-beta.10` 版本，所以在您[按照指示安装 Noir](https://noir-lang.org/docs/getting_started/quick_start) 后，运行：
+
+```
+noirup -v 1.0.0-beta.10
+```
+
+我们使用的区块链是 `anvil`，这是一个本地测试区块链，属于 [Foundry](https://getfoundry.sh/introduction/installation) 的一部分。
+
+## 实现 {#implementation}
+
+因为这是一个复杂的系统，我们将分阶段实现它。
+
+### 第 1 阶段 - 手动零知识 {#stage-1}
+
+在第一阶段，我们将在浏览器中签署一笔交易，然后手动将信息提供给零知识证明。 零知识代码期望在 `server/noir/Prover.toml` 中获取该信息（文档在[此处](https://noir-lang.org/docs/getting_started/project_breakdown#provertoml-1)）。
+
+要查看实际操作：
+
+1. 确保您已安装 [Node](https://nodejs.org/en/download) 和 [Noir](https://noir-lang.org/install)。 最好将它们安装在 UNIX 系统上，例如 macOS、Linux 或 [WSL](https://learn.microsoft.com/en-us/windows/wsl/install)。
+
+2. 下载阶段 1 的代码并启动 Web 服务器以提供客户端代码。
+
+ ```sh
+ git clone https://github.com/qbzzt/250911-zk-bank.git -b 01-manual-zk
+ cd 250911-zk-bank
+ cd client
+ npm install
+ npm run dev
+ ```
+
+ 这里需要一个 Web 服务器的原因是，为了防止某些类型的欺诈，许多钱包（例如 MetaMask）不接受直接从磁盘提供的文件
+
+3. 用钱包打开浏览器。
+
+4. 在钱包中，输入一个新的密码短语。 请注意，这将删除您现有的密码短语，因此_请确保您有备份_。
+
+ 密码短语是 `test test test test test test test test test test test junk`，这是 anvil 的默认测试密码短语。
+
+5. 浏览到[客户端代码](http://localhost:5173/)。
+
+6. 连接到钱包并选择您的目标帐户和金额。
+
+7. 点击 **Sign** 并签署交易。
+
+8. 在 **Prover.toml** 标题下，您会找到文本。 用该文本替换 `server/noir/Prover.toml`。
+
+9. 执行零知识证明。
+
+ ```sh
+ cd ../server/noir
+ nargo execute
+ ```
+
+ 输出应类似于
+
+ ```
+ ori@CryptoDocGuy:~/noir/250911-zk-bank/server/noir$ nargo execute
+
+ [zkBank] Circuit witness successfully solved
+ [zkBank] Witness saved to target/zkBank.gz
+ [zkBank] Circuit output: (0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b, 0x0cfc0a67cb7308e4e9b254026b54204e34f6c8b041be207e64c5db77d95dd82d, 0x450cf9da6e180d6159290554ae3d8787, 0x6d8bc5a15b9037e52fb59b6b98722a85)
+ ```
+
+10. 将最后两个值与您在 Web 浏览器上看到的哈希进行比较，以查看消息是否已正确哈希。
+
+#### `server/noir/Prover.toml` {#server-noir-prover-toml}
+
+[此文件](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) 显示了 Noir 期望的信息格式。
+
+```toml
+message="send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 500 finney (milliEth) 0 "
+```
+
+消息采用文本格式，这使得用户易于理解（在签名时是必要的），也便于 Noir 代码解析。 金额以 finney 为单位，一方面可以实现小数额转账，另一方面也易于阅读。 最后一个数字是 [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce)。
+
+字符串长度为 100 个字符。 零知识证明不能很好地处理可变大小的数据，因此通常需要填充数据。
+
+```toml
+pubKeyX=["0x83",...,"0x75"]
+pubKeyY=["0x35",...,"0xa5"]
+signature=["0xb1",...,"0x0d"]
+```
+
+这三个参数是固定大小的字节数组。
+
+```toml
+[[accounts]]
+address="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+balance=100_000
+nonce=0
+
+[[accounts]]
+address="0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+balance=100_000
+nonce=0
+```
+
+这是指定结构数组的方式。 对于每个条目，我们指定地址、余额（以 milliETH 为单位，又称 [finney](https://cryptovalleyjournal.com/glossary/finney/)) 和下一个 nonce 值。
+
+#### `client/src/Transfer.tsx` {#client-src-transfer-tsx}
+
+[此文件](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/client/src/Transfer.tsx) 实现了客户端处理，并生成 `server/noir/Prover.toml` 文件（包含零知识参数的文件）。
+
+以下是更有趣部分的解释。
+
+```tsx
+export default attrs => {
+```
+
+此函数创建 `Transfer` React 组件，其他文件可以导入该组件。
+
+```tsx
+ const accounts = [
+ "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+ "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+ "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+ "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+ ]
+```
+
+这些是帐户地址，由 `test ...` test junk` 密码短语创建的地址。 如果您想使用自己的地址，只需修改此定义即可。
+
+```tsx
+ const account = useAccount()
+ const wallet = createWalletClient({
+ transport: custom(window.ethereum!)
+ })
+```
+
+这些 [Wagmi 钩子](https://wagmi.sh/react/api/hooks) 让我们能够访问 [viem](https://viem.sh/) 库和钱包。
+
+```tsx
+ const message = `send ${toAccount} ${ethAmount*1000} finney (milliEth) ${nonce}`.padEnd(100, " ")
+```
+
+这是用空格填充的消息。 每次 [`useState`](https://react.dev/reference/react/useState) 变量之一发生变化时，组件都会重新绘制，`message` 也会更新。
+
+```tsx
+ const sign = async () => {
+```
+
+当用户点击 **Sign** 按钮时，此函数将被调用。 消息会自动更新，但签名需要用户在钱包中批准，除非必要，否则我们不想请求它。
+
+```tsx
+ const signature = await wallet.signMessage({
+ account: fromAccount,
+ message,
+ })
+```
+
+要求钱包[签署消息](https://viem.sh/docs/accounts/local/signMessage)。
+
+```tsx
+ const hash = hashMessage(message)
+```
+
+获取消息哈希。 将其提供给用户以进行调试（Noir 代码的调试）会很有帮助。
+
+```tsx
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+[获取公钥](https://viem.sh/docs/utilities/recoverPublicKey)。 这是 [Noir `ecrecover`](https://github.com/colinnielsen/ecrecover-noir) 函数所必需的。
+
+```tsx
+ setSignature(signature)
+ setHash(hash)
+ setPubKey(pubKey)
+```
+
+设置状态变量。 这样做会重新绘制组件（在 `sign` 函数退出后）并向用户显示更新后的值。
+
+```tsx
+ let proverToml = `
+```
+
+`Prover.toml` 的文本。
+
+```tsx
+message="${message}"
+
+pubKeyX=${hexToArray(pubKey.slice(4,4+2*32))}
+pubKeyY=${hexToArray(pubKey.slice(4+2*32))}
+```
+
+Viem 以 65 字节十六进制字符串的形式为我们提供公钥。 第一个字节是 `0x04`，一个版本标记。 后面是公钥的 `x` 的 32 个字节，然后是公钥的 `y` 的 32 个字节。
+
+然而，Noir 期望以两个字节数组的形式获取此信息，一个用于 `x`，一个用于 `y`。 在客户端解析它比在零知识证明中解析它更容易。
+
+请注意，这通常是零知识中的良好实践。 零知识证明内部的代码是昂贵的，因此任何可以在零知识证明外部完成的处理_都应该_在零知识证明外部完成。
+
+```tsx
+signature=${hexToArray(signature.slice(2,-2))}
+```
+
+签名也以 65 字节的十六进制字符串形式提供。 但是，最后一个字节仅用于恢复公钥。 由于公钥已经提供给 Noir 代码，我们不需要它来验证签名，Noir 代码也不需要它。
+
+```tsx
+${accounts.map(accountInProverToml).reduce((a,b) => a+b, "")}
+`
+```
+
+提供帐户。
+
+```tsx
+ setProverToml(proverToml)
+ }
+
+ return (
+ <>
+ 转账
+```
+
+这是组件的 HTML（更准确地说，是 [JSX](https://react.dev/learn/writing-markup-with-jsx)）格式。
+
+#### `server/noir/src/main.nr` {#server-noir-src-main-nr}
+
+[此文件](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr)是实际的零知识代码。
+
+```
+use std::hash::pedersen_hash;
+```
+
+[Pedersen 哈希](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/)由 [Noir 标准库](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash)提供。 零知识证明通常使用此哈希函数。 与标准哈希函数相比，在[算术电路](https://rareskills.io/post/arithmetic-circuit)中计算要容易得多。
+
+```
+use keccak256::keccak256;
+use dep::ecrecover;
+```
+
+这两个函数是外部库，在 [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml) 中定义。 它们的功能正如其名，一个函数用于计算 [keccak256 哈希](https://emn178.github.io/online-tools/keccak_256.html)，另一个函数用于验证以太坊签名并恢复签名者的以太坊地址。
+
+```
+global ACCOUNT_NUMBER : u32 = 5;
+```
+
+Noir 受到了 [Rust](https://www.rust-lang.org/) 的启发。 默认情况下，变量是常量。 这就是我们定义全局配置常量的方式。 具体来说，`ACCOUNT_NUMBER` 是我们存储的帐户数量。
+
+`u` 命名的数据类型是该位数的无符号整数。 唯一支持的类型是 `u8`、`u16`、`u32`、`u64` 和 `u128`。
+
+```
+global FLAT_ACCOUNT_FIELDS : u32 = 2;
+```
+
+如下文所述，此变量用于帐户的 Pedersen 哈希。
+
+```
+global MESSAGE_LENGTH : u32 = 100;
+```
+
+如上所述，消息长度是固定的。 在此处指定。
+
+```
+global ASCII_MESSAGE_LENGTH : [u8; 3] = [0x31, 0x30, 0x30];
+global HASH_BUFFER_SIZE : u32 = 26+3+MESSAGE_LENGTH;
+```
+
+[EIP-191 签名](https://eips.ethereum.org/EIPS/eip-191) 需要一个带有 26 字节前缀的缓冲区，后跟 ASCII 格式的消息长度，最后是消息本身。
+
+```
+struct Account {
+ balance: u128,
+ address: Field,
+ nonce: u32,
+}
+```
+
+我们存储的关于一个帐户的信息。 [`Field`](https://noir-lang.org/docs/noir/concepts/data_types/fields) 是一个数字，通常最多 253 位，可以直接用于实现零知识证明的[算术电路](https://rareskills.io/post/arithmetic-circuit)。 这里我们使用 `Field` 来存储一个 160 位的以太坊地址。
+
+```
+struct TransferTxn {
+ from: Field,
+ to: Field,
+ amount: u128,
+ nonce: u32
+}
+```
+
+我们为一笔转账交易存储的信息。
+
+```
+fn flatten_account(account: Account) -> [Field; FLAT_ACCOUNT_FIELDS] {
+```
+
+一个函数定义。 参数是 `Account` 信息。 结果是一个 `Field` 变量数组，其长度为 `FLAT_ACCOUNT_FIELDS`
+
+```
+ let flat = [
+ account.address,
+ ((account.balance << 32) + account.nonce.into()).into(),
+ ];
+```
+
+数组中的第一个值是帐户地址。 第二个值包括余额和 nonce。 `.into()` 调用将数字更改为所需的数据类型。 `account.nonce` 是一个 `u32` 值，但要将其加到 `account.balance « 32`（一个 `u128` 值）上，它需要是一个 `u128`。 这是第一个 `.into()`。 第二个将 `u128` 结果转换为一个 `Field`，以便它能放入数组中。
+
+```
+ flat
+}
+```
+
+在 Noir 中，函数只能在末尾返回值（没有提前返回）。 要指定返回值，您需要在函数的右括号之前对其进行求值。
+
+```
+fn flatten_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] {
+```
+
+此函数将帐户数组转换为 `Field` 数组，可用作 Petersen 哈希的输入。
+
+```
+ let mut flat: [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] = [0; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER];
+```
+
+这就是你指定一个可变变量的方式，也就是说，_不是_一个常量。 Noir 中的变量必须总有一个值，所以我们将这个变量初始化为全零。
+
+```
+ for i in 0..ACCOUNT_NUMBER {
+```
+
+这是一个 `for` 循环。 请注意，边界是常量。 Noir 循环必须在编译时知道其边界。 原因是算术电路不支持流控制。 在处理 `for` 循环时，编译器只是将循环内的代码多次放置，每次迭代一次。
+
+```
+ let fields = flatten_account(accounts[i]);
+ for j in 0..FLAT_ACCOUNT_FIELDS {
+ flat[i*FLAT_ACCOUNT_FIELDS + j] = fields[j];
+ }
+ }
+
+ flat
+}
+
+fn hash_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> Field {
+ pedersen_hash(flatten_accounts(accounts))
+}
+```
+
+最后，我们来到了哈希帐户数组的函数。
+
+```
+fn find_account(accounts: [Account; ACCOUNT_NUMBER], address: Field) -> u32 {
+ let mut account : u32 = ACCOUNT_NUMBER;
+
+ for i in 0..ACCOUNT_NUMBER {
+ if accounts[i].address == address {
+ account = i;
+ }
+ }
+```
+
+此函数查找具有特定地址的帐户。 在标准代码中，此函数会非常低效，因为它会遍历所有帐户，即使在找到地址之后也是如此。
+
+然而，在零知识证明中，没有流控制。 如果我们需要检查一个条件，我们必须每次都检查它。
+
+`if` 语句也会发生类似的情况。 上面循环中的 `if` 语句被翻译成这些数学语句。
+
+_conditionresult = accounts[i].address == address_ // 如果相等则为 1，否则为 0
+
+_accountnew = conditionresult\*i + (1-conditionresult)\*accountold_
+
+```rust
+ assert (account < ACCOUNT_NUMBER, f"{address} does not have an account");
+
+ account
+}
+```
+
+如果断言为假，[`assert`](https://noir-lang.org/docs/dev/noir/concepts/assert) 函数会导致零知识证明崩溃。 在这种情况下，如果我们找不到具有相关地址的帐户。 要报告地址，我们使用[格式化字符串](https://noir-lang.org/docs/noir/concepts/data_types/strings#format-strings)。
+
+```rust
+fn apply_transfer_txn(accounts: [Account; ACCOUNT_NUMBER], txn: TransferTxn) -> [Account; ACCOUNT_NUMBER] {
+```
+
+此函数应用转账交易并返回新的帐户数组。
+
+```rust
+ let from = find_account(accounts, txn.from);
+ let to = find_account(accounts, txn.to);
+
+ let (txnFrom, txnAmount, txnNonce, accountNonce) =
+ (txn.from, txn.amount, txn.nonce, accounts[from].nonce);
+```
+
+在 Noir 中，我们无法在格式字符串内访问结构元素，因此我们创建了一个可用的副本。
+
+```rust
+ assert (accounts[from].balance >= txn.amount,
+ f"{txnFrom} does not have {txnAmount} finney");
+
+ assert (accounts[from].nonce == txn.nonce,
+ f"Transaction has nonce {txnNonce}, but the account is expected to use {accountNonce}");
+```
+
+这是两个可能使交易无效的条件。
+
+```rust
+ let mut newAccounts = accounts;
+
+ newAccounts[from].balance -= txn.amount;
+ newAccounts[from].nonce += 1;
+ newAccounts[to].balance += txn.amount;
+
+ newAccounts
+}
+```
+
+创建新的帐户数组，然后返回它。
+
+```rust
+fn readAddress(messageBytes: [u8; MESSAGE_LENGTH]) -> Field
+```
+
+该函数从消息中读取地址。
+
+```rust
+{
+ let mut result : Field = 0;
+
+ for i in 7..47 {
+```
+
+地址总是 20 字节（又名 40 个十六进制数字）长，从第 7 个字符开始。
+
+```rust
+ result *= 0x10;
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ result += (messageBytes[i]-48).into();
+ }
+ if messageBytes[i] >= 65 & messageBytes[i] <= 70 { // A-F
+ result += (messageBytes[i]-65+10).into()
+ }
+ if messageBytes[i] >= 97 & messageBytes[i] <= 102 { // a-f
+ result += (messageBytes[i]-97+10).into()
+ }
+ }
+
+ result
+}
+
+fn readAmountAndNonce(messageBytes: [u8; MESSAGE_LENGTH]) -> (u128, u32)
+```
+
+从消息中读取金额和 nonce。
+
+```rust
+{
+ let mut amount : u128 = 0;
+ let mut nonce: u32 = 0;
+ let mut stillReadingAmount: bool = true;
+ let mut lookingForNonce: bool = false;
+ let mut stillReadingNonce: bool = false;
+```
+
+在消息中，地址之后的第一个数字是 finney（又称 千分之一 ETH）的转账金额。 第二个数字是 nonce。 它们之间的任何文本都将被忽略。
+
+```rust
+ for i in 48..MESSAGE_LENGTH {
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ let digit = (messageBytes[i]-48);
+
+ if stillReadingAmount {
+ amount = amount*10 + digit.into();
+ }
+
+ if lookingForNonce { // 我们刚找到它
+ stillReadingNonce = true;
+ lookingForNonce = false;
+ }
+
+ if stillReadingNonce {
+ nonce = nonce*10 + digit.into();
+ }
+ } else {
+ if stillReadingAmount {
+ stillReadingAmount = false;
+ lookingForNonce = true;
+ }
+ if stillReadingNonce {
+ stillReadingNonce = false;
+ }
+ }
+ }
+
+ (amount, nonce)
+}
+```
+
+返回一个[元组](https://noir-lang.org/docs/noir/concepts/data_types/tuples)是从函数返回多个值的 Noir 方式。
+
+```rust
+fn readTransferTxn(message: str) -> TransferTxn
+{
+ let mut txn: TransferTxn = TransferTxn { from: 0, to: 0, amount:0, nonce:0 };
+ let messageBytes = message.as_bytes();
+
+ txn.to = readAddress(messageBytes);
+ let (amount, nonce) = readAmountAndNonce(messageBytes);
+ txn.amount = amount;
+ txn.nonce = nonce;
+
+ txn
+}
+```
+
+此函数将消息转换为字节，然后将金额转换为 `TransferTxn`。
+
+```rust
+// 相当于 Viem 的 hashMessage
+// https://viem.sh/docs/utilities/hashMessage#hashmessage
+fn hashMessage(message: str) -> [u8;32] {
+```
+
+我们能够对帐户使用 Pedersen 哈希，因为它们只在零知识证明内部进行哈希。 然而，在此代码中，我们需要检查由浏览器生成的消息签名。 为此，我们需要遵循 [EIP 191](https://eips.ethereum.org/EIPS/eip-191) 中的以太坊签名格式。 这意味着我们需要创建一个组合缓冲区，其中包含标准前缀、ASCII 格式的消息长度和消息本身，并使用以太坊标准 keccak256 对其进行哈希。
+
+```rust
+ // ASCII 前缀
+ let prefix_bytes = [
+ 0x19, // \x19
+ 0x45, // 'E'
+ 0x74, // 't'
+ 0x68, // 'h'
+ 0x65, // 'e'
+ 0x72, // 'r'
+ 0x65, // 'e'
+ 0x75, // 'u'
+ 0x6D, // 'm'
+ 0x20, // ' '
+ 0x53, // 'S'
+ 0x69, // 'i'
+ 0x67, // 'g'
+ 0x6E, // 'n'
+ 0x65, // 'e'
+ 0x64, // 'd'
+ 0x20, // ' '
+ 0x4D, // 'M'
+ 0x65, // 'e'
+ 0x73, // 's'
+ 0x73, // 's'
+ 0x61, // 'a'
+ 0x67, // 'g'
+ 0x65, // 'e'
+ 0x3A, // ':'
+ 0x0A // '\n'
+ ];
+```
+
+为避免应用程序要求用户签署可用作交易或其他用途的消息的情况，EIP 191 规定所有已签名的消息都以字符 0x19（不是有效的 ASCII 字符）开头，后跟 `Ethereum Signed Message:` 和一个换行符。
+
+```rust
+ let mut buffer: [u8; HASH_BUFFER_SIZE] = [0u8; HASH_BUFFER_SIZE];
+ for i in 0..26 {
+ buffer[i] = prefix_bytes[i];
+ }
+
+ let messageBytes : [u8; MESSAGE_LENGTH] = message.as_bytes();
+
+ if MESSAGE_LENGTH <= 9 {
+ for i in 0..1 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+1] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 10 & MESSAGE_LENGTH <= 99 {
+ for i in 0..2 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+2] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 100 {
+ for i in 0..3 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+3] = messageBytes[i];
+ }
+ }
+
+ assert(MESSAGE_LENGTH < 1000, "Messages whose length is over three digits are not supported");
+```
+
+处理长度最多为 999 的消息，如果大于此长度则失败。 我添加了此代码，尽管消息长度是常量，但这样做可以更容易地更改它。 在生产系统上，为了更好的性能，您可能会假设 `MESSAGE_LENGTH` 不会改变。
+
+```rust
+ keccak256::keccak256(buffer, HASH_BUFFER_SIZE)
+}
+```
+
+使用以太坊标准 `keccak256` 函数。
+
+```rust
+fn signatureToAddressAndHash(
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64]
+ ) -> (Field, Field, Field) // 地址、哈希的前 16 个字节、哈希的后 16 个字节
+{
+```
+
+此函数验证签名，这需要消息哈希。 然后，它为我们提供签名地址和消息哈希。 消息哈希以两个 `Field` 值的形式提供，因为它们在程序的其余部分比字节数组更容易使用。
+
+我们需要使用两个 `Field` 值，因为字段计算是对一个大数进行[模](https://en.wikipedia.org/wiki/Modulo)运算，但该数字通常小于 256 位（否则很难在 EVM 中执行这些计算）。
+
+```rust
+ let hash = hashMessage(message);
+
+ let mut (hash1, hash2) = (0,0);
+
+ for i in 0..16 {
+ hash1 = hash1*256 + hash[31-i].into();
+ hash2 = hash2*256 + hash[15-i].into();
+ }
+```
+
+将 `hash1` 和 `hash2` 指定为可变变量，并逐字节将哈希写入其中。
+
+```rust
+ (
+ ecrecover::ecrecover(pubKeyX, pubKeyY, signature, hash),
+```
+
+这类似于 [Solidity 的 `ecrecover`](https://docs.soliditylang.org/en/v0.8.30/cheatsheet.html#mathematical-and-cryptographic-functions)，但有两个重要区别：
+
+- 如果签名无效，调用会失败一个 `assert` 并中止程序。
+- 虽然可以从签名和哈希中恢复公钥，但这是可以在外部完成的处理，因此不值得在零知识证明中进行。 如果有人在这里试图欺骗我们，签名验证将会失败。
+
+```rust
+ hash1,
+ hash2
+ )
+}
+
+fn main(
+ accounts: [Account; ACCOUNT_NUMBER],
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64],
+ ) -> pub (
+ Field, // 旧帐户数组的哈希
+ Field, // 新帐户数组的哈希
+ Field, // 消息哈希的前 16 个字节
+ Field, // 消息哈希的后 16 个字节
+ )
+```
+
+最后，我们到达 `main` 函数。 我们需要证明我们有一笔交易，可以有效地将帐户哈希从旧值更改为新值。 我们还需要证明它具有此特定的交易哈希，以便发送者知道他们的交易已处理。
+
+```rust
+{
+ let mut txn = readTransferTxn(message);
+```
+
+我们需要 `txn` 是可变的，因为我们不是从消息中读取“from”地址，而是从签名中读取。
+
+```rust
+ let (fromAddress, txnHash1, txnHash2) = signatureToAddressAndHash(
+ message,
+ pubKeyX,
+ pubKeyY,
+ signature);
+
+ txn.from = fromAddress;
+
+ let newAccounts = apply_transfer_txn(accounts, txn);
+
+ (
+ hash_accounts(accounts),
+ hash_accounts(newAccounts),
+ txnHash1,
+ txnHash2
+ )
+}
+```
+
+### 阶段 2 - 添加服务器 {#stage-2}
+
+在第二阶段，我们添加一个服务器，用于接收和实现来自浏览器的转账交易。
+
+要查看实际操作：
+
+1. 如果 Vite 正在运行，请停止它。
+
+2. 下载包含服务器的分支，并确保您拥有所有必需的模块。
+
+ ```sh
+ git checkout 02-add-server
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+ 无需编译 Noir 代码，它与您在阶段 1 中使用的代码相同。
+
+3. 启动服务器。
+
+ ```sh
+ npm run start
+ ```
+
+4. 在单独的命令行窗口中，运行 Vite 以提供浏览器代码。
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+5. 浏览到客户端代码 [http://localhost:5173](http://localhost:5173)
+
+6. 在您发出交易之前，您需要知道 nonce 以及您可以发送的金额。 要获取此信息，请单击 **Update account data** 并签署消息。
+
+ 我们在这里遇到了一个两难的境地。 一方面，我们不希望签署可以重复使用的消息（[重放攻击](https://en.wikipedia.org/wiki/Replay_attack)），这就是我们首先需要 nonce 的原因。 但是，我们还没有 nonce。 解决方案是选择一个只能使用一次且双方都已有的 nonce，例如当前时间。
+
+ 这个解决方案的问题在于时间可能不完全同步。 因此，我们改为签署一个每分钟都会变化的值。 这意味着我们受到重放攻击的漏洞窗口最多为一分钟。 考虑到在生产环境中，已签名的请求将受到 TLS 的保护，并且隧道的另一端——服务器——已经可以泄露余额和 nonce（它必须知道这些才能工作），这是一个可以接受的风险。
+
+7. 一旦浏览器取回余额和 nonce，它就会显示转账表单。 选择目标地址和金额，然后单击 **Transfer**。 签署此请求。
+
+8. 要查看转账，请**更新帐户数据**或查看运行服务器的窗口。 服务器每次状态更改时都会记录日志。
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ Listening on port 3000
+ Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 36000 finney (milliEth) 0 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 64000 (1)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 100000 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ Txn send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 7200 finney (milliEth) 1 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 56800 (2)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 3000 finney (milliEth) 2 processed
+ New state:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 53800 (3)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 has 139000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-1}
+
+[此文件](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/index.mjs) 包含服务器进程，并与 [`main.nr`](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/noir/src/main.nr) 中的 Noir 代码进行交互。 以下是一些有趣部分的解释。
+
+```js
+import { Noir } from '@noir-lang/noir_js'
+```
+
+[noir.js](https://www.npmjs.com/package/@noir-lang/noir_js) 库是 JavaScript 代码和 Noir 代码之间的接口。
+
+```js
+const circuit = JSON.parse(await fs.readFile("./noir/target/zkBank.json"))
+const noir = new Noir(circuit)
+```
+
+加载算术电路——我们在前一阶段创建的已编译 Noir 程序——并准备执行它。
+
+```js
+// 我们只在收到已签名请求时提供帐户信息
+const accountInformation = async signature => {
+ const fromAddress = await recoverAddress({
+ hash: hashMessage("Get account data " + Math.floor((new Date().getTime())/60000)),
+ signature
+ })
+```
+
+要提供帐户信息，我们只需要签名。 原因是，我们已经知道消息会是什么，因此也知道了消息哈希。
+
+```js
+const processMessage = async (message, signature) => {
+```
+
+处理一条消息并执行它编码的交易。
+
+```js
+ // 获取公钥
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+现在我们在服务器上运行 JavaScript，我们可以在服务器上而不是在客户端上检索公钥。
+
+```js
+ let noirResult
+ try {
+ noirResult = await noir.execute({
+ message,
+ signature: signature.slice(2,-2).match(/.{2}/g).map(x => `0x${x}`),
+ pubKeyX,
+ pubKeyY,
+ accounts: Accounts
+ })
+```
+
+`noir.execute` 运行 Noir 程序。 这些参数等同于 [`Prover.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) 中提供的参数。 请注意，长值以十六进制字符串数组（`["0x60", "0xA7"]`）的形式提供，而不是像 Viem 那样以单个十六进制值（`0x60A7`）的形式提供。
+
+```js
+ } catch (err) {
+ console.log(`Noir error: ${err}`)
+ throw Error("Invalid transaction, not processed")
+ }
+```
+
+如果出现错误，捕获它，然后将简化版本中继到客户端。
+
+```js
+ Accounts[fromAccountNumber].nonce++
+ Accounts[fromAccountNumber].balance -= amount
+ Accounts[toAccountNumber].balance += amount
+```
+
+应用交易。 我们已经在 Noir 代码中做过了，但在这里再做一次比从那里提取结果更容易。
+
+```js
+let Accounts = [
+ {
+ address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ balance: 5000,
+ nonce: 0,
+ },
+```
+
+初始的 `Accounts` 结构。
+
+### 阶段 3 - 以太坊智能合约 {#stage-3}
+
+1. 停止服务器和客户端进程。
+
+2. 下载包含智能合约的分支，并确保您拥有所有必需的模块。
+
+ ```sh
+ git checkout 03-smart-contracts
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+3. 在单独的命令行窗口中运行 `anvil`。
+
+4. 生成验证密钥和 solidity 验证器，然后将验证器代码复制到 Solidity 项目。
+
+ ```sh
+ cd noir
+ bb write_vk -b ./target/zkBank.json -o ./target --oracle_hash keccak
+ bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
+ cp target/Verifier.sol ../../smart-contracts/src
+ ```
+
+5. 转到智能合约并设置环境变量以使用 `anvil` 区块链。
+
+ ```sh
+ cd ../../smart-contracts
+ export ETH_RPC_URL=http://localhost:8545
+ ETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+ ```
+
+6. 部署 `Verifier.sol` 并将地址存储在环境变量中。
+
+ ```sh
+ VERIFIER_ADDRESS=`forge create src/Verifier.sol:HonkVerifier --private-key $ETH_PRIVATE_KEY --optimize --broadcast | awk '/Deployed to:/ {print $3}'`
+ echo $VERIFIER_ADDRESS
+ ```
+
+7. 部署 `ZkBank` 合约。
+
+ ```sh
+ ZKBANK_ADDRESS=`forge create ZkBank --private-key $ETH_PRIVATE_KEY --broadcast --constructor-args $VERIFIER_ADDRESS 0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b | awk '/Deployed to:/ {print $3}'`
+ echo $ZKBANK_ADDRESS
+ ```
+
+ `0x199..67b` 值是 `Accounts` 初始状态的 Pederson 哈希。 如果您在 `server/index.mjs` 中修改此初始状态，您可以运行一个交易来查看零知识证明报告的初始哈希。
+
+8. 运行服务器。
+
+ ```sh
+ cd ../server
+ npm run start
+ ```
+
+9. 在不同的命令行窗口中运行客户端。
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+10. 运行一些交易。
+
+11. 要验证链上状态是否已更改，请重新启动服务器进程。 可以看到 `ZkBank` 不再接受交易，因为交易中的原始哈希值与链上存储的哈希值不同。
+
+ 这是预期的错误类型。
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ Listening on port 3000
+ Verification error: ContractFunctionExecutionError: The contract function "processTransaction" reverted with the following reason:
+ Wrong old state hash
+
+ Contract Call:
+ address: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
+ function: processTransaction(bytes _proof, bytes32[] _publicInputs)
+ args: (0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf00000000000000000000000000000000000000000000000b75c020998797da7800000000000000000000000000000000000000000000000
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-2}
+
+此文件中的更改主要与创建实际证明并将其提交到链上有关。
+
+```js
+import { exec } from 'child_process'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+```
+
+我们需要使用 [Barretenberg 包](https://github.com/AztecProtocol/aztec-packages/tree/next/barretenberg)来创建要发送到链上的实际证明。 我们可以通过运行命令行界面 (`bb`) 或使用 [JavaScript 库 `bb.js`](https://www.npmjs.com/package/@aztec/bb.js) 来使用此包。 JavaScript 库比本地运行代码慢得多，所以我们在这里使用 [`exec`](https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback) 来使用命令行。
+
+请注意，如果您决定使用 `bb.js`，您需要使用与您正在使用的 Noir 版本兼容的版本。 在撰写本文时，当前的 Noir 版本 (1.0.0-beta.11) 使用 `bb.js` 版本 0.87。
+
+```js
+const zkBankAddress = process.env.ZKBANK_ADDRESS || "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
+```
+
+这里的地址是您在从干净的 `anvil` 开始并按照上述说明操作时获得的地址。
+
+```js
+const walletClient = createWalletClient({
+ chain: anvil,
+ transport: http(),
+ account: privateKeyToAccount("0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6")
+})
+```
+
+此私钥是 `anvil` 中的默认预资助帐户之一。
+
+```js
+const generateProof = async (witness, fileID) => {
+```
+
+使用 `bb` 可执行文件生成证明。
+
+```js
+ const fname = `witness-${fileID}.gz`
+ await fs.writeFile(fname, witness)
+```
+
+将见证写入文件。
+
+```js
+ await execPromise(`bb prove -b ./noir/target/zkBank.json -w ${fname} -o ${fileID} --oracle_hash keccak --output_format fields`)
+```
+
+实际创建证明。 此步骤还会创建一个包含公共变量的文件，但我们不需要它。 我们已经从 `noir.execute` 获得了这些变量。
+
+```js
+ const proof = "0x" + JSON.parse(await fs.readFile(`./${fileID}/proof_fields.json`)).reduce((a,b) => a+b, "").replace(/0x/g, "")
+```
+
+证明是 `Field` 值的 JSON 数组，每个值都表示为十六进制值。 然而，我们需要在交易中以单个 `bytes` 值的形式发送它，Viem 将其表示为一个大的十六进制字符串。 在这里，我们通过连接所有值、删除所有 `0x`，然后在末尾添加一个来更改格式。
+
+```js
+ await execPromise(`rm -r ${fname} ${fileID}`)
+
+ return proof
+}
+```
+
+清理并返回证明。
+
+```js
+const processMessage = async (message, signature) => {
+ .
+ .
+ .
+
+ const publicFields = noirResult.returnValue.map(x=>'0x' + x.slice(2).padStart(64, "0"))
+```
+
+公共字段需要是 32 字节值的数组。 然而，由于我们需要在两个 `Field` 值之间划分交易哈希，它显示为一个 16 字节的值。 在这里，我们添加零，以便 Viem 将其理解为实际的 32 字节。
+
+```js
+ const proof = await generateProof(noirResult.witness, `${fromAddress}-${nonce}`)
+```
+
+每个地址只使用一次每个 nonce，这样我们就可以使用 `fromAddress` 和 `nonce` 的组合作为见证文件和输出目录的唯一标识符。
+
+```js
+ try {
+ await zkBank.write.processTransaction([
+ proof, publicFields])
+ } catch (err) {
+ console.log(`Verification error: ${err}`)
+ throw Error("Can't verify the transaction onchain")
+ }
+ .
+ .
+ .
+}
+```
+
+将交易发送到链上。
+
+#### `smart-contracts/src/ZkBank.sol` {#smart-contracts-src-zkbank-sol}
+
+这是接收交易的链上代码。
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.21;
+
+import {HonkVerifier} from "./Verifier.sol";
+
+contract ZkBank {
+ HonkVerifier immutable myVerifier;
+ bytes32 currentStateHash;
+
+ constructor(address _verifierAddress, bytes32 _initialStateHash) {
+ currentStateHash = _initialStateHash;
+ myVerifier = HonkVerifier(_verifierAddress);
+ }
+```
+
+链上代码需要跟踪两个变量：验证器（由 `nargo` 创建的独立合约）和当前状态哈希。
+
+```solidity
+ event TransactionProcessed(
+ bytes32 indexed transactionHash,
+ bytes32 oldStateHash,
+ bytes32 newStateHash
+ );
+```
+
+每次状态更改时，我们都会发出一个 `TransactionProcessed` 事件。
+
+```solidity
+ function processTransaction(
+ bytes calldata _proof,
+ bytes32[] calldata _publicFields
+ ) public {
+```
+
+此函数处理交易。 它以验证器要求的格式获取证明（作为 `bytes`）和公共输入（作为 `bytes32` 数组），以最小化链上处理并因此降低燃料成本。
+
+```solidity
+ require(_publicInputs[0] == currentStateHash,
+ "Wrong old state hash");
+```
+
+零知识证明需要证明交易将我们当前的哈希更改为一个新的哈希。
+
+```solidity
+ myVerifier.verify(_proof, _publicFields);
+```
+
+调用验证器合约以验证零知识证明。 如果零知识证明错误，此步骤将回滚交易。
+
+```solidity
+ currentStateHash = _publicFields[1];
+
+ emit TransactionProcessed(
+ _publicFields[2]<<128 | _publicFields[3],
+ _publicFields[0],
+ _publicFields[1]
+ );
+ }
+}
+```
+
+如果一切检查无误，则将状态哈希更新为新值，并发出一个 `TransactionProcessed` 事件。
+
+## 中心化组件的滥用 {#abuses}
+
+信息安全包括三个属性：
+
+- _机密性_，用户不能读取他们无权读取的信息。
+- _完整性_，信息不能被未经授权的用户以未经授权的方式更改。
+- _可用性_，授权用户可以使用系统。
+
+在此系统中，完整性通过零知识证明提供。 可用性更难保证，而机密性则不可能，因为银行必须知道每个帐户的余额和所有交易。 无法阻止拥有信息的实体共享该信息。
+
+使用[隐身地址](https://vitalik.eth.limo/general/2023/01/20/stealth.html)可能可以创建一个真正机密的银行，但这超出了本文的范围。
+
+### 虚假信息 {#false-info}
+
+服务器违反完整性的一种方式是在[请求数据](https://github.com/qbzzt/250911-zk-bank/blob/03-smart-contracts/server/index.mjs#L278-L291)时提供虚假信息。
+
+为了解决这个问题，我们可以编写第二个 Noir 程序，该程序接收帐户作为私有输入，并接收请求信息的地址作为公共输入。 输出是该地址的余额和 nonce，以及帐户的哈希。
+
+当然，此证明无法在链上验证，因为我们不希望在链上发布 nonce 和余额。 但是，它可以通过在浏览器中运行的客户端代码进行验证。
+
+### 强制交易 {#forced-txns}
+
+在 L2 上确保可用性和防止审查的通常机制是[强制交易](https://docs.optimism.io/stack/transactions/forced-transaction)。 但强制交易无法与零知识证明相结合。 服务器是唯一可以验证交易的实体。
+
+我们可以修改 `smart-contracts/src/ZkBank.sol` 以接受强制交易，并防止服务器在处理它们之前更改状态。 然而，这使我们面临简单的拒绝服务攻击。 如果强制交易无效，因此无法处理怎么办？
+
+解决方案是提供一个零知识证明，证明强制交易无效。 这为服务器提供了三个选项：
+
+- 处理强制交易，提供零知识证明，证明其已处理并且生成了新的状态哈希。
+- 拒绝强制交易，并向合约提供零知识证明，证明交易无效（未知地址、错误的 nonce 或余额不足）。
+- 忽略强制交易。 无法强制服务器实际处理交易，但这意味着整个系统都不可用。
+
+#### 可用性保证金 {#avail-bonds}
+
+在实际实现中，维持服务器运行可能存在某种利润动机。 我们可以通过让服务器发布可用性保证金来加强这种激励，如果在一定时期内未处理强制交易，任何人都可以销毁该保证金。
+
+### 错误的 Noir 代码 {#bad-noir-code}
+
+通常，为了让人们信任智能合约，我们会将源代码上传到[区块浏览器](https://eth.blockscout.com/address/0x7D16d2c4e96BCFC8f815E15b771aC847EcbDB48b?tab=contract)。 然而，在零知识证明的情况下，这是不够的。
+
+`Verifier.sol` 包含验证密钥，它是 Noir 程序的一个函数。 然而，该密钥并不能告诉我们 Noir 程序是什么。 要真正拥有一个可信的解决方案，您需要上传 Noir 程序（以及创建它的版本）。 否则，零知识证明可能反映了不同的程序，一个带有后门的程序。
+
+在区块浏览器开始允许我们上传和验证 Noir 程序之前，您应该自己动手（最好上传到 [IPFS](/developers/tutorials/ipfs-decentralized-ui/)）。 然后，高级用户将能够下载源代码，自己编译，创建 `Verifier.sol`，并验证它与链上的版本完全相同。
+
+## 结论 {#conclusion}
+
+Plasma 类型的应用程序需要一个中心化组件作为信息存储。 这带来了潜在的漏洞，但作为回报，它允许我们以区块链本身无法实现的方式保护隐私。 通过零知识证明，我们可以确保完整性，并可能使运行中心化组件的任何人在经济上更有利于维护可用性。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
+
+## 致谢 {#acknowledgements}
+
+- Josh Crites 阅读了本文的草稿，并帮助我解决了一个棘手的 Noir 问题。
+
+任何剩余的错误都由我负责。
diff --git a/public/content/translations/zh/developers/tutorials/calling-a-smart-contract-from-javascript/index.md b/public/content/translations/zh/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
index d314fff16c9..9cb3c1db9f8 100644
--- a/public/content/translations/zh/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
+++ b/public/content/translations/zh/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
@@ -1,12 +1,8 @@
---
-title: 通过JavaScript调用智能合约
-description: 以DAI代币为例展示如何通过JavaScript调用智能合约函数
+title: "通过 JavaScript 调用智能合约"
+description: "以 DAI 代币为例，介绍如何通过 JavaScript 调用智能合约函数"
author: jdourlens
-tags:
- - "交易"
- - "前端"
- - "JavaScript"
- - "web3.js"
+tags: [ "交易", "前端", "JavaScript", "web3.js" ]
skill: beginner
lang: zh
published: 2020-04-19
@@ -15,15 +11,15 @@ sourceUrl: https://ethereumdev.io/calling-a-smart-contract-from-javascript/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
---
-在本教程中，我们将会看到如何通过JavaScript调用[智能合约](/developers/docs/smart-contracts/)。 首先读取智能合约的状态（例如：ERC20持有者的余额），然后通过代币转账修改区块链的状态。 你首先需要了解[设置JS环境与区块链交互](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/)。
+在本教程中，我们将了解如何通过 JavaScript 调用[智能合约](/developers/docs/smart-contracts/)函数。 首先是读取智能合约的状态（例如，ERC20 持有者的余额），然后我们将通过代币转账来修改区块链的状态。 你应该已经熟悉[如何设置 JS 环境来与区块链交互](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/)。
-在本例中，我们将使用DAI代币，基于测试目的，我们将使用ganache-cli分叉区块链并解锁一个已经拥有很多DAI的地址。
+在本例中，我们将使用 DAI 代币。为了进行测试，我们将使用 ganache-cli 分叉区块链，并解锁一个已有很多 DAI 的地址：
```bash
ganache-cli -f https://mainnet.infura.io/v3/[YOUR INFURA KEY] -d -i 66 1 --unlock 0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81
```
-要与智能合约交互，我们需要它的地址和ABI：
+要与智能合约交互，我们需要它的地址和 ABI：
```js
const ERC20TransferABI = [
@@ -74,9 +70,9 @@ const ERC20TransferABI = [
const DAI_ADDRESS = "0x6b175474e89094c44da98b954eedeac495271d0f"
```
-对于此项目，我们剥离完整的ERC20 ABI ，仅保留`balanceOf`和`transfer`函数，不过你可以在这里获取完整的[ERC20 ABI](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/)。
+在这个项目中，我们删除了完整的 ERC20 ABI，只保留了 `balanceOf` 和 `transfer` 函数，但你可以[在这里找到完整的 ERC20 ABI](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/)。
-然后我们需要实例化我们的智能合约：
+然后我们需要实例化智能合约：
```js
const web3 = new Web3("http://localhost:8545")
@@ -84,23 +80,23 @@ const web3 = new Web3("http://localhost:8545")
const daiToken = new web3.eth.Contract(ERC20TransferABI, DAI_ADDRESS)
```
-我们还会设置两个地址：
+我们还将设置两个地址：
-- 一个接受转账
-- 一个已经解锁并将发送
+- 接收转账的一方，以及
+- 我们已解锁的、将发送转账的一方：
```js
const senderAddress = "0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81"
const receiverAddress = "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
```
-在下一部分中，我们会调用 `balance Of` 函数来检索当前的代币数量，此时这两个地址的代币数量都被冻结。
+在下一部分中，我们将调用 `balanceOf` 函数来检索这两个地址当前持有的代币数量。
## 调用：从智能合约读取值 {#call-reading-value-from-a-smart-contract}
-第一个例子，将调用“常量（constant）”方法并且在EVM中执行这个智能合约方法，并不发送任何交易。 为此我们将读取一个地址的ECR20余额。 [阅读关于 ECR20 代币的文章](/developers/tutorials/understand-the-erc-20-token-smart-contract/)。
+第一个示例将调用一个“常量”方法，并在 EVM 中执行其智能合约方法，而无需发送任何交易。 为此，我们将读取一个地址的 ERC20 余额。 [阅读我们关于 ERC20 代币的文章](/developers/tutorials/understand-the-erc-20-token-smart-contract/)。
-你可以访问为其提供 ABI 的实例化智能合约方法，如下所示：`yourContract.methods.methodname`。 通过使用`call`函数，你可以接收执行函数的结果。
+你可以按如下方式访问你为其提供了 ABI 的实例化智能合约的方法：`yourContract.methods.methodname`。 通过使用 `call` 函数，你将收到执行该函数的结果。
```js
daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
@@ -112,11 +108,11 @@ daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
})
```
-请记住，DAI ERC20有18位小数，这意味着你需要移除18个零才能获得正确的数额。 uint256 将以字符串形式返回，因为 Javascript 不处理大数值。 如果不确定，请了解我们关于bignumber.js的教程[如何在JS中处理大数](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/)。
+请记住，DAI ERC20 有 18 位小数，这意味着你需要去掉 18 个零才能得到正确的金额。 由于 JavaScript 不处理大数值，`uint256` 会作为字符串返回。 如果你不确定[如何在 JS 中处理大数，请查看我们关于 bignumber.js 的教程](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/)。
-## 发送：将交易发送给智能合约函数 {#send-sending-a-transaction-to-a-smart-contract-function}
+## 发送：向智能合约函数发送交易 {#send-sending-a-transaction-to-a-smart-contract-function}
-对于第二个示例，我们将调用DAI智能合约的transfer函数，发送10个DAI到第二个地址。 transfer函数接受两个参数：收件人地址和转账代币的数量：
+在第二个示例中，我们将调用 DAI 智能合约的 `transfer` 函数，向我们的第二个地址发送 10 个 DAI。 `transfer` 函数接受两个参数：接收方地址和要转账的代币数量：
```js
daiToken.methods
@@ -130,6 +126,6 @@ daiToken.methods
})
```
-调用函数返回将被在区块链中挖矿(mine) 的交易的哈希。 在以太坊中，交易哈希是可以预测的 - 这里是我们在执行前获得交易哈希值的方法([了解如何计算哈希](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction))。
+该函数调用返回交易的哈希，该交易将被挖矿并加入区块链。 在以太坊上，交易哈希是可预测的——因此我们可以在交易执行前就得到其哈希（[在此处了解如何计算哈希](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)）。
-因为该函数只向区块链提交交易，除非通过挖矿并包含在区块链中，否则我们无法看到结果。 在下一个教程中，我们将学习[如何通过了解其哈希值来等待一个交易在区块链上的执行](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/)。
+由于该函数只是将交易提交到区块链，因此只有当它被挖出并打包到区块链中时，我们才能看到结果。 在下一篇教程中，我们将学习[如何根据交易哈希等待其在区块链上执行](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/)。
diff --git a/public/content/translations/zh/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/zh/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
new file mode 100644
index 00000000000..13a78d5fcf2
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -0,0 +1,585 @@
+---
+title: "为您的合约构建用户界面"
+description: "我们将使用 TypeScript、React、Vite 和 Wagmi 等现代组件来构建一个现代但简约的用户界面，并学习如何将钱包连接到用户界面、调用智能合约来读取信息、向智能合约发送交易以及监控来自智能合约的事件以识别更改。"
+author: Ori Pomerantz
+tags: [ "typescript", "react", "vite", "wagmi", "前端" ]
+skill: beginner
+published: 2023-11-01
+lang: zh
+sidebarDepth: 3
+---
+
+您在以太坊生态系统中找到了我们需要的功能。 您编写了智能合约来实现它，甚至可能编写了一些在链下运行的相关代码。 太好了！ 遗憾的是，如果没有用户界面，您就不会有任何用户，而且您上一次编写网站时，人们还在使用拨号调制解调器，JavaScript 还是个新事物。
+
+本文就是为您准备的。 我假设您了解编程，或许还了解一些 JavaScript 和 HTML，但您的用户界面技能已经生疏和过时了。 我们将一起学习一个简单的现代应用，这样您就会知道现在是如何做的了。
+
+## 为何这很重要 {#why-important}
+
+理论上，您可以让人们使用 [Etherscan](https://holesky.etherscan.io/address/0x432d810484add7454ddb3b5311f0ac2e95cecea8#writeContract) 或 [Blockscout](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=write_contract) 与您的合约进行交互。 对于经验丰富的以太坊用户来说，这很好。 但我们正努力为[另外十亿人](https://blog.ethereum.org/2021/05/07/ethereum-for-the-next-billion)服务。 如果没有出色的用户体验，这是不可能实现的，而友好的用户界面是其中的重要组成部分。
+
+## Greeter 应用 {#greeter-app}
+
+现代 UI 的工作原理背后有很多理论，也有[很多不错的网站](https://react.dev/learn/thinking-in-react)[对此进行了解释](https://wagmi.sh/core/getting-started)。 我不会重复那些网站已经做得很好的工作，而是假设您更喜欢通过实践来学习，并从一个您可以上手的应用开始。 您仍然需要理论来完成工作，我们稍后会讲到这一点——我们将逐个源文件进行讲解，并在讲到时进行讨论。
+
+### 安装 {#installation}
+
+1. 如有必要，请将 [Holesky 区块链](https://chainlist.org/?search=holesky&testnets=true) 添加到您的钱包并[获取测试 ETH](https://www.holeskyfaucet.io/)。
+
+2. 克隆 github 仓库。
+
+ ```sh
+ git clone https://github.com/qbzzt/20230801-modern-ui.git
+ ```
+
+3. 安装必要的软件包。
+
+ ```sh
+ cd 20230801-modern-ui
+ pnpm install
+ ```
+
+4. 启动应用。
+
+ ```sh
+ pnpm dev
+ ```
+
+5. 浏览到应用显示的 URL。 在大多数情况下，该 URL 为 [http://localhost:5173/](http://localhost:5173/)。
+
+6. 您可以在[区块链浏览器](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=contract)上看到合约源代码，它是 Hardhat Greeter 的略微修改版本。
+
+### 文件演练 {#file-walk-through}
+
+#### `index.html` {#index-html}
+
+该文件是标准的 HTML 样板文件，但导入脚本文件的这一行除外。
+
+```html
+
+```
+
+#### `src/main.tsx` {#main-tsx}
+
+文件扩展名告诉我们，这是一个用 [TypeScript](https://www.typescriptlang.org/) 编写的 [React 组件](https://www.w3schools.com/react/react_components.asp)，TypeScript 是 JavaScript 的一个扩展，支持[类型检查](https://en.wikipedia.org/wiki/Type_system#Type_checking)。 TypeScript 被编译成 JavaScript，因此我们可以用它来进行客户端执行。
+
+```tsx
+import '@rainbow-me/rainbowkit/styles.css'
+import { RainbowKitProvider } from '@rainbow-me/rainbowkit'
+import * as React from 'react'
+import * as ReactDOM from 'react-dom/client'
+import { WagmiConfig } from 'wagmi'
+import { chains, config } from './wagmi'
+```
+
+导入我们需要的库代码。
+
+```tsx
+import { App } from './App'
+```
+
+导入实现该应用的 React 组件（见下文）。
+
+```tsx
+ReactDOM.createRoot(document.getElementById('root')!).render(
+```
+
+创建根 React 组件。 `render` 的参数是 [JSX](https://www.w3schools.com/react/react_jsx.asp)，这是一种同时使用 HTML 和 JavaScript/TypeScript 的扩展语言。 这里的感叹号告诉 TypeScript 组件：“你不知道 `document.getElementById('root')` 是否会是 `ReactDOM.createRoot` 的有效参数，但别担心——我是开发者，我告诉你它会是”。
+
+```tsx
+
+```
+
+该应用将放在 [一个 `React.StrictMode` 组件](https://react.dev/reference/react/StrictMode)中。 该组件告诉 React 库插入额外的调试检查，这在开发过程中很有用。
+
+```tsx
+
+```
+
+该应用也位于 [一个 `WagmiConfig` 组件](https://wagmi.sh/react/api/WagmiProvider)中。 [Wagmi (we are going to make it) 库](https://wagmi.sh/) 将 React UI 定义与 [viem 库](https://viem.sh/)连接起来，用于编写以太坊去中心化应用程序。
+
+```tsx
+
+```
+
+最后，还有[一个 `RainbowKitProvider` 组件](https://www.rainbowkit.com/)。 此组件处理登录以及钱包和应用之间的通信。
+
+```tsx
+
+
+ ,
+)
+```
+
+当然，我们必须关闭其他组件。
+
+#### `src/App.tsx` {#app-tsx}
+
+```tsx
+import { ConnectButton } from '@rainbow-me/rainbowkit'
+import { useAccount } from 'wagmi'
+import { Greeter } from './components/Greeter'
+
+export function App() {
+```
+
+这是创建 React 组件的标准方法——定义一个函数，每次需要渲染时都会调用该函数。 这个函数通常在顶部有一些 TypeScript 或 JavaScript 代码，然后是一个返回 JSX 代码的 `return` 语句。
+
+```tsx
+ const { isConnected } = useAccount()
+```
+
+这里我们使用 [`useAccount`](https://wagmi.sh/react/api/hooks/useAccount) 来检查我们是否通过钱包连接到区块链。
+
+按照惯例，在 React 中，名为 `use...` 的函数是返回某种数据的 [hooks](https://www.w3schools.com/react/react_hooks.asp)。 当您使用此类挂钩时，您的组件不仅会获取数据，而且当该数据更改时，组件会使用更新后的信息重新渲染。
+
+```tsx
+ return (
+ <>
+```
+
+React 组件的 JSX _必须_返回一个组件。 当我们有多个组件并且没有任何东西可以"自然地"包装它们时，我们使用一个空组件 (`<> ... `) 将它们变成单个组件。
+
+```tsx
+ Greeter
+ = (evt) =>
+ setNewGreeting(evt.target.value)
+```
+
+这是新问候语输入字段发生变化时的事件处理程序。 类型 [`ChangeEventHandler`](https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forms_and_events/) 指定这是 HTML 输入元素值变化的处理器。 之所以使用 `` 部分，是因为这是一个[泛型类型](https://www.w3schools.com/typescript/typescript_basic_generics.php)。
+
+```tsx
+ const preparedTx = usePrepareContractWrite({
+ address: greeterAddr,
+ abi: greeterABI,
+ functionName: 'setGreeting',
+ args: [ newGreeting ]
+ })
+ const workingTx = useContractWrite(preparedTx.config)
+```
+
+这是从客户端角度提交区块链交易的过程：
+
+1. 使用 [`eth_estimateGas`](https://docs.alchemy.com/reference/eth-estimategas) 将交易发送到区块链中的一个节点。
+2. 等待节点的响应。
+3. 收到响应后，请用户通过钱包签署交易。 这一步_必须_在收到节点响应后进行，因为在签名之前，用户会看到交易的 gas 成本。
+4. 等待用户批准。
+5. 再次发送交易，这次使用 [`eth_sendRawTransaction`](https://docs.alchemy.com/reference/eth-sendrawtransaction)。
+
+第 2 步可能会花费一段可感知的时间，在此期间，用户会想知道他们的命令是否真的被用户界面接收到，以及为什么还没有要求他们签署交易。 这会造成糟糕的用户体验 (UX)。
+
+解决方案是使用[准备钩子](https://wagmi.sh/react/prepare-hooks)。 每次参数更改时，立即向节点发送 `eth_estimateGas` 请求。 然后，当用户实际想要发送交易时（在本例中，通过按**更新问候语**），gas 成本是已知的，用户可以立即看到钱包页面。
+
+```tsx
+ return (
+```
+
+现在我们终于可以创建要返回的实际 HTML 了。
+
+```tsx
+ <>
+ Greeter
+ {
+ !readResults.isError && !readResults.isLoading &&
+
+```
+
+创建一个 `ShowGreeting` 组件（在下面解释），但前提是问候语已成功从区块链中读取。
+
+```tsx
+
+```
+
+这是用户可以设置新问候语的输入文本字段。 每次用户按下一个键，我们都会调用 `greetingChange`，它会调用 `setNewGreeting`。 由于 `setNewGreeting` 来自 `useState` 钩子，它会导致 `Greeter` 组件再次渲染。 这意味着：
+
+- 我们需要指定 `value` 来保留新问候语的值，否则它将变回默认值，即空字符串。
+- 每次 `newGreeting` 更改时都会调用 `usePrepareContractWrite`，这意味着它在准备好的交易中总是会有最新的 `newGreeting`。
+
+```tsx
+
+```
+
+如果没有 `workingTx.write`，那么我们仍在等待发送问候语更新所需的信息，因此按钮是禁用的。 如果有一个 `workingTx.write` 值，那么这就是调用以发送交易的函数。
+
+```tsx
+
+ {attrs.name}
+
+ {JSON.stringify(attrs.object, null, 2)}
+```
+
+大多数字段都是使用 [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp) 显示的。
+
+```tsx
+
+ { funs.length > 0 &&
+ <>
+ Functions:
+
+```
+
+唯一的例外是函数，它不属于 [JSON 标准](https://www.json.org/json-en.html)，因此必须单独显示。
+
+```tsx
+ {funs.map((f, i) =>
+```
+
+在 JSX 中，`{` 花括号 `}` 内的代码被解释为 JavaScript。 然后，`(` 圆括号 `)` 内的代码再次被解释为 JSX。
+
+```tsx
+ (- {f}
)
+ )}
+```
+
+React 要求 [DOM 树](https://www.w3schools.com/js/js_htmldom.asp)中的标签具有不同的标识符。 这意味着同一标签（在本例中为[无序列表](https://www.w3schools.com/tags/tag_ul.asp)）的子标签需要不同的 `key` 属性。
+
+```tsx
+
+
+ }
+
+
+}
+```
+
+结束各种 HTML 标签。
+
+##### 最终的 `export` {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+`Greeter` 组件是我们需要为应用导出的组件。
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+最后，与 WAGMI 相关的各种定义都在 `src/wagmi.ts` 中。 我不会在这里解释所有内容，因为其中大部分是您不太可能需要更改的样板代码。
+
+这里的代码与[在 github 上](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts)的代码不完全相同，因为在文章后面我们添加了另一条链（[Redstone Holesky](https://redstone.xyz/docs/network-info)）。
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+导入应用支持的区块链。 您可以在 [viem github](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions) 中查看支持的链的列表。
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+要使用 [WalletConnect](https://walletconnect.com/)，您需要为您的应用提供一个项目 ID。 您可以在 [cloud.walletconnect.com](https://cloud.walletconnect.com/sign-in) 上获取。
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia ],
+ [
+ publicProvider(),
+ ],
+)
+
+const { connectors } = getDefaultWallets({
+ appName: 'My wagmi + RainbowKit App',
+ chains,
+ projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+ autoConnect: true,
+ connectors,
+ publicClient,
+ webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### 添加另一个区块链 {#add-blockchain}
+
+如今有很多 [L2 扩容解决方案](/layer-2/)，您可能想支持一些 viem 尚不支持的方案。 要做到这一点，您需要修改 `src/wagmi.ts`。 这些说明解释了如何添加 [Redstone Holesky](https://redstone.xyz/docs/network-info)。
+
+1. 从 viem 导入 `defineChain` 类型。
+
+ ```ts
+ import { defineChain } from 'viem'
+ ```
+
+2. 添加网络定义。
+
+ ```ts
+ const redstoneHolesky = defineChain({
+ id: 17_001,
+ name: 'Redstone Holesky',
+ network: 'redstone-holesky',
+ nativeCurrency: {
+ decimals: 18,
+ name: 'Ether',
+ symbol: 'ETH',
+ },
+ rpcUrls: {
+ default: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ public: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ },
+ blockExplorers: {
+ default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+ },
+ })
+ ```
+
+3. 将新链添加到 `configureChains` 调用中。
+
+ ```ts
+ const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia, redstoneHolesky ],
+ [ publicProvider(), ],
+ )
+ ```
+
+4. 确保应用知道您在新网络上的合约地址。 在这种情况下，我们修改 `src/components/Greeter.tsx`：
+
+ ```ts
+ const contractAddrs : AddressPerBlockchainType = {
+ // Holesky
+ 17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+ // Redstone Holesky
+ 17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+
+ // Sepolia
+ 11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+ }
+ ```
+
+## 结论 {#conclusion}
+
+当然，您并不真正关心为 `Greeter` 提供用户界面。 您想为自己的合约创建用户界面。 要创建您自己的应用，请执行以下步骤：
+
+1. 指定创建 wagmi 应用。
+
+ ```sh copy
+ pnpm create wagmi
+ ```
+
+2. 为应用命名。
+
+3. 选择 **React** 框架。
+
+4. 选择 **Vite** 变体。
+
+5. 您可以[添加 Rainbow kit](https://www.rainbowkit.com/docs/installation#manual-setup)。
+
+现在去为您的合约创造一个全世界都能使用的界面吧。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
+
diff --git a/public/content/translations/zh/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/zh/developers/tutorials/deploying-your-first-smart-contract/index.md
index 95dffc887cf..6cd21974f77 100644
--- a/public/content/translations/zh/developers/tutorials/deploying-your-first-smart-contract/index.md
+++ b/public/content/translations/zh/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -1,12 +1,8 @@
---
-title: 部署第一个智能合约
-description: 介绍如何在以太坊测试网络上部署你第一个智能合约
+title: "部署你的第一个智能合约"
+description: "介绍如何在以太坊测试网上部署您的第一个智能合约"
author: "jdourlens"
-tags:
- - "智能合约"
- - "remix"
- - "solidity"
- - "deploying"
+tags: [ "智能合同", "remix", "Solidity", "部署" ]
skill: beginner
lang: zh
published: 2020-04-03
@@ -15,17 +11,17 @@ sourceUrl: https://ethereumdev.io/deploying-your-first-smart-contract/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
---
-我猜你和我们一样会很兴奋在以太坊区块链上[部署](/developers/docs/smart-contracts/deploying/)[智能合约](/developers/docs/smart-contracts/)并与之交互。
+我们想必您和我们一样兴奋，即将在以太坊区块链上[部署](/developers/docs/smart-contracts/deploying/)并与您的第一个[智能合约](/developers/docs/smart-contracts/)交互。
-别担心，作为我们的第一个智能合约，我们会将其部署在[本地测试网络](/developers/docs/networks/)上，因此你不需要任何开销就可以随意部署和运行它。
+别担心，由于这是我们的第一个智能合约，我们会将其部署在[本地测试网](/developers/docs/networks/)上，因此您不需要任何开销就可以随意部署和运行它。
## 编写合约 {#writing-our-contract}
-第一步[访问Remix](https://remix.ethereum.org/)并创建一个新文件。 在Remix界面的左上角添加一个新文件，并输入所需的文件名。
+第一步是[访问 Remix](https://remix.ethereum.org/) 并创建一个新文件。 在 Remix 界面的左上角，添加一个新文件并输入您想要的文件名。
-
+
-在这个新文件中，我们将粘贴如下代码：
+在新文件中，我们将粘贴以下代码。
```solidity
// SPDX-License-Identifier: MIT
@@ -33,15 +29,15 @@ pragma solidity >=0.5.17;
contract Counter {
- // Public variable of type unsigned int to keep the number of counts
+ // 用于记录计数的无符号整数类型的公共变量
uint256 public count = 0;
- // Function that increments our counter
+ // 递增计数器的函数
function increment() public {
count += 1;
}
- // Not necessary getter to get the count value
+ // 用于获取计数值的非必要 getter 函数
function getCount() public view returns (uint256) {
return count;
}
@@ -49,51 +45,51 @@ contract Counter {
}
```
-如果你曾经写过程序，应该可以轻松猜到这个程序是做什么的。 下面按行解释：
+如果您有编程经验，应该可以轻松猜出这个程序是做什么的。 下面是逐行解释：
- 第 4 行：我们定义了一个名为 `Counter` 的合约。
-- 第 7 行：我们的合约存储了一个无符号整型 `count`，从 0 开始。
-- 第 10 行：第一个函数将修改合约的状态，并使用 `increment()` 递增我们的变量 `count`。
-- 第 15 行，第二个函数就是一个取值器，能够从智能合约外部读取 `count` 变量的值。 请注意，因为我们将 `count` 变量定义为公共变量，所以这个函数是不必要的，但它可以作为一个例子展示。
+- 第 7 行：我们的合约存储了一个名为 `count` 的无符号整数，初始值为 0。
+- 第 10 行：第一个函数会修改合约的状态，并调用 `increment()` 来递增我们的变量 `count`。
+- 第 15 行：第二个函数只是一个取值器，用于在智能合约外部读取 `count` 变量的值。 请注意，由于我们将 `count` 变量定义为 public，这个函数不是必需的，但这里用作示例。
-第一个简单的智能合约到此结束。 正如你所知，它看上去像是 Java 或 C++ 这样的面向对象编程 (OOP) 语言中的一个类。 现在可以运行我们的合约了。
+我们第一个简单的智能合约就是这样。 您可能知道，它看起来像 Java 或 C++ 等 OOP（面向对象编程）语言中的类。 现在是时候体验我们的合约了。
## 部署合约 {#deploying-our-contract}
-当我们写了第一个智能合约后，我们现在可以将它部署在区块链中并运行它。
+我们已经编写了第一个智能合约，现在要将它部署到区块链上进行体验。
-[在区块链上部署智能合约](/developers/docs/smart-contracts/deploying/)实际上只是发送了一个包含已编译智能合约代码的交易，并且没有指定任何收件人。
+在区块链上[部署智能合约](/developers/docs/smart-contracts/deploying/)实际上只是发送一笔包含已编译智能合约代码且未指定任何接收者的交易。
-我们首先点击左侧的编译图标来[编译合约](/developers/docs/smart-contracts/compiling/)：
+我们首先通过点击左侧的编译图标来[编译合约](/developers/docs/smart-contracts/compiling/)：
-
+
然后点击编译按钮：
-
+
-你可以选择“Auto compile”选项，这样在将合约内容保存到文本编辑器时合约也随之编译。
+您可以选择“Auto compile”选项，这样当您在文本编辑器中保存内容时，合约将始终被编译。
-然后切换到部署和运行交易屏幕：
+然后导航至“deploy and run transactions”屏幕：
-
+
-在“部署和运行交易”屏幕上，仔细检查显示的合约名称并点击“部署”。 正如你在页面顶部所见，当前环境是“JavaScript 虚拟机”，这意味着我们将在本地测试区块链上部署我们的智能合约并与之交互，以便能够更快地进行测试且无须支付任何费用。
+进入“deploy and run transactions”屏幕后，请再次确认您的合约名称已显示，然后点击 Deploy。 如您在页面顶部所见，当前环境是“JavaScript 虚拟机”，这意味着我们将在本地测试区块链上部署我们的智能合约并与之交互，以便能够更快地进行测试，且无须支付任何费用。
-
+
-点击“部署”按钮后，你可以看到合约在底部显示出来。 点击左侧的箭头展开，可以看到合约的内容。 这里有我们的变量`counter`、函数`increment()`和getter `getCounter()`。
+点击“Deploy”按钮后，您会看到您的合约出现在底部。 点击左边的箭头展开，这样就能看到我们合约的内容。 这里有我们的变量 `counter`、`increment()` 函数和 getter `getCounter()`。
-如果你点击`count`或`getCount`按钮，它将实际检索合约的`count`变量的内容，并显示出来。 因为我们尚未调用`increment`函数，它应该显示0。
+如果您点击 `count` 或 `getCount` 按钮，它将实际检索并显示合约的 `count` 变量的内容。 由于我们还没有调用 `increment` 函数，它应该显示 0。
-
+
-现在点击按钮来调用`increment`函数。 你可以在窗口底部看到交易产生的日志。 当按下检索数据按钮而非`increment`按钮时，你看到的日志有所不同。 这是因为读取区块链的数据不需要任何交易（写入）或费用。 因为只有修改区块链的状态需要进行交易。
+现在我们来点击按钮，调用 `increment` 函数。 您会在窗口底部看到已执行交易的日志。 您会发现，当您按下检索数据的按钮时，日志与按下 `increment` 按钮时的日志是不同的。 这是因为在区块链上读取数据不需要任何交易（写入）或费用。 因为只有修改区块链的状态才需要进行交易：
-在按下increment按钮后，将产生一个交易来调用我们的`increment()`函数，如果我们点击count或getCount按钮，将读取我们的智能合约的最新状态，count变量大于0。
+按下 increment 按钮后，会生成一个调用我们 `increment()` 函数的交易。之后，如果我们再点击 count 或 getCount 按钮，就会读取到智能合约的最新状态，其中的 count 变量值将大于 0。
-
+
-在下一个教程中，我们将论述[如何在智能合约中添加事件](/developers/tutorials/logging-events-smart-contracts/)。 记录事件是调试智能合约了解调用函数时所发生情况的方便方式。
+在下一篇教程中，我们将介绍[如何向您的智能合约添加事件](/developers/tutorials/logging-events-smart-contracts/)。 记录事件是调试您的智能合约和了解调用函数时发生的情况的便捷方式。
diff --git a/public/content/translations/zh/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/zh/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..b11c95cfb86
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,363 @@
+---
+title: "如何在本地多客户端测试网上开发和测试去中心化应用程序"
+description: "本指南将首先引导你完成实例化和配置多客户端本地以太坊测试网，然后使用该测试网部署和测试去中心化应用程序。"
+author: "Tedi Mitiku"
+tags: [ "客户端", "节点", "智能合同", "可组合性", "共识层", "执行层", "测试" ]
+skill: intermediate
+lang: zh
+published: 2023-04-11
+---
+
+## 简介 {#introduction}
+
+本指南将引导你完成实例化可配置的本地以太坊测试网、向其部署智能合约，以及使用该测试网对你的去中心化应用程序运行测试的整个过程。 本指南专为希望在部署到实时测试网或主网之前，根据不同的网络配置在本地开发和测试其去中心化应用程序的开发者而设计。
+
+在本指南中，你将：
+
+- 使用 [Kurtosis](https://www.kurtosis.com/) 和 [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) 实例化本地以太坊测试网，
+- 将 Hardhat 去中心化应用程序开发环境连接到本地测试网，以编译、部署和测试去中心化应用程序，以及
+- 配置本地测试网，包括节点数量和特定 EL/CL 客户端配对等参数，以便能够根据各种网络配置进行开发和测试工作。
+
+### 什么是 Kurtosis？ {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) 是一个可组合的构建系统，专为配置多容器测试环境而设计。 它专门帮助开发者创建需要动态设置逻辑的可复现环境，例如区块链测试网。
+
+在本指南中，Kurtosis eth-network-package 启动一个本地以太坊测试网，支持 [`geth`](https://geth.ethereum.org/) 执行层 (EL) 客户端，以及 [`teku`](https://consensys.io/teku)、[`lighthouse`](https://lighthouse.sigmaprime.io/) 和 [`lodestar`](https://lodestar.chainsafe.io/) 共识层 (CL) 客户端。 此软件包可作为 Hardhat Network、Ganache 和 Anvil 等框架中网络的可配置和可组合替代方案。 Kurtosis 为开发者提供了对其使用的测试网的更强控制力和灵活性，这也是 [以太坊基金会使用 Kurtosis 测试合并](https://www.kurtosis.com/blog/testing-the-ethereum-merge) 并继续使用它来测试网络升级的一个主要原因。
+
+## 设置 Kurtosis {#setting-up-kurtosis}
+
+在继续之前，请确保你已：
+
+- 在本地计算机上[安装并启动 Docker 引擎](https://docs.kurtosis.com/install/#i-install--start-docker)
+- [安装 Kurtosis 命令行界面](https://docs.kurtosis.com/install#ii-install-the-cli)（如果已安装命令行界面，则将其升级到最新版本）
+- 安装 [Node.js](https://nodejs.org/en)、[yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable) 和 [npx](https://www.npmjs.com/package/npx)（用于你的去中心化应用程序环境）
+
+## 实例化本地以太坊测试网 {#instantiate-testnet}
+
+要启动本地以太坊测试网，请运行：
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+注意：此命令使用 `--enclave` 标志将你的网络命名为： "local-eth-testnet"。
+
+Kurtosis 会在后台打印出它为解析、验证和执行指令而采取的步骤。 最后，你应该会看到类似如下的输出：
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name: local-eth-testnet
+UUID: 39372d756ae8
+Status: RUNNING
+Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+d4085a064230 cl-genesis-data
+1c62cb792e4c el-genesis-data
+bd60489b73a7 genesis-generation-config-cl
+b2e593fe5228 genesis-generation-config-el
+d552a54acf78 geth-prefunded-keys
+5f7e661eb838 prysm-password
+054e7338bb59 validator-keystore-0
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> RUNNING
+ metrics: 5054/tcp ->
+ tcp-discovery: 9000/tcp -> 127.0.0.1:54263
+ udp-discovery: 9000/udp -> 127.0.0.1:60470
+a8b6c926cdb4 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:54267 RUNNING
+ metrics: 5064/tcp ->
+d7b802f623e8 el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:54253 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:54251
+ tcp-discovery: 30303/tcp -> 127.0.0.1:54254
+ udp-discovery: 30303/udp -> 127.0.0.1:53834
+ ws: 8546/tcp -> 127.0.0.1:54252
+514a829c0a84 prelaunch-data-generator-1680646157905431468 STOPPED
+62bd62d0aa7a prelaunch-data-generator-1680646157915424301 STOPPED
+05e9619e0e90 prelaunch-data-generator-1680646157922872635 STOPPED
+
+```
+
+恭喜！ 你使用 Kurtosis 通过 Docker 实例化了一个本地以太坊测试网，其中包含一个 CL（`lighthouse`）和一个 EL 客户端（`geth`）。
+
+### 回顾 {#review-instantiate-testnet}
+
+在本节中，你执行了一个命令，指示 Kurtosis 使用[托管在 GitHub 上的 `eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) 在 Kurtosis [Enclave](https://docs.kurtosis.com/advanced-concepts/enclaves/) 中启动一个本地以太坊测试网。 在你的 enclave 中，你会找到“文件工件”和“用户服务”。
+
+你的 enclave 中的[文件工件](https://docs.kurtosis.com/advanced-concepts/files-artifacts/)包含用于引导 EL 和 CL 客户端的所有生成和使用的数据。 这些数据是使用 `prelaunch-data-generator` 服务创建的，该服务基于此 [Docker 镜像](https://github.com/ethpandaops/ethereum-genesis-generator)构建。
+
+用户服务显示在你的 enclave 中运行的所有容器化服务。 你会注意到，一个同时具有 EL 客户端和 CL 客户端的节点已被创建。
+
+## 将你的去中心化应用程序开发环境连接到本地以太坊测试网 {#connect-your-dapp}
+
+### 设置去中心化应用程序开发环境 {#set-up-dapp-env}
+
+现在你已经有了一个正在运行的本地测试网，你可以连接你的去中心化应用程序开发环境来使用你的本地测试网。 本指南将使用 Hardhat 框架将一个二十一点 (blackjack) 去中心化应用程序部署到你的本地测试网。
+
+要设置你的去中心化应用程序开发环境，克隆包含我们的示例去中心化应用程序的代码库并安装其依赖项，请运行：
+
+```python
+git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn
+```
+
+这里使用的 [smart-contract-example](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example) 文件夹包含使用 [Hardhat](https://hardhat.org/) 框架的去中心化应用程序开发者的典型设置：
+
+- [`contracts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/contracts) 包含一些用于二十一点 (Blackjack) 去中心化应用程序的简单智能合约
+- [`scripts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/scripts) 包含一个脚本，用于将代币合约部署到你的本地以太坊网络
+- [`test/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/test) 包含一个针对你的代币合约的简单 .js 测试，用于确认我们的二十一点 (Blackjack) 去中心化应用程序中的每个玩家都已铸造了 1000 枚代币
+- [`hardhat.config.ts`](https://github.com/kurtosis-tech/awesome-kurtosis/blob/main/smart-contract-example/hardhat.config.ts) 用于配置你的 Hardhat 设置
+
+### 配置 Hardhat 以使用本地测试网 {#configure-hardhat}
+
+设置好去中心化应用程序开发环境后，你现在将连接 Hardhat 以使用 Kurtosis 生成的本地以太坊测试网。 为此，请将你的 `hardhat.config.ts` 配置文件中 `localnet` 结构里的 `<$YOUR_PORT>` 替换为任何 `el-client-` 服务的 RPC URI 输出端口。 在本示例案例中，端口为 `64248`。 你的端口会有所不同。
+
+`hardhat.config.ts` 中的示例：
+
+```js
+localnet: {
+url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO：将 $YOUR_PORT 替换为以太坊网络 Kurtosis 包生成的节点 URI 的端口
+
+// 这些是与 eth-network-package 创建的预置资金的测试帐户关联的私钥
+//
+accounts: [
+ "ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
+ "48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
+ "7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
+ "b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
+ "df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
+ "7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
+ ],
+},
+```
+
+保存文件后，你的 Hardhat 去中心化应用程序开发环境就已连接到你的本地以太坊测试网！ 你可以通过运行以下命令来验证你的测试网是否正常工作：
+
+```python
+npx hardhat balances --network localnet
+```
+
+输出应如下所示：
+
+```python
+0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
+0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
+0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
+0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
+0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
+0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000
+```
+
+这证实了 Hardhat 正在使用你的本地测试网，并检测到由 `eth-network-package` 创建的预置资金的帐户。
+
+### 在本地部署和测试你的去中心化应用程序 {#deploy-and-test-dapp}
+
+在去中心化应用程序开发环境完全连接到本地以太坊测试网后，你现在可以使用本地测试网对你的去中心化应用程序运行开发和测试工作流。
+
+要编译和部署 `ChipToken.sol` 智能合约以进行本地原型设计和开发，请运行：
+
+```python
+npx hardhat compile
+npx hardhat run scripts/deploy.ts --network localnet
+```
+
+输出应如下所示：
+
+```python
+ChipToken 已部署到： 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d
+```
+
+现在尝试对你的本地去中心化应用程序运行 `simple.js` 测试，以确认我们的二十一点 (Blackjack) 去中心化应用程序中的每个玩家都铸造了 1000 枚代币：
+
+输出应如下所示：
+
+```python
+npx hardhat test --network localnet
+```
+
+输出应如下所示：
+
+```python
+ChipToken
+ mint
+ ✔ 应该为 PLAYER ONE 铸造 1000 个筹码
+
+ 1 个通过 (654ms)
+```
+
+### 回顾 {#review-dapp-workflows}
+
+至此，你已经设置好一个去中心化应用程序开发环境，将其连接到由 Kurtosis 创建的本地以太坊网络，并已对你的去中心化应用程序进行了编译、部署和简单测试。
+
+现在，让我们探讨如何配置底层网络，以便在不同的网络配置下测试我们的去中心化应用程序。
+
+## 配置本地以太坊测试网 {#configure-testnet}
+
+### 更改客户端配置和节点数量 {#configure-client-config-and-num-nodes}
+
+你的本地以太坊测试网可以配置为使用不同的 EL 和 CL 客户端对，以及不同数量的节点，具体取决于你想要开发或测试的场景和特定网络配置。 这意味着，一旦设置好，你就可以启动一个自定义的本地测试网，并用它来运行相同的工作流（部署、测试等）。 在各种网络配置下，以确保一切都按预期工作。 要了解有关可以修改的其他参数的更多信息，请访问此链接。
+
+试试看！ 你可以通过 JSON 文件将各种配置选项传递给 `eth-network-package`。 此网络参数 JSON 文件提供了 Kurtosis 将用于设置本地以太坊网络的具体配置。
+
+获取默认配置文件并对其进行编辑，以启动具有不同 EL/CL 对的三个节点：
+
+- 节点 1：`geth`/`lighthouse`
+- 节点 2：`geth`/`lodestar`
+- 节点 3：`geth`/`teku`
+
+此配置创建了一个由以太坊节点实现组成的异构网络，用于测试你的去中心化应用程序。 你的配置文件现在应如下所示：
+
+```yaml
+{
+ "participants":
+ [
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lighthouse",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lodestar",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "teku",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ ],
+ "network_params":
+ {
+ "preregistered_validator_keys_mnemonic": "giant issue aisle success illegal bike spike question tent bar rely arctic volcano long crawl hungry vocal artwork sniff fantasy very lucky have athlete",
+ "num_validator_keys_per_node": 64,
+ "network_id": "3151908",
+ "deposit_contract_address": "0x4242424242424242424242424242424242424242",
+ "seconds_per_slot": 12,
+ "genesis_delay": 120,
+ "capella_fork_epoch": 5,
+ },
+}
+```
+
+每个 `participants` 结构都映射到网络中的一个节点，因此 3 个 `participants` 结构将告诉 Kurtosis 在你的网络中启动 3 个节点。 每个 `participants` 结构都允许你指定用于该特定节点的 EL 和 CL 对。
+
+`network_params` 结构配置网络设置，这些设置用于为每个节点创建创世文件，以及网络的每时隙秒数等其他设置。
+
+将编辑后的参数文件保存在你希望的任何目录中（在下面的示例中，它保存在桌面上），然后通过运行以下命令来使用它运行你的 Kurtosis 包：
+
+```python
+kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"
+```
+
+注意：此处使用 `kurtosis clean -a` 命令来指示 Kurtosis 在启动新测试网之前销毁旧测试网及其内容。
+
+同样，Kurtosis 会运行一会并打印出正在执行的各个步骤。 最终，输出应如下所示：
+
+```python
+Starlark code successfully run. No output was returned.
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+INFO[2023-04-07T11:43:16-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+Name: local-eth-testnet
+UUID: bef8c192008e
+Status: RUNNING
+Creation Time: Fri, 07 Apr 2023 11:41:58 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+cc495a8e364a cl-genesis-data
+7033fcdb5471 el-genesis-data
+a3aef43fc738 genesis-generation-config-cl
+8e968005fc9d genesis-generation-config-el
+3182cca9d3cd geth-prefunded-keys
+8421166e234f prysm-password
+d9e6e8d44d99 validator-keystore-0
+23f5ba517394 validator-keystore-1
+4d28dea40b5c validator-keystore-2
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+485e6fde55ae cl-client-0-beacon http: 4000/tcp -> http://127.0.0.1:65010 RUNNING
+ metrics: 5054/tcp -> http://127.0.0.1:65011
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65012
+ udp-discovery: 9000/udp -> 127.0.0.1:54455
+73739bd158b2 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:65016 RUNNING
+ metrics: 5064/tcp -> http://127.0.0.1:65017
+1b0a233cd011 cl-client-1-beacon http: 4000/tcp -> 127.0.0.1:65021 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65023
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65024
+ udp-discovery: 9000/udp -> 127.0.0.1:56031
+ validator-metrics: 5064/tcp -> 127.0.0.1:65022
+949b8220cd53 cl-client-1-validator http: 4000/tcp -> 127.0.0.1:65028 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65030
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65031
+ udp-discovery: 9000/udp -> 127.0.0.1:60784
+ validator-metrics: 5064/tcp -> 127.0.0.1:65029
+c34417bea5fa cl-client-2 http: 4000/tcp -> 127.0.0.1:65037 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65035
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65036
+ udp-discovery: 9000/udp -> 127.0.0.1:63581
+e19738e6329d el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:64986 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64988
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64987
+ udp-discovery: 30303/udp -> 127.0.0.1:55706
+ ws: 8546/tcp -> 127.0.0.1:64989
+e904687449d9 el-client-1 engine-rpc: 8551/tcp -> 127.0.0.1:64993 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64995
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64994
+ udp-discovery: 30303/udp -> 127.0.0.1:58096
+ ws: 8546/tcp -> 127.0.0.1:64996
+ad6f401126fa el-client-2 engine-rpc: 8551/tcp -> 127.0.0.1:65003 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:65001
+ tcp-discovery: 30303/tcp -> 127.0.0.1:65000
+ udp-discovery: 30303/udp -> 127.0.0.1:57269
+ ws: 8546/tcp -> 127.0.0.1:65002
+12d04a9dbb69 prelaunch-data-generator-1680882122181135513 STOPPED
+5b45f9c0504b prelaunch-data-generator-1680882122192182847 STOPPED
+3d4aaa75e218 prelaunch-data-generator-1680882122201668972 STOPPED
+```
+
+恭喜！ 你已成功将本地测试网配置为 3 个节点，而不是 1 个。 要对你的去中心化应用程序运行与之前相同的工作流（部署和测试），请执行与之前相同的操作，将你的 `hardhat.config.ts` 配置文件中 `localnet` 结构里的 `<$YOUR_PORT>` 替换为新的 3 节点本地测试网中任何 `el-client-` 服务的 RPC URI 输出端口。
+
+## 结论 {#conclusion}
+
+就这些！ 回顾这篇简短的指南，你：
+
+- 使用 Kurtosis 通过 Docker 创建了一个本地以太坊测试网
+- 将你的本地去中心化应用程序开发环境连接到本地以太坊网络
+- 在本地以太坊网络上部署了一个去中心化应用程序并对其进行了简单测试
+- 将底层以太坊网络配置为 3 个节点
+
+我们很乐意听取你的意见，哪些方面做得好，哪些方面可以改进，或者回答你的任何问题。 请随时通过 [GitHub](https://github.com/kurtosis-tech/kurtosis/issues/new/choose) 或[发送电子邮件](mailto:feedback@kurtosistech.com)与我们联系！
+
+### 其他示例和指南 {#other-examples-guides}
+
+我们鼓励你查看我们的[快速入门](https://docs.kurtosis.com/quickstart)（你将在其中构建一个 Postgres 数据库和 API）以及我们 [awesome-kurtosis 代码库](https://github.com/kurtosis-tech/awesome-kurtosis)中的其他示例，你将在其中找到一些很棒的示例，包括用于以下用途的包：
+
+- [启动同一个本地以太坊测试网](https://github.com/kurtosis-tech/eth2-package)，但连接了额外的服务，例如交易垃圾信息发送器（用于模拟交易）、分叉监控器以及连接的 Grafana 和 Prometheus 实例
+- 对同一个本地以太坊网络执行[子网络测试](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/ethereum-network-partition-test)
diff --git a/public/content/translations/zh/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md b/public/content/translations/zh/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
index a9df421999e..8b4f1cf170d 100644
--- a/public/content/translations/zh/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
+++ b/public/content/translations/zh/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
@@ -1,12 +1,9 @@
---
title: "如何缩减合约以规避合约大小限制"
-description: 您可以做些什么避免智能合约变得太大？
+description: "你可以做些什么避免智能合约变得太大？"
author: Markus Waas
lang: zh
-tags:
- - "solidity"
- - "智能合约"
- - "存储"
+tags: [ "Solidity", "智能合同", "存储" ]
skill: intermediate
published: 2020-06-26
source: soliditydeveloper.com
@@ -15,46 +12,44 @@ sourceUrl: https://soliditydeveloper.com/max-contract-size
## 为什么会有限制？ {#why-is-there-a-limit}
-在 [2016 年 11 月 22 日](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)，伪龙硬分叉引入了 [EIP-170](https://eips.ethereum.org/EIPS/eip-170)，将智能合约的大小限制在 24.576 kb。 对于作为 Solidity 开发者的您来说，这意味着当您向合约中添加越来越多的功能时，在某个时候您会达到极限，并且在部署时会看到错误：
+在 [2016 年 11 月 22 日](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)，Spurious Dragon 硬分叉引入了 [EIP-170](https://eips.ethereum.org/EIPS/eip-170)，增加了 24.576 kb 的智能合约大小限制。 对于 Solidity 开发者来说，这意味着当你向合约中添加越来越多的功能时，在某个时候你会达到限制，并且在部署时会看到错误：
-`警告：合约代码大小超过 24576 字节（Spurious Dragon 分叉中引入的限制）。 该合约可能无法在主网上部署。 请考虑启用优化器（其“运行”值较低！），关闭 revert 字符串，或使用库。`
+`警告：合约代码大小超过 24576 字节（Spurious Dragon 分叉中引入的限制）。 该合约可能无法在主网上部署。 请考虑启用优化器（“运行”值较低！）、关闭 revert 字符串或使用程序库。`
-引入这一限制是为了防止拒绝服务 (DOS) 攻击。 任何对合约的调用从矿工费上来说都是相对便宜的。 然而，根据被调用合约代码的大小（从磁盘读取代码、预处理代码、将数据添加到 Merkle 证明），合约调用对以太坊节点的影响会不成比例地增加。 每当您出现这样的情况，攻击者只需要很少的资源就能给别人造成大量的工作，您就有可能遭受 DOS 攻击。
+引入这一限制是为了防止拒绝服务 (DOS) 攻击。 就燃料而言，对合约的任何调用都相对便宜。 然而，根据被调用合约代码的大小（从磁盘读取代码、预处理代码、将数据添加到 Merkle 证明），合约调用对以太坊节点的影响会不成比例地增加。 每当你出现这样的情况，攻击者只需要很少的资源就能给别人造成大量的工作，你就有可能遭受 DOS 攻击。
-最初，这不是什么大问题，因为一个自然合约大小限制是区块燃料限制。 显然，合约必须和其所有字节码一起部署在交易内。 如果只将单个交易添加到区块中，可能会用完所有燃料，而燃料并非无限。 [伦敦升级](/ethereum-forks/#london)后，区块燃料限制已能够根据网络需求在 15M 和 30M 单位之间变动。
+最初，这不是什么大问题，因为一个天然的合约大小限制就是区块燃料限制。 显然，合约必须和其所有字节码一起部署在交易内。 如果只将单个交易添加到区块中，可能会用完所有燃料，而燃料并非无限。 自从[伦敦升级](/ethereum-forks/#london)后，区块燃料限制便可根据网络需求在 15M 和 30M 单位之间变化。
-在下文中，我们将根据其潜在的影响顺序来研究一些方法。 从减肥的角度来谈一谈。 对于一个人来说，要达到他们的目标体重（在我们的例子中是 24 kb），最好的策略是首先关注影响较大的方法。 在大多数情况下，只要调整您的饮食就能达到目标，但有时您需要做得更多一些。 然后您可以增加一些锻炼（中等影响）或甚至补充剂（小影响）。
+在下文中，我们将根据其潜在的影响顺序来研究一些方法。 从减肥的角度来谈一谈。 对于一个人来说，要达到他们的目标体重（在我们的例子中是 24 kb），最好的策略是首先关注影响较大的方法。 在大多数情况下，只要调整你的饮食就能达到目标，但有时你需要做得更多一些。 然后你可以增加一些锻炼（中等影响）或甚至补充剂（小影响）。
-## 较大影响 {#big-impact}
+## 重大影响 {#big-impact}
-### 把合约分开 {#separate-your-contracts}
+### 拆分合约 {#separate-your-contracts}
-这应始终是您的第一个方法。 如何将合约分成多个较小的合约？ 一般来说，它会迫使您为您的合约想出一个好的架构。 从代码可读性的角度来看，较小的合约总是首选。 对于拆分合同，请问您自己：
+这应始终是你的首选方法。 如何将合约分成多个较小的合约？ 一般来说，它会迫使你为你的合约想出一个好的架构。 从代码可读性的角度来看，较小的合约总是首选。 对于拆分合约，问问你自己：
- 哪些函数属于同一类？ 每一组函数最好能在自己的合约中。
- 哪些函数不需要读取合约状态或仅需要读取状态的特定子集？
-- 您能把存储和功能分开吗？
+- 你能把存储和功能分开吗？
-### 使用库 {#libraries}
+### 程序库 {#libraries}
-将功能代码移出存储空间的一个简单方法是使用[库](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries)。 不要将库函数声明为内部函数，因为这些函数将在编译过程中直接被[添加到合约中](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking)。 但是，如果您使用公共函数，那么这些函数事实上将在一个单独的库合约中。 可以考虑使用命令 [using for](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for)，使库的使用更加方便。
+将功能代码与存储分离的一个简单方法是使用[程序库](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries)。 不要将程序库函数声明为 internal，因为它们会在编译期间直接[添加到合约中](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking)。 但是，如果你使用 public 函数，那么这些函数实际上会位于一个单独的程序库合约中。 考虑[使用 using for](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for) 使程序库的使用更加方便。
-### 使用代理 {#proxies}
+### 代理 {#proxies}
-一个更先进的策略是代理系统。 库在后台使用 `DELEGATECALL`，它只是用调用合约的状态执行另一个合约的函数。 查看[这篇博客文章](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2)来了解更多关于代理系统的信息。 它们可以为您提供了更多的功能，例如它们能够升级，但它们也增加了很多复杂性。 我不会仅仅为了减少合约的大小而增加这些东西，除非由于某种原因这是唯一的选择。
+一个更先进的策略是代理系统。 程序库在后台使用 `DELEGATECALL`，它只是用调用合约的状态来执行另一个合约的函数。 查看[这篇博文](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2)以了解更多关于代理系统的信息。 它们提供了更多功能（例如，支持可升级性），但同时也增加了很多复杂性。 我不会仅仅为了减少合约大小而添加这些，除非出于某种原因这是你唯一的选择。
## 中等影响 {#medium-impact}
### 移除函数 {#remove-functions}
-这一点应该是显而易见的， 即函数在一定程度上会增加合约的大小。
+这一点应该很明显。 函数会显著增加合约的大小。
-- **外部函数**：为了方便起见，我们常常添加大量视图函数。 这完全没有问题，直到您遇到大小限制。 然后，您可能需要真正考虑，移除绝对必要以外的所有内容。
-- **内部函数**：您也可以移除内部/ 私有函数，只要函数只被调用一次，就可以简单地内联代码。
+- **外部**：我们常常为了方便而添加许多视图函数。 这完全没问题，直到你达到大小限制。 这时，你可能就要认真考虑，只保留绝对必要的函数。
+- **Internal**：只要函数只被调用一次，你也可以移除 internal/private 函数，并直接内联代码。
-### 避免额外的变量 {#avoid-additional-variables}
-
-像这样一个简单的更改：
+### 避免使用额外的变量 {#avoid-additional-variables}
```solidity
function get(uint id) returns (address,address) {
@@ -69,30 +64,41 @@ function get(uint id) returns (address,address) {
}
```
-大小差异为** 0.28kb**。 您有可能在合约中找到许多类似的情况，这些情况加起来可以达到很大的数额。
+这样一个简单的改动就能产生 **0.28kb** 的差异。 你有可能在合约中找到许多类似的情况，这些情况加起来可以达到很大的数额。
### 缩短错误信息 {#shorten-error-message}
-长的恢复信息，尤其是许多不同的回滚消息可能会使合约变得臃肿。 相反，使用简短的错误代码，并在合约中对其进行解码。 一条长信息可以变得很短：
+过长的 revert 信息，特别是许多不同的 revert 信息，可能会使合约变得臃肿。 可以改用简短的错误代码，然后在你的客户端解码它们。 一条长信息可以变得短很多：
```solidity
-require(msg.sender == owner, "Only the owner of this contract can call this function");
-
+require(msg.sender == owner, "只有本合约的所有者才能调用此函数");
```
```solidity
require(msg.sender == owner, "OW1");
```
-### 在优化器中考虑一个低运行值 {#consider-a-low-run-value-in-the-optimizer}
+### 使用自定义错误代替错误信息
+
+[Solidity 0.8.4](https://blog.soliditylang.org/2021/04/21/custom-errors/) 引入了自定义错误。 它们是减小合约大小的极佳方法，因为它们和函数一样，被 ABI 编码为选择器。
+
+```solidity
+error Unauthorized();
+
+if (msg.sender != owner) {
+ revert Unauthorized();
+}
+```
+
+### 考虑在优化器中使用较低的运行值 {#consider-a-low-run-value-in-the-optimizer}
-您也可以更改优化器设置。 默认值为 200，表示它试图在一个函数被调用 200 次的情况下优化字节码。 如果您将其改为 1，相当于告诉优化器针对每个函数只运行一次的情况进行优化。 一个仅运行一次的优化函数意味着它对部署本身进行了优化。 请注意，**这将会增加运行函数的 [gas 成本](/developers/docs/gas/)**，所以，您可能不想这样做。
+你也可以更改优化器设置。 默认值为 200，表示它试图在一个函数被调用 200 次的情况下优化字节码。 如果将其更改为 1，基本上就是告诉优化器针对每个函数只运行一次的情况进行优化。 一个仅运行一次的优化函数意味着它对部署本身进行了优化。 请注意，**这会增加运行函数的[燃料成本](/developers/docs/gas/)**，所以你可能不希望这样做。
-## 轻微的影响 {#small-impact}
+## 较小影响 {#small-impact}
### 避免将结构体传递给函数 {#avoid-passing-structs-to-functions}
-如果您正在使用 [ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2)，它可以帮助您不将结构体传递给函数。 不会将参数作为结构体传递...
+如果你正在使用 [ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2)，不将结构体传递给函数会有所帮助。 不要将参数作为结构体传递，而是直接传递所需的参数。 在这个例子中，我们又节省了 **0.1kb**。
```solidity
function get(uint id) returns (address,address) {
@@ -114,16 +120,14 @@ function _get(address addr1, address addr2) private view returns(address,address
}
```
-... 而是直接传递所需参数。 在此示例中，我们又节省了 **0.1kb**。
-
-### 声明函数和变量的正确可见性 {#declare-correct-visibility-for-functions-and-variables}
+### 为函数和变量声明正确的可见性 {#declare-correct-visibility-for-functions-and-variables}
-- 函数或变量仅从外部调用？ 那么，将他们声明为 `external` 而不是 `public`。
-- 函数或变量仅从合约内调用？ 那么，将它们声明为 `private` 或 `internal` 而不是 `public`。
+- 函数或变量只从外部调用？ 将它们声明为 `external` 而不是 `public`。
+- 函数或变量只从合约内部调用？ 将它们声明为 `private` 或 `internal` 而不是 `public`。
-### 移除修改器 {#remove-modifiers}
+### 移除修饰符 {#remove-modifiers}
-修改器，尤其是在密集使用的情况下，可能会对合约大小产生重大影响。 可以考虑移除它们，而改用函数。
+修饰符，尤其是在密集使用的情况下，可能会对合约大小产生重大影响。 可以考虑移除它们，改用函数。
```solidity
modifier checkStuff() {}
@@ -137,4 +141,4 @@ function checkStuff() private {}
function doSomething() { checkStuff(); }
```
-这些提示应有助您大幅度减少合约的大小。 我要再次强调的是，如果可能的话，务必将重点放在拆分合约上，以获得最大的效果。
+这些技巧应该能帮助你显著减小合约的大小。 我要再次强调的是，如果可能的话，务必将重点放在拆分合约上，以获得最大的效果。
diff --git a/public/content/translations/zh/developers/tutorials/eip-1271-smart-contract-signatures/index.md b/public/content/translations/zh/developers/tutorials/eip-1271-smart-contract-signatures/index.md
index 8a1eda2b413..6c5d1038884 100644
--- a/public/content/translations/zh/developers/tutorials/eip-1271-smart-contract-signatures/index.md
+++ b/public/content/translations/zh/developers/tutorials/eip-1271-smart-contract-signatures/index.md
@@ -1,13 +1,9 @@
---
title: "EIP-1271：签署和验证智能合约签名"
-description: 基于 EIP-1271 的智能合约签名生成与验证概述。 我们还介绍了 Safe（原 Gnosis Safe）中使用的 EIP-1271 实现，以此为智能合约开发者提供一个可参考的具体例子。
+description: "基于 EIP-1271 的智能合约签名生成与验证概述。 我们还介绍了 Safe（原 Gnosis Safe）中使用的 EIP-1271 实现，以此为智能合约开发者提供一个可参考的具体例子。"
author: Nathan H. Leung
lang: zh
-tags:
- - "eip-1271"
- - "智能合约"
- - "验证"
- - "签名"
+tags: [ "eip-1271", "智能合同", "验证", "签署" ]
skill: intermediate
published: 2023-01-12
---
@@ -24,7 +20,7 @@ published: 2023-01-12
1. 信息：“我想用我的以太坊钱包登录这个网站”
2. 签名者：我的地址是 `0x000…`
-3. 证明：这里有一些证明，证明我，`0x000…`，确实创建了这整条信息（通常会加密）。
+3. 证明：这里有一些证据，证明我 `0x000…` 确实创建了这整条信息（这通常是加密的）。
值得注意的是，数字签名包括“信息”和“签名”两部分。
@@ -36,11 +32,11 @@ published: 2023-01-12
要在基于以太坊的区块链上创建数字签名，通常需要一个别人不知道的秘密私钥。 这样，你的签名才是你的（如果其他人不知道密钥，则无法创建相同的签名）。
-你的以太坊帐户（即你的外部帐户/EOA）有一个与之关联的私钥，这是通常在网站或去中心化应用程序要求你签名时使用的私钥（例如“使用以太坊登录”）。
+你的以太坊帐户（即你的外部持有帐户/EOA）有一个与之关联的私钥，当网站或去中心化应用程序要求你签名时（例如，用于“通过以太坊登录”），通常会使用此私钥。
-应用程序可以在[不知道你的私钥](https://en.wikipedia.org/wiki/Public-key_cryptography)的情况下[验证你使用 ethers.js 等第三方库创建的签名](https://docs.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum)，并且确认_你_是那个创建签名的人。
+应用程序可以使用 ethers.js 等第三方库来[验证你创建的签名](https://www.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum)，同时[无需知道你的私钥](https://en.wikipedia.org/wiki/Public-key_cryptography)，并确信签名是由_你_创建的。
-> 事实上，由于外部帐户数字签名使用公钥加密，可以在**链下**生成和验证! 这就是无燃料去中心化自治组织投票的工作原理—并非在链上提交投票，而是使用加密库在链下创建和验证数字签名。
+> 事实上，由于 EOA 数字签名使用公钥密码学，它们可以在**链下**生成和验证！ 这就是免 Gas 的 DAO 投票的运作方式 — 无需在链上提交投票，而是使用加密库在链下创建和验证数字签名。
虽然外部帐户帐户有私钥，但智能合约帐户没有任何类型的私钥或密钥（因此“使用以太坊登录”等自然不适用于智能合约帐户）。
@@ -50,13 +46,13 @@ EIP-1271 旨在解决：如果智能合约没有可以合并到签名中的密
智能合约没有可用于签署信息的私钥。 那么，我们如何辨别签名的真伪呢？
-有一种想法是，我们可以直接_询问_智能合约签名是否真实！
+嗯，有一个想法是，我们可以直接_询问_智能合约签名是否真实！
EIP-1271 所做的就是将“询问”智能合约给定签名是否有效这一想法标准化。
实现 EIP-1271 的合约必须有一个名为 `isValidSignature` 的函数，该函数接收信息和签名。 然后，合约可以运行一些验证逻辑（规范并没有在此强制执行任何特定内容），然后返回一个表示签名是否有效的值。
-如果 `isValidSignature` 返回表示签名有效的结果，这就相当于合约在说“是的，我承认这个签名和信息！”
+如果 `isValidSignature` 返回有效的结果，那基本上就是合约在说“是的，我批准这个签名 + 信息！”
### 接口
@@ -71,13 +67,13 @@ contract ERC1271 {
bytes4 constant internal MAGICVALUE = 0x1626ba7e;
/**
- * @dev Should return whether the signature provided is valid for the provided hash
- * @param _hash Hash of the data to be signed
- * @param _signature Signature byte array associated with _hash
+ * @dev 应返回所提供的签名对于所提供的哈希是否有效
+ * @param _hash 待签名数据的哈希值
+ * @param _signature 与 _hash 关联的签名字节数组
*
- * MUST return the bytes4 magic value 0x1626ba7e when function passes.
- * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
- * MUST allow external calls
+ * 函数通过时必须返回 bytes4 魔术值 0x1626ba7e。
+ * 不得修改状态（solc < 0.5 使用 STATICCALL，solc > 0.5 使用 view 修饰符）
+ * 必须允许外部调用
*/
function isValidSignature(
bytes32 _hash,
@@ -90,28 +86,28 @@ contract ERC1271 {
## EIP-1271 实现示例：安全
-合约可通过多种方式实现 `isValidSignature`—规范本身对具体实现没有做出太多要求。
+合约可通过多种方式实现 `isValidSignature` — 规范本身对具体实现没有做出太多要求。
实现 EIP-1271 的一个代表性合约是 Safe（原 Gnosis Safe）。
-在 Safe 的代码中，[实现了 ](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol) `isValidSignature`，从而使签名可通过以下[两种方式](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support)创建和验证：
+在 Safe 的代码中，`isValidSignature` 的[实现方式](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol)使得签名可以通过[两种方式](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support)创建和验证：
-1. 链上消息
+1. 链上信息
1. 创建：一个安全的所有者创建一个新的安全交易来“签名”一则消息，并将消息作为数据传入交易中。 一旦足够的所有者对交易进行签名，使签名数量达到多签名阈值后，交易就会被广播并运行。 在交易中，会调用一个安全函数，将消息添加到“已批准”消息列表中。
- 2. 验证：调用 Safe 合约的 `isValidSignature` 函数，并传入待验证的消息作为消息参数，传入[一个空值作为签名参数](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32)（即 `0x`）。 Safe 合约会看到签名参数为空，将不会对签名进行密码验证，而是直接检查消息是否在“已批准”消息列表中。
+ 2. 验证：在 Safe 合约上调用 `isValidSignature`，将被验证的信息作为信息参数传入，并为[签名参数传入一个空值](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32)（即 `0x`）。 Safe 合约会看到签名参数为空，将不会对签名进行密码验证，而是直接检查消息是否在“已批准”消息列表中。
2. 链下信息：
- 1. 创建：安全的所有者在链下创建一条消息，然后让其他安全的所有者分别对消息进行签名，直到有足够的签名来达到多签名批准阈值。
- 2. 验证：调用 `isValidSignature`。 在消息参数中，传入要验证的消息。 在签名参数中，传入每个安全所有者的签名，所有签名都是背靠背连接在一起的。 Safe 合约会检查是否有足够签名以达到阈值，**并**检查每个签名的有效性。 如果是，它将返回一个表示签名验证成功的值。
+ 1. 创建：Safe 所有者在链下创建一条信息，然后让其他 Safe 所有者分别对该信息进行签名，直到有足够的签名来满足多重签名批准阈值。
+ 2. 验证：调用 `isValidSignature`。 在消息参数中，传入要验证的消息。 在签名参数中，传入每个安全所有者的签名，所有签名都是背靠背连接在一起的。 Safe 将检查签名数量是否足以达到阈值，**并且**每个签名都有效。 如果是，它将返回一个表示签名验证成功的值。
## `_hash` 参数到底是什么？ 为什么不传递整条消息？
-你可能已经发现，[EIP-1271 接口](https://eips.ethereum.org/EIPS/eip-1271)中的 `isValidSignature` 函数并不接收消息本身，而是使用 `_hash` 参数。 这意味着我们只需将消息的 32 个字节长的哈希值（一般通过 keccak256）传入 `isValidSignature`，而不是传入任意长度的完整消息。
+你可能已经注意到，[EIP-1271 接口](https://eips.ethereum.org/EIPS/eip-1271)中的 `isValidSignature` 函数并不接收信息本身，而是接收一个 `_hash` 参数。 这意味着我们不是将完整的任意长度信息传递给 `isValidSignature`，而是传递该信息的 32 字节哈希值（通常是 keccak256）。
-calldata 的每一个字节（即传入智能合约函数的函数参数数据）都会[花费 16 个单位燃料（若为空字节，则会花费 4 上单位燃料）](https://eips.ethereum.org/EIPS/eip-2028)，因此在消息较长时，这可以节省很多的燃料费。
+calldata 的每个字节——即传递给智能合约函数的函数参数数据——[会花费 16 Gas（如果为零字节，则花费 4 Gas）](https://eips.ethereum.org/EIPS/eip-2028)，因此如果信息很长，可以节省大量 Gas。
### 先前的 EIP-1271 规范
-现有 EIP-1271 规范中的 `isValidSignature` 函数，其第一个参数为 `bytes` 类型（任意长度，而不是固定长度的 `bytes32`），并且参数名为 `message`。 这是 EIP-1271 标准的一个[旧版本](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206)。
+在实际中存在一些 EIP-1271 规范，它们的 `isValidSignature` 函数第一个参数的类型为 `bytes`（任意长度，而不是固定长度的 `bytes32`），参数名为 `message`。 这是 EIP-1271 标准的[一个旧版本](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206)。
## 如何在我的合约中实现 EIP-1271？
@@ -122,6 +118,6 @@ calldata 的每一个字节（即传入智能合约函数的函数参数数据
最终，都将由作为合约开发者的你来决定！
-## 结论
+## 总结
[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) 是一个允许智能合约验证签名的通用标准。 它为智能合约打开了一扇门，使其行为更像外部帐户（例如，为“使用以太坊登录”提供一种与智能合约协同工作的方式），而且它可通过多种方式实现（例如 Safe 有一个有用且有趣的实现方式值得考虑)。
diff --git a/public/content/translations/zh/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/zh/developers/tutorials/erc-721-vyper-annotated-code/index.md
index b22617d525b..486aff8a6ce 100644
--- a/public/content/translations/zh/developers/tutorials/erc-721-vyper-annotated-code/index.md
+++ b/public/content/translations/zh/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -1,31 +1,34 @@
---
-title: "Vyper ERC-721 合约概览"
-description: Ryuya Nakamura 编写的 ERC-721 合约及其原理
+title: "Vyper ERC-721 合约详解"
+description: "Ryuya Nakamura 的 ERC-721 合约及其工作原理"
author: Ori Pomerantz
lang: zh
-tags:
- - "vyper"
- - "erc-721"
- - "python"
+tags: [ "vyper", "erc-721", "python" ]
skill: beginner
published: 2021-04-01
---
## 简介 {#introduction}
-[ERC-721](/developers/docs/standards/tokens/erc-721/) 标准的作用是持有非同质化代币 (NFT) 的所有权。 [ERC-20](/developers/docs/standards/tokens/erc-20/) 代币如同商品一样，因为每个代币之间没有任何区别。 相比之下，ERC-721 代币专门用来代表类似但又不同的资产，例如表示不同的[卡通猫咪](https://www.cryptokitties.co/) 或各种房地产的所有权。
+[ERC-721](/developers/docs/standards/tokens/erc-721/) 标准用于持有非同质化代币 (NFT) 的所有权。
+[ERC-20](/developers/docs/standards/tokens/erc-20/) 代币的行为像商品，因为单个代币之间没有区别。
+与此相反，ERC-721 代币是为相似但不相同的资产设计的，例如不同的猫咪
+卡通或不同房地产的所有权凭证。
-在本文中，我们将分析 [Ryuya Nakamura 编写的 ERC-721 合约](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy)。 该合约是用 [Vyper](https://vyper.readthedocs.io/en/latest/index.html) 语言编写的，Vyper 是一种类似 Python 的合约语言，与使用 Solidity 相比，编写不安全的代码变得更加困难。
+在本文中，我们将分析 [Ryuya Nakamura 的 ERC-721 合约](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy)。
+该合约使用 [Vyper](https://vyper.readthedocs.io/en/latest/index.html) 编写，这是一种类似 Python 的合约语言，其设计使得编写不安全的代码比使用 Solidity 更难。
## 合约 {#contract}
```python
-# @dev Implementation of ERC-721 non-fungible token standard.
+# @dev ERC-721 非同质化代币标准的实现。
# @author Ryuya Nakamura (@nrryuya)
-# Modified from: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
+# 修改自：https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
```
-Vyper 中的注释与 Python 中一样，以哈希 (`#`) 开头并且持续一整行。 [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) 使用包含 `@` 的注释生成方便人阅读的文档。
+在 Vyper 中，注释与 Python 一样，以哈希符号 (`#`) 开头，并持续到行尾。 包含
+`@` 的注释被 [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) 用于生成人类可读的
+文档。
```python
from vyper.interfaces import ERC721
@@ -33,159 +36,194 @@ from vyper.interfaces import ERC721
implements: ERC721
```
-ERC-721 接口内置在 Vyper 语言中。 [你可以点击此处查看代码定义。](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py) 接口定义是用 Python 而不是 Vyper 编写的，因为接口不仅在区块链内使用， 而且在外部客户端向区块链发送交易时也使用，而客户端可能 是用 Python 编写的。
+ERC-721 接口内置于 Vyper 语言中。
+[你可以在这里查看代码定义](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py)。
+接口定义是用 Python 而不是 Vyper 编写的，因为接口不仅在
+区块链内部使用，而且在外部客户端向区块链发送交易时也会使用，而客户端可能
+是用 Python 编写的。
-第一行导入接口，第二行指定我们在这里执行它。
+第一行导入接口，第二行指定我们在此处实现它。
-### ERC721 接收者接口 {#receiver-interface}
+### ERC721Receiver 接口 {#receiver-interface}
```python
-# Interface for the contract called by safeTransferFrom()
+# safeTransferFrom() 调用的合约接口
interface ERC721Receiver:
def onERC721Received(
```
-ERC-721 支持两类转账：
+ERC-721 支持两种类型的转账：
-- `transferFrom`，让发送者指定任何目的地地址并让发送者 承担转账责任。 这意味着你可以转账到一个无效的地址，在这种情况下，NFT 将永远丢失。
-- `safeTransferFrom`，检查目的地址是否是合约。 如果是，ERC-721 合约 将会询问接收合约是否要接收这笔 NFT 转账。
+- `transferFrom`，它允许发送者指定任何目标地址，并将转账的责任
+ 放在发送者身上。 这意味着你可以转账到无效地址，在这种情况下，
+ NFT 将永久丢失。
+- `safeTransferFrom`，它会检查目标地址是否为合约。 如果是，ERC-721 合约
+ 会询问接收合约是否愿意接收该 NFT。
-接收合约必须执行 `ERC721Receiver` 才能回应 `safeTransferFrom` 请求。
+要响应 `safeTransferFrom` 请求，接收合约必须实现 `ERC721Receiver`。
```python
_operator: address,
_from: address,
```
-`_from` 地址是代币的当前所有者。 `_operator` 地址是请求转账的 地址（由于限额，这两个地址可能不同）。
+`_from` 地址是代币的当前所有者。 `_operator` 地址是请求
+转账的地址（由于授权额度的存在，这两个地址可能不同）。
```python
_tokenId: uint256,
```
-ERC-721 代币 ID 是 256 位的。 通常，这些 ID 是通过对代币所代表的 任何东西进行哈希运算创建的。
+ERC-721 代币 ID 是 256 位的。 通常，它们是通过对代币所代表的任何
+事物的描述进行哈希运算来创建的。
```python
_data: Bytes[1024]
```
-请求最多可以有 1024 字节的用户数据。
+请求最多可以包含 1024 字节的用户数据。
```python
) -> bytes32: view
```
-为了防止发生合约意外接受转账的情况，返回值不是布尔值， 而是一个具有特定值的 256 位数字串。
+为防止合约意外接受转账，返回值不是布尔值，
+而是具有特定值的 256 位数据。
-此函数是 `view`，这意味着它可以读取区块链的状态，但不能修改。
+此函数是 `view` 函数，这意味着它可以读取区块链的状态，但不能修改它。
### 事件 {#events}
-[事件](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e) 的触发是为了向区块链外部的用户和服务器通知事件。 请注意，事件 的内容不向区块链上的合约提供。
+发出[事件](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e)是为了将事件通知给区块链外部的用户和服务器。 请注意，区块链上的合约无法访问事件的
+内容。
```python
-# @dev Emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are
-# created (`from` == 0) and destroyed (`to` == 0). Exception: during contract creation, any
-# number of NFTs may be created and assigned without emitting Transfer. At the time of any
-# transfer, the approved address for that NFT (if any) is reset to none.
-# @param _from Sender of NFT (if address is zero address it indicates token creation).
-# @param _to Receiver of NFT (if address is zero address it indicates token destruction).
-# @param _tokenId The NFT that got transferred.
+# @dev 当任何 NFT 的所有权因任何机制发生变化时发出。当 NFT 被
+# 创建（`from` == 0）和销毁（`to` == 0）时，会发出此事件。例外：在合约创建期间，可以
+# 创建和分配任意数量的 NFT 而不发出 Transfer 事件。在任何
+# 转账时，该 NFT 的批准地址（如有）将被重置为无。
+# @param _from NFT 的发送者（如果地址是零地址，则表示代币创建）。
+# @param _to NFT 的接收者（如果地址是零地址，则表示代币销毁）。
+# @param _tokenId 被转移的 NFT。
event Transfer:
sender: indexed(address)
receiver: indexed(address)
tokenId: indexed(uint256)
```
-这类似于 ERC-20 转账事件，不同之处在于我们报告的是 `tokenId` 而不是金额。 没有人拥有零地址，所以根据惯例我们用它来报告代币的创建和销毁。
+这类似于 ERC-20 的 Transfer 事件，区别在于我们报告的是 `tokenId` 而不是数量。
+没有人拥有零地址，因此按照惯例，我们用它来报告代币的创建和销毁。
```python
-# @dev This emits when the approved address for an NFT is changed or reaffirmed. The zero
-# address indicates there is no approved address. When a Transfer event emits, this also
-# indicates that the approved address for that NFT (if any) is reset to none.
-# @param _owner Owner of NFT.
-# @param _approved Address that we are approving.
-# @param _tokenId NFT which we are approving.
+# @dev 当 NFT 的批准地址被更改或重新确认时发出此事件。零
+# 地址表示没有批准地址。当 Transfer 事件发出时，这也
+# 表示该 NFT 的批准地址（如有）被重置为无。
+# @param _owner NFT 的所有者。
+# @param _approved 我们正在批准的地址。
+# @param _tokenId 我们正在批准的 NFT。
event Approval:
owner: indexed(address)
approved: indexed(address)
tokenId: indexed(uint256)
```
-ERC-721 批准与 ERC-20 限额类似。 特定地址只允许转移特定 代币。 这就形成了一种合约在接受代币时作出回应的机制。 合约不能侦听 事件，所以如果你只是把代币转移给合约，它们不会“知道”这笔转账。 因此，代币所有者 首先提交批准，然后向合约发送请求：“我批准你转移 代币 X，请执行......”。
+ERC-721 的批准类似于 ERC-20 的授权额度。 一个特定地址被允许转移一个特定的
+代币。 这为合约在接受代币时提供了一种响应机制。 合约无法
+监听事件，所以如果你只是将代币转移给它们，它们不会“知道”这件事。 这样，
+所有者首先提交批准，然后向合约发送请求：“我已批准你转移代币
+X，请执行...”
-这是一种设计选择，使 ERC-721 标准与 ERC-20 标准类似。 由于 ERC-721 代币 为非同质化代币，合约还可以通过查看代币的所有权来确定 它得到了一个特定代币。
+这是一种设计选择，旨在使 ERC-721 标准与 ERC-20 标准相似。 因为
+ERC-721 代币不是同质化的，合约也可以通过
+查看代币的所有权来识别它收到了一个特定的代币。
```python
-# @dev This emits when an operator is enabled or disabled for an owner. The operator can manage
-# all NFTs of the owner.
-# @param _owner Owner of NFT.
-# @param _operator Address to which we are setting operator rights.
-# @param _approved Status of operator rights(true if operator rights are given and false if
-# revoked).
+# @dev 当为所有者启用或禁用操作员时发出此事件。操作员可以管理
+# 所有者的所有 NFT。
+# @param _owner NFT 的所有者。
+# @param _operator 我们正在为其设置操作员权限的地址。
+# @param _approved 操作员权限的状态（如果授予操作员权限则为 true，如果
+# 撤销则为 false）。
event ApprovalForAll:
owner: indexed(address)
operator: indexed(address)
approved: bool
```
-有时候，拥有一个能够管理某个帐户所有特定类型代币（由一个特定合约 管理的所有代币）的_运营者_是很有用的，这类似于委托书。 例如，我可能想把这样一种权力赋予一个合约，即 检查我是否已经 6 个月没有联系它了，如果属实，就会把我的资产分配给我的继承者（如果他们中一人要求这样做，合约在没有 被交易调用时什么都做不了）。 在 ERC-20 中，我们只需给继承合约提供一个高限额即可。 但这对 ERC-721 不起作用，因为代币是非同质化的。 这是对应的。
+有时，拥有一个可以管理一个帐户所有特定类型代币（由特定合约管理的代币）的_操作员_是很有用的，这类似于授权委托书。 例如，我可能想将这种权力授予一个合约，让它检查我是否
+有六个月没有联系它，如果是，就将我的资产分配给我的继承人（如果其中一个继承人提出请求，因为合约在没有
+被交易调用的情况下什么也做不了）。 在 ERC-20 中，我们可以给继承合约一个高额的授权额度，
+但这不适用于 ERC-721，因为它的代币是非同质化的。 这与上述情况等效。
-`approved` 值表示事件是等待批准，还是等待撤回批准。
+`approved` 值告诉我们该事件是用于批准还是撤销批准。
### 状态变量 {#state-vars}
-这些变量包含代币的当前状态：哪些是可用的以及谁拥有它们。 其中大多数 是 `HashMap` 对象，即[存在于两个类型之间的单向映射](https://vyper.readthedocs.io/en/latest/types.html#mappings)。
+这些变量包含代币的当前状态：哪些代币可用以及谁拥有它们。 这些变量大多是
+`HashMap` 对象，即[存在于两种类型之间的单向映射](https://vyper.readthedocs.io/en/latest/types.html#mappings)。
```python
-# @dev Mapping from NFT ID to the address that owns it.
+# @dev 从 NFT ID 到其所有者地址的映射。
idToOwner: HashMap[uint256, address]
-# @dev Mapping from NFT ID to approved address.
+# @dev 从 NFT ID 到批准地址的映射。
idToApprovals: HashMap[uint256, address]
```
-以太坊中的用户和合约标识用 160 位地址表示。 这两个变量从代币 ID 映射 到代币所有者及批准的转让者（一次最多 1 个映射）。 在以太坊中，未初始化 数据始终为零，因此如果没有所有者或批准的转让者，该代币的值 为零。
+在以太坊中，用户和合约身份由 160 位地址表示。 这两个变量将代币 ID 映射
+到其所有者和被批准转移它们的人（每个代币最多一个）。 在以太坊中，
+未初始化的数据始终为零，因此如果没有所有者或批准的转移者，该代币的
+值为零。
```python
-# @dev Mapping from owner address to count of his tokens.
+# @dev 从所有者地址到其代币数量的映射。
ownerToNFTokenCount: HashMap[address, uint256]
```
-此变量保存每个所有者的代币数量。 没有从所有者到代币的映射，因此 识别特定所有者所拥有代币的唯一方法是在区块链的事件历史记录 中回溯并查看相应的 `Transfer` 事件。 我们可以使用此变量了解我们拥有全部非同质化代币的 时间，而无需进一步回溯。
+此变量保存每个所有者的代币数量。 没有从所有者到代币的映射，因此
+识别特定所有者所拥有代币的唯一方法是回溯区块链的事件历史
+并查看相应的 `Transfer` 事件。 我们可以使用这个变量来知道我们何时拥有了所有的 NFT，而不需要
+再往前追溯。
-注意，此算法只适用于用户接口和外部服务器。 在区块链自身运行的代码无法 读取过去的事件。
+请注意，此算法仅适用于用户界面和外部服务器。 在区块链上运行的
+代码本身无法读取过去的事件。
```python
-# @dev Mapping from owner address to mapping of operator addresses.
+# @dev 从所有者地址到操作员地址映射的映射。
ownerToOperators: HashMap[address, HashMap[address, bool]]
```
-一个帐户可能有多个运营者。 仅有 `HashMap` 不足以跟踪它们，因为每个键都会生成单一值。 然而，可以将 `HashMap[address, bool]` 作为值。 默认情况下，每个地址的都值是 `False`，这意味着它 不是运营者。 你可以根据需要将值设置为 `True`。
+一个帐户可以有多个操作员。 一个简单的 `HashMap` 不足以
+跟踪它们，因为每个键只对应一个值。 相反，你可以使用
+`HashMap[address, bool]` 作为值。 默认情况下，每个地址的值都是 `False`，这意味着它
+不是操作员。 你可以根据需要将值设置为 `True`。
```python
-# @dev Address of minter, who can mint a token
+# @dev 铸币者地址，可以铸造代币
minter: address
```
-必须以某种方式创建新代币。 在此合约中，只允许一个实体创建 代币，即 `minter`。 例如，这可能足以满足游戏的需要。 但对于其他用途，可能需要创建一个 更复杂的业务逻辑。
+新代币必须以某种方式创建。 在这个合约中，只有一个实体被允许这样做，那就是
+`minter`（铸币者）。 例如，这对于一个游戏来说可能已经足够了。 对于其他目的，可能需要
+创建更复杂的业务逻辑。
```python
-# @dev Mapping of interface id to bool about whether or not it's supported
+# @dev 接口 ID 到布尔值的映射，表示是否支持该接口
supportedInterfaces: HashMap[bytes32, bool]
-# @dev ERC165 interface ID of ERC165
+# @dev ERC165 的 ERC165 接口 ID
ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
-# @dev ERC165 interface ID of ERC721
+# @dev ERC721 的 ERC165 接口 ID
ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
```
-[ERC-165](https://eips.ethereum.org/EIPS/eip-165) 为合约规定了一种机制，用来表明应用程序 如何与合约通信以及合约符合哪些 ERC。 在这种情况下，合约符合 ERC-165 和 ERC-721。
+[ERC-165](https://eips.ethereum.org/EIPS/eip-165) 指定了一种机制，让合约可以公开应用程序
+如何与其通信，以及它符合哪些 ERC。 在这种情况下，该合约符合 ERC-165 和 ERC-721。
### 函数 {#functions}
-以下函数确实实现了 ERC-721。
+这些是实际实现 ERC-721 的函数。
#### 构造函数 {#constructor}
@@ -194,15 +232,17 @@ ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000
def __init__():
```
-和 Python 中一样，在 Vyper 中，构造函数也被称为 `__init__`。
+在 Vyper 中，与 Python 一样，构造函数被称为 `__init__`。
```python
"""
- @dev Contract constructor.
+ @dev 合约构造函数。
"""
```
-在 Python 和 Vyper 中，通过指定多行字符串（以 `"""` 起始和结束），你还可以创建注释，但不能以任何方式使用它。 这些注释也可以包括 [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) 注释。
+在 Python 和 Vyper 中，你也可以通过指定一个多行字符串（以 `"""` 开始和结束）
+来创建注释，并且不以任何方式使用它。 这些注释也可以包含
+[NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html)。
```python
self.supportedInterfaces[ERC165_INTERFACE_ID] = True
@@ -210,57 +250,64 @@ def __init__():
self.minter = msg.sender
```
-要访问状态变量，可以使用 `self.`（也是与 Python 中的相同）。
+要访问状态变量，请使用 `self.`（同样，与 Python 中一样）。
#### 视图函数 {#views}
-这些函数不修改区块链状态，因此在外部调用时它们可以 免费执行。 如果视图函数是合约调用的，它们仍然必须在每个节点 上执行，因此需要消耗燃料。
+这些函数不修改区块链的状态，因此如果从外部调用，可以
+免费执行。 如果视图函数由合约调用，它们仍必须在
+每个节点上执行，因此会消耗燃料。
```python
@view
@external
```
-函数定义前面以 (`@`) 开头的这些关键词称为_修改器_。 它们 规定能够调用函数的环境。
+在函数定义之前，以 at 符号（`@`）开头的这些关键字被称为_装饰器_。 它们
+指定了可以调用函数的环境。
-- `@view` 指定此函数为 view 函数。
-- `@external` 指定该特定函数可以由交易及其它合约调用。
+- `@view` 指定此函数是视图函数。
+- `@external` 指定此特定函数可由交易和其他合约调用。
```python
def supportsInterface(_interfaceID: bytes32) -> bool:
```
-与 Python 相比，Vyper 是一种[静态类型语言](https://wikipedia.org/wiki/Type_system#Static_type_checking)。 如果没有先确定[数据类型](https://vyper.readthedocs.io/en/latest/types.html)，就无法声明变量或函数参数。 因此在上例中，输入参数是一个 256 位的 `bytes32` 值 （256 位是[以太坊虚拟机](/developers/docs/evm/)的原生字长宽度）。 输出是一个 布尔值。 按照惯例，函数参数的名称以下划线 (`_`) 开头。
+与 Python 相反，Vyper 是一种[静态类型语言](https://wikipedia.org/wiki/Type_system#Static_type_checking)。
+如果不确定[数据类型](https://vyper.readthedocs.io/en/latest/types.html)，就无法声明变量或函数参数。 在这种情况下，输入参数是 `bytes32`，一个 256 位的值
+（256 位是[以太坊虚拟机](/developers/docs/evm/)的原生字长）。 输出是一个布尔
+值。 按照惯例，函数参数的名称以下划线 (`_`) 开头。
```python
"""
- @dev Interface identification is specified in ERC-165.
- @param _interfaceID Id of the interface
+ @dev 接口标识在 ERC-165 中指定。
+ @param _interfaceID 接口的 ID
"""
return self.supportedInterfaces[_interfaceID]
```
-返回 HashMap `self.supportedInterfaces` 中的值，该 HashMap 在构造函数 (`__init__`) 中设置。
+从 `self.supportedInterfaces` HashMap 返回值，该值在构造函数 (`__init__`) 中设置。
```python
-### VIEW FUNCTIONS ###
+### 视图函数 ###
```
-下面这些视图函数让用户和其它合约可以获得代币相关信息。
+这些是向用户和其他合约提供有关代币信息的视图函数。
```python
@view
@external
def balanceOf(_owner: address) -> uint256:
"""
- @dev Returns the number of NFTs owned by `_owner`.
- Throws if `_owner` is the zero address. NFTs assigned to the zero address are considered invalid.
- @param _owner Address for whom to query the balance.
+ @dev 返回 `_owner` 拥有的 NFT 数量。
+ 如果 `_owner` 是零地址，则抛出异常。分配给零地址的 NFT 被视为无效。
+ @param _owner 查询余额的地址。
"""
assert _owner != ZERO_ADDRESS
```
-此行[宣称](https://vyper.readthedocs.io/en/latest/statements.html#assert) `_owner` 不 为 0。 如果为 0，就会出现错误，操作会被回滚。
+此行[断言](https://vyper.readthedocs.io/en/latest/statements.html#assert) `_owner` 不是
+零。 如果是，则会发生错误并且操作将被回滚。
```python
return self.ownerToNFTokenCount[_owner]
@@ -269,70 +316,75 @@ def balanceOf(_owner: address) -> uint256:
@external
def ownerOf(_tokenId: uint256) -> address:
"""
- @dev Returns the address of the owner of the NFT.
- Throws if `_tokenId` is not a valid NFT.
- @param _tokenId The identifier for an NFT.
+ @dev 返回 NFT 所有者的地址。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
+ @param _tokenId NFT 的标识符。
"""
owner: address = self.idToOwner[_tokenId]
- # Throws if `_tokenId` is not a valid NFT
+ # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
assert owner != ZERO_ADDRESS
return owner
```
-在以太坊虚拟机 (evm) 中，任何没有存储值的存储都为零。 如果 `_tokenId` 处没有代币，那么 `self.idToOwner[_tokenId]` 的值为 0。 在这种情况下，该函数 会回滚操作。
+在以太坊虚拟机 (evm) 中，任何未存储值的存储空间其值都为零。
+如果 `_tokenId` 处没有代币，那么 `self.idToOwner[_tokenId]` 的值为零。 在这种
+情况下，函数会回滚。
```python
@view
@external
def getApproved(_tokenId: uint256) -> address:
"""
- @dev Get the approved address for a single NFT.
- Throws if `_tokenId` is not a valid NFT.
- @param _tokenId ID of the NFT to query the approval of.
+ @dev 获取单个 NFT 的批准地址。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
+ @param _tokenId 要查询其批准情况的 NFT 的 ID。
"""
- # Throws if `_tokenId` is not a valid NFT
+ # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
assert self.idToOwner[_tokenId] != ZERO_ADDRESS
return self.idToApprovals[_tokenId]
```
-注意，`getApproved` _可以_返回零。 如果代币有效，则返回 `self.idToApprovals[_tokenId]`。 如果没有批准者，该值为 0。
+注意，`getApproved` _可以_ 返回零。 如果代币有效，它会返回 `self.idToApprovals[_tokenId]`。
+如果没有批准者，该值为零。
```python
@view
@external
def isApprovedForAll(_owner: address, _operator: address) -> bool:
"""
- @dev Checks if `_operator` is an approved operator for `_owner`.
- @param _owner The address that owns the NFTs.
- @param _operator The address that acts on behalf of the owner.
+ @dev 检查 `_operator` 是否是 `_owner` 的批准操作员。
+ @param _owner 拥有 NFT 的地址。
+ @param _operator 代表所有者行事的地址。
"""
return (self.ownerToOperators[_owner])[_operator]
```
-此函数检查是否允许 `_operator` 管理 `_owner` 在此合约中的所有代币。 因为可以有多个运营者，所以这是一个两级 HashMap。
+此函数检查是否允许 `_operator` 管理此合约中 `_owner` 的所有代币。
+因为可以有多个操作员，所以这是一个两级 HashMap。
-#### 转账帮助函数 {#transfer-helpers}
+#### 转账辅助函数 {#transfer-helpers}
-这些函数执行代币转账或管理过程中的一些操作。
+这些函数实现了代币转移或管理过程中的部分操作。
```python
-### TRANSFER FUNCTION HELPERS ###
+### 转账函数辅助 ###
@view
@internal
```
-修改器 `@internal` 表示该函数只能由 同一合约内的其他函数访问。 按照惯例，这些函数名称也以下划线 (`_`) 开头。
+这个装饰器 `@internal` 意味着该函数只能从
+同一合约内的其他函数访问。 按照惯例，这些函数名也以下划线 (`_`) 开头。
```python
def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
"""
- @dev Returns whether the given spender can transfer a given token ID
- @param spender address of the spender to query
- @param tokenId uint256 ID of the token to be transferred
- @return bool whether the msg.sender is approved for the given token ID,
- is an operator of the owner, or is the owner of the token
+ @dev 返回给定的支出者是否可以转移给定的代币 ID
+ @param spender 要查询的支出者地址
+ @param tokenId 要转移的代币的 uint256 ID
+ @return bool，表示 msg.sender 是否被批准用于给定的代币 ID，
+ 是所有者的操作员，还是代币的所有者
"""
owner: address = self.idToOwner[_tokenId]
spenderIsOwner: bool = owner == _spender
@@ -341,117 +393,123 @@ def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
```
-有三种方式可以允许地址转移代币：
+有三种方式可以允许一个地址转移代币：
1. 该地址是代币的所有者
-2. 该地址经批准可以使用该代币
-3. 该地址是代表代币所有者的运营者
+2. 该地址被批准使用该代币
+3. 该地址是代币所有者的操作员
-上面的函数可以是一个视图函数，因为它并不改变状态。 为了降低运营成本，任何_可以_ 成为视图函数的函数都_应该_成为视图函数。
+上面的函数可以是一个视图函数，因为它不改变状态。 为了降低运营成本，任何
+可以成为视图函数的函数都_应该_是视图函数。
```python
@internal
def _addTokenTo(_to: address, _tokenId: uint256):
"""
- @dev Add a NFT to a given address
- Throws if `_tokenId` is owned by someone.
+ @dev 将一个 NFT 添加到给定地址
+ 如果 `_tokenId` 已被某人拥有，则抛出异常。
"""
- # Throws if `_tokenId` is owned by someone
+ # 如果 `_tokenId` 已被某人拥有，则抛出异常
assert self.idToOwner[_tokenId] == ZERO_ADDRESS
- # Change the owner
+ # 更改所有者
self.idToOwner[_tokenId] = _to
- # Change count tracking
+ # 更改计数跟踪
self.ownerToNFTokenCount[_to] += 1
@internal
def _removeTokenFrom(_from: address, _tokenId: uint256):
"""
- @dev Remove a NFT from a given address
- Throws if `_from` is not the current owner.
+ @dev 从给定地址移除一个 NFT
+ 如果 `_from` 不是当前所有者，则抛出异常。
"""
- # Throws if `_from` is not the current owner
+ # 如果 `_from` 不是当前所有者，则抛出异常
assert self.idToOwner[_tokenId] == _from
- # Change the owner
+ # 更改所有者
self.idToOwner[_tokenId] = ZERO_ADDRESS
- # Change count tracking
+ # 更改计数跟踪
self.ownerToNFTokenCount[_from] -= 1
```
-当转账出现问题时，我们会撤销调用。
+当转账出现问题时，我们会回滚该调用。
```python
@internal
def _clearApproval(_owner: address, _tokenId: uint256):
"""
- @dev Clear an approval of a given address
- Throws if `_owner` is not the current owner.
+ @dev 清除给定地址的批准
+ 如果 `_owner` 不是当前所有者，则抛出异常。
"""
- # Throws if `_owner` is not the current owner
+ # 如果 `_owner` 不是当前所有者，则抛出异常
assert self.idToOwner[_tokenId] == _owner
if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
- # Reset approvals
+ # 重置批准
self.idToApprovals[_tokenId] = ZERO_ADDRESS
```
-仅在必要时更改值。 状态变量位于存储中。 写入存储是 EVM（以太坊虚拟机）执行的最昂贵的操作之一（就 [燃料](/developers/docs/gas/)而言）。 因此，尽量减少写入操作，即使是写入现有值， 成本也很高。
+仅在必要时更改值。 状态变量存在于存储中。 写入存储是
+EVM（以太坊虚拟机）执行的最昂贵的操作之一（就
+[燃料](/developers/docs/gas/)而言）。 因此，最好尽量减少写入操作，即使写入
+现有值也会产生高昂的成本。
```python
@internal
def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
"""
- @dev Execute transfer of a NFT.
- Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
- address for this NFT. (NOTE: `msg.sender` not allowed in private function so pass `_sender`.)
- Throws if `_to` is the zero address.
- Throws if `_from` is not the current owner.
- Throws if `_tokenId` is not a valid NFT.
+ @dev 执行 NFT 的转移。
+ 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
+ 地址，否则抛出异常。（注意：私有函数中不允许使用 `msg.sender`，因此传递 `_sender`。）
+ 如果 `_to` 是零地址，则抛出异常。
+ 如果 `_from` 不是当前所有者，则抛出异常。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
"""
```
-我们使用此内部函数是因为有两种代币转账方式（常规和安全方式），但 我们希望代码中只有一个位置进行此操作，以使审计更容易。
+我们有这个内部函数，因为有两种转移代币的方式（常规和安全），但
+我们希望只在代码中的一个位置执行它，以使审计更容易。
```python
- # Check requirements
+ # 检查要求
assert self._isApprovedOrOwner(_sender, _tokenId)
- # Throws if `_to` is the zero address
+ # 如果 `_to` 是零地址，则抛出异常
assert _to != ZERO_ADDRESS
- # Clear approval. Throws if `_from` is not the current owner
+ # 清除批准。如果 `_from` 不是当前所有者，则抛出异常
self._clearApproval(_from, _tokenId)
- # Remove NFT. Throws if `_tokenId` is not a valid NFT
+ # 移除 NFT。如果 `_tokenId` 不是有效的 NFT，则抛出异常
self._removeTokenFrom(_from, _tokenId)
- # Add NFT
+ # 添加 NFT
self._addTokenTo(_to, _tokenId)
- # Log the transfer
+ # 记录转账
log Transfer(_from, _to, _tokenId)
```
-要在 Vyper 中触发一个事件，可以使用 `log` 语句（[请点击此处了解更多详情](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging)）。
+要在 Vyper 中发出事件，请使用 `log` 语句（[在此处查看更多详细信息](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging)）。
#### 转账函数 {#transfer-funs}
```python
-### TRANSFER FUNCTIONS ###
+### 转账函数 ###
@external
def transferFrom(_from: address, _to: address, _tokenId: uint256):
"""
- @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
- address for this NFT.
- Throws if `_from` is not the current owner.
- Throws if `_to` is the zero address.
- Throws if `_tokenId` is not a valid NFT.
- @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
- they maybe be permanently lost.
- @param _from The current owner of the NFT.
- @param _to The new owner.
- @param _tokenId The NFT to transfer.
+ @dev 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
+ 地址，否则抛出异常。
+ 如果 `_from` 不是当前所有者，则抛出异常。
+ 如果 `_to` 是零地址，则抛出异常。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
+ @notice 调用者有责任确认 `_to` 能够接收 NFT，否则
+ 它们可能会永久丢失。
+ @param _from NFT 的当前所有者。
+ @param _to 新的所有者。
+ @param _tokenId 要转移的 NFT。
"""
self._transferFrom(_from, _to, _tokenId, msg.sender)
```
-此函数允许你向任意地址转账。 除非该地址是用户或是知道如何转移代币的 合约，否则你转移的任何代币都将卡在该地址中变得毫无用处。
+此函数允许你转移到任意地址。 除非该地址是用户，或者是一个知道
+如何转移代币的合约，否则你转移的任何代币都将卡在该地址中并变得无用。
```python
@external
@@ -462,30 +520,34 @@ def safeTransferFrom(
_data: Bytes[1024]=b""
):
"""
- @dev Transfers the ownership of an NFT from one address to another address.
- Throws unless `msg.sender` is the current owner, an authorized operator, or the
- approved address for this NFT.
- Throws if `_from` is not the current owner.
- Throws if `_to` is the zero address.
- Throws if `_tokenId` is not a valid NFT.
- If `_to` is a smart contract, it calls `onERC721Received` on `_to` and throws if
- the return value is not `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
- NOTE: bytes4 is represented by bytes32 with padding
- @param _from The current owner of the NFT.
- @param _to The new owner.
- @param _tokenId The NFT to transfer.
- @param _data Additional data with no specified format, sent in call to `_to`.
+ @dev 将一个 NFT 的所有权从一个地址转移到另一个地址。
+ 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的
+ 批准地址，否则抛出异常。
+ 如果 `_from` 不是当前所有者，则抛出异常。
+ 如果 `_to` 是零地址，则抛出异常。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
+ 如果 `_to` 是一个智能合约，它会在 `_to` 上调用 `onERC721Received`，如果
+ 返回值不是 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`，则抛出异常。
+ 注意：bytes4 由带填充的 bytes32 表示
+ @param _from NFT 的当前所有者。
+ @param _to 新的所有者。
+ @param _tokenId 要转移的 NFT。
+ @param _data 没有指定格式的附加数据，在调用 `_to` 时发送。
"""
self._transferFrom(_from, _to, _tokenId, msg.sender)
```
-可以先进行转账，因为如果出现问题，我们无论如何都会回滚该操作，因此 调用中的一切操作都会被取消。
+可以先执行转移，因为如果出现问题，我们无论如何都会回滚，
+所以调用中完成的所有操作都将被取消。
```python
- if _to.is_contract: # check if `_to` is a contract address
+ if _to.is_contract: # 检查 `_to` 是否是合约地址
```
-首先检查地址是否为合约（如果有代码）。 如果不是，假定它是一个用户 地址，并且该用户能够使用或转移代币。 但不要让该地址 给你一种虚假的安全感。 如果你将代币转移到一个没有人知道私钥的地址，即使使用了 `safeTransferFrom`，也可能损失代币。
+首先检查该地址是否是合约（即它是否有代码）。 如果不是，则假定它是一个用户
+地址，并且该用户将能够使用或转移代币。 但不要让它给你一种
+虚假的安全感。 即使使用 `safeTransferFrom`，如果你将代币转移
+到一个没有人知道其私钥的地址，你仍然可能会丢失代币。
```python
returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
@@ -494,43 +556,44 @@ def safeTransferFrom(
调用目标合约，看它是否可以接收 ERC-721 代币。
```python
- # Throws if transfer destination is a contract which does not implement 'onERC721Received'
+ # 如果转移目标是一个未实现 'onERC721Received' 的合约，则抛出异常
assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
```
-如果目的地是一个合约，但它不接受 ERC-721 代币（或者决定不接受这笔特定转账），则回滚。
+如果目标是一个合约，但它不接受 ERC-721 代币（或者决定不接受此
+特定转移），则回滚。
```python
@external
def approve(_approved: address, _tokenId: uint256):
"""
- @dev Set or reaffirm the approved address for an NFT. The zero address indicates there is no approved address.
- Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.
- Throws if `_tokenId` is not a valid NFT. (NOTE: This is not written the EIP)
- Throws if `_approved` is the current owner. (NOTE: This is not written the EIP)
- @param _approved Address to be approved for the given NFT ID.
- @param _tokenId ID of the token to be approved.
+ @dev 为一个 NFT 设置或重新确认批准地址。零地址表示没有批准地址。
+ 除非 `msg.sender` 是当前的 NFT 所有者，或者是当前所有者的授权操作员，否则抛出异常。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。（注意：这并未写入 EIP）
+ 如果 `_approved` 是当前所有者，则抛出异常。（注意：这并未写入 EIP）
+ @param _approved 要为给定 NFT ID 批准的地址。
+ @param _tokenId 要批准的代币 ID。
"""
owner: address = self.idToOwner[_tokenId]
- # Throws if `_tokenId` is not a valid NFT
+ # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
assert owner != ZERO_ADDRESS
- # Throws if `_approved` is the current owner
+ # 如果 `_approved` 是当前所有者，则抛出异常
assert _approved != owner
```
-根据惯例，如果你不想要批准者，可以指定零地址而不是你自己。
+按照惯例，如果你不想有批准者，你应该指定零地址，而不是你自己。
```python
- # Check requirements
+ # 检查要求
senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
assert (senderIsOwner or senderIsApprovedForAll)
```
-要设置批准，你可以是所有者，也可以是所有者授权的运营者。
+要设置批准，你要么是所有者，要么是所有者授权的操作员。
```python
- # Set the approval
+ # 设置批准
self.idToApprovals[_tokenId] = _approved
log Approval(owner, _approved, _tokenId)
@@ -538,14 +601,14 @@ def approve(_approved: address, _tokenId: uint256):
@external
def setApprovalForAll(_operator: address, _approved: bool):
"""
- @dev Enables or disables approval for a third party ("operator") to manage all of
- `msg.sender`'s assets. It also emits the ApprovalForAll event.
- Throws if `_operator` is the `msg.sender`. (NOTE: This is not written the EIP)
- @notice This works even if sender doesn't own any tokens at the time.
- @param _operator Address to add to the set of authorized operators.
- @param _approved True if the operators is approved, false to revoke approval.
+ @dev 为第三方（“操作员”）启用或禁用批准，以管理
+ `msg.sender` 的所有资产。它还会发出 ApprovalForAll 事件。
+ 如果 `_operator` 是 `msg.sender`，则抛出异常。（注意：这并未写入 EIP）
+ @notice 即使发送者当时不拥有任何代币，此操作也有效。
+ @param _operator 要添加到授权操作员集合中的地址。
+ @param _approved 如果操作员被批准，则为 True；如果撤销批准，则为 false。
"""
- # Throws if `_operator` is the `msg.sender`
+ # 如果 `_operator` 是 `msg.sender`，则抛出异常
assert _operator != msg.sender
self.ownerToOperators[msg.sender][_operator] = _approved
log ApprovalForAll(msg.sender, _operator, _approved)
@@ -553,10 +616,12 @@ def setApprovalForAll(_operator: address, _approved: bool):
#### 铸造新代币和销毁现有代币 {#mint-burn}
-创建合约的帐户就是 `minter`，是获得授权可以铸造 新非同质化代币的超级用户。 然而，即使是铸币者，也不允许其销毁现有代币。 只有所有者或所有者授权的实体 才能那样做。
+创建合约的帐户是 `minter`（铸币者），即被授权铸造
+新 NFT 的超级用户。 然而，即使是它，也不允许销毁现有代币。 只有所有者或所有者
+授权的实体才能这样做。
```python
-### MINT & BURN FUNCTIONS ###
+### 铸造和销毁函数 ###
@external
def mint(_to: address, _tokenId: uint256) -> bool:
@@ -566,67 +631,81 @@ def mint(_to: address, _tokenId: uint256) -> bool:
```python
"""
- @dev Function to mint tokens
- Throws if `msg.sender` is not the minter.
- Throws if `_to` is zero address.
- Throws if `_tokenId` is owned by someone.
- @param _to The address that will receive the minted tokens.
- @param _tokenId The token id to mint.
- @return A boolean that indicates if the operation was successful.
+ @dev 铸造代币的函数
+ 如果 `msg.sender` 不是铸币者，则抛出异常。
+ 如果 `_to` 是零地址，则抛出异常。
+ 如果 `_tokenId` 已被某人拥有，则抛出异常。
+ @param _to 将接收铸造代币的地址。
+ @param _tokenId 要铸造的代币 id。
+ @return 一个布尔值，指示操作是否成功。
"""
- # Throws if `msg.sender` is not the minter
+ # 如果 `msg.sender` 不是铸币者，则抛出异常
assert msg.sender == self.minter
```
-只有铸币者（创建 ERC-721 合约的帐户）可以铸造新代币。 如果我们将来想改变铸币者的 身份，这可能会成为一个问题。 在生产合约 中，你可能需要一个函数，允许 铸币者将铸币者特权转让给其他人。
+只有铸币者（创建 ERC-721 合约的帐户）可以铸造新代币。 如果我们将来想改变铸币者的
+身份，这可能会成为一个问题。 在
+生产合约中，你可能需要一个允许铸币者将
+铸币者特权转移给他人的函数。
```python
- # Throws if `_to` is zero address
+ # 如果 `_to` 是零地址，则抛出异常
assert _to != ZERO_ADDRESS
- # Add NFT. Throws if `_tokenId` is owned by someone
+ # 添加 NFT。如果 `_tokenId` 已被某人拥有，则抛出异常
self._addTokenTo(_to, _tokenId)
log Transfer(ZERO_ADDRESS, _to, _tokenId)
return True
```
-根据惯例，新代币铸造视作来自零地址的转账。
+按照惯例，新代币的铸造被视为从零地址的转移。
```python
@external
def burn(_tokenId: uint256):
"""
- @dev Burns a specific ERC721 token.
- Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
- address for this NFT.
- Throws if `_tokenId` is not a valid NFT.
- @param _tokenId uint256 id of the ERC721 token to be burned.
+ @dev 销毁一个特定的 ERC721 代币。
+ 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
+ 地址，否则抛出异常。
+ 如果 `_tokenId` 不是有效的 NFT，则抛出异常。
+ @param _tokenId 要销毁的 ERC721 代币的 uint256 id。
"""
- # Check requirements
+ # 检查要求
assert self._isApprovedOrOwner(msg.sender, _tokenId)
owner: address = self.idToOwner[_tokenId]
- # Throws if `_tokenId` is not a valid NFT
+ # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
assert owner != ZERO_ADDRESS
self._clearApproval(owner, _tokenId)
self._removeTokenFrom(owner, _tokenId)
log Transfer(owner, ZERO_ADDRESS, _tokenId)
```
-任何可以转移代币的人都可以销毁它。 虽然销毁代币看起来等同于 转移到零地址，但零地址实际上并没有接收到代币。 这样我们可以释放所有用于代币的 存储，因而可以降低交易的燃料成本。
+任何被允许转移代币的人都可以销毁它。 虽然销毁看起来等同于
+转移到零地址，但零地址实际上并不接收代币。 这使我们能够
+释放用于该代币的所有存储空间，从而可以降低交易的燃料成本。
## 使用此合约 {#using-contract}
-与 Solidity 相比，Vyper 中没有继承。 这种有意而为之的设计选择，是为了使代码 更清晰，从而更容易受保护。 因此，要创建你自己的 Vyper ERC-721 合约，你可以 利用[此合约](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy)，并修改 它以实现想要的业务逻辑。
+与 Solidity 相反，Vyper 没有继承。 这是一个刻意的设计选择，旨在使
+代码更清晰，从而更容易保护。 因此，要创建你自己的 Vyper ERC-721 合约，你可以使用此
+合约并修改它
+以实现你想要的业务逻辑。
-### 总结 {#conclusion}
+## 结论 {#conclusion}
-回顾一下，下面是此合约中最重要的几点：
+作为回顾，以下是此合约中一些最重要的概念：
-- 要通过安全转账方式接收 ERC-721 代币，合约必须实现 `ERC721Receiver` 接口。
-- 即使使用了安全转账方式，如果你将代币发送到私钥未知 的地址，代币仍然会被卡住。
-- 当操作出现问题时，最好 `revert` 该调用，而不是只返回 失败值。
-- 有了所有者，ERC-721 代币才存在。
-- 有三种经过授权的 NFT 转账方式。 你可以是所有者，可以针对特定代币获得批准， 或者可以是所有者全部代币的运营者。
-- 过去的事件只在区块链之外可见。 区块链中运行的代码无法看到它们。
+- 要通过安全转移接收 ERC-721 代币，合约必须实现 `ERC721Receiver` 接口。
+- 即使你使用安全转移，如果将代币发送到一个其私钥
+ 未知的地址，代币仍然可能会卡住。
+- 当操作出现问题时，一个好主意是 `revert`（回滚）该调用，而不是仅仅返回
+ 一个失败值。
+- 当 ERC-721 代币有所有者时，它们才存在。
+- 有三种方式可以被授权转移 NFT。 你可以是所有者，被批准用于特定代币，
+ 或者是所有者所有代币的操作员。
+- 过去的事件仅在区块链外部可见。 在区块链内部运行的代码无法查看它们。
现在去实现安全的 Vyper 合约吧。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
+
diff --git a/public/content/translations/zh/developers/tutorials/erc20-annotated-code/index.md b/public/content/translations/zh/developers/tutorials/erc20-annotated-code/index.md
index a1927070a0a..deee115ca1c 100644
--- a/public/content/translations/zh/developers/tutorials/erc20-annotated-code/index.md
+++ b/public/content/translations/zh/developers/tutorials/erc20-annotated-code/index.md
@@ -1,30 +1,39 @@
---
-title: "ERC-20 合约概览"
-description: OpenZeppelin 的 ERC-20 合约内容和解读
+title: "ERC-20 合约详解"
+description: "OpenZeppelin ERC-20 合约中有什么，为什么？"
author: Ori Pomerantz
lang: zh
-tags:
- - "solidity"
- - "erc-20"
+tags: [ "Solidity", "erc-20" ]
skill: beginner
published: 2021-03-09
---
## 简介 {#introduction}
-以太坊最常见的用途之一是由一个团队来打造一种可以交易的代币，在某种意义上是他们自己的货币。 这些代币通常遵循一个标准， [ERC-20](/developers/docs/standards/tokens/erc-20/)。 此标准使得人们能够以此来开发可以用于所有 ERC-20 代币的工具，如流动资金池和钱包。 在这篇文章中，我们将带领大家分析 [OpenZeppelin Solidity ERC20 实现](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)以及 [ ERC20 接口定义](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)。
+以太坊最常见的用途之一是由一个团队来打造一种可以交易的代币，在某种意义上是他们自己的货币。 这些代币通常遵循一个标准：
+[ERC-20](/developers/docs/standards/tokens/erc-20/)。 此标准使得编写适用于所有 ERC-20
+代币的工具（例如流动性资金池和钱包）成为可能。 在本文中，我们将分析
+[OpenZeppelin Solidity ERC20 实现](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)以及
+[接口定义](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)。
-这里使用的是附加说明的源代码。 如果想要实现 ERC-20， [请阅读此教程](https://docs.openzeppelin.com/contracts/2.x/erc20-supply)。
+这是带注释的源代码。 如果你想实现 ERC-20，
+[请阅读本教程](https://docs.openzeppelin.com/contracts/2.x/erc20-supply)。
## 接口 {#the-interface}
-像 ERC-20 这样的标准，其目的是允许符合标准的多种代币，都可以在应用程序之间进行互操作，例如钱包和分布式交易所。 为实现这个目的，我们要创建一个 [接口](https://www.geeksforgeeks.org/solidity-basics-of-interface/)。 任何需要使用代币合约的代码 可以在接口中使用相同的定义，并且与使用它的所有代币合约兼容。无论是像 MetaMask 这样的钱包、 诸如 etherscan.io 之类的去中心化应用程序，或一种不同的合约，例如流动资金池。
+ERC-20 等标准的目的是让多种代币实现能够在应用程序（如钱包和去中心化交易所）之间互操作。 为实现此目的，我们创建一个
+[接口](https://www.geeksforgeeks.org/solidity/solidity-basics-of-interface/)。 任何需要使用代币合约的代码
+都可以在接口中使用相同的定义，并与所有使用它的代币合约兼容，无论它是像
+MetaMask 这样的钱包，像 etherscan.io 这样的去中心化应用程序，还是像流动性资金池这样不同的合约。
-
+
-如果你是一位经验丰富的程序员，你可能记得在 [Java](https://www.w3schools.com/java/java_interface.asp) 中，甚至在 [C 头文件](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html) 中看到过类似的构造。
+如果你是一位经验丰富的程序员，你可能还记得在 [Java](https://www.w3schools.com/java/java_interface.asp)
+甚至 [C 头文件](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html)中见过类似的构造。
-这是来自 OpenZeppelin 的 [ERC-20 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) 的定义。 这是将[人类可读标准](https://eips.ethereum.org/EIPS/eip-20)转换为 Solidity 代码。 当然， 接口本身并不定义_如何_做事。 这一点在下文合约的源代码中作了解释。
+这是 OpenZeppelin 的
+[ERC-20 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) 定义。 它是将[人类可读标准](https://eips.ethereum.org/EIPS/eip-20)翻译成 Solidity 代码。 当然，
+接口本身并不定义_如何_做任何事情。 这一点在下文合约的源代码中作了解释。
@@ -32,7 +41,8 @@ published: 2021-03-09
// SPDX-License-Identifier: MIT
```
-Solidity 文件中一般需要标识软件许可证。 [你可以在这里看到许可证列表](https://spdx.org/licenses/)。 如果需要不同的 许可证，只需在注释中加以说明。
+Solidity 文件应该包含许可证标识符。 [你可以在此处查看许可证列表](https://spdx.org/licenses/)。 如果你需要其他
+许可证，只需在注释中说明即可。
@@ -40,17 +50,20 @@ Solidity 文件中一般需要标识软件许可证。 [你可以在这里看到
pragma solidity >=0.6.0 <0.8.0;
```
-Solidity 语言仍在迅速地发展，新版本可能不适配旧的代码 ([请点击此处查看](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html))。 因此，最好不仅指定一个最低的 语言版本，也指定一个最高的版本，即测试过代码的最新版本。
+Solidity 语言仍在快速发展，新版本可能与旧代码不兼容
+（[在此处查看](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html)）。 因此，最好不仅指定语言的最低
+版本，还指定最高版本，即你测试过代码的最新版本。
```solidity
/**
- * @dev Interface of the ERC20 standard as defined in EIP.
+ * @dev EIP 中定义的 ERC20 标准接口。
*/
```
-注释中的 `@dev` 是 [NatSpec 格式](https://docs.soliditylang.org/en/develop/natspec-format.html)的一部分，用于 从源代码生成文档。
+注释中的 `@dev` 是 [NatSpec 格式](https://docs.soliditylang.org/en/develop/natspec-format.html) 的一部分，用于从源代码生成
+文档。
@@ -58,135 +71,162 @@ Solidity 语言仍在迅速地发展，新版本可能不适配旧的代码 ([
interface IERC20 {
```
-根据惯例，接口名称以 `I` 开头。
+按照惯例，接口名称以 `I` 开头。
```solidity
/**
- * @dev Returns the amount of tokens in existence.
+ * @dev 返回存在的代币数量。
*/
function totalSupply() external view returns (uint256);
```
-此函数标记为 `external`，表示[它只能从合约之外调用](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2)。 它返回的是合约中代币的总供应量 这个值按以太坊中最常见的类型返回，即无符号的 256 位（256 位是 以太坊虚拟机的原生字长宽度）。 此函数也是视图 `view` 类型，这意味着它不会改变合约状态，这样它可以在单个节点上执行，而不需要在区块链的每个节点上执行。 这类函数不会生成交易，也不会消耗[燃料](/developers/docs/gas/)。
+此函数是 `external`，表示[它只能从合约外部调用](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2)。
+它返回合约中代币的总供应量。 这个值按以太坊中最常见的类型返回，即无符号的 256 位（256 位是
+以太坊虚拟机的原生字长）。 此函数也是 `view` 函数，意味着它不会改变状态，所以它可以在单个节点上执行，而不必让
+区块链中的每个节点都运行它。 这类函数不会产生交易，也不消耗[燃料](/developers/docs/gas/)。
-**注意：**理论上讲，合约创建者可能会通过返回比实际数量少的总供应量来做骗局，让每个代币 比实际看起来更有价值。 然而，这种担忧忽视了区块链的真正内涵。 所有在区块链上发生的事情都要通过每个节点 进行验证。 为了实现这一点，每个合约的机器语言代码和存储都可以在每个节点上找到。 虽然无需发布你的合约代码，但这样其它人都不会认真对待你，除非你发布源代码和用于编译的 Solidity 版本，这样人们可以用它来验证你提供的机器语言代码。 例如，请查看[此合约](https://etherscan.io/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD#code)。
+\*\*注意：\*\*理论上，合约创建者似乎可以通过返回比实际值小的总供应量来作弊，使每个代币看起来
+比实际更有价值。 然而，这种担忧忽视了区块链的真正本质。 区块链上发生的一切都可以由
+每个节点验证。 为实现这一点，每个合约的机器语言代码和存储都位于每个节点上。 虽然你不需要发布合约的 Solidity
+代码，但除非你发布源代码以及用于编译它的 Solidity 版本，否则没有人会把你当回事，这样才能根据你提供的机器语言代码进行
+验证。
+例如，请参阅[此合约](https://eth.blockscout.com/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD?tab=contract)。
```solidity
/**
- * @dev Returns the amount of tokens owned by `account`.
+ * @dev 返回 `account` 拥有的代币数量。
*/
function balanceOf(address account) external view returns (uint256);
```
-顾名思义，`balanceOf` 返回一个帐户的余额。 以太坊帐户在 Solidity 中通过 `address` 类型识别，该类型有 160 位。 它也是 `external` 和 `view` 类型。
+顾名思义，`balanceOf` 返回账户余额。 以太坊账户在 Solidity 中使用 `address` 类型进行标识，该类型占 160 位。
+它也是 `external` 和 `view`。
```solidity
/**
- * @dev Moves `amount` tokens from the caller's account to `recipient`.
+ * @dev 将 `amount` 数量的代币从调用者的账户转移到 `recipient`。
*
- * Returns a boolean value indicating whether the operation succeeded.
+ * 返回一个布尔值，表示操作是否成功。
*
- * Emits a {Transfer} event.
+ * 触发一个 {Transfer} 事件。
*/
function transfer(address recipient, uint256 amount) external returns (bool);
```
-`transfer` 函数将代币从调用者地址转移到另一个地址。 这涉及到状态的更改，所以它不是 `view` 类型。 当用户调用此函数时，它会创建交易并消耗燃料。 还会触发一个 `Transfer` 事件，以通知区块链上的所有人。
+`transfer` 函数将代币从调用者转移到另一个地址。 这涉及状态变更，所以它不是 `view` 函数。
+当用户调用此函数时，它会创建交易并消耗燃料。 它还会触发一个 `Transfer` 事件，将该事件通知
+区块链上的所有人。
-该函数有两种输出，对应两种不同的调用：
+该函数有两种输出，对应两种不同的调用者：
-- 直接从用户接口调用函数的用户。 此类用户通常会提交一个交易 并且不会等待响应，因为响应可能需要无限期的时间。 用户可以查看交易收据 （通常通过交易哈希值识别）或者查看 `Transfer` 事件，以确定发生了什么。
-- 将函数作为整个交易一部分调用的其他合约 这些合约可立即获得结果， 由于它们在相同的交易里运行，因此可以使用函数返回值。
+- 直接从用户界面调用函数的用户。 通常，用户提交交易后
+ 不会等待响应，因为响应可能需要不确定的时间。 用户可以
+ 通过查找交易收据（通过交易哈希值识别）或查找
+ `Transfer` 事件来查看发生了什么。
+- 将函数作为整个交易一部分调用的其他合约。 这些合约会立即获得结果，
+ 因为它们在同一笔交易中运行，所以它们可以使用函数返回值。
-更改合约状态的其他函数创建的同类型输出。
+更改合约状态的其他函数会创建相同类型的输出。
-限额允许帐户使用属于另一位所有者的代币。 比如，当合约作为卖方时，这个函数就很实用。 合约无法 监听事件，如果买方要将代币直接转给卖方合约， 该合约无法知道已经获得付款。 因此，买方允许 卖方合约支付一定的额度，而让卖方转账相应金额。 这通过卖方合约调用的函数完成，这样卖方合约 可以知道是否成功。
+授权额度允许一个账户花费属于其他所有者的代币。
+例如，对于充当卖方的合约，这很有用。 合约无法
+监控事件，因此如果买方将代币直接转移给卖方合约
+，该合约不会知道它已收到付款。 因此，买方授权
+卖方合约花费一定金额，然后卖方转走该金额。
+这是通过卖方合约调用的函数完成的，因此卖方合约
+可以知道它是否成功。
```solidity
/**
- * @dev Returns the remaining number of tokens that `spender` will be
- * allowed to spend on behalf of `owner` through {transferFrom}. This is
- * zero by default.
+ * @dev 返回 `spender` 通过 {transferFrom} 可代表 `owner` 花费的
+ * 剩余代币数量。默认
+ * 为零。
*
- * This value changes when {approve} or {transferFrom} are called.
+ * 调用 {approve} 或 {transferFrom} 时，此值会发生变化。
*/
function allowance(address owner, address spender) external view returns (uint256);
```
-`allowance` 函数允许任何人查询一个 地址 (`owner`) 给另一个地址 (`spender`) 的许可额度。
+`allowance` 函数允许任何人查询一个
+地址（`owner`）授权另一个地址（`spender`）花费的额度。
```solidity
/**
- * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
+ * @dev 将 `spender` 对调用者代币的授权额度设置为 `amount`。
*
- * Returns a boolean value indicating whether the operation succeeded.
+ * 返回一个布尔值，表示操作是否成功。
*
- * IMPORTANT: Beware that changing an allowance with this method brings the risk
- * that someone may use both the old and the new allowance by unfortunate
- * transaction ordering. One possible solution to mitigate this race
- * condition is to first reduce the spender's allowance to 0 and set the
- * desired value afterwards:
+ * 重要提示：请注意，使用此方法更改授权额度会带来风险，
+ * 有人可能因不利的交易排序而同时使用新旧两种授权额度。
+ * 缓解此竞态条件的一个可行方案是，先将花费者的授权额度降至 0，
+ * 然后再设置所需的值：
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
- * Emits an {Approval} event.
+ * 触发一个 {Approval} 事件。
*/
function approve(address spender, uint256 amount) external returns (bool);
```
-`approve` 函数创建了一个许可额度。 请务必阅读关于 如何避免函数被滥用的信息。 在以太坊中，你可以控制自己交易的顺序， 但无法控制其他方交易的执行顺序， 除非在看到其他方的交易发生之前 不提交你自己的交易。
+`approve` 函数创建一个授权额度。 请务必阅读有关
+如何滥用它的消息。 在以太坊中，你可以控制自己交易的顺序，
+但无法控制其他人交易的执行顺序，
+除非在看到对方的交易发生之前
+不提交自己的交易。
```solidity
/**
- * @dev Moves `amount` tokens from `sender` to `recipient` using the
- * allowance mechanism. `amount` is then deducted from the caller's
- * allowance.
+ * @dev 使用
+ * 授权机制将 `amount` 数量的代币从 `sender` 转移到 `recipient`。然后从调用者的授权额度中扣除 `amount`。
*
- * Returns a boolean value indicating whether the operation succeeded.
+ * 返回一个布尔值，表示操作是否成功。
*
- * Emits a {Transfer} event.
+ * 触发一个 {Transfer} 事件。
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
```
-最后，消费者使用 `transferFrom` 函数用来使用许可额度。
+最后，`transferFrom` 由花费者用来实际花费授权额度。
```solidity
/**
- * @dev Emitted when `value` tokens are moved from one account (`from`) to
- * another (`to`).
+ * @dev 当 `value` 数量的代币从一个帐户 (`from`) 转移到
+ * 另一个 (`to`) 时触发。
*
- * Note that `value` may be zero.
+ * 请注意，`value` 可能为零。
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
- * @dev Emitted when the allowance of a `spender` for an `owner` is set by
- * a call to {approve}. `value` is the new allowance.
+ * @dev 当通过
+ * 调用 {approve} 为 `owner` 设置 `spender` 的授权额度时触发。`value` 是新的授权额度。
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
```
-在 ERC-20 合约状态发生变化时就会激发这些事件。
+当 ERC-20 合约的状态发生变化时，会触发这些事件。
## 实际合约 {#the-actual-contract}
-这是实现 ERC-20 标准的实际合约， [摘自此处](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)。 不能照原样使用，但可以 通过[继承](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm)将其扩展，使之可用。
+这是实现 ERC-20 标准的实际合约，
+[摘自此处](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)。
+它不应按原样使用，但你可以
+[继承](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm)它以将其扩展为可用的东西。
```solidity
// SPDX-License-Identifier: MIT
@@ -195,9 +235,9 @@ pragma solidity >=0.6.0 <0.8.0;
-### 导入声明 {#import-statements}
+### Import 语句 {#import-statements}
-除了上述接口定义外，合约定义还要导入两个其他文件：
+除了上面的接口定义，合约定义还导入了另外两个文件：
```solidity
@@ -206,37 +246,42 @@ import "./IERC20.sol";
import "../../math/SafeMath.sol";
```
-- `GSN/Context.sol` 是使用 [OpenGSN](https://www.opengsn.org/) 所需的文件，该系统允许用户在没有以太币的情况下 使用区块链。 请注意，这里的文件是旧版本，如果需要集成 OpenGSN， [请使用此教程](https://docs.opengsn.org/javascript-client/tutorial.html)。
-- [SafeMath 库](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/)，用于 完成没有溢出问题的加法和减法。 这非常必要，否则会出现，用户仅有一个代币，花掉 两个代币后，反而有了 2^256-1 个代币。
+- `GSN/Context.sol` 是使用 [OpenGSN](https://www.opengsn.org/) 所需的定义，该系统允许没有以太币的用户
+ 使用区块链。 请注意，这是一个旧版本，如果你想与 OpenGSN 集成
+ [请使用本教程](https://docs.opengsn.org/javascript-client/tutorial.html)。
+- [SafeMath 库](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/)，用于防止 Solidity **<0.8.0** 版本中的
+ 算术上溢/下溢。 在 Solidity ≥0.8.0 中，算术运算在
+ 上溢/下溢时会自动还原，因此不再需要 SafeMath。 此合约使用 SafeMath 是为了与
+ 旧版编译器向后兼容。
-这里的注释说明了合约的目的。
+此注释说明了合约的目的。
```solidity
/**
- * @dev Implementation of the {IERC20} interface.
+ * @dev {IERC20} 接口的实现。
*
- * This implementation is agnostic to the way tokens are created. This means
- * that a supply mechanism has to be added in a derived contract using {_mint}.
- * For a generic mechanism see {ERC20PresetMinterPauser}.
+ * 此实现与代币的创建方式无关。这意味着
+ * 必须使用 {_mint} 在派生合约中添加供应机制。
+ * 有关通用机制，请参阅 {ERC20PresetMinterPauser}。
*
- * TIP: For a detailed writeup see our guide
- * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
- * to implement supply mechanisms].
+ * 提示：有关详细的说明，请参阅我们的指南
+ * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[如何
+ * 实现供应机制]。
*
- * We have followed general OpenZeppelin guidelines: functions revert instead
- * of returning `false` on failure. This behavior is nonetheless conventional
- * and does not conflict with the expectations of ERC20 applications.
+ * 我们遵循了通用的 OpenZeppelin 指南：函数在失败时会还原，而
+ * 不会返回 `false`。但是，此行为是常规行为，
+ * 并且与 ERC20 应用程序的预期不冲突。
*
- * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
- * This allows applications to reconstruct the allowance for all accounts just
- * by listening to said events. Other implementations of the EIP may not emit
- * these events, as it isn't required by the specification.
+ * 此外，在调用 {transferFrom} 时会触发 {Approval} 事件。
+ * 这允许应用程序仅通过监听所述事件
+ * 即可重建所有账户的授权额度。EIP 的其他实现
+ * 可能不会触发这些事件，因为规范没有要求。
*
- * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
- * functions have been added to mitigate the well-known issues around setting
- * allowances. See {IERC20-approve}.
+ * 最后，添加了非标准的 {decreaseAllowance} 和 {increaseAllowance}
+ * 函数，以缓解围绕设置
+ * 授权额度的众所周知的问题。请参阅 {IERC20-approve}。
*/
```
@@ -257,27 +302,36 @@ contract ERC20 is Context, IERC20 {
```
-此行将 `SafeMath` 库附加到 `uint256` 类型。 你可以在 [此处](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol)找到此程序库。
+此行将 `SafeMath` 库附加到 `uint256` 类型。 你可以在
+[此处](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol)找到此库。
-### 变量的定义 {#variable-definitions}
+### 变量定义 {#variable-definitions}
-这些定义具体指定了合约的状态变量。 虽然声明这些变量为 `private`，但 这只意味着区块链上的其他合约无法读取它们。 _区块链上 没有秘密_，所有节点上的软件在每个区块上 都有每个合约的状态。 根据惯例，状态变量名称为 `_`。
+这些定义指定了合约的状态变量。 这些变量被声明为 `private`，但这只意味着区块链上的其他合约无法读取它们。 区块链上
+_没有秘密_，每个节点上的软件都有每个区块中
+每个合约的状态。 按照惯例，状态变量命名为 `_`。
-前两个变量是[映射](https://www.tutorialspoint.com/solidity/solidity_mappings.htm)， 表示它们的结果与[关联数组](https://wikipedia.org/wiki/Associative_array)相同， 不同之处在于关键词为数值。 存储空间仅分配给数值不同于 默认值（零）的条目。
+前两个变量是[映射](https://www.tutorialspoint.com/solidity/solidity_mappings.htm)，
+这意味着它们的行为大致与[关联数组](https://wikipedia.org/wiki/Associative_array)相同，
+只是键是数值。 存储空间仅分配给值不同于
+默认值（零）的条目。
```solidity
mapping (address => uint256) private _balances;
```
-第一个映射，`_balances`，是代币地址和对应的余额。 要查看 余额，请使用此语法：`_balances[]`。
+第一个映射 `_balances` 是地址及其各自的此代币余额。 要访问
+余额，请使用此语法：`_balances[]`。
```solidity
- 映射 (address => mapping (address => uint256)) private _allowances;
+ mapping (address => mapping (address => uint256)) private _allowances;
```
-此变量，`_allowances` 存储之前提到过的许可限额。 第一个索引是 代币的所有者，第二个索引是获得许可限额的合约。 要查询地址 A 可以 从地址 B 帐户中支出的额度，请使用 `_allowances[B][A]`。
+此变量 `_allowances` 存储前面解释的授权额度。 第一个索引是
+代币的所有者，第二个索引是具有授权额度的合约。 要访问地址 A 可以
+从地址 B 的账户中花费的金额，请使用 `_allowances[B][A]`。
@@ -295,126 +349,142 @@ contract ERC20 is Context, IERC20 {
uint8 private _decimals;
```
-这三个变量用于提高可读性。 前两项的含义不言自明，但 `_decimals` 并非如此。
+这三个变量用于提高可读性。 前两项的含义不言自明，但 `_decimals`
+并非如此。
-一方面，以太坊不具有浮点数或分数变量。 另一方面， 人们希望能够拆分代币。 人们选择将黄金做为货币的一个原因是 当有人想要购买一只牛的一小部分时，就很难找零。
+一方面，以太坊没有浮点或分数变量。 另一方面，
+人们希望能够拆分代币。 人们选择将黄金作为货币的一个原因是，
+当有人想用牛换鸭子时，很难找零。
-解决方案是保持整数值，但是计数时使用一个价值非常小的分数代币， 而不是真正的代币。 就以太币而言，分数代币称为 wei，10^18 个 wei 等于一个 以太币。 在撰写本文时，10,000,000,000,000 wei 约等于一美分或欧分。
+解决方案是跟踪整数，但计数时使用一个价值非常小的分数代币，
+而不是真正的代币。 就以太币而言，分数代币称为 wei，10^18 个 wei 等于一个
+ETH。 在撰写本文时，10,000,000,000,000 wei 约等于一美分或欧分。
-应用程序需要知道如何显示代币余额。 如果某位用户有 3,141,000,000,000,000,000 wei，那是否是 3.14 个以太币？ 31.41 个以太币？ 还是 3,141 个以太币？ 对于以太币，10^18 个 wei 等于 1 个以太币，但对于你的 代币，你可以选择一个不同的值。 如果无法合理拆分代币，你可以将 `_decimals` 值设为零。 如果想要使用与以太币相同的标准，请使用 **18**。
+应用程序需要知道如何显示代币余额。 如果某位用户有 3,141,000,000,000,000,000 wei，那是否是
+3.14 个 ETH？ 31.41 个 ETH？ 3,141 个 ETH？ 对于以太币，10^18 wei 等于 1 个 ETH，但对于你的
+代币，你可以选择一个不同的值。 如果拆分代币没有意义，你可以将
+`_decimals` 值设为零。 如果想要使用与 ETH 相同的标准，请使用值 **18**。
### 构造函数 {#the-constructor}
```solidity
/**
- * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
- * a default value of 18.
+ * @dev 设置 {name} 和 {symbol} 的值，用
+ * 默认值 18 初始化 {decimals}。
*
- * To select a different value for {decimals}, use {_setupDecimals}.
+ * 要为 {decimals} 选择不同的值，请使用 {_setupDecimals}。
*
- * All three of these values are immutable: they can only be set once during
- * construction.
+ * 所有这三个值都是不可变的：它们只能在
+ * 构造期间设置一次。
*/
constructor (string memory name_, string memory symbol_) public {
+ // In Solidity ≥0.7.0, 'public' is implicit and can be omitted.
+
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
```
-构造函数在首次创建合约时调用。 根据惯例，函数参数名为 `_`。
+构造函数在首次创建合约时调用。 按照惯例，函数参数名为 `_`。
-### 用户接口函数 {#user-interface-functions}
+### 用户界面函数 {#user-interface-functions}
```solidity
/**
- * @dev Returns the name of the token.
+ * @dev 返回代币的名称。
*/
function name() public view returns (string memory) {
return _name;
}
/**
- * @dev Returns the symbol of the token, usually a shorter version of the
- * name.
+ * @dev 返回代币的符号，通常是
+ * 名称的缩写。
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
- * @dev Returns the number of decimals used to get its user representation.
- * For example, if `decimals` equals `2`, a balance of `505` tokens should
- * be displayed to a user as `5,05` (`505 / 10 ** 2`).
+ * @dev 返回用于获取其用户表示的小数位数。
+ * 例如，如果 `decimals` 等于 `2`，`505` 个代币的余额应
+ * 向用户显示为 `5,05` (`505 / 10 ** 2`)。
*
- * Tokens usually opt for a value of 18, imitating the relationship between
- * ether and wei. This is the value {ERC20} uses, unless {_setupDecimals} is
- * called.
+ * 代币通常选择值 18，模仿
+ * 以太币和 wei 之间的关系。这是 {ERC20} 使用的值，除非
+ * 调用 {_setupDecimals}。
*
- * NOTE: This information is only used for _display_ purposes: it in
- * no way affects any of the arithmetic of the contract, including
- * {IERC20-balanceOf} and {IERC20-transfer}.
+ * 注意：此信息仅用于_显示_目的：它
+ * 绝不影响合约的任何算术，包括
+ * {IERC20-balanceOf} 和 {IERC20-transfer}。
*/
function decimals() public view returns (uint8) {
return _decimals;
}
```
-这些函数，`name`、`symbol` 和 `decimals` 帮助用户界面了解合约，从而正常演示合约。
+这些函数，`name`、`symbol` 和 `decimals` 帮助用户界面了解你的合约，以便它们能够正确显示。
-返回类型为 `string memory`，意味着返回在内存中存储的字符串。 变量，如 字符串，可以存储在三个位置：
+返回类型是 `string memory`，表示返回存储在内存中的字符串。 变量，例如
+字符串，可以存储在三个位置：
-| | 有效时间 | 合约访问 | 燃料成本 |
+| | 生命周期 | 合约访问 | 燃料成本 |
| ---- | ----- | ---- | ------------------- |
-| 内存 | 函数调用 | 读/写 | 几十到几百不等（距离越远费用越高） |
-| 调用数据 | 函数调用 | 只读 | 不可用作返回类型，只可用作函数参数 |
-| 存储 | 直到被修改 | 读/写 | 高（读取需要 800，写入需要 2万） |
+| 内存 | 函数调用 | 读/写 | 几十到几百不等（位置越高成本越高） |
+| 调用数据 | 函数调用 | 只读 | 不能用作返回类型，只能用作函数参数类型 |
+| 存储 | 直到被修改 | 读/写 | 高（读取为 800，写入为 2 万） |
在这种情况下，`memory` 是最好的选择。
### 读取代币信息 {#read-token-information}
-这些是提供代币信息的函数，不管是总量还是 帐户余额。
+这些是提供代币信息的函数，无论是总供应量还是
+账户余额。
```solidity
/**
- * @dev See {IERC20-totalSupply}.
+ * @dev 请参阅 {IERC20-totalSupply}。
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
```
-`totalSupply` 函数返回代币的总量。
+`totalSupply` 函数返回代币的总供应量。
```solidity
/**
- * @dev See {IERC20-balanceOf}.
+ * @dev 请参阅 {IERC20-balanceOf}。
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
```
-读取一个帐户的余额。 请注意，任何人都可以查看他人帐户的余额。 试图隐藏此信息没有意义，因为它在每个节点上 都是可见的。 _区块链上没有秘密_
+读取账户余额。 请注意，任何人都可以获取其他任何人的账户
+余额。 试图隐藏此信息没有意义，因为它在每个节点上
+都是可见的。 _区块链上没有秘密。_
-### 代币转账 {#transfer-tokens}
+### 转移代币 {#transfer-tokens}
```solidity
/**
- * @dev See {IERC20-transfer}.
+ * @dev 请参阅 {IERC20-transfer}。
*
- * Requirements:
+ * 要求：
*
- * - `recipient` cannot be the zero address.
- * - the caller must have a balance of at least `amount`.
+ * - `recipient` 不能是零地址。
+ * - 调用者必须拥有至少 `amount` 的余额。
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
```
-调用 `transfer` 函数以从发送人的帐户转移代币到另一个帐户。 注意 虽然函数返回的是布尔值，但那个值始终为**真实值**。 如果转账失败， 合约会撤销调用。
+`transfer` 函数用于将代币从发送者的账户转移到另一个账户。 请注意
+，即使它返回一个布尔值，该值也始终为 **true**。 如果转移
+失败，合约将还原调用。
@@ -424,44 +494,51 @@ contract ERC20 is Context, IERC20 {
}
```
-`_transfer` 函数完成了实际工作。 这是一个私有函数，只能由 其他合约函数调用。 根据常规，私人函数名为 `_`，与状态 变量相同。
+`_transfer` 函数执行实际工作。 它是一个私有函数，只能由
+其他合约函数调用。 按照惯例，私有函数命名为 `_`，与状态
+变量相同。
-在 Solidity 中，我们通常使用 `msg.sender` 代表信息发送人。 然而，这会破坏 [OpenGSN](http://opengsn.org/) 的规则。 如果我们想使用代币进行交易而不用以太币，我们 需要使用 `_msgSender()`。 对于正常交易，它返回 `msg.sender`，但是对于没有以太币的交易， 则返回原始签名而不是传递信息的合约。
+通常在 Solidity 中，我们使用 `msg.sender` 表示消息发送者。 然而，这会破坏
+[OpenGSN](http://opengsn.org/)。 如果我们想允许使用我们的代币进行无以太币交易，我们
+需要使用 `_msgSender()`。 对于正常交易，它返回 `msg.sender`，但对于无以太币的交易，
+它返回原始签名者而不是中继消息的合约。
-### 许可额度函数 {#allowance-functions}
+### 授权额度函数 {#allowance-functions}
-这些是实现许可额度功能的函数：`allowance`、`approve`、`transferFrom` 和 `_approve`。 此外，除基本标准外，OpenZeppelin 实现还包含了一些能够提高 安全性的功能：`increaseAllowance` 和 ` decreaseAllowance `。
+这些是实现授权额度功能的函数：`allowance`、`approve`、`transferFrom`
+和 `_approve`。 此外，OpenZeppelin 实现超出了基本标准，包含了一些提高
+安全性的功能：`increaseAllowance` 和 `decreaseAllowance`。
-#### 许可额度函数 {#allowance}
+#### allowance 函数 {#allowance}
```solidity
/**
- * @dev See {IERC20-allowance}.
+ * @dev 请参阅 {IERC20-allowance}。
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
```
-`allowance` 函数使每个人都能检查任何许可额度。
+`allowance` 函数允许任何人检查任何授权额度。
-#### 审批函数 {#approve}
+#### approve 函数 {#approve}
```solidity
/**
- * @dev See {IERC20-approve}.
+ * @dev 请参阅 {IERC20-approve}。
*
- * Requirements:
+ * 要求：
*
- * - `spender` cannot be the zero address.
+ * - `spender` 不能是零地址。
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
```
-调用此函数以创建许可额度。 它与上述 `transfer` 函数相似：
+此函数用于创建授权额度。 它与上面的 `transfer` 函数相似：
-- 该函数仅调用一个完成真正工作的内部函数（本例中为 `_approve`）。
-- 函数要么返回 `true`（如果成功），要么撤销（如果失败）。
+- 该函数仅调用一个执行实际工作的内部函数（本例中为 `_approve`）。
+- 函数要么返回 `true`（如果成功），要么还原（如果失败）。
@@ -471,25 +548,27 @@ contract ERC20 is Context, IERC20 {
}
```
-我们使用内部函数尽量减少发生状态变化之处。 _任何_可以改变状态的 函数都是一种潜在的安全风险，需要对其安全性进行审核。 这样我们就能减少出错的机会。
+我们使用内部函数来尽量减少发生状态变化的地方。 _任何_改变
+状态的函数都是潜在的安全风险，需要进行安全审计。 这样我们出错的机会就更少了。
-#### TransferFrom 函数 {#transferFrom}
+#### transferFrom 函数 {#transferFrom}
-这个函数被消费者用于使用许可额度。 这里需要两步操作：将消费的金额转账， 并在许可额度中减去这笔金额。
+这个函数由花费者调用以花费授权额度。 这需要两个操作：转移花费的金额
+并从授权额度中减去该金额。
```solidity
/**
- * @dev See {IERC20-transferFrom}.
+ * @dev 请参阅 {IERC20-transferFrom}。
*
- * Emits an {Approval} event indicating the updated allowance. This is not
- * required by the EIP. See the note at the beginning of {ERC20}.
+ * 触发一个 {Approval} 事件，指示更新后的授权额度。EIP
+ * 并未要求此项。请参阅 {ERC20} 开头的注释。
*
- * Requirements:
+ * 要求：
*
- * - `sender` and `recipient` cannot be the zero address.
- * - `sender` must have a balance of at least `amount`.
- * - the caller must have allowance for ``sender``'s tokens of at least
- * `amount`.
+ * - `sender` 和 `recipient` 不能是零地址。
+ * - `sender` 必须拥有至少 `amount` 的余额。
+ * - 调用者必须拥有至少 `amount` 的 ``sender`` 代币授权额度
+ * 。
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual
override returns (bool) {
@@ -498,7 +577,9 @@ contract ERC20 is Context, IERC20 {
-`a.sub(b, "message")` 函数调用做了两件事。 首先，它计算了 `a-b`，这是新的许可额度。 之后，它检查这一结果是否为负数。 如果结果为负，将撤销调用，并发出相应的信息。 请注意，撤销调用后，之前在调用中完成的任何处理都会被忽略，所以我们不需要 撤消 `_transfer`。
+`a.sub(b, "message")` 函数调用做了两件事。 首先，它计算 `a-b`，这是新的授权额度。
+其次，它检查此结果是否为负数。 如果结果为负，将还原调用，并发出提供的消息。 请注意，当调用还原时，该调用期间先前完成的任何处理都将被忽略，因此我们不需要
+撤销 `_transfer`。
```solidity
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,
@@ -507,50 +588,60 @@ contract ERC20 is Context, IERC20 {
}
```
-#### OpenZeppelin 安全加法 {#openzeppelin-safety-additions}
+#### OpenZeppelin 安全补充 {#openzeppelin-safety-additions}
-将许可额度从一个非零值设定为另一个非零值是有危险的， 因为你只能控制自己的交易顺序，而无法控制其他人的交易顺序。 假设现在有两个用户，天真的 Alice 和不诚实的 Bill。 Alice 想要从 Bill 处获取一些服务， 她认为值五个代币，所以她给了 Bill 五个代币的许可额度。
+将非零授权额度设置为另一个非零值是危险的，
+因为你只能控制自己交易的顺序，而不能控制其他人的交易顺序。 假设现在有两个用户，天真的 Alice 和不诚实的 Bill。 Alice 想要从 Bill 处获取一些服务，
+她认为值五个代币，所以她给了 Bill 五个代币的授权额度。
-之后有了一些变化，Bill 的价格提高到了十个代币。 Alice 仍然想要购买服务，就发送了一笔交易，将 Bill 的许可额度设置为 10。 当 Bill 在交易池中看到这个新的交易时， 他就会发送一笔交易，以花费 Alice 的五个代币，并且设定高得多的 燃料价格，这样就会更快挖矿。 这样的话，Bill 可以先花五个代币，然后 当 Alice 的新许可额度放款后，他就可以再花费十个代币，这样总共花费了 15 个代币， 超过了 Alice 本欲授权的金额。 这种技术叫做 [抢先交易](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running)
+之后有了一些变化，Bill 的价格提高到了十个代币。 Alice 仍然想要购买服务，就发送了一笔交易，将 Bill 的授权额度设置为 10。 当 Bill 在交易池中看到这个新的交易时，
+他就会发送一笔交易，以花费 Alice 的五个代币，并且设定高得多的
+燃料价格，这样就会更快挖出。 这样，Bill 可以先花五个代币，然后
+当 Alice 的新授权额度被挖出后，他就可以再花费十个代币，这样总共花费了 15 个代币，
+超过了 Alice 本欲授权的金额。 这种技术称为
+[抢先交易](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running)
-| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的许可额度 | Bill 从 Alice 处获得的总收入 |
-| ----------------- | ---------- | ----------------------------- | --------- | ---------- | -------------------- |
-| approve(Bill, 5) | 10 | | | 5 | 0 |
-| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
-| approve(Bill, 10) | 11 | | | 10 | 5 |
-| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 15 |
+| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的授权额度 | Bill 从 Alice 处获得的总收入 |
+| ------------------------------------ | ---------- | ------------------------------------------------ | --------- | ---------- | -------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| approve(Bill, 10) | 11 | | | 10 | 5 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 15 |
-为了避免这个问题，有两个函数（`increaseAllowance` 和 `decreaseAllowance`）使你 能够修改指定数额的许可额度。 所以，如果 Bill 已经花费了五个代币， 他就只能再花五个代币。 根据时间的不同，有两种方法可以生效， 这两种方法都会使 Bill 最终只得到十个代币：
+为避免此问题，这两个函数（`increaseAllowance` 和 `decreaseAllowance`）允许你
+修改指定数额的授权额度。 所以，如果 Bill 已经花费了五个代币，
+他就只能再花五个代币。 根据时间的不同，有两种方法可以生效，
+这两种方法都会使 Bill 最终只得到十个代币：
A：
-| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的许可额度 | Bill 从 Alice 处获得的总收入 |
-| -------------------------- | ----------:| ---------------------------- | ---------:| ----------:| -------------------- |
-| approve(Bill, 5) | 10 | | | 5 | 0 |
-| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
-| increaseAllowance(Bill, 5) | 11 | | | 0+5 = 5 | 5 |
-| | | transferFrom(Alice, Bill, 5) | 10,124 | 0 | 10 |
+| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的授权额度 | Bill 从 Alice 处获得的总收入 |
+| --------------------------------------------- | ---------: | ----------------------------------------------- | --------: | ---------: | -------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| increaseAllowance(Bill, 5) | 11 | | | 0+5 = 5 | 5 |
+| | | transferFrom(Alice, Bill, 5) | 10,124 | 0 | 10 |
B：
-| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的许可额度 | Bill 从 Alice 处获得的总收入 |
-| -------------------------- | ----------:| ----------------------------- | ---------:| ----------:| --------------------:|
-| approve(Bill, 5) | 10 | | | 5 | 0 |
-| increaseAllowance(Bill, 5) | 11 | | | 5+5 = 10 | 0 |
-| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 10 |
+| Alice 的交易 | Alice 的随机数 | Bill 的交易 | Bill 的随机数 | Bill 的授权额度 | Bill 从 Alice 处获得的总收入 |
+| --------------------------------------------- | ---------: | ------------------------------------------------ | --------: | ---------: | -------------------: |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| increaseAllowance(Bill, 5) | 11 | | | 5+5 = 10 | 0 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 10 |
```solidity
/**
- * @dev Atomically increases the allowance granted to `spender` by the caller.
+ * @dev 以原子方式增加调用者授予 `spender` 的授权额度。
*
- * This is an alternative to {approve} that can be used as a mitigation for
- * problems described in {IERC20-approve}.
+ * 这是 {approve} 的替代方案，可用于缓解
+ * {IERC20-approve} 中描述的问题。
*
- * Emits an {Approval} event indicating the updated allowance.
+ * 触发一个 {Approval} 事件，指示更新后的授权额度。
*
- * Requirements:
+ * 要求：
*
- * - `spender` cannot be the zero address.
+ * - `spender` 不能是零地址。
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
@@ -558,23 +649,24 @@ B：
}
```
-`a.add(b)` 函数是一个安全加法。 在罕见的情况下，`a`+`b`>=`2^256`，不会发生 普通加法会出现的溢出错误。
+`a.add(b)` 函数是一个安全加法。 在 `a`+`b`>=`2^256` 的罕见情况下，它不会像
+普通加法那样发生环绕。
```solidity
/**
- * @dev Atomically decreases the allowance granted to `spender` by the caller.
+ * @dev 以原子方式减少调用者授予 `spender` 的授权额度。
*
- * This is an alternative to {approve} that can be used as a mitigation for
- * problems described in {IERC20-approve}.
+ * 这是 {approve} 的替代方案，可用于缓解
+ * {IERC20-approve} 中描述的问题。
*
- * Emits an {Approval} event indicating the updated allowance.
+ * 触发一个 {Approval} 事件，指示更新后的授权额度。
*
- * Requirements:
+ * 要求：
*
- * - `spender` cannot be the zero address.
- * - `spender` must have allowance for the caller of at least
- * `subtractedValue`.
+ * - `spender` 不能是零地址。
+ * - `spender` 必须拥有至少
+ * `subtractedValue` 的调用者授权额度。
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue,
@@ -585,29 +677,31 @@ B：
### 修改代币信息的函数 {#functions-that-modify-token-information}
-这些是完成实际工作的四个函数：`_transfer`、`_mint`、`_burn` 和 `_approve`。
+这些是执行实际工作的四个函数：`_transfer`、`_mint`、`_burn` 和 `_approve`。
-#### \_transfer 函数 {#_transfer}
+#### _transfer 函数 {#_transfer}
```solidity
/**
- * @dev Moves tokens `amount` from `sender` to `recipient`.
+ * @dev 将 `amount` 数量的代币从 `sender` 转移到 `recipient`。
*
- * This is internal function is equivalent to {transfer}, and can be used to
- * e.g., implement automatic token fees, slashing mechanisms, etc.
+ * 这个内部函数等同于 {transfer}，可用于
+ * 例如，实现自动代币费用、惩罚机制等。
*
- * Emits a {Transfer} event.
+ * 触发一个 {Transfer} 事件。
*
- * Requirements:
+ * 要求：
*
- * - `sender` cannot be the zero address.
- * - `recipient` cannot be the zero address.
- * - `sender` must have a balance of at least `amount`.
+ * - `sender` 不能是零地址。
+ * - `recipient` 不能是零地址。
+ * - `sender` 必须拥有至少 `amount` 的余额。
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
```
-`_transfer` 这个函数将代币从一个帐户转到另一个帐户。 有两个函数调用它，分别是 `transfer`（从发送人本人帐户发送）和 `transferFrom`（使用许可额度，从其他人的帐户发送）。
+这个函数 `_transfer` 将代币从一个账户转移到另一个账户。 它由
+`transfer`（用于从发送者自己的账户转移）和 `transferFrom`（用于使用授权额度
+从其他人的账户转移）调用。
@@ -616,7 +710,8 @@ B：
require(recipient != address(0), "ERC20: transfer to the zero address");
```
-实际上以太坊中没有人拥有零地址（即不存在对应公钥可以转换为零地址的私钥）。 有人使用该地址时，通常是一个软件漏洞，所以 如果将零地址用作发送人或接收人，交易将失败。
+实际上以太坊中没有人拥有零地址（即不存在对应公钥可以转换为零地址的私钥）。 当人们使用该地址时，通常是一个软件漏洞，所以
+如果将零地址用作发送人或接收人，交易将失败。
@@ -627,12 +722,15 @@ B：
使用该合约有两种方法：
-1. 将其作为模板，编写自己的代码
-1. [从它继承](https://www.bitdegree.org/learn/solidity-inheritance)一个合约，并且重写你需要修改的函数
+1. 将其用作你自己的代码的模板
+2. [继承它](https://www.bitdegree.org/learn/solidity-inheritance)，并仅覆盖你需要修改的那些函数
-第二种方法要好得多，因为 OpenZeppelin ERC-20 代码已经过审核，其安全性也已得到证实。 当你的合约继承它时， 可以清楚地表明修改了哪些函数，只需要审核这些特定的函数，人们就会信任你的合约。
+第二种方法要好得多，因为 OpenZeppelin ERC-20 代码已经过审核，其安全性也已得到证实。 当你使用继承时，
+你可以清楚地表明你修改了哪些函数，而信任你的合约的人只需要审核那些特定的函数。
-代币每次易手时，通常都需要调用一个函数。 然而，`_transfer` 是一个非常重要的函数， 重新编写可能会不安全（见下文），所以最好不要重写。 解决方案是重写 `_beforeTokenTransfer` 函数，这是一个[挂钩函数](https://wikipedia.org/wiki/Hooking)。 你可以重写此函数，之后每次转账都会调用它。
+代币每次易手时，执行一个函数通常很有用。 然而，`_transfer` 是一个非常重要的函数，
+编写它可能会不安全（见下文），所以最好不要覆盖它。 解决方案是 `_beforeTokenTransfer`，一个
+[钩子函数](https://wikipedia.org/wiki/Hooking)。 你可以覆盖此函数，每次转移都会调用它。
@@ -641,7 +739,10 @@ B：
_balances[recipient] = _balances[recipient].add(amount);
```
-这些是实际实现转账的代码。 请注意，将转账金额从发送人帐户上扣除，然后加到接收人帐户之间， 不得有任何**动作**。 这很重要，因为如果 中间调用不同的合约，可能会被用来骗过这个合约。 目前转账为最小操作单元，即中间什么都不会发生。
+这些是实际执行转移的代码。 请注意，它们之间**没有任何东西**，并且我们在将转账金额加到接收人账户之前，先从发送人账户中扣除
+。 这很重要，因为如果
+中间调用了另一个合约，可能会被用来骗过这个合约。 这样，转移
+是原子性的，中间不会发生任何事情。
@@ -650,23 +751,32 @@ B：
}
```
-最后，激发一个 `Transfer` 事件。 智能合约无法访问事件，但区块链外运行的代码 可以监听事件并对其作出反应。 例如，钱包可以跟踪所有者获得更多代币事件。
+最后，触发一个 `Transfer` 事件。 智能合约无法访问事件，但区块链外运行的代码
+可以监听事件并对其作出反应。 例如，钱包可以跟踪所有者何时获得更多代币。
-#### \_mint 和 \_burn 函数 {#_mint-and-_burn}
+#### _mint 和 _burn 函数 {#_mint-and-_burn}
-这两个函数（`_mint` 和 `_burn`）修改代币的总供应量。 它们都是内部函数，在原有合约中没有任何调用它们的函数。 因此，仅通过继承合约并添加你自己的逻辑， 来决定在什么条件下可以铸造新代币或消耗现有代币时， 它们才是有用的。
+这两个函数（`_mint` 和 `_burn`）修改代币的总供应量。
+它们是内部函数，在此合约中没有调用它们的函数，
+因此，仅当你继承该合约并添加自己的
+逻辑来决定在何种条件下铸造新代币或销毁现有
+代币时，它们才有用。
-**注意：**每一个 ERC-20 代币都通过自己的业务逻辑来决定代币管理。 例如，一个固定供应总量的合约可能只在构造函数中调用 `_mint`，而从不调用 `_burn`。 一个销售代币的合约 将在支付时调用 `_mint`，并大概在某个时间点调用 `_burn`， 以避免过快的通货膨胀。
+\*\*注意：\*\*每个 ERC-20 代币都有自己的业务逻辑来决定代币管理。
+例如，一个固定供应量的合约可能只在构造函数中调用 `_mint`
+，而从不调用 `_burn`。 一个销售代币的合约
+将在收到付款时调用 `_mint`，并大概在某个时间点调用 `_burn`，
+以避免失控的通货膨胀。
```solidity
- /** @dev Creates `amount` tokens and assigns them to `account`, increasing
- * the total supply.
+ /** @dev 创建 `amount` 数量的代币并将其分配给 `account`，增加
+ * 总供应量。
*
- * Emits a {Transfer} event with `from` set to the zero address.
+ * 触发一个 {Transfer} 事件，其中 `from` 设置为零地址。
*
- * Requirements:
+ * 要求：
*
- * - `to` cannot be the zero address.
+ * - `to` 不能是零地址。
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
@@ -681,17 +791,17 @@ B：
-```
+```solidity
/**
- * @dev Destroys `amount` tokens from `account`, reducing the
- * total supply.
+ * @dev 从 `account` 销毁 `amount` 数量的代币，减少
+ * 总供应量。
*
- * Emits a {Transfer} event with `to` set to the zero address.
+ * 触发一个 {Transfer} 事件，其中 `to` 设置为零地址。
*
- * Requirements:
+ * 要求：
*
- * - `account` cannot be the zero address.
- * - `account` must have at least `amount` tokens.
+ * - `account` 不能是零地址。
+ * - `account` 必须拥有至少 `amount` 的代币。
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
@@ -706,23 +816,26 @@ B：
`_burn` 函数与 `_mint` 函数几乎完全相同，但它们的方向相反。
-#### \_approve 函数 {#_approve}
+#### _approve 函数 {#_approve}
-这是实际设定许可额度的函数。 请注意，它允许所有者指定 一个高于所有者当前余额的许可额度。 这是允许的，因为在转账时 会核查余额，届时可能不同于 创建许可额度时的金额。
+这是实际指定授权额度的函数。 请注意，它允许所有者指定
+一个高于所有者当前余额的授权额度。 这是可以的，因为余额在
+转移时会进行检查，届时余额可能不同于创建授权额度时的
+余额。
```solidity
/**
- * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
+ * @dev 将 `spender` 对 `owner` 代币的授权额度设置为 `amount`。
*
- * This internal function is equivalent to `approve`, and can be used to
- * e.g., set automatic allowances for certain subsystems, etc.
+ * 此内部函数等同于 `approve`，可用于
+ * 例如，为某些子系统设置自动授权额度等。
*
- * Emits an {Approval} event.
+ * 触发一个 {Approval} 事件。
*
- * Requirements:
+ * 要求：
*
- * - `owner` cannot be the zero address.
- * - `spender` cannot be the zero address.
+ * - `owner` 不能是零地址。
+ * - `spender` 不能是零地址。
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
@@ -733,7 +846,8 @@ B：
-激发一个 `Approval` 事件。 根据应用程序的编写， 消费者合约可以从代币所有者或监听事件的服务器获知审批结果。
+触发一个 `Approval` 事件。 根据应用程序的编写方式，
+花费者合约可以从所有者或监听这些事件的服务器获知批准结果。
```solidity
emit Approval(owner, spender, amount);
@@ -741,57 +855,73 @@ B：
```
-### 修改小数点设置变量 {#modify-the-decimals-variable}
+### 修改 Decimals 变量 {#modify-the-decimals-variable}
```solidity
/**
- * @dev Sets {decimals} to a value other than the default one of 18.
+ * @dev 将 {decimals} 设置为不同于默认值 18 的值。
*
- * WARNING: This function should only be called from the constructor. Most
- * applications that interact with token contracts will not expect
- * {decimals} to ever change, and may work incorrectly if it does.
+ * 警告：此函数应仅从构造函数中调用。大多数
+ * 与代币合约交互的应用程序不希望
+ * {decimals} 发生变化，如果发生变化可能会导致工作不正常。
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
```
-此函数修改了 `>_decimals` 变量，此变量用于设置用户接口如何计算金额。 你应该从构造函数里面调用。 在之后的任何时候调用都是不正当的， 应用程序一般不会处理。
+此函数修改 `_decimals` 变量，该变量用于告知用户界面如何解释金额。
+你应该从构造函数中调用它。 在之后的任何时候调用都是不诚实的，
+应用程序也并非设计用于处理这种情况。
### 钩子 {#hooks}
```solidity
/**
- * @dev Hook that is called before any transfer of tokens. This includes
- * minting and burning.
+ * @dev 在任何代币转移之前调用的钩子函数。这包括
+ * 铸造和销毁。
*
- * Calling conditions:
+ * 调用条件：
*
- * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
- * will be to transferred to `to`.
- * - when `from` is zero, `amount` tokens will be minted for `to`.
- * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
- * - `from` and `to` are never both zero.
+ * - 当 `from` 和 `to` 都非零时，`amount` 数量的 ``from`` 代币
+ * 将被转移到 `to`。
+ * - 当 `from` 为零时，将为 `to` 铸造 `amount` 数量的代币。
+ * - 当 `to` 为零时，将销毁 `amount` 数量的 ``from`` 代币。
+ * - `from` 和 `to` 永远不会都为零。
*
- * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+ * 要了解有关钩子函数的更多信息，请转到 xref:ROOT:extending-contracts.adoc#using-hooks[使用钩子函数]。
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
```
-这是转账过程中要调用的挂钩函数。 该函数是空的，但如果你需要 它做一些事情，只需覆盖它即可。
+这是在转移过程中要调用的钩子函数。 这里是空的，但如果你需要
+它做一些事情，只需覆盖它即可。
+
+## 结论 {#conclusion}
-## 总结 {#conclusion}
+为了复习，以下是此合约中一些最重要的思想（在我看来，你的可能有所不同）：
-复习一下，这些是我认为此合约中最重要的概念（你们的看法可能与我不同）
+- _区块链上没有秘密_。 智能合约可以访问的任何信息
+ 都对全世界可见。
+- 你可以控制自己交易的顺序，但不能控制其他人交易发生的时间。 这就是为什么更改授权额度可能很危险，因为它让
+ 花费者可以花费两个授权额度的总和。
+- `uint256` 类型的值会环绕。 换言之，_0-1=2^256-1_。 如果这不是期望的
+ 行为，你必须检查它（或使用为你执行此操作的 SafeMath 库）。 请注意，这在
+ [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html) 中已更改。
+- 在特定位置执行特定类型的所有状态更改，因为这使审计更容易。
+ 这就是为什么我们有 `_approve`，它由 `approve`、`transferFrom`、
+ `increaseAllowance` 和 `decreaseAllowance` 调用
+- 状态更改应是原子性的，中间没有任何其他操作（如你在 `_transfer` 中看到的
+ ）。 这是因为在状态更改期间，你处于不一致的状态。 例如，
+ 在你从发送者的余额中扣除和添加到接收者的余额之间的
+ 时间里，存在的代币比应有的要少。 如果它们之间
+ 有操作，特别是调用另一个合约，这可能会被滥用。
-- _区块链上没有秘密_ 智能合约可以访问的任何信息 都可以提供给全世界。
-- 你可以控制自己交易的订单，但在其他人的交易发生时， 则不能控制。 这就是为什么更改许可额度时会有风险，因为它 允许消费者花掉这两个许可额度的总和。
-- `uint256` 类型值的溢出。 换言之，_0-1=2^256-1_。 如果这不是预期的 行为，你必须自行检查（或使用 SafeMath 库执行该服务）。 请注意， [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html) 中对此进行了更改。
-- 将特定类型变量的状态改变放在一个特定的地方，这样可以使审核更容易。 这就是我们使用以下等函数的原因，例如 `_approve` 函数，它可以被`approve`、`transferFrom`、 `increaseAllowance` 和 `decreaseAllowance` 调用。
-- 状态更改应为最小操作单元，其中没有任何其他动作 （如在 `_transfer` 中所见）。 这是因为在状态更改期间，会出现不一致的情况。 例如， 在减少发送人的余额，和增加接收人的余额之间， 代币总量会小于应有总量。 如果在这两个时刻之间有任何操作， 特别是调用不同的合约，则可能出现滥用。
+现在你已经了解了 OpenZeppelin ERC-20 合约是如何编写的，
+尤其是如何使其更加安全，你可以去编写自己的安全合约和应用程序了。
-现在你已经了解了 OpenZeppelin ERC-20 合约是怎么编写的， 尤其是如何使之更加安全，你即可编写自己的安全合约和应用程序。
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/erc20-with-safety-rails/index.md b/public/content/translations/zh/developers/tutorials/erc20-with-safety-rails/index.md
index 435ec89c661..8ab3075da73 100644
--- a/public/content/translations/zh/developers/tutorials/erc20-with-safety-rails/index.md
+++ b/public/content/translations/zh/developers/tutorials/erc20-with-safety-rails/index.md
@@ -1,62 +1,64 @@
---
-title: ERC-20 安全保障
-description: 如何帮助人们避免犯下低级错误
+title: "带安全保障的 ERC-20"
+description: "如何帮助人们避免犯下低级错误"
author: Ori Pomerantz
lang: zh
-tags:
- - "erc-20"
+tags: [ "erc-20" ]
skill: beginner
published: 2022-08-15
---
## 简介 {#introduction}
-以太坊的厉害之处之一在于不存在可以修改或取消你的交易的中心化组织。 但同时，以太坊也面临许多困难，其中之一便是没有任何中心化组织有权力消除用户错误或非法交易。 在这篇文章中，你将了解以太坊用户在使用 [ERC-20](/developers/docs/standards/tokens/erc-20/) 代币时犯下的一些常见错误以及如何创建 ERC-20 合约来帮助用户避免犯这些错误，或者赋予中心化组织某些权力（例如冻结帐户的权力）。
+以太坊的优点之一在于，没有任何中心化机构可以修改或撤销你的交易。 以太坊的一大问题也正在于此：没有任何中心化机构有权撤销用户错误或非法交易。 在本文中，你将了解用户在使用 [ERC-20](/developers/docs/standards/tokens/erc-20/) 代币时常犯的一些错误，以及如何创建 ERC-20 合约来帮助用户避免这些错误，或赋予中心化机构某些权力（例如冻结帐户）。
-请注意：虽然我们将使用 [OpenZeppelin ERC-20 代币合约](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)，本文未对此进行详细阐述。 你可以在[这里](/developers/tutorials/erc20-annotated-code)找到此信息。
+请注意，虽然我们将使用 [OpenZeppelin ERC-20 代币合约](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)，但本文不会对其进行详细解释。 你可以在[此处](/developers/tutorials/erc20-annotated-code)找到此信息。
-如果你想要查看完整的源代码：
+如果你想查看完整的源代码：
-1. 请打开 [Remix IDE](https://remix.ethereum.org/)。
-2. 点击克隆 github 图标 ()。
-3. 克隆 github 存储库 `https://github.com/qbzzt/20220815-erc20-safety-rails`。
-4. 打开**合约 > erc20-safety-rails.sol**。
+1. 打开 [Remix IDE](https://remix.ethereum.org/)。
+2. 点击克隆 GitHub 图标（）。
+3. 克隆 GitHub 仓库 `https://github.com/qbzzt/20220815-erc20-safety-rails`。
+4. 打开 **contracts > erc20-safety-rails.sol**。
## 创建 ERC-20 合约 {#creating-an-erc-20-contract}
-在添加安全保障功能之前，我们首先需要 ERC-20 合约。 在这篇文章中，我们将使用 [the OpenZeppelin 合约向导](https://docs.openzeppelin.com/contracts/5.x/wizard)。 在另一个浏览器中将其打开，然后遵循以下说明：
+在添加安全保障功能之前，我们首先需要 ERC-20 合约。 在本文中，我们将使用 [OpenZeppelin 合约向导](https://docs.openzeppelin.com/contracts/5.x/wizard)。 在另一个浏览器中将其打开，然后遵循以下说明：
+
+1. 选择 **ERC20**。
-1. 选择 **ERC-20**。
2. 请输入以下设置：
- | 参数 | 值 |
- | -------------- | ---------------- |
- | 姓名 | SafetyRailsToken |
- | Symbol | SAFE |
- | Premint | 1000 |
- | 特性 | 无 |
- | Access Control | Ownable |
- | Upgradability | 无 |
+ | 参数 | Value |
+ | ---- | ---------------- |
+ | 名称 | SafetyRailsToken |
+ | 符号 | SAFE |
+ | 预铸 | 1000 |
+ | 功能 | 无 |
+ | 访问控制 | Ownable |
+ | 可升级性 | 无 |
+
+3. 向上滚动并点击 **Open in Remix**（适用于 Remix）或 **Download** 以使用不同的环境。 我将假设你正在使用 Remix，如果你使用其他工具，请做相应更改。
-3. 向上滚动并点击 **Open in Remix**（适用于 Remix）或点击 **Download** 以使用另一个环境。 假设你正在使用 Remix，如果你想使用其他环境，只需要做些适当调整即可。
-4. 我们现在已经拥有一份功能齐全的 ERC-20 合约。 你可以展开 `.deps`>`npm` 查看导入的代码。
-5. 编译、部署并使用该合约，确认其作为 ERC-20 合约能否正常发挥作用。 如果你需要学习如何使用 Remix，请[使用本教程](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth)。
+4. 我们现在已经拥有一份功能齐全的 ERC-20 合约。 你可以展开 `.deps` > `npm` 查看导入的代码。
+
+5. 编译、部署并试用该合约，看看它是否能作为 ERC-20 合约正常运行。 如果你需要学习如何使用 Remix，请[参阅此教程](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth)。
## 常见错误 {#common-mistakes}
-### 错误 {#the-mistakes}
+### 这些错误 {#the-mistakes}
-用户有时会向错误的地址发送代币。 尽管有时我们很难理解他们这么做的目的，但有两种错误类型经常发生且很容易检测到：
+用户有时会向错误的地址发送代币。 虽然我们无法读懂他们的心思，不知道他们想做什么，但有两种经常发生且易于检测的错误类型：
-1. 给合约自己的地址发送代币。 例如，[Optimism 的 OP 代币](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c)在不到 2 个月的时间内累计[超过 120,000个](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000042#tokentxns)。 这代表着人们可能刚刚失去的大量财富。
+1. 将代币发送到合约自己的地址。 例如，[Optimism 的 OP 代币](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c)在不到两个月的时间里累积了[超过 120,000](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000042) 个 OP 代币。 这代表着一笔巨额财富，而人们很可能就这样白白损失了。
-2. 将代币发送到一个空地址，该地址并不对应一个[外部帐户](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs)或者一份[智能合约](/developers/docs/smart-contracts)。 尽管我没有关于这类情况发生频率的统计资料，但[这种事件发生一次，就能让用户损失 20,000,000 代币](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595)。
+2. 将代币发送到空地址，即不对应[外部帐户](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs)或[智能合约](/developers/docs/smart-contracts)的地址。 虽然我没有关于这种情况发生频率的统计数据，但有[一次事件可能造成了 20,000,000 代币的损失](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595)。
-### 防止转账 {#preventing-transfers}
+### 阻止转账 {#preventing-transfers}
-Open Zeppelin ERC-20 合约包含[一个钩子（`_beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368)），在转账代币之前会调用此钩子。 默认情况下，这个钩子不会发生任何作用，但是我们可以在钩子上挂起自己的功能，例如在出现问题时进行回滚的检查。
+OpenZeppelin ERC-20 合约包含一个[钩子 `_beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368)，它在代币转账前被调用。 默认情况下，这个钩子不执行任何操作，但我们可以在其上挂载自己的功能，例如在出现问题时进行回滚检查。
-若要使用此钩子，请在构造函数后面添加此函数：
+要使用这个钩子，请在构造函数后添加以下函数：
```solidity
function _beforeTokenTransfer(address from, address to, uint256 amount)
@@ -67,42 +69,42 @@ Open Zeppelin ERC-20 合约包含[一个钩子（`_beforeTokenTransfer`](https:/
}
```
-如果你不熟悉 Solidity，你可能对此函数的某些部分感到陌生。
+如果你不太熟悉 Solidity，此函数的某些部分对你来说可能比较陌生：
```solidity
internal virtual
```
-`virtual` 关键字表明，正如我们可以从 `ERC-20` 继承函数并重写此函数一样，其他合约也可以从我们这里继承函数并重写此函数。
+`virtual` 关键字表示，就像我们从 `ERC20` 继承功能并重写此函数一样，其他合约也可以从我们这里继承并重写此函数。
```solidity
override(ERC20)
```
-我们必须明确指定我们正在[重写](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding) `_beforeTokenTransfer` 的 ERC20 代币定义。 一般来说，从安全的角度来看，显式定义比隐式定义要好得多—如果你做过的事就在眼前，你就不会忘记你已经做了这件事。 这也是我们需要指定重写哪个超类的 `_beforeTokenTransfer` 的原因。
+我们必须明确指定我们正在[重写](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding) `_beforeTokenTransfer` 的 ERC20 代币定义。 通常，从安全角度来看，显式定义比隐式定义要好得多——如果做过的事情就在眼前，你就不会忘记。 这也是我们需要指定正在重写哪个超类的 `_beforeTokenTransfer` 的原因。
```solidity
super._beforeTokenTransfer(from, to, amount);
```
-这一行调用我们从其中继承函数的合约的 `_beforeTokenTransfer` 函数。 在这种情况下，只有 `ERC20` 和 `Ownable` 没有这个钩子。 尽管目前 `ERC20._beforeTokenTransfer` 没有执行任何操作，但我们还是会调用它，以防将来添加功能（然后我们决定重新部署合约，因为合约在部署后不会改变）。
+这行代码调用我们所继承的、且包含此函数的合约的 `_beforeTokenTransfer` 函数。 在本例中，只有 `ERC20` 有这个钩子，`Ownable` 没有。 尽管目前 `ERC20._beforeTokenTransfer` 不执行任何操作，但我们仍然调用它，以防将来添加新功能（然后我们决定重新部署合约，因为合约在部署后无法更改）。
-### 对要求进行编码 {#coding-the-requirements}
+### 将要求编写为代码 {#coding-the-requirements}
-我们希望在函数中添加以下要求：
+我们想向函数中添加这些要求：
- `to` 地址不能等于 `address(this)`，即 ERC-20 合约本身的地址。
-- `to` 地址不能为空，必须为以下任一地址：
- - 外部帐户 (EOA)。 我们无法直接检查地址是否为外部帐户，但可以检查地址的以太币余额。 外部帐户几乎总是有余额的，即使不再使用也是如此—余额很难降至最后一 Wei。
- - 智能合约。 测试一个地址是否是智能合约要难一些。 有一个检查外部代码长度的操作码，被称为 [`EXTCODESIZE`](https://www.evm.codes/#3b)，但它不能直接在 Solidity 中使用。 为此，我们必须使用以太坊虚拟机汇编语言 [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html)。 我们还可以使用 Solidity 的其他值（[`.code` 和 `.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)），但开销更大。
+- `to` 地址不能为空，它必须是以下之一：
+ - 一个外部帐户 (EOA)。 我们无法直接检查一个地址是否为 EOA，但可以检查该地址的 ETH 余额。 EOA 几乎总是有余额，即使不再使用也是如此——很难将余额清零到最后一个 wei。
+ - 一个智能合约。 测试一个地址是否为智能合约要更难一些。 有一个检查外部代码长度的操作码，名为 [`EXTCODESIZE`](https://www.evm.codes/#3b)，但它不能直接在 Solidity 中使用。 我们必须为此使用 [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html)，它是一种 EVM 汇编语言。 我们也可以使用 Solidity 中的其他值（[`.code` 和 `.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)），但它们成本更高。
-让我们逐行查看新代码：
+我们来逐行查看新代码：
```solidity
- require(to != address(this), "Can't send tokens to the contract address");
+ require(to != address(this), "不能将代币发送到合约地址");
```
-这是第一个要求，即检查确保 `to` 和 `this(address)` 不同。
+这是第一个要求，检查 `to` 和 `this(address)` 是否不相同。
```solidity
bool isToContract;
@@ -111,48 +113,48 @@ Open Zeppelin ERC-20 合约包含[一个钩子（`_beforeTokenTransfer`](https:/
}
```
-这就是我们检查地址是否为合约的方法。 我们无法直接从 Yul 接收输出，因此我们定义了一个变量来保留结果（本例中为 `isToContract`）。 Yul 的工作方式是将每个操作码都视为一个函数。 因此我们首先调用 [`EXTCODESIZE`](https://www.evm.codes/#3b) 来获取合约大小，然后使用 [`GT`](https://www.evm.codes/#11) 来检查它是否为零（我们处理的是无符号整数，所以它当然不能为负）。 然后，我们将结果写入 `isToContract` 中。
+我们通过这种方式检查一个地址是否为合约。 我们无法直接从 Yul 接收输出，因此我们定义了一个变量来保存结果（在本例中为 `isToContract`）。 Yul 的工作方式是，每个操作码都被视为一个函数。 所以我们首先调用 [`EXTCODESIZE`](https://www.evm.codes/#3b) 来获取合约大小，然后使用 [`GT`](https://www.evm.codes/#11) 来检查它是否不为零（我们处理的是无符号整数，所以它当然不可能是负数）。 然后我们将结果写入 `isToContract`。
```solidity
- require(to.balance != 0 || isToContract, "Can't send tokens to an empty address");
+ require(to.balance != 0 || isToContract, "不能将代币发送到空地址");
```
-最后，我们还要实际检查地址是否为空。
+最后，我们进行空地址的实际检查。
-## 管理访问 {#admin-access}
+## 管理访问权限 {#admin-access}
-有时，拥有可以撤消错误的管理员是很有用的。 为了减少滥用的可能性，该管理员可以是[多重签名](https://blog.logrocket.com/security-choices-multi-signature-wallets/)，因此必须有多人同意才能进行操作。 本文将介绍两种管理功能：
+有时候，有一个可以撤销错误的管理员是很有用的。 为了减少潜在的滥用，这个管理员可以是一个[多签](https://blog.logrocket.com/security-choices-multi-signature-wallets/)，这样就需要多个人同意才能执行一项操作。 本文将介绍两种管理功能：
-1. 冻结和解冻帐户。 例如，当帐户可能被泄露时，这就很有用。
+1. 冻结和解冻帐户。 例如，当帐户可能被盗用时，这就很有用。
2. 资产清理。
- 有时，欺诈者会将欺诈性代币发送到真实代币的合约中以获得合法性。 例如，[参见此处](https://optimistic.etherscan.io/token/0x2348b1a1228ddcd2db668c3d30207c3e1852fbbe?a=0x4200000000000000000000000000000000000042)。 合法的 ERC-20 合约是 [0x4200....0042](https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000042)。 冒充它的合约是 [0x234....bbe](https://optimistic.etherscan.io/address/0x2348b1a1228ddcd2db668c3d30207c3e1852fbbe)。
+ 有时，诈骗者会向真实代币的合约发送诈骗代币，以使其看起来合法。 例如，[请看这里](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe?tab=holders)。 合法的 ERC-20 合约是 [0x4200....0042](https://optimism.blockscout.com/token/0x4200000000000000000000000000000000000042)。 冒充它的诈骗合约是 [0x234....bbe](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe)。
也有可能有人误将合法的 ERC-20 代币发送到我们的合约中，这也是我们希望有办法将这些代币取出的另一个原因。
-OpenZeppelin 提供两种机制来实现管理访问：
+OpenZeppelin 提供了两种机制来实现管理访问：
-- [`Ownable`](https://docs.openzeppelin.com/contracts/5.x/access-control#ownership-and-ownable) 合约只有一个所有者。 具有 `onlyOwner`[ 修改器](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm)的函数只能由该所有者调用。 所有者可以将所有权转让给其他人或完全放弃。 所有其他帐户的权利通常是相同的。
+- [`Ownable`](https://docs.openzeppelin.com/contracts/5.x/access-control#ownership-and-ownable) 合约只有一个所有者。 带有 `onlyOwner` [修饰符](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm)的函数只能由该所有者调用。 所有者可以将所有权转让给其他人或完全放弃所有权。 所有其他帐户的权利通常是相同的。
- [`AccessControl`](https://docs.openzeppelin.com/contracts/5.x/access-control#role-based-access-control) 合约具有[基于角色的访问控制 (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control)。
-为简单起见，本文将使用 `Ownable`。
+为简单起见，本文使用 `Ownable`。
### 冻结和解冻合约 {#freezing-and-thawing-contracts}
-冻结和解冻合约需要几处更改：
+冻结和解冻合约需要进行几项更改：
-- 从地址到[布尔值](https://en.wikipedia.org/wiki/Boolean_data_type)的[映射](https://www.tutorialspoint.com/solidity/solidity_mappings.htm)来追踪哪些地址被冻结。 所有值的初始值都是 0，对于布尔值来说，它被解释为“false”。 这正是我们想要的，因为默认情况下帐户不会被冻结。
+- 一个从地址到[布尔值](https://en.wikipedia.org/wiki/Boolean_data_type)的[映射](https://www.tutorialspoint.com/solidity/solidity_mappings.htm)，用于跟踪哪些地址被冻结。 所有值的初始值都为零，对于布尔值，这被解释为 false。 这正是我们想要的，因为默认情况下帐户不会被冻结。
```solidity
mapping(address => bool) public frozenAccounts;
```
-- 当帐户被冻结或解冻时，用于通知相关人员的[事件](https://www.tutorialspoint.com/solidity/solidity_events.htm)。 从技术上讲，这些操作并不需要事件，但它有助于链下代码能够监听这些事件并了解正在发生的情况。 当发生与他人相关的事情时，智能合约能够发出这些信息，这被认为是一种很好的方式。
+- 使用[事件](https://www.tutorialspoint.com/solidity/solidity_events.htm)来通知所有相关方帐户被冻结或解冻。 从技术上讲，这些操作并不需要事件，但它有助于链下代码能够侦听这些事件并了解正在发生的情况。 当发生可能与其他人相关的事情时，智能合约发出事件被认为是一种良好实践。
- 这些事件都有索引，因此可以搜索帐户被冻结或解冻的所有时间。
+ 这些事件已编入索引，因此可以搜索某个帐户所有被冻结或解冻的时间。
```solidity
- // When accounts are frozen or unfrozen
+ // 当帐户被冻结或解冻时
event AccountFrozen(address indexed _addr);
event AccountThawed(address indexed _addr);
```
@@ -165,27 +167,27 @@ OpenZeppelin 提供两种机制来实现管理访问：
onlyOwner
```
- 标记为 [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) 的函数可由其他智能合约调用，也可由交易直接调用。
+ 标记为 [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) 的函数可以从其他智能合约调用，也可以通过交易直接调用。
```solidity
{
- require(!frozenAccounts[addr], "Account already frozen");
+ require(!frozenAccounts[addr], "帐户已被冻结");
frozenAccounts[addr] = true;
emit AccountFrozen(addr);
} // freezeAccount
```
- 如果帐户已被冻结，则会回滚。 否则，冻结帐户并 `emit` 一个事件。
+ 如果帐户已被冻结，则回滚。 否则，冻结它并 `emit` 一个事件。
- 更改 `_beforeTokenTransfer` 以防止资金从冻结帐户中转出。 请注意，资金仍可转入冻结帐户。
```solidity
- require(!frozenAccounts[from], "The account is frozen");
+ require(!frozenAccounts[from], "该帐户已被冻结");
```
### 资产清理 {#asset-cleanup}
-要释放此合约持有的 ERC-20 代币，我们需要调用它们所属代币合约上的函数，即 [ `transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) 或 [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve)。 在这种情况下，没有必要将燃料浪费在许可额度上，我们也可以直接转账。
+要释放此合约持有的 ERC-20 代币，我们需要在该代币所属的代币合约上调用一个函数，即 [`transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) 或 [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve)。 在这种情况下，没有必要将燃料浪费在许可额度上，我们不如直接转账。
```solidity
function cleanupERC20(
@@ -198,7 +200,7 @@ OpenZeppelin 提供两种机制来实现管理访问：
IERC20 token = IERC20(erc20);
```
-这是我们收到地址时为合约创建对象的语法。 我们可以做到这一点，是因为我们将 ERC20 代币的定义作为源代码的一部分（见第 4 行），该文件包括 [IERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) 的定义，即 OpenZeppelin ERC-20 合约的接口。
+这是我们在收到地址时为合约创建对象的语法。 我们可以这样做，因为我们的源代码中包含了 ERC20 代币的定义（见第 4 行），并且该文件包含了 [IERC20 的定义](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)，即 OpenZeppelin ERC-20 合约的接口。
```solidity
uint balance = token.balanceOf(address(this));
@@ -206,8 +208,10 @@ OpenZeppelin 提供两种机制来实现管理访问：
}
```
-这是一个清理函数，所以我们可能不想留下任何代币。 与其手动从用户那里获取余额，我们不如将这一过程自动化。
+这是一个清理函数，所以我们大概不希望留下任何代币。 与其让用户手动获取余额，我们不如将这个过程自动化。
## 结论 {#conclusion}
-这并不是一个完美的解决方案—“用户犯错误”的问题没有完美的解决方案。 不过，使用这类检查至少可以避免一些错误。 冻结帐户的功能虽然危险，但可以通过阻止黑客窃取资金来限制某些黑客攻击的危害。
+这不是一个完美的解决方案——“用户犯错”问题没有完美的解决方案。 不过，使用这类检查至少可以避免一些错误。 冻结帐户的功能虽然危险，但可以通过拒绝黑客获得被盗资金来限制某些黑客攻击造成的损害。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/zh/developers/tutorials/ethereum-for-web2-auth/index.md
new file mode 100644
index 00000000000..0968f82f1eb
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -0,0 +1,886 @@
+---
+title: "使用以太坊进行 web2 身份验证"
+description: "阅读本教程后，开发者将能够把以太坊登录 (web3) 与 SAML 登录集成。SAML 是 web2 中用于提供单点登录和其他相关服务的标准。 这允许通过以太坊签名对访问 web2 资源的请求进行身份验证，用户属性则来自认证。"
+author: Ori Pomerantz
+tags: [ "web2", "认证", "eas" ]
+skill: beginner
+lang: zh
+published: 2025-04-30
+---
+
+## 简介
+
+[SAML](https://www.onelogin.com/learn/saml) 是 web2 中使用的一种标准，允许[身份提供者 (IdP)](https://en.wikipedia.org/wiki/Identity_provider#SAML_identity_provider) 为[服务提供者 (SP)](https://en.wikipedia.org/wiki/Service_provider_\(SAML\)) 提供用户信息。
+
+在本教程中，您将学习如何将以太坊签名与 SAML 集成，以允许用户使用其以太坊钱包向尚不支持原生以太坊的 web2 服务进行身份验证。
+
+请注意，本教程面向两类不同的受众：
+
+- 了解以太坊并需要学习 SAML 的以太坊人士
+- 了解 SAML 和 web2 身份验证并需要学习以太坊的 Web2 人士
+
+因此，本教程会包含许多您已了解的介绍性材料。 您可以随意跳过。
+
+### 面向以太坊人士的 SAML
+
+SAML 是一种中心化协议。 服务提供者 (SP) 仅在与身份提供者 (IdP) 或签署 IdP 证书的[证书颁发机构](https://www.ssl.com/article/what-is-a-certificate-authority-ca/)存在预先信任关系时，才会接受来自 IdP 的断言（例如“这是我的用户 John，他应有权执行 A、B 和 C”）。
+
+例如，SP 可以是为公司提供差旅服务的旅行社，而 IdP 可以是公司的内部网站。 当员工需要预订商务差旅时，旅行社会先将他们发送至公司进行身份验证，然后才允许他们实际预订差旅。
+
+
+
+这就是浏览器、SP 和 IdP 这三个实体协商访问权限的方式。 SP 无需提前了解任何有关使用浏览器的用户的信息，只需信任 IdP 即可。
+
+### 面向 SAML 人士的以太坊
+
+以太坊是一个去中心化系统。
+
+
+
+用户拥有私钥（通常保存在浏览器扩展程序中）。 您可以从私钥派生出公钥，再从公钥派生出 20 字节的地址。 当用户需要登录系统时，系统会要求他们使用随机数（一次性值）签署一条信息。 服务器可以验证签名是由该地址创建的。
+
+
+
+签名仅验证以太坊地址。 要获取其他用户属性，您通常会使用[认证](https://attest.org/)。 一份认证通常包含以下字段：
+
+- **认证者**，进行认证的地址
+- **接收者**，认证适用的地址
+- **数据**，被认证的数据，例如姓名、权限等。
+- **模式**，用于解释数据的模式 ID。
+
+由于以太坊的去中心化特性，任何用户都可以创建认证。 认证者的身份对于确定哪些认证是可靠的至关重要。
+
+## 设置
+
+第一步是让 SAML SP 和 SAML IdP 能够相互通信。
+
+1. 下载软件。 本文的示例软件[在 Github 上](https://github.com/qbzzt/250420-saml-ethereum)。 不同阶段存储在不同分支中，此阶段您需要 `saml-only`
+
+ ```sh
+ git clone https://github.com/qbzzt/250420-saml-ethereum -b saml-only
+ cd 250420-saml-ethereum
+ pnpm install
+ ```
+
+2. 使用自签名证书创建密钥。 这意味着该密钥本身就是其证书颁发机构，需要手动将其导入服务提供者。 有关详细信息，请参阅 [OpenSSL 文档](https://docs.openssl.org/master/man1/openssl-req/)。
+
+ ```sh
+ mkdir keys
+ cd keys
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-sp.crt -keyout saml-sp.pem -subj /CN=sp/
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-idp.crt -keyout saml-idp.pem -subj /CN=idp/
+ cd ..
+ ```
+
+3. 启动服务器（SP 和 IdP）
+
+ ```sh
+ pnpm start
+ ```
+
+4. 浏览到 SP 的 URL [http://localhost:3000/](http://localhost:3000/)，然后单击按钮重定向到 IdP（端口 3001）。
+
+5. 向 IdP 提供您的电子邮件地址，然后单击**登录服务提供者**。 您会看到您被重定向回服务提供者（端口 3000），并且它通过您的电子邮件地址识别了您。
+
+### 详细说明
+
+以下是分步说明：
+
+
+
+#### src/config.mts
+
+此文件包含身份提供者和服务提供者的配置。 通常这两者是不同的实体，但为了简单起见，我们可以在这里共享代码。
+
+```typescript
+const fs = await import("fs")
+
+const protocol="http"
+```
+
+我们目前只是在测试，所以使用 HTTP 没问题。
+
+```typescript
+export const spCert = fs.readFileSync("keys/saml-sp.crt").toString()
+export const idpCert = fs.readFileSync("keys/saml-idp.crt").toString()
+```
+
+读取公钥，公钥通常对两个组件都可用（可以直接信任，也可以由受信任的证书颁发机构签名）。
+
+```typescript
+export const spPort = 3000
+export const spHostname = "localhost"
+export const spDir = "sp"
+
+export const idpPort = 3001
+export const idpHostname = "localhost"
+export const idpDir = "idp"
+
+export const spUrl = `${protocol}://${spHostname}:${spPort}/${spDir}`
+export const idpUrl = `${protocol}://${idpHostname}:${idpPort}/${idpDir}`
+```
+
+两个组件的 URL。
+
+```typescript
+export const spPublicData = {
+```
+
+服务提供者的公开数据。
+
+```typescript
+ entityID: `${spUrl}/metadata`,
+```
+
+按照惯例，在 SAML 中，`entityID` 是实体的元数据所在的 URL。 此元数据对应于此处的公共数据，但其格式为 XML。
+
+```typescript
+ wantAssertionsSigned: true,
+ authnRequestsSigned: false,
+ signingCert: spCert,
+ allowCreate: true,
+ assertionConsumerService: [{
+ Binding: 'urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST',
+ Location: `${spUrl}/assertion`,
+ }]
+ }
+```
+
+对我们来说，最重要的定义是 `assertionConsumerServer`。 它意味着，要向服务提供者断言某事（例如，“向您发送此信息的用户是 somebody@example.com”），我们需要使用 [HTTP POST](https://www.w3schools.com/tags/ref_httpmethods.asp) 到 URL `http://localhost:3000/sp/assertion`。
+
+```typescript
+export const idpPublicData = {
+ entityID: `${idpUrl}/metadata`,
+ signingCert: idpCert,
+ wantAuthnRequestsSigned: false,
+ singleSignOnService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/login`
+ }],
+ singleLogoutService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/logout`
+ }],
+ }
+```
+
+身份提供者的公共数据是类似的。 它指定要登录用户，您需要 POST 到 `http://localhost:3001/idp/login`，要注销用户，则 POST 到 `http://localhost:3001/idp/logout`。
+
+#### src/sp.mts
+
+这是实现服务提供者的代码。
+
+```typescript
+import * as config from "./config.mts"
+const fs = await import("fs")
+const saml = await import("samlify")
+```
+
+我们使用 [`samlify`](https://www.npmjs.com/package/samlify) 程序库来实现 SAML。
+
+```typescript
+import * as validator from "@authenio/samlify-node-xmllint"
+saml.setSchemaValidator(validator)
+```
+
+`samlify` 程序库需要一个包来验证 XML 是否正确、是否使用预期的公钥签名等。 为此，我们使用 [`@authenio/samlify-node-xmllint`](https://www.npmjs.com/package/@authenio/samlify-node-xmllint)。
+
+```typescript
+const express = (await import("express")).default
+const spRouter = express.Router()
+const app = express()
+```
+
+`express`](https://expressjs.com/) [`Router`](https://expressjs.com/en/5x/api.html#router) 是一个可以挂载在网站内部的“迷你网站”。 在本例中，我们用它将所有服务提供者的定义组合在一起。
+
+```typescript
+const spPrivateKey = fs.readFileSync("keys/saml-sp.pem").toString()
+
+const sp = saml.ServiceProvider({
+ privateKey: spPrivateKey,
+ ...config.spPublicData
+})
+```
+
+服务提供者自身的表示是所有的公共数据以及用于签署信息的私钥。
+
+```typescript
+const idp = saml.IdentityProvider(config.idpPublicData);
+```
+
+公共数据包含服务提供者需要了解的关于身份提供者的一切信息。
+
+```typescript
+spRouter.get(`/metadata`,
+ (req, res) => res.header("Content-Type", "text/xml").send(sp.getMetadata())
+)
+```
+
+为了实现与其他 SAML 组件的互操作性，服务和身份提供者应在 `/metadata` 中以 XML 格式提供其公共数据（称为元数据）。
+
+```typescript
+spRouter.post(`/assertion`,
+```
+
+这是浏览器用来标识自己的页面。 断言包括用户标识符（此处我们使用电子邮件地址），并且可以包括其他属性。 这是上述序列图中步骤 7 的处理程序。
+
+```typescript
+ async (req, res) => {
+ // console.log(`SAML 响应：\n${Buffer.from(req.body.SAMLResponse, 'base64').toString('utf-8')}`)
+```
+
+您可以使用注释掉的命令来查看断言中提供的 XML 数据。 它经过 [base64 编码](https://en.wikipedia.org/wiki/Base64)。
+
+```typescript
+ try {
+ const loginResponse = await sp.parseLoginResponse(idp, 'post', req);
+```
+
+解析来自身份服务器的登录请求。
+
+```typescript
+ res.send(`
+
+
+ 你好 ${loginResponse.extract.nameID}
+
+
+ `)
+ res.send();
+```
+
+发送 HTML 响应，只是为了向用户显示我们已成功登录。
+
+```typescript
+ } catch (err) {
+ console.error('处理 SAML 响应时出错：', err);
+ res.status(400).send('SAML 身份验证失败');
+ }
+ }
+)
+```
+
+如果失败，通知用户。
+
+```typescript
+spRouter.get('/login',
+```
+
+当浏览器尝试获取此页面时，创建一个登录请求。 这是上述序列图中步骤 1 的处理程序。
+
+```typescript
+ async (req, res) => {
+ const loginRequest = await sp.createLoginRequest(idp, "post")
+```
+
+获取信息以发布登录请求。
+
+```typescript
+ res.send(`
+
+
+
+```
+
+此页面会自动提交表单（见下文）。 这样，用户无需执行任何操作即可被重定向。 这是上述序列图中的步骤 2。
+
+```typescript
+
+
+
+ `)
+ }
+)
+
+app.use(express.urlencoded({extended: true}))
+```
+
+[此中间件](https://expressjs.com/en/5x/api.html#express.urlencoded) 读取 [HTTP 请求](https://www.tutorialspoint.com/http/http_requests.htm)的正文。 默认情况下，express 会忽略它，因为大多数请求都不需要它。 我们需要它，因为 POST 会使用正文。
+
+```typescript
+app.use(`/${config.spDir}`, spRouter)
+```
+
+将路由器挂载在服务提供者目录 (`/sp`) 中。
+
+```typescript
+app.get("/", (req, res) => {
+ res.send(`
+
+
+
+
+
+ `)
+})
+```
+
+如果浏览器尝试获取根目录，请为其提供一个指向登录页面的链接。
+
+```typescript
+app.listen(config.spPort, () => {
+ console.log(`服务提供者正在运行于 http://${config.spHostname}:${config.spPort}`)
+})
+```
+
+使用此 express 应用监听 `spPort`。
+
+#### src/idp.mts
+
+这是身份提供者。 它与服务提供者非常相似，下面的解释针对的是不同的部分。
+
+```typescript
+const xmlParser = new (await import("fast-xml-parser")).XMLParser(
+ {
+ ignoreAttributes: false, // 保留属性
+ attributeNamePrefix: "@_", // 属性前缀
+ }
+)
+```
+
+我们需要读取并理解从服务提供者收到的 XML 请求。
+
+```typescript
+const getLoginPage = requestId => `
+```
+
+此函数创建带有自动提交表单的页面，该页面在上述序列图的步骤 4 中返回。
+
+```typescript
+
+
+ 登录页面
+
+
+ 登录页面
+
+
+
+
+const idpRouter = express.Router()
+
+idpRouter.post("/loginSubmitted", async (req, res) => {
+ const loginResponse = await idp.createLoginResponse(
+```
+
+这是上述序列图中步骤 5 的处理程序。 [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) 创建登录响应。
+
+```typescript
+ sp,
+ {
+ authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+ audience: sp.entityID,
+```
+
+受众是服务提供者。
+
+```typescript
+ extract: {
+ request: {
+ id: req.body.requestId
+ }
+ },
+```
+
+从请求中提取的信息。 我们在请求中关心的唯一参数是 requestId，它让服务提供者能够匹配请求及其响应。
+
+```typescript
+ signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert } // 确保签名
+```
+
+我们需要 `signingKey` 来获取签署响应的数据。 服务提供者不信任未签名的请求。
+
+```typescript
+ },
+ "post",
+ {
+ email: req.body.email
+```
+
+这是我们发送回服务提供者的包含用户信息的字段。
+
+```typescript
+ }
+ );
+
+ res.send(`
+
+
+
+
+
+
+
+ `)
+})
+```
+
+同样，使用自动提交的表单。 这是上述序列图中的步骤 6。
+
+```typescript
+
+// 用于登录请求的 IdP 端点
+idpRouter.post(`/login`,
+```
+
+这是接收来自服务提供者的登录请求的端点。 这是上述序列图中的步骤 3 的处理程序。
+
+```typescript
+ async (req, res) => {
+ try {
+ // 权宜之计，因为我无法让 parseLoginRequest 工作。
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+```
+
+我们应该能够使用 [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144) 来读取身份验证请求的 ID。 然而，我无法使其正常工作，也不值得花太多时间在这上面，所以我只是用了一个[通用的 XML 解析器](https://www.npmjs.com/package/fast-xml-parser)。 我们需要的信息是 `` 标签内的 `ID` 属性，它位于 XML 的顶层。
+
+## 使用以太坊签名
+
+既然我们能将用户身份发送到服务提供者，下一步就是以可信的方式获取用户身份。 Viem 允许我们直接向钱包请求用户地址，但这相当于向浏览器请求信息。 我们无法控制浏览器，所以我们不能自动信任从它那里得到的响应。
+
+因此，IdP 将向浏览器发送一个字符串以供签名。 如果浏览器中的钱包签署了这个字符串，就意味着它确实是那个地址（也就是说，它知道与该地址对应的私钥）。
+
+要看到此操作的实际效果，请停止现有的 IdP 和 SP，然后运行以下命令：
+
+```sh
+git checkout eth-signatures
+pnpm install
+pnpm start
+```
+
+然后浏览[到 SP](http://localhost:3000) 并按照指示操作。
+
+请注意，此时我们不知道如何从以太坊地址获取电子邮件地址，因此我们向 SP 报告 `@bad.email.address`。
+
+### 详细说明
+
+更改在前一个图中的步骤 4-5。
+
+
+
+我们唯一更改的文件是 `idp.mts`。 以下是更改的部分。
+
+```typescript
+import { v4 as uuidv4 } from 'uuid'
+import { verifyMessage } from 'viem'
+```
+
+我们需要这两个额外的程序库。 我们使用 [`uuid`](https://www.npmjs.com/package/uuid) 来创建[随机数](https://en.wikipedia.org/wiki/Cryptographic_nonce)值。 值本身不重要，重要的是它只使用一次。
+
+[`viem`](https://viem.sh/) 程序库让我们能够使用以太坊定义。 这里我们需要它来验证签名是否确实有效。
+
+```typescript
+const loginPrompt = "要访问服务提供者，请签署此随机数："
+```
+
+钱包会请求用户允许签署该信息。 只包含随机数的信息可能会让用户感到困惑，所以我们加入了这个提示。
+
+```typescript
+// 在此处保留 requestID
+let nonces = {}
+```
+
+我们需要请求信息才能对其做出响应。 我们可以在请求时发送它（步骤 4），然后在响应时接收它（步骤 5）。 然而，我们不能信任从浏览器获得的信息，因为它可能受恶意用户的控制。 所以最好将其存储在这里，以随机数作为密钥。
+
+请注意，为简单起见，我们在此将其作为变量。 然而，这有几个缺点：
+
+- 我们容易受到拒绝服务攻击。 恶意用户可以多次尝试登录，从而耗尽我们的内存。
+- 如果 IdP 进程需要重新启动，我们就会丢失现有的值。
+- 我们无法在多个进程之间进行负载均衡，因为每个进程都有自己的变量。
+
+在生产系统上，我们会使用数据库并实现某种过期机制。
+
+```typescript
+const getSignaturePage = requestId => {
+ const nonce = uuidv4()
+ nonces[nonce] = requestId
+```
+
+创建一个随机数，并存储 `requestId` 以备将来使用。
+
+```typescript
+ return `
+
+
+
+
+
+ 请签名
+
+
+
+
+
+`
+}
+```
+
+其余的只是标准 HTML。
+
+```typescript
+idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => {
+```
+
+这是序列图中的步骤 5 的处理程序。
+
+```typescript
+ const requestId = nonces[req.params.nonce]
+ if (requestId === undefined) {
+ res.send("错误的随机数")
+ return ;
+ }
+
+ nonces[req.params.nonce] = undefined
+```
+
+获取请求 ID，并从 `nonces` 中删除该随机数以确保其不能被重用。
+
+```typescript
+ try {
+```
+
+因为签名无效的方式有很多，所以我们将此包装在 `try ...` 中。 `catch` 区块以捕获任何抛出的错误。
+
+```typescript
+ const validSignature = await verifyMessage({
+ address: req.params.account,
+ message: `${loginPrompt}${req.params.nonce}`,
+ signature: req.params.signature
+ })
+```
+
+使用 [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage) 实现序列图中的步骤 5.5。
+
+```typescript
+ if (!validSignature)
+ throw("签名无效")
+ } catch (err) {
+ res.send("错误：" + err)
+ return ;
+ }
+```
+
+处理程序的其余部分与我们之前在 `/loginSubmitted` 处理程序中所做的相同，只有一个小改动。
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ .
+ .
+ .
+ {
+ email: req.params.account + "@bad.email.address"
+ }
+ );
+```
+
+我们没有实际的电子邮件地址（我们将在下一节中获取），因此暂时返回以太坊地址，并明确标记它不是电子邮件地址。
+
+```typescript
+// 用于登录请求的 IdP 端点
+idpRouter.post(`/login`,
+ async (req, res) => {
+ try {
+ // 权宜之计，因为我无法让 parseLoginRequest 工作。
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+ } catch (err) {
+ console.error('处理 SAML 响应时出错：', err);
+ res.status(400).send('SAML 身份验证失败');
+ }
+ }
+)
+```
+
+在步骤 3 的处理程序中，现在使用 `getSignaturePage` 代替 `getLoginPage`。
+
+## 获取电子邮件地址
+
+下一步是获取服务提供者请求的标识符，即电子邮件地址。 为此，我们使用[以太坊认证服务 (EAS)](https://attest.org/)。
+
+获取认证的最简单方法是使用 [GraphQL 应用程序接口](https://docs.attest.org/docs/developer-tools/api)。 我们使用以下查询：
+
+```
+query GetAttestationsByRecipient {
+ attestations(
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+ take: 1
+ ) {
+ data
+ id
+ attester
+ }
+}
+```
+
+此 [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) 仅包含一个电子邮件地址。 此查询请求此模式的认证。 认证的主题称为 `recipient`。 它总是一个以太坊地址。
+
+警告：我们在这里获取认证的方式存在两个安全问题。
+
+- 我们访问的 API 端点 `https://optimism.easscan.org/graphql` 是一个中心化组件。 我们可以获取 `id` 属性，然后在链上进行查找以验证认证是否真实，但 API 端点仍然可以通过不告知我们某些认证来对其进行审查。
+
+ 这个问题并非无法解决，我们可以运行自己的 GraphQL 端点，并从链上日志中获取认证，但这对于我们的目的来说过于繁琐。
+
+- 我们不查看认证者身份。 任何人都可以向我们提供虚假信息。 在实际实现中，我们会有一组受信任的认证者，并且只查看他们的认证。
+
+要看到此操作的实际效果，请停止现有的 IdP 和 SP，然后运行以下命令：
+
+```sh
+git checkout email-address
+pnpm install
+pnpm start
+```
+
+然后提供您的电子邮件地址。 您有两种方法可以做到这一点：
+
+- 使用私钥导入钱包，并使用测试私钥 `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80`。
+
+- 为您的电子邮件地址添加认证：
+
+ 1. 在认证浏览器中浏览到[该模式](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977)。
+
+ 2. 单击**用模式认证**。
+
+ 3. 输入您的以太坊地址作为接收者，您的电子邮件地址作为 email address，并选择**链上**。 然后单击**创建认证**。
+
+ 4. 在您的钱包中批准交易。 您需要在 [Optimism 区块链](https://app.optimism.io/bridge/deposit)上有一些 ETH 来支付燃料费。
+
+无论哪种方式，完成后请浏览至 [http://localhost:3000](http://localhost:3000) 并按照指示操作。 如果您导入了测试私钥，您收到的电子邮件将是 `test_addr_0@example.com`。 如果您使用自己的地址，它应该是您认证的任何内容。
+
+### 详细说明
+
+
+
+新的步骤是 GraphQL 通信，即步骤 5.6 和 5.7。
+
+同样，以下是 `idp.mts` 的更改部分。
+
+```typescript
+import { GraphQLClient } from 'graphql-request'
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk'
+```
+
+导入我们需要的程序库。
+
+```typescript
+const graphqlEndpointUrl = "https://optimism.easscan.org/graphql"
+```
+
+[每个区块链都有一个单独的端点](https://docs.attest.org/docs/developer-tools/api)。
+
+```typescript
+const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch })
+```
+
+创建一个新的 `GraphQLClient` 客户端，我们可以用它来查询端点。
+
+```typescript
+const graphqlSchema = 'string emailAddress'
+const graphqlEncoder = new SchemaEncoder(graphqlSchema)
+```
+
+GraphQL 只给我们一个包含字节的不透明数据对象。 为了理解它，我们需要模式。
+
+```typescript
+const ethereumAddressToEmail = async ethAddr => {
+```
+
+一个从以太坊地址转换到电子邮件地址的函数。
+
+```typescript
+ const query = `
+ query GetAttestationsByRecipient {
+```
+
+这是一个 GraphQL 查询。
+
+```typescript
+ 认证(
+```
+
+我们正在寻找认证。
+
+```typescript
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+```
+
+我们想要的认证是那些在我们模式中，接收者是 `getAddress(ethAddr)` 的认证。 [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) 函数确保我们的地址具有正确的[校验和](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md)。 这对于 GraphQL 来说是必要的，因为它是大小写敏感的。 "0xBAD060A7"、"0xBad060A7" 和 "0xbad060a7" 是不同的值。
+
+```typescript
+ take: 1
+```
+
+无论我们找到多少认证，我们都只想要第一个。
+
+```typescript
+ ) {
+ data
+ id
+ attester
+ }
+ }`
+```
+
+我们想要接收的字段。
+
+- `attester`：提交认证的地址。 通常这用于决定是否信任认证。
+- `id`：认证 ID。 您可以使用此值[在链上读取认证](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64)以验证 GraphQL 查询中的信息是否正确。
+- `data`：模式数据（在本例中为电子邮件地址）。
+
+```typescript
+ const queryResult = await graphqlClient.request(query)
+
+ if (queryResult.attestations.length == 0)
+ return "no_address@available.is"
+```
+
+如果没有认证，则返回一个明显不正确但对服务提供者来说看似有效的值。
+
+```typescript
+ const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data)
+ return attestationDataFields[0].value.value
+}
+```
+
+如果存在值，则使用 `decodeData` 解码数据。 我们不需要它提供的元数据，只需要值本身。
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ sp,
+ {
+ .
+ .
+ .
+ },
+ "post",
+ {
+ email: await ethereumAddressToEmail(req.params.account)
+ }
+ );
+```
+
+使用新函数获取电子邮件地址。
+
+## 去中心化呢？
+
+在这种配置下，只要我们依赖可信的认证者进行以太坊到电子邮件地址的映射，用户就无法冒充他们不是的人。 然而，我们的身份提供者仍然是一个中心化组件。 任何拥有身份提供者私钥的人都可以向服务提供者发送虚假信息。
+
+可能有一个使用[多方计算 (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) 的解决方案。 我希望在未来的教程中写到它。
+
+## 总结
+
+采用像以太坊签名这样的登录标准面临着一个“先有鸡还是先有蛋”的问题。 服务提供商希望吸引尽可能广泛的市场。 用户希望能够访问服务，而不必担心支持他们的登录标准。
+创建适配器，例如以太坊 IdP，可以帮助我们克服这个障碍。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/zh/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
index 9bb59646124..5b690c1e99f 100644
--- a/public/content/translations/zh/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
+++ b/public/content/translations/zh/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
@@ -1,60 +1,55 @@
---
-title: 以太坊开发入门
-description: "这是一份针对以太坊开发入门的初学者指南。 我们将带领你从启动一个 API 终端节点开始，到提出一个命令行请求，再到编写你的第一个 web3 脚本。 无需区块链的开发经验！"
+title: "以太坊开发入门"
+description: "这是一份针对以太坊开发入门的初学者指南。 我们将带领你从启动一个 API 终端节点开始，到提出一个命令行请求，再到编写你的第一个 web3 脚本。 无需区块链开发经验！"
author: "Elan Halpern"
-tags:
- - "javascript"
- - "ethers.js"
- - "节点"
- - "querying"
- - "alchemy"
+tags: [ "javascript", "ethers.js", "节点", "查询中", "Alchemy" ]
skill: beginner
lang: zh
published: 2020-10-30
-source: Medium
+source: "中"
sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f
---
-
+
-这是一份关于以太坊开发的初学者指南。 在本教程中，我们将使用[ Alchemy](https://alchemyapi.io/)，这是一个领先的区块链开发者平台，为 70% 的顶级区块链应用程序（包括 Maker、0x、MyEtherWallet、Dharma 和 Kyber）的数百万用户提供支持。 Alchemy 使我们能够访问以太坊链上的 API 端点，这样我们就可以读写交易。
+这是一份关于以太坊开发的初学者指南。 在本教程中，我们将使用 [Alchemy](https://alchemyapi.io/)，这是一个领先的区块链开发者平台，为 70% 的顶级区块链应用程序（包括 Maker、0x、MyEtherWallet、Dharma 和 Kyber）的数百万用户提供支持。 Alchemy 使我们能够访问以太坊链上的 API 端点，这样我们就可以读写交易。
-我们将带你注册Alchemy来编写你的第一个web3 脚本！ 无需区块链的开发经验！
+我们将带你注册 Alchemy 来编写你的第一个 web3 脚本！ 无需区块链开发经验！
-## 1. 注册免费Alchemy帐户 {#sign-up-for-a-free-alchemy-account}
+## 1. 注册一个免费的 Alchemy 帐户 {#sign-up-for-a-free-alchemy-account}
-创建 Alchemy 帐户很容易，[点击此处免费注册](https://auth.alchemyapi.io/signup)。
+创建 Alchemy 帐户很容易，[点击此处免费注册](https://auth.alchemy.com/)。
-## 2. 创建一个Alchemy应用程序 {#create-an-alchemy-app}
+## 2. 创建 Alchemy 应用 {#create-an-alchemy-app}
-为了与以太坊通信，以及为了使用 Alchemy 的产品，你需要一个 API 密钥来验证你的请求。
+为了与以太坊链通信，以及为了使用 Alchemy 的产品，你需要一个 API 密钥来验证你的请求。
-你可以通过[仪表板](http://dashboard.alchemyapi.io/)创建API密钥。 要创建一个新密钥，导航到如下所示的“Create App”：
+你可以[从仪表板创建 API 密钥](https://dashboard.alchemy.com/)。 要创建一个新密钥，导航到如下所示的“Create App”：
-特别感谢[_ShapeShift_](https://shapeshift.com/)_让我们展示他们的仪表板！_
+特别感谢 [_ShapeShift_](https://shapeshift.com/) _允许我们展示他们的仪表板！_
-
+
填写“Create App”下的详细信息以获取你的新密钥。 在此处还可以看到你以前创建的应用以及你的团队创建的应用。 通过点击任何应用的“View Key”来查看现有密钥。
-
+
-你也可以通过将鼠标悬停在“Apps”上并选择一个来获取现有API密钥。 你可以在这里“查看密钥”，以及“编辑应用程序”来特定域名加入白名单、查看几个开发者工具，并查看分析。
+你也可以通过将鼠标悬停在“Apps”上并选择一个来获取现有 API 密钥。 你可以在这里“View Key”，以及“Edit App”以将特定域加入白名单、查看几个开发者工具并查看分析。
-
+
-## 3. 在命令行中发送请求 {#make-a-request-from-the-command-line}
+## 3. 从命令行发出请求 {#make-a-request-from-the-command-line}
-使用JSON-RPC和curl通过Alchemy与以太坊区块链交互。
+使用 JSON-RPC 和 curl 通过 Alchemy 与以太坊区块链交互。
-对于手动请求，我们建议通过`JSON RPC`发送`POST`请求来进行交互。 只需传入`Content-Type: application/json`标头和查询作为`POST`主体，具有以下字段：
+对于手动请求，我们建议通过 `POST` 请求与 `JSON-RPC` 交互。 只需传入 `Content-Type: application/json` 标头，并将你的查询作为 `POST` 正文，其中包含以下字段：
-- `jsonrpc`: JSON-RPC版本，目前只支持`2.0`。
-- `method`：ETH API方法。 [请参阅API参考。](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
-- `params`：要传递到方法的参数列表。
-- `id`：请求的ID。 将通过响应返回，这样就可以跟踪一个响应属于哪个请求。
+- `jsonrpc`：JSON-RPC 版本——目前仅支持 `2.0`。
+- `method`：ETH API 方法。 [请参阅 API 参考。](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
+- `params`：要传递给方法的参数列表。
+- `id`：你的请求的 ID。 响应中会返回此 ID，以便你跟踪响应所属的请求。
-这是一个可通过命令行运行的示例，用于查询当前燃气价格：
+这是一个可以从命令行运行以检索当前燃料价格的示例：
```bash
curl https://eth-mainnet.alchemyapi.io/v2/demo \
@@ -63,7 +58,7 @@ curl https://eth-mainnet.alchemyapi.io/v2/demo \
-d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
```
-_**注意：**将 [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) 替换成你自己的应用程序接口密钥 `https://eth-mainnet.alchemyapi.io/v2/**your-api-key`。_
+_\*\*注意：\*\*请将 [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) 替换为你自己的 API 密钥 `https://eth-mainnet.alchemyapi.io/v2/**your-api-key`。_
**结果：**
@@ -71,37 +66,29 @@ _**注意：**将 [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainne
{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 10000000000000 }
```
-## 4. 设置Web3客户端 {#set-up-your-web3-client}
+## 4. 设置你的 Web3 客户端 {#set-up-your-web3-client}
-**如果你已有客户端，** 将你当前的节点提供商的 URL 更改为你的 API 密钥的 Alchemy URL： `“https://eth-mainnet.alchemyapi.io/v2/your-api-key”`
+\*\*如果你有现有客户端，\*\*请将你当前的节点提供商 URL 更改为包含你 API 密钥的 Alchemy URL：`“https://eth-mainnet.alchemyapi.io/v2/your-api-key"`
-**_注意：_**下面的脚本需要在一个**节点环境**中运行或**保存到一个文件运行**，而不是通过命令行运行。 如果你尚未安装节点或npm ，请查看此适用于mac的快速设置指南。
+**_注意：_**下面的脚本需要在**节点环境**中运行或**保存在文件中**运行，而不是从命令行运行。 如果你尚未安装 Node 或 npm，请查看此 [Mac 快速设置指南](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs)。
-许多 [Web3 库](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries)都可以和 Alchemy 集成。但是，我们建议使用 [Alchemy Web3](https://docs.alchemy.com/reference/api-overview)，它是 web3.js 的替代插件，可与 Alchemy 无缝协作。 这个库有很多优点，例如自动重试和可靠的WebSocket支持。
-
-要安装 AlchemyWeb3.js，请**导航到项目目录**并运行：
-
-**使用yarn：**
+有许多可以与 Alchemy 集成的 [Web3 库](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries)，但我们建议使用 [Alchemy Web3](https://docs.alchemy.com/reference/api-overview)，这是一个 web3.js 的直接替代品，经构建和配置可与 Alchemy 无缝协作。 这个库有很多优点，例如自动重试和可靠的 WebSocket 支持。
+要安装 AlchemyWeb3.js，**导航到你的项目目录**并运行：
+**使用 Yarn：**
```
yarn add @alch/alchemy-web3
```
-
-**使用NPM：**
-
-
+**使用 NPM：**
```
npm install @alch/alchemy-web3
```
-
-要与Alchemy的节点基础设施交互，请在NodeJS中运行或将其添加到JavaScript文件：
-
-
+要与 Alchemy 的节点基础设施交互，请在 NodeJS 中运行或将其添加到 JavaScript 文件：
```js
const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
@@ -110,39 +97,26 @@ const web3 = createAlchemyWeb3(
)
```
+## 5. 编写你的第一个 Web3 脚本！ {#write-your-first-web3-script}
-
-
-## 5. 编写你的第一个Web3脚本！ {#write-your-first-web3-script}
-
-现在用一个小的web3编程来练习，我们将编写一个简单的脚本，用于打印出以太坊主网中最新的区块高度。
+现在用一个小的 web3 编程来练习，我们将编写一个简单的脚本，用于打印出以太坊主网中最新的区块高度。
**1. 在终端中创建一个新的项目目录并通过 cd 命令进入该目录（如果尚未这样做）：**
-
-
```
mkdir web3-example
cd web3-example
```
-
**2. 在项目中安装 Alchemy Web3（或任何 Web3）依赖项（如果尚未这样做）：**
-
-
```
npm install @alch/alchemy-web3
```
-
**3. 创建一个名为 `index.js` 的文件并添加以下内容：**
-
-
-> 最终应将`demo`替换为你的Alchemy HTTP API密钥 。
-
-
+> 你最终应将 `demo` 替换为你的 Alchemy HTTP API 密钥。
```js
async function main() {
@@ -154,29 +128,22 @@ async function main() {
main()
```
+不熟悉 async 函数？ 请查看这篇 [Medium 帖子](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c)。
-不熟悉 async 函数？ 来看看这篇 [Medium 文章](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c)。
-
-**4. 使用节点在终端中运行该脚本**
-
-
+**4. 在你的终端中使用 node 运行**
```
node index.js
```
-
-**5. 现在应该会在控制台中看到最新的区块编号输出结果！**
-
-
+**5. 现在你应该可以在控制台中看到最新的区块编号输出！**
```
The latest block number is 11043912
```
+**哇！** 恭喜！ 你刚刚使用 Alchemy 编写了你的第一个 Web3 脚本 🎉\*\*
-**哇！ 恭喜！ 你刚刚使用 Alchemy 编写了你的第一个 Web3 脚本🎉**
-
-不知道下一步该怎么做？ 尝试部署你的第一个智能合约，开始练习 Solidity 编程同时参阅我们的 [Hello World 智能合约指南](https://docs.alchemyapi.io/tutorials/hello-world-smart-contract)，或使用 [Dashboard Demo App](https://docs.alchemyapi.io/tutorials/demo-app) 测试你的仪表板知识！
+不知道下一步该怎么做？ 尝试部署你的第一个智能合约，并在我们的 [Hello World 智能合约指南](https://www.alchemy.com/docs/hello-world-smart-contract)中动手进行一些 Solidity 编程，或者使用 [Dashboard 演示应用](https://docs.alchemyapi.io/tutorials/demo-app)测试你的仪表板知识！
-免费_[注册 Alchemy](https://auth.alchemyapi.io/signup)，查看我们的[相关文档](https://docs.alchemyapi.io/)，并关注我们的 [Twitter](https://twitter.com/AlchemyPlatform)_ 了解最新消息。
+_[免费注册 Alchemy](https://auth.alchemy.com/)，查看我们的[文档](https://www.alchemy.com/docs/)，以及要了解最新消息，请在 [Twitter](https://twitter.com/AlchemyPlatform) 上关注我们_。
diff --git a/public/content/translations/zh/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/zh/developers/tutorials/guide-to-smart-contract-security-tools/index.md
index d750829690f..5b59cd19c5c 100644
--- a/public/content/translations/zh/developers/tutorials/guide-to-smart-contract-security-tools/index.md
+++ b/public/content/translations/zh/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -1,105 +1,102 @@
---
-title: 智能合约安全工具指南
-description: 三种不同的测试和程序分析技术概述
+title: "智能合约安全工具指南"
+description: "三种不同的测试和程序分析技术概述"
author: "Trailofbits"
lang: zh
-tags:
- - "solidity"
- - "智能合约"
- - "安全性"
+tags: [ "Solidity", "智能合同", "安全性。" ]
skill: intermediate
published: 2020-09-07
-source: 构建安全的合约
+source: "构建安全的合约"
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
---
我们将使用三种独特的测试和程序分析技术：
-- **使用 [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) 进行静态分析**。通过不同的程序演示（例如控制流程图），同时对程序的所有路径进行模拟和分析。
-- **使用 [Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) 进行模糊测试。** 代码是通过伪随机生成的交易来执行的， 模糊器将尝试找到一个违反某个给定的合约特性的交易序列。
-- **使用 [Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) 进行符号执行。** 一种正式的验证技术，它将每个路径转换为数学公式，在此基础上可对最重要的约束加以检查。
+- **通过 [Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) 进行静态分析。** 通过不同的程序表示形式（例如控制流图），同时对程序的所有路径进行近似和分析。
+- **使用 [Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) 进行模糊测试。** 通过伪随机生成的交易来执行代码。 模糊器将尝试找到一个违反某个给定属性的交易序列。
+- **使用 [Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) 进行符号执行。** 这是一种形式化验证技术，可将每个执行路径转换为数学公式，在此基础上可检查约束条件。
-每种技术都有优缺点，在[特定情况](#determining-security-properties)下会很有用：
+每种技术都有其优缺点，并且在[特定案例](#determining-security-properties)中会很有用：
-| 技术 | 工具 | 使用方法 | 速度 | 错误遗漏 | 误报 |
+| 技术 | 工具 | 用法 | 速度 | 遗漏的漏洞 | 误报 |
| ---- | --------- | -------------- | -- | ----- | -- |
-| 静态分析 | Slither | CLI 和脚本 | 秒 | 中度 | 低 |
+| 静态分析 | Slither | CLI 和脚本 | 秒 | 中等 | 低 |
| 模糊测试 | Echidna | Solidity 属性 | 分钟 | 低 | 无 |
-| 符号执行 | Manticore | Solidity 属性和脚本 | 小时 | 无\* | 无 |
+| 符号执行 | Manticore | Solidity 属性和脚本 | 小时 | 无\* | 无 |
-\* 如果在没有超时情况下遍历所有路径
+\* 如果在没有超时的情况下探索了所有路径
-**Slither** 可以在几秒钟内分析合同，但是静态分析可能会导致误报，不太适合复杂的检查（例如算术检查）。 通过用于按钮访问内置检测器的 API 或用于用户自定义检查的 API 运行 Slither。
+**Slither** 可在数秒内分析合约，但是，静态分析可能会导致误报，并且不太适合复杂的检查（例如，算术检查）。 通过 API 运行 Slither，以便捷地访问内置探测器或进行用户自定义的检查。
-**Echidna** 需要运行几分钟，并且只会产生真阳性的测试结果。 Echidna 会检查用户提供的用 Solidity 编写的安全属性。 由于它的随机侦测的特性，它也许会错失一些漏洞。
+**Echidna** 需要运行数分钟，且只会产生真阳性结果。 Echidna 会检查用户提供的、用 Solidity 编写的安全属性。 由于它基于随机探索，因此可能会遗漏某些漏洞。
-**Manticore** 进行的是“最大权重”分析。 像 Echidna 一样，Manticore 会验证用户提供的特性。 它需要更多的时间来运行，但它可以证明某个特性的有效性，并且不会报告误报。
+**Manticore** 执行“最重量级”的分析。 与 Echidna 一样，Manticore 也可验证用户提供的属性。 它需要更长的运行时间，但能够证明属性的有效性，并且不会产生误报。
-## 推荐工作流程 {#suggested-workflow}
+## 建议的工作流程 {#suggested-workflow}
-从 Slither 的内置检测器开始，确保现在没有或以后不会引入简单的漏洞。 使用 Slither 检查与继承、变量依赖关系和结构问题相关的属性。 随着代码库的增大，可以使用 Echidna 来测试状态机更复杂的特性。 再次使用 Slither 开发专门用于那些 Solidity 不提供保护的自定义检查，比如防止某个函数被覆盖。 最后，使用 Manticore 对关键安全属性进行有针对性的验证，例如算术运算。
+从 Slither 的内置检测器入手，确保当前不存在或将来不会引入简单的漏洞。 使用 Slither 检查与继承、变量依赖和结构问题相关的属性。 随着代码库的增长，可使用 Echidna 测试状态机更复杂的属性。 再次使用 Slither，为 Solidity 未提供的保护（例如，防止函数被覆写）开发自定义检查。 最后，使用 Manticore 对关键安全属性（例如算术运算）执行针对性验证。
-- 使用 Slither 的 CLI 来捕捉常见问题
+- 使用 Slither 的 CLI 捕获常见问题
- 使用 Echidna 测试合约的高级安全属性
- 使用 Slither 编写自定义静态检查
-- 如果需要深入保证关键安全属性，请使用 Manticore
+- 如果你希望深入确保关键安全属性，请使用 Manticore
-**关于单元测试的说明**。 单元测试是构建高质量软件的必要条件。 然而，要找出安全漏洞，这些技术并不是最合适的。 它们通常用来测试正向代码行为（例如：代码在正常情况下按预期工作）， 但安全漏洞往往存在于开发者未考虑的边缘情况。 在我们进行的数十次智能合约安全测试研究中，[单元测试覆盖率对于我们在客户端的代码中发现的安全漏洞的数量或者严重程度没有影响](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/)。
+**关于单元测试的说明**。 单元测试是构建高质量软件所必需的。 然而，这些技术并非是发现安全漏洞的最佳方法。 它们通常用于测试代码的积极行为（即，代码在正常情况下按预期工作），而安全漏洞往往存在于开发者没有考虑到的边缘情况。 在我们对数十个智能合约安全审计的研究中，我们发现[单元测试覆盖率对我们在客户代码中发现的安全漏洞的数量或严重性没有影响](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/)。
## 确定安全属性 {#determining-security-properties}
-为了有效测试和验证代码，你必须确定需要注意的地方。 因为花费在安全上的资源是有限的，只有划分出代码库中的薄弱和高价值部分，才能优化你的工作。 威胁建模可以提供帮助。 供考虑的审核方法有：
+为有效测试和验证你的代码，你必须确定需要关注的领域。 由于你在安全方面的资源有限，因此确定代码库中薄弱或高价值的部分对于优化你的工作至关重要。 威胁建模可以提供帮助。 请考虑审查：
- [快速风险评估](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html)（时间紧迫时我们的首选方法）
-- [数据中心系统威胁建模指南](https://csrc.nist.gov/publications/detail/sp/800-154/draft) (aka NIST 800-154)
-- [Shostack 线程建模](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
-- [STRIDE](https://wikipedia.org/wiki/STRIDE_(security)) / [DREAD](https://wikipedia.org/wiki/DREAD_(risk_assessment_model))
+- [以数据为中心的系统威胁建模指南](https://csrc.nist.gov/pubs/sp/800/154/ipd) (又名 NIST 800-154)
+- [Shostack 威胁建模](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
+- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\))
- [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.)
-- [使用断言](https://blog.regehr.org/archives/1091)
+- [断言的使用](https://blog.regehr.org/archives/1091)
### 组件 {#components}
-了解要检查的内容也有助于选择正确的工具。
+了解你想要检查的内容也有助于你选择正确的工具。
-通常与智能合约相关的领域比较广泛，包括：
+与智能合约经常相关的广泛领域包括：
-- **状态机**。大多数合约都可以表示为状态机。 考虑检查以下几点：(1) 不能到达无效状态，(2) 如果状态有效则可以到达，以及 (3) 没有状态会限制合约。
+- **状态机。** 大多数合约都可以表示为状态机。 考虑检查：(1) 无法达到无效状态；(2) 如果一个状态有效，则该状态可以达到；(3) 没有状态会使合约陷入陷阱。
- Echidna 和 Manticore 是测试状态机规范的首选工具。
-- **访问控制。**如果你的系统有特权用户（例如所有者、监管者等），你必须确保 (1) 每个用户只能执行授权操作，并且 (2) 没有用户可以阻止权限更大的用户的操作。
+- **访问控制。** 如果你的系统有特权用户（例如所有者、控制者……） 你必须确保 (1) 每个用户只能执行授权的操作，以及 (2) 没有用户可以阻止更具特权的用户执行操作。
- - Slither、Echidna 和 Manticore 都可以检查访问控制正确与否。 例如，Slither 可以检查是否只有白名单上的函数缺少 onlyOwner 修改器。 Echidna 和 Manticore 可用于更复杂的访问控制，例如仅当合约达到给定状态时才授予权限。
+ - Slither、Echidna 和 Manticore 都可以检查访问控制的正确性。 例如，Slither 可以检查是否只有列入白名单的函数缺少 `onlyOwner` 修饰符。 Echidna 和 Manticore 对于更复杂的访问控制很有用，例如仅在合约达到特定状态时才授予权限。
-- **算术运算**。检查算术运算的可靠性至关重要。 在所有地方使用 `SafeMath` 是防止上溢/下溢很好的做法，但你还必需考虑其他算术缺陷，包括四舍五入和限制合约的缺陷。
+- **算术运算。** 检查算术运算的可靠性至关重要。 处处使用 `SafeMath` 是防止溢出/下溢的好方法，但你仍必须考虑其他算术缺陷，包括舍入问题和使合约陷入陷阱的缺陷。
- - 在这里，Manticore 是最佳选择。 如果算术超出 SMT 求解器的范围，则可以使用 Echidna。
+ - Manticore 是此处的最佳选择。 如果算术运算超出了 SMT 求解器的范围，则可以使用 Echidna。
-- **继承的正确性**。Solidity 合约在很大程度上依赖于多重继承。 因此，很容易出现一些诸如像缺少`超级`调用的遮蔽函数和曲解了 C3 线性化的顺序之类的错误。
+- **继承的正确性。** Solidity 合约严重依赖多重继承。 诸如遮蔽函数缺少 `super` 调用以及对 c3 线性化顺序的误解等错误都很容易出现。
- - Slither 是确保检测出这些问题的工具。
+ - Slither 是确保检测这些问题的工具。
-- **外部交互**。这里指合约之间的互动，一些外部合约不应该被信任。 例如，如果你的合约依赖于外部预言机，那么如果现有预言机有一半被泄漏，它是否仍然是安全的？
+- **外部交互。** 合约之间会相互交互，某些外部合约不应被信任。 例如，如果你的合约依赖外部预言机，当一半可用预言机被攻破时，它是否仍然安全？
- - Manticore 和 Echidna 是测试你的合约外部互动的最佳选择。 Manticore 有一个内置机制来存留外部合约。
+ - Manticore 和 Echidna 是测试你的合约与外部交互的最佳选择。 Manticore 有一个内置机制，可以为外部合约创建存根。
-- **标准一致性**。 以太坊标准（例如 ERC20）记录了他们在设计上的缺陷。 请注意你正在构建的标准的局限性。
- - Slither、Echidna 和 Manticore 可以帮助你发现偏离特定标准的情况。
+- **标准一致性。** 以太坊标准（例如 ERC20）的设计曾出现过缺陷。 请注意你所依据的标准的局限性。
+ - Slither、Echidna 和 Manticore 将帮助你检测与特定标准的偏差。
### 工具选择备忘清单 {#tool-selection-cheatsheet}
-| 组件 | 工具 | 示例 |
-| ------ | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 状态机 | Echidna、Manticore | |
-| 访问控制 | Slither、Echidna、Manticore | [Slither 练习 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md)、[Echidna 练习 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) |
-| 算术运算 | Manticore、Echidna | [Echidna 练习 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md)、[Manticore 练习 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) |
-| 继承的正确性 | Slither | [Slither 练习 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) |
-| 外部交互 | Manticore、Echidna | |
-| 标准一致性 | Slither、Echidna、Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) |
+| 组件 | 工具 | 示例 |
+| ------ | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 状态机 | Echidna、Manticore | |
+| 访问控制 | Slither、Echidna、Manticore | [Slither 练习 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md)、[Echidna 练习 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) |
+| 算术运算 | Manticore、Echidna | [Echidna 练习 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md)、[Manticore 练习 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) |
+| 继承的正确性 | Slither | [Slither 练习 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) |
+| 外部交互 | Manticore、Echidna | |
+| 标准一致性 | Slither、Echidna、Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) |
-其他领域需要根据你的目标进行检查， 但以上囊括的大致重点领域对于所有智能合约系统来说都是一个良好的开端。
+根据你的目标，可能还需要检查其他领域，但这些粗粒度的重点领域对于任何智能合约系统来说都是一个很好的起点。
-我们公开的审计包含了经过验证或测试的属性实例。 请考虑阅读以下报告的`自动测试和验证部分`，以查看实际安全属性：
+我们的公开审计报告包含经过验证或测试的属性示例。 请考虑阅读以下报告的“自动化测试和验证”部分，以审查真实世界的安全属性：
- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)
-- [平衡器](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf)
+- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf)
diff --git a/public/content/translations/zh/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/zh/developers/tutorials/hello-world-smart-contract-fullstack/index.md
index f214751ac8f..db1e4bb5c00 100644
--- a/public/content/translations/zh/developers/tutorials/hello-world-smart-contract-fullstack/index.md
+++ b/public/content/translations/zh/developers/tutorials/hello-world-smart-contract-fullstack/index.md
@@ -1,76 +1,79 @@
---
-title: 针对初学者的 Hello World 智能合约指南 - 全栈
-description: 关于编写和部署一个基于以太坊的简单智能合约的入门教程。
+title: "初学者全栈 Hello World 智能合约"
+description: "关于在以太坊上编写和部署一个简单智能合约的入门教程。"
author: "nstrike2"
tags:
- - "solidity"
- - "hardhat"
- - "alchemy"
- - "智能合约"
- - "deploying"
- - "区块链浏览器"
- - "前端"
- - "交易"
+ [
+ "Solidity",
+ "hardhat",
+ "Alchemy",
+ "智能合同",
+ "部署",
+ "区块浏览器",
+ "前端",
+ "交易"
+ ]
skill: beginner
lang: zh
published: 2021-10-25
---
-如果你是区块链开发的新手，不知道从哪里开始或者如何部署并与智能合约交互，那么这个指南就是为你准备的。 我们将演示如何使用 [MetaMask](https://metamask.io)、[Solidity](https://docs.soliditylang.org/en/v0.8.0/)、[安全帽](https://hardhat.org)以及 [Alchemy](https://alchemyapi.io/eth)，在 Goerli 测试网络上创建和部署一个简单的智能合约。
+如果你是区块链开发的新手，不知道从哪里开始或者如何部署并与智能合约交互，那么本指南就是为你准备的。 我们将使用 [MetaMask](https://metamask.io)、[Solidity](https://docs.soliditylang.org/en/v0.8.0/)、[Hardhat](https://hardhat.org) 和 [Alchemy](https://alchemy.com/eth) 逐步创建一个简单的智能合约并将其部署到 Goerli 测试网上。
-你将会需要一个 Alchemy 帐户来完成这个教程。 [注册一个免费帐户](https://www.alchemy.com/)。
+你将需要一个 Alchemy 帐户来完成这个教程。 [注册一个免费帐户](https://www.alchemy.com/)。
-如果你有任何问题，请随时在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中提出！
+如果你在任何时候有任何疑问，欢迎随时在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中联系我们！
-## 第一部分 - 使用安全帽创建和部署你的智能合约 {#part-1}
+## 第一部分 - 使用Hardhat创建和部署你的智能合约 {#part-1}
-### 连接以太坊网络 {#connect-to-the-ethereum-network}
+### 连接到以太坊网络 {#connect-to-the-ethereum-network}
-有多种方法可以向以太坊链发起连接请求。 简单起见，我们将会使用一个 Alchemy 上的免费帐户。Alchemy 是一个区块链开发者平台和应用程序接口，让我们在不用自己运行节点的情况下与以太坊链进行通信。 Alchemy 还有着用于监控和分析的开发者工具；我们将在本教程中利用这些工具来深入了解我们智能合约部署中的情况。
+有很多方法可以向以太坊链发送请求。 为简单起见，我们将使用 Alchemy 上的免费帐户。Alchemy 是一个区块链开发者平台和 API，让我们在不用自己运行节点的情况下与以太坊链进行通信。 Alchemy 还有着用于监控和分析的开发者工具；我们将在本教程中利用这些工具来深入了解我们智能合约部署中的情况。
-### 创建你的应用程序和应用程序接口密钥 {#create-your-app-and-api-key}
+### 创建你的应用和 API 密钥 {#create-your-app-and-api-key}
-当你创建了一个 Alchemy 帐户后，你可以通过创建应用程序来生成应用程序接口密钥。 这将允许你向 Goerli 测试网发送请求。 如果你不熟悉测试网，你可以[阅读 Alchemy 指南来选择一个网络](https://docs.alchemyapi.io/guides/choosing-a-network)。
+创建 Alchemy 帐户后，你可以通过创建应用来生成 API 密钥。 这将允许你向 Goerli 测试网发送请求。 如果你不熟悉测试网，可以[阅读 Alchemy 关于选择网络的指南](https://www.alchemy.com/docs/choosing-a-web3-network)。
-在 Alchemy 仪表板上，找到位于导航栏的 **Apps** 下拉菜单并点击 **Create App**。
+在 Alchemy 仪表板上，找到位于导航栏的“应用”下拉菜单并点击“创建应用”。
-
+
-给你的应用程序命名为“_Hello World_”并写一个简短的描述。 选择 **Staging** 作为你的环境以及 **Goerli** 作为你的网络。
+给你的应用命名为“_Hello World_”并写一个简短的描述。 选择“**Staging**”作为你的环境以及“**Goerli**”作为你的网络。
-_注：请确保选择 **Goerli**，否则本教程将不适用。_
+_注意：请确保选择 **Goerli**，否则本教程将无法正常进行。_
-点击 **Create app**。 你的应用程序应该会出现在下面的表中。
+点击“**Create app**”。 你的应用程序应该会出现在下表中。
-### 创建一个以太坊帐户 {#create-an-ethereum-account}
+### 创建以太坊帐户 {#create-an-ethereum-account}
你需要一个以太坊帐户来发送和接受交易。 我们将会使用 MetaMask，这是一个浏览器中的虚拟钱包，可供用户管理他们的以太坊帐户地址。
-你可以[在这里](https://metamask.io/download)免费下载并创建一个 MetaMask 帐户。 When you are creating an account, or if you already have an account, make sure to switch over to the “Goerli Test Network” in the upper right (so that we’re not dealing with real money).
+你可以[在此处](https://metamask.io/download)免费下载和创建 MetaMask 帐户。 在你创建帐户时，或者如果你已经有帐户，请确保切换到右上角的“Goerli 测试网络”（这样我们就不会使用实际货币进行交易）。
-### 步骤 4：从水龙头添加以太币 {#step-4-add-ether-from-a-faucet}
+### 步骤 4：从水龙头获取以太币 {#step-4-add-ether-from-a-faucet}
-为了将你的智能合约部署到测试网络，你需要一些虚拟以太币。 为了获得 Goerli 网络上的以太币，请前往 Goerli 水龙头并输入你的 Goerli 帐户地址。 注意 Goerli 水龙头最近可能不太可靠 - 请查看[测试网络页面](/developers/docs/networks/#goerli)以了解可以尝试的选项列表：
+要将你的智能合约部署到测试网，你需要一些虚拟 ETH。 要在 Goerli 网络上获取 ETH，请前往 Goerli 水龙头并输入你的 Goerli 帐户地址。 请注意，Goerli 水龙头最近可能不太可靠 - 请参阅[测试网页面](/developers/docs/networks/#goerli)获取可供尝试的选项列表：
-_注：由于网络拥塞，这可能需要一些时间。_
+_注意：由于网络拥堵，这可能需要一些时间。_
+``
-### 步骤 5：查看帐户余额 {#step-5-check-your-balance}
+### 第 5 步：检查你的余额 {#step-5-check-your-balance}
-为了核查钱包中的以太币，我们使用 [Alchemy 的 Composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D)来发送 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币金额。 想要了解更多请查看 [Alchemy 关于如何使用 Composer 工具的简短教程](https://youtu.be/r6sjRxBZJuU)。
+为仔细检查 ETH 是否已在你的钱包中，我们来使用 [Alchemy 的 composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D)发出一个 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 要了解更多信息，请查看 [Alchemy 关于如何使用 composer 工具的简短教程](https://youtu.be/r6sjRxBZJuU)。
-输入你的 MetaMask 帐户地址并点击 **Send Request**。 你将会看到类似以下代码片段的响应。
+输入你的 MetaMask 帐户地址并点击“**Send Request**”。 你将看到类似以下代码片段的响应。
```json
{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
```
-> _注：此结果以 wei 为单位，而非 ETH。 Wei is used as the smallest denomination of ether._
+> _注意：此结果以 wei 为单位，而非 ETH。 Wei 是以太币的最小计量单位。_
-Phew! 这里显示了我们所有的虚拟货币。
+哦！ 这里显示了我们所有的虚拟货币。
-### 步骤 6：初始化我们的项目 {#step-6-initialize-our-project}
+### 第 6 步：初始化我们的项目 {#step-6-initialize-our-project}
首先，需要为我们的项目创建一个文件夹。 导航到你的命令行并输入以下内容。
@@ -81,14 +84,14 @@ cd hello-world
现在我们进入了项目文件夹，我们将使用 `npm init` 来初始化项目。
-> 如果你尚未安装 npm，请按照[这些说明来安装 Node.js 和 npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm)。
+> 如果你尚未安装 npm，请按照[这些说明安装 Node.js 和 npm](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm)。
对于本教程而言，你如何回答初始化问题并不重要。 以下是我们的参考操作方式：
```
package name: (hello-world)
version: (1.0.0)
-description: hello world smart contract
+description: hello world 智能合约
entry point: (index.js)
test command:
git repository:
@@ -96,26 +99,26 @@ keywords:
author:
license: (ISC)
-About to write to /Users/.../.../.../hello-world/package.json:
+即将写入 /Users/.../.../.../hello-world/package.json：
{
"name": "hello-world",
"version": "1.0.0",
- "description": "hello world smart contract",
+ "description": "hello world 智能合约",
"main": "index.js",
"scripts": {
- "test": "echo \"Error: no test specified\" && exit 1"
+ "test": "echo \"错误：未指定测试\" && exit 1"
},
"author": "",
"license": "ISC"
}
```
-批准 package.json，我们就可以进行下一步了！
+批准 package.json，我们就可以继续了！
-### 步骤 7：下载安全帽 {#step-7-download-hardhat}
+### 第 7 步：下载Hardhat {#step-7-download-hardhat}
-安全帽是一个用于编译、部署、测试和调试以太坊软件的开发环境。 它帮助开发者在本地构建智能合约和去中心化应用程序并部署到实时链上。
+Hardhat是一个用于编译、部署、测试和调试以太坊软件的开发环境。 它帮助开发者在本地构建智能合约和去中心化应用程序并部署到实时链上。
在我们的 `hello-world` 项目中运行：
@@ -123,9 +126,9 @@ About to write to /Users/.../.../.../hello-world/package.json:
npm install --save-dev hardhat
```
-查看此页面，了解更多有关[安装说明](https://hardhat.org/getting-started/#overview)的详细信息。
+请查看此页面，详细了解[安装说明](https://hardhat.org/getting-started/#overview)。
-### 步骤 8：创建安全帽项目 {#step-8-create-hardhat-project}
+### 第 8 步：创建Hardhat项目 {#step-8-create-hardhat-project}
在我们的 `hello-world` 项目文件夹中，运行：
@@ -145,17 +148,17 @@ npx hardhat
888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
-👷 Welcome to Hardhat v2.0.11 👷
+👷 欢迎来到Hardhat v2.0.11 👷
-What do you want to do? …
-Create a sample project
-❯ Create an empty hardhat.config.js
-Quit
+你想做什么？…
+创建一个示例项目
+❯ 创建一个空的 hardhat.config.js
+退出
```
-这将会在项目中生成一个 `hardhat.config.js` 文件。 我们稍后将在教程中使用它来为我们的项目指定设置。
+这将在项目中生成一个 `hardhat.config.js` 文件。 我们稍后将在教程中使用它来为我们的项目指定设置。
-### 步骤 9：添加项目文件夹 {#step-9-add-project-folders}
+### 第 9 步：添加项目文件夹 {#step-9-add-project-folders}
为了使项目有条理，我们将创建两个新的文件夹。 在命令行中，导航到你的 `hello-world` 项目的根目录中并输入：
@@ -164,46 +167,46 @@ mkdir contracts
mkdir scripts
```
-- `contracts/` 是保存我们的 hello world 智能合约代码文件的位置
-- `scripts/` 是我们存放脚本的位置，用于部署我们的合约和与之交互。
+- `contracts/` 是我们存放 hello world 智能合约代码文件的地方
+- `scripts/` 是我们存放部署和交互合约脚本的地方
-### 步骤 10：编写合约 {#step-10-write-our-contract}
+### 第 10 步：编写我们的合约 {#step-10-write-our-contract}
你可能在问自己，到底什么时候才能写代码？ 就是现在！
-在你最喜爱的编辑器中打开 hello-world 项目。 智能合约通常使用 Solidity 来编写，我们也将使用它来编写智能合约。
+在你最喜爱的编辑器中打开 hello-world 项目。 智能合约通常使用 Solidity 来编写，我们也将使用它来编写智能合约。
-1. 导航到 `contracts` 文件夹并创建一个名为 `HelloWorld.sol` 的新文件。
+1. 导航到 `contracts` 文件夹并创建一个名为 `HelloWorld.sol` 的新文件
2. 下面是我们将在本教程中使用的示例 Hello World 智能合约。 将下面的内容复制到 `HelloWorld.sol` 文件中。
-_注：务必阅读注释以理解此合约的内容。_
+_注意：务必阅读注释以理解此合约的内容。_
```
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// 指定 Solidity 的版本，使用语义版本控制。
+// 了解更多：https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity >=0.7.3;
-// Defines a contract named `HelloWorld`.
-// 一个合约是函数和数据（其状态）的集合。 Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// 定义一个名为 `HelloWorld` 的合约。
+// 合约是函数和数据（其状态）的集合。一旦部署，合约就位于以太坊区块链上的一个特定地址。了解更多：https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {
- //Emitted when update function is called
- //Smart contract events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.
+ // 在调用 update 函数时发出
+ // 智能合约事件是合约向应用程序前端传达区块链上发生的事情的一种方式，前端可以“监听”某些事件并在事件发生时采取行动。
event UpdatedMessages(string oldStr, string newStr);
- // Declares a state variable `message` of type `string`.
- // 状态变量是其值永久存储在合约存储中的变量。 The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+ // 声明一个 `string` 类型的状态变量 `message`。
+ // 状态变量是其值永久存储在合约存储中的变量。`public` 关键字使变量可以从合约外部访问，并创建一个其他合约或客户端可以调用以访问该值的函数。
string public message;
- // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
- // 构造器用于初始化合约的数据。 Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ // 与许多基于类的面向对象语言类似，构造函数是一个特殊函数，仅在创建合约时执行。
+ // 构造函数用于初始化合约的数据。了解更多：https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
constructor(string memory initMessage) {
- // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+ // 接受一个字符串参数 `initMessage`，并将其值设置到合约的 `message` 存储变量中）。
message = initMessage;
}
- // A public function that accepts a string argument and updates the `message` storage variable.
+ // 一个接受字符串参数并更新 `message` 存储变量的 public 函数。
function update(string memory newMessage) public {
string memory oldMsg = message;
message = newMessage;
@@ -214,13 +217,13 @@ contract HelloWorld {
这是一个在创建时存储一条消息的基础智能合约。 可以通过调用 `update` 函数来更新该合约。
-### 步骤 11：将 Metamask 和 Alchemy 连接至你的项目 {#step-11-connect-metamask-alchemy-to-your-project}
+### 第 11 步：将 MetaMask 和 Alchemy 连接到你的项目 {#step-11-connect-metamask-alchemy-to-your-project}
-我们创建了 MetaMask 钱包、Alchemy 帐户，并且编写了一个智能合约，现在是将这三者连起来的时候了。
+我们已经创建了 MetaMask 钱包、Alchemy 帐户并编写了智能合约，现在是时候将这三者连接起来了。
-从你的钱包发出的每一笔交易都需要使用你独有私钥的签名。 为了给我们的程序提供此权限，我们可以安全地将私钥存储在一个环境文件中。 我们也会在此存储一个 Alchemy 的应用程序接口密钥。
+从你的钱包发出的每一笔交易都需要使用你独有的私钥签名。 为了给我们的程序提供此权限，我们可以安全地将私钥存储在一个环境文件中。 我们也会在此存储一个 Alchemy 的 API 密钥。
-> 如需了解更多关于发送交易的信息，请查看关于使用 web3 发送交易的[教程](https://docs.alchemyapi.io/alchemy/tutorials/sending-transactions-using-web3-and-alchemy)。
+> 要了解有关发送交易的更多信息，请查看有关使用 web3 发送交易的[本教程](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project)。
首先，在项目目录中安装 dotenv 软件包：
@@ -228,31 +231,31 @@ contract HelloWorld {
npm install dotenv --save
```
-然后，在项目根目录下创建一个 `.env` 文件。 在文件中添加你的 MetaMask 私钥和 HTTP Alchemy 应用程序接口 URL。
+然后，在项目根目录下创建一个 `.env` 文件。 在文件中添加你的 MetaMask 私钥和 HTTP Alchemy API URL。
你的环境文件必须以 `.env` 命名，否则不会被识别为环境文件。
不要命名为 `process.env` 或 `.env-custom` 或其他名称。
-- 遵循[这些说明](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key)导出你的私钥
-- 请从下方获取超文本传输协议 Alchemy 应用程序接口网址
+- 按照[这些说明](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key)导出你的私钥
+- 请参阅下文以获取 HTTP Alchemy API URL
-你的 `.env` 文件应该类似：
+你的 `.env` 文件应如下所示：
```
API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
PRIVATE_KEY = "your-metamask-private-key"
```
-为了将这些变量和代码连接，我们将在步骤 13 中调用 `hardhat.config.js` 文件中的这些变量。
+为了真正将它们连接到我们的代码，我们将在第 13 步的 `hardhat.config.js` 文件中引用这些变量。
-### 步骤 12：安装 Ethers.js {#step-12-install-ethersjs}
+### 第 12 步：安装 Ethers.js {#step-12-install-ethersjs}
-Ethers.js 是一个程序库，通过以更加方便用户的方法打包[标准 JSON RPC 方法](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc)，从而更容易与以太坊互动，以及向以太坊提出请求。
+Ethers.js 是一个库，它通过将[标准 JSON-RPC 方法](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc)封装成更方便用户的方法，从而更容易与以太坊互动并提出请求。
-安全帽可用于集成[插件](https://hardhat.org/plugins/)以获取额外的工具和扩展功能。 我们将利用 [Ethers 插件](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers)完成合约部署。
+Hardhat允许我们集成[插件](https://hardhat.org/plugins/)以获取额外的工具和扩展功能。 我们将利用 [Ethers 插件](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers)来进行合约部署。
在你的项目目录中输入：
@@ -260,11 +263,11 @@ Ethers.js 是一个程序库，通过以更加方便用户的方法打包[标准
npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
```
-### 步骤 13：更新 hardhat.config.js {#step-13-update-hardhat-configjs}
+### 第 13 步：更新 hardhat.config.js {#step-13-update-hardhat-configjs}
-到目前为止，我们已经添加了几个依赖库和插件，现在我们需要更新 `hardhat.config.js`，以便项目使用所有这些新的组件。
+到目前为止，我们已经添加了几个依赖项和插件，现在我们需要更新 `hardhat.config.js`，以便我们的项目了解所有这些依赖项和插件。
-按如下所示更新你的 `hardhat.config.js` 代码：
+将你的 `hardhat.config.js` 更新为如下所示：
```javascript
/**
@@ -289,9 +292,9 @@ module.exports = {
}
```
-### 步骤 14：编写合约 {#step-14-compile-our-contract}
+### 第 14 步：编译我们的合约 {#step-14-compile-our-contract}
-为了确保一切正常，我们来编译一下合约。 `compile` 任务是安全帽的内部任务之一。
+为了确保一切正常，我们来编译一下合约。 `compile` 任务是内置的 hardhat 任务之一。
在命令行中运行：
@@ -299,21 +302,21 @@ module.exports = {
npx hardhat compile
```
-你可能会看到关于 `SPDX license identifier not provided in source file` 的警告，但不用担心，希望其他方面看起来一切正常！ 如果遇到问题，你可以随时在 [Alchemy cord](https://discord.gg/u72VCg3) 社区中发消息询问。
+你可能会看到关于“`SPDX license identifier not provided in source file`”的警告，但无需担心——希望其他的一切正常！ 如果编译不成功，可以随时在 [Alchemy discord](https://discord.gg/u72VCg3) 中发消息。
-### 步骤 15：编写部署脚本 {#step-15-write-our-deploy-script}
+### 第 15 步：编写我们的部署脚本 {#step-15-write-our-deploy-script}
合约已经写完，配置文件也准备妥当，现在是写合约部署脚本的时候了。
-转到 `scripts/` 文件夹，创建一个名为 `deploy.js` 的新文件，在其中添加以下内容：
+导航到 `scripts/` 文件夹并创建一个名为 `deploy.js` 的新文件，向其中添加以下内容：
```javascript
async function main() {
const HelloWorld = await ethers.getContractFactory("HelloWorld")
- // Start deployment, returning a promise that resolves to a contract object
+ // 开始部署，返回一个解析为合约对象的 promise
const hello_world = await HelloWorld.deploy("Hello World!")
- console.log("Contract deployed to address:", hello_world.address)
+ console.log("合约已部署到地址：", hello_world.address)
}
main()
@@ -324,23 +327,23 @@ main()
})
```
-安全帽在[合约教程](https://hardhat.org/tutorial/testing-contracts.html#writing-tests)中对这些代码的每一行均提供了很好的解释，我们在这里直接引用他们的解释。
+Hardhat在他们的[合约教程](https://hardhat.org/tutorial/testing-contracts.html#writing-tests)中极好地解释了每一行代码的作用，我们在此处采用了他们的解释。
```javascript
const HelloWorld = await ethers.getContractFactory("HelloWorld")
```
-ethers.js 中的 `ContractFactory` 是用于部署新智能合约的抽象对象。因此这里的 `HelloWorld` 是我们 hello world 合约实例的[工厂](https://en.wikipedia.org/wiki/Factory_(object-oriented_programming))。 使用 `hardhat-ethers` 插件时，`ContractFactory` 和 `Contract` 实例默认与第一个签名者（所有者）相连。
+ethers.js 中的 `ContractFactory` 是用于部署新智能合约的抽象，因此这里的 `HelloWorld` 是我们 hello world 合约实例的[工厂](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\))。 使用 `hardhat-ethers` 插件时，`ContractFactory` 和 `Contract` 实例默认与第一个签名者（所有者）相连。
```javascript
const hello_world = await HelloWorld.deploy()
```
-调用 `ContractFactory` 代码中的 `deploy()` 函数会启动合约部署，然后返回解析为 `Contract` 对象的 `Promise`。 这个对象包括我们智能合约中每个函数的对应调用方法。
+在 `ContractFactory` 上调用 `deploy()` 会启动部署，并返回一个解析为 `Contract` 对象的 `Promise`。 这个对象包括我们智能合约中每个函数的对应调用方法。
-### 步骤 16：部署合约 {#step-16-deploy-our-contract}
+### 第 16 步：部署我们的合约 {#step-16-deploy-our-contract}
-我们终于准备好部署我们的智能合约啦！ 导航到命令行后运行：
+我们终于准备好部署我们的智能合约啦！ 导航到命令行并运行：
```bash
npx hardhat run scripts/deploy.js --network goerli
@@ -349,36 +352,36 @@ npx hardhat run scripts/deploy.js --network goerli
你会看到类似以下所示的信息：
```bash
-Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+合约已部署到地址：0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
```
**请保存这个地址**。 之后在教程中我们会用到这个地址。
-如果我们在 [Goerli etherscan](https://goerli.etherscan.io) 搜索我们的合约地址，我们应能够看到它已经成功部署。 交易将类似以下：
+如果我们前往 [Goerli etherscan](https://goerli.etherscan.io) 并搜索我们的合约地址，应该能看到它已成功部署。 交易将类似以下：
-`From` 地址应该匹配你的 MetaMask 帐户地址，`To` 地址将是**合约创建**。 如果我们点击进入交易，我们将在 `To` 字段中看到我们的合约地址。
+`From` 地址应匹配你的 MetaMask 帐户地址，`To` 地址将显示**合约创建**。 如果我们点击进入交易，我们将在 `To` 字段中看到我们的合约地址。
恭喜！ 你刚刚在以太坊测试网上部署了一个智能合约。
-为了更深入了解到底发生了什么，我们转到 [Alchemy 仪表板](https://dashboard.alchemyapi.io/explorer)中的 Explorer 选项卡。 如果你有多个 Alchemy 应用程序，请确保按应用程序筛选，然后选择 **Hello World**。
+要了解后台运行情况，我们导航到我们的 [Alchemy 仪表板](https://dashboard.alchemy.com/explorer)中的 Explorer 选项卡。 如果你有多个 Alchemy 应用，请确保按应用筛选并选择“**Hello World**”。
-在这里，你会看到一系列 JSON-RPC 方法，当我们调用 `.deploy()` 函数时，安全帽/Ethers 会在后端完成这些方法。 在这里有两个重要的方法，[`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) 是用于把我们的合约写入 Goerli 链的请求，[`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash) 是根据哈希读取交易信息的请求。 如需了解更多关于发送交易的信息，请查看[我们关于使用 Web3 发送交易的教程](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)。
+在这里，你会看到一系列 JSON-RPC 方法，当我们调用 `.deploy()` 函数时，Hardhat/Ethers 会在后台为我们调用这些方法。 这里有两个重要方法：[`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) 是将我们的合约写入 Goerli 链的请求，而 [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash) 是在给定哈希的情况下读取我们交易信息的请求。 要了解有关发送交易的更多信息，请查看[我们关于使用 Web3 发送交易的教程](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)。
-## 第二部分 - 和你的智能合约交互 {#part-2-interact-with-your-smart-contract}
+## 第二部分：与你的智能合约交互 {#part-2-interact-with-your-smart-contract}
现在我们已经成功地将智能合约部署到 Goerli 网络，让我们学习如何与它交互。
-### 创建 interact.js 文件 {#create-a-interactjs-file}
+### 创建一个 interact.js 文件 {#create-a-interactjs-file}
这是我们将在其中编写交互脚本的文件。 我们将使用在第一部分中安装的 Ethers.js 库。
-在 `scripts/` 文件夹中，新建一个文件，命名为 `interact.js`，添加以下代码：
+在 `scripts/`文件夹中，新建一个文件，命名为 `interact.js`，添加以下代码：
```javascript
// interact.js
@@ -388,9 +391,9 @@ const PRIVATE_KEY = process.env.PRIVATE_KEY
const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
```
-### 更新 .env 文件 {#update-your-env-file}
+### 更新你的 .env 文件 {#update-your-env-file}
-我们将使用新的环境变量，因此需要在[我们之前创建的 ](#step-11-connect-metamask-&-alchemy-to-your-project)`.env` 文件中定义这些变量。
+我们将使用新的环境变量，因此需要在我们[之前创建](#step-11-connect-metamask-&-alchemy-to-your-project)的 `.env` 文件中定义这些变量。
我们需要为 Alchemy `API_KEY` 和部署你的智能合约的 `CONTRACT_ADDRESS` 添加定义。
@@ -405,36 +408,36 @@ PRIVATE_KEY = ""
CONTRACT_ADDRESS = "0x"
```
-### 获取你的合约应用程序二进制接口 {#grab-your-contract-ABI}
+### 获取你的合约 ABI {#grab-your-contract-ABI}
-我们的合约 [ABI（应用程序二进制接口）](/glossary/#abi)是与我们的智能合约交互的接口。 安全帽自动生成应用程序二进制接口，并将其保存在 `HelloWorld.json` 中。 为了使用该接口，我们需要通过在我们的 `interact.js` 文件中添加以下代码行来解析内容：
+我们的合约 [ABI（应用程序二进制接口）](/glossary/#abi)是与我们的智能合约交互的接口。 Hardhat自动生成 ABI，并将其保存在 `HelloWorld.json` 中。 为了使用该接口，我们需要通过在我们的 `interact.js` 文件中添加以下代码行来解析内容：
```javascript
// interact.js
const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
```
-如果你想查看应用程序二进制接口，你可以将其发送到你的控制台：
+如果你想查看 ABI，可以将其打印到控制台：
```javascript
console.log(JSON.stringify(contract.abi))
```
-要查看输出到控制台的应用程序二进制接口，请导航至你的终端并运行：
+要查看输出到控制台的 ABI，请导航至你的终端并运行：
```bash
npx hardhat run scripts/interact.js
```
-### 创建合约的实例 {#create-an-instance-of-your-contract}
+### 创建合约实例 {#create-an-instance-of-your-contract}
为了与我们的合约进行交互，我们需要在代码中创建一个合约实例。 要使用 Ethers.js 实现，我们需要使用三个概念：
-1. 提供者 - 为你提供区块链读写访问权限的节点提供者。
+1. 提供者 - 为你提供区块链读写访问权限的节点提供者
2. 签名者 - 代表可以给交易签名的以太坊帐户
-3. 合约 - 代表部署在链上的特定合约的 Ethers.js对象
+3. 合约 - 代表部署在链上的特定合约的 Ethers.js 对象
-我们将使用上一步中的合约应用程序二进制接口来创建我们的合约实例：
+我们将使用上一步中的合约 ABI 来创建我们的合约实例：
```javascript
// interact.js
@@ -458,13 +461,13 @@ const helloWorldContract = new ethers.Contract(
在 [ethers.js 文档](https://docs.ethers.io/v5/)获取更多关于提供者、签名者和合约的信息。
-### 阅读 init 消息 {#read-the-init-message}
+### 读取初始消息 {#read-the-init-message}
还记得我们用 `initMessage = "Hello world!"` 部署合约时的情况吗？ 我们现在要读取存储在智能合约中的消息，并将其输出到控制台。
-在 JavaScript 中，与网络交互时会使用异步函数。 要了解更多关于异步函数的信息，[请阅读这篇 Medium 文章](https://blog.bitsrc.io/understanding-asynchronous-javascript-the-event-loop-74cd408419ff)。
+在 JavaScript 中，与网络交互时会使用异步函数。 要了解有关异步函数的更多信息，请[阅读这篇 Medium 文章](https://blog.bitsrc.io/understanding-asynchronous-javascript-the-event-loop-74cd408419ff)。
-使用下面的代码来调用智能合约中的 `message` 函数，并读取 init 消息：
+使用下面的代码来调用智能合约中的 `message` 函数，并读取初始消息：
```javascript
// interact.js
@@ -481,7 +484,7 @@ main()
在终端使用 `npx hardhat run scripts/interact.js` 运行文件后，我们应该看到如下响应：
```
-The message is: Hello world!
+消息是：Hello world!
```
恭喜！ 你刚刚成功从以太坊区块链读取了智能合约数据，好样的！
@@ -508,11 +511,11 @@ async function main() {
main()
```
-请注意，在第 11 行，我们对返回的交易对象调用了 `.wait()`。 这确保了脚本在退出函数前等待交易在区块链上完成挖掘。 如果不包含 `.wait()` 调用，脚本可能不会看到合约中更新后的 `message` 值。
+请注意，在第 11 行，我们对返回的交易对象调用了 `.wait()`。 这确保了脚本在退出函数前等待交易在区块链上完成出块。 如果不包含 `.wait()` 调用，脚本可能不会看到合约中更新后的 `message` 值。
### 读取新消息 {#read-the-new-message}
-你可以重复[前面的步骤](#read-the-init-message)来读取更新后的 `message` 值。 花点时间，看看是否可以进行必要的更改以输出新值！
+你应该能够重复[前面的步骤](#read-the-init-message)来读取更新后的 `message` 值。 花点时间，看看是否可以进行必要的更改以输出新值！
如果你需要提示，你的 `interact.js` 文件现在应如下所示：
@@ -561,12 +564,12 @@ main()
`npx hardhat run scripts/interact.js --network goerli`
```
-The message is: Hello World!
-Updating the message...
-The new message is: This is the new message.
+消息是：Hello World!
+正在更新消息...
+新消息是：This is the new message.
```
-当运行那条脚本时，你可能会发现 `Updating the message...` 步骤需要一段时间才能加载完成，然后再加载新消息。 这是由挖矿过程导致的；如果你希望在对交易进行挖矿的同时追踪交易，可以访问 [Alchemy 内存池](https://dashboard.alchemyapi.io/mempool)查看交易的状态。 如果交易被丢弃，可以访问 [Goerli Etherscan](https://goerli.etherscan.io) 并搜索你的交易哈希值。
+当运行该脚本时，你可能会发现“Updating the message...”步骤需要一段时间才能加载完成，然后再加载新消息。 这是由挖矿过程导致的；如果你希望在对交易进行挖矿的同时追踪交易，可以访问 [Alchemy 内存池](https://dashboard.alchemyapi.io/mempool)查看交易的状态。 如果交易被丢弃，可以访问 [Goerli Etherscan](https://goerli.etherscan.io) 并搜索你的交易哈希值。
## 第三部分：将你的智能合约发布到 Etherscan {#part-3-publish-your-smart-contract-to-etherscan}
@@ -574,19 +577,19 @@ The new message is: This is the new message.
通过在 Etherscan 上验证你的智能合约，任何人都可以查看其源代码，并与智能合约进行交互。 让我们开始吧！
-### 步骤 1：在你的 Etherscan 帐户上生成应用程序接口密钥 {#step-1-generate-an-api-key-on-your-etherscan-account}
+### 第 1 步：在 Etherscan 帐户中生成 API 密钥 {#step-1-generate-an-api-key-on-your-etherscan-account}
-需要 Etherscan 应用程序接口密钥来验证你是否拥有你正在尝试发布的智能合约。
+需要 Etherscan API 密钥来验证你是否拥有你正在尝试发布的智能合约。
-如果你还没有 Etherscan 帐户，[请注册一个帐户](https://etherscan.io/register)。
+如果你还没有 Etherscan 帐户，请[注册一个帐户](https://etherscan.io/register)。
-登录后，在导航栏中找到你的用户名，将鼠标悬停在用户名上，然后选择 **My profile** 按钮。
+登录后，在导航栏中找到你的用户名，将鼠标悬停在用户名上，然后选择“**My profile**”按钮。
-在你的个人资料页面上，应该可以看到一个侧边导航栏。 从侧边导航栏中，选择 **API Key**。 接下来，按“Add”按钮创建一个新的应用程序接口密钥，将你的应用程序命名为 **hello-world**，然后按 **Create New API Key** 按钮。
+在你的个人资料页面上，应该可以看到一个侧边导航栏。 从侧边导航栏中，选择“**API Keys**”。 接下来，按“Add”按钮创建一个新的 API 密钥，将你的应用程序命名为 **hello-world**，然后按“**Create New API Key**”按钮。
-你的新应用程序接口密钥应出现在应用程序接口密钥表中。 将应用程序接口复制到剪贴板。
+你的新 API 密钥应出现在 API 密钥表中。 将 API 复制到剪贴板。
-接下来，我们需要将 Etherscan 应用程序接口添加到 `.env` 文件中。
+接下来，我们需要将 Etherscan API 密钥添加到我们的 `.env` 文件中。
添加完成后，你的 `.env` 文件应如下所示：
@@ -598,11 +601,11 @@ CONTRACT_ADDRESS = "your-contract-address"
ETHERSCAN_API_KEY = "your-etherscan-key"
```
-### 使用安全帽部署智能合约 {#hardhat-deployed-smart-contracts}
+### Hardhat部署的智能合约 {#hardhat-deployed-smart-contracts}
#### 安装 hardhat-etherscan {#install-hardhat-etherscan}
-使用安全帽将你的合约发布到 Etherscan 非常简单。 首先需要安装 `hardhat-etherscan` 插件。 `hardhat-etherscan` 会在 Etherscan 上自动验证智能合约的源代码和应用程序二进制接口。 为了添加此插件，你需要在 `hello-world` 目录中运行：
+使用Hardhat将你的合约发布到 Etherscan 非常简单。 首先需要安装 `hardhat-etherscan` 插件。 `hardhat-etherscan` 会在 Etherscan 上自动验证智能合约的源代码和 ABI。 为了添加此插件，你需要在 `hello-world` 目录中运行：
```text
npm install --save-dev @nomiclabs/hardhat-etherscan
@@ -630,14 +633,14 @@ module.exports = {
},
},
etherscan: {
- // Your API key for Etherscan
- // Obtain one at https://etherscan.io/
+ // Etherscan 的 API 密钥
+ // 在 https://etherscan.io/ 获取一个
apiKey: ETHERSCAN_API_KEY,
},
}
```
-#### 在 Etherscan 验证你的智能合约 {#verify-your-smart-contract-on-etherscan}
+#### 在 Etherscan 上验证你的智能合约 {#verify-your-smart-contract-on-etherscan}
确认所有文件都已保存，且所有 `.env` 变量都已正确配置。
@@ -652,34 +655,34 @@ npx hardhat verify --network goerli DEPLOYED_CONTRACT_ADDRESS 'Hello World!'
如果一切正常，你会在终端中看到以下消息：
```text
-Successfully submitted source code for contract
+成功提交合约源代码
contracts/HelloWorld.sol:HelloWorld at 0xdeployed-contract-address
-for verification on Etherscan. Waiting for verification result...
+正在 Etherscan 上验证。等待验证结果...
-Successfully verified contract HelloWorld on Etherscan.
+在 Etherscan 上成功验证合约 HelloWorld。
https://goerli.etherscan.io/address/#contracts
```
-恭喜！ 你的智能合约代码已经在 Etherscan 部署！
+恭喜！ 你的智能合约代码已在 Etherscan 上！
-### 在 Etherscan 查看你的智能合约！ {#check-out-your-smart-contract-on-etherscan}
+### 在 Etherscan 上查看你的智能合约！ {#check-out-your-smart-contract-on-etherscan}
-当你进入终端中给出的链接时，你应该会看到你的智能合约代码和应用程序二进制接口已在 Etherscan 上发布！
+当你进入终端中给出的链接时，你应该会看到你的智能合约代码和 ABI 已在 Etherscan 上发布！
-**哇 - 你成功了！ 现在所有人都可以调用或写入你的智能合约！ 我们已经等不及看你接下来会做什么了！**
+**哇哦 - 你成功了！ 现在所有人都可以调用或写入你的智能合约！ 我们已经等不及看你接下来会做什么了！**
-## 第 4 部分 - 将智能合约与前端集成 {#part-4-integrating-your-smart-contract-with-the-frontend}
+## 第四部分 - 将你的智能合约与前端集成 {#part-4-integrating-your-smart-contract-with-the-frontend}
本教程结束时，你将知道如何：
- 将 MetaMask 钱包连接到你的去中心化应用程序
-- 使用 [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) 应用程序接口从你的智能合约中读取数据
+- 使用 [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API 从你的智能合约中读取数据
- 使用 MetaMask 对以太坊交易签名
-对于此去中心化应用程序，我们会使用 [React](https://reactjs.org/) 作为前端框架；然而，需要注意的是，我们不会花很多时间来分解其基本内容，而是会聚焦于将 Web3 功能引入我们的项目。
+对于此去中心化应用程序，我们会使用 [React](https://react.dev/) 作为前端框架；然而，需要注意的是，我们不会花很多时间来分解其基本内容，而是会聚焦于将 Web3 功能引入我们的项目。
-作为前提条件，你需要对 React 有基本的了解。 否则，建议你完成官方的 [React 入门教程](https://reactjs.org/tutorial/tutorial.html)。
+作为前提条件，你需要对 React 有基本的了解。 否则，建议你完成官方的 [React 入门教程](https://react.dev/learn)。
### 克隆启动文件 {#clone-the-starter-files}
@@ -692,13 +695,13 @@ https://goerli.etherscan.io/address/#contracts
下面，用你喜欢的代码编辑器打开 `starter-files`，然后进入 `src` 文件夹。
-我们编写的所有代码都将保存在 `src` 文件夹下。 我们将通过编辑 `HelloWorld.js` 组件并编写 `util/interact.js` JavaScript 文件，为我们的项目提供 Web3 功能。
+我们将编写的所有代码都将存放在 `src` 文件夹下。 我们将编辑 `HelloWorld.js` 组件和 `util/interact.js` JavaScript 文件，为我们的项目提供 Web3 功能。
### 查看初始文件 {#check-out-the-starter-files}
在我们开始编写之前，让我们看看初始文件为我们提供了什么。
-#### 让你的 react 项目运行起来 {#get-your-react-project-running}
+#### 运行你的 React 项目 {#get-your-react-project-running}
首先在浏览器中运行 React 项目。 React 的美妙之处在于，一旦我们的项目在浏览器中运行，保存的任何更改都会在浏览器中实时更新。
@@ -709,21 +712,21 @@ cd starter-files
npm install
```
-依赖项安装完成后，在终端运行 `npm start`：
+安装完成后，在终端中运行 `npm start`：
```bash
npm start
```
-这样做应该会在你的浏览器中打开 [http://localhost:3000/](http://localhost:3000/)，在这里你会看到我们项目的前端界面。 它应该包含一个字段 \(一个更新存储在智能合约中的消息的地方\)，一个“Connect Wallet”按钮，以及一个“Update”按钮。
+这样做应该会在你的浏览器中打开 [http://localhost:3000/](http://localhost:3000/)，在这里你会看到我们项目的前端界面。 它应该包含一个字段（一个更新存储在智能合约中的消息的地方），一个“Connect Wallet”按钮，以及一个“Update”按钮。
-如果你试图点击这些按钮，你会发现它们都不起作用—这是因为我们仍然需要对其功能进行编程。
+如果你试图点击这些按钮，你会发现它们都不起作用——这是因为我们仍然需要对其功能进行编程。
#### `HelloWorld.js` 组件 {#the-helloworld-js-component}
让我们在编辑器中返回 `src` 文件夹并打开 `HelloWorld.js` 文件。 理解该文件中的所有内容非常重要，因为它是我们将要处理的主要 React 组件。
-在该文件开头，你会发现我们有几条 import 语句，这些语句是我们项目运行所必须的，它们包括 React 程序库，useEffect 和 useState 钩子，一些来自 `./util/interact.js` 的项（我们之后还会更详细的说明它们！）以及 Alchemy 徽标。
+在该文件开头，你会发现我们有几条 import 语句，这些语句是我们项目运行所必须的，它们包括 React 库，useEffect 和 useState 钩子，一些来自 `./util/interact.js` 的项（我们之后还会更详细的说明它们！），以及 Alchemy 徽标。
```javascript
// HelloWorld.js
@@ -755,10 +758,10 @@ const [newMessage, setNewMessage] = useState("")
以下是每个变量的含义：
-- `walletAddress` — 存储用户钱包地址的字符串
-- `status` — 用于存储有用消息，指导用户如何与去中心化应用程序交互的字符串
-- `message` — 存储智能合约中当前消息的字符串
-- `newMessage` — 存储将要写入智能合约中的新消息的字符串
+- `walletAddress` - 存储用户钱包地址的字符串
+- `status`- 用于存储有用消息，指导用户如何与去中心化应用程序交互的字符串
+- `message` - 存储智能合约中当前消息的字符串
+- `newMessage` - 存储将要写入智能合约中的新消息的字符串
在状态变量后，你会发现五个还未实现的函数：`useEffect`、`addSmartContractListener`、`addWalletListener`、`connectWalletPressed` 以及 `onUpdatePressed`。 我们会在下面解释它们的作用：
@@ -787,11 +790,11 @@ const onUpdatePressed = async () => {
}
```
-- [`useEffect`](https://reactjs.org/docs/hooks-effect.html) — 这是会在你的组件被渲染后调用的 React 钩子。 因为向它传入了一个空的数组 `[]` 属性 \（见第 4 行\），它只会在组件的_第一次_渲染时被调用。 在这里我们会加载智能合约中存储的当前消息，调用智能合约和钱包监听器，并更新用户界面来反映钱包是否已连接。
-- `addSmartContractListener` — 这个函数设置了一个监听器，这个监听器会监视 HelloWorld 合约中的 `UpdatedMessages` 事件，并在智能合约中的消息变化时更新用户界面。
-- `addWalletListener` — 这个函数设置了一个监听器，来检测用户的 MetaMask 钱包的状态变化，比如用户断开他们的钱包或切换钱包地址时。
-- `connectWalletPressed` — 这个函数用于将用户的 MetaMask 钱包连接到我们的去中心化应用程序。
-- `onUpdatePressed` — 这个函数会在用户更新智能合约中存储的消息时被调用。
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) - 这是一个在你的组件渲染后被调用的 React 钩子。 因为向它传入了一个空的数组 `[]` 属性（见第 4 行），它只会在组件的_第一次_渲染时被调用。 在这里我们会加载智能合约中存储的当前消息，调用智能合约和钱包监听器，并更新用户界面来反映钱包是否已连接。
+- `addSmartContractListener` - 这个函数设置了一个监听器，这个监听器会监视 HelloWorld 合约中的 `UpdatedMessages` 事件，并在智能合约中的消息变化时更新用户界面。
+- `addWalletListener` - 这个函数设置了一个监听器，来检测用户的 MetaMask 钱包的状态变化，比如用户断开他们的钱包或切换地址时。
+- `connectWalletPressed` - 这个函数用于将用户的 MetaMask 钱包连接到我们的去中心化应用程序。
+- `onUpdatePressed` - 这个函数会在用户更新智能合约中存储的消息时被调用。
在接近该文件末尾处，我们获得我们组件的用户界面。
@@ -830,16 +833,17 @@ return (
-
-
+
+
+
)
```
如果你细致地检查这段代码，就会发现我们在用户界面中的哪里使用了各种状态变量：
-- 在第 6-12 行，如果用户的钱包已连接 \(即 `walletAddress.length > 0`\)，我们就在 ID 为“walletButton;”的按钮中显示用户 `walletAddress` 的截短版，否则我们就只显示“连接钱包”。
+- 在第 6-12 行，如果用户的钱包已连接（即 `walletAddress.length > 0`），我们就在 ID 为“walletButton”的按钮中显示用户 `walletAddress` 的截短版；否则我们就只显示“Connect Wallet”。
- 在第 17 行，我们显示在 `message` 字符串中获取的智能合约中存储的当前消息。
-- 在第 23-26 行，我们使用一个[受控组件，](https://reactjs.org/docs/forms.html#controlled-components)以用于在文本字段中输入更改时更新 `newMessage` 状态变量。
+- 在第 23-26 行，我们使用一个[受控组件](https://legacy.reactjs.org/docs/forms.html#controlled-components)，以用于在文本字段中输入更改时更新我们的 `newMessage` 状态变量。
除了状态变量之外，你还将看到，在分别单击 ID 为 `publishButton` 和 `walletButton` 的按钮时，会调用 `connectWalletPressed` 和 `onUpdatePressed`。
@@ -851,7 +855,7 @@ return (
#### `interact.js` 文件 {#the-interact-js-file}
-因为我们建议采用 [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) 规范，我们需要一个单独的文件包含用来管理我们的去中心化应用程序的逻辑、数据和规则的所有函数，然后我们就能将这些函数导出到前端 \(`HelloWorld.js` 组件\)。
+因为我们建议采用 [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) 规范，我们需要一个单独的文件包含用来管理我们的去中心化应用程序的逻辑、数据和规则的所有函数，然后我们就能将这些函数导出到前端（我们的 `HelloWorld.js` 组件）。
👆🏽这就是 `interact.js` 文件的确切目的！
@@ -875,45 +879,45 @@ export const updateMessage = async (message) => {}
`helloWorldContract` 对象之后的四个未实现函数会发挥以下作用：
-- `loadCurrentMessage` — 这个函数处理加载智能合约中存储的信息的逻辑。 它会使用 [Alchemy Web3 API](https://github.com/alchemyplatform/alchemy-web3)，向 Hello World 智能合约发起一个_读取_调用。
-- `connectWallet` — 这个函数会将用户的 MetaMask 连接到我们的去中心化应用程序。
-- `getCurrentWalletConnected` — 这个函数会在页面加载时检查是否已经有以太坊帐户连接到我们的去中心化应用程序，并且相应更新我们的用户界面。
-- `updateMessage` — 这个函数会更新智能合约中存储的消息。 它会向 Hello World 智能合约发起一个_写入_调用，所以用户的 MetaMask 钱包需要签名一个以太坊交易来更新此消息。
+- `loadCurrentMessage` - 这个函数处理加载智能合约中存储的消息的逻辑。 它会使用 [Alchemy Web3 API](https://github.com/alchemyplatform/alchemy-web3)，向 Hello World 智能合约发起一个_读取_调用。
+- `connectWallet` - 这个函数会将用户的 MetaMask 连接到我们的去中心化应用程序。
+- `getCurrentWalletConnected` - 这个函数会在页面加载时检查是否已经有以太坊帐户连接到我们的去中心化应用程序，并且相应更新我们的用户界面。
+- `updateMessage` - 这个函数会更新智能合约中存储的消息。 它会向 Hello World 智能合约发起一个_写入_调用，所以用户的 MetaMask 钱包需要签署一个以太坊交易来更新此消息。
现在我们已经了解所操作的对象，让我们看看如何从智能合约中读取吧！
-### 第三步：从你的智能合约中读取 {#step-3-read-from-your-smart-contract}
+### 第 3 步：从你的智能合约中读取 {#step-3-read-from-your-smart-contract}
为了从智能合约中读取，你需要成功设置以下内容：
-- 一个到以太坊链的应用程序接口连接
+- 一个到以太坊链的 API 连接
- 一个已加载的智能合约实例
- 一个用来调用智能合约函数的函数
- 一个监听器，用于监听智能合约中你正读取的数据出现变化时的更新
听起来步骤可能很多，但是不要担心！ 我们会引导你逐步完成这些步骤！ :\)
-#### 建立一个到以太坊链的应用程序接口连接 {#establish-an-api-connection-to-the-ethereum-chain}
+#### 建立到以太坊链的 API 连接 {#establish-an-api-connection-to-the-ethereum-chain}
-还记得我们在教程的第二部分怎么用我们的 [Alchemy Web3 密钥从我们的智能合约中读取](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library)吗？ 你在去中心化应用程序中也需要一个 Alchemy Web3 密钥来从链上读取。
+还记得在本教程的第 2 部分中，我们是如何使用 [Alchemy Web3 密钥从我们的智能合约中读取](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library)的吗？ 你在去中心化应用程序中也需要一个 Alchemy Web3 密钥来从链上读取。
-如果你还没有提前准备好，首先，我们来安装 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3)，导航到 `starter-files` 的根目录，然后在你的终端运行以下内容：
+如果你还没有，首先安装 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3)，导航到 `starter-files` 的根目录，然后在你的终端运行以下命令：
```text
npm install @alch/alchemy-web3
```
-[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 是 [Web3.js](https://docs.web3js.org/) 的包装器，提供增强的应用程序接口方法和其他重要优势，让 Web3 开发者的工作更轻松。 它设计成只需经过最少的配置即可使用，因此你可以直接在你的应用程序中开始使用它！
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 是 [Web3.js](https://docs.web3js.org/) 的包装器，提供增强的 API 方法和其他重要优势，让 Web3 开发者的工作更轻松。 它设计成只需经过最少的配置即可使用，因此你可以直接在你的应用程序中开始使用它！
-然后，在你的项目目录中安装 [dotenv](https://www.npmjs.com/package/dotenv) 程序包，我们就有了一个在获取我们应用程序接口密钥后安全存储它的地方。
+然后，在你的项目目录中安装 [dotenv](https://www.npmjs.com/package/dotenv) 程序包，这样我们就有了一个在获取我们 API 密钥后安全存储它的地方。
```text
npm install dotenv --save
```
-对于我们的去中心化应用程序，将不再使用 HTTP 应用程序接口密钥，**而是改用 Websockets 应用程序接口密钥**，因为它会允许我们设置一个监测智能合约中消息变化的监听器。
+对于我们的去中心化应用程序，我们将不再使用 HTTP API 密钥，而是改用 **Websockets API 密钥**，因为它会允许我们设置一个监测智能合约中消息变化的监听器。
-在你获得应用程序接口密钥后，在你的根目录中创建 `.env` 文件，并在其中添加你的 Alchemy Websockets URL。 在这之后，你的 `.env` 文件应该如下所示：
+在你获得 API 密钥后，在你的根目录中创建 `.env` 文件，并在其中添加你的 Alchemy Websockets URL。 在这之后，你的 `.env` 文件应该如下所示：
```javascript
REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/
@@ -938,17 +942,17 @@ const web3 = createAlchemyWeb3(alchemyKey)
#### 加载你的 Hello World 智能合约 {#loading-your-hello-world-smart-contract}
-要加载你的 Hello World 智能合约，将需要其合约地址和应用程序二进制接口，如果你完成了[这个教程的第三部分](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan)，这两者都可以在 Etherscan 上找到。
+要加载你的 Hello World 智能合约，你需要它的合约地址和 ABI，如果你完成了[本教程的第 3 部分](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan)，这两者都可以在 Etherscan 上找到。
-#### 如何从 Etherscan 获取合约的应用程序二进制接口 {#how-to-get-your-contract-abi-from-etherscan}
+#### 如何从 Etherscan 获取你的合约 ABI {#how-to-get-your-contract-abi-from-etherscan}
-如果你跳过了这个教程的第三部分，你可以使用 HelloWorld 合约，其地址为 [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code)。 它的应用程序二进制接口可在[这里](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code)找到。
+如果你跳过了本教程的第 3 部分，你可以使用地址为 [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code) 的 HelloWorld 合约。 其 ABI 可以在[这里](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code)找到。
-在指定合约将要调用的函数，以及确保函数以你期望的格式返回数据时，合约的应用程序二进制接口必不可少。 复制合约应用程序二进制接口后，让我们将其保存到 `src` 目录，保存为文件名为 `contract-abi.json` 的 JSON 文件。
+在指定合约将要调用的函数，以及确保函数以你期望的格式返回数据时，合约的 ABI 必不可少。 复制合约 ABI 后，让我们将其保存到 `src` 目录，保存为文件名为 `contract-abi.json` 的 JSON 文件。
你的 contract-abi.json 文件应存储在 src 文件夹。
-有了合约地址、应用程序二进制接口和 Alchemy Web3 端点，我们就可以使用[合约方法](https://docs.web3js.org/api/web3-eth-contract/class/Contract)来加载智能合约的实例。 将你的合约应用程序二进制接口导入 `interact.js` 文件，然后添加你的合约地址。
+有了合约地址、ABI 和 Alchemy Web3 端点，我们就可以使用[合约方法](https://docs.web3js.org/api/web3-eth-contract/class/Contract)来加载智能合约的实例。 将你的合约 ABI 导入 `interact.js` 文件，然后添加你的合约地址。
```javascript
// interact.js
@@ -957,7 +961,7 @@ const contractABI = require("../contract-abi.json")
const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
```
-现在，我们终于可以删除 `helloWorldContract` 变量的注释，并用 AlchemyWeb3 端点加载智能合约了：
+现在，我们终于可以取消 `helloWorldContract` 变量的注释，并用 AlchemyWeb3 端点加载智能合约了：
```javascript
// interact.js
@@ -988,9 +992,9 @@ export const helloWorldContract = new web3.eth.Contract(
我们现在已经加载了合约，可以实现 `loadCurrentMessage` 函数了！
-#### 在 `interact.js` 文件中实现 `loadCurrentMessage` {#implementing-loadCurrentMessage-in-your-interact-js-file}
+#### 在你的 `interact.js` 文件中实现 `loadCurrentMessage` {#implementing-loadCurrentMessage-in-your-interact-js-file}
-这个函数非常简单。 我们将通过一个简单的异步 Web3 调用来从我们的合约中读取信息。 我们的函数会返回智能合约中存储的消息：
+这个函数非常简单。 我们将通过一个简单的异步 web3 调用来从我们的合约中读取信息。 我们的函数会返回智能合约中存储的消息：
将 `interact.js` 文件中的 `loadCurrentMessage` 更新为如下：
@@ -1017,17 +1021,17 @@ useEffect(async () => {
注意，我们只希望在组件第一次渲染时调用 `loadCurrentMessage` 函数一次。 我们很快会实现 `addSmartContractListener` 以在智能合约中的消息变化后自动更新用户界面。
-在我们深入研究监听器之前，让我们看看现在已经做了什么！ 保存你的 `HelloWorld.js` 和 `interact.js` 文件，然后访问 [http://localhost:3000/](http://localhost:3000/)。
+在我们深入研究监听器之前，让我们看看现在已经做了什么！ 保存你的 `HelloWorld.js` 和 `interact.js` 文件，然后访问 [http://localhost:3000/](http://localhost:3000/)
你会发现当前的消息不再是“No connection to the network.” 相反，它反映了智能合约中存储的消息。 酷！
-#### 你的用户界面现在应该反映了智能合约中存储的消息 {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
+#### 你的用户界面现在应反映智能合约中存储的消息 {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
说到监听器……
#### 实现 `addSmartContractListener` {#implement-addsmartcontractlistener}
-回想我们在[这个教程的第 1 部分](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract)编写的 `HelloWorld.sol`，你会记得有一个名为 `UpdatedMessages` 的智能合约事件，这是在调用我们的智能合约的 `update` 函数后触发的 \（参见第 9 行和第 27 行\）：
+回想我们在[本系列教程的第 1 部分](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract)中编写的 `HelloWorld.sol` 文件，你会记得有一个名为 `UpdatedMessages` 的智能合约事件，这是在调用我们的智能合约的 `update` 函数后触发的（参见第 9 行和第 27 行）：
```javascript
// HelloWorld.sol
@@ -1037,7 +1041,7 @@ useEffect(async () => {
pragma solidity ^0.7.3;
// Defines a contract named `HelloWorld`.
-// 一个合约是函数和数据（其状态）的集合。 Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// A contract is a collection of functions and data (its state). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {
//Emitted when update function is called
@@ -1045,11 +1049,11 @@ contract HelloWorld {
event UpdatedMessages(string oldStr, string newStr);
// Declares a state variable `message` of type `string`.
- // 状态变量是其值永久存储在合约存储中的变量。 The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+ // State variables are variables whose values are permanently stored in contract storage. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
string public message;
// Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
- // 构造器用于初始化合约的数据。 Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ // Constructors are used to initialize the contract's data. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
constructor(string memory initMessage) {
// Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
@@ -1065,7 +1069,7 @@ contract HelloWorld {
}
```
-智能合约事件是你的合约向你的前端应用程序传达区块链上发生的事情 \（即：有一个_事件_\）的一种方式，你的前端应用程序可以“监听”特定事件，并在事件发生时采取行动。
+智能合约事件是你的合约向你的前端应用程序传达区块链上发生的事情（即：有一个_事件_）的一种方式，你的前端应用程序可以“监听”特定事件，并在事件发生时采取行动。
`addSmartContractListener` 函数将专门监听我们 Hello World 智能合约的 `UpdatedMessages` 事件，并更新用户界面来显示新消息。
@@ -1081,7 +1085,7 @@ function addSmartContractListener() {
} else {
setMessage(data.returnValues[1])
setNewMessage("")
- setStatus("🎉 Your message has been updated!")
+ setStatus("🎉 你的消息已更新！")
}
})
}
@@ -1092,7 +1096,7 @@ function addSmartContractListener() {
- 如果事件触发时出现错误，它将通过我们的 `status` 状态变量反映在用户界面中。
- 反之，我们就可以使用返回的 `data` 对象。 `data.returnValues` 是一个以 0 为起始索引的数组，其中数组的第一个元素保存的是之前的消息，而第二个元素则保存了更新后的新消息。 总体来说，在成功触发事件的情况下，我们会将 `message` 字符串设置为更新后的消息，同时清除 `newMessage` 字符串，并且更新 `status` 状态变量以表明已在智能合约上发布一条新的消息。
-最终，我们应在 `useEffect` 钩子函数中调用这个监听器，确保它在 `HelloWorld.js` 组件初次渲染时即被初始化。 综上所述，我们的 `useEffect` 钩子函数应当如下所示：
+最终，我们应在 `useEffect` 函数中调用这个监听器，确保它在 `HelloWorld.js` 组件初次渲染时即被初始化。 综上所述，我们的 `useEffect` 函数应当如下所示：
```javascript
// HelloWorld.js
@@ -1106,35 +1110,35 @@ useEffect(async () => {
现在我们已经掌握了从智能合约读取消息的方法，那么接下来了解如何向智能合约中写入消息那就太棒了！ 然而，要向我们的去中心化应用执行写入，我们首先必须有一个连接到该去中心化应用程序的以太坊钱包。
-接下来，我们将着手设置以太坊钱包 \(MetaMask\)，然后将其连接到我们的去中心化应用程序！
+接下来，我们将着手设置以太坊钱包（MetaMask），然后将其连接到我们的去中心化应用程序！
-### 第四步：设置你的以太坊钱包 {#step-4-set-up-your-ethereum-wallet}
+### 第 4 步：设置你的以太坊钱包 {#step-4-set-up-your-ethereum-wallet}
-为了向以太坊链上写入任何数据，用户必须使用其虚拟钱包的私钥来签署交易。 在本教程中，我们将使用浏览器中的虚拟钱包 [MetaMask](https://metamask.io/) 来管理你的以太坊帐户地址，因为它让终端用户签署交易变得极其简单。
+为了向以太坊链上写入任何数据，用户必须使用其虚拟钱包的私钥来签署交易。 在本教程中，我们将使用 [MetaMask](https://metamask.io/)，这是一个浏览器中的虚拟钱包，用于管理你的以太坊帐户地址，因为它让终端用户签署交易变得极其简单。
-如果你想了解更多关于以太坊交易的运作方式，请查看以太坊基金会的[这个页面](/developers/docs/transactions/)。
+如果你想进一步了解以太坊交易的运作方式，请查看以太坊基金会的[这个页面](/developers/docs/transactions/)。
#### 下载 MetaMask {#download-metamask}
-你可以[在这里](https://metamask.io/download)免费下载并创建一个 MetaMask 帐户。 在你创建帐户时，或者如果你已经有帐户，请确保切换到右上角的“Goerli 测试网络”（这样我们就不会使用实际货币进行交易）。
+你可以[在此处](https://metamask.io/download)免费下载和创建 MetaMask 帐户。 在你创建帐户时，或者如果你已经有帐户，请确保切换到右上角的“Goerli 测试网络”（这样我们就不会使用实际货币进行交易）。
-#### 通过水龙头中添加以太币 {#add-ether-from-a-faucet}
+#### 通过水龙头获取以太币 {#add-ether-from-a-faucet}
-为了在以太坊区块链上签署交易，我们需要一些虚拟以太币。 要获取以太币，你可以前往 [FaucETH](https://fauceth.komputing.org) 并输入你的 Goerli 帐户地址，单击“Request funds”，然后在下拉菜单中选择“Ethereum Testnet Goerli”，最后再次单击“Request funds”按钮。 你应该会很快在你的 MetaMask 帐户中看到以太币！
+为了在以太坊区块链上签署交易，我们需要一些虚拟 Eth。 要获取 Eth，你可以前往 [FaucETH](https://fauceth.komputing.org) 并输入你的 Goerli 帐户地址，单击“Request funds”，然后在下拉菜单中选择“Ethereum Testnet Goerli”，最后再次单击“Request funds”按钮。 你应该会很快在你的 MetaMask 帐户中看到以太币！
-#### 查看你的余额 {#check-your-balance}
+#### 检查你的余额 {#check-your-balance}
-为了核查我们帐户中有余额，我们使用 [Alchemy composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D)发出 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入你的 Metamask 帐户地址并单击“发送请求”后，你应该会看到这样的响应：
+为了仔细检查我们的余额，让我们使用 [Alchemy 的 composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) 发出一个 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入你的 MetaMask 帐户地址并点击“Send Request”后，你应该会看到这样的响应：
```text
{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
```
-**注意：**结果以 wei 为单位，而非 ETH。 Wei is used as the smallest denomination of ether. 从 wei 到 eth 的转换是：1 eth = 10¹⁸ wei。 因此，如果我们将 0xde0b6b3a7640000 转换为十进制，我们会得到 1\*10¹⁸，它等于 1 eth。
+\*\*注意：\*\*此结果以 wei 为单位，而不是 eth。 Wei 是以太币的最小计量单位。 从 wei 到 eth 的转换是：1 eth = 10¹⁸ wei。 因此，如果我们将 0xde0b6b3a7640000 转换为十进制，我们会得到 1\*10¹⁸，它等于 1 eth。
-Phew! 我们的虚拟以太币都在那里了！ 🤑
+哦！ 我们的虚拟以太币都在那里了！ 🤑
-### 第五步：将 MetaMask 连接到你的用户界面 {#step-5-connect-metamask-to-your-UI}
+### 第 5 步：将 MetaMask 连接到你的 UI {#step-5-connect-metamask-to-your-UI}
既然我们的 MetaMask 钱包已经设置好了，我们将我们的去中心化应用程序与之连接！
@@ -1154,7 +1158,7 @@ export const connectWallet = async () => {
method: "eth_requestAccounts",
})
const obj = {
- status: "👆🏽 Write a message in the text-field above.",
+ status: "👆🏽 在上面的文本字段中写入一条消息。",
address: addressArray[0],
}
return obj
@@ -1172,8 +1176,7 @@ export const connectWallet = async () => {
@@ -1187,20 +1190,20 @@ export const connectWallet = async () => {
首先，该函数会检查你的浏览器是否启用了 `window.ethereum`。
-`window.ethereum` 是一个由 MetaMask 和其他钱包提供商注入的全局应用程序接口，它允许网站请求用户的以太坊帐户。 如果被批准，它可以读取用户连接的区块链上的数据，并建议用户签署消息和交易。 参阅 [MetaMask 文档](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents)了解更多信息！
+`window.ethereum` 是由 MetaMask 和其他钱包提供商注入的全局 API，允许网站请求用户的以太坊帐户。 如果被批准，它可以读取用户连接的区块链上的数据，并建议用户签署消息和交易。 有关详细信息，请查看 [MetaMask 文档](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents)！
-如果 `window.ethereum` _ 不存在_，则表示未安装 MetaMask。 这会导致返回一个 JSON 对象，其中返回的 `address` 是一个空字符串，而 `status` JSX 对象指示用户必须安装 MetaMask。
+如果 `window.ethereum` _不_存在，则意味着 MetaMask 未安装。 这将导致返回一个 JSON 对象，其中返回的 `address` 是一个空字符串，而 `status` JSX 对象则会提示用户必须安装 MetaMask。
-现在如果 `window.ethereum` _存在_，那么事情就会变得有趣。
+现在，如果 `window.ethereum` _是_存在的，事情就变得有趣了。
-使用 try/catch 循环，我们将尝试通过调用 [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) 连接到 MetaMask。 调用此函数将在浏览器中打开 MetaMask，提示用户将他们的钱包连接到你的去中心化应用程序。
+使用 try/catch 循环，我们将通过调用 [`window.ethereum.request({ method: \"eth_requestAccounts\" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) 来尝试连接到 MetaMask。 调用此函数将在浏览器中打开 MetaMask，提示用户将他们的钱包连接到你的去中心化应用程序。
-- 如果用户选择连接，`method: "eth_requestAccounts"` 将返回一个数组，其中包含连接到去中心化应用程序的用户的所有帐户地址。 总之，我们的 `connectWallet` 函数将返回一个 JSON 对象，其中包含此数组中的_第一个 _ `address` \（见第 9 行\），并返回一条 `status` 信息，提示用户向智能合约写入信息。
-- 如果用户拒绝连接，则 JSON 对象将包含返回的 `address` 的空字符串和反映用户拒绝连接的 `status` 信息。
+- 如果用户选择连接，`method: "eth_requestAccounts"` 将返回一个数组，其中包含连接到去中心化应用程序的用户的所有帐户地址。 总而言之，我们的 `connectWallet` 函数将返回一个 JSON 对象，其中包含此数组中的_第一个_ `address`（见第 9 行）和一条提示用户向智能合约写入消息的 `status` 消息。
+- 如果用户拒绝连接，则 JSON 对象将包含一个空字符串作为返回的 `address`，以及一条反映用户拒绝连接的 `status` 消息。
现在我们已经编写了这个 `connectWallet` 函数，下一步是调用它到我们的 `HelloWorld.js` 组件中。
-#### 将 `connectWallet` 函数添加到你的 `HelloWorld.js` 用户界面组件中 {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
+#### 将 `connectWallet` 函数添加到你的 HelloWorld.js 用户界面组件 {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
导航到 `HelloWorld.js` 文件中的 `connectWalletPressed` 函数，并将其更新为以下内容：
@@ -1214,21 +1217,21 @@ const connectWalletPressed = async () => {
}
```
-注意我们的大部分函数是如何从 `interact.js` 文件中的 `HelloWorld.js` 组件中抽象出来的？ 这就是我们遵守 M-V-C 规范的原因！
+注意到我们的大部分功能是如何从 `interact.js` 文件中的 `HelloWorld.js` 组件中抽象出来的吗？ 这就是我们遵守 M-V-C 规范的原因！
-在 `connectWalletPressed` 中，我们只需对导入的 `connectWallet` 函数进行 await 调用，并使用其响应，通过变量的状态挂钩更新我们的 `status` 和 `walletAddress ` 变量。
+在 `connectWalletPressed` 中，我们只需对导入的 `connectWallet` 函数进行 `await` 调用，并使用其响应通过它们的状态钩子来更新 `status` 和 `walletAddress` 变量。
-现在，让我们保存两个文件 \(`HelloWorld.js` 和 `interact.js`\) ，并测试一下我们目前的用户界面。
+现在，让我们保存两个文件（`HelloWorld.js` 和 `interact.js`），并测试一下我们目前的用户界面。
-打开浏览器，在地址栏中输入 [localhost:3000](http://localhost:3000/)，然后按页面右上角的“Connect Wallet”按钮。
+打开浏览器，在地址栏中输入 [http://localhost:3000/](http://localhost:3000/)，然后按页面右上角的“Connect Wallet”按钮。
如果你安装了 MetaMask，系统会提示你将钱包连接到去中心化应用程序。 接受邀请并连接。
-你会看到钱包按钮现在反映你的地址已连接！ 太棒了 🔥 ！
+你会看到钱包按钮现在反映你的地址已连接！ 太棒了 🔥！
-接下来，尝试刷新页面......有点儿奇怪。 我们的钱包按钮提示我们连接 MetaMask，尽管它已经连接......
+接下来，尝试刷新页面…… 这很奇怪。 我们的钱包按钮提示我们连接 MetaMask，尽管它已经连接......
-然而，不要害怕！ 我们可以通过实现 `getCurrentWalletConnected` 轻松解决这个问题（明白了吗？），它将检查一个地址是否已经连接到我们的去中心化应用程序，并相应地更新我们的用户界面！
+然而，不要害怕！ 我们可以轻松解决这个问题（明白了吗？） 通过实现 `getCurrentWalletConnected`，它将检查一个地址是否已经连接到我们的去中心化应用程序，并相应地更新我们的用户界面！
#### `getCurrentWalletConnected` 函数 {#the-getcurrentwalletconnected-function}
@@ -1246,12 +1249,12 @@ export const getCurrentWalletConnected = async () => {
if (addressArray.length > 0) {
return {
address: addressArray[0],
- status: "👆🏽 Write a message in the text-field above.",
+ status: "👆🏽 在上面的文本字段中写入一条消息。",
}
} else {
return {
address: "",
- status: "🦊 Connect to MetaMask using the top right button.",
+ status: "🦊 使用右上角按钮连接到 MetaMask。",
}
}
} catch (err) {
@@ -1268,8 +1271,7 @@ export const getCurrentWalletConnected = async () => {
@@ -1279,9 +1281,9 @@ export const getCurrentWalletConnected = async () => {
}
```
-这段代码与我们刚刚在上一步中编写的 `connectWallet` 函数 _非常相似_ 。
+这段代码与我们刚刚在上一步中编写的 `connectWallet` 函数非常相似。
-主要区别在于，这里我们调用了 `eth_accounts` 方法，它只是返回一个数组，其中包含当前连接到我们的去中心化应用程序的 MetaMask 地址，而不是调用 `eth_requestAccounts` 方法来打开 MetaMask 以供用户连接他们的钱包。
+主要区别在于，我们这里调用的方法是 `eth_accounts`，它只是返回一个包含当前连接到我们去中心化应用程序的 MetaMask 地址的数组，而不是调用会打开 MetaMask 供用户连接钱包的 `eth_requestAccounts` 方法。
为了看看这个函数在实际应用中的效果，让我们在 `HelloWorld.js` 组件的 `useEffect` 函数中调用它：
@@ -1319,10 +1321,10 @@ function addWalletListener() {
window.ethereum.on("accountsChanged", (accounts) => {
if (accounts.length > 0) {
setWallet(accounts[0])
- setStatus("👆🏽 Write a message in the text-field above.")
+ setStatus("👆🏽 在上面的文本字段中写入一条消息。")
} else {
setWallet("")
- setStatus("🦊 Connect to MetaMask using the top right button.")
+ setStatus("🦊 使用右上角按钮连接到 MetaMask。")
}
})
} else {
@@ -1330,7 +1332,7 @@ function addWalletListener() {
)
@@ -1340,11 +1342,11 @@ function addWalletListener() {
我敢打赌，到了这一步你可能已经无需我们帮助就能理解这里发生的情况了，但为了确保详尽无遗，我们还是快速梳理一下：
-- 首先，我们的函数检查是否启用了 `window.ethereum` \（即 MetaMask 已安装\）。
+- 首先，我们的函数会检查 `window.ethereum` 是否已启用（即 MetaMask 是否已安装）。
- 如果未启用，我们只需将 `status` 状态变量设置为提示用户安装 MetaMask 的 JSX 字符串。
- - 如果启用，我们会在第 3 行设置监听器 `window.ethereum.on("accountsChanged")` 监听 MetaMask 钱包中的状态变化，变化包括用户将其他帐户连接到去中心化应用程序、切换帐户或断开帐户。 如果至少连接了一个帐户，`walletAddress` 状态变量将更新为监听器返回的 `accounts` 数组中的第一个帐户。 否则，`walletAddress` 设置为空字符串。
+ - 如果启用，我们会在第 3 行设置监听器 `window.ethereum.on("accountsChanged")` 监听 MetaMask 钱包中的状态变化，变化包括用户将其他帐户连接到去中心化应用程序、切换帐户或断开帐户。 如果至少连接了一个帐户，`walletAddress` 状态变量将更新为监听器返回的 `accounts` 数组中的第一个帐户。 否则，`walletAddress` 将设置为空字符串。
-最后，但同样重要的一点是，我们必须在 `useEffect` 函数中调用它：
+最后但同样重要的一点是，我们必须在 `useEffect` 函数中调用它：
```javascript
// HelloWorld.js
@@ -1362,9 +1364,9 @@ useEffect(async () => {
}, [])
```
-就是这样！ 我们已经成功完成了所有钱包功能的编程！ 现在，我们来完成最后一个任务：更新智能合约中存储的消息！
+就这些！ 我们已经成功完成了所有钱包功能的编程！ 现在，我们来完成最后一个任务：更新智能合约中存储的消息！
-### 第六步：实现 `updateMessage` 函数 {#step-6-implement-the-updateMessage-function}
+### 第 6 步：实现 `updateMessage` 函数 {#step-6-implement-the-updateMessage-function}
好嘞，伙计们，我们已经来到最后阶段了！ 在 `interact.js` 文件中的 `updateMessage` 函数中，我们将执行以下操作：
@@ -1378,7 +1380,7 @@ useEffect(async () => {
显然，我们在函数开头加入一些输入错误处理代码是有意义的做法。
-如果未安装 MetaMask 扩展，或者钱包尚未连接 \（即传入的 `address` 为空字符串\），亦或是 `message` 为空字符串，我们希望函数能够提前返回。 让我们在 `updateMessage` 函数中添加以下错误处理代码：
+如果未安装 MetaMask 扩展，或者钱包尚未连接（即传入的 `address` 为空字符串），亦或是 `message` 为空字符串，我们希望函数能够提前返回。 让我们在 `updateMessage` 函数中添加以下错误处理代码：
```javascript
// interact.js
@@ -1387,13 +1389,13 @@ export const updateMessage = async (address, message) => {
if (!window.ethereum || address === null) {
return {
status:
- "💡 Connect your MetaMask wallet to update the message on the blockchain.",
+ "💡 连接你的 MetaMask 钱包以更新区块链上的消息。",
}
}
if (message.trim() === "") {
return {
- status: "❌ Your message cannot be an empty string.",
+ status: "❌ 你的消息不能为空字符串。",
}
}
}
@@ -1401,7 +1403,7 @@ export const updateMessage = async (address, message) => {
现在，我们已经实现了正确的输入错误处理，接下来就是通过 MetaMask 来签署交易的时候了！
-#### 签署交易 {#signing-our-transaction}
+#### 签署我们的交易 {#signing-our-transaction}
如果你已经对传统的 web3 以太坊交易驾轻就熟，那么接下来我们要编写的代码将会非常熟悉。 在输入错误处理代码下方，向 `updateMessage` 函数添加以下内容：
@@ -1426,11 +1428,10 @@ try {
✅{" "}
- View the status of your transaction on Etherscan!
+ 在 Etherscan 上查看您的交易状态！
- ℹ️ Once the transaction is verified by the network, the message will be
- updated automatically.
+ ℹ️ 一旦交易被网络验证，消息将自动更新。
),
}
@@ -1443,11 +1444,11 @@ try {
让我们来详细解析下这些代码的工作原理。 首先，我们设置了交易参数，具体内容如下：
-- `to` 指定接收者地址\（我们的智能合约\）
+- `to` 指定接收者地址（我们的智能合约）
- `from` 指定交易的签名者，即我们传入函数的 `address` 变量
-- `data` 包含对我们的“Hello World”智能合约中 `update` 方法的调用，其中将 `message` 字符串变量作为输入
+- `data` 包含对我们的 Hello World 智能合约中 `update` 方法的调用，其中将 `message` 字符串变量作为输入
-接下来，我们进行对 `window.ethereum.request` 进行异步调用，请求 MetaMask 对交易进行签名。 请注意，在第 11 和 12 行中，我们指定了以太坊方法 `eth_sendTransaction`，并传入了我们的 `transactionParameters`。
+接下来，我们进行对 `window.ethereum.request` 进行异步调用，请求 MetaMask 对交易进行签名。 请注意，在第 11 和 12 行中，我们指定了以太坊方法 `eth_sendTransaction` 并传入了我们的 `transactionParameters`。
此时，MetaMask 将在浏览器中打开，并提示用户签署或拒绝交易。
@@ -1464,13 +1465,13 @@ export const updateMessage = async (address, message) => {
if (!window.ethereum || address === null) {
return {
status:
- "💡 Connect your MetaMask wallet to update the message on the blockchain.",
+ "💡 连接你的 MetaMask 钱包以更新区块链上的消息。",
}
}
if (message.trim() === "") {
return {
- status: "❌ Your message cannot be an empty string.",
+ status: "❌ 你的消息不能为空字符串。",
}
}
@@ -1492,11 +1493,10 @@ export const updateMessage = async (address, message) => {
✅{" "}
- View the status of your transaction on Etherscan!
+ 在 Etherscan 上查看您的交易状态！
- ℹ️ Once the transaction is verified by the network, the message will
- be updated automatically.
+ ℹ️ 一旦交易被网络验证，消息将自动更新。
),
}
@@ -1510,7 +1510,7 @@ export const updateMessage = async (address, message) => {
最后但同样重要的是，我们需要将 `updateMessage` 函数与我们的 `HelloWorld.js` 组件进行连接。
-#### 将 `updateMessage` 函数连接到 `HelloWorld.js` 前端 {#connect-updatemessage-to-the-helloworld-js-frontend}
+#### 将 `updateMessage` 连接到 `HelloWorld.js` 前端 {#connect-updatemessage-to-the-helloworld-js-frontend}
我们的 `onUpdatePressed` 函数应当通过异步调用导入的 `updateMessage` 函数，并根据交易成功或失败的结果来修改 `status` 状态变量：
@@ -1527,12 +1527,12 @@ const onUpdatePressed = async () => {
现在就去测试一下 **Update** 按钮吧！
-### 开发你的去中心化应用程序 {#make-your-own-custom-dapp}
+### 制作你自己的自定义去中心化应用程序 {#make-your-own-custom-dapp}
哇哦，你成功完成了本教程的全部内容！ 回顾一下，你已经学习了如何：
- 使用 MetaMask 钱包连接你的去中心化应用程序项目
-- 使用 [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) 应用程序接口从你的智能合约中读取数据
+- 使用 [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API 从你的智能合约中读取数据
- 使用 MetaMask 对以太坊交易签名
现在，你已经完全掌握本教程中的技能，可以着手开发属于自己的个性化去中心化应用程序项目了！ 一如既往，如果你有任何问题，欢迎随时在 [Alchemy Discord](https://discord.gg/gWuC7zB) 频道联系我们寻求帮助。 🧙♂️
diff --git a/public/content/translations/zh/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/zh/developers/tutorials/hello-world-smart-contract/index.md
index 636862577c8..8ae7ddedbc5 100644
--- a/public/content/translations/zh/developers/tutorials/hello-world-smart-contract/index.md
+++ b/public/content/translations/zh/developers/tutorials/hello-world-smart-contract/index.md
@@ -1,88 +1,84 @@
---
-title: 针对初学者的智能合约指南
-description: 关于编写和部署一个基于以太坊的简单智能合约的入门教程。
+title: "面向初学者的 Hello World 智能合约"
+description: "关于在以太坊上编写和部署一个简单智能合约的入门教程。"
author: "elanh"
-tags:
- - "solidity"
- - "hardhat"
- - "alchemy"
- - "智能合约"
- - "入门指南"
- - "部署"
+tags: [ "Solidity", "hardhat", "Alchemy", "智能合同", "部署" ]
skill: beginner
lang: zh
published: 2021-03-31
---
-如果您是区块链开发的初学者，还不知道如何开始，或者您只是想了解怎样部署智能合约并与之进行交互，这篇教程就是为您准备的。 通过使用虚拟钱包 ([MetaMask](https://metamask.io/))、[Solidity](https://docs.soliditylang.org/en/v0.8.0/)、[Hardhat](https://hardhat.org/) 和 [Alchemy](https://alchemyapi.io/eth)（如果您不理解这些名词的含义，不用担心，后续我们会进行解释），我们将演示在 Ropsten 测试网络上创建并部署一个简单的智能合约。
+如果你是区块链开发的初学者，还不知道如何开始，或者你只是想了解怎样部署智能合约并与之进行交互，这篇教程就是为你准备的。 我们将逐步演示如何使用虚拟钱包 [MetaMask](https://metamask.io/)、[Solidity](https://docs.soliditylang.org/en/v0.8.0/)、[Hardhat](https://hardhat.org/) 和 [Alchemy](https://www.alchemy.com/eth) 在 Sepolia 测试网上创建和部署一个简单的智能合约（如果你还不了解这些术语的含义，别担心，我们稍后会解释）。
-在本教程的第 2 部分，我们将学习在智能合约部署后如何与之进行交互，第 3 部分将学习如何在 Etherscan 上发布智能合约。
+在本教程的[第 2 部分](https://docs.alchemy.com/docs/interacting-with-a-smart-contract)中，我们将介绍如何在部署智能合约后与其进行交互；在[第 3 部分](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan)中，我们将介绍如何在 Etherscan 上发布它。
-如果您有任何问题，请随时在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中提出！
+如果你在任何时候有任何问题，请随时在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中提出！
-## 步骤 1：连接到以太坊网络 {#step-1}
+## 第 1 步：连接到以太坊网络 {#step-1}
-有多种方法可以向以太坊链发起连接请求。 为了简单起见，我们将使用一个 Alchemy 上的免费帐户。 Alchemy 是一个区块链开发者平台和 API，允许我们与以太坊进行通信，而无需运行我们自己的节点。 平台还有用于监测和分析的开发者工具，我们将在本教程中利用这些工具来了解我们智能合约部署中的情况。 如果您还没有 Alchemy 账户，[您可以在这里免费注册](https://dashboard.alchemyapi.io/signup)。
+有很多方法可以向以太坊链发送请求。 为简单起见，我们将使用 Alchemy 上的免费帐户，这是一个区块链开发者平台和应用程序接口 (API)，它允许我们与以太坊链通信，而无需运行自己的节点。 该平台还有用于监控和分析的开发者工具，我们将在本教程中利用这些工具来了解智能合约部署的内部工作原理。 如果你还没有 Alchemy 帐户，[可在此处免费注册](https://dashboard.alchemy.com/signup)。
-## 步骤 2：创建应用程序（和应用程序接口密钥） {#step-2}
+## 第 2 步：创建你的应用程序（和 API 密钥） {#step-2}
-创建 Alchemy 帐户后，您可以通过创建应用程序来生成应用程序接口密钥。 我们可以用它向 Ropsten 测试网发出请求。 如果您不熟悉测试网络，请查看[此页面](/developers/docs/networks/)。
+创建 Alchemy 帐户后，你可以通过创建应用程序来生成应用程序接口密钥。 这将使我们能够向 Sepolia 测试网络发出请求。 如果你不熟悉测试网，请查看[此页面](/developers/docs/networks/)。
-1. 在 Alchemy 仪表板中，将鼠标悬停在导航栏中的“应用程序”上，单击“创建应用程序”并前往此页面。
+1. 在 Alchemy 仪表板中，通过在导航栏中选择“Select an app”，然后点击“Create new app”，导航到“Create new app”页面。
-
+
-2. 将您的应用命名为“Hello World”，提供简短的描述，选择“Staging”作为环境（用于您的应用程序簿记），选择“Ropsten”网络。
+2. 将你的应用程序命名为“Hello World”，提供简短描述，并选择一个用例，例如“Infra & Tooling”。 接下来，搜索“Ethereum”并选择网络。
-3. 点击“Create app”，完成！ 您的应用程序应该就会出现在下面的表格中。
+3. 点击“Next”继续，然后点击“Create app”，就完成了！ 你的应用程序应出现在导航栏下拉菜单中，并提供可供复制的 API 密钥。
-## 步骤 3：创建一个以太坊账户（地址） {#step-3}
+## 第 3 步：创建以太坊帐户（地址） {#step-3}
-我们需要一个以太坊帐户来发送和接收交易。 在本教程中，我们将使用 MetaMask，它是浏览器中的虚拟钱包，用来管理您的以太坊账户地址。 关于[交易](/developers/docs/transactions/)的详细信息。
+我们需要一个以太坊帐户来发送和接收交易。 在本教程中，我们将使用 MetaMask，它是浏览器中的虚拟钱包，用来管理你的以太坊帐户地址。 更多关于[交易](/developers/docs/transactions/)的信息。
-您可以点击[此处](https://metamask.io/download)免费下载并创建一个 MetaMask 账户。 创建账户时，或者如果您已经有一个账户时，确保切换到右上方的“Ropsten 测试网络”（这样我们就不会用实际货币进行交易）。
+你可以在[此处](https://metamask.io/download)免费下载 MetaMask 并创建以太坊帐户。 创建帐户时，或者如果你已有帐户，请确保使用网络下拉菜单切换到“Sepolia”测试网（这样我们就不会处理真实货币）。
-
+如果你没有看到 Sepolia 列出，请进入菜单，然后进入 Advanced，向下滚动以打开“Show test networks”。 在网络选择菜单中，选择“Custom”选项卡，找到测试网列表并选择“Sepolia”。
-## 步骤 4：从水龙头添加以太币 {#step-4}
+
-为了将我们的智能合约部署到测试网络，我们需要一些虚拟以太币。 要获取以太币，您可以转到 [Ropsten 水龙头](https://faucet.dimensions.network/)并输入您的 Ropsten 帐户地址，然后点击“Send Ropsten Eth”。 由于网络原因，您接收虚拟以太币可能需要一些时间。 您应该会很快在您的 MetaMask 帐户中看到以太币！
+## 第 4 步：从水龙头获取以太币 {#step-4}
-## 步骤 5：查看账户余额 {#step-5}
+为了将我们的智能合约部署到测试网，我们需要一些假的 Eth。 要获取 Sepolia ETH，你可以访问 [Sepolia 网络详情](/developers/docs/networks/#sepolia)页面查看各种水龙头列表。 如果一个不能用，就试试另一个，因为它们有时会枯竭。 由于网络拥堵，收到你的假 ETH 可能需要一些时间。 之后不久，你应该就能在你的 Metamask 帐户中看到 ETH 了！
-为了核查我们账户中有余额，我们使用 [Alchemy composer 工具](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D)发出 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入您的 MetaMask 帐户地址并点击“Send Request”后，您应该会看到这样的响应：
+## 第 5 步：检查你的余额 {#step-5}
+
+为了再次检查我们的余额，让我们使用 [Alchemy 的编辑器工具](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest) 发出 [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入你的 MetaMask 帐户地址并点击“Send Request”后，你应该会看到这样的响应：
```json
{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
```
-> **注意：**结果以 wei 为单位，而非 ETH。 Wei 是以太币的最小计量单位。 将 wei 转换为 ETH 的公式为：1 eth = 1018 wei。 因此，如果我们将 0x2B5E3AF16B1880000 转换为十进制，我们会得到 5\*10¹⁸，即 5 ETH。
+> \*\*注意：\*\*这个结果以 wei 为单位，而不是 ETH。 Wei 是以太币的最小计量单位。 wei 到 ETH 的换算方法是：1 eth = 1018 wei。 所以，如果我们将 0x2B5E3AF16B1880000 转换为十进制，我们会得到 5\*10¹⁸，即 5 ETH。
>
-> 哦！ 我们的虚拟货币到账了
-不要提交 .env！ 请确保永远不要与任何人共享或公开您的 .env 文件，因为这样做会泄露您的私钥。 如果您使用版本控制，请将您的 .env 添加到 gitignore 文件中。
+不要提交 .env！ 请确保永远不要与任何人共享或公开你的 .env 文件，因为这样做会泄露你的机密信息。 如果你使用版本控制，请将你的 .env 添加到 gitignore 文件中。
-## 步骤 12：安装 Ethers.js {#step-12-install-ethersjs}
+## 第 12 步：安装 Ethers.js {#step-12-install-ethersjs}
-Ethers.js 是一个软件库，通过以更加方便用户的方法打包[标准 JSON RPC 方法](/developers/docs/apis/json-rpc/)，从而更容易与以太坊互动，并向以太坊提出请求。
+Ethers.js 是一个程序库，它通过将[标准的 JSON-RPC 方法](/developers/docs/apis/json-rpc/)封装成对用户更友好的方法，使得与以太坊交互和发出请求变得更加容易。
-安全帽使我们更容易将[插件](https://hardhat.org/plugins/)集成到工具和扩展功能中。 我们将利用 [Ethers 插件](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers)完成合约部署（[Ethers.js](https://github.com/ethers-io/ethers.js/) 有非常简洁的部署方法）。
+Hardhat可以非常轻松地集成[插件](https://hardhat.org/plugins/)，以获得额外的工具和扩展功能。 我们将利用 [Ethers 插件](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers)进行合约部署（[Ethers.js](https://github.com/ethers-io/ethers.js/) 有一些非常简洁的合约部署方法）。
-在您的项目目录中输入：
+在你的项目目录中输入：
```
npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
```
-下一步中，我们还将在 `hardhat.config.js` 中使用 ethers。
+我们还将在下一步的 `hardhat.config.js` 中要求 ethers。
-## 步骤 13：更新 hardhat.config.js {#step-13-update-hardhatconfigjs}
+## 第 13 步：更新 hardhat.config.js {#step-13-update-hardhatconfigjs}
-到目前为止，我们已经添加了几个依赖库和插件，现在我们需要更新 `hardhat.config.js`，以便项目使用所有这些新的组件。
+到目前为止，我们已经添加了几个依赖项和插件，现在我们需要更新 `hardhat.config.js`，以便我们的项目了解所有这些依赖项和插件。
-按如下所示更新您的 `hardhat.config.js` 代码：
+将你的 `hardhat.config.js` 更新为如下所示：
```
require('dotenv').config();
@@ -270,10 +266,10 @@ const { API_URL, PRIVATE_KEY } = process.env;
*/
module.exports = {
solidity: "0.7.3",
- defaultNetwork: "ropsten",
+ defaultNetwork: "sepolia",
networks: {
hardhat: {},
- ropsten: {
+ sepolia: {
url: API_URL,
accounts: [`0x${PRIVATE_KEY}`]
}
@@ -281,9 +277,9 @@ module.exports = {
}
```
-## 步骤 14：编译合约 {#step-14-compile-our-contracts}
+## 第 14 步：编译我们的合约 {#step-14-compile-our-contracts}
-为了确保一切正常，我们来编译一下合约。 `compile` 任务是安全帽的内部任务之一。
+为了确保一切正常，我们来编译一下合约。 `compile` 任务是内置的 hardhat 任务之一。
在命令行中运行：
@@ -291,21 +287,21 @@ module.exports = {
npx hardhat compile
```
-您可能会看到关于 `SPDX license identifier not provided in source file` 的警告，但不用担心，希望其它的均看起来正常！ 如果遇到问题，您可以随时在 [Alchemy cord](https://discord.gg/u72VCg3) 社区中发消息询问。
+你可能会收到关于 `SPDX license identifier not provided in source file` 的警告，但不必担心——希望其他一切都正常！ 如果编译不成功，可以随时在 [Alchemy discord](https://discord.gg/u72VCg3) 中发消息。
-## 步骤 15：编写部署脚本 {#step-15-write-our-deploy-scripts}
+## 第 15 步：编写我们的部署脚本 {#step-15-write-our-deploy-scripts}
合约已经写完，配置文件也准备妥当，现在是写合约部署脚本的时候了。
-转到 `scripts/` 文件夹，创建一个名为 `deploy.js` 的新文件，在其中添加以下内容：
+导航到 `scripts/` 文件夹并创建一个名为 `deploy.js` 的新文件，向其中添加以下内容：
```
async function main() {
const HelloWorld = await ethers.getContractFactory("HelloWorld");
- // Start deployment, returning a promise that resolves to a contract object
+ // 开始部署，返回一个解析为合约对象的 promise
const hello_world = await HelloWorld.deploy("Hello World!");
- console.log("Contract deployed to address:", hello_world.address);}
+ console.log("合约已部署到地址：", hello_world.address);}
main()
.then(() => process.exit(0))
@@ -315,48 +311,49 @@ main()
});
```
-安全帽在[合约教程](https://hardhat.org/tutorial/testing-contracts.html#writing-tests)中对这些代码的每一行均提供了很好的解释，我们在这里直接引用他们的解释。
+Hardhat在他们的[合约教程](https://hardhat.org/tutorial/testing-contracts.html#writing-tests)中极好地解释了每一行代码的作用，我们在此处采用了他们的解释。
```
const HelloWorld = await ethers.getContractFactory("HelloWorld");
```
-ethers.js 中的 `ContractFactory` 是用于部署新智能合约的抽象对象。因此这里的 `HelloWorld` 是我们 hello world 合约实例的工厂。 使用 `hardhat-ethers` 插件时，`ContractFactory` 和 `Contract` 实例默认与第一个签名账户相连。
+ethers.js 中的 `ContractFactory` 是一个用于部署新智能合约的抽象，所以这里的 `HelloWorld` 是我们的 hello world 合约实例的工厂。 使用 `hardhat-ethers` 插件时，`ContractFactory` 和 `Contract` 实例默认连接到第一个签名者。
```
const hello_world = await HelloWorld.deploy();
```
-调用 `ContractFactory` 代码中的 `deploy()` 函数会启动合约部署，然后返回解析为 `Contract` 的 `Promise`。 这个对象包括我们智能合约中每个函数的对应调用方法。
+在 `ContractFactory` 上调用 `deploy()` 将开始部署，并返回一个解析为 `Contract` 的 `Promise`。 这个对象包括我们智能合约中每个函数的对应调用方法。
-## 步骤 16：部署合约 {#step-16-deploy-our-contract}
+## 第 16 步：部署我们的合约 {#step-16-deploy-our-contract}
-我们终于准备好部署我们的智能合约啦！ 导航到命令行后运行：
+我们终于准备好部署我们的智能合约啦！ 导航到命令行并运行：
```
-npx hardhat run scripts/deploy.js --network ropsten
+npx hardhat run scripts/deploy.js --network sepolia
```
-您会看到类似以下所示的信息：
+你会看到类似以下所示的信息：
```
-Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+合约已部署到地址：0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
```
-如果我们访问 [Ropsten etherscan](https://ropsten.etherscan.io/) 并搜索我们的合约地址，应该能够看到它已经成功部署。 交易将类似以下：
+如果我们访问 [Sepolia etherscan](https://sepolia.etherscan.io/) 并搜索我们的合约地址，我们应该能看到它已成功部署。 交易将类似以下：
-`From` 地址应该和您的 MetaMask 账户地址相同，而 To 地址会显示“Contract Creation”，但如果我们点击进入交易，我们会在 `To` 字段看到我们的合约地址：
+`From` 地址应与你的 MetaMask 帐户地址匹配，而 To 地址将显示“Contract Creation”，但如果我们点击进入交易，我们将在 `To` 字段中看到我们的合约地址：
-恭喜！ 您刚刚在以太坊区块链上部署了一个智能合约 🎉
+恭喜！ 你刚刚向以太坊链部署了一个智能合约 🎉
-为了更深入了解到底发生了什么，我们转到 [Alchemy 仪表板](https://dashboard.alchemyapi.io/explorer)中的 Explorer 选项卡。 如果您有多个 Alchemy 应用程序，请确保按应用程序筛选，然后选择“Hello World”。 
+要了解其内部工作原理，我们导航至 [Alchemy 仪表板](https://dashboard.alchemyapi.io/explorer)中的“浏览器”选项卡。 如果你有多个 Alchemy 应用程序，请确保按应用程序筛选并选择“Hello World”。
+
-在这里您会看到一系列的 JSON-RPC 调用，都是在我们调用 `.deploy()` 函数时，Hardhat/Ethers 替我们在后端完成的。 这里有两项重要调用，一个是 [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction)，这是实际将我们的合约写入 Ropsten 链的请求，另一个是 [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash)，此为读取有关我们交易给定哈希值的请求（即 交易时的典型模式）。 如需了解更多关于发送交易的信息，请查看关于[使用 Web3 发送交易](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)的本教程
+在这里，你会看到当我们调用 `.deploy()` 函数时，Hardhat/Ethers 在后台为我们进行的一些 JSON-RPC 调用。 这里需要指出的两个重要调用是 [`eth_sendRawTransaction`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-send-raw-transaction)，这是将我们的合约实际写入 Sepolia 链的请求；以及 [`eth_getTransactionByHash`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-get-transaction-by-hash)，这是一个根据哈希读取交易信息的请求（处理交易时的典型模式）。 要了解有关发送交易的更多信息，请查看本教程：[使用 Web3 发送交易](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
-这是本教程第 1 部分的全部内容，在第 2 部分中，我们将更新我们的初始信息，从而[与我们的智能合约交互](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#part-2-interact-with-your-smart-contract)；在第 3 部分，我们将[在 Etherscan 上发布我们的智能合约](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#optional-part-3-publish-your-smart-contract-to-etherscan)，使得每个人都会知道如何与之交互。
+本教程的第 1 部分到此结束，在第 2 部分中，我们将通过更新初始消息来实际[与我们的智能合约进行交互](https://www.alchemy.com/docs/interacting-with-a-smart-contract)；在第 3 部分中，我们将[把我们的智能合约发布到 Etherscan](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan)，这样每个人都知道如何与它交互。
-**想了解更多有关 Alchemy 的信息吗？ 查看我们的[网站](https://alchemyapi.io/eth)。 不想错过更新？ [在这里](https://www.alchemyapi.io/newsletter)订阅我们的新闻通讯！ 请务必关注我们的 [Twitter](https://twitter.com/alchemyplatform) 并加入我们的 [Discord](https://discord.com/invite/u72VCg3)**。
+**想了解更多关于 Alchemy 的信息吗？ 请访问我们的[网站](https://www.alchemy.com/eth)。 不想错过任何更新？ 在此[订阅](https://www.alchemy.com/newsletter)我们的新闻通讯！ 也请务必加入我们的 [Discord](https://discord.gg/u72VCg3)。**。
diff --git a/public/content/translations/zh/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/zh/developers/tutorials/how-to-implement-an-erc721-market/index.md
index 1e2498d5bfe..788b2cff919 100644
--- a/public/content/translations/zh/developers/tutorials/how-to-implement-an-erc721-market/index.md
+++ b/public/content/translations/zh/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -1,12 +1,8 @@
---
-title: 如何实现ERC-721市场
-description: 如何在一个去中心化的分类信息板上销售代币化的物品。
-author: "Alberto Cuesta Cañada"
-tags:
- - "智能合约"
- - "erc-721"
- - "solidity"
- - "代币"
+title: "如何实现ERC-721市场 "
+description: "如何在一个去中心化的分类信息板上销售代币化的物品。"
+author: "Alberto Cuesta Cañada "
+tags: [ "智能合同", "erc-721", "Solidity", "通证" ]
skill: intermediate
lang: zh
published: 2020-03-19
@@ -26,13 +22,13 @@ sourceUrl: https://hackernoon.com/how-to-implement-an-erc721-market-1e1a32j9
基于公共区块链技术的分类信息板的商业模式和Ebay及普通的公司有显著的不同。
-首先，这种商业模式有[一个去中心化的视角](/developers/docs/web2-vs-web3/)。 目前现存的平台都需要维护自己的服务器。 去中心化的平台是由其用户来维护的，因此其核心平台的成本从平台所有者的角度来讲会降至零。
+首先，要考虑[去中心化角度](/developers/docs/web2-vs-web3/)。 目前现存的平台都需要维护自己的服务器。 去中心化的平台是由其用户来维护的，因此其核心平台的成本从平台所有者的角度来讲会降至零。
-中心化平台有前端界面，后台网站或者可以访问该去中心化平台的接口。 它同时也会有许多其他选择。 平台所有者可以限制客户的访问并强制每个人使用他们的接口，并收取费用。 平台所有者还可以决定是否开放访问权限（这是对普通用户的一种强权!），并让任何人构建与平台的接口。 或者平台所有者可以在这些极端情况中决定任何方法。
+中心化平台有前端界面，后台网站或者可以访问该去中心化平台的接口。 它同时也会有许多其他选择。 平台所有者可以限制客户的访问并强制每个人使用他们的接口，并收取费用。 平台所有者也可以决定开放访问权限（权力归于人民！） 并允许任何人构建该平台的界面。 或者平台所有者可以在这些极端情况中决定任何方法。
_比我更有远见的商业领袖知道如何将其货币化。 我所看到的是，这与现状不同，并且可能是有利可图的。_
-此外，还可以从自动化和支付的角度来看问题。 在分类信息板中，有些东西可以[非常有效地代币化](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) ，并产生交易。 代币化的资产很容易在区块链中转移。 高度复杂的支付方式可以在区块链中被轻松实现。
+此外，还可以从自动化和支付的角度来看问题。 有些东西可以非常[有效地代币化](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com)并在分类广告板中交易。 代币化的资产很容易在区块链中转移。 高度复杂的支付方式可以在区块链中被轻松实现。
我在这里嗅到了一个商机。 通过区块链技术，可以轻松实现一个无需运行成本的分类信息板。复杂的支付路径被包含到了每笔交易里。 我相信有人会想出一个关于如何使用它的创意。
@@ -40,9 +36,9 @@ _比我更有远见的商业领袖知道如何将其货币化。 我所看到的
## 实现 {#implementation}
-前段时间我们启动了一个[开源项目](https://github.com/HQ20/contracts?ref=hackernoon.com)，其中包含了一些商业案例的示例实现和其他相关的资源，推荐你看一看。
+不久前，我们启动了一个[开源代码库](https://github.com/HQ20/contracts?ref=hackernoon.com)，其中包含业务案例示例实现和其他好东西，请看一看。
-这个[以太坊分类信息板](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com)的代码在那里，请使用并研究它。 请注意，这个项目的代码尚未经过审核，你在把资金投入这个项目之前需要进行代码的尽职审查。
+这个[以太坊分类广告板](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com)的代码就在那里，请随意使用。 请注意，这个项目的代码尚未经过审核，你在把资金投入这个项目之前需要进行代码的尽职审查。
这个项目的基础并不复杂。 分类信息板中的所有广告是一个包含几个字段的结构体：
@@ -67,13 +63,9 @@ mapping(uint256 => Trade) public trades;
接下来的问题是我们需要处理哪些物品，以及用于支付交易的货币是什么。
-对于物品，我们只是要求它们实现[ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com)的接口。这实际上只是一种在区块链中表示现实世界物品的方式，
-
-尽管它最适合数字资产。 我们将在构造函数中定制化我们自己的ERC721合约，这意味着我们分类信息板中的任何资产都需要事先被代币化
-
-对于付款，我们将做类似的事情。 大多数区块链项目定义了自己的[ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com)加密货币。 其他一些人更喜欢使用像DAI这样的主流技术。 在这个分类信息板的应用中，你只需要在构造函数里决定你构建的货币是什么。 很容易。
-
+对于这些物品，我们只要求它们实现 [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com) 接口，这实际上只是在区块链中表示现实世界物品的一种方式，尽管它[最适用于数字资产](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com)。 我们将在构造函数中定制化我们自己的ERC721合约，这意味着我们分类信息板中的任何资产都需要事先被代币化。
+对于付款，我们将做类似的事情。 大多数区块链项目都定义了自己的 [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com) 加密货币。 其他一些人更喜欢使用像DAI这样的主流技术。 在这个分类信息板的应用中，你只需要在构造函数里决定你构建的货币是什么。 很容易。
```solidity
constructor (
@@ -85,13 +77,10 @@ tradeCounter = 0;
}
```
-
目前我们到达这里了。 我们有广告、用于交易的商品和用来付款的货币。 制作一个广告意味着将同一个物品放在托管中，以表明你拥有它并且你没有发布它两次，可能是在不同的分类信息板上。
下面的代码正是这样做的。 将物品放在托管中，制作广告，做一些记账操作。
-
-
```solidity
function openTrade(uint256 _item, uint256 _price)
public
@@ -108,11 +97,8 @@ function openTrade(uint256 _item, uint256 _price)
}
```
-
接受交易意味着选择某个广告（交易）、支付价格、接收物品。 以下的代码用来获取交易。 检查它是否可用。 支付该物品的费用。 获取物品。 更新广告信息。
-
-
```solidity
function executeTrade(uint256 _trade)
public
@@ -126,13 +112,10 @@ function executeTrade(uint256 _trade)
}
```
-
最后，我们可以选择让卖家在买家接受之前退出交易。 在某些模型中，广告会在过期前保留一段时间。 你的选择，具体取决于你的市场设计。
该代码与用于执行交易的代码非常相似，只是没有货币交换。同时该物品返回到广告的发行方。
-
-
```solidity
function cancelTrade(uint256 _trade)
public
@@ -140,21 +123,18 @@ function cancelTrade(uint256 _trade)
Trade memory trade = trades[_trade];
require(
msg.sender == trade.poster,
- "Trade can be cancelled only by poster."
+ "交易只能由发布者取消。"
);
- require(trade.status == "Open", "Trade is not Open.");
+ require(trade.status == "Open", "交易未开放。");
itemToken.transferFrom(address(this), trade.poster, trade.item);
trades[_trade].status = "Cancelled";
emit TradeStatusChange(_trade, "Cancelled");
}
```
+就是这样。 你已经浏览到了该代码实现的末尾。 令人惊讶的是，一些业务概念在用代码表达时是多么紧凑，这就是其中一个例子。 在我们的[代码库](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol)中查看完整的合约。
-就是这样。 你已经浏览到了该代码实现的末尾。 令人惊讶的是，一些业务概念在用代码表达时是多么紧凑，这就是其中一个例子。 请在[我们的代码库中](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol)查看完整的合约代码。
-
-
-
-## 总结 {#conclusion}
+## 结论 {#conclusion}
分类信息板是一种易于在互联网技术的帮助下大规模扩张的常见市场结构，也是一种容易形成少数垄断赢家的非常流行的商业模式。
@@ -162,4 +142,4 @@ function cancelTrade(uint256 _trade)
在本文中，我尝试将分类信息板的商业业务与技术实现结合起来进行讲解。 如果你拥有合适的技能，这些知识应该可以帮助你创建愿景和实施路线图。
-与往常一样，如果你想构建任何有趣的东西并希望得到一些建议，[请给我留言！](https://albertocuesta.es/) 我总是很乐意为你提供帮助。
+与往常一样，如果你想构建任何有趣的东西并希望得到一些建议，请[给我留言](https://albertocuesta.es/)！ 我总是很乐意为你提供帮助。
diff --git a/public/content/translations/zh/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/zh/developers/tutorials/how-to-mint-an-nft/index.md
index 2ae13c116a9..d0cce858998 100644
--- a/public/content/translations/zh/developers/tutorials/how-to-mint-an-nft/index.md
+++ b/public/content/translations/zh/developers/tutorials/how-to-mint-an-nft/index.md
@@ -1,28 +1,24 @@
---
-title: 如何铸造非同质化代币（非同质化代币教程系列 2/3）
-description: 本教程描述了如何使用我们的智能合约和 Web3 在以太坊区块链上铸造非同质化代币。
+title: "如何铸造 NFT（NFT 教程系列第 2/3 部分）"
+description: "本教程介绍如何使用我们的智能合约和 Web3 在以太坊区块链上铸造 NFT。"
author: "苏米-穆德吉尔"
-tags:
- - "ERC-721"
- - "Alchemy"
- - "solidity"
- - "智能合约"
+tags: [ "ERC-721", "Alchemy", "Solidity", "智能合同" ]
skill: beginner
lang: zh
published: 2021-04-22
---
-[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html)：6900 万美元 [3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b)：1100 万美元 [Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens)：600 万美元
+[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html)：6900 万美元\n[3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b)：1100 万美元\n[Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens)：600 万美元
-他们都使用 Alchemy 的强大应用程序接口铸造非同质化代币。 在本教程中，我们将教你如何在 < 10 分钟内做到这一点。
+他们都使用 Alchemy 强大的 API 铸造了各自的 NFT。 在本教程中，我们将在 \<10 分钟内教会你如何做到同样的事情。
-“铸造非同质化代币”是在区块链上发布你的 ERC-721 代币的唯一方式。 使用我们在[非同质化代币教程系列第 1 部分](/developers/tutorials/how-to-write-and-deploy-an-nft/)中获得的智能合约，我们可以运用我们的 Web3 技能并铸造非同质化代币。 在本教程结束时，你将能够按照你的内心（和钱包）的愿望铸造出更多非同质化代币！
+“铸造 NFT”是指在区块链上发布你的 ERC-721 代币的唯一实例的行为。 让我们使用 [本 NFT 教程系列第 1 部分](/developers/tutorials/how-to-write-and-deploy-an-nft/)中的智能合约，一展我们的 Web3 技能，铸造一个 NFT 吧。 在本教程结束时，你将能随心所欲（钱包也得跟上！）地铸造任意数量的 NFT！
我们开始吧！
## 第 1 步：安装 Web3 {#install-web3}
-如果你跟随第一个教程创建了你的非同质化代币智能合约，那么你在使用 Ethers.js 方面已经有了经验。 Web3 与 Ethers 相似，也是一个库，用于更轻松地创建对以太坊区块链的请求。 在本教程中，我们将使用增强版 Web3 库 [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3)，它提供自动重试和强大的 WebSocket 支持。
+如果你学习了关于创建 NFT 智能合约的第一个教程，那么你应该已经有使用 Ethers.js 的经验了。 Web3 与 Ethers 类似，都是能让你更轻松地向以太坊区块链创建请求的库。 在本教程中，我们将使用 [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3)，这是一个增强的 Web3 库，可提供自动重试和强大的 WebSocket 支持。
在你的项目主目录中运行：
@@ -32,298 +28,156 @@ npm install @alch/alchemy-web3
## 第 2 步：创建 `mint-nft.js` 文件 {#create-mintnftjs}
-在你的脚本目录中，创建一个 `mint-nft.js` 文件并添加以下代码行：
+在你的 `scripts` 目录中，创建一个 `mint-nft.js` 文件，并添加以下代码行：
```js
-require("dotenv").config()
-const API_URL = process.env.API_URL
-const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
-const web3 = createAlchemyWeb3(API_URL)
+require("dotenv").config()\nconst API_URL = process.env.API_URL\nconst { createAlchemyWeb3 } = require("@alch/alchemy-web3")\nconst web3 = createAlchemyWeb3(API_URL)
```
-## 第 3 步：获取你的合约应用程序二进制接口 {#contract-abi}
+## 第 3 步：获取你的合约 ABI {#contract-abi}
-我们的合约 ABI（应用程序二进制接口）是与我们的智能合约交互的接口。 你可以在[此处](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is)了解更多关于合约应用程序二进制接口的信息。 安全帽自动为我们生成应用程序二进制接口，并将其保存在 `MyNFT.json` 文件中。 为了使用该接口，我们需要通过在我们的 `mint-nft.js` 文件中添加以下代码行来解析内容：
+我们的合约 ABI（应用程序二进制接口）是用于与我们的智能合约交互的接口。 你可以在[此处](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is)了解更多关于合约 ABI 的信息。 Hardhat 会自动为我们生成一个 ABI 并将其保存在 `MyNFT.json` 文件中。 为了使用它，我们需要将以下代码行添加到我们的 `mint-nft.js` 文件中以解析内容：
```js
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
```
-如果你想查看应用程序二进制接口，你可以将其发送到你的控制台：
+如果你想查看 ABI，可以将其打印到控制台：
```js
console.log(JSON.stringify(contract.abi))
```
-要运行 `mint-nft.js` 并查看输出到控制台的应用程序二进制接口，请导航至你的终端并运行:
+要运行 `mint-nft.js` 并在控制台中查看打印出的 ABI，请导航到你的终端并运行：
```js
node scripts/mint-nft.js
```
-## 第 4 步：使用 IPFS 系统为你的非同质化代币配置元数据 {#config-meta}
+## 第 4 步：使用 IPFS 为你的 NFT 配置元数据 {#config-meta}
-如果你还记得我们第 1 部分的教程，我们的 `mintNFT` 智能合约函数使用 tokenURI 参数，该参数应解析为描述非同质化代币元数据的 JSON 文档，正是它生成非同质化代币并赋予非同质化代币可配置的属性，如名称、描述、图像和其他属性。
+如果你还记得我们第 1 部分教程的内容，我们的 `mintNFT` 智能合约函数接受一个 `tokenURI` 参数，该参数应解析为一个 JSON 文档，用于描述 NFT 的元数据——正是元数据赋予了 NFT 生命，让它拥有可配置的属性，例如名称、描述、图片和其他特性。
-> _星际文件系统 (IPFS) 是一个分散协议和对等网络，用于在分布式文件系统中存储和共享数据。_
+> _星际文件系统 (IPFS) 是一种用于在分布式文件系统中存储和共享数据的去中心化协议和点对点网络。_
-我们将使用 Pinata，一个方便的星际文件系统应用程序接口和工具包，用于存储我们的非同质化代币资产和元数据，以确保我们的非同质化代币真正去中心化。 如果你没有 Pinata 帐户，请在[此处](https://app.pinata.cloud)注册一个免费帐户，并完成电子邮件验证步骤。
+我们将使用 Pinata，一个方便的 IPFS API 和工具包，来存储我们的 NFT 资产和元数据，以确保我们的 NFT 是真正去中心化的。 如果你还没有 Pinata 帐户，请[在此处](https://app.pinata.cloud)注册一个免费帐户，并完成电子邮件验证步骤。
创建帐户后：
-- 导航到“文件”页面，点击页面左上方蓝色的“上传”按钮。
+- 导航到“文件”页面，然后单击页面左上角的蓝色“上传”按钮。
-- 将图像上传到 Pinata — 这将是你的非同质化代币的图像资产。 你可以随意为该资产命名。
+- 将图片上传到 Pinata — 这将是你的 NFT 的图片资产。 你可以随意为该资产命名
-- 上传之后，你将在“File”页面的表格中看到文件信息。 你还会看到 CID 列。 你可以通过单击旁边的复制按钮来复制 CID。 你可以通过 `https://gateway.pinata.cloud/ipfs/` 查看你上传的信息。 例如，你可以在[此处](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5)找到我们在星际文件系统上使用的图片。
+- 上传后，你将在“文件”页面的表格中看到文件信息。 你还会看到一个 CID 列。 你可以通过单击旁边的复制按钮来复制 CID。 你可以在以下地址查看你上传的内容：`https://gateway.pinata.cloud/ipfs/`。 例如，你可以在[此处](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5)找到我们在 IPFS 上使用的图片。
-为了方便更偏向视觉型的学习者理解，上述步骤总结如下：
+为方便偏爱视觉学习的学习者，我们将以上步骤总结如下：
-
+
-现在，我们要再上传一份文件到 Pinata。 但在我们上传之前，需要先创建该文件！
+现在，我们还要向 Pinata 上传一份文档。 但在此之前，我们需要先创建它！
-在你的根目录中，创建一个名为 `nft-metadata.json` 的新文件，并添加以下 json 代码：
+在你的根目录中，新建一个名为 `nft-metadata.json` 的文件，并添加以下 json 代码：
```json
-{
- "attributes": [
- {
- "trait_type": "Breed",
- "value": "Maltipoo"
- },
- {
- "trait_type": "Eye color",
- "value": "Mocha"
- }
- ],
- "description": "The world's most adorable and sensitive pup.",
- "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
- "name": "Ramses"
-}
+{\n "attributes": [\n {\n "trait_type": "品种",\n "value": "马尔济斯"\n },\n {\n "trait_type": "眼睛颜色",\n "value": "摩卡"\n }\n ],\n "description": "世界上最可爱、最敏感的小狗。",\n "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",\n "name": "Ramses"\n}
```
-可随意更改 json 中的数据。 你可以删除或添加到属性部分。 最重要的是，确保图像字段指向你的星际文件系统图像的位置——否则，你的非同质化代币将包含一张（非常可爱！）的狗狗照片。
+你可以随意更改 json 中的数据。 你可以删除或添加属性部分。 最重要的是，确保 `image` 字段指向你的 IPFS 图片的位置 — 否则，你的 NFT 将包含一张（非常可爱的！） 狗狗的照片。
-编辑完 JSON 文件后，保存并上传到 Pinata，步骤与上传图像相同。
+编辑完 JSON 文件后，保存并上传到 Pinata，步骤与上传图片时相同。
-
+
-## 第 5 步：创建你的合约实例 {#instance-contract}
+## 第 5 步：创建合约实例 {#instance-contract}
-现在，为了与我们的合约进行交互，我们需要在代码中创建一个实例。 为此，我们需要合约地址，可以从部署或 [Etherscan](https://sepolia.etherscan.io/) 中通过查找用来部署合约的地址获得。
+现在，为了与我们的合约交互，我们需要在代码中创建它的一个实例。 为此，我们需要我们的合约地址。我们可以通过在 [Blockscout](https://eth-sepolia.blockscout.com/) 上查找你用于部署合约的地址，从部署中获取合约地址。
-
+
在上面的示例中，我们的合约地址是 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778。
-接下来我们将使用 Web3 的[合约方法](https://docs.web3js.org/api/web3-eth-contract/class/Contract)，创建使用应用程序二进制接口和地址的合约。 在你的 `mint-nft.js` 文件中，添加以下内容:
+接下来，我们将使用 Web3 的 [合约方法](https://docs.web3js.org/api/web3-eth-contract/class/Contract)，通过 ABI 和地址来创建我们的合约。 在你的 `mint-nft.js` 文件中，添加以下内容：
```js
-const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
-
-const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"\n\nconst nftContract = new web3.eth.Contract(contract.abi, contractAddress)
```
## 第 6 步：更新 `.env` 文件 {#update-env}
-现在，为了创建并发送交互到以太坊链，我们将使用你的以太坊公共帐户地址来获得帐户随机数（解释如下）。
+现在，为了创建交易并将其发送到以太坊链，我们将使用你的以太坊公共帐户地址来获取帐户 nonce（随机数，下文会解释）。
-将你的公钥添加到你的 `.env` 文件中 — 如果你完成了教程第 1 部分，我们的 `.env` 文件现在应该如下所示：
+将你的公钥添加到 `.env` 文件中 — 如果你完成了本教程的第 1 部分，你的 `.env` 文件现在应该如下所示：
```js
-API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
-PRIVATE_KEY = "your-private-account-address"
-PUBLIC_KEY = "your-public-account-address"
+API_URL = "https://eth-sepolia.g.alchemy.com/v2/你的-api-密钥"\nPRIVATE_KEY = "你的-私有-账户-地址"\nPUBLIC_KEY = "你的-公共-账户-地址"
```
## 第 7 步：创建你的交易 {#create-txn}
-首先，让我们定义一个名为 `mintNFT(tokenData)` 的函数并通过执行以下操作创建我们的交易：
+首先，我们来定义一个名为 `mintNFT(tokenData)` 的函数，并通过以下操作创建我们的交易：
-1. 获取 _PRIVATE_KEY_ 和 _PUBLIC_KEY_，来源为 `.env` 文件。
+1. 从 `.env` 文件中获取你的 _PRIVATE_KEY_ 和 _PUBLIC_KEY_。
-1. 接下来，我们需要弄清楚帐户的随机数。 随机数规范用于跟踪从你的地址发送的交易数量——我们这样做是出于安全目的，以防止[重放攻击](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce)。 要获得从你的地址发送的交易数量，我们要用到 [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount)。
+2. 接下来，我们需要确定帐户 nonce（随机数）。 nonce 规范用于跟踪从你的地址发送的交易数量 — 出于安全目的和防止[重放攻击](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce)的需要，我们必须使用它。 为了获取从你的地址发送的交易数量，我们使用 [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount)。
-1. 最后，我们将使用以下信息设置我们的交易：
+3. 最后，我们将用以下信息设置我们的交易：
-- `'from': PUBLIC_KEY`——我们的交易源于我们的公共地址
+- `'from': PUBLIC_KEY` — 交易的来源，即我们的公共地址
-- `'to': contractAddress`——我们希望与之交互并发送交易的合约
+- `'to': contractAddress` — 我们希望与之交互并向其发送交易的合约
-- `'nonce': nonce` — 帐户随机数和从我们的地址发送的交易数量
+- `'nonce': nonce` — 帐户 nonce（随机数），即从我们的地址发送的交易数量
-- `'gas': estimatedGas`——预估完成交易所需的燃料
+- `'gas': estimatedGas` — 完成交易所需的预估燃料
-- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()`——我们希望在这笔交易中进行的计算——铸造一个非同质化代币
+- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — 我们希望在此交易中执行的计算，在本例中就是铸造一个 NFT
你的 `mint-nft.js` 文件现在应该如下所示：
```js
- require('dotenv').config();
- const API_URL = process.env.API_URL;
- const PUBLIC_KEY = process.env.PUBLIC_KEY;
- const PRIVATE_KEY = process.env.PRIVATE_KEY;
-
- const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
- const web3 = createAlchemyWeb3(API_URL);
-
- const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
- const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
- const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
-
- async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
-
- //the transaction
- const tx = {
- 'from': PUBLIC_KEY,
- 'to': contractAddress,
- 'nonce': nonce,
- 'gas': 500000,
- 'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
- };
- }
+ require('dotenv').config();\n const API_URL = process.env.API_URL;\n const PUBLIC_KEY = process.env.PUBLIC_KEY;\n const PRIVATE_KEY = process.env.PRIVATE_KEY;\n\n const { createAlchemyWeb3 } = require("@alch/alchemy-web3");\n const web3 = createAlchemyWeb3(API_URL);\n\n const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");\n const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";\n const nftContract = new web3.eth.Contract(contract.abi, contractAddress);\n\n async function mintNFT(tokenURI) {\n const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //获取最新的 nonce\n\n //交易\n const tx = {\n 'from': PUBLIC_KEY,\n 'to': contractAddress,\n 'nonce': nonce,\n 'gas': 500000,\n 'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()\n };\n }
```
## 第 8 步：签署交易 {#sign-txn}
-现在我们已经创建了我们的交易，我们需要签署它，以便将其发送出去。 在这里我们将使用到我们的私钥。
+创建好交易后，我们需要对其进行签名才能发送。 在这里，我们将使用我们的私钥。
-`web3.eth.sendSignedTransaction` 会给我们提供交易的哈希值，我们可以用它来确保我们的交易被开采出来，没有被网络丢弃。 你会注意到在交易签署部分，我们已经增加了一些错误检查，以便我们知晓交易是否成功通过。
+`web3.eth.sendSignedTransaction` 将为我们提供交易哈希，我们可以用它来确保我们的交易被挖出，而没有被网络丢弃。 你会注意到，在交易签名部分，我们添加了一些错误检查，以便我们知道交易是否成功。
```js
-require("dotenv").config()
-const API_URL = process.env.API_URL
-const PUBLIC_KEY = process.env.PUBLIC_KEY
-const PRIVATE_KEY = process.env.PRIVATE_KEY
-
-const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
-const web3 = createAlchemyWeb3(API_URL)
-
-const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
-const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
-const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
-
-async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
-
- //the transaction
- const tx = {
- from: PUBLIC_KEY,
- to: contractAddress,
- nonce: nonce,
- gas: 500000,
- data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
- }
-
- const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
- signPromise
- .then((signedTx) => {
- web3.eth.sendSignedTransaction(
- signedTx.rawTransaction,
- function (err, hash) {
- if (!err) {
- console.log(
- "The hash of your transaction is: ",
- hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
- )
- } else {
- console.log(
- "Something went wrong when submitting your transaction:",
- err
- )
- }
- }
- )
- })
- .catch((err) => {
- console.log(" Promise failed:", err)
- })
-}
+require("dotenv").config()\nconst API_URL = process.env.API_URL\nconst PUBLIC_KEY = process.env.PUBLIC_KEY\nconst PRIVATE_KEY = process.env.PRIVATE_KEY\n\nconst { createAlchemyWeb3 } = require("@alch/alchemy-web3")\nconst web3 = createAlchemyWeb3(API_URL)\n\nconst contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")\nconst contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"\nconst nftContract = new web3.eth.Contract(contract.abi, contractAddress)\n\nasync function mintNFT(tokenURI) {\n const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //获取最新的 nonce\n\n //交易\n const tx = {\n from: PUBLIC_KEY,\n to: contractAddress,\n nonce: nonce,\n gas: 500000,\n data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),\n }\n\n const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)\n signPromise\n .then((signedTx) => {\n web3.eth.sendSignedTransaction(\n signedTx.rawTransaction,\n function (err, hash) {\n if (!err) {\n console.log(\n "你的交易哈希是：",\n hash,\n "\n检查 Alchemy 的内存池 (Mempool) 来查看你的交易状态！"\n )\n } else {\n console.log(\n "提交交易时出错了：",\n err\n )\n }\n }\n )\n })\n .catch((err) => {\n console.log(" Promise 失败：", err)\n })\n}
```
-## 第 9 步：调用 `mintNFT` 并运行节点 `mint-nft.js` {#call-mintnft-fn}
+## 第 9 步：调用 `mintNFT` 并运行 `node mint-nft.js` {#call-mintnft-fn}
-还记得你上传到 Pinata 的 `metadata.json` 吗？ 从 Pinata 获取其哈希代码，并将以下内容作为参数传送给函数 `mintNFT` `https://gateway.pinata.cloud/ipfs/`
+还记得你上传到 Pinata 的 `metadata.json` 吗？ 从 Pinata 获取其哈希码，并将以下内容作为参数传递给 `mintNFT` 函数 `https://gateway.pinata.cloud/ipfs/`
-如何获取哈希代码：
+获取哈希码的方法如下：
-_How to get your nft metadata hashcode on Pinata_
+_如何在 Pinata 上获取你的 NFT 元数据哈希码_
-> 仔细检查你复制的哈希代码是否链接到你的 **metadata.json**，方法是将 `https://gateway.pinata.cloud/ipfs/` 加载到独立窗口。 页面看起来应该类似于下面的截图：
+> 通过将 `https://gateway.pinata.cloud/ipfs/` 加载到单独的窗口中，仔细检查你复制的哈希码是否链接到你的 **metadata.json**。 该页面应类似于下面的屏幕截图：
-_Your page should display the json metadata_
+_你的页面应显示 json 元数据_
-总之，你的代码应该看起来像这样：
+总而言之，你的代码应该如下所示：
```js
-require("dotenv").config()
-const API_URL = process.env.API_URL
-const PUBLIC_KEY = process.env.PUBLIC_KEY
-const PRIVATE_KEY = process.env.PRIVATE_KEY
-
-const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
-const web3 = createAlchemyWeb3(API_URL)
-
-const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
-const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
-const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
-
-async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
-
- //the transaction
- const tx = {
- from: PUBLIC_KEY,
- to: contractAddress,
- nonce: nonce,
- gas: 500000,
- data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
- }
-
- const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
- signPromise
- .then((signedTx) => {
- web3.eth.sendSignedTransaction(
- signedTx.rawTransaction,
- function (err, hash) {
- if (!err) {
- console.log(
- "The hash of your transaction is: ",
- hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
- )
- } else {
- console.log(
- "Something went wrong when submitting your transaction:",
- err
- )
- }
- }
- )
- })
- .catch((err) => {
- console.log("Promise failed:", err)
- })
-}
-
-mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
+require("dotenv").config()\nconst API_URL = process.env.API_URL\nconst PUBLIC_KEY = process.env.PUBLIC_KEY\nconst PRIVATE_KEY = process.env.PRIVATE_KEY\n\nconst { createAlchemyWeb3 } = require("@alch/alchemy-web3")\nconst web3 = createAlchemyWeb3(API_URL)\n\nconst contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")\nconst contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"\nconst nftContract = new web3.eth.Contract(contract.abi, contractAddress)\n\nasync function mintNFT(tokenURI) {\n const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //获取最新的 nonce\n\n //交易\n const tx = {\n from: PUBLIC_KEY,\n to: contractAddress,\n nonce: nonce,\n gas: 500000,\n data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),\n }\n\n const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)\n signPromise\n .then((signedTx) => {\n web3.eth.sendSignedTransaction(\n signedTx.rawTransaction,\n function (err, hash) {\n if (!err) {\n console.log(\n "你的交易哈希是：",\n hash,\n "\n检查 Alchemy 的内存池 (Mempool) 来查看你的交易状态！"\n )\n } else {\n console.log(\n "提交交易时出错了：",\n err\n )\n }\n }\n )\n })\n .catch((err) => {\n console.log("Promise 失败：", err)\n })\n}\n\nmintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
```
-现在，运行 `node scripts/mint-nft.js` 来部署你的非同质化代币。 几秒钟后，你应该在终端中看到这样的响应：
+现在，运行 `node scripts/mint-nft.js` 来部署你的 NFT。 几秒钟后，你应该会在终端中看到如下响应：
- 你的交易哈希值为：0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
-
- 检查 Alchem 的内存池以查看你的交易状态！
+ ```
+ 你的交易哈希为：0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8\n\n请检查 Alchemy 的内存池 (Mempool)，查看你的交易状态！
+ ```
-接下来，访问你的 [Alchemy 内存池](https://dashboard.alchemyapi.io/mempool)，查看你的交易状态（待定、已开采还是被网络放弃）。 如果你的交易被丢弃，还可以访问 [Goerli Etherscan](https://sepolia.etherscan.io/) 并搜索你的交易哈希值。
+接下来，访问你的 [Alchemy 内存池](https://dashboard.alchemyapi.io/mempool)，查看你的交易状态（待处理、已挖出或已被网络丢弃）。 如果你的交易被丢弃，检查 [Blockscout](https://eth-sepolia.blockscout.com/) 并搜索你的交易哈希也会有所帮助。
-_View your NFT transaction hash on Etherscan_
+_在 Etherscan 上查看你的 NFT 交易哈希_
-就是这样！ 你现在已经在以太坊区块链上部署和铸造了一个非同质化代币 `](https://any.site/ipfs/bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im)，你将以去中心化的方式获得该内容。
+
+## 缺点 {#drawbacks}
+
+你无法可靠地删除 IPFS 文件，因此，只要你在修改用户界面，最好要么保持其中心化，要么使用[星际名称系统 (IPNS)](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs)，这是一个在 IPFS 之上提供可变性的系统。 当然，任何可变的东西都可能被审查，就 IPNS 而言，可以通过向持有其对应私钥的人施压来实现。
+
+此外，某些软件包与 IPFS 存在兼容性问题，因此如果你的网站非常复杂，这可能不是一个好的解决方案。 当然，任何依赖于服务器集成的东西都不能仅仅通过将客户端放在 IPFS 上来实现去中心化。
+
+## 结论 {#conclusion}
+
+正如以太坊让你能够将去中心化应用程序的数据库和业务逻辑方面去中心化一样，IPFS 也能让你将用户界面去中心化。 这可以让你关闭针对你的去中心化应用程序的又一个攻击向量。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/zh/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
index 6abf8c58b78..626c3fe19f3 100644
--- a/public/content/translations/zh/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
+++ b/public/content/translations/zh/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -1,14 +1,8 @@
---
-title: 使用 create-eth-app 启动去中心化应用程序前端开发
-description: 如何使用 create-eth-app 及其功能的概述
+title: "使用 create-eth-app 启动去中心化应用程序前端开发"
+description: "create-eth-app 的用法及其功能概述"
author: "Markus Waas"
-tags:
- - "create-eth-app"
- - "前端"
- - "javascript"
- - "ethers.js"
- - "图表"
- - "defi"
+tags: [ "前端", "javascript", "ethers.js", "the graph", "DeFi" ]
skill: beginner
lang: zh
published: 2020-04-27
@@ -16,11 +10,11 @@ source: soliditydeveloper.com
sourceUrl: https://soliditydeveloper.com/create-eth-app
---
-上一次，我们了解 [Solidity](https://soliditydeveloper.com/solidity-overview-2020) 大的框架时，已经提到了 [create-eth-app](https://github.com/PaulRBerg/create-eth-app)。 现在，您将了解如何使用它，它集成了哪些功能以及如何对其进行扩展等内容。 这个应用程序由 [Sablier](http://sablier.com/)创始人 Paul Razvan Berg 启动，它将启动您的前端开发，并且具有多个可选集成供您选择。
+上次我们探讨了 [Solidity 的宏观概况](https://soliditydeveloper.com/solidity-overview-2020)，并提到了 [create-eth-app](https://github.com/PaulRBerg/create-eth-app)。 现在，你将了解如何使用它，它集成了哪些功能以及如何对其进行扩展等内容。 这个应用程序由 [Sablier](http://sablier.com/) 创始人 Paul Razvan Berg 发起，将帮助你启动前端开发，并提供多种可选集成。
## 安装 {#installation}
-安装需要 Yarn 0.25 或更高版本 (`npm install yarn --global`)。 安装就像运行程序一样简单：
+安装需要 Yarn 0.25 或更高版本（`npm install yarn --global`）。 操作非常简单，只需运行：
```bash
yarn create eth-app my-eth-app
@@ -28,44 +22,44 @@ cd my-eth-app
yarn react-app:start
```
-这是正后台使用 [create-react-app](https://github.com/facebook/create-react-app)。 要查看您的应用程序，请打开 `http://localhost:3000/`。 当您准备好部署到生产环境中时，使用 yarn build 创建一个缩小的捆绑包。 一个简单的托管它的方法是使用 [ Netlify](https://www.netlify.com/)。 您可以创建一个 GitHub 存储库，将其添加到 Netlify，设置构建命令，这样就完成了！ 您的应用程序将被托管并可供所有人使用。 所有这些都是免费的。
+它在底层使用了 [create-react-app](https://github.com/facebook/create-react-app)。 要查看你的应用程序，请打开 `http://localhost:3000/`。 当你准备好部署到生产环境中时，使用 yarn build 创建一个精简捆绑包。 一种简单的托管方法是 [Netlify](https://www.netlify.com/)。 你可以创建一个 GitHub 存储库，将其添加到 Netlify，设置构建命令，这样就完成了！ 你的应用程序将被托管并可供所有人使用。 所有这些都是免费的。
## 功能 {#features}
### React 和 create-react-app {#react--create-react-app}
-首先，我们来了解应用程序的核心：React 和 _create-react-app_ 带来的所有附加功能。 如果您不想集成以太坊，那么仅使用它是一个很好的选择。 [React](https://reactjs.org/) 本身使构建交互式 UI 变得非常容易。 它可能不像 [Vue](https://vuejs.org/) 那样方便初学者，但仍然被广泛使用。 它具有更多的功能，最重要的是还有数千个附加库可供选择。 _create-react-app_ 也使它非常容易开始使用，具有的功能包括：
+首先，我们来了解应用程序的核心：React 和 _create-react-app_ 带来的所有附加功能。 如果你不想集成以太坊，那么仅使用它是一个很好的选择。 [React](https://react.dev/) 本身使构建交互式用户界面变得非常容易。 它可能不像 [Vue](https://vuejs.org/) 那样对初学者友好，但它仍是主流，功能更丰富，最重要的是有数以千计的附加程序库可供选择。 使用 _create-react-app_ 也很容易上手，其功能包括：
- React、JSX、ES6、TypeScript、Flow 语法支持。
-- ES6 之外的语言附加功能，如对象扩展运算符。
-- 自动添加前缀的 CSS，所以您不需要 -webkit- 或其他前缀。
+- ES6 之外的语言附加功能，如对象展开运算符。
+- 自动添加前缀的 CSS，所以你不需要 -webkit- 或其他前缀。
- 快速交互式单元测试运行程序，内置对覆盖率报告的支持。
- 对常见错误发出警告的实时开发服务器。
-- 一个用于捆绑 JS、CSS 和图片的构建脚本，带有哈希值和资源映射。
+- 一个用于捆绑JS、CSS和图片的构建脚本，带有哈希值和源映射。
-尤其是 _create-eth-app_ 正在使用新的 [hooks effect](https://reactjs.org/docs/hooks-effect.html)。 这是一种编写强大而又非常小巧的所谓功能组件的方法。 关于如何在 _create-eth-app_ 中使用 Apollo，请看下面关于 Apollo 的部分。
+_create-eth-app_ 特别使用了新的 [effect hook](https://legacy.reactjs.org/docs/hooks-effect.html)。 一种编写功能强大但代码量很小的所谓函数式组件的方法。 要了解它们在 _create-eth-app_ 中的用法，请参阅下文关于 Apollo 的部分。
-### Yarn Workspace {#yarn-workspaces}
+### Yarn Workspaces {#yarn-workspaces}
-[Yarn Workspace](https://classic.yarnpkg.com/en/docs/workspaces/)允许您拥有多个包， 但可以从根目录对他们进行管理，而且可以使用 `yarn install` 一次性安装所有依赖项。 这对于较小的附加包，例如智能合约地址/ABI 管理（关于您在哪里部署了哪些智能合约以及如何与它们通信的信息）或图集成等，尤其有意义，这两个包都是 `create-eth-app` 的一部分。
+[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) 允许多个包存在，同时能够从根目录管理所有这些包，并使用 `yarn install` 一次性为所有包安装依赖项。 这对于较小的附加包尤其有意义，例如智能合约地址/ABI 管理（关于你将哪个智能合约部署在何处以及如何与其通信的信息）或图谱集成，这两者都是 `create-eth-app` 的一部分。
### ethers.js {#ethersjs}
-虽然 [Web3](https://docs.web3js.org/) 仍被广泛使用，但 [ethers.js](https://docs.ethers.io/) 作为一种替代方案，在过去一年中获得了更多的关注，并且已集成到 _create-eth-app_ 中。 您可以使用这个操作，将它更改为 Web3，或者考虑升级为 [ethers.js v5](https://docs.ethers.org/v5/)，该版本即将完成测试阶段。
+虽然 [Web3.js](https://docs.web3js.org/) 仍是主流，但 [ethers.js](https://docs.ethers.io/) 在去年作为替代方案获得了更多关注，并被集成到了 _create-eth-app_ 中。 你可以使用这个操作，将它更改为 Web3，或者考虑升级为 [ethers.js v5](https://docs.ethers.org/v5/)，该版本即将完成测试阶段。
-### 图表 {#the-graph}
+### The Graph {#the-graph}
-与 [Restful API](https://restfulapi.net/) 相比，[GraphQL](https://graphql.org/) 是处理数据的另一种方式。 与 Restful Api 相比，它们有几个优势，特别是对于去中心化的区块链数据来说更是如此。 如果您对这背后的原因感兴趣，可以看看 [GraphQL 将为去中心化网络提供动力](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a)。
+[GraphQL](https://graphql.org/) 是与 [Restful API](https://restfulapi.net/) 相对应的一种处理数据的方式。 与 Restful 应用程序接口相比，它们有几个优势，特别是对于去中心化的区块链数据来说更是如此。 如果你对此背后的原因感兴趣，可以看看 [GraphQL Will Power the Decentralized Web](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a)。
-通常您会直接从您的智能合约中获取数据。 想要读取上次交易的时间吗？ 只需调用 `MyContract.methods.latestTradeTime().call()`，它将数据从以太坊节点（如 Infura）提取到你的去中心化应用程序。 但如果您需要数百个不同的数据点，该怎么办？ 这将导致在节点上进行数百次数据提取操作，每次都有[往返延时](https://wikipedia.org/wiki/Round-trip_delay_time)，使你的去中心化应用程序缓慢且效率低下。 一个变通的办法是在您的合约中设置一个取数器调用函数，一次性返回多个数据。 但这并不总是理想的。
+通常你会直接从你的智能合约中获取数据。 想要读取最新一笔交易的时间吗？ 只需调用 `MyContract.methods.latestTradeTime().call()`，它会从以太坊节点获取数据并传输到你的去中心化应用程序中。 但如果你需要数百个不同的数据点，该怎么办？ 这将导致在节点上进行数百次数据提取操作，每次都有[往返时延 (RTT)](https://wikipedia.org/wiki/Round-trip_delay_time)，使你的去中心化应用程序缓慢且效率低下。 一个变通方法可能是在你的合约中设置一个获取器调用函数，一次返回多个数据。 但这并不总是理想的。
-然后您可能对历史数据也感兴趣。 您不仅想知道上次交易的时间，还想知道自己做过的所有交易的时间。 使用 _create-eth-app_ 子图包，阅读[文档](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph)并使其适合您自己的合约。 如果您正在寻找受欢迎的智能合约，甚至可能已经有了一个子图。 可以查看[子图浏览器](https://thegraph.com/explorer/)。
+然后你可能对历史数据也感兴趣。 你不仅想知道上次交易的时间，还想知道自己做过的所有交易的时间。 使用 _create-eth-app_ 子图包，阅读[相关文档](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph)并将其适配到你自己的合约。 如果你正在寻找受欢迎的智能合约，甚至可能已经有了一个子图。 查看[子图浏览器](https://thegraph.com/explorer/)
有了子图后，你可以在去中心化应用程序中编写一个简单的查询来检索所有重要的区块链数据，包括你需要的历史数据，并且只需一次提取操作即可。
### Apollo {#apollo}
-由于 [Apollo Boost](https://www.apollographql.com/docs/react/get-started/) 集成，你可以轻松将图集成到 React 去中心化应用程序中。 特别是在使用 [React hooks 和 Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks) 时，获取数据就像在您的组件中写一个 GraphQl 查询一样简单：
+借助 [Apollo Boost](https://www.apollographql.com/docs/react/get-started/) 集成，你可以轻松地将子图集成到你的 React 去中心化应用程序中。 特别是在使用 [React hooks 和 Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks) 时，获取数据就像在你的组件中写一个 GraphQl 查询一样简单：
```js
const { loading, error, data } = useQuery(myGraphQlQuery)
@@ -79,32 +73,32 @@ React.useEffect(() => {
## 模板 {#templates}
-在顶部，您可以从几个不同的模板中进行选择。 到目前为止，您可以使用 Aave、Comp、UniSwap 或 sablier 集成。 它们都增加了重要的服务智能合约地址以及预先制作的子图集成。 只需将模板添加到创建命令，例如 `yarn create eth-app my-eth-app --with-template aave`。
+在顶部，你可以从几个不同的模板中进行选择。 到目前为止，你可以使用 Aave、Compound、UniSwap 或 sablier 集成。 它们都增加了重要的服务智能合约地址以及预先制作的子图集成。 只需将模板添加到创建命令，例如 `yarn create eth-app my-eth-app --with-template aave`。
### Aave {#aave}
-[Aave](https://aave.com/) 是一个去中心化的货币借贷市场。 存款人向市场提供流动性以赚取被动收入，而借款人则可以利用抵押物进行借贷。 Aave 的一个独特功能是那些[闪电贷](https://docs.aave.com/developers/guides/flash-loans)，让您可以在没有任何抵押品的情况下借钱，只要您在一次交易中返还贷款即可。 例如，这对于在套利交易中为您提供额外的现金很有用。
+[Aave](https://aave.com/) 是一个去中心化的货币借贷市场。 存款人向市场提供流动性以赚取被动收入，而借款人则可以利用抵押品进行借贷。 Aave 的一个独特功能是[闪电贷](https://aave.com/docs/developers/flash-loans)，让你可以在没有任何抵押品的情况下借钱，只要你在一次交易中返还贷款即可。 例如，这对于在套利交易中为你提供额外的现金很有用。
-为您赢得利益的交易代币被称为 _aTokens_。
+为你赚取利息的交易代币被称为 _aTokens_。
-当您选择将 Aave 与 _create-eth-app_ 集成时，您将获得[子图集成](https://docs.aave.com/developers/getting-started/using-graphql)。 Aave 使用 The Graph，并且已经在 [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) 和 [Mainnet](https://thegraph.com/explorer/subgraph/aave/protocol) 上以[原始](https://thegraph.com/explorer/subgraph/aave/protocol-raw)或[格式化](https://thegraph.com/explorer/subgraph/aave/protocol)形式为您提供了几个现成的子图。
+当你选择将 Aave与 _create-eth-app_ 集成时，你将获得一个[子图集成](https://docs.aave.com/developers/getting-started/using-graphql)。 Aave 使用 The Graph，并已在 [Ropsten 测试网](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten)和[主网](https://thegraph.com/explorer/subgraph/aave/protocol)上以[原始](https://thegraph.com/explorer/subgraph/aave/protocol-raw)或[格式化](https://thegraph.com/explorer/subgraph/aave/protocol)形式为你提供多个即用型子图。
-
+
### Compound {#compound}
-[ Compound ](https://compound.finance/) 类似于 Aave。 集成中已包含新的 [Compound v2 Subgraph](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195)。 在这里，赚取利益的代币竟然被称为* cTokens*。
+[Compound](https://compound.finance/) 与 Aave 类似。 该集成已包含新的 [Compound v2 子图](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195)。 令人惊讶的是，这里赚取利息的代币被称为 _cTokens_。
### Uniswap {#uniswap}
-[Uniswap](https://uniswap.exchange/) 是一个去中心化的交易所 (DEX)。 流动性供应商可以通过为交易双方提供所需的代币或以太币来赚取费用。 它正在被广泛使用，因此对于非常多的各种代币来说，它的流动性是最高的当中的一个。 例如，你可以轻松地将其集成到你的去中心化应用程序中，让用户可以将他们的以太币换成 DAI 币。
+[Uniswap](https://uniswap.exchange/) 是一个去中心化交易所 (DEX)。 流动性供应商可以通过为交易双方提供所需的代币或以太币来赚取费用。 它被广泛使用，因此在众多代币中拥有最高的流动性之一。 例如，你可以轻松地将其集成到你的去中心化应用程序中，让用户可以将他们的 ETH 兑换成 DAI。
-遗憾的是，在撰写本文时，集成仅针对 Uniswap v1，而不是 [刚刚发布的 v2](https://uniswap.org/blog/uniswap-v2/)。
+遗憾的是，在撰写本文时，集成仅针对 Uniswap v1，而不是[刚刚发布的 v2](https://uniswap.org/blog/uniswap-v2/)。
### Sablier {#sablier}
-[Sablier](https://sablier.com/) 允许用户进行流支付。 完成最初的设置后，您实际上是不断地得到您的货币，而不是在某个支付日，并且不需要进行进一步的管理。 该集成包含了它[自己的子图](https://thegraph.com/explorer/subgraph/sablierhq/sablier)。
+[Sablier](https://sablier.com/) 允许用户进行流支付。 完成最初的设置后，你实际上是不断地得到你的货币，而不是在某个支付日，并且不需要进行进一步的管理。 该集成包含其[自己的子图](https://thegraph.com/explorer/subgraph/sablierhq/sablier)。
-## 接下来是什么？ {#whats-next}
+## 接下来该做什么？ {#whats-next}
-如果您对 _create-eth-app_ 有任何疑问，请访问 [Sablier 社区服务器](https://discord.gg/bsS8T47)，在那里您可以与 _create-eth-app_ 的作者取得联系。 作为接下来的第一步，您可能希望集成一个 UI 框架，例如 [Material UI](https://material-ui.com/)，为您实际需要的数据编写 GraphQL 查询并设置部署。
+如果你对 _create-eth-app_ 有任何疑问，请访问 [Sablier 社区服务器](https://discord.gg/bsS8T47)，在那里你可以与 _create-eth-app_ 的作者取得联系。 作为接下来的第一步，你可能希望集成一个 UI 框架，例如 [Material UI](https://mui.com/material-ui/)，为你实际需要的数据编写 GraphQL 查询并设置部署。
diff --git a/public/content/translations/zh/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md b/public/content/translations/zh/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
index f5d501d3dce..8385de17136 100644
--- a/public/content/translations/zh/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
+++ b/public/content/translations/zh/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
@@ -1,11 +1,8 @@
---
-title: 通过 SQL 学习以太坊基础主题
-description: 本教程帮助读者通过使用结构化查询语言 (SQL) 查询链上数据，了解以太坊的基本概念，包括交易、区块和燃料。
+title: "通过 SQL 学习以太坊基础主题"
+description: "本教程帮助读者通过使用结构化查询语言 (SQL) 查询链上数据，了解以太坊的基本概念，包括交易、区块和燃料。"
author: "Paul Apivat"
-tags:
- - "SQL"
- - "查询"
- - "交易"
+tags: [ "SQL", "查询", "交易" ]
skill: beginner
lang: zh
published: 2021-05-11
@@ -13,25 +10,25 @@ source: paulapivat.com
sourceUrl: https://paulapivat.com/post/query_ethereum/
---
-针对开发者的以太坊教程很多，但对于数据分析师或希望不运行客户端或节点就能查看链上数据的人员，教育资源却稀缺。
+面向开发者的以太坊教程很多，但缺少面向数据分析师或希望在不运行客户端或节点的情况下查看链上数据的人员的教育资源。
-本教程帮助读者通过 [Dune Analytics](https://dune.xyz/home) 提供的接口，使用结构化查询语言 (SQL) 查询链上数据，从而了解以太坊的基本概念，包括交易、区块和燃料。
+本教程通过 [Dune Analytics](https://dune.com/) 提供的界面，帮助读者使用结构化查询语言 (SQL) 查询链上数据，从而了解以太坊的基本概念，包括交易、区块和燃料。
-链上数据可以帮助我们理解网络和算力经济 — 以太坊，并且帮助我们理解以太坊当前所面临的挑战（例如不断上涨的燃料），更重要的是，了解一些围绕扩容解决方案的讨论。
+链上数据可以帮助我们了解以太坊（它是一个网络，也是一个算力经济体），并且应该作为理解以太坊当今所面临挑战（即不断上涨的燃料价格）以及更重要的扩容解决方案相关讨论的基础。
### 交易 {#transactions}
-用户以太坊之旅的第一步是初始化具有以太币余额的用户控制帐户或实体。 帐户类型分为两种 — 用户控制帐户或智能合约（参阅 [ethereum.org](/developers/docs/accounts/)）。
+用户的以太坊之旅，始于初始化一个拥有 ETH 余额的用户控制帐户或实体。 帐户类型分为两种——用户控制帐户或智能合约（请参阅 [ethereum.org](/developers/docs/accounts/)）。
-可以在诸如 [Etherscan](https://etherscan.io/) 等区块浏览器上查看任何帐户。 区块浏览器是你访问以太坊数据的门户。 它们实时显示区块上的数据、交易、矿工、帐户和其他链上活动（参阅[此处](/developers/docs/data-and-analytics/block-explorers/)）。
+任何帐户都可以在 [Etherscan](https://etherscan.io/) 或 [Blockscout](https://eth.blockscout.com/) 等区块浏览器上查看。 区块浏览器是访问以太坊数据的门户。 它们实时显示区块、交易、矿工、帐户及其他链上活动的数据（请参阅[此处](/developers/docs/data-and-analytics/block-explorers/)）。
-然而，用户可能希望直接查询数据，以核对外部区块浏览器提供的信息。 [Dune Analytics](https://duneanalytics.com/) 为任何对 SQL 有一定了解的人提供了这种功能。
+然而，用户可能希望直接查询数据，以核对外部区块浏览器提供的信息。 [Dune Analytics](https://dune.com/) 为任何对 SQL 有一定了解的人提供了这种功能。
-作为参考，以太坊基金会 (EF) 的智能合约帐户可以在 [Etherscan](https://etherscan.io/address/0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae) 上查看。
+作为参考，以太坊基金会 (EF) 的智能合约帐户可以在 [Blockscout](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe) 上查看。
-值得注意的是，包括以太坊基金会帐户在内的所有帐户都有一个公共地址，可用来发送和接收交易。
+值得注意的是，包括以太坊基金会的帐户在内的所有帐户都有一个公共地址，可用来发送和接收交易。
-Etherscan 上的帐户余额由常规交易和内部交易构成。 尽管使用了这一名称，但内部交易并不是改变链状态的_真正_交易。 它们是通过执行合约发起的价值转移（[原文](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions)）。 因为内部交易没有签名，它们**没有**包含在区块上，并且不能通过 Dune Analytics 查询。
+Etherscan 上的帐户余额由常规交易和内部交易构成。 尽管名为内部交易，但它们并不是改变链上状态的_真正_交易。 它们是通过执行合约发起的价值转移（[来源](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions)）。 由于内部交易没有签名，它们**并未**包含在区块链上，因此无法用 Dune Analytics 查询。
因此，本教程将侧重于常规交易。 可以这样查询：
@@ -61,33 +58,33 @@ SELECT
FROM temp_table
```
-产生的信息与 Etherscan 交易页面提供的信息相同。 为了比较起见，下面是两种来源的信息：
+这将产生与 Etherscan 交易页面上提供的信息相同的信息。 为便于比较，以下是这两个来源：
#### Etherscan {#etherscan}
-[Etherscan 上以太坊基金会的合约页面。](https://etherscan.io/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
+[Blockscout 上的 EF 合约页面。](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
#### Dune Analytics {#dune-analytics}
-可以在[此处](https://duneanalytics.com/paulapivat/Learn-Ethereum)找到仪表板。 点击表格查看查询（另请参阅上文）。
+你可以在[此处](https://dune.com/paulapivat/Learn-Ethereum)找到看板。 点击表格查看查询（另请参阅上文）。
-### 交易明细 {#breaking_down_transactions}
+### 交易详解 {#breaking_down_transactions}
-提交的交易包含几条信息，包括[（原文）](/developers/docs/transactions/)：
+一笔已提交的交易包含以下几项信息（[来源](/developers/docs/transactions/)）：
-- **接收者**：接收地址（通过“to”查询）
-- **签名**：虽然由发送者的私钥签署交易，但我们可以通过 SQL 查询的是发送者的公共地址（“from”）。
-- **价值**：指的是转移的以太币数量（参阅 `ether` 列）。
-- **数据**：指的是经过哈希运算的任意数据（参阅 `data` 列）
-- **gasLimit** – 交易可以消耗的最大数量的燃料单位。 燃料单位代表计算步骤
-- **maxPriorityFeePerGas** - 作为矿工小费包含的最大燃料数量
+- **接收方**：接收地址（查询时用 "to"）
+- **签名**：虽然由发送者的私钥签署交易，但我们可以用 SQL 查询的是发送者的公共地址（"from"）。
+- **价值**：这是转移的 ETH 数量（请参阅 `ether` 列）。
+- **数据**：这是经过哈希运算的任意数据（请参阅 `data` 列）
+- **gasLimit** – 交易可消耗的最大燃料单位数量。 燃料单位代表计算步骤
+- **maxPriorityFeePerGas** - 作为给矿工的小费所包含的最大燃料数量
- **maxFeePerGas** - 愿意为交易支付的最大燃料数量（包括 baseFeePerGas 和 maxPriorityFeePerGas）
-我们可以向以太坊基金会公共地址查询这些具体的交易信息：
+我们可以查询发送至以太坊基金会公共地址的交易中的这些具体信息：
```sql
SELECT
@@ -106,15 +103,15 @@ ORDER BY block_time DESC
### 区块 {#blocks}
-每笔交易都会改变以太坊虚拟机 ([EVM](/developers/docs/evm/)) 的状态（[原文](/developers/docs/transactions/)）。 交易广播到网络上进行验证并被记录在一个区块中。 每笔交易都与一个区块编号相关联。 要查看数据，我们可以查询一个具体的区块编码：12396854（截至本文撰写日期 2021 年 11 月 5 日，以太坊基金会交易中最新的区块）。
+每笔交易都会改变以太坊虚拟机 ([EVM](/developers/docs/evm/)) 的状态（[来源](/developers/docs/transactions/)）。 交易会广播到网络进行验证，并被包含在一个区块中。 每笔交易都与一个区块编号相关联。 要查看数据，我们可以查询一个具体的区块编号：12396854（在撰写本文时 [2021 年 5 月 11 日]，这是以太坊基金会交易中最新的区块）。
-此外，当我们查询下两个区块时，我们可以看到每个区块包含上一个区块的哈希值（即父哈希值），以此来说明区块链是如何形成的。
+此外，当我们查询下两个区块时，可以看到每个区块都包含上一个区块的哈希值（即父哈希），这说明了区块链是如何形成的。
-每个区块都包含对其父块的引用。 如下面的 `hash` 和 `parent_hash` 列所示（[原文](/developers/docs/blocks/)）：
+每个区块都包含对其父区块的引用。 这在下面的 `hash` 和 `parent_hash` 列之间有所显示（[来源](/developers/docs/blocks/)）：
-
+
-下面是 Dune Analytics上的[查询](https://duneanalytics.com/queries/44856/88292)：
+以下是 Dune Analytics 上的[查询](https://dune.com/queries/44856/88292)：
```sql
SELECT
@@ -130,14 +127,14 @@ LIMIT 10
我们可以通过查询时间、区块编号、难度、哈希值、父哈希值及随机数来检查一个区块。
-此查询唯一不包含的内容是_交易列表_，需要通过下面的单独查询和_状态根_来查看它。 完整或归档节点将存储所有交易和状态转换，允许客户端随时查询链的状态。 因为这需要非常大的存储空间，我们可以将链数据与状态数据分开：
+此查询唯一未涵盖的是_交易列表_（这需要下文的单独查询）和_状态根_。 完整节点或归档节点将存储所有交易和状态转换，允许客户端随时查询链的状态。 因为这需要非常大的存储空间，我们可以将链数据与状态数据分开：
- 链数据（区块列表、交易）
- 状态数据（每次交易状态转换的结果）
-状态根属于状态数据，是_隐式_数据（未存储在链上），而链数据是显式数据并存储在链上（[原文](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored)）。
+状态根属于后者，是_隐式_数据（不存储在链上），而链数据是显式数据，存储在链本身上（[来源](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored)）。
-在本教程中，我们将侧重于_可以_在 Dune Analytics 上使用 SQL 查询的链上数据。
+在本教程中，我们将重点关注那些_可以_通过 Dune Analytics 用 SQL 查询的链上数据。
如上所述，每个区块都包含一个交易列表，我们可以通过筛选一个特定区块来查询它。 我们将尝试最新的区块 12396854：
@@ -151,7 +148,7 @@ ORDER BY block_time DESC`
-添加到链中的这个单独区块改变了以太坊虚拟机 ([EVM](/developers/docs/evm/)) 的状态。 几十笔，有时数百笔交易会同时进行验证。 在本例中，记录了 222 笔交易。
+这个被添加到链上的区块，改变了以太坊虚拟机 ([EVM](/developers/docs/evm/)) 的状态。 有时几十笔、甚至几百笔交易会同时得到验证。 在这个特定的案例中，包含了 222 笔交易。
要查看实际有多少笔成功交易，我们将添加另一个筛选器来计算成功的交易：
@@ -166,13 +163,13 @@ SELECT
FROM temp_table
```
-对于区块 12396854，在 222 笔交易中，有 204 笔成功验证：
+对于区块 12396854，在 222 笔总交易中，有 204 笔成功验证：
-交易请求每秒发生数十次，但区块大约每 15 秒提交一次（[原文](/developers/docs/blocks/)）。
+交易请求每秒发生数十次，但区块大约每 15 秒提交一次（[来源](/developers/docs/blocks/)）。
-要了解大约每 15 秒产生一个区块，我们可以用一天的总秒数 (86400) 除以 15，得到估算的每日平均区块数量（大约 5760 个）。
+要了解大约每 15 秒产生一个区块，我们可以用一天的总秒数 (86400) 除以 15，得到估算的每日平均区块数量（约 5760 个）。
每天产生的以太坊区块数量图表（2016 年至今）如下所示：
@@ -182,10 +179,10 @@ FROM temp_table
-查询如下所示：
+查询如下：
```sql
-# query to visualize number of blocks produced daily since 2016
+# 用于可视化自 2016 年以来每日产出区块数量的查询
SELECT
DATE_TRUNC('day', time) AS dt,
@@ -194,7 +191,7 @@ FROM ethereum."blocks"
GROUP BY dt
OFFSET 1
-# average number of blocks produced per day
+# 每日产出区块的平均数量
WITH temp_table AS (
SELECT
@@ -209,13 +206,13 @@ SELECT
FROM temp_table
```
-2016 年以来每天产生的平均区块数量略高于 5,874 个。 或者，将 86400 秒除以平均区块数量 5874 应得到 14.7 秒，或大约每 15 秒一个区块。
+自 2016 年以来，每日产出的平均区块数量为 5,874，略高于该估算值。 另外，将 86400 秒除以 5874 个平均区块数，得出 14.7 秒，即大约每 15 秒一个区块。
### 燃料 {#gas}
-区块的大小是有限的。 最大区块大小是动态的，根据网络需求在 12,500,000 到 25,000,000 个单位之间变化。 需要设置大小限制，防止任意大的区块大小给全节点造成磁盘空间和速度要求方面的压力（[出处](/developers/docs/blocks/)）。
+区块的大小是有限的。 最大区块大小是动态的，根据网络需求在 12,500,000 到 25,000,000 个单位之间变化。 需要设置限制，以防止任意大的区块给完整节点在磁盘空间和速度方面带来压力（[来源](/developers/docs/blocks/)）。
-了解区块燃料限额的一种方法是将其视为区块空间（可在其中批量处理交易）的**供应**。 可以查询并显示从 2016 年至今的区块燃料限额：
+理解区块燃料限制的一种方法是，将其看作是可用于批量处理交易的区块空间的**供应**。 可以查询并可视化从 2016 年至今的区块燃料限制：
@@ -228,7 +225,7 @@ GROUP BY dt
OFFSET 1
```
-每天都有实际的燃料使用量，用于支付在以太坊链上完成的计算（例如，发送交易、调用智能合同、铸造非同质化代币）。 这是对以太坊可用区块空间的**需求**：
+然后是每日实际使用的燃料，用于支付在以太坊链上完成的计算（即发送交易、调用智能合约、铸造 NFT）。 这是对以太坊可用区块空间的**需求**：
@@ -241,17 +238,17 @@ GROUP BY dt
OFFSET 1
```
-我们还可以将这两个图表合并在一起，看看**需求和供应**如何契合：
+我们还可以将这两个图表并列，看看**需求和供应**如何匹配：
-
+
-因此，考虑到现有的供应情况，我们可以理解燃料价格是以太坊区块空间需求量的函数。
+因此，在给定可用供应的情况下，我们可以将燃料价格理解为以太坊区块空间需求的函数。
-最后，我们可能想查询以太坊链的日均燃料价格，但种查询会造成特别长的查询时间，所以我们将进行筛选，查询以太坊基金会对每笔交易支付的平均燃料数额。
+最后，我们可能想查询以太坊链的日均燃料价格，但这样做会导致查询时间特别长，所以我们将筛选查询，只查询以太坊基金会为每笔交易支付的平均燃料量。
-我们可以看到多年来为以太坊基金会地址上进行的全部交易而支付的燃料价格。 查询如下：
+我们可以看到多年来，向以太坊基金会地址发起的交易所支付的燃料价格。 查询如下：
```sql
SELECT
@@ -265,8 +262,8 @@ ORDER BY block_time DESC
### 总结 {#summary}
-在本教程中，我们经过查询和感受链上数据，了解了以太坊基础概念以及以太坊区块链工作原理。
+通过本教程，我们查询并感受了链上数据，从而了解了以太坊的基本概念以及以太坊区块链的工作原理。
-包含本教程中所用全部代码的仪表板可以在[此处](https://duneanalytics.com/paulapivat/Learn-Ethereum)找到。
+包含本教程中所有代码的看板可以在[此处](https://dune.com/paulapivat/Learn-Ethereum)找到。
-若要更多地使用数据来探索 Web3，[请在推特上找到我](https://twitter.com/paulapivat)。
+若要更多地使用数据来探索 Web3，请在 [Twitter](https://twitter.com/paulapivat) 上找到我。
diff --git a/public/content/translations/zh/developers/tutorials/logging-events-smart-contracts/index.md b/public/content/translations/zh/developers/tutorials/logging-events-smart-contracts/index.md
index 1edade90aac..94f0caf04b4 100644
--- a/public/content/translations/zh/developers/tutorials/logging-events-smart-contracts/index.md
+++ b/public/content/translations/zh/developers/tutorials/logging-events-smart-contracts/index.md
@@ -1,12 +1,8 @@
---
-title: 使用事件记录智能合约中的数据
-description: 智能合约事件的简介，以及如何利用事件来记录数据
+title: "使用事件记录智能合约中的数据"
+description: "智能合约事件的简介，以及如何利用事件来记录数据"
author: "jdourlens"
-tags:
- - "智能合约"
- - "remix"
- - "solidity"
- - "事件"
+tags: [ "智能合同", "remix", "Solidity", "事件" ]
skill: intermediate
lang: zh
published: 2020-04-03
@@ -15,7 +11,7 @@ sourceUrl: https://ethereumdev.io/logging-data-with-events/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
---
-在solidity中，[事件](/developers/docs/smart-contracts/anatomy/#events-and-logs)是智能合约可触发的调度信号。 去中心化应用程序或其他任何连接到以太坊 JSON-PRC 应用程序接口的程序，都可以监听这些事件并执行相应操作。 还可以为事件编制索引，便于以后可以搜索事件历史。
+在 Solidity 中，[事件](/developers/docs/smart-contracts/anatomy/#events-and-logs)是智能合约可以发出的信号。 去中心化应用程序或任何连接到以太坊 JSON-RPC API 的应用都可以监听这些事件并采取相应行动。 还可以为事件编制索引，便于以后可以搜索事件历史。
## 事件 {#events}
@@ -25,9 +21,9 @@ address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
event Transfer(address indexed from, address indexed to, uint256 value);
```
-事件签名在合约代码中声明，可以使用 emit 关键字触发。 例如，转账事件记录谁发送了转账 (_from_)、发送给谁 (_to_) 以及转移了多少代币 (_value_)。
+事件签名在合约代码中声明，可以使用 `emit` 关键字触发。 例如，转账事件记录了谁发送了转账 (`_from`)、转账给谁 (`_to`)，以及转账的代币数量 (`_value`)。
-如果我们回到我们的 Counter 智能合约并决定在每次价值变化时记录。 由于这个合约不是为了部署，而是作为基础，通过扩展来构建另一个合约：因此它被称为抽象合约。 在我们的计数器示例中，此合约如下所示：
+如果我们回到我们的 Counter 智能合约并决定在每次值变化时记录。 由于这个合约不是为了部署，而是作为基础，通过扩展来构建另一个合约：因此它被称为抽象合约。 在我们的计数器示例中，此合约如下所示：
```solidity
pragma solidity 0.5.17;
@@ -36,16 +32,16 @@ contract Counter {
event ValueChanged(uint oldValue, uint256 newValue);
- // Private variable of type unsigned int to keep the number of counts
+ // 用于保存计数的私有无符号整数变量
uint256 private count = 0;
- // Function that increments our counter
+ // 递增计数器的函数
function increment() public {
count += 1;
emit ValueChanged(count - 1, count);
}
- // Getter to get the count value
+ // 用于获取计数值的 getter 函数
function getCount() public view returns (uint256) {
return count;
}
@@ -55,12 +51,12 @@ contract Counter {
注意：
-- **第5行**：我们声明了事件及其包含的内容、旧值以及新值。
+- **第 5 行**：我们声明了事件及其包含的内容、旧值以及新值。
-- **第13行**：当我们增加count变量的值时，我们会触发事件。
+- **第 13 行**：当我们增加 `count` 变量的值时，我们会触发事件。
-如果我们现在部署合约并调用increment函数，如果你在名为logs的数组内单击新交易，我们将看到Remix会自动显示它。
+如果我们现在部署合约并调用 `increment` 函数，如果你在名为 `logs` 的数组内单击新交易，我们将看到 Remix 会自动显示它。
-
+
-日志在调试智能合约时非常有用，另一方面，如果你构建一个不同人使用的应用，并且使分析更容易跟踪和了解你的智能合约的使用情况，那么日志也是非常重要的手段。 交易生成的日志显示在常见区块浏览器中，例如，你还可以使用日志创建链下脚本，以便监听特定事件并在事件发生时采取行动。
+日志在调试智能合约时非常有用，但如果你构建供不同人使用的应用程序，日志也很重要，因为它们可以让你更轻松地进行分析，以跟踪和了解你的智能合约是如何被使用的。 交易生成的日志显示在常见区块浏览器中，例如，你还可以使用日志创建链下脚本，以便监听特定事件并在事件发生时采取行动。
diff --git a/public/content/translations/zh/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/zh/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
index 6b874fe3699..cd11dc0992f 100644
--- a/public/content/translations/zh/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
+++ b/public/content/translations/zh/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -1,9 +1,8 @@
---
-title: 离线数据完整性的默克尔证明
-description: 在链上确保链下数据的完整性
+title: "离线数据完整性的默克尔证明"
+description: "在链上确保主要存储在链下的数据的数据完整性"
author: Ori Pomerantz
-tags:
- - "storage"
+tags: [ "存储" ]
skill: advanced
lang: zh
published: 2021-12-30
@@ -11,15 +10,21 @@ published: 2021-12-30
## 简介 {#introduction}
-理想的情况下，我们想要将所有东西存储在以太坊存储器中。这些数据存储于数以千计的计算机中 且有极高的可用性（数据不会被审查）和完整性（不能在未经授权的情况下修改数据）， 但存储一个 32 字节的词一般需要花费 20,000 燃料。 在撰写此教程时，该费用 等于 6.60 美元。 每字节 21 美分对许多应用程序来说都过于昂贵。
+理想的情况下，我们想要将所有东西存储在以太坊存储器中。这些数据存储于数以千计的计算机中
+且有极高的可用性（数据不会被审查）和完整性（不能在未经授权的情况下修改数据），
+但存储一个 32 字节的词一般需要花费 20,000 燃料。 在撰写此教程时，该费用
+等于 6.60 美元。 每字节 21 美分对许多应用程序来说都过于昂贵。
-为了解决这个问题，以太坊生态系统开发了[许多以去中心化方式存储数据的 代替方法](/developers/docs/storage/)。 通常情况下， 需要在可用性与价格之间进行取舍。 然而，完整性通常可以得到保证。
+为了解决这个问题，以太坊生态系统开发了许多以去中心化
+方式存储数据的替代方法。 通常情况下，
+需要在可用性与价格之间进行取舍。 然而，完整性通常可以得到保证。
-本篇文章中，你将学习**如何**在以下情况下确保数据的完整性：不将数据存储在区块链上，而是使用 [Merkle 证明](https://computersciencewiki.org/index.php/Merkle_proof)。
+在本文中，你将学习**如何**使用
+[默克尔证明](https://computersciencewiki.org/index.php/Merkle_proof)，在不将数据存储在区块链上的情况下确保数据完整性。
## 工作原理 {#how-does-it-work}
-理论上，我们只需要存储链上数据的哈希值，然后将所有数据发送到需要这些数据的交易中。 但是，这会非常昂贵。 1 字节的数据通过交易发送的成本约 16 个燃料，目前约 0.5 美分，或每千字节约 5 美元。 每兆字节 5,000 美元，这对于许多应用程序来说仍然太昂贵，而且还没有加上对数据进行哈希计算的费用。
+理论上，我们只需将数据的哈希存储在链上，并在需要它的交易中发送所有数据。 但是，这会非常昂贵。 1 字节的数据通过交易发送的成本约 16 个燃料，目前约 0.5 美分，或每千字节约 5 美元。 每兆字节 5,000 美元，这对于许多应用程序来说仍然太昂贵，而且还没有加上对数据进行哈希计算的费用。
解决办法是反复对不同的数据子集进行哈希计算。对于不需要发送的数据，只要发送哈希值即可。 默克尔树是一种树型数据结构，每个节点值都是其下方节点的哈希值：
@@ -27,15 +32,15 @@ published: 2021-12-30
根哈希是唯一需要存储在链上的部分。 为了证明一个特定值，你需要提供所有与之合并才能获取根的哈希值。 例如，要证明 `C`，你需要提供 `D`、`H(A-B)` 和 `H(E-H)`。
-
+
## 实现 {#implementation}
-[此处提供示例代码](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity)。
+[此处提供了示例代码](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity)。
-### 链下代码 {#off-chain-code}
+### 链下代码 {#offchain-code}
-在这篇文章中，我们使用 JavaScript 进行链下计算。 大多数去中心化应用程序的 JavaScript 中都有链下组件。
+在本文中，我们使用 JavaScript 进行链下计算。 大多数去中心化应用程序的 JavaScript 中都有其链下组件。
#### 创建默克尔根 {#creating-the-merkle-root}
@@ -45,44 +50,48 @@ published: 2021-12-30
const ethers = require("ethers")
```
-[我们使用源自以太币包的哈希函数](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256)。
+[我们使用 ethers 包中的哈希函数](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256)。
```javascript
-// The raw data whose integrity we have to verify. The first two bytes a
-// are a user identifier, and the last two bytes the amount of tokens the
-// user owns at present.
+// 需要我们验证其完整性的原始数据。前两个字节
+// 是用户标识符，后两个字节是该
+// 用户当前拥有的代币数量。
const dataArray = [
0x0bad0010, 0x60a70020, 0xbeef0030, 0xdead0040, 0xca110050, 0x0e660060,
0xface0070, 0xbad00080, 0x060d0091,
]
```
-例如，将每条数据编码为单个 256 位整数，并以非 JSON 的格式存储。 然而，这意味着在提取合约中的数据时，可以大大减少处理工作，从而显著降低了燃料成本。 [你可以在链上读取 JSON 格式的数据](https://github.com/chrisdotn/jsmnSol)，但请尽量避免这么做。
+例如，将每条数据编码为单个 256 位整数，并以非 JSON 的格式存储。 然而，这意味着在提取合约中的数据时，可以大大减少处理工作，从而显著降低了燃料成本。 [你可以在链上读取 JSON](https://github.com/chrisdotn/jsmnSol)，但如果可以避免，最好不要这么做。
```javascript
-// The array of hash values, as BigInts
+// 作为 BigInt 的哈希值数组
const hashArray = dataArray
```
在此例中，我们的数据开始就是 256 位，因此不需要处理。 如果我们使用更复杂的数据结构，如字符串，我们需要确保先取数据的哈希值并获取哈希数组。 请注意，还有一个原因是我们不关心用户是否知道其他用户的信息。 否则，我们将不得不进行散列计算，使用户 1 不知道用户 0 的值，用户 2 不知道用户 3 的值，等等。
```javascript
-// Convert between the string the hash function expects and the
-// BigInt we use everywhere else.
+// 在哈希函数所需的字符串与
+// 我们在其他任何地方使用的 BigInt 之间进行转换。
const hash = (x) =>
BigInt(ethers.utils.keccak256("0x" + x.toString(16).padStart(64, 0)))
```
-以太币哈希函数的预期结果是一个带十六进制数字的 JavaScript 字符串，如 `0x60A7`，并用另一个相同结构的字符串响应。 然而，对于代码的其他部分，使用 `BigInt` 类型更为容易，所以我们将转换为一个十六进制字符串，然后再转回 BigInt。
+ethers 哈希函数需要一个包含十六进制数的 JavaScript 字符串（例如 `0x60A7`），并返回另一个具有相同结构的字符串。 但是，对于代码的其余部分，使用 `BigInt` 会更简单，因此我们将其转换为十六进制字符串，然后再转换回来。
```javascript
-// Symmetrical hash of a pair so we won't care if the order is reversed.
+// 对称哈希一对值，这样我们就不必关心顺序是否颠倒。
const pairHash = (a, b) => hash(hash(a) ^ hash(b))
```
-此函数是对称的（a [xor](https://en.wikipedia.org/wiki/Exclusive_or) b 的哈希值）。 这意味着在检查默克尔证明时，我们不必烦恼是将证明中的值放在计算值之前还是之后。 默克尔证明在链上进行检查，所以链上的步骤越少越好。
+这个函数是对称的（a [xor](https://en.wikipedia.org/wiki/Exclusive_or) b 的哈希）。 这意味着在检查默克尔证明时，我们不必烦恼是将证明中的值放在计算值之前还是之后。 默克尔证明在链上进行检查，所以链上的操作越少越好。
-警告： 密码学没有表面看起来那么容易。 本文的初始版本提供了哈希函数 `hash(a^b)`。 那是一个**糟糕的**想法，因为这意味着如果知道 `a` 和 `b` 的合法值，则可以使用 `b' = a^b^a'` 证明任何所需的 `a'` 值。 使用此函数，就必须计算 `b'`，令 `hash(a') ^ hash(b')` 等于一个已知值（通往根的下一个分支），这要困难得多。
+警告：
+密码学没有表面看起来那么容易。
+本文的初始版本使用了哈希函数 `hash(a^b)`。
+那是一个**糟糕**的想法，因为这意味着如果你知道 `a` 和 `b` 的合法值，就可以使用 `b' = a^b^a'` 来证明任何你想要的 `a'` 值。
+使用这个函数，你必须计算 `b'`，使得 `hash(a') ^ hash(b')` 等于一个已知值（通往根节点的下一个分支），这就困难得多了。
```javascript
// The value to denote that a certain branch is empty, doesn't
@@ -95,11 +104,11 @@ const empty = 0n
```javascript
-// Calculate one level up the tree of a hash array by taking the hash of
-// each pair in sequence
+// 通过按顺序获取每对值的哈希，
+// 计算哈希数组在树中的上一层
const oneLevelUp = (inputArray) => {
var result = []
- var inp = [...inputArray] // To avoid over writing the input // Add an empty value if necessary (we need all the leaves to be // paired)
+ var inp = [...inputArray] // 避免覆盖输入 // 如有必要，添加一个空值（我们需要所有的叶子都 // 配对）
if (inp.length % 2 === 1) inp.push(empty)
@@ -110,13 +119,13 @@ const oneLevelUp = (inputArray) => {
} // oneLevelUp
```
-此函数通过对默克尔树中当前层级的值对进行哈希处理来上升一个层级。 请注意，这不是最高效的实现。我们本来可以避免重复输入，并且只需在循环中适当地加上 `hashEmpty`，但此代码为了提高可读性进行过优化。
+此函数通过对默克尔树中当前层级的值对进行哈希处理来上升一个层级。 请注意，这不是最高效的实现，我们本可以避免复制输入，只需在循环中的适当位置添加 `hashEmpty`，但此代码为可读性进行了优化。
```javascript
const getMerkleRoot = (inputArray) => {
var result
- result = [...inputArray] // Climb up the tree until there is only one value, that is the // root. // // If a layer has an odd number of entries the // code in oneLevelUp adds an empty value, so if we have, for example, // 10 leaves we'll have 5 branches in the second layer, 3 // branches in the third, 2 in the fourth and the root is the fifth
+ result = [...inputArray] // 沿树向上，直到只剩一个值，这个值就是 // 根。 // // 如果某一层有奇数个条目， // oneLevelUp 中的代码会添加一个空值，因此如果我们有（例如） // 10 个叶子，那么第二层将有 5 个分支，第三层 // 有 3 个，第四层有 2 个，根是第五个
while (result.length > 1) result = oneLevelUp(result)
@@ -126,35 +135,35 @@ const getMerkleRoot = (inputArray) => {
要到达根，一直上升到只剩下一个值的层级。
-#### 创建一个默克尔证明 {#creating-a-merkle-proof}
+#### 创建默克尔证明 {#creating-a-merkle-proof}
默克尔证明是与要证明的值一起哈希处理以便返回默克尔根的值。 要证明的值往往来自其他数据，因此这里更愿意单独提供，而不是作为代码的一部分。
```javascript
-// A merkle proof consists of the value of the list of entries to
-// hash with. Because we use a symmetrical hash function, we don't
-// need the item's location to verify the proof, only to create it
+// 默克尔证明包含与之哈希的条目
+// 列表的值。因为我们使用了对称哈希函数，我们不
+// 需要条目的位置来验证证明，只需要用它来创建证明
const getMerkleProof = (inputArray, n) => {
var result = [], currentLayer = [...inputArray], currentN = n
- // Until we reach the top
+ // 直到我们到达顶部
while (currentLayer.length > 1) {
- // No odd length layers
+ // 没有奇数长度的层
if (currentLayer.length % 2)
currentLayer.push(empty)
result.push(currentN % 2
- // If currentN is odd, add with the value before it to the proof
+ // 如果 currentN 是奇数，则将其之前的值添加到证明中
? currentLayer[currentN-1]
- // If it is even, add the value after it
+ // 如果是偶数，则添加其后的值
: currentLayer[currentN+1])
```
-我们对 `(v[0],v[1])`、`(v[2],v[3])` 等进行哈希处理。 因此，对于偶数值，我们需要下一个值，而奇数值则需要上一个值。
+我们对 `(v[0],v[1])`、`(v[2],v[3])` 等进行哈希。 因此，对于偶数值，我们需要下一个值，而奇数值则需要上一个值。
```javascript
- // Move to the next layer up
+ // 移动到上一层
currentN = Math.floor(currentN/2)
currentLayer = oneLevelUp(currentLayer)
} // while currentLayer.length > 1
@@ -163,9 +172,9 @@ const getMerkleProof = (inputArray, n) => {
} // getMerkleProof
```
-### 链上代码 {#on-chain-code}
+### 链上代码 {#onchain-code}
-最后，我们有核查证明的代码。 链上代码用 [Solidity](https://docs.soliditylang.org/en/v0.8.11/) 语言编写。 优化在这里更为重要，因为燃料费相对昂贵。
+最后，我们有核查证明的代码。 链上代码是用 [Solidity](https://docs.soliditylang.org/en/v0.8.11/) 编写的。 优化在这里更为重要，因为燃料费相对昂贵。
```solidity
//SPDX-License-Identifier: Public Domain
@@ -174,7 +183,7 @@ pragma solidity ^0.8.0;
import "hardhat/console.sol";
```
-编写此代码时，我使用的是[安全帽开发环境](https://hardhat.org/)，它使我们在开发过程中可以获得 [Solidity 的控制台输出](https://hardhat.org/tutorial/debugging-with-hardhat-network.html)。
+我使用 [Hardhat 开发环境](https://hardhat.org/) 编写了此代码，该环境允许我们在开发时从 [Solidity 获取控制台输出](https://hardhat.org/tutorial/debugging-with-hardhat-network.html)。
```solidity
@@ -185,15 +194,15 @@ contract MerkleProof {
return merkleRoot;
}
- // Extremely insecure, in production code access to
- // this function MUST BE strictly limited, probably to an
- // owner
+ // 极不安全，在生产代码中，对
+ // 此函数的访问权限必须受到严格限制，可能仅限于
+ // 所有者
function setRoot(uint _merkleRoot) external {
merkleRoot = _merkleRoot;
} // setRoot
```
-为默克尔根设置和获取函数。 在生产系统中，让每个人都更新默克尔根是一个_非常糟糕的主意_。 这里这样做是为了简化示例代码。 **不要在数据完整性非常重要的系统上执行**。
+为默克尔根设置和获取函数。 在生产系统中，允许任何人更新默克尔根是一个_极其糟糕的主意_。 这里这样做是为了简化示例代码。 **不要在数据完整性至关重要的系统上这样做**。
```solidity
function hash(uint _a) internal pure returns(uint) {
@@ -205,12 +214,12 @@ contract MerkleProof {
}
```
-此函数生成一个配对哈希值。 它只是将 `hash` 和 `pairHash` 函数的 JavaScript 代码转变为 Solidity。
+此函数生成一个配对哈希值。 这只是 `hash` 和 `pairHash` 的 JavaScript 代码的 Solidity 翻译版本。
-**注意：**这是又一次对可读性的优化。 根据[函数定义](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm)，也许可以将数据存储为 [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays) 类型值并避免转换。
+\*\*注意：\*\*这是另一个为可读性而优化的例子。 根据[函数定义](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm)，或许可以将数据存储为 [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays) 值，从而避免转换。
```solidity
- // Verify a Merkle proof
+ // 验证默克尔证明
function verifyProof(uint _value, uint[] calldata _proof)
public view returns (bool) {
uint temp = _value;
@@ -226,16 +235,18 @@ contract MerkleProof {
} // MarkleProof
```
-用数学符号表示，默克尔证明的验证看起来像这样：`H(proof_n, H(proof_n-1, H(proof_n-2, ... H(proof_1, H(proof_0, value))...)))`. 此代码实现了默克尔证明。
+用数学符号表示，默克尔证明验证如下所示：`H(proof_n, H(proof_n-1, H(proof_n-2, ...` H(proof_1, H(proof_0, value))...)))`。 此代码实现了默克尔证明。
-## 默克尔证明和卷叠很难混淆 {#merkle-proofs-and-rollups}
+## 默克尔证明与卷叠 {#merkle-proofs-and-rollups}
-默克尔证明对[卷叠](/developers/docs/scaling/#rollups)的作用不大。 原因在于，卷叠将所有交易数据写入一层网络，但在二层网络进行处理。 发送交易的默克尔证明的成本平均达到每个层级 638 个燃料（目前，如果字节不为零，调用数据中一个字节花费 16 个燃料，如果为零，则花费 4 个燃料）。 如果我们的数据包含 1024 个字，默克尔证明需要 10 个层级，或者总共 6380 个燃料。
+默克尔证明不能与[卷叠](/developers/docs/scaling/#rollups)很好地配合使用。 原因在于，卷叠将所有交易数据写入一层网络，但在二层网络进行处理。 发送交易的默克尔证明的成本平均达到每个层级 638 个燃料（目前，如果字节不为零，调用数据中一个字节花费 16 个燃料，如果为零，则花费 4 个燃料）。 如果我们的数据包含 1024 个字，默克尔证明需要 10 个层级，或者总共 6380 个燃料。
-举一个[乐观卷叠](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m)的示例，写入一层网络的燃料成本约为 100 gwei，写入二层网络的成本为 0.001 gwei（这里按正常价格计，成本可能因为网络拥塞而增加）。 所以对于一层网络上 1 个燃料的成本，我们可能需要在二层网络上花费 10 万个燃料的处理费用。 假定我们不用重写存储，这意味着我们可以用一个一层网络燃料的价格将大约五个字写入二层网络的存储中。 对于单个默克尔证明，我们可以将全部 1024 个字写入存储（假定它们可以在链上计算出来，而不是在交易中提供），并且还剩下大部分燃料。
+以 [Optimism](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m) 为例，写入 L1 的燃料成本约为 100 gwei，写入 L2 的燃料成本为 0.001 gwei（这是正常价格，拥堵时可能会上涨）。 所以对于一层网络上 1 个燃料的成本，我们可能需要在二层网络上花费 10 万个燃料的处理费用。 假定我们不用重写存储，这意味着我们可以用一个一层网络燃料的价格将大约五个字写入二层网络的存储中。 对于单个默克尔证明，我们可以将全部 1024 个字写入存储（假设它们一开始就可以在链上计算，而不是在交易中提供），并且仍然有大部分燃料剩余。
-## 总结 {#conclusion}
+## 结论 {#conclusion}
在现实中，你可能永远不会独立实现默克尔树。 有很多广为人知并经过审核的程序库可供使用，一般来说，最好不要自己独立实现加密基元。 但我希望你们现在能够更好地理解默克尔证明，并能够决定何时值得使用。
-请注意，虽然默克尔证明能维持_完整性_，但并不维持_可用性_。 如果数据存储方决定禁止访问，而且你不能构建默克尔树来访问你的资产，那么知道没有人可以拿走你的资产也只能作为一种小小的慰藉而已。 所以默克尔树最好和某种去中心化存储一起使用，例如星际文件系统。
+请注意，虽然默克尔证明可以保持_完整性_，但不能保持_可用性_。 如果数据存储方决定禁止访问，而且你不能构建默克尔树来访问你的资产，那么知道没有人可以拿走你的资产也只能作为一种小小的慰藉而已。 所以默克尔树最好和某种去中心化存储一起使用，例如星际文件系统。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md b/public/content/translations/zh/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
index 7585e1ca55a..64fc1748493 100644
--- a/public/content/translations/zh/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
+++ b/public/content/translations/zh/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
@@ -1,29 +1,27 @@
---
-title: 使用 InfluxDB 和 Grafana 监测 Geth
-description:
+title: "使用 InfluxDB 和 Grafana 监控 Geth"
+description: "使用 InfluxDB 和 Grafana 为你的 Geth 节点设置监控，以跟踪性能并识别问题。"
author: "Mario Havel"
-tags:
- - "客户端"
- - "节点"
+tags: [ "客户端", "节点" ]
skill: intermediate
lang: zh
published: 2021-01-13
---
-本教程将帮助你设置 Geth 节点的监测方法，以便更好地了解其性能并发现潜在问题。
+本教程将帮助你为你的 Geth 节点设置监控，以便更好地了解其性能并发现潜在问题。
## 前提条件 {#prerequisites}
- 你应该已经运行一个 Geth 实例。
- 大部分步骤和示例都针对 linux 环境，基础的终端知识会有所帮助。
-- 请观看这段关于 Geth 指标集的概览视频：[监测以太坊基础设施（作者 Péter Szilágyi）](https://www.youtube.com/watch?v=cOBab8IJMYI)
+- 请观看这段关于 Geth 指标集的概览视频：[监测以太坊基础设施（作者 Péter Szilágyi）](https://www.youtube.com/watch?v=cOBab8IJMYI)。
-## 监测堆栈 {#monitoring-stack}
+## 监控堆栈 {#monitoring-stack}
-以太坊客户端收集大量数据，可以通过时序数据库读取这些数据。 为了便于监测，你可以将数据输入数据可视化软件。 下面提供了多种选项供你选择：
+以太坊客户端收集大量数据，可以通过时序数据库读取这些数据。 为了便于监控，你可以将数据输入数据可视化软件。 有多种可用选项：
-- [Prometheus](https://prometheus.io/)（拉取模式）
-- [InfluxDB](https://www.influxdata.com/get-influxdb/)（推送模式）
+- [Prometheus](https://prometheus.io/)（拉取模型）
+- [InfluxDB](https://www.influxdata.com/get-influxdb/)（推送模型）
- [Telegraf](https://www.influxdata.com/get-influxdb/)
- [Grafana](https://www.grafana.com/)
- [Datadog](https://www.datadoghq.com/)
@@ -35,7 +33,8 @@ published: 2021-01-13
## 设置 InfluxDB {#setting-up-influxdb}
-首先，下载并安装 InfluxDB。 [Influxdata 下载页面](https://portal.influxdata.com/downloads/)提供了多种下载选项。 选择适合你安装环境的下载选项。 你还可以通过[资源库](https://repos.influxdata.com/)安装它。 例如，在基于 Debian 的发行版中：
+首先，我们来下载并安装 InfluxDB。 可以在 [Influxdata 发布页面](https://portal.influxdata.com/downloads/)找到各种下载选项。 选择适合你环境的版本。
+你也可以从[资源库](https://repos.influxdata.com/)安装。 例如，在基于 Debian 的发行版中：
```
curl -tlsv1.3 --proto =https -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add
@@ -48,26 +47,27 @@ sudo systemctl start influxdb
sudo apt install influxdb-client
```
-在成功安装 InfluxDB 后，确保它在后台运行。 默认情况下，可以通过 `localhost:8086` 访问它。 在使用 `influx` 客户端前，你必须创建具有管理员权限的新用户。 该用户将进行高级管理，创建数据库和用户。
+成功安装 InfluxDB 后，请确保它正在后台运行。 默认情况下，可以通过 `localhost:8086` 访问它。
+在使用 `influx` 客户端之前，你必须创建一个拥有管理员权限的新用户。 此用户将用于高级别管理，例如创建数据库和用户。
```
curl -XPOST "http://localhost:8086/query" --data-urlencode "q=CREATE USER username WITH PASSWORD 'password' WITH ALL PRIVILEGES"
```
-现在，你可以用此用户的身份通过 influx 客户端进入 [InfluxDB 命令行](https://docs.influxdata.com/influxdb/v1.8/tools/shell/)。
+现在你可以用此用户通过 influx 客户端进入 [InfluxDB 命令行](https://docs.influxdata.com/influxdb/v1.8/tools/shell/)。
```
influx -username 'username' -password 'password'
```
-你可以通过其命令行直接与 InfluxDB 通信，为 geth 指标创建数据库和用户。
+在其命令行中与 InfluxDB 直接通信，你可以为 geth 指标创建数据库和用户。
```
create database geth
create user geth with password choosepassword
```
-如下验证已创建的条目：
+使用以下命令验证创建的条目：
```
show databases
@@ -80,19 +80,20 @@ show users
exit
```
-InfluxDB 正在运作，将其配置为存储来自 Geth 的指标。
+InfluxDB 正在运行，并已配置为存储来自 Geth 的指标。
## 准备 Geth {#preparing-geth}
-设置好数据库后，我们需要在 Geth 中启用指标收集。 留意 `geth - help` 中的 `METRICS AND STATS OPTIONS`。 此处可以找到多个选项，在此例中，我们希望 Geth 将数据推送到 InfluxDB。 基本设置指定了端点，可以通过它访问 InfluxDB 并进行数据库身份验证。
+设置好数据库后，我们需要在 Geth 中启用指标收集功能。 请注意 `geth --help` 中的 `METRICS AND STATS OPTIONS`。 那里有多个选项，在本例中，我们希望 Geth 将数据推送到 InfluxDB。
+基本设置指定了 InfluxDB 的可访问端点以及数据库的身份验证信息。
```
geth --metrics --metrics.influxdb --metrics.influxdb.endpoint "http://0.0.0.0:8086" --metrics.influxdb.username "geth" --metrics.influxdb.password "chosenpassword"
```
-此标记可以附加到启动客户端的命令或保存到配置文件中。
+这些标志可以附加到启动客户端的命令中，或保存到配置文件中。
-你可以通过在数据库中列出指标来验证 Geth 是否成功推送了数据。 在 InfluxDB 命令行中:
+你可以通过在数据库中列出指标等方式，验证 Geth 是否正在成功推送数据。 在 InfluxDB 命令行中：
```
use geth
@@ -101,7 +102,8 @@ show measurements
## 设置 Grafana {#setting-up-grafana}
-下一步是安装 Grafana，后者通过图形解释数据。 按照 Grafana 文档中针对你安装环境的安装过程操作。 如果不想安装其他版本，确保安装 OSS 版本。 下面是通过资源库安装 发行版本的示例安装步骤：
+下一步是安装 Grafana，它将以图形方式解译数据。 请遵照 Grafana 文档中适用于你的环境的安装流程进行操作。 若无其他特殊需求，请确保安装 OSS 版本。
+使用资源库为 Debian 发行版安装的示例步骤：
```
curl -tlsv1.3 --proto =https -sL https://packages.grafana.com/gpg.key | sudo apt-key add -
@@ -112,36 +114,38 @@ sudo systemctl enable grafana-server
sudo systemctl start grafana-server
```
-在 Grafana 开始运行后，应该能够在 `localhost:3000` 访问它。 使用你喜欢的浏览器访问此路径，然后用默认凭据登录（用户：`admin` 和密码：`admin`）。 当提示时，更改默认密码并保存。
+Grafana 运行后，应该可以通过 `localhost:3000` 访问。
+使用你偏好的浏览器访问此路径，然后使用默认凭据（用户：`admin`，密码：`admin`）登录。 出现提示时，请更改默认密码并保存。
-你将被重定向到 Grafana 主页。 首先，设置你的源数据。 点击左边栏中的配置图标并选择“Data sources”。
+你将被重定向到 Grafana 主页。 首先，设置你的数据源。 点击左侧栏的配置图标，然后选择“Data sources”。
-现在尚未创建任何数据源，点击“Add data source”定义一个数据源。
+目前还没有创建任何数据源，点击“添加数据源”来定义一个。
-在本次设置中，请选择“InfluxDB”并继续操作。
+对于此设置，选择“InfluxDB”并继续。
-如果你在同台一机器上运行工具，数据源配置就相当简单。 你需要设置 InfluxDB 地址和详细信息，以便访问数据库。 请参考下图。
+如果你在同一台机器上运行这些工具，数据源配置会非常简单。 你需要设置 InfluxDB 地址和用于访问数据库的详细信息。 请参考下图。
-如果所有操作都已完成并且 InfluxDB 可以访问，请点击“Save and test”，等待确认信息弹出。
+如果一切都已完成且 InfluxDB 可访问，请点击“保存并测试”，然后等待确认信息弹出。
-现在 Grafana 设置为读取 InfluxDB 中的数据。 此时，你需要创建一个解释和显示数据的仪表板。 仪表板属性是在 JSON 文件中编码的，可让任何人创建并轻松导入。 在左侧栏上，点击“Create and Import”。
+Grafana 现已设置为从 InfluxDB 读取数据。 现在，你需要创建一个仪表板来解译和显示数据。 仪表板属性在 JSON 文件中编码，任何人都可以创建并轻松导入。 在左侧栏上，点击“创建和导入”。
-要创建 Geth 监测仪表板，复制[此仪表板](https://grafana.com/grafana/dashboards/13877/)的 ID 并粘贴到 Grafana 的“导入页面”中。 保存仪表板后，其外观应该如下所示：
+对于 Geth 监控仪表板，请复制[此仪表板](https://grafana.com/grafana/dashboards/13877/)的 ID，并将其粘贴到 Grafana 的“导入页面”中。 保存仪表板后，它应如下所示：
-你可以修改你的仪表板。 每个面板都可以编辑、移动、删除或添加。 你可以更改你的配置。 一切由你决定！ 要了解有关仪表板工作原理的更多信息，请参阅 [Grafana 文档](https://grafana.com/docs/grafana/latest/dashboards/)。 你也可能对[警报](https://grafana.com/docs/grafana/latest/alerting/)感兴趣。 这可以让你设置在指标达到特定值时的提醒通知。 支持各种交流渠道。
+你可以修改你的仪表板。 每个面板都可以编辑、移动、移除或添加。 你可以更改你的配置。 一切由你决定！ 要详细了解仪表板的工作原理，请参阅 [Grafana 的文档](https://grafana.com/docs/grafana/latest/dashboards/)。
+你可能还对[警报](https://grafana.com/docs/grafana/latest/alerting/)感兴趣。 这使你可以设置当指标达到特定值时的警报通知。 支持多种通信渠道。
diff --git a/public/content/translations/zh/developers/tutorials/nft-minter/index.md b/public/content/translations/zh/developers/tutorials/nft-minter/index.md
index 19b68ed3c1b..74116a10787 100644
--- a/public/content/translations/zh/developers/tutorials/nft-minter/index.md
+++ b/public/content/translations/zh/developers/tutorials/nft-minter/index.md
@@ -1,17 +1,16 @@
---
-title: 非同质化代币铸币机教程
-description: 在本教程中，你将构建一个非同质化代币铸币机，并学习如何通过使用 MetaMask 和 Web3 工具将智能合约连接到 React 前端来创建全栈去中心化应用程序。
+title: "非同质化代币铸币机教程"
+description: "在本教程中，你将构建一个非同质化代币铸币机，并学习如何通过使用 MetaMask 和 Web3 工具将智能合约连接到 React 前端来创建全栈去中心化应用程序。"
author: "smudgil"
tags:
- - "solidity"
- - "非同质化代币"
- - "铸币机"
- - "Alchemy"
- - "智能合约"
- - "前端"
- - "用户界面"
- - "钱包"
- - "Pinata"
+ [
+ "Solidity",
+ "非同质化代币",
+ "Alchemy",
+ "智能合同",
+ "前端",
+ "Pinata"
+ ]
skill: intermediate
lang: zh
published: 2021-10-06
@@ -19,88 +18,88 @@ published: 2021-10-06
对于具有 Web2 背景的开发者来说，最大的挑战之一是弄清楚如何将智能合约连接到前端项目并与之交互。
-通过构建非同质化代币铸币机 — 一个可以用来输入数字资产链接、名称与描述的简单用户界面 — 您将学会如何：
+通过构建非同质化代币铸币机 — 一个可以用来输入数字资产链接、名称与描述的简单用户界面 — 你将学会如何：
-- 通过您的前端项目连接到 MetaMask
+- 通过你的前端项目连接到 MetaMask
- 在前端调用智能合约的方法
- 使用 MetaMask 签署交易
-在本教程中，我们将使用 [React](https://reactjs.org/) 作为前端框架。 由于本教程主要侧重于 Web3 开发，我们不会花太多时间来细讲 React 基础知识。 相反，我们将专注于为项目添加功能。
+在本教程中，我们将使用 [React](https://react.dev/) 作为我们的前端框架。 由于本教程主要侧重于 Web3 开发，我们不会花太多时间来细讲 React 基础知识。 相反，我们将专注于为项目添加功能。
-作为先决条件，您应该对 React 有入门水平的认识 — 了解组件、属性、useState/useEffect 和基本函数调用是如何工作的。 如果您以前从未听过这些术语，您可能想参阅这个 [React 入门教程](https://reactjs.org/tutorial/tutorial.html)。 对于视觉型学习者，我们强烈推荐 Net Ninja 推出的[现代 React 开发完整教程](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d)精彩视频系列。
+作为先决条件，你应该对 React 有入门水平的认识 — 了解组件、属性、useState/useEffect 和基本函数调用是如何工作的。 如果你以前从未听说过这些术语，不妨看看这篇 [React 入门教程](https://react.dev/learn/tutorial-tic-tac-toe)。 对于视觉型学习者，我们强烈推荐 Net Ninja 推出的这个优秀的[现代 React 完整教程](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d)视频系列。
-如果您还没有 Alchemy 帐户，您肯定需要一个来完成本教程以及在区块链上完成任何构建。 点击[此处](https://alchemy.com/)注册一个免费帐户。
+如果你还没有 Alchemy 帐户，你肯定需要一个来完成本教程以及在区块链上完成任何构建。 请[在此](https://alchemy.com/)注册一个免费帐户。
事不宜迟，让我们开始吧！
-## 制作非同质化代币 101 {#making-nfts-101}
+## NFT 制作入门 {#making-nfts-101}
在我们开始考虑任何代码之前，了解非同质化代币的工作原理非常重要。 它包括两个步骤：
-### 在以太坊区块链上发布非同质化代币智能合约 {#publish-nft}
+### 在以太坊区块链上发布 NFT 智能合约 {#publish-nft}
两种非同质化代币智能合约标准的最大区别在于，ERC-1155 是多代币标准且包含批量功能，而 ERC-721 是单代币标准，因此仅支持一次转账一个代币。
### 调用铸币函数 {#minting-function}
-通常，此铸币函数需要您传入两个变量作为参数，第一个是 `recipient`，它指定将要接收您的新铸造非同质化代币的地址，第二个是非同质化代币的 `tokenURI`，它是一个字符串，解析为描述非同质化代币元数据的 JSON 文档。
+通常，这个铸币函数需要你传入两个变量作为参数：第一个是 `recipient`，它指定将接收你新铸造的 NFT 的地址；第二个是 NFT 的 `tokenURI`，它是一个字符串，可解析为描述此 NFT 元数据的 JSON 文档。
-非同质化代币的元数据是其核心所在，使它拥有多种属性，例如名称、描述、图像（或不同的数字资产）及其他特性。 这是 [tokenURI 示例](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2)，其中包含非同质化代币的元数据。
+非同质化代币的元数据是其核心所在，使它拥有多种属性，例如名称、描述、图像（或不同的数字资产）及其他特性。 这是一个 `tokenURI` 的[示例](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2)，其中包含某个 NFT 的元数据。
在本教程中，我们将重点关注第 2 部分，使用我们的 React UI 调用现有的非同质化代币智能合约铸币函数。
-在本教程中，我们将要调用的 ERC-721 非同质化代币智能合约的[链接在此处](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE)。 如果您想了解我们如何创建该合约，强烈建议您参阅我们另一个教程[“如何创建非同质化代币”](https://docs.alchemyapi.io/alchemy/tutorials/how-to-create-an-nft)。
+本教程中我们将调用的 ERC-721 NFT 智能合约的[链接在此](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE)。 如果你想了解我们是如何制作它的，我们强烈建议你查看我们的另一篇教程：[“如何创建 NFT”](https://www.alchemy.com/docs/how-to-create-an-nft)。
太好了，现在我们已经了解了非同质化代币的工作原理，我们来克隆我们的启动文件！
## 克隆启动文件 {#clone-the-starter-files}
-首先，浏览到 [nft-minter-tutorial GitHub 资源库](https://github.com/alchemyplatform/nft-minter-tutorial)，获取此项目的启动文件。 将此资源库克隆到您的本地环境中。
+首先，访问 [nft-minter-tutorial GitHub 仓库](https://github.com/alchemyplatform/nft-minter-tutorial)以获取本项目的启动文件。 将此仓库克隆到你的本地环境中。
-打开这个克隆的 `nft-minter-tutorial` 资源库后，您会注意到它包含两个文件夹：`minter-starter-files` 和 `nft-minter`。
+打开这个克隆的 `nft-minter-tutorial` 仓库后，你会发现它包含两个文件夹：`minter-starter-files` 和 `nft-minter`。
-- `minter-starter-files` 包含此项目的启动文件（基本上是 React UI）。 在本教程中，**我们将在此目录中操作**，您将学习如何通过将其连接到您的以太坊钱包和非同质化代币智能合约来实现此用户界面。
-- `nft-minter` 包含已完成的完整教程，**如果您遇到困难**，可以作为**参考**。
+- `minter-starter-files` 包含此项目的启动文件（主要是 React UI）。 在本教程中，**我们将在该目录中工作**，你将学习如何通过将其连接到你的以太坊钱包和 NFT 智能合约来激活此 UI。
+- `nft-minter` 包含完整的教程，**如果你遇到困难**，可以作为**参考**。
-接下来，在代码编辑器中打开 `minter-starter-files` 副本，然后浏览到 `src` 文件夹。
+接下来，在你的代码编辑器中打开 `minter-starter-files` 的副本，然后导航到 `src` 文件夹。
-我们编写的所有代码都将保存在 `src` 文件夹下。 我们将编辑 `Minter.js` 组件并编写额外的 javascript 文件来为我们的项目提供 Web3 功能。
+我们将编写的所有代码都将存放在 `src` 文件夹下。 我们将编辑 `Minter.js` 组件并编写额外的 javascript 文件，为我们的项目提供 Web3 功能。
## 第 2 步：查看我们的启动文件 {#step-2-check-out-our-starter-files}
在我们开始编码之前，必须检查起始文件中已经为我们提供了什么。
-### 让您的 react 项目运行起来 {#get-your-react-project-running}
+### 运行你的 React 项目 {#get-your-react-project-running}
首先在浏览器中运行 React 项目。 React 的美妙之处在于，一旦我们的项目在浏览器中运行，保存的任何更改都会在浏览器中实时更新。
-要让项目运行，浏览到 `minter-starter-files` 文件夹的根目录，然后在终端运行 `npm install` 以安装项目的依赖项：
+要运行项目，请导航到 `minter-starter-files` 文件夹的根目录，然后在终端中运行 `npm install` 来安装项目的依赖项：
```bash
cd minter-starter-files
npm install
```
-依赖项安装完成后，在终端运行 `npm start`：
+安装完成后，在终端中运行 `npm start`：
```bash
npm start
```
-运行后，http://localhost:3000/ 应该在浏览器中打开，您可以在其中看到项目前端。 其中应该包括 3 个字段：一个用于输入非同质化代币资产的链接、一个用于输入非同质化代币的名称，一个提供描述。
+运行后，http://localhost:3000/ 应该在浏览器中打开，你可以在其中看到项目前端。 其中应该包括 3 个字段：一个用于输入非同质化代币资产的链接、一个用于输入非同质化代币的名称，一个提供描述。
-如果您尝试点击“Connect Wallet”或“Mint NFT”按钮，您会发现它们不起作用 — 那是因为我们仍然需要对它们的功能进行编程！ :\)
+如果你尝试点击“Connect Wallet”或“Mint NFT”按钮，你会发现它们不起作用 — 那是因为我们仍然需要对它们的功能进行编程！ :\)
-### Minter.js 组件 {#minter-js}
+### `Minter.js` 组件 {#minter-js}
-**注：**确保您位于 `minter-starter-files` 文件夹而不是 `nft-minter` 文件夹！
+\*\*注意：\*\*请确保你位于 `minter-starter-files` 文件夹，而不是 `nft-minter` 文件夹！
-我们在编辑器中返回 `src` 文件夹并打开 `Minter.js` 文件。 理解该文件中的所有内容非常重要，因为它是我们将要处理的主要 React 组件。
+让我们在编辑器中返回 `src` 文件夹，并打开 `Minter.js` 文件。 理解该文件中的所有内容非常重要，因为它是我们将要处理的主要 React 组件。
在该文件的顶部，有我们将在特定事件后更新的状态变量。
```javascript
-//State variables
+//状态变量
const [walletAddress, setWallet] = useState("")
const [status, setStatus] = useState("")
const [name, setName] = useState("")
@@ -108,135 +107,135 @@ const [description, setDescription] = useState("")
const [url, setURL] = useState("")
```
-从未听过 React 状态变量或状态挂钩？ 参阅[这些](https://reactjs.org/docs/hooks-state.html)文档。
+从未听过 React 状态变量或状态挂钩？ 查看[这些](https://legacy.reactjs.org/docs/hooks-state.html)文档。
以下是每个变量的含义：
-- `walletAddress` — 存储用户钱包地址的字符串
-- `status` — 包含要在用户界面底部显示的消息的字符串
-- `name` — 存储非同质化代币名称的字符串
-- `description` — 存储非同质化代币描述的字符串
-- `url` — 字符串，表示指向非同质化代币数字资产的链接
+- `walletAddress` - 存储用户钱包地址的字符串
+- `status` - 包含要显示在 UI 底部的消息的字符串
+- `name` - 存储 NFT 名称的字符串
+- `description` - 存储 NFT 描述的字符串
+- `url` - 指向 NFT 数字资产链接的字符串
-在状态变量之后，您会看到三个未实现的函数：`useEffect`、`connectWalletPressed` 和 `onMintPressed`。 您会注意到所有这些函数都是 `async` 函数，这是因为我们将在其中进行异步 API 调用！ 它们的名称与功能同名：
+在状态变量之后，你会看到三个未实现的函数：`useEffect`、`connectWalletPressed` 和 `onMintPressed`。 你会注意到所有这些函数都是 `async` 的，这是因为我们将在其中进行异步 API 调用！ 它们的名称与功能同名：
```javascript
useEffect(async () => {
- //TODO: implement
+ //待办：实现
}, [])
const connectWalletPressed = async () => {
- //TODO: implement
+ //待办：实现
}
const onMintPressed = async () => {
- //TODO: implement
+ //待办：实现
}
```
-- [`useEffect`](https://reactjs.org/docs/hooks-effect.html) — 这是一个 React 挂钩，在渲染组件后调用。 因为向它传入了一个空的数组 `[]` 属性（见第 3 行），只会在组件的*第一次*渲染时调用它。 在这里，我们将调用钱包监听器和另一个钱包函数，来更新我们的用户界面以指示钱包是否已经连接。
-- `connectWalletPressed` - 将调用此函数，将用户的 MetaMask 钱包连接到我们的去中心化应用程序。
-- `onMintPressed` — 将调用此函数来铸造用户的非同质化代币。
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) - 这是一个 React 钩子，在组件渲染后调用。 因为它传入了一个空数组 `[]` 属性（见第 3 行），所以它只会在组件_首次_渲染时被调用。 在这里，我们将调用钱包监听器和另一个钱包函数，来更新我们的用户界面以指示钱包是否已经连接。
+- `connectWalletPressed` - 此函数将被调用，以将用户的 MetaMask 钱包连接到我们的去中心化应用程序。
+- `onMintPressed` - 此函数将被调用，以铸币用户的 NFT。
-在接近该文件末尾处，我们获得我们组件的用户界面。 如果您仔细查看此代码，您会注意到，当相应文本字段的输入发生变化时，我们更新了 `url`、`name` 和 `description` 状态变量。
+在接近该文件末尾处，我们获得我们组件的用户界面。 如果你仔细查看此代码，你会注意到当相应文本字段中的输入发生变化时，我们会更新 `url`、`name` 和 `description` 状态变量。
-您还将看到，在分别单击 ID 为 `mintButton` 和 `walletButton` 的按钮时，会调用 `connectWalletPressed` 和 `onMintPressed`。
+你还会看到，当分别点击 ID 为 `mintButton` 和 `walletButton` 的按钮时，会调用 `connectWalletPressed` 和 `onMintPressed`。
```javascript
-//the UI of our component
+//我们组件的 UI
return (
- 🧙♂️ Alchemy NFT Minter
+ 🧙♂️ Alchemy NFT 铸币器
- Simply add your asset's link, name, and description, then press "Mint."
+ 只需添加你的资产链接、名称和描述，然后按“铸币”。
{status}
-
+
)
```
最后，我们来看看这个铸币机组件是在哪里添加的。
-如果您打开 `App.js` 文件，将会看到我们的铸币机组件是在第 7 行添加的。此文件是 React 中的主要组件，作为所有其他组件的容器。
+如果你转到 `App.js` 文件（它是 React 中的主组件，充当所有其他组件的容器），你会看到我们的 Minter 组件在第 7 行被注入。
-**在本教程中，我们将只编辑 `Minter.js file` 并在我们的 `src` 文件夹中添加文件。**
+**在本教程中，我们将只编辑 `Minter.js file` 文件，并在我们的 `src` 文件夹中添加文件。**
我们已经了解了我们正在进行的操作，现在我们来设置我们的以太坊钱包！
-## 设置您的以太坊钱包 {#set-up-your-ethereum-wallet}
+## 设置你的以太坊钱包 {#set-up-your-ethereum-wallet}
为了让用户能够与你的智能合约交互，他们需要将其以太坊钱包连接到你的去中心化应用程序。
### 下载 MetaMask {#download-metamask}
-在本教程中，我们将使用 MetaMask，它是浏览器中的虚拟钱包，用来管理您的以太坊账户地址。 如果您想了解更多关于以太坊交易如何运作的信息，请参阅[此页面](/developers/docs/transactions/)。
+在本教程中，我们将使用 MetaMask，它是浏览器中的虚拟钱包，用来管理你的以太坊帐户地址。 如果你想进一步了解以太坊上的交易如何运作，请查看[此页面](/developers/docs/transactions/)。
-您可以点击[此处](https://metamask.io/download)免费下载并创建一个 MetaMask 账户。 在创建账户时，或者如果您已经有一个账户，确保切换到右上角的“Ropsten 测试网络”\（这样我们就不会交易真正的钱币\）。
+你可以[在此处](https://metamask.io/download)免费下载和创建 MetaMask 帐户。 在创建帐户时，或者如果你已经有一个帐户，确保切换到右上角的“Ropsten 测试网络”\（这样我们就不会交易真正的钱币\）。
-### 通过水龙头中添加以太币 {#add-ether-from-faucet}
+### 从水龙头获取以太币 {#add-ether-from-faucet}
-为了铸造我们的非同质化代币（或在以太坊区块链上签署任何交易），我们需要一些虚拟以太币。 要获取以太币，您可以转到 [Ropsten 水龙头](https://faucet.ropsten.be/)并输入您的 Ropsten 帐户地址，然后点击“Send Ropsten Eth”。 您应该会很快在您的 MetaMask 帐户中看到以太币！
+为了铸造我们的非同质化代币（或在以太坊区块链上签署任何交易），我们需要一些虚拟以太币。 要获取 Eth，你可以前往 [Ropsten 水龙头](https://faucet.ropsten.be/) 并输入你的 Ropsten 帐户地址，然后点击“Send Ropsten Eth”。 你应该会很快在你的 MetaMask 帐户中看到以太币！
-### 检查您的余额 {#check-your-balance}
+### 检查你的余额 {#check-your-balance}
-为了核查我们账户中有余额，我们使用 [Alchemy composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D)发出 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入您的 MetaMask 帐户地址并点击“Send Request”后，您应该会看到这样的响应：
+为了仔细检查我们的余额，让我们使用 [Alchemy 的 composer 工具](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) 发出一个 [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) 请求。 这将返回我们钱包中的以太币数量。 输入你的 MetaMask 帐户地址并点击“Send Request”后，你应该会看到这样的响应：
```text
{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
```
-**注意：**结果以 wei 为单位，而非 ETH。 Wei 是以太币的最小计量单位。 从 wei 到 eth 的转换是：1 eth = 10¹⁸ wei。 因此，如果我们将 0xde0b6b3a7640000 转换为十进制，我们会得到 1\*10¹⁸，它等于 1 eth。
+\*\*注意：\*\*此结果以 wei 为单位，而不是 eth。 Wei 是以太币的最小计量单位。 从 wei 到 eth 的转换是：1 eth = 10¹⁸ wei。 因此，如果我们将 0xde0b6b3a7640000 转换为十进制，我们会得到 1\*10¹⁸，它等于 1 eth。
哦！ 我们的虚拟以太币都在那里了！
REACT_APP_PINATA_SECRET =
```
-保存该文件，然后您就可以开始编写函数将您的 JSON 元数据上传到星际文件系统！
+保存该文件，然后你就可以开始编写函数将你的 JSON 元数据上传到星际文件系统！
### 实现 pinJSONToIPFS {#pin-json-to-ipfs}
-对我们来说幸运的是，Pinata 提供了一个[专门用于将 JSON 数据上传到星际文件系统的应用程序接口](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json)和一个方便的使用 axios 示例的 JavaScript，我们做一些轻微修改后就可以使用它。
+幸运的是，Pinata 有一个[专门用于将 JSON 数据上传到 IPFS 的 API](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json)，以及一个方便的、带有 axios 示例的 JavaScript，我们可以稍作修改后加以使用。
-在您的 `utils` 文件夹中，我们创建另一个名为 `pinata.js` 的文件，然后从 .env 文件中导入我们的 Pinata 私钥和密钥，如下所示：
+在你的 `utils` 文件夹中，我们创建另一个名为 `pinata.js` 的文件，然后从 .env 文件中导入我们的 Pinata 私钥和密钥，如下所示：
```javascript
require("dotenv").config()
@@ -531,7 +528,7 @@ const key = process.env.REACT_APP_PINATA_KEY
const secret = process.env.REACT_APP_PINATA_SECRET
```
-接下来，将下面的代码粘贴到您的 `pinata.js` 文件中。 别担心，我们将详细讲解每一行的含义！
+接下来，将下面的代码粘贴到你的 `pinata.js` 文件中。 别担心，我们将详细讲解每一行的含义！
```javascript
require("dotenv").config()
@@ -542,7 +539,7 @@ const axios = require("axios")
export const pinJSONToIPFS = async (JSONBody) => {
const url = `https://api.pinata.cloud/pinning/pinJSONToIPFS`
- //making axios POST request to Pinata ⬇️
+ //向 Pinata 发出 axios POST 请求 ⬇️
return axios
.post(url, JSONBody, {
headers: {
@@ -571,40 +568,40 @@ export const pinJSONToIPFS = async (JSONBody) => {
首先，它导入 [axios](https://www.npmjs.com/package/axios)，axios 是一个基于 Promise 的超文本传输协议客户端，可用于浏览器和 node.js，我们将使用它创建一个发送到 Pinata 的请求。
-然后，我们使用异步函数 `pinJSONToIPFS`，它以 `JSONBody` 作为输入参数，并在其报头中使用 Pinata 应用程序接口密钥和私钥，这些都是为了向其 `pinJSONToIPFS` 应用程序接口发出 POST 请求。
+然后，我们使用异步函数 `pinJSONToIPFS`，它以 `JSONBody` 作为输入参数，并在其报头中使用 Pinata api 密钥和私钥，这些都是为了向其 `pinJSONToIPFS` API 发出 POST 请求。
- 如果此 POST 请求成功，我们的函数返回一个 `success` 布尔值为 true 的 JSON 对象以及固定我们元数据的 `pinataUrl`。 我们将使用返回的 `pinataUrl` 作为我们智能合约的 mint 函数的 `tokenURI` 输入。
- 如果此 post 请求失败，我们的函数返回一个 `success` 布尔值为 false 的 JSON 对象和一个指示我们错误的 `message` 字符串。
-与 `connectWallet` 函数返回类型一样，会返回 JSON 对象，因此我们可以使用它们的参数更新状态变量和用户界面。
+与 `connectWallet` 函数返回类型一样，会返回 JSON 对象，因此我们可以使用它们的参数更新状态变量和 UI。
-## 加载您的智能合约 {#load-your-smart-contract}
+## 加载你的智能合约 {#load-your-smart-contract}
-我们有办法通过 `pinJSONToIPFS` 函数将非同质化代币元数据上传到星际文件系统，现在我们需要一种办法来加载我们智能合约的实例，以便我们可以调用其 `mintNFT ` 函数。
+我们有办法通过 `pinJSONToIPFS` 函数将 NFT 元数据上传到 IPFS，现在我们需要一种办法来加载我们智能合约的实例，以便我们可以调用其 `mintNFT` 函数。
-正如我们之前提到的，在本教程中，我们将使用[这个现有的非同质化代币智能合约](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE)；但是，如果您想了解我们如何创建或者想自己创建一个，我们强烈建议您参阅我们的另一个教程[“如何创建非同质化代币。”](https://docs.alchemyapi.io/alchemy/tutorials/how-to-create-an-nft)。
+正如我们之前提到的，在本教程中，我们将使用[这个现有的 NFT 智能合约](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE)；但是，如果你想了解我们如何创建或者想自己创建一个，我们强烈建议你参阅我们的另一个教程[“如何创建 NFT”](https://www.alchemy.com/docs/how-to-create-an-nft)。
-### 智能合约应用程序二进制接口 {#contract-abi}
+### 合约 ABI {#contract-abi}
-如果您仔细研究我们的文件，您会注意到我们的 `src` 目录中有一个 `contract-abi.json` 文件。 在指定合约将要调用的函数以及确保函数以您期望的格式返回数据时，应用程序二进制接口必不可少。
+如果你仔细研究我们的文件，你会注意到我们的 `src` 目录中有一个 `contract-abi.json` 文件。 在指定合约将要调用的函数以及确保函数以你期望的格式返回数据时，应用程序二进制接口必不可少。
我们还需要一个 Alchemy 应用程序接口密钥和 Alchemy Web3 应用程序接口，用来连接到以太坊区块链并加载我们的智能合约。
-### 创建您的 Alchemy API 密钥 {#create-alchemy-api}
+### 创建你的 Alchemy API 密钥 {#create-alchemy-api}
-如果您还没有 Alchemy 帐户，请[在此处免费注册。](https://alchemy.com/?a=eth-org-nft-minter)
+如果你还没有 Alchemy 帐户，[请在此处免费注册。](https://alchemy.com/?a=eth-org-nft-minter)
-创建 Alchemy 帐户后，您可以通过创建应用程序来生成应用程序接口密钥。 我们可以用它向 Ropsten 测试网发出请求。
+创建 Alchemy 帐户后，你可以通过创建应用程序来生成应用程序接口密钥。 我们可以用它向 Ropsten 测试网发出请求。
-通过将鼠标悬停在导航栏中的“Apps”上方并点击“Create App”，导航到您的 Alchemy 仪表板中的“Create App”页面。
+通过将鼠标悬停在导航栏中的“Apps”上方并点击“Create App”，导航到你的 Alchemy 仪表板中的“Create App”页面。
-给您的应用程序命名，我们选择“My First NFT!”（我的第一个非同质化代币！），提供简短描述，对于您的应用程序簿记环境选择“Staging”，对于网络选择“Ropsten”。
+给你的应用程序命名，我们选择“My First NFT!”（我的第一个非同质化代币！），提供简短描述，对于你的应用程序簿记环境选择“Staging”，对于网络选择“Ropsten”。
-点击“Create app”，完成！ 您的应用程序应该就会出现在下面的表格中。
+点击“Create app”，完成！ 你的应用程序应该就会出现在下面的表格中。
太棒了，我们已经创建了我们的 HTTP Alchemy 应用程序接口网址，现在请将其复制到剪贴板......
-…...然后让我们将它添加到我们的 `.env` 文件中。 总之，您的 .env 文件应如下所示：
+…然后让我们将它添加到我们的 `.env` 文件中。 总之，你的 .env 文件应如下所示：
```text
REACT_APP_PINATA_KEY =
@@ -612,18 +609,18 @@ REACT_APP_PINATA_SECRET =
REACT_APP_ALCHEMY_KEY = https://eth-ropsten.alchemyapi.io/v2/
```
-既然我们已经有合约应用程序二进制接口和 Alchemy 应用程序接口密钥了，现在我们可以使用 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 加载我们的智能合约。
+既然我们已经有合约 ABI 和 Alchemy API 密钥了，现在我们可以使用 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 加载我们的智能合约。
-### 设置您的 Alchemy Web3 端点和合约 {#setup-alchemy-endpoint}
+### 设置你的 Alchemy Web3 端点和合约 {#setup-alchemy-endpoint}
-首先，如果您还没有 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3)，您需要通过在终端导航到主目录 `nft-minter-tutorial` 来安装它：
+首先，如果你还没有 [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3)，你需要通过在终端导航到主目录 `nft-minter-tutorial` 来安装它：
```text
cd ..
npm install @alch/alchemy-web3
```
-接下来，我们返回 `interact.js` 文件。 在该文件顶部添加以下代码，以便从您的 .env 文件中导入 Alchemy 密钥并设置您的 Alchemy Web3 端点：
+接下来，我们返回 `interact.js` 文件。 在该文件顶部添加以下代码，以便从你的 .env 文件中导入 Alchemy 密钥并设置你的 Alchemy Web3 端点：
```javascript
require("dotenv").config()
@@ -632,7 +629,7 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(alchemyKey)
```
-[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 是 [Web3.js](https://docs.web3js.org/) 的包装类，提供增强的应用程序接口方法和其他重要优势，让 Web3 开发者的工作更轻松。 它设计成只需经过最少的配置即可使用，因此您可以直接在您的应用程序中开始使用它！
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) 是 [Web3.js](https://docs.web3js.org/) 的包装器，提供增强的 API 方法和其他重要优势，让 Web3 开发者的工作更轻松。 它设计成只需经过最少的配置即可使用，因此你可以直接在你的应用程序中开始使用它！
接下来，我们将合约应用程序二进制接口和合约地址添加到我们的文件中。
@@ -650,7 +647,7 @@ const contractAddress = "0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE"
## 实现 mintNFT 函数 {#implement-the-mintnft-function}
-在 `interact.js` 文件中，我们定义的函数 `mintNFT`，它将用相同的名称铸造非同质化代币。
+在 `interact.js` 文件中，我们定义的函数 `mintNFT`，它将用相同的名称铸造 NFT。
因为我们将进行大量异步调用\（调用 Pinata 将我们的元数据固定到星际文件系统，调用 Alchemy Web3 加载我们的智能合约，并且调用 MetaMask 签署我们的交易\），我们的函数也将是异步的。
@@ -666,21 +663,21 @@ export const mintNFT = async (url, name, description) => {}
```javascript
export const mintNFT = async (url, name, description) => {
- //error handling
+ //错误处理
if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
return {
success: false,
- status: "❗Please make sure all fields are completed before minting.",
+ status: "❗请在铸币前确保所有字段都已填写完毕。",
}
}
}
```
-本质上，如果有任何输入参数是空字符串，我们返回一个 JSON 对象，其中 `success` 布尔值为 false，并且 `status` 字符串指示我们用户界面中的所有字段必须完整。
+本质上，如果有任何输入参数是空字符串，我们返回一个 JSON 对象，其中 `success` 布尔值为 false，并且 `status` 字符串指示我们 UI 中的所有字段必须完整。
-### 将元数据上传到星际文件系统 {#upload-metadata-to-ipfs}
+### 将元数据上传到 IPFS {#upload-metadata-to-ipfs}
-在知道我们的元数据格式正确后，下一步是将其包装到 JSON 对象中，并通过我们编写的 `pinJSONToIPFS` 将其上传到星际文件系统！
+在知道我们的元数据格式正确后，下一步是将其包装到 JSON 对象中，并通过我们编写的 `pinJSONToIPFS` 将其上传到 IPFS！
为此，我们首先需要将 `pinJSONToIPFS` 函数导入到 `interact.js` 文件中。 在 `interact.js` 文件最顶部，我们添加：
@@ -694,26 +691,26 @@ import { pinJSONToIPFS } from "./pinata.js"
```javascript
export const mintNFT = async (url, name, description) => {
- //error handling
+ //错误处理
if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
return {
success: false,
- status: "❗Please make sure all fields are completed before minting.",
+ status: "❗请在铸币前确保所有字段都已填写完毕。",
}
}
- //make metadata
+ //创建元数据
const metadata = new Object()
metadata.name = name
metadata.image = url
metadata.description = description
- //make pinata call
+ //发出 pinata 请求
const pinataResponse = await pinJSONToIPFS(metadata)
if (!pinataResponse.success) {
return {
success: false,
- status: "😢 Something went wrong while uploading your tokenURI.",
+ status: "😢 上传你的 tokenURI 时出错了。",
}
}
const tokenURI = pinataResponse.pinataUrl
@@ -733,16 +730,16 @@ window.contract = await new web3.eth.Contract(contractABI, contractAddress)
最后，在 `mintNFT` 函数中添加我们的以太坊交易：
```javascript
-//set up your Ethereum transaction
+//设置你的以太坊交易
const transactionParameters = {
- to: contractAddress, // Required except during contract publications.
- from: window.ethereum.selectedAddress, // must match user's active address.
+ to: contractAddress, // 合约发布期间外为必填项。
+ from: window.ethereum.selectedAddress, // 必须与用户活动地址匹配。
data: window.contract.methods
.mintNFT(window.ethereum.selectedAddress, tokenURI)
- .encodeABI(), //make call to NFT smart contract
+ .encodeABI(), //调用 NFT 智能合约
}
-//sign the transaction via MetaMask
+//通过 MetaMask 签署交易
try {
const txHash = await window.ethereum.request({
method: "eth_sendTransaction",
@@ -751,24 +748,24 @@ try {
return {
success: true,
status:
- "✅ Check out your transaction on Etherscan: https://ropsten.etherscan.io/tx/" +
+ "✅ 在 Etherscan 上查看你的交易：https://ropsten.etherscan.io/tx/" +
txHash,
}
} catch (error) {
return {
success: false,
- status: "😥 Something went wrong: " + error.message,
+ status: "😥 出错了：" + error.message,
}
}
```
-如果您已经熟悉以太坊交易，您会注意到其结构与您以前看到的非常相似。
+如果你已经熟悉以太坊交易，你会注意到其结构与你以前看到的非常相似。
- 首先，我们设置交易参数。
- - `to` 指定接收者地址\（我们的智能合约\）
- - `from` 指定交易的签名者\（用户连接到 MetaMask 的地址：`window.ethereum.selectedAddress`\）
- - `data` 包含对智能合约 `mintNFT` 方法的调用，该方法接收 `tokenURI` 和用户的钱包地址 `window.ethereum.selectedAddress ` 作为输入
-- 然后，我们发出一个 await 调用 `window.ethereum.request`，我们通过它要求 MetaMask 签署交易。 注意，在该请求中，我们指定了我们的以太币方法 \(eth_SentTransaction\) 并传入了 `transactionParameters`。 此时，MetaMask 将在浏览器中打开，并提示用户签署或拒绝交易。
+ - `to` 指定接收者地址（我们的智能合约）
+ - `from` 指定交易的签名者（用户连接到 MetaMask 的地址：`window.ethereum.selectedAddress`）
+ - `data` 包含对智能合约 `mintNFT` 方法的调用，该方法接收 `tokenURI` 和用户的钱包地址 `window.ethereum.selectedAddress` 作为输入
+- 接下来，我们进行对 `window.ethereum.request` 进行异步调用，请求 MetaMask 对交易进行签名。 注意，在该请求中，我们指定了我们的以太币方法（`eth_SentTransaction`）并传入了 `transactionParameters`。 此时，MetaMask 将在浏览器中打开，并提示用户签署或拒绝交易。
- 如果交易成功，该函数将返回一个 JSON 对象，其中布尔值 `success` 设置为 true，并且 `status` 字符串提示用户查看 Etherscan 区块浏览器以获取有关其交易的更多信息。
- 如果交易失败，该函数将返回一个 JSON 对象，其中 `success` 布尔值设置为 false，并且 `status` 字符串指示错误信息。
@@ -776,43 +773,43 @@ try {
```javascript
export const mintNFT = async (url, name, description) => {
- //error handling
+ //错误处理
if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
return {
success: false,
- status: "❗Please make sure all fields are completed before minting.",
+ status: "❗请在铸币前确保所有字段都已填写完毕。",
}
}
- //make metadata
+ //创建元数据
const metadata = new Object()
metadata.name = name
metadata.image = url
metadata.description = description
- //pinata pin request
+ //pinata 置顶请求
const pinataResponse = await pinJSONToIPFS(metadata)
if (!pinataResponse.success) {
return {
success: false,
- status: "😢 Something went wrong while uploading your tokenURI.",
+ status: "😢 上传你的 tokenURI 时出错了。",
}
}
const tokenURI = pinataResponse.pinataUrl
- //load smart contract
+ //加载智能合约
window.contract = await new web3.eth.Contract(contractABI, contractAddress) //loadContract();
- //set up your Ethereum transaction
+ //设置你的以太坊交易
const transactionParameters = {
- to: contractAddress, // Required except during contract publications.
- from: window.ethereum.selectedAddress, // must match user's active address.
+ to: contractAddress, // 合约发布期间外为必填项。
+ from: window.ethereum.selectedAddress, // 必须与用户活动地址匹配。
data: window.contract.methods
.mintNFT(window.ethereum.selectedAddress, tokenURI)
- .encodeABI(), //make call to NFT smart contract
+ .encodeABI(), //调用 NFT 智能合约
}
- //sign transaction via MetaMask
+ //通过 MetaMask 签署交易
try {
const txHash = await window.ethereum.request({
method: "eth_sendTransaction",
@@ -821,13 +818,13 @@ export const mintNFT = async (url, name, description) => {
return {
success: true,
status:
- "✅ Check out your transaction on Etherscan: https://ropsten.etherscan.io/tx/" +
+ "✅ 在 Etherscan 上查看你的交易：https://ropsten.etherscan.io/tx/" +
txHash,
}
} catch (error) {
return {
success: false,
- status: "😥 Something went wrong: " + error.message,
+ status: "😥 出错了：" + error.message,
}
}
}
@@ -837,7 +834,7 @@ export const mintNFT = async (url, name, description) => {
## 将 mintNFT 连接到我们的 Minter.js 前端 {#connect-our-frontend}
-打开您的 `Minter.js` 文件，并将顶部的 `import { connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` 行更新为：
+打开你的 `Minter.js` 文件，并将顶部的 `import { connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` 行更新为：
```javascript
import {
@@ -847,7 +844,7 @@ import {
} from "./utils/interact.js"
```
-最后，实现 `onMintPressed` 函数对导入的 `mintNFT` 函数进行 await 调用，并更新 `status` 状态变量以表示我们的交易是成功还是失败：
+最后，实现 `onMintPressed` 函数对导入的 `mintNFT` 函数进行 `await` 调用，并更新 `status` 状态变量以表示我们的交易是成功还是失败：
```javascript
const onMintPressed = async () => {
@@ -856,22 +853,22 @@ const onMintPressed = async () => {
}
```
-## 将您的非同质化代币部署到在线网站 {#deploy-your-NFT}
+## 将你的 NFT 部署到在线网站 {#deploy-your-NFT}
-准备好让您的项目上线和用户互动了吗？ 查看[本教程](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online)，将您的铸币机部署到在线网站。
+准备好让你的项目上线和用户互动了吗？ 查看[本教程](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online)以将你的 Minter 部署到在线网站。
最后一步......
-## 掀起区块链世界的风暴 {#take-the-blockchain-world-by-storm}
+## 让区块链世界为之震撼 {#take-the-blockchain-world-by-storm}
-开个玩笑，您已经完成了本教程！
+开个玩笑，你已经完成了本教程！
-概括一下，通过构建非同质化代币铸币机，您成功学会了如何：
+概括一下，通过构建非同质化代币铸币机，你成功学会了如何：
-- 通过您的前端项目连接到 MetaMask
+- 通过你的前端项目连接到 MetaMask
- 在前端调用智能合约的方法
- 使用 MetaMask 签署交易
-大概，你想要在钱包中炫耀通过你的去中心化应用程序铸造的非同质化代币 — 所以请务必参阅我们的快速教程：[如何查看钱包中的非同质化代币](https://docs.alchemyapi.io/alchemy/tutorials/how-to-write-and-deploy-a-nft-smart-contract/how-to-view-your-nft-in-your-wallet)！
+也许你希望能够在钱包中展示通过你的去中心化应用程序铸造的 NFT — 因此请务必查看我们的快速教程[“如何在钱包中查看你的 NFT”](https://www.alchemy.com/docs/how-to-view-your-nft-in-your-mobile-wallet)！
-一如既往，如果您有任何问题，我们会在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中随时为您提供帮助。 我们迫不及待地想看看您如何在将来的项目中应用本教程中的概念！
+一如既往，如果你有任何问题，我们会在 [Alchemy Discord](https://discord.gg/gWuC7zB) 中随时为你提供帮助。 我们迫不及待地想看看你如何在将来的项目中应用本教程中的概念！
diff --git a/public/content/translations/zh/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/zh/developers/tutorials/optimism-std-bridge-annotated-code/index.md
index c5185d455c7..f44bf087138 100644
--- a/public/content/translations/zh/developers/tutorials/optimism-std-bridge-annotated-code/index.md
+++ b/public/content/translations/zh/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -1,84 +1,89 @@
---
-title: "乐观解决方案标准链桥合约演示"
-description: 乐观解决方案标准链桥如何运作？ 为什么它会这样工作？
+title: "Optimism 标准链桥合约详解"
+description: "Optimism 的标准链桥如何运作？ 它为何以这种方式运作？"
author: Ori Pomerantz
-tags:
- - "solidity"
- - "链桥"
- - "二层网络"
+tags: [ "Solidity", "链桥", "二层网络" ]
skill: intermediate
published: 2022-03-30
lang: zh
---
-[乐观解决方案](https://www.optimism.io/)采用[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)技术。 乐观卷叠能够以比以太坊主网（也称“第一层”）低得多的价格处理交易，因为交易只是由几个节点而非网络上的所有节点处理。 同时所有数据都已写入第一层，因此一切都能够得到证明并重建，并且具有主网的所有完整性和可用性保证。
+[Optimism](https://www.optimism.io/) 是一种[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)。
+乐观卷叠能够以比以太坊主网（也称为第 1 层或 L1）低得多的价格处理交易，因为交易仅由少数节点处理，而不是网络上的每个节点。
+同时，所有数据都会写入 L1，因此，所有内容都可以用主网的完整性和可用性保证来证明和重构。
-要在乐观解决方案（或任何其他第二层）上使用第一层资产，需要[桥接](/bridges/#prerequisites)该资产。 实现这一点的一种方法是，用户在一层网络上锁定资产（以太币和 [ERC-20 代币](/developers/docs/standards/tokens/erc-20/)是最常见的资产）并收到供在二层网络上使用的对等资产。 最后，拥有这些资产的任何人可能想把它们桥接回第一层。 在桥接过程中，资产会在第二层销毁，然后在第一层上发放给用户。
+要在 Optimism（或任何其他 L2）上使用 L1 资产，需要将这些资产[桥接](/bridges/#prerequisites)。
+实现这一点的一种方法是，用户在 L1 上锁定资产（最常见的是 ETH 和 [ERC-20 代币](/developers/docs/standards/tokens/erc-20/)），并在 L2 上收到等值的资产以供使用。
+最后，持有这些资产的任何人可能都想将它们桥接回 L1。
+执行此操作时，资产在 L2 上被销毁，然后在 L1 上释放回给用户。
-这就是[乐观解决方案标准链桥](https://docs.optimism.io/app-developers/bridging/standard-bridge)的工作方式。 在本文中，我们将学习链桥的源代码，看看它如何工作，并将它作为精心编写的 Solidity 代码示例加以研究。
+这就是 [Optimism 标准链桥](https://docs.optimism.io/app-developers/bridging/standard-bridge) 的运作方式。
+在本文中，我们将深入研究该链桥的源代码，了解其运作方式，并将其作为编写良好的 Solidity 代码示例进行学习。
-## 控制流通 {#control-flows}
+## 控制流 {#control-flows}
-链桥有两种主要流通方式：
+该链桥有两个主要流程：
-- 存款（从第一层到第二层）
-- 提款（从第二层到第一层）
+- 存款（从 L1 到 L2）
+- 取款（从 L2 到 L1）
-### 存款流通 {#deposit-flow}
+### 存款流程 {#deposit-flow}
-#### 第一层 {#deposit-flow-layer-1}
+#### 第 1 层 {#deposit-flow-layer-1}
-1. 如果存入 ERC-20，存款人会给链桥一笔费用，这笔费用从所存入的金额中抽取
-2. 存款人调用第一层链桥（`depositERC20`、`depositERC20To`、`depositETH` 或 `depositETHTo`）
-3. 第一层链桥拥有桥接的资产
- - 以太币：资产由存款人在调用过程中转移
- - ERC-20：资产被链桥转移给链桥自身，使用的是存款人提供的费用
-4. 第一层链桥使用跨域信息机制调用第二层链桥上的 `finalizeDeposit`
+1. 如果存入 ERC-20，存款人会授予链桥一笔许可额度，用于花费待存入的金额
+2. 存款人调用 L1 链桥（`depositERC20`、`depositERC20To`、`depositETH` 或 `depositETHTo`）
+3. L1 链桥持有桥接的资产
+ - ETH：资产由存款人在调用过程中转账
+ - ERC-20：链桥使用存款人提供的许可额度将资产转账给自己
+4. L1 链桥使用跨域消息机制在 L2 链桥上调用 `finalizeDeposit`
-#### 二层网络 {#deposit-flow-layer-2}
+#### 第 2 层 {#deposit-flow-layer-2}
-5. 第二层链桥验证调用 `finalizeDeposit` 是否合法：
- - 来自交叉域信息合约
- - 最初来自第一层链桥
-6. 第二层链桥检查第二层上的 ERC-20 代币合约是否正确：
- - 第二层合约报告，对应的第一层合约与第一层上提供代币的合约相同
- - 第二层合约报告它支持正确的接口（[使用 ERC-165](https://eips.ethereum.org/EIPS/eip-165)）。
-7. 如果第二层合约正确，请调用它以便在适当地址铸造相应数量的代币。 如果不正确，请启动提款过程让用户可以在第一层上认领代币。
+5. L2 链桥验证对 `finalizeDeposit` 的调用是合法的：
+ - 来自跨域消息合约
+ - 最初来自 L1 上的链桥
+6. L2 链桥检查 L2 上的 ERC-20 代币合约是否正确：
+ - L2 合约报告其 L1 对应合约与 L1 上代币来源的合约相同
+ - L2 合约报告它支持正确的接口（[使用 ERC-165](https://eips.ethereum.org/EIPS/eip-165)）。
+7. 如果 L2 合约正确，则调用它向相应地址铸造相应数量的代币。 如果不正确，则启动取款流程，允许用户在 L1 上认领代币。
-### 提款流程 {#withdrawal-flow}
+### 取款流程 {#withdrawal-flow}
-#### 二层网络 {#withdrawal-flow-layer-2}
+#### 第 2 层 {#withdrawal-flow-layer-2}
-1. 提款人调用第二层链桥（`withdraw` 或 `withdrawTo`）
-2. 第二层链桥销毁属于 `msg.sender` 的适当数量代币
-3. 第二层链桥使用跨域信息机制调用第一层链桥上的 `finalizeETHWithdrawal` 或 `finalizeERC20Withdrawal`
+1. 取款人调用 L2 链桥（`withdraw` 或 `withdrawTo`）
+2. L2 链桥销毁属于 `msg.sender` 的相应数量的代币
+3. L2 链桥使用跨域消息机制在 L1 链桥上调用 `finalizeETHWithdrawal` 或 `finalizeERC20Withdrawal`
-#### 第一层 {#withdrawal-flow-layer-1}
+#### 第 1 层 {#withdrawal-flow-layer-1}
-4. 第一层链桥验证调用 `finalizeETHWithdrawal` 或 `finalizeERC20Withdrawal` 是否合法：
- - 来自交叉域信息机制
- - 最初来自第二层上的链桥
-5. 第一层链桥将适当资产（以太币或 ERC-20）转账到适当地址
+4. L1 链桥验证对 `finalizeETHWithdrawal` 或 `finalizeERC20Withdrawal` 的调用是合法的：
+ - 来自跨域消息机制
+ - 最初来自 L2 上的链桥
+5. L1 链桥将相应资产（ETH 或 ERC-20）转账到相应地址
-## 一层网络代码 {#layer-1-code}
+## 第 1 层代码 {#layer-1-code}
-以下代码在第一层即以太坊主网上运行。
+这是在 L1（以太坊主网）上运行的代码。
### IL1ERC20Bridge {#IL1ERC20Bridge}
-[此接口在此处定义](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol)。 其中包括桥接 ERC-20 代币所需的函数和定义。
+[此接口在此处定义](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol)。
+它包含桥接 ERC-20 代币所需的函数和定义。
```solidity
// SPDX-License-Identifier: MIT
```
-[大多数乐观解决方案代码都是依据 MIT 许可证发布的](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-)。
+[Optimism 的大部分代码都是在 MIT 许可下发布的](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-)。
```solidity
pragma solidity >0.5.0 <0.9.0;
```
-编写代码时，Solidity 最新版本为 0.8.12。 在 0.9.0 版发布之前，我们不知道这段代码是否与它兼容。
+在撰写本文时，Solidity 的最新版本是 0.8.12。
+在 0.9.0 版本发布之前，我们不知道这段代码是否与其兼容。
```solidity
/**
@@ -86,20 +91,23 @@ pragma solidity >0.5.0 <0.9.0;
*/
interface IL1ERC20Bridge {
/**********
- * Events *
+ * 事件 *
**********/
event ERC20DepositInitiated(
```
-在乐观解决方案链桥术语中，_存款_是指从第一层转账到第二层，_提款_是指从第二层转账到第一层。
+在 Optimism 链桥术语中，_deposit_ 是指从 L1 到 L2 的转账，而 _withdrawal_ 是指从 L2 到 L1 的转账。
```solidity
address indexed _l1Token,
address indexed _l2Token,
```
-大多数情况下，第一层上的 ERC-20 地址与第二层上对应的 ERC-20 地址不同。 [可以在此处参阅代币地址列表](https://static.optimism.io/optimism.tokenlist.json)。 带有 `chainId` 1 的地址在第一层（主网），带有 `chainId` 10 的地址在第二层（乐观解决方案）上。 另两个 `chainId` 值用于 Kovan 测试网络 (42) 和乐观 Kovan 测试网络 (69)。
+在大多数情况下，L1 上的 ERC-20 地址与 L2 上等效的 ERC-20 地址不同。
+[你可以在此处查看代币地址列表](https://static.optimism.io/optimism.tokenlist.json)。
+`chainId` 为 1 的地址在 L1（主网）上，`chainId` 为 10 的地址在 L2 (Optimism) 上。
+另外两个 `chainId` 值分别用于 Kovan 测试网 (42) 和 Optimistic Kovan 测试网 (69)。
```solidity
address indexed _from,
@@ -109,7 +117,7 @@ interface IL1ERC20Bridge {
);
```
-可以为转账添加注解，在这种情况下，注解将被添加到报告它们的事件中。
+可以为转账添加备注，在这种情况下，它们将被添加到报告这些转账的事件中。
```solidity
event ERC20WithdrawalFinalized(
@@ -122,33 +130,35 @@ interface IL1ERC20Bridge {
);
```
-同一链桥合约处理双向转账。 就第一层链桥而言，这意味着存款的初始化和提款的终局化。
+同一链桥合约处理双向转账。
+就 L1 链桥而言，这意味着存款的初始化和取款的最终敲定。
```solidity
/********************
- * Public Functions *
+ * 公共函数 *
********************/
/**
- * @dev get the address of the corresponding L2 bridge contract.
- * @return Address of the corresponding L2 bridge contract.
+ * @dev 获取相应 L2 链桥合约的地址。
+ * @return 相应 L2 链桥合约的地址。
*/
function l2TokenBridge() external returns (address);
```
-并不是真需要此函数，因为在第二层上它是一个预部署的合约，所以它总是位于地址 `0x4200000000000000000000000000000000000010` 处。 使用此函数是为了与第二层链桥对称，因为知道第一层桥的地址_并非_不重要。
+这个函数并非真的需要，因为在 L2 上它是一个预部署的合约，所以它总是在地址 `0x4200000000000000000000000000000000000010`。
+它在这里是为了与 L2 链桥对称，因为 L1 链桥的地址_并非_微不足道。
```solidity
/**
- * @dev deposit an amount of the ERC20 to the caller's balance on L2.
- * @param _l1Token Address of the L1 ERC20 we are depositing
- * @param _l2Token Address of the L1 respective L2 ERC20
- * @param _amount Amount of the ERC20 to deposit
- * @param _l2Gas Gas limit required to complete the deposit on L2.
- * @param _data Optional data to forward to L2. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @dev 将一定数量的 ERC20 存入调用者在 L2 上的余额。
+ * @param _l1Token 我们要存入的 L1 ERC20 的地址
+ * @param _l2Token L1 对应的 L2 ERC20 的地址
+ * @param _amount 要存入的 ERC20 的数量
+ * @param _l2Gas 在 L2 上完成存款所需的燃料限制。
+ * @param _data 要转发到 L2 的可选数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function depositERC20(
address _l1Token,
@@ -159,19 +169,21 @@ interface IL1ERC20Bridge {
) external;
```
-`_l2Gas` 参数是指允许交易花费的第二层燃料的数量。 [达到某个（上限）额度前，交易是免费的](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2)，所以除非 ERC-20 合约在铸币时行为确实怪异，否则这应该不是问题。 此函数处理常见场景，即用户将资产桥接到不同区块链上的相同地址。
+`_l2Gas` 参数是交易允许花费的 L2 燃料数量。
+[在某个（高）限制内，这是免费的](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2)，所以除非 ERC-20 合约在铸造时做了什么非常奇怪的事情，否则这应该不成问题。
+此函数处理常见场景，即用户将资产桥接到不同区块链上的相同地址。
```solidity
/**
- * @dev deposit an amount of ERC20 to a recipient's balance on L2.
- * @param _l1Token Address of the L1 ERC20 we are depositing
- * @param _l2Token Address of the L1 respective L2 ERC20
- * @param _to L2 address to credit the withdrawal to.
- * @param _amount Amount of the ERC20 to deposit.
- * @param _l2Gas Gas limit required to complete the deposit on L2.
- * @param _data Optional data to forward to L2. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @dev 将一定数量的 ERC20 存入接收者在 L2 上的余额。
+ * @param _l1Token 我们要存入的 L1 ERC20 的地址
+ * @param _l2Token L1 对应的 L2 ERC20 的地址
+ * @param _to 用于记入取款的 L2 地址。
+ * @param _amount 要存入的 ERC20 的数量。
+ * @param _l2Gas 在 L2 上完成存款所需的燃料限制。
+ * @param _data 要转发到 L2 的可选数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function depositERC20To(
address _l1Token,
@@ -183,26 +195,26 @@ interface IL1ERC20Bridge {
) external;
```
-此函数基本上与 `depositERC20` 相同，但它允许你将 ERC-20 发送到不同的地址。
+此函数与 `depositERC20` 几乎相同，但它允许你将 ERC-20 发送到不同的地址。
```solidity
/*************************
- * Cross-chain Functions *
+ * 跨链函数 *
*************************/
/**
- * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the
- * L1 ERC20 token.
- * This call will fail if the initialized withdrawal from L2 has not been finalized.
+ * @dev 完成从 L2 到 L1 的取款，并将资金记入接收者
+ * L1 ERC20 代币的余额。
+ * 如果从 L2 初始化的取款尚未最终确定，此调用将失败。
*
- * @param _l1Token Address of L1 token to finalizeWithdrawal for.
- * @param _l2Token Address of L2 token where withdrawal was initiated.
- * @param _from L2 address initiating the transfer.
- * @param _to L1 address to credit the withdrawal to.
- * @param _amount Amount of the ERC20 to deposit.
- * @param _data Data provided by the sender on L2. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @param _l1Token 用于 finalizeWithdrawal 的 L1 代币地址。
+ * @param _l2Token 发起取款的 L2 代币地址。
+ * @param _from 发起转账的 L2 地址。
+ * @param _to 用于记入取款的 L1 地址。
+ * @param _amount 要存入的 ERC20 的数量。
+ * @param _data 发送人在 L2 上提供的数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function finalizeERC20Withdrawal(
address _l1Token,
@@ -215,16 +227,20 @@ interface IL1ERC20Bridge {
}
```
-乐观解决方案中的提款（以及从第二层到第一层的其他信息）是一个包含两个步骤的过程：
+在 Optimism 中，取款（以及从 L2 到 L1 的其他消息）是一个两步过程：
-1. 在第二层上的启动交易。
-2. 在第一层上完成或声明交易。 在第二层交易的[缺陷质询期](https://community.optimism.io/docs/how-optimism-works/#fault-proofs)结束后此交易才可以进行。
+1. 在 L2 上发起一笔交易。
+2. 在 L1 上敲定或声明一笔交易。
+ 这笔交易需要在 L2 交易的[故障挑战期](https://community.optimism.io/docs/how-optimism-works/#fault-proofs)结束后才能进行。
### IL1StandardBridge {#il1standardbridge}
-[此接口在此处定义](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol)。 该文件包含以太币的事件和函数定义。 这些定义与上述 `IL1ERC20Bridge` 中为 ERC-20 定义的定义非常相似。
+[此接口在此处定义](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol)。
+该文件包含 ETH 的事件和函数定义。
+这些定义与上面 `IL1ERC20Bridge` 中为 ERC-20 定义的定义非常相似。
-链桥接口分为两个文件，因为某些 ERC-20 代币需要自定义处理，标准链桥接无法处理它们。 这样，处理此类代币的自定义链桥可以实现 `IL1ERC20Bridge`，而不必再桥接以太币。
+链桥接口分为两个文件，因为某些 ERC-20 代币需要自定义处理，标准链桥无法处理它们。
+这样，处理此类代币的自定义链桥可以实现 IL1ERC20Bridge，而不必再桥接 ETH。
```solidity
// SPDX-License-Identifier: MIT
@@ -237,7 +253,7 @@ import "./IL1ERC20Bridge.sol";
*/
interface IL1StandardBridge is IL1ERC20Bridge {
/**********
- * Events *
+ * 事件 *
**********/
event ETHDepositInitiated(
address indexed _from,
@@ -247,7 +263,8 @@ interface IL1StandardBridge is IL1ERC20Bridge {
);
```
-此事件与 ERC-20 版本 (`ERC20DepositInitiated`) 几乎相同，只是没有第一层和第二层代币的地址。 其他事件和函数也是如此。
+此事件与 ERC-20 版本 (`ERC20DepositInitiated`) 几乎相同，只是没有 L1 和 L2 代币地址。
+其他事件和函数也是如此。
```solidity
event ETHWithdrawalFinalized(
@@ -257,11 +274,11 @@ interface IL1StandardBridge is IL1ERC20Bridge {
);
/********************
- * Public Functions *
+ * 公共函数 *
********************/
/**
- * @dev Deposit an amount of the ETH to the caller's balance on L2.
+ * @dev 将一定数量的 ETH 存入调用者在 L2 上的余额。
.
.
.
@@ -269,7 +286,7 @@ interface IL1StandardBridge is IL1ERC20Bridge {
function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
/**
- * @dev Deposit an amount of ETH to a recipient's balance on L2.
+ * @dev 将一定数量的 ETH 存入接收者在 L2 上的余额。
.
.
.
@@ -281,13 +298,13 @@ interface IL1StandardBridge is IL1ERC20Bridge {
) external payable;
/*************************
- * Cross-chain Functions *
+ * 跨链函数 *
*************************/
/**
- * @dev Complete a withdrawal from L2 to L1, and credit funds to the recipient's balance of the
- * L1 ETH token. Since only the xDomainMessenger can call this function, it will never be called
- * before the withdrawal is finalized.
+ * @dev 完成从 L2 到 L1 的取款，并将资金记入接收者
+ * L1 ETH 代币的余额。由于只有 xDomainMessenger 可以调用此函数，因此在
+ * 取款最终确定之前永远不会调用它。
.
.
.
@@ -303,62 +320,65 @@ interface IL1StandardBridge is IL1ERC20Bridge {
### CrossDomainEnabled {#crossdomainenabled}
-[此合约](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol)由两个链桥（[一层网络](#the-l1-bridge-contract)和[二层网络](#the-l2-bridge-contract)）继承，以便向其他层发送信息。
+[此合约](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol)由两个链桥（[L1](#the-l1-bridge-contract) 和 [L2](#the-l2-bridge-contract)）继承，用于向另一层发送消息。
```solidity
// SPDX-License-Identifier: MIT
pragma solidity >0.5.0 <0.9.0;
-/* Interface Imports */
+/* 接口导入 */
import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
```
-[这个接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol)告诉合约如何发送使用跨域信使向另一层发送信息。 跨域信使完全是另一种系统，值得单独写一篇文章来介绍，我希望将来能写出来。
+[此接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol) 告知合约如何使用跨域信使向另一层发送消息。
+跨域信使完全是另一种系统，值得单独写一篇文章来介绍，我希望将来能写出来。
```solidity
/**
* @title CrossDomainEnabled
- * @dev Helper contract for contracts performing cross-domain communications
+ * @dev 执行跨域通信的合约的帮助合约
*
- * Compiler used: defined by inheriting contract
+ * 使用的编译器：由继承合约定义
*/
contract CrossDomainEnabled {
/*************
- * Variables *
+ * 变量 *
*************/
- // Messenger contract used to send and receive messages from the other domain.
+ // 用于从其他域发送和接收消息的信使合约。
address public messenger;
/***************
- * Constructor *
+ * 构造函数 *
***************/
/**
- * @param _messenger Address of the CrossDomainMessenger on the current layer.
+ * @param _messenger 当前层上的 CrossDomainMessenger 地址。
*/
constructor(address _messenger) {
messenger = _messenger;
}
```
-合约需要知道的一个参数就是跨域信使在这一层的地址。 此参数在构造函数中设置一次，并且永远不会更改。
+合约需要知道的一个参数，就是跨域信使在这一层的地址。
+此参数在构造函数中设置一次，并且永远不会更改。
```solidity
/**********************
- * Function Modifiers *
+ * 函数修饰符 *
**********************/
/**
- * Enforces that the modified function is only callable by a specific cross-domain account.
- * @param _sourceDomainAccount The only account on the originating domain which is
- * authenticated to call this function.
+ * 强制修饰的函数只能由特定的跨域帐户调用。
+ * @param _sourceDomainAccount 源域上唯一经过
+ * 身份验证可调用此函数的帐户。
*/
modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
```
-跨域消息传递可以由运行在区块链（以太坊主网或乐观解决方案）上的任何合约使用。 但是每一层都需要链桥。如果信息来自于另一边的链桥，将_只_信任特定信息。
+跨域消息传递可以由运行在区块链（以太坊主网或 Optimism）上的任何合约使用。
+但是每一层都需要链桥。如果消息来自于另一边的链桥，将只信任特定消息。
```solidity
require(
@@ -367,7 +387,7 @@ contract CrossDomainEnabled {
);
```
-只能信任来自适当跨域信使（`messenger`，如下所示）的信息。
+只能信任来自适当跨域信使（messenger，如下所示）的消息。
```solidity
@@ -377,9 +397,10 @@ contract CrossDomainEnabled {
);
```
-跨域信使要提供另一层发送信息的地址，就需要用到 [`.xDomainMessageSender()` 函数](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128)。 只要在信息发起的交易中调用它，它就可以提供此信息。
+跨域信使提供另一层发送消息的地址的方式是[`.xDomainMessageSender()` 函数](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128)。
+只要在消息发起的交易中调用它，它就可以提供此信息。
-我们需要确保我们收到的信息来自另一个链桥。
+我们需要确保我们收到的消息来自另一个链桥。
```solidity
@@ -387,29 +408,30 @@ contract CrossDomainEnabled {
}
/**********************
- * Internal Functions *
+ * 内部函数 *
**********************/
/**
- * Gets the messenger, usually from storage. This function is exposed in case a child contract
- * needs to override.
- * @return The address of the cross-domain messenger contract which should be used.
+ * 获取信使，通常来自存储。如果子合约需要重写
+ *，则公开此函数。
+ * @return 应该使用的跨域信使合约的地址。
*/
function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
return ICrossDomainMessenger(messenger);
}
```
-该函数返回跨域信使。 我们使用函数而不是变量 `messenger`，以允许从该函数继承的合约使用一种算法来指定要使用的跨域信使。
+该函数返回跨域信使。
+我们使用函数而不是变量 messenger，以允许从该函数继承的合约使用一种算法来指定要使用的跨域信使。
```solidity
/**
- * Sends a message to an account on another domain
- * @param _crossDomainTarget The intended recipient on the destination domain
- * @param _message The data to send to the target (usually calldata to a function with
- * `onlyFromCrossDomainAccount()`)
- * @param _gasLimit The gasLimit for the receipt of the message on the target domain.
+ * 向另一个域上的帐户发送消息
+ * @param _crossDomainTarget 目的域上的预期接收者
+ * @param _message 发送到目标的数据（通常是带有
+ * `onlyFromCrossDomainAccount()` 的函数的 calldata）
+ * @param _gasLimit 在目标域上接收消息的燃料限制。
*/
function sendCrossDomainMessage(
address _crossDomainTarget,
@@ -417,17 +439,18 @@ contract CrossDomainEnabled {
bytes memory _message
```
-最后是向另一层发送信息的函数。
+最后是向另一层发送消息的函数。
```solidity
) internal {
// slither-disable-next-line reentrancy-events, reentrancy-benign
```
-[Slither](https://github.com/crytic/slither) 是一个静态分析器，乐观解决方案在每个合约上运行它以查找漏洞和其他潜在问题。 在本例中，下面一行会触发两个漏洞：
+[Slither](https://github.com/crytic/slither) 是一个静态分析器，Optimism 在每个合约上运行它以查找漏洞和其他潜在问题。
+在本例中，下面一行会触发两个漏洞：
-1. [重入事件](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3)
-2. [良性重入](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
+1. [可重入事件](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3)
+2. [良性可重入](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
```solidity
getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
@@ -435,9 +458,9 @@ contract CrossDomainEnabled {
}
```
-在这种情况下，我们不担心重入漏洞，我们知道 `getCrossDomainMessenger()` 返回一个可信地址，即使 Slither 无法知道这一点。
+在这种情况下，我们不担心可重入性，我们知道 `getCrossDomainMessenger()` 返回一个可信地址，即使 Slither 无法知道这一点。
-### 第一层链桥合约 {#the-l1-bridge-contract}
+### L1 链桥合约 {#the-l1-bridge-contract}
[此合约的源代码在此处](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1StandardBridge.sol)。
@@ -446,46 +469,48 @@ contract CrossDomainEnabled {
pragma solidity ^0.8.9;
```
-接口可以来自其他合约，因此它们必须支持各种 Solidity 版本。 但是链桥本身属于我们的合约，我们可以严格限制它使用的 Solidity 版本。
+接口可以来自其他合约，因此它们必须支持各种 Solidity 版本。
+但是链桥本身属于我们的合约，我们可以严格限制它使用的 Solidity 版本。
```solidity
-/* Interface Imports */
+/* 接口导入 */
import { IL1StandardBridge } from "./IL1StandardBridge.sol";
import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
```
-[IL1ERC20Bridge](#IL1ERC20Bridge) 和 [IL1StandardBridge](#IL1StandardBridge) 已在上面进行了说明。
+[IL1ERC20Bridge](#IL1ERC20Bridge) 和 [IL1StandardBridge](#IL1StandardBridge) 已在上面解释。
```solidity
import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
```
-[此接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol)让我们创建信息来控制第二层上的标准链桥。
+[此接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) 让我们能够创建消息来控制 L2 上的标准链桥。
```solidity
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
```
-[此接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)让我们控制 ERC-20 合约。 [你可以在此处阅读更多信息](/developers/tutorials/erc20-annotated-code/#the-interface)。
+[此接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) 让我们能够控制 ERC-20 合约。
+[你可以在此处阅读更多相关信息](/developers/tutorials/erc20-annotated-code/#the-interface)。
```solidity
-/* Library Imports */
+/* 库导入 */
import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
```
-[如上所述](#crossdomainenabled)，此合约用于层间信息传递。
+[如上所述](#crossdomainenabled)，此合约用于层间消息传递。
```solidity
import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
```
-[`Lib_PredeployAddresses`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol) 为第二层合约提供地址，这些合约始终使用相同的地址。 其中包括第二层上的标准链桥。
+[`Lib_PredeployAddresses`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol) 包含 L2 合约的地址，这些合约的地址始终相同。 其中包括 L2 上的标准链桥。
```solidity
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
```
-[OpenZeppelin 的地址工具](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol)。 它用于区分合约地址和属于外部帐户 (EOA) 的地址。
+[OpenZeppelin 的 Address 工具](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol)。 它用于区分合约地址和属于外部帐户 (EOA) 的地址。
请注意，这不是一个理想的解决方案，因为无法区分直接调用和合约构造函数的调用，但至少这让我们能够识别和防止一些常见的用户错误。
@@ -498,26 +523,26 @@ import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.s
1. 回滚
2. 返回 `false`
-处理这两种情况会使我们的代码更加复杂，因此我们使用 [OpenZeppelin 的 `SafeERC20`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol)，确保[所有失败都导致回滚](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96)。
+处理这两种情况会让我们的代码更复杂，因此我们改用 [OpenZeppelin 的 `SafeERC20`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol)，它能确保[所有失败都会导致回滚](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96)。
```solidity
/**
* @title L1StandardBridge
- * @dev The L1 ETH and ERC20 Bridge is a contract which stores deposited L1 funds and standard
- * tokens that are in use on L2. It synchronizes a corresponding L2 Bridge, informing it of deposits
- * and listening to it for newly finalized withdrawals.
+ * @dev L1 ETH 和 ERC20 链桥是一个合约，它存储已存入的 L1 资金和正在 L2 上使用的标准
+ * 代币。它同步一个相应的 L2 链桥，通知其存款
+ * 并监听其新最终确定的取款。
*
*/
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
using SafeERC20 for IERC20;
```
-此行表示我们如何指定在每次使用 `IERC20` 接口时使用 `SafeERC20` 包装器。
+此行表示我们如何指定在每次使用 IERC20 接口时使用 SafeERC20 包装器。
```solidity
/********************************
- * External Contract References *
+ * 外部合约引用 *
********************************/
address public l2TokenBridge;
@@ -527,50 +552,65 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
```solidity
- // Maps L1 token to L2 token to balance of the L1 token deposited
+ // 将 L1 代币映射到 L2 代币再映射到已存入 L1 代币的余额
mapping(address => mapping(address => uint256)) public deposits;
```
-像这样的双重[映射](https://www.tutorialspoint.com/solidity/solidity_mappings.htm)是定义[二维稀疏数组](https://en.wikipedia.org/wiki/Sparse_matrix)的方式。 此数据结构中的值被标识为 `deposit[L1 token addr][L2 token addr]`。 默认值为零。 只有设置为不同值的单元才会写入存储。
+像这样的双重 [mapping](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) 是定义[二维稀疏数组](https://en.wikipedia.org/wiki/Sparse_matrix)的方式。
+此数据结构中的值被标识为 deposit[L1 代币地址][L2 代币地址]。
+默认值为零。
+只有设置为不同值的单元才会写入存储。
```solidity
/***************
- * Constructor *
+ * 构造函数 *
***************/
- // This contract lives behind a proxy, so the constructor parameters will go unused.
+ // 此合约位于代理之后，因此构造函数参数将不被使用。
constructor() CrossDomainEnabled(address(0)) {}
```
-希望能够升级此合约而无需复制存储中的所有变量。 为此，我们使用 [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy)，此合约使用 [`delegatecall`](https://solidity-by-example.org/delegatecall/) 将呼叫转移到地址由代理合约存储的单独联系人（当你升级时，你告诉代理更改该地址）。 当你使用 `delegatecall` 时，存储仍然是_调用_合约的存储，因此合约所有状态变量的值不受影响。
+希望能够升级此合约而无需复制存储中的所有变量。
+为此，我们使用 [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy)，这是一个使用 [`delegatecall`](https://solidity-by-example.org/delegatecall/) 将调用转移到另一个独立合约的合约，该独立合约的地址由代理合约存储（当你升级时，你告知代理更改该地址）。
+当你使用 `delegatecall` 时，存储仍然是_调用_合约的存储，因此合约所有状态变量的值不受影响。
-这种模式的结果是不使用 `delegatecall` _调用_的合约的存储，因此传递给它的构造函数值无关紧要。 这就是我们可以为 `CrossDomainEnabled` 构造函数提供一个无意义值的原因。 这也是下面的初始化与构造函数分开的原因。
+这种模式的结果是不使用 `delegatecall` 调用的合约的存储，因此传递给它的构造函数值无关紧要。
+这就是我们可以为 `CrossDomainEnabled` 构造函数提供一个无意义值的原因。
+这也是下面的初始化与构造函数分开的原因。
```solidity
/******************
- * Initialization *
+ * 初始化 *
******************/
/**
- * @param _l1messenger L1 Messenger address being used for cross-chain communications.
- * @param _l2TokenBridge L2 standard bridge address.
+ * @param _l1messenger 用于跨链通信的 L1 Messenger 地址。
+ * @param _l2TokenBridge L2 标准链桥地址。
*/
// slither-disable-next-line external-function
```
-此 [Slither 测试](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external)可识别不是从合约代码调用且因此可以声明为 `external` 而不是 `public` 的函数。 `external` 函数的燃料成本可以更低，因为可以在 calldata 中为它们提供参数。 声明为 `public` 的函数必须可以在合约内部访问。 合约不能修改自己的 calldata，所以参数必须位于内存中。 当外部调用这类函数时，需要将 calldata 复制到内存中，这就会消耗燃料。 在本例中，函数只被调用一次，因此效率低下对我们来说无关紧要。
+此 [Slither 测试](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external)识别未从合约代码中调用的函数，因此可以声明为 `external` 而不是 `public`。
+`external` 函数的燃料成本可以更低，因为可以在 calldata 中为它们提供参数。
+声明为 `public` 的函数必须可以在合约内部访问。
+合约不能修改自己的 calldata，所以参数必须位于内存中。
+当外部调用这类函数时，需要将 calldata 复制到内存中，这就会消耗燃料。
+在本例中，函数只被调用一次，因此效率低下对我们来说无关紧要。
```solidity
function initialize(address _l1messenger, address _l2TokenBridge) public {
- require(messenger == address(0), "Contract has already been initialized.");
+ require(messenger == address(0), "合约已被初始化。"
```
-`initialize` 函数只应调用一次。 如果第一层跨域信使或第二层代币链桥的地址发生变化，我们将创建新代理和新链桥来调用它。 这种情况不太可能发生，除非升级整个系统，这非常罕见。
+`initialize` 函数只应调用一次。
+如果 L1 跨域信使或 L2 代币链桥的地址发生变化，我们将创建新代理和新链桥来调用它。
+这种情况不太可能发生，除非升级整个系统，这非常罕见。
-请注意，此函数没有任何机制限制_谁_可以调用它。 这意味着理论上，攻击者可以等到我们部署代理和第一版链桥后，抢在合法用户之前在[前台运行](https://solidity-by-example.org/hacks/front-running/)以使用 `initialize` 函数。 但是有两种方法可以防止这种情况：
+请注意，此函数没有任何机制限制谁可以调用它。
+这意味着理论上，攻击者可以等到我们部署代理和第一版链桥后，通过[抢先交易](https://solidity-by-example.org/hacks/front-running/)抢在合法用户之前使用 `initialize` 函数。 但是有两种方法可以防止这种情况：
-1. 如果合约不是由外部帐户直接部署，而是[在有另一个合约创建它们的交易中](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595)部署，那么整个过程可以成为最小操作单元，并且能够在执行任何其他交易之前完成。
+1. 如果合约不是由外部帐户直接部署，而是在[有另一个合约创建它们的交易中部署](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595)，那么整个过程可以成为最小操作单元，并且能够在执行任何其他交易之前完成。
2. 如果对 `initialize` 的合法调用失败，总是可以忽略新创建的代理和链桥并创建新的。
```solidity
@@ -584,15 +624,15 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
```solidity
/**************
- * Depositing *
+ * 存款 *
**************/
- /** @dev Modifier requiring sender to be EOA. This check could be bypassed by a malicious
- * contract via initcode, but it takes care of the user error we want to avoid.
+ /** @dev 修饰符要求发送方为 EOA。 恶意
+ * 合约可以通过 initcode 绕过此检查，但它能避免我们想要防止的用户错误。
*/
modifier onlyEOA() {
- // Used to stop deposits from contracts (avoid accidentally lost tokens)
- require(!Address.isContract(msg.sender), "Account not EOA");
+ // 用于阻止来自合约的存款（避免代币意外丢失）
+ require(!Address.isContract(msg.sender), "帐户不是 EOA");
_;
}
```
@@ -601,17 +641,18 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
```solidity
/**
- * @dev This function can be called with no data
- * to deposit an amount of ETH to the caller's balance on L2.
- * Since the receive function doesn't take data, a conservative
- * default amount is forwarded to L2.
+ * @dev 可以在没有数据的情况下调用此函数
+ * 以将一定数量的 ETH 存入调用者在 L2 上的余额。
+ * 由于接收函数不接受数据，一个保守的
+ * 默认数量被转发到 L2。
*/
receive() external payable onlyEOA {
_initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
}
```
-此函数存在的目的是测试。 请注意，它没有出现在接口定义中 — 它不适合正常使用。
+此函数存在的目的是测试。
+请注意，它没有出现在接口定义中 — 它不适合正常使用。
```solidity
/**
@@ -633,18 +674,18 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
}
```
-这两个函数是 `_initiateETHDeposit` 的包装器，_initiateETHDeposit 处理实际的以太币存款。
+这两个函数是 `_initiateETHDeposit` 的包装器，`_initiateETHDeposit` 处理实际的 ETH 存款。
```solidity
/**
- * @dev Performs the logic for deposits by storing the ETH and informing the L2 ETH Gateway of
- * the deposit.
- * @param _from Account to pull the deposit from on L1.
- * @param _to Account to give the deposit to on L2.
- * @param _l2Gas Gas limit required to complete the deposit on L2.
- * @param _data Optional data to forward to L2. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @dev 通过存储 ETH 并通知 L2 ETH 网关
+ * 存款来执行存款逻辑。
+ * @param _from 在 L1 上提取存款的帐户。
+ * @param _to 在 L2 上给予存款的帐户。
+ * @param _l2Gas 在 L2 上完成存款所需的燃料限制。
+ * @param _data 要转发到 L2 的可选数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function _initiateETHDeposit(
address _from,
@@ -652,11 +693,14 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
uint32 _l2Gas,
bytes memory _data
) internal {
- // Construct calldata for finalizeDeposit call
+ // 为 finalizeDeposit 调用构建 calldata
bytes memory message = abi.encodeWithSelector(
```
-跨域信息的工作方式是将信息作为其 calldata 来调用目的地合约。 Solidity 合约总是解释它们的 calldata 符合 [应用程序二进制接口规范](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html)。 Solidity 函数 [`abi. encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) 可创建该 calldata。
+跨域消息的工作方式是将消息作为其 calldata 来调用目的地合约。
+Solidity 合约总是根据
+[ABI 规范](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html)来解释它们的 calldata。
+Solidity 函数 [`abi.encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) 创建该 calldata。
```solidity
IL2ERC20Bridge.finalizeDeposit.selector,
@@ -669,24 +713,24 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
);
```
-此处的信息用来使用下面的参数调用 [`finalizeDeposit` 函数](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148)：
+这里的消息是使用这些参数调用 [`finalizeDeposit` 函数](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148)：
-| 参数 | 值 | 意义 |
-| ----------- | -------------------------------- | -------------------------------------------------------------------------------- |
-| \_l1Token | address(0) | 在第一层上代表以太币（不是 ERC-20 代币）的特殊值 |
-| \_l2Token | Lib_PredeployAddresses.OVM_ETH | 乐观解决方案上管理以太币的第二层合约 `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000`（此合约仅供乐观解决方案内部使用） |
-| \_from | \_from | 第一层上发送以太币的地址 |
-| \_to | \_to | 第二层上接收以太币的地址 |
-| amount | msg.value | 已发送的 wei 数量（已经发送到链桥的 wei） |
-| \_data | \_data | 附加到存款的额外日期 |
+| 参数 | Value | 含义 |
+| ------------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| \_l1Token | address(0) | 在 L1 上代表 ETH（不是 ERC-20 代币）的特殊值 |
+| \_l2Token | Lib_PredeployAddresses.OVM_ETH | 在 Optimism 上管理 ETH 的 L2 合约，地址为 `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000`（此合约仅供 Optimism 内部使用） |
+| \_from | \_from | 发送 ETH 的 L1 地址 |
+| \_to | \_to | 接收 ETH 的 L2 地址 |
+| amount | msg.value | 发送的 wei 数量（已经发送到链桥） |
+| \_data | \_data | 附加到存款的额外数据 |
```solidity
- // Send calldata into L2
+ // 将 calldata 发送到 L2
// slither-disable-next-line reentrancy-events
sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
```
-通过跨域信使发送信息。
+通过跨域信使发送消息。
```solidity
// slither-disable-next-line reentrancy-events
@@ -701,9 +745,9 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
* @inheritdoc IL1ERC20Bridge
*/
function depositERC20(
- .
- .
- .
+ .
+ .
+ .
) external virtual onlyEOA {
_initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
}
@@ -712,9 +756,9 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
* @inheritdoc IL1ERC20Bridge
*/
function depositERC20To(
- .
- .
- .
+ .
+ .
+ .
) external virtual {
_initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
}
@@ -724,18 +768,18 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
```solidity
/**
- * @dev Performs the logic for deposits by informing the L2 Deposited Token
- * contract of the deposit and calling a handler to lock the L1 funds. (e.g., transferFrom)
+ * @dev 通过通知 L2 存款代币
+ * 合约存款并调用处理程序锁定 L1 资金来执行存款逻辑。（例如，transferFrom）
*
- * @param _l1Token Address of the L1 ERC20 we are depositing
- * @param _l2Token Address of the L1 respective L2 ERC20
- * @param _from Account to pull the deposit from on L1
- * @param _to Account to give the deposit to on L2
- * @param _amount Amount of the ERC20 to deposit.
- * @param _l2Gas Gas limit required to complete the deposit on L2.
- * @param _data Optional data to forward to L2. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @param _l1Token 我们要存入的 L1 ERC20 的地址
+ * @param _l2Token L1 对应的 L2 ERC20 的地址
+ * @param _from 在 L1 上提取存款的帐户
+ * @param _to 在 L2 上给予存款的帐户
+ * @param _amount 要存入的 ERC20 的数量。
+ * @param _l2Gas 在 L2 上完成存款所需的燃料限制。
+ * @param _data 要转发到 L2 的可选数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function _initiateERC20Deposit(
address _l1Token,
@@ -748,26 +792,29 @@ contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
) internal {
```
-此函数类似于上面的 `_initiateETHDeposit`，但有一些重要区别。 第一个区别是此函数接收代币地址和转账金额作为参数。 对于以太币，对链桥的调用已经包括将资产转账到链桥帐户 (`msg.value`)。
+此函数类似于上面的 `_initiateETHDeposit`，但有一些重要区别。
+第一个区别是此函数接收代币地址和转账金额作为参数。
+对于 ETH，对链桥的调用已经包括将资产转账到链桥帐户 (`msg.value`)。
```solidity
- // When a deposit is initiated on L1, the L1 Bridge transfers the funds to itself for future
- // withdrawals. safeTransferFrom also checks if the contract has code, so this will fail if
- // _from is an EOA or address(0).
+ // 当在 L1 上发起存款时，L1 链桥将资金转移给自己以备将来
+ // 取款。safeTransferFrom 还会检查合约是否有代码，因此如果
+ // _from 是 EOA 或 address(0)，此操作将失败。
// slither-disable-next-line reentrancy-events, reentrancy-benign
IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
```
-ERC-20 代币的转账过程不同以太币：
+ERC-20 代币的转账过程不同于 ETH：
-1. 用户 (`_from`) 提供费用让链桥转移适当的代币。
+1. 用户（`_from`）授予链桥许可额度以转移相应的代币。
2. 用户使用代币合约的地址、金额等调用链桥。
3. 在存款过程中，链桥转移代币（给自己）。
-第一步可能和最后两步发生在不同的交易中。 但是，前台运行不是问题，因为调用 `_initiateERC20Deposit` 的两个函数（`depositERC20` 和 `depositERC20To`）只将 `msg.sender` 作为 `_from` 参数调用该函数。
+第一步可能和最后两步发生在不同的交易中。
+但是，抢先交易不是问题，因为调用 `_initiateERC20Deposit` 的两个函数（`depositERC20` 和 `depositERC20To`）只将 `msg.sender` 作为 `_from` 参数调用该函数。
```solidity
- // Construct calldata for _l2Token.finalizeDeposit(_to, _amount)
+ // 为 _l2Token.finalizeDeposit(_to, _amount) 构建 calldata
bytes memory message = abi.encodeWithSelector(
IL2ERC20Bridge.finalizeDeposit.selector,
_l1Token,
@@ -778,7 +825,7 @@ ERC-20 代币的转账过程不同以太币：
_data
);
- // Send calldata into L2
+ // 将 calldata 发送到 L2
// slither-disable-next-line reentrancy-events, reentrancy-benign
sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
@@ -786,7 +833,8 @@ ERC-20 代币的转账过程不同以太币：
deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
```
-将存入的代币数量添加到 `deposits` 数据结构中。 第二层上可能有多个地址对应于同一个第一层 ERC-20 代币，因此仅使用链桥的第一层 ERC-20 代币余额来跟踪存款是不够的。
+将存入的代币数量添加到 `deposits` 数据结构中。
+L2 上可能有多个地址对应于同一个 L1 ERC-20 代币，因此仅使用链桥的 L1 ERC-20 代币余额来跟踪存款是不够的。
```solidity
@@ -795,7 +843,7 @@ ERC-20 代币的转账过程不同以太币：
}
/*************************
- * Cross-chain Functions *
+ * 跨链函数 *
*************************/
/**
@@ -808,20 +856,21 @@ ERC-20 代币的转账过程不同以太币：
bytes calldata _data
```
-第二层链桥向第二层跨域信使发送信息，使得第一层跨域信使调用此函数（当然是在[完成信息的交易](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions)在第一层上提交以后）。
+L2 链桥向 L2 跨域信使发送一条消息，这会使 L1 跨域信使调用此函数（当然，前提是[最终确定该消息的交易](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions)已在 L1 上提交）。
```solidity
) external onlyFromCrossDomainAccount(l2TokenBridge) {
```
-确保这是一个_合法_信息，来自跨域信使并源自第二层代币链桥。 此函数用于从链桥中提取以太币，因此我们必须确保它仅由授权调用者调用。
+确保这是一条_合法_消息，来自跨域信使并源自 L2 代币链桥。
+此函数用于从链桥中提取 ETH，因此我们必须确保它仅由授权调用者调用。
```solidity
// slither-disable-next-line reentrancy-events
(bool success, ) = _to.call{ value: _amount }(new bytes(0));
```
-转移以太币的方式是用 `msg.value` 中 wei 的数量调用接收者。
+转移 ETH 的方式是用 `msg.value` 中的 wei 数量调用接收者。
```solidity
require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
@@ -830,7 +879,7 @@ ERC-20 代币的转账过程不同以太币：
emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
```
-触发一个关于提款的事件。
+触发一个关于取款的事件。
```solidity
}
@@ -858,7 +907,7 @@ ERC-20 代币的转账过程不同以太币：
```solidity
- // When a withdrawal is finalized on L1, the L1 Bridge transfers the funds to the withdrawer
+ // 当在 L1 上最终确定取款时，L1 链桥将资金转移给取款人
// slither-disable-next-line reentrancy-events
IERC20(_l1Token).safeTransfer(_to, _amount);
@@ -868,28 +917,35 @@ ERC-20 代币的转账过程不同以太币：
/*****************************
- * Temporary - Migrating ETH *
+ * 临时 - 迁移 ETH *
*****************************/
/**
- * @dev Adds ETH balance to the account. This is meant to allow for ETH
- * to be migrated from an old gateway to a new gateway.
- * NOTE: This is left for one upgrade only so we are able to receive the migrated ETH from the
- * old contract
+ * @dev 将 ETH 余额添加到帐户。这旨在允许将 ETH
+ * 从旧网关迁移到新网关。
+ * 注意：这只保留一次升级，以便我们能够从
+ * 旧合约接收迁移的 ETH
*/
function donateETH() external payable {}
}
```
-对于早期实现的链桥， 当我们从该实现转移到当前实现时，我们必须转移所有资产。 ERC-20 代币可以转移。 但是，要将以太币转账到合约，你需要得到该合约的批准，`donateETH` 就起到这一作用。
+链桥有更早的实现。
+当我们从该实现转移到当前实现时，我们必须转移所有资产。
+ERC-20 代币可以直接移动。
+但是，要将 ETH 转账到合约，你需要得到该合约的批准，`donateETH` 就起到这一作用。
-## 第二层上的 ERC-20 代币 {#erc-20-tokens-on-l2}
+## L2 上的 ERC-20 代币 {#erc-20-tokens-on-l2}
-为了使 ERC-20 代币适合标准链桥，它需要允许标准链桥并且_只_允许标准链桥铸造代币。 这是必要的，因为链桥需要确保在乐观解决方案上流通的代币数量和锁定在第一层链桥合约内的代币数量相同。 如果第二层上的代币太多，一些用户将无法将他们的资产桥接到第一层。 我们实际上将重新建立[部分准备金银行制度](https://www.investopedia.com/terms/f/fractionalreservebanking.asp)，而不是一个受信任的链桥。 如果第一层上的代币太多，其中一些代币将永远锁定在链桥合约中，因为不销毁第二层代币就无法释放它们。
+为了使 ERC-20 代币适合标准链桥，它需要允许标准链桥并且只允许标准链桥铸造代币。
+这是必要的，因为链桥需要确保在 Optimism 上流通的代币数量和锁定在 L1 链桥合约内的代币数量相同。
+如果 L2 上的代币太多，一些用户将无法将他们的资产桥接到 L1。
+我们本质上不是在创建一个可信的链桥，而是在重建[部分准备金银行制度](https://www.investopedia.com/terms/f/fractionalreservebanking.asp)。
+如果 L1 上的代币太多，其中一些代币将永远锁定在链桥合约中，因为不销毁 L2 代币就无法释放它们。
### IL2StandardERC20 {#il2standarderc20}
-第二层上使用标准链桥的每个 ERC-20 代币都需要提供[此接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol)，它具有标准链桥需要的函数和事件。
+在 L2 上使用标准链桥的每个 ERC-20 代币都需要提供[此接口](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol)，其中包含标准链桥所需的函数和事件。
```solidity
// SPDX-License-Identifier: MIT
@@ -898,20 +954,24 @@ pragma solidity ^0.8.9;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
```
-[标准 ERC-20 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)不包含 `mint` 和 `burn` 函数。 [ERC-20 标准](https://eips.ethereum.org/EIPS/eip-20)不需要这些方法，它未指定创建和销毁代币的机制。
+[标准 ERC-20 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)不包括 `mint` 和 `burn` 函数。
+[ERC-20 标准](https://eips.ethereum.org/EIPS/eip-20)不需要这些方法，它未指定创建和销毁代币的机制。
```solidity
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
```
-[ERC-165 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol)用于指定一个合约提供哪些函数。 [你可以在此处参阅该标准](https://eips.ethereum.org/EIPS/eip-165)。
+[ERC-165 接口](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol)用于指定合约提供的函数。
+[你可以在此处阅读该标准](https://eips.ethereum.org/EIPS/eip-165)。
```solidity
interface IL2StandardERC20 is IERC20, IERC165 {
function l1Token() external returns (address);
```
-此函数提供桥接到此合约的第一层代币的地址。 请注意，我们在相反方向没有类似函数。 我们需要能够桥接任何第一层代币，无论第二层支持是否在实施计划。
+此函数提供桥接到此合约的 L1 代币的地址。
+请注意，我们在相反方向没有类似函数。
+我们需要能够桥接任何 L1 代币，无论第二层支持是否在实施计划。
```solidity
@@ -924,11 +984,13 @@ interface IL2StandardERC20 is IERC20, IERC165 {
}
```
-铸造（创建）和燃烧（销毁）代币的函数和事件。 链桥应该是唯一可以运行这些函数的实体，以确保代币数量正确（等于锁定在第一层上的代币数量）。
+铸造（创建）和销毁（销毁）代币的函数和事件。
+链桥应该是唯一可以运行这些函数的实体，以确保代币数量正确（等于锁定在 L1 上的代币数量）。
### L2StandardERC20 {#L2StandardERC20}
-[这是我们对 `IL2StandardERC20` 接口的实现](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol)。 除非你需要某种自定义逻辑，否则你应该使用它。
+[这是我们对 `IL2StandardERC20` 接口的实现](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol)。
+除非你需要某种自定义逻辑，否则你应该使用它。
```solidity
// SPDX-License-Identifier: MIT
@@ -937,7 +999,8 @@ pragma solidity ^0.8.9;
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
```
-[OpenZeppelin ERC-20 合约](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)。 乐观解决方案不相信重新编写合约，尤其是合约经过严格审计并且需要足够的信任来持有资产时。
+[OpenZeppelin ERC-20 合约](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)。
+Optimism 不相信重新发明轮子，尤其是当轮子经过严格审计并且需要足够的信任来持有资产时。
```solidity
import "./IL2StandardERC20.sol";
@@ -952,10 +1015,10 @@ contract L2StandardERC20 is IL2StandardERC20, ERC20 {
```solidity
/**
- * @param _l2Bridge Address of the L2 standard bridge.
- * @param _l1Token Address of the corresponding L1 token.
- * @param _name ERC20 name.
- * @param _symbol ERC20 symbol.
+ * @param _l2Bridge L2 标准链桥的地址。
+ * @param _l1Token 相应 L1 代币的地址。
+ * @param _name ERC20 名称。
+ * @param _symbol ERC20 符号。
*/
constructor(
address _l2Bridge,
@@ -973,7 +1036,7 @@ contract L2StandardERC20 is IL2StandardERC20, ERC20 {
```solidity
modifier onlyL2Bridge() {
- require(msg.sender == l2Bridge, "Only L2 Bridge can mint and burn");
+ require(msg.sender == l2Bridge, "只有 L2 链桥可以铸造和销毁");
_;
}
@@ -988,11 +1051,12 @@ contract L2StandardERC20 is IL2StandardERC20, ERC20 {
}
```
-这是 [ERC-165](https://eips.ethereum.org/EIPS/eip-165) 的工作方式。 每个接口都是许多受支持的函数，并被标识为这些函数的[应用程序二进制接口函数选择器](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector)的[异或](https://en.wikipedia.org/wiki/Exclusive_or)。
+这就是 [ERC-165](https://eips.ethereum.org/EIPS/eip-165) 的工作方式。
+每个接口都是由一系列支持的函数组成，并通过这些函数的 [ABI 函数选择器](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector)的[异或](https://en.wikipedia.org/wiki/Exclusive_or)运算来识别。
-第二层链桥使用 ERC-165 作为完整性检查机制，确保它发送资产的 ERC-20 合约是 `IL2StandardERC20`。
+L2 链桥使用 ERC-165 作为完整性检查，以确保它发送资产的 ERC-20 合约是 `IL2StandardERC20`。
-**注：**没有任何东西可以阻止流氓合约为 `supportsInterface` 提供虚假应答，所以这是一种完整性检查机制_而不是_安全机制。
+**注意：** 没有任何东西可以阻止恶意合约为 `supportsInterface` 提供虚假应答，所以这是一种完整性检查机制而_不是_安全机制。
```solidity
// slither-disable-next-line external-function
@@ -1011,66 +1075,73 @@ contract L2StandardERC20 is IL2StandardERC20, ERC20 {
}
```
-只允许第二层链桥铸造和销毁资产。
+只允许 L2 链桥铸造和销毁资产。
-`_mint` 和 `_burn` 实际上是在 [OpenZeppelin ERC-20 合约](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn)中定义的。 该合约只是没有将它们暴露在外部，因为铸造和销毁代币的条件与 ERC-20 使用方式的数量一样多变。
+`_mint` 和 `_burn` 实际上是在 [OpenZeppelin ERC-20 合约](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn)中定义的。
+该合约只是没有将它们暴露在外部，因为铸造和销毁代币的条件与 ERC-20 使用方式的数量一样多变。
-## 第二层链桥代码 {#l2-bridge-code}
+## L2 链桥代码 {#l2-bridge-code}
-这是在乐观解决方案上运行链桥的代码。 [此合约源自此处](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol)。
+这是在 Optimism 上运行链桥的代码。
+[此合约的源代码在此处](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol)。
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
-/* Interface Imports */
+/* 接口导入 */
import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
```
-[IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) 接口与我们上面看到的[第一层等效](#IL1ERC20Bridge)接口非常相似。 有两个明显区别：
+[IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) 接口与我们上面看到的 [L1 等效接口](#IL1ERC20Bridge)非常相似。
+有两个明显区别：
-1. 在第一层上你发起存款并完成提款。 在此处你发起提款并完成存款。
-2. 在第一层上，有必要区分以太币和 ERC-20 代币。 在第二层上，我们可以对两者使用相同的函数，因为在乐观解决方案上的以太币余额会作为地址为 [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://optimistic.etherscan.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000) 的 ERC-20 代币在内部处理。
+1. 在 L1 上你发起存款并完成取款。
+ 在此处你发起取款并完成存款。
+2. 在 L1 上，有必要区分 ETH 和 ERC-20 代币。
+ 在 L2 上，我们可以对两者使用相同的函数，因为在内部，Optimism 上的 ETH 余额被当作一个地址为 [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://explorer.optimism.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000) 的 ERC-20 代币来处理。
```solidity
-/* Library Imports */
+/* 库导入 */
import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
-/* Contract Imports */
+/* 合约导入 */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
/**
* @title L2StandardBridge
- * @dev The L2 Standard bridge is a contract which works together with the L1 Standard bridge to
- * enable ETH and ERC20 transitions between L1 and L2.
- * This contract acts as a minter for new tokens when it hears about deposits into the L1 Standard
- * bridge.
- * This contract also acts as a burner of the tokens intended for withdrawal, informing the L1
- * bridge to release L1 funds.
+ * @dev L2 标准链桥是一个与 L1 标准链桥协同工作的合约，
+ * 用于在 L1 和 L2 之间实现 ETH 和 ERC20 的转换。
+ * 当该合约监听到 L1 标准
+ * 链桥的存款时，它将充当新代币的铸造者。
+ * 该合约还充当用于取款的代币的销毁者，通知 L1
+ * 链桥释放 L1 资金。
*/
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
/********************************
- * External Contract References *
+ * 外部合约引用 *
********************************/
address public l1TokenBridge;
```
-跟踪第一层链桥的地址。 请注意，与第一层对应项相比，此处我们_需要_该变量。 第一层链桥的地址事先不为人知。
+跟踪 L1 链桥的地址。
+请注意，与 L1 对应项相比，此处我们需要该变量。
+L1 链桥的地址事先不为人知。
```solidity
/***************
- * Constructor *
+ * 构造函数 *
***************/
/**
- * @param _l2CrossDomainMessenger Cross-domain messenger used by this contract.
- * @param _l1TokenBridge Address of the L1 bridge deployed to the main chain.
+ * @param _l2CrossDomainMessenger 此合约使用的跨域信使。
+ * @param _l1TokenBridge 部署到主链的 L1 链桥地址。
*/
constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
CrossDomainEnabled(_l2CrossDomainMessenger)
@@ -1079,7 +1150,7 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
}
/***************
- * Withdrawing *
+ * 取款 *
***************/
/**
@@ -1108,21 +1179,23 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
}
```
-这两个函数发起提款。 请注意，无需指定第一层代币地址。 第二层代币需要告诉我们第一层代币的地址。
+这两个函数发起取款。
+请注意，无需指定 L1 代币地址。
+L2 代币需要告诉我们 L1 代币的地址。
```solidity
/**
- * @dev Performs the logic for withdrawals by burning the token and informing
- * the L1 token Gateway of the withdrawal.
- * @param _l2Token Address of L2 token where withdrawal is initiated.
- * @param _from Account to pull the withdrawal from on L2.
- * @param _to Account to give the withdrawal to on L1.
- * @param _amount Amount of the token to withdraw.
- * @param _l1Gas Unused, but included for potential forward compatibility considerations.
- * @param _data Optional data to forward to L1. This data is provided
- * solely as a convenience for external contracts. Aside from enforcing a maximum
- * length, these contracts provide no guarantees about its content.
+ * @dev 通过销毁代币并通知
+ * L1 代币网关取款来执行取款逻辑。
+ * @param _l2Token 发起取款的 L2 代币地址。
+ * @param _from 在 L2 上提取取款的帐户。
+ * @param _to 在 L1 上给予取款的帐户。
+ * @param _amount 要取款的代币数量。
+ * @param _l1Gas 未使用，但为潜在的向前兼容性考虑而包含。
+ * @param _data 要转发到 L1 的可选数据。此数据
+ * 仅为方便外部合约而提供。除了强制执行最大
+ * 长度外，这些合约对其内容不提供任何保证。
*/
function _initiateWithdrawal(
address _l2Token,
@@ -1132,17 +1205,17 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
uint32 _l1Gas,
bytes calldata _data
) internal {
- // When a withdrawal is initiated, we burn the withdrawer's funds to prevent subsequent L2
- // usage
+ // 当发起取款时，我们销毁取款人的资金以防止后续的 L2
+ // 使用
// slither-disable-next-line reentrancy-events
IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
```
-请注意，我们_不_依赖 `_from` 参数，而是依赖更难伪造的 `msg.sender`（据我所知它无法伪造）。
+请注意，我们不依赖 `_from` 参数，而是依赖更难伪造的 `msg.sender`（据我所知它无法伪造）。
```solidity
- // Construct calldata for l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
+ // 为 l1TokenBridge.finalizeERC20Withdrawal(_to, _amount) 构建 calldata
// slither-disable-next-line reentrancy-events
address l1Token = IL2StandardERC20(_l2Token).l1Token();
bytes memory message;
@@ -1150,7 +1223,7 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
```
-在第一层上，有必要区分以太币和 ERC-20。
+在 L1 上，有必要区分 ETH 和 ERC-20。
```solidity
message = abi.encodeWithSelector(
@@ -1172,7 +1245,7 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
);
}
- // Send message up to L1 bridge
+ // 将消息发送到 L1 链桥
// slither-disable-next-line reentrancy-events
sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
@@ -1181,7 +1254,7 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
}
/************************************
- * Cross-chain Function: Depositing *
+ * 跨链函数：存款 *
************************************/
/**
@@ -1202,11 +1275,12 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
```
-确保信息来源是合法的。 这很重要，因为此函数调用 `_mint` 并且可用于提供链桥在第一层所拥有代币范围外的代币。
+确保消息来源是合法的。
+这很重要，因为此函数调用 `_mint` 并且可用于提供链桥在 L1 所拥有代币范围外的代币。
```solidity
- // Check the target token is compliant and
- // verify the deposited token on L1 matches the L2 deposited token representation here
+ // 检查目标代币是否合规且
+ // 验证 L1 上的存款代币与此处的 L2 存款代币表示匹配
if (
// slither-disable-next-line reentrancy-events
ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
@@ -1216,12 +1290,12 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
完整性检查：
1. 支持正确的接口
-2. 第二层 ERC-20 合约的第一层地址与第一层的代币来源相符
+2. L2 ERC-20 合约的 L1 地址与 L1 的代币来源相符
```solidity
) {
- // When a deposit is finalized, we credit the account on L2 with the same amount of
- // tokens.
+ // 当存款最终确定时，我们会在 L2 上为该帐户记入相同数量的
+ // 代币。
// slither-disable-next-line reentrancy-events
IL2StandardERC20(_l2Token).mint(_to, _amount);
// slither-disable-next-line reentrancy-events
@@ -1235,30 +1309,31 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
```solidity
} else {
- // Either the L2 token which is being deposited-into disagrees about the correct address
- // of its L1 token, or does not support the correct interface.
- // This should only happen if there is a malicious L2 token, or if a user somehow
- // specified the wrong L2 token address to deposit into.
- // In either case, we stop the process here and construct a withdrawal
- // message so that users can get their funds out in some cases.
- // There is no way to prevent malicious token contracts altogether, but this does limit
- // user error and mitigate some forms of malicious contract behavior.
+ // 存入的 L2 代币要么不同意其 L1 代币的正确地址
+ //，要么不支持正确的接口。
+ // 这只应在存在恶意的 L2 代币，或者用户以某种方式
+ // 指定了错误的 L2 代币地址进行存款时发生。
+ // 在任何一种情况下，我们都在此停止该过程并构建一条取款
+ // 消息，以便用户在某些情况下可以取回他们的资金。
+ // 完全防止恶意代币合约是不可能的，但这确实限制了
+ // 用户错误并减轻了某些形式的恶意合约行为。
```
-如果用户由于使用错误的第二层代币地址犯了可检测到的错误，我们希望取消存款并在第一层上返还代币。 在第二层我们可以做到这一点的唯一方法是等到缺陷质询期到来后发送一条信息，但对用户来说这要比永久失去代币好得多。
+如果用户由于使用错误的 L2 代币地址犯了可检测到的错误，我们希望取消存款并在 L1 上返还代币。
+在 L2 我们可以做到这一点的唯一方法是等到故障挑战期到来后发送一条消息，但对用户来说这要比永久失去代币好得多。
```solidity
bytes memory message = abi.encodeWithSelector(
IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
_l1Token,
_l2Token,
- _to, // switched the _to and _from here to bounce back the deposit to the sender
+ _to, // 在这里切换了 _to 和 _from 以将存款退回给发送者
_from,
_amount,
_data
);
- // Send message up to L1 bridge
+ // 将消息发送到 L1 链桥
// slither-disable-next-line reentrancy-events
sendCrossDomainMessage(l1TokenBridge, 0, message);
// slither-disable-next-line reentrancy-events
@@ -1268,10 +1343,15 @@ contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
}
```
-## 总结 {#conclusion}
+## 结论 {#conclusion}
+
+标准链桥是最灵活的资产转移机制。
+然而，由于它非常通用，因而并非总是可供使用的最简便机制。
+特别是对于取款，大多数用户喜欢使用[第三方链桥](https://optimism.io/apps#bridge)，这些链桥不用等待挑战期并且不需要进行默克尔证明就能完成取款。
-标准链桥是最灵活的资产转移机制。 然而，由于它非常笼统，因而并非总是可供使用的最简便机制。 特别是对于提款，大多数用户喜欢使用[第三方链桥](https://optimism.io/apps#bridge)，这些链桥不用等待质询期并且不需要进行默克尔证明就能完成提款。
+通常，这些链桥的工作方式是在 L1 上拥有资产，而且它们会立即为这些资产提供一小笔费用（通常少于标准链桥取款的燃料费用）。
+当链桥（或运行链桥的人）预计 L1 资产短缺时，它将从 L2 转移足够的资产。 由于这些取款的数额非常庞大，大笔的取款费用经分期摊销后，所占百分比要小得多。
-通常，这些链桥的工作方式是在第一层上拥有资产，而且它们会立即为这些资产提供一小笔费用（通常少于标准链桥提款的燃料费用）。 当链桥（或运行链桥的人）预计第一层资产短缺时，它将从第二层转移足够的资产。 由于这些提款的数额非常庞大，大笔的提款费用经分期摊销后，所占百分比要小得多。
+希望本文能帮助你更多地了解第 2 层如何工作以及如何编写清晰安全的 Solidity 代码。
-希望本文能帮助你更多地了解二层网络如何工作以及如何编写清晰安全的 Solidity 代码。
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/reverse-engineering-a-contract/index.md b/public/content/translations/zh/developers/tutorials/reverse-engineering-a-contract/index.md
index 02f7f9b40ad..b7b2a359e57 100644
--- a/public/content/translations/zh/developers/tutorials/reverse-engineering-a-contract/index.md
+++ b/public/content/translations/zh/developers/tutorials/reverse-engineering-a-contract/index.md
@@ -1,158 +1,154 @@
---
title: "对合约进行逆向工程"
-description: 没有源代码时如何理解合约
+description: "没有源代码时如何理解合约"
author: Ori Pomerantz
lang: zh
-tags:
- - "以太坊虚拟机"
- - "操作码"
- - "逆向工程"
- - "反编译器"
+tags: [ "evm", "操作码" ]
skill: advanced
published: 2021-12-30
---
## 简介 {#introduction}
-_区块链上没有秘密_，发生的一切都是持续的、可验证的、公开的。 理想情况下，[应将智能合约的源代码发布到 Etherscan 上进行验证](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code)。 然而，[情况并非总是如此](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code)。 在本文中，你将研究一份没有源代码的合约 [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f)，从而学习如何对合约进行逆向工程。
+_区块链上没有秘密_，发生的一切都是一致、可验证且公开可用的。 理想情况下，[合约的源代码应在 Etherscan 上发布和验证](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code)。 然而，[情况并非总是如此](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code)。 在本文中，你将学习如何通过分析一份没有源代码的合约 [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f) 来对合约进行逆向工程。
-有一些反编译器，但它们不一定能提供[有用的结果](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f)。 在本文中，你将从[操作码](https://github.com/wolflo/evm-opcodes)入手，学习如何对合约手动进行逆向工程并理解合约，以及如何解读反编译器生成的结果。
+反编译器是存在的，但它们并不总能生成[可用的结果](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f)。 在本文中，你将学习如何从[操作码](https://github.com/wolflo/evm-opcodes)入手，手动对合约进行逆向工程并理解合约，以及如何解读反编译器的结果。
-为了能够理解本文，你应当已经了解以太坊虚拟机基础知识，并至少对以太坊虚拟机汇编器有几分熟悉。 [点击此处了解这些主题](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e)。
+为了能够理解本文，你应当已经了解 EVM 基础知识，并至少对 EVM 汇编器有几分熟悉。 [你可以在此处阅读关于这些主题的内容](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e)。
## 准备可执行代码 {#prepare-the-executable-code}
-你可以在 Etherscan 上获得合约的操作码，操作如下：点击 **Contract** 选项卡，然后**切换至 Opcodes 视图**。 你将看到每行有一条操作码。
+你可以通过 Etherscan 获取合约的操作码，点击 **Contract** 选项卡，然后点击 **Switch to Opcodes View**。 你将看到每行有一条操作码的视图。
-
+
-但是，为了能够理解跳转，你需要知道每条操作码在代码中的位置。 为此，一种方式是打开 Google Spreadsheet 并把操作码粘贴到 C 列。[你可以创建这个已制作好的电子表格的副本，从而跳过以下步骤](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing)。
+但是，为了能够理解跳转，你需要知道每条操作码在代码中的位置。 为此，一种方法是打开一个 Google 电子表格并将操作码粘贴到 C 列。[你可以创建这个已准备好的电子表格的副本，从而跳过以下步骤](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing)。
-下一步是获得正确的操作码位置，以便我们能够理解跳转。 我们将操作码大小放入 B 列，操作码位置（十六进制形式）放入 A 列。在单元格 `B1` 中输入下面的函数，然后复制并粘贴到 B 列其余单元格中，直到代码结束。 完成后，你就可以隐藏 B 列。
+下一步是获得正确的代码位置，以便我们能够理解跳转。 我们将操作码大小放入 B 列，位置（十六进制形式）放入 A 列。在单元格 `B1` 中输入此函数，然后复制并粘贴到 B 列的其余单元格中，直到代码结束。 完成后，你就可以隐藏 B 列。
```
=1+IF(REGEXMATCH(C1,"PUSH"),REGEXEXTRACT(C1,"PUSH(\d+)"),0)
```
-首先该函数给操作码增加一个字节，然后查找 `PUSH` 操作码。 Push 操作码比较特殊，因为它们需要额外的字节表示压入的值。 如果操作码是 `PUSH`，我们提取该字节的数值并在函数中增加相应的值。
+首先，该函数为操作码本身添加一个字节，然后查找 `PUSH`。 PUSH 操作码比较特殊，因为它们需要额外的字节表示压入的值。 如果操作码是 `PUSH`，我们就提取字节数并将其加上。
-在 `A1` 单元格中输入第一个偏移量 0。 然后在 `A2` 单元格中，输入下面的函数，并再次将它复制粘贴到 A 列其余他单元格中：
+在 `A1` 单元格中输入第一个偏移量，零。 然后在 `A2` 单元格中，输入此函数，并再次将它复制粘贴到 A 列其余单元格中：
```
=dec2hex(hex2dec(A1)+B1)
```
-我们需要此函数提供十六进制值，因为跳转（`JUMP` 和 `JUMPI`）之前压入的值也是十六进制的。
+我们需要此函数来提供十六进制值，因为在跳转（`JUMP` 和 `JUMPI`）之前压入的值是以十六进制形式给出的。
## 入口点 (0x00) {#the-entry-point-0x00}
-智能合约总会从第一个字节开始执行。 下面是代码的开始部分：
+合约总会从第一个字节开始执行。 下面是代码的初始部分：
-| 偏移量 | 操作码 | 堆栈（在操作码之后） |
-| -----: | ------------ | -------------------- |
-| 0 | PUSH1 0x80 | 0x80 |
-| 2 | PUSH1 0x40 | 0x40, 0x80 |
-| 4 | MSTORE | 空 |
-| 5 | PUSH1 0x04 | 0x04 |
-| 7 | CALLDATASIZE | CALLDATASIZE 0x04 |
-| 8 | LT | CALLDATASIZE\<4 |
-| 9 | PUSH2 0x005e | 0x5E CALLDATASIZE\<4 |
-| C | JUMPI | 空 |
+| 偏移量 | 操作码 | 堆栈（在操作码之后） |
+| --: | ------------ | ---------------------------------------------- |
+| 0 | PUSH1 0x80 | 0x80 |
+| 2 | PUSH1 0x40 | 0x40, 0x80 |
+| 4 | MSTORE | 空 |
+| 5 | PUSH1 0x04 | 0x04 |
+| 7 | CALLDATASIZE | CALLDATASIZE 0x04 |
+| 8 | LT | CALLDATASIZE\<4 |
+| 9 | PUSH2 0x005e | 0x5E CALLDATASIZE\<4 |
+| C | JUMPI | 空 |
这段代码执行了两项操作：
1. 将 0x80 作为一个 32 字节的值写入内存地址 0x40-0x5F（0x80 存储在 0x5F，而 0x40-0x5E 全部都是零）。
-2. 读取 calldata 长度。 通常，以太坊合约的调用数据遵循[应用程序二进制接口](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html)，该接口至少需要四个字节用于函数选择器。 如果调用数据长度小于四个字节，将跳转至 0x5E。
+2. 读取 calldata 大小。 通常，以太坊合约的调用数据遵循[应用二进制接口 (ABI)](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html)，该接口最少需要四个字节的函数选择器。 如果调用数据大小小于四个字节，将跳转至 0x5E。
-
+
-### 0x5E 处的处理程序（用于非应用程序二进制接口数据调用） {#the-handler-at-0x5e-for-non-abi-call-data}
+### 0x5E 处的处理程序（用于非 ABI 调用数据）{#the-handler-at-0x5e-for-non-abi-call-data}
-| 偏移量 | 操作码 |
-| -----: | ------------ |
-| 5E | JUMPDEST |
-| 5F | CALLDATASIZE |
-| 60 | PUSH2 0x007c |
-| 63 | JUMPI |
+| 偏移量 | 操作码 |
+| --: | ------------ |
+| 5E | JUMPDEST |
+| 5F | CALLDATASIZE |
+| 60 | PUSH2 0x007c |
+| 63 | JUMPI |
-此代码片段以 `JUMPDEST` 开头。 如果跳转到的操作码不是 `JUMPDEST`，以太坊虚拟机程序会抛出异常。 然后它查看 CALLDATASIZE，如果为“true”（即非零），则跳转到 0x7C。 我们将在下面讨论。
+此代码片段以 `JUMPDEST` 开头。 如果跳转到的操作码不是 `JUMPDEST`，以太坊虚拟机 (EVM) 程序会抛出异常。 然后它查看 CALLDATASIZE，如果为“true”（即非零），则跳转到 0x7C。 我们将在下面讨论。
-| 偏移量 | 操作码 | 堆栈（在操作码之后） |
-| -----: | ---------- | ----------------------------------------------------------------- |
-| 64 | CALLVALUE | 调用提供的 [Wei](/glossary/#wei)。 在 Solidity 中称为 `msg.value` |
-| 65 | PUSH1 0x06 | 6 CALLVALUE |
-| 67 | PUSH1 0x00 | 0 6 CALLVALUE |
-| 69 | DUP3 | CALLVALUE 0 6 CALLVALUE |
-| 6A | DUP3 | 6 CALLVALUE 0 6 CALLVALUE |
-| 6B | SLOAD | Storage[6] CALLVALUE 0 6 CALLVALUE |
+| 偏移量 | 操作码 | 堆栈（在操作码之后） |
+| --: | ---------- | -------------------------------------------------------------------------------------- |
+| 64 | CALLVALUE | 调用提供的 [Wei](/glossary/#wei)。 在 Solidity 中称为 `msg.value` |
+| 65 | PUSH1 0x06 | 6 CALLVALUE |
+| 67 | PUSH1 0x00 | 0 6 CALLVALUE |
+| 69 | DUP3 | CALLVALUE 0 6 CALLVALUE |
+| 6A | DUP3 | 6 CALLVALUE 0 6 CALLVALUE |
+| 6B | SLOAD | Storage[6] CALLVALUE 0 6 CALLVALUE |
-因此，当没有调用数据时，我们读取 Storage [6] 中的值。 我们还不知道这个值是什么，但我们可以查找合约收到的没有调用数据的交易。 仅转账以太币而没有任何调用数据（因此没有方法）的交易在 Etherscan 中具有方法 `Transfer`。 事实上，[合约收到的第一笔交易](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7)就是转账。
+因此，当没有调用数据时，我们读取 Storage[6] 中的值。 我们还不知道这个值是什么，但我们可以查找合约收到的没有调用数据的交易。 仅转账 ETH 而没有任何调用数据（因此没有方法）的交易在 Etherscan 中的方法为“`Transfer`”。 事实上，[该合约收到的第一笔交易](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7)是一笔转账。
-如果我们查看该交易并点击 **Click to see More**，我们会看到调用数据（称为输入数据）实际上是空的 (`0x`)。 另请注意，值为 1.559 ETH，稍后将介绍。
+如果我们查看该交易并点击\*\*“Click to see More”\*\*（点击查看更多），我们会看到调用数据（称为输入数据）实际上是空的 (`0x`)。 另请注意，值为 1.559 ETH，这与稍后内容有关。
-
+
-接下来，点击 **State** 选项卡并展开我们正在进行逆向工程的合约 (0x2510...)。 可以看到在交易过程中 `Storage[6]` 确实发生了变化，如果你将十六进制更改为**数值**，就会看到该值变成了 1,559,000,000,000,000,000（为了清楚起见，这里添加了逗号），即转账数额（以 wei 为单位），对应于下一个合约价值。
+接下来，点击\*\*“State”**（状态）选项卡并展开我们正在进行逆向工程的合约 (0x2510...)。 可以看到在交易过程中 `Storage[6]` 确实发生了变化，如果你将“Hex”更改为**“Number”\*\*（数值），就会看到该值变成了 1,559,000,000,000,000,000，即转账数额（以 wei 为单位，我为了清楚起见添加了逗号），对应于下一个合约价值。
![Storage[6] 中的变化](storage6.png)
-如果我们查看同一段时间内[其他 `Transfer` 交易](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange)引起的状态变化，就会发现 `Storage[6]` 跟踪一段时间内的合约价值。 现在，我们将其称为 `Value*`。 星号 (`*`) 提醒我们，我们还不*知道*这个变量的作用，但它不会只是跟踪合约价值，因为当你可以使用 `ADDRESS BALANCE` 获取帐户余额时，无需使用非常昂贵的存储。 第一个操作码压入合约地址。 第二个操作码读取堆栈顶部的地址并将其替换为该地址的余额。
+如果我们在[同一时期的其他 `Transfer` 交易](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange)引起的状态变化中查看，会发现 `Storage[6]` 在一段时间内跟踪了合约的价值。 现在，我们将其称为 Value\*。 星号 (\*) 提醒我们，我们还_不_知道这个变量的作用，但它不会只是跟踪合约价值，因为当你可以使用 `ADDRESS BALANCE` 获取帐户余额时，无需使用非常昂贵的存储。 第一个操作码压入合约自己的地址。 第二个操作码读取堆栈顶部的地址并将其替换为该地址的余额。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ------------------------------------------- |
-| 6C | PUSH2 0x0075 | 0x75 Value\* CALLVALUE 0 6 CALLVALUE |
-| 6F | SWAP2 | CALLVALUE Value\* 0x75 0 6 CALLVALUE |
-| 70 | SWAP1 | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 71 | PUSH2 0x01a7 | 0x01A7 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 74 | JUMP | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------- |
+| 6C | PUSH2 0x0075 | 0x75 Value\* CALLVALUE 0 6 CALLVALUE |
+| 6F | SWAP2 | CALLVALUE Value\* 0x75 0 6 CALLVALUE |
+| 70 | SWAP1 | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 71 | PUSH2 0x01a7 | 0x01A7 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 74 | JUMP | |
我们将继续在跳转目标处跟踪此代码。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------- | ----------------------------------------------------------- |
-| 1A7 | JUMPDEST | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1A8 | PUSH1 0x00 | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1AA | DUP3 | CALLVALUE 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1AB | NOT | 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------- | ----------------------------------------------------------- |
+| 1A7 | JUMPDEST | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1A8 | PUSH1 0x00 | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AA | DUP3 | CALLVALUE 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AB | NOT | 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
`NOT` 是按位运算符，因此它反转调用值中每一位的值。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | --------------------------------------------------------------------------- |
-| 1AC | DUP3 | Value\* 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1AD | GT | Value\*>2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1AE | ISZERO | Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1AF | PUSH2 0x01df | 0x01DF Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1B2 | JUMPI | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------------------------------------------------------------------ |
+| 1AC | DUP3 | Value\* 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AD | GT | Value\*>2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AE | ISZERO | Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AF | PUSH2 0x01df | 0x01DF Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1B2 | JUMPI | |
-如果 `Value*` 小于 2^256-CALLVALUE-1 或等于它，则跳转。 这看起来像是防止溢出的逻辑。 事实上，我们看到在偏移量 0x01DE 处进行了一些无意义的操作（例如，写入内存后马上删除）后，如果检测到溢出，合约将回滚，这是正常行为。
+如果 `Value*` 小于或等于 2^256-CALLVALUE-1，则跳转。 这看起来像是防止溢出的逻辑。 事实上，我们看到在偏移量 0x01DE 处进行了一些无意义的操作（例如，写入内存后马上删除）后，如果检测到溢出，合约将回滚，这是正常行为。
-请注意，这种溢出极不可能发生，因为它需要调用值加上 `Value*`，与 2^256 wei 相当，大约 10^59 个以太币。 [在撰写本文时，以太币的总供应量不到两亿个](https://etherscan.io/stat/supply)。
+请注意，这种溢出极不可能发生，因为它需要调用值加上 `Value*`，与 2^256 wei 相当，大约 10^59 个 ETH。 [在撰写本文时，ETH 的总供应量不到两亿个](https://etherscan.io/stat/supply)。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | -------- | ----------------------------------------- |
-| 1DF | JUMPDEST | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1E0 | POP | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
-| 1E1 | ADD | Value\*+CALLVALUE 0x75 0 6 CALLVALUE |
-| 1E2 | SWAP1 | 0x75 Value\*+CALLVALUE 0 6 CALLVALUE |
-| 1E3 | JUMP | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | -------- | ----------------------------------------- |
+| 1DF | JUMPDEST | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E0 | POP | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E1 | ADD | Value\*+CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E2 | SWAP1 | 0x75 Value\*+CALLVALUE 0 6 CALLVALUE |
+| 1E3 | JUMP | |
如果执行到此处，获取 `Value* + CALLVALUE` 并跳转到偏移量 0x75 处。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | -------- | ------------------------------- |
-| 75 | JUMPDEST | Value\*+CALLVALUE 0 6 CALLVALUE |
-| 76 | SWAP1 | 0 Value\*+CALLVALUE 6 CALLVALUE |
-| 77 | SWAP2 | 6 Value\*+CALLVALUE 0 CALLVALUE |
-| 78 | SSTORE | 0 CALLVALUE |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | -------- | ------------------------------- |
+| 75 | JUMPDEST | Value\*+CALLVALUE 0 6 CALLVALUE |
+| 76 | SWAP1 | 0 Value\*+CALLVALUE 6 CALLVALUE |
+| 77 | SWAP2 | 6 Value\*+CALLVALUE 0 CALLVALUE |
+| 78 | SSTORE | 0 CALLVALUE |
-如果执行到此处（要求调用数据为空），我们将调用值添加到 `Value*`。 这与我们所说的 `Transfer` 交易的操作是一致的。
+如果执行到此处（要求调用数据为空），我们将调用值添加到 `Value*`。 这与我们所说的 `Transfer` 交易所做的事情是一致的。
-| 偏移量 | 操作码 |
-| -----: | ------ |
-| 79 | POP |
-| 7A | POP |
-| 7B | STOP |
+| 偏移量 | 操作码 |
+| --: | ---- |
+| 79 | POP |
+| 7A | POP |
+| 7B | STOP |
最后，清除堆栈（并非必需）并表明交易成功结束。
@@ -160,7 +156,7 @@ _区块链上没有秘密_，发生的一切都是持续的、可验证的、公
-## 0x7C 的处理程序 {#the-handler-at-0x7c}
+## 0x7C 处的处理程序 {#the-handler-at-0x7c}
我特意没有将此处理程序的作用写入标题中。 重点不是教你这个特定的合约如何运作，而是如何对合约进行逆向工程。 你和我一样，都通过观察代码了解该合约的作用。
@@ -169,86 +165,86 @@ _区块链上没有秘密_，发生的一切都是持续的、可验证的、公
- 如果调用数据包含 1、2 或 3 个字节（从偏移量 0x63 处开始）
- 如果方法签名未知（从偏移量 0x42 和 0x5D 处开始）
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | -------------------- |
-| 7C | JUMPDEST | |
-| 7D | PUSH1 0x00 | 0x00 |
-| 7F | PUSH2 0x009d | 0x9D 0x00 |
-| 82 | PUSH1 0x03 | 0x03 0x9D 0x00 |
-| 84 | SLOAD | Storage[3] 0x9D 0x00 |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------------------------------------ |
+| 7C | JUMPDEST | |
+| 7D | PUSH1 0x00 | 0x00 |
+| 7F | PUSH2 0x009d | 0x9D 0x00 |
+| 82 | PUSH1 0x03 | 0x03 0x9D 0x00 |
+| 84 | SLOAD | Storage[3] 0x9D 0x00 |
这是另一个存储单元，我在任何交易中都找不到它，所以很难知道它的含义。 下面的代码将使其更明确。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------------------------------------------- | ------------------------------- |
-| 85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff Storage[3] 0x9D 0x00 |
-| 9A | AND | Storage[3]-as-address 0x9D 0x00 |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff Storage[3] 0x9D 0x00 |
+| 9A | AND | Storage[3]-as-address 0x9D 0x00 |
上面的操作码将我们从 Storage[3] 读取的值截断为 160 位，即以太坊地址的长度。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------ | ------------------------------- |
-| 9B | SWAP1 | 0x9D Storage[3]-as-address 0x00 |
-| 9C | JUMP | Storage[3]-as-address 0x00 |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ----- | ----------------------------------------------------------------------------------- |
+| 9B | SWAP1 | 0x9D Storage[3]-as-address 0x00 |
+| 9C | JUMP | Storage[3]-as-address 0x00 |
上面的跳转是多余的，因为我们要执行下一个操作码。 这个代码远不如它本应该的那样具有燃料效率。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------- | ------------------------------- |
-| 9D | JUMPDEST | Storage[3]-as-address 0x00 |
-| 9E | SWAP1 | 0x00 Storage[3]-as-address |
-| 9F | POP | Storage[3]-as-address |
-| A0 | PUSH1 0x40 | 0x40 Storage[3]-as-address |
-| A2 | MLOAD | Mem[0x40] Storage[3]-as-address |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| 9D | JUMPDEST | Storage[3]-as-address 0x00 |
+| 9E | SWAP1 | 0x00 Storage[3]-as-address |
+| 9F | POP | Storage[3]-as-address |
+| A0 | PUSH1 0x40 | 0x40 Storage[3]-as-address |
+| A2 | MLOAD | Mem[0x40] Storage[3]-as-address |
在代码的最开始，我们将 Mem[0x40] 设置为 0x80。 如果我们在后面部分查找 0x40，会发现我们没有更改它 - 所以我们可以假设它是 0x80。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ------------------------------------------------- |
-| A3 | CALLDATASIZE | CALLDATASIZE 0x80 Storage[3]-as-address |
-| A4 | PUSH1 0x00 | 0x00 CALLDATASIZE 0x80 Storage[3]-as-address |
-| A6 | DUP3 | 0x80 0x00 CALLDATASIZE 0x80 Storage[3]-as-address |
-| A7 | CALLDATACOPY | 0x80 Storage[3]-as-address |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ----------------------------------------------------------------------------------------------------- |
+| A3 | CALLDATASIZE | CALLDATASIZE 0x80 Storage[3]-as-address |
+| A4 | PUSH1 0x00 | 0x00 CALLDATASIZE 0x80 Storage[3]-as-address |
+| A6 | DUP3 | 0x80 0x00 CALLDATASIZE 0x80 Storage[3]-as-address |
+| A7 | CALLDATACOPY | 0x80 Storage[3]-as-address |
将所有调用数据复制到内存，从 0x80 处开始。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------- | -------------------------------------------------------------------------------- |
-| A8 | PUSH1 0x00 | 0x00 0x80 Storage[3]-as-address |
-| AA | DUP1 | 0x00 0x00 0x80 Storage[3]-as-address |
-| AB | CALLDATASIZE | CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
-| AC | DUP4 | 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
-| AD | DUP6 | Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
-| AE | GAS | GAS Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
-| AF | DELEGATE_CALL | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A8 | PUSH1 0x00 | 0x00 0x80 Storage[3]-as-address |
+| AA | DUP1 | 0x00 0x00 0x80 Storage[3]-as-address |
+| AB | CALLDATASIZE | CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
+| AC | DUP4 | 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
+| AD | DUP6 | Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
+| AE | GAS | GAS Storage[3]-as-address 0x80 CALLDATASIZE 0x00 0x00 0x80 Storage[3]-as-address |
+| AF | DELEGATE_CALL | |
现在事情清楚了很多。 此合约可以作为[代理](https://blog.openzeppelin.com/proxy-patterns/)，调用 Storage[3] 中的地址来完成真实的工作。 `DELEGATE_CALL` 调用另一个合约，但它保存在同一个存储中。 这意味着我们代理的受委托合约访问相同的存储空间。 调用的参数如下：
- _燃料_：所有剩余的燃料
- _调用地址_：Storage[3] 做为地址
- _调用数据_：从 0x80 开始的 CALLDATASIZE 字节数，0x80 是我们存入初始调用数据的位置
-- _返回数据_：None (0x00 - 0x00) 我们将通过其他方式获取返回数据（见下文）
+- _返回数据_：无 (0x00 - 0x00) 我们将通过其他方式获取返回数据（见下文）
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | -------------- | --------------------------------------------------------------------------------------------- |
-| B0 | RETURNDATASIZE | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B1 | DUP1 | RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B2 | PUSH1 0x00 | 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B4 | DUP5 | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B5 | RETURNDATACOPY | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| B0 | RETURNDATASIZE | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B1 | DUP1 | RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B2 | PUSH1 0x00 | 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B4 | DUP5 | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B5 | RETURNDATACOPY | RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
此处，我们将所有返回数据复制到从 0x80 开始的内存缓冲区。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ---------------------------------------------------------------------------------------------------------------------------- |
-| B6 | DUP2 | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B7 | DUP1 | (((call success/failure))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B8 | ISZERO | (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| B9 | PUSH2 0x00c0 | 0xC0 (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| BC | JUMPI | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| BD | DUP2 | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| BE | DUP5 | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| BF | RETURN | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| B6 | DUP2 | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B7 | DUP1 | (((call success/failure))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B8 | ISZERO | (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| B9 | PUSH2 0x00c0 | 0xC0 (((did the call fail))) (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| BC | JUMPI | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| BD | DUP2 | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| BE | DUP5 | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| BF | RETURN | |
因此在调用之后，我们将返回数据复制到缓冲区 0x80 - 0x80+RETURNDATASIZE，如果调用成功，我们将准确地 `RETURN` 该缓冲区。
@@ -256,106 +252,106 @@ _区块链上没有秘密_，发生的一切都是持续的、可验证的、公
如果执行到此处，即到达 0xC0，意味着我们调用的合约已回滚。 由于我们只是该合约的代理，我们希望返回相同的数据并且也回滚。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | -------- | ------------------------------------------------------------------------------------------------------------------- |
-| C0 | JUMPDEST | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| C1 | DUP2 | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| C2 | DUP5 | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
-| C3 | REVERT | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| C0 | JUMPDEST | (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| C1 | DUP2 | RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| C2 | DUP5 | 0x80 RETURNDATASIZE (((call success/failure))) RETURNDATASIZE (((call success/failure))) 0x80 Storage[3]-as-address |
+| C3 | REVERT | |
所以我们 `REVERT` 至我们之前用于 `RETURN` 的相同缓冲区：0x80 - 0x80+RETURNDATASIZE
-## 应用程序二进制接口调用 {#abi-calls}
+## ABI 调用 {#abi-calls}
-如果调用数据长度为四个字节或更多，这可能是一个有效的应用程序二进制接口调用。
+如果调用数据大小为四个字节或更多，这可能是一个有效的 ABI 调用。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ------------------------------------------------- |
-| D | PUSH1 0x00 | 0x00 |
-| F | CALLDATALOAD | (((First word (256 bits) of the call data))) |
-| 10 | PUSH1 0xe0 | 0xE0 (((First word (256 bits) of the call data))) |
-| 12 | SHR | (((first 32 bits (4 bytes) of the call data))) |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | -------------------------------------------------------------------------------------------------------- |
+| D | PUSH1 0x00 | 0x00 |
+| F | CALLDATALOAD | (((调用数据的第一个字 (256 位)))) |
+| 10 | PUSH1 0xe0 | 0xE0 (((调用数据的第一个字 (256 位)))) |
+| 12 | SHR | (((调用数据的前 32 位 (4 字节)))) |
-Etherscan 指出 `1C` 是一个未知操作码，因为[它是在 Etherscan 编写此功能后添加的](https://eips.ethereum.org/EIPS/eip-145)并且还没有更新。 [最新操作码表](https://github.com/wolflo/evm-opcodes)告诉我们这是右移操作。
+Etherscan 指出 `1C` 是一个未知操作码，因为它是在 Etherscan 编写此功能[之后添加的](https://eips.ethereum.org/EIPS/eip-145)并且他们还没有更新。 [最新的操作码表](https://github.com/wolflo/evm-opcodes)显示这是右移
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------------- | -------------------------------------------------------------------------------------------------------- |
-| 13 | DUP1 | (((呼叫数据的前 32 位(4 字节))))(((呼叫数据的前 32 位(4 字节)))) |
-| 14 | PUSH4 0x3cd8045e | 0x3CD8045E (((first 32 bits (4 bytes) of the call data))) (((first 32 bits (4 bytes) of the call data))) |
-| 19 | GT | 0x3CD8045E>first-32-bits-of-the-call-data (((first 32 bits (4 bytes) of the call data))) |
-| 1A | PUSH2 0x0043 | 0x43 0x3CD8045E>first-32-bits-of-the-call-data (((first 32 bits (4 bytes) of the call data))) |
-| 1D | JUMPI | (((first 32 bits (4 bytes) of the call data))) |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 13 | DUP1 | (((调用数据的前 32 位 (4 字节)))) (((调用数据的前 32 位 (4 字节)))) |
+| 14 | PUSH4 0x3cd8045e | 0x3CD8045E (((调用数据的前 32 位 (4 字节)))) (((调用数据的前 32 位 (4 字节)))) |
+| 19 | GT | 0x3CD8045E>first-32-bits-of-the-call-data (((调用数据的前 32 位 (4 字节)))) |
+| 1A | PUSH2 0x0043 | 0x43 0x3CD8045E>first-32-bits-of-the-call-data (((调用数据的前 32 位 (4 字节)))) |
+| 1D | JUMPI | (((调用数据的前 32 位 (4 字节)))) |
-通过像这样将方法签名匹配测试一分为二，平均可以省去一半的测试。 紧随其后的代码和 0x43 处的代码遵循相同的模式：`DUP1` 调用数据的前 32 位，`PUSH4 (((method signature> `，运行 `EQ` 检查是否相等，然后如果方法签名匹配，`JUMPI`。 以下是方法签名、它们的地址以及[相应的方法定义](https://www.4byte.directory/)（如果已知）：
+通过像这样将方法签名匹配测试一分为二，平均可以省去一半的测试。 紧随其后的代码和 0x43 处的代码遵循相同的模式：`DUP1` 调用数据的前 32 位，`PUSH4 (((方法签名))`，运行 `EQ` 检查是否相等，然后如果方法签名匹配，`JUMPI`。 以下是方法签名、它们的地址以及[相应的方法定义](https://www.4byte.directory/)（如果已知）：
-| 方法 | 方法签名 | 跳转到的偏移量 |
-| -------------------------------------------------------------------------------------- | ---------- | -------------- |
-| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e) | 0x3cd8045e | 0x0103 |
-| ??? | 0x81e580d3 | 0x0138 |
-| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4 | 0x0158 |
-| ??? | 0x1f135823 | 0x00C4 |
-| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab) | 0x2eb4a7ab | 0x00ED |
+| 方法 | 方法签名 | 跳转到的偏移量 |
+| --------------------------------------------------------------------------------------------------------- | ---------- | ------- |
+| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e) | 0x3cd8045e | 0x0103 |
+| ??? | 0x81e580d3 | 0x0138 |
+| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4 | 0x0158 |
+| ??? | 0x1f135823 | 0x00C4 |
+| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab) | 0x2eb4a7ab | 0x00ED |
-如果没有找到匹配项，代码跳转到 [0x7C 处的代理处理程序](#the-handler-at-0x7c)，指望我们作为代理的合约有匹配项。
+如果没有找到匹配项，代码会跳转到[位于 0x7C 的代理处理程序](#the-handler-at-0x7c)，寄希望于我们所代理的合约有匹配项。
-
+
## splitter() {#splitter}
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ----------------------------- |
-| 103 | JUMPDEST | |
-| 104 | CALLVALUE | CALLVALUE |
-| 105 | DUP1 | CALLVALUE CALLVALUE |
-| 106 | ISZERO | CALLVALUE 0 CALLVALUE |
-| 107 | PUSH2 0x01df | 0x010F CALLVALUE==0 CALLVALUE |
-| 10A | JUMPI | CALLVALUE |
-| 10B | PUSH1 0x00 | 0x00 CALLVALUE |
-| 10D | DUP1 | 0x00 0x00 CALLValUE |
-| 10E | REVERT | |
-
-此函数首先检查调用没有发送任何以太币。 此函数不是 [`payable`](https://solidity-by-example.org/payable/)。 如果有人向我们发送了以太币，而那肯定是误发，我们希望 `REVERT` 以避免将此以太币放入他们无法取回的位置。
-
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------------------------------------------- | --------------------------------------------------------------------------- |
-| 10F | JUMPDEST | |
-| 110 | POP | |
-| 111 | PUSH1 0x03 | 0x03 |
-| 113 | SLOAD | (((Storage[3] a.k.a the contract for which we are a proxy))) |
-| 114 | PUSH1 0x40 | 0x40 (((Storage[3] a.k.a the contract for which we are a proxy))) |
-| 116 | MLOAD | 0x80 (((Storage[3] a.k.a the contract for which we are a proxy))) |
-| 117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((Storage[3] a.k.a the contract for which we are a proxy))) |
-| 12C | SWAP1 | 0x80 0xFF...FF (((Storage[3] a.k.a the contract for which we are a proxy))) |
-| 12D | SWAP2 | (((Storage[3] a.k.a the contract for which we are a proxy))) 0xFF...FF 0x80 |
-| 12E | AND | ProxyAddr 0x80 |
-| 12F | DUP2 | 0x80 ProxyAddr 0x80 |
-| 130 | MSTORE | 0x80 |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ----------------------------- |
+| 103 | JUMPDEST | |
+| 104 | CALLVALUE | CALLVALUE |
+| 105 | DUP1 | CALLVALUE CALLVALUE |
+| 106 | ISZERO | CALLVALUE==0 CALLVALUE |
+| 107 | PUSH2 0x010f | 0x010F CALLVALUE==0 CALLVALUE |
+| 10A | JUMPI | CALLVALUE |
+| 10B | PUSH1 0x00 | 0x00 CALLVALUE |
+| 10D | DUP1 | 0x00 0x00 CALLVALUE |
+| 10E | REVERT | |
+
+此函数首先检查调用没有发送任何 ETH。 此函数不是 [`payable`](https://solidity-by-example.org/payable/)。 如果有人向我们发送了 ETH，而那肯定是误发，我们希望 `REVERT` 以避免将此 ETH 放入他们无法取回的位置。
+
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 10F | JUMPDEST | |
+| 110 | POP | |
+| 111 | PUSH1 0x03 | 0x03 |
+| 113 | SLOAD | (((Storage[3] 又名我们作为代理的合约))) |
+| 114 | PUSH1 0x40 | 0x40 (((Storage[3] 又名我们作为代理的合约))) |
+| 116 | MLOAD | 0x80 (((Storage[3] 又名我们作为代理的合约))) |
+| 117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((Storage[3] 又名我们作为代理的合约))) |
+| 12C | SWAP1 | 0x80 0xFF...FF (((Storage[3] 又名我们作为代理的合约))) |
+| 12D | SWAP2 | (((Storage[3] 又名我们作为代理的合约))) 0xFF...FF 0x80 |
+| 12E | AND | ProxyAddr 0x80 |
+| 12F | DUP2 | 0x80 ProxyAddr 0x80 |
+| 130 | MSTORE | 0x80 |
0x80 现在包含代理地址
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | --------- |
-| 131 | PUSH1 0x20 | 0x20 0x80 |
-| 133 | ADD | 0xA0 |
-| 134 | PUSH2 0x00e4 | 0xE4 0xA0 |
-| 137 | JUMP | 0xA0 |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | --------- |
+| 131 | PUSH1 0x20 | 0x20 0x80 |
+| 133 | ADD | 0xA0 |
+| 134 | PUSH2 0x00e4 | 0xE4 0xA0 |
+| 137 | JUMP | 0xA0 |
### E4 代码 {#the-e4-code}
这是我们第一次看到这些行，但它们与其他方法是共享的（见下文）。 所以我们将调用堆栈 X 中的值，记住在 `splitter()` 中此 X 的值是 0xA0。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------- | ----------- |
-| E4 | JUMPDEST | X |
-| E5 | PUSH1 0x40 | 0x40 X |
-| E7 | MLOAD | 0x80 X |
-| E8 | DUP1 | 0x80 0x80 X |
-| E9 | SWAP2 | X 0x80 0x80 |
-| EA | SUB | X-0x80 0x80 |
-| EB | SWAP1 | 0x80 X-0x80 |
-| EC | RETURN | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------- | ----------- |
+| E4 | JUMPDEST | X |
+| E5 | PUSH1 0x40 | 0x40 X |
+| E7 | MLOAD | 0x80 X |
+| E8 | DUP1 | 0x80 0x80 X |
+| E9 | SWAP2 | X 0x80 0x80 |
+| EA | SUB | X-0x80 0x80 |
+| EB | SWAP1 | 0x80 X-0x80 |
+| EC | RETURN | |
因此，此代码接收堆栈 (X) 中一个内存指针，并导致合约 `RETURN` 缓冲区 0x80 - X。
@@ -363,224 +359,224 @@ Etherscan 指出 `1C` 是一个未知操作码，因为[它是在 Etherscan 编
## currentWindow() {#currentwindow}
-偏移量 0x158-0x163 中的代码与我们在 `splitter()` 中看到的 0x103-0x10E 中的代码相同（除 `JUMPI` 目标地址外），因此我们知道 `currentWindow ()` 也不是 `payable`。
+偏移量 0x158-0x163 中的代码与我们在 `splitter()` 中看到的 0x103-0x10E 中的代码相同（除 `JUMPI` 目标地址外），因此我们知道 `currentWindow()` 也不是 `payable`。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | -------------------- |
-| 164 | JUMPDEST | |
-| 165 | POP | |
-| 166 | PUSH2 0x00da | 0xDA |
-| 169 | PUSH1 0x01 | 0x01 0xDA |
-| 16B | SLOAD | Storage[1] 0xDA |
-| 16C | DUP2 | 0xDA Storage[1] 0xDA |
-| 16D | JUMP | Storage[1] 0xDA |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------------------------------------ |
+| 164 | JUMPDEST | |
+| 165 | POP | |
+| 166 | PUSH2 0x00da | 0xDA |
+| 169 | PUSH1 0x01 | 0x01 0xDA |
+| 16B | SLOAD | Storage[1] 0xDA |
+| 16C | DUP2 | 0xDA Storage[1] 0xDA |
+| 16D | JUMP | Storage[1] 0xDA |
### DA 代码 {#the-da-code}
此代码也与其他方法共享。 所以我们将调用堆栈 Y 中的值，并且记住在 `currentWindow()` 中这个 Y 的值是 Storage[1]。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------- | ---------------- |
-| DA | JUMPDEST | Y 0xDA |
-| DB | PUSH1 0x40 | 0x40 Y 0xDA |
-| DD | MLOAD | 0x80 Y 0xDA |
-| DE | SWAP1 | Y 0x80 0xDA |
-| DF | DUP2 | 0x80 Y 0x80 0xDA |
-| E0 | MSTORE | 0x80 Y 0xDA |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------- | ---------------- |
+| DA | JUMPDEST | Y 0xDA |
+| DB | PUSH1 0x40 | 0x40 Y 0xDA |
+| DD | MLOAD | 0x80 Y 0xDA |
+| DE | SWAP1 | Y 0x80 0xDA |
+| DF | DUP2 | 0x80 Y 0x80 0xDA |
+| E0 | MSTORE | 0x80 0xDA |
将 Y 写入 0x80-0x9F。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ---------- | -------------- |
-| E1 | PUSH1 0x20 | 0x20 0x80 0xDA |
-| E3 | ADD | 0xA0 0xDA |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ---------- | -------------- |
+| E1 | PUSH1 0x20 | 0x20 0x80 0xDA |
+| E3 | ADD | 0xA0 0xDA |
其余部分已在[上面](#the-e4-code)解释过。 所以跳转到 0xDA，将栈顶 (Y) 的值写入 0x80-0x9F，并返回该值。 对于 `currentWindow()` 方法，返回 Storage[1]。
## merkleRoot() {#merkleroot}
-偏移量 0xED-0xF8 中的代码与我们在 `splitter()` 中看到的 0x103-0x10E 中的代码相同（除 `JUMPI` 目标地址外），因此我们知道 `merkleRoot ()` 也不是 `payable`。
+偏移量 0xED-0xF8 中的代码与我们在 `splitter()` 中看到的 0x103-0x10E 中的代码相同（除 `JUMPI` 目标地址外），因此我们知道 `merkleRoot()` 也不是 `payable`。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | -------------------- |
-| F9 | JUMPDEST | |
-| FA | POP | |
-| FB | PUSH2 0x00da | 0xDA |
-| FE | PUSH1 0x00 | 0x00 0xDA |
-| 100 | SLOAD | Storage[0] 0xDA |
-| 101 | DUP2 | 0xDA Storage[0] 0xDA |
-| 102 | JUMP | Storage[0] 0xDA |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------------------------------------ |
+| F9 | JUMPDEST | |
+| FA | POP | |
+| FB | PUSH2 0x00da | 0xDA |
+| FE | PUSH1 0x00 | 0x00 0xDA |
+| 100 | SLOAD | Storage[0] 0xDA |
+| 101 | DUP2 | 0xDA Storage[0] 0xDA |
+| 102 | JUMP | Storage[0] 0xDA |
-[我们已经弄清楚了](#the-da-code)跳转后会发生什么。 嗯，`merkleRoot()` 返回 Storage[0]。
+我们已经弄清楚了[跳转后会发生什么](#the-da-code)。 所以，`merkleRoot()` 返回 Storage[0]。
## 0x81e580d3 {#0x81e580d3}
偏移量 0x138-0x143 中的代码与我们在 `splitter()` 中看到的 0x103-0x10E 中的代码相同（除 `JUMPI` 目标地址外），因此我们知道此函数也不是 `payable`。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ------------------------------------------------------------ |
-| 144 | JUMPDEST | |
-| 145 | POP | |
-| 146 | PUSH2 0x00da | 0xDA |
-| 149 | PUSH2 0x0153 | 0x0153 0xDA |
-| 14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA |
-| 14D | PUSH1 0x04 | 0x04 CALLDATASIZE 0x0153 0xDA |
-| 14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA |
-| 152 | JUMP | 0x04 CALLDATASIZE 0x0153 0xDA |
-| 18F | JUMPDEST | 0x04 CALLDATASIZE 0x0153 0xDA |
-| 190 | PUSH1 0x00 | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 192 | PUSH1 0x20 | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 194 | DUP3 | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 195 | DUP5 | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 196 | SUB | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 197 | SLT | CALLDATASIZE-4\<32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 198 | ISZERO | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 19C | JUMPI | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------------ | ------------------------------------------------------------------------------- |
+| 144 | JUMPDEST | |
+| 145 | POP | |
+| 146 | PUSH2 0x00da | 0xDA |
+| 149 | PUSH2 0x0153 | 0x0153 0xDA |
+| 14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA |
+| 14D | PUSH1 0x04 | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA |
+| 152 | JUMP | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 18F | JUMPDEST | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 190 | PUSH1 0x00 | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 192 | PUSH1 0x20 | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 194 | DUP3 | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 195 | DUP5 | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 196 | SUB | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 197 | SLT | CALLDATASIZE-4\<32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 198 | ISZERO | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19C | JUMPI | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
看起来此函数至少使用调用数据的 32 个字节（一个字）。
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------ | -------------------------------------------- |
-| 19D | DUP1 | 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 19E | DUP2 | 0x00 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
-| 19F | REVERT | |
+| 偏移量 | 操作码 | 堆栈 |
+| --: | ------ | -------------------------------------------- |
+| 19D | DUP1 | 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19E | DUP2 | 0x00 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19F | REVERT | |
如果此函数没有获得调用数据，则交易将回滚且不会任何返回数据。
-我们来看看，如果此函数*确实*获得了它需要的调用数据，会出现什么情况。
-
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ---------------------------------------- |
-| 1A0 | JUMPDEST | 0x00 0x04 CALLDATASIZE 0x0153 0xD |
-| 1A1 | POP | 0x04 CALLDATASIZE 0x0153 0xDA |
-| 1A2 | CALLDATALOAD | calldataload(4) CALLDATASIZE 0x0153 0xDA |
-
-`calldataload(4)` 是在方法签名*之后*调用数据的第一个字
-
-| 偏移量 | 操作码 | 堆栈 |
-| -----: | ------------ | ---------------------------------------------------------------------------- |
-| 1A3 | SWAP2 | 0x0153 CALLDATASIZE calldataload(4) 0xDA |
-| 1A4 | SWAP1 | CALLDATASIZE 0x0153 calldataload(4) 0xDA |
-| 1A5 | POP | 0x0153 calldataload(4) 0xDA |
-| 1A6 | JUMP | calldataload(4) 0xDA |
-| 153 | JUMPDEST | calldataload(4) 0xDA |
-| 154 | PUSH2 0x016e | 0x016E calldataload(4) 0xDA |
-| 157 | JUMP | calldataload(4) 0xDA |
-| 16E | JUMPDEST | calldataload(4) 0xDA |
-| 16F | PUSH1 0x04 | 0x04 calldataload(4) 0xDA |
-| 171 | DUP2 | calldataload(4) 0x04 calldataload(4) 0xDA |
-| 172 | DUP2 | 0x04 calldataload(4) 0x04 calldataload(4) 0xDA |
-| 173 | SLOAD | Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA |
-| 174 | DUP2 | calldataload(4) Storage[4] calldataload(4) 0x04 calldataload(4) 0xDA |
-| 175 | LT | calldataload(4)\)`，另一个是`isClaimed()`，所以此合约看起来像一个空投合约。 我们可以[尝试使用反编译器](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761)，而不是逐个操作码查看其余代码，反编译器会为此合约中的以下三个函数生成有用的结果。 其他合约的逆向工程留给读者作为练习。
+在剩下方法中，其中一个是 `claim()`，另一个是 `isClaimed()`，所以此合约看起来像一个空投合约。 我们可以[尝试使用反编译器](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761)，而不是逐个操作码查看其余代码，反编译器会为此合约中的三个函数生成有用的结果。 其他合约的逆向工程留给读者作为练习。
### scaleAmountByPercentage {#scaleamountbypercentage}
@@ -588,7 +584,7 @@ Etherscan 指出 `1C` 是一个未知操作码，因为[它是在 Etherscan 编
```python
def unknown8ffb5c97(uint256 _param1, uint256 _param2) payable:
- require calldata.size - 4 >=′ 64
+ require calldata.size - 4 >= 64
if _param1 and _param2 > -1 / _param1:
revert with 0, 17
return (_param1 * _param2 / 100 * 10^6)
@@ -610,18 +606,18 @@ def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _pa
require _param2 == addr(_param2)
...
if currentWindow <= _param1:
- revert with 0, 'cannot claim for a future window'
+ revert with 0, '不能为未来的窗口申领'
```
我们在这里看到两件重要的事情：
-- `_param2`，虽然被声明为 `uint256`，但实际上是一个地址
+- `_param2` 虽然被声明为 `uint256`，但实际上是一个地址
- `_param1` 是被声明的窗口，它必须是 `currentWindow` 或更早。
```python
...
if stor5[_claimWindow][addr(_claimFor)]:
- revert with 0, 'Account already claimed the given window'
+ revert with 0, '帐户已申领指定窗口'
```
所以现在我们知道 Storage[5] 是一个窗口和地址数组，并知道该地址是否申领了此窗口内奖励。
@@ -641,10 +637,10 @@ def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _pa
s = sha3(mem[_66 + 32 len mem[_66]])
continue
if unknown2eb4a7ab != s:
- revert with 0, 'Invalid proof'
+ revert with 0, '无效证明'
```
-我们知道 `unknown2eb4a7ab` 实际上是函数 `merkleRoot()`，所以此代码看起来像是在验证一个[默克尔证明](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5)。 这意味着 `_param4` 是默克尔证明。
+我们知道 `unknown2eb4a7ab` 实际上是 `merkleRoot()` 函数，所以这段代码看起来像是在验证[默克尔证明](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5)。 这意味着 `_param4` 是默克尔证明。
```python
call addr(_param2) with:
@@ -652,7 +648,7 @@ def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _pa
gas 30000 wei
```
-这就是合约将自己的以太币转账到另一个地址（合约地址或外部地址）的方式。 它使用一个值来调用该函数，该值是要转账的金额。 因此，该合约看起来像是一次以太币空投。
+这就是合约将自己的 ETH 转账到另一个地址（合约地址或外部地址）的方式。 它使用一个值来调用该函数，该值是要转账的金额。 因此，该合约看起来像是一次 ETH 空投。
```python
if not return_data.size:
@@ -662,22 +658,22 @@ def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _pa
value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
```
-下面两行表明 Storage[2] 也是我们调用的合约。 如果我们[查阅构造函数交易](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange)，就会看到此合约是 [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)，即一个封装的以太币合约，[其源代码已经上传到 Etherscan](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code)。
+下面两行表明 Storage[2] 也是我们调用的合约。 如果[查看构造函数交易](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange)，会发现此合约是 [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)，一个封装以太币合约，其[源代码已上传到 Etherscan](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code)。
-是的，看起来这些合约试图将以太币发送到 `_param2`。 如果它可以做到，那就太好了。 如果做不到，它会尝试发送 [WETH](https://weth.tkn.eth.limo/)。 如果 `_param2` 是外部帐户(EOA)，那么它总是可以收到以太币，但合约帐户可以拒绝接收以太币。 但是，WETH 是 ERC-20，合约不能拒绝接受。
+所以看起来这些合约试图将 ETH 发送到 `_param2`。 如果可以，那就太好了。 如果不行，它会尝试发送 [WETH](https://weth.tkn.eth.limo/)。 如果 `_param2` 是外部帐户 (EOA)，那么它总是可以收到 ETH，但合约帐户可以拒绝接收 ETH。 但是，WETH 是 ERC-20，合约不能拒绝接受。
```python
...
log 0xdbd5389f: addr(_param2), unknown81e580d3[_param1] * _param3 / 100 * 10^6, bool(ext_call.success)
```
-在此函数结束时，我们看到正在生成一个日志项。 [查看生成的日志项](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events)并筛选以 `0xdbd5...` 开头的主题。 如果[点击生成此类项的其中一个交易](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274)，我们会看到它确实看起来像一个声明 - 该帐户向我们进行逆向工程的合约发送一条消息并获得了以太币。
+在此函数结束时，我们看到正在生成一个日志项。 [查看生成的日志条目](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events)并以 `0xdbd5...` 开头的主题进行筛选。 如果[点击生成此类条目的其中一个交易](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274)，我们会看到它确实看起来像一个申领 - 该帐户向我们进行逆向工程的合约发送一条消息并获得了 ETH。
-
+
### 1e7df9d3 {#1e7df9d3}
-此函数和上面的 [`claim`](#claim) 非常相似。 它也检查默克尔证明，尝试将以太币转账到第一个参数，并生成相同类型的日志项。
+此函数和上面的 [`claim`](#claim) 非常相似。 它也检查默克尔证明，尝试将 ETH 转账到第一个参数，并生成相同类型的日志项。
```python
def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
@@ -695,7 +691,7 @@ def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
mem[mem[64] + 32] = s + sha3(mem[(32 * _param3.length) + 160 len mem[(32 * _param3.length) + 128]])
...
if unknown2eb4a7ab != s:
- revert with 0, 'Invalid proof'
+ revert with 0, '无效证明'
...
call addr(_param1) with:
value s wei
@@ -710,7 +706,7 @@ def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
log 0xdbd5389f: addr(_param1), s, bool(ext_call.success)
```
-主要区别在于第一个参数，即要提款的窗口，不存在。 相反，所有可以声明的窗口都有一个循环。
+主要区别在于第一个参数，即要取款的窗口，不存在。 相反，所有可以申领的窗口都有一个循环。
```python
idx = 0
@@ -739,8 +735,10 @@ def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
continue
```
-所以它看起来像一个声明所有窗口的 `claim` 变体。
+所以它看起来像一个申领所有窗口的 `claim` 变体。
-## 总结 {#conclusion}
+## 结论 {#conclusion}
-现在，你应该知道如何通过操作码或反编译器（当它有效时）理解没有源代码的智能合约。 从本文的篇幅明显可以看出，对合约进行逆向工程并非易事，但在安全性至关重要的系统中，能够验证合约是否按承诺运作是一项重要技能。
+现在，你应该知道如何通过操作码或反编译器（当它有效时）来理解源代码不可用的合约。 从本文的篇幅明显可以看出，对合约进行逆向工程并非易事，但在安全性至关重要的系统中，能够验证合约是否按承诺运作是一项重要技能。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/zh/developers/tutorials/run-node-raspberry-pi/index.md
index b2b89fdfd40..577a50c046d 100644
--- a/public/content/translations/zh/developers/tutorials/run-node-raspberry-pi/index.md
+++ b/public/content/translations/zh/developers/tutorials/run-node-raspberry-pi/index.md
@@ -1,150 +1,169 @@
---
-title: 如何通过刷写MicroSD卡将您的Raspberry Pi 4变为一个节点
-description: 刷写树莓派 4，插入以太网电缆，连接固态硬盘并打开设备电源，将树莓派 4 变为以太坊全节点 + 验证者。
+title: "在树莓派 4 上运行以太坊节点"
+description: "刷写你的树莓派 4，插入网线，连接固态硬盘并启动设备，将树莓派 4 变成一个完整的以太坊节点 + 验证者。"
author: "EthereumOnArm"
-tags:
- - "客户端"
- - "执行层"
- - "共识层"
- - "节点"
+tags: [ "客户端", "执行层", "共识层", "节点" ]
lang: zh
-skill: advanced
+skill: intermediate
published: 2022-06-10
source: Ethereum on ARM
-sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/kiln/kiln-testnet.html
+sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/
---
-**Ethereum on Arm 是一个定制 Linux 映像，它可以将树莓派转变成以太坊节点。**
+**Ethereum on Arm 是一个自定义的 Linux 镜像，可将树莓派转变为以太坊节点。**
-为了使用 Ethereum on Arm 将树莓派转变成以太坊节点，推荐使用以下硬件：
+要使用 Ethereum on Arm 将树莓派转变为以太坊节点，推荐使用以下硬件：
-- 树莓派 4（B 型，8 GB）
-- MicroSD 卡（最小 16 GB，Class 10）
-- 最小 2TB 的 USB3.0 固态硬盘或使用 USB3.0 转 SATA 转接盒的固态硬盘
+- 树莓派 4（B 型 8GB）、Odroid M1 或 Rock 5B（8GB/16GB RAM）板
+- MicroSD 卡（最低 16 GB，Class 10）
+- 最低 2 TB 的 USB 3.0 固态硬盘，或带有 USB 转 SATA 硬盘盒的固态硬盘。
- 电源
- 以太网电缆
-- 端口转发（详情请查看客户端）
+- 端口转发（更多信息请参见客户端）
- 带散热片和风扇的外壳
-- USB 键盘、显示器和 HDMI 数据线（微型 HDMI）（可选）
+- USB 键盘、显示器和 HDMI 线（micro-HDMI）（可选）
## 为什么要在 ARM 上运行以太坊？ {#why-run-ethereum-on-arm}
-ARM 单板机是一种便宜、灵活的小型计算机。 它们价格低廉、效率高、可配置成将全部资源专用于节点、能耗低、体积小，可以很顺利地安装在任何家庭中，因此成为运行以太坊节点的不二之选。 启动节点也非常容易，因为树莓派的 MicroSD 卡可以简单地使用预建映像刷写，无需下载或构建软件。
+ARM 单板机是非常实惠、灵活的小型计算机。 它们是运行以太坊节点的理想选择，因为它们价格低廉，可配置为将所有资源专用于节点，从而提高效率，而且功耗低、体积小，可以不引人注目地放置在任何家庭中。 启动节点也非常容易，因为树莓派的 MicroSD 卡只需用预构建的镜像刷写即可，无需下载或构建软件。
## 工作原理 {#how-does-it-work}
-使用预先构建的映像刷写树莓派的内存卡。 此映像包含了运行以太坊节点所需的一切。 在刷写完内存卡后，用户只需要启动树莓派即可。 运行节点所需的所有进程自动启动。 这是可行的，因为内存卡中有基于 Linux 的操作系统，系统级进程在此操作系统上自动运行，将树莓派转变成以太坊节点。
+使用预构建的镜像刷写树莓派的存储卡。 此镜像包含运行以太坊节点所需的一切。 刷好卡后，用户只需启动树莓派即可。 运行节点所需的所有进程都会自动启动。 这是可行的，因为存储卡中包含一个基于 Linux 的操作系统 (OS)，系统级进程在其上自动运行，从而将该设备转变为以太坊节点。
-以太坊不能在流行的树莓派 Linux 操作系统“Raspbian”下运行，因为 Raspbian 还在使用 32 位指令集架构，这会给以太坊用户带来内存问题，而且共识客户端也不支持 32 位二进制文件。 为了解决这一问题，Ethereum on Arm 团队迁移到原生 64 位操作系统“Armbian”。
+以太坊无法在使用流行的树莓派 Linux 操作系统“Raspbian”上运行，因为 Raspbian 仍使用 32 位架构，这会导致以太坊用户遇到内存问题，并且共识客户端不支持 32 位二进制文件。 为了克服这个问题，Ethereum on Arm 团队迁移到了一个名为“Armbian”的原生 64 位操作系统。
-**映像负责处理所有必要的步骤**，包括从设置环境和格式化固态磁盘，到安装和运行以太坊软件，以及启动区块链同步。
+**镜像会处理所有必要的步骤**，从设置环境和格式化固态硬盘，到安装和运行以太坊软件，以及启动区块链同步。
-## 执行客户端和共识客户端说明 {#note-on-execution-and-consensus-clients}
+## 关于执行客户端和共识客户端的说明 {#note-on-execution-and-consensus-clients}
-Ethereum on Arm 相关文档解释了如何设置执行客户端*或*共识客户端，两个以太坊测试网（Kiln 和 Ropsten）除外。 这种可选性只有在以太坊从工作量证明过渡到权益证明（称为[合并](/roadmap/merge)）之前才有可能。
+Ethereum on Arm 镜像包含作为服务预构建的执行客户端和共识客户端。 以太坊节点需要两个客户端都已同步并正在运行。 您只需下载并刷写镜像，然后启动服务。 该镜像预装了以下执行客户端：
-
-合并后，将无法单独运行执行客户端和共识客户端 — 它们必须成对运行。 因此，在本教程中，我们将在以太坊测试网 (Kiln) 上运行一对执行客户端和共识客户端。
-
+- Geth
+- Nethermind
+- Besu
-## Kiln 树莓派 4 映像 {#the-kiln-raspberry-pi-4-image}
+以及以下共识客户端：
-Kiln 是一个专门用于测试合并的公共测试网。 Ethereum on Arm 团队开发了一个映像，让用户可以在这个合并测试网上快速启动一对以太坊客户端。 Kiln 合并已经发生，但该网络仍在运行，因此可用于本教程。 Kiln 上的以太币没有实际价值。
+- Lighthouse
+- Nimbus
+- Prysm
+- Teku
-Kiln 树莓派 4 映像是一种“即插即用”映像，它会自动安装和设置执行客户端与共识客户端，配置它们相互通信并连接到 Kiln 网络。 用户需要做的就是使用一个简单的命令启动他们的进程。 该映像包含四种执行客户端（Geth、Nethermind、Besu 和 Erigon）和四种共识客户端（Lighthouse、Prysm、Nimbus、Teku），可供用户选择。
+您应该各选择一个来运行——所有执行客户端都与所有共识客户端兼容。 如果您没有明确选择客户端，节点将回退到其默认设置——Geth 和 Lighthouse，并在单板机通电时自动运行它们。 您必须在路由器上打开 30303 端口，以便 Geth 能够找到并连接到对等节点。
-从 [Ethereum on Arm](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/ES56R_SuvaVFkiMO1Tgnf6kB7lEbBfla5c2c18E3WQRJzA?download=1) 下载树莓派映像并验证 SHA256 哈希：
+## 下载镜像 {#downloading-the-image}
+
+树莓派 4 以太坊镜像是“即插即用”镜像，它会自动安装并设置执行客户端和共识客户端，配置它们相互通信并连接到以太坊网络。 用户所要做的就是使用一个简单的命令来启动其进程。
+
+从 [Ethereum on Arm](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/Ec_VmUvr80VFjf3RYSU-NzkBmj2JOteDECj8Bibde929Gw?download=1) 下载树莓派镜像，并验证 SHA256 哈希值：
```sh
-# From directory containing the downloaded image
-shasum -a 256 ethonarm_kiln_22.03.01.img.zip
-# Hash should output: 485cf36128ca60a41b5de82b5fee3ee46b7c479d0fc5dfa5b9341764414c4c57
+# 从包含已下载镜像的目录中
+shasum -a 256 ethonarm_22.04.00.img.zip
+# 哈希值应输出：fb497e8f8a7388b62d6e1efbc406b9558bee7ef46ec7e53083630029c117444f
```
-请注意，对于没有树莓派但有 AWS 帐户的用户，提供的 ARM 实例可以运行相同的映像。 说明和 AWS 映像可从 Ethereum on Arm (https://ethereum-on-arm-documentation.readthedocs.io/en/latest/kiln/kiln-testnet.html) 下载。
+请注意，Rock 5B 和 Odroid M1 单板机的镜像可在 Ethereum-on-Arm [下载页面](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/quick-guide/download-and-install.html)获取。
-## 刷写 MicroSD 卡 {#flashing-the-microsd}
+## 刷写 MicroSD {#flashing-the-microsd}
-首先，应将用于树莓派的 MicroSD 卡插入台式机或笔记本电脑中，以便可以刷写。 接着，在终端执行以下命令，将下载的映像刷写到 SD 卡中：
+应首先将用于树莓派的 MicroSD 卡插入台式机或笔记本电脑，以便进行刷写。 然后，使用以下终端命令将下载的镜像刷写到 SD 卡上：
```shell
-# 检查 Micro SD 卡名
-sudo fdisk -I
+# 检查 MicroSD 卡名称
+sudo fdisk -l
>> sdxxx
```
-正确的 SD 卡名称非常重要，因为下一条命令中的指令 `dd` 会在写入映像前彻底清除 SD 卡上的全部已有内容。 接下来，导航到包含压缩映像文件的目录：
+正确获取名称非常重要，因为下一个命令包含 `dd`，它会在将镜像写入卡上之前完全擦除卡上的现有内容。 要继续，请导航到包含压缩镜像的目录：
```shell
-# 解压并烧录镜像
-unzip ethonarm_kiln_22.03.01.img.zip
-sudo dd bs=1M if=ethonarm_kiln_22.03.01.img of=/dev/mmcblk0 conv=fdatasync status=progress
+# 解压缩并刷写镜像
+unzip ethonarm_22.04.00.img.zip
+sudo dd bs=1M if=ethonarm_22.04.00.img of=/dev/ conv=fdatasync status=progress
```
-现在 SD 卡已刷写完成，可以将其插入树莓派中了。
+现在卡已刷写完毕，可以将其插入树莓派了。
## 启动节点 {#start-the-node}
-将 SD 卡插入树莓派后，连接以太网电缆和固态硬盘，然后打开电源。 操作系统将启动并自动执行预先配置好的任务，包括安装和构建客户端软件，从而将树莓派转变成以太坊节点。 此过程大约需要 10-15 分钟。
+将 SD 卡插入树莓派后，连接以太网电缆和固态硬盘，然后打开电源。 操作系统将启动并自动开始执行预配置的任务，将树莓派转变为以太坊节点，包括安装和构建客户端软件。 这可能需要 10-15 分钟。
-所有安装和配置完成后，通过安全外壳连接登录设备，或者如果单板机已经连接了键盘和显示器，也可以直接使用终端。 使用 `ethereum` 帐户登录，因为此帐户有启动节点所需的权限。
+一旦所有内容都安装和配置完毕，请通过 ssh 连接登录设备，或者如果单板机连接了显示器和键盘，则直接使用终端。 使用 `ethereum` 帐户登录，因为该帐户具有启动节点所需的权限。
```shell
-User: ethereum
-Password: ethereum
+用户：ethereum
+密码：ethereum
```
-然后，用户可以选择他们希望运行的执行客户端和共识客户端组合，并按如下方式启动他们的 systemctl 进程（示例中运行 Geth 和 Lighthouse）：
+默认的执行客户端 Geth 将自动启动。 您可以通过使用以下终端命令检查日志来确认这一点：
-```shell
-sudo systemctl start geth-lh
-sudo systemctl start lh-geth-beacon
+```sh
+sudo journalctl -u geth -f
```
-可以使用以下指令检查日志
+共识客户端需要显式启动。 为此，请先在路由器上打开 9000 端口，以便 Lighthouse 能够找到并连接到对等节点。 然后启用并启动 lighthouse 服务：
-```shell
-# logs for Geth
-sudo journalctl -u geth-lh -f
-#logs for lighthouse
-sudo journalctl -u lh-geth-beacon -f
+```sh
+sudo systemctl enable lighthouse-beacon
+sudo systemctl start lighthouse-beacon
```
-[Ethereum on Arm 相关文档](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/kiln/kiln-testnet.html#id2)中提供有每一对客户端组合的特定服务名称。 它们可用于更新此处提供的命令，以用于任何客户端组合。
+使用日志检查客户端：
+
+```sh
+sudo journalctl -u lighthouse-beacon
+```
+
+请注意，共识客户端将在几分钟内同步，因为它使用检查点同步。 执行客户端将需要更长的时间——可能需要几个小时，并且在共识客户端完成同步之前它不会启动（这是因为执行客户端需要一个同步目标，而同步后的共识客户端会提供这个目标）。
+
+随着 Geth 和 Lighthouse 服务运行并同步，您的树莓派现在就是一个以太坊节点了！ 与以太坊网络交互最常见的方式是使用 Geth 的 Javascript 控制台，它可以附加到端口 8545 上的 Geth 客户端。 也可以使用像 Curl 这样的请求工具，以 JSON 对象格式提交命令。 在 [Geth 文档](https://geth.ethereum.org/)中查看更多信息。
+
+Geth 预先配置为将指标报告到一个 Grafana 仪表板，该仪表板可以在浏览器中查看。 更高级的用户可能希望通过导航到 `ipaddress:3000`，并传递 `user: admin` 和 `passwd: ethereum`，来使用此功能监控其节点的健康状况。
## 验证者 {#validators}
-为了运行验证者，必须首先访问 32 个测试网以太币，它们必须存入 Kiln 存款合约。 这可以按照 [Kiln 启动板](https://kiln.launchpad.ethereum.org/en/)上的分步指南来完成。 在台式机/笔记本电脑上执行此操作，但不要生成密钥 — 密钥生成可以直接在树莓派上完成。
+也可以选择性地将验证者添加到共识客户端。 验证者软件允许您的节点积极参与共识，并为网络提供加密经济安全保障。 您会因为这项工作获得 ETH 奖励。 要运行验证者，您必须首先拥有 32 ETH，这些 ETH 必须存入存款合约中。 您可以按照 [Launchpad](https://launchpad.ethereum.org/) 上的分步指南进行存款。 请在台式机/笔记本电脑上执行此操作，但不要生成密钥——这可以直接在树莓派上完成。
-在树莓派上打开一个终端并运行以下命令来生成存款密钥：
+在树莓派上打开一个终端，并运行以下命令以生成存款密钥：
```
-cd && deposit new-mnemonic --num_validators 1 --chain kiln
+sudo apt-get update
+sudo apt-get install staking-deposit-cli
+cd && deposit new-mnemonic --num_validators 1
```
-保持助记词安全！ 上面的命令在节点的密钥库中生成了两个文件：验证者密钥和存款数据文件。 存款数据需要上传到启动板，因此必须要从树莓派复制到台式机/笔记本电脑。 这可以使用安全外壳连接或任何其他复制/粘贴方法来完成。
+（或者下载 [staking-deposit-cli](https://github.com/ethereum/staking-deposit-cli) 在离线计算机上运行，并运行 `deposit new-mnemnonic` 命令）
-在存款数据文件在运行启动板的计算机上可用后，就可以将其拖放到启动板界面上的 `+` 上。 按照屏幕上的说明将交易发送到存款合约。
+请妥善保管助记词！ 上面的命令在节点的密钥库中生成了两个文件：验证者密钥和存款数据文件。 存款数据需要上传到 Launchpad，因此必须从树莓派复制到台式机/笔记本电脑。 这可以通过 ssh 连接或任何其他复制/粘贴方法完成。
-返回树莓派，可以启动验证者。 这需要导入验证者密钥，设置领取奖励的地址，然后启动预先配置好的验证者进程。 以下示例适用于 Lighthouse — 其他共识客户端的说明见 [Ethereum on Arm 相关文档](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/kiln/kiln-testnet.html#lighthouse)：
+一旦存款数据文件在运行 Launchpad 的计算机上可用，就可以将其拖放到 Launchpad 屏幕上的 `+` 号上。 按照屏幕上的说明向存款合约发送一笔交易。
+
+回到树莓派上，可以启动一个验证者。 这需要导入验证者密钥，设置领取奖励的地址，然后启动预配置的验证者进程。 下面的示例适用于 Lighthouse——其他共识客户端的说明可在 [Ethereum on Arm 文档](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/)中找到：
```shell
-#导入验证器密钥
-lighthouse-kl account validator import --directory=/home/ethereum/validator_keys --datadir=/home/ethereum/.lh-geth/kiln/testnet-lh
+# 导入验证者密钥
+lighthouse account validator import --directory=/home/ethereum/validator_keys
-#设置收款地址地址
-sudo sed -i ‘’ /etc/ethereum/kiln/lh-geth-validator.conf
+# 设置奖励地址
+sudo sed -i 's/' /etc/ethereum/lighthouse-validator.conf
-#启动验证器
-sudo systemctl start lh-geth-validator
+# 启动验证者
+sudo systemctl start lighthouse-validator
```
-恭喜，你现在拥有运行在树莓派上的以太坊全节点和验证者！
+恭喜，您现在有了一个在树莓派上运行的完整以太坊节点和验证者！
+
+## 更多详细信息 {#more-details}
+
+本页概述了如何使用树莓派设置 Geth-Lighthouse 节点和验证者。 更详细的说明可在 [Ethereum-on-Arm 网站](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/index.html)上找到。
-## 感谢反馈 {#feedback-appreciated}
+## 感谢您的反馈 {#feedback-appreciated}
-我们知道树莓派拥有庞大的用户群体，能对以太坊网络的健康产生非常积极的影响。 请深入了解本教程中的详细信息，尝试在其他测试网甚至以太坊主网上运行，查看 Ethereum on Arm GitHub，提供反馈，提出问题并拉取请求，并帮助改进技术和相关文档！
+我们知道树莓派拥有庞大的用户群，可以对以太坊网络的健康产生非常积极的影响。
+请深入研究本教程中的详细信息，尝试在测试网上运行，查看 Ethereum on Arm GitHub，提供反馈、提出问题和拉取请求，并帮助改进技术和文档！
## 参考文献 {#references}
diff --git a/public/content/translations/zh/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/zh/developers/tutorials/scam-token-tricks/index.md
new file mode 100644
index 00000000000..1ae7d7b590c
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/scam-token-tricks/index.md
@@ -0,0 +1,470 @@
+---
+title: "诈骗代币使用的一些伎俩以及如何检测它们"
+description: "在本教程中，我们将剖析一个诈骗代币，了解诈骗者使用的一些伎俩、他们如何实施这些伎俩，以及我们如何检测它们。"
+author: Ori Pomerantz
+tags:
+ [
+ "诈骗",
+ "Solidity",
+ "erc-20",
+ "javascript",
+ "typescript"
+ ]
+skill: intermediate
+published: 2023-09-15
+lang: zh
+---
+
+在本教程中，我们将剖析[一个诈骗代币](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code)，了解诈骗者使用的一些伎俩以及他们如何实施这些伎俩。 在本教程结束时，你将对 ERC-20 代币合约、其功能以及为何有必要保持怀疑态度有更全面的了解。 然后，我们查看该诈骗代币发出的事件，并了解如何自动识别它不是合法代币。
+
+## 诈骗代币——它们是什么、人们为什么发行诈骗代币，以及如何避免它们 {#scam-tokens}
+
+以太坊最常见的用途之一是由一个团队来打造一种可以交易的代币，在某种意义上是他们自己的货币。 然而，任何存在可以带来价值的合法使用场景的地方，就会有试图窃取那些价值的犯罪分子。
+
+你可以从用户角度在 [ethereum.org 的其他地方](/guides/how-to-id-scam-tokens/)阅读更多关于此主题的内容。 本教程重点剖析一个诈骗代币，了解它是如何制作的以及如何被检测出来。
+
+### 我如何知道 wARB 是个骗局？ {#warb-scam}
+
+我们剖析的代币是 [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code)，它伪装成与合法的 [ARB 代币](https://etherscan.io/token/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1)等价。
+
+知道哪个是合法代币的最简单方法是查看其发行组织 [Arbitrum](https://arbitrum.foundation/)。 合法地址已在[他们的相关文档](https://docs.arbitrum.foundation/deployment-addresses#token)中指定。
+
+### 为什么源代码是可用的？ {#why-source}
+
+通常，我们期望试图诈骗他人的人会保密，事实上，许多诈骗代币的代码都不可用（例如，[这个](https://optimistic.etherscan.io/token/0x15992f382d8c46d667b10dc8456dc36651af1452#code)和[这个](https://optimistic.etherscan.io/token/0x026b623eb4aada7de37ef25256854f9235207178#code)）。
+
+然而，合法代币通常会公布其源代码，因此为了显得合法，诈骗代币的作者有时也会这样做。 [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) 是那些源代码可用的代币之一，这使得理解它变得更容易。
+
+虽然合约部署者可以选择是否公布源代码，但他们_不能_公布错误的源代码。 区块浏览器独立编译提供的源代码，如果得不到完全相同的字节码，它就会拒绝该源代码。 [你可以在 Etherscan 网站上阅读更多相关内容](https://etherscan.io/verifyContract)。
+
+## 与合法 ERC-20 代币的比较 {#compare-legit-erc20}
+
+我们将把这个代币与合法的 ERC-20 代币进行比较。 如果你不熟悉合法 ERC-20 代币通常是如何编写的，请[参阅本教程](/developers/tutorials/erc20-annotated-code/)。
+
+### 特权地址的常量 {#constants-for-privileged-addresses}
+
+合约有时需要特权地址。 为长期使用而设计的合约允许一些特权地址更改这些地址，例如，为了能够使用新的多签合约。 有几种方法可以做到这一点。
+
+[`HOP` 代币合约](https://etherscan.io/address/0xc5102fe9359fd9a28f877a67e36b0f050d81a3cc#code) 使用 [`Ownable`](https://docs.openzeppelin.com/contracts/2.x/access-control#ownership-and-ownable) 模式。 特权地址保存在存储中，在一个名为 `_owner` 的字段中（参见第三个文件 `Ownable.sol`）。
+
+```solidity
+abstract contract Ownable is Context {
+ address private _owner;
+ .
+ .
+ .
+}
+```
+
+[`ARB` 代币合约](https://etherscan.io/address/0xad0c361ef902a7d9851ca7dcc85535da2d3c6fc7#code)没有直接的特权地址。 然而，它不需要一个。 它位于[地址 `0xb50721bcf8d664c30412cfbc6cf7a15145234ad1`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1#code) 的一个 [`proxy`](https://docs.openzeppelin.com/contracts/5.x/api/proxy) 之后。 该合约有一个特权地址（参见第四个文件 `ERC1967Upgrade.sol`），可用于升级。
+
+```solidity
+ /**
+ * @dev 在 EIP1967 管理员时隙中存储一个新地址。
+ */
+ function _setAdmin(address newAdmin) private {
+ require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+ StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+ }
+```
+
+相比之下，`wARB` 合约有一个硬编码的 `contract_owner`。
+
+```solidity
+contract WrappedArbitrum is Context, IERC20 {
+ .
+ .
+ .
+ address deployer = 0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1;
+ address public contract_owner = 0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33;
+ .
+ .
+ .
+}
+```
+
+[此合约所有者](https://etherscan.io/address/0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33)不是一个可以在不同时间由不同帐户控制的合约，而是一个[外部所有的帐户](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs)。 这意味着它可能是为个人短期使用而设计的，而不是作为控制一个将保持有价值的 ERC-20 的长期解决方案。
+
+事实上，如果我们查看 Etherscan，我们会发现诈骗者在 2023 年 5 月 19 日期间仅使用了该合约 12 小时（从[第一笔交易](https://etherscan.io/tx/0xf49136198c3f925fcb401870a669d43cecb537bde36eb8b41df77f06d5f6fbc2)到[最后一笔交易](https://etherscan.io/tx/0xdfd6e717157354e64bbd5d6adf16761e5a5b3f914b1948d3545d39633244d47b)）。
+
+### 虚假的 `_transfer` 函数 {#the-fake-transfer-function}
+
+标准做法是使用[一个内部的 `_transfer` 函数](/developers/tutorials/erc20-annotated-code/#the-_transfer-function-_transfer)来进行实际的转账。
+
+在 `wARB` 中，这个函数看起来几乎是合法的：
+
+```solidity
+ function _transfer(address sender, address recipient, uint256 amount) internal virtual{
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+可疑的部分是：
+
+```solidity
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+```
+
+如果合约所有者发送代币，为什么 `Transfer` 事件显示它们来自 `deployer`？
+
+然而，还有一个更重要的问题。 谁调用这个 `_transfer` 函数？ 它不能从外部调用，它被标记为 `internal`。 而且我们拥有的代码不包含任何对 `_transfer` 的调用。 很明显，它在这里只是个诱饵。
+
+```solidity
+ function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(_msgSender(), recipient, amount);
+ return true;
+ }
+
+ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(sender, recipient, amount);
+ _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+ return true;
+ }
+```
+
+当我们查看用于转账代币的函数 `transfer` 和 `transferFrom` 时，我们看到它们调用了一个完全不同的函数 `_f_`。
+
+### 真正的 `_f_` 函数 {#the-real-f-function}
+
+```solidity
+ function _f_(address sender, address recipient, uint256 amount) internal _mod_(sender,recipient,amount) virtual {
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+这个函数中有两个潜在的危险信号。
+
+- 使用了[函数修饰符](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `_mod_`。 然而，当我们查看源代码时，我们发现 `_mod_` 实际上是无害的。
+
+ ```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+ ```
+
+- 我们在 `_transfer` 中看到的同样问题，即当 `contract_owner` 发送代币时，它们似乎来自 `deployer`。
+
+### 虚假事件函数 `dropNewTokens` {#the-fake-events-function-dropNewTokens}
+
+现在我们来看一个看起来像真正骗局的东西。 为了便于阅读，我对函数做了一些编辑，但功能上是等效的。
+
+```solidity
+function dropNewTokens(address uPool,
+ address[] memory eReceiver,
+ uint256[] memory eAmounts) public auth()
+```
+
+这个函数有 `auth()` 修饰符，这意味着它只能由合约所有者调用。
+
+```solidity
+modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+}
+```
+
+这个限制完全合理，因为我们不希望随机帐户分发代币。 然而，函数的其余部分是可疑的。
+
+```solidity
+{
+ for (uint256 i = 0; i < eReceiver.length; i++) {
+ emit Transfer(uPool, eReceiver[i], eAmounts[i]);
+ }
+}
+```
+
+一个将资金从池子帐户转账到一个接收者数组（包含金额数组）的函数是完全合理的。 在许多用例中，你会希望将代币从单一来源分发到多个目的地，例如工资发放、空投等。 在单笔交易中完成比发行多笔交易更便宜（在燃料方面），甚至比在同一笔交易中从不同的合约多次调用 ERC-20 更便宜。
+
+然而，`dropNewTokens` 并没有这样做。 它会发出 [`Transfer` 事件](https://eips.ethereum.org/EIPS/eip-20#transfer-1)，但实际上并不转账任何代币。 没有正当理由通过告知脱链应用一笔并未真正发生的转账来迷惑它们。
+
+### 销毁 `Approve` 函数 {#the-burning-approve-function}
+
+ERC-20 合约应该有一个用于授权的 [`approve` 函数](/developers/tutorials/erc20-annotated-code/#approve)，我们的诈骗代币确实有这样一个函数，而且它甚至是正确的。 然而，由于 Solidity 源于 C，它是区分大小写的。 “Approve”和“approve”是不同的字符串。
+
+此外，该功能与 `approve` 无关。
+
+```solidity
+ function Approve(
+ address[] memory holders)
+```
+
+此函数被调用时，会传入一个代币持有者的地址数组。
+
+```solidity
+ public approver() {
+```
+
+`approver()` 修饰符确保只有 `contract_owner` 可以调用此函数（见下文）。
+
+```solidity
+ for (uint256 i = 0; i < holders.length; i++) {
+ uint256 amount = _balances[holders[i]];
+ _beforeTokenTransfer(holders[i], 0x0000000000000000000000000000000000000001, amount);
+ _balances[holders[i]] = _balances[holders[i]].sub(amount,
+ "ERC20: burn amount exceeds balance");
+ _balances[0x0000000000000000000000000000000000000001] =
+ _balances[0x0000000000000000000000000000000000000001].add(amount);
+ }
+ }
+
+```
+
+对于每个持有者地址，该函数将持有者的全部余额转移到地址 `0x00...01`，从而有效地销毁它（标准中的实际 `burn` 也会更改总供应量，并将代币转账到 `0x00...00`）。 这意味着 `contract_owner` 可以移除任何用户的资产。 这看起来不像是你希望在治理代币中拥有的功能。
+
+### 代码质量问题 {#code-quality-issues}
+
+这些代码质量问题并不能_证明_这个代码是骗局，但它们让它看起来很可疑。 像 Arbitrum 这样的有组织的公司通常不会发布这么糟糕的代码。
+
+#### `mount` 函数 {#the-mount-function}
+
+虽然[标准](https://eips.ethereum.org/EIPS/eip-20)中没有规定，但一般来说，创建新代币的函数被称为 [`mint`](https://ethereum.org/el/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn)。
+
+如果我们查看 `wARB` 的构造函数，我们会发现 mint 函数由于某种原因被重命名为 `mount`，并且被调用五次，每次使用初始供应量的五分之一，而不是为了效率一次性处理全部数量。
+
+```solidity
+ constructor () public {
+
+ _name = "Wrapped Arbitrum";
+ _symbol = "wARB";
+ _decimals = 18;
+ uint256 initialSupply = 1000000000000;
+
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ }
+```
+
+`mount` 函数本身也很可疑。
+
+```solidity
+ function mount(address account, uint256 amount) public {
+ require(msg.sender == contract_owner, "ERC20: mint to the zero address");
+```
+
+查看 `require`，我们发现只有合约所有者被允许铸币。 这是合法的。 但是错误信息应该是_只有所有者才能铸币_或类似的东西。 相反，它使用了不相关的 _ERC20: mint to the zero address_。 检查是否铸币到零地址的正确测试是 `require(account != address(0), "")`，但该合约从未费心去检查。
+
+```solidity
+ _totalSupply = _totalSupply.add(amount);
+ _balances[contract_owner] = _balances[contract_owner].add(amount);
+ emit Transfer(address(0), account, amount);
+ }
+```
+
+还有两个与铸币直接相关的可疑事实：
+
+- 有一个 `account` 参数，大概是应该接收铸币数量的帐户。 但增加的余额实际上是 `contract_owner` 的。
+
+- 虽然增加的余额属于 `contract_owner`，但发出的事件却显示了一笔向 `account` 的转账。
+
+### 为什么同时有 `auth` 和 `approver`？ 为什么 `mod` 什么都不做？ {#why-both-autho-and-approver-why-the-mod-that-does-nothing}
+
+这个合约包含三个修饰符：`_mod_`、`auth` 和 `approver`。
+
+```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+```
+
+`_mod_` 接收三个参数，但不对它们做任何处理。 为什么要有它？
+
+```solidity
+ modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+
+ modifier approver() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+```
+
+`auth` 和 `approver` 更合理，因为它们检查合约是否由 `contract_owner` 调用。 我们期望某些特权操作，例如铸币，仅限于该帐户。 然而，设置两个功能_完全相同的_独立函数有什么意义呢？
+
+## 我们可以自动检测到什么？ {#what-can-we-detect-automatically}
+
+通过查看 Etherscan，我们可以看到 `wARB` 是一个诈骗代币。 然而，这是一个中心化的解决方案。 理论上，Etherscan 可能会被颠覆或黑客攻击。 最好能够独立判断一个代币是否合法。
+
+我们可以通过查看它们发出的事件来使用一些技巧来识别一个 ERC-20 代币是否可疑（无论是骗局还是写得非常糟糕）。
+
+## 可疑的 `Approval` 事件 {#suspicious-approval-events}
+
+[`Approval` 事件](https://eips.ethereum.org/EIPS/eip-20#approval)只应在直接请求下发生（与 [`Transfer` 事件](https://eips.ethereum.org/EIPS/eip-20#transfer-1) 不同，后者可能因授权而发生）。 关于此问题的详细解释以及为何请求需要是直接的，而不是由合约介导，请参阅 [Solidity 文档](https://docs.soliditylang.org/en/v0.8.20/security-considerations.html#tx-origin)。
+
+这意味着批准从[外部所有的帐户](/developers/docs/accounts/#types-of-account)支出的 `Approval` 事件必须来自源于该帐户且目的地为 ERC-20 合约的交易。 来自外部所有的帐户的任何其他类型的批准都是可疑的。
+
+这里有一个[识别这类事件的程序](https://github.com/qbzzt/20230915-scam-token-detection)，它使用了 [viem](https://viem.sh/) 和 [TypeScript](https://www.typescriptlang.org/docs/)，这是一种具有类型安全的 JavaScript 变体。 要运行它：
+
+1. 将 `.env.example` 复制到 `.env`。
+2. 编辑 `.env` 以提供以太坊主网节点的 URL。
+3. 运行 `pnpm install` 以安装必要的包。
+4. 运行 `pnpm susApproval` 以查找可疑的批准。
+
+下面是逐行解释：
+
+```typescript
+import {
+ Address,
+ TransactionReceipt,
+ createPublicClient,
+ http,
+ parseAbiItem,
+} from "viem"
+import { mainnet } from "viem/chains"
+```
+
+从 `viem` 导入类型定义、函数和链定义。
+
+```typescript
+import { config } from "dotenv"
+config()
+```
+
+读取 `.env` 以获取 URL。
+
+```typescript
+const client = createPublicClient({
+ chain: mainnet,
+ transport: http(process.env.URL),
+})
+```
+
+创建一个 Viem 客户端。 我们只需要从区块链读取数据，所以这个客户端不需要私钥。
+
+```typescript
+const testedAddress = "0xb047c8032b99841713b8e3872f06cf32beb27b82"
+const fromBlock = 16859812n
+const toBlock = 16873372n
+```
+
+可疑 ERC-20 合约的地址，以及我们将在其中查找事件的区块。 节点提供商通常会限制我们读取事件的能力，因为带宽可能会变得昂贵。 幸运的是，`wARB` 在 18 小时内没有被使用，所以我们可以查找所有事件（总共只有 13 个）。
+
+```typescript
+const approvalEvents = await client.getLogs({
+ address: testedAddress,
+ fromBlock,
+ toBlock,
+ event: parseAbiItem(
+ "event Approval(address indexed _owner, address indexed _spender, uint256 _value)"
+ ),
+})
+```
+
+这是向 Viem 请求事件信息的方式。 当我们向它提供确切的事件签名，包括字段名称时，它会为我们解析事件。
+
+```typescript
+const isContract = async (addr: Address): boolean =>
+ await client.getBytecode({ address: addr })
+```
+
+我们的算法仅适用于外部所有的帐户。 如果 `client.getBytecode` 返回任何字节码，这意味着这是一个合约，我们应该直接跳过它。
+
+如果你以前没有使用过 TypeScript，函数定义可能看起来有点奇怪。 我们不仅告诉它第一个（也是唯一的）参数叫做 `addr`，还告诉它类型是 `Address`。 同样，`: boolean` 部分告诉 TypeScript 该函数的返回值是布尔值。
+
+```typescript
+const getEventTxn = async (ev: Event): TransactionReceipt =>
+ await client.getTransactionReceipt({ hash: ev.transactionHash })
+```
+
+这个函数从一个事件中获取交易收据。 我们需要收据来确保我们知道交易的目的地是什么。
+
+```typescript
+const suspiciousApprovalEvent = async (ev : Event) : (Event | null) => {
+```
+
+这是最重要的函数，它实际决定了一个事件是否可疑。 返回类型 `(Event | null)` 告诉 TypeScript 这个函数可以返回一个 `Event` 或 `null`。 如果事件不可疑，我们返回 `null`。
+
+```typescript
+const owner = ev.args._owner
+```
+
+Viem 有字段名称，所以它为我们解析了事件。 `_owner` 是要花费的代币的所有者。
+
+```typescript
+// 合约的批准不可疑
+if (await isContract(owner)) return null
+```
+
+如果所有者是合约，则假定此批准不可疑。 要检查合约的批准是否可疑，我们需要追踪交易的完整执行过程，看它是否到达了所有者合约，以及该合约是否直接调用了 ERC-20 合约。 这比我们想做的要消耗更多资源。
+
+```typescript
+const txn = await getEventTxn(ev)
+```
+
+如果批准来自外部所有的帐户，获取导致它的交易。
+
+```typescript
+// 如果批准来自不是交易 `from` 的 EOA 所有者，则该批准是可疑的
+if (owner.toLowerCase() != txn.from.toLowerCase()) return ev
+```
+
+我们不能只检查字符串是否相等，因为地址是十六进制的，所以它们包含字母。 有时，例如在 `txn.from` 中，这些字母都是小写的。 在其他情况下，例如 `ev.args._owner`，地址是[用于错误识别的混合大小写](https://eips.ethereum.org/EIPS/eip-55)。
+
+但是如果交易不是来自所有者，并且该所有者是外部所有的，那么我们就有一个可疑的交易。
+
+```typescript
+// 如果交易目的地不是我们正在
+// 调查的 ERC-20 合约，那也是可疑的
+if (txn.to.toLowerCase() != testedAddress) return ev
+```
+
+同样，如果交易的 `to` 地址，即第一个被调用的合约，不是正在调查的 ERC-20 合约，那么它就是可疑的。
+
+```typescript
+ // 如果没有理由怀疑，则返回 null。
+ return null
+}
+```
+
+如果两个条件都不成立，那么 `Approval` 事件就不可疑。
+
+```typescript
+const testPromises = approvalEvents.map((ev) => suspiciousApprovalEvent(ev))
+const testResults = (await Promise.all(testPromises)).filter((x) => x != null)
+
+console.log(testResults)
+```
+
+[`async` 函数](https://www.w3schools.com/js/js_async.asp)返回一个 `Promise` 对象。 使用常见语法 `await x()`，我们在继续处理之前等待该 `Promise` 完成。 这在编程和理解上很简单，但效率也很低。 在等待特定事件的 `Promise` 完成时，我们已经可以开始处理下一个事件了。
+
+这里我们使用 [`map`](https://www.w3schools.com/jsref/jsref_map.asp) 来创建一个 `Promise` 对象数组。 然后我们使用 [`Promise.all`](https://www.javascripttutorial.net/es6/javascript-promise-all/) 等待所有这些 promise 完成。 然后我们 [`filter`](https://www.w3schools.com/jsref/jsref_filter.asp) 这些结果以移除不可疑的事件。
+
+### 可疑的 `Transfer` 事件 {#suspicious-transfer-events}
+
+另一种识别诈骗代币的可能方法是查看它们是否有任何可疑的转账。 例如，从没有那么多代币的帐户进行的转账。 你可以看到[如何实现这个测试](https://github.com/qbzzt/20230915-scam-token-detection/blob/main/susTransfer.ts)，但 `wARB` 没有这个问题。
+
+## 结论 {#conclusion}
+
+ERC-20 诈骗的自动检测存在[假阴性](https://en.wikipedia.org/wiki/False_positives_and_false_negatives#False_negative_error)问题，因为骗局可以使用一个完全正常的 ERC-20 代币合约，而这个合约只是不代表任何真实的东西。 所以你应该总是尝试_从可信来源获取代币地址_。
+
+自动检测在某些情况下可以提供帮助，例如在 DeFi 组件中，那里有许多代币，需要自动处理。 但一如既往，[买家自负](https://www.investopedia.com/terms/c/caveatemptor.asp)，自己做研究，并鼓励你的用户也这样做。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
diff --git a/public/content/translations/zh/developers/tutorials/secret-state/index.md b/public/content/translations/zh/developers/tutorials/secret-state/index.md
new file mode 100644
index 00000000000..fc98817c210
--- /dev/null
+++ b/public/content/translations/zh/developers/tutorials/secret-state/index.md
@@ -0,0 +1,589 @@
+---
+title: "为保密状态使用零知识"
+description: "链上游戏受到限制，因为它们无法保留任何隐藏信息。 阅读本教程后，读者将能够结合零知识证明和服务器组件，创建具有脱链保密状态组件的可验证游戏。 我们将通过创建一个扫雷游戏来演示实现此目标的技术。"
+author: Ori Pomerantz
+tags: [ "服务器", "链下", "中心化", "零知识", "zokrates", "mud" ]
+skill: advanced
+lang: zh
+published: 2025-03-15
+---
+
+_区块链上没有秘密_。 发布在区块链上的所有内容都对所有人开放阅读。 这是必要的，因为区块链的基础是任何人都能对其进行验证。 然而，游戏通常依赖于保密状态。 例如，如果可以去区块链浏览器上查看地图，那么[扫雷](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\))游戏就毫无意义。
+
+最简单的解决方案是使用[服务器组件](/developers/tutorials/server-components/)来保存保密状态。 然而，我们使用区块链的原因是防止游戏开发者作弊。 我们需要确保服务器组件的诚实性。 服务器可以提供状态的哈希，并使用[零知识证明](/zero-knowledge-proofs/#why-zero-knowledge-proofs-are-important)来证明用于计算移动结果的状态是正确的。
+
+阅读本文后，你将了解如何创建这种保存保密状态的服务器、用于显示状态的客户端以及用于两者之间通信的链上组件。 我们使用的主要工具将是：
+
+| 工具 | 目的 | 已在版本上验证 |
+| --------------------------------------------- | ------------ | --------------------------------------: |
+| [Zokrates](https://zokrates.github.io/) | 零知识证明及其验证 | 1.1.9 |
+| [Typescript](https://www.typescriptlang.org/) | 服务器和客户端的编程语言 | 5.4.2 |
+| [Node](https://nodejs.org/en) | 运行服务器 | 20.18.2 |
+| [Viem](https://viem.sh/) | 与区块链通信 | 2.9.20 |
+| [MUD](https://mud.dev/) | 链上数据管理 | 2.0.12 |
+| [React](https://react.dev/) | 客户端用户界面 | 18.2.0 |
+| [Vite](https://vitejs.dev/) | 提供客户端代码 | 4.2.1 |
+
+## 扫雷示例 {#minesweeper}
+
+[扫雷](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) 是一款包含带雷区秘密地图的游戏。 玩家选择在特定位置挖掘。 如果该位置有地雷，游戏结束。 否则，玩家会得到该位置周围八个方格中的地雷数量。
+
+此应用程序使用 [MUD](https://mud.dev/) 编写，这是一个允许我们使用[键值数据库](https://aws.amazon.com/nosql/key-value/)在链上存储数据并自动与脱链组件同步该数据的框架。 除了同步之外，MUD 还可以轻松地提供访问控制，并让其他用户无需许可即可[扩展](https://mud.dev/guides/extending-a-world)我们的应用程序。
+
+### 运行扫雷示例 {#running-minesweeper-example}
+
+要运行扫雷示例：
+
+1. 确保你已[安装先决条件](https://mud.dev/quickstart#prerequisites)：[Node](https://mud.dev/quickstart#prerequisites)、[Foundry](https://book.getfoundry.sh/getting-started/installation)、[`git`](https://git-scm.com/downloads)、[`pnpm`](https://git-scm.com/downloads) 和 [`mprocs`](https://github.com/pvolok/mprocs)。
+
+2. 克隆存储库。
+
+ ```sh copy
+ git clone https://github.com/qbzzt/20240901-secret-state.git
+ ```
+
+3. 安装软件包。
+
+ ```sh copy
+ cd 20240901-secret-state/\npnpm install\nnpm install -g mprocs
+ ```
+
+ 如果 Foundry 是作为 `pnpm install` 的一部分安装的，你需要重新启动命令行 shell。
+
+4. 编译合约
+
+ ```sh copy
+ cd packages/contracts\nforge build\ncd ../..
+ ```
+
+5. 启动程序（包括 [anvil](https://book.getfoundry.sh/anvil/) 区块链）并等待。
+
+ ```sh copy
+ mprocs
+ ```
+
+ 请注意，启动需要很长时间。 要查看进度，首先使用向下箭头滚动到 _contracts_ 选项卡，查看正在部署的 MUD 合约。 当收到 _Waiting for file changes…_ 信息时，合约已部署，进一步的进度将在 _server_ 选项卡中进行。 在那里，等待直到收到信息 _Verifier address: 0x...._。
+
+ 如果此步骤成功，你将看到 `mprocs` 屏幕，左侧是不同的进程，右侧是当前选定进程的控制台输出。
+
+ 
+
+ 如果 `mprocs` 出现问题，你可以在各自的命令行窗口中手动运行四个进程：
+
+ - **Anvil**
+
+ ```sh
+ cd packages/contracts\nanvil --base-fee 0 --block-time 2
+ ```
+
+ - **合约**
+
+ ```sh
+ cd packages/contracts\npnpm mud dev-contracts --rpc http://127.0.0.1:8545
+ ```
+
+ - **服务器**
+
+ ```sh
+ cd packages/server\npnpm start
+ ```
+
+ - **客户端**
+
+ ```sh
+ cd packages/client\npnpm run dev
+ ```
+
+6. 现在你可以浏览到[客户端](http://localhost:3000)，点击**新游戏**，然后开始玩。
+
+### 表 {#tables}
+
+我们需要在链上创建[多个表](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts)。
+
+- `Configuration`：此表是单例，没有键，只有一条记录。 它用于保存游戏配置信息：
+ - `height`：雷区的高度
+ - `width`：雷区的宽度
+ - `numberOfBombs`：每个雷区中的炸弹数量
+
+- `VerifierAddress`：此表也是单例。 它用于保存配置的一部分，即验证者合约 (`verifier`) 的地址。 我们可以将此信息放在 `Configuration` 表中，但它是由不同的组件（服务器）设置的，因此将其放在单独的表中更容易。
+
+- `PlayerGame`：键是玩家的地址。 数据为：
+
+ - `gameId`：32 字节的值，是玩家正在玩的地图的哈希（游戏标识符）。
+ - `win`：一个布尔值，表示玩家是否赢得游戏。
+ - `lose`：一个布尔值，表示玩家是否输掉游戏。
+ - `digNumber`：游戏中成功挖掘的次数。
+
+- `GamePlayer`：此表保存反向映射，从 `gameId` 到玩家地址。
+
+- `Map`：键是包含三个值的元组：
+
+ - `gameId`：32 字节的值，是玩家正在玩的地图的哈希（游戏标识符）。
+ - `x` 坐标
+ - `y` 坐标
+
+ 值是一个数字。 如果检测到炸弹，则为 255。 否则，它是该位置周围的炸弹数量加一。 我们不能只使用炸弹的数量，因为默认情况下 EVM 中的所有存储和 MUD 中的所有行值都为零。 我们需要区分“玩家还没有在这里挖掘”和“玩家在这里挖掘了，发现周围没有炸弹”。
+
+此外，客户端和服务器之间的通信通过链上组件进行。 这也是使用表实现的。
+
+- `PendingGame`：未处理的开始新游戏的请求。
+- `PendingDig`：未处理的在特定游戏中特定位置挖掘的请求。 这是一个[脱链表](https://mud.dev/store/tables#types-of-tables)，意味着它不会写入 EVM 存储，只能使用事件在脱链上读取。
+
+### 执行和数据流 {#execution-data-flows}
+
+这些流程协调客户端、链上组件和服务器之间的执行。
+
+#### 初始化 {#initialization-flow}
+
+当你运行 `mprocs` 时，会发生以下步骤：
+
+1. [`mprocs`](https://github.com/pvolok/mprocs) 运行四个组件：
+
+ - [Anvil](https://book.getfoundry.sh/anvil/)，运行本地区块链
+ - [Contracts](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/contracts)，它会编译（如果需要）和部署 MUD 的合约
+ - [Client](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/client)，它运行 [Vite](https://vitejs.dev/) 来为网络浏览器提供 UI 和客户端代码。
+ - [Server](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/server)，它执行服务器操作
+
+2. `contracts` 包部署 MUD 合约，然后运行[ `PostDeploy.s.sol` 脚本](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol)。 此脚本设置配置。 来自 github 的代码指定了[一个 10x5 的雷区，其中有 8 个地雷](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol#L23)。
+
+3. [服务器](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts) 通过[设置 MUD](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L6) 来启动。 除此之外，这会激活数据同步，以便在服务器内存中存在相关表的副本。
+
+4. 服务器订阅一个函数，该函数在 [`Configuration` 表更改时](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L23)执行。 `PostDeploy.s.sol` 执行并修改表后，会调用[此函数](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L24-L168)。
+
+5. 当服务器初始化函数获取配置后，[它会调用 `zkFunctions`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L34-L35)来初始化[服务器的零知识部分](#using-zokrates-from-typescript)。 这只有在我们获得配置后才能发生，因为零知识函数必须将雷区的宽度和高度作为常量。
+
+6. 服务器的零知识部分初始化后，下一步是[将零知识验证合约部署到区块链](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L42-L53)并在 MUD 中设置被验证者地址。
+
+7. 最后，我们订阅更新，这样当玩家请求[开始新游戏](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71)或[在现有游戏中挖掘](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73-L108)时，我们就能看到。
+
+#### 新游戏 {#new-game-flow}
+
+这是当玩家请求新游戏时发生的情况。
+
+1. 如果此玩家没有进行中的游戏，或者有一个但 gameId 为零的游戏，客户端会显示一个[新游戏按钮](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175)。 当用户按下此按钮时，[React 会运行 `newGame` 函数](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L96)。
+
+2. [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L43-L46) 是一个 `System` 调用。 在 MUD 中，所有调用都通过 `World` 合约路由，在大多数情况下，你调用 `__`。 在这种情况下，调用的是 `app__newGame`，然后 MUD 将其路由到 [`GameSystem` 中的 `newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L16-L22)。
+
+3. 链上函数检查玩家是否没有进行中的游戏，如果没有，则[将请求添加到 `PendingGame` 表](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L21)。
+
+4. 服务器检测到 `PendingGame` 中的更改并[运行订阅的函数](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71)。 此函数调用 [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L110-L114)，后者又调用 [`createGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L116-L144)。
+
+5. `createGame` 做的第一件事是[创建一个包含适当数量地雷的随机地图](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L120-L135)。 然后，它调用 [`makeMapBorders`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L147-L166) 来创建一张带有空白边框的地图，这对于 Zokrates 是必需的。 最后，`createGame`调用 [`calculateMapHash`](#calculateMapHash)，以获取地图的哈希，该哈希用作游戏 ID。
+
+6. `newGame` 函数将新游戏添加到 `gamesInProgress`。
+
+7. 服务器做的最后一件事是调用 [`app__newGameResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L38-L43)，这是链上操作。 此函数位于不同的 `System` 中，即 [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol)，以启用访问控制。 访问控制在 [MUD 配置文件](https://mud.dev/config) [`mud.config.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts#L67-L72) 中定义。
+
+ 访问列表只允许单个地址调用 `System`。 这将服务器功能的访问权限限制为单个地址，因此没有人可以冒充服务器。
+
+8. 链上组件更新相关表：
+
+ - 在 `PlayerGame` 中创建游戏。
+ - 在 `GamePlayer` 中设置反向映射。
+ - 从 `PendingGame` 中删除请求。
+
+9. 服务器识别到 `PendingGame` 中的变化，但由于 [`wantsGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L58-L60) 为 false，因此不执行任何操作。
+
+10. 在客户端，[`gameRecord`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L143-L148) 被设置为玩家地址的 `PlayerGame` 条目。 当 `PlayerGame` 改变时，`gameRecord` 也会改变。
+
+11. 如果 `gameRecord` 中有值，并且游戏尚未分出胜负，客户端会[显示地图](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190)。
+
+#### 挖掘 {#dig-flow}
+
+1. 玩家[点击地图单元格的按钮](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L188)，这会调用 [`dig` 函数](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L33-L36)。 此函数在链上调用 [`dig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L24-L32)。
+
+2. 链上组件[执行多项健全性检查](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L25-L30)，如果成功，则将挖掘请求添加到 [`PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L31)。
+
+3. 服务器[检测到 `PendingDig` 中的变化](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73)。 [如果有效](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L75-L84)，它会[调用零知识代码](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L86-L95)（如下所述）来生成结果和证明其有效的证据。
+
+4. [服务器](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L97-L107) 在链上调用 [`digResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L45-L64)。
+
+5. `digResponse` 做两件事。 首先，它检查[零知识证明](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L47-L61)。 然后，如果证明通过，它会调用 [`processDigResult`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L67-L86) 来实际处理结果。
+
+6. `processDigResult` 检查游戏是否[失败](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L76-L78)或[获胜](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L83-L86)，并[更新 `Map`（链上地图）](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L80)。
+
+7. 客户端会自动获取更新并[更新显示给玩家的地图](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190)，并在适用时告知玩家是赢是输。
+
+## 使用 Zokrates {#using-zokrates}
+
+在上面解释的流程中，我们跳过了零知识部分，将其视为一个黑匣子。 现在让我们打开它，看看这段代码是如何编写的。
+
+### 对地图进行哈希 {#hashing-map}
+
+我们可以使用[此 JavaScript 代码](https://github.com/ZK-Plus/ICBC24_Tutorial_Compute-Offchain-Verify-onchain/tree/solutions/exercise) 来实现我们使用的 Zokrates 哈希函数 [Poseidon](https://www.poseidon-hash.info)。 然而，虽然这样做会更快，但也会比仅仅使用 Zokrates 哈希函数来做要复杂得多。 这是一个教程，因此代码为简单性而非性能进行了优化。 因此，我们需要两个不同的 Zokrates 程序，一个仅用于计算地图的哈希（`hash`），另一个用于实际创建地图上某个位置挖掘结果的零知识证明（`dig`）。
+
+### 哈希函数 {#hash-function}
+
+这是计算地图哈希的函数。 我们将逐行分析这段代码。
+
+```
+import "hashes/poseidon/poseidon.zok" as poseidon;\nimport "utils/pack/bool/pack128.zok" as pack128;
+```
+
+这两行从 [Zokrates 标准程序库](https://zokrates.github.io/toolbox/stdlib.html)中导入两个函数。 [第一个函数](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/hashes/poseidon/poseidon.zok)是 [Poseidon 哈希](https://www.poseidon-hash.info/)。 它接受一个 [`field` 元素](https://zokrates.github.io/language/types.html#field)数组并返回一个 `field`。
+
+Zokrates 中的字段元素通常小于 256 位，但相差不大。 为了简化代码，我们将地图限制为最多 512 位，并对一个包含四个字段的数组进行哈希，每个字段我们只使用 128 位。 为此，[`pack128` 函数](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok)将一个 128 位数组转换为一个 `field`。
+
+```
+ def hashMap(bool[${width+2}][${height+2}] map) -> field {
+```
+
+这一行开始了一个函数定义。 `hashMap` 接受一个名为 `map` 的参数，它是一个二维 `bool`(ean) 数组。 地图的尺寸是 `width+2` 乘以 `height+2`，原因[在下面解释](#why-map-border)。
+
+我们可以使用 `${width+2}` 和 `${height+2}`，因为 Zokrates 程序在此应用程序中作为[模板字符串](https://www.w3schools.com/js/js_string_templates.asp)存储。 `${` 和 `}` 之间的代码由 JavaScript 评估，这样程序就可以用于不同的地图大小。 地图参数周围有一个单位宽度的无炸弹边框，这就是我们需要将宽度和高度加二的原因。
+
+返回值是一个包含哈希的 `field`。
+
+```
+ bool[512] mut map1d = [false; 512];
+```
+
+地图是二维的。 然而，`pack128` 函数不适用于二维数组。 所以我们首先使用 `map1d` 将地图展平为一个 512 字节的数组。 默认情况下，Zokrates 变量是常量，但我们需要在循环中为这个数组赋值，所以我们将其定义为 [`mut`](https://zokrates.github.io/language/variables.html#mutability)。
+
+我们需要初始化数组，因为 Zokrates 没有 `undefined`。 `[false; 512]` 表达式表示[一个包含 512 个 `false` 值的数组](https://zokrates.github.io/language/types.html#declaration-and-initialization)。
+
+```
+ u32 mut counter = 0;
+```
+
+我们还需要一个计数器来区分我们在 `map1d` 中已经填充的位和尚未填充的位。
+
+```
+ for u32 x in 0..${width+2} {
+```
+
+这是在 Zokrates 中声明 [`for` 循环](https://zokrates.github.io/language/control_flow.html#for-loops)的方式。 Zokrates 的 `for` 循环必须有固定的边界，因为虽然它看起来像一个循环，但编译器实际上会“展开”它。 表达式 `${width+2}` 是一个编译时常量，因为 `width` 是在 TypeScript 代码调用编译器之前设置的。
+
+```
+ for u32 y in 0..${height+2} {\n map1d[counter] = map[x][y];\n counter = counter+1;\n }\n }
+```
+
+对于地图中的每个位置，将该值放入 `map1d` 数组并增加计数器。
+
+```
+ field[4] hashMe = [\n pack128(map1d[0..128]),\n pack128(map1d[128..256]),\n pack128(map1d[256..384]),\n pack128(map1d[384..512])\n ];
+```
+
+`pack128` 用于从 `map1d` 创建一个包含四个 `field` 值的数组。 在 Zokrates 中，`array[a..b]` 表示从 `a` 开始到 `b-1` 结束的数组切片。
+
+```
+ return poseidon(hashMe);\n}
+```
+
+使用 `poseidon` 将此数组转换为哈希。
+
+### 哈希程序 {#hash-program}
+
+服务器需要直接调用 `hashMap` 来创建游戏标识符。 然而，Zokrates 只能调用程序上的 `main` 函数来启动，所以我们创建了一个带有 `main` 的程序，该程序调用哈希函数。
+
+```
+${hashFragment}\n\ndef main(bool[${width+2}][${height+2}] map) -> field {\n return hashMap(map);\n}
+```
+
+### 挖掘程序 {#dig-program}
+
+这是应用程序零知识部分的核心，我们在这里生成用于验证挖掘结果的证明。
+
+```
+${hashFragment}\n\n// (x,y) 位置的地雷数量\ndef map2mineCount(bool[${width+2}][${height+2}] map, u32 x, u32 y) -> u8 {\n return if map[x+1][y+1] { 1 } else { 0 };\n}
+```
+
+#### 为何需要地图边框 {#why-map-border}
+
+零知识证明使用[算术电路](https://medium.com/web3studio/simple-explanations-of-arithmetic-circuits-and-zero-knowledge-proofs-806e59a79785)，它没有 `if` 语句的简单等价物。 相反，它们使用[条件运算符](https://en.wikipedia.org/wiki/Ternary_conditional_operator)的等价物。 如果 `a` 可以是零或一，你可以将 `if a { b } else { c }` 计算为 `ab+(1-a)c`。
+
+因此，Zokrates 的 `if` 语句总是会评估两个分支。 例如，如果你有以下代码：
+
+```
+bool[5] arr = [false; 5];\nu32 index=10;\nreturn if index>4 { 0 } else { arr[index] }
+```
+
+它会出错，因为它需要计算 `arr[10]`，即使该值稍后会乘以零。
+
+这就是为什么我们需要在地图周围设置一个单位宽度的边框。 我们需要计算一个位置周围的地雷总数，这意味着我们需要看到我们正在挖掘的位置的上方一行、下方一行、左边和右边的位置。 这意味着这些位置必须存在于提供给 Zokrates 的地图数组中。
+
+```
+def main(private bool[${width+2}][${height+2}] map, u32 x, u32 y) -> (field, u8) {
+```
+
+默认情况下，Zokrates 证明包含其输入。 知道一个地点周围有五个地雷是没有用的，除非你真的知道是哪个地点（而且你不能仅仅将它与你的请求匹配，因为那样证明者可能会使用不同的值而不会告诉你）。 然而，我们需要在将地图提供给 Zokrates 的同时保持其保密。 解决方案是使用一个 `private` 参数，一个_不_被证明揭示的参数。
+
+这为滥用开辟了另一条途径。 证明者可以使用正确的坐标，但在该位置周围创建一个包含任意数量地雷的地图，甚至可能在该位置本身创建地雷。 为防止这种滥用，我们让零知识证明包含地图的哈希，即游戏标识符。
+
+```
+ return (hashMap(map),
+```
+
+这里的返回值是一个元组，包括地图哈希数组和挖掘结果。
+
+```
+ if map2mineCount(map, x, y) > 0 { 0xFF } else {
+```
+
+如果该位置本身有炸弹，我们使用 255 作为特殊值。
+
+```
+ map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +\n map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +\n map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)\n }\n );\n}
+```
+
+如果玩家没有踩到地雷，则将该位置周围区域的地雷数量相加并返回。
+
+### 在 TypeScript 中使用 Zokrates {#using-zokrates-from-typescript}
+
+Zokrates 有一个命令行界面，但在这个程序中，我们在 [TypeScript 代码](https://zokrates.github.io/toolbox/zokrates_js.html)中使用它。
+
+包含 Zokrates 定义的程序库名为 [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts)。
+
+```typescript
+import { initialize as zokratesInitialize } from "zokrates-js"
+```
+
+导入 [Zokrates JavaScript 绑定](https://zokrates.github.io/toolbox/zokrates_js.html)。 我们只需要 [`initialize`](https://zokrates.github.io/toolbox/zokrates_js.html#initialize) 函数，因为它返回一个解析为所有 Zokrates 定义的 promise。
+
+```typescript
+export const zkFunctions = async (width: number, height: number) : Promise => {
+```
+
+与 Zokrates 本身类似，我们也只导出一个函数，该函数也是[异步的](https://www.w3schools.com/js/js_async.asp)。 当它最终返回时，它提供了几个函数，如下所示。
+
+```typescript
+const zokrates = await zokratesInitialize()
+```
+
+初始化 Zokrates，从程序库中获取我们需要的一切。
+
+```typescript
+const hashFragment = `\n import "utils/pack/bool/pack128.zok" as pack128;\n import "hashes/poseidon/poseidon.zok" as poseidon;\n .\n .\n .\n }\n `\n\nconst hashProgram = `\n ${hashFragment}\n .\n .\n .\n `\n\nconst digProgram = `\n ${hashFragment}\n .\n .\n .\n `
+```
+
+接下来是我们上面看到的哈希函数和两个 Zokrates 程序。
+
+```typescript
+const digCompiled = zokrates.compile(digProgram)\nconst hashCompiled = zokrates.compile(hashProgram)
+```
+
+这里我们编译这些程序。
+
+```typescript
+// 为零知识验证创建密钥。\n// 在生产系统上，您需要使用设置仪式。\n// (https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony)。\nconst keySetupResults = zokrates.setup(digCompiled.program, "")\nconst verifierKey = keySetupResults.vk\nconst proverKey = keySetupResults.pk
+```
+
+在生产系统上，我们可能会使用更复杂的[设置仪式](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony)，但对于演示来说，这已经足够了。 用户知道证明者密钥不是问题 - 他们仍然不能用它来证明事情，除非它们是真实的。 因为我们指定了熵（第二个参数，`""`），所以结果总是相同的。
+
+\*\*注意：\*\*Zokrates 程序的编译和密钥创建是缓慢的过程。 不需要每次都重复它们，只需在地图大小改变时重复即可。 在生产系统上，你只需执行一次，然后存储输出。 我在这里不这样做只是为了简单起见。
+
+#### `calculateMapHash` {#calculateMapHash}
+
+```typescript
+const calculateMapHash = function (hashMe: boolean[][]): string {\n return (\n "0x" +\n BigInt(zokrates.computeWitness(hashCompiled, [hashMe]).output.slice(1, -1))\n .toString(16)\n .padStart(64, "0")\n )\n}
+```
+
+[`computeWitness`](https://zokrates.github.io/toolbox/zokrates_js.html#computewitnessartifacts-args-options) 函数实际上运行 Zokrates 程序。 它返回一个包含两个字段的结构：`output`，即程序的输出（作为 JSON 字符串），和 `witness`，即创建结果的零知识证明所需的信息。 在这里，我们只需要输出。
+
+输出是一个形如 `"31337"` 的字符串，即一个用引号括起来的十进制数。 但我们需要的 `viem` 输出是形如 `0x60A7` 的十六进制数。 所以我们使用 `.slice(1,-1)` 去掉引号，然后用 `BigInt` 将剩余的字符串（一个十进制数）转换成一个 [`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)。 `.toString(16)` 将这个 `BigInt` 转换成一个十六进制字符串，`"0x"+` 添加了十六进制数的标记。
+
+```typescript
+// 挖掘并返回结果的零知识证明\n// (服务器端代码)
+```
+
+零知识证明包括公共输入（`x` 和 `y`）和结果（地图的哈希和炸弹数量）。
+
+```typescript
+ const zkDig = function(map: boolean[][], x: number, y: number) : any {\n if (x<0 || x>=width || y<0 || y>=height)\n throw new Error("Trying to dig outside the map")
+```
+
+在 Zokrates 中检查索引是否越界是个问题，所以我们在这里做。
+
+```typescript
+const runResults = zokrates.computeWitness(digCompiled, [map, `${x}`, `${y}`])
+```
+
+执行挖掘程序。
+
+```typescript
+ const proof = zokrates.generateProof(\n digCompiled.program,\n runResults.witness,\n proverKey)\n\n return proof\n }
+```
+
+使用 [`generateProof`](https://zokrates.github.io/toolbox/zokrates_js.html#generateproofprogram-witness-provingkey-entropy) 并返回证明。
+
+```typescript
+const solidityVerifier = `\n // 地图尺寸: ${width} x ${height}\n \n${zokrates.exportSolidityVerifier(verifierKey)}\n `
+```
+
+一个 Solidity 验证者，这是一个我们可以部署到区块链并用于验证 `digCompiled.program` 生成的证明的智能合约。
+
+```typescript
+ return {\n zkDig,\n calculateMapHash,\n solidityVerifier,\n }\n}
+```
+
+最后，返回其他代码可能需要的所有内容。
+
+## 安全测试 {#security-tests}
+
+安全测试很重要，因为功能性漏洞最终会暴露出来。 但如果应用程序不安全，那么在有人作弊并窃取他人资源而被揭露之前，这种不安全性很可能会隐藏很长一段时间。
+
+### 权限 {#permissions}
+
+这个游戏中有一个特权实体，即服务器。 它是唯一允许调用 [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) 中函数的用户。 我们可以使用 [`cast`](https://book.getfoundry.sh/cast/) 来验证对有权限函数的调用是否只允许作为服务器帐户进行。
+
+[服务器的私钥位于 `setupNetwork.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/mud/setupNetwork.ts#L52)。
+
+1. 在运行 `anvil`（区块链）的计算机上，设置这些环境变量。
+
+ ```sh copy
+ WORLD_ADDRESS=0x8d8b6b8414e1e3dcfd4168561b9be6bd3bf6ec4b\nUNAUTHORIZED_KEY=0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a\nAUTHORIZED_KEY=0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d
+ ```
+
+2. 使用 `cast` 尝试将验证者地址设置为未经授权的地址。
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $UNAUTHORIZED_KEY
+ ```
+
+ 不仅 `cast` 会报告失败，你还可以在浏览器中的游戏中打开 **MUD 开发工具**，点击**表格**，然后选择 **app\_\_VerifierAddress**。 看到地址不为零。
+
+3. 将验证者地址设置为服务器的地址。
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $AUTHORIZED_KEY
+ ```
+
+ **app\_\_VerifiedAddress** 中的地址现在应该为零。
+
+同一 `System` 中的所有 MUD 函数都经过相同的访问控制，因此我认为此测试已足够。 如果你不这么认为，可以检查 [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) 中的其他函数。
+
+### 零知识滥用 {#zero-knowledge-abuses}
+
+验证 Zokrates 的数学超出了本教程的范围（也超出了我的能力）。 然而，我们可以对零知识代码运行各种检查，以验证如果操作不正确，它会失败。 所有这些测试都将要求我们更改 [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts) 并重新启动整个应用程序。 仅仅重新启动服务器进程是不够的，因为它会将应用程序置于一种不可能的状态（玩家正在进行游戏，但服务器不再可用该游戏）。
+
+#### 错误答案 {#wrong-answer}
+
+最简单的可能性是在零知识证明中提供错误的答案。 为此，我们进入 `zkDig` 内部并[修改第 91 行](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L91)：
+
+```ts
+proof.inputs[3] = "0x" + "1".padStart(64, "0")
+```
+
+这意味着无论正确答案是什么，我们总是声称只有一个炸弹。 尝试玩这个版本，你会在 `pnpm dev` 屏幕的**服务器**选项卡中看到这个错误：
+
+```
+ cause: {\n code: 3,\n message: 'execution reverted: revert: Zero knowledge verification fail',\n data: '0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000\n000000000000000000000000000000000000000000000000205a65726f206b6e6f776c6564676520766572696669636174696f6\ne206661696c'\n },
+```
+
+所以这种作弊会失败。
+
+#### 错误的证明 {#wrong-proof}
+
+如果我们提供正确的信息，但只有错误的证明数据，会发生什么？ 现在，将第 91 行替换为：
+
+```ts
+proof.proof = {\n a: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],\n b: [\n ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],\n ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],\n ],\n c: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],\n}
+```
+
+它仍然失败，但现在它失败时没有给出原因，因为它是在验证者调用期间发生的。
+
+### 用户如何验证零信任代码？ {#user-verify-zero-trust}
+
+智能合约相对容易验证。 通常，开发者会将源代码发布到区块浏览器，区块浏览器会验证源代码确实能编译成[合约部署交易](/developers/docs/smart-contracts/deploying/)中的代码。 在 MUD `System` 的情况下，这[稍微复杂一些](https://mud.dev/cli/verify)，但相差不大。
+
+对于零知识来说，这更难。 验证者包含一些常量并对它们进行一些计算。 这并不能告诉你正在证明什么。
+
+```solidity
+ function verifyingKey() pure internal returns (VerifyingKey memory vk) {\n vk.alpha = Pairing.G1Point(uint256(0x0f43f4fe7b5c2326fed4ac6ed2f4003ab9ab4ea6f667c2bdd77afb068617ee16), uint256(0x25a77832283f9726935219b5f4678842cda465631e72dbb24708a97ba5d0ce6f));\n vk.beta = Pairing.G2Point([uint256(0x2cebd0fbd21aca01910581537b21ae4fed46bc0e524c055059aa164ba0a6b62b), uint256(0x18fd4a7bc386cf03a95af7163d5359165acc4e7961cb46519e6d9ee4a1e2b7e9)], [uint256(0x11449dee0199ef6d8eebfe43b548e875c69e7ce37705ee9a00c81fe52f11a009), uint256(0x066d0c83b32800d3f335bb9e8ed5e2924cf00e77e6ec28178592eac9898e1a00)]);
+```
+
+解决方案是，至少在区块浏览器将 Zokrates 验证添加到其用户界面之前，应用程序开发者应提供 Zokrates 程序，并且至少有一些用户使用适当的验证密钥自行编译它们。
+
+要做到这一点：
+
+1. [安装 Zokrates](https://zokrates.github.io/gettingstarted.html)。
+
+2. 创建一个文件 `dig.zok`，包含 Zokrates 程序。 下面的代码假设你保留了原始地图尺寸 10x5。
+
+ ```zokrates
+ import "utils/pack/bool/pack128.zok" as pack128;\n import "hashes/poseidon/poseidon.zok" as poseidon;\n\n def hashMap(bool[12][7] map) -> field {\n bool[512] mut map1d = [false; 512];\n u32 mut counter = 0;\n\n for u32 x in 0..12 {\n for u32 y in 0..7 {\n map1d[counter] = map[x][y];\n counter = counter+1;\n }\n }\n\n field[4] hashMe = [\n pack128(map1d[0..128]),\n pack128(map1d[128..256]),\n pack128(map1d[256..384]),\n pack128(map1d[384..512])\n ];\n\n return poseidon(hashMe);\n }\n\n\n // (x,y) 位置的地雷数量\n def map2mineCount(bool[12][7] map, u32 x, u32 y) -> u8 {\n return if map[x+1][y+1] { 1 } else { 0 };\n }\n\n def main(private bool[12][7] map, u32 x, u32 y) -> (field, u8) {\n return (hashMap(map) ,\n if map2mineCount(map, x, y) > 0 { 0xFF } else {\n map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +\n map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +\n map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)\n }\n );\n }
+ ```
+
+3. 编译 Zokrates 代码并创建验证密钥。 验证密钥必须使用与原始服务器相同的熵来创建，[在这种情况下为空字符串](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L67)。
+
+ ```sh copy
+ zokrates compile --input dig.zok\nzokrates setup -e ""
+ ```
+
+4. 自己创建 Solidity 验证者，并验证其功能与区块链上的验证者相同（服务器添加了一条注释，但这不重要）。
+
+ ```sh copy
+ zokrates export-verifier\ndiff verifier.sol ~/20240901-secret-state/packages/contracts/src/verifier.sol
+ ```
+
+## 设计决策 {#design}
+
+在任何足够复杂的应用程序中，都存在需要权衡取舍的相互竞争的设计目标。 让我们看看一些权衡取舍，以及为什么当前的解决方案比其他选项更可取。
+
+### 为何使用零知识 {#why-zero-knowledge}
+
+对于扫雷游戏，你并不真正需要零知识。 服务器可以一直持有地图，然后在游戏结束时才全部揭示。 然后，在游戏结束时，智能合约可以计算地图哈希，验证其是否匹配，如果不匹配，则惩罚服务器或完全忽略该游戏。
+
+我没有使用这个更简单的解决方案，因为它只适用于具有明确定义的结束状态的短时游戏。 当一个游戏可能是无限的（例如[自治世界](https://0xparc.org/blog/autonomous-worlds)），你需要一个在_不_揭示状态的情况下证明其状态的解决方案。
+
+作为一篇教程，本文需要一个易于理解的短时游戏，但这项技术对于较长的游戏最为有用。
+
+### 为何选择 Zokrates？ {#why-zokrates}
+
+[Zokrates](https://zokrates.github.io/) 不是唯一可用的零知识程序库，但它类似于一种普通的[命令式](https://en.wikipedia.org/wiki/Imperative_programming)编程语言，并支持布尔变量。
+
+对于你的应用程序，如果有不同的需求，你可能更愿意使用 [Circum](https://docs.circom.io/getting-started/installation/) 或 [Cairo](https://www.cairo-lang.org/tutorials/getting-started-with-cairo/)。
+
+### 何时编译 Zokrates {#when-compile-zokrates}
+
+在这个程序中，我们[每次服务器启动时](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L60-L61)都会编译 Zokrates 程序。 这显然是浪费资源，但这是一个教程，为简单性而优化。
+
+如果我正在编写一个生产级应用程序，我会检查是否有一个包含此雷区大小的已编译 Zokrates 程序的文件，如果有，就使用它。 在链上部署验证者合约也是如此。
+
+### 创建验证者和证明者密钥 {#key-creation}
+
+[密钥创建](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L63-L69)是另一个纯计算，对于给定的雷区大小，不需要执行多次。 同样，为了简单起见，它只执行一次。
+
+此外，我们可以使用[一个设置仪式](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony)。 设置仪式的优点是，你需要每个参与者的熵或一些中间结果才能在零知识证明上作弊。 如果至少有一名仪式参与者是诚实的并删除了该信息，那么零知识证明就可以免受某些攻击。 然而，_没有机制_可以验证信息已从所有地方删除。 如果零知识证明至关重要，你应参与设置仪式。
+
+在这里，我们依赖于[perpetual powers of tau](https://github.com/privacy-scaling-explorations/perpetualpowersoftau)，它有数十名参与者。 这可能足够安全，而且简单得多。 我们也不在密钥创建期间添加熵，这使得用户更容易[验证零知识配置](#user-verify-zero-trust)。
+
+### 在哪里验证 {#where-verification}
+
+我们可以在链上（需要消耗燃料）或客户端（使用 [`verify`](https://zokrates.github.io/toolbox/zokrates_js.html#verifyverificationkey-proof)）验证零知识证明。 我选择了第一种，因为这让你可以[验证验证者](#user-verify-zero-trust)一次，然后只要其合约地址保持不变，就可以信任它不会改变。 如果在客户端进行验证，你每次下载客户端时都必须验证收到的代码。
+
+此外，虽然这个游戏是单人游戏，但许多区块链游戏是多人游戏。 链上验证意味着你只需验证一次零知识证明。 在客户端进行验证将需要每个客户端独立验证。
+
+### 在 TypeScript 还是 Zokrates 中展平地图？ {#where-flatten}
+
+总的来说，当处理可以在 TypeScript 或 Zokrates 中完成时，最好在 TypeScript 中完成，因为它速度快得多，并且不需要零知识证明。 例如，这就是我们不向 Zokrates 提供哈希并让其验证其正确性的原因。 哈希必须在 Zokrates 内部完成，但返回的哈希与链上哈希之间的匹配可以在其外部进行。
+
+然而，我们仍然在 [Zokrates 中展平地图](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L15-L20)，而我们本可以在 TypeScript 中完成。 原因是在我看来，其他选择更糟。
+
+- 向 Zokrates 代码提供一个一维布尔数组，并使用诸如 `x*(height+2)\n+y` 的表达式来获取二维地图。 这会使[代码](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L44-L47)变得更复杂一些，所以我认为对于一个教程来说，性能提升是不值得的。
+
+- 向 Zokrates 发送一维数组和二维数组。 然而，这个解决方案对我们没有任何好处。 Zokrates 代码必须验证提供的一维数组确实是二维数组的正确表示。 所以不会有任何性能提升。
+
+- 在 Zokrates 中展平二维数组。 这是最简单的选择，所以我选择了它。
+
+### 在哪里存储地图 {#where-store-maps}
+
+在此应用程序中，[`gamesInProgress`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L20) 只是内存中的一个变量。 这意味着如果你的服务器崩溃并需要重新启动，它存储的所有信息都将丢失。 玩家不仅无法继续他们的游戏，甚至无法开始新游戏，因为链上组件认为他们仍在进行游戏。
+
+这对于生产系统来说显然是糟糕的设计，在生产系统中，你会将此信息存储在数据库中。 我在这里使用变量的唯一原因是因为这是一个教程，简单性是主要考虑因素。
+
+## 结论：在什么条件下这是合适的技术？ {#conclusion}
+
+所以，现在你知道如何编写一个带有服务器的游戏，该服务器存储不属于链上的保密状态。 但在什么情况下你应该这样做呢？ 主要有两个考虑因素。
+
+- _长期运行的游戏_：[如上所述](#why-zero-knowledge)，在短时游戏中，你可以在游戏结束后发布状态，然后对所有内容进行验证。 但当游戏时间很长或不确定，并且状态需要保密时，这就不是一个选项。
+
+- _可接受一定的中心化_：零知识证明可以验证完整性，即实体没有伪造结果。 他们不能做的是确保该实体仍然可用并回答信息。 在可用性也需要去中心化的情况下，零知识证明不是一个充分的解决方案，你需要[多方计算](https://en.wikipedia.org/wiki/Secure_multi-party_computation)。
+
+[点击此处查看我的更多作品](https://cryptodocguy.pro/)。
+
+### 致谢 {#acknowledgements}
+
+- Alvaro Alonso 阅读了本文的草稿，并澄清了我对 Zokrates 的一些误解。
+
+任何剩余的错误都由我负责。
diff --git a/public/content/translations/zh/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/zh/developers/tutorials/secure-development-workflow/index.md
index a0e6bdba9bb..eaca9675b65 100644
--- a/public/content/translations/zh/developers/tutorials/secure-development-workflow/index.md
+++ b/public/content/translations/zh/developers/tutorials/secure-development-workflow/index.md
@@ -1,19 +1,16 @@
---
-title: 智能合约安全清单
-description: 编写安全智能合约的推荐工作流程
+title: "智能合约安全清单"
+description: "编写安全智能合约的推荐工作流程"
author: "Trailofbits"
-tags:
- - "智能合约"
- - "安全性"
- - "solidity"
+tags: [ "智能合同", "安全性。", "Solidity" ]
skill: intermediate
lang: zh
published: 2020-09-07
-source: 构建安全的合约
+source: "构建安全的合约"
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
---
-## 智能合约开发清单 {#smart-contract-development-checklist}
+## 智能合约开发核对清单 {#smart-contract-development-checklist}
这是一个高级别的过程，我们建议在你编写智能合约时遵循。
@@ -24,21 +21,21 @@ sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/devel
考虑你的智能合约的特殊功能：
-- 你的合约是否可以升级？ 使用 [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) 或 [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/) 检查你的可升级代码是否有缺陷。 我们记录了 17 种升级可能出现的问题。
-- 你的合约是否声明符合 ERC 的要求？ 使用 [`slither-check-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) 对它们进行审核。 这个工具能立即识别出六个常见规范的偏差。
-- 你是否与第三方代币集成？ 在依赖外部合约之前，请先查看我们的[代币集成清单](/developers/tutorials/token-integration-checklist/)。
+- 你的合约是否可以升级？ 使用 [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) 或 [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/) 审核可升级代码中的漏洞。 我们记录了 17 种升级可能出现的问题。
+- 你的合约是否声明符合 ERC 的要求？ 使用 [`slither-check-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) 检查它们。 这个工具能立即识别出六个常见规范的偏差。
+- 你是否与第三方代币集成？ 在依赖外部合约之前，请查看我们的[代币集成核对清单](/developers/tutorials/token-integration-checklist/)。
目视检查代码的关键安全功能。
-- 查看 Slither 的 [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) printer。 避免以外屏蔽和 C3 线性化问题。
-- 查看 Slither 的 [function-summary](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) printer。 它报告功能可见性和访问控制。
-- 查看 Slither 的 [vars-and-auth](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) printer。 它报告了对状态变量的访问控制。
+- 查看 Slither 的 [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) 打印机。 避免以外屏蔽和 C3 线性化问题。
+- 查看 Slither 的 [function-summary](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) 打印机。 它报告功能可见性和访问控制。
+- 查看 Slither 的 [vars-and-auth](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) 打印机。 它报告了对状态变量的访问控制。
记录关键安全属性，并使用自动化测试生成器对其进行评估：
-- 学习 [记录代码的安全属性](/developers/tutorials/guide-to-smart-contract-security-tools/)。 一开始是艰难的，但它是实现良好结果的最重要的活动。 这也是使用本教程中任何高级技术的先决条件。
-- 在 Solidity 中定义安全属性，用于 [Echidna](https://github.com/crytic/echidna) 和 [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html)。 重点是你的状态机、访问控制、算术运算、外部交互和标准一致性。
-- 使用 [ Slither 的 Python API](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) 定义安全属性。 重点是继承、变量依赖项、访问控制和其他结构问题。
+- 学习如何[为您的代码记录安全属性](/developers/tutorials/guide-to-smart-contract-security-tools/)。 一开始是艰难的，但它是实现良好结果的最重要的活动。 这也是使用本教程中任何高级技术的先决条件。
+- 在 Solidity 中定义安全属性，以便与 [Echidna](https://github.com/crytic/echidna) 和 [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html) 结合使用。 重点是你的状态机、访问控制、算术运算、外部交互和标准一致性。
+- 使用 [Slither 的 Python API](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) 定义安全属性。 重点是继承、变量依赖项、访问控制和其他结构问题。
- 在每次提交时，使用 [Crytic](https://crytic.io) 运行你的属性测试。 Crytic 可以使用和评估安全属性测试，因此团队中的每个人都可以轻松地看到他们通过 GitHub。 测试失败会阻止提交。
最后，请注意自动化工具无法轻易找到的问题：
@@ -48,8 +45,8 @@ sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/devel
- 加密操作
- 与外部 DeFi 组件的风险互动
-## 寻求帮助 {#ask-for-help}
+## 请求帮助 {#ask-for-help}
-[以太坊的办公时间](https://calendly.com/dan-trailofbits/office-hours)为每周二下午。 这些 1 小时的 1 对 1 会议是一个机会，你可以向我们询问有关安全的任何问题，使用我们的工具进行故障排除，并获得专家对你当前方法的反馈。 我们将帮助你消化本指南。
+[以太坊答疑时间](https://calendly.com/dan-trailofbits/office-hours)于每周二下午举行。 这些 1 小时的 1 对 1 会议是一个机会，你可以向我们询问有关安全的任何问题，使用我们的工具进行故障排除，并获得专家对你当前方法的反馈。 我们将帮助你消化本指南。
-加入我们的 Slack: [ Empire Hacking](https://join.slack.com/t/empirehacking/shared_invite/zt-h97bbrj8-1jwuiU33nnzg67JcvIciUw)。 如果你有任何问题，可以随时在 #crytic 和 #ethereum 频道上联系我们。
+加入我们的 Slack：[Empire Hacking](https://join.slack.com/t/empirehacking/shared_invite/zt-h97bbrj8-1jwuiU33nnzg67JcvIciUw)。 如果你有任何问题，可以随时在 #crytic 和 #ethereum 频道上联系我们。
diff --git a/public/content/translations/zh/developers/tutorials/send-token-ethersjs/index.md b/public/content/translations/zh/developers/tutorials/send-token-ethersjs/index.md
index 649ce0790f5..f3a0e2f2db9 100644
--- a/public/content/translations/zh/developers/tutorials/send-token-ethersjs/index.md
+++ b/public/content/translations/zh/developers/tutorials/send-token-ethersjs/index.md
@@ -1,27 +1,25 @@
---
-title: 使用 ethers.js 发送代币
-description: 使用 ethers.js 发送代币的初学者入门指南。
+title: "使用 ethers.js 发送代币"
+description: "使用 ethers.js 发送代币的初学者友好指南。"
author: Kim YongJun
-tags:
- - "ETHERS.JS"
- - "ERC-20"
- - "代币"
+tags: [ "ETHERS.JS", "ERC-20", "代币" ]
skill: beginner
lang: zh
published: 2021-04-06
---
-## 使用 ethers.js(5.0) 发送代币 {#send-token}
+## 使用 ethers.js (5.0) 发送代币 {#send-token}
-### 在本教程中，您将学习如何： {#you-learn-about}
+### 在本教程中，你将学习如何：{#you-learn-about}
- 导入 ethers.js
-- 进行代币转账
+- 转账代币
- 根据网络流量情况设置燃料价格
-### 入门指南 {#to-get-started}
+### 开始上手 {#to-get-started}
-开始前，我们必须先将 ethers.js 库导入我们的 javascript 中 包括 ethers.js(5.0)
+开始前，我们必须先将 ethers.js 程序库导入到我们的 javascript 中
+包含 ethers.js (5.0)
### 安装 {#install-ethersjs}
@@ -29,16 +27,16 @@ published: 2021-04-06
/home/ricmoo> npm install --save ethers
```
-浏览器版 ES6
+浏览器中的 ES6
```html
```
-浏览器版 ES3(UMD)
+浏览器中的 ES3 (UMD)
```html