与传统的链上数据工具相比，Hemera 不仅关注数据的采集和展示，更注重数据的价值挖掘和智能化应用。通过支持多链结构的数据聚合分析，Hemera 帮助用户实现更深入的洞察。例如，它能够迅速追踪区块链上的交易路径，分析资金流动，识别关键的交互节点，从而揭示出隐藏在链上复杂交互背后的商业逻辑与市场动向。

Hemera 的设计理念还体现了开放性与易用性。借助现代化的可视化界面和 API 接口，用户可以方便地自定义查询和创建分析模型，无论是需要基础的区块链数据统计，还是高级的数据科学分析需求，Hemera 都能轻松满足。此外，Hemera 采用高度优化的数据存储与计算技术，确保在面对大规模链上数据时，依然能够保持良好的性能和响应速度。

通过 Hemera，区块链的数据不再是孤立的记录，而是可以被探索、关联和深入解读的丰富资产。无论是开发去中心化应用（DApp），研究 DeFi 生态，还是分析 NFT 市场，Hemera 都是不可或缺的强力助手。它的智能化链上数据分析能力，正引领着区块链数据分析进入一个全新的时代。

1.介绍 Hemera Protocol

什么是 Hemera？
Hemera是一种以账户为中心的可编程索引协议（Account-Centric Indexing, ACI），专注于简化链上数据的访问和管理。不同于传统的区块链索引方式，Hemera基于用户账户而非每个交易进行索引，从而提升数据访问效率、减少资源消耗，特别适用于开发人员和链上应用的数据管理需求。

传统区块链数据访问的挑战
1.效率低：数据访问费时且耗费大量资源。
2.成本高：复杂查询频繁调用，导致高基础设施成本。
3.数据膨胀：传统索引方式对每个事件或交易建立索引，导致冗余数据量大。

Hemera 如何应对这些挑战？
1.用户级数据访问：通过以账户为中心的索引简化数据访问流程。
2.实时用户行为洞察：支持跨链实时分析用户行为。
3.灵活的用户定义函数（UDF）：提供内置函数库并支持自定义UDF，方便开发者进行特定的数据提取和分析。

Hemera 应用场景
1.区块链浏览器：高效探索链上数据。
2.投资组合追踪：快速获取和分析资产投资组合。
3.身份解决方案：便捷地构建以用户为中心的去中心化身份账户。

2. 环境配置

为了顺利运行Hemera项目，需要安装以下软件和开发环境：

1.Python：链上数据处理的必备语言环境，参考安装教程：Python安装教程。
2.PostgreSQL：数据库管理系统，用于存储和管理链上数据，参考安装教程：PostgreSQL安装教程。若出现安装问题，参考解决教程：PostgreSQL安装过程问题解决教程
3.PostgreSQL可视化工具：建议安装Navicat或Workbench等可视化工具进行数据库管理。
4.WSL（Windows子系统）：在Windows上运行Linux环境的必备工具，方便开发者使用Linux命令行和应用程序，详细安装指南：WSL安装教程。

3. 获取项目源码

克隆源码
对于有一定开发经验的用户，可从GitHub克隆Hemera项目源码并自行配置环境：

提示：请确保已安装Git，参考安装教程：Git详细安装教程。

4.Hemerea入门demo

Demo 运行步骤
    1.创建项目文件夹

             在主目录下创建 code/hemere 文件夹，用于存放项目代码：

             mkdir -p ~/code/hemere

    2.进入文件夹

          进入刚创建的 code/hemere 文件夹：

          cd ~/code/hemere

   3.检查 Git 版本

          确认安装了 Git，并检查 Git 版本：

           git --version

   4.克隆代码仓库

          从GitHub克隆Hemera项目源码到本地：

         git clone https://github.com/HemeraProtocol/hemera-indexer.git

    5.进入项目目录

            进入下载的项目文件夹 hemera-indexer：

            cd hemera-indexer/
    6.安装 Python 开发环境

           安装 Python 3.9.5 环境：

           sudo apt install python3
    7.安装 Python 虚拟环境管理工具

           安装 venv，用于创建Python虚拟环境：

            sudo apt install python3-venv
    8.检查 Python 版本

            确认 Python 安装正确并查看版本：

             python3 --version
    9.创建 Python 虚拟环境

            在项目文件夹中创建虚拟环境 venv：

              python3 -m venv ./venv

           到此为止全部完成会在~/code/hemere/hemera-indexer目录下面看见一个venv文件夹，说明Python虚拟环境创建成功

    10.安装依赖管理工具 Make

          Make用于自动化依赖管理，确保系统中已安装：

           sudo apt install make
   11.下载项目依赖

           使用 Make 下载和整理项目依赖：

           make development

         下载所有依赖之后会提示：source .venv/bin/activate

  12.激活虚拟环境

         进入 Python 虚拟环境：

          source .venv/bin/activate

         要退出虚拟环境，请运行：

          deactivate

  13.运行 Demo

            运行 Demo 脚本以获取特定区块上的数据。本示例中，将查询区块 100001 到 100003 的信息：

          运行效果展示：

5.用户定义函数 (User-Defined Functions, UDF)

1.什么是 UDF？
        用户定义函数（UDF）允许开发者编写自定义的查询函数，以便更灵活高效地提取特定数据。Hemera内置了多个预构建的UDF示例，如提取账户余额、事件日志等，开发者可以根据需求进一步调整，甚至创建全新的UDF以满足特定的业务需求。

2.UDF 的工作原理
 UDF包含以下核心组件：

  1.数据模型：定义UDF中处理的数据结构。
  2.数据类：组织输入和输出数据的类型，以提升效率。
  3.业务逻辑：定义UDF的核心逻辑，用于数据处理和转换。

6. 构建和部署您的第一个 UDF

环境配置
    1.使用Docker：适用于快速部署环境。
       步骤1：安装Docker。
       步骤2：克隆hemera-indexer仓库。
       步骤3：获取目标EVM链的RPC URL。
         更多Docker使用说明详见：Docker文档。
    2.从源码构建：适用于开发和调试。
          安装开发工具（Linux/Unix环境）。
          执行 make development 启动开发环境。
          配置 PostgreSQL 实例。
          运行 hemera.py stream 启动索引器。
           详细安装指南参见：源码构建文档。
创建一个简单的 UDF 步骤
  1.定义数据类：例如，为ERC721 Token Mint定义数据结构。
  2.实现数据库模型：在PostgreSQL中定义ERC721 Token Mint事件的数据存储模型。
 3.实现UDF任务：在UDF中实现数据处理逻辑，过滤和提取链上事件。
 4.测试 UDF：编写单元测试以验证UDF的准确性。
 5.部署 UDF：将UDF文件加入Hemera索引器目录，更新配置并重启索引器以加载新功能。
代码示例：ERC721 Token Mint Tracker 示例代码。

7.高级 UDF 开发与实际应用

实战示例：ERC20 Token 追踪
目标是开发一个UDF，追踪指定钱包地址的ERC20 Token交易流量，包括所有收款和付款的累计数量。UDF输入和输出如下：

    1.输入：钱包地址。
     2.输出：返回该地址接收和发送的ERC20 Token累计数额。
UDF 的实际应用场景
     1.区块链浏览器：通过结合多种UDF实现链上交互的可视化。
     2.链上社交图谱：分析地址之间的交互，构建去中心化的社交图谱。
     3.DeFi投资组合追踪：聚合多种DeFi协议的数据，以便用户实时跟踪投资组合。
UDF 性能优化
  1.数据结构优化：使用集合等高效数据结构，加快查询速度。
  2.批处理：将数据分批处理，减少单次RPC调用压力。
  3.缓存：缓存频繁访问的数据，提升响应速度。
  4.并行处理：将任务分块，并使用多工作节点并行执行，提高处理效率。

8. Hemera 生态系统与开发者支持

Hemera积极支持开发者参与生态建设，并提供详细的开发指南和技术支持，开发者可以在生态系统中贡献自己的UDF模块。Hemera的支持内容包括：

   1.文档和教程：Hemera文档
   2.GitHub仓库：Hemera Protocol GitHub
   3.社区支持：Discord社区

此外，Hemera提供 UDF构建者计划，鼓励开发者创建和分享UDF的实际应用案例。更多详情请访问：UDF构建者计划。

作者：卢菜菜的编程小窝 ，可爱杰尼龟
————————————————

原文链接：https://blog.csdn.net/A_mikey/article/details/143776862

1.打开sui的链接 点击这里跳转到GitHub

接下来我们来一起完成task1吧！

一、点击  学习任务

宝子们可以先进q群，因为到时候提pr的时候，需要在群里发自己的GitHub地址的，不然不让合并。然后有一些b站上的学习资料，课程源码可以获取，大家自行查看。

二、查看readme.md

在任务列表中，点击 README.md 文件，可以了解任务的具体要求和步骤。这是开展学习的基础材料，里面包含了项目的背景信息、任务目标和如何进行的详细说明。

可以查看任务

​

三、点击01.hello_xu200.md

这个指南将为你提供完成第一个合约上链所需的具体步骤和示例代码，是你动手实践的重要参考。

根据这个指南，来完成第一个合约上链

四、完成第一个合约上链

（一）安装Sui CLI
https://docs.sui.io/guides/developer/getting-started/sui-install

1、选择操作系统:
我选择的是Windows的，然后点进这个链接。

2、查找版本
点进来之后，右边窗格有个Releases，点击+号，查看更多版本。

3、下载并解压
我这里选择的是这个版本，大家下载完成后，解压。

解压之后如图

4、配置环境变量
将此目录地址复制，然后配置到系统的环境变量里面。

5、查看sui的版本信息
输入:    sui --version

查看版本信息，表明正在使用 Sui 的版本 1.35.2，后面的部分是该版本的构建哈希值（4e46da89efd5）这样就完成好sui cli的安装啦。

（二）完成Sui钱包安装
1、选择钱包
截至目前，生态项目收录平台Sui Directory上列出了11款钱包。除了简单的存储SUI功能之外，这些钱包还提供了丰富的功能，例如铸造NFT和探索Web3的apps。

举例来说，Ethos钱包包括一个地址簿，你可以使用它更容易地向朋友发送tokens，也可以在apps中直接购买和交易tokens，而无需从交易所购买。您可以在Suiet钱包的浏览器中发现更多Web3 apps。ComingChat则在客户端提供了加密聊天等其他功能。

您可以选择任意一款能够满足您需求的钱包，无需担心，您还可以安装和使用多个钱包，每个钱包都可以显示您在Sui上拥有的tokens数量。您还可以使用一个钱包创建多个账户，每个账户中放置不同数量的tokens。

2、安装 Suiet Wallet
可以直接点击 Suiet Wallet 然后添加扩展程序

Sui Wallet 是官方推出的钱包，主要用于管理 Sui 区块链上的资产和交易，功能相对基础且稳定。而 Suiet Wallet 则是一个社区驱动的钱包，通常会集成更多的功能，例如跨链支持、去中心化应用（DApp）的集成等，可能在用户体验和界面设计上更为灵活和创新。总的来说，选择哪个钱包取决于你的需求，比如你更看重官方支持还是希望尝试更丰富的功能。

我这里是添加社区版的钱包，也就是Suiet Wallet。

3、添加至谷歌浏览器中

4、创建帐户
安装好钱包扩展程序后，界面上将显示「创建新钱包（create a new wallet ）」和「导入现有钱包（import an existing one）」的选项。您可以在此钱包中创建一个账户，然后将该账户导入其他钱包。使用其中任何一个钱包都将显示您在Sui上的tokens数量。

创建新账户时，您需要设置一个密码（注意不是密钥）。使用常规方法设置即可，例如使用字母、数字和特殊字符的组合，同时，请务必安全保存您的密码。

此时，钱包扩展程序将生成一组用于找回钱包的短语用于保护钱包的安全，这些短语也称为助记词，通常由12个单词组成（有些钱包会更多）。请务必保存好您的助记词，并将其离线安全地存储。如果您丢失了助记词，将无法访问您的钱包。

5、使用钱包
如果您从CEX中购买tokens，您需要向交易所提供您的公钥。公钥通常会很明显的显示在钱包界面，点击一次即可将其复制。使其他人或公司可通过公钥向您发送tokens、NFT和其他数字资产。

公钥由一长串数字和字母组成，类似于：

0x06fe7f254m20119a0c39fa6f62r96b8494c3af1aa5a5bf84439f44c405675d

*请注意，出于安全考虑，上述公钥在长度和字符方面可能与实际公钥略有不同。

当您进入Sui上需要支付的app时，钱包扩展程序会自动开启，并请求您对该交易进行批准。如果超过设定时间，则需要您重新输入钱包的密码打开钱包。

钱包还支持您直接发送tokens到另一个钱包，此时您需要其他钱包所有者提供其公钥才能发送。

（三）安装好编辑器
我这里选择用vscode 来安装move插件。

1、打开插件市场
首先打开插件市场 在vscode右边箭头所指图标点一下，

点击安装(install)按钮，等待插件安装完成

2、安装依赖插件
官方插件有个依赖项插件也需要一并安装

插件安装后必须要进行设置才能使用,很多同学到了这一步会碰到插件不起作用的问题

3、配置插件设置
首先进入到插件设置界面

进入到 settings界面

点击 edit in settings.json 按钮

把exe的全路径+名称都填进去了，记得要使用双斜杠 \ 来表示路径的斜杠 (win系统)

（四）接下来便可以根据这个任务指南，来完成啦。

1、输入此url 创建fork
https://github.com/move-cn/letsmove?tab=readme-ov-file

然后点击folk按钮

点击创建fork

2、在自己的GitHub仓库里可以看到刚刚fork的仓库， 也就是副本仓库

然后克隆项目和最后的提pr都可以参考这位大佬的文章哦。

震惊！原来贡献开源代码这么简单，分分钟上手！_开源代码如何贡献-CSDN博客

（五）创建和部署一个基于 Sui 区块链的 Move 项目
1、创建项目

2、切换目录

3、构建项目

4、测试项目

5、查看地址

6、发布合约

这整个过程就是创建、构建、测试并最终发布一个 Move 项目到 Sui 区块链的基本流程。

五、最后提pr完成task1
提pr请参考文章提到的大佬写的文章哦。

总结
  通过本次"Let's Move"激励计划的学习，我们不仅掌握了如何使用Sui CLI安装和配置环境，还了解了如何选择和使用钱包管理我们的数字资产。通过创建、构建和发布Move项目的整个流程，我们深刻体会到了区块链开发的乐趣与挑战。每一步的实践都是对理论知识的巩固，而最终的提PR过程则使我们有机会参与到开源社区中，贡献自己的力量。希望通过本次任务，能够激励更多的开发者加入到Move语言的学习与应用中，为未来的区块链技术发展贡献智慧与力量。

作者： yoona1020、花花花1
————————————————

原文链接：https://blog.csdn.net/A_mikey/article/details/143688044

零知识证明是一种密码学协议，允许证明者在不泄露任何额外信息的情况下，向验证者证明自己知道某个特定的秘密或信息。简单来说，证明者可以证明自己“知道”某件事，而无需透露这件事的具体内容。

零知识证明的重要性在于它能在保护隐私的同时，确保信息的真实性和可靠性。

零知识证明通常生成很麻烦，但是验证很迅速，其主要的运用场景是：
- 隐私保护：验资、投票、交易
- 计算压缩：区块链扩容

1. 零知识证明（ZKP）的基本流程：

1) 编译（Compile）
输入：program
输出：verification_key（验证密钥，类型为字符串）

2) 证明（Prove）
输入：program，public_inputs（公共输入），private_inputs（私有输入）
输出：proof（证明，类型为字符串）

3) 验证（Verify）
输入：proof，public_inputs，verification_key
输出：布尔值（返回true 或 false 以验证证明的有效性）

工作流程：

Prover Function（证明者函数）
• 通过私有输入和公共输入生成零知识证明。

Verifier Function（验证者函数）
• 接收零知识证明与公共输入，并通过验证密钥进行验证，返回true 或 false。

2. zkApp 的优势：

1. zkApp 使用 TypeScript 编写，支持在浏览器中直接运行。
2. 可编程隐私（Programmable Privacy）：提供灵活的隐私配置，允许开发者根据需求编写隐私功能。
3. 链下执行与链上验证（Offchain Execution & Onchain Verification）：zkApp 可以在链下执行计算，链上只做验证，从而减少了Gas费用。
4. 无需可信设置（No Trusted Setup）：zkApp 不依赖于传统的可信设置步骤，简化了系统复杂度。
5. 可组合性与 zkRollup 风格的扩展性（Composability and zkRollup-style Scaling）：zkApp 通过递归扩展支持可组合性和 Rollup 风格的扩展性，提升了系统的可扩展性。
6. 通过 Mina 区块链实现互操作性（Interoperability through Mina’s succinct blockchain）：zkApp 通过 Mina 的精简区块链实现了跨链互操作性。

3. zkApp 每个方法的编译过程：

每个 zkApp 的方法实际上被编译成一个程序，该程序具有以下两个要素：

1. 输入（Input）：方法的参数（arguments）和链上状态（on-chain values）。
2. 输出（Output）：执行的更新列表以及与链上状态相关的前提条件列表。

zkApp 中的智能合约的执行流程可以被描述为：

zkCircuits(State0(public), private inputs) ===> Tx[proof, updates] ===> State1
解释：zkCircuits 处理初始状态（State0），接受公共和私有输入，生成交易证明（Tx proof）和更新列表（updates），最终更新到新的状态（State1）。

• 方法的参数包含私有输入和智能合约的某些状态。
• 方法还利用外部世界的状态信息，生成对智能合约状态和外部世界状态的更新。

二、搭建第一个zkapp

• 编写一个基本的智能合约，该合约存储一个作为链上状态的数字。
• 合约逻辑允许仅通过其平方来替换这个数字；例如，3 -> 9 -> 81，依此类推。
• 使用zkApp CLI创建一个项目。
• 编写你的智能合约代码。
• 使用模拟的本地 Mina 区块链与智能合约进行交互。

先决条件

• Node.JS v18+
• NPM v10+
• git v2+

1. 下载或者更新 zkApp CLI​

npm install -g zkapp-cli

2. 创建一个新项目

- Zk project 命令能够为你的项目生成用户界面。
- 请选择none选项。​

$ zk project <project-name>

3. 准备项目

首先删除新项目附带的默认文件。

rm src/Add.ts
rm src/Add.test.ts
rm src/interact.ts

创建新文件：

zk file src/Square
touch src/main.ts

• zk file命令创建了src/square.ts和src/Square.test.ts测试文件。

4. 编写 index.ts

在文本编辑器中打开 src/index.ts 并将其更改为如下所示：

import { Square } from './Square.js';

export { Square };

src/index.ts 文件包含了你希望从智能合约项目外部（例如从用户界面）进行调用的所有导出内容。

5. 编写 zkapp 智能合约

在src/Square.ts文件中编写你的智能合约。

/*

Field：o1js中的原生数字类型。你可以将Field元素视为无符号整数。Field元素是o1js中最基础的类型，所有其他o1js兼容类型都是基于 Field元素构建的。
SmartContract：创建zkApp智能合约的类。
state：在zkApp智能合约中使用的便捷装饰器，用于创建对zkApp账户中链上存储状态的引用。
State：在zkApp智能合约中使用的类，用于在zkApp账户中创建链上存储的状态。
method：在zkApp智能合约中使用的便捷装饰器，用于创建智能合约中的方法（类似函数）。使用此装饰器的方法是用户与智能合约交互的入口点。

*/ 
import { Field, SmartContract, state, State, method } from 'o1js';

// 名为 Square 的智能合约有一个链上状态元素，名为num，类型为Field，
// zkApp可以拥有最多八个链上状态字段
export class Square extends SmartContract {
    @state(Field) num = State<Field>();
    init() {
        super.init(); // 添加init方法，用于在部署时设置智能合约的初始状态
        this.num.set(Field(3)); // 将链上状态num初始化为值 3
    }
    
    // 如果用户向update()方法提供的数字（例如 9）是现有链上状态num的平方（例如 3），则将链上存储的num值更新为提供的值（在此情况下为 9）。
    // 如果用户提供的数字不满足这些条件，他们将无法生成证明或更新链上状态。
    @method async update(square: Field) {
        const currentstate = this.num.get(); 
        this.num.requireEquals(currentstate); 
        square.assertEquals(currentstate.mul(currentstate));
        this.num.set(square);
    }
}

当用户调用智能合约上的方法时，所有断言必须为真，才能从该智能合约生成零知识证明。Mina网络只有在附加的证明有效时才会接受交易并更新链上状态。

6. 与智能合约交互

接下来，编写一个与智能合约交互的脚本。在 src 文件夹下创建 main.ts 文件，以便你能够与智能合约进行交互。

/*
    Field：与之前学到的相同的 o1js 无符号整数类型。
    Mina：用于模拟本地 Mina 区块链，方便将智能合约部署到其中，并像用户一样与其交互。
    PrivateKey：一个包含用于操作私钥的函数的类。
    AccountUpdate：生成一个可以更新 zkApp 账户的数据结构的类。
*/
import { Square } from './Square.js';
import { Field, Mina, PrivateKey, AccountUpdate } from 'o1js';

// 初始化本地区块链
const useProof = false; // 设置是否使用证明
const Local = await Mina.LocalBlockchain({ proofsEnabled: useProof });
Mina.setActiveInstance(Local);

// 模拟本地区块链提供了预先资助的账户
const deployerAccount = Local.testAccounts[0];
const deployerKey = deployerAccount.key;
const senderAccount = Local.testAccounts[1];
const senderKey = senderAccount.key;
// ----------------------------------------------------

// 创建公钥/私钥对。公钥是您的地址以及将 zkApp 部署到的位置
const zkAppPrivateKey = PrivateKey.random();
const zkAppAddress = zkAppPrivateKey.toPublicKey();

// 创建一个 Square 实例，并将其部署到 zkAppAddress
const zkAppInstance = new Square(zkAppAddress);
const deployTxn = await Mina.transaction(deployerAccount, async () => {
    AccountUpdate.fundNewAccount(deployerAccount);
    await zkAppInstance.deploy();
});
await deployTxn.sign([deployerKey, zkAppPrivateKey]).send(); // 发送签名

// 获取部署后 Square 的初始状态
const num0 = zkAppInstance.num.get();
console.log('state after init:', num0.toString());

// ----------------------------------------------------
// 创建了一个新交易，尝试将字段更新为值9。
const txn1 = await Mina.transaction(senderAccount, async () => {
    await zkAppInstance.update(Field(9));
});
await txn1.prove();
await txn1.sign([senderKey]).send();

const num1 = zkAppInstance.num.get();
console.log('state after txn1:', num1.toString());

// ----------------------------------------------------
// 尝试一个失败的交易,看一看结果会是怎样
try {
    const txn2 = await Mina.transaction(senderAccount, async () => {
        await zkAppInstance.update(Field(75));
    });
    await txn2.prove();
    await txn2.sign([senderKey]).send();
} catch (error: any) {
    console.log(error.message);
}
const num2 = zkAppInstance.num.get();
console.log('state after txn2:', num2.toString());

// ----------------------------------------------------

const txn3 = await Mina.transaction(senderAccount, async () => {
    await zkAppInstance.update(Field(81));
});
await txn3.prove();
await txn3.sign([senderKey]).send();

const num3 = zkAppInstance.num.get();
console.log('state after txn3:', num3.toString());

// ----------------------------------------------------

7. 构建并运行智能合约

现在，Square 智能合约已经完成，以下命令将以模拟本地区块链运行您的项目。
要将 TypeScript 代码编译成 JavaScript，请使用：

npm run build

要运行 JavaScript 代码：

node build/src/main.js

您可以选择将这些命令合并为一行：

npm run build && node build/src/main.js

8. 运行结果

一、什么是DePIN？

DePIN，全称Decentralized Physical Infrastructure Networks，即分散物理基础设施网络，是一种通过 区块链技术 和 物联网IoT 将物理基础设施去中心化管理的新方式。其核心理念是通过代币激励机制，鼓励个人和企业共享和管理物理资源，从而创建一个更民主、更高效的基础设施管理模式。

二、DePIN的工作原理

DePIN的工作原理主要包括以下几个方面：

1. 物理基础设施：DePIN需要在现实世界中建立和维护物理基础设施，这些基础设施可以是数据存储设备、无线热点、计算设备等。
2. 区块链架构：区块链作为一个不可篡改的账本，记录所有的交易和数据交换，确保透明度和信任。
3. 代币激励：通过代币激励机制，鼓励资源提供者共享资源，并为网络的使用者提供经济激励。
4. 智能合约：智能合约自动管理资源共享的条款和条件，确保网络的高效运行。

三、DePIN的优势

• 分散化管理：消除中心化控制点，增强系统的安全性和弹性。
• 成本效益：通过点对点交易降低成本，消除传统的中间费用。
• 透明度和信任：区块链技术确保所有的交易和数据交换都是透明且可信的。
• 创新和竞争：降低进入门槛，鼓励更多的参与者加入，促进市场竞争和创新。

四、DePIN的应用场景

1. 数据存储：

• Filecoin，通过鼓励用户共享未使用的存储空间，提供去中心化的数据存储服务。该平台利用区块链技术，确保数据存储和检索的安全性和可靠性。

2. 计算资源：

• Render Network (RNDR) 是一个分布式 GPU 渲染服务平台，通过将 GPU 计算能力整合在一起，为需要高性能计算资源的用户提供服务。该平台记录所有的计算过程，并通过区块链技术确保透明和可信。

3. 无线网络：

• Helium 创建了一个去中心化的无线网络，通过激励用户共享无线热点，提供廉价且广泛的无线连接服务。用户可以部署 Helium 热点设备，这些设备不仅提供无线连接，还能通过加入网络获得加密货币奖励
• Wicrypt 专注于解决非洲地区互联网连接问题，提供了一系列长距离WiFi路由器产品。其中 Spider Wi-Fi Hotspot 可以支持多达70个设备同时连接，覆盖距离可达200米。通过 SIM卡槽 和 4G-LTE接收功能，用户可以获得高达 300 Mbps的 WiFi 互联网连接。

4. 视频流媒体：

• Theta 网络通过共享带宽和存储，为全球用户提供高质量的视频流媒体服务。
• NATIX 是一个利用智能手机进行街景采集的项目。通过在智能手机上安装 NATIX 应用，用户可以贡献街景数据，这些数据用于创建更精准和实时的地图。该应用利用手机的多种传感器（如摄像头、麦克风、加速度计等）来实现这一目标。用户可以免费下载并使用应用，甚至可以通过推荐码获取奖励积分。
• DIMO设备安装在汽车上，可以实时提供车辆数据，并将匿名化的数据提供给第三方开发者使用。用户通过贡献数据可以获得代币奖励。

五、DePIN的挑战

尽管DePIN具有许多优势，但其发展也面临一些挑战：

• 技术复杂性：区块链技术和IoT的结合增加了系统的复杂性，要求更高的技术水平。
• 监管不确定性：不同国家和地区的监管政策差异较大，可能影响DePIN的全球推广。
• 初始资本投入：建立和维护物理基础设施需要较高的初始资本投入。

六、结论

DePIN代表了基础设施管理的新范式，通过区块链和IoT技术的结合，创造了一个更安全、更高效、更透明的管理模式。尽管面临技术和监管上的挑战，但随着技术的进步和市场的扩大，DePIN有望在未来几年内彻底改变我们管理和利用物理资源的方式。

需求与创新相辅相成，通过了解区块链的历史事件，我们可以看到它的发展方向。

一、历史进程

1. 起源：
   - 1976年，密码学大师Diffie和Hellman发表了论文《密码学的新方向》，奠定了未来密码学发展的方向，包括非对称加密、椭圆曲线算法、哈希等。
   
   - 同年，经济学家哈耶克（Hayek）出版了《货币的非国家化》，提出非主权货币和去中心化货币的理念，为区块链的诞生铺平道路。
   
2. 密码学的发展：
   - 1980年，RSA算法诞生，为非对称加密体系奠定基础。
   
   - 1982年，Lamport提出拜占廷将军问题，标志着分布式计算的可靠性理论进入实质性阶段。
   
   - 1985年，Koblitz和Miller独立提出椭圆曲线加密（ECC）算法，使非对称加密实用化。
   
3. 密码学货币的雏形：
   - 1997年，HashCash方法（第一代POW算法）出现，用于反垃圾邮件。
   
   - 1998年，戴伟和尼克·萨博提出密码学货币的概念，为比特币的精神先驱。
   
4. 点对点网络：
   - 1999-2001年，Napster、EDonkey 2000和BitTorrent分别先后出现，奠定了P2P网络计算的基础。
   
5. 比特币的诞生：
   - 2008年，中本聪发表《比特币：点对点的电子现金系统》论文，开启了比特币时代。
   
   - 2009年，中本聪挖掘创始区块，比特币正式诞生。
   
6. 区块链的演进：
   - 区块链1.0：始于比特币，区块链的雏形。主要关注数字货币和支付功能。
   
   比特币（Bitcoin）升级事件：
   - 2017年，Segregated Witness (SegWit)： SegWit通过分离签名数据和交易数据来改善比特币的扩展性，同时还为实施第二层解决方案（如闪电网络）铺平了道路。
   - 2021年，Taproot： 通过引入新的签名方案和智能合约功能，提高了比特币的隐私性和可扩展性，同时降低了链上智能合约的成本。
   
   - 区块链2.0：以以太坊为中心，引入智能合约
   
   - 区块链3.0：Cardano等新一代区块链平台出现，将应用扩展至物流、人力资源、科学、教育等各行各业。

二、什么是区块链Layer0、Layer1、Layer2？

在区块链领域，Layer0、Layer1和Layer2是用来描述不同层次的技术解决方案的术语。这些术语通常用于描述区块链系统的层次结构以及不同层次之间的关系。

Layer0（零层）： Layer0通常指的是底层基础设施，即区块链网络本身。这包括底层的共识机制（如：POW、POS）、区块链协议、网络安全性（如：双重支付、防止网络攻击）、加密算法等。其目标是提供一个可靠、安全且高效的基础，以支持更高层次的区块链协议。

Layer1（一层）： Layer1是构建在Layer0之上的第一层协议或区块链应用程序。Layer1通常是指原生于底层区块链网络上的协议和智能合约，例如以太坊上的智能合约和ERC-20代币标准。Layer1提供了基本的区块链功能，包括账户和资产管理、智能合约执行等。

Layer2（二层）： Layer2是建立在Layer1之上的第二层解决方案，旨在增强区块链的扩展性、互操作性和功能性。Layer2解决方案可以是任何在Layer1之上构建的技术，包括闪电网络、状态通道、侧链、Plasma等。这些解决方案通过在Layer1之外进行交易和状态管理，提高了交易吞吐量和性能，并降低了交易成本。

三、应用的发展过程

1. 概念验证阶段（2009-2013年）： 区块链技术最初出现在比特币白皮书中，旨在作为一种去中心化的数字货币系统。在这个阶段，人们主要将注意力集中在比特币这一加密货币的发展，以验证区块链技术的可行性。
2. 去中心化金融（DeFi）和智能合约的兴起（2013-2017年）： 随着对区块链技术的认知不断加深，人们开始意识到区块链不仅可以用作数字货币，还可以构建智能合约和去中心化应用。以太坊的推出使得智能合约得以实现，并促进了去中心化金融（DeFi）的兴起，包括去中心化交易所（DEX）、借贷平台、稳定币等，区块链 L1 开始蓬勃发展。
3. 企业区块链应用的探索（2015年至今）： 随着区块链技术的不断成熟和发展，越来越多的企业开始探索如何将区块链应用于他们的业务中。在这个阶段，大型企业和机构开始尝试区块链技术，尤其是在供应链管理、跨境支付、数字身份验证等领域。
4. Layer2 解决方案的发展（2018年至今）： 随着对区块链可扩展性和性能的需求（高手续费、交易速度慢）不断增长，Layer2 解决方案开始成为关注焦点。这些解决方案包括闪电网络、Raiden Network、Plasma 等，旨在通过在链下进行交易和状态管理来提高交易吞吐量和性能，并降低交易成本。
5. NFT 和元宇宙的崛起（2020年至今）： 近年来，非同质化代币（NFT）和元宇宙成为了区块链应用的新热点。NFT 技术使得数字资产的唯一性和所有权可以得到确权，从而推动了数字艺术、游戏、虚拟地产等领域的发展。同时，元宇宙的概念也吸引了越来越多的关注，人们开始探索利用区块链技术构建虚拟世界，并在其中进行各种交互和交易。

四、总结

人们对于区块链的认知是呈螺旋式不断上升的，现在区块链的应用很多，但是烂项目、骗局也很多，擦亮自己的眼睛，保持清醒的头脑。

l 1、查看当前项目的依赖模块：

在命令行输入npm ls(npm list)，可以查看当前文件夹下安装的模块

npm install express          # 局部安装

npm install express -g   # 全局安装

l 本地安装。

将安装包放在 ./node_modules 下（运行 npm 命令时所在的目录），如果没有 node_modules 目录，会在当前执行 npm 命令的目录下生成 node_modules 目录。

可以通过 require() 来引入本地安装的包。

l 我们可以使用以下命令来卸载 Node.js 模块。

npm uninstall express

l 卸载后，你可以到 /node_modules/ 目录下查看包是否还存在，或者使用以下命令查看：

npm ls

npm uninstall express -g 卸载全局

5、

l 我们可以使用以下命令更新模块：

npm update express

npm  i moment@2.22.2

第二

初步的介绍了异步编程和同步编程以及await关键字的作用，别去举了一个实例来演示。

async是用来定义异步函数的关键字，并且await关键字智能在异步函数内部使用，要执行的代码加了await关键字后，要等该代码执行完之后才可以执行下一步。

接着给了一个nodejs的实例(主要将http请求报文和响应报文和何如在浏览器中去看报文)

创建一个文件夹，在里面在创建一个项目，进入项目目录，在显示目录位置那将这个框内东西全部删除，然后输入cmd进入到命令控制台，然后输入npm i http 下载并安装名为http的软件包。这将使你能够在你的Node.js应用程序中使用http模块，以便处理HTTP请求和响应。

接着将老师给的实例放入项目文件夹中，并在vscode中打开这个项目，这个项目中js文件引入 required 模块：我们可以使用 require入 Node.js模块，开始讲解了如何看请求报文和响应报文，请求报文:1、请求行里有请求的方法以及路由以及http协议和地址，2、请求头部可以看它包含关于请求的附加信息,文本数据使用哪种编码格式进行编码和解码，3、请求体可以看它的请求数据。响应报文：1、状态行可以看http协议，状态信息，2、响应头部可以看用什么编码格式等，3、响应体看html内容和数据

讲解了创建服务器的代码一些参数(request,response)以及为什么传这俩个参数,这俩个参数（也可以去其他名字）的主要是帮我们去分割报文，如果没有这俩个参数我们需要人工去分割报文，接着讲解了url和method，以及细讲了我们在go语言中用的路由如何跳转的底层一点的代码，用了if else去判断应该走那个路径和做的操作，在终端用nodejs的命令开启服务器，然后看效果是否与老师一样。

DAPP将了作业就是车险合约的测试。

学习资料：

• 北京大学肖臻老师的课是精华，一定要看！！！！有基础的同学也可以去看，你会有很多新的收获，我当时就是每一集都做了笔记，干货超多。
  B站网址：https://www.bilibili.com/video/BV1Vt411X7JF/?spm_id_from=333.337.search-card.all.click&vd_source=6e2f6be95b1505776bf456848f7a47fa

这个是我当时学习参考的博主写的笔记，记录的非常详细:
https://blog.csdn.net/Mu_Xiaoye/article/details/104299664

• 书籍（可选）：《精通以太坊》、《区块链基础知识25讲》，有需要的朋友可以评论区找我要。

阶段二：深入学习

一、了解去中心化应用（DApps）

• 学习什么是DApps，它们的优势和挑战。
• 了解DApps的工作原理和生态系统。

关于dapp的概念b站有视频讲解都大差不差，技术的同学不需要在这个板块浪费时间，非技术的同学需要细看。。。

二、学习Web3.js

• 了解如何使用Web3.js与以太坊网络交互。
• 编写简单的Web3.js应用程序。

1. 学习Web3.js之前可以自己去操作安装一条geth私链，网上有很多使用教程，推荐下载原来pow版本（不要下最新的，因为最新版geth使用的是权益证明，我们先把难的boss放一放），把链跑起来就完成第一步了。
2. 准备好需要使用的插件：metamask（火狐可以直接访问，chrome跟edge懂的都懂），使用私链连接metamask并查看挖出的token即完成了第二步。
3. 跟着这个网站一步一步来，初体验web3.js https://docs.web3js.org/guides/getting_started/introduction

三、深入了解智能合约

• 学习更复杂的智能合约设计模式和最佳实践。
• 探索智能合约安全性和漏洞。

深入学习智能合约，推荐 Solidity by Example 去跑一跑上面的例子会加深你对智能合约的理解。
Defi 部分的讲解推荐：https://www.bilibili.com/video/BV19x4y1w7aj/?spm_id_from=333.880.my_history.page.click&vd_source=6e2f6be95b1505776bf456848f7a47fa 梁老师讲的非常好，很详细，没有听懂的部分可以反复听。

阶段三：项目实践

一、开发一个简单的去中心化应用

• 设计一个有趣的DApp概念，并实现其智能合约和前端界面。
• 部署你的DApp到以太坊主网或测试网络。

Github上有很多不错的项目可以去参考借鉴，当然不要忘记去薅测试币。做技术得同学可以把自己得代码发布到git上方便做工作的时候用

二、参与区块链社区

• 加入区块链社区，与其他开发者和爱好者互动。
• 参与区块链项目和活动，拓展您的网络。

1. 工具：科学上网工具、twitter、discord、telegram
2. 相关的区块链项目：https://www.bilibili.com/video/BV15T4y1s7WQ/?spm_id_from=333.337.search-card.all.click&vd_source=6e2f6be95b1505776bf456848f7a47fa

三、持续学习和探索

• 跟踪最新的区块链技术和发展。
• 不断学习并尝试新的项目和想法。

1. 建议去看一本书《九章链术》，这本书里的一些关于区块链项目的实践例子很值得参考，会改变你对于软件项目的看法。
2. 市场认可度比较高的项目（需要自己去挖掘哦，这里只提供网址）：
   https://coinmarketcap.com/
   https://www.coingecko.com/
   https://defillama.com/
   https://www.geckoterminal.com/
   https://dexscreener.com/

日常会在这里更新一些有趣的新项目，https://twitter.com/0xgangWhat，欢迎点赞、评论、收藏、转发and关注我~。

一、公式推演

1、交换

△y  = (△x * y ) / △x + x

2、添加流动性

S = √(△x * △y)
T = √(x * y)

x / ‌‌y = (x + △x) / (y + △y)  =>  △x / △y  = x / y

L0/L1 = T/(T+S)
S = (△x / x) * T = (△y / y) * T

3、移除流通性

△x = x * (S / T)
△y = y * (S / T)

二、智能合约编写

1、合约结构设计

• 在开始编写之前，需要明确定义合约的功能和结构。这个合约是一个自动市场做市商（AMM），主要包括交换、提供流动性和移除流动性等功能。

2、导入依赖：

• 确保导入了所需的依赖文件，如 IERC20.sol，它定义了 ERC20 标准接口。

3、合约定义：

• 定义合约名称为 CPAMM，采用 Solidity 的版本 ^0.8.13。
• 定义两种代币 token0 和 token1，这些代币通过 IERC20 接口定义。

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

import "./IERC20.sol";

contract CPAMM {

    // 定义代币0和代币1的储备量 reserve0 和 reserve1。
    IERC20 public immutable token0;
    IERC20 public immutable token1;
    
    // 定义合约的总供应量 totalSupply 和用户余额的映射 balanceOf。
    uint public totalSupply;
    mapping(address => uint) public balanceOf;
}

4、构造函数：

• 编写构造函数 constructor，在合约初始化时传入两种代币的地址，并将其存储在状态变量中。

    constructor(address _token0, address _token1) {
        token0 = IERC20(_token0);
        token1 = IERC20(_token1);
    }

5、内部函数定义：

• 定义一些内部函数，如 _mint、_burn、_sqrt、_update 和 _min，用于增发代币、销毁代币、计算平方根、更新代币储备量和计算两个数中的最小值等功能。

    // 私有函数，用于增发代币给指定地址
    function _mint(address _to, uint _amount) private {
        balanceOf[_to] += _amount;
        totalSupply += _amount;
    }

    // 私有函数，用于销毁指定地址的代币
    function _burn(address _from, uint _amount) private {
        balanceOf[_from] -= _amount;
        totalSupply -= _amount;
    }

    // 计算平方根的内部函数
    function _sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    // 更新代币储备量的内部函数
    function _update(uint _reserve0, uint _reserve1) private {
        reserve0 = _reserve0;
        reserve1 = _reserve1;
    }

    // 返回两个数中较小的数
    function _min(uint _x, uint _y) private pure returns (uint) {
        return _x > _y ? _y : _x;
    }

6、交换功能（swap 函数）：

• 编写交换函数，用户通过提供其中一种代币来交换获得另一种代币。在函数中，需要进行一些检查，如检查输入金额是否有效、检查输入代币是否合法等。
• 计算输出代币的数量，并将输出代币转给用户。
• 更新代币储备量。

    function swap(address _tokenIn, uint _amountIn) external returns (uint amountOut) {
        // 检查输入金额是否有效
        require(_amountIn > 0, "Invalid Amount");
        // 检查输入代币是否合法
        require(_tokenIn == address(token0) || _tokenIn == address(token1), "Invalid token");
        
        // 确定输入代币和输出代币
        bool isToken0 = _tokenIn == address(token0);
        (IERC20 tokenIn, IERC20 tokenOut) = 
            isToken0 ? (token0, token1) : (token1, token0);
            
        // 确定输入代币和输出代币的储备量
        (uint reserveIn, uint reserveOut) = 
            isToken0 ? (reserve0, reserve1) : (reserve1, reserve0);
            
        // 将输入代币转入合约
        tokenIn.transferFrom(msg.sender, address(this), _amountIn);
        
        // 计算输出代币数量(△y  = (△x * y ) / △x + x)
        amountOut = (_amountIn * reserveOut) / (reserveIn + _amountIn);
        
        // 将输出代币转给用户
        tokenOut.transfer(msg.sender, amountOut);
        
        // 更新代币储备量
        _update(token0.balanceOf(address(this)), token1.balanceOf(address(this)));
    }

7、添加流动性功能（addLiquidity 函数）：

• 编写添加流动性函数，用户可以将两种代币同时提供给合约以增加流动性。需要检查提供的金额是否有效，并将两种代币转入合约。
• 计算用户获得的份额，并增发份额给用户。
• 更新代币储备量。

    function addLiquidity(uint _amount0, uint _amount1) external returns (uint shares) {
         // 检查提供的金额是否有效
         require(_amount0 > 0 && _amount1 > 0, "Invalid amount");
         // 将代币0和代币1转入合约
         token0.transferFrom(msg.sender, address(this), _amount0);
         token1.transferFrom(msg.sender, address(this), _amount1);
         
         // 如果储备量不为零，则检查提供的代币比例是否匹配
         if (reserve0 > 0 || reserve1 > 0) {
             require(_amount0 * reserve1 == _amount1 * reserve0, "dy/dx != y/x");
         }

         // 计算用户获得的份额
         if (totalSupply == 0) {
            shares = _sqrt(_amount0 * _amount1);
         } else {
         	// 取小的S，S = (△x / x) * T = (△y / y) * T 
            shares = _min(
                (_amount0 * totalSupply) / reserve0,
                (_amount1 * totalSupply) / reserve1
            ); 
         }
         // 检查份额是否有效
         require(shares > 0, "share is zero");
         // 增发份额给用户
         _mint(msg.sender, shares);
         // 更新代币储备量
        _update(token0.balanceOf(address(this)), token1.balanceOf(address(this)));
     }

8、移除流动性功能（removeLiquidity 函数）：

• 编写移除流动性函数，用户可以根据持有的份额从合约中提取相应的代币。计算用户提取的代币数量，并将相应的代币转回给用户。
• 更新代币储备量。

function removeLiquidity(uint _shares) external returns (uint amount0, uint amount1) {
    // 检查提供的份额是否有效
    require(_shares > 0, "Invalid shares");
    // 计算提取的代币数量
    amount0 = (_shares * reserve0) / totalSupply;
    amount1 = (_shares * reserve1) / totalSupply;
        
    // 销毁用户的份额
    _burn(msg.sender, _shares);
        
    // 将相应的代币转回给用户
    token0.transfer(msg.sender, amount0);
    token1.transfer(msg.sender, amount1);
        
    // 更新代币储备量
    _update(token0.balanceOf(address(this)), token1.balanceOf(address(this)));
}

1、下载npm依赖

> makdir remix-workspace

// 注意：老用户需要把旧版本删除重新下载
> npm uninstall -g remixd

> npm install -g @remix-project/remixd

//如果下载失败可以尝试换一个镜像
> npm config set registry http://registry.npm.taobao.org

2、检查版本号

> remixd -v

3、启动服务

// 假设现有一个项目为uniswapv2，需要remix连接该本地目录
> remixd -s ./uniswapv2 -u https://remix.ethereum.org

完成连接！

Uniswap 是一种自动流动性协议，由恒定乘积公式( x * y = k )提供支持，并在以太坊区块链上的不可升级智能合约系统中实施。 它消除了对可信中介的需求，优先考虑去中心化、抗审查和安全的特性。

每个Uniswap智能合约是由一个由两个 ERC-20代币组成的流动资金池。

具体一个例子来说明:
原本流动性池有5 个 tokenA 和 20 个 tokenB，当 Tim 换掉 1个 tokenA 时，他会先支付 0.3%的手续费，也就是 0.003个 tokenA (0.3% * 1 )。支付费用后，剩余的 tokenA，也就是 0.997 tokenA，会换成 tokenB，所以新的 X 变成了5.997 tokenA。由于 K 必须保持不变，新的Y可以从公式中计算出来 X * Y= newX * newY。所以 newY 是 16.675004 (X * Y /newX = 5 20/5.997=16.675004)。这意味着池中将持有 16.675004 个 tokenB，剩余的 tokenB 将发送给Tim，这意味着 Tim 将收到 3.324996 个 tokenB (Y - newY = 20 -16.675004 = 3.324996)。交换后，池中有6个 tokenA 和 16.675004个 tokenB

交易池：

Tim：

2、交易滑点

流动性更好的交易池可以为用户提供较低的交易滑点

假设池子X有1个A token，10个B token;池子Y有10个A token，100个B token，不考虑交易费用，两个池子的汇率此时相同
Trader用0.1个A token分别在池子X与Y当中兑换B token，兑换完之后X当中有1个A token，9.09个B token，Y当中有10.1个A token，99个B token此时X中汇率为1 A token = 8.26 B token，Y中汇率为1 Atoken =9.8 B token

A交易池：

B交易池：

3、清算

清算是一种资产处理方式，在加密货币领域，清算主要指交易者或者资产借贷人将初始保证金全部或部分强制平仓。当他们无法满足杠杆寸头的保证金要求时，就会发生这样的情况。

比如：
① ETH 2000 美金的时候，我使用 MakerDAO 存入 100 ETH，理论上我可以借出 200,000 美金 (Dai)；
② 但因为 MakerDAO 的设计机制（抵押品的价值要大于贷款价值）需要超过 150% 的质押率（借 1 美元需要抵押 1.5 美金的 ETH），来维持 Dai 的稳。
③ 所以我们最多只能借出 100/1.5*2000 ≈ 133,333 美金，而这时的清算价格就是 2000 美金。
④ 如果 ETH 价格跌破 2000 美金，你的 ETH 则会被清算掉，相当于你用 1333 美金的价格购买了 100 个 ETH。（当然你也可以少借一些 Dai，来降低清算线）

如果你想避免 100 个  ETH 在 2000 美金时被清算掉，要么在清算触发之前将 133,333 美金的 Dai 归还借贷系统（再加上借贷的费用），要么就继续质押更多的 ETH，降低清算线。

当抵押品价格持续上涨的时候，你可以借出越来越多的钱，而当抵押品价格下跌的时候，则会不断增加抵押资产被清算的风险。如果想降低风险，则需要通过补仓降低清算风险，或提前平仓，避免强制平仓（清算）的出现。

4、无偿损失

无常损失是指向双边池注入流动性后，所存的代币总价值相较于存款之前代币总价值的差值。简单来说就是，我注入流动性后赚的钱，还没有我不注入流动性赚的多。

具体可以参考本篇文章：无常损失（获得 Rekt 的）初学者指南 |由 Nate Hindman |班科尔 (bancor.network)

参考视频：大佬们口中的无常损失是什么？玩UniSwap做市商为什么会亏钱？（第170期） (youtube.com)

5、APY 与 APR

APR (Annual Percentage Rate, 稳定年回报率)，指在进行一笔投资时，不考虑复利（将利润进行复投）的年收益。

APY (Annual Percentage Yield，复利年收益率)，指在进行一笔投资时，考虑复利的年收益。

APR 的计算公式非常简单，APR = 日利率 * 投资天数

APY 则相对复杂一点，因为要考虑复利的情况，APY = (1 + 日利率) ^ (投资天数 - 1)

比如我投资了 100 元，分别投资 APR 和 APY 日利率为 1% 的投资品，那么一年下来我最终可以获得：

APR：100 * 1% * 365 = 365 元

APY：100 * (1 + 1%) ^ (365 - 1) ≈ 3740 元

也就是说日利率为 1 % 的 APR 年华收益为 365%，而日利率为 1% 的 APY 年华收益则为 3740%，竟然收益相差 10 倍，是不是看上去很吓人，不过这里是有坑点的。

在 DeFi 中，我们经常会看到上千的年华收益，就像我上边举的例子，1% 的日利率，复投一年下来也有 3740% 的 APY。但这里需要注意两种情况：

1. 是否真的存在稳定的日利率？
2. 收益是否按照投资的货币或者稳定币来计算？

几乎所有的 DeFi 收益都是波动的，比如你看到一个 DeFi 协议告诉你 APY 年华有 3740%，可能只有今天的日利率是 1%，随着参与人数不断增多，奖励被稀释，可能明天的日利率就降到 0.1%，后天就降到了 0.01%，并且持续减少，最后的 APY 只有 4% 左右。

此外，还有一些 DeFi 项目的收益并不是按照稳定币或者你投入的代币计算的。比如你看到一个 APY 为 1000% 的项目，需要质押 ETH，但每日给你的收益是 shitcoin（一种价格波动非常大的代币，甚至有可能归零）。

不过，在 UniswapV3 中只能使用 APR，因为流动性注入者的收益是单独计算的，并不会进行复利投资。

6、 TVL

TVL（Total Value Locked） 总锁定价值，指 DeFi 项目中用户所存储或抵押的数字资产总价值。通常视情况以美元或其他法币计价。

DeFi 的重要运转方式主要围绕用户质押借贷或注入流动性展开，这要求用户将资金质押或存入在 DeFi 项目方的智能合约当中。所以 TVL 表明了资本对 DeFi 交易者和投资者的利润和可用性影响。

1. 更好的安全性由于更高的 TVL 意味着更多的资本锁定在 DeFi 协议中，通常（相对）意味着 DeFi 协议更加安全。如果我们发现一个 DeFi 平台有较高的 APY，但 TVL 相对较低，那么该平台有可能是野鸡平台，并随时有可能 Rug pull。
2. 更好的可用性所谓的可用性，比如一个 DEX 池子深度较好，则交易价格也会较好。再比如质押借贷协议中，如果某个代币的 TVL 较高，那么借贷利率也会较低。
3. 更好的流动性TVL 更好的项目往往具有更好的流动性，不容易遇到流动性枯竭。
4. 更好的传播度由于 TVL 是衡量一个 DeFi 项目的重要指标，所以 TVL 较高的项目，也会获得 DeFi 从业者或行业的更多关注，从而带来更多的曝光度和传播度。

这是以太坊从 2023 年 3 月到 2024 年 3 月的一个 TVL，我们可以看到它的趋势都是相对平稳的。

这里放一张对比图，我们就可以发现市场对于新链发展的一个趋势。

7、价值捕获

在区块链中，价值捕获可以简单理解为「项目方（公链、DeFi 等）从用户交易行为中获取商业利润的手段」。而价值捕获手段是否健康、良性则一般会体现在币价上。所以去衡量一个项目的价值或估值，尤其是 DeFi，会往往研究其价值捕获方式。而对于交易行为，最直接的价值捕获手段则是手续费，比如：

1. Layer1 → 矿工费；
2. DeFi → 借贷分润；
3. CEX/DEX → 交易手续费；

参考资料：

1、【Web3 DeFi】Uniswap 快速入门_bilibili

2、DeFi 热点词汇详解

工具：

1、Parsec：https://parsec.finance/， 可以清晰的看到 ETH 价格变动会触发的清算数量。

2、欧科云链：https://www.oklink.com/zh-cn/chainhub/protocols/DeFi，可以看到 Maker 的总借款量和日清算量等数据。

3、Dune： https://dune.com/dsalv/Liquidations，可以看到过去一段时间 Maker，AAve 和 Compound 的清算情况

4、计算无常损失的工具

• https://poolgenie.xyz/ 查看 AMM DEX 不同池子过去七天的无常损失情况
• https://decentyields.com/impermanent-loss-calculator 无常损失计算模拟
• https://www.impermanent-loss-calculator.net/
• https://impermanentloss.github.io/calculator/
• https://dailydefi.org/tools/impermanent-loss-calculator/

5、查看TVL的工具

• https://defillama.com/ 多链 TVL 查看工具
• https://www.defipulse.com/ 以太坊 DeFi TVL 查看工具
• https://tokenterminal.com/ 专业且详细的 DeFi 数据跟踪工具
• https://coindix.com/ 查看多条公链上各自代币的 TVL

一、accounts支持的钱包类型

在accounts中总共支持两大类共3种钱包类型。

1. keystore：本地文件夹

• keystore 类型的钱包其实是一个本地文件夹目录。在这个目录下可以存放多个文件，每个文件都存储着一个私钥信息。这些文件都是json格式，其中的私钥可以是加密的，也可以是非加密的明文。但非加密的格式已经被废弃了。
• keystore的目录路径可以在配置文件中指定，默认路径是/keystore。
• keystore中的每一个文件有固定文件命名格式：UTC--<created_at UTC ISO8601>--。
• keystore目录和目录内的文件是可以直接拷贝到其它电脑的keystore目录。

2、HD：分层确定性（Hierarchical Deterministic）钱包

这个概念的中文名称叫做“分层确定性”，这是一种 key的派生方式，它可以在只使用一个主公钥的情况下，生成任意多个子公钥，而这些子公钥都是可以被主私钥控制的。
HD的概念最早是从比特币的BIP-32提案中提出来的。每一个key都有自己的路径，即是是一个派生的 key，这一点和 keystore类型是一样的。

在accounts模块中共支持两种HD钱包：Ledger和Trezor (在usbWallet文件中)

二、目录结构

1、accounts.go

accounts.go定义了accounts模块对外导出的一些结构体和接口，包括Account结构体、Wallet接口和Backend接口。其中Account由一个以太坊地址和钱包路径组成；而各种类型的钱包需要实现Wallet和Backend接口来接入账入管理。

1) account

//帐户表示位于定义的特定位置的以太坊帐户
//通过可选的URL字段。
type Account struct {
	Address common.Address `json:"address"` //从密钥派生的以太坊帐户地址
	URL     URL            `json:"url"`     //后端中的可选资源定位器
}

2) 钱包--钱包应该是这里面最重要的一个接口了

//Wallet表示可能包含一个或多个软件或硬件钱包账户（源自同一种子）。
type Wallet interface {
	//URL检索可访问此钱包的规范路径。它是用户按上层定义多个钱包的排序顺序后端。
	URL() URL

	//状态返回文本状态以帮助用户处于钱包。
	Status() (string, error)

	//open初始化对钱包实例的访问。它不是用来解锁或解密帐户密钥，而不是简单地建立到硬件的连接钱包和/或获取衍生种子。
	//passphrase参数可能被特定钱包实例。
	//请注意，如果您打开一个钱包，您必须关闭它以释放任何分配的资源（使用硬件钱包时尤其重要）。
	Open(passphrase string) error

	//关闭释放打开钱包实例持有的任何资源。
	Close() error

	//帐户检索钱包当前识别的签名帐户列表的。
	Accounts() []Account

	//包含返回帐户是否属于此特定钱包的一部分。
	Contains(account Account) bool

	//派生尝试在处显式派生层次确定性帐户指定的派生路径。如果请求，将添加派生帐户到钱包的跟踪帐户列表。
	Derive(path DerivationPath, pin bool) (Account, error)

	//SelfDerive设置钱包尝试的基本帐户派生路径发现非零帐户并自动将其添加到跟踪的列表账户。
	//您可以通过使用nil调用selfderive来禁用自动帐户发现链状态读取器。
	SelfDerive(base DerivationPath, chain ethereum.ChainStateReader)

	//sign hash请求钱包对给定的hash进行签名。它只通过包含在中的地址查找指定的帐户，或者可以借助嵌入的URL字段中的任何位置元数据。
	SignHash(account Account, hash []byte) ([]byte, error)

	//signtx请求钱包签署给定的交易。它只通过包含在中的地址查找指定的帐户，或者可以借助嵌入的URL字段中的任何位置元数据。
	SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)

	//signhashwithpassphrase请求钱包使用提供作为额外身份验证信息的密码。它只通过包含在中的地址查找指定的帐户，或者可以借助嵌入的URL字段中的任何位置元数据。
	SignHashWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)

//signtxwithpassphrase请求钱包签署给定的交易，使用提供作为额外身份验证信息的密码。它只通过包含在中的地址查找指定的帐户，或者可以借助嵌入的URL字段中的任何位置元数据。
	SignTxWithPassphrase(account Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
}

3) 后端 Backend

// Backend是一个钱包提供器。 可以包含一批账号。他们可以根据请求签署交易，这样做。
type Backend interface {
	
	// Wallets获取当前能够查找到的钱包，所生成的钱包列表将根据后端分配的内部URL按字母顺序排序。由于钱包（特别是硬件钱包）可能会打开和关闭，所以在随后的检索过程中，相同的钱包可能会出现在列表中的不同位置。
	Wallets() []Wallet


	// 订阅创建异步订阅，以便在后端检测到钱包的到达或离开时接收通知。
	Subscribe(sink chan<- WalletEvent) event.Subscription
}

Backend 接口是一个钱包 provider，它包含一个钱包列表，在检测到钱包开启或关闭时可以接收到通知，可以用来请求签名交易。其中 Wallets() 返回当前可用的钱包，按字母顺序排序，Subscribe() 创建异步订阅的方法，当钱包发生变动时通过 chan 接收消息。

４） TextHash 和 TextAndHash

func TextHash(data []byte) []byte {
	hash, _ := TextAndHash(data)
	return hash
}

func TextAndHash(data []byte) ([]byte, string) {
	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
	hasher := sha3.NewLegacyKeccak256()
	hasher.Write([]byte(msg))
	return hasher.Sum(nil), msg
}

这段代码是以太坊中用于生成签名消息的辅助函数。它们用于创建一个可以安全用于计算签名的消息哈希。

TextHash 函数和 TextAndHash 函数都执行相同的操作，但 TextHash 只返回了哈希值，而 TextAndHash 返回了哈希值和生成该哈希值的消息。

这些函数创建了一个特定格式的消息，这个格式提供了消息的上下文，并且会被用于消息的签名。生成的消息格式是：

keccak256("\x19Ethereum Signed Message:\n"${message length}${message})

其中 ${message length} 是消息长度，${message} 是实际消息内容。

TextAndHash 函数返回了计算得到的哈希值和创建该哈希值的消息。这有助于在创建签名时了解签名的消息内容。

这种消息格式的创建目的在于为消息提供上下文，同时也用于防止对交易进行签名。这种处理方式是为了增加消息的安全性和可靠性，确保消息的签名能够被正确验证。

5) WalletEvent

WalletEventType 是一个整数类型，代表钱包订阅系统中可以触发的不同事件类型。它定义了以下常量：

• WalletArrived: 当通过USB或者密钥库中的文件系统事件检测到新钱包时触发。
• WalletOpened: 当成功打开钱包并开始后台进程（例如自动密钥派生）时触发。
• WalletDropped: 暂时未提供具体注释或描述该事件类型的用途。

WalletEvent 结构体是由账户后端（account backend）触发的事件，当检测到钱包的到来或离开时使用。它包含以下字段：

• Wallet: 表示到来或离开的钱包实例。
• Kind: 表示发生在系统中的事件类型，使用 WalletEventType 中的值来描述具体事件。

type WalletEventType int

const (
	WalletArrived WalletEventType = iota
	WalletOpened
	WalletDropped
)

type WalletEvent struct {
	Wallet Wallet         
	Kind   WalletEventType
}

这段代码定义了一个钱包事件系统，用于表示钱包订阅系统中可能触发的不同事件类型和事件结构。

这种事件系统用于监控钱包的状态变化，当新钱包被检测到、钱包成功打开或者其他钱包状态变化时，系统可以触发相应的事件。这对于后台进程、自动化任务或者用户通知非常有用，能够及时响应钱包状态的变化。

2、hd.go

hd.go中定义了HD类型的钱包的路径解析等函数。

3、manager.go

manager.go中定义了Manager结构及其方法。这是accounts模块对外导出的主要的结构和方法之一。其它模块（比如cmd/geth中）通过这个结构体提供的方法对钱包进行管理。

1）常量和配置

• managerSubBufferSize: 用于确定账户管理器在其通道中缓冲的钱包事件数量的常量，限定了通道的缓冲大小为50个事件。
• Config 结构体: 包含全局账户管理器的设置。其中InsecureUnlockAllowed: 布尔值，表示是否允许在不安全的环境中解锁账户。

2）结构体和通道

newBackendEvent 结构体: 用于让管理器知道应该追踪给定后端以获取钱包更新。

• backend: 要追踪的后端。
• processed: 通道，用于通知事件发出者后端已经被整合。

type newBackendEvent struct {
	backend   Backend
	processed chan struct{} // Informs event emitter that backend has been integrated
}

Manager 结构体: 是一个整体的账户管理器。该结构体可以注册不同的后端以跟踪和管理钱包，同时还可以进行订阅以获取钱包的变更事件。这个结构体管理了一个全局的账户状态，可以订阅钱包变更事件、缓存钱包信息，并允许注册新的后端以追踪其钱包。

• config: 指向 Config 结构体的指针，保存了全局账户管理器的配置。
• backends: 存储已注册后端的映射，将后端类型映射到对应的后端实例切片。
• updaters: 存储针对所有后端的钱包更新订阅。
• updates: 用于接收后端钱包变化的订阅接收器。
• newBackends: 用于接收要被管理器追踪的新后端。
• wallets: 缓存了所有已注册后端中的所有钱包信息。
• feed: 用于通知到达或离开的钱包的钱包更新通道。
• quit: 通道，用于接收错误退出的信号。
• term: 用于通知更新循环终止的信号。
• lock: 读写锁，用于保护账户管理器内部状态的并发访问。

type Manager struct {
	config      *Config               
	backends    map[reflect.Type][]Backend 
	updaters    []event.Subscription       
	updates     chan WalletEvent          
	newBackends chan newBackendEvent       
	wallets     []Wallet                  
	feed event.Feed
	quit chan chan error
	term chan struct{} 
	lock sync.RWMutex
}

2) 创建Manager

func NewManager(config *Config, backends ...Backend) *Manager {
	// Retrieve the initial list of wallets from the backends and sort by URL
	var wallets []Wallet
	for _, backend := range backends {
		wallets = merge(wallets, backend.Wallets()...)
	}
	// Subscribe to wallet notifications from all backends
	updates := make(chan WalletEvent, managerSubBufferSize)

	subs := make([]event.Subscription, len(backends))
	for i, backend := range backends {
		subs[i] = backend.Subscribe(updates)
	}
	// Assemble the account manager and return
	am := &Manager{
		config:      config,
		backends:    make(map[reflect.Type][]Backend),
		updaters:    subs,
		updates:     updates,
		newBackends: make(chan newBackendEvent),
		wallets:     wallets,
		quit:        make(chan chan error),
		term:        make(chan struct{}),
	}
	for _, backend := range backends {
		kind := reflect.TypeOf(backend)
		am.backends[kind] = append(am.backends[kind], backend)
	}
	go am.update()

	return am
}

NewManager 会将所有 backends 的 wallets 收集起来，获取所有的 backends 的时间订阅，然后根据这些参数创建新的 manager。

3) update

update在 NewManager 作为一个 goroutine 被调用，一直运行，监控所有 backend 触发的更新消息，发给 feed 用来进行进一步的处理。

func (am *Manager) update() {
	// Close all subscriptions when the manager terminates
	defer func() {
		am.lock.Lock()
		for _, sub := range am.updaters {
			sub.Unsubscribe()
		}
		am.updaters = nil
		am.lock.Unlock()
	}()

	// Loop until termination
	for {
		select {
		case event := <-am.updates:
			// Wallet event arrived, update local cache
			am.lock.Lock()
			switch event.Kind {
			case WalletArrived:
				am.wallets = merge(am.wallets, event.Wallet)
			case WalletDropped:
				am.wallets = drop(am.wallets, event.Wallet)
			}
			am.lock.Unlock()

			// Notify any listeners of the event
			am.feed.Send(event)
		case event := <-am.newBackends:
			am.lock.Lock()
			// Update caches
			backend := event.backend
			am.wallets = merge(am.wallets, backend.Wallets()...)
			am.updaters = append(am.updaters, backend.Subscribe(am.updates))
			kind := reflect.TypeOf(backend)
			am.backends[kind] = append(am.backends[kind], backend)
			am.lock.Unlock()
			close(event.processed)
		case errc := <-am.quit:
			// Manager terminating, return
			errc <- nil
			// Signals event emitters the loop is not receiving values
			// to prevent them from getting stuck.
			close(am.term)
			return
		}
	}
}

4) backend

返回backend

func (am *Manager) Backends(kind reflect.Type) []Backend {
	am.lock.RLock()
	defer am.lock.RUnlock()

	return am.backends[kind]
}

5）账户管理器（Manager）的几个方法，用于操作和管理账户及其相关后端。

• Close() error: 这个方法用于终止账户管理器内部的通知流程。它将一个错误通道传递给 quit 通道，并且等待返回的错误信号。一旦 Close() 被调用，账户管理器的内部通知流程将会被关闭。
• Config() *Config: 这个方法用于获取账户管理器的配置信息，返回一个指向 Config 结构体的指针。它允许外部访问账户管理器的配置参数。
• AddBackend(backend Backend): 这个方法用于启动对额外后端的追踪，以便进行钱包更新。它创建了一个空的信号通道 done，并通过 newBackends 通道发送一个 newBackendEvent 结构体，通知账户管理器要开始追踪一个新的后端。在发送通知后，方法会等待并阻塞，直到收到了 done 信号，这表示新的后端已经被成功整合到了账户管理器中。

func (am *Manager) Close() error {
	errc := make(chan error)
	am.quit <- errc
	return <-errc
}

func (am *Manager) Config() *Config {
	return am.config
}

func (am *Manager) AddBackend(backend Backend) {
	done := make(chan struct{})
	am.newBackends <- newBackendEvent{backend, done}
	<-done
}

这些方法组成了账户管理器的一部分，允许对账户管理器进行关闭、获取配置信息，并添加新的后端以进行钱包更新的跟踪。

6) subscribe

订阅消息

// Subscribe creates an async subscription to receive notifications when the
// manager detects the arrival or departure of a wallet from any of its backends.
func (am *Manager) Subscribe(sink chan<- WalletEvent) event.Subscription {
	return am.feed.Subscribe(sink)
}

7) wallets

一下方法属于账户管理器 (Manager)，用于管理和操作账户、钱包以及钱包地址。

Wallets() 方法

• Wallets() []Wallet: 返回所有在此账户管理器下注册的签名账户。这个方法获取了读取锁 (RLock)，并在获取后立即释放锁 (RUnlock)，然后调用了 walletsNoLock() 方法来获取所有已注册的钱包。

func (am *Manager) Wallets() []Wallet {
	am.lock.RLock()
	defer am.lock.RUnlock()

	return am.walletsNoLock()
}

walletsNoLock() 方法

• walletsNoLock() []Wallet: 在不获取锁的情况下返回所有已注册的钱包。由于这个方法被 Wallets() 方法调用，它被限制在拥有读取锁的情况下调用。

func (am *Manager) walletsNoLock() []Wallet {
	cpy := make([]Wallet, len(am.wallets))
	copy(cpy, am.wallets)
	return cpy
}

Wallet() 方法

• Wallet(url string) (Wallet, error): 根据特定 URL 检索与之相关联的钱包。这个方法先使用 parseURL() 函数解析传入的 URL，然后在已注册的钱包列表中查找匹配的钱包，找到匹配的则返回钱包实例，找不到则返回 ErrUnknownWallet 错误。

func (am *Manager) Wallet(url string) (Wallet, error) {
	am.lock.RLock()
	defer am.lock.RUnlock()

	parsed, err := parseURL(url)
	if err != nil {
		return nil, err
	}
	for _, wallet := range am.walletsNoLock() {
		if wallet.URL() == parsed {
			return wallet, nil
		}
	}
	return nil, ErrUnknownWallet
}

Accounts() 方法

• Accounts() []common.Address: 返回账户管理器中所有钱包的所有账户地址。它获取读取锁，然后遍历所有已注册的钱包，并收集它们的账户地址，最终返回一个地址切片。

func (am *Manager) Accounts() []common.Address {
	am.lock.RLock()
	defer am.lock.RUnlock()

	addresses := make([]common.Address, 0) // return [] instead of nil if empty
	for _, wallet := range am.wallets {
		for _, account := range wallet.Accounts() {
			addresses = append(addresses, account.Address)
		}
	}
	return addresses
}

Find() 方法

• Find(account Account) (Wallet, error): 通过指定的账户来寻找其对应的钱包。它获取读取锁，然后遍历所有已注册的钱包来查找包含指定账户的钱包。如果找到匹配的钱包，则返回该钱包实例，否则返回 ErrUnknownAccount 错误。

func (am *Manager) Find(account Account) (Wallet, error) {
	am.lock.RLock()
	defer am.lock.RUnlock()

	for _, wallet := range am.wallets {
		if wallet.Contains(account) {
			return wallet, nil
		}
	}
	return nil, ErrUnknownAccount
}

Subscribe() 方法

• Subscribe(sink chan<- WalletEvent) event.Subscription: 创建一个异步订阅，用于接收账户管理器检测到的钱包到来或离开的通知。它返回一个事件订阅接口。

func (am *Manager) Subscribe(sink chan<- WalletEvent) event.Subscription {
	return am.feed.Subscribe(sink)
}

merge() 和 drop() 方法

这两个方法是用于处理钱包切片的工具函数。merge() 函数按顺序插入新的钱包，并保持原始列表的顺序。drop() 函数从排序缓存中移除指定的钱包。这些方法主要用于在管理器中添加或移除钱包时维护钱包切片的有序性。

func merge(slice []Wallet, wallets ...Wallet) []Wallet {
	for _, wallet := range wallets {
		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
		if n == len(slice) {
			slice = append(slice, wallet)
			continue
		}
		slice = append(slice[:n], append([]Wallet{wallet}, slice[n:]...)...)
	}
	return slice
}

func drop(slice []Wallet, wallets ...Wallet) []Wallet {
	for _, wallet := range wallets {
		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
		if n == len(slice) {
			// Wallet not found, may happen during startup
			continue
		}
		slice = append(slice[:n], slice[n+1:]...)
	}
	return slice
}

4、url.go

这个文件中的代码定义了代表以太坊钱包路径的URL结构体及相关函数。与hd.go中不同的是，URL结构体中保存了钱包的类型（scheme）和钱包路径的字符串形式的表示；而hd.go中定义了HD钱包路径的类型（非字符串类型）的解析及字符串转换等方法。

5、keystore

这是一个子目录，此目录下的代码实现了keystore类型的钱包。

• account_cache.go

此文件中的代码实现了accountCache结构体及方法。accountCache的功能是在内存中缓存keystore钱包目录下所有账号信息。无论keystore目录中的文件如何变动（新建、删除、修改），accountCache都可以在扫描目录时将变动更新到内存中。

• file_cache.go

此文件中的代码实现了fileCache结构体及相关代码。与account_cache.go类似，file_cache.go中实现了对keystore目录下所有文件的信息的缓存。accountCache就是通过fileCache来获取文件变动的信息，进而得到账号变动信息的。

• key.go

key.go主要定义了Key结构体及其json格式的marshal/unmarshal方式。另外这个文件中还定义了通过keyStore接口将Key写入文件中的函数。keyStore接口中定义了Key被写入文件的具体细节，在passphrase.go和plain.go中都有实现。

• keystore.go

这个文件里的代码定义了KeyStore结构体及其方法。KeyStore结构体实现了Backend接口，是keystore类型的钱包的后端实现。同时它也实现了keystore类型钱包的大多数功能。

• passphrase.go

passphrase.go中定义了keyStorePassphrase结构体及其方法。keyStorePassphrase结构体是对keyStore接口（在key.go文件中）的一种实现方式，它会要求调用者提供一个密码，从而使用aes加密算法加密私钥后，将加密数据写入文件中。

• plain.go

这个文件中的代码定义了keyStorePlain结构体及其方法。keyStorePlain与keyStorePassphrase类似，也是对keyStore接口的实现。不同的是，keyStorePlain直接将密码明文存储在文件中。目前这种方式已被标记弃用且整个以太坊项目中都没有调用这个文件里的函数的地方，确实谁也不想将自己的私钥明文存在本地磁盘上。

• wallet.go

wallet.go中定义了keystoreWallet结构体及其方法。keystoreWallet是keystore类型的钱包的实现，但其功能基本都是调用KeyStore对象实现的。

• watch.go

watch.go中定义了watcher结构体及其方法。watcher用来监控keystore目录下的文件，如果文件发生变化，则立即调用account_cache.go中的代码重新扫描账户信息。但watcher只在某些系统下有效，这是文件的build注释：// +build darwin,!ios freebsd linux,!arm64 netbsd solaris

6、usbwallet

这是一个子目录，此目录下的代码实现了对通过usb接入的硬件钱包的访问。

• hub.go

hub.go中定义了Hub结构体及其方法。Hub结构体实现了Backend接口，是usbwallet类型的钱包的后端实现。

• ledger.go

ledger.go中定义了ledgerDriver结构体及其方法。ledgerDriver结构体是driver接口的实现，它实现了与ledger类型的硬件钱包通信协议和代码。

• trezor.go

trezor.go中定义了trezorDriver结构体及其方法。与ledgerDriver类似，trezorDriver结构体也是driver接口的实现，它实现了与trezor类型的硬件钱包的通信协议和代码。

• wallet.go

wallet.go中定义了wallet结构体。wallet结构体实现了Wallet接口，是硬件钱包的具体实现。但它内部其实主要调用硬件钱包的driver实现相关功能。

7、scwallet

这个文件夹是关于不同account之间的互相安全通信（secure wallet），通过定义会话秘钥、二级秘钥来确保通话双方的信息真实、不被篡改、利用。 尤其是转账信息更不能被利用、被他人打开、和被篡改。

8、abi

ABI是Application Binary Interface的缩写，字面意思 应用二进制接口，可以通俗的理解为合约的接口说明。当合约被编译后，那么它的abi也就确定了。abi主要是处理智能合约与账户的交互。

mkdir ChainSkills
cd ChainSkills
mkdir private

2、进入private文件夹

cd private

3、ps：使用puppeth工具

D:\ChainSkills\private>puppeth
+-----------------------------------------------------------+
| Welcome to puppeth, your Ethereum private network manager |
|                                                           |
| This tool lets you create a new Ethereum network down to  |
| the genesis block, bootnodes, miners and ethstats servers |
| without the hassle that it would normally entail.         |
|                                                           |
| Puppeth uses SSH to dial in to remote servers, and builds |
| its network components out of Docker containers using the |
| docker-compose toolset.                                   |
+-----------------------------------------------------------+

Please specify a network name to administer (no spaces, hyphens or capital letters please)
> chainskills

Sweet, you can set this via --network=chainskills next time!

INFO [11-22|09:01:22.263] Administering Ethereum network           name=chainskills
WARN [11-22|09:01:22.298] No previous configurations found         path=.puppeth\chainskills

What would you like to do? (default = stats)
 1. Show network stats
 2. Configure new genesis
 3. Track new remote server
 4. Deploy network components
> 2

What would you like to do? (default = create)
 1. Create new genesis from scratch
 2. Import already existing genesis
> 1

Which consensus engine to use? (default = clique)
 1. Ethash - proof-of-work
 2. Clique - proof-of-authority
> 1

Which accounts should be pre-funded? (advisable at least one)
> 0x

Should the precompile-addresses (0x1 .. 0xff) be pre-funded with 1 wei? (advisable yes)
>

Specify your chain/network ID if you want an explicit one (default = random)
> 556677
INFO [11-22|09:01:54.950] Configured new genesis block

What would you like to do? (default = stats)
 1. Show network stats
 2. Manage existing genesis
 3. Track new remote server
 4. Deploy network components
> 2

 1. Modify existing configurations
 2. Export genesis configurations
 3. Remove genesis configuration
> 2

Which folder to save the genesis specs into? (default = current)
  Will create chainskills.json, chainskills-aleth.json, chainskills-harmony.json, chainskills-parity.json
>
INFO [11-22|09:02:10.370] Saved native genesis chain spec          path=chainskills.json
INFO [11-22|09:02:10.372] Saved genesis chain spec                 client=aleth path=chainskills-aleth.json
INFO [11-22|09:02:10.374] Saved genesis chain spec                 client=parity path=chainskills-parity.json
INFO [11-22|09:02:10.376] Saved genesis chain spec                 client=harmony path=chainskills-harmony.json

以上过程会创建这个创世块(genesis block)
5、初始化节点

geth --datadir . init .\chainskills.json

6、创建一个新账户

geth --datadir . account new

会弹出password,输入密码，会是隐形的，会弹出再次确认，得到address,记住这就是账户地址。
7、创建密码文件 password.sec，把你创建账户的密码放在里面。
8、设置主账户（跳过直接做下面一步）：

miner.setEtherbase(addr账户地址) 

9、对你的账户排序

geth --datadir . account list

10.进入编译器界面输入挖矿命令

粘贴如下命令:

geth    --networkid 556677   --cache=2048  --nodiscover --datadir "." --http  --http.api "eth,web3,debug,personal,net,miner" --http.corsdomain "*"  --http.port=8545  --http.addr="0.0.0.0"    --txpool.lifetime  1m   --allow-insecure-unlock   --unlock 0 --password password.sec    console

10、到编译器中打开chainskill文件夹，在private右键创建password.sec，输入第一个账户密码
11、再进入private夹中，开始挖矿（startnode.cmd文件需要自己新建，文件内容就是第10步的挖矿命令）

startnode.cmd
miner.start(1)

12.终止挖矿

miner.stop()
exit 或 ctrl + c

13、可另外打开一个界面，输入命令，另一个挖矿不能停

geth attach ipc:\\.\pipe\geth.ipc

14、在此界面中你可以查有多少账户

eth.accounts

15、查询正在挖矿的账户

eth.coinbase

16、查询账户正在挖矿的账户余额

eth.getBalance(eth.coinbase)

17、查询1账户余额

eth.getBalance(eth.accounts[1])

18、解锁账户

personal.unlockAccount("账户")

19、转账命令(先解锁）

eth.sendTransaction({from:"账户一",to:"账户二",value:web3.toWei(10,"ether")})

20、.换个挖矿账户

miner.setEtherbase("0xffb862171700e1e1954af94d0159a0b0bdd32bd2"); 

21、终止挖矿

miner.stop

22、开始挖矿

miner.start

1.  nvm是什么

nvm全英文也叫node.js version management，是一个nodejs的版本管理工具。nvm和n都是node.js版本管理工具，为了解决node.js各种版本存在不兼容现象可以通过它可以安装和切换不同版本的node.js。

2. nvm下载

https://github.com/coreybutler/nvm-windows/releases

3. nvm安装

https://blog.csdn.net/weixin_44582077/article/details/110237056

4. nvm命令提示

• nvm arch：显示node是运行在32位还是64位。
• nvm install <version> [arch] ：安装node， version是特定版本也可以是最新稳定版本latest。可选参数arch指定安装32位还是64位版本，默认是系统位数。可以添加--insecure绕过远程服务器的SSL。
• nvm list [available] ：显示已安装的列表。可选参数available，显示可安装的所有版本。list可简化为ls。
• nvm on ：开启node.js版本管理。
• nvm off ：关闭node.js版本管理。
• nvm proxy [url] ：设置下载代理。不加可选参数url，显示当前代理。将url设置为none则移除代理。
• nvm node_mirror [url] ：设置node镜像。默认是https://nodejs.org/dist/。如果不写url，则使用默认url。设置后可至安装目录settings.txt文件查看，也可直接在该文件操作。
• nvm npm_mirror [url] ：设置npm镜像。https://github.com/npm/cli/archive/。如果不写url，则使用默认url。设置后可至安装目录settings.txt文件查看，也可直接在该文件操作。
• nvm uninstall <version> ：卸载指定版本node。
• nvm use [version] [arch] ：使用制定版本node。可指定32/64位。
• nvm root [path] ：设置存储不同版本node的目录。如果未设置，默认使用当前目录。
• nvm version ：显示nvm版本。version可简化为v。

所需环境：
1、Linux 或 Windows Server（本章以Windows平台做部署目标，系统为Windows11）；
2、Java 1.8；
3、Tomcat 8/9；（二进制安装选8，源文件安装选9）
4、Maven 3.6；
5、MySQL（可以使用5或者8版本，最好使用5）；
6、MySQL Connector Jar（版本对应MySQL）；
7、default.sakai.porperties（后面提供下载地址）。

一、Sakai二进制文件环境配置

1、JDK环境配置

装 JDK 和 JRE，安装完成后添加环境变量 JAVA_HOME 为 JDK 安装路径，在系统 PATH 变量中添加 JDK 安装路径 /bin ，在 cmd 中测试 java -version 跳出版本信息即配置完毕。

JAVA_HOME：C:\Program Files\Java\jdk1.8.0_221\
Path：JAVA_HOME\bin
JRE_HOME:C:\Program Files\Java\jdk1.8.0_221

2、Tomcat环境配置

添加环境变量 CATALINA_HOME 为 Tomcat 文件夹路径，在系统 PATH 变量中添加 Tomcat 文件夹路径。然后进入其内的 bin 文件夹，执行 startup.bat ,启动Tomcat 服务器，在浏览器地址栏输入 http://localhost:8080 ，如果出现 tomcat的主页，则说明安装正确，执行shutdown.bat，即可退出。

CATALINA_HOME: C:\tomcat8

3、Maven环境配置

解压Maven并重命名文件夹为Maven，添加环境变量MAVEN_HOME为Maven文件夹路径，在系统PATH变量中添加MAVEN文件夹路径/bin，在cmd中测试mvn -version跳出版本信息即配置完毕。

4、MySQL环境配置

MySQL升降版本：

https://blog.csdn.net/qq_40262372/article/details/116803151

MySQL安装：

https://zhuanlan.zhihu.com/p/88271915

MySQL卸载一定要卸干净不然再下载会出错的！！！

解压MySQL并重命名文件夹为MySQL，添加环境变量MySQL_HOME为MySQL文件夹路径，在系统PATH变量中添加MySQL文件夹路径/bin。

在MySQL文件夹下建立my.ini配置文件，内容为如下（具体路径按实际情况更改，注意为斜杠）：

[mysqld]
basedir=C:/MySQL
datadir=C:/MySQL/data

从cmd中进入MySQL/bin（这一步有坑，如果不不进入bin文件夹进行配置，服务开启会提示找不到文件），键入命令mysqld --initialize，执行MySQL初始化操作，新版的MySQL会在data文件夹中生成一个err后缀的文件，初始密码就在文件中，老版本的没有root用户初始密码。初始化完毕后，使用mysqld --install mysql创建MySQL服务，然后使用net start mysql开启MySQL服务。

服务运行后，输入mysql -u root -p连接数据库，密码根据实际情况输入，如果顺利键入quit退出。

5、Sakai环境配置

将Sakai 20.0 Binary压缩包中所有内容直接解压至Tomcat目录下即可。

解压Maven并重命名文件夹为Maven，添加环境变量MAVEN_HOME为Maven文件夹路径，在系统PATH变量中添加MAVEN文件夹路径/bin，在cmd中测试mvn -version跳出版本信息即配置完毕。

二、部署搭建

1、将与 MySQL 版本对应的 MySQL Connector Jar 拷贝至 Tomcat/lib 目录下；

2、在Tomcat/bin文件夹下新建文件setenv.bat，内容如下：

set JAVA_OPTS=-server -Xmx1028m -XX:MaxMetaspaceSize=512m -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Djava.awt.headless=true -Dcom.sun.management.jmxremote -Dhttp.agent=Sakai -Djava.util.Arrays.useLegacyMergeSort=true -Dfile.encoding=UTF8

3、编辑 Tomcat/conf/content.xml 文件，在块中增加如下内容

<JarScanner>
    <!-- This is to speedup startup so that tomcat doesn't scan as much -->
    <JarScanFilter defaultPluggabilityScan="false" />
</JarScanner>

4、编辑 Tomcat/conf/server.xml 文件，搜索内容 “Connector port” ，在此之后增加 URIEncoding="UTF-8"，即

<Connector port="8080" URIEncoding="UTF-8" ...

5、在 Tomcat 路径下新建文件夹 Sakai ，下载一份 default.sakai.properties ，下载地址如下：https://sakaiproject.atlassian.net/wiki/spaces/DOC/pages/17310646929/Sakai+21+Install+Guide+Binary

将【default.sakai.properties】重命名为【sakai.properties】

搜索username@javax，取消默认的注释，将数据库的用户名与密码修改为如下（此处可根据实际情况修改）：

username@javax.sql.BaseDataSource=sakaiuser
password@javax.sql.BaseDataSource=sakaipassword

搜索MySQL，将注释符号全部去掉，修改后如下：

vendor@org.sakaiproject.db.api.SqlService=mysql
driverClassName@javax.sql.BaseDataSource=com.mysql.jdbc.Driver
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
url@javax.sql.BaseDataSource=jdbc:mysql://127.0.0.1:3306/sakaidatabase?useUnicode=true&characterEncoding=UTF-8
validationQuery@javax.sql.BaseDataSource=select 1 from DUAL
defaultTransactionIsolationString@javax.sql.BaseDataSource=TRANSACTION_READ_COMMITTED

此处注意！

Git上下载的文件连接地址可能是 mysql://127.0.0.1:3306/sakai 而不是 sakaidatabase，此处要根据下面步骤建立的数据库名确定连接地址，避免不必要的错误！

6、登陆 MySQL ，键入如下 SQL 命令：

//版本8（不推荐，会少三张表）
create database sakaidatabase default character set utf8
create user 'sakaiuser'@'localhost' identified by 'sakaipassword';
create user 'sakaiuser'@'127.0.0.1' identified by 'sakaipassword';
grant all on sakaidatabase .* to  'sakaiuser'@'127.0.0.1' WITH GRANT OPTION;
grant all on sakaidatabase .* to  'sakaiuser'@'localhost' WITH GRANT OPTION;
flush privileges;

//版本5
create database sakaidatabase default character set utf8;
grant all on sakaidatabase.* to sakaiuser@'localhost' identified by 'sakaipassword';
grant all on sakaidatabase.* to sakaiuser@'127.0.0.1' identified by 'sakaipassword';
flush privileges;

7、运行 Tomcat 目录下的 bin 子目录里的 startup.bat 启动 Sakai ，运行的时间可能是4-5分钟，然后等待启动完成后在浏览器的地址栏输入 http://localhost:8080/portal ，以用户admin密码admin登录进去。

三、Sakai源文件环境配置

1、JDK环境配置（同上）

2、Tomcat环境配置(同上，选择9的版本)

3、Maven环境配置（同上）

4、MySQL环境配置（同上）

5、安装git

https://blog.csdn.net/mukes/article/details/115693833  根据这个博主的文章一步步写就可以。

四、部署Sakai

1、将与 MySQL 版本对应的 MySQL Connector Jar 拷贝至 Tomcat/lib 目录下；

2、在Tomcat / bin文件夹下新建文件 setenv.bat ，内容如下：

set JAVA_OPTS=-server -Xmx1028m -XX:MaxMetaspaceSize=512m -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Djava.awt.headless=true -Dcom.sun.management.jmxremote -Dhttp.agent=Sakai -Djava.util.Arrays.useLegacyMergeSort=true -Dfile.encoding=UTF8

3、编辑 Tomcat / conf / content.xml 文件，在块中增加如下内容

<JarScanner>
    <!-- This is to speedup startup so that tomcat doesn't scan as much -->
    <JarScanFilter defaultPluggabilityScan="false" />
</JarScanner>

4、编辑 Tomcat / conf / server.xml 文件，搜索内容 “Connector port” ，在此之后增加 URIEncoding="UTF-8"，即

<Connector port="8080" URIEncoding="UTF-8" ...

5、在 Tomcat 路径下新建文件夹 Sakai ，下载一份 default.sakai.properties ，下载地址如下：https://sakaiproject.atlassian.net/wiki/spaces/DOC/pages/17310646929/Sakai+21+Install+Guide+Binary

将【default.sakai.properties】重命名为【sakai.properties】

搜索username@javax，取消默认的注释，将数据库的用户名与密码修改为如下（此处可根据实际情况修改）：

username@javax.sql.BaseDataSource=sakaiuser
password@javax.sql.BaseDataSource=sakaipassword

搜索MySQL，将注释符号全部去掉，修改后如下：

vendor@org.sakaiproject.db.api.SqlService=mysql
driverClassName@javax.sql.BaseDataSource=com.mysql.jdbc.Driver
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
url@javax.sql.BaseDataSource=jdbc:mysql://127.0.0.1:3306/sakaidatabase?useUnicode=true&characterEncoding=UTF-8
validationQuery@javax.sql.BaseDataSource=select 1 from DUAL
defaultTransactionIsolationString@javax.sql.BaseDataSource=TRANSACTION_READ_COMMITTED

此处注意！

Git上下载的文件连接地址可能是 mysql://127.0.0.1:3306/sakai 而不是 sakaidatabase，此处要根据下面步骤建立的数据库名确定连接地址，避免不必要的错误！

6、登陆 MySQL ，键入如下 SQL 命令：

//版本8（不推荐，会少三张表）
create database sakaidatabase default character set utf8
create user 'sakaiuser'@'localhost' identified by 'sakaipassword';
create user 'sakaiuser'@'127.0.0.1' identified by 'sakaipassword';
grant all on sakaidatabase .* to  'sakaiuser'@'127.0.0.1' WITH GRANT OPTION;
grant all on sakaidatabase .* to  'sakaiuser'@'localhost' WITH GRANT OPTION;
flush privileges;

//版本5
create database sakaidatabase default character set utf8;
grant all on sakaidatabase.* to sakaiuser@'localhost' identified by 'sakaipassword';
grant all on sakaidatabase.* to sakaiuser@'127.0.0.1' identified by 'sakaipassword';
flush privileges;

7、新建一个文件夹进入，下载Sakai源文件

git clone https://github.com/sakaiproject/sakai.git

8、打开编辑器（我这里选择的是IDEA），将 Sakai 部署到 tomcat 中，第一次的话速度会非常慢，需要耐心等待。

// mvn clean install sakai:deploy -Dmaven.tomcat.home=/path/to/your/tomcat

mvn clean install sakai:deploy -Dmaven.tomcat.home=D:\Programs\tomcat8

配置好 Java 及 maven 版本。

9、现在启动Tomcat，进入你的tomcat安装目录的bin目录下，打开cmd：

./startup.sh && tail -f ../logs/catalina.out

Sakai 启动后（通常需要大约 30 秒），打开浏览器并导航到http://localhost:8080/portal ，以用户admin密码admin登录进去。