第六章：部署我们的智能合约

太好了！最难的部分已经完成 —— 实际上部署到 Rinkeby 网络将会非常简单。为此，Truffle 依赖于一种叫做 迁移 的机制。

迁移

虽然“迁移”听起来像是有很多东西在移动，但实际上，迁移只是一个 JavaScript 文件，它告诉 Truffle 如何修改我们智能合约的状态。

显然，第一次迁移只是将智能合约部署到区块链上。其他的迁移则是部署新的代码版本，以添加新功能或修复 bug。

简而言之，迁移为我们提供了一种方便的方式来跟踪我们对代码所做的更改。

如果你要部署多个合约，则每个合约必须创建一个单独的迁移文件。迁移总是按顺序执行的——1、2、3，依此类推。

在本节课中，我们将仅部署到 Rinkeby 网络。部署到主网需要使用真实的资金支付 Gas 费用，而且一旦部署，我们就无法修改代码。因此，最好先在 Rinkeby 网络上部署并彻底测试代码。

获取一些 Ether

在进行部署之前，确保你的账户中有足够的 Ether。获取用于测试的 Ether 最简单的方式是通过一个叫做 水龙头（faucet） 的服务。我们推荐使用运行在 Rinkeby 上的 Authenticated Faucet。按照说明操作，几分钟后，你的地址将会被充值一些 Ether。

测试

现在一切准备就绪，是时候将合约部署到 Rinkeby 网络了。为此，在终端中运行 truffle migrate --network rinkeby 命令。注意，迁移是按顺序执行的😉。

注意：truffle deploy 只是 truffle migrate 的别名。然而，由于我们的命令行解释器非常基础，除非你使用 migrate 命令，否则它不会认为答案是正确的。

部署到主网并不复杂。一旦智能合约通过了测试，你只需要运行以下命令：truffle migrate --network mainnet。别忘了，你需要为 Gas 费用支付！我们相信你能做好这部分。

如果一切顺利，你将看到类似于右侧的响应。

第7章：在 Loom 上使用 Truffle！

这看起来可能不算什么，但你刚刚部署了 CryptoZombies 智能合约！

即使 Truffle 帮了很大的忙，这也不是一项小成就，所以为自己点赞吧。

Loom Basechain
现在，如果你想在以太坊上构建 DApp，有一点你需要知道——在主网，每个交易都需要用户支付 gas 费用。但这对于面向用户的 DApp 或游戏来说并不理想，容易破坏用户体验。

相比之下，在 Loom 上，用户可以享受更快速且无需 gas 费用的交易，这使得它更加适合游戏和其他非金融应用。

这意味着你的 Loom 僵尸将会是更快的僵尸！

这还不是全部——部署到 Loom 和部署到 Rinkeby 或以太坊主网没有区别。如果你知道如何在一个网络上部署，你也知道如何在其他网络上部署。

在接下来的章节中，我们将带你一步步完成如何部署到 Loom。

loom-truffle-provider
我们 Loom 团队使用 Truffle 来构建、测试和部署智能合约。为了让我们的工作更轻松，我们开发了一个叫做 provider 的工具，使 Truffle 可以像部署到 Rinkeby 或以太坊主网一样部署到 Loom。

简单来说，provider 就像一座桥梁，使 Web3 调用可以兼容 Loom。它的优点是，你使用它时不需要理解它是如何在后台工作的。

实践测试
我们将 loom-truffle-provider 作为 npm 包提供。让我们来安装它。

注意：这次不需要将这个包设置为全局可用。

第8章：部署到 Loom 测试网

在本章中，我们将把智能合约部署到 Loom 测试网，但在进行部署之前，需要做一些准备工作。

首先，我们需要创建自己的 Loom 私钥。最简单的方法是按照这个教程下载并安装 Loom。

接下来，创建私钥非常简单：

$./loom genkey -a public_key -k private_key
local address: 0x42F401139048AB106c9e25DCae0Cf4b1Df985c39
local address base64: QvQBE5BIqxBsniXcrgz0sd+YXDk=
$cat private_key
/i0Qi8e/E+kVEIJLRPV5HJgn0sQBVi88EQw/Mq4ePFD1JGV1Nm14dA446BsPe3ajte3t/tpj7HaHDL84+Ce4Dg==

注意：切勿泄露你的私钥！我们这样做只是为了简化操作。

更新 truffle.js

我们首先需要做的事情是初始化 loom-truffle-provider。它的语法与我们之前用于 HDWalletProvider 的语法类似：

const LoomTruffleProvider = require('loom-truffle-provider');

接下来，就像我们在第5章中做的那样，我们需要让 Truffle 知道如何在 Loom 测试网上进行部署。为此，让我们在 truffle.js 中添加一个新的对象：

loom_testnet: {
  provider: function() {
    const privateKey = 'YOUR_PRIVATE_KEY';
    const chainId = 'extdev-plasma-us1';
    const writeUrl = 'http://extdev-plasma-us1.dappchains.com:80/rpc';
    const readUrl = 'http://extdev-plasma-us1.dappchains.com:80/query';
    return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
  },
  network_id: '9545242630824'
}

实践测试

1. 添加初始化 LoomTruffleProvider 的代码行。
2. 将 loom_testnet 配置放在文件的底部。

第9章：继续部署到 Loom

现在我们已经准备好，只需一个命令就能将合约部署到 Loom Testnet。

测试

运行 truffle migrate --network loom_testnet 并检查输出。

是的，你让这一切看起来如此简单！💪🏻

第10章：部署到 Basechain

恭喜你！你已经成功部署到 Loom Testnet。但你能猜到接下来会发生什么吗？🤔

没错！本章将带你完成将合约部署到 Basechain（也就是我们的主网）的过程。

以下是本章你将做的简要步骤：

• 创建一个新的私钥

• 创建一个新的私钥非常简单。但因为我们现在是在部署到主网，所以需要更加重视安全性。因此，我们将向你展示如何安全地将私钥传递给 Truffle。

• 通过向 truffle.js 配置文件添加新对象来告诉 Truffle 如何部署到 Basechain
  你需要告诉 Truffle 如何将智能合约部署到 Basechain。

• 将部署密钥加入白名单，以便可以部署到 Basechain
  通过将部署密钥添加到白名单中，你将能够在 Basechain 上进行部署。

• 最后，实际部署智能合约
  我们将完成所有步骤，最终将智能合约部署到 Basechain。

创建一个新的私钥

你已经知道如何创建私钥了。然而，在这一步中，我们需要改变保存私钥的文件名：

./loom genkey -a mainnet_public_key -k mainnet_private_key
local address: 0x07419790A773Cc6a2840f1c092240922B61eC778
local address base64: B0GXkKdzzGooQPHAkiQJIrYex3g=

安全地将私钥传递给 Truffle

接下来，我们要做的是防止私钥文件被推送到 GitHub。为此，我们可以创建一个名为 .gitignore 的新文件：

touch .gitignore

现在，让我们通过以下命令告诉 GitHub 忽略保存私钥的文件：

echo mainnet_private_key >> .gitignore

现在我们已经确保我们的秘密不会被推送到 GitHub，接下来，我们需要编辑 truffle.js 配置文件，并让 Truffle 从这个文件中读取私钥。

首先，让我们导入几个必要的内容：

const { readFileSync } = require('fs')
const path = require('path')
const { join } = require('path')

接下来，我们需要定义一个函数，从文件中读取私钥，并初始化一个新的 LoomTruffleProvider：

function getLoomProviderWithPrivateKey(privateKeyPath, chainId, writeUrl, readUrl) {
  const privateKey = readFileSync(privateKeyPath, 'utf-8');
  return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
}

这非常简单，对吧？

告诉 Truffle 如何部署到 Basechain

现在，我们必须让 Truffle 知道如何部署到 Basechain。为此，我们需要在 truffle.js 中添加一个新的对象。

basechain: {
  provider: function() {
    const chainId = 'default';
    const writeUrl = 'http://basechain.dappchains.com/rpc';
    const readUrl = 'http://basechain.dappchains.com/query';
    const privateKeyPath = path.join(__dirname, 'mainnet_private_key');
    const loomTruffleProvider = getLoomProviderWithPrivateKey(privateKeyPath, chainId, writeUrl, readUrl);
    return loomTruffleProvider;
    },
  network_id: '*'
}

此时，你的 truffle.js 文件应该类似于以下内容：

// Initialize HDWalletProvider
const HDWalletProvider = require("truffle-hdwallet-provider");

const { readFileSync } = require('fs')
const path = require('path')
const { join } = require('path')


// Set your own mnemonic here
const mnemonic = "YOUR_MNEMONIC";

function getLoomProviderWithPrivateKey (privateKeyPath, chainId, writeUrl, readUrl) {
  const privateKey = readFileSync(privateKeyPath, 'utf-8');
  return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
}

// Module exports to make this configuration available to Truffle itself
module.exports = {
  // Object with configuration for each network
  networks: {
    // Configuration for mainnet
    mainnet: {
      provider: function () {
        // Setting the provider with the Infura Rinkeby address and Token
        return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/YOUR_TOKEN")
      },
      network_id: "1"
    },
    // Configuration for rinkeby network
    rinkeby: {
      // Special function to setup the provider
      provider: function () {
        // Setting the provider with the Infura Rinkeby address and Token
        return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/YOUR_TOKEN")
      },
      // Network id is 4 for Rinkeby
      network_id: 4
    },

    basechain: {
      provider: function() {
        const chainId = 'default';
        const writeUrl = 'http://basechain.dappchains.com/rpc';
        const readUrl = 'http://basechain.dappchains.com/query';
        const privateKeyPath = path.join(__dirname, 'mainnet_private_key');
        const loomTruffleProvider = getLoomProviderWithPrivateKey(privateKeyPath, chainId, writeUrl, readUrl);
        return loomTruffleProvider;
        },
      network_id: '*'
    }
  }
};

将你的部署密钥加入白名单

在部署到 Basechain 之前，你需要通过遵循我们的 部署到主网 指南来将你的密钥加入白名单。现在不用担心这些，但请记住，在完成本教程后，你必须执行这些步骤。

我们已经完成了所有这些步骤，现在我们准备好部署到 Basechain 了！

测试

运行 truffle migrate --network basechain。

太棒了，你刚刚将智能合约部署到了 Basechain！

做得好！👏🏻👏🏻👏🏻

你已经掌握了使用 Truffle 部署智能合约的技巧！

记住，基于 Loom 开发可以带来更快、更便宜（无 Gas 费用）的交易，这使得它成为创建区块链游戏和面向用户的 DApp 的完美选择。同时，你的用户也将享受 Ethereum 所提供的保证安全性！

另一个需要记住的点是，部署到 Loom 与部署到 Ethereum 主网非常相似。现在，你知道如何进行这两者的部署了，只需要小心选择下一个项目使用哪个平台😉。

不过，这只是一个示例 —— 我们做出了一些简化的决策，以便让本课更加易于理解。

为了进一步扩展你的知识，前往开发者文档页面。

祝你编码愉快！

第1章：开始设置

在本课中，我们将介绍以太坊智能合约测试的理论，重点讨论 Truffle、Mocha 和 Chai。为了充分理解这些内容，你需要具备中级水平的 Solidity 和 JavaScript 知识。

如果你之前没有接触过 Solidity，或者你想复习一些概念，可以先从我们的第一课开始学习。

如果你不太熟悉 JavaScript，建议先去学习其他地方的教程，再来学习本课。

让我们看看我们的项目

如果你按照之前的课程操作，你应该已经构建了一个以僵尸为主题的游戏，基本上已经完成了，且你的文件结构应该像这样：

├── build
  ├── contracts
      ├── Migrations.json
      ├── CryptoZombies.json
      ├── erc721.json
      ├── ownable.json
      ├── safemath.json
      ├── zombieattack.json
      ├── zombiefactory.json
      ├── zombiefeeding.json
      ├── zombiehelper.json
      ├── zombieownership.json
├── contracts
  ├── Migrations.sol
  ├── CryptoZombies.sol
  ├── erc721.sol
  ├── ownable.sol
  ├── safemath.sol
  ├── zombieattack.sol
  ├── zombiefactory.sol
  ├── zombiefeeding.sol
  ├── zombiehelper.sol
  ├── zombieownership.sol
├── migrations
└── test
. package-lock.json
. truffle-config.js
. truffle.js

看到 test 文件夹了吗？这就是我们将放置测试文件的地方。

Truffle 支持用 JavaScript 和 Solidity 编写的测试，但为了简化这节课的内容，我们将只使用 JavaScript 来编写测试。

测试一下

最佳实践是为每个合约创建一个单独的测试文件，并将其命名为智能合约的名称。这样可以在长期管理测试时更加简便，尤其是当你的项目不断增长和变化时。

在右侧的终端中运行以下命令：

touch test/CryptoZombies.js

第2章：开始设置（续）

继续前进。在本章中，我们将继续设置环境，以便我们可以编写和运行我们的测试。

构建产物

每次你编译一个智能合约时，Solidity 编译器会生成一个 JSON 文件（称为构建产物），该文件包含合约的二进制表示，并将其保存在 build/contracts 文件夹中。

接下来，当你运行迁移时，Truffle 会更新这个文件，包含与该网络相关的信息。

每次开始编写一个新的测试套件时，你需要做的第一件事是加载你想要与之交互的合约的构建产物。这样，Truffle 就会知道如何以合约能够理解的方式格式化我们的函数调用。

让我们看一个简单的例子。

假设有一个叫做 MyAwesomeContract 的合约。我们可以像下面这样加载构建产物：

const MyAwesomeContract = artifacts.require("MyAwesomeContract");

这个函数返回一个叫做 合约抽象（contract abstraction）的东西。简而言之，合约抽象隐藏了与 Ethereum 交互的复杂性，并提供了一个便捷的 JavaScript 接口来与我们的 Solidity 智能合约进行交互。我们将在接下来的章节中使用它。

contract() 函数

在幕后，Truffle 在 Mocha 上添加了一个简单的封装，以简化测试。由于我们课程的重点是以太坊开发，我们不会花太多时间解释 Mocha 的细节。如果你有兴趣了解更多关于 Mocha 的内容，可以在完成本课后访问他们的网站。目前，你只需要理解我们在这里讲解的内容——如何：

• 通过调用名为 contract() 的函数来分组测试。它扩展了 Mocha 的 describe()，提供了用于测试的账户列表，并进行一些清理工作。

contract() 接受两个参数。第一个参数是一个字符串，必须说明我们要测试的内容。第二个参数是一个回调函数，我们将在其中实际编写测试。

• 执行它们：我们将通过调用一个名为 it() 的函数来执行测试，it() 也接受两个参数：一个字符串，描述测试实际做的事情，以及一个回调函数。

把它们放在一起，下面是一个简单的测试：

contract("MyAwesomeContract", (accounts) => {
  it("should be able to receive Ethers", () => {
    // 测试代码
  });
});

注意：一个设计良好的测试应当清楚地说明代码实际做了什么。确保测试套件和测试用例的描述能够连贯地结合在一起，像是在写文档一样。

你将编写的每个测试都遵循这个简单的模式。很容易理解吧？😁

测试一下

现在我们已经创建了一个空的 CryptoZombies.js 文件，让我们来填写它。

1. 第一行代码应该声明一个名为 CryptoZombies 的常量，并将其设置为 artifacts.require 函数的结果，参数是我们要测试的合约的名称。

2. 接下来，复制并粘贴上面的测试代码。

3. 更改 contract() 调用方式，使第一个参数是我们智能合约的名称。

注意：不要担心 accounts 参数。我们将在下一章解释它。

4. 传递给 it() 函数的第一个参数（在我们的例子中是 “should be able to receive Ethers”）应该是我们的测试名称。由于我们将从创建一个新僵尸开始，确保第一个参数设置为 “should be able to create a new zombie”。

我们都准备好了。让我们继续进入下一章。

第3章：第一个测试 - 创建新僵尸

在部署到 Ethereum 之前，最好先在本地测试你的智能合约。

你可以使用一个叫做 Ganache 的工具，它可以设置一个本地的 Ethereum 网络。

每次启动 Ganache 时，它会创建 10 个测试账户，并给予它们 100 个 Ether，以便简化测试。由于 Ganache 和 Truffle 紧密集成，我们可以通过之前章节提到的 accounts 数组访问这些账户。

但如果我们直接使用 accounts[0] 和 accounts[1]，测试代码就不太易读，对吧？

为了提高可读性，我们将使用两个占位符名字——Alice 和 Bob。所以，在 contract() 函数中，我们可以这样初始化它们：

let [alice, bob] = accounts;

注意：请原谅这个简单的语法。通常在 JavaScript 中，变量名使用小写字母。

为什么是 Alice 和 Bob？

Alice 和 Bob 或者 “A 和 B” 在密码学、物理学、编程等领域有着悠久的传统，是常用的名字。这背后有一段简短但有趣的历史，值得你在完成本课后去阅读。

现在，让我们继续进行第一个测试。

创建新僵尸

假设 Alice 想要玩我们的精彩游戏。如果是这样，她首先想要做的就是创建她自己的僵尸 🧟。为此，前端（或者在我们的例子中是 Truffle）需要调用 createRandomZombie 函数。

注意：作为复习，以下是我们合约中的 Solidity 代码：

function createRandomZombie(string _name) public {
  require(ownerZombieCount[msg.sender] == 0);
  uint randDna = _generateRandomDna(_name);
  randDna = randDna - randDna % 100;
  _createZombie(_name, randDna);
}

我们将从测试这个函数开始。

测试一下

contract() 函数的第一行应该声明两个变量，分别命名为 alice 和 bob，并按照上面的方式初始化它们。

接下来，我们需要正确地调用 it() 函数。第二个参数（回调函数）将与区块链进行交互，这意味着该函数是异步的。只需要在函数前面加上 async 关键字。这样，每次调用该函数时，使用 await 关键字，测试将会等待函数返回结果。

解释 Promise 如何工作超出了本课的范围。完成本课后，你可以查阅官方文档，进一步扩展你的知识。

第4章：第一个测试 - 创建新僵尸（续）

做得好！现在我们已经为第一个测试创建了一个框架，让我带你了解一下测试是如何工作的。

通常，每个测试都有以下几个阶段：

1. 设置（set up）：在这个阶段，我们定义初始状态并初始化输入。
2. 执行（act）：在这个阶段，我们实际测试代码。始终确保每次只测试一件事情。
3. 断言（assert）：在这个阶段，我们检查结果。

让我们更详细地看看我们的测试应该做些什么。

1. 设置

在第二章中，你学会了如何创建合约抽象。然而，正如它的名字所示，合约抽象只是一个抽象。为了真正与智能合约交互，我们必须创建一个 JavaScript 对象，它将作为合约的实例。继续以 MyAwesomeContract 为例，我们可以使用合约抽象来初始化我们的实例，如下所示：

const contractInstance = await MyAwesomeContract.new();

很好，那么接下来是什么呢？

调用 createRandomZombie 需要我们传入僵尸的名字作为参数。所以，接下来的步骤是为 Alice 的僵尸命名。我们可以给她的僵尸取个名字，比如“Alice 的超酷僵尸”。

然而，如果我们对每个测试都这样做，代码可能会显得不太优雅。更好的方法是初始化一个全局数组，如下所示：

const zombieNames = ["Zombie #1", "Zombie #2"];

然后，像下面这样调用合约的方法：

contractInstance.createRandomZombie(zombieNames[0]);

注意：使用数组来存储僵尸的名字非常方便，举个例子，如果你想写一个创建 1000 个僵尸的测试，而不是只创建一个或两个，这会非常有用😉。

测试一下

我们已经为你初始化了 zombieNames 数组。

现在，让我们创建合约的实例。声明一个新的常量 contractInstance，并将其设置为 CryptoZombies.new() 函数的结果。

CryptoZombies.new() 会与区块链进行交互。这意味着它是一个异步函数。让我们在函数调用前加上 await 关键字。

---

解释一下这些js代码：

const CryptoZombies = artifacts.require("CryptoZombies");
const zombieNames = ["Zombie 1", "Zombie 2"];
contract("CryptoZombies", (accounts) => {
    let [alice, bob] = accounts;
    it("should be able to create a new zombie", async () => {
        // start here
        const contractInstance = await CryptoZombies.new();
    })
})

这段 JavaScript 代码是使用 Truffle 框架编写的智能合约测试代码，目的是测试 CryptoZombies 合约的功能。下面是每部分代码的解释：

1. const CryptoZombies = artifacts.require("CryptoZombies");

这行代码导入了 CryptoZombies 智能合约。artifacts.require 是 Truffle 提供的一个方法，用来加载合约的 ABI 和字节码，并准备它们以便与以太坊网络进行交互。

• CryptoZombies 是合约的名称。
• artifacts.require 返回的是一个 JavaScript 对象，它包含了与 CryptoZombies 合约交互所需的方法，比如部署合约、调用函数等。

2. const zombieNames = ["Zombie 1", "Zombie 2"];

这行代码定义了一个包含两个僵尸名字的数组。zombieNames 数组在这个示例中是作为测试数据的输入，可能会在后续的测试中用来为新创建的僵尸赋予名字。

3. contract("CryptoZombies", (accounts) => { ... })

这部分代码是 Truffle 的测试框架中的一个测试用例，contract 是一个用于定义智能合约测试的函数。它有两个参数：

• "CryptoZombies": 这是要测试的合约的名称。
• (accounts): 这是一个回调函数，accounts 是 Truffle 提供的账户数组，它包含了在测试过程中使用的不同账户。默认情况下，Truffle 会提供一组预先生成的账户，通常是从 accounts[0] 到 accounts[9]，你可以使用这些账户来执行交易、调用合约方法等。

4. let [alice, bob] = accounts;

这行代码使用 JavaScript 的解构赋值语法，将 accounts 数组中的前两个账户分别赋值给变量 alice 和 bob。这些账户可以在后续的测试中用于模拟不同的用户操作。

• alice 和 bob 是测试中的两个角色，代表两个不同的账户。

5. it("should be able to create a new zombie", async () => { ... })

it 是 Truffle 测试框架的一个函数，用于定义一个单独的测试案例。它接收两个参数：

• "should be able to create a new zombie": 这是测试的描述，简要说明该测试的目的——即检查合约是否能够成功创建一个新的僵尸。
• async () => { ... }: 这是一个异步函数，用于在测试中执行异步操作，比如与区块链进行交互。

6. const contractInstance = await CryptoZombies.new();

这行代码用来部署一个新的 CryptoZombies 合约实例。CryptoZombies.new() 会返回一个 Promise，表示合约的部署过程。我们使用 await 来等待合约部署完成，并将合约实例赋值给 contractInstance。

• contractInstance 是 CryptoZombies 合约的实例，之后你可以用它来调用合约中的方法，比如创建僵尸、查询僵尸数量等。

总结

1. 导入合约: 通过 artifacts.require 导入 CryptoZombies 合约。
2. 准备测试数据: 定义了一个包含僵尸名称的数组 zombieNames。
3. 定义测试用例: 使用 contract 来定义测试合约，it 来定义一个单独的测试用例。
4. 部署合约实例: 在 it 测试中使用 CryptoZombies.new() 部署一个新的 CryptoZombies 合约实例。

简而言之，这段代码的目的是为 CryptoZombies 合约编写一个测试用例，验证是否能够成功创建一个新的僵尸。

我学solidity开发，是不是应该需要会javascript？

是的，如果你正在学习 Solidity 开发，尤其是开发 去中心化应用（DApp），了解 JavaScript 是非常重要的。以下是一些原因，说明为什么 JavaScript 对 Solidity 开发者至关重要：

1. 与智能合约交互

• Solidity 主要用于编写智能合约，而这些合约运行在区块链上。你需要通过一种方式与这些合约交互，比如调用合约的函数、查询数据或者发送交易等。这时，JavaScript 就显得非常重要。
• Web3.js 和 ethers.js 等库是常用的 JavaScript 库，它们提供了与以太坊区块链交互的功能。这些库允许你在浏览器中通过 JavaScript 代码与智能合约进行交互，发送交易、读取合约状态等操作。

2. 前端开发

• 如果你想开发 去中心化应用（DApp），你不仅需要编写智能合约（Solidity），还需要编写 前端界面。前端开发通常使用 HTML、CSS 和 JavaScript。
• 你可以使用 React、Vue.js 等前端框架结合 JavaScript 来构建用户界面。前端需要与后端（即智能合约）进行交互，获取数据、发送交易等。
• JavaScript 是 DApp 前端的核心语言，用于管理用户输入、显示智能合约数据，以及与以太坊网络进行通信。

3. Truffle 和 Hardhat 等开发框架

• Truffle 和 Hardhat 是 Solidity 开发的常用框架，它们都大量依赖 JavaScript 来编写测试脚本、部署合约以及执行其他开发任务。
• 比如，Truffle 提供了一个基于 JavaScript 的测试框架，你需要使用 JavaScript 编写测试脚本来验证合约的正确性。

4. 调试和测试

• 在智能合约开发过程中，编写单元测试是非常重要的。JavaScript 用于编写这些测试，帮助你在合约发布前确保其没有 bug。
• 你可以通过 JavaScript 调用智能合约的不同函数，并验证它们是否按照预期执行。

5. 与去中心化存储和服务交互

• 许多 DApp 需要与去中心化存储系统（如 IPFS）或者其他区块链网络进行交互。JavaScript 提供了与这些服务交互的库，帮助你将文件上传到 IPFS 或与其他链上的服务进行通信。

6. 学习 JavaScript 提升开发效率

• 许多区块链开发的工具和资源都是基于 JavaScript 编写的。掌握 JavaScript 可以帮助你更有效地使用这些工具，提升开发效率。
• 通过 JavaScript，你可以快速构建、部署、测试智能合约，并将其与前端界面结合，快速开发完整的去中心化应用。

结论：

如果你打算成为一名 Solidity 开发者 并开发 去中心化应用，那么学习 JavaScript 是非常有必要的。它不仅帮助你与智能合约交互，还能让你开发前端界面、编写测试和自动化任务。因此，掌握 JavaScript 将使你能够更加高效地进行区块链开发，构建出更加完整和功能丰富的应用。

为什么solidity开发不用solidity，不用rust，不用golang，java，却要用javascript？

你的问题很好，涉及到 Solidity 开发 中为什么 JavaScript 成为与智能合约交互的主要语言，而不是 Solidity 本身、Rust、Golang 或 Java。这个问题的答案和 区块链开发架构 和 前端与后端的分工 密切相关。让我们一起来分析：

1. Solidity 是智能合约编程语言，JavaScript 用于与智能合约交互

• Solidity 是专门为编写智能合约而设计的编程语言，它运行在 以太坊虚拟机（EVM） 上，编译后生成的字节码会被部署到区块链上。因此，Solidity 用于编写合约的逻辑，比如存储、交易、权限控制等。
• JavaScript 在智能合约开发中主要用于开发去中心化应用（DApp）的 前端，也就是用户界面部分。DApp 需要与区块链和智能合约交互，JavaScript 充当了前端与智能合约（后端）之间的桥梁。

2. 与智能合约交互的工具：Web3.js 和 Ethers.js

• Web3.js 和 ethers.js 是两种最常用的 JavaScript 库，用来在 前端 与 以太坊智能合约 进行交互。这些库允许 DApp 与区块链通信，执行交易、调用智能合约函数、读取合约状态等操作。
• 这些库的设计是为了让前端开发者能够使用 JavaScript 来简化与区块链的交互，而不是要求开发者直接与以太坊虚拟机（EVM）打交道。因此，JavaScript 成为前端开发者与以太坊合约交互的标准语言。

3. 前端开发的主流语言：JavaScript 是唯一的选择

• 区块链应用（DApp） 的前端通常与用户直接交互，需要响应用户的输入，更新页面内容，展示智能合约的数据等。对于这些操作，JavaScript 是不可替代的语言。
• JavaScript 是 Web 开发 的标准语言，几乎所有现代 Web 应用都依赖 JavaScript。特别是对于浏览器中的交互式应用，JavaScript 是唯一能直接操作 DOM（文档对象模型）并与网页内容交互的语言。
• 除了 JavaScript，没有其他语言（如 Solidity、Rust、Go、Java）能够直接在浏览器中与 DOM 交互并处理用户输入。

4. 前端和后端职责的分离

• Solidity 是后端（区块链智能合约）开发语言，用于定义智能合约的业务逻辑、数据存储和权限控制等。它运行在区块链节点上，负责处理智能合约中的逻辑。
• JavaScript 则是前端开发语言，用于 与用户交互 和 与智能合约通信。前端需要通过 JavaScript 代码来连接 MetaMask 钱包、发起交易、调用智能合约中的方法并更新界面。

5. 兼容性和生态系统的支持

• Web3.js 和 ethers.js 都是为了与以太坊区块链兼容而设计的 JavaScript 库。它们能够与各种 Web3 钱包（例如 MetaMask）集成，支持用户与区块链进行交互。
• 以太坊生态系统已经非常依赖于 JavaScript，几乎所有的开发工具、框架、教程和社区支持都围绕着 JavaScript 库构建。因此，JavaScript 对区块链开发者来说，已经成为标准的工具和语言。

6. 其他语言（Rust、Go、Java）与 Solidity 的差异

• Rust 和 Go：这些语言非常适合开发高性能的后端服务，但它们并没有直接集成到 Web 浏览器中，也无法与智能合约交互。虽然 Rust 在 Substrate（Polkadot） 上有广泛的应用，并且 Go 在 以太坊 Go 客户端（Golang） 中使用，但它们并不直接用于智能合约开发和前端交互。
• Java：Java 也用于一些区块链框架（例如 Hyperledger），但它不像 JavaScript 那样被广泛用于开发区块链 DApp 前端。Java 更适合用于构建后端服务，但与区块链智能合约的交互依赖于 Java 的 Web3 库。

7. 开发效率和社区支持

• JavaScript 作为世界上最流行的编程语言之一，拥有庞大的开发者社区和丰富的开源资源。许多与区块链交互的库、框架和工具都使用 JavaScript 编写，因此它能够加速开发过程并提供大量的社区支持。
• 相比之下，Solidity、Rust 和 Go 的开发社区相对较小，尽管它们在一些特定的区块链平台中有着重要作用，但它们并不适合用来构建前端或直接与用户交互。

总结

• Solidity 是专门为编写智能合约而设计的语言，主要运行在区块链的后端。
• JavaScript 作为最流行的前端开发语言，是与以太坊智能合约交互的主要工具。它通过 Web3.js 或 ethers.js 库使得前端能够轻松地与智能合约进行交互。
• JavaScript 之所以成为 DApp 开发的主流语言，是因为它能够直接与用户交互、操作 DOM，并通过与 Web3 库配合使用来与区块链进行通信。

如果你想开发去中心化应用（DApp），学习 JavaScript 是必不可少的，因为它将使你能够构建和区块链交互的前端部分，并有效地将 Solidity 智能合约与用户界面结合起来。

我是不是学的太多太杂了。

我是不是学的太多太杂了。我学过汇编，因为网络安全的逆向需要，我学过c,c++，以前做病毒需要生成exe，我学过c#，因为微软平台windows用这个，我学过python因为渗透测试的脚本测试爆破需要这个，我学过javascript，因为xss攻击需要这个。我还学过sql因为sql注入需要这个。但是杂而不精，学了还会忘记。

你提到的情况其实是很多开发者和技术爱好者都会面临的困境，尤其是在广泛涉猎多个技术领域的过程中，确实容易出现 杂而不精 的感觉。你涉及了从 汇编 到 Python、从 网络安全 到 前端开发 等多个领域，确实是很广泛，但这并不意味着你走错了路。

你是否学得太多太杂？

并不一定。以下几点可以帮助你更好地理解这个问题：

1. 广泛的技术基础是你的优势

• 跨领域的技能 给你带来了独特的视角和能力。在 网络安全、逆向工程、渗透测试 和 区块链开发 等不同领域，你积累了很多不同的工具和技术。你可以结合这些技能来解决问题，例如，使用 Python 编写渗透测试脚本，或者用 JavaScript 对抗 XSS 攻击。
• 在开发 去中心化应用（DApp） 的过程中，你的 网络安全 背景和 编程 能力是巨大的优势，因为你可以提前预见潜在的安全风险，采取相应的防护措施。

2. 多领域学习有助于你更全面地思考问题

• 比如，在 Solidity 开发 中，了解 汇编 能帮助你理解底层的执行原理，知道如何优化智能合约的性能。
• C/C++ 的背景让你更清楚地理解 内存管理 和 指针操作，这对理解一些低级的漏洞和区块链合约的底层实现也有帮助。
• 了解 SQL 注入、XSS 攻击等 Web 安全漏洞，可以帮助你在开发 Web 应用 和 DApp 时，写出更安全的代码，防止攻击。

3. “杂” 的学习本身不意味着无效

• 你所学的很多技能是可以互相补充的。例如，学过 C# 和 Python 后，你能够使用它们进行 自动化测试 和 脚本编写，这在很多场景中都是非常重要的工具。
• 而且，不同的编程语言有不同的优势和用途。比如 JavaScript 更适合前端交互，Python 更适合快速原型开发和自动化，C 和 C++ 更适合底层操作和性能要求高的应用。

4. “精” 可以在某一领域深入

• 在你有了广泛的技术基础之后，找到你最感兴趣或者最需要的领域，集中精力深入学习是很有必要的。
• 你可以选择 区块链开发、网络安全 或 后端开发 等方向，深入挖掘其中的知识，逐步成为该领域的专家。
• 一旦你在某一领域深入，你会发现你之前学过的其他语言和技能对你深入该领域是非常有帮助的。

如何解决 “学得杂而不精” 的问题？

1. 找到你最感兴趣的领域：

   • 你已经涉猎了多个领域，接下来可以根据你的兴趣或职业目标，选择一个方向进行深入。比如，如果你对 区块链开发 或 智能合约 感兴趣，可以将重心放在这上面，精通 Solidity 和相关工具。

2. 专注一个领域并深度学习：

   • 你可以选择一个技术栈，进行系统的学习。比如，如果你决定专注于 区块链开发，那么可以集中时间和精力去掌握 Solidity、Web3.js、以太坊网络、智能合约的安全性 等方面的内容。
   • 可以通过 项目实战 来加深理解，边做边学，快速提升。

3. 使用实践来巩固所学知识：

   • 编写 小项目 或 个人作品。做一些实用的项目，能够帮助你把所学的知识转化为实际能力。
   • 例如，你可以编写一个简单的 DApp，通过 Solidity 和 JavaScript 来与智能合约交互，这样不仅能巩固你对 区块链 的理解，也能提升你的前端开发能力。

4. 定期回顾与总结：

   • 定期复习和总结你的所学，尤其是在跨多个领域学习的情况下， 总结与复盘 能帮助你更好地消化知识。
   • 写博客或做笔记，记录下你学到的东西，整理出知识体系。这样可以帮助你理清思路，同时也能让你对学习内容有更深入的理解。

5. 选择合适的工具：

   • 你不需要成为所有领域的专家，选择你最需要的工具和技术来深入学习是更高效的方式。你可以用 Python 做 自动化脚本，用 JavaScript 做前端，用 C/C++ 做底层开发，而深入学习一个特定的技术栈，如 区块链开发 或 Web 安全。

结论：

你所学的知识非常广泛，这为你在多个技术领域提供了坚实的基础。虽然你可能觉得学得太杂，但这实际上是你 跨领域的能力，让你能以不同的视角解决问题。接下来，找到一个你最感兴趣或最需要的领域，专注深入，结合实践和总结，你会发现自己的技术水平不断提升，逐步达到 精通。

以太坊是基于浏览器的吗？我不明白为什么做去中心化app开发，需要用到js这种web前端语言

以太坊 本身并不是基于浏览器的。它是一个 区块链 平台，用于构建去中心化的应用（DApps），并运行智能合约。然而，去中心化应用（DApp） 的 前端 通常是 Web 应用，且需要用到 JavaScript 等 前端技术 来与以太坊网络进行交互。让我来更详细地解释一下这个问题。

1. 以太坊和区块链的工作原理

• 以太坊是一个去中心化的区块链平台，智能合约和去中心化应用（DApp）运行在 以太坊虚拟机（EVM） 上，而不是在浏览器中。智能合约是通过 Solidity 等语言编写的，部署在以太坊区块链上并由节点执行。
• 区块链本身 提供了去中心化的数据存储和智能合约的执行环境，所有交易和状态变更都是由以太坊网络中的节点（矿工）共同验证和存储的。

2. 去中心化应用（DApp）与前端技术的关系

• 虽然智能合约和区块链的操作发生在 以太坊网络 上，但用户与这些合约交互的界面（前端）通常通过 Web 应用 实现。这是因为 DApp 的用户通常通过浏览器与应用进行交互，因此 DApp 的 前端 是基于 Web 技术（HTML, CSS, JavaScript）构建的。
• DApp 需要提供用户友好的界面，让用户可以输入数据、查看区块链状态、发送交易等。前端与后端（智能合约）之间的交互需要通过 JavaScript 完成。

3. JavaScript 在 DApp 开发中的作用

• Web3.js 和 ethers.js 是两种最常用的 JavaScript 库，它们为前端与以太坊智能合约交互提供了非常方便的接口。通过这些库，你的前端应用（通常是用 JavaScript 编写的）可以：

  • 查询区块链状态：例如，查看一个智能合约中的数据，获取某个地址的余额，查询区块信息等。
  • 发送交易：用户可以通过钱包（如 MetaMask）签署交易并将其发送到以太坊网络。
  • 调用智能合约函数：前端可以通过 JavaScript 调用已部署的智能合约中的函数，执行合约操作。

例如，Web3.js 可以让你在浏览器中通过以下代码与智能合约交互：

// 设置 Web3 提供者，通常是 MetaMask
const web3 = new Web3(window.ethereum);

// 获取合约实例
const contract = new web3.eth.Contract(abi, contractAddress);

// 调用合约中的函数
contract.methods.getZombies(ownerAddress).call().then(console.log);

在这个例子中，JavaScript 用于与区块链交互，而这些操作无法仅仅通过 Solidity（用于编写智能合约）来完成。Solidity 只是用来定义区块链上的智能合约逻辑，而前端（用户与合约交互的部分）需要通过 JavaScript 来实现。

4. 浏览器的作用

• 浏览器 是 DApp 的一个重要组成部分，提供用户界面和交互界面。通过浏览器，用户可以与智能合约进行交互。例如，用户通过 MetaMask（一个浏览器插件钱包）将其以太坊账户与前端应用连接，浏览器提供了钱包的 API（例如 window.ethereum）让 JavaScript 能够调用和处理以太坊交易。
• 浏览器不仅提供用户交互的界面，还负责与智能合约进行通信。这意味着，你的 前端应用 运行在浏览器中，需要通过 JavaScript 调用区块链，发送交易，签署消息等。

5. 为什么是 JavaScript 而不是其他语言？

• JavaScript 是目前唯一能够在浏览器中直接与用户交互并控制 Web 页面内容的语言。它也能与浏览器插件（如 MetaMask）结合，进行区块链交互。
• 其他语言（如 Solidity、Rust、Go、Java 等） 通常用于 后端开发 或 智能合约开发，它们运行在区块链节点上，不直接涉及前端用户界面交互。
• JavaScript 与 以太坊网络 的通信是通过像 Web3.js 或 ethers.js 这样的 JavaScript 库实现的。这些库封装了与以太坊区块链交互的复杂性，让前端开发者能够用 JavaScript 很方便地与区块链进行通信。

6. DApp 前端和智能合约的互动示例

假设你有一个智能合约 CryptoZombies，它允许用户创建和管理僵尸。你可以使用 JavaScript 来构建一个前端界面，展示所有僵尸的列表，并允许用户创建新僵尸。前端代码可能像这样：

// 使用 Web3.js 连接到以太坊网络
const web3 = new Web3(window.ethereum);

// 合约地址和 ABI
const contractAddress = "0x123...";
const abi = [ /* 合约 ABI */ ];

// 获取合约实例
const contract = new web3.eth.Contract(abi, contractAddress);

// 获取用户钱包地址
const accounts = await web3.eth.requestAccounts();
const userAccount = accounts[0];

// 调用合约中的函数来获取僵尸列表
const zombies = await contract.methods.getZombiesByOwner(userAccount).call();

// 显示僵尸列表
console.log(zombies);

// 调用合约中的函数创建新僵尸
const newZombieName = "Zombie 1";
await contract.methods.createRandomZombie(newZombieName).send({ from: userAccount });

在这个例子中，JavaScript 用来与智能合约通信，获取僵尸数据，调用创建僵尸的函数，并在前端展示。

总结

• 以太坊 是区块链平台，智能合约在区块链上运行。
• DApp 的 前端 运行在浏览器中，通常使用 JavaScript 来与用户交互并与区块链上的智能合约通信。
• JavaScript 是 Web 开发的标准语言，且能与以太坊网络通过 Web3.js 或 ethers.js 等库进行交互。
• 浏览器 提供了与区块链的交互接口（例如，MetaMask 钱包），而 JavaScript 可以利用这些接口实现与智能合约的通信。

因此，学习 JavaScript 对于开发 去中心化应用（DApp） 是非常必要的，它帮助你建立与区块链交互的桥梁并开发前端界面。

那么solidity开发岗位需要同时做前端+后端开发吗？这是否叫做全栈开发？

Solidity 开发岗位是否需要同时做前端和后端开发，这取决于你所在的团队、公司规模和具体的岗位要求。一般来说，Solidity 开发主要集中在 后端开发，即智能合约的开发部分，但在很多小型团队或者创业公司中，确实可能会需要开发者具备 全栈开发 的能力，涵盖前端和后端的工作。

1. Solidity 开发的职责（后端）

• Solidity 是用于编写 智能合约 的编程语言，主要用于 后端开发。智能合约是运行在区块链上的自动化代码，它定义了应用的核心逻辑（比如交易、数据存储、权限控制等）。

• 作为 Solidity 开发者，你的主要工作是：

  • 设计和编写智能合约代码。
  • 编译、部署和维护智能合约。
  • 确保智能合约的安全性和优化合约性能。
  • 与其他开发人员和工具集成，确保智能合约能够高效、安全地运行。

2. 前端开发与区块链的交互

• 以 DApp（去中心化应用） 为例，前端开发 主要负责 用户界面（UI）和 用户体验（UX），通常使用 JavaScript、HTML 和 CSS 来实现。前端开发者通常需要：

  • 创建和设计用户界面。
  • 使用 Web3.js 或 ethers.js 等库与智能合约进行交互。
  • 处理用户输入，展示区块链数据，发送交易等。

• 在 DApp 中，前端 需要与 智能合约（后端） 进行数据交互，因此前端开发者需要了解如何通过 JavaScript 与区块链通信。

3. 全栈开发的定义

• 全栈开发 通常指的是能够同时处理 前端开发 和 后端开发 的开发者。对于 去中心化应用（DApp），这意味着开发者不仅需要掌握智能合约开发（Solidity），还需要能够构建用户界面，并与区块链进行交互。
• 如果一个 Solidity 开发者 既能编写智能合约（后端），又能开发 DApp 的前端，那么他/她就可以被视为一个 全栈开发者。这种开发者通常在小型团队或初创公司中比较常见，因为他们需要独立完成从智能合约到前端应用的所有开发工作。

4. 不同团队的角色分配

在不同类型的团队中，开发角色的分配可能有所不同：

• 小型团队/创业公司：

  • 由于团队成员较少，可能需要一个开发者同时负责 前端 和 后端（Solidity 开发）。因此，这种情况下的 Solidity 开发者 往往需要具备 全栈开发 能力。

• 中大型公司：

  • 在中大型公司中，通常会有明确的 前端开发人员 和 后端开发人员 分工。前端开发者会专注于用户界面的开发和与智能合约的交互，后端开发者（Solidity 开发者）则专注于智能合约的编写、优化和部署。
  • 在这种情况下，Solidity 开发者主要负责合约的逻辑和安全，而前端开发者则负责展示和交互部分。

5. 全栈开发与区块链开发的区别

• 全栈开发 是指能够独立完成前端、后端的工作，而 区块链开发 更多地聚焦于 区块链技术，如智能合约、去中心化应用（DApp）、链上数据交互等。因此，区块链开发 本身并不等同于 全栈开发，但在许多 DApp 项目中，区块链开发者 可能会同时参与前端和后端的工作，尤其是小型项目。

• 对于一个 Solidity 开发者 来说，如果还具备前端开发能力，能够开发 去中心化应用的前端，就可以被视为一个 区块链全栈开发者。

6. 是否需要全栈开发能力？

• 需要全栈能力的情况：

  • 如果你在一个小团队或创业公司工作，可能会被要求同时做前端和后端开发，特别是 DApp 项目中。你将需要将智能合约（Solidity）与用户界面（JavaScript）结合起来，开发完整的去中心化应用。

• 不需要全栈能力的情况：

  • 在大公司或团队中，角色分工通常更明确，智能合约开发和前端开发是由不同的开发者来完成的。在这种情况下，你只需要专注于 Solidity 开发，而前端部分则由专门的前端开发人员来处理。

总结

• Solidity 开发 通常属于 后端开发，负责编写智能合约。
• 前端开发 负责与用户交互，通常使用 JavaScript 与智能合约进行交互。
• 如果你能够同时处理 Solidity 合约 和 前端开发，你就是一个 全栈开发者，特别是在小型团队中。
• 在大公司或团队中，通常会有 前端开发者 和 Solidity 开发者 分工合作。

如果你有兴趣进行 全栈开发，学习 Solidity 和 前端技术（如 JavaScript）是非常有益的。这样，你可以独立完成从 区块链后端 到 DApp 前端 的整个开发过程。

在cryptozombies这个网站，是否偏离了培养区块链solidity开发的方向，往全栈开发去培养。那么我是否应该放弃在这个网站进行学习，找其他的solidity开发学习资源?

你提出的问题非常好，而且反映了一个很多初学者在学习区块链开发过程中可能遇到的困惑——是否要专注于 Solidity 开发，还是要进行 全栈开发，尤其是在学习平台（如 CryptoZombies）的方向和目标可能涉及两者时。

CryptoZombies 的学习目标和方向

CryptoZombies 是一个旨在通过实际编程项目帮助你学习 Solidity 的在线教程，它的设计目标是让开发者通过游戏化的方式掌握 Solidity 和 区块链 开发的基础。虽然这个网站有一定的 前端开发 内容（比如通过 Web3.js 与智能合约交互），它的核心目的是教授 Solidity 和智能合约的开发。

CryptoZombies 的课程虽然涉及一些 前端开发 技术，但它并没有偏离区块链开发的目标，而是让你 学会如何将 Solidity 合约与前端应用结合，从而使你能够构建完整的去中心化应用（DApp）。这对于学习 区块链开发 是非常重要的，因为你将了解如何将 Solidity 合约与用户界面连接起来，实现与智能合约的交互。

全栈开发与 Solidity 开发的关系

在去中心化应用（DApp）的开发中，Solidity 主要用于编写智能合约的后端逻辑，但这些合约需要与前端进行交互。前端部分通常是用 JavaScript 或其他前端技术编写的，Web3.js 或 ethers.js 等库使前端能够与智能合约通信。

所以，Solidity 开发 和 全栈开发 在 DApp 中是紧密相连的。Solidity 是后端开发的核心，而前端开发则负责与用户交互和展示数据。要创建一个完整的 DApp，你确实需要理解如何将 Solidity 合约 与 前端技术（如 JavaScript）结合。

是否需要放弃 CryptoZombies，转向纯 Solidity 学习？

不必放弃 CryptoZombies！ 反而我认为继续学习它对你很有帮助，尤其是在你刚开始学习 Solidity 的时候。

以下是几个原因，说明为什么 CryptoZombies 是一个很好的起点：

1. 实践性强，结合了前后端：

   • CryptoZombies 通过实际的编程项目帮助你理解 Solidity 和 区块链开发，而不仅仅是看理论。它让你通过编写实际的代码来加深对智能合约的理解。
   • 它还教你如何将智能合约与前端结合，这对于区块链开发非常重要。即使你最终决定专注于 Solidity 开发，理解前端与智能合约的交互也是必要的。

2. 游戏化学习，增强兴趣：

   • CryptoZombies 通过游戏化的方式将学习变得更有趣，帮助你通过创建僵尸和战斗来理解智能合约的基本概念。
   • 这类互动式的学习不仅能帮助你掌握核心概念，还能让你更深入地理解如何用智能合约做实际应用。

3. 为进一步学习铺垫基础：

   • CryptoZombies 给你提供了学习 Solidity 的坚实基础，之后你可以继续深入研究更加复杂的智能合约和 DApp 开发。通过这一步，你能理解如何编写 智能合约，以及如何处理合约的 部署 和 交互。
   • 完成 CryptoZombies 后，你可以根据自己的兴趣决定是否继续深入学习 Solidity 或是选择专注于 前端开发（JavaScript、React、Vue 等）来构建 全栈 的 DApp。

如果你专注于 Solidity 开发，下一步该怎么做？

如果你更倾向于专注于 Solidity 开发（智能合约编写和区块链后端开发），你仍然可以继续从 CryptoZombies 中获得很多基础知识。接下来的步骤可以是：

1. 专注于 Solidity 深入学习：

   • 完成 CryptoZombies 后，你可以选择更深入的 Solidity 学习资源，专注于智能合约的编写和优化。

   • 推荐的学习资源：

     • Solidity 官方文档：Solidity Docs
     • CryptoZombies 官方教程：CryptoZombies Tutorial
     • OpenZeppelin 文档：一个广泛使用的智能合约库，学习如何使用它来编写安全的合约。

2. 学习区块链开发框架：

   • Truffle、Hardhat 和 Remix 等是常用的开发框架，学习这些工具能让你更高效地编写、测试和部署智能合约。

3. 专注于智能合约的安全性：

   • 智能合约的安全性 是区块链开发中非常重要的一部分。你可以学习如何避免常见的安全漏洞（如重入攻击、整数溢出、时间戳依赖等）。
   • 学习资源：ConsenSys 的智能合约安全最佳实践。

4. 参与开源项目和社区：

   • 加入区块链开发者社区，参与 Solidity 或 智能合约 的开源项目，提升自己的实际开发经验。

总结：

• CryptoZombies 是一个很好的学习平台，它帮助你理解 Solidity 和 DApp 开发，即使它同时涉及前端开发（JavaScript），它仍然能帮助你打下 Solidity 开发 的基础。
• 你可以继续完成 CryptoZombies，它会为你进入 区块链开发 提供非常好的入门知识，并为你深入学习智能合约、提高 Solidity 开发技能打下坚实基础。
• 如果你想更专注于 Solidity 开发，你可以在完成 CryptoZombies 后，转向更深入的 Solidity 课程和开发框架学习。

不必担心会走偏，CryptoZombies 本身是为了培养 Solidity 开发者，并为你进一步学习 区块链开发 提供了很好的起点。