1、web3具体是啥？

定义：一个运行在“区块链”技术之上的“去中心化”的互联网。

web1：用户只能浏览网上的内容
web2：用户不仅是浏览方，还可以是内容（博客、评论、视频、商品等等）的创作者，深度参与到信息网络之中
web3: 核心就是用户所创作内容的所属权，不再属于平台，而是属于创作者本人，通过协议的方式授权给某些平台。

2、区块链了解一下

学习视频：www.bilibili.com/video/BV1Vt…

什么是区块链：
1. 区块链，就是一个又一个区块组成的链条。每一个区块中保存了一定的信息，它们按照各自产生的时间顺序连接成链条。这个链条被保存在所有的服务器中，只要整个系统中有一台服务器可以工作，整条区块链就是安全的。这些服务器在区块链系统中被称为节点，它们为整个区块链系统提供存储空间和算力支持。如果要修改区块链中的信息，必须征得半数以上节点的同意并修改所有节点中的信息，而这些节点通常掌握在不同的主体手中，因此篡改区块链中的信息是一件极其困难的事。相比于传统的网络，区块链具有两大核心特点：一是数据难以篡改、二是去中心化。基于这两个特点，区块链所记录的信息更加真实可靠，可以帮助解决人们互不信任的问题。
2. 节点：轻节点（保存部分链上信息，不用一直在线）、全节点（保存所有链上信息，一直在线）
3. 链条：最长合法链、叔链（一个交易提交后，节点会计算出哈希值生成区块后，将其发到区块链上，但同一时间，有很多节点参与计算，可能会有两个或多个区块符合标准后上链，这样主链就出现了分叉，当运行一段时间后，区跨链会使用最长的链作为合法的主链，而其他链会被舍弃掉，这个分叉的链也称为叔链。）
挖矿是怎啥意思？
1. 挖矿设备：普通电脑CPU --> GPU --> 矿机：ASIC芯片（专门为挖矿设计的芯片）
2. 挖矿的过程，就是计算哈希值的过程，让计算的哈希值小于等于给定的阈值
比特币用的算法是SHA-256，根据区块block header和其中的Nonce值计算一个初始哈希，通过不断调整随机数Nonce值，从而计算出一个符合目标阈值的哈希值，而所谓符合目标阈值，大体上就是计算出的hash值是以一定个数的0开头。
1. 共识机制：ethereum.org/zh/develope…
  - 工作量证明 (PoW) ：以太坊曾经使用
  - 权益证明 (PoS) ：以太坊目前使用
加密货币是个啥？
1. 简单的来说，加密货币是节点成功计算出区块后，被给予的奖励，而且在发起交易需要上链的时候，需要支付一定的费用（gas费），这些都是以加密货币支付。
2. 比特币白皮书（中文版）

3、以太坊：简介

以太坊是一条区块链，其中嵌入了规范化计算机（称为以太坊虚拟机，或 EVM）。它是以去中心化、无需许可、抗审查的方式构建应用程序和组织的基础。
比特币和以太坊本质上都是基于区块链的去中心化的分布式账本，但以太坊可以让开发者发布应用程序，这些应用程序也是去中心化的，称为去中心化应用（DAPP）。

4、什么是智能合约？

开发者将程序（可重用的代码片段）上传到以太坊虚拟机状态，用户发出请求以使用不同参数执行这些代码片段。我们将这些上传至网络并由网络执行的程序称为智能合约。
智能合约一旦部署到以太坊网络中，就无法更改。
合约实例：etherscan.io/tokens

以下是币安发行代币（BNB）的智能合约

/**
 *Submitted for verification at Etherscan.io on 2017-07-06
*/

pragma solidity ^0.4.8;

/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}
contract BNB is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
        address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
        mapping (address => uint256) public freezeOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
        
        /* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
        
        /* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function BNB(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
        ) {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes
        decimals = decimalUnits;                            // Amount of decimals for display purposes
                owner = msg.sender;
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
                if (_value <= 0) throw; 
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approve(address _spender, uint256 _value)
        returns (bool success) {
                if (_value <= 0) throw; 
        allowance[msg.sender][_spender] = _value;
        return true;
    }
       

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
                if (_value <= 0) throw; 
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }

    function burn(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
                if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        totalSupply = SafeMath.safeSub(totalSupply,_value);                                // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }
        
        function freeze(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
                if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                // Updates totalSupply
        Freeze(msg.sender, _value);
        return true;
    }
        
        function unfreeze(uint256 _value) returns (bool success) {
        if (freezeOf[msg.sender] < _value) throw;            // Check if the sender has enough
                if (_value <= 0) throw; 
        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      // Subtract from the sender
                balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
        Unfreeze(msg.sender, _value);
        return true;
    }
        
        // transfer balance to owner
        function withdrawEther(uint256 amount) {
                if(msg.sender != owner)throw;
                owner.transfer(amount);
        }
        
        // can accept ether
        function() payable {
    }
}

以太坊合约开发文档

简单概述一下，如果把区跨链看成是一个云数据库，那么合约就相当于云函数，是可以读取、修改链上数据的方法库。

5、认识一下代币（Token）

代币标准：ethereum.org/zh/develope…
同质化代币标准ERC-20：在以太坊上发行加密货币
非同质化代币标准 ERC-721：发行NFT需要遵守的标准

5、DAPP：介绍

去中心化应用 (dapp) 是在去中心化网络上构建的应用程序，结合了智能合约和前端用户界面
使用 JavaScript API 库，与既有合约交互就可以构建一个 dapp。
1. web3.js：web3js.readthedocs.io/en/v1.8.2/
2. ethers.js：docs.ethers.org/v6/

6、去中心化自治组织（DAO）：web3催生的组织形式

去中心化自治组织是指集体所有且由区块链监管的组织，为一个共同的使命而奋斗。
了解更多...

7、其他

一些术语
1. L1：一层网络，是底层区块链。以太坊和比特币都是一层网络区块链。它们是基石，各种二层网络都构建于其上
2. L2：二层网络，用于描述一系列具体的以太坊扩容解决方案，二层网络是一条独立的区块链，它扩展了以太坊并继承了以太坊的安全保证。
3. 区块链三难困境：用于描述区块链技术面临的三个主要挑战：去中心化、可扩展性和安全性。虽然针对这些挑战有许多潜在的解决方案，但没有一个单一的解决方案能够同时解决所有这三个挑战，L1常从强调去中心化和安全性开始，L2通常是提高可扩展性和速度。

【web3】各位前端们，是时候了解一下web3了

1、web3具体是啥？

2、区块链了解一下

3、以太坊：简介

4、什么是智能合约？

5、认识一下代币（Token）

5、DAPP：介绍

6、去中心化自治组织（DAO）：web3催生的组织形式

7、其他