以太坊上的核心开发者 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中去看看了。

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

祝你今天愉快,再见。

本文参与登链社区写作激励计划 ,好文好收益,欢迎正在阅读的你也加入。

0 条评论

请先 登录 后评论
李大狗
李大狗

上海对外经贸大学区块链研究中心副主任

51 篇文章, 5850 学分