文章作者: @BoxMrChen，欢迎转载，转载请注明出处。 文章 Github 仓库: https://github.com/nishuzumi/blog 欢迎Star。如果文章有误，欢迎提PR。 进入交流群：欢迎添加个人微信 Im3boxtech，备注进群，我会拉你进入交流群。

本文章主要讲述了如何在 Solidity 中使用 zk-SNARKs，以及如何使用 ZoKrates 编译器来生成证明和验证合约。

这文章不会过于深入 zk-SNARKs 的技术原理，这文章目的是为让读者能够理解 sk-SNARKs 的技术能在 EVM 中达到什么效果，如何使用，并且能在代码中运用。

zk-SNARKs 简介

关于 zk-SNARKs 的简短描述为，我们需要在 zk 电路中编写一段代码，这段代码的输入是一些公开的数据，输出是一些私有的数据。zk-SNARKs 的验证算法可以验证这段代码的输出是否正确，但是验证算法不会泄露任何私有数据。而 Solidity 合约的主要目的是验证 zk-SNARKs 的验证算法的结果，如果验证算法的结果正确，那么合约会执行一些操作。

也就是说，在 EVM 上，只是进行了结果的验证，并没有进行一些复杂的计算，这些计算都是在 zk 电路中进行的。而这部分 zk 电路，则是在链下进行的，然后将结果提交到链上。

在 Solidity 中使用 zk-SNARKs

首先，我们需要知道 zk-SNARKs 可以完成什么功能，其实很简单，我们可以简单的认为，zk-SNARKs 可以完成对一个函数运算结果的校验，比如说，我们有一个函数，输入是三个数字，输出是一个数字，我们可以使用 zk-SNARKs 来校验这个函数的输出是否正确。但是我们并不需要知道输入的三个数字是什么，只需要知道这个函数的输出即可，也就是说，在一个函数完成计算时，我们可以知道确实是有这么三个数他能符合这个函数的输入，并且能输出正确结果，但是我们并不知道这三个数是什么。

在 Solidity 中，我们可以使用 zk-SNARKs 来完成对一个函数的校验，但是我们需要知道这个函数的输入和输出，然后我们可以使用 ZoKrates 编译器来生成 zk 电路，然后将 zk 电路的代码放到 Solidity 合约中，然后在合约中完成对 zk 电路的验证。

安装 ZoKrates 编译器

安装 ZoKrates

curl -LSfs get.zokrat.es | sh

也可以选择其他安装方式，具体选择查看他们的 Github 页面。

编写 zk 电路

从上一章节我们浅显的知道，一个 zk-SNARKs 电路需要的最基本的东西为：

• 一个函数 - 我们需要有一个函数对数据进行运算，也就是程序 C

• lambda - 所谓的“有毒废料”，其实就是一个 root key，我们需要通过它来生成 pk 和 vk

有了这两个基础条件，用户就可以通过 pk，目标值，输入值来生成证明 w。随后，我们的验证程序通过 vk，目标值，证明 w 来验证证明的正确性。

我们先假设有这么一个第三方，他可以安全的生成 lambda，然后安全的将程序和 lambda 进行运算生成 vk 和 pk。

那么现在有两个新的角色，user 和 project。user 是用户，他确确实实拥有着一些数据，project 是项目合约，他需要验证用户的数据是否正确。

一个函数

我们首先需要一个函数，但是我并不打算举一些简单例子，因为我觉得这样做非常没有意义，因为 zk-SNARKs 的主要目的是为了验证一些复杂的函数，而不是一些简单的函数。

比如，我们现在需要生成一个存款凭证，有这个凭证，我们可以在任何地方取出这笔钱，但是我们并不知道这笔钱是谁的，我们只知道这笔钱是谁存的，存了多少，以及存款的时间。

首先我们需要一个存款函数，这个函数的输入为存款的金额，和一个随机数，然后输出为一个存款凭证。任何拥有这个凭证的人都可以取出这笔资金。所以，实际上，我们只需要编写验证知道这个凭证的验证函数即可。

import "hashes/sha256/512bit" as sha256;
import "utils/pack/u32/nonStrictUnpack256" as unpack256;

// deposit_amount: 存款金额
// secret: 随机数
// returns: 用于取款的commitment
def main(field deposit_amount, private field secret) -> u32[8] {
    return sha256(unpack256(deposit_amount), unpack256(secret));
}

关于 Zok 的语法和用法这里不过多描述，具体可以参考官网，这里简单解释一下，这个函数的输入为两个数字，一个是存款金额，一个是随机数，然后输出为一个 u32[8]，实际上就是 uint256.同时我们注意一下，参数中 deposit_amount 没有 private 关键词，说明这个参数是公开数据。

编译文件

这部分内容在 zokrates 中有讲述方式为

# compile
zokrates compile -i deposit.zok
# perform the setup phase
zokrates setup
# execute the program
zokrates compute-witness -a 337 113569
# generate a proof of computation
zokrates generate-proof
# export a solidity verifier
zokrates export-verifier
# or verify natively
zokrates verify

运行完成后会生成一堆文件，我们需要的是 proof.json, proving.key, verification.key, verifier.sol, out。

大部分其实都是模版文件生成文件可能不一样的地方在于 Verifier 合约中 verifyingKey，当然，我们阅读这个文件其实意义也不大，因为这里面全是一大堆数字和运算。 实际上我们需要看的内容就是这些 ∑

function verifyTx(
        Proof memory proof, uint[8] memory input
    ) public view returns (bool r) {
    uint[] memory inputValues = new uintUnsupported embed;

    for(uint i = 0; i < input.length; i++){
        inputValues[i] = input[i];
    }
    if (verify(inputValues, proof) == 0) {
        return true;
    } else {
        return false;
    }
}

可以看到，我们需要两个参数,proof 和 input。至于这两个参数是干嘛的，我们暂时不过多深究。不过我们需要注意的是，在 inputs 中，所有的共有参数都会被加入到这个数组中，在数字最开头部分被推入。

比如，自动生成的 proof.json 文件就是一个有效的数据。

{
  "scheme": "gm17",
  "curve": "bn128",
  "proof": {
    "a": [
      "0x05a83e3c3b3ff9d59bdffdcf7aa655f42b941b0063f82cf26516846056d09aa6",
      "0x018039b7de92979ef6251c877971888ae049d09a6b48e5aa98c23ef91550ed36"
    ],
    "b": [
      [
        "0x1e88e783456a27e4f02dde8c742610339e395eb0bbf7f7efc1113815dcf0a16f",
        "0x1cc9de9e60c6519ea69c9b3a71c0809ac7ae3389a598d66fc27d378738d5de29"
      ],
      [
        "0x0715544abbc18e741620ff7c76cb2a7d3558ee157d23f275ab65c43c25357d07",
        "0x0344257236ba33a3ce7ce34b8d518f7572984036db6f77fc2fc13f51c548a837"
      ]
    ],
    "c": [
      "0x177113e528c76661a03a8f3f072f29e684244297a62926a0000d3a7135c1441f",
      "0x18cf275d0bc621473688848946584af771afca42e4f2bd0ef1e5d06e0adefd0f"
    ]
  },
  "inputs": [
    "0x0000000000000000000000000000000000000000000000000000000000000151",
    "0x00000000000000000000000000000000000000000000000000000000bb3eada7",
    "0x000000000000000000000000000000000000000000000000000000004b704815",
    "0x00000000000000000000000000000000000000000000000000000000cddda451",
    "0x00000000000000000000000000000000000000000000000000000000ca701d2a",
    "0x000000000000000000000000000000000000000000000000000000001f278e64",
    "0x00000000000000000000000000000000000000000000000000000000ef16f074",
    "0x0000000000000000000000000000000000000000000000000000000040e13298",
    "0x0000000000000000000000000000000000000000000000000000000026c5da72"
  ]
}

至此，我们可以写一个简单合约。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {Verifier} from "./verifier.sol";

contract Master {
    event Despoit(uint256 commitment, uint amount);

    mapping(uint => uint) public proofs;

    Verifier v;

    constructor() {
        v = new Verifier();
    }

    function deposit(uint commitment) public payable {
        proofs[commitment] = msg.value;
        emit Despoit(commitment, msg.value);
    }

    function withdraw(
        uint commitment,
        Verifier.Proof memory proof,
        uint[9] memory inputs
    ) public {
        uint amount = inputs[0];
        require(v.verifyTx(proof, inputs));
        require(proofs[commitment] == amount);

        payable(msg.sender).transfer(amount);
    }
}

要注意的是 Verifier 合约中会出现两个pragma solidity，记得删掉中间那一个，保留最上面的那个，否则编译无法通过。

测试

首先我们需要明白一下标准流程，我们需要先进行 compile，setup，然后再进行 compute-witness，然后再进行 generate-proof，最后再进行 export-verifier。

但是这套流程并不是每次都必须的，因为这个是一个完整流程。我们需要进行一下区分。

必要条件

• compile - 编译 zk 电路 - 只需要执行一次 这个功能会生成 out 文件和 abi.json 文件，这两个是编译后的程序。

• setup - 生成 zk 电路的 pk 和 vk - 只需要执行一次 这个功能会生成 proving.key 和 verification.key 文件，这两个文件是 zk 电路的公钥和私钥。实际上在进行 setup 的时候会产生 lambda，但是这些过程我们不需要太过于关心。

提交证明条件

• compute-witness - 生成证明 - 这个功能会生成 witness 文件，这个文件是一个中间文件。

• generate-proof - 生成证明的 Proof - 这个功能会生成 proof.json 文件，这个文件是证明需要提交的内容，一般来说里面的内容就是我们需要提交到链上的参数。

接受证明条件

• export-verifier - 生成 verifier.sol - 这个功能会生成 verifier.sol 文件，这个文件是一个合约，我们需要将这个合约部署到链上，然后在我们的合约中调用这个合约来验证证明的正确性。

• verify - 本地验证 - 这个功能会验证证明的正确性，但是这个功能并不会生成任何文件。

编写文件

根据上面内容，我们可以写出一些用于测试的单元测试逻辑。

import { expect } from "chai";
import { ethers } from "hardhat";
import { Verifier } from "../typechain-types/Verifier";
import { CompilationArtifacts, ZoKratesProvider } from "zokrates-js";
import { readFileSync } from "fs";
import { Master } from "../typechain-types";
import { resolve } from 'path'

describe("Verifier", function () {
  let master: Master;
  let zokratesProvider: ZoKratesProvider

  const zokArtifacts: CompilationArtifacts = {
    program: readFileSync(resolve(__dirname, '../zok/out')),
    abi: JSON.parse(readFileSync(resolve(__dirname, '../zok/abi.json'), 'utf-8'))
  }

  const provingKey = readFileSync(resolve(__dirname, '../zok/proving.key'))

  beforeEach(async () => {
    const { initialize } = await import("zokrates-js");
    zokratesProvider = (await initialize()).withOptions({
      backend: 'ark',
      curve: 'bn128',
      scheme: 'gm17'
    });

    const bn256 = await ethers.getContractFactory("BN256G2").then((f) => f.deploy());

    master = await ethers.getContractFactory("Master", {
      libraries: {
        "contracts/verifier.sol:BN256G2": bn256.address,
      }
    }).then((f) => f.deploy());
  })

  it("should verify a proof", async () => {
    const { witness, output } = zokratesProvider.computeWitness(
      zokArtifacts,
      [`${ethers.constants.WeiPerEther}`, '23'],
    )

    const commitment = hexListToUint256BigEndian(JSON.parse(output)).toString();

    await master.deposit(
      commitment,
      { value: ethers.constants.WeiPerEther }
    )

    const proof = zokratesProvider.generateProof(
      zokArtifacts.program,
      witness,
      provingKey);


    const sender = (await ethers.getSigners())[0];
    expect(() => master.connect(sender).
      withdraw(commitment, proof.proof as Verifier.ProofStruct, proof.inputs)
    ).to.changeEtherBalance(sender, ethers.constants.WeiPerEther);
  })
});


function hexListToUint256BigEndian(hexList: string[]) {
  let uint256Data = "0x";
  for (const hex of hexList) {
    const cleanedHex = hex.replace("0x", "");
    uint256Data += cleanedHex;
  }
  const uint256BigNumber = ethers.BigNumber.from(uint256Data);
  return uint256BigNumber;
}

项目的基础文件都放在: https://github.com/nishuzumi/blog/tree/main/sources/zk 中，欢迎 Star。

原文链接：github.com/nishuzumi/blog/blob/main/ETH/MEV资料.md

MEV 资料

总结了一点 MEV 的资料，欢迎补充。

有用的链接

Artemis：https://www.paradigm.xyz/2023/05/artemis

Paradigm 出品的 MEV 框架，由 Rust 编写。

在 crates/strategies 文件目录下，有两个范例

• Uniswap V2-V3 套利策略

• Opensea - Sudo 套利策略

cake_sniper：https://github.com/Supercycled/cake_sniper

一个抢跑 MEV 的机器人。由 Python 编写，代码比较老旧，可以用于学习思路。

rusty-sando：https://github.com/mouseless-eth/rusty-sando

用 Huff 和 Artemis 编写的套利机器人，具有 Uniswap V2/V3 的三明治攻击机器人。

awesome-MEV-resources：https://github.com/0xalpharush/awesome-MEV-resources

超多超全的 MEV 资料。

本文开源仓库地址

本文翻译自 Consensys

翻译者：@BoxMrChen

在这篇文章中，我们的目标是从实用的角度对 zk-SNARKs 进行概述。我们将把实际的数学问题视为一个黑箱，并试图围绕我们如何使用它们来发展一些直觉。我们还将展示一项关于 在以太坊中集成 zk-SNARKs 的最近工作的简单应用 。

零知识证明

零知识证明的目标是让验证者能够确信证明者掌握了一个满足某种关系的秘密参数，也就是所谓的见证人，而无需向验证者或任何其他人揭示这个见证人。

我们可以更具体地将其想象为一个程序，标记为 C ，接收两个输入： C(x, w)。输入 x 是公开输入，而 w 是秘密见证输入。程序的输出是布尔值，即 true 或 false 。然后，目标是给定特定的公开输入 x ，证明证明者知道一个秘密输入 w ，使得 C(x,w) == true 。

我们将专门讨论非交互式零知识证明。这意味着证明本身是一块可以在无需证明者任何交互的情况下进行验证的数据。

示例程序

假设 Bob 得到了某个值的哈希 H ，他希望有证据证明 Alice 知道哈希为 H 的值 s 。通常，Alice 会通过给 Bob s 来证明这一点，然后 Bob 会计算哈希并检查它是否等于 H 。

然而，假设 Alice 不想向 Bob 透露 s 的值，而只是想证明她知道这个值。她可以使用 zk-SNARK 来实现这一点。

我们可以使用以下程序来描述 Alice 的情况，这里以 Javascript 函数的形式编写：

function C(x, w) {  return ( sha256(w) == x );}

这个程序不涉及任何 ZK 内容，他只是用于表示我们想要达到的效果是什么样。我们可以将其视为一个黑盒，我们将在下一节中讨论如何使用 zk-SNARKs 来构建这样的程序。

换句话说：该程序接收一个公共哈希 x 和一个秘密值 w ，如果 w 的 SHA-256 哈希等于 x ，则返回 true 。

将 Alice 的问题通过函数 C(x,w)进行翻译，我们可以看到 Alice 需要创建一个证明，证明她拥有 s ，使得 C(H, s) == true ，而无需揭示 s 。这就是 zk-SNARKs 解决的一般问题。

zk-SNARK 的定义

一个 zk-SNARK 由三个算法 G, P, V 组成，定义如下：

密钥生成器 G 由一个秘密参数 lambda 和一个程序 C 组成 ，并生成两个公开可用的密钥，一个 proving key pk（证明密钥） ，和一个 verification key vk（验证密钥） 。这些密钥是公开参数，只需要使用程序 C 生成一次。

证明者 P 将证明密钥 pk 、公共输入 x 和见证 w 作为输入。该算法生成一个证明 prf = P(pk, x, w) ，证明者知道一个见证 w ，并且该见证满足程序的要求。

验证器 V 计算 V(vk, x, prf) ，如果证明是正确的，它将返回 true ，否则返回 false 。因此，如果证明者知道一个满足 C(x,w) == true 的见证 w ，这个函数就会返回真。

请注意在生成器中使用的秘密参数 lambda 。这个参数有时使得在现实世界的应用中使用 zk-SNARKs 变得棘手。原因在于，任何知道这个参数的人都可以生成假的证明。具体来说，给定任何程序 C 和公开输入 x ，知道 lambda 的人可以生成一个证明 fake_prf ，使得 V(vk, x, fake_prf) 评估为 true ，而无需知道秘密 w 。

因此，实际运行生成器需要一个非常安全的过程，以确保没有人了解并保存参数。这就是 Zcash 团队进行极其复杂的仪式以生成证明密钥和验证密钥的原因，同时确保“有毒废料” lambda 在过程中被销毁。

针对示例程序的 zk-SNARK

在实际操作中， Alice 和 Bob 如何使用 zk-SNARK，以便 Alice 证明她知道上述示例中的秘密值？ 首先，如上所述，我们将使用由以下函数定义的程序：

function C(x, w) {
  return sha256(w) == x;
}

首先，Bob 需要运行生成器 G，以创建证明密钥 pk 和验证密钥 vk。首先，随机生成 lambda，并将其作为输入：

(pk, vk) = G(C, lambda)

请小心处理参数 lambda，因为如果 Alice 知道 lambda 的值，她将能够创建假的证明。Bob 将与 Alice 分享 pk 和 vk。

Alice 现在将扮演证明者的角色。她需要证明她知道哈希值为已知哈希 H 的值 s。她运行证明算法 P，使用输入 pk、H 和 s 来生成证明 prf：

prf = P(pk, H, s)

接下来，Alice 将证明 prf 呈现给 Bob ，Bob 运行验证函数 V(vk, H, prf)。在这种情况下，由于 Alice 正确地知道了秘密 s，所以会返回真值。Bob 可以确信 Alice 知道这个秘密，但 Alice 并不需要向 Bob 透露这个秘密。

可重用的证明和验证密钥

在我们上述的例子中，如果 Bob 想向 Alice 证明他知道一个秘密，那么他就不能使用 zk-SNARK，因为 Alice 无法知道 Bob 是否保存了 lambda 参数。Bob 完全有可能伪造证据。

如果一个程序对许多人有用（比如 Zcash 的例子），一个独立于 Alice 和 Bob 的可信赖的独立团队可以运行生成器，创建证明密钥 pk 和验证密钥 vk，而且这样做没有人会了解到 lambda。

任何相信该团队没有作弊的人，都可以在未来的互动中使用这些密钥。

以太坊中的 zk-SNARKs

开发者已经开始将 zk-SNARKs 集成到以太坊中。这看起来是什么样子呢？具体来说，你可以将验证算法的构建模块以预编译合约的形式添加到以太坊中。具体操作如下：在链下运行生成器，生成证明密钥和验证密钥。然后，任何证明者都可以使用证明密钥创建证明，这也是在链下完成的。然后，你可以在智能合约内部运行通用验证算法，使用证明、验证密钥和公开输入作为输入参数。然后，你可以使用验证算法的结果来触发其他链上活动。

示例：保密交易

以下是一个简单的例子，说明了 zk-SNARKs 如何帮助提高以太坊的隐私性。假设我们有一个简单的代币合约。通常，一个代币合约的核心是将地址映射到余额：

mapping (address => uint256) balances;

我们将保留相同的基本核心，只是将余额替换为余额的哈希值：

mapping (address => bytes32) balanceHashes;

我们不会隐藏交易的发送者或接收者。但我们会隐藏余额和发送的金额。这种属性有时被称为保密交易。

我们将使用两个 zk-SNARKs 来将代币从一个账户发送到另一个账户。发送者和接收者各创建一个证明。

通常在一个代币合约中，为了使大小值的交易有效，我们需要验证以下内容：

balances[fromAddress] >= value

我们的 zk-SNARKs 需要证明这一点是成立的，以及更新后的哈希值与更新后的余额相匹配。

主要的思想是，发送者将使用他们的 初始余额 和 值 作为私有数据。使用 初始余额、结束余额 和 值的哈希 作为公开数据。同样，接收者将使用 初始余额 和 值 作为私有数据。使用 初始余额 、 结束余额 和 值的哈希 作为公开数据。

以下是发送者的 zk-SNARK 程序，其中如前所述，x 代表公开数据，w 代表私有数据。

/**
 * @param x 公开数据
 * @param w 私有数据
 */
function senderFunction(x, w) {
  return (
    w.senderBalanceBefore > w.value && // 确保发送者有足够的余额
    sha256(w.value) == x.hashValue && // 确保发送的值与公开的哈希值匹配
    sha256(w.senderBalanceBefore) == x.hashSenderBalanceBefore && // 确保发送者的初始余额与公开的哈希值匹配
    sha256(w.senderBalanceBefore - w.value) == x.hashSenderBalanceAfter // 确保发送者的结束余额与公开的哈希值匹配
  );
}

接受者的 zk-SNARK 程序如下：

/**
 * @param x 公开数据
 * @param w 私有数据
 */
function receiverFunction(x, w) {
  return (
    sha256(w.value) == x.hashValue &&
    sha256(w.receiverBalanceBefore) == x.hashReceiverBalanceBefore &&
    sha256(w.receiverBalanceBefore + w.value) == x.hashReceiverBalanceAfter
  );
}

这些程序会检查发送余额是否大于正在发送的值，并检查所有哈希是否匹配。一组受信任的人员将为我们的 zk-SNARKs 生成证明和验证密钥。我们称它们为 confTxSenderPk、confTxSenderVk、confTxReceiverPk 和 confTxReceiverVk。 confTxSenderPk 和 confTxReceiverPk 将被用于生成证明，而 confTxSenderVk 和 confTxReceiverVk 将被用于验证证明。

在代币合约中使用 zk-SNARKs 可能会是这样的：

function transfer(address _to, bytes32 hashValue, bytes32 hashSenderBalanceAfter, bytes32 hashReceiverBalanceAfter, bytes zkProofSender, bytes zkProofReceiver) {
  bytes32 hashSenderBalanceBefore = balanceHashes[msg.sender];
  bytes32 hashReceiverBalanceBefore = balanceHashes[_to];

  bool senderProofIsCorrect = zksnarkverify(confTxSenderVk, [hashSenderBalanceBefore, hashSenderBalanceAfter, hashValue], zkProofSender);

bool receiverProofIsCorrect = zksnarkverify(confTxReceiverVk, [hashReceiverBalanceBefore, hashReceiverBalanceAfter, hashValue], zkProofReceiver);

  if(senderProofIsCorrect && receiverProofIsCorrect) {
    balanceHashes[msg.sender] = hashSenderBalanceAfter;
    balanceHashes[_to] = hashReceiverBalanceAfter;
  }
}

因此，区块链上唯一更新的只是余额的哈希值，而不是余额本身。然而，我们可以知道所有的余额都被正确地更新了，因为我们可以自己检查证明已经被验证过了。

通过上面的例子，我们也可以看到，在区块链上我们只进行了余额的 Hash 存储，而没有暴露真实的余额，这就对数据进行了保密，我们除了知道两者之间发生了交易，但是我们不知道具体交易金额，这就保证了交易的隐私性。

详细信息

上述的保密交易方案主要是为了给出一个实际的例子，说明我们如何在以太坊上使用 zk-SNARKs。要创建一个健全的保密交易方案，我们需要解决一些问题：

• 用户需要在客户端跟踪他们的余额，如果你失去余额数据，那么你就失去了这个账户的控制权。余额或许可以用来自签名密钥的密钥加密并存储在链上。

• 余额需要使用 32 字节的数据并熵编码，以防止反向解析哈希以计算余额。

• 需要处理向未使用地址发送的边缘情况。

• 发件人需要与收件人进行交互才能发送。我们可能会有一个系统，发件人可以使用他们的证明来启动交易。然后，收件人可以在区块链上看到他们有一个“待处理的入账交易”，并可以完成它。

这篇文章适合拥有ChatGPT账号的朋友，并且身边缺少美国VISA或者万事达卡。

如果你没有ChatGPT账户，问题不大，你可以看我上一篇文章：

https://mirror.xyz/boxchen.eth/9O9CSqyKDj4BKUIil7NC1Sa1LJM-3hsPqaeW_QjfFBc

同时，如果你想要使用，你还需要有一定的加密货币知识，不过没关系，如果你没有加密货币知识，你可以直接加入群寻求群主帮助。

当然，如果你有账号需求，代收验证码，或者需要帮助开通Plus，也可以加群直接联系群主。

现在提供服务：

• 成品号 - 一人一号，包括邮箱和账号密码都可以修改，是目前市面上唯一一个提供邮箱密码的。

• 代收验证码 - 你如果借不到验证码也可以找我

• 代充Plus会员和depay

如果你有问题或者有需要，可以直接进去找群主或者客服。切回正题，事前准备内容：

• 一个可用的ChatGPT账号

• 一个日本地区的IP（当然也不限制，不过我自己用的是日本IP）

• 一些USDT（如果没有，可以加群找人代充）

• 一个虚拟信用卡，点此注册

第一步 检测资格

第一步自然是检测是否有Plus资格，不过从2月11日开始，Plus资格已经不用排队。

检测方法很简单，先看左侧是否有升级按钮。

如果有，点击。

然后点击Upgrade Plan。如果出现下面这个页面，那么就证明你有资格。

第二部 创建虚拟信用卡

其实，如果你人在海外其实就没必要看这篇文章，所以我默认你并没有海外信用卡。

理论上来说，VISA，JCB，银联卡都可以，但是当你注册的时候你会发现原来都不行，支付端用的是Link进行支付，他们会校验发卡地区，如果是中国地区，包括香港省，那么都会进行拒绝。所以很多虚拟信用卡都无法使用

注意，以下两个方案都需要使用虚拟货币，USDT或者USDC。所以需要注册一个虚拟货币交易所。可以通过下面两个链接进行注册。

币安：accounts.binance.com/register?ref=GGVAE39W

OKX：cnouyi.cards/join/2251590

方案0 OneKey Visa Card

打开OneKey网站 ：card.onekey.so/?i=6519PX 按照流程注册即可，Onekey是大公司，注册流程非常简单。优先推荐。

方案1 Depay

Depay 信用卡，打开depay的网站。完成正常注册即可，注册成功后需要下载他们的APP。

IOS需要国外store账号，安卓可以直接下载APK。

可以看到有两种卡的选择，这取决于你自己了，他们之间开的应该没有差异（不过我用的是KYC版的）。

不过，你现在肯定是开不了的，因为你要先充值USDT才行（而且目前只支持USDT-TRC20）。点击钱包，然后点击USDT。进入下面这个页面，充值即可，我个人推荐用多少冲多少。我这里先冲个40U作为测试。

注意⚠️：如果你不是Crypto玩家，或者你不知道如何购买USDT，没关系，你可以在上面的群聊里面找到群主，向他咨询代充问题。

经过一系列的操作，卡已经办好了。

第三部 开通

此时我们有了信用卡，就可以去开通啦。不过开通之前，我推荐：

• 用一个人比较少的IP地址（这个就看你的代理有多少人在开通这玩意了。。）

• 日本和美国IP有限推荐

• 账单地址随便填，这个无所谓（如果是Nobepay，则需要填写对应的地址）。

🎉🎉🎉🎉 铛铛铛 你现在就已经是高贵的ChatGPT Plus用户了。

你可以享受到超快的速度，极速的反应，和双模型回答。

第四部 取消自动订阅（可选）

当然，最后我们肯定是要取消自动订阅的，不然每个月20美金，要是不用了还框框扣，岂不是亏大发？

点击：My account

点击 Manage my subscription

然后点击Cancel plan就行了，当然取消后，你这个月还是正常使用的，如果以后你还想继续使用，重新订阅即可。

结尾宣言

本文作者 Box，推特@BoxMrChen。

如有问题，可以加群交流。

加个群8

如果你有账号需求，代收验证码，或者需要帮助开通Plus，也可以加群直接联系群主。

现在提供服务：

• 成品号 - 一人一号，包括邮箱和账号密码都可以修改，是目前市面上唯一一个提供邮箱密码的。

• 代收验证码 - 你如果借不到验证码也可以找我

• 代充Plus会员和depay

如果你有问题或者有需要，可以直接进去找群主或者客服。

ChatGPT Plus教程

Plus的申请教程也来了，快来成为高贵的Plus用户。

https://mirror.xyz/boxchen.eth/fi-WPM78UeTRwo_r3rNZesrZ_hfQfFltkOT2kb9k6Jk

准备

1. 代理，要求是，韩国，日本，印度，新加坡，美国这几个地址。其他的不太清楚，反正香港肯定不行。

2. 准备一个国外手机号，如果没有用接码平台也行，有些接码平台是无法接的，所以我找了一个，sms-activate.org

3. 准备一个浏览器

开始

第一步 准备接码

打开接码平台 sms-activate.org，注册一个账号

接码OpenAi的一次费用是大概11卢布，人民币来看差不多是1块钱，不过只能充美金，就先充个1美金吧。

充值完成需要等一会，就先放着，直接进行下一步。

第二部 注册OpenAI账号

首先是打开ChatGPT的账户注册页面。谷歌注册或者邮箱注册都可以，无所谓，这里用邮箱注册作为例子。

用邮箱注册后有个验证邮件，进去邮箱，点开链接。

现在开始一步步走就行了。

当然，有一些人会在这里遇到一个问题，会出现提示说不能在当前国家服务

来，给你一招。一般你出现这种问题，就是因为你的代理没有全局，或者位置不对。香港的代理是100%无法通过的。

但是又有个非常神奇的问题，只要你出现了这个提示，那么你接下来怎么切换代理，都是没用的。现在教你一招解决。

解决地区问题 - 方法一

首先，你要把你的代理切换到不是香港的地区，我这里选韩国。

然后，先复制下面这段代码

window.localStorage.removeItem(Object.keys(window.localStorage).find(i=>i.startsWith('@@auth0spajs')))

接着在地址栏里输入

javascript:

注意，这里一定要输入，因为你复制的话是粘贴不了的。

然后再粘贴我们第一段复制的内容

然后按下回车键，接着刷新页面，如果你的代理没问题，就可以正常看到注册页面了。

解决地区问题 - 方法二

开启无痕模式/隐身模式，重新尝试即可，记得在尝试前，可以打开ipip.net查看一下自己ip，如果还是国内，请检测代理问题。

填写手机号

这里我们选择印度，然后到我们的接码网站上去。在左侧搜索OpenAi，然后点击印度。

点击小黄车。

然后我们复制这个号码，粘贴过去。然后我们点击发送验证码就完事了。

等一会网站会提示验证码，我们复制粘贴。

这样就成功了，随便点一个进去完事。

使用ChatGPT

注册完后，我们去ChatGPT网站去登陆。

在下面这个地方就可以开始你的奇思妙想了。

本位作者:

Box，推特@BoxMrChen。有事私聊

常见问题

问题一

解答：切换代理，刷新页面。

文接上回，我们已经部署了Uniswap的核心合约，接下来我们将部署完整版的UniswapV3。完整版的UniswapV3包含了以下合约：

• UniswapV3Factory (Pool生成合约)

• UniswapV3SwapRouter (包装类交易合约)

• NonfungiblePositionManager (NFT管理合约)

• NonfungibleTokenPositionDescriptor (NFT仓位描述合约)

• NFTDescriptor (NFT描述合约)

• WETH9 (WrapperETH)

我们上一章节已经部署完成了前两个合约，那么我们这一章节就需要开始部署后续合约。其实部署方法都是一样的。只不过有一点点需要注意的地方是，NonfungibleTokenPositionDescriptor需要进行Library链接，将NFTDescriptor部署后作为Library链接到NonfungibleTokenPositionDescriptor中。接下来我们会继续完善我们的部署脚本，将这些合约都部署出来。

完善部署脚本

我们继续完善我们的部署脚本，将上一章节中部署的合约和这一章节中需要部署的合约都部署出来。因为部署方式和上一章节中的部署方式一样，所以我们只需要在00_deploy_univ3.ts中添加一些代码即可。 不过我们还需要添加一个WETH9的合约。我们上一章节中，在填写WETH9的位置直接使用了0地址代替，现在可不行了。所以我们先打开网址https://github.com/gnosis/canonical-weth/blob/master/contracts/WETH9.sol，复制里面的代码，然后在contracts文件夹下新建一个WETH9.sol文件，将代码粘贴进去。然后我们运行一下yarn hardhat compile，将合约编译一下。可以不出所料的出现一个错误。

这是因为我们的编译器版本不对，因为WETH9的合约是用>=0.4.22 <0.6的版本进行编译，而我们默认的是^0.8.0的版本，所以我们需要修改编译器的版本。不过得益于Hardhat的强大功能，我们可以设定多个版本的编译器，这样我们就能在多个版本的编译器下编译我们的合约了。 我们打开hardhat.config.ts，在solidity的配置项中添加一个compilers的配置项，将其设置为一个数组，数组中包含我们需要的编译器版本。

const config: HardhatUserConfig = {
  solidity: {
    compilers: [
      {
        version: '0.8.0',
      },
      {
        version: '0.4.22',
      },
    ],
  },
};

修改完成后，我们再次编译。

修改deploy文件

我们打开00_deploy_univ3.ts，在main函数中添加一些代码。

import { utils } from 'ethers'
import { DeployFunction } from "hardhat-deploy/types";
import {
    abi as FACTORY_ABI,
    bytecode as FACTORY_BYTECODE,
} from '@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json'

import {
    abi as SWAP_ROUTER_ABI,
    bytecode as SWAP_ROUTER_BYTECODE,
} from '@uniswap/v3-periphery/artifacts/contracts/SwapRouter.sol/SwapRouter.json'
import { HardhatRuntimeEnvironment } from "hardhat/types";

import {
    abi as NFTDescriptor_ABI, bytecode as NFTDescriptor_BYTECODE
} from '@uniswap/v3-periphery/artifacts/contracts/libraries/NFTDescriptor.sol/NFTDescriptor.json'

import {
    abi as NFTPositionManager_ABI, bytecode as NFTPositionManager_BYTECODE
} from '@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json'

import {
    abi as NFTPositionDescriptor_ABI, bytecode as NFTPositionDescriptor_BYTECODE
} from '@uniswap/v3-periphery/artifacts/contracts/NonfungibleTokenPositionDescriptor.sol/NonfungibleTokenPositionDescriptor.json'


const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
    const { deployments, ethers } = hre
    const [deployer] = await ethers.getSigners()
    const factory = await deployments.deploy("UniV3Factory", {
        from: deployer.address,
        contract: {
            bytecode: FACTORY_BYTECODE,
            abi: FACTORY_ABI
        },
    })

    const WETH9 = await deployments.deploy("WETH9", {
        from: deployer.address
    })

    await deployments.deploy("UniV3SwapRouter", {
        from: deployer.address,
        contract: {
            abi: SWAP_ROUTER_ABI,
            bytecode: SWAP_ROUTER_BYTECODE
        },
        args: [factory.address, WETH9.address]
    })

    const NFTDescriptorlibrary = await deployments.deploy('NFTDescriptorLibrary', {
        from: deployer.address,
        contract: {
            abi: NFTDescriptor_ABI,
            bytecode: NFTDescriptor_BYTECODE
        }
    })

    const linkedBytecode = linkLibrary(NFTPositionDescriptor_BYTECODE,
        {
            ['contracts/libraries/NFTDescriptor.sol:NFTDescriptor']: NFTDescriptorlibrary.address
        }
    )

    const positionDescriptor = await deployments.deploy('NFTPositionDescriptor', {
        from: deployer.address,
        contract: {
            abi: NFTPositionDescriptor_ABI,
            bytecode: linkedBytecode
        },
        args: [
            WETH9.address,
            // 'ETH' as a bytes32 string
            '0x4554480000000000000000000000000000000000000000000000000000000000'
        ]
    })

    await deployments.deploy('NFTPositionManager', {
        from: deployer.address,
        contract: {
            abi: NFTPositionManager_ABI,
            bytecode: NFTPositionManager_BYTECODE
        },
        args: [factory.address, WETH9.address, positionDescriptor.address]
    })
}

function linkLibrary(bytecode: string, libraries: {
    [name: string]: string
} = {}): string {
    let linkedBytecode = bytecode
    for (const [name, address] of Object.entries(libraries)) {
        const placeholder = `__\$${utils.solidityKeccak256(['string'], [name]).slice(2, 36)}\$__`
        const formattedAddress = utils.getAddress(address).toLowerCase().replace('0x', '')
        if (linkedBytecode.indexOf(placeholder) === -1) {
            throw new Error(`Unable to find placeholder for library ${name}`)
        }
        while (linkedBytecode.indexOf(placeholder) !== -1) {
            linkedBytecode = linkedBytecode.replace(placeholder, formattedAddress)
        }
    }
    return linkedBytecode
}

export default func;

其实上面很多都是些重复的代码，我们需要关注两段内容。第一段是这个linkLibrary函数。

function linkLibrary(bytecode: string, libraries: {
    [name: string]: string
} = {}): string {
    let linkedBytecode = bytecode
    for (const [name, address] of Object.entries(libraries)) {
        const placeholder = `__\$${utils.solidityKeccak256(['string'], [name]).slice(2, 36)}\$__`
        const formattedAddress = utils.getAddress(address).toLowerCase().replace('0x', '')
        if (linkedBytecode.indexOf(placeholder) === -1) {
            throw new Error(`Unable to find placeholder for library ${name}`)
        }
        while (linkedBytecode.indexOf(placeholder) !== -1) {
            linkedBytecode = linkedBytecode.replace(placeholder, formattedAddress)
        }
    }
    return linkedBytecode
}

他的作用是将文件中library的链接到Bytecode里面去，但是一般情况下，我们不会采用这种方式。因为从源码部署的时候，我们可以借助工具来简化这个过程。而library是一种极为有效的减少合约字节码的方式，在后续的文章中，我们会专门讲解这个问题。第二段是这个NFTDescriptorlibrary的部署。

const linkedBytecode = linkLibrary(NFTTokenPositionDescriptor_BYTECODE,
    {
        ['contracts/libraries/NFTDescriptor.sol:NFTDescriptor']: NFTDescriptorlibrary.address
    }
)

const positionDescriptor = await deployments.deploy('NFTPositionDescriptor', {
    from: deployer.address,
    contract: {
        abi: NFTPositionDescriptor_ABI,
        bytecode: linkedBytecode
    },
    args: [
        WETH9.address,
        // 'ETH' as a bytes32 string
        '0x4554480000000000000000000000000000000000000000000000000000000000'
    ]
})

其实这里就是借助linkLibrary函数，将NFTDescriptor的地址链接到NFTTokenPositionDescriptor的Bytecode中。

部署合约

到此，我们可以验证一下我们的部署脚本是否有问题。我们运行yarn hardhat deploy，如果一切顺利，我们可以看到如下的输出。

Nothing to compile
No need to generate any newer typings.
✨  Done in 1.45s.

简单来说就是没有什么特别的输出，如果这里出现了报错，那么就证明我们的部署脚本出现了问题。有人可能会有疑问，我这里什么参数都没有填，我这合约究竟部署到了什么地方去了？其实，如果我们直接执行deploy脚本，那么他会默认部署到一个本地的网络中。我们也可以通过yarn hardhat node来启动一个本地的网络。但是，因为我们没有启动一个本地网络，所以在deploy时会自动启动一个本地网络用于部署，当部署完成后又会自动的关闭这个网络。所以我们基本看不到任何反馈输入，不过，没有反馈其实就是最好的反馈了。

结语

这一个章节我们把UniswapV3进行了完整部署，有了这个部署，我们就可以在后续的章节中进行一些测试了。当然，有能力的朋友也可以在这上面进行一些初步的合约开发工作。不过我并不是很推荐使用这种方式，因为用这种方式，当合约报错时，你是无法进行精确到行的Debug的。不过这个问题我们将在后面的章节进行解决。在下一章，我们将会部署一个Uniswap的前端进行测试。

文章首发于: ee.web3box.dev 作者:https://twitter.com/BoxMrChen 由SafeHouseDAO出品

既然是一个循序渐进的教程，那么肯定不能一上来就开始写代码。就好比你想造一台永动机，你至少要知道这个永动机动起来是什么样子，你才能更好的去分解他。

所以这一章节我们主要是部署一个UniswapV3，所以这章节的目的是快速并且简单的部署好一个UniswapV3，用于未来我们程序和Uni的联调。

安装Uni包

不过，在安装之前，我推荐你把第二章配置好的模版保存起来，以后就不用重新配置了。当然，这是可选内容。

首先安装UniswapV3，我们要知道一件事。Uniswap的合约分为两个，一个是v3-periphery 另外一个是v3-core 。现在简单介绍一下这两个仓库的合约是代表什么。

v3-core

core合约是uniswap中负责掌管pool和factory的仓库。

pool：是资金存储和交换运算的合约。

factory：用于批量创造Pool的合约。

这两个合约是整个uniswap的核心。就算在没有periphery的情况下，也能正常运行的最小合约。

v3-periphery

periphery存放的是外围合约，这些合约是给用户和开发者一个统一的接口或者是便捷的通证。核心合约有NFTManager和SwapRouter。

NFTManager：一个用于记录用户创建的流动性各类数据的合约。

SwapRouter：包装类，将交换的各种逻辑进行包装抽象。

这里我们不过度展开UniswapV3的逻辑。我们重点是如何去部署他。

通过执行

yarn add @uniswap/v3-core @uniswap/v3-periphery@1.4.1

先安装好两个必要的合约仓库。要注意的是，@uniswap/v3-periphery@1.4.1 是带了版本号的，这是因为在编写本文的时候，1.4.2版本缺少artifacts文件夹，相关issue如下。github-issue, 如果当你看到这篇文章时，这个issue已经被解决了，那么就不用加上末尾的版本号指定了。

通过ByteCode部署

部署合约其实只有一种方式，就是从bytecode进行部署，但是不同的工具会提供不同等级的封装。以至于封装到极致后，你只需要输入一个合约名称就可以部署。不过为了方便了解原理，我们就使用最为基础的部署方式进行部署。

我们先创建一个deploy文件。在deploy文件夹下创建一个名为00_deploy_univ3.ts的文件。

代码内容如下。

import { DeployFunction } from "hardhat-deploy/types";

const func: DeployFunction = async function () {
    
}

export default func;

这是一个deploy文件最基础的框架函数，我们首先要部署的是core中的factory合约。所以我们修改代码为。

import { DeployFunction } from "hardhat-deploy/types";
import {
    abi as FACTORY_ABI,
    bytecode as FACTORY_BYTECODE,
} from '@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json'
import { HardhatRuntimeEnvironment } from "hardhat/types";

const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
    const { deployments,ethers } = hre
    const [deployer] = await ethers.getSigners()
    await deployments.deploy("UniV3Factory", {
        from: deployer.address,
        contract: {
            bytecode: FACTORY_BYTECODE,
            abi: FACTORY_ABI
        },
    })
}

export default func;

加了”一点点”细节后，我们的代码丰富了起来。这里先解释一下关键内容。

import {
    abi as FACTORY_ABI,
    bytecode as FACTORY_BYTECODE,
} from '@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json'

这段代码的内容是从uniswap提供的官方包中，引入bytecode和abi数据，这样我们就能直接在下面进行内容填充。

await deployments.deploy("UniV3Factory", {
    from: deployer.address,
    contract: {
        bytecode: FACTORY_BYTECODE,
        abi: FACTORY_ABI
    },
})

这段代码是部署V3Factory合约的代码。其中deploy是hardhat-deploy插件提供的函数，我们在第二个参数中指定了bytecode和abi——这两个必须都要有。

当然，我们还要修改tsconfig.json文件，添加 "resolveJsonModule": true的选项。修改后文件如下。

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "resolveJsonModule": true
  },
}

接下来是SwapRouter合约，我们如法炮制，修改代码如下。当然你也可以尝试自己动手试试。

import { DeployFunction } from "hardhat-deploy/types";
import {
    abi as FACTORY_ABI,
    bytecode as FACTORY_BYTECODE,
} from '@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json'

import {
    abi as SWAP_ROUTER_ABI,
    bytecode as SWAP_ROUTER_BYTECODE,
} from '@uniswap/v3-periphery/artifacts/contracts/SwapRouter.sol/SwapRouter.json'
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { constants } from "ethers";

const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
    const { deployments, ethers } = hre
    const [deployer] = await ethers.getSigners()
    const factory = await deployments.deploy("UniV3Factory", {
        from: deployer.address,
        contract: {
            bytecode: FACTORY_BYTECODE,
            abi: FACTORY_ABI
        },
    })

    await deployments.deploy("UniV3SwapRouter", {
        from: deployer.address,
        contract: {
            abi: SWAP_ROUTER_ABI,
            bytecode: SWAP_ROUTER_BYTECODE
        },
        args:[factory.address,constants.AddressZero]
        // 上面是部署合约的参数，第一个参数为factory地址，第二个为WETH地址，这里为了图方便就直接用0地址啦😁
    })
}

export default func;

那么我们的部署脚本到这里就编写完成了。通过命令yarn hardhat deploy 即可将代码部署到任何网络上。

不过，通过bytecode直接部署会有一些不好的地方，比如在出错的时候，你无法获得源码级别的错误追踪。并且，我们部署的也是一个残缺的版本，因为我们还缺少NonfungiblePositionManager，NonfungibleTokenPositionDescriptor，NFTDescriptor合约，不过，它们的部署方式都是一样的。你可以试着用上述的方法添加它们。就当是课后作业啦。

结语

这一个章节只构建了通过bytecode部署uniswap的基础文件，但是我们的内容其实是不够一个实际的uniswap运行的。所以在下一章节，我们会使用另外一种方式部署uniswapv3，并且编写测试用例。等测试用例通过后，我们再用源码编译的方式对UniswapV3进行部署。

PS：我发现mirror不太适合写这种技术类文章，后续会切换到其他平台。

本篇会介绍常用的几种Solidity开发环境，同时会推荐一种最为合适的开发环境并且安装必要的内容。

环境介绍

目前Solidity开发环境大致分为2类

• 线上类：依赖于浏览器的一体式开发环境，可以方便的进行debug，管理账户余额，配置环境等等操作。

• 线下类：适用于本地开发的环境。

线上类

线上类产品主要是Remxi <https://remix.ethereum.org/ >

Remix是ETH官方提供的线上开发环境，是一个非常强大的整合云环境开发IDE。提供了文件管理，在线编译，静态分析，部署以及运行交易，测试等功能。并且内置了强大的插件系统。

Remix在各个方面都非常强大，甚至能直接修改读取本地文件。美中不足的是不支持多版本编译器。在面对一些简单开发，或者临时对链上进行一些分析或数据调用操作是非常合适的。

线下类

Truffle Suite

网址：https://trufflesuite.com/

Truffle Suite是一个套件名称，其中包含了truffle，ganache，drizzle等工具。

Truffle：一个适用于EVM的开发环境，包含测试等工具套件。

Ganache：一个用于测试开发的evm本地节点，可用于合约的部署开发测试等功能。

Drizzle：基于 Redux的前端组建，方便在前端进行交互。

Hardhat

网址：https://hardhat.org/

前身Builder，是一个功能超级齐全的Solidity开发框架，几乎涵盖了所有的Solidity开发需要的功能。自带智能合约的测试，编译，以及本地节点，是一个高整合的开发框架，并且具有强大的插件系统，使得开发更为简单。

Foundry

网址：https://getfoundry.sh/

基于Rust开发的一个solidity开发框架，以速度为主打。同样也是涵盖了开发，测试，本地节点功能。与Hardhat不同的是，foundry的测试代码使用的是solidity编写，但是配合vm cheat code也能和本地环境进行互动。但是相比于Hardhat还是缺少了一些功能。

还有一些使用python开发的框架，本文并不一一阐述，有兴趣的朋友可以自行搜索。

Hardhat的环境搭建

在三种主流的开发环境下，Hardhat其强大的功能让他成为了开发框架的标杆，如果有人还在推荐truffle作为你的开发框架，请自豪的搬出Hardhat并且让他也加入Hardhat的大家族。

当然，这并不是代表Hardhat没有缺点，只不过在优点和缺点进行权衡利弊后显得微不足道。当然Foundry也是一个非常强大的框架，但是他的功能依然没有Hardhat全面，不过，将Hardhat和Foundry一起使用会有意想不到的效果。

不过，我们暂时不去做这种事情，因为Hardhat目前已经足以应对大部分情况。

废话不多说，直接进入下一步。

创建项目，安装Hardhat

找到一个你喜欢的目录，新建文件夹后，用vscode打开这个文件夹。你也可以使用终端，输入code \path\to\your\project，即可用vscode一键打开项目目录。

打开VSCode后，我们按下Command+J 这个组合键即可打开VSCode的Terminal栏。在这里我们进行安装Hardhat。

输入npx hardhat 等待提示按下回车，稍等片刻（如果比较慢请开启科学上网）。

这里我们按一下 下方向键，选择Create a TypeScript project 当然你完全可以选择Create a Javascript project 只不过并不是很推荐，因为TS在多人协作比JS具有更多的优势。

按照提示完成初步设定，不过注意要在Do you want to install this sample project's dependencies with npm 时输入n。因为我们需要用Yarn来管理依赖。

然后我们输入yarn add "hardhat@^2.11.1" @nomicfoundation/hardhat-toolbox @nomicfoundation/hardhat-network-helpers @nomicfoundation/hardhat-chai-matchers @nomiclabs/hardhat-ethers @nomiclabs/hardhat-etherscan chai ethers hardhat-gas-reporter solidity-coverage @typechain/hardhat typechain @typechain/ethers-v5 @ethersproject/abi @ethersproject/providers 进行依赖安装。

注意⚠️

如果你出现了这个错误。不用慌，这在JS的世界是再常见不过的事情了，将来还会遇到各种各样的问题，比如缺少python编译环境啦，架构不对啦等等。

这里遇到的问题是当前的node版本并不符合要求。可以看到，需要node的版本为 ^14,^16,^18。所以这里我们需要重新安装node到符合条件的版本，这个问题可能是因为你安装的node版本不对，或者是你使用了brew install nvm ，如果是，你可以输入brew uninstall nvm 然后使用以下命令安装：curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash 。然后重启终端。

安装完成

安装完成后，你的目录结构应该是这样。

安装其他必要依赖

当然，我们教程的目的是企业级工程，所以只安装本体的Hardhat是完完全全不够的，因为这还缺少一个工程可持续升级的功能。

Typescript

因为我们创建的是typescript项目，所以我们需要安装typescript的依赖。

yarn add ts-node typescript chai @types/node @types/mocha @types/chai

Hardhat deploy

这是hardhat工程化必要的插件，这个插件用来帮忙管理代码部署，你能轻松的在代码中根据名称获取到你部署的合约地址，同时也能根据上下文来决定什么合约需要部署。还能和migration一样设定只能部署一次的合约。同时也给测试提供了非常方便的函数来进行灵活的合约部署，比如你可以只部署带有某些tag的合约。

安装Hardhat deploy只需要输入以下命令

yarn add hardhat-deploy @nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers ethers

然后在hardhat.config.ts 文件中添加import "hardhat-deploy" 。

到此，deploy就已经安装完成。我们在根目录下建立deploy文件夹，以后的deploy文件都会放在这个文件夹下。

Dotenv

dotenv是可以把.env 文件导入到系统环境变量中给程序使用的一个js包，这个包非常有用，因为我们在工程化开发代码的时候，一定会使用git或者其他的版本管理工具。对于私有项目来说，一些机密的变量上传到版本库可能问题不太大，但是如果是公有项目，那将会或多或少的有一些安全问题。所以我们需要把一些变量放到不会被上传到版本控制的文件。

输入

yarn add dotenv

然后修改hardhat.config.ts 在最上面添加import 'dotenv/config' 。

到此为止，我们必要的项目工程包就已经安装完成，你可以把这个包做成一个模版，保存起来以后使用。

我们运行一下测试命令来看看我们的整合包是否正常。

yarn hardhat test

当你看到以上内容时，那么恭喜你，一个符合工程标准的环境就搭建好了。

VSCode插件（可选内容）

当然，给我们的VSCode装点插件可以更好的帮助我们开发。我这里推荐几个插件。

• Hardhat Solidity - 这个是Hardhat团队开发的Solidity插件，非常好用

• Copilot - Github的智能补全代码插件，也是非常好用

• Material Theme Icons - 美化插件

• Material Theme - 还是个美化插件

最后安装效果如下。

当然啦，每个人自己对美都有一种定义，所以如果你决定不好看，请随意的更换。

总结

本章讲述了如何安装Hardhat的工程环境，在后续的教程中，会通过实现一个与Uniswap进行交互的程序来开展后面的内容。

subscribe://

在文章开始前，先明确好几个阅读要点。文章中会多次出现，必要条件，可选内容，一定不要，注意⚠️ 等词。他们的意思分别为。

• 必要条件：属于一定需要的内容，缺少后将会无法进行教程。

• 可选内容：属于补充性内容，并不会对教程产生影响

• 一定不要：属于强制规范内容，请不要做此内容下的行为

• 注意⚠️：属于提示性内容，该内容中会进行指引，并且指出什么应该，什么不应该。

目标人群

本文适合以下用户阅读。必要条件：具备理解能力和英语阅读能力。

• 计算机专业相关人员

• Web2转向Web3的有基础开发者

• 有开发简单项目，但是缺少开发大型项目经验的开发者

• 在校大学生，需要有自制力和自学能力还有较为出色的综合能力

• 进来图一乐

本文不适合以下用户阅读。

• 毫无编程基础的用户

• 顶尖高手

开发环境

本文将全程用Macos进行开发，如果你是使用Windows系统，推荐两个解决方案。

• 更换Mac

• 自行搜索一些无法在Windows上执行的命令如何用其他方案替代，比如安装Node环境，在Unix类系统下可以使用nvm，但是win只能下载安装包

必要软件

• 科学上网工具

软件环境安装

一般情况下，开发一个Dapp（EVM）需要一些基础软件，下面是必要的基础软件在Macos下安装的方式。请注意全程开启科学上网，如果没有科学上网工具，请自行搜索替代源。

必要软件有：

• Git

• VSCode

• Nodejs（v16+）

如果你知道如何手动安装这些，可以跳过接下来的教程。

不过，为了方便安装，我们会先安装一个可选软件，Brew。

安装Brew

输入命令到终端

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

安装过程中需要输入一次系统密码，并且后续需要按一次回车键。

如果出现以上提示，执行下方命令即可。

安装Git,Nvm

输入命令

brew install git
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

安装Nodejs

输入命令

nvm install --lts

安装VSCode

输入命令

brew install --cask visual-studio-code

检验

至此，我们已经安装了必要软件中的node，vscode，git。但是我们可以输入以下命令进行检验

git -v
node -v
code -v

结果应该如下。

可选安装

不过，为了更好的开发体验，我们还需要安装一个yarn包管理工具。

输入命令

npm install yarn -g
######
yarn -v

结果应该包含以下内容

总结

自此，我们已经进行了最初步的环境环境安装，这一章节并没有难度和太大的意义，但是这是对能否学习这门课程的一个初步检验，也可以认为是一个门槛。如果在这一章都遇到较大的问题，推荐静下心来仔细研究后再进行学习。

subscribe://