以太坊上的核心开发者 Austin | 以太坊上的最佳开发实践

以太坊上的核心开发者 Austin

以太坊上的核心开发者 Austin | 以太坊上的最佳开发实践

注： 本文转载自BeWater公众号：
https://mp.weixin.qq.com/s/urpZWSl8AdUN7LvckcgkoA

嗨，我是Austin Griffith，我将向你展示 Scaffold-eth，这是在以太坊上构建应用程序的好办法。

让我们从一个智能合约的例子开始吧！

Scaffold-eth 项目地址：

https://github.com/austintgriffith/scaffold-eth

当我们做出一些改变，给合约例如添加了一些东西，dApp 会自动适应。

如果我删除了这个 owner，然后点击保存、部署。我们会看到 owner 从前端消失了。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;
  constructor() {
    // what should we do on deploy?
  }

  function setPurpose(string memory newPurpose) public {
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

它允许你编辑你的智能合约，尝试一些新东西，然后把它部署到本地链上，你的本地应用程序会自适应它。

我们可以从faucet里拿到一些测试币，然后可以调用这个合约。

Scaffold-eth 允许我们在智能合约上开发，玩玩 Solidity 代码，学习 Solidity，在前端创建应用程序。

它自动适应你在智能合约中的变化，并帮助你创建一个前端，所以每当你添加一个新的功能，就会有一个新的按钮来代表它，你可以玩你的 Solidity 代码，进行学习。

我将会花大部分时间来分享 scaffold-eth，我现在将先说另一个事。

Ethereum.org

如果你要了解以太坊，最好的起点是去ethereum.org。Etherscan 当然也不错，但ethereum.org是一个了解以太坊的好地方。

你将会学习如何得到一个钱包、如何拿到 ETH，如何使用 Metamask， 如何通过 Metamask 和应用交互。

然后了解以太坊是什么，了解为什么我们在去中心化，了解为什么去中心化金融更重要，了解DAO，了解去中心化治理，了解 NFT，了解以太坊的历史和以太坊2.0。

你学习所有这些东西，以及我们要去的地方，然后现在我们可以来开发，来创建项目了。

Eth.build

我们从学习如何写代码开始，我们可以打开 Remix，在浏览器里写智能合约，又或者我们可以使用 eth.build。eth.build 可以帮助你了解基本原理。

Eth.build： https://sandbox.eth.build/

了解什么是哈希函数，什么是密钥对，你可以用密钥对做什么，它是如何签署和解密信息的？

然后继续下去，了解加密、了解分布式账本、了解拜占庭容错、区块链与智能合约。你会接触到所有这些。

你可以进入这里，这里可以帮助你弄清楚这些事情是如何运作的。

例子：密钥对

在线示例：

https://eth.build/build#ee99fc77fcd9626afa3d96d7cf6d91965d8ecb4dc14fa22c7331fac825cc1426

在这里，我们有一个密钥对，我正在点击这个按钮，我正在生成一个全新的私钥，它生成一个地址，我们可以使用该私钥来签署一些信息。

我们可以使用该私钥来签署一个信息，这个信息和这些签名可以在整个网络通用。如果你把那条信息和那个签名放进解密盒里，你可以解密该信息的地址。

请注意这两个地址是相同的，而且这个地址是可以跨网络的。

因此，这是这些密钥对的超能力，这就所有一切正常运作的原因，这就是ECDSA。

你可以了解更多关于曲线和椭圆曲线密码学的信息，这超出了我的能力范围，我只是一个创建者。

但eth.build会帮助你开始，并在它周围探究，学习一些基本知识。

然后你可以把区块链带进来，你可以做更多的事情。

让我们看看以太坊目前的区块数是多少。那里是以太坊的当前区块。

所以这就是你可以使用eth.build的原因，我们可以和智能合约交互，获得地址、ABI和接口。

在这个工具盒里很多东西可以学习。

例子：拜占庭将军

在线示例：

https://eth.build/build#516dbe184d75c0ad9abc9ddd5957b77daa6918275b856545fafc4cd9adb271c5

让我们来看拜占庭将军。

这里有所有这些士兵，他们展示PoW是如何工作的。

我们可以看到这个士兵在这里抓住了一个哈希。

然后，如果我们看向外面，所有这些士兵都在做这件事，试图找到一个带有前置的 0 的哈希值，对鲍勃将军的信息进行加密，这样他就可以把它发送出去，说他想在星期一的黎明进行攻击。

因此，这是对工作量证明机制的一种探索，eth.build是一种很好的方式，让你了解密钥对，了解一些基本原理。

Scaffold-eth

一旦你掌握了基本原理，你就可以准备建立你的本地环境了。

有很多伟大的工具来建立你的本地环境，但我今天要谈的是scaffold-eth。

Scaffold-eth 是Ethers.js+Hardhat+React，所以它是一种所有东西同时工作的方式。

在web3中寻找一个技术栈并在以太坊之上建立起来这真的很复杂。虽然有很多工具去做这件事却仍有很多事情可能会出错。

通过 scaffold.eth，我们从一些有用的东西开始，我们有一个后端，是我们的 Hardhat Blockchain。我们有一个前端，也就是我们的React。

我们使用Hardhat来编译和部署，然后我们用我们的前端来展示合约并与之交互。

因此，这给了你一个开箱即用的 DApp 模板，它帮助你学习Solidity，然后帮助你建立一堆不同的东西来学习，让你了解你可以在以太坊上建立的所有不同的东西，什么有用，什么没用，以及一些其他问题。

好了，让我们继续深入了解一下scaffold-eth吧。让我们写一点代码，让你熟悉一下如何使用这个工具。

我们正在浏览这个文档，我们来看下基础数据类型。

如果你是一个好的web2程序员，你应该能够直接地并理解这一点。

我们有8位的无符号整数，或者我们有256位的无符号整数，我们有Address，我们有Bool。

让我们在这里选择其中一个。让我们选择这个地址并把它带进来。

Set Purpose —— 值的设置

我们之前有一个类似的，让我们继续，从前端复制我的地址。

现在，如果我保存并部署它，我们应该看到，一个新的地址被添加在这里，在这里的右边。让我们继续。

所以现在这就是地址，让我们不叫地址，而叫它owner。然后让我们写下我们的第一个规则。

Solidity 要求使用 require 这个修饰符，它就像做条件检查的 assert 命令。

所以，如果你要求，message.sender== owner，那就是说，不管是谁进入这里，message.sender是调用这个函数的人。

它可以是一整个调用链去调用智能合约，然后这个智能合约再调用......这太复杂了。

调用这个函数的人，所以我们在这里检查的是我们希望只有owner可以调用函数，以及设置 purpose。

如果你不是owner，就会报出你不是owner的提示。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;
  constructor() {
    // what should we do on deploy?
  }

  function setPurpose(string memory newPurpose) public {
      require( msg.sender == owner, "NOT THE OWNER!");
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

好的，我们将在这里加上分号，并输入yarn deploy。

就这样，我们部署了我们的新合约。我们正在顺利地搭建应用程序。

让我们保存并部署它，使它看起来更漂亮。我们继续，我们有一个owner，可以更新这个存储位置。

所以我们有这个字符串purpose，我们有这个函数，让我们可以更新这个purpose。

然后我们添加了这个新的owner，我们说只有owner可以设置purpose，所以在这里，我应该可以说hello，我点击发送。果然，purpose更新了。

现在，我们需要做的是测试另一种情况，测试坏情况。

我们想看到别人进来的场景，所以我要做的是，我将创建一个新的无痕窗口，然后我将进入localhost，

你会注意到，我在右上方有一个不同的地址，看到这个是绿色和粉色的，这个是紫色和绿色的。

有一点不同吧。

我们将调用这个粉红色的家伙和这个紫色的家伙，所以我们选择粉红色的那个，去faucet里拿一些测试币，然后他 "尝试这个"，它应该失败，它应该报错：not the owner。

我们继续，所以我们已经测试了这行代码。

我们已经用其它账号试过了，他们无法设定purpose。

而我们用owner账户试了一下，他能够设置purpose。

现在看来这段内容运行的不错，它把其他人挡在了外面。

我们在这边创建了一个具备验证性质的智能合约，只有拥有合格私钥的人才能控制合约，才能更新purpose 这个变量。

Set Purpose2.0 —— 权限控制

好吧，这不那么有趣。

让我们来想一想，可以做什么来让更多的人参与进来，让我们把它想得更像一个任何人都可以进入的自动售货机。

因此，与其把它设置成只有一个owner可以调用，不如把它设置成payable的。

好的，然后我们要做的是，我们会说 "msg.value"需要大于或等于0.001 eth。

好的，然后我们在不足的情况下说 "not enough"。好的，所以我们已经改变了规则，这个地址不再重要了。

我们不再需要一个owner了，它不为任何人所拥有。

事实上，当我们部署这个智能合约时，如果我们做得正确，甚至我们都不能阻止它，没有人能够阻止这个自动售货机。这是一台不可阻挡的自动售货机，任何人如果想更新这个字符串的话，都可以进入这里并支付0.001个以太坊。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;
  constructor() {
    // what should we do on deploy?
  }

  function setPurpose(string memory newPurpose) public {
      require( msg.value >= 0.001 ether, "NOT ENOUGH!");
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

这是个相当酷的小项目。好的，让我们看看，让我们部署这个，看看我在这里是否做错了什么，看看它是否能让我们满意。就这样，编译部署，现在我们的前端更新了，这里有一个新的字段，可以放入交易值。

所以我想说设置purpose为hello world时，我会设置0.001 ether，我们拿这个 ether 乘以10的18次方换算成wei。因为这些Ethereum节点会运行一个EVM，EVM 需要简单，它不想做浮点数运算。

我们没有在EVM中内置小数，而是基本上把所有东西都乘以10的18次方，以创造一种假的小数系统。

因此，一个ETH等于10的18次方的wei。因此，当我想用0.001个ETH时，我需要将其乘以10的18次方，以使其达到0.001ETH。

所以这里的数值和这里的数值是一样的，看到了吧。

这是相同的，人类更容易阅读小数，但机器需要它来处理整数。

我们调用这个函数，它制作一个交易，我们支付 ETH 来更新 purpose。我们支付这么多ETH，你可以看到现在合约里有ETH。所以自动售货机开始收集人们设定的 Purpose 值。 好吧，我们等一下，我们没有办法将这些ETH提取出来。

我想炫耀的以太坊的超能力，就是你可以在这个区块链上面进行创新。所以，你想象可以一下，让我们回退一点，当有人说区块链是什么样子的，对吗？区块链是什么样子的？嗯，大多数人都会说它可能看起来像一组排成一排的区块。他们可能会说，区块链看起来像这样，就像这些区块链，而且它指向前一个区块。

这没错。但实际上，如果你考虑它的物理情况，区块链是所有这些节点，它是网络上所有这些节点。

所以区块链看起来更像这样，它是一个点对点的网络，所有这些机器都在点对点地交流，他们就什么达成了共识？

我们来想想分布式账本。

所以比特币得出的共识是——什么是分布式账本的价值？爱丽丝发送 1 给鲍勃，鲍勃发送 2 给查理，账本上的每个人都在记录，每个人都达成了一致。

对于以太坊的账本而言，它不仅仅是一个账本，我们在这里记录资金往来的信息。

它实际上是一个执行环境。

因此，这是一个小小计算机，每个人都运行那个小小计算机，这不是一个很好的画法，但想象一下：

这是一个小计算机，每个人都在运行自己的小计算机。当你部署这个智能合约时，网络上的每个节点都会得到你的智能合约的副本。

而每当你想调用一个更新它的函数时，当我们调用这个更新字符串时，网络上的每个节点都必须将他们的字符串更新为新的值。

因此，我们现在看的这个分布式账本实际上是一个执行环境，它正在执行交易。每个人都在跟踪这个区块链，用工作证明来保证它的安全。

如果我们想从web2的角度来考虑以太坊，我们可以把它想成一个数据库。当你有一个数据库，并且有很多人在使用它时，你需要扩大规模，你需要增加更多的冗余。

那么，对于以太坊，每一个节点都是冗余的，所以网络中的一部分节点可以崩溃，你仍然可以问其他仍然在线的节点问值是什么。所以以太坊网络具有抗审查能力。

这里无需人的信任，你唯一要信任的是代码。我们知道这将完全按照我们的程序来做。当我说，当我们部署这个后，甚至我们都不能阻止它，这正是你希望它工作的方式。你希望能够部署一个智能合约，准确地做它应该做的事情。

好吧，我们通过scaffold-eth在以太坊上建立了一个小自动售货机，里面有一些钱，我们可能需要提取这些资金。

我们需要把它想成是对抗性的，譬如，任何人都可以攻击这个合约，这个合约里有什么问题吗，有什么东西我们也许可以添加点什么东西在这之上，我们可以如何在这之上进行编程。

所以考虑下所谓区块链网络，就是由这些机器组成的大网络，他们为我们处理所谓“区块链”的东西，

我们的工作只是在这里写我们的小规则，我们可以通过在这里写小规则来快速创新。

所以让我们看看我们可以创新什么，让我们做一些别的事情。

Set Purpose3.0 —— 经济机制

让我们做一个 "uint256 public price"，所以我将跟踪一个巨大的数字，我将设置它，我将把它称为price，我将设置它等于 "0.001 eth"，然后我们在这里替换这个，基本上只是设置一个变量，我们希望price 是什么。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;
  constructor() {
    // what should we do on deploy?
  }

  uint256 public price = 0.001 ether;

  function setPurpose(string memory newPurpose) public {
      require( msg.value >= price, "NOT ENOUGH!");
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

如果我部署了这个，它应该正常工作，我们不应该有任何问题，我应该能够回到这里。我应该能够发送同样的交易，发送一些钱，并设置 price 。

让我们再想一想经济学的问题。

让我们想一想，我们要如何在这里创造一些机制设计。

让我们想一想，如果我们做这样的事情会怎么样：

我们将在这里添加的是我们将看到价格=价格*1001/1000，这将做将会慢慢提升价格。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;
  constructor() {
    // what should we do on deploy?
  }

  uint256 public price = 0.001 ether;

  function setPurpose(string memory newPurpose) public {
      require( msg.value >= price, "NOT ENOUGH!");
      price = price * 1001 / 1000;
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

好的。所以，让我们去确保我们的操作顺序是正确的。

开始吧，所以我们确保我们采取，记住没有小数，这些都是整数。

好的，我认为这将会正常工作。

让我们继续前进，用yarn deploy这个，看看它看起来如何。

我们正在做的是在智能合约的基础上添加创新的机制，只需添加一两行代码，突然间整个系统的工作方式就会变得有些不同。

好的，所以我要发送第一笔交易了。现在看看这个，价格已经上升了。

所以接下来如果我会发送 "Hello World 2"，这个每次我创建一个新的，价格都会上升一点，你可以看到更多的钱进入智能合约。

所以，很快的，我们设计了一个价格函数，然后让我们让价格按曲线上升。

我们只是把它扔进了合约里，在scaffold-eth中测试了一下，基本上我们就准备好了。我们已经有了这个应用程序，可以开始使用了。

我们最终可能会建立一些用户界面的例子，我们使它更干净一点。

我们会将其内置到用户界面中，这样它就能在幕后完成这些工作。

但现在这个界面这是为开发者建立的，这已经准备好了。这是为开发人员建立的，以便他们在智能合约上工作和学习 Solidity。

你会想把它分割出来，并在你进行的过程中实际建立你自己的前端，但很多东西都会在这里，示例UI让你真正的可以与智能合约交互、监听事件以及许多其他东西。

好了，你已经把握了关键。

假设你已经把scaffold-eth搞清楚了。你已经构建了一个项目，你准备部署它。你将进入Hardhat配置，选择你的网络。可以选择主网，让我们把这个东西发送到主网；可以选择测试网，让我们把这个东西发送到测试网。

所以你可以选择你的公共网络。

你可以用"yarn generate"来创建一个新的账户，然后你给这个账户充值。

然后你可以用 "deploy"，而不是部署到localhost，它将部署到你想去的任何网络。

你做一个其他的改变。

你打开你的前端，你打开你的app.jsx，你会在这里将这个网络更新为mainnet 或任何你想要的，它将在这个网络上工作。

然后你可以用"yarn build "或"yarn s3 "或"yarn surge "。又或者建立你的静态网站，指向你已经在那个公共网络上的智能合约。

你也可以把你的应用程序放在公共网络上。

因此，你可以给别人一个URL，他们可以与你的智能合约应用程序互动。

好的，很酷，所以这就是你如何部署一个应用程序。

Mapping 类型与 Token

一旦你有了scaffold-eth，并且你已经做了实验，你已经学会了所有这些不同的东西，你需要学习基础数据类型，你需要学习映射。

而你所做的是，你会点击一个映射，你进入这里，你会找到一个映射，你会把它带入你的智能合约，你会说，好吧，这看起来像什么？

这个映射是做什么的？这是一个从地址到uint的映射。OK，所以它是什么，基本上可以认为它指的是某个地址的余额。

它可以告诉你任何给定的地址的余额，所以如果我们把我们的所有者放在那里，我们设置owner的余额等于100，然后我们部署它。

现在我们刚刚创建了一个完全不同的东西。这实际上非常类似于一个代币，如ERC20代币。

我们已经设置好了，所以我们要追踪余额。那么，一个代币接下来需要什么呢？

好吧，可能需要一些叫做transfer的函数，这个transfer函数将接受一些地址来调用表明谁在发送它，以及uint256表示的发送的金额，我们将使设置为public。

然后，我们的规则是什么，应该设置什么规则？我们需要制定一个规则。

让我们要求message.sender的余额大于或等于金额，所以基本上他们想发送一些金额，我们需要确保他们有这个金额，如果没有，我们就说not enough。

然后，一旦我们知道他们有这个数额，我们会怎么做？

我们将扣除他们的余额，我们将说，-=balance；然后，我们将拿到第 2 个地址的余额。我们将说，+=balance。

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT

import "hardhat/console.sol";
//import "@openzeppelin/contracts/access/Ownable.sol"; //https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

contract YourContract {

  //event SetPurpose(address sender, string purpose);

  string public purpose = "Building Unstoppable Apps";
  address public owner = 0x6088587a4dAdf60eBcAdA345EC9cA18e69d6C828;

  mapping(address => uint) public balance;
  constructor() {
    balance[owner] = 100;
  }

  function transfer(address to, uint256 amount) public {
    require(balance[msg.sender]>=amount, "NOT ENOUGH");
    balance[msg.sender] -= amount;
    balance[to] += amount;
  }

  uint256 public price = 0.001 ether;

  function setPurpose(string memory newPurpose) public {
      require( msg.value >= price, "NOT ENOUGH!");
      price = price * 1001 / 1000;
      purpose = newPurpose;
      console.log(msg.sender,"set purpose to",purpose);
      //emit SetPurpose(msg.sender, purpose);
  }
}

你刚刚为自己建立了一个代币，这个东西在5年或10年前花了大量的工作，建立一个去中心化的货币，你可以在以太坊中通过几行代码建立。

让我点击保存，让我部署这个，让我们看看它是否有效。顺便说一下，这是100wei，如果我想说得非常具体，这是100wei，而不是100eth。所以要注意这一点。

但我们现在只是在处理wei的问题，这很好。

我只是在展示我们如何能够看到一个人的余额，我们可以给一个匿名者发送一些代币。

好的，我们复制这个地址，然后找到我们的transfer函数，我们把它粘贴进去。

这就是scaffold-eth的作用，它有很多components和hooks，你会用到的，让我们继续前进，给他们发送50。

我们继续——我们发送了50，所以现在如果我检查这个人的余额，他有50。

如果我们去检查这个人的余额，他也有50元。

所以它起作用了，这就是一个映射，这就是你如何学习什么是映射的。

你看一下这些例子，把它们粘贴到scaffold.eth中，然后你就随便玩玩了。

文档地址：

https://solidity-by-example.org/mapping/

其它内容学习

所以这就是一个映射。接下来你要学习的是结构。

那是一个原始数据类型的结构。也许可以做一个待办事项列表，从待办事项列表中添加和删除一些东西。

文档地址：

https://solidity-by-example.org/structs/

然后你将学习modifiers修改器。这是一种写这些规则的方法，你可以只有一个规则，然后你可以把它应用于其他函数，而不必重写那些requirement语句。

事件events真的很重要，因为它们给你的前端提供信息。

智能合约可以发出events，你可以从区块链上读取events。因此，events被存储在区块链上。

但它们存储的地方不是以其他合约可以接触得到的，所以事件的读取只为你的前端服务，它们只为人类可阅读而服务。

它们不是为了被其他智能合约调用而使用。

所以问题在于，events 对于获取信息来说是很好的，他们却不适用于与智能合约交互。

继承真的很重要，所以当你看到我们先前设置的只有owners可以做某事的所有权模式，你想做什么而又不想自己写，你可能要去OpenZeppelin，把他们的ownable 模式带进来，然后你说这是ownerable的。现在我们可以到这里，我们可以说 "only owner"，现在only owner可以调用。

只有owner可以进入那里并调用那个函数，而不是要跟踪一个owner，设置modifier和设置所有其他的东西，设置require函数，我们可以只带入OpenZeppelin的代码。

因此，你可以从OpenZeppelin引入很多其他的标记和很多其他的东西。一旦你使用了继承，请检查一下fallback 函数中的 payable ，然后你的旅途才真正开始。

这只是在学习语言，你刚刚学会了语言，你刚刚学会了global units，你已经学会了什么是message.sender和message.sender以及block.timestamp。你有点明白了，你是一个程序员，你对Solidity的理解足以让你能意识到我们应该建立什么。这就是我们要做的，所以这里是Eth开发的快速方式。我在教人们如何在Ethereum上构建应用的过程中获得了一些思考。

为了真正理解以太坊的工作方式，以及哪些东西能用，哪些不能用，你需要经历一堆的概念。而这一切都始于对Solidity的使用。我们已经说过了，通过这些原始概念。

其它的 Amazing 例子！

引用地址：

https://medium.com/@austin_48503/%EF%B8%8Fethereum-dev-speed-run-bd72bcba6a4c

然后再看看简单的NFT例子。

基本上，它将只是通过教你铸造你自己的NFT。

如果你想了解它对该合约做一些小的改动的话。这是你的NFT合约，非常简单。它从OpenZeppelin中引用了很多东西。

然后将分支扩展到buyer mint，把它设置为不是由艺术家支付 NFT gas费，而是设置为只有买方需要支付gas 费。

买家支付NFT的 gas 费，而不是艺术家。这只是你做的一个小改变。我们也可以创建一个画廊，人们可以进入并在其中铸造NFT。

从这里开始，你就是进入赛道了。

接下来是一个分布式的质押挑战，你会学会payable 的功能。你会学习到block.time。

如果过了这个特定的时间，那我们就执行一些行为。

接下来你会经历代币售卖机和下一个任务，你会学习如何部署代币。你将学习如何部署一个代币售卖机。

你将从你的供应商那里购买代币，然后是难一点的部分，你必须把你的代币卖回给售卖机，这很复杂，因为ERC20中的Approve模式实际上是两个交易。

一个是对代币合约的approve，然后是对售卖机的另一个交易，让它去收取你的代币，然后返回给你ETH或其他东西。

在公共确定型区块链上玩转提交commit reveal和randomness真的很难。

了解这一点的原因，了解什么是commit reveal。了解你如何使用预言机来提供随机性，然后了解更多关于预言机的信息。

了解你如何从API中将数据喂给区块链，以及这样做的利与弊。

学习如何建立一个去中心化的交易所，所以你可以在一个智能合约中用代币交换ETH，而不是一个可能被黑客攻击或崩溃的订单簿，其中的诀窍是你持有各自代币的储备，在两者之间进行交易。

进入这个领域，学习如何建立你自己的decks，然后有很多DeFi的东西。

学习ERC20s的粘合曲线。学习如何在前端建立你自己的swaps。

学习如何建立你自己的借贷功能，然后学习如何用智能合约调用杠杆。

然后签署信息是很重要的事情。

回到我们可以签署和解密消息的那个密钥对，你可以在链外进行，比如说状态通道；但你也可以在链上进行，比如说合约钱包可以要求少数不同签名者的签名，你可以在链外把所有这些签名集中起来，然后在链上做一个交易。

这就是ECDSA库。还有元交易，然后在以太坊加速赛中要击败的最后一个BOSS，可以建立你自己的多签。

我这里有一个例子，但最好是自己建立它。所以请看Solidity的例子。

而且这里有很多很好的例子，包括黑客。了解重入攻击是如何生效的，了解黑客是如何工作的。看看代码审计，看看代码审计师是如何对其他智能合约进行反馈的。

我的 twitter

今天我们和 scaffold-eth 一起建造了一堆东西。

如果要后续沟通的话，我是Twitter上的@AustinGriffith。让我们看看这里。

我是Twitter上的@AustinGriffith，我的 DMs （直接沟通）是开放的。

scaffold-eth是我们开始的地方，就在这里。

如果你想获得基础知识，请到eth.build。

但一旦你掌握了基础知识，就可以跳到scaffold-eth中去看看了。

祝您好运，在以太坊上建立一些了不起的东西。

祝你今天愉快，再见。