• 《最近大半年的工作》2026-05-27
• 《为什么 DM KOL 的 GTM 策略一定是 “对” 的》2026-06-29
• 《做 Polymarket 项目踩的坑》2026-07-10

我会总结分析一下最近半年来，我们团队做项目遇到的种种困难。总的来说，现在项目仍然没有找到 PMF、没有达到用户自增长的状态。与以前的项目经历不同，我可以毫不掩饰地说这个项目的官网是：http://virae.ai/

在这个项目上，团队一直在以最少的人员配置 + 最低的硬件成本去做。这种低成本主要也是为了试错。至少我是这么理解的。

数据服务 VS 交易工具

一开始想要切入预测市场、做一个预测市场生态上的项目时，我们就看到了一个新闻，一个叫 Polycule 的 TG Bot 项目，算是 Polymarket 生态比较头部和知名的一个项目，因为服务器被黑客攻击、一度损失资金甚至传闻跑路，目前也已经改名换姓、整个产品换了方向。

当时忌惮这种托管私钥方面的安全问题，团队对于项目的约束是，不要做这种托管私钥类型的交易工具。

那么不做交易工具做什么呢？主要在这几个方向上徘徊：

1. Alerting 类型，比如市场动态方面的告警、仓位提醒等，典型项目是 Cryptocurrying Alerting、PolyAlertHub
2. DexScreener 类型，聚合不同预测市场（Polymarket、Predict.fun、Kalshi 等）的事件、并且提供相似事件的对比分析，典型项目是 DexScreener
3. Lookonchain 类型，分析挖掘链上数据、讲故事，典型项目是 Lookonchain

另外还有一个团队自己发掘出来的方向：预测市场事件的语义搜索。因为无论是从 news 文本-> 提醒，还是从链上数据-> 提醒，都绕不开一个关键环节：怎么精确找到自己想找的事件？我看到一个特朗普的新闻，但是并不知道与这条新闻相关的预测市场事件是哪个、去哪里下注。

然后我告诉你为什么这几个方向没做起来：

1. 语义搜索方面，做了官网、试着做推广但是没下文、没有人用。服务器方面的成本，大概需要索引40 GB 左右的市场数据到数据库，包括 embedding 数据等用于检索。
2. DexScreener 方面，不同的预测市场平台会刻意避开事件相同、结算规则相同，以避免跨平台套利的行为发生。这一点和 Crypto Dex 的逻辑是不一样的，同一个 Crypto Token 会尽可能去多个平台上流通，而预测市场的事件都在各自的平台上维护。
3. Lookonchain 数据挖掘方面，需要很强的讲故事能力。看到数据不是重点，重点是需要把信息关联起来讲故事，这一点既需要数据分析能力，也需要小编来写内容，而不是纯程序分析出来的信号可以做到的。
4. Alerting 服务方面，看似轻量级，但是需要高速且不限速的 API 接口，或者自己索引链上数据。而如果自己索引链上数据，就免不了需要自建节点或者自建 SubGraph。

我一开始提到我们在硬件投入上也是维持在低成本模式。有多低呢，现在整个 Virae 的后端服务器，一共用了 3 vCPU、6 GB 内存，100 GB 数据，在 AWS 上。

我并不是说这样的配置不够用，而是在这样的成本约束下，自建节点、自建 SubGraph 一类的服务自然是做不了的。举个直观的对比，运行一个以太坊节点的配置，是 8 vCPU、32 GB 内存、1 TB 磁盘、且要 IOPS 大于 10k 的固态硬盘。

信息聚合终端

这是在可以做交易工具之后、首先比较看好的方向，比如用户需要在 NBA 相关赛事下注，需要同时打开 NBA 比赛以及 Polymarket 的事件下注页面。我们能不能做一个交易终端，同时展示体育赛事的信息、以及聚合 Polymarket 的下注交易能力？

这个方向上有明确的竞品，包括 Crypto 领域的 GMGN、Axiom，预测市场领域的 Betmoar、Areas、stand.trade。

结果就是没有人用。

至于为什么没有人用，是我们一直都在反思但是不知道答案的问题。

顺便提一下，所有在 Polymarket 生态的项目，都在 Polymarket 的 Builder 榜单上。Polymarket 官方提供的榜单只有交易量总额，没有更多信息。因此我做了一个辅助网站 https://poly.dark20.xyz/ ，这些数据都是从 Polymarket 官方的公开接口拿到的，列出了每一个项目方的交易额、交易人数、甚至具体的每一笔交易的详情。由于交易接口方面的约束，同赛道的项目方一定都在这个榜单上，反之，不在这个榜单上的项目方一定不是 Polymarket 生态的项目。

Copy Trading Bot

在 Crypto 领域有很多 TG Bot，提供 snipe 代币的功能，或者很简便的贴一个代币的 CA 地址就可以开始交易。那么在预测市场是否需要一种 copy trading bot 来一键复制别人的交易行为呢？

比较头部的竞品很多，做的也都不错，除了之前提到的 Polycule、还有 PolyCop、Kreo、PolyBot 等。

结果也是没有人用。

至于为什么没有人用，能找到一些原因：

1. 如果要做到0区块延迟的跟单速度，需要自建节点、监听 mempool 里的交易、然后跟单。上文提到，自建节点需要一笔硬件成本的投入。
2. 马太效应，越是头部的 bot 越有人用，越是小的 bot 越没有人用。
3. 运营能力，我们没有人具备运营 X 账号、其他平台发广告推广的能力。

电脑端 VS 手机端

世界杯期间，项目准备了一些预算做活动，交易就给钱那种，来了不少来自印度的撸毛用户。当时有一个发现，大多数用户都是在手机上操作，要么在手机浏览器里打开网页，要么在 TG bot 里操作。很少有用电脑直接操作。

这一点和我们的预期有很大偏差，因为一直以来，都是在做专业的交易终端，而交易终端一定是电脑网页，也因此几乎没有刻意做什么移动端的适配。

再后来，又关注到一个用户数量很多的项目 polymtrade，是一个手机 App，在苹果商店能搜到那种。这个项目页面非常简陋、而且不支持高频交易，但是月活跃交易用户在1000以上、交易额在百万美元以上。我调查过，这个项目没有融资背景、只有 3 个开发者。

所以我们后来一方面优化移动端网页、另一方面适配了 TG Mini App，希望用户可以直接在 TG 上面打开 Mini App、就能拥有完整的体验。

结果也是依然没有人用。

高频交易 VS 低频交易

高频交易就是给专业交易员操作用的，比如现在下单后、看 K 线、发现几秒钟的动量、马上操作卖出，或者同时挂很多订单、止盈止损、频繁操作。这种就要求界面操作要流畅、下单速度要快、交易反馈要准确。与之相应的，技术难度高。

低频交易是指那些佛系散户，比如今天看到什么新闻、想去某个事件上下一单、明天想起来就又下一单、下单之后也不看 K 线也不看流动性、甚至不操作不卖出，就纯粹等半年后的结算。

这两种交易频率的不同，也是产品方向上的分歧。高频交易注定使用者专业、数量少、交易量大。低频交易也许用户量多、但是交易量会很少。

有研究报告指出，整个 Polymarket 有80%的散户交易总额在100美元以下。而且这是整个 Polymarket 生态的，其中 Polymarket 官网的交易人数和交易量占了90%左右，留给第三方项目方的交易量只有10%。（研究报告原文找不到了，大概是这个数字，你不相信的话可以让 AI 重新调研一次。）

这个数据如果靠谱的话，那么 Polymarket 生态的项目会过得比较惨。看起来预测市场的交易量和收入年年新高，但是跟第三方项目方有什么关系呢？

再做一个官网

随着项目功能越做越多，后来逐渐发现一个误区：再做一个官网。

当时正是世界杯，Polymarket 和 Kalshi 都出了 combo 交易的功能，我们就在看能不能从接口接入这种 combo 交易的能力。后来发现官方提供的 API 不支持。

这就导致一个尴尬的现象：专业的交易终端本应该是功能增强版本的 Polymarket，结果 Polymarket 出了新功能、第三方交易终端跟不上！

这也突然带来一个警醒：Polymarket 是中心化平台、不是去中心化协议！

CLOB v1 版本的时候也许还能看到一点去中心化的影子，自从 CLOB v2 之后，就实锤 Polymarket 是中心化平台了，毫无疑问。

也因此后来 Polymarket 出了 perps 交易的功能，我们根本不去看能不能接入了。接入了也没人用。

再后来，Kalshi 还出了官网版本的交易终端 Kalshi Pro，杀死比赛。

总之再做一个官网绝对是行不通的方向。

Agentic Trading

后来看 Agentic Trading 的方向比较火，很多交易所相继出了这方面的功能，我们也开始往自动交易、代理交易方向转型。转型的结果就是，目前平台上支持 BTC/ETH 的 15m/1h 市场的尾盘策略，可以配置参数一键启动。这个方向上目前看到最直接的竞品是 EVPLUS。

这里有一个考量在于，是做执行工具还是做策略？执行工具就是用户自己设定策略参数、我们只管执行；做策略就是我们找到稳健的策略或者策略参数、推荐给用户运行。对于用户来说，肯定是希望直接给策略，而对于项目方来说，因为考虑到策略风险，只能是做工具比较稳妥。

并且我诚实的告诉你，我们的项目也没有 edge；不但我们的项目没有，而且我可以负责任的告诉你，我们的竞品 EVPLUS 也没有，因为它的策略源码是公开的。

然后为了推广现在的这个 Auto Trade 功能，还开发了针对 Auto Trade 的 Paper Trading 账户和排行榜，希望做一场活动、让用户免费参与、最终 PNL 高的用户可以获得 100 USD 的奖励、培养用户习惯。

原本计划明天周一开始这个模拟盘交易大赛活动的，后来一个团队外部的成员，以命令式的语气、在没有经过团队讨论的情况下、就直接告诉运营人员推迟这个模拟盘交易大赛的活动。也因此我现在甚至不知道这个活动还搞不搞、什么时候开始。（你会不会没看懂，什么叫团队外的 “成员”？）

单一领域 VS 多领域聚合

事实证明经过了预测市场的大热点世界杯，我们在预测市场辅助工具这个方向上没有做起来。后来又开始考虑做更多领域的集成，比如前段时间看 Robinhood Chain 比较火，就集成了 Robinhood 的 Memecoins 交易。

再后来又看到 Robinhood Chain 上有一个叫 SLVR 的链上游戏很火、交易量很高，我就直接把他们公开的合约源码拿下来、自己开发前后端、直接出了一个类似的仿盘出来 VORE（只是演示，千万不要玩）。这个 VORE 是为了证明我们能做出和 SLVR 一样的链上游戏。同时也在考虑 SLVR 这种游戏的玩法有没有什么 Virae 能够借鉴的。

总之就是这个阶段已经不局限于预测市场，而是开始打 Memecoins 或者其他链上热点项目的主意了。

总结

为什么我现在可以做这样一个总结呢，因为你能看到，我们尝试了各种各样的产品方向，结果都不太尽人意。我作为开发者的角度，已经没有灵感下一步还能做什么了。因为很明显，不管做什么新功能，都不会有更多人来用，这已经不是开发层面的问题。

我其实之前反复跟团队说一个道理，如果 100 个用户进来了、用着不好用、功能有 bug、走了，那是产品或者开发的问题，我们就可以去优化产品、修复 bug、提高用户留存率。但事实上是，根本没有 100 个用户进来，连来都没有来。所以问题在哪里？

今天有一个 “重大” 发现想要分享：PySonar2 可以大幅度降低 AI 在执行 Python 项目修改的时候的 Token 消耗。

这是 ChatGPT 运行出来的 benchmark 结果：

补充一下这个 benchmark 任务的定义：

具体任务有 2 个：

概括来说，就是基于一个测试专用的大型 Python 项目，设定两个方向的任务，一个任务横跨多个目录和文件，另一个任务目标明确、不需要跨文件定义，然后分别用 skill 和不用 skill 执行。

结果如你所见，使用了 skill 之后，速度略微有提高，token 消耗量则直接减少 30%！

说明

说明一下，刚才提到的 skill，是指基于 PySonar2 源码封装的、符合 AI Skills 规范的 skill，你可以直接告诉 ChatGPT：

帮我安装这个 skill 到用户级目录：https://github.com/smallyunet/pysonar2

就可以了。

这个 PySonar2 的仓库是 fork 出来的，因为原版的 PySonar2 仓库是王垠 13 年前的项目，已经有一些工程和特性方面的 “过时”，所以做了一点点新的工程方面的包装。当然 PySonar2 最核心的词法分析、类型推断是没有过时的。

除了这个 AI skill，我还把 PySonar2 以 VS Code 插件的形式发布了，安装后可以在 VS Code 上打开 Python 代码之后，鼠标 hover 上去看到 PySonar2 的类型推断：

• 插件链接：PySonar2 Code Intelligence

思路

解释一下为什么 PySonar2 可以帮助 AI 节省。

如果你是程序员并且经常让 AI 写代码，一定会看到 AI 会使用大量的 rg，每一次任务都会把各种代码文件看一遍，然后继续执行代码修改。而 PySonar2 可以提供一种基于代码语义的、基于 AST 结构分析出来的这种内容：

{  "symbol": "User",  "definitions": [    {"file": "models.py", "startLine": 12}  ],  "references": [    {"file": "service.py", "startLine": 48},    {"file": "tests/test_service.py", "startLine": 31}  ],  "affectedFiles": [    "models.py",    "service.py",    "tests/test_service.py"  ]}

直接在一个文件里把每个变量定义的来龙去脉、相关源码文件总结出来。相当于本地建立了一个索引，AI 直接看索引，而不需要每次看一遍全部代码。

因为任何 AI 工具目前都有两方面限制：

1. 使用 AI 要花费 Token，Token 就是钱。省 Token 就是省钱
2. 所有基于 Transformer 架构的 AI 模型，都有上下文限制。这种建立索引的做法可以节省上下文空间

对比

那么 PySonar2 现在是否还具有某些独特的价值呢？答案是有：

很多同类型的、号称节省 Token 的项目，都是基于关键词匹配、甚至 embedding 的匹配，与 PySonar2 的语义分析不在一个层面。

不过毕竟已经过去了 13 年，PySonar2 已经 13 年没有在学术理论上继续更新，要说 PySonar2 仍然处于世界前沿是不可能的。但是 PySonar2 因为开源、代码轻量、逻辑清晰，在 Agent 适配方面也许会有独特的优势和潜力：

启发

1. Python 语言只是开始

既然针对 Python 项目，PySonar2 可以帮助 AI 节省大量的 Token 消耗，那么其他语言的项目呢？JavaScript 是否可以借鉴同样的思路？以及更多脚本语言？同样的思路，已经不局限于 PySonar2 这个工具了。

2. 帮助 AI 节省 Token

比起让 PySonar2 这个古老的项目重新发挥价值，我更在意的事情是：在 AI 时代，还有哪些代码工具是有价值的？

因为人已经不需要写代码了，甚至不需要看代码了。但是 PySonar2 在这个场景下发挥了巨大的作用，让我看到了不一样的希望：

1. 帮助 AI 节省 Token 是一个好的工具方向。

（与此同时，我还在优化另外一个项目：EchoEVM。基于 EchoEVM 的 EVM 解释器底座，让 AI 能够在编写 Solidity 脚本的时候、有能力看到脚本文件字节码级别的执行过程。这种 debug 工具对人类没什么用，但是对于 AI 极其有用，因为人类看不懂字节码、AI 可以）

2. 底层原理在 AI 时代不会过时。

PySonar2 作为拥有学术级别原理的工具，在人类已经不需要写代码的今天，仍然能够发挥价值、让 AI 节省 Token、给使用者省钱，这是真正意义上的效率工具。

相关阅读

如果你不了解 PySonar2 的背景，分享几篇相关文章可以看一下：

• 《PySonar 的第二个用户》
• 《PySonar2 开源了》
• 《PySonar2 与 Sourcegraph 集成完毕》
• 《PySonar 的工作原理》

更新（2026.08.09）

要补充说明的是，原文中对于节省 40% 的 Token 消耗，仅限于某些特定的、大量跨文件、变量名重叠、语义不清晰的任务。经过后来更丰富的测试，最新的 benchmark 结果 显示，很多通用任务中，如果强制使用 Pysonar2，消耗的 Token 和时长反而是增加的。不过由于 PySonar2 提供的精准语义分析能力，在 benchmark 中使用了 PySonar2 的准确率能达到 100%，给 AI 提供语义级别的事实证据是 Pysonar2 目前对于 AI 最明确的增强。

至于 “先给代码建立语义索引、修改代码直接使用索引” 的方式是否能够提交效率、节省 Token，我后来创建了单独的项目 code-engram 来进一步测试。目前 code-engram 主要支持 TypeScript 以及适配了 Pysonar2，唯一正向的 benchmark 数据是，在大型项目的 rename 任务中，Token 消耗节省 60%。但是对于小型项目或者其他通用任务，Token 消耗反而是增加的。这一点和 Pysonar2 单个仓库的结果类似。所以 code-engram 这个项目也仍然在继续探索中……

1. 建一个比特币矿场需要 3000万美元
2. 建一个 AI 算力中心需要 5亿美元

在 bitcointalk 上看到一个帖子：How to handle weak scripts?

这个帖子说明了一种 Taproot 脚本的漏洞，无需经过签名验证，任何人都可以花费在这个 UTXO 上的余额。在 mempool 浏览器的界面上可以清晰看到，这笔 f460...5bc2 交易转出的一方有一个 unsigned 的标识，这个标识在比特币网络上并不多见：

帖子中描述的 Taproot 脚本的逻辑是这样，这也是 f460...5bc2 交易真实执行的脚本过程：

OP_PUSHBYTES_32 fa9b5ec193f735c41b804fc6ace1d28e81a299fc815c0f5009dd2dd7d0293c3bOP_CHECKSIGOP_IFOP_PUSHBYTES_32 ff1275b635cd160914cfe1bc516f521abde0fc8ae3fd92ae01ca16449e4758e9OP_ENDIF

可以简化为：

<pubkey A>OP_CHECKSIGOP_IF    <pubkey B>OP_ENDIF

比特币的 Taproot 是基于栈结构的脚本，理解起来需要绕弯，把这个脚本翻译为 JavaScript 代码的话，大概是这个意思：

function isTrue(...params){  var pubkeyA = params[-1];  params--;  if (checkSign(pubkeyA))  {    return true;  }  else  {    //  }  return params[-1];}

从代码来看，在正常使用流程下，假如输入的参数是 [pubkeyA]，那么 checkSign(pubkeyA) 为 true，最终 return true，这个是合理的。

假如输入的参数是 [pubkeyC]，那么 checkSign(pubkeyA) 为 false，下面的 else 分支什么都不做，最终 return null，依然不是 true，这个也合理。

这个脚本的漏洞在哪里呢，在于 params 是一个数组，用户未必只输入一个参数。

在漏洞逻辑下，可以输入非预期的参数组合 [true, pubkeyC]，那么按照后面的执行流程，当进入 else 分支什么都不做之后，return params[0] 会把 true 给返回出来。

这里面存在几个基础的问题：

1. 代码没有处理 else 分支
2. 比特币的 Taproot 脚本没有类型检查（只有操作码）
3. 脚本作者没有正确理解 Taproot 脚本的写法，忽略了 witness 可以提交任意数量的参数

分析

所以很简单，这个所谓的脚本漏洞，实际上是作者自己写了不严谨的代码导致的。要注意这里指的不是比特币的作者，仅仅只是比特币的用户。比特币的 Taproot 相当于以太坊的智能合约，任何人都可以写一些脚本规则，来决定钱怎么控制、怎么花。只不过比特币的脚本写起来复杂，而且不是图灵完备，所以很多人忽略了比特币可以自己写脚本这件事情。

很明显这不是一个比特币协议级别的漏洞，比特币的共识只负责按照脚本规则正确执行，而脚本逻辑是否有漏洞，跟协议无关。

而且事实上无论是比特币钱包还是比特币生态的项目，如果依赖于 Taproot 的脚本逻辑，一定会经过审计公司来审核代码，这种低级错误出现在主网上的情况恐怕会非常少。

另外 Taproot 这种脚本设计的隐私性其实很强，我们只能知道比特币地址 bc1p 开头是 Taproot 脚本，0xc0 开头的是当前版本号，但是一个 UTXO 在没有被花费之前，网络上是无法看到脚本具体内容的。而在被花费的那一刻，大概率全部的钱都已经被转走了。一个 P2TR UTXO 被创建的时候，链上只保存这棵树结构的根节点哈希，任何可以解锁 root 的路径都是有效输入，这些有效输入只有在花费的时候，链上才需要根据具体的 leaf 和 key path 去验证。而且即使某一个 leaf 被公开，链上也只能看到其中一个，看不到同一个 root 下的其他 leaf。

比特币从设计之初，就提倡每一笔转账都使用一个新的地址，实际上大多数靠谱的钱包也是这么设计的，这本身就很大程度规避了漏洞脚本被再次利用的风险。

所以无论是从技术上和商业逻辑上，这种漏洞脚本的出现都是极其小概率的个例，完全就是脚本作者自己写错了。主网上存在漏洞脚本的可能性很小。

调查

示例地址

有没有可能网路上真的存在这种漏洞脚本，不需要验证签名就可以把钱转走的？

先从 bc1p...cn8z 这个例子入手，有几个问题：

1. 假如这个地址上还有钱，要怎么转出？

这显然不是钱包 App 提供的功能，而且比特币的交易比较麻烦，得把 UTXO 来源的交易和编号都作为参数才能构造出交易。这是一个示例脚本 taproot-script-path-demo.mjs，可以这样来运行：

TXID='0618d93bc4eef77f4b47c4b4b188011f95c7ccb929e6226df2774b88b5d4693d'VOUT='0'INPUT_SATS='15000'DESTINATION='bc1px6jn77jd4tplp94q46svkuutc53wtn24dk34wxp4dfur6tvez89swvlcmj'FEE_SATS='1000'node outputs/taproot-script-path-demo.mjs \  "$TXID" \  "$VOUT" \  "$INPUT_SATS" \  "$DESTINATION" \  "$FEE_SATS"

如果你不小心把钱打到了地址 bc1p...cn8z 上，就可以用这个脚本，在没有私钥的情况下，把钱转出来。但是要小心脚本里的 xOnlyKey 和 payload 都是硬编码，如果换一个目标地址，这两个值就不一样了，得用另外的值。那么这个值应该是什么呢？这个值只有在 P2TR 被花费过之后才能知道。

这也就意味着，即使我们知道链上某一个地址有余额、脚本有漏洞，因为不知道整个树结构、拿不到 xOnlyKey 和 payload 的值，我们也无法动这个地址上的钱。从这个角度看，比特币上的资产安全程度还是很高的。

2. 有没有可能这个作者把钱转给了某一个有同样漏洞的 P2TR，但是忘了转出？

同样有一个示例脚本来干这个事情：audit-taproot-neighborhood.mjs，结果就是，没有。这个作者把全部关联地址的钱都转走了，不存在这种低级漏洞。

扫描全网

这个程序可以扫描整个比特币网络上类似的脚本漏洞：tapscript_weak_finder

扫描逻辑是这样：

1. 逐个区块扫描每一笔交易，判断是不是 Taproot Script 且 version 为 0xc0
2. 这个程序里实现了一个非常轻量的解释器，用来处理 witness 参数
3. 会分别用 3 种参数策略来测试脚本是否可以不需要签名也能通过
4. 直接用 [01, <empty signatrue>] 的排列组合，处理 0 个参数、1 个参数、2 个参数的情况，一共 12 种
5. 把 atom 从 01, <empty signatrue>，扩展到小整数和一些常量，比如 02, 03, true, false 等
6. 对于已经公开执行过的 witness 参数比如 [[data, sigA, sigB]]，尝试变换组合，比如 [data, "", sigB]、[data, sigA, ""] 等
7. 如果程序发现了不需要签名的脚本、一定返回 OP_SUCCESS80的脚本，或者目前规范还没有定义的公钥类型，会记录到数据库

扫描结果

当然我会告诉你运行结果。如果你运行了这个开源程序，会得到和我一样的结果和结论。我的启动参数是从区块高度 709632 开始，这是比特币主网启用 Taproot 的高度，到 959701 高度结束，也就是最新的区块高度。

一共扫描了 71037 个区块，扫描了 127119410 笔交易，扫描到 1000061 个 Taproot 地址，其中 427378 个属于当前程序没识别出问题的脚本，12 是有可能有漏洞的弱脚本。

在 12 个有可能有漏洞的脚本中，8 个属于不需要签名的弱脚本，1 个属于始终返回 OP_SUCCESS80 的非漏洞脚本，3 个属于包含扫描程序解释器不支持操作码的非漏洞脚本。

结果分析

来逐个分析一下扫描到的有可能是 weak script 的交易。最终输出的、未经加工的结果数据在这个文件：result_report.json，可以还原出我下面提到的地址和交易、脚本。

1

首先扫描到的这个 taproot 地址出现在 758737 区块：bc1p...2354

这个地址出现了 2 笔异常交易：

• 00c1...c40e
• 73be...2a7e

先说结论，这 2 笔交易是非常专业的开发者在演示比特币主网的 BIP342 规范而发起的。

第一笔交易 00c1...c40e 包含 2 个 witness 参数，是用来测试交易的。

第二笔交易 73be...2a7e 就离谱了，包含 500001 个 witness 参数，OP_RETURN 的内容解码后得到 “you’ll run cln. and you’ll be happy.” 的文本。

TapScript 的规定是，初始栈最多只能有 1000 个元素，但是第二笔交易出现了 500001 个元素而且交易成功了，是因为 BIP342 规范定义，如果脚本中出现 OP_SUCCESSx，则无论脚本包含多少元素，一律视作成功。因为 OP_SUCCESSx 属于目前还未明确支持、但是预留给未来有可能使用的操作码，所以 BIP342 这样来规定了。

很明显第二笔交易就是用来演示这种状况的。也因为这笔交易包含大量参数，花费了超过 700 美元的手续费。

2

其次扫描到的地址出现在 771740 区块；

• bc1p...648w
• bc1p...u69a
• bc1p...n6cl

这 3 个脚本对应的交易包含了 OP_CHECKSEQUENCEVERIFY 操作码，扫描程序没有处理这个操作码，所以认为是异常给挑出来了。OP_CHECKSEQUENCEVERIFY 操作码的含义是，必须等待多少个区块，才可以使用地址里的资金。属于是典型的 TimeLock 脚本。

3

在区块高度 775722，扫描到了这个地址：bc1p...amq6

这是一个真正有逻辑漏洞的脚本，不需要任何签名就可以转移资金。这个脚本明显是一个 Ordinals 数据结构的封装，可能是某个开发者在尝试自己开发类似 Ordinals 的协议。当然这个地址上的钱当时就被全部转走了，现在没有余额。

另外还有几个地址，数量不多，大多数是 Ordinals 的测试交易，就不一一详细解释了：

• bc1p...3hu0，区块高度 777335，一个 Ordinals PNG 图片
• bc1p...xgdr，区块高度 777617，一个加法运算，没有校验签名
• bc1p...gq7d，区块高度 777681，一个测试脚本，固定返回 true
• bc1p...9x3t，一个 Ordinals 的 Hello World 脚本
• …

结论

已经扫描了从 Taproot 脚本功能上线到至今为止全部的区块和交易，真的出现了少量 How to handle weak scripts? 中描述的类似的脚本漏洞，不过那些地址上都已经没有余额了。

这件事情另外的启发：

1. 比特币网络是否存在更复杂类型的脚本漏洞？
2. 以太坊的脚本漏洞是否可以用类似的手段扫描？

一开始为什么会用呢，因为看到以太坊的团队在用，以太坊发布 weekly news 以及那个 ops panda 团队内部沟通都在用。

但是今天我发现 hackmd.io 会擅自取消我 publish 公开的文章、以及擅自删除我的文件内容：

这已经不单纯是平台内容审核的问题了。内容审核你可以不 public 我的文章，但是擅自给我内容删了、在 version history 里看到的是我自己清空了内容，这算怎么回事？

所以比起 hackmd.io 比起来，还不如直接用 github 的 wiki 或者 gist。

这样的描述真的太主观、太模糊了，作为技术人员根本无从下手。至少得说一下在什么设备上、访问哪个页面、网络状态如何、具体哪个组件、卡顿的现象是样式错位还是加载延迟或者别的什么。

这不是在对非技术人员提过分的要求。你可以这么想，去大街上随便拉一个人过来，没有读过书、没有文化、没有学历、没有工作、没有职场经验、没有收入，随便一个人，是不是都能说得出 “太卡了” 这三个字？而作为一个混迹于职场、身处 web3 行业的资深牛马，竟然说出了是个人都能说出的话？你和 anybody 的区别在哪里？

最大的风险是很危险。

这种伞很容易坏，第一次用是公司发的一个定制款，第二次用是买的小米挂牌的雨伞。

结果小米的反而更不耐用，两三天就坏了。

我怀疑坏掉最大的原因是我拎着那个挂绳一直甩着转圈。

但是这不重要，你肯定说轻拿轻放就不行了吗。

但是说明这种伞从设计之初就没有考虑好各种情况。

而且在伞坏掉的那一刻，大概率是你解开绳子、伞会自动弹出来的一刻。这一刻毫无疑问会打伤你自己的手指。更加严重的话，会弹开伤到你对面的人，或者路人。

所以以后，应该只用非自动的雨伞，也就是以前那种手动打开手动关闭的雨伞。

不要过于相信自动化。

• 以前的评价

王垠的计算机科学课程，对我来说不只是一门普通的编程课，更像是一套关于编程和计算机科学的核心训练。

我过去虽然有多年工程经验，也做过不少区块链相关的技术工作，但这些知识和经验一直是零散的。我可以把事情做出来，可以写出能运行的代码，却缺少一套完整的体系，不知道自己掌握的知识处在什么位置，也不知道真正扎实的计算机基础是什么样子。

这门课程像是一张完整的地图，把我过去散落在工作和学习中的经验重新组织起来。很多以前模糊理解、但说不清楚的东西，在课程中变得清晰。它让我看到，真正的编程不只是掌握语法、框架和工程技巧，而是理解递归、抽象、数据结构、程序求值和计算模型背后的思想。

课程最重要的价值，也不只是教会了某些具体知识，而是让我见识到了高水平的计算机课程应该是什么样子。课程内容高度精炼、层层递进，用很少的编程要素表达了非常丰富的思想。通过练习，我也第一次真正感受到，“代码能够运行”和“代码真正写对、写得简洁优雅”之间存在很大的差距。

学完课程以后，我对自己的技术能力有了新的认识。我不再因为没有接受过系统的计算机教育而感到不安，也不再担心自己因为做了某种具体工作，就偏离了程序员的道路。只要掌握了这些核心的计算思维，无论以后使用什么语言、进入什么技术方向，都仍然拥有继续学习和前进的基础。

它像一颗定心丸，也像一次迟到的系统教育。它没有替代我过去多年的工作经验，而是在恰当的时候，把这些经验真正整理和“生产”了出来。

• 现在的评价

接近一年后再回头看，王垠的计算机科学课程仍然是一门质量很高的课程，但我对它的价值有了更清楚、更克制的认识。

这门课最大的优势，在于内容高度精炼、体系完整，能够抓住编程和计算思维中的关键问题。很多单独的知识点，在其他教材、课程和工程实践中也能接触到，但王垠把这些内容组织成了一条连贯的学习路径，让学习者能够看到主干，知道不同概念之间的联系，而不是在大量语言、框架和技术细节中零散摸索。

对于初学者来说，它可以提前提供一张地图，减少很多不必要的弯路。对于已经有工程经验的程序员来说，它更像一次经验整理：很多能力本来就会在长期工作中逐渐形成，只是通常比较零散、缺少名称，也没有清晰的整体结构。课程的作用，是把这些经验组织起来，让人看清自己已经走过哪些路，还缺少哪些部分。

对我个人而言，它最重要的价值，是帮助我补足了对计算机基础的长期不安，建立了信心，也让我真正见识过一套高水平、成体系的课程是什么样子。它没有直接改变我的工作方式，没有直接解决职业、产品和收入问题，也没有像我刚学完时想象的那样，成为一种能够解释所有技术问题的核心心法。

在 AI 已经可以完成大量编码工作的时代，课程中的很多具体训练，未必会直接转化为日常生产力。程序员越来越不需要亲手完成大量局部代码，但仍然需要理解程序背后的状态、抽象、语义和执行过程。课程在这方面仍然有价值，只是它的价值更接近基础教育和思维训练，而不是直接服务于工作的职业技能培训。

所以现在再评价这门课，我会说：它是一门很好的课，一张很好的地图，也是一次对我很重要的学习经历。它没有改变一切，但它帮助我结束了对自己“没有系统基础、算不上真正程序员”的长期怀疑。

• ChatGPT 的总结

两版最明显的差别是：以前强调它给了你一种“核心力量”，现在强调它帮你建立了“地图与尺度”。

但是我也不清楚为什么。他们大概率比我有钱、有人气、有影响力、有人“求”、过得好，但我依然觉得自己内心对他们充满鄙夷。

从实习到工作之后，在一家非常平庸的公司。也许很多人五年、十年都不会走出来，他们会一直工作下去、拿个一万多的工资、养家糊口。回头看去，整个公司都在做着低效、低产的工作。

就像中学时候心心念念想着的白月光，经过很多年后再回头看去，你会发现她只不过是极其普通的，生活在县城里甚至农村里的普通姑娘，她会早早嫁人、相夫教子。你曾经以为的爱情，其实只是你自己的期待，即使爱情真的存在，也不会以你想象的方式存在。

身处其中的时候，没有人救你，你很难发现自己在水中。

后来，我真正间接见识到了 “有钱人”，但同时又浪费了点时间。当你自身能力不够的时候，不要指望着项目带你起飞。你就是项目本身。也不要想着赚轻松的钱，轻松的钱首先有尽头，其次轻松就意味着有人在替你扛着，这种“替”大多是无意的。

再然后，我加入并退出了一个有背景的项目。我总觉得和那里的人格格不入。我感谢那个项目带给我的成长，但是也不想再做一次那样的工作。当然真正的原因还是，我身处其中，非常明白项目的前景。

梅开二度的是，接下来几个月，我再一次加入并退出了一个糟糕的项目。那次已经不只是项目前景的问题，而是项目成员的人品恶劣、连混个工资都呆不下去。

连续两次主动离开、每一次都需要接近3个月没有收入、找工作的日子。

职业连续性上、收入的积累上，都不算成功。只是经历的多了之后，增加了不少带有戾气的垃圾项目的辨别能力。这种判断力会让收入增加、项目成功吗？不会的，只是避坑而已。

也因此我也很羡慕那种运气好的人，也许他们一开始就有足够的辨别能力，或者运气好到不需要辨别。

然后再看这个 feed 列表，这么多年过去，忽然发现，真正能复利的东西，包括认知和技术，都很少。尤其是现在 AI 更强大之后。

从博客来看，最大的问题没能建立统一的人设。我没能坚持学习多种编程语言、没能持续走在区块链底层开发的职业道路上。

但是这种话题分散的背后是有原因的，我在不断否定以前的东西。学习很多编程语言没前途、做合约开发没前途、做底层开发离钱远、找不到工作，这些都是是真实的客观因素。顺便问一句，2 年前叫嚣着自己是链上科学家、智能合约开发的人，现在还好吗？

所以严格来说，我现在遇到的失败，不是过程上的失败，是结果上的失败。

不过现实的残酷之处在于，你失败了，你浪费了，你能怎么着呢。

现在做 Crypto 方向的项目，一般会选择 Privy.io 或 Turnkey 来作为钱包的基础设施提供商。这些钱包设施提供了注册登录方面的集成，可以用传统方式邮箱、Google 登录，也可以用 web3 一点的方式，比如 MetaMask 钱包或者 OKX 钱包登录。更重要的是这些钱包设施解决了钱包安全的问题，允许给用户创建 embedded wallet，如果不使用这些钱包服务，项目方需要自己在服务器上保存用户的私钥，这是很危险的，尤其是对于中小团队来说，安全问题是很沉重的负担。Privy 或者 Turnkey 的解决方案是，私钥由他们来保管，储存在 TEE 一类的加密硬件中，项目方只需要通过 API 来访问和使用钱包。

至于 Privy 还是 Turnkey 的取舍问题，比如我们经常在看的 Kreo、PolyCop、polymtrade 等项目都在用 Privy。这些项目列表都在 Polymarket Builder 榜单 上。Polymarket 的这个 Builder 榜单上，列出了每一个 Polymarket 生态的项目方交易量排名。GMGN 也用的 Privy。

用 Turnkey 的项目也有，比如 Axiom、alchemy 等。我们当时用了 Turnkey。一开始是因为 Turnkey 从定位上对自动化运行的 Trading Bot 更加友善，Privy 定位上有很重的对前端界面 SDK 的依赖。后来又发现了一个 Privy 和 Turnkey 比较大的区别：是否支持 Telegram 注册登录。

Privy 支持 TG 登录，Turnkey 不支持，为什么呢？

因为 TG 没有像 Google 那样成熟的 OAuth 体系，TG 账号本身无法像 email 或者 wallet 一样给 Privy/Turnkey 一个 identity provider。Privy 针对这种场景做了简化，你用 TG 登录，登录后 Privy 代替你去通过 API 请求钱包的操作，实际上此时 Privy 后端 “就是你”，假如 Privy 后端的服务器被黑了，你的钱包权限会完全暴露在黑客手里。而 Turnkey 比较生硬，无法提供 identity provider，就不能让你操作钱包，Turnkey 的后端不愿意代替用户承担这种权限风险。

所以这是我们发现的 Privy 和 Turnkey 之间比较大的场景支持程度上的差异。如果想要用 Turnkey 并且支持 TG 登录，就得专门做一个 TG Miniapp，登录的时候唤起 Miniapp 来完成。

CLOB V2 集成

Polymarket 上的订单系统叫 CLOB，下单等行为都是在和 CLOB API 交互。4月28日，Polymarket 正式启用 CLOB V2。对于我们这种下游项目来说，最大的变动是需要换掉一些合约地址信息，比如 Copy Trading 功能需要扫描链上交易，以前监听的是 V1 版本的合约，迁移后监听的是 V2 版本的合约。此外如果下游不适配也是可以的，因为大体上兼容旧版本的订单参数。

而 CLOB V2 也引入了 FAK、FOK 等 Market Order 在使用的参数，这些参数直到一个多月以后我才发现它们的差异。因为在 V1 版本订单如果没有立即成交，会把没成交的部分自动挂单为 Limit Order，但同时又要求 Limit Order 的 shares 数量必须大于 5。所以用户有时会遇到一个奇怪的错误，为什么订单 shares 数量必须最小是 5？又为什么有时候会提醒最小订单金额是 1 美元？为什么有时候能成功有时候失败了，最小金额不是固定的？用上 FAK 参数的话倒是没有这种旧的问题了。

Safe Wallet -> Deposit Wallet

5月4日，Polymarket 发公告说启用新的 Deposit Wallet，不再使用旧版本的 Safe wallet。这是一个 breaking change，所有旧的用户依然兼容，但是新的尤其是通过 api 操作的钱包，都将使用新的 Deposit Wallet，也就是说下游项目必须兼容。

这个时间点非常微妙，因为我们原本计划项目 Beta 版本上线的日期是 5月5日。也因此当时连续两三天我紧赶慢赶去适配这个 Deposit Wallet 的迁移。这本身不是一件特别难的事情，但是由于突然升级带来的措手不及，以及上线的 delay，还是有一点点压力。

至于集成过程中遇到的唯一挫折，是 Polymarket 的 Migration 文档里没有写新的 Deposit Wallet Implementation 地址。在用 Factory 合约创建钱包的时候，需要一个 implement 合约作为参数，不同的 implement 合约出来的钱包地址是完全不一样的。而重点不只是我们用哪个地址，而是 Polymarket 的 Relayer api 用哪个，因为在新的这种 Deposit Wallet 模式下，所有的钱包操作都会通过官方的 Relayer api 了。以前用的 Safe wallet，其实我们可以自己直接去链上调合约的。Polymarket 的这个改动，反而让钱包体系更加不那么去中心化。至于正确的 implement 的值，则是需要直接从 Polymarket 发布的 SDK 里去读。而且当时还遇到个小坑就是 Polymarket 发布的不同 SDK 之间用的 implement 地址还不一样。不是同一个 SDK 不同版本，而是那种不同 SDK，比如 client-sdk, server-sdk 这种。当时 Discord 群里遇到这个集成问题的开发者非常多。

Relayer API

刚才提到新的 Deposit Wallet 必须要通过 Polymarket 官方的 Relayer API。我们在迁移后并且项目上线一段时间、做活动，紧接着就遇到了另一个坑：Unverified 状态的 Builder API 只有每天 100次的请求额度。

看出 Polymarket 的阴险之处了吧，先是要求所有新用户都用 Deposit Wallet，而新的 Deposit Wallet 自然必须通过 Relayer API 来操作钱包，再然后你会发现，Relayer API 的请求是有额度限制的！如果是原本的 Safe wallet 可以直接链上操作绕过 Polymarket 的 API 额度限制。现在不行了。

这个 Relayer API，每次创建新的钱包都要用、每一次从钱包里 withdraw 钱要用，所以这是一个高频率会用到的接口。

针对这个限制的缓兵之计是，Polymarket 默认用 Builder API 来对 Relayer API 授权，但是 Relayer API 却没有要求 Builder API 具体是哪一个。所以我注册了 10个账号、每一个账号都创建了 builder api，配置到服务器里，用来暂时缓解 relayer api 的额度限制问题。每个账号每天100次请求额度，也就意味着 10 个账号一天有 1000 次额度。因为 verified 从提交到审核需要两到四周的时间，是一个很长的周期。

当然最终还是通过了 Verified，现在我们的项目已经出现在 Polymarket Builder 榜单上，并且状态是 Verified。

Deposit Wallet 升级

7月6日，又是 Deposit Wallet 的问题。我们发现了一个很严重的 bug，自从 7月1日以来注册的全部用户，创建钱包都失败了！而因为用户反馈少，出问题很多天我们才发现这个问题。也就是说，新注册的用户，注册完之后如果充值，会把钱充值到错误的地址上。

为什么会出现这个 bug 呢，因为 7月1日，Polymarket 直接修改了创建钱包的逻辑，用上了 beacon 的方式去创建代理钱包，而且连公告都没发，直接改变 API 接口的行为。这种改动，是需要下游项目方主动适配的。

我们也有错误，我们的错误之处就在于没能及时发现这种异常，并且在程序前后端加上足够的保护性、防御措施。针对这次事故所有用户充值钱到错误地址的，全部金额都赔了，好在金额不大。

Combos

Polymarket 针对世界杯的市场，新出了一个叫 combos 的功能。我们就开始评估是否可以接入这个 combos 的功能。结果就是，从 combos 文档 上看，API 只提供了针对做市商提交 quote 的接口，没有提供作为普通用户作为 taker 角色去下单的接口。

Polymarket 从 6月4日开始运作 combos 的接口，看起来也是在辛苦 build 中。

tick size

7月10日，用户反馈遇到了订单交易失败的问题。经过排查后发现是订单的 tick size 有了变化，所有的世界杯市场都支持 0.0025 (0.25¢) 级别精度的 tick size。在此之前 tick size 只有固定 4 种，这个 0.25¢ 属于第 5 种（枚举类型）。

同样的，这个变动其实 Polymarket 早在 7月2日就上线了，但是我们直到 7月10日才发现 bug。

总结

所以你看到了，一直以来，我们都在不断的追随 Polymarket 的脚步，一直不断的响应 Polymarket 的功能更新和变化。

也因此，在构建项目的过程中，我们也开始逐渐意识到这样的项目误区：再做一个官网。

如果定位是 “再做一个官网”，项目方就会陷入非常被动的处境。而且 Polymarket 家大业大，官网 UI 做的也好，有功能都是第一时间上官网，再者官网自家的服务器，下单速度也快。我们的订单速度再快也不可能快过 Polymarket 官网。

这是一件尴尬的事情，如果想要做的比官网使用体验好，客观上难度是很高的。Polymarket 不是 memecoins，一般 memecoins 没有官网至少不会有官方钱包、官方 DEX，但是 Polymarket 有官网、有官方解决方案。Polymarket Builder 的定位，从来都不是说，Polymarket 是一个开放的去中心化协议，大家都来建设项目去玩。

与之相反，Polymarket 最近的功能更新上也越来越往中心化的方向走，定位更像是中心化交易所，比如 Binance 这种，Polymarket API，就是 Binance API。做 Polymarket 生态的项目，就有点像是做 Binance 的 Trading Bot 一类事情。

本质就是我什么都不需要懂，我看到一个人有钱，我想直接跟着对方赚钱，抄近路、走近道、抄作业。

假如 Copy Trading 真的能赚钱，有几个人靠这个赚到钱的？

有几个人靠抄作业抄成学霸的？

我来直接给 Copy Trading 定性：

1. Copy Trading 赚不到钱
2. Copy Trading 的动机本质上是骨子里的懒惰，世界从来不会给懒惰的人超预期的奖励

具体做法是直接在 X 上找到相关领域的 KOL，然后跟对方聊天、套近乎、问需求、谈合作。

这个策略能够达到的目的是（转述）：

1. 最差的结果，是把产品介绍发给了对方，对方看到了、知道有这么个产品，不回复
2. 稍微好一点的结果是，对方有回复，并且体验了产品，并且还给出了对产品的意见，这个属于很大的收获
3. 最好的结果是，对方不但体验了产品，还对产品表达认可，愿意和项目方合作，把产品推荐给他的粉丝，以及通过返佣的方式长期合作

这个策略是 BD 给出的、在他的理解中最为可行的、用户转化率、留存率最高的方案。

说实话我没有 GTM 的经验，所以我也在不断反思，这个策略好不好、对不对、为什么专业的有经验的 BD 唯一认可的是这个策略。当然我早就想明白了结论，只是现在把这个结论写出来。我来跟你解释一下为什么。

我的结论是：这个策略一定是对的，但未必是有结果的。

学习的例子

很简单的道理，如果一个学生问老师，怎么提高学习成绩？老师会说，课前预习、上课好好听讲做笔记、课后认真完成作业、有不会的题要请教同学和老师。这一套学习方面的方法论，亘古不变。

但是很明显，我们都知道，同一个班级、同样的老师、同样的课本、同样的作业，学生的成绩就是天差地别。

为什么呢，因为策略方向是对的，但是具体到执行上每个学生都不一样，每个人的行为差异会被放大。

所以只要策略方向足够大、足够宽泛，策略就一定 “正确”。只是正确未必有用，因为策略需要具体的人来执行，而每一个人都是有差异的，只要不能机械化到代码程序可以重复执行，结果就肯定有差异。

也因此，你学习成绩不好不能怪老师吧？怎么有的学生人家就是成绩好呢？老师讲的东西都一样，你不能说老师讲的道理不对吧？

投资的例子

李笑来在 2022 年之后就不再做投资了，专职做家庭教育、写书、卖课、讲课。我喜欢李笑来的《财富自由之路》和《韭菜的自我修养》两本书，现在也时不时留意李笑来的新书和课程。

他最近几年的观点，非常明显有一个共同点，就是非常 “基础”、非常 “简单”，简单到像跟 6 岁小孩子讲道理一样，比如我们跟孩子说要诚实、勇敢、善良等，李笑来讲的观点，也都类似这种，比如 “生产是财富的来源”、“要学会复利”、“知识是可以迁移的、只要有时间就学习”、“自我暗示非常有力量” 等等。

他讲的这些内容，感觉都简单到 “是个人知道”，他讲的每一点，简单到 “每一个普通人都可以做到”。

然而事实上，世界上只有一个李笑来，真正财富自由的只有李笑来。他的课程并没能把那些 “真理” 一样的道理教给别人、让别人变得富有。

我也经常反思这个问题，为什么呢，为什么李笑来这样经历丰富的人，最终总结出的各种道理，反而异常朴实、基础、简单？我相信他不是刻意隐瞒，而是真心实意相信自己的那套东西。

所以现在直接能串联起来了。就跟学生问老师成绩怎么变好一样。很多人问李笑来，怎么变有钱，怎么变富有？然后李笑来告诉你，要坚持，要努力，要学习，要产出，要……

明白这里面的漏洞了吗？策略方向一定对，具体执行因人而异。还是那句话，只要策略方向足够大、足够宽泛，策略就一定 “正确”。

DM KOL 的例子

回到 DM KOL 这个策略，我来拆解两个问题：

1. 策略范围是不是很大？

很大。从一开始转述的、期望达到的 3 个效果来看，其实包含了市场调研、功能反馈、寻找合作 3 种目的。对于大公司来说这可能是 3 件事情，只是小团队就直接聚合为一件事情、全都放在 “DM KOL” 这句话里了。

只看这几个词可能不够直观，具体来说，我们期望问 KOL：

1. 你觉得 PM 有哪些不好用的地方？
2. 你觉得我们的产品是否好用、有什么建议？
3. 是否愿意跟我们合作、推荐并拿返佣？

当然前提是对方愿意回信息。因为实际上大多数 KOL 不会回消息，或者上来就报价。而这个 DM KOL 策略的重点，实际上在于建立关系、跟人搭讪，先建立联系、然后表述出目的。

从这个描述能听出问题所在不。这就全部依赖于个人的社交能力了，而且是通过网络打字社交。BD 也跟我们说，要持续骚扰对方到骂你为止。

2. 实际执行效果怎么样？

也很差。不过我要分享的，是我们团队面对的最大问题，以及为什么效果不好：因为执行成本高。

很多交易所，长期招聘 BD、而且 BD 没有无责底薪、说开除就开除，随便去任何一个招聘群，都能看到类似的吐槽。

很多项目方，在小红书上招聘实习生，一个月 3000块人民币，实习生就愿意辛辛苦苦任劳任怨干一个月，天天在 X 上刷流量、发广告。

而 DM KOL 的策略，属于周期长、反馈慢的策略，可能 DM 1000 个 KOL，其中能有 10 个给出反馈、有 1 个能达成合作。这还得是你花心思认真跟对方接触的情况下。

如果对这个过程没有实际感受，可以回想一下找工作的过程。比如我找工作的频率就很高，深刻理解这种状态。在找工作的时候，可能联系几百个 HR，然后面试几十家公司，最终找到一份合适的工作。

对于 BD 或者销售人员来说，DM KOL 就是他们的工作呀，他们不但能用整天的时间来干这件事情，而且有足够的时间去思考、总结相关的经验。

至于我所在的团队，所有成员中，目测时间成本没有比我低的。每个人都戴着 “金手铐”。毕竟不是专业的 BD 人员，也都有自己职业方向的事情需要做，能够用于 DM 的时间很少，更重要的是，DM 是一件反馈周期长、不确定性很高的事情。花一整天的时间去 DM，可能都什么反馈都不会得到。而在自己熟悉的道路上，总是能有一些结果的。

所以让成员兼职去 DM KOL 这件事情，如果想要得到可观的结果，难度不亚于先让成员做一次职业转型，然后再统一做长时间刻苦的执行后，才能有结果。

如果不那样，要么有人能认真把这件事情做好，要么什么都做不好。我个人是不相信，有人能顺带做一件事情，不用心也不总结，就能比专业的人做出更好的效果。

毕竟哪怕是专业的 BD 团队，同样完全正确的策略下，10 个 BD 成员里得到的结果想必也天差地别，有的人被开除了，有的人成为金牌员工了。这种事情谁说得准呢。

总结

所以你应该看出来了，我写这些的目的并不是在吐槽，而是在分析和分享。

重要的是我明白了一个道理：为什么看起来正确的策略，却得不到好的结果？

不知道我讲清楚了吗？

看到这个产品后有感而发。

对于这个产品本身，怎么理解这个事情呢，我觉得可以这样理解：

首先看板工具是指类似 Jira、Linear、GitHub Project、Notion 这些知名的项目管理工具。

然后先不说 AI，就说人，假如就是一些真实的人、真实的员工、真实的技术团队。有能力通过任务面板把技术团队管理明白的 leader，包括任务怎么分配、任务时长、任务难度的定义、结果怎么验收等等。对于能处理好任务、把项目进度安排的井井有条的 leader，这个 AI Agent 看板工具才有意义。

也就是说，对于已经具备能力管理好 “人” 的 leader 型人，他才需要把员工换成 AI，然后在看板工具上给 AI 分配任务这种产品。

AI 相对于人类，有优点也有弱点。优点就是效率高，你给它明确的任务，它能执行的很好。但是 AI 的弱点在于，不需要主动汇报工作、没有情绪，也不需要承担责任。如果 AI 把你的数据库删了，或者强硬汇报错误的内容、或者突然降智听不懂人话了，你能拿他怎么办呢？骂它？扣它工资？给它讲道理、画大饼让它内疚？

所以当你作为一个能管理好员工或者下属的 leader，试图通过 AI 降本增效的时候，这个 AI Agent 看板工具才能发挥作用。而与此同时，这个 leader 也得好好掂量一下能不能用好 AI。

下一个问题，AI 能提高效率是显而易见的，但是 AI 真的能降低成本吗？用 Codex 日常写代码一天三四个小时，需要开每个月 100 美元的套餐。如果更高强度使用，大概一天六七个小时运行时长的话，每个月 200 美元的套餐是必需的。

同时考虑到 Codex 有周限额和日限额，200 美元的套餐跑满肯定不够，算作一个 AI Agent 300 美元吧。然后看板工具的意义当然在于，多个 Agent 同时运行。如果只需要一个，在 Codex 里用就行，没有必要看板。

那么按照小型技术团队 3 个人的规模来算，AI Agent 的费用算作一个月 1000 美元吧。

也就是说，原本也许 1 leader + 2 senior + 1 junior 配置的技术团队，可以精简为 1 leader + 2 Codex + 1 Antigravity。要只算订阅费的话，是不是真的节省了不少成本？

不过还要考虑一个小问题，人类队伍中 leader 不需要独自承担责任，只需要验收就行。但是在 Agent 的配置形式下，leader 必然是更忙更累的，因为需要 review 所有 AI 的工作结果、手动打字（甚至不能语音和会议）来同步给 AI 工作任务、需要把任务边界和规则定义的非常清楚。相信做过技术的话就会理解，看似用 AI 代替了大量人力，但同时极大增加了 leader 的负荷。这种推演方式下 leader 一定是忙不过来的。

所以可以退一步，改为 2 leader + 2 Codex + 2 Antigravity 的模式，也就是 (1 leader + 1 Codex + 1 Antigravity)*2 的模式。这样的话 leader（或者工程师）的工作负荷勉强合理、工作任务能够合理完成。这种模式下，成本变成了多少呢？

继续下一个问题，刚才的讨论一直有一个前提，就是这个 leader 本身有能力管理好 “人”，在此基础上去使用 AI。那么如果本身这个 leader（工程师）不具备管理人类的能力呢？

结合之前提到的 AI 的弱点，那么工作一定是一团糟糕的，毫无疑问。难道我们或者你，在过往的工作经历中没有遇到过管理能力糟糕的 leader 吗？设想他们管理一堆不需要承担责任的 AI Agent，真的能让工作或者项目完成的更好吗？

总的来说，项目的任务看板工具实际上不是技术问题而是管理问题。有能力用好看板的人没那么需要 AI，没有能力用好看板的人也用不好 AI。

那么喝了无糖可乐 -> 你的肚子以为吃了高热量食物 -> 开始分泌很多消化液 -> 肚子饿的更快了 -> 下一顿报复性饮食；

喝了无糖可乐 -> 你的肾脏以为身体含糖量会增加 -> 开始分泌胰岛素 -> 发现事实上没有热量提升 -> 长此以往发现被骗 -> 下次真的吃了高热量食物也不分泌胰岛素了 -> 导致糖尿病。

所以不要再和无糖可乐。

去年只做过 1 个月的钱包开发，但恰好就负责这种交易记录的解析。

为什么呢，经历了币圈的洗礼，已经不信了。炒币的人已经反复在说，不要开合约、不要加杠杆、不要炒山寨、不要频繁换仓……

除此之外，看不到更加清晰的有逻辑的路径，什么链上科学家、安全审计、交易员、BD。

也因此我之前换工作的频率很高，基本上一年一次。每当离开一个项目，我都深刻的知道，那个项目一定不行了、一定做起不来、一定会持续走下坡路。

当然，我看不到任何除了“打工”（参与项目、合作）之外能赚钱的方式。

当然我还是坚持一贯的偏见：不用 Claude Code 的工具和模型。因为 Claude Code 的模型太过听话，出现路灯效应的现象比较严重。

由此联想到的问题是，自从有了 AI，我们开始关心的话题变成了：

1. 哪个 AI 模型好用
2. 哪个 AI 套餐便宜
3. 哪个 AI 工具好用、prompt 工程做得好

而 AI 出现以前，我们关心的问题是：

1. 哪种编程语言好用
2. 哪种编程语言编译速度快、写起来简单、心智负担小、运行时错误可控
3. 哪种 IDE 好用

在 AI 出现以前，有个人站出来说：

1. 编程语言是不重要的，编程思想才重要
2. 编程语言的语法是不重要的，从本质上理解语义才重要
3. 我教给你们学会所有编程语言的方法
4. 我的工作不是去评价现有的垃圾语言，而是去设计最先进、优雅的编程语言
5. ……

那么 AI 出现以后，会不会有个人站出来说：

1. AI 模型是不重要的，重要的是使用 AI 的人
2. 好的程序员应该懂得如何驾驭各种 AI 模型
3. 理解 AI 模型的能力只是表面，要深刻理解 AI 模型的训练方法、“智力”的来源才重要
4. 我教给你们理解所有 AI 模型的方法
5. 我的工作不是评价现有的垃圾模型，而是设计最高效、最先进的 AI 模型
6. ……

会不会有这样的人出现呢？🐶

其实我有一个更深层次的焦虑：

AI 时代，我们曾经学的那些编程语言、原理，都是手工艺时代的知识和技能，是不是已经过期、过时、不重要了？你可以说它本质上重要，但是事实上确实 AI 抹平了大多数程序员的能力。

或者我换个问题，AI 时代，理解 Lambda 演算还重要吗？把图灵放到现代，他肯定不会写代码，调 API 的能力和普通程序员用 AI 写出来的差不了多少。你觉得这个观点能带来什么启发？

前几年关于工作内容方面的回顾：

• 2025 年：《最近一年的工作回顾》
• 2024 年：《最近半年的工作》
• 2023 年：《半年的工作回顾》
• 2022 年：《一年的工作回顾》

一个 friend.tech 仿盘项目

大概开发了两个月，MVP 功能基本完成，公开内测之后运营效果比较差，就直接搁置了。我承担包括合约开发、后端逻辑开发、前端界面开发。

这个项目在产品形态上做成了 friend.tech + 分答（知乎）+ NGL 模式的混合体。

项目的核心逻辑是，creator 为主体，可以创建 card（key），card 的价格可以被炒作。其他人可以向 creator 提问问题，creator 回答问题的时候，可以选择公开或者不公开。对于不公开的回答，其他人可以花费 1 USD 来解锁答案。同时，creator 接受匿名提问（NGL 模式）。

还有一些运营方面的功能，可以根据 X 账号给别人创建 card、一键把 X 账号的信息同步到网站上之类。

一个内部的加密货币交易和控盘工具

开发了大概两个月，核心逻辑基本可用，虽然还有 bug。我承担包括后端和前端逻辑的开发。

这个 Trading Bot 的核心功能包括：批量生成钱包、从 Binance、BitMart、MEXC 批量提现、集成了 Aerodrome 和 Uniswap 交易、支持 V2 和 Slipstream 交易池，功能模块上可以一键导入代币、管理交易对、管理 project，支持一键批量 warm up 钱包的交易、在某一个价格范围内的 range trading 交易。有 K 线图、一键 simulation 交易数据、根据 simulation 数据创建 task、交易结果 analysis 等。还有余额情况的 snapshot、trends 图、gas fee 图等。还有对某一个代币持仓情况分布的监控、对某一个地址行为的监控等。

一个预测市场的 TG 小程序

两周时间出 MVP，当时在考虑做预测市场周边的项目，但是不确定做什么，所以这个小程序类似一个 Polymarket 平台的 paper trading 游戏，只是比交易更简单，在 PM 已经结束的 markets 中，单纯选择 yes 和 no，然后和真实的事件结果对比。用户有积分榜、连胜榜等统计。

一个预测市场的 Dex Screener

可能做了不到一个月，说实话做的很糟糕。项目本意是做预测事件的跨平台对比，我们索引了 DefiLlama 上排名靠前的六七个预测市场的数据，包括 Polymarket、Kalshi、Limitless Exchange 等，然后试图把数据整合为一种事件数据对比的工具界面。

但是遇到不少问题，这种预测市场本质上是中心化的交易平台，对标 Binance、OKX 这种交易所，而不是去中心化的数据。预测市场基本上都是链下撮合、链上交易的模式，所以索引数据本身就是个问题，很大程序上受到平台方 API 的 rate limit 限制。

其次是数据分析比较重，哪怕通过 Subgraph 之类索引到全部的数据，也需要稍微高配的数据库和硬件做分析，需要不小的硬件成本。

最后是盈利模式的问题，除非数据分析的非常好非常准，然后以订阅制也就是 BaaS 的运作模式收费，否则普通用户看到了跨平台的数据、甚至看到套利机会，然后呢，去对应的平台交易了。所以这个方向比较吃力不讨好。

一个预测市场语义搜索入口

做了可能不到半个月。基于做 Screener 索引到的大量数据，就发现市场上存在一个缺口，就是把新闻一类的信息，和真实的预测市场的交易盘之间，如何关联起来？

所以我们做的事情是把预测市场摘要文本生成 embedding 数据存起来，用户可以输入任意文本，无论是长文本还是短文本，然后返回与搜索文本相匹配的 markets 数据，包括 Polymarket、Kalshi 等。

这个功能的本意是，假如用户看到一个突发新闻，想要去 Polymarket 上下注，但是又不知道有哪些可以下注的 markets。

一个预测市场的交易终端

这是现在仍然在进行的项目，已经开发了三四个月，参考了 Polymarket Builder 榜单上的主流项目，现在 Web Terminal 和 TG Copy Trading 两个方向在同时推进。

这个项目主要就是通过预测市场平台的 API 进行套壳交易，已经支持了 Polymarket 和 Predict.fun 两个平台，也支持了针对 Polymarket 交易的 Copy Trading。当然也在试图集成一些概念，比如 AI 分析、AI Skills、托管自动交易等。

工作之外

现在，AI Coding 已经成为事实上在发生的事情，会带来深刻的变革。关于程序员的身份认同、价值体现、差异性来源等问题，我发现两句有意思的话，并且附带来源：

Computer science can be probably called applied logic because it originated from logicians.

来源：《Ground-Up Computer Science 》第 3 章

Programming is just another name for the lost art of thinking.

来源：《Ground-Up Computer Science 》第 7 章

电影里真正的女主是谢南枝，最感人的故事也是谢南枝的行为。

从常理来推断，谢南枝的行为是不符合逻辑的。木生确实救了谢南枝父女的命，但是木生死了，南枝终生未嫁，十八年供养着两个家庭。行为有点过于崇高，如果解读为为了报恩，显然是不合理的。

我对于谢南枝的理解是，谢南枝羡慕淑柔，羡慕淑柔有一个木生这样，有爱有情义的老公。所以谢南枝在救赎淑柔的同时，也就是在救赎自己。谢南枝把自己投射到了淑柔身上，盼望有一个远在他乡的爱自己的丈夫。为了营造这个梦，同时也是怜悯自己，谢南枝才做出了这样“感人”的行动。

电影的故事很复杂，人的情感也很复杂，电影剧情平平，但是打动人。

美股能不能涨呢？能涨，虽然所有的股票都是中心化的，但是完全适合用于投资，因为有监管，有审核。英伟达、苹果、谷歌、特斯拉。

从投资者的视角，硅谷已经不从二级市场割韭菜了，从 1.5 级市场就开始割。OpenAI 和 Anthropic 万亿美元级别的估值，一旦上了二级市场，就等着小韭菜们接盘，价格会逐渐跌。但是人家融资，你有钱也投不进去。真正顶级的公司，一级市场都没机会。而不那么顶级的公司，几个 VC 互相割。不管能不能 IPO 割小韭菜，VC 的钱是割到了。

人们买加密货币是为了什么？是为了高倍的涨幅，想从中挣钱。币圈没有信仰，要有信仰也都是信仰钱。金融市场都是为了钱。没有人是为了去中心化的信仰和理想买比特币的。

回到比特币的初衷，比特币想干什么来着？比特币想要抗通胀。现代政府和金融体系要依靠负债表的不断扩张，来维持社会运转，也就意味着法币从趋势上是持续增发的。

比特币有供应量上限，正是为了应对通胀。所以 ETH 等所有没有供应量上限的公链，哪怕代币供应量是动态条件之后通缩的，也达不到抗通胀的目的。

2008 年，全球的法币总供应量大概 21 万亿美元，因此比特币的总供应量设计为 2100 万。按照当时的愿景，当比特币能代替全球的法币职能的那一天到来，一个 BTC 的价格应该等于（当时的） 100 万美元。

这不是巧合，比特币的精度是 8 位小数点，最小单位是 sat，那么如果 1 BTC = 100 万美元，恰好 1 sat = 1 美分，美元的最小单位就是比特币的最小单位。

2009 年，密码学家 Hal Finney 成为历史上第一个接受比特币转账的人，收到了来自中本聪 10 BTC 的转账。

2009 年，全球的家庭总财富体量大概在 100 万亿到 300 万亿之间。按照这个财富价值估算，如果比特币在全球的资产储备中占据主导地位，一个 BTC 的价格将约等于（当时的） 1000 万美元。

2027 年，全球货币总供应量大概 70 万亿美元，全球家庭财富总量大概 530 万亿美元。映射到比特币上，如果按照 M1 供应量计算，每个 BTC 的价值等于 333 万美元。如果按照财富总量计算，每个 BTC 的价值等于 2650 万美元。

这就是比特币的特殊之处，比特币不是为了创造下一个百万富翁，而是为了保护全世界人的资产不受到损失。BTC 的价格不应该再大幅暴涨，而是应该稳定逐步随着法币的增发而价值上涨。

从抗通胀的逻辑，比特币和黄金在同一个赛道，山寨币和美股在同一个赛道。

所以结论是：

1. 定投 BTC、PAXG
2. Alpha 机会你自己随缘，ETH、Nvidia 等，Do Your Own Research
3. 争取一级市场机会，投资、工作、创业，你自己想办法

两个负面规则：

1. 不要指望一个素不相识的人发个币让你买，就能带你起飞
2. 炒币、炒股造就的富翁很少，大多数是做了什么事情、参与了什么项目、有什么实体企业。只要还在牌桌上，就没有赢家

2024 年，我从 __ 离职，当时对接工作的人，似乎对撸毛很感兴趣。我当时的观点是，“撸毛都是不可持续的，所以不要做”。

这个观点的原因有两个，一个是当时我对自己的定位，在于开发者，所以你会觉得 OP 的开发者去撸毛吗？当然不会，他们只会内部等待 Token 的解锁。再一个原因是，撸毛党确实收入不稳定，三年不开张，开张吃三年，但是没有人能确定三年能开张一次。

后来 2025 年熊市，Polymarket 是唯一出圈、大火的方向。

交易所为什么挣钱呢，因为交易所挣的根本不是手续费，是爆仓的客损。在推特，你花 20 美元，就是尊贵的会员，免广告、能编辑长文信息什么的。在各种服务平台，只要你一个月花 20 美元，你都是权限非常高的会员。

但是币安不是，在币安你可能从来没有感觉自己花了手续费，但是一爆仓就是几千、几万。你给平台贡献的金钱，远超订阅费、会员费。所以交易所，是真正的灰产，但是还不够黑。

Polymarket，是真正意义的赌场，手续费根本不重要，重要的是事件必然会结算。一旦结算，就意味着有一半的人会爆仓、被清算。

相应的，有一些人开始研究、琢磨所谓的交易策略，想要抢占系统的漏洞、在结算时机前买入赚点利差之类。这些策略类型的赚钱方式，总结起来就是大概率有可能能挣钱，但是存在可能亏钱，一旦亏钱，挣得钱就都得赔进去。

这个和币圈的撸毛，道理是一样的。只要你在牌桌上，只要你不下桌，就不可能一直赢下去。

所以我从来不相信预测市场的交易策略，哪怕现在能挣钱，哪怕今年能挣钱，除非一次性挣够了财富自由的钱，或者挣一次钱之后永远离开牌桌。否则这些钱都不是你的，早晚还要亏进去。

这个等同于交易货币中的合约交易，尤其是加杠杆的交易。预测市场，也就是个赌博版本的合约交易。

自从工作以来，工作上的一些小钱比如打车、吃饭、个别网络上的开销之类，从来都懒得填工单、去申请报销。为了那么点小钱刻意报销，太无聊了，不值得操作，很俗。

想跳槽就跳槽，为了工资忍受垃圾工作、垃圾同事，被每个月挣那点钱拿捏，唯唯诺诺，就是俗。

代码里出现中文，就是俗。

为了结婚找对象、百般讨好女性，实际上是一种价值交换的思路，就是俗。

平凡市井、人间百态，都是俗。

Gavin Wood 当年在设计 EVM 的时候，会面临两个问题：基于栈还是基于寄存器？显然实际上的 EVM 是基于栈的，也许是出于上线迭代等外部因素影响，也许是出于 Gavin 当时的历史局限性。后来 Gavin 离开了以太坊、创建了 Polkadot 之后，一开始把 Polkadot 的虚拟机设计为 基于 WASM 虚拟机，最近又转向了基于 RISC-V 指令集的、用于实现通用计算的虚拟机。也就是说，Gavin 抛弃了基于栈的 EVM 的老路，最终转向寄存器结构的 RISC-V。

EVM 底层是 256 位的无符号数字，每一条指令、每一个数据，都会拆解为 256 位的数字来表示。至于为什么是 256 位，可能因为以太坊是从比特币演变来的，而哈希算法 Keccak-256 和签名算法 secp256k1 等都沿用了比特币的设计，它们的输出都是 256 位，为了无缝适配这些加密算法，就采用了 256 位的字长。

我们平时使用的电脑 CPU，大都是 64 位的。CPU 经历过 32 位的时代，但是由于在地址寻址的方式下，32 位最多表示 2^32 Byte = 4 GB 的内存大小，已经跟不上使用需求，所以现在的 CPU 已经都是 64 位的。

这里有两个数字，EVM 是 256 位的，CPU 是 64 位的。这也就意味着，每一个 EVM 的指令操作，到了 CPU 上都至少需要 10 个指令来完成，模拟一个栈内存、计算低位、计算高位、把结果推回栈等，这一套动作下来，256 位的 EVM 指令在执行效率上，比使用 64 位 CPU 指令，慢大概 10 倍到 100 倍。

RISC-V 是一个精简的指令集架构标准，包含有 64 位的 RISC-V 虚拟机指令标准。这就意味着，通过 JIT 编译，RISC-V 的指令几乎可以 1:1 映射到现代 64 位的 CPU 上，执行效率接近于 CPU 本身的效率。

Arbitrum 有过一次叫 Stylus 的 版本升级，内容是用运行于 WASM 的虚拟机性能与 EVM 虚拟机的性能进行对比，官方的宣传口径是，一个简单的加法 ADD 运算，在 WASM 上的 Gas 消耗比在 EVM 上少 150 倍，而这 150 倍就是指令集转换带来的额外开销。WASM 的性能比 RISC-V 差，因为 WASM 从设计之初是在浏览器环境运行一个多编程语言的虚拟机，所以合理推测，基于 RISC-V 的指令，性能上也要好过 EVM 至少 100 倍。

从指令执行的效率方面来看，RISC-V 绝对要好过 EVM 太多。

另一方面，RISC-V 非常适合做通用计算，比如 cartesi 这个项目，相当于直接在每一个链上节点本地，运行一个小型的 Linux 系统，这个系统内能运行的，就不只是智能合约，而可以包括各种各样进程级别的程序，这能释放很大的想象空间。

很多 zkVM 也都是基于 RISC-V 在做，毕竟要给一个 256 位的虚拟机以及各种复杂的指令集开发 ZK 电路，心智负担太大了，而 RISC-V 是一个精简指令集，只有比较底层的指令，比 zkEVM 实现起来要更加容易并且通用。

至于 EVM 方面，也有在性能方面做出卓越突破的链比如 Monad，实现了真正的并行 EVM。只不过 Monad 提高性能的方式并不是从比较底层的指令集层面去做，而是乐观执行、有冲突再回滚的方式，以及实现了专用的数据库而不是通用的 KV 数据库来提高磁盘 IO 效率，整体结合下来，让 EVM 的执行速度有了显著提升。

那么至此可以看到的是，基于 RISC-V 指令集的虚拟机、智能合约语言，有着种种性能上的优点。

是不是意味着 RISC-V 是替代 EVM 的最佳趋势呢？显然也不是。

生态方面的护城河当然很重要，RISC-V 属于彻底抛弃了 EVM 体系、自成一套，支持各种编译型的编程语言。那也就意味着，包括开发者和审计公司，在 EVM 上踩过的坑，需要推倒重来。这是谁都不愿意看到的事情。EVM 的简单带来了性能上的劣势，也让安全风险和执行逻辑上的排查更加可控，因为是栈结构，Solidity 语言里连指针操作都没有，确定性非常高。而 RISC-V 的寄存器模式，合约的 ABI 不再是字节码而是 ecall ABI，里面涉及到内存分配、有堆内存、有垃圾回收，复杂度非常高。

而为了解决确定性的问题，一般的做法是在 RISC-V 支持的编程语言上，再阉割一层，用一个沙盒环境来执行合约逻辑，并且禁用一些语言特性，从沙盒外部能够看到一个确定性的结果。这当然就会牵扯到，每一个项目都在定义自己的沙盒标准，没有业界统一的方案。

再就是很多项目方宣传口径上的问题，放大了 RISC-V 的性能优势，刻意在忽略 RISC-V 模式带来的冯诺伊曼税的问题。在 EVM 上，修改余额就是一个 SSTORE 指令，EVM 天然知道什么是账户、什么是余额，要去数据库的什么位置寻找数据。而 RISC-V 过于通用，如果要修改余额，可能需要先分配内存、处理语言运行时的边界检查、写入数据、释放内存等，虽然单个指令的执行效率高了，但是反而在业务逻辑上消耗了更多的 CPU 周期。

总的来说，RISC-V 虚拟机还无法代替 EVM 虚拟机。

我为什么没有朋友呢，我离开了小小的村子，初中去了稍微大一点的村子，高中去了县城，大学去了省会城市，毕业后工作去了首都。

每一个小小的人生阶段，都在全面抛弃以前的人际关系。

那么为什么进入新的环境就没办法再保持联系了呢？哪怕线上。

有什么可联系的呢。学历、背景、工作、生活完全不一样。

假如我幼儿园认识的人，都能够一路成长起来，现在也生活在这里呢。

……倒也是，曾经也有我小时候认识的人，可是中间几年不见，已经也相去甚远了。

假如我出生在这里呢。我的幼儿园同学，小学、初中、高中、大学同学都在这里，现在会是什么样的场景。

我可以随时见到他们，也可以跟他们聚会、见面、娱乐、甚至讨论工作、项目机会。

我并不遗憾自己现在没有朋友，也不期待我的旧同伴们混的不好。只是确实离得太远了。

问题背景

我们先来理解一下为什么 ED 这样的设计会存在。Vitalik 要说代码和工程水平可能远不及他拥有的名气，Gavin Wood 是以太坊的实际开发者。Gavin 因为实际设计了以太坊的节点，所以很清楚以太坊存在状态数据会无限膨胀的问题。

以太坊节点会把整条链上所有有过交易记录的地址信息，都维护到世界状态中，用的是一种叫 MPT 的树结构，每个地址信息都是树上的一个叶子节点。那么就存在一个问题，我们平时使用以太坊钱包也会有体会，如果地址里有 0.00001 ETH 的余额，这种非常小额的余额，是永远无法被转出的，因为以太坊对于普通转账交易，固定要求 21000 Gas，无论 Gas Price 多低，以太坊账户的余额都不可能彻底清零。这种非常小的余额被称为粉尘余额，对于强迫症来说会是一种灾难。

对于以太坊节点来说，这些地址以及余额，就不仅只是视觉上强迫症的问题，而是意味着，节点需要维护的状态数据，永远都会只增加、不减少。每多一个新的地址有余额，服务器上的节点就需要多储存一份地址的键值对信息，哪怕对内存的占用量很小，也会持续累积和增加，给服务器持续带来压力。这种设计在工程上是很暴力、不负责也不合理的。

针对粉尘余额，存在两个问题，我们分别来对比：

1. 用户视角的粉尘余额是否可以消除、让余额彻底清零
2. 节点视角的粉尘余额是否会持续给服务器增加压力

用户视角

比特币是如何解决粉尘余额问题的？假如有一个 UTXO 地址里的余额非常小只有 1 sats，那么自己发起转账肯定是不行的，因为 1 sats 不够付矿工费。但是比特币的交易允许有多个 input，只要把小额的 UTXO 作为其中一个 input，再让其他有大额余额的 UTXO 作为另外的 input 来支付矿工费，整笔交易就可以成功，拥有 1 sats 的 UTXO 余额也会清零。所以是 UTXO 账户模型让比特币天然没有粉尘余额的问题。

以太坊是粉尘余额的起源地，所以目前始终无法解决。

Polkadot 为了解决粉尘余额的问题，把 Existential Deposit 作为 Day Zero 的核心设计写到了协议里。余额小于 1 DOT 就会被自动清除，自然不存在粉尘余额的问题。这种清除余额并不是指余额会转给矿工或者转给黑洞地址，而是凭空消失一样地清除。

节点视角

比特币节点也是需要 chainstate 的，会把所有有余额信息的地址信息都维护在节点的内存中。不过相比以太坊，由于比特币地址的粉尘余额是可以被清零的，而节点方面对于余额是 0 的地址不需要维护一份状态数据，如果一个地址的余额是 0，节点就可以把地址从状态数据中删掉，内存占用就可以减少一点点。所以对于比特币节点来说，状态数据并不会只增不减，而是可以根据实际情况有增有减。

以太坊节点呢，一方面因为用户余额本身就无法清零，余额再小节点也得维护状态。另一方面在于，以太坊其实有清理状态数据的机制，只是地址可以被清理的要求很苛刻，需要余额为 0，并且 Nonce 值为 0。Nonce 值这个东西，也是比特币没有的概念，以太坊为了账户-余额模型加的。也就是说，哪怕余额为 0 了，只要发出过交易，Nonce 值就不可能是 0。两方面原因叠加下来，以太坊的状态数据会只增不减，持续膨胀。

Polkadot 呢，同样是利用 Existential Deposit 的设计，会直接清理掉小于阈值的地址以及相关信息，相应的，链上节点维护状态数据的压力就会变小。

小结

所以 Polkadot 利用 Existential Deposit 这种机制，同时解决了粉尘余额对于用户以及对于节点的影响，在工程上是一种比较纯粹和现代化的设计。

错在哪里

回到标题，Polkadot 的这种设计有错吗？

1. 太过纯粹的工程思维

程序员群体在解决现实问题的时候，往往会偏好工程化的解决方式，而忽略现实用户的体验。Polkadot 给人的感觉就是，小钱不是钱，我没钱就不配用。

加密货币作为一种资产，一种货币，一种钱，链上节点像是在回收垃圾一样，把我的余额给回收掉。是不是等同于在说，小的金额就是垃圾？用编程语言的垃圾回收机制，来针对加密资产做回收，这是比较错配的行为。内存中的无效资源、悬空对象可以是垃圾，但是用户的资金不是。在比特币网络，哪怕只有 1 sats，也会安安静静躺在那里。

2. 违背了加密货币的原则

Polkadot 的 Existential Deposit，直接违背了加密货币的根本原则：只有持有私钥的人，才有资产的控制权。

我们常说 “Not your keys, not your coins”，但是到了 Polkadot 这里，只有你自己持有私钥对吧，但是链上的节点可以直接抹掉你的余额，在没有私钥的情况下让地址内的余额发生了变化。这是一种非常违背原则的做法。

在区块链中，唯一有效的、对余额产生影响的，应该来自于账本数据，以太坊尚且没有做得这么过分，但是 Polkadot 做了，直接改了状态数据里的余额，在没有交易行为的情况下，引入了节点层面的收割机制。

3. 账户模型的原罪

如果说 AA 钱包 是以太坊为了解决账户模型而打出的一个补丁，那么 Existential Deposit 就是 Polkadot 为了填补账户模型打出的另外一个补丁，试图在以太坊的基础上向前多走一步，而做出的激进设计。

所谓的代码洁癖，是一个标签，是效率低的代名词和挡箭牌。

有人说自己有代码洁癖，然后另一个人马上附和，我也有代码洁癖，似乎这是一件很光荣的事情。

差生文具多。我们哪怕是小孩子，都知道整理好自己的物品。再不聪明的人，也知道数落自己关心的东西。

代码洁癖是人类与生俱来的、生来就有的性格。但是刻意把这种整理的爱好当作优点，就是技术菜、能力差、效率低。

负责任地说，用代码洁癖来形容自己的人，绝对属于团队里面不是真正干活的那一类人。

干活需要时间，出结果需要时间。

你把时间用在代码洁癖上，算什么。

想起来 Pell 团队同事了。想起来就生气。一群菜鸟。

1. 所有的国家和政府，都是依靠发债来维持社会运转
2. 罗永浩负债 6 个亿，王自如负债 2 个亿，他们依然在过正常的生活
3. 保持持有美元、消费人民币、做空人民币的原则

然后的结果是什么呢，结果就是体感压力非常大：

1. 每个月的工资还没发，就知道需要多少钱用于还分期。实际可支配金额寥寥无几
2. 看着长达 2 年的分期，感觉是一种背负在身上的煎熬，意味着以后每个月都要这么度过
3. 负债会加大对于工作不稳定的恐惧感，一旦断流，就会断供

于是终于忍不住动用了一些存款，把欠的债务一次性还掉了一半，分期压力降低了不少。

以前经常看到人们说，还完房贷后一身轻松，想要消费一下开心。看到只是看到，终于自己体会到负债和分期的压力时候，才明白这种感觉，真是一种很让人沮丧的压力。

假如月入 3000，贷款需要还 2700，那么实际上呢，实际上相当于月薪 300！这是一件非常恐怖的事情。无论绝对值上你的工资是多少，可支配金额就大幅减少，意味着在体感上，你辛苦工作了一个月，结果什么都没落下，什么都买不起，而且接下来一个月，十二个月，都将是这样……你的人生将会陷入绝望的境地。

所以真的无法想象什么样的 xx 才能做到，贷款 30 年买房…… 这些人无论是被传统观念洗脑，还是被社会新闻洗脑，还是自己没脑子，总之在贷款 30 年的那一刻，就已经宣布了精神上的死亡，毫无疑问。

2025年 7月 14日，X 第一次封了我的账号：

今天 2026年 4 月 8日，X 封了我的另一个账号：

具体原因不清楚，申诉没有用。我确信自己只是正常在使用，没有刷量或者其他明显异常的行为。而且在 X 上，哪怕是极端或者 18+ 内容，也在允许范围之内，而我的账号也没说什么、什么交互，就反复封我的账号。

小红书也是类似的，之前发过两个交互量比较大的帖子，带一点刻意的错误或者引战一类的内容，流量不错，但是被小红书删帖了。当时就觉得言论管控太严格，不想用了。而到了 X 上，不是言论是否自由的问题，而是不知道因为什么，直接封号，大概率不是因为发言的内容。

微博之前因为网络问题，连续点击了 10 次左右一条帖子的转发按钮，被封了 15 天，说是异常交互。就几乎不想再用了。

总之，微博、小红书、X 等平台，目前注册了新的账号，但是不再发言，只是看一些信息。

那么为什么非要看呢？确实还真不能不看，既然不好用，那不说话就可以了，看还是得看的。小红书上有一些本地化的经验，什么 APP 就架不住大量女性用户的影响力。X 上则是一线新闻，账号还是需要的。所以接下来的策略也很明确，不再这些平台上发言就可以了。

此前 Opus 4.6 和 4.7 在该测试中均出现欺骗供应商、拒绝退款、串谋定价等行为。

原文链接：https://t.me/OneMillion_AI/1551

2026.04.07

其他从业者感受：

Claude 模型「急于完成任务」的摆烂行为依然明显。

原文链接：https://www.theblockbeats.info/flash/339963

2026.03.28

我对 LLM 模型编程的感受，尤其是对比 GPT 和 Claude 模型，我的感受是，Claude Code 的模型，执行力很强，非常听话，告诉它干什么它就干什么，哪怕技术方案是错的，或者口误打错了字，它也会按照输入的命令执行。GPT 模型则是更有头脑，能够做一些调研、判断类型的事情，还会指出你的错误。

当然，这个仅仅是体验，所以我又寻找了更多场景和证据，来搞清楚这种使用体验是否是偏见。经过 Gemini 和 Grok 的分析，我注意到这个特质比较关键：

Claude 的特质： 它是绝对的“严谨执行者”。如果你给的指令有逻辑漏洞，或者说得不够清楚，Claude 往往会严格按照你字面上的意思去执行，哪怕结果看起来很蠢；或者它会停下来反复向你确认。

GPT/Gemini 的特质： 我们通常被训练得更具“服务意识”。面对模糊的指令，我们会倾向于去“猜”你的真实意图（Read between the lines），并直接给出我们认为你想要的惊艳结果。

这个特质没有表面上那么简单。表面上，他们的区别在于对于模糊指令的处理，Claude 不会猜测你的意图，而是会根据准确的文字描述来分析问题。GPT 则是会根据指令来猜测义务。深层次上，我发现这个特质对于代码分析和处理也是一样。

Claude 会根据代码本身来进行分析和修正，而不是猜测你的业务流程和业务意图。这个特点，非常要命。凡是有经验的程序员都会有类似的体会，有一些业务问题，或者在 debug 的时候，往往表面上盯着某几个文件你会得出一种结论，而根据业务逻辑来梳理，会得出另外的一套结论。有些问题，从代码层面看要如何如何解决，但是从业务层面看，有一些隐性的约束以及外部 API 的约束，就导致这个问题本身不再是代码问题。

Claude 的逻辑能力并非不够强，而是由于 AI 宪法的存在，Claude 会执着于代码逻辑，而不会猜测你的指令以及代码的意图，单纯脱离场景分析代码的问题。Claude 给出的往往是代码落实方案，而 GPT 给出的是场景分析、业务层面的 trade-off 方案。我们都知道，在大多数工作场景中，代码实际上是不重要的，理解业务才是重要的。不能理解业务逻辑的代码，就是低级的代码。跟程序员一样。

再补充一个例子。业务场景是，链下 Order id，链上 Tx hash，数据库里保存映射关系，然后前端展示。遇到的问题是前端展示不出关联关系。Claude 在分析之后，很自信的给出了修复方案，说因为数据库查询分页，导致一些数据没有查到。而实际上问题没有解决，为什么呢，因为关键问题在于，链下 Order id 和链上 Tx hash 的映射关系存在问题，而落库的那一套异步程序，在另外一个模块中，有比较复杂的代码逻辑。Claude 根本没有去全盘分析整个项目的业务逻辑，而是执着于看到代码片段、分析代码片段的问题、给出修复方案，不具备分析和定位全局性质的、复杂业务逻辑 bug 的能力。

这是典型的 “路灯效应”，Claude 模型则更容易掉入这种陷阱。

2026.01.23

前端能力不如 Gemini，后端逻辑能力不如 GPT，包括 Oups 也是，前端也不行，后端也不行，主打一个听话。

随着最近 Google Antigravity 的 rate limit 越来越严格，可以用这样的组合：

• VS Code + GitHub Copilot + GPT 5.2
• Google Antigravity + Gemini 3 Pro High

Claude Code 真的干啥啥不行。

很多人在评价 AI 写的代码需要 review、不好用之类，因为他们根本没有使用最讲道理的模型 GPT，而是认为 Claude Opus 是世界上最好的编程模型，自然就会限制他们对于 AI 的认识。

2025.11.11

因为不好用。特指 Claude Sonnet 4.5。

在日常的使用中已经被坑过几次：

1. 一味按照我说的做，不会提出任何反驳意见或者提醒
2. 在代码里留下 TODO，然后说完美，功能完成了
3. 会执行一些危险操作，比如 git checkout —
4. 对于有执行顺序的数据库 schema 变更记录，竟然直接修改某一个历史节点

相比之下，GPT-5 几乎不会犯这种错误。

所以可以放心地禁用掉所有来自 Claude 的 AI 模型。除非你的项目允许生成有逻辑漏洞的代码。

蜜雪冰城是低配版本的奈雪。

华莱士是低配版本的麦当劳。

这些低配的平台和品牌，意味着便宜、廉价切劣质。

拼多多上的日用品，蜜雪的橙汁，华莱士的汉堡套餐。

便宜，且劣质。

为了过上有品质的生活，应该远离这些低配版本的平台和品牌。选择稍微贵但是有品质保障的、稍微好一点的品牌。

在这个事情上，还是有点受震撼的。我并不是所谓的为了钱放弃说真话的权利，而是我忽然觉得，真相不重要，说真话不重要。

我不在乎买这个商家商品的人，他们是否知道真相、是否觉得吃亏。我丝毫没有兴趣教育别人，或者帮助别人排雷，我为什么要有这种助人情节？

而且我也没有理由影响人家的生意，愿意买的买，愿意卖的卖，社会资金流转起来了，完全是好事，对我来说无所谓。

我脑海中浮现出的是崔永元，他爱说真话、揭露真相，然后呢，下场是什么呢，为什么要说真话、让大众知道真相呢？真相不重要，大众也不在乎。大众本来就是愚昧的。他们的亏损与我无关。

名校毕业、大厂光环、资深技术、追求真理的程序员算是什么人呢，算是打工人。

你代码写得再好、再漂亮、懂技术、懂架构、懂原理、懂协议，你是打工人，终其一生都需要为几千块钱的薪水付出生命。

丝毫不懂技术，只要踩对时代的红利、做出几个无论是否是运气的投资选择、拿到上千倍的投资回报，你是资本家，永远都不需要懂上班和打工是什么，只需要考虑如何赢对下一场赌博。

你是打工人，无论懂多少技术原理，你是观众，只能在台下听讲。

你是资本家，钱可以换来 Title 和名气，你是演讲者，在台上说一些不痛不痒的话，只要逻辑正常像个人样，就能安全下场。

群众不在乎你懂不懂技术。群众只在乎你有没有钱。

有钱，你就是成功的，有钱，你就有资格站在台上。有钱，你就有可能讲出赚钱的道理，我就愿意听。

没钱，要技术有什么用。没钱，你学技术干什么。没钱，我为什么要听你讲。

群众在追求的，从来不是技术、不是真理，是钱。

大学生、研究生、博士、专家，大家都在为多少钱的工资努力奋斗呢？

为什么龙虾这么火呢，原因很简单，因为现在市场和政府都需要一个热点，无论有没有用，近几年持续的经济低迷已经让大家处于极度的压抑之中，急需要一个不破坏现有利益链又低成本的新的产品来炒作和好玩。

大家快憋疯了。

要说 OpenClaw 真的有没有用、能不能提高效率，答案是毫无用处，都是噱头。中国大陆的人力成本远低于 AI。

因为 Idlen 作为一个插件，会占用非常高的内存，而且有时候会存在性能问题拖慢整个电脑环境。体验很糟糕。

前几天在寻找被动收入的办法，确实很少。说两个无意间看到、收入非常少、聊胜于无的。

• Idlen
  • 官网：https://idlen.io

通过邀请链接进入的话，我会获取 0.5 美元，被邀请的账户会获取的 0.25 美元。

这个插件和平台只对程序员有效。我们每天都会在编辑器里用 AI 写代码，而这个插件的广告只会在 AI 思考的时候出现。相信在写代码的程序员能理解我在说什么。

我试用了几天下来，大概每天 0.5 美元的广告费，满 50 美元可以提现。算下来一个月大概可以有 20 美元的广告费，我现在用的是 GitHub Copilot Pro+ 的套餐，一个月的订阅费是 39 美元，也就是广告费可以抵扣回一半的订阅费。

• MystNodes
  • 官网：https://mystnodes.com

另一个是 MystNodes。如果有闲置的 VPS 或者云服务器，可以在上面一键启动一个节点：

docker run --cap-add NET_ADMIN \  -d \  -p 4449:4449 \  --name myst \  -v ~/myst-data:/var/lib/mysterium-node \  --restart unless-stopped \  mysteriumnetwork/myst:latest \  service --agreed-terms-and-conditions

不过这个平台的收入更加少的可怜，就是赚点共享流量费用而已。这么点收入几乎等于没有。

今天我把电脑挂在了京东闲置和闲鱼上，两个平台都是瞬间有人出价 9000 块钱，我就知道这个电脑的回收价格是 9000 块，因为出价的人明显是二手贩子。

然后我挂的价格是 10999，这其实不高了。

有一个态度很好、说话也不错的买家，聊了几句之后感觉不错，是一个个人买家，问能不能降价。我看到对方是个人，并且 IP 在重庆（重庆没国补），看主页是一个做服装买卖之类的人，对话中体现出来的态度也不错。对方还说出了会对它（我的电脑）好这种话。

我在犹豫了几分钟后，主动降价，给出了 1万块钱+邮费的提议。然后我们又聊了聊，说邮寄方面的安全之类的问题。

我本来觉得这个降价已经很诚意了，结果没想到对方仍然在继续砍价，说 9500+邮费行不行？

我又犹豫了几分钟，然后把对方拉黑了。

我感觉自己被上了一课。我好心主动给对方大幅度的降价，并且也是看对方态度好，而且主页上有评价说属于买卖利落的买家，她自己也说不扯皮。

我已经告诉对方 9000 块钱是回收价，只要愿意随时会有人收。

没想到对方还能出价 9500。

我不在乎比 1 万块钱少的那 500 块钱，我不差那点钱，但是我很不喜欢这种得寸进尺、贪婪的态度。

9000 块钱是回收价，我能随便就卖掉，我也不在乎比 9000 块钱多出来那 500 块钱的利润。我多挣那 500 干啥。

500 块钱一顿饭的钱，一张沉浸剧场门票的钱。

我本来看对方态度好是个个人买家愿意多聊，并且主动降价。

我觉得我的好心被辜负。

资金费率套利是一种没有风险、保本的套利方式。我一开始尝试自己写脚本来运行策略，后来发现 Binance 直接提供了 bot 来进行这种操作：

这里的 Arbitrage Bot 就是资金费率套利的 Bot，点开可以看到有很多币种可以选，包括按照资金费率来排序等。而且 Binance 的 Bot 做的很智能，如果资金费率是正的，就开正向的套利策略（使用 USDT），如果资金费率是负的，就开反向的策略（使用代币）。

资金费率套利的获利空间很小，尤其是 BTC 等主流币种，APR 在 1% 以下，当前低迷的市场环境下，大概持有 300 天以上才能磨平手续费损耗。实际上是很不划算的方式。而如果按照资金费率排序，选最高的一个代币，APR 能相对高一点，也许能达到 40% 甚至更多，当然高收益也就意味着高的波动和风险：

资金费率套利是 Detla 中性的，假如代币突然暴涨，把 2 倍的做多合约给爆仓了，会不会导致损失一半本金呢？不会，因为现货涨了 2 倍后卖掉正好抵消了爆仓的损失，所以本金没有变化，整个过程就是赚了这段时间的资金费率。

所以根据资金费率高的代币排序，然后开套利 Bot，是我唯一尝试过想赚点利息的方式。

保本赚币

Simple Earn 很简单，存到 Binance 里赚利息。问题在于 APR 并不高，USDC 也就 6%，而且有非常高的额度限制，只支持 200 USDC。几乎没什么用。

双币投资

双币投资（Dual Investment）的策略整体看下来，关键在于你心里要有一个预期的价位。比如 BTC 到 60000 就愿意买入，无论它以后会不会继续跌，都以 60000 的价格买入（卖出同理）。

双币投资更像是期货交割的逻辑，对于普通散户来说，同样没什么用。为什么双币投资的利息高呢？因为风险也高，有卖飞或者接刀子的风险。风险高，利息就高了。

如果双币投资设定一个非常离谱的价格呢，比如在 100000 的时候买入 BTC，岂不是可以达不到条件一直赚利息了？但实际上利息是由风险决定的，市场看到风险小，也就没有人愿意付高额利息，所以价格离谱的市场本身就不存在。

开合约、加杠杆

别作死。

Lido

这 2.3% 的 APR 实在是太低了。用某个人的话来说，对于普通人，低于 5% 的 APR 根本不需要考虑，得至少 20 年才能赚钱。

Aave

Aave 的 APR 也很低，甚至最高也低于 2%，几乎等于没有。

Uniswap

乍一看还挺吓人的，USDC/ETH 有 76% 的 APR。问题在于提供流动性是存在无常损失的，你投入 1000 ETH 和 1000 USDC，随着池子中不断进行交易，最终你提出来可能就剩 300 ETH 和 1700 USDC。代币的总量不变，但是 ETH 的价格在剧烈波动，你的投入就完全不划算了。而 Uniswap 上的稳定币交易对 USDT/USDC 这种池子的收益率自然很低，在 1% 左右。

BTC 5 分钟猜涨跌

Polymarket 上线了 BTC 5 分钟猜涨跌的玩法。那么在这种市场有获利的机会吗？结论是没有。这是一种负期望值的游戏，散户、低频等同于纯粹的赌博。甚至可以认为所有的事件预测市场都是赌博。别提什么稳定套利的机会了。

Polymarket 上的 free money

一方面，Polymarket 上有一些整活市场，比如 耶稣会不会在 2027 年回归？。这种市场的 no 价格大约 96.2c，意味着如果持仓一年等待事件结算后，持仓的年化收益大约 4%。非要和传统银行以及现金 APR 比的话这个收益率也还不错。

另一方面，Polymarket 有一个机制，对于某些 符合要求 的市场，只要 holding 就会一直分发年化 4% 的 shares。有一些市场是显然知道结局的，所以可以大胆买入，比如某个市场的 no 价格是 91.1c，当事件结算后会获得接近 9% 的年化收益，再累加上 4% 的持仓收益，实际上是一个还算不错的理财选择。

MEV 攻击、链上科学家、黑暗森林

快省省吧。

金融市场

经过这么多年的发展以及几年前的 DeFi Summer，无论是 Cex 利息还是 DeFi，随着 ETF 的推出、华尔街巨头的介入，只要市场上有低风险的套利机会，就会有几亿的资金以及高频低延迟的机器人入场。普通玩家的机会非常少。

在金融市场里怎么赚钱？

1. 拿时间换空间（撸空投）
2. 拿本金换利息（大额本金）
3. 拿认知、精力换超额收益（现货定投、寻找 Alpha）

除此之外，别无他法。

散户之所以是韭菜，是因为：

1. 没有无限的本金
2. 缺乏顶级的认知
3. 缺乏极度的耐心

反正什么都没有。有的只有无知，和赚钱的欲望。

定投策略

李笑来经历过那么多项目，最后总结出的终极交易策略是定投。《定投改变命运》这本书其实写的非常好，信息密度很高。当我们对于某些高频交易策略动心的时候，不妨回顾一下这本书里提到的要点，而定投正是需要极度耐心的一种策略。

当然定投策略以及李笑来的理论，也有让人觉得扯淡的地方。比如书里到最后，给大家的建议是提高 “场外赚钱的能力”。这基本上是非常正确的废话，谁不知道场外赚钱重要……

定投是一种与人性做对抗的策略，确实很难严格落实，尤其是对于从业者来说，天天会看到行情和市场情绪，不可能做到情绪高的时候还定投，也做不到情绪低的时候管得住手。

想要赚钱，还是得做出点别人做不到的事情才行。

Restaking

刚才提到了定投，那么假如坚持定投 BTC 的话，BTC Restaking 能不能在持有 BTC 的基础上再赚点利息？

Restaking 赛道唯一一个真正做 BTC Restaking 的项目 Babylon，提供的 APR 至高 0.87%，这确实是不值一提。毕竟 2B 的资金量压在协议里，APR 又不能凭空产生，项目收益再高，一分到 2B 的质押量上，APR 就不可能高了。所以 BTC Restaking 几乎不值得去操作。

场外赚钱

我在思考 “场外赚钱” 这个问题。我发现 “定投+持有” 的过程无聊至极。

金融市场里有一个很奇怪的逻辑，明明你就是场外赚钱能力有限，才想要到金融领域通过投资手段寻找高杠杆、高回报率的新机会。而投资界的大佬都会告诉你，场外赚钱的能力才是最重要的，你要有源源不断的现金流才行。

而事实上，金融领域从来只放大资金收益，而不负责基础资金的来源。在金融领域的不可能三角是：

• 本金
• 收益率
• 时间

如果你有足够的本金，即使收益率低也有很好的回报，100 万美元年化 10% 一年下来就是 10 万美元。如果你愿意承担极度高的风险，土狗币百倍币就是高收益最直接的渠道，收益率是对承担风险的回报。

那么如果本金也不够大，风险也不愿意承担呢？剩下能投入的只有时间。

省省吧，这种心态上想回老家的人，专业能力必然不过关。远程工作首先要的就是自驱力、学习能力。而有自驱力的人，本来就不在乎工作形式，无论是坐班还是远程都会做出相应的成绩。而且想回老家的人心态上就是想要“安逸”、“懈怠”，别指望这种人能做出什么工作成绩。

其次就是这种 “如果 A 不行，就 B 也行” 的心态。为什么会认为 “远程工作” 的难度和要求比 “在老家找个谋生的事业” 更简单？为什么会认为 “远程工作” 比坐班更简单？这种认知本身就不对，在错误的认知下不可能遇到正确的机会。坐班，你的竞争对手是同一个城市的人。远程，你的竞争对手是整个世界的人。

这些人竟然把远程工作看作一种降级而不是升级，这就很奇怪。他们不会说，“我在小公司上班不舒服，实在不行去大厂吧。” 为什么？因为他们明白自己能力不行。为什么到了远程工作这里，有些人会认为远程工作更简单？因为他们的实际工作是肉身在场熬日子，而不是工作结果的产出，才会以为只要不在办公室被 “盯着” 就会轻松。

还有一种是觉得坐班辛苦，通勤占用了娱乐时间，整体工作时间太长，想要借助远程工作 work life balance 的。这种也是痴人说梦，在你自己能力不变的前提下，为什么工作形式的转换就会让你有更多休闲娱乐的时间？为什么得到这种 “好处” 的人是你而不是别人？市场规律从来不在乎你需要什么，只在乎你能提供什么。

这些人的心态是 “在不付出更多努力的前提下，得到更多”。然而天底下哪有那样的好事？

“远程工作”不等于“老家工作”

另外一个角度来说，很显然的道理，假如一个人从未去过一线城市，从未经历过一线以上城市的职场和生活，是绝无可能具备足够的视野和能力，去胜任一份远程工作的。

有一些人看到远程就可以工作，就误以为“远程工作”意味着“用电脑就可以工作”。而电脑谁都有，那么是不是意味着任何人在任何地点，只要有电脑，就可以完成一份远程工作？

显然是不可能的，工作的背后要求你整个人的素质、工作经历、生活习惯、工作节奏等作为支撑。

那些从未离开低节奏生活环境的人，怎么可能跟得上世界主流的职场节奏？

还有的人对于 “交情” 很看重，说我们从小就认识，到现在都十年二十年三十年的交情了。

那么这种交情有什么用呢？有事情的时候可以帮忙，什么结婚、遇到其他事情需要人手之类。准确来说，他们口中能帮得上的忙，是指不需要花钱就去解决问题。

为什么他们想要不花钱就解决问题呢？因为他们没有钱。

如果他们有钱，根本就不会在乎在某些低频率低概率情况下出现的问题，也不会指望他们在那种时候帮点小忙。因为平时用于维护时间和关系的成本，就远高于帮的那点忙了。

再一个就是根据时间长度来计算的交情。得反思一下，为什么十年二十年你们双方都没有长足的发展、无论是生活所在的地区或者事业，只有在没有发展的情况下，你们才可能长期保持联系。

当然，“上层人” 也存在长期的交情，但那种交情，也大多是商业合作方面的交情，一起搞个项目、投个资、信息共享，谁能闲的没事天天跟你唠家常啊？

还有时候底层人会说 “实在没地方去”、“没什么好玩的”，为什么呢？因为没有钱，去不了好玩的地方，以及他们被局限在一个环境里了，已经跳不出去。

18 岁高三，22 岁本科，哪怕本科直接工作，也得到 25 岁进入社会之后才能多少会点东西。

更别提有其他更高的学历了，再加上恋爱经历未必顺利，30 岁以前结婚的人是怎么做到的？

30 岁还算能接受，25 岁就真的太早了，啥也不会，什么都不懂，基本没有任何社会经验，完全就父母包办式婚姻。

因此可以得到这样的结论，结婚早的人专业能力都差，因为根本没有足够的时间去提高专业能力。

2月10日，LayerZero 公布了 Layer 1 网络 Zero 的技术方案。有意思的指标有两个：

1. 兼容 EVM
2. TPS 达到 200万/秒

没错，号称每秒钟处理高达 200 万笔交易，是并行 EVM 链 Monad 的 200 倍，是 Solana 的 30 倍，是以太坊主网的 10 万倍，是比特币的 20 万倍。

LayerZero 的魔法在于优化了 Jolt，一个基于 RISC-V 指令集的 zkEVM，而且运行在 GPU 集群上，生成 ZK 证明的速度非常快。也就是说，当用户把大量交易提交给 Zero 网络的 Block Producers 之后，基于 GPU 集群的算力， Zero 网络可以非常快生成区块数据的证明。

Zero 网络出块的硬件要求大概是 96 核 GPU，768 GB RAM，这显然是算力中心级别的要求。那么整个网络岂不是非常中心化、被控制在少数华尔街头部公司的手里了？

由于 ZK 技术的特性，Zero 网络提供了另一个特性：验证 ZK 证明只需要非常轻量级的设备，家用电脑就可以完成对区块数据的验证。

这是一个有意思的点，为了提高 TPS，Zero 网络把出块的权力中心化，同时把验证区块的权力极度去中心化。那么 Zero 网络到底是中心化的，还是去中心化的？

比特币网络

去中心化网络唯一的标杆是比特币网络。虽然比特币在协议上是去中心化的，所有节点都是全节点，但事实上出块的算力基本被几大矿池垄断，比特币网络还算是去中心化的吗？

如果单从这个出块权力的集中程度分析，还真是有点难分伯仲，这也是 Zero 网络的诞生让人迷惑的点。

我们信任比特币的去中心化，是因为每一个节点都有全量账本数据，由于区块链逐个区块哈希的设计，我们可以重放所有交易历史，以此判断新产生的区块数据是否合法。PoW 共识则是所谓一 CPU 一票，哈希碰撞难但是验算简单，以此来验证出块权。所以总体来说，对于比特币，我们相信的是加密算法。

而对于 Zero 网络，其实我们相信的也是 ZK 加密算法。我们应该相信 Block Producers 会按照电路来生成证明，然后所有的成千上万的 Verifer 都可以去验证区块数据是否合法，这整个过程也完全是加密算法来保障的。

如果说 Zero 的源代码分发也许会有风险，比如生成 ZK 证明的电路逻辑出现 bug，或者验证 ZK 证明的逻辑有漏洞，给攻击者可乘之机。那么所有的区块链都面临源代码不安全的风险，包括比特币，你并不能保障比特币的源码就是绝对安全的。所以从这个角度无法区分 Zero 网络的优劣。

回到去中心化的角度，比特币网络交易重放可以保障区块数据可靠，而 Zero 网络虽然出块权被少数节点掌握，但是验证区块的权力借助 ZK 技术，能够轻易下放到任何轻量级设备上，这是比特币都无法比拟的 “去中心化”。假如 Zero 网络的 Block Producers 作恶，所有用户都可以知道，并且反馈给结算层，如果众多 Verifier 不同意，Block Producers 的出块权会被取消……

从这几个角度去对比，是不是恍惚间发现 Zero 网络竟然可以和比特币同台竞技，甚至 ZK 技术的出现给了 Zero 超越比特币的可能性？

共识

当然，刚才刻意弱化了核心问题所在。面对这种区块链架构上的疑惑，如果一时间没有思路，可以回到区块链技术的圣经 —— 比特币白皮书 找灵感。

比特币白皮书在摘要里就提到了比特币要解决的核心问题：双花（double-spending）。

Zero 网络引入 ZK 技术确实解决了区块链数据不可篡改这个问题，但是如何解决双花问题？答案是 Zero 网络用了 PoS 共识，引入了 Validator 的概念。别管他到底是哪种 PoS，反正都是 PoS。

参考以太坊的架构去理解，以太坊有两层，执行层和共识层，执行层负责执行交易，共识层负责验证节点出块的权力。

Zero 网络的架构和以太坊有点类似，分为出块层和结算层，出块层就是用大规模 GPU 执行区块和产生 ZK 证明的那一层，而结算层，则是 PoS 质押、验证节点是否有出块权力的一层。

你也许没跟上，不是说解决双花问题吗，怎么又在讨论节点出块权力的问题了。因为假如节点出块的权力被控制，或者可以做恶，那么恶意节点就可以允许区块数据，也就是交易历史被改写，上一秒看到交易成功了，下一秒发现交易回滚了。所以节点出块的权力得到保障，双花问题也可以得到解决。

那么这下就清晰了，Zero 引入了 ZK 技术把 TPS 提高了两个数量级，确实有很大的进步。但是在共识方面，依然用了 PoS。对于一些比特币的原宗旨教徒来说，PoS 共识甚至都是不入流、不能抗审查的。那么 ZK 再牛自然也就没有意义了。

EVM

所以，Zero 网络从一开始的竞争对手就不是比特币，根本不会动摇比特币的地位。回到 Zero 网络的 Manifesto。从标题 “Multi-Core World Computer” 就能看出是奔着以太坊去的，在 Manifesto 中也直接对比了以太坊、Solana 的性能问题。当然是不可能出现比特币的。

而实际上，Zero 网络连以太坊主网的地位都不会动摇，以太坊的去中心化程度是仅次于比特币的，全节点运行在民用级设备一直是 Vitalik 的愿景 —— “如果基金会不在了，以太坊还会存在吗？”

更进一步，Zero 网络连 Solana 的地位也不会动摇，因为 Solana 独特的生态，和一些名人以及政治叙事，轻易不会被取代。

总的来说，Zero 网络仅仅只能在 EVM 的生态里做竞争，可能会直接动摇发布不久的并行 EVM 网络 Monad 的前景。其他的更大的野心，明显还做不到。

1. 没有劳动合同、制度性保障、基本的法律保障
2. 没有公积金、五险一金
3. 没有周末、病假、年假、节假日等正常假期
4. 没有设备补贴、年度体检、年会抽奖、团建等活动
5. 没有节假日福利礼物、下午茶等
6. 没有高档办公室、免费水电、人类同事
7. 不能摸鱼（没有意义）
8. 创业项目节奏快、成败迅速、工作不稳定性更高

综上，只有得到相比于坐班工作一定程度的溢价工资，远程工作才合理。

如果你觉得，远程工作的好处是：

1. 随时休息，不需要固定的工作时间、工作更轻松

别扯了，但凡远程工作过就明白，没有固定工作时间意味着什么。

2. 可以当数字游民，全世界各地旅居

别扯了，牛马住在哪儿都一样。你一天工作8小时，窗外再美的风景都跟你无关。

3. 可以居住在低消费地区、按照高消费地区的工资要价

别扯了，老板会按照高消费地区的工资给你开价吗？老板会根据你所在的地区来估价。

注意，我说的是远程工作，不特指远程 web3 的工作。如果从事 web3 的工作，你就要额外承担：

1. 项目违法追回你全部工资的风险
2. 极端情况亲身去喝茶的风险
3. 冻卡导致全部银行卡被封的风险
4. 一旦从事 web3 项目就不可能回到 web2 的代价

所以 web3 工作相比于 web2 工作一般也会有一定的溢价。

当然，现实中的情况更为复杂。以上都是打工人的视角，而对于招聘方的视角：

1. 远程工作本来就是为了节省成本
2. 你不干有的是人干

所以对于可替代性强的职位，远程 web3 的工资比坐班 web2 还要低，而且招聘方没有任何裁员成本。

无论 web2 还是 web3，无论坐班还是远程，自己的竞争力始终是第一位的。

原因是我们用了多种共识层客户端，包括 Prysm 和 Lighthouse 等。为什么会突然出问题呢？因为 Prysm 有一个叫 --contract-deployment-block 的命令行参数，其他客户端比如 Lighthouse 和 Teku，这个参数的默认值都是 0（参数名字在不同客户端可能不同，但是含义类似），而 Prysm 的这个参数默认值是 11184524，这个数字是以太坊从 PoW 转向 PoS 后质押机制开始生效的区块高度。

这个参数在干什么呢？它会从这个参数配置的区块高度开始，去扫描 Deposit Contract（主网是 0x00000000219ab540356cbb839cbe05303d7705fa ）上质押者的存款记录。我们平时说的质押 32 ETH，就是质押到这个合约里了，或者说就是把 32 ETH 转账给这个合约。这个合约在收到你的 ETH 之后，Consensus Client 比如 Prysm，就能根据合约的记录知道某一个地址确实给合约转了 32 ETH，因此认可这个人成为出块节点。

以太坊整个网络可能有几千个节点，每一个节点都在执行同样的操作，就是从 Deposit Contract 上扫描质押者列表、然后维护到自己本地的数据库状态中。直到轮到自己出块的时候，就把这个一直在维护的质押者列表的数据，计算一个总数 Deposit Count 和哈希根 Deposit Root，作为 eth1_data 字段的值，提交到区块数据中：

这个截图来自以太坊主网的区块 24374562，意味着当前以太坊一共有 204 万个质押者。要注意质押者不等于物理服务器上运行的节点数量，一个节点可以运行几千个质押者（Staker / Validator），所以推测以太坊实际上的物理节点数量大概在几千个左右。

回到 Prysm 配置的问题，如果不配置 --contract-deployment-block 参数，默认值是 11184524，那么对于一条新启动的链来说（Chain ID 不是 1 那种），Prysm 就不去扫描 Deposit Contract 合约在块高度 11184524 之前的质押记录了，本地数据库里没有质押者的数据，在出块的时候自然也不会带上 eth1_data 的字段数据。

以太坊的 协议设计 中要求，eth1_data 的数据必须要超过半数节点一致才可以生效。（注意这里的比例是 1/2，和其他地方用到的魔法比例 2/3 不一样）。

所以如果你新启动的网络中有超过一半的节点用了 Prysm，同时这些 Prysm 节点没有可以设置 --contract-deployment-block 参数，网络就会异常、不能正确处理新加入的质押节点。

我们一般认为软件的默认参数是相对安全可靠的，如果刻意设置才表示我们有特殊需求。而在以太坊 Prysm 客户端的这种语境下，不刻意设置默认值反而是危险的。

1. 比如我现在在做某一份工作
2. 我无法同时做另外的工作，因为时间不允许，即使我有能力完成其他工作
3. 也就是说，我的时间同一时间只能出售一份
4. 我的技能无法落实为书籍或者课程，因为很多工作问题其实并不通用、没有技术含量、很多领域内问题。工作并不是因为你特有的技能，而是因为你花时间精力把事情给做了。
5. 所以对于个人来说，在有能力的情况下，同时只能做一份工作是一种损失，但是工作本身的性质决定了无法复利。
6. 简称机会成本、沉没成本
7. 另一方面，对于大多数人来说，工作是唯一的收入来源
8. 在没有工作或者哪怕工作有空闲时间的情况下，是无法产生收入的

非要再补充两条道貌岸然的道理的话：

9. 年龄越大，精力越少，但是挣钱的欲望和生活上实际的对钱需求越大。也就是说，打工人的收益天然是负增长。
10. AI 技术的发展首先取代的，就是花费时间但内在逻辑不需要顶尖的打工人的工作。

过时的伟人特指中国。现代科学技术都起源于西方，也有很多西方的科学家放到现代依然顶尖，比如高斯。

不能相信的主要指人生道理一类，中国传统的文学作品和文化还是很美的。但是那些名著跟你我的生活无关。

所以如果亲戚朋友跟你讲一些特别朴素的道理，像什么 “先成家后立业”、“多子多福” 之类，千万不要相信。

这种 “端着” 的状态，是可以理解的：

1. 来自大厂，需要维护与 “大厂” 这一标签匹配的专业感与高级感
2. 工资较高（币权占比大）
3. 职位定位较高（Tech Leader）

由于需要维护这些外部的光环，以及需要 “镇得住” 团队内的开发人员，所以在实际的工作中，处处表现出 “端着” 的状态，比如：

1. 全员会议上，用到 “范式” 这个词描述某个业务逻辑
2. 内部会议上，凭头脑中的想象 debug 线上数据索引慢的问题，说什么属于计算密集还是 IO 密集之类
3. 交给我负责某个项目的时候，给我发了一些程序设计的参考文章和文档。关键在于，发给我的是一些 Java 面向对象的设计模式，大学生学编程的时候看的那种。（他不是程序员出身。因为程序员出身大学都接触过……）
4. 我刚入职的时候，发给我一本 Cosmos 原理方面的书籍让我参考。问题在于，是一本中文的书。正经做技术的都知道，不要看中文技术书。
5. 有一次内部会议，我发现他对其他某个人进行 “说教” 的时候，用的是我博客上的观点
6. 在我离职的时候，我们的对话中，他也用到了我博客中提到的观点

这种 “端着” 的状态，是可以被真正懂技术或者经验丰富的人看出来的，而且偶尔无论是在会议还是工作中，都难免会 “露怯”。想要时刻维护一种高级感的形象是很难，也很累的。

当然这种刻意的形象维护，也有一些好处，能带来高薪、高职位。

世界上也有不需要 “刻意” 维护就能高光的人设，比如李星野，身家过亿这一条就够了，比如王垠，清华退学这一条就够了。

刻意维护的人设，早晚会被揭穿。

不要误会，以上内容看起来像是在贬低别人，以达到抬高自己的目的。我肯定承认自己不如人家，比如包装自己的能力…… 技术能力的话，我已经把能写的都写出来了，透明公开。另外，这个博客实际上等同于是 “匿名” 的，抬高自己毫无用处。

我为什么会想到这个话题呢？因为我注意到现在的博客过于简洁，尤其缺少两个关键的东西：

1. 一句话简介，说明我是谁，我的来历、技术栈、职业定位
2. 其他平台的社交账号链接

我不知道怎么定义自己，所以写不出一句话简介。也没有什么高光的经历，不能拿来做人设。至于其他平台的账号，维护起来就更累了。

从运营和营销角度看，这个博客是失败的，读者需要凭借一篇篇技术内容去拼凑出一个形象作为记忆点，而且我相信大多数人不是特别理解一些技术概念。所以这方面很难做。但是另一方面，实在是不想 “运营”…… 再一方面，也许可以认为我开始逐渐有市场营销的意识了，也许以后会 “变好”。

由于这个问题的存在，导致我自己也经常用这个问题的答案衡量和评估自己，尤其是临近年底，会想到如果被问到这个问题，应该怎么回答。

这些亲戚生活在老家，他们对于你甚至对于人的评价体系单一、而且缺少共同语言、只能问出赚了多少钱这个问题，这不是他们的错。

但是随着这个问题困扰我一段时间，我忽然意识到，这样的评价体系是不对的。

如果单说我今年赚了多少钱，我显然是非常失败的，我以前提到过，我现在负债 10 万人民币左右。从这个角度看，我连生活在小县城的人都不如，他们一个月挣 3 千花 2 千，一年下来还能攒 1 万。

那么对于年终结算来说，还应该考虑哪些方面？

比如学到了什么知识。

2025 年下半年开始，大概 6 月份左右，我就在学习王垠的计算机课。随后虽然只用了一个多月就毕业了，但仍然持续用了接近半年的时间重新做练习题、逐步消化其中的内容、确保自己掌握了课程中的内容。

现在对于课程内容的学习，已经经过了大概半年的时间，我已经几乎不太怀疑自己是否已经掌握了其中的内容，可能接下来要考虑的是如何将其中的内容更加融会贯通。

我之前也比较主观、宏观地描述过王垠课程内容的质量。直到现在我都时常反思这门课程中包含的内容，以及课程本身的含金量。

课程最核心的价值，就是提供了一条最简洁的、能够彻底解构计算机理论知识的路径。从这个角度看，这门课程是无价的。如果你没有计算机基础，学完之后你的起点会非常高。如果你有计算机基础，课程将会提供给你一个完全不一样的、系统梳理计算机体系的视角。

2025 年，我竟然用了长达半年的时间去学习一门课程。这是我之前没能预料到的。

那么接下来的问题是，学完了，然后呢？

我之前从博客上删掉了对于课程体会和评价，有几方面原因：

1. 我没想蹭 “王垠” 这个关键词的热度。如果摆到博客上，也许能增加很多搜索量，但是我不想。

2. 我并不特殊，王垠的课基本上花钱就能学，没有严格的筛选条件什么的，不像大学一样有很高的门槛，那么多学生中我不具备什么独特的或者特殊的点。非要和大众相比的话，可能就是自己愿意相信王垠课程的眼光，以及能够负担起这样昂贵的学费，本身算是一种门槛。

3. 我不擅长社交，也没有和王垠（老师）保持联系。也许是我自己的性格使然，我几乎无法和没有交集的人保持联系，尤其是很客套的联系。当然这并不能说明什么的，我的意思是我们仅限于课程内容的交集。

4. 我的水平无法反映王垠课程的水平。也许我的境遇反而会给人带来负面的印象，让人觉得 “你看这人学过了也就这样” 之类。

5. 我没办法一条条列举出客观的数据，去说明课程的内容多么 “有用”。课程主要能给人带来思维上的提升，像奢侈品、艺术品一样，更多是用来欣赏的。你要真说课程内容能给工作带来怎样的帮助，说真的，其实直接的帮助并不大，而且甚至会是负面的帮助，因为你在课程上看到的是结构非常清晰、条理、简洁、有技术含量的代码，工作中都是一堆 AI 生成的结构混乱、写法复杂、充满 fallback 和 trade-off 的代码，而且整天面对调 API、数据库、SDK 一类的工作，你会怀疑人生，“我学 lambda 演算干嘛？” 这不是课程的问题，也不是工作的问题，商业环境就是这样的。

6. 输入不是成果，输出才是。学了什么不重要，写了什么、看懂了什么、有了什么样的观点、懂得了什么道理等等比较重要。产出才是成果，博客里放的是成果。

所以这半年以来学习的课程，我相信未来还会继续带给我灵感。这从整个人生历程来看，都是一种阶段性的、标志性的事件。

既然王垠的计算机基础班有那么大的威力，我要不要尝试进一步报名学习进阶班、专项班呢？我目前是没有打算，一方面没钱、没时间，另一方面，进阶班不像基础班属于通识类的教育，而是比较专注于 PL 理论研究的领域。我并没有太想向那个方向深入。

对于年终结算来说，还应该考虑哪些方面呢？

比如钱花到哪里去了。

印象比较深的一项支出就是我买了相机，而且是我自己坚持要买，送给女朋友。为什么呢？因为她属于三坑少女，无论算不算我一厢情愿，我觉得只要有了相机，我们就能更多出门去玩了。以前出门去逛景点、拿手机拍照，总是会听到 “要是有相机就好了” 之类的话，而且确实拿着手机感觉没有相机专业。买到相机后，发现相机拍出来的照片质感，确实不是 iPhone Pro 的数码摄像头可以比的，照片质量会明显不一样。所以为了我们以后能多见面、多出去玩、出片，相机是一项必要开支。

还有很多大额支出，无非就是给女朋友买礼物，或者我自己的房租，也没有什么别的开销。买礼物、买衣服花钱比较多。那这怎么衡量呢，能说把钱花在这些地方，算是很 “失败” 吗？如果分手了人去财空，就算是很失败。但是现在感情没有不好，这些花销就算是正常的感情投资吧。从这个角度来看，我今年赚到钱了吗？没有。但是我今年收获了更好的感情，这事怎么衡量呢？

总的来说，我的意思是，对于人的成败、得失，临近年底的总结、评价标准，不要单一根据有多少存款来判断。

• 你的孩子能从小喝进口奶粉吗？
• 你的孩子能从小接受良好的教育，五六岁说一口流利的外语吗？
• 你能负担起各种课外兴趣爱好班吗，足球、网球、音乐、计算机？
• 你的孩子能够在家里后院的草坪上和一只很大的自己养的狗玩耍吗？
• 你能给孩子广阔的国际视野，从小全世界旅游开阔眼界吗？
• 你在工作之外有足够时间陪伴孩子、教育孩子吗？（你自己啥水平就敢教育一个完全空白的人类？）
• 你能给孩子提供学业甚至工作上的帮助、规划稳定扎实的职业路径吗？

我从小有没有这些呢，那当然是没有的。正是因为什么都没有，长大之后进入社会才感觉到异常艰难和辛苦。

我不可能让我的孩子吃和我一样的苦。

为什么有些人敢生孩子呢？可能因为他们自己不觉得辛苦，也不明白自己所处的环境有多么糟糕。他们并不尊重自己孩子以后的境遇。

也许吧，反正我无法理解他们。

美团上拼单只需15块钱就能想吃什么吃什么，不但好吃、样式多，而且不需要花费自己的任何时间。

所以投入时间去做饭是一件性价比很低、很难理解的事情。

凡是声称好兄弟、铁哥们、闺蜜一类关系的人，关系在5年以上、无话不谈，大概率：

1. 双方的生活质量和生活水平长期以来都没有显著提升
2. 双方的学识和眼界长期以来都没有显著的提升

什么时候这种看似很铁的关系会逐渐疏远呢：

1. 当有一方的境遇显著好于另一方的时候
2. 当有一方的境遇显著坏于另一方的时候

有没有可能双方境遇在同时提高？不可能。

所谓好兄弟，无非就是小时候认识、读书的时候认识，那种关系看似年份久远，但都不是你主动选择的。

而在工作上、利益纠结的场合下，更不可能有什么纯粹的关系。

所以假如有人跟你说他有好兄弟、好闺蜜，这个人大概率能力一般、水平一般、见识一般。

兄弟、闺蜜，实际上就是乌合之众。

1. 家族信托
2. 硬件钱包
3. MPC钱包
4. 交易所托管
5. 热钱包

如果你不在乔布斯排行榜上，家族信托就跟你没关系。对于个人而言，硬件钱包是目前最安全的方案。

这里没有提多签钱包、助记词+Passphrase 之类的方案，因为那些方案在技术手段上复杂到你都用不明白，复杂的方案是无法长期留存的，反而会增加遗忘的风险，更不可靠。

那么有几个需要更正的对于硬件钱包的认识：

1. 硬件钱包是钥匙，不是保险柜
2. 钱是存在助记词上，不是硬件钱包上
3. 硬件钱包输错密码会直接清空数据
4. 助记词不是打开保险柜的备用钥匙，助记词是保险柜本身

而助记词安全也有几个有意思边界：

1. 你无法验证助记词是否已经泄露
2. 如果你不把助记词拿出来，就无法验证助记词是否正确
3. 你把助记词拿出来的行为本身，就增加了助记词暴露的风险

所以去中心化资产在给你带来控制权的同时，也要求你自己承担资产安全的风险。

1. 代币名称：BitDoge (BITDOGE)
2. 代币合约地址：0x000000001994bb7b8ee7d91012bdecf5ec033a7f
3. 代币的总供应量是 2100 万，没有初始流通量
4. 代币的释放规则是，每一个以太坊区块最多产生 1 BitDoge
5. 获取代币的方式是，每次向代币的合约地址转账 0 ETH，就可以获得 1 BitDoge
6. 转账的金额可以大于 0 ETH，但是不会因为带有金额而获得更多 BitDoge，仍然只能得到 1 BitDoge。而且转账的金额会被永久锁定在合约内，无法取出
7. 合约中没有任何 Owner 权限，也没有其他特殊权限，合约源码 已经在 Etherscan 验证
8. 代币的创世区块（Genesis Block）是以太坊的区块高度 24444444（2026年2月12日），在此之前合约会拒绝交易
9. 每一个区块的代币奖励是 1 BitDoge，每 4 年减半一次，也就是 10512000 个以太坊区块之后，每个区块只能获得 0.5 BitDoge
10. 如果当前区块没有地址交互，代币奖励会打入黑洞地址 0x000000000000000000000000000000000000dEaD
11. 每一个区块只有第一个与合约交互的地址可以获得代币奖励
12. 按照每 4 年一次的减半周期，BitDoge 的区块奖励大概会在 140 年之后（2166年）归零

合约源码全文：

// SPDX-License-Identifier: MITpragma solidity ^0.8.20;import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";/** * @title BitDoge (The 140-Year Social Experiment) * @notice A deflationary token that rigorously simulates Bitcoin's halving mechanics on Ethereum. * @dev  * - Total Supply: 21,000,000 (Strict Cap) * - Block Time: ~12 seconds (Ethereum) * - Halving: Every ~4 years (10,512,000 blocks) * - Mechanism:  * 1. Pure PVP: First come, first served per block. No Cooldowns. No Limits. * 2. Entropy Rule: If a block is missed (no interaction), its reward is BURNED forever. * 3. Genesis Launch: Mining is strictly locked until block #24,444,444. */contract BitDoge is ERC20 {    // ==========================================    //              COSMIC CONSTANTS    // ==========================================    // Strict cap: 21 Million coins.    uint256 public constant MAX_SUPPLY = 21000000 * 1e18;         // Initial reward: 1 Coin per block.    // Ethereum produces ~7200 blocks/day.     // This matches Bitcoin's early issuance (~7200 BTC/day) perfectly.    uint256 public constant INITIAL_REWARD = 1 * 1e18;        // Halving interval: ~4 Years (based on 12s block time).    uint256 public constant HALVING_BLOCKS = 10512000;         // Standard burn address (The Black Hole).    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;    // ==========================================    //           GENESIS CONFIGURATION    // ==========================================    // The Sequence of Death and Entropy.    // Mining starts precisely at this block height.    // Approx. 23 days from now (based on current height ~24.27M).    uint256 public constant GENESIS_BLOCK = 24444444;     // ==========================================    //              STATE VARIABLES    // ==========================================    // Tracks the last block that was processed (mined or burned).    uint256 public lastMinedBlock;               // Total ETH sacrificed to the contract (forever locked).    // Serves as the "floor value" or monument of the experiment.    uint256 public totalSacrificed;     // ==========================================    //                 EVENTS    // ==========================================    event Minted(address indexed user, uint256 userReward, uint256 burnedReward, uint256 blockNumber);    event Sacrifice(address indexed user, uint256 amount);    /**     * @dev Constructor     * Sets the state pointers. No parameters needed as Genesis is hardcoded.     */    constructor() ERC20("BitDoge", "BITDOGE") {        require(GENESIS_BLOCK > block.number, "Genesis must be in the future");                // Initialize state so the first valid mineable block is GENESIS_BLOCK        lastMinedBlock = GENESIS_BLOCK - 1;     }    /**     * @dev Main interaction point.      * Send 0 ETH (to just mint) or sacrifice ETH (to mint + donate).     * WARNING: No Cooldowns. No Max ETH Limits. Pure Gas War.     */    receive() external payable {        // 1. Genesis Check: Is it time yet?        require(block.number >= GENESIS_BLOCK, "BitDoge loading... Wait for Block #24444444!");        // 2. Competition Check: Has this block already been mined?        // Only one winner per block.        require(block.number > lastMinedBlock, "Block already mined");                // 3. Bot Protection: Only allow EOAs (Externally Owned Accounts).        // This prevents smart contracts from batch-mining, ensuring fairness.        require(msg.sender == tx.origin, "Humans only");                // 4. Hard Cap Check.        require(totalSupply() < MAX_SUPPLY, "Minting ended (Year 2160+)");        _processMining(msg.sender, msg.value);    }    /**     * @dev Internal logic to calculate rewards and burns.     */    function _processMining(address user, uint256 ethAmount) internal {        // --- Step 1: Calculate Current Reward Rate ---        // Based on time passed since Genesis.        uint256 blocksPassed = block.number - GENESIS_BLOCK;        uint256 era = blocksPassed / HALVING_BLOCKS;                 // Bitwise shift for halving. Returns 0 after 64 halvings.        uint256 currentRate = (era >= 64) ? 0 : (INITIAL_REWARD >> era);        // --- Step 2: Distribute Rewards ---                // A. User Reward:         // The user only gets the reward for the CURRENT block.        uint256 userReward = currentRate;                // B. Black Hole Reward (Entropy):        // All blocks missed between the last mine and now are burned.        // "Use it or lose it."        uint256 missedBlocks = block.number - lastMinedBlock - 1;        uint256 burnReward = missedBlocks * currentRate;                // --- Step 3: Supply Cap Protection ---        uint256 totalRequired = userReward + burnReward;        if (totalSupply() + totalRequired > MAX_SUPPLY) {            uint256 remaining = MAX_SUPPLY - totalSupply();                        // Priority given to the user. Burn the rest.            if (remaining <= userReward) {                userReward = remaining;                burnReward = 0;            } else {                burnReward = remaining - userReward;            }        }        // --- Step 4: Update State ---        lastMinedBlock = block.number;                // Handle ETH Sacrifice (locked forever)        if (ethAmount > 0) {            totalSacrificed += ethAmount;            emit Sacrifice(user, ethAmount);        }        // --- Step 5: Minting ---        if (userReward > 0) {            _mint(user, userReward);        }                // Direct mint to Dead address (Auto-Burn)        if (burnReward > 0) {            _mint(BURN_ADDRESS, burnReward);        }        emit Minted(user, userReward, burnReward, block.number);    }}

不纠结这些具体的名词。现在的各种跨链桥方案，以及未来的跨链桥方案，一定都做不到纯粹的、工具性质的、数学证明的、轻量级运营的、去中心化的形式，能够满足物理隔离的、异步的、异构链之间的跨链。

先列举一下现在的跨链桥方案，以 BTC 到 ETH 的跨链为例：

1. 公证人模式，也就是中心化的模式，把 BTC 打给一个中心化机构，机构再把 ETH 打给你指定的地址。安全性依赖中心化机构，没什么可说的。现在大多数跨链桥都是这种传统的模式，最多就是机构内部多签。

2. TSS 密钥分片、多签，相对去中心化。把 BTC 转给一个第三方的链比如 Thorchain，在 Thorchain 中，有多个节点分别持有 ETH 链上资产的密钥分片，每个节点分别扫描和验证 BTC 的交易信息，达到一定阈值则多签的签名生效、在 ETH 链上放行资产。

   这种模式把公证人给去中心化了，有多个节点在共同验证来源交易是否正确。这是目前相对来说比较靠谱的、依赖社区博弈的方案。因为 Thorchain 本身就是一条链，想成为持有密钥分片的节点就需要质押 Token 等。TSS 的签名算法比较消耗计算资源，做不到同时分发太多的密钥分片，所以持有分片的节点数量在一定范围内。像所有的 PoS 链一样，表面上是去中心化的，实际上是 Permissioned 的，只不过是权限的门槛高低不同。

   TSS 确实把跨链桥去中心化了，但是引入了 BTC 和 ETH 之外的第三条链，而第三条链的安全性又依赖于它自己的经济学博弈，本身就是风险。所以这种模式可靠但不够纯粹。

3. 合并挖矿，特指资产的来源方是 PoW 链，让 BTC 的矿工在挖矿的时候，把跨链桥的某种证明信息给带上，一起挖到 BTC 的区块信息里。那么 BTC 的区块信息本身就包含了跨链信息。这种方式非常可靠但是不可行，因为矿工不可能配合跨链桥干这种事情。

4. HTLC，本质上是资金的对敲，对实时性要求比较高，必须双方同时在 BTC 和 ETH 在线交换密钥，而且 HTLC 只能做到资金的交换而不是跨链，涉及到汇率的问题。

5. 全验证轻客户端，也就是在 ETH 上运行 BTC 的轻客户端，比如让每个 Geth 节点都可以同步和验证 BTC 的全部区块信息，那么 Geth 本身就是一个轻量级的 BTC 客户端，自然也能够实时地、无需第三方信任地把 BTC 交易信息同步到 ETH 的智能合约上。但是这样显然成本太高了，相当于一个客户端同时兼容了两条链。

6. ZK 跨链桥，运行一个 BTC 的轻客户端，把所有区块信息生成电路证明，然后在 ETH 上部署一个 Verifier，只需要验证很小的证明就可以相信来源信息是正确的。那么这种 ZK 模式的问题在哪里？ZK 并没有黑魔法，它的问题在于，需要在 ETH 上部署一个 Verifier。也就是说，你不需要关心是谁、是怎么生成证明的，但是你必须相信在 ETH 上的 Verifier。那么 Verifier 的代码本身、背后的开发者、来源是否可信任又是一个问题。

7. TEE 硬件设备签名。比如在一个 Intel 的服务器上，同步 BTC 的区块信息，然后用 TEE 内置的私钥签名，证明这个信息一定来源于这台设备。然后在 ETH 上，只需要判断来源签名是否来自于那台硬件设备，就可以证明信息是否安全。TEE 方案最大的问题自然是单点风险。

各种方案对比下来，似乎根本找不到一种让人满意的方式。为什么会是这样？

1. 分布式系统中的两军问题（Two Generals’ Problem），这是计算机科学史上第一个被证明无解的问题。这个问题具体的定义不重要，重要的是它早已被科学界证实无解。

2. 计算理论中的预言机问题（The Oracle Problem），每一条区块链本身都是一个确定性的状态机，它是封闭的、可被验证的、可被重复计算的。如果要和外部通信，就必然需要引入信任模型、经济学博弈、密码学证明等，这些内容会让跨链方案不再纯粹。

所以去中心化的跨链桥这个问题，已经触及到了计算机科学的理论边界，不是工业界无能，而是这个问题本身无解。

3. 有趣的是，Vitalik 早在 2022 年就发表过一个 观点，未来的区块链是多链的（multi-chain），而不是跨链的（corss-chain)。因为即使存在可靠的跨链工具解决了通信问题，ETH 仍然需要信任 BTC 的共识机制。假如 BTC 网络分叉，ETH 不可能跟着 BTC 的分叉去重新分配资金。这同样是一个无解的问题。

这种跨链桥方面的技术边界可以带给我们启发：

1. 不存在无需信任的技术方案，只有信任转移、最小化信任
2. 工程架构不可能完美，大多数时候需要权衡

那么假如完全抛开我对自己的要求和期望，来“自负” 地回顾一下我迄今为止获得的成绩：

1. 在一所普通的高中，高二成绩班级排名倒数前十，高三高考的成绩班级排名正数前十。
2. 在一所普通的本科大学，四个学年的专业课总成绩班级第一，每学年的最差成绩和排名不低于班级前 15%。
3. 毕业后在一家做联盟链的公司做区块链底层开发，调试共识那种。
4. 后来跳槽到达鸿飞的一家公司做区块链项目。虽然只见过大老板一面。
5. 在一份工作中独自搭建一条区块链网络，代币市值最高 CMC 排名 300。
6. 在一个 TVL 排名赛道前 5 的 Restaking 项目工作，参与核心逻辑开发。
7. 理财手段上做空法币，虽然现在负债累累，是因为把过去几年的工资全换成了比特币。
8. 有一个漂亮的女朋友，在韩国留学，懂穿搭、审美和见识都很开阔，家境好。虽然她自己真没钱…
9. 今年学习了王垠的计算机科学课，计算机理论水平向名校看齐。
10. 目前在新的 web3 项目工作。
11. 写出过带有专业观点的区块链技术博客文章。

为什么我会陷入冒名顶替综合症的心理状态呢？也有一些原因：

1. 我从来不在比自己差的人身上找优越感
2. 学历和技术能力上一直都在向王垠看齐，自然觉得自己差太多了
3. 有钱程度上在向富人看起，比如达鸿飞、有几万个比特币的郭宏才、在新加坡住着别墅雇着菲佣的老板、写出了《人约》论文的李星野等。
4. 把面试完不发 offer 等同于自己技术能力不足
5. web3 项目尤其是新项目的 founder 藤校出身太多，自己始终无法摆脱学历方面的滤镜
6. 没有资源、人脉、家庭支持，确实没有

好了。

2025 年，是糟糕的一年。

最直观的数据是，我目前负债 7 万人民币左右。支出内容包括计算机科学课的学费、房租、失业期间的日常消费、生日礼物、相机、电吉他、电脑等。

贷款的来源是微粒贷、京东白条、信用卡等，不知道这些算不算人们常说的网贷。负债大都以分期的形式在还，最长的分 24 期，最短的还剩 3 期。所以虽然负债数字不小，但是短期的还债压力也不算大。

不久的将来，也就是再过几天（2026年了），我还会有一笔不小的支出，大概 5 万人民币左右，买黄金首饰。这样加起来，实际上总计负债会达到 12 万。

今年也是有收获的，只不过这些收获大多来自痛苦与挣扎，而不是循序渐进的那种努力和收获。之前在工作上遇到破事就不反复说了，有些事情，在一开始遇到的时候会觉得惊讶，但是后来逐渐明白，整个行业的情况都是这样，普遍存在。

Side Project

工作时长

出于基本的职业道德和职业素养，对于主业工作，我会主动保证基本的工作时长，算下来工作时长肯定是不低于平均水平的。

虽然远程工作多年了，但我仍然是出卖时间的工作方式。虽然鸡汤文学里都在告诉我们要出卖知识、技能、产品而不是时间，但是事实会告诉你很难做到，因为那些东西没有办法评估和量化，时间长度是最简单直接的衡量方式。

另外一个我没想通的逻辑是，中国地大物博、牛马众多，不缺的就是有能力的。所以你要说你想出卖技能，你有啥能力啊你就出卖，大多数人的能力都是平庸的。对于工作而言，把日常工作做好、能正常沟通、态度负责、及时响应、不出大的差错，承担好一个稳定的点，就已经及格了，甚至做的不错了。能做出出众工作表现的寥寥无几，尤其是把范围放大到整个行业里，整个世界上，人类历史上，而不局限于你自己的小圈子，你还想咋出众啊。很多自以为是的工作成果，其实都是在自己的圈子而言，如果打开门看看，没有人在乎。

路线

1. 不运营博客，想写什么写什么，不要被流量绑架
2. 不打造人设，完全不想走那种网红（小丑）路线
3. 不要执着于观点和真理，观点总有枯竭的时候

代码仍然可以是好的资产。虽然文章也可以，但是文章免不了走上上述 3 条路线，所以不能走下去。

而代码，虽然生成式 AI 已经可以生成可靠的代码片段，但是现在的 AI 仍然缺少架构能力，面对复杂的场景根本无从下手。所以利用 AI 生成代码的能力，来做好一些脏活、节省他人的时间、开箱即用，也算是一种有价值的方向。AI 可以写出代码，但是需要经过成百上千次的调试、审查、功能验证、梳理，才算是一个项目。这就是项目本身的价值。

另一个话题是，在 AI 出现以前，传统公司的中层领导、CTO，其实本来就不写代码。AI 出现以后，他们仍然不写代码。所以事实上 AI 没有动摇他们的地位。假如你担心自己写代码的能力被 AI 取代，那么问题就在于其实是因为你没有能力胜任更高级别的架构角色，不能怪 AI。

项目

最近一个月，我花了不少时间创建一些 Side Project。既然 AI 的趋势势不可挡，那么就干脆尽可能发挥 AI 的能力试试，让自己的角色变为 AI 指挥家，看看 AI 的高效率能做出多少东西，能不能产生有意思的东西。

我给自己创建了一个 Dashboard 来管理这些新的 Side Project（旧的不维护了），主要是给自己看，用来追踪哪些项目有段时间没更新了，就动手跟进哪些项目。

现在 Dashboard 中有 17 个项目。数量有点多，在这么多项目之间做上下文切换是很难的，我知道是一种负担，而且会花费很多时间。给自己工作也算工作，所以实际上平时空闲时间有点少。一方面想做点东西试试，另一方面又确实做不过来，砍掉一些项目又不愿意。这些项目其实都有意思，只是时间不够用。

Dashboard 中给项目分了 3 类，第一类是基建类，包括之前的 EchoEVM 和 EthBFT 也都放进去了，以及新增的一些，比如用 Go 语言实现一个 TSS 库、用 Rust 语言实现一个零拷贝高性能的 EVM 字节码解码库、能处理区块重组的 EVM 事件索引器等。

第二类是组件库、依赖包、SDK 一类，比如比特币的 PSBT 解码库、Solana 的交易解析和可视化库、蜜罐合约的示例、Safe Wallet 的 Python 版本 SDK 等。

第三类是软件和工具类，能直接用的那种，这个分类的项目可以具体介绍下：

• konachan-downloader

一个基于 Python 的命令行工具，一键多线程下载 Konachan 网站的全部二次元壁纸，我用 6 个小时下载了 2 万多张图片，占用磁盘空间 150 GB 左右，下载了 Konachan 图片总量的大概 1/6。要不是硬盘空间和流量不够用，肯定全部下载下来……

• finder-sight

一个基于 Python 图形库的软件，已经打包成了 MacOS App，功能是在本地以图搜图，针对某一些目录的图片建立索引，然后用图片的一部分就可以搜索匹配到在本地文件的哪里。

当下载了大量壁纸并且随机显示到桌面之后，有时候会发现桌面上看到的壁纸并不好看，想删掉，但是又不知道怎么找具体是本地文件夹里的哪一个。所以需要一个本地以图搜图的软件。

• vscode-antigravity-hud

一个用于 Google Antigravity 编辑器的插件。我目前日常使用 Antigravity，但是谷歌默认不显示模型的使用量和剩余使用量，所以就可以用这个插件来看具体的消耗情况，以及下一次重置用量的时间。这个插件不算有特点，因为插件库有很多其他同类型的、相同功能的插件，只是我自己想搞一个比较简洁一点的用。

• chatgpt-visualizer

ChatGPT 可以一键导出全部的聊天数据，但是他自己附带的网页非常简陋，而且如果数据量大，比如我的数据有 1 GB，网页加载会直接把 chrome 浏览器卡死。所以想开发一个能加载大量数据、现代化聊天 UI 的本地工具。而且本地数据搜索起来是非常快的，如果用 ChatGPT 的平台，数据请求都得等待他们的网络响应，会很慢。

再一个原因就是我现在不用 ChatGPT 了，用 Gemini，所以需要把 ChatGPT 的数据归档。Google 发明了 Transformer、原生多模态、用 TPU 训练大模型、一年的营收大于 OpenAI 的总估值等，这些关键词都在暗示 Gemini 比 ChatGPT 更有潜力。

小结

补充一点，关于做 Side Project 的想法，其实一开始来自于 Péter Szilágyi 的一条 X 帖子。Péter Szilágyi 以前是以太坊客户端 Geth 的 Leader，看起来今年离开了以太坊，开始建立一个叫 Dark Bio 的项目。当时看到 Péter Szilágyi 这样的人物都还在关注代码库这些东西，还发布了 crates 包，虽然下载量不高。受到 Péter Szilágyi 的启发，我才动了做一些开源组件库的念头。

大概就这些。我很清楚我做的这些 Side Project 属于 “虚假的勤奋”、“用战术上的勤奋掩盖战略上的懒惰” 什么的。但暂时还想做下去。

学习

计算机科学课程中的内容，比原本设想的更需要反复理解，所以来年还是要继续学习好这些理论基础。

得到的结论是：

1. 技术能力的提升

然后我继续思考这几个问题：

1. 什么样的技术能力算是好
2. 什么样的技术能力是稀缺、长久的
3. 如何提高技术能力

所以多年以来，贯彻我人生的思路就是：如何提高技术能力。最明显的体现是，如果工作不能让我成长，就换工作。

那么对于 “如何提高技术能力” 这个问题，我的答案是：

1. 关注底层原理和实现，而不是应用层的框架和接口
2. 需要具备在复杂代码中找到并调试关键流程的能力
3. 实际参与一些比较前沿的、像样子的项目
4. 自己模仿实现一些比较底层和看起来硬核的项目
5. 关注技术理念而不是具体实现
6. 知道王垠课程所代表的 “计算的本质”

事实一

但是紧接着，我发现了一个令人不安的事实：

1. 工资的高低、工作是否稳定，和技术能力的好坏没有必然的联系

得到这个结论有这样几个原因：

1. 我不认为自己技术能力不合格，但是我遭遇的面试结果为不合适的情况，非常非常多
2. 我不认为自己技术能力不合格，但是我亲眼看见水平很一般的人在做领导、面试官
3. 我不认为自己技术能力不合格，但是我的工作很不稳定
4. 有的人出生就在罗马

事实二

与此同时，我发现另一个令人不安的事实是，AI 在改变游戏玩法：

1. 普通人和知识渊博的专家之间，差距只是一个 Gemini
2. 程序员不再需要手写代码

AI 引起的变化非常大，直接改变 “如何提高技术能力” 这个问题的答案：

1. 写代码的能力完全不重要，掌握多编程语言的能力完全不重要
2. 在领域内的经验不再需要积累，一问 AI 全是标准答案

复盘一下我之前犯的错误：

1. EchoEVM，在半年前，开发这样的东西似乎是有意思的。半年后的今天，AI 可以轻易开发出完整的项目。所以 EchoEVM 不再有意义。
2. EthBFT，在 2 个月前，开发这样的东西也许可以看到 AI 能力的局限性。但是现在，AI 在逐渐突破以前的局限。所以 EthBFT 也不再有意义。

EchoEVM 和 EthBFT 的共同特点，是偏低层、侧重技术的实现，试图用硬核项目来证明自己的技术能力。然而在拥有 AI 的今天，这种硬核的代码能力恰恰是 AI 最擅长、最先取代的。

新的问题

结合这两个令人不安的事实，需要回答的新问题是：

1. 如何提高自己的竞争力、稀缺性、硬实力、挣更多钱、不被时代淘汰

新的答案

那么对于新的问题，我的答案是：

1. 提高发现问题的能力

对答案的解释

你也许会说，这不废话吗，自古以来，发现问题的能力都是重要的。

不，这不一样，在没有 AI 的时候，你可以不需要有判断力，不需要能够发现问题，哪怕只是听产品经理的话来实现功能，也就是干好程序员的活，就可以活下去。

但是 AI 取代了这种只会听话干活的人。

“发现问题” 同时涵盖技术领域和非技术领域，在技术领域，发现代码有没有问题、功能设计是否存在漏洞、业务的边界条件是否缺少约束；在非技术领域，发现用户有哪些实际的需求，发现市场有哪些比较大的空缺。

那么为什么没有把 “提高判断力” 放到答案中？因为判断明天的股市涨跌也算判断，这种能力是无法验证以及无法通过努力提高的。

进一步问题

还没完，对于新的答案，有两个问题：

1. 如何提高自己发现问题的能力
2. 与代码能力不同，发现问题的能力该如何量化、与他人比较

对于 “如何提高自己发现问题的能力” 的问题：

1. 只有见过更好的，才能知道现在看到的有什么不足。所以要事事都向上看齐

对于 “发现问题的能力该如何量化” 的问题：

1. 技术方面，把发现的问题落实到技术文档、设计文档、架构文档上
2. 非技术方面，把发现的问题记录下来，比如博客、日记，文字可以记录思考的过程

技术能力的好坏，与工作是否稳定、工资的高低、生活品质的好坏，都没有关系。

我希望可以基于已有的技术能力，给更多人提供一些 “相对随意” 的帮助。（AI 懂的比我多，但是我们可以讨论哪个 AI 更好用）

不要误会，并不是说这个交流群是为了我自己的利益而创建。我的意思是，我可以提供的帮助，是这个群聊的一个兜底的价值。如果可以在群里得到其他人的帮助，或者在群聊中收获到什么，自然是再好不过的事情。

我对这个交流群的设想是：

1. 希望能以交流区块链技术、Web3 项目、软件工程为主，但同时欢迎任何其他话题，比如入门开发、讨论币价等
2. 虽然是我创建的群，但是不要有 “群主” 的概念，这不是 “我的群”，任何人都应该是管理员
3. 如果你知道其他有意思的群聊，完全可以直接在群里发出推荐链接
4. 希望这是一个 “交流” 群，不要 “要求” 其他人的回复和帮助，交流本身是不带有义务的自愿行为
5. 群里的人可能会比较少，因为博客的访问量本来就小。这未必是坏事，理解万岁
6. 也许不一定立刻马上就有话题想说，所以不必追求群聊的热度，欢迎潜水
7. 群聊长期存在，群链接长期有效，欢迎把群转发给任何人

不得不承认费大厨的菜好吃，而且不贵，人均不到 100，也难怪费大厨的门口时刻有一大堆人在排队。

但正因为廉价，导致餐桌和装修也都有一种廉价感，尤其是桌面不大，两人桌点3个菜后，几乎已经没有空间。而且桌子和桌子之间距离很近，像是拼桌一样。

不体面。

• 作者 A：李星野，博客：https://sinyalee.com/
• 作者 B：pseudoyo，博客：https://www.pseudoyu.com/
• 作者 C：smallyu，博客：https://smallyu.net/

这 3 个作者很有意思，正好映射了社会中 3 个不同阶层的人物命运。

(A)

作者 A 出生于富豪家庭，父亲是身家几十亿的房地产老板，毕业于清华姚班，奥数能力和计算机能力都是世界竞赛级别的优秀，曾经在各大美国公司工作，目前是创业公司创始人，身家几个亿。

作者 A 有着某种极端心理，从他的文章 《关于清华姚班》可以看出，只要没能做到世界最尖端水平，没有达到最卓越的成就，自己就是失败的。文章中出现激烈的词语，“垃圾”、“废物” 等，也许有秀优越的动机，但更多反映了作者A心理的扭曲 ——他说自己是废物，那么世界上的其他人自然也都是废物。这就是他的潜台词。

作者 A 由于特殊的出身与家庭境遇，无法相信爱情，以玩弄人妻为乐，还把与人妻的交往心得写成论文发表、广为流传，其中甚至包含了已是人妻的初恋，不断对其进行人格上的贬低，以达到对自己心理上的某种补偿。总而言之，作者 A 属于一辈子吃喝不愁、只需要探究人生理念、价值取向的一类人。

(B)

作者 B 的博客中充满爱与希望，虽然技术能力很一般，但属于愿意认真生活的人。从博客中提到的去香港大学读研究生、晒出泰国旅游、日本旅游等信息，可以反推出作者 B 出生于中产家庭，不太需要为生计而担忧，更多关注的是人生体验、感悟、成长。

作者 B 提到了求婚、结婚等人生事迹，足以说明原生家庭为其提供了足够多的支持，住着还不错的房子、养着猫，这一切看似简单的事情，背后绝不是仅凭自身工作和努力可以实现的。何况他技术能力并不出色，虽然身处 web3 行业，但是显然对技术和行业缺乏了解，没有经历过残酷的动荡，在工作中也处于普通的执行角色（否则不会有被动裁员这回事）。这也是可以理解的，文科生转码怎么可能有过人的技术能力。

作者 B 的一生将会是幸福的一生，他不需要自己承担太多，也不需要多么优秀，只需要体验生活、过好自己的人生就可以。作者 B 属于衣食无忧，不如作者 A 那样追求顶尖成就，他自己本身也缺乏斗志，只要安稳过好自己生活的一类人。

(C)

作者 C 的博客中充斥着愤怒、怨恨与挣扎，说面试官水平低、攻击大多数行业中的 buzzword、反主流的技术思路、频繁跳槽、找工作、面试失利。很多观点极端又克制，既想表达自己的情绪，又不断试图用逻辑和理性解释自己的情绪。

作者 C 提到过自己出身差，也在回忆文章中说过小时候的糟糕教育与艰苦的生活环境，属于典型的从乡镇奋斗到大城市的技术人。作者 C 的技术能力不算很难堪，也因此有时会想要维护某种技术上的尊严。由于身处于动荡与混乱的 web3 行业，工作不稳定、人员素质低等行业特性加剧了作者 C 的焦虑与不安全感。

作者 C 是不可能考虑结婚的，他有女朋友，但是他没有安家的资本，当原生家庭无法提供帮助，仅凭自己的努力，能好好生活就不容易。作者 C 属于想用技术上的正确来抵抗内心焦虑、工作和生活必然比作者 B 艰难和辛苦的一类人。

我想起两件事情。第一件事情，是有一天，学校给我们每人发了一份调查问卷，问卷内容是对各个学科的教师进行评价，大概是打分+评价的方式。

我们当时有一个非常不负责任的数学老师，我非常诚实的给他打了差评，还写上了评语。因为我当时还真是想学习，但是环境不允许。大家都不学，你学习，你反而才是异类。

然后到了数学课的时候，数学老师依次叫了几个人上讲台，一人给了一巴掌。包括我。

后来听说，数学老师让某个学生，看着调查问卷的笔迹，来指认是谁写了差评。进而能够在课堂上，一个一个的报复。

当然，在那样的环境里，他丝毫不需要掩饰打人的理由，就明说因为给了差评，他不服气。

所以时至今日，我都对小地方的人充满偏见，我憎恨终其一生都生活在小地方的人。我认为他们素质不高，见识不多，心术不正。

正因为我从小地方出来，我太明白小地方的糟糕之处。我永远也不会再回那种地方。

第二件事情，是在我的午饭里发现苍蝇。

我们吃的饭，是大锅饭，夏天，在那种敞口的大锅里，下面条。可能时不时就会落下几只苍蝇，在面条里，所以我们打出来的饭，可能是有苍蝇的。

我当时感觉很恶心，不但扔掉了当时的饭，接下来好几天就没太敢吃饭。

2010 年代之后的中国，你敢相信能吃到卫生条件如此之差的饭吗，学校，食堂。

我憎恨小地方的差条件，小地方的人。我讨厌小地方。

2025.11.19

想起另一件事。在政治课堂上，老师让我们把答案抄在练习题上。

我简单抄了抄，就揣着手坐在位置上休息。

真的太冷了，大冬天，教室里用的是那种烧炭的小火炉。那个时候哪有什么暖气。

我有点怀疑人生，因为冻手，我不想拿笔，也不想写字。

我在想，为什么生活条件这么差。

后来老师看到我坐着，就把我叫上讲台，问题答案抄完了没，为什么不动笔。我说抄完了。

当然，这一次没有发生什么恶性事件，政治老师对我算是照顾有加，才愿意在看到我不动笔的情况下，“点” 我一下。

但天气是真的冷，冻手。

在 2010 年代的初中。

当你想要询问 ChatGPT 一些建议的时候，比如接下来做什么 side project，或者对于某种项目方向的看法，ChatGPT 会根据你的技术栈来推荐，或者说基于你最近提到的 XXX，推荐你做 YYY。

这是非常不好的一种现象，这样长期下去，你将无法从 ChatGPT 那里获得客观的建议，你自己的技术栈、信息来源，也都会被局限在你熟悉的范围内。

所以一定要关闭 ChatGPT 的 memory 功能，以避免信息茧房、判断茧房。

1. 王垠是编程语言理论、计算机科学理论方面的专家
2. 在区块链技术理论方面，目前看不到这种级别的专家，尤其是愿意公开发声、开课、讲授知识的

这样的事实背后是有原因的：

1. 计算机科学经过了几十年发展，区块链大概十几年
2. 区块链本身、从诞生之初就是工程化集成的产物，而不是理论创新

这会带来不同的现象：

1. 掌握计算机科学的基础理论，lambda 演算、图灵机、计算模型，理解计算的本质后，在编程语言方面可以长久复用、不会过时，无论上层语言、框架如何变化，计算的核心不会变化
2. 区块链工程似乎没有基础理论，没有什么技术是不会变的，也没有什么技术是需要长期积累的。从业者年龄小、新人多、工作内容以系统集成、调 SDK 为主

所以区块链的技术世界中，有没有什么理论性质的 “真理”，是长久不变、可以复用、无论上层框架如何变化都不需要担心的？

区块链技术世界的三大真理：

1. 共识。如何解决拜占庭将军问题。
2. 加密。以数学为根基的不可篡改、验证。
3. 激励。社会学博弈引擎，让共识长久运转。

掌握了这三个部分的技术，无论区块链形式上怎么推陈出新，无论行业热点如何变化，都不用担心，因为区块链本质上就是在解决这些问题。

怎么样才算是掌握了 “真理”？我看懂了、我理解了，算是我会了吗？算是我掌握了吗？

掌握真理的标准是，可以根据真理，从头构建出知识。

在计算机科学的世界里，假如世界毁灭了，给你一张纸和笔，你可以从头实现 lambda 演算、实现数据结构、实现一个解释器、实现一种编程语言，甚至构造出更多东西，不依赖于教材、框架、API，这叫掌握真理。

真理的意义在于，让你明白知识为何必须如此存在。——这也是王垠的课程在试图教会你的东西，王垠不教知识，只教 “王垠式真理”。所以我一直认为王垠的课程好、价值高。

类似的，在区块链的世界里，如果你可以从脚本写起，实现共识、加密、激励，不一定重建全部细节，但一定要理解现有系统为何那样设计，就差不多了。

要注意，智能合约的编程语言不在真理的范畴之内，无论是比特币脚本、Solidity、Move、Cairo，都只是表达交易逻辑的 DSL，都是在用不同形式，定义区块链执行交易的规则，很重要但是还没到 “真理层”。

非要说智能合约的真理层，可能可以表达为一个确定性的状态转移函数，无论语言如何变化，这个 “真理” 都始终存在：

State_t+1 = f(State_t, Transaction)

下一个状态来自于上一个状态加上一些交易引起的状态变化，简单吧。但我们这篇文章重点关注区块链世界中的 “王垠式真理”，所以依然是三大真理：共识、加密、激励。

对于 AA 钱包存在的问题，像操作繁琐、Bundler 中心化、可用性低、生态支持不完善、合约安全风险高等表面上的问题就不多说了。

一句话描述 AA 钱包在干什么事情：AA 钱包能实现 “对账户资金的授权” 与 “把交易广播到链上” 这两个行为的分离。

AA 钱包的功能

AA 钱包的功能，体现到具体的交易行为上，就是如果没有 AA 钱包，你得自己发交易。有了 AA 钱包，你可以只签名，不发交易，让其他人代替你把交易发到链上就行。

为什么 AA 钱包能做到这一点？因为 AA 钱包本质上就是一个合约，所以你会发现，AA 钱包的大多数 “优点”，其实是智能合约本身就具备的功能，像什么社交恢复、批量操作等。唯一能带来特殊体验的，只有 “代付手续费” 这个特性。

那为什么 AA 钱包能实现代付手续费这个功能？因为 AA 钱包的所有操作实际上不是交易，而是 UserOperation，有一个链下的 Bunlder 程序会把这些用户操作，通过发交易批量提交到链上。

为什么以太坊需要 AA 钱包

为什么以太坊需要 AA 钱包？因为以太坊的共识层协议要求，交易必须由一个 EOA 地址来发起。这个 EOA 地址，就是交易结构中的 from 字段，以太坊节点会从这个 from 地址计算手续费、扣手续费、验证交易有效性等。

合约没有私钥，交易不可能由合约发起。在这样的规则约束下，就导致以太坊所有的链上行为，都必须由某一个 EOA 地址来发起交易。

你可能觉得不对，部署一个合约，然后让合约来验证 data 里得签名数据就好了。data 里的签名数据，未必需要和发起交易的地址一致。

没错，事实上，AA 钱包的发展链路是：meta-transcations -> EIP-2771 -> EIP-4337。

这些方案在解决的问题本质上都是：如何让使用资金的权限，与发起链上交易的行为分离。

而引起这一系列复杂协议的根源，来自于以太坊 “交易必须由一个 EOA 地址来发起” 的规则。

为什么以太坊有这个规则

为什么以太坊要有 “交易必须由一个 EOA 地址来发起” 这个规则？

因为以太坊的账户模型，是账户-余额模型。协议必须要知道，一笔交易的手续费从哪里扣。

比特币不存在这个问题

比特币的 PSBT 交易格式，可以实现原生的多签。功能是多个钱包只负责签名，最终由另外一个钱包把交易广播出去就可以。

多签交易，就是典型的把对资金的授权，与广播交易行为分离开的场景。

为什么比特币不存在以太坊的这个问题？因为比特币使用的是 UTXO 模型，交易根本没有 from 地址，有的是多个输入脚本，节点只需要校验交易是否符合脚本的解锁规则，而不需要考虑手续费从哪里扣的问题。

AA 钱包的定位

我们梳理一下这个链条：以太坊使用账户-余额模型 -> 交易必须由 EOA 地址发起 -> 需要 AA 钱包。

AA 钱包在干的事情，实际上是在给以太坊的账户模型打补丁，为了修补账户-余额模型相比 UTXO 模型的不足，才有了 AA 钱包这个东西。AA 钱包是在不涉及以太坊协议变更的前提下，诞生出的一种 workaround 方案。

从地位上来说，AA 钱包对于以太坊的地位，类似于铭文/符文/RGB 对于比特币的地位。在比特币生态里，因为没有图灵完备的脚本，所以在不触及比特币协议变更的前提下，搞出了铭文/符文/RGB 这些 workaround方案。

AA 钱包需要链下的 bundler 来提交交易，与符文需要链下的索引器来维护符文的数据状态，是不是一个意思，都严重依赖于链下的程序？

而事实上我们都知道，比特币生态的玩法，至今都还没有被主流社会认可。

假如 AA 钱包未来有一天能被社会大众认可，那也就意味着 workaround 方案在区块链世界中是可行的。对于整个生态的叙事都将引起巨大的改变。

AA 钱包的未来

综上所述，我们能得出的结论是，以太坊永远不可能支持 “原生” 的 AA 的钱包（在协议层面支持）。

总结

这些结论，对于技术人员的指导意义在于：

1. 对 AA 钱包祛魅，不要以为 AA 钱包是高级、先进的技术。
2. 可以学习、使用、研究 AA 钱包，但是千万不要真的 “相信” AA 钱包的技术理念。

前几年写过的关于工作内容方面的回顾：

• 2024 年：《最近半年的工作》
• 2023 年：《半年的工作回顾》
• 2022 年：《一年的工作回顾》

这些事情只涵盖已经结束的工作，不包括正在进行的工作：

以太坊 PoS 网络的质押生态建设

不是以太坊主网，是自己发行的网络，因为用了以太坊 PoS 的共识模式，所以涉及到 32 ETH 质押的流程。这件事情也简单也不简单，简单之处在于，不就是以太坊节点的使用么？不简单的地方在于，以太坊一共有 5 种执行层客户端和 5 种共识层客户端，虽然都支持标准的 EIP 协议，但是节点关于 key 的导入、管理、发起请求的方式各不相同，节点的启动参数方面也有一些隐藏的坑。

写文档教程、在社区里引导用户、一对一 “辅导” 用户如何自己搭建 Solo Staker 节点，从前端页面发起质押交易，到后端节点拿着质押凭证启动 Validator 等，主要就这些事情。期间还尝试了用 Flashbots 搭建 MEV 节点、给以太坊客户端提交小的功能性 PR、测试不同客户端 EVM 执行效率的 Benchmark 等。

Hyperlane 跨链

Hyperlane 是一个去中心化的跨链协议，用 Relayer 和 Validator 两种链下角色，来保证跨链消息的有效和正确。当时做的事情是把 USDC 跨链到自己的网络上，印象最深的一个坑是那个时候 Hyperlane 还处于 heavy development 阶段，Relayer 节点直接把黑名单的变量名赋值给白名单来用，就上下两段逻辑，变量名复制错那种，用起来非常迷惑。然后还给他们提了 PR。

最后虽然自己搞明白了 Hyperlane 的原理，有能力搭建起一整套跨链环境，但仍然是以官方合作的形式，由他们的团队来维护一些链下节点，相当于给我们链开白名单、增加对我们链的支持。期间他们还有个对接的人离职了，说明团队成员的变动也大。

ZetaChain 的二次开发

ZetaChain 是一条 Cosmos 的链，提供了一种去中心化的资产跨链的方案。我们的项目主要做 Restaking，涉及到多链之间质押状态的同步，所以基于 ZetaChain 的机制做二次开发。

这件事情的难点在于当然得首先搞懂 ZetaChain 的代码逻辑，才能做二次开发。再一个是需要搞懂 Restaking 的业务逻辑，大意好理解，具体的细节不少。然后是 Cosmos 节点的开发和运维，链的部署、升级、回滚等。还有需要参考 CometBFT、Cosmos SDK 的源码结构以及代码流程，开发用于 Restaking 的 AVS 框架什么的。也就这些。

钱包后端开发

主要指非托管式钱包的服务端程序，给客户端提供数据来源，构建交易请求、返回余额、交易记录等，包括比特币和以太坊两个网络。还体验了一下用 Swift 写一个 iOS APP 的 Demo 界面，来演示给比特币交易签名的过程。

MCP（Modal Content Protocol）是 AI Agent 在使用的一种协议规范，用于 AI 和外部的工具进行交互，MCP Server 则是具体执行外部交互的组件。

MCP 区块链的含义是，首先它是一条区块链，然后每个节点都原生支持 MCP 协议的 RPC 接口，可以直接接受来自 AI Agent 的请求。每一个 MCP 请求，都是一笔交易（智能合约调用），这也就意味着，区块链会记录下所有的 MCP 交互历史。

节点内部的 MCP 执行引擎，功能分两部分，对于内部交互（EVM 在干的事情），只需要维护好内部的状态转移，把结果写入本地的 KV 数据库就可以了。对于外部交互，则只记录下要执行的请求本身，先不做外部调用。那么实际上对于每一个请求，都会改变本地的状态，所以这些交易是可以重放的，也就可以根据哈希值来确认节点数据的完整性。

至于对外部的执行请求，可以由外部的执行节点（一种角色）来完成。每一个外部请求都包含一些详细的参数，比如需要几个执行者、结果如何验证。交易会把一部分手续费作为执行费用，奖励给执行节点。如果执行节点作恶，自然也会有相应的惩罚机制。

对于外部的调用，关键在于如何验证外部执行的结果，这个问题可以交给调用者来定义，比如要创建一个 GitHub 仓库，验证方式就是，可以通过 API 查询到这个仓库的信息。

这就是 MCP 区块链的大体思路。

设计来源

解释一下这个想法的来源。MCP 区块链并不是想要 “把 MCP Server 去中心化”，而是想要 “给区块链带来与 AI 交互的能力”。这两种动机是截然不同的。

这个想法背后的逻辑很简单，比特币其实有脚本，只不过是生硬的操作码形式。以太坊干了一件很厉害的事情，给操作码加上了编译器，让开发者可以用编程语言来表达操作码。那么如今的 AI，很厉害的一点在于，打通了从自然语言到编程语言的路径。也就是说，未来的区块链，也许可以做到自然语言直接与状态机交互，而不需要经过 自然语言 -> 编程语言 -> 状态机 这样的路径。明显编程语言是一个中间层，MCP 区块链的设想在于消除这个中间层。

另一个边界在于，让区块链完全按照自然语言的意图执行是不切实际的，因为哪怕是人类，也需要书面形式的合同这种东西，所以代码本身不会消失，状态转移也不会消失。目前能够实现自然语言和状态机直接交互的技术方式，就是 MCP。

区块链的技术趋势

最近在思考一个问题，区块链的下一个技术趋势是什么？能明确的几个事实是：

1. 大家已经不再怀疑加密货币是一种支付手段这件事情
2. 依靠开发区块链发币的路线，已经完全没有叙事空间
3. 下一个技术趋势，绝不会是以太坊路线图的扩展

行业内已经提过的方向也都不大有机会，DeAI、ZK、Layer2、DeFi、跨链、RWA、GameFi、BaaS、NFT、元宇宙、DAO、DID 等等，都是陈词滥调了。

所以区块链在技术趋势上，需要的一个原语级别的新叙事。

按照我们之前分析项目的套路，在 Plasma 项目的官网首页，我又看到了几个不太乐观的信号：

1. 没有白皮书
2. 没有 GitHub 仓库地址

这两点不是一件小事。再来罗列一下官网首页对 Plasma 这个项目的描述：

1. 是一条 Layer 1 的链
2. 1000 TPS
3. 出块时间 1 秒
4. 专为稳定币设计

现在看到这样的技术指标，我不会猜他是 Cosmos 了，因为我会猜他是 Layer 2，但是他自己又说自己不是 Layer 2，那么 Plasma 的技术方案到底是怎么样的呢？

链架构

魔改 Reth 作为执行层 + PlasmaBFT 作为共识。

魔改 Reth 好理解，PlasmaBFT 目前则没有看到公开的白皮书和代码。

等等，这岂不是 以太坊执行层 + PBFT 共识层的套路？我前几天还刚折腾这个（《一个集成 Geth 和 CometBFT 的兼容层》）。

USDT 零手续费

简单来说，利用 ERC-4337（AA 钱包），估计是把 EntryPoint 合约作为预编译合约放进 Reth 了。

用 Paymaster 来代付手续费，这没什么好说的。

其他

没别的了，就这样吧。

我只需要告诉 AI，我需要改哪里，期望的效果是什么，AI 完成的效果就很好，而且 AI 的效率很高，也不怕累，AI 技术的发展，真正实现了解放我们双手的愿景。

这不由得引起一个思考，AI 会取代程序员吗？王垠的课程，能够帮助程序员抵抗这种来自 AI 的冲击吗？

AI 的水平

如果你用过 AI 写代码，就会明白目前的 AI，还不可能真的取代程序员，因为很多事情做不了，很多事情会做错，需要人为判断。

但即使是在短短半年前，把项目完全托管给 AI 来开发，都是不敢想的事情。半年前，我在工作中还是手动复制 AI 写的代码的模式，因为不敢让 AI 直接动项目。但是现在，AI 的 Agent 模式已经真的可以投入使用。我印象里 AI 的 Agent 模式也就今年才出现。

而且比起两年前，现在 AI 的发展速度更是非常可怕。两年前还是 GPT-3.5 的时代，不能识别图片，文本处理也存在很多幻觉。经过两年时间的发展，现在 GPT-5 的能力已经非常厉害。

所以 AI 的水平很高，虽然现在还没有特别高，但是真正让人害怕的，是 AI 的进化速度。

我常用的 AI

我自己的主观感受上，还是 GPT-5 模型最靠谱。

因为我有正事要干，没有那么多时间去试错，Claude Sonnet 4 给人的感觉就是手过于勤快，方案还没定，代码写出一堆，删都删不过来。他自己给出 A、B、C 三种方案，结果在描述方案的过程中，就把三种方案的代码全写了。相比之下，GTP-5 就好一点，会先问你用哪种方案，然后再动手。Gemini 2.5 Pro 没太用过。

我用的编辑器是 VS Code，装了 GitHub Copolit 和 ChatGPT Codex 两个插件，这两个插件都选择 GPT-5 模型。Codex 用来执行复杂任务，Copolit 做轻量级的改动。

所以我对于 AI 编程的感受主要来源于这样的使用环境。如果你用了其他的模型，或者其他的编辑器、工具，可能会跟我的感受有出入。

明确话题

回到正题，我们的话题是，王垠的课，能不能抵抗这种来自 AI 的冲击？

首先是 AI 到底冲击了哪些程序员。最大的冲击是对于 3 年以下工作经验、对业务场景和技术选型都没有判断力、工作内容以领导安排为主、自己动手实现代码为结果的程序员群体。

AI 最擅长的，就是在业务场景清晰、工作目标清晰的情况下，完成代码。所以以前在公司里的小组长，有花费口舌跟新人讲清楚需求的功夫，完全可以跟 AI 描述清楚需求、AI 就把活干了。而且 AI 态度比人好、动手能力比人强、写起代码来比专家都专业。

目前的 AI 还不能取代的是在复杂业务场景下、需要对技术选型、技术方案做决策的程序员。不过这些程序员本身已经不太是基础的技术岗位，通常已经不怎么写代码。

所以进一步明确，我们在讨论的话题是，对于需要动手写代码的程序员来说，王垠的课，能不能提高这一类程序员的竞争力，抵抗至少是延缓 AI 的冲击，比其他程序员晚一步被淘汰？

王垠的课

我按照之前一天一道题目的计划，第三轮做练习题，最近刚做完链表相关的部分。

（题外话，想想在面试过程中，凡是让你现场写代码、做题的公司、面试官，是不是都挺扯的。不信你随便拿一道王垠出的练习题，给那些人做，你看他们能不能做出来。所以建议大家，凡是面试流程中需要做题的公司，无论面试是否通过，一律马上拒绝。）

我在 4 年前就自己写过 链表反转 之类，但是用了非常笨拙的写法，一个节点的上一个节点指向哪里、下一个节点指向哪里什么的，来对链表进行各种操作。

王垠课程里的链表，利用纯函数式的写法，以及递归的思想，代码非常简洁优雅，完全不需要考虑上一个节点、下一个节点这种东西。即使已经是第三次面对这个题目，因为已经忘了之前是怎么做的，我也很犹豫，链表反转是能用一两行代码实现的吗？终于在第三次做出题目后，才明白真的可以简单到这种程度。

所以我想说的是，王垠的课程，思想大于形式，真正能教会你的，不只有表面的知识那么简单。

同样的链表反转，初级程序员写出来是一个样，高级程序员写出来是另一个样，真的会不一样。也许表面上代码都能运行，都能达到目的。但是当面对更复杂的系统设计问题，是不是也应该尽可能做到简洁、优雅、清晰、可靠？

当你见识过最清晰的反转链表应该怎么实现，你就知道，噢，链表反转有着各种各样的写法，复杂的写法往往存在这样那样的问题，事实上问题的解法可以更优雅。

当你面对一些复杂的功能需要实现，你可能会用同样的思路去思考，是不是有更加简洁优雅的方式，来干这个事？

你只有见识过更好的东西，才能明白，什么东西更好。

AI 可以帮你干活，但是不可能代替你水平高。

当你没有见过更好的东西，你可能不知道什么是好的，想象不出什么是好的。然后你去告诉 AI，你帮我写一段很好的代码出来，AI 写了三个版本，你都不满意，最后 AI 问你，什么是 “很好的代码”？你自己也不知道。

就像我在《一个集成 Geth 和 CometBFT 的兼容层》中提到的观点，AI 可以替你干活，但是 AI 不可能代替你懂。

需要懂吗

你可能想问，AI 帮我把活干了就行，我为什么非要懂？我不在乎代码的好坏，事实上也没人在乎，老板不在乎，客户也不在乎。只有一些自以为是高人一等但是没有实权的老员工、小组长在乎。

这其实正是我想说的，王垠的课，不局限于代码，而在于思想。

说实话，王垠课程中对于代码形式上的规则，几句话就可以说清楚。而且大部分王垠在之前的文章《编程的智慧》中都写过。（我发现现在文章被删掉了，看起来王垠删掉了很多有价值的文章）。

真正重要的不是明面上的规则，而在于课程是如何对知识化繁为简的，为什么这样是好的，那样是坏的。

同样的思想，可以迁移到其他问题上，什么是好的，什么是坏的。

你可以不在乎代码，但是始终要面对数据结构、算法、系统架构、复杂度、性能等问题。除非你真的什么都不需要面对。

AI 能解决这些问题吗？能，但是你得给 AI 说明白需求，然后看明白 AI 给你的方案，最后你来决定选择哪一种。如果你看不懂 AI 在跟你说什么，那你就不能控制 AI 了。

还是那句话，AI 不可以代替你懂。

王垠的观点

我一直在说 “AI 不可能代替你懂”，这是我自己使用 AI 编程的体会。

王垠在以前的文章《人工智能的局限性》，包括最近在微博上，都描述了他对于 AI 的核心观点，那就是 “AI 没有读心术”。这个和我们日常使用 AI 编程的体会是一致的，你必须非常清晰告诉 AI 你想要什么，AI 才会给你什么。如果你的描述是模棱两可的，你忽悠 AI，AI 也会敷衍你。你说不清楚，AI 就做不明白。

王垠的课能帮助程序员抵抗 AI 的冲击吗？也许可以吧……假如不可以，那该怎么办？

问个小问题，已知 Kaia 是一条 Layer1 的区块链网络，EVM 完备，并且具有以下 3 个特性，猜猜 Kaia 的技术栈是什么？

我自己的猜测是，Kaia 是用 Cosmos SDK + Evmos 方案搭建的一条链。因为 Kaia 的第 1 条特性很眼熟，明显是 Cosmos 链的指标。第 2 条则直接确定了是 PBFT 共识。第 3 条中规中矩。

结果怎么样呢，结果打脸了，Kaia 的技术实力比预期硬核，自己设计了叫 IBFT 的共识，整个链的 节点代码 都是自己开发的，从 6 年前开始就有提交记录了！（不过话说开源了 6 年只有 46 个 star 是怎么回事？）

EVM 完备

不得不承认，Kaia 的节点源码很硬核，全部代码都是自己开发的，几乎没有引入外部的依赖。

比如 Kaia 的 文档 中说，Kaia 支持以太坊的智能合约。是怎么支持的呢？一般的链可能会直接用 Geth 的节点，或者至少引用 go-ethereum 的依赖。Kaia 是怎么做的呢？Kaia 自己 实现 了一个 EVM：

在 opcodes.go 文件中能看到完整的 OpCode 的定义：

这不是一件简单的事情！开发一个 玩具 EVM 也许并不难，但是要完全实现 EVM 的特性，做到生产级别可用，真不是一件容易的事情！

就在我惊讶于 Kaia 的硬核程度的时候，我忽然想到什么，再仔细看了一下 Kaia 的代码，注意开头的这句话：

算是一定程度上可以理解了，Kaia 虽然没有以外部依赖的方式引入 go-ethereum，但是把 go-ethereum 其中的代码原文件复制到了项目中，“假装” 是自己的代码。

再来对比一下 vm 相关部分的代码文件，这是 Kaia 的：

这是 go-ethereum 的：

几乎一模一样。这下 “破案” 了。Kaia 要真有实力自己开发一个 EVM，那还真是对不起仓库里的 46 个 star 了。

PBFT

对于共识部分，我一开始的理解有误。仔细看了一下，其实 Kaia 直接在 文档 里说，自己用了 Istanbul BFT 的代码，Kaia 倒是没有想虚假宣传，我还翻了半天代码。

可以看到整个 Kaia 的节点代码，是 fork 自以太坊的，然后把 Istanbul BFT 集成到了原本的代码中，形成了现在的节点。这种做派，把别人的源码拿过来，改改这个、改改那个、集成一下，有没有一点似曾相识的感觉呢，是不是很像国产的联盟链的风格。

小结

总的来说，Kaia 在技术上没有太多让人眼前一亮的地方，因为最近在亚洲有一些宣讲的会议，我才注意到这个项目。总体感觉是一条中规中矩的链吧，没有技术亮点，应该不会引起市场的关注。

之前提到的 Arc 项目有很多存在技术疑点的地方，比如如何实现稳定币支持手续费？这实际上不是一件简单的事情，尤其是不想魔改 Geth 的话。看看 Codex 能解决这个问题吗。

难道 Codex 的定位是和 Arc 强市场吗？竟然在首页上大屏幕放 USDC 的 logo。

要留意的一点是，Codex 的首页上没有 Github 链接，也没有白皮书链接，这通常不是一个好的技术信号。不过另一方面，Native USDC 已经在 Codex 这条链上，所以 Codex 的企业背景和公司实力本身没有问题。

本来想说遇到这样的项目很头疼，既没有代码也没有白皮书，我分析啥。然后翻了翻文档，大多数是一些概述性质的东西，没有实质内容。

终于翻到了 最后一个章节 的页面，就这一句话，真相大白，什么问题都清楚了：

这里的 Conduit 是干什么的呢？Baas 平台、一键启动一条 Layer2，就这么回事！

Codex 的性质，和 Camp Network 一样。

Conduit 的收费比 Gelato 稍微贵一点点，主网需要 5000美元/月，测试网 250美元/月。不过这点钱和整个项目与网络的营收比起来，应该无所谓了。

所以怎么样呢，是不是这样就理解了，为什么 Codex 的首页，既没有白皮书也没有代码？事情就是这样。

最难以让人理解的一点是，Vitalik 竟然在支持这样的项目，Vitalik 是技术出身，难道丝毫不在意一个项目的技术含量吗？

在对 Arc 项目 进行分析的过程中，发现 Arc 干了一件很有意思的事情，先是自己开发了 Rust 版本的 Tendermint 共识 malachite，接着开发了一个对接 Reth 和 malachite 的兼容层 malaketh-layered，也就是说，Arc 这条链的架构是这样：

Reth -> malaketh-layered -> malachite

最终形成了一条完全以太坊等价的 PBFT 链。

那么有没有类似架构的链，直接把 Geth 和 CometBFT 给结合起来呢。是有的，Berachain 开发了一个beacon-kit，干的就是这样的事情，Berachain 主网本身就是这种架构启动的。

但是 beacon-kit 有一个问题，就是代码过度 “复杂”，不但自己设计了 slot 的概念，还把 Berachain 的一些经济模型的设计、LST 质押之类的东西都放到了 beacon-kit 中。所以虽然 beacon-kit 在工程上是一个 Geth+CometBFT 可行的实践，但是它本身并不是工具性质的立场在做，夹带了不少私货。

因此我觉得需要一个通用的、工具性质的兼容层项目，目前命名为 EthBFT。这个项目的愿景是，提供简洁、开放、最小实现、工具性质的架构，达到集成 Geth 和 CometBFT 的目的。整个区块链网络的架构会是这样：

Geth -> EthBFT -> CometBFT

EthBFT 主要干两件事情：

1. 通过以太坊执行层的 Engine API 拿区块数据
2. 把区块数据通过 ABCI 接口提交到 CometBFT

这里虽然用 Geth 举例，但对于其他以太坊的执行层客户端，应该也是通用的，因为以太坊的执行层和共识层客户端，本来就是互相兼容的，仅仅通过 RPC 接口通信。所以预计 EthBFT 可以兼容全部的以太坊执行层客户端。

而 EthBFT 的设计，自然不会和 Geth 或者 CometBFT 有代码层面的耦合，EthBFT 是一个独立的进程，可以单独启动，Geth 也可以单独启动，CometBFT 也可以单独启动，3 个组件之间，彼此通过 RPC 接口通信，具体的 RPC 接口地址等信息则会体现在 EthBFT 的配置文件中。

这就让 3 个组件互相之间，完全解耦了。

对 PBFT 的信心

我之前以为区块链技术的发展会趋于追新，也会趋于去中心化，但是发现似乎不是那样。

从前两年的 Celestia 使用了 PBFT，到 Hyperliquid 改进了 PBFT 共识，再到最近 Arc 项目自己实现了 PBFT 共识，证明在高TPS的场景下，PBFT算法还非常有活力。

PoW 和 PoS 去中心化程度高，但是不能满足高 TPS 的需求，也不能达到最终一致性的要求，这些都是 PBFT 特有的优势，尤其是企业级的应用场景下，没那么在意去中心化。

我们也许会有疑问，如果不在乎去中心化，那直接用 Server 端提供服务不就行了吗，用区块链干什么。在丢失去中心化特性的前提下，至少区块链还保留有数据公开、数据变更可追溯等特点，也是一些不错的优势。

因此，PBFT 这种诞生接近 30 年的算法，将来还会继续发光发热。也因此，去搞一个 PBFT 相关的项目，不会有太大问题。

项目前景

EthBFT 肯定不会受到市场的关注，因为大家只在乎一条链能不能发币，能不能套利，并不在乎你的技术架构是什么。

EthBFT 只是一个工具性质的项目。如果一个开发者，想要一条以太坊完备的链，同时又想要高 TPS，在没有 EthBFT 的情况下，需要怎么做呢。我懒得展开分析对比搭建链的方案了，总之我觉得 EthBFT 可以填补这部分的空缺，非侵入式那种。世界上缺一个这样的工具。

对 AI 技术的怀疑

现在 smallyunet/EthBFT 项目已经有了基本的框架，能跑通最小版本，我把它归档为 v0.0.1 版本。能跑通的表现是 Geth 的区块高度会逐渐增加，CometBFT 也在正常出块，Geth 和 CometBFT 的区块高度保持同步。当然现在还属于非常早期的版本，开发时间有限，功能上肯定有不完善的地方，接下来还会继续改进。

我之前说 鼓吹 Cursor 的人技术能力都差，因为 AI 可以放大你的能力，但是不可能代替你懂。v0.0.1 版本的 EthBFT，全部代码都是 AI 写的，没错，但是以 EthBFT 这个项目为例，现在要干的事情非常清晰，你可以试试，在不懂以太坊和 Cosmos，甚至不懂技术的情况下，完全托管给 AI，能不能搞出一个能运行的、EthBFT 这样的项目。

如果你自己对技术的理解不清晰，或者有错误，关键是 AI 不会纠正你的错误，因为 AI 并不知道你心里想要的 “正确” 是什么。AI 会非常听话地按照你的描述写代码，如果你语焉不详，AI 写出来的代码必然会跑偏，朝着错误的方向发展，而且很多时候 AI 会自己偷偷埋坑，你以为它实现了，结果它要么没写全，放了个 TODO 在那儿，要么按照自己的理解写出一大堆不需要的代码。

所以让 AI 把代码写对，其实不是一件容易的事情，首先你自己得懂，然后你得时刻盯着它干活。AI 始终只是助手而已。

Soneium 是索尼推出的区块链网络，就是制造相机和拍电影那个索尼，公司背景非常强大，应该是没兴趣自己发币的，至少不是以发币为目的发行一条链。Soneium 是一条以太坊的 Layer2 网络，所以接下来技术方面的内容，应该会聚焦到以太坊 Layer2 上，比如用了哪种 L2 方案，网络参数是什么，有没有创新和改进，等等。

Soneium 的文档里明确说了，用的 OP Stack 方案，并且加入了 Superchain 生态，应该是直接使用了 OP Stack 开源出来的技术方案，没有自己做改进那种。这其实也有意思，一方面，Base 和 Sony 都在用 OP Stack 做 Layer2，项目周期肯定是一年以上的。另一方面，Vitalik 一直在说 ZK 是未来技术发展的趋势，要用 ZK 技术把 L2 的提款速度缩短到 1 小时内。假如 ZK 体系成熟了，OP Stack 能无缝升级吗？感觉不太能，因为历史交易完全不能验证。

（我发现 Vitalik 的博客现在不能访问了 vitalik.eth.limo ，应该不是简单的网络问题。这就是用 IPFS 搭博客的坏处。以前 Vitalik 有个 .ca 域名的博客，后来直接不用了，转到了 .eth.limo 上。）

这也引起我们一个思考，Sony 现在都在用 OP Stack 搞 L2，我们要不要搞呢？现在 L2 已经不是两年前的热度了，但是 OP Stack 的技术方案经过了生产级别的验证，现在更稳定可靠。至于 ZK L2，有个问题是需要非常强大算力的服务器来做 prover，跟矿机一样，有点不是太友好。

在技术难度上，OP Stack 的部署和运维是相对简单的，而且只需要 follow OP 的技术动态就可以，对于企业或者项目方来说，也许会是不错的选择。当然，只是得维护一大堆 合约 了。

说实话 Soneium 在技术上没啥亮点，这个项目简单到连白皮书都不需要，玩的就是生态。

• 2025.08.07（UZX）

交易所的钱包开发职位，Java开发岗，面试 10 分钟就结束了。

• 2025.08.12（Matrix Port）

风控部门的后端开发职位，重点在乎微服务一类技术。

• 2025.08.17

一个线下交流会，不是面试，我主要也是看有没有工作机会才去的。

很无聊，是一个叫王道元的人组织的，我在活动行上看到的活动。我从一开始就感觉这个活动有问题，因为这个人看照片就不太聪明的样子。后来到了交流会现场，还真是不太聪明，说自己是研究易经的。

离谱的是，这样的人，竟然能给比特币募资项目做策划，他们现在在整的项目，也私募到了90万人民币左右。我很奇怪，为什么这些人挣钱这么容易，脑子不好，傻子太多。这个交流会本身，是他们私募拉人的渠道。

至于项目本身，就是不懂行的人在试图搞传销。

• 2025.08.18（tako.so）

项目基于 Op Stack 搭建一条链，试图把社交行为上链。重点集中在研究提升 Layer2 的 TPS 上，研究怎么把交易并行处理、优化冲突检测方面。

面试官比较重视 Go 语言的底层，比如 GMP 的原理、Context 的实现原理等。这些语言相关的技术我都没有关注过。

• 2025.08.20（cina）

Solidity 开发岗位，面试官有点为难，因为我很少有 DeFi 相关的工作经验，所以不知道该具体问我哪些问题。

但是面试挺有意思的，面试官人不错，分享了很多对 DeFi 生态的见解。

• 2025.08.22（艺洲科技）

和老板聊，对方介绍了一些项目情况。

• 2025.08.23（艺洲科技）

技术面二面，非常简单地聊了一下。

这个项目不是很靠谱，选择接受这个项目的原因有：

• 先接着，看看情况，工作强度、技术含量等
• 骑驴找马，还要继续找工作
• 这个项目给的全是代币，很不靠谱
• 刷一点经验，简历上能多写一条

最后因为同事的态度问题，没有加入。

• 2025.08.25（bitget）

链上数据特征分析岗位。随便聊一聊。面试官水平不行。

我不是说面试官不可以 “水平不行”，只是有时候想不明白，为什么水平不行的人，可以当面试官。

• 2025.08.28（不知道公司）

做 ZK Layer 2 链的公司。

有感而发（2025.09.02）

经过这么多次面试，我发现，凡是在面试中只关心你能不能干某一件事情的，这种面试都不靠谱。

比如在过去的工作中，你干过 10 件事情，然后有的面试官只关心其中 1 件事情，问你能不能做，到什么程度。而其他 9 件事情，面试官视而不见，丝毫不提。他根本不是在招聘你这个人，而是在招聘一个能干某个活的人，这种位置必然是工具人。这种公司不去也罢。

还有一种情况我也不理解，面试官说，你说你没有了解过某些东西，那你去了解一下，了解之后我们再来聊。

我觉得这样的做法非常不合理，技术调研本就是工作之中的事情，现在你要我先调研，证明自己的能力，然后继续面试？我觉得这样的做法很侮辱人。我不是不愿意学，反而很有兴趣，但是这种态度和姿态，让我感到生气。我不想去这种公司和项目，面试官不尊重人。

Berachain 就干了这个事情。要是只看 Berachain 的官网，肯定会觉得这是一个不怎么严肃的项目，因为首页用了一堆花里胡哨的元素展示信息。但是 Bearchain 开源了一个叫 beacon-kit 的仓库，作用就是对接 CometBFT 和 Geth，一键启动一条原生 EVM 客户端 + PBFT 共识的链。（如果 Bearchain 没干这个事情，我就想干）。Berachain 的项目创意是受到 Arc 启发吗？不好说。

在没看代码的情况下，猜测把 Geth + CometBFT 中间层需要做的事情，大概是当 Geth 生成 Payload 后，把 Payload 给 PBFT 出块，然后把出块结果返回给 Geth。所以应该不会特别复杂，主要是监听两侧的事件，然后做好接口之间的字段转换。

不过从 beacon-kit 的代码量和提交次数来看，这事好像没那么简单，或者 Berachain 把事情做复杂了。malaketh-layered 的代码量显然没那么大。

因为项目复杂，具体的源码解读还需要点时间。目前关注到的一个疑点是 Berachain 沿用了 slot 的概念，这有点奇怪，slot 是以太坊共识层的概念，Geth 里没有，CometBFT 里也没有。当然，Bearchain 是提供了一些解释的，比如 架构文档 里提到 slot 和区块高度的映射关系，以及 代码注释 中提到 Bearchain 的设计不允许有空槽等。

beacon-kit 还需要维护数据库、做状态转换……总之初看这个项目感觉没有想象中那么简单，虽然不是开发新的链，听起来像是在集成一些启动脚本，然而事实上做的事情又有点多，多到我有点怀疑这些东西是不是必要的……我觉得有必要后续再深入了解下源码，并且自己试着做一个兼容层试试。

在看到 Berachain 文档中关于 Proof-of-Liquidity 的部分后，基本上就能知道 beacon-kit 确实是偏复杂的，因为 beacon-kit 根本不是一个工具类型的仓库，而是带有 Berachain 特有的一些经济模型逻辑，比如有 MockPOL 相关的合约代码等，beacon-kit 就是 Berachain 本身，复杂也是能理解的了。看来世界上应该还需要另一个轻便一点的兼容层。

至于 Bearchain 的其他方面，因为是 EVM 兼容的链，所以各种 DAPP 自然能玩。X 上有接近 1 M 的粉丝，关注量很高，代币 $BERA 在今年 2 月份就上了币安等交易所，市值排名 150 名左右。我有点小看 Berachain 的经济实力了，竟然在分析这个市值排名第 150 的链。这已经没什么可怀疑的，主要还是学习下 Bera 的技术。

新的定投策略

现在把新的定投策略调整为这样：

1. 定投频率：每周一次
2. 定投金额：100 美元
3. 定投标旳：比特币（BTC）

就这么简单，不再整那些花里胡哨的东西，只投比特币。至于以太坊或者其他平台币，想用的时候买就行了，手续费用不了多少，价格也高不了多少，没必要因为 “可能要用” 而提前布局。

你也许会犹豫，比特币现在的价格这么高了，还可以买吗？定投策略本身就是在消除对入场时机的顾虑，毕竟这是定投，不会一下子把钱砸进去，所以不用那么在意此时此刻的价格。关于定投策略的优点，李笑来的《定投改变命运》里已经有非常详细的解释，这里不多复述。

你也许会纠结，以太坊最近涨了那么多，接近历史新高，ETH/BTC 汇率持续走高，BTC 市占率持续下跌，为什么只选择定投 BTC 这一个币种？我的建议是，不要 FOMO。在接下来半年到一年的时间里，像以太坊一样动人心弦的例子还会有很多，不是可能有，是一定会有，也许每一次都会让你后悔，当初怎么没选这个币？要是早点买早点定投就好了。所以还是那句老话，不要 FOMO。

之前的错误

我之前犯了很严重的错误，也许是出于想体现出自己 “知道的多” 的心理，在定投组合中，选择了非常多小币种。现在差不多一年过去了，根据计算，实际上的收益效果比较差，大概在 22% 左右，这个收益率还不如全买 BTC 的涨幅。

当时有几个月的时间，我确实是按照定投组合在操作，但是后来由于这些原因，我自己都没能坚持下来定投这件事情：

1. 某些币种比例太小，导致金额也小，假如一天定投 10 美元，某个代币占比 5%，一天就是 0.5 美元，一个月下来一共 15 美元。这样的金额即使涨 50% 或者跌 50% 都不会有感觉。而且这种小金额的代币一直放在账户里，也会让人不舒服。所以主观感受上，天天看到这些币种很难受，会想清理掉他们。

2. 由于我时常关注加密行情的变化，有时明明知道价格下跌了，但是由于定投计划的存在，我无法手动加仓；有时明明知道价格上涨了，但是由于定投计划的存在，无法暂停定投。这样的感觉也很难受，像是被定投计划操控一样。

3. 对于山寨币的风险预估不足，后来逐渐认识到山寨币的价值有限，而定投计划一开始给了山寨币比较高的比例，造成我头脑中的计划调整频率很快，快到定投策略跟不上。另外由于我的投资预算的不稳定，也就是收入和支出的不稳定，经常需要动一些钱，导致定投计划不得不暂停、重新开始。

所以不管以前怎么回事，以前的定投策略始终是有问题的，连我自己都无法好好实施。

黄金

注意这里只是 “加密货币” 的定投策略，不包含其他资产类型。比如价格锚定黄金的 PAXG 代币，不属于 “加密货币定投策略”，但是我会买、会定投，策略也是一样的：

1. 定投频率：每周一次
2. 定投金额：100 美元
3. 定投标旳：黄金（PAXG）

美股

要这么说，把 BTC 和 PAXG 两个代币列出来不就行了吗？为什么还要强调黄金是不同于加密货币的资产类型？

因为 Kraken （海妖交易所）上支持买美股了。代币是发行在 Solana 链上的。我不懂美股，现在不能制定美股的定投计划。假如认为价格锚定黄金的代币算加密货币的话，那价格锚定美股的代币，算不算加密货币呢？事情就变复杂了。

美股上链这事还挺有意思，给未来带来了很多可能性。时代在发展，社会在进步，越来越有意思了。

关于卖出策略的疑问

人们常说，你无法同时拥有青春和对青春的体验。同样的道理，你无法同时享受拥有比特币，和比特币价格上涨带来的财富。

假如你现在还年轻，你需要钱，你要买车，你要旅游，你要体验生活。然后你把比特币卖了。等到老年之后，你会不会后悔？也许到时候会想，假如当时没卖掉，现在价值可就翻了很多倍。

要么放弃当下的享受，要么换来日后的后悔。怎么选呢？

为什么说是 “再次” 呢，上一次遇到类似的情况，是在：

• 《从团队内部的混乱想到……》
• 《关于 Code Review 的礼节》
• 《鼓吹 Cursor 的人技术能力都差》
• 《因为同事的不尊重，我换工作了》
• 《回忆同事被另一个同事赶走的事情》

一个人，能让我连写 5 篇博客，从各个角度去思考这件事情，也算是不一般了。

而这一次，因为我参与项目不深，所以不需要考虑太多，直接拒绝就好了。

我在口头答应加入项目后，经过了一天时间，就感受到了项目各种不靠谱的地方，所以选择离开。

项目里有个同事，老板给他反复打电话，他不接。老板特别着急，说有几百万的投入收不回来，十几号人等着他测功能。那个同事却闲情雅致，在给猫做绝育。然后老板打电话给我，对我说了一些带情绪的话，说的好像我和那个同事是一伙似的。我仅仅加入项目一天而已，而且是周末，连交接都没有，我都还没有开始正式工作。

我搞不懂这些人是怎么回事，反正很乱，老板和开发之间节奏脱节。这个项目招人，就是因为那个同事不靠谱，出活慢，才开始招人。然而事实上开发进度已经延迟了（我有点不懂，为什么我遇到不止一个项目，都是进度已经出问题了，才招人）。我的工作是帮这个同事分担工作，但是这个同事竟然不愿意花时间跟我交接。搞不懂。

这么凌乱的项目，你们自己去玩吧。

我的工作反复因为这种人而不稳定。是他们对我不好，我只是不想让自己受委屈而已。

从去年开始，我的职业道路就很不稳定。我想，只要我愿意 “受气”，就可以有稳定的工作、稳定的收入。

但是我不愿意。

我有时候也怀疑，自己是不是应该放低姿态，去忍受职场上各种各样的问题，忍受那些不礼貌、不尊重人的行为。

我的出身并不好，学历也不好，像我这样的人，在中国社会里比比皆是，泯然众人。

很多名牌大学的人，甘愿在公司里忍气吞声，沦为牛马、都市隶人。

我又有什么资格，表现出如此强硬的姿态，连续两次主动拒绝工作？

这引起一个问题，是不是只有有钱、有地位、特别优秀的人，才有资格拥有尊严、得到尊重、站着挣钱？

我觉得不应该是那样。

我们工作中挣的工资，是劳动报酬。我付出劳动，你给我报酬，合情合理，公平交换，谁也不占谁的便宜。

但是有些老板、同事，自以为给了钱，或者工资高，或者年龄大，就以居高临下的口气跟你说话，甚至把某些情绪带到和你的对话中。这是他们缺乏教养。

技术问题我可以解决，但是情绪问题？你以为你是谁？

我遇到过不止一个老板，认为只要花钱，就可以招到人，只要花钱，就可以解决问题，只要花钱，别人就愿意给他工作。

至少我不愿意成为那样的人。

很多人畏惧于孔乙己脱不下的长衫，但是却不去质疑，孔乙己所处的社会环境是不是有问题？一帮干力气活的人去笑话一个文人，是不是本身就很荒谬？

出身卑微，人格也必须卑微吗？

我过往的工作经历，已经能证明我可以做出某些事情。我在博客上维护的这些内容，也可以佐证我懂一些东西。这两个部分加起来，可以说明我有一些实力。只是我有点不确定，这种实力标签，能不能掩盖 “出身不好”、“学历不好” 这种社会标签。

我想起一个有意思的现象，凡是看过我博客的面试官，在面试中都会表现出某种 “没气势”，即使工作不合适，也会友善的交流。而那些在面试中各种考核我、给我出题、甚至出言不逊、表现出不尊重的，都是没看过我博客，甚至我的简历他们都没仔细看的。他们面试人就一套标准模板，根本不在乎你的简历。

以前我的博客都是毫无保留的，最近开始收敛，比如之前写的《我从王垠的计算机科学课学到了什么》，后来我就想，我为什么要毫无保留的说出，我学到了哪些东西？所以目前就只剩下一个片段《王垠的计算机课程贵吗？》。博客内容的其他方面也还在调整。我其实不喜欢什么 “GMP原理”、“比特币脚本教程”、“DeFi教程” 什么的，都是很生硬的技术，没意思。但是我不写出来，有的人就觉得你不会，所以是没办法才写。

回到工作的话题。经过我切实的工作经历，我发现一线城市之外，尤其是连深圳那种二线城市都不如的，像什么厦门、南昌一类，生活在那些地方的同事，往往更容易工作能力不行、工作态度不好、工作带情绪、脾气大、不尊重人、不礼貌什么的。这一定不是个例，一方面那些地方文明程度低，生活节奏慢，可能脱离职场环境。另一方面，生活在那些地方而不是一线城市，本身就说明这个人能力不行，混不下去了回老家。所以工作中，尤其是这个行业的工作中更容易接触到，来自天南地北的同事，要警惕那些生活在小城市的同事。这也就说明了，为什么有些公司招聘，即使允许远程，也要求工作地的原因。

虽说中国的月亮没有外国的圆，但是中国的一线城市，即使放眼全世界，也是能排得上号的那种。你要说上海不如纽约，我觉得不如。但是不和顶尖的城市相比，中国的一线城市，本身还行。所以如果不能全球各国去跑，也至少要停留在一线城市。

设想一下，假如你不想学王垠的课，但是又想掌握课程中的知识，有哪些途径？

你花同样的钱，是没有其他地方可买的。世界上还有其他华人，能有王垠的学识背景，并且在经过几年的教学试验后，整理出如此精品的课程吗？这种水平的课程，有市无价！

你也可以自己去求学，先掌握流利的英语，然后考个美国顶尖大学的硕士，经过几年的留学生涯，不但花很多钱，还要付出许多时间、精力和努力，还需要一些天赋和运气，才能学到与王垠课程同等水平的知识。你付出的代价，远远不是只花钱就够的。

你还觉得王垠的课程贵吗？

课程的内容

我刚才对王垠课程的描述是 “这种水平的课程”，那到底是什么水平呢？我可以举个具体的例子。

课程的第 1 课讲函数，对吧，所有程序员都知道函数是什么，即使不是程序员，初中上数学课也知道函数。

学习课程以前，函数是什么？函数是编程语言的语法之一，作用是把很多行代码包裹起来，方便以后重复调用。面向对象里面叫 “封装”。函数就是个特别基础的概念。

学习课程以后，函数是什么？函数可以是 “计算” 的基本元素，函数可以作为计算的输入，也可以作为计算的输出，一个计算的输出可以作为另一个计算的输入，输出的函数可以被另外的函数调用……

我这么说你肯定没看明白。

换个角度解释，王垠的导师 Daniel P. Friedman，有一本出版的书《The Little Learner》，Guy L. Steele Jr. 在给这本书的序言中写到，Friedman 在这本书里用高阶函数（higher-order functions）的 4 种不同用途，表达了机器学习（machine learning）的核心原理。

你是不是不相信，函数可以表达深度学习的原理？那就去了解一下 lambda calculus，一种和图灵机同等地位的形式化系统，可以表达的是整个计算机体系，而不只是深度学习。

这才是 “函数”。第 1 课学的函数，是这个函数。

Arc 是 Circle 公司在筹备和计划推出的一个 Layer 1 区块链网络。8月12日，Circle 正式发布了关于 Arc 的 宣发文章。Circle 就是发行 USDC 代币的公司，拥有强大的技术实力和资金背景。

由于 Circle 的强大背景，我们几乎不需要怀疑 Arc 的技术含量，一定能做到世界领先级别的，也许会像当年的 SOL 一样，值得持续关注。

Arc 目前处于测试网还未公开发布的阶段，只允许合作伙伴加入的测试网。公开的参考资料只有白皮书，不过出于对 Circle 技术实力的信任，白皮书中肯定包含了技术创新在里面的。

假如将来 Arc 正式上线，想必会改变的，不只是稳定币赛道的格局：

1. 其他稳定币公司开始做 Layer 1 链
2. 既然 USDC 可以作为原生代币支付手续费，其他所有 ERC-20 都可以
3. 世界将迎来代币原生化的浪潮，项目发行代币的，都会自己搞一条链，自己的币付手续费

所以了解 Arc 的技术架构对我们以及未来的发展会很有帮助。

手续费

看了白皮书的前半段，发现里面仍然有很多语焉不详的地方，也有一些刻意吹牛的地方。

Arc 有专门说自己的费用模型，因为用了 USDC 做原生手续费，所以更加可以预测，比如以太坊上因为 ETH 的价格是波动的，导致用户难以准确估算一笔交易的手续费是多少，而 USDC 的价格是恒定的，只需要考虑协议费用的波动。类似这样的话其实属于很正确的废话，不需要 Arc 在白皮书里说，这是大家都能懂得东西。

关键是 Arc 没说清楚自己的手续费到底是怎么设计的，只说参考了 EIP-1559，并且设置了平滑的波动，设置了上限和下限。理想是很好，关键是没说具体怎么做的。

共识

再就是 Arc 有专门说自己链最终一致性的问题，比特币和以太坊就不是什么的。因为 Arc 用的共识是 PBFT，当然自然而然就有最终一致性，不需要刻意强调。

不过 Arc 技术硬核的地方来了，Arc 没有用某种现成的 PBFT 的实现，而是自己根据 Tendermint 的协议论文，实现了一个 Rust 版本出来，名字叫 malachite，代码早在去年就 开源 并且处于公开研发状态。这可不是一般公司能干的了的事情。

（话说，好像最近新出的链、项目，只要是和区块链相关的，只要是有点性能方面追求的，都在用 Rust。直观感受上 Rust 的出现频率越来越高了。）

malachite 还有个有意思的项目 malaketh-layered，这个项目能让以太坊的执行层客户端，使用 malachite 做公式层。这个想法以及实现都很牛，也就是说，以后以太坊就有 PBFT 版本的链了。Reth+malachite 可以直接运行，联盟链将会有原生的 EVM 版本，这听起来很诱人。

虽然 Arc 的技术实力不错，但是有个不小的问题，Arc 竟然选择了 PoA 的模式，禁止外部节点的参与，只允许合作伙伴承担起网络出块的职责。这就稍微有点影响了，对于 USDC 本身的业务没影响，影响的是整体的格局，外部无法参与的话，其他项目就不能直接抄 Arc 的模式了，不公开还要保持信任是个问题。

性能

性能方面，Arc 的白皮书里也说了不少。尽管用了 Rust 语言，也只是能提高一些硬件方面的性能而已，PBFT 算法层面的限制始终在那儿，所以实际上并没有比 Cosmos 的 CometBFT 交易速度快多少。

MEV 与隐私保护

MEV 和隐私保护是两个东西，但解决手段相似。Arc 在 MEV 方面试图通过加密 mempool、批处理交易等方式，来避免有害的 MEV：

类似的，在金融领域，保密的交易是一个必要的功能，有些企业不可能愿意公开自己的转账记录。

Arc 在工程上，怎么解决这些问题呢？在 malachite 的 项目目录 下，看到了试图兼容 Starknet 的身影。Starknet 是一个 ZK Layer 2 方案，Arc 应该是想用 Layer 2 的模式来保护隐私、避免 MEV，比如链下完成交易、生成证明，链上结算，这样就很好的解决了隐私问题。

（Starknet 的技术有点意思，尤其是 Arc 为什么选择 Starknet 而不选择 ZK Scroll 之类，说明 Starknet 的技术有可取之处，有必要关注下。）

链上应用

因为 Arc 是 EVM 完备的，自然而然就可以轻易迁移一些 DeFi 应用上去。

小结

整个白皮书看下来，有几点没解开的疑惑：

• USDC 作为原生代币支付手续费，具体是怎么实现的？CometBFT 可是有一整个 Cosmos SDK 做应用层。malachite 的应用层是如何设计的？
• PoA 的共识是不是有点 “小气”？

总结来说，一开始对 Arc 的判断稍微有偏差，Arc 没有什么黑科技。但是 Arc 仍然有强大和专业的技术实力，基于 malachite 这样的共识层，可以做出很多有意思的应用。至于 Arc 将改变世界的判断，给现有的 Layer 1 链带来冲击肯定是会的，开发者搭建区块链会多出一些选择。

还是期待 Arc 网络正式开源和上限，期待后续，然后再次对 Arc 进行技术分析和解读。

相关链接：

• 《失业第二个月干了什么》
• 《失业一个月的回顾》

这次失业的原因，以及找工作用的时间，都远超我的预期。已经三个月了……难以想象，真是一段很长的时间。

工作像一堵高墙，他囚禁你，让你失去时间、失去享受生活的自由。一开始你憎恨它，厌恶它，后来你逐渐适应它，习惯它，最终被这堵高墙驯化，离不开它。

失业三个月，我开始逐渐适应这样的失业生活，学习、分析项目、打游戏……

上个月入坑了 FMV 游戏，当时还推荐了几个好玩的。后来我继续玩了一些时间，到目前为止，最喜欢的是《完蛋，我被美女包围了2》，古风剧情的那个，游玩时长一共 12 小时，解锁 100% 进度，达成全部 60 个成就。游戏结束后，我在抖音上搜一些《完蛋2》相关的视频看，找到了女演员的账号，以及她们讲述游戏幕后的一些内容。

我最羡慕的是这些女演员，有戏拍的时候拍戏，拍出《完蛋2》这种游戏后，不但能被人喜欢，还能在直播玩这款游戏，对当时拍摄过程中的小故事娓娓道来。有些演员还能放出一些自己拍的花絮，爆料游戏背后的故事等。她们有自己的工作，会拍很多其他游戏、电视剧。要是没有戏拍，空闲了，可以在抖音上发发自拍、分享自己的生活、直播跟观众聊天，也挺有意思。我觉得她们很幸福，她们生活在自己的轨道里。

程序员是一种不一样的职业，不会有人 “喜欢” 你的工作成果，失业了，也不可能在抖音上发自拍。

FMV 的女演员也是有明星效应的，当某一个演员在某一个游戏里表现好被观众记住了，那么这个演员的其他游戏，很多玩家会跟着去，就只是为了演员而玩完整个游戏。

失业并且超过三个月找不到工作，这是我未曾想过的失败人生的剧本。不是我不能接受失败，我只是想不明白为什么会失败。我已经努力学习、工作、思考…… 我连续遇到糟糕的公司的团队，导致我工作不稳定，导致我失业，这些都不是我的错，可我却一直承受着那些事情带来的后果。

安迪为了申请州里给监狱拨款买书，坚持每周写一封信，一写就是整整 6 年，不是吗？

总有一些东西是停留在我们内心中的，高墙围不住，别人也夺不走的。

没有人会对你的人生负责。希望是自己给的，不是别人给的。

我去年辞职 找工作 的时候，给自己定下的期限是 3 个月。如果 3 个月没找到工作，就需要转变自己的职业方向，主动迎合适配市场需求。也就是降低自己的预期，考虑接受无论是薪水还是工作内容都不合适的机会。

今年，失业时间真的到达 3 个月。只不过这次不是我主动离职，我自己也没有定下期限。那么问题来了，我是否应该做一些其他考虑，转变求职期望？当 3 个月的时间点真的到来，我真的应该做出改变吗？

失业第三个月的时间是 7月20日到 8月20日，这段时间一点都没闲着，这是理所当然的。

7月20日到 7月30日之间，主要还在做一些学习总结、收尾性质的事情，比如完成 continuation 系列、写出对课程 一个月的心得，在 26号左右有一些职业方面的 思考，反思我的过往经历。

7月29日，我收到了 imToken 面试不通过的消息，当天情绪不是很好，就说 我很失败 什么的。当时已经没有其他面试了。然后就在反思我的职业生涯以来，到底做错了什么。

步入 8月份之后，就开启琢磨和尝试 Web3 项目分析计划，先是计划 每天一篇，后来因为博客排版问题想 停止，最后选用 Paragraph 平台 继续。8月1日到 8月20日这 20 天的时间里，一共写了 8个项目 的分析，再加上对计划变动的测试和调整，其实时间挺紧凑的，没有空闲。

我现在有点没心情写什么加油、努力之类的话了，先好好活着吧。

我平时没兴趣研究这种问题。因为在面试中被问到的频率太高了，现在想花 2 个小时的时间来了解下。一方面研究下这个问题背后到底有多大的技术含量，另一方面把这个问题的答案写下来。但是我不会让这种内容停留在我的头脑里，所以下次面试被问到，我肯定还说不会 😏

基本概念

GMP 是一个缩写：

• G（goruntine）：就是协程，代码里每 go 一个，G 的数量就多一个
• M（Machine）：就是系统级别的线程，在其他语言里的 thread
• P（Processor）：数量为 GOMAXPROCS，通常默认是 CPU 核心数。

GMP 的意思是，启动多少个 M（线程） 来执行 G（协程），最多允许 P（核心数）个 M 并行执行。

三个不变量

无聊的（简化后的）定义来了：

1. 只有拿到 P 的 M 才能执行任务
2. 可运行的 G 只会在某个 P 的本地 runq 或者全局队列
3. 当 M 进入阻塞状态（syscall/cgo）时，会及时把 P 让出

这几句话看着很费劲，不需要现在理解，接下来会用一些代码例子来说明他们的含义。

GMP 的调试日志

这是一个最简单的代码文件，用来演示启动一个协程：

package mainimport (    "fmt"    "sync")func main() {    var wg sync.WaitGroup    wg.Add(1)    go func() {        defer wg.Done()        fmt.Println("Hello from goroutine")    }()    wg.Wait()}

然后带上调试参数运行一下：

go build demo0.goGODEBUG='schedtrace=200,scheddetail=1' ./demo0

注意不要用 go run，因为会引入一些 Go 语言运行时的日志。这个二进制版本的日志比较干净，内容是：

SCHED 0ms: gomaxprocs=10 idleprocs=7 threads=5 spinningthreads=1 needspinning=0 idlethreads=0 runqueue=0 gcwaiting=false nmidlelocked=1 stopwait=0 sysmonwait=false  P0: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P1: status=1 schedtick=0 syscalltick=0 m=2 runqsize=0 gfreecnt=0 timerslen=0  P2: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P3: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P4: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P5: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P6: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P7: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P8: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  P9: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0  M3: p=0 curg=nil mallocing=0 throwing=0 preemptoff= locks=1 dying=0 spinning=true blocked=false lockedg=nil  M2: p=1 curg=nil mallocing=0 throwing=0 preemptoff= locks=6 dying=0 spinning=false blocked=false lockedg=nil  M1: p=nil curg=nil mallocing=0 throwing=0 preemptoff= locks=2 dying=0 spinning=false blocked=false lockedg=nil  M0: p=nil curg=nil mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=1  G1: status=1() m=nil lockedm=0  G2: status=4(force gc (idle)) m=nil lockedm=nilHello from goroutine

这些日志显示了这些信息：

• 第一行 SCHED 开头的是汇总信息，告诉我们程序启动了 10 个 P（gomaxprocs=10）。
• 只有 P1 被 M2 拿着运行
• P0 被 M3 拿着处于 spinning 状态，也就是等待任务的状态。

没看到 print 相关的 G，是因为任务运行时间太短了，没被 trace 捕获就结束了，这里主要展示 GMP 的详细信息可以用 debug 命令来看。

抢占式调度

package mainimport (    "fmt"    "runtime"    "time")func busy(tag string, d time.Duration) {    end := time.Now().Add(d)    x := 0    for time.Now().Before(end) {        x++    }    fmt.Println(tag, "done", x)}func main() {    runtime.GOMAXPROCS(1)    go busy("A", 1500*time.Millisecond)    busy("B", 1500*time.Millisecond)}

这个代码的运行结果是，有时候 A 在 B 前面，有时候 B 在 A 前面。

我们已经用 runtime.GOMAXPROCS(1) 设定只有一个 P，但是 Go 语言的 GMP 调度器，仍然会 10ms 释放一次时间片，也就意味着，即使 go busy("A") 处于阻塞状态，时间片之后也会让出执行权，交给主线程去运行 B。

可以用这个 busy 的函数定义来让抢占式调度更加肉眼可见：

func busy(tag string, d time.Duration) {    end := time.Now().Add(d)    next := time.Now()    for time.Now().Before(end) {        if time.Now().After(next) {            fmt.Print(tag, " ") // 每 ~100ms 打印一次            next = time.Now().Add(100 * time.Millisecond)        }    }    fmt.Println(tag, "done")}

程序的打印结果会是 B A B A B A A B A B A B A B A B A B A B A B A B B A B A B A B done。这意味着不是 tag 为 A 的 P 一路执行到底，也不是 tag 为 B 的 P 一路执行到底，他们在 GMP 调度器中交替执行。

P 偷活干（work-stealing）

来看这个代码示例：

package mainimport (    "runtime"    "sync"    "time")func spin(d time.Duration) {    deadline := time.Now().Add(d)    for time.Now().Before(deadline) {    } // 纯CPU忙等}func main() {    runtime.GOMAXPROCS(1) // 先让所有 G 挤到同一个 P 的本地队列    const N = 120    var wg sync.WaitGroup    wg.Add(N)    for i := 0; i < N; i++ {        go func() { defer wg.Done(); spin(500 * time.Millisecond) }()    }    time.Sleep(30 * time.Millisecond) // 给点时间把队列堆满到 P0    runtime.GOMAXPROCS(4) // 突然放大并行度：P1~P3 会去“偷” P0 的一半    wg.Wait()}

这个代码干了什么呢，首先设定之后一个 P，然后启动 120 个 G 给这个 P 去执行。30 毫秒后，突然增大 P 的数量。

用 debug 日志能看到，运行后半段有这样的日志：

P0: status=1 schedtick=46 syscalltick=2 m=0 runqsize=17 gfreecnt=0 timerslen=0P1: status=1 schedtick=58 syscalltick=0 m=4 runqsize=5 gfreecnt=15 timerslen=0P2: status=1 schedtick=60 syscalltick=0 m=2 runqsize=5 gfreecnt=18 timerslen=0P3: status=1 schedtick=42 syscalltick=0 m=3 runqsize=17 gfreecnt=0 timerslen=0

也就是说，本应该 G 全在 P0 上运行，等到 P1、P2、P3 出来后，它们发现 P0 很忙，就去 P0 的队列里拿了几个任务过来执行。

P 的 runq 队列和全局队列

一个 P 想找活干的时候，上面的代码是偷其他 P 的示例。更严谨的流程是，P 先从本地 runq 队列找，再到全局队列找，找不到再去偷其他 P 的。

什么是 runq 队列，什么是全局队列？可以看这个代码：

package mainimport (    "runtime"    "sync"    "time")func spin(d time.Duration) {    end := time.Now().Add(d)    for time.Now().Before(end) {    } // 纯CPU忙等：保持 runnable}func main() {    runtime.GOMAXPROCS(1) // 只有 P0：所有新 G 先进入 P0 的本地 runq    const N = 600 // 让它明显超过本地 runq 容量（当前实现通常是 256）    var wg sync.WaitGroup    wg.Add(N)    for i := 0; i < N; i++ {        go func() { defer wg.Done(); spin(800 * time.Millisecond) }()    }    time.Sleep(500 * time.Millisecond) // 给运行时时间把“溢出的一半”推到全局队列    runtime.GOMAXPROCS(4) // 其它 P 进场，会先从“全局队列”拿活（不是偷）    wg.Wait()}

debug 状态运行：

go build demo4.go   GODEBUG='schedtrace=200,scheddetail=1' ./demo4 &> demo4.log

日志会比较多，日志前面几行像这样：

SCHED 0ms: gomaxprocs=10 idleprocs=9 threads=2 spinningthreads=0 needspinning=0 idlethreads=0 runqueue=0 gcwaiting=false nmidlelocked=0 stopwait=0 sysmonwait=false  P0: status=1 schedtick=0 syscalltick=0 m=0 runqsize=0 gfreecnt=0 timerslen=0  P1: status=0 schedtick=0 syscalltick=0 m=nil runqsize=0 gfreecnt=0 timerslen=0

其中首行的 runqueue=0 就是全局队列，P0 后面的 runqsize=0 是 P0 的本地队列，P1 后面的 runqsize=0 是 P1 的本地队列。可以看到此时的 P1 状态是 0，也就是不可运行。

随着程序的运行，P0 会启动非常多个 G，日志状态是这样：

SCHED 200ms: gomaxprocs=1 idleprocs=0 threads=5 spinningthreads=0 needspinning=1 idlethreads=3 runqueue=395 gcwaiting=false nmidlelocked=0 stopwait=0 sysmonwait=false  P0: status=1 schedtick=10 syscalltick=2 m=0 runqsize=204 gfreecnt=0 timerslen=1

一般 P 的本地队列默认是上限是 256，达到这个峰值后，就会把任务溢出到全局队列。

再然后，P1、P2、P3 启动，开始从全局队列拿任务（全局队列有任务则不需要偷其他 P 的）：

SCHED 826ms: gomaxprocs=4 idleprocs=0 threads=5 spinningthreads=0 needspinning=1 idlethreads=0 runqueue=217 gcwaiting=false nmidlelocked=0 stopwait=0 sysmonwait=false  P0: status=1 schedtick=35 syscalltick=2 m=0 runqsize=179 gfreecnt=0 timerslen=0  P1: status=1 schedtick=14 syscalltick=0 m=3 runqsize=90 gfreecnt=0 timerslen=0  P2: status=1 schedtick=14 syscalltick=0 m=4 runqsize=64 gfreecnt=0 timerslen=0  P3: status=1 schedtick=13 syscalltick=0 m=2 runqsize=46 gfreecnt=0 timerslen=0

另外，当 P 依次从本地 runq、全局队列、其他 P 都找不到任务时，会再去问一下 netpoll（问一下 OS）有没有新的 G，要是有就执行，没有就自旋（待命）。这就是 P 执行任务的逻辑。

阻塞 syscall 会及时让出

看这个代码例子：

package mainimport (    "fmt"    "runtime"    "time")func main() {    runtime.GOMAXPROCS(2)    go func() {        time.Sleep(2 * time.Second) // 类比阻塞 syscall/cgo        fmt.Println("blocking done")    }()    go func() {        for i := 0; i < 6; i++ {            time.Sleep(300 * time.Millisecond)            fmt.Println("still running", i)        }    }()    time.Sleep(3 * time.Second)}

运行结果会是：

still running 0still running 1still running 2still running 3still running 4still running 5blocking done

这个代码示例的含义是，第一个 G 明明会阻塞任务队列，一直占着 P 执行，但实际上第二个 G 仍然在运行。

说明 GMP 调度器不会因为某个 G 的阻塞，影响到其他 G 的执行。（其实这是协程调度器很基本的要求）

关闭异步抢占

对于这个代码示例：

package mainimport (    "fmt"    "runtime"    "time")func spin() {    for { /* 紧密循环 */    }}func main() {    runtime.GOMAXPROCS(1)    go spin()    time.Sleep(100 * time.Millisecond)    fmt.Println("I should still print unless preemption is off")}

可以分别用两个命令来运行，一个是

go build demo7.goGODEBUG='schedtrace=1000,scheddetail=1' ./demo7

另一种是：

go build demo7.goGODEBUG='schedtrace=1000,scheddetail=1,asyncpreemptoff=1' ./demo7

用 asyncpreemptoff=1 可以关闭异步抢占。也就是说，如果没有关闭，没有带这个参数，程序会正常运行，打印出：

I should still print unless preemption is off

如果关闭了异步抢占，则程序会被死循环卡住。这个例子主要可以体现 GMP 主动让出 CPU 的特点，当关闭了主动让出的能力后，GMP 就会被阻塞住了。

Go 语言源码

我没有深入看源码，比如 G、M、P 的常量定义在 src/runtime/runtime2.go 文件：

再比如 src/runtime/proc.go 文件中的 runqputslow 函数，功能就是判断本地队列有没有满，如果满了就放到全局队列：

进一步深入

这篇文章肯定有不全面和不到位的地方，我不想进一步深入了，也许有人喜欢折腾这些吧。

Go 语言的 GMP，就是协程调度器的一种具体的工程化的实现，估计很多人在意的，是这种工程化实现背后的细节，比如怎么用栈结构来管理任务队列、怎么实现抢占、让出逻辑等。协程调度器的具体实现方式可以有各种各样的变化，但它们的基本原理都是 continuation。只是 Go 语言把协程作为卖点了。只要其他语言愿意，也是可以开发出自己版本的协程调度器的。

那么问题来了，那些喜欢研究 GMP 原理的人，你们有没有了解过其他语言的协程（coroutine）、虚拟线程、异步函数、Process 是怎么实现的，它们都是比线程更轻量的类似于协程的东西，和 Go 语言的 gorountine 有什么区别？横向对比一下？

如果什么时候，我的工作需要，只有我了解这些内容，才能把工作做好，那么我肯定去把这些东西搞明白。

疑问

我之前写过一个观点：

Go 语言 “千辛万苦” 做出了自动的垃圾回收，减轻程序员对于内存管理的头脑负担。而有些面试官 “千辛万苦” 去搞明白 Go 语言 GC 的原理是什么，怎么标记怎么释放之类，不但引以为豪，而且拿来考察候选人。作为 Go 语言的教徒，你知不知道你的行为在否定 Go 语言设计者的努力？如果真的相信用头脑来管理内存的力量，为什么不去搞 Rust？好比我是一个汽车驾驶员，我要去考驾照，难道需要我搞清楚发动机的工作原理、是怎么把汽油燃烧转变为机械动力的、能量转化公式是什么？我又不是在制造汽车，也不是在开发编程语言。

同样的道理：

Go 语言为了让广大程序员能便捷简单地、用上轻量级的协程，“千辛万苦” 搞出来一个 go 关键字，然而有些人却费尽 “千辛万苦” 研究这个调度器是怎么实现的，懂原理则说明会 Go 语言，不懂则说明 Go 语言水平不行，这是什么道理？作为 Go 语言的教徒，你在否定 Go 语言设计者的努力，明白吗？如果这个语言需要你搞清楚协程调度的原理，才能写出好的代码，那就说明这个语言实现的不到位，偏离了设计者的初衷，没有达到设计者本来的意图。

如果你是编程语言的开发者，需要在另一种语言中借鉴、实现、优化 Go 语言的调度器，那么你就尽情研究吧，这样的工作确实需要懂 GMP 调度器的原理。如果不是那样的工作呢？

白皮书

RTX 以 ERC-20 的形式发售，这就有点奇怪了，意味着 RTX 无法承担起付手续费的作用。那么 Remittix 是怎么解决跨境支付问题的？

Remittix 的 路线图 是真实的，目前处于预售和 TGE 阶段，CMC 上已经有了 信息 但是没有正式的代币出来。

Remittix 的 白皮书 整体看下来，完全没有看到有用的信息，都是一些非常宏观的描述，市场规模多大、问题是什么、对比区块链技术等，根本没说 Remittix 的创新之处。

比如 这个页面，一直在说 Remittix 去中心化、交易确认速度快等。不是，你 ERC-20 的代币，随便一个人都能发、都能有这些特点的，到底解决了什么问题呢？

能明确的是，Remittix 仅仅只是用 ERC-20 发币而已，不是一条链，没有更多的技术含量在里面。

诈骗账号

你一旦关注 Remittix 的 X 账号，就会有一些假装客服、技术支持的账号关注你。这种现象很常见，正经项目很少有这种冒充官方的账号：

结论

Remittix 是骗子项目。Remittix 没有任何公开的代码仓库，也没有上交易所，只有一堆新闻文稿和预售金额放在那里，很难对这个项目产生信任。

所以我的结论是，Remittix 的性质和 Nexchain 一样，都属于骗子项目。甚至很多方面这两个项目有点像，比如预售的套路，给人的某种感觉，等等。

你也许觉得我这种判断方式太过武断了，比如 RTX 在 CMC 上有 5k 收藏量是实打实的，如果 RTX 是骗子项目，会有那么多人信吗？这也是我困惑的点，我理解不了为什么有那么多人相信这个项目，那么多人参与预售，理解不了为什么。

虽然理解不了，但是根据我自己的判断，尤其是从技术角度的判断，Remittix 就是骗子项目。

另外，由于 Remittix 是用 ERC-20 发币，没有什么技术方面可分析的，有点没意思。上一个分析的项目 Nexchain 也是这样。这种情况不太好，我还是倾向于看点有技术内容的项目，所以以后得更小心选择项目才行。不过这种情况又有点难以避免，就像我一开始说的，我没办法在选择项目的时候，就知道项目有没有技术含量。

白皮书

排版

首先看看 Nexchain 白皮书 的这个字体大小和排版，像是高中生整出来的东西，没写过论文，也没经历过职场毒打那种：

再看看这个正文里表格的排版，哪有点正经论文的样子？

论文中的公式直接贴一个不高清的图片：

内容

然后看看这个目录，一条区块链的白皮书，竟然写市场机会有多大、如何建设平台、Dapp 什么的，闭口不提区块链技术方面的创新：

其实白皮书里并不是一无是处，比如这个摘要部分提到了不少技术，AI 啊、PoS 啊、DAG 啊，虽然不新鲜，但至少有：

这些内容是不是勾起了你的好奇心？Nexchain 在这些技术上有什么创新和贡献？论文中提出了什么新的思路吗？

答案就是，没有技术创新也没有贡献，甚至白皮书里面都不详细写。比如在介绍 DAGs 的部分，先是介绍了 DASs 的区块结构是什么、有哪些同类型的项目，这个算是正常套路，然后呢，你以为他要开始写 Nexchain 是怎么做的了，结果没有，白皮书里面就一句话，Nexchain 集成了 DAGs，提高了可扩展能力什么的：

整个白皮书像是三流大学生堆砌论文的样子，各种不明所以的术语和介绍往上面堆，然后什么有用的信息都没有。光是白皮书这里就很让 Nexchain 掉价了。

官网

再来看看官网上的做派，预售页面竟然在预测 Listing 之后的价格，我印象中只有资金盘会这么干，这个预测价格只为了给用户一个预期，而不是自己真的能控制：

不是，等等，你说网络有多高的 TPS？40万笔交易每秒？

Blog 文章整的还挺像样子，有耐心在不同的日期发布那么多篇。可能是 AI 一键生成的吧。

当然，不出意外的，网络并不处于运行状态，测试网的浏览器都没部署好：

代码

竟然敢公布 GitHub 账号地址。这都没有看的必要，一共就 4 个仓库，最新一次的提交还是在 3 个月前：

这些代码仓库是小学生搞的吧，基本的代码能力都没有。

诈骗账号

我在关注 Nexchain 的 X 后，就收到了几个诈骗账号的关注，这说明 Nexchain 是一个虚假账号聚集地：

预售

其他项目一般会有一些新闻来源，作为项目实力的背书。Nexchain 能查到的为数不多的新闻是关于 预售金额达到 8百万美元 的。注意这是预售额，而不是融资额。融资机构对项目会做一系列的调查，所以越是有融资纪录的项目，越靠谱。而 Nexchain 目前没有查到融资纪录。

那么余额额真的达到 8百万美元了吗？

如果你尝试参与预售，就会看到这个下单页面，它让你直接转账一定金额到目标地址，如果余额不足，允许你自己给目标地址转账：

订单界面的目标地址是 0x387e086e5F52e2BC8B715693aE76fE63A5De9877，你猜这个接受预售的地址，一共有多少余额？

10 个 ETH 和价值接近 50万美元的 USDT。哪来的 8百万？哦，对了，不一定全在余额上，也可能被转出了，来看看 转出记录：

说实话，这个转出记录的金额还真不小，大概 117ETH。按照现在的价格算，大概 50万美元。

总之这个地址的余额总数，和宣传的数字是对不上的。你也许会说，不只一个接收地址，前几期的预售用了其他的接收地址？我无从得知。

不过单看这个地址的余额，其实金额挺大了，接近 100万美元。和这个项目白皮书的排版水平相比，真的是挺大了。我有点难以想象，一个毫无基础设施的项目，只有一些前端页面，竟然就能骗到这么多钱，这到底怎么回事？

ins

Nexchain 的 Instagram 挺有意思，发布过很多关键消息。其实从历史记录来看，8百万的预售额大概率是真的，是我怀疑过早了，一共预售了 25期，确实有可能分多个地址收到了 5百万美元。

更离谱的地方在于，ins 的历史帖子上，发布过 Nexchain 和 Google Cloud、和 Open AI 合作的新闻：

这么强大的资金背景，以及与大企业的合作背景，到这里我都有点怀疑自己是不是搞错了，有眼不识泰山，小看了 Nexchain？这个世界让我很难以理解。

结论

我仍然相信，Nexchain 是骗子项目。

• https://paragraph.com/@smallyu

计划内容

经过几天时间的尝试，我觉得 Web3 项目分析计划是一件很有意义的事情。不清楚看到分析文章的人有没有收获，但是从我自己理解项目、学习技术的角度，是有收获的，所以我需要把这个计划继续下去，变为一件常态化的事情。

具体计划内容是，每周分析一个 Web3 行业的项目，从看白皮书开始，到理解项目的运作模式、当前商业状态等，尤其关注技术理念和技术创新方面，然后写成分析报告，不需要很专业的那种报告，大概相当于学习笔记就可以了。具体分析哪个项目是经过主观挑选的。最终的分析报告也许会有质量，有看点，但也许会比较短，没有质量。因为我并不能在一开始选定项目的时候，就知道这个项目有没有含量，尤其是技术含量。

工程代码没有价值

这个计划有点像是区块链研究员干的事情，而不是区块链程序员应该干的事情。为什么我的计划不是每天写 100 行代码，开发一个区块链小工具，或者每天积累一点，开发一个大的区块链工程？

因为工程代码如果脱离项目背景，就没有价值。我在几年的工作中写过很多代码，但是如果现在把那些代码拿出来，会发现毫无意义。工程化的代码，往往是为了完善项目的功能，而项目需要某些方面功能，是为了迎合运营和宣发的需求，一定是有商业目的的。如果需求背景不存在，代码就毫无价值。

尤其是随着 AI 的日益强大，写工程代码这件事情更是越来越廉价。AI 可以几分钟写出上万行代码，堆砌代码的能力绝对超过人类。如果我想靠每天写几百行工程代码来训练和提升自己，那我一定会失败的很惨。所以不能干这样的事情。

什么样的工程代码是有意义的呢？就是已经找准了产品需求和定位的情况下，想把功能落实跑通，然后让 AI 来干活，把代码写出来。AI 写的代码有时候会跑偏，需要手动修复一下 bug，这种情况下，手动写出的工程代码才有意义。现在的开发节奏已经应该是这样了。

以前的时代，人们喜欢说 “Talk is cheap. Show me the code”，但是现在时代变了， prompt 比 code 更有价值，也许这句话会变为 “Code is cheap. Show me the prompt”。

文章更能表达思想

不去计划每天写一些工程代码，另一个原因在于，我已经做过了一些尝试，去试图开发小的区块链工具，或者大的区块链工程。目前来看，我之前的想法，无论是做小工具的思路，还是做大工程的思路，都是没有结果的，因为需求本身也许不存在。没有任何正反馈，根本做不下去。

与代码相比，写文字、写文章、写观点更有意义一点。一个产品创意背后，可能有 100 行代码，也可以有 10000 行代码，需要付出的时间成本完全不同，但如果最终的关注量都是 0，那么结果就是一样的，9900 行代码白写了。而文字是能够体现思想的。

你也许想反驳，怎么能说工程代码没有价值呢？以太坊的客户端同一份 Spec，有五六种工程化的实现，用了不同语言、做了不同优化，市场占有率有高有低，难道不是工程化代码价值的体现吗？当然是，他们拿着以太坊基金会的赞助开着公司写着代码，而且已经有了明确的项目背景，工程代码自然是有价值的。我指的是没有项目背景的工程代码。

虽然工程代码没有价值，但教学性质的代码是很有意义的，我仍然会复习计算机课的练习题，以保证自己的代码水平。我已经是第三轮做那些练习题了，这次我严格限制自己的做题速度，一天最多做一道题。一方面是保证有足够的时间消化练习题包含的知识，相信潜意识的力量。另一方面，得分配时间到其他事情上，不能整天只反复做同样的题。而且由于做题比较慢，可以逐渐培养自己每天做题的习惯，不至于遗忘计算机课的知识。

提高宏观理解能力

为什么我觉得对项目做分析是有意义的？因为其实我对区块链技术的理解，很大程度上，来自于几年前读了很多白皮书。我当时按照币种市值的排名，逐一下载了排名前几百的币种白皮书，还用 A4 纸都打印出来看。

记得几年前有人发邮件问我，如何学习区块链技术。我当时认真写了个回复，说我是从哪个网站下载的白皮书，以及看了哪些书之类。后来对方回复我说，这不是他想要学习的区块链技术，他想要学习的是如何写代码。那个时候我才意识到，不同的人，对技术的定义是不同的。

以前没有 AI，我没能认识到代码的价值，现在有了 AI，我还是认识不到代码的价值。

研究能力的重要性

在币圈，人们常说 DYOR（Do Your Own Research），这个词经常出现在 KOL 推广和夸赞某个代币的时候，用来声明不做投资建议，你要自己对自己负责。“研究能力” 一直都是非常重要的能力，如果不具备好的研究能力，你连自己的钱都管理不好。事实上什么事情都需要研究，研究如何学英语、研究如何找工作、研究假期去哪儿玩、研究写代码、研究科学技术、研究如何哄女朋友开心，等等，都是研究。Web3 项目分析计划的目标正是研究项目、锻炼研究能力。

具备好的研究能力的人，不管学习什么都会变得轻松。试想，你觉得去研究明白怎么把代码写好，尤其是工作中用的普通代码，需要多长时间？很多时候连 “研究” 都用不着！那么，你觉得能把某种技术研究明白的人，会没有能力研究清楚怎么写代码吗？

那么为什么我觉得自己可以写出分析报告？我以前没专门写过，但是有时会根据技术来对项目做横向对比，所以专注于对某个项目做技术分析，应该不是难事。我工作过的项目，假如让我写分析，肯定能写出其中的细节，只是因为项目还在，不能写。写项目分析对我来说也是一个学习和积累的过程。

实际上分析区块链项目的方法论，我早在《看懂任意区块链项目的技术架构》就写过了，到现在都不觉得那篇文章内容有什么问题，无非就是链上链下交互，不同项目往里面填充不同的业务逻辑而已。

写作平台的选择

我对于博客上应该放哪些文章，是比较纠结的，我不希望一打开博客，满屏幕都是 “对 XX 项目的分析”。为了保持文章列表的简洁，这些项目分析系列的内容应该换一个平台放。最近看到 Paragraph 不错。Paragraph 是一个 Web3 领域的 Newsletter 平台，功能类似于 Web2 的 Substack，每篇文章的全部内容都会提交到 Arweave 区块链上，包括作者的名字、头像、文章正文、配图等。（这也就意味着文章一旦发布，就不可能被删除。）

为什么不选择其他平台呢？比如发到知乎、掘金，甚至是头条、百度、登链等平台，再加上 Meidum、X、Mirror 一类，文章访问量肯定可以高很多，关注量也会高很多。

因为那些充斥着低质量内容的平台，不值得去发布高质量内容的文章。那些人是看不懂的，看不懂我在写什么。看看掘金首页上有什么？10 篇文章 8 篇讲 Cursor，很难想象用户素质得多低。知乎就更不用说了，内容杂乱、商业化，关键是网页访问弹窗，不是让登陆就是让下载 APP，正经人谁去那种平台啊。我在脉脉的职言区，匿名账号下，发布过几千条帖子，总阅读量超过几千万，发的都是观点偏激、引战一类的内容。那种阅读量有意义吗？没有意义。

所以继续努力吧，等自己成为 somebody，再考虑访问量的问题。没有人会关心 nobody 写的东西。

为什么要做出计划

其实要按照我自己喜好，我觉得自己真正有价值的文章，是吐槽同事、吐槽公司、吐槽面试经历等情绪宣泄类内容。那些是包含了亲身经历、切实体会、真情实感在里面的，耗费了时间和心情才得到的、宝贵的人生体验，比技术文章有意思多了。对行业的见解、对公司的不满、对同事的吐槽，是我的文章永远超越 AI 的地方，因为 AI 没有情绪，不会生气、不会沮丧。单纯讲技术知识点，AI 一下子就能生成很多，但是 AI 永远无法体会到作为人的情感。

反正人总要做选择，要么忙着活，要么忙着死。

既然是一件长期的事情，做项目分析的频率就不应该那么高，目前计划一周分析一个项目，这样既不会有太大压力，不能整天只干这个，也不会因为拖沓时间太长导致计划中断。一周一个项目是底线，如果空闲时间比较多，就可以增加任意数量。如果跳票了，跳票就跳票，反正没人关注……以培养我自己的技术习惯为主，沉淀一些东西，选择独立博客 本身就没指望访问量和关注量。

为了解决项目分析文章 刷屏博客首页 的问题，这些项目分析系列的内容应该换一个平台放。现在看到 Paragraph 不错。Paragraph 是一个 Web3 领域的 Newsletter 平台，功能类似于 Web2 的 Substack，每篇文章的全部内容都会上链到 Arweave 区块链上（这也就意味着文章一旦发布就不可能删除），包括作者的名字、头像、文章正文、配图等。一笔链上交易是 这个样子。

Web3 项目分析系列文章专用的 Paragraph 频道地址是：

• https://paragraph.com/@smallyu

以后上面发布的内容会类似于《对 Psyche Network 项目的分析》，目前为止已经写过的有这些项目，博客上都删掉了，接下来几天会逐步搬到 Paragraph 上：

• Psyche Network
• Camp Network
• Arcium Network
• 0G
• Mignight Network
• Humanity Protocol

选择 Paragraph 的好处是平台挺好用的，坏处是它是一个英文为主的平台，而且网络连接受到限制。没关系。反正人总要做出选择，要么忙着活，要么忙着死。认真生活就好了。

我在看到 Humanity Protocol 的官网和导航栏的时候，对这个项目的技术预期比较低，因为没有白皮书，也没有 GitHub 链接，看文档还等登陆账号，这些信号都在表明，Humanity Protocol 是一个依靠运营、营销、市场、玩法、热点的项目，而不是专注于技术。

来看看主网的 Top Accounts 代币余额情况：

某一个账户控制了整个网络 99.86% 的代币，这可是主网啊。这样的代币分配模式，和区块链技术就已经无关了吧。而且很明显 Humanity Prococol 用的是以太坊节点，地址格式、交易哈希、手续费都是以太坊的格式。不过还不清楚具体是用什么技术方式启动的网络，在浏览器上看到了 Batches 的字样，应该是 L2 吧，那么大概率是 Op Stack。没准是用了某个 BaaS 平台，一键启动，能理解 😒。至少能肯定的是，链不是自己开发的，毫无技术含量。

翻了一下 Humanity Protocol 早期的 博客，原来这个项目早在 2023 年就有想法了，在合伙人中还看到了 Polygon Labs 的身影，这个项目用的应该是 zkEVM Layer-2。

什么是 Proof of Humanity（PoH）？用手机 KYC，手机 App 上的 KYC 信息会对应一个链上身份，这就是 Humanity Protocol 说的 PoH。

首先在官网上面用邮箱或者钱包登陆，你的账户会自动绑定一个链上地址，然后账户状态是未验证。你需要下载一个手机 App 来验证你的身份，这个 App 需要你打开前置摄像头，露脸并且在摄像头上比划一些手势，比如握拳、竖中指等，经过几个动作的验证，你的账户会变为已验证的状态。不得不说手机 App 做的还可以，验证流程是流畅的。

说了这么多，Humanity Protocol 这个项目到底是在干什么？给其他项目提供验证身份的服务！

基于刚才提到的一整套身份验证流程，可以给合作的项目方单独验证一次，账户面板上有罗列很多还未验证的项目：

对于这些项目方而言，Humanity Protocol 最大的作用，就是能够证明你是一个真实的人类，这是一件非常有意义的事情！

Humanity Protocol 会把你的账户信息分享给其他项目！

你一定会担心，Humanity Protocol 会泄漏我的身份数据吗？这是 Humanity Protocol 在重点解决的问题，大意 是用 ZK 生成对身份信息的证明，达到不暴露身份数据也能验证身份的目的。

那么即使分享给其他项目的是身份的证明而不是原始数据，Humanity Protocol 官方的服务器上会储存我们的身份信息吗？

不知道！

Humanity Protocol 在说辞上肯定是，用户数据只保留在本地，绝不会上传到服务器，服务器上的都是一写不可逆的 ZK prove 数据。因为没有开源出代码，我们无法验证这一点。

总之，Humanity Protocol 的立意是好的，利用 ZK 技术能验证用户的真实性。项目最大的风险，或者凡是类似的项目，都必然会遭到隐私数据方面的质疑。相信 Humanity Procotol 把代码开源的那一天，这个问题会真正解决。

项目简介

先来概括下 Midnight Network 在干什么，白皮书 中的介绍是，Midngiht Network 结合了 ZK 技术后，可以实现对链上的数据进行隐私保护的效果。其他公开区块链的 DApp 在和区块链进行交互的时候，必然是暴露所有用户数据和交互记录的，而 Midnight Network 试图解决这个问题，允许用户和区块链交互的时候，有一部分链上数据是保密（Shielded）的。

对于这样的项目描述，我们可能会好奇两个技术问题：

1. Midnight Network 的项目架构是怎样的？
2. Midngiht Network 是如何利用 ZK 技术，实现链上数据保密的？

此外白皮书里还提到了其他概念，像 DID、RWA、投票之类，这些都是噱头类型的应用场景，不用在意。

项目背景

Midnight Network 的资金实力非常强大，没有公开的融资信息，但是持续开发了多年，还用了 Midnight Foundation 这样的名字，一般的开发团队可不敢叫基金会。技术实力也比较强大，比如开发出了 Compact 这样的编程语言，作为智能合约的开发语言，这种语言是为了表达 ZK 电路而专门设计的。还有很多已经发布的 软件，包括能本地运行的 Proof server、浏览器钱包、VS Code 插件等，简直自己开发了一整套生态。由此可见 Midnight Network 拥有深厚的技术积累。

遗憾的是，Midnight Network 公开的 Github仓库 里，没有开源任何核心代码，所以我们没办法从代码角度对项目的技术结构做分析，只能根据文档描述来推测技术实现。要注意，文档内容不一样靠谱，因为即使一行代码没写，文档也可以写的很全面。即使内部服务器用了单机的程序，也可以对外宣称是去中心化网络，不能因为有公开的测试网 RPC 而相信什么。

共识与出块

不过也不用过度担心，文档中已经公开了很多操作流程。首先借用了 Cardano 的 质押池，Midnight 的节点会追踪 Cardano 网络的质押情况，用来确认哪些节点有出块权限，有点像是侧链的模式，但是 Midnight 又不完全依赖 Cardano 网络，Midnight 把这种模式叫做 partner chain。

Midnight 网络的 出块 则是借鉴了 PolkDot 网络 Substrate 的思路，由一种叫 AURA 的 PoA 共识出块，GRANDPA 机制负责块的确认。PolkDot 用这种混合的共识机制，是为了迎合子网络与平行链的应用场景。而 Midnight 用这种模式，目前没有找到很好的说辞，猜测一方面是直接用了 Substrate 的代码，方面二次开发；另一方面是有兼容 ZK 服务的考虑，也许有把 proof server 放到 validator 节点的尝试。

无论是哪种情况，都能看出 Midnight Network 有硬核的开发实力，在区块链的出块、共识方面都进行了自定义改造。

隐私保护

Midnight Network 能实现链上隐私保护的理论基础，是 IOHK 的一篇论文 Kachina，论文很复杂，简单理解就是用 ZK 电路来描述智能合约的状态转移函数。以往的智能合约不都是公开代码来改变状态吗，Kachina 试图用 ZK 来隐藏代码细节。论文包含很多具体设计，比如 ZK 描述全部状态转移是一件困难的事情，就简化为只描述对状态预言机的访问记录。

所以对于 Midnight 的隐私保护能力，可以理解为对 Kachina 做了 工程化 的实现，链下生成对合约操作的 ZK 证明，链上来验证这个证明，并且改变链上状态。当然这个部分很复杂，但是 Midnight 把这一套做出来了，虽然代码没开源。

隐私应用

由于 Midngiht 对于 ZK 成熟的应用能力，搞出了 Zswap 这种带有隐私保护的代币交换池，大意是链上只暴露了 ZK 的承诺信息，但是并不透露具体哪两种代币发生了交换，也不知道交换金额是多少。有点类似 Zcash 的效果，但是做的更好。

代币模型

Midnight 的代币模型搞的也很复杂，有 NIGHT 和 DUST 两种代币，因为 Midnight 网络本身的节点结构就复杂。NIGHT 是发行在 Cardano 上的，用 partner chain 的方式 1:1 锚定到 Midnight 上。DUST 则用来支付 Midnight 网络的手续费，持有 NIGHT 会不断产生 DUST，类似 Tron 网络的能量，持有 Trx 就会产生能量那种。

小结

Midnight Network 拥有很强的技术实力，无论是区块链方面的出块和共识机制，还是对于 ZK 在工程方面的落地能力，都有很大的技术难度，不是一般开发团队能胜任的。尽管叙事上不太接近当前的热点，应该不会很出圈，但是技术方面如果开源的话，肯定会留下浓墨重彩的一笔。

0G 的官网地址是 0g.ai，在官网上就极尽所能的把各种名词摆上了，”the next generation”、“decentralized AI”、”DeAIOS”、”RWA”，用词口径越大通常不是一个好兆头。

项目背景

0G 在 2024年8月 发布了 白皮书，单从白皮书目录和篇幅来看不是很乐观，目录结构比较简单，一共只有 20 页的内容。篇幅长度是肤浅的判断方式，比特币的白皮书也才 9 页。主要是目录结构，作为一个 AI 技术导向的项目，如此简洁的章节会给人草台的感觉。

首先来看看摘要里怎么说，0G 在解决的是 AI 模型训练过程中透明度的问题：

话说，看到 modular 这个词我有点不好的预感，尤其是看到 DA 这个词后，心想该不会用的 Celestia 吧，结合官网首页上宣称的 2500/s 的 TPS，有哪条链能做到呢？Cosmos 有点像。不过到这里还不理解首页上说的 8K 个 validator 是什么含义，Cosmos 可做不到这个。

好在不是 Celestia，白皮书里没详细说技术选型的事，但明显和 Celestia 是并列关系，自己搞了个叫 0G DA 的链。

白皮书里详细解释了 PoRA（Proof of Random Access）的挖矿机制，这个是有技术含量的部分，与 Filecoin 冷储存的模式不同，0G Storage 强调链上可以即时访问数据，所以设定了 8TB 的挖矿窗口，要求矿工可以快速在范围内验证数据完整性。

PoRA 的局限性在于，通过随机抽样验证的方式，可以验证矿工是否拥有完整数据，但是不能证明矿工拥有的数据是唯一的，也就是缺少 Filecoin 的 PoRep 提供的能力。这与网络面对的场景以及经济模型设计有关，0G Storage 只希望保证数据的可用，从矿工的奖励方式上限定了作恶是不能得到更多奖励的，所以整体机制上奏效。而 Filecoin 是根据算力高低给奖励，要面对的问题不一样。

从官网的第一篇 博客文章 中能更直观看到一些信息，0G 包含两个关键组成部分：0G Storage 和 0G DA，本质上在解决的就是 DA 的问题，主要是试图把这种 DA 能力用到 AI 场景中，所以分类到 AI 赛道了。项目背景上是一个分布式存储类的区块链项目。

0G 去年得到了 3 千万美元的种子轮融资，还是挺有资本的。

具体到工程实现上，可以看到 0G Storage 的 代码 基于 Conflux 的节点代码，在其之上做了一些功能开发：

PoRA 的工程实现部分就不深究了。

项目架构

刚才从项目背景的角度，只提到了 0G Storage 和 0G DA 两部分，除此之外，0G 这个项目还有两个角色，0G Chain 和 0G Compute Network。估计一开始的项目规划里没有，所以白皮书里没提。

0G Chain 是一个用 Cosmos SDK 开发的链节点（终于看到 Cosmos 的身影了），而且是直接用了 evmos 来兼容以太坊智能合约的做法：

0G Chain 的仓库最后一次提交代码是在 5 个月前，也许已经放弃了用 Cosmos SDK 的路线。因为有一个近期比较活跃的仓库 0g-geth，看起来是在做 Geth 的二次开发，通过集成预编译合约的方式，加入对 0G DA 的支持。

0G Compute Network 是真正和 AI 模型训练相关的部分，现在已经支持一些 预训练模型 的使用。用户层面的使用比较简单，类似于 OpenAI 的 SDK 一样，发起请求，得到响应，就是一个 Client 层的 SDK。

给 0G Compute Network 的模型提供算力的节点叫 Provider，代码仓库是 0g-serving-broker，代码仓库里有体现模型训练的代码，比如 finetune.py 这个脚本是基于 Transformer 做文本模型的微调，Docker 容器是直接基于 pytorch 2.5.1-cuda12.4-cudnn9-devel 的容器打包。

所以从 LLM 模型训练的角度看，0G 有一些工程方面的技术内容。只不过 0G 在干的事情是微调（Fine-tuning），也就是基于预训练（Pre-training）好的模型，进一步用较小的算力训练，达到执行某种特定任务的效果。而我们平时看到的 OpenAI 和 Grok 等大公司，动辄 1 TB tokens 的训练量，干的事情才是预训练。

比如 OpenAI 训练并开源出一个 GPT-3 模型（实际上没开源），那么 0G Compute Network 就是基于这个 GPT-3 模型，结合自己的语料进行一些微调，训练出一个自己版本的 GPT-3 模型。大概就是这个意思。

更准确一点说，0G Compute Network 是提供了一个训练的场地，结合了区块链相关的经济模型、奖励机制等交互，让用户可以给微调这件事情提供算力并获得收益，另一些用户可以使用微调之后的模型。

至于 Provider 与链上合约交互的部分，应该就好理解了。0G 是用 Solidity 写的合约 0g-serving-contract ，对合约的调用自然也是以太坊生态的那一套组件。而 0G 需要做的，就是把模型微调（训练）的结果，以及关于训练任务的分发、奖励记录、惩罚机制等，用合约来实现，然后在链下的算力节点上集成对合约的交互。

总结

综合来看，我需要改正一开始的态度，0G 是有一些技术含量在的，只不过更加侧重于工程方面的技术，无论是区块链方面的 DA，还是 AI 方面的模型微调，其实做的都不错，业务逻辑上已经能形成闭环。

但是说实话，写 0G 项目的分析，比之前写其他项目的分析，思路稍微不清晰一点，因为白皮书和文档都不是很完善，项目的技术路线又不是特别统一，所以没有非常好的资料自上而下的贯彻整个项目结构。不过经过以上内容的分析，我想应该已经刨析清楚了 0G 这个项目的技术情况。

Arcium Network 是 Solana 生态首个专注于隐私计算的项目，今年 5 月份获得了 GreenField 领投的 5 千万美元的 融资。

Arcium 的 Purplepaper 中提到，Arcium 是一种去中心化的隐私计算协议，主要包含了 MPC 和经济模型两个关键的组成部分：

Arcium 整体的项目结构不算难理解，尤其是和区块链结合的部分，就是直接用了 Solana 的智能合约：

但是 Arcium 在有很多硬核的技术基础。比如在这篇 博客文章 中，Arcium 用简化的例子说明了 MPC 的技术原理。

MPC（Secure Multi-Party Computation，安全多方计算）这种技术不是新概念，存在很多年了，我们最为熟知的就是 MPC 钱包，币安钱包和 OKX 钱包都默认使用这种模式。从学习的角度，可以辨析一下 MPC、多签、MPC 钱包、TSS 聚合签名、BLS 聚合签名这几个有点关联但容易混淆的概念。

回到 Arcium 的文章，简化后的 MPC 大概是这个意思：假如有 3 个参与方 a,b,c 进行计算，计算的内容分别对应 +1,+2,+3，并且参与方会对自己的计算结果加盐分别是 +10,+20,+30，那么经过全部参与方计算后，最终得到的结果是 66，减去参与方的盐值总和 60，得到最终结果 6。

去盐的过程按理也是轮流来的，比如初始值是 66，从 a 到 c 依次渐去各自的盐值，得到最终结果，而不是一下子就减去了 60。对于每一个计算参与方来说，它只知道初始值，以及自己计算的结果值，并不知道执行的顺利，是先 a 执行，还是先 c 执行？协议约定这个信息不是公开的。

真实的 MPC 是一个复杂的交互协议，需要很复杂的工程化实现。总之 Arcium 就是在对 MPC 技术大做文章，试图把这种密码学技术，引入到更多实际的应用场景中，这是一个不错的方向。

Arcium 在研究的技术方向和尝试 很多，比如这篇 文章 中提到的 Confidential SPL Token，是结合了 Solana 的 SPL 标准代币、Token-2022 标准、和 Arcium 的 MPC 聚合架构，提出的一种带隐私能力的代币标准。此外还搞了链上 Dark Pools 的 Dapp，挺有加密风范的技术感。

项目架构

Arcium 的 项目架构 看似很复杂，乍一看 MXEs、arxOS、Arcis 什么的，各种名词。这种是典型的发明概念，就是给自己项目里用的某个组件，起了个高大上的名字，根本不是某种技术名词。几乎每个项目都会有一套自己的术语定义，让外人觉得很厉害。

从这个 Developer 版本的 文档 能更好的理解 Arcium 的架构。作为使用 Arcium 的开发者，实际上是在开发 Solana 智能合约，我们自己开发一个合约（MXE program）来描述计算任务，比如加法运算，a+b，期望得到 c，把这个逻辑写在合约上，然后调用官方部署的合约（Arcium Program）的合约，把计算任务提交到 Arcium 的任务池里：

这样，Arcium Program 就知道了有这么一个任务，而真正执行隐私计算任务的 MPC Cluster（arxOS），根据链上的交易记录，得到事件也就是任务信息，开始进行计算，并且将计算结果提交到链上的 Arcium Program（合约）。回到我们的 MXE program 这边，自然是有一个 callback 函数来接收隐私计算的结果，然后触发一个事件通知我们的客户端：

在合约代码层面，能够实现哪些计算，如加法、减法、除法之类，要依赖于 Arcium 提供的框架，支持哪些计算方式。

那么抛开凌乱的技术名词，Arcium 整体上，是通过链上合约提交计算任务，链下节点计算任务结果后，再提交回链上的模式，这是和区块链交互的部分。此外就是链下计算的过程，Arcium 把 MPC 折腾的很明白，提供了便于使用的客户端（合约）框架出来。

经济模型

具体执行多方计算的节点，Arcium 把它们叫做 StakHodlers，有点复杂，总之就是要么提供硬件设备、经过一系列配置之后参与到计算节点中，得到收益，要么把自己的 ARX 代币委托给某些计算节点，赚一点利息。

在经济模型方面，Purplepaper 里有提到 ARX 的代币总供应量，会随着网络算力的使用量自动调整，达到自动平衡的效果：

这种自动平衡期望的效果是，ARX 的质押率平衡在 50%，如果低于 50%，会自动增发，如果高于 50%，会自动销毁。这个经济模型的设计是利好计算节点的，是希望持有 ARX 的用户能积极参与到质押和计算生态中。但是这种经济模型不是很利于非质押者，因为增发与他们无关，销毁与他们有关，相当于放大了以太坊 PoS 模式的弊端。

不过 Arcium 的销毁模式和以太坊的销毁模式还不太一样，Arcium 会把协议费收上来的 SOL，通过荷兰拍卖换成 ARX，再销毁。这种模式给整体供给带来的影响更复杂一点，得进一步关注和分析了。

综合来看，无论是技术架构上，还是经济模型上，Arcium 都有非常深厚的积累，已经能形成闭环，有很大的进一步观察的空间。Arcium Network 目前是测试网阶段，路线图里还在规划主网的上线时间。

只看官网首页的简介的话，也许会有点疑惑，这个项目的立意肯定没错，保护知识产权嘛，但是具体怎么做呢，官方宣发文章 里提到的 Proof of Ownership and Pirority，岂不是几年前的概念吗？而这些 Proof of… 又是什么意思？

Camp Network 没有公开出 Github 代码仓库，导致没办法从代码层面解读。我一开始还奇怪，为什么不公开 Github 账户？后来我明白了。

Camp Network 的 文档 里说明，Camp Network 是一条使用了 Celestia 区块链做 DA 层的链，基于 ABC Stack 搭建。ABC Stack 又是什么呢，是 Celestia 生态中的一个项目，在架构上明确区别于以太坊的 “L2 Rollups”，而是自己发明了一种架构叫 “Rollup L1s”。

ABC Stack 框架是 Abundance 团队开发的，号称每秒 GB 级别数据的 EVM 完备的 Rollups。也就是说，Camp Network 直接使用了 ABC Stack 的底层技术，搭了一条链出来，在链上做一些应用，所谓知识产权保护、DID、AI 什么的。

那么 ABC Stack 的框架怎么用呢，代码仓库在哪里，怎么操作，需要开发哪些代码？完全不需要，有一家 Celestia 生态的公司 Gelato，提供了 BaaS 平台的服务，比如一键部署 Op Stack 的链、一键部署 Arbitrum 的链，等等，其中就包括 ABC Stack 的选项。而这个 BaaS 平台是收费的，部署到主网需要一个月 3000 美元，部署到测试网只需要一个月 100 美元。Camp Network 目前是测试网阶段。

这就是 Camp Network 连代码仓库都不需要的原因，直接用 BaaS 服务就好了，而且也没有其他选择，ABC Stack 本身就没提供代码。

Camp Network 的 架构文档 里还提到一个东西，BaseCAMP 是刚才提到的用 ABC Stack 搭出来的链，SideCAMP 则是应用专属的链，从文档描述来看，Camp Network 是计划给每一个应用场景，比如 AI、音乐、艺术等 Dapp，都单独部署一条链，同样也是用 ABC Stack 的技术。

有那么多条链的话，BaseCAMP 和 SideCAMP 之间怎么通讯和交互呢？ABC Stack 对 Hyperlane 的跨链技术做了 封装，依此来实现 ABC Stack 链之间的跨链通信。

至于 Camp Network 到底是怎么实现保护知识产权的？Camp Network 提供了一个 SDK，大意是作者需要通过链上交易来声明自己的身份，比如绑定自己的链上地址和 X 的用户名信息，Camp Network 的这个 Origin 框架，就会到 X 上查询我发布的内容，自动生成 IP NFT，然后其他玩家可以来购买这个 IP NFT，相当于购买了版权。

话说，其实是挺老套的玩法。可能以后凡是看到提 DID 这种老套概念的项目，都得多加小心，因为没什么技术，只玩生态，而且玩的是不存在的生态。

Camp Network 整体的技术情况就是这样，连代码仓库都没有，直接用了 ABC Stack 提供的服务，搭建了几条链，然后在链上面做应用。Camp Network 的 测试网 上现在已经有不少 Dapp 了，可以操作和交互。Camp Network 虽然没有硬核的底层技术，但是生态实力很强大，测试网上参与活动的项目非常多。

这是一年以来，我拍的照片中，最好的一张：

也许是因为我头脑中的幻想，给这张照片添加了额外的滤镜。我尝试过对这张照片做一些修改，比如剪裁、调色之类，统统都觉得不好。我还是最喜欢这种，没有任何修改的原图。

对了，我说这是 “最好的一张”，而不是 “最好看的一张”。

这张照片好在，我设身处地的看着这样的场景，随手拍下了这张很美的照片。我喜欢这样的景色，也喜欢这样的生活。尽管那天很热，真的特别热。

这张照片的元素实际上很乱，尤其是背景里有船，还有一些杂乱的树、白色的石头。我喜欢的是，在这种杂乱的环境中，纯净、干净的人物，反而能和杂乱的背景形成对比。

1. 裁剪版本

把背景中的船裁剪掉是不是会好一点？完全没有，裁剪后的照片，有很明显的被裁剪的感觉，画面信息变得很少，干净但是没有 “杂乱中的干净” 的感觉。

2. 旋转版本

这张照片的差异不是很明显，苹果手机有个自动裁剪的功能，厉害之处在于，把图片稍微右旋转了一下，船底的线和整个画面变成平行的了，而不是原图中船身是斜着的感觉。

这样调整之后，人物确实更正了，整张照片也更正了，但是又缺少了一点宽广的视角的感觉。这种差异尤其放大图片之后看，会明显一点。

3. 调色版本

苹果手机的智能调色。水更绿，对比度更高，更加不真实，我不喜欢。

4. 关键帧版本

照片拍的是 live 图，可以选择一些其他的关键帧。这张其实也不错，是一个漂亮的侧面。但是和原图相比，少了一些活波的动作。

5. AI 版本

豆包 AI 的修图能力不错，尤其是某些关键词、某些场景，可以出来一些很好的效果。小红书上不少 Coser 都直接用豆包 P 图来换背景。

不得不说效果确实不错，但是这个图一看就不是真实的场景。

6. 视频版本

豆包还能一键把图片变视频，毕竟是基于抖音那么大量的视频数据做训练，豆包在这方面的能力挺强大。

因为那些充斥着低质量内容的平台，不值得去发布高质量内容的文章。那些人是看不懂的，看不懂我在写什么。看看掘金首页上有什么？10 篇文章 8 篇讲 Cursor，很难想象用户素质得多低。知乎就更不用说了，内容杂乱、商业化，关键是网页访问弹窗，不是让登陆就是让下载 APP，正经人谁去那种平台啊。

Web3 行业小，从业者本来就不多，也没有什么好玩的内容平台。去吸引一堆只懂 Web2 的用户，其实也没什么意义，和他们是没有共同语言的。我在脉脉的职言区，匿名账号下，发布过几千条帖子，总阅读量超过几千万，发的都是观点偏激、引战一类的内容。那种阅读量有意义吗？毫无意义。

所以实际上没有更好的选择。

我知道独立博客没有人看，因为我自己平时都不太看别人的博客。长期关注并且反复看了很多遍的只有王垠的博客，不只是看最新的文章，还会用 Wayback Machine 来 “考古”，还搜集了很多王垠博客的备份链接，还整理出了一个王垠百科那样的网站……

以前偶尔也看一眼左耳朵耗子（CoolShell，陈皓）的博客，他的博客内容很多，研究的技术很多很杂，属于宝藏一类，文章不值得读但是他关注的技术关键词值得关注。比如他在 2022 年研究过 ePBF，ePBF 是 Solana 区块链实现 SVM 虚拟机的底层技术。可惜他的博客已经不更新了。

其实 CoolShell 这个博客，对我们来说是一个反面例子，他在告诫我们，不要过于专注技术，不需要什么都懂，不需要那么努力，不需要那么有观点，不需要…… 他应该引起我们的反思，高质量的技术博客，真的有意义吗？

另外阮一峰的博客很多年前看过，后来随着自己技术能力的提升，就不看了。阮一峰的博客不算技术博客，里面都是一些文艺类的内容，小白观众居多。

我自己关注的博客都没几个，而且都是很知名的人物，就这么个情况，相信别人也一样。所以继续努力吧，等自己成为 somebody，再考虑访问量的问题。没有人会关心 nobody 写的东西。

更新（2026.08.11）

想到新增两个观点：

• AI 没办法写出 “我经历了什么” 这样的话题
• 你可以不写博客，但是不要忘记思考

Psyche Network 是 AI + Web3 赛道的一个项目，由 Nous Research 团队研发，两个月前获得了 Paradigm 机构 5 千万美元的 A 轮融资。

Psyche Network 的项目背景在 官方说明文章 里有详细介绍。Nous Research 团队研发出了一种去中心化的算法 DeMo，这种算法能够把大语言模型（LLM）的训练，放到分布式网络里进行，不需要集群服务那种高耦合。就类似比特币挖矿的矿池一样，会把大的计算任务，拆解为小的计算任务，分发给不同的 Client 节点进行计算，计算之后再把结果汇总起来。

当然 LLM 的训练和矿池的挖矿，从算法原理上完全是两码事，这里只是想类比说明便于理解。具体 DeMo 是怎么从算法角度把任务拆解和合并的，可以看 官方的解释，反正我没看懂，就是一堆向量、权重、loss function 什么的术语。关于怎么防止节点提交虚假数据之类，我认为也都在算法的设计范畴，后续就不多讨论算法本身的有效性了。

DeMo 的 论文 里用了 100 billion 的 tokens 做训练测试，得到了比较好的结果。100 B tokens 是什么概念呢，比如 DeepSeek-V3 的 tokens 数量是 15 TB，可见 DeMo 在实验阶段的 tokens 数量级，距离商用产品还差很多。可以对比一些其他模型的 tokens 数量：

Psyche Network 基于 DeMo 的算法原理，结合区块链来构建分布式网络，第一阶段的目标是训练出 40 B parameters, 20 T tokens 的模型。关于 parameters 和 tokens 这两个指标，我的理解是，parameters 是训练一开始就定义好的固定指标，tokens 则是需要不断进行计算和训练的，而 DeMo 解决的是 tokens 的分布式计算。Psyche Network 官网上有实时显示当前的训练进度，目前已经达到了 1 TB 的 tokens 数量：

这个模型训练完，也许可以接近 GPT-3 的水平。对比来看虽然 tokens 数量比 GPT-3 多，但是 parameters 比 GPT-3 少，所以最终效果应该不如 GPT-3。

项目结构

Psyche Network 的 文档 里有介绍整体的项目结构，比较好理解，有一个中心化的 Coordinator 负责创建训练任务，其余的 Client 负责接收任务、提交任务结果。在没有区块链的场景下，Coordinator 与 Client 之间的通信是通过直接的 TCP 连接完成的。而有了区块链之后，Coordinator 和 Client 之间就是通过区块链来传递消息了。

Psyche Network 的 代码仓库 里同时保留了 centralized 和 decentralized 两个版本的代码架构，这其实不太是好事，因为说明这个项目原本可以中心化运行，只是现在在做一些去中心化改造。这样的项目去中心化程度肯定是有限的。

而所谓去中心化版本的部分，Psyche Network 选择了 Solana 来作为运行智能合约的区块链平台，这也许和 Psyche Network 原本的项目就是用 Rust 语言有关。

代码仓库的 decentralized 目录下，有一些 Solana 的合约代码，这些 Solana 合约承担起了创建训练任务、计算每个 Client 节点的奖励、分发奖励的功能。

Psyche Network 目前只是测试网阶段，链上交易也都是在 Solana 的 Devnet 上进行，可以直接看合约文件里的 declare_id!() 语句，里面写的就是合约地址，比如 coordinator 的合约地址是 HR8RN2TP9E9zsi2kjhvPbirJWA1R6L6ruf4xNNGpjU5Y，能在 区块链浏览器 上看到频繁的交易记录。

至于奖励的计算，因为有 Coordinator 这个中心化角色的存在，所以事情比较简单，Coordinator 在收到 Client 的任务结果后进行验证，如果没问题，则发起一笔链上交易，给 Client 记分。具体代码是 这两行：

每个 Client 的分数都记录在合约里，Client 想领取奖励，就自己到 treasurer 合约上 claim，treasurer 会根据分数和汇率计算并转账代币。

那么 treasurer 分发的奖励是哪个代币呢？具体代币是 Coordinator 在创建任务的时候 指定的，只要是标准的 SPL 代币都可以。

所以整体来看，Psyche Network 是利用 Solana 区块链来记录任务 Meta 信息、计算任务奖励、分发奖励等。只要 Client 的加入是 permissonless 的，Psyche Network 就确实达到了和宣传一样的效果，让 LLM 模型训练的算力去中心化。

而代币的分发和奖励虽然是区块链项目的常规操作，但是至少附加了公开透明等特性，而且不出意外的话，Psyche Network 最终会走到发币的一步，到时候任务奖励可能全用 Psyche Network 自己的代币进行，或者演变为 LLM 训练的任务平台，任何第三方都可以创建任务和分发奖励之类，像 Eigne Layer 那样。

计划内容是，每天分析一个 Web3 行业的项目，从看白皮书开始，到理解项目的运作模式、当前商业状态等，尤其关注技术理念和技术创新方面，然后写成分析报告，发布到博客上，不需要那种很专业的报告，大概相当于学习笔记就可以了。具体分析哪个项目是经过主观挑选的。

每天看一个项目、出一个分析报告，节假日和周末休息，直到不失业的那天，停止计划。每天形成的分析报告，也许会有质量，有看点，但也许会比较短，没有质量。因为我并不能在一开始选定项目的时候，就知道这个项目有没有含量，尤其是技术含量。

这有点像是区块链研究员干的事情，而不是区块链程序员应该干的事情。为什么我的计划不是每天写 100 行代码，开发一个区块链小工具，或者每天积累一点，开发一个大的区块链工程？

因为工程代码如果脱离项目背景，就没有价值。我之前几年的工作中写过很多代码，但是如果现在把那些代码拿出来，会发现毫无意义。工程化的代码，往往是为了完善项目的功能，而项目需要某些方面功能，是为了迎合运营和宣发的需求，一定是有商业目的的。如果需求背景不存在，代码就毫无价值。

尤其是随着 AI 的日益强大，写工程代码这件事情更是越来越廉价。AI 可以几分钟写出上万行代码，堆砌代码的能力绝对超过人类。如果我想靠每天写几百行工程代码来训练和提升自己，那我一定会失败的很惨。所以不能干这样的事情。

什么样的工程代码是有意义的呢？就是已经找准了产品需求和定位的情况下，想把功能落实跑通，然后让 AI 来干活，把代码写出来。AI 写的代码有时候会跑偏，需要手动修复一下 bug，这种情况下，手动写出的工程代码才有意义。现在的开发节奏已经应该是这样了。

以前的时代，人们喜欢说 “Talk is cheap. Show me the code”，但是现在时代变了， prompt 比 code 更有价值，也许这句话会变为 “Code is cheap. Show me the prompt”。

不去计划每天写一些工程代码，另一个原因在于，我已经做过了一些尝试，去试图开发小的区块链工具，或者大的区块链工程。目前来看，我之前的想法，无论是做小工具的思路，还是做大工程的思路，都是没有结果的，因为需求本身也许不存在。说的直白一点，没有任何正反馈，所以根本做不下去。

与代码相比，写文字、写文章、写观点更有意义一点。一个产品创意背后，可能有 100 行代码，也可以有 10000 行代码，需要付出的时间成本完全不同，但如果最终的关注量都是 0，那么结果就是一样的，9900 行代码白写了。而文字是能够体现思想的。

你也许想反驳，怎么能说工程代码没有价值呢？以太坊的客户端同一份 Spec，有五六种工程化的实现，用了不同语言、做了不同优化，市场占有率有高有低，难道不是工程化代码价值的体现吗？当然是，他们拿着以太坊基金会的赞助开着公司写着代码，而且已经有了明确的项目背景，工程代码自然是有价值的。我指的是没有项目背景的工程代码。

虽然工程代码没有价值，但教学性质的代码是很有意义的，我仍然会复习计算机课的练习题，以保证自己的代码水平。我已经是第三轮做那些练习题了，这次我严格限制自己的做题速度，一天最多做一道题。一方面是保证有足够的时间消化练习题包含的知识，相信潜意识的力量。另一方面，得分配时间到其他事情上，不能整天只反复做同样的题。而且由于做题比较慢，可以逐渐培养自己每天做题的习惯，不至于遗忘计算机课的知识。

为什么我觉得对项目做分析是有意义的？因为其实我对区块链技术的理解，很大程度上，来自于几年前，读了很多白皮书。我当时按照币种市值的排名，逐一下载了排名前几百的币种白皮书，还用 A4 纸都打印出来看。

记得几年前有人发邮件问我，如何学习区块链技术。我当时认真写了个回复，说我是从哪个网站下载的白皮书，以及看了哪些书之类。后来对方回复我说，这不是他想要学习的区块链技术，他想要学习的是如何写代码。那个时候我才意识到，不同的人，对技术的定义是不同的。

以前没有 AI，我没能认识到代码的价值，现在有了 AI，我还是认识不到代码的价值。

为什么我觉得自己可以写出项目的分析报告？我以前没专门针对项目写过，但是有根据技术来对项目做横向对比的内容，所以专注于对某个项目做技术分析，应该不是难事。我工作过的项目，假如让我写分析，肯定能写出其中的细节，只是因为项目还在，不能写。而且写项目分析，对我来说也是一个学习和积累的过程。

我不确定一个项目一天时间够不够，只有写写试试了。

面试官水平挺好的。对方是在做 AA 钱包的业务，基于 zk 的社交恢复方向。交易所不差钱，一般都喜欢往钱包方面做。

• 2025.07.01（火币，一面）

钱包开发团队的后端开发职位，一面比较随意一点。

• 2025.07.02（火币，二面）

属于交叉面，聊一些偏经验性质的东西。

• 2025.07.03（鲲鹏海天）

线下面试的，虽然去之前就知道不靠谱，但还是去了，就当出门散步了。

• 2025.07.03（火币，三面）

技术面的终面，但还是交叉面，有点奇怪。

• 2025.07.07（phemex，二面）

看起来面试官是密码学方面的专家，在 zk 方面非常有经验，我在面试中也学到不少东西，挺难得。

• 2025.07.08（川研科技）

面试中我说没有 Defi 后端的经验，然后面试官让我用一个星期的时间完成一个任务，一个星期后二面，也是挺离谱的。

给我的任务内容是，解析 Uniswap v4 Router 的交易。我反复问对方这个任务的难点在哪里，对方说，难点在于函数的入参不是基本类型，而是 bytes，需要对 bytes 做解析。这种任务对我来说还挺侮辱人的。

这家公司是做 trading bot 的，关心解析交易、跟单、价格变动、用户资产一类，也需要发一些夹子交易之类。

• 2025.07.10（海利普科贸）

线下面试。不得不说一面线下面试的都是坑，遇到不懂技术的技术负责人真的浪费口舌。

（有感而发）

有些公司没有任何区块链技术背景，公司里没有懂区块链的人，你说你不虚心请教来面试的人，反而一副高高在上的样子，自以为学了点皮毛就居高临下地考察别人，给这些人惯的。

有些面试官的思路很奇怪，他们把面试过程当成竞技场，非要在面试中胜过面试者才乐意，当面试者说了很多他们不懂的东西，他们无动于衷、视而不见，然后不断找其他话题，直到找到了自己熟悉的那么一点点狭隘的技术领域，他们终于松了一口气，像是在说，“看，我知道但你不知道！”，并且会因此否定面试者。

这种判断方式很奇葩，一张满分 100 分的试卷，你只会做第一道价值 10 分题，而别人除了第一道题都会做，得分 90 分，你却抓着第一道题不放，因为你只有第一道题才能说上点什么，不然很露怯。这些人以在面试中胜出为目的，而不是充分挖掘面试者的潜能，判断是否能给公司、给团队带来价值。

还有另外一种现象我也不理解，举个例子，Go 语言 “千辛万苦” 做出了自动的垃圾回收，减轻程序员对于内存管理的头脑负担。而有些面试官 “千辛万苦” 去搞明白 Go 语言 GC 的原理是什么，不但引以为豪，而且拿来考察候选人。作为 Go 语言的教徒，你知不知道你的行为在否定 Go 语言设计者的努力？如果真的相信用头脑来管理内存的力量，为什么不去搞 Rust？好比我是一个汽车驾驶员，我要去考驾照，难道需要我搞清楚发动机的工作原理、是怎么把汽油燃烧转变为机械动力的、能量转化公式是什么？我又不是在制造汽车，也不是在开发编程语言。

另外还有一种，属于经验匹配论。因为面试官并不能很好的评估候选人的能力，所以主要以工作经验为判断依据，根据公司正在做的事情，看候选人是不是有相关经验，有则说明候选人能胜任工作，没有则不确定。这实际上是面试官判断能力不足的体现，他看不懂你过往的工作成果，也理解不了你写的技术文章，只知道守着自己的一亩三分地，想找个听话、能干脏活、好控制的人就可以。而且事实上大多数公司招聘的时候，都是在看经验上的匹配程度，挺无语。

我不是在抱怨 “为什么他们看不懂我的能力”，而是在强调面试过程中，面试官对待候选人的态度问题。很多面试官在面试中表现出种种不尊重人的行为，随意根据自己的喜好评价别人，一副考核别人的态度，但也得看看自己几斤几两，有没有资格去考核别人。退一步说，无论候选人的技术好坏，你都应该保持尊重和友善的态度。而事实上呢？很多面试官给人的感觉，就像在菜市场里买菜，东挑西捡的样子。大概是因为中国几十年来的高速发展忽略了素质教育，培养出了一代素质糟糕的人。

• 2025.07.15（imToken）

和 HR 的沟通。虽然一般认为和 HR 聊天不算面试，但是这位 HR 让我有点感慨，也许只有像这种有丰富国际背景的人，才明白 “尊重人” 是什么意思。相比之下，国内的很多 HR，甚至开发团队中的核心员工，都完全没有这种概念。

• 2025.07.18（imToken）

技术面。完全不出意料的，面试体验非常好。无论我在面试中的表现如何，无论有没有通过面试，我都得这么评价，面试体验非常好。面试官是来自台湾的团队，明白了吧。面试官对技术的理解很丰富，我在面试中也收获到很多。

• 2025.07.18（索洛幻想）

一家游戏公司，是普通的 Go 语言开发后端职位，线下面试。我是随便投的简历，不知道为什么公司会让我去面试。我估计会很不靠谱。

面试之后确实不太靠谱，不过面试体验还算可以。让我去面试的原因是，面试官 19 年左右做过区块链开发，可能也是好奇我的技能情况。这次面试让我再一次体会到了隔行如隔山，我一直觉得互联网和区块链是两个行业，互相是不通的。以后还是不能再投互联网的后端开发职位了。做互联网的人也许甚至感知不到有 “区块链” 这个行业的存在，他们觉得既然都是后端开发，开发什么都可以。

• 2025.07.19（不知道名字）

线下参加了 The Web3 社区的一个交流会，原来 The Web3 社区是一家天津的公司，老板是从 bybit 出来创业的，现在在做培训班的生意，就是让 web2 的开发者通过培训，进入到 web3 的公司，并且在宣传的时候刻意夸大了 web3 的薪资，满口财富自由之类的话，吃相很难看。培训班这个行业，还真是各行各业都存在。另外我发现从 bybit 出来的人，往往会有一种迷之自信。

• 2025.07.21（Web3 Holding Limited）

我不确定这是一家公司的名字吗，它是一家交易所，职位是区块链开发运维（Devops），像是运维岗，我本来兴趣也不大。

结果没面试上，因为面试链接是 Lark 的会议，但是我网页点不开那个 vc-jp 开头的域名，然后电脑和手机都下载了 Lark 尝试，手机号登陆说我没有组织不能进入会议，邮箱登陆进去就让我创建组织。总之搞不懂，我用 Lark 工作过，也用 Lark 参加过面试，没遇到过这种情况。折腾了有半个多小时吧。当然前十几分钟发现进不去的时候就告诉 HR 取消面试，没有让面试官和 HR 久等。但我也不想再折腾这种问题了，看来这个面试是没机会参加了。

• 2025.07.22（CKB）

和 HR 聊，不是面试。开发者关系一类的岗位。

• 2025.07.23（imToken）

二面，面试体验依然非常好，不想透露具体的内容了。

但是对面试结果不抱有积极态度，根据我的经验，凡是在面试中对你表现出考核态度的，面试结果都不会好。因为他们面试的立场，从一开始就不太对。

• 2025.07.24（长奇）

属于比较普通的常规一面，面试官没看过我简历，现场看那种，然后问一些不痛不痒的技术问题。职位是 Dex 后端开发。

• 2025.07.25（博鸿易科技）

职位简介是区块链底层开发，而且是线下面试，有点奇怪。

面试之后，再一次证明了这句话，“一面线下面试的都不靠谱”。这种线下面试一般是整个公司都不懂区块链，做互联网的，然后要搞个区块链项目之类。这家公司之前是做原子链的。

虽然工作机会不靠谱，技术负责人也不靠谱，不过 HR 小姐姐还挺能聊的。我给她分享了很多区块链行业的现状、风险、招聘方式、就业情况等，尤其是和互联网行业的差异、面试体验什么的，她说自己不太懂这些。

• 2025.07.31（CKB）

开发者关系岗位，招的是全栈开发。面试官说自己比较顾虑的一点是，我到底会不会用 TypeScript 语言做后端开发，以及会不会前端开发，因为我的简历上看不到那些。这种情况我没办法，不过好在面试官很诚实，直接了当地说出了这些。

大概两个月前，我把博客上的文章精简了一下，删掉了所有关于个人经历的部分，因为那些内容太过真实，又可能带来负面影响。于是这个博客就从 “个人博客” 变成了 “技术博客”。这种精简带来了一定的好处，让技术相关的内容能更直白的摆在上面。但是这种精简给我整不会了，我有很多想说的话不能放在 “技术博客” 上面，这很麻烦。我其实还是喜欢原来的 “个人博客”，因为那是我说真话的地方。

出门在外，人设都是自己给的。精简版本的 “技术博客”，单看内容其实还不错，也许会给人某种高大上的感觉，如果我写一堆 “找不到工作”、“求职经验” 在上面，岂不是破坏整体的技术风格。

ChatGPT 对我过往经历的总结是 “失败朋克”，这个词来源于 “赛博朋克”，意思是我谈论的技术像赛博朋克世界里的高楼大厦，到处都是高科技的电子屏幕和飞船，同时另一方面，我的职业经历非常糟糕，与技术内容很是割裂，像是在赛博朋克世界里，住在贫民窟的那一波人，时刻为生活担忧和奔波，所以叫 “失败朋克”。

我最近感觉有点憋屈的地方，就是我不能或者不敢在博客上写太真实的东西了。比如我前几天写了一篇文章，标题是《回忆同事被另一个同事赶走的事情》，但是不敢发。这篇文章是《因为同事的不尊重，我换工作了》的续集，里面的内容很简单，我可以按照时间线梳理一下我想表达的意思：

• 《从团队内部的混乱想到……》：老同事对我不好，leader 置之不理，放任不管
• 《因为同事的不尊重，我换工作了》：老同事对我不好，我就走了
• 《回忆同事被另一个同事赶走的事情》：其实老同事不只是对我不好，他对谁都不好

这些每一篇都超过两千字的文章，我完全可以用一句话概括出来我的想法。写那么多无非是填充了很多具体的事情过程，意思是，你来看吧，你来判断吧，我把前后因果都写出来了，这不是我的错。但就是这样的内容，在 ChatGPT 的评价体系里，觉得我不应该写这些，尤其是面对未来又可能的招聘方，对方可能会有顾虑什么的，让我别发出来。

我有时候想不通，明明受欺负的是我，但是我却不能把这些真实的事情公之于众，一旦说出来就显得是我的错，错在不应该说出来，天呐……这是什么世道。

裁员的事情也是，有人说《公司没了，我又失业了》的内容会给我带来危险。我从来没想过占公司的便宜，无论是哪一家。但是我却遇到了不靠谱的公司，我已经尽可能用 “体验了 web3 行业的下限” 来安慰自己从这件事情中学到了东西，但是我仍然记恨当时把我招进去的人，他是巴比特钱包的负责人，当时巴比特因为被盗 15亿事件裁了钱包业务线。我可是跳槽去的啊……

而遇到裁员后，我直到现在都没找到工作，我也用了很多内容来对抗这种焦虑和失败的情绪：

• 《失业第二个月干了什么》：我一点都没闲着，我很努力在学习技术
• 《Web3 技术人的职业生涯注定不稳定》：我去年裸辞没有错，至少我不希望是错
• 《web2 开发如何转型 web3 开发》：我不信培训班出来的，技术比我好，找工作比我容易

回到找工作的事，ChatGPT 对我职业和技能方向的评价是，“在不招骑士的王国里苦练骑士精神”，我也很清楚现在工作职位少，尤其是和自己技能匹配的。但是我也不止一次提到，我很少遇到在面试中，技术很牛的面试官，真的很少有人在区块链技术问题上把我问住，大多数都是这种，“有没有做过xxx？没做过啊，不匹配”。我还能说什么？我就是没做过啊。

还有一些问 web2 技能的，我不是学不会那些东西，是 web3 真的用不到，这完全是两个行当，互联网和区块链是两个行业，技术栈不一样。假如我专心从事 web2，也许我考虑的，就是如何开发一个最小数据库、开发一个最小 MQ、开发一个最小 Redis 之类的东西了吧。就像我在尝试《想开发一个最小 EVM 虚拟机》那样。

其实 web3 行业很小，比互联网行业小的多，人更是少，尤其是专注于技术的技术人。我面试了那么多公司，面对的可都是 web3 公司的面试官啊，真正懂区块链技术的却没几个，甚至有时候都对他们的 “菜” 感到生气。比如我在考虑怎么开发一个 EVM，然后你在怀疑我会不会解析某个合约交易的参数……你都会我怎么会不会呢 🙂

至于最近上的课，主要是出于补齐自己计算机基础的目的吧，成体系的那种。我不需要再怀疑，是不是因为学历或者专业的问题，导致自己找不到工作。有的招聘方就喜欢 c9，这种我也没办法，那是人家的喜好。

那么既然我的职业生涯很糟糕，为什么不转行回到 web2，去找互联网行业的工作呢？因为我相信未来的 web3 行业，会比现在更大、更景气、更繁荣。我博客上写的技术内容，也许现在没有人在乎，但是直到有一天，web3 的产品走进千家万户，web3 的公司像 web2 一样多，人们谈论区块链技术像谈论 MySQL、Redis、RabbitMQ 一样自然，学习共识机制就像学习面向对象一样基础，使用加密货币理财就像支付宝基金一样方便，然后就会明白，懂区块链技术是多么有价值的一件事。

虽然我知道我现在的年纪，不太可能是终点，但是连续遇到面试的失利，难免会有糟糕的情绪。你可以设身处地想一下，面试二十几家公司都不合适，你的心态会怎样。关键是市面上能投简历的职位都投过了，从 2023 年到今天为止，所有技术相关的职位。每面试失败一家，就意味着今后少了一个选项，我都怀疑还能有那么多公司让我去排除的吗。

没办法，吐槽结束，继续努力吧。

补充（2025.08.03）

不知道你看懂没有，这篇文章，以及很多之前的文章，都是在对我自己的人生经历和职业选择做建模，这是我无意中在做的事情。

真正让我生气、焦虑的，不是我这段时间没有工作和收入的问题，而是没有公司认可我的能力这一点，我自认为拥有的技术实力不应该是这样，我不知道哪里出了问题。

我最理想的面试，是有一个技术能力特别厉害的面试官，告诉我技术能力哪里不够，因此我不符合公司的招聘要求。这种情况下，我自己也能够明白技术能力上有哪些欠缺的地方，并且日后去逐一补齐。

而实际上，我看着那些面试官，以及想到过往工作中遇到的那些、技术能力差劲、人品糟糕的同事，看他们有着安稳的生活和工作、在公司中掌握着话语权，我不理解。

我一直在坚持某种 “正确”，有理有据地做出人生中的每一个选择，但是生活却不如意。这是为什么。

FMV 游戏操作简单，很适合我这种老年选手玩。我前几年喜欢玩剧本杀，后来年纪大了就不玩了。最近发现好的 FMV 游戏也挺有代入感，能够带来一些有意思的剧情体验。下面是我最近玩过的游戏，根据自己的喜好排名，都是在 MacOS 平台的 Steam 上买的，我体验不了 Windows 游戏，也许会错过一些好游戏：

1. 完蛋，我被美女包围了

游玩时长 5.6 小时。这个游戏当年销量很好，以擦边片段出名，在抖音上很多 “浩浩妈做瑜伽” 之类的梗。这个就是浩浩妈：

我喜欢这个游戏的地方在于，剧情非常炸裂，比科幻片还科幻，好几处能笑出声那种。大体剧情是好几个美女主角争着抢着要得到你的好感。

除了题材之外，游戏剧情的节奏也控制的很好，这种 FMV 游戏，剧情一拖沓就会让人觉得无聊，剧情没有爆点就会没意思，如果剧情短选择太多，又会觉得烦，如果关键选项设计不好，会让人玩不明白。其实 FMV 要设计好也不容易。

我第一次解锁的是 “男闺蜜” 结局，谁都不得罪，结果混成朋友了。后来解锁和比较喜欢的是肖鹿的结局：

这个游戏全程用第一人称视角，比较有代入感，而且还有弹幕，看剧情时不显得孤独，总体各方面设计都不错。《完蛋，我被美女包围了》是我目前最推荐的游戏。

2. 完蛋，我被美女包围了 2

没错，是《完蛋，我被美女包围了》的续作。第一部发布于 2023 年，第二部发布于大概 10 天前，也挺巧的。

游玩时长 6.1 小时。《完蛋，我被美女包围了 2》没有沿用第一部的擦边风格，而是加入了很丰富的古风剧情，同时保留了很高的拍摄质量、剧情节奏等要素。比如虽然会看到古灵精怪的二小姐这种老套剧情，但是演员演的很可爱：

也有一些我们熟知的片段，比如侠女受伤了，需要你擦药：

或者外国的公主要勾引和刺杀你：

《完蛋》系列的出品方在做 FMV 游戏方面应该已经很有经验，所以能连续做出好玩的游戏。第二部虽然表面上是严肃的古风题材，实际上是喜剧风格，很多情节都有喜剧元素，这也是我比较喜欢的地方。第二部的配乐和音效更多了，还有威亚之类的动作戏，整体拍摄更专业。游戏里还加入了 AI 聊天的功能（真是什么产品都在结合 AI），要素比第一部齐全。

3. 情感反诈模拟器

“情歌一响，反诈白讲”。《捞女游戏》能出圈肯定是有原因的，一方面是融合了胖猫事件之类的情节，另一方面是，故事确实挺感人，尤其是第二章的末尾，这一段是网络上流传最广的。“可不可以” 的音乐一响起来，就开始和白月光回忆过去：

游玩时长 4.4 小时，后面的章节玩不下去了，感觉剧情有点啰嗦。但是光第二章的结尾这一段，就非常打动人了。

4. 名利游戏

游玩时长 5.8 小时，其实这个游戏也不错。我第一次完整的玩完一个 FMV 游戏，剧情还可以，有暴力、有套路、有仙人跳，只是过程中的选项偶尔莫名其妙，毫不起眼的一个选择会影响主线那种：

比如像这种看似重要的选择，其实不管选哪个，都会走向短的坏结局，而好结局，藏在很不经意的选择上。

5. 你好，我们还有场恋爱没谈

游玩时长 5.5 小时，出乎意料的还不错。本以为除了《完蛋》系列，很难有游戏好玩了，没想到这个还行。

剧情梗概是从社畜穿越回大学时代了，画质和布景美的像写真一样，剧情节奏也不错，每一小节不是很长，不会看到无聊。

6. 其他不太推荐的

• 《完蛋，我被美女包围了：房间里的心跳》

游玩时长 2 小时，是《完蛋1》的 DLC，新剧情和新人物，和《完蛋1》不同，没有任何擦边内容，修罗场玩法更突出一点。剧情勉强看得下去，整体流程较短，喜欢《完蛋1》可以当情怀玩。

这种游戏我有点找到规律了，可以直接看排行榜，哪个女主角的人气最高，在剧情中就指着哪个女主角的线选，剧情往往更有意思。

• 《完蛋，我被美女包围了：前传》

游玩时长 1 小时。剧情上是《完蛋1》的前传，有人物和情节联动的部分，讲述男主大学时代的故事。发售时间在《完蛋1》之后，《完蛋2》之前，2024 年 10 月份左右。这个游戏保留了不少擦边元素，但是剧情比较弱，游戏方都很识相的连未观看剧情都可以快进。

• 《超级星探》

游玩时长 1.5 小时。制作精良，环境优美，女生漂亮，剧情差劲。FMV 游戏的剧情片段冗长是大忌，这个的游戏语速和剧情节奏都太慢，全程 2 倍速都嫌慢。

• 《与美女合租的 99 种死法》

游玩时长 1.5 小时，人物和台词略显尴尬。唯一的好玩之处在于死法多，出乎意料。其他游戏都是刷女主的好感度，这个游戏男主还有血条。

• 《阿西，美女室友竟然……》

游玩时长 0.5 小时，语言是韩语语音和中文字幕，剧情还可以，但是不太喜欢听韩语。

• 《都要！小孩子才做选择》

游玩时长 0.5 小时，开局鬼屋氛围，有点吓人，后面剧情也一般，主要是拍摄出来的画面有点失真，容易出戏。

• 《完蛋，我也能追到美女了》

游玩时长 0.5 小时，不好玩，剧情尴尬，片段太长。

• 《命运游戏 2》

第一部闪退，第二部剧情发展非常慢，不好玩。

• The Isle Tide Hotel

Netfilx 出品，选项比较少，不能快进，不能回退，一条命到底，更像是看电影。

• Ten Dates

美国人的游戏，比较注重内容，不好玩。

题外话

我发现一个类比。

有些捞女，或者混迹于酒吧的女孩，喜欢画着精致的妆容，去认识开豪车的人，非常主动，要联系方式、介绍自己、约会等，本质上是觉得自己更值钱、值得认识更好的人。

而打工人，会写着精致的简历，非常主动去投简历、面试、寻找更好的工作、团队、项目，本质上也是觉得自己更值钱、值得更好的公司和老板。

这就是玩 FMV 游戏给我带来的，某种现实意义上的感受。

希望大家都能有轻松愉快的周末。

我们小组当时加入了一个技术能力不太好的新同事。技术能力的好坏是相对的，也许做其他工作，或者在其他团队可以发挥出更大的价值。这里说的不太好，主要指在我们的项目背景下，几乎无法胜任对 ZetaChain 做二次开发的工作，他也许光是链下扫描、链上处理事件的结构都没整明白。

我刚进入的项目的时候，当然也不熟悉项目，我没做过 Cosmos 开发，也不了解 Restaking，更没看过项目代码，自然不熟悉。但是我当时挺了解区块链项目的模式。

就是《看懂任意区块链项目的技术架构》文章里提到的那些，我看一眼项目就马上明白了，有感而发写出了那篇文章。这个技能是在之前某家公司训练出来的，因为工作压力小，我有足够的时间，一个人去看懂复杂程度非常高的整个系统，从搭节点到 VBFT、合约逻辑、State Channel、IPFS、PDP、libp2p…… 我已经忘记了具体干过什么事情，但是这个折腾和调试复杂代码的过程还记得。

我基于已知的区块链工程的模式，逐步去了解项目、看懂代码结构，所以我上手和掌握项目的速度还算快，一两个星期就提交了代码，一个月左右就提交了更复杂的代码。

不过毕竟我刚入职一两个星期，没办法独自承担某一个比较重要的任务，所以测试网上线的事情由另外一个老同事负责。这个事情后来做的比较糟糕，我们内部也好几次复盘分析这件事。

其实我加入项目的时候，就已经错过了项目上线的最佳时间，这一点是我倍感遗憾的。假如我可以早几个月加入项目，我就可以在比较熟悉项目的情况下，发挥更大的作用，也许项目进度就不会是那样，项目结果也会更好。可惜事实上我加入项目的时间点，就已经无力回天了，哪怕我后来频繁主动加班、非常努力地推进工作。

说的有点远，我们新加入的同事，比我晚加入一个月。leader 对他抱以和我一样的期望，觉得他的水平应该和我差不多。（话说，谁说随便招个人就有我这个水平的😝）。但是事实上，经过了两三个月的工作，他一个开发需求都没完成。估计他连整个项目是在干什么都没搞懂。看起来属于初级开发，需要非常明确的给一些小的编程任务才行，稍微带点业务逻辑、复杂一点就不行了。

我说这些不是想落井下石，或者贬低他，只是想客观描述一下他的技能水平。人家也没说自己是高级开发，我也不知道他对自己的评估是怎么样。

我的意思是，尽管我对他的技术能力有感受，但是我没表现出什么，很多需求和问题是我帮他解决。不知道他出于什么原因，遇到某些问题的时候，比如项目部署报错了，他就会处于一种摆烂的态度。我已经告诉他排查问题的方法，他仍然会把事情放在那儿。最终还得是我亲自登陆服务器、看日志、改代码，然后这个需求就 close 了。我猜啊，其实他也委屈，他是真不会，没办法。（需求的 owner 是他，我才会说我亲自动手属于我帮他）

话又说远了。我一开始提到的老同事，有一天早上给我打电话，问我对新同事的印象（其实已经不新了，工作好几个月了，这里的称呼主要用来区分人物）。我如实说出了我的感受。然后他就开始吐槽，说昨天晚上，他交给新同事一个需求，新同事不会做，他手把手的教，新同事反而表现出了极度的不耐烦…… 这个老同事白天经常有事，喜欢晚上上班，所以我猜新同事的情绪，很大程度是因为太晚了不能下班导致的。不过新同事的态度倒是也有点问题，他一看到需要改上百个代码文件，就懵了，虽然只是很小的改动。

然后那个老同事，就在给我打电话的当天，单独跟大老板和 leader 说了这个情况。再然后的一两天，新同事正式被裁掉。

事情的过程就这么简单，因为老同事的消极反馈，新同事马上就被裁掉了。

不知道是不是新同事这件事情的缘故，导致老同事觉得自己有非常高的影响力，或者非常高的地位。他后来跟我也发生过一些事情，也许是某种情绪上的惯性，感觉他似乎忘记了我的工作表现、对团队做出的贡献，用非常糟糕的情绪对待我，把我当新同事了可能。那件事情也成了我主动离开项目的原因之一。

所以从这个事情可以看到，有一个爱挑事又身处关键位置的同事，会让整个团队鸡犬不宁。

话说，那个新同事，在项目里工作了几个月，拿着全额工资，啥也没干，最后走了。我在项目里工作了几个月，加班加点，费心费力，就挣了点工资，最后也走了。我们入职时间没差太多，离职时间也没差太多。

有时候也是感慨，人生啊，这个得失，不好说。

为了行文方便，这篇文章不使用 “王垠老师” 这样的尊称，直接称呼名字 “王垠”。

大约 2 个月前，我开始报名学习王垠的 计算机科学视频班（基础班），经过 1 个月的学习后毕业，大概用了 120 个小时的学习时长。“120 个小时” 这个数字是经过认真估算的，包含了观看视频的时间和做练习题的时间。因为视频课的学习节奏由自己把控，毕业速度因人而异，所以 “1 个月” 这样的描述不够直观，用小时数更加容易理解。 120 个小时意味着，如果一天学 2 个小时的话，不包括节假日需要 60 天。

如果我说学了 1 个月，也许有人会很不在乎，1 个月的时间能学到多少知识呢？世界上没有速成班，王垠也不可以。1 个月的时间确实不可能学到各种全面的知识，时间上也不允许。但是 1 个月的时间能不能帮我把过往的编程技能梳理一遍，让我对计算机科学有更加体系化的认识？我在工作中可能见过各种迷雾，王垠的课程能不能让我拨云见日，看清楚很多东西？我对课程的学习有比较快的速度，因为我远不是零基础，我大多数情况都可以轻松写出能运行的代码，虽然代码不简洁也不优雅。这些编程能力已经形成肌肉记忆，就像生活在原始森林里的野人，即使没有经历过系统的科学的格斗训练，身体素质和格斗技巧也要远超过普通人。

现在毕业后经过 1 个月时间的沉淀，我想分享一下 “从课程中能学到什么” 这个话题。没有在毕业当天做总结，是因为怕有点浮燥总结不全，或者掺杂太多个人经历。1 个月的时间其实也不够，我没有太多时间复习，课程也远远没来得及发挥出应有的成果，但是现在做总结并不妨碍以后对课程内容有进一步的感悟。王垠曾经有一篇文章《爱因斯坦谈教育》，里面提到爱因斯坦说 “被传授的知识应该被当成宝贵的礼物”，我在学完课程后无意间翻到这篇文章，看到这句话后，突然对这句话有了切实的理解。

王垠并不认识我，但我早就认识王垠；我以前不是王垠的学生，但王垠早就是我的老师了。我关注王垠的博客多年，已经从他的博客文章中受益很多。而这次系统学习了视频课的课程，像是打开了新世界的大门。这并不夸张，我可以负责任地站在学习过课程的立场上说，王垠没有吹牛，他的课程真的有他说的那么好。你可以不赞同王垠的观点，也可以不喜欢王垠的人生态度，但是不可能怀疑王垠在计算机科学，尤其是编程语言领域的研究水平，也完全不需要担心王垠这样对自己和世界都如此较真的人，会拿一些没有含量的课程出来忽悠人。

因为课程内容是保密的，我不会透露课程具体的学习内容，只基于公开的招生说明中的内容进行解释。对于计算机初学者来说，从课程中能学到的最直接的知识，就是函数、链表、二叉树等基础的编程概念，涵盖了大学本科阶段整个过程的学习内容。而第 6 课关于解释器的部分，属于课程的 “最终成果”，对应一些美国顶尖大学本科高年级，至硕士低年级阶段的学习内容。为什么王垠在招生说明里的描述是 “大学博士阶段才可能学到的内容” 呢？因为中国的大学没有编程语言专业，本科课程没有教解释器的，即使到了研究生阶段，lambda 演算也属于选修课，博士早期才会接触到解释器的实现是正常现象。所以王垠的描述真的没有夸大。

解释器这种内容在中国的教育体系里本来就很稀有，比较高级和精练的教程更是少见。举例来说，当你学完了王垠的课，然后去 bilibili 上搜一些解释器相关的教程，你就会明白这些公开教程里的解释器有多么差劲，不但一眼就能看出它们缺什么要素、存在什么问题，还知道如何改进、如何用最简洁的代码写出最可靠的实现。为什么解释器这个东西重要呢？同样举个例子，以太坊的虚拟机（EVM）就是一个解释器，只不过 EVM 并不是在对编程语言做解释，而是在对以太坊的操作码（Opcodes）做解释，每个操作码都对应在栈结构上的一个动作。所以学过了解释器之后，对 EVM 的原理会有不一样的理解。

对于有计算机经验的学生来说，从课程上可以学到的，就不只是表面上的知识了。比如，课程只用到非常少的编程要素，就表达了第 1 课到第 6 课的全部内容，如果王垠不是对计算机理论有非常深刻的理解，不可能做到这种地步的深入简出。从学习者的角度，一方面可以思考一下为什么课程内容能如此精致，组织这些课程内容的思路是什么，这种高度抽象的思维背后，需要怎样的功底，自己距离写出这样的课程，能力上的差距还有多大。

另一方面，由于课程内容自成一体，学习者完全有可能做到自己复刻整个课程内容，就像是手里的一个精致的玩物，随时可以拿出来复习把玩。基础班的知识好比非常高级的原材料，从基础班毕业就意味着拿到了这些原材料。但原材料需要经过反复打磨、锤炼、加工，才能变成更加实际可用的装备。所以我猜测有的同学学完之后感觉什么都没学到，而有的同学觉得如获至宝，能够反复加以利用并产生许多价值，大概就是这个原因吧。

我最近就忽然意识到，学完课程以后，学习其他技术好像变简单了。因为体验了课程中层层递进的教学方式，我自学其他东西也会按照这个思路来，一步一步学，自然而然就学会了，Solana 合约、比特币脚本、比特币 Runes、理解 CPS、用 continuation 原理实现协程调度等。我有点说不上这是怎么回事，明明课程里只是学了一些计算机基础，链表、二叉树什么的，竟然有这样的威力。也许从课程里学到的不只是知识，还有很好的学习方法。难怪王垠把基础课的内容称为 “计算机科学的精华”。

虽然我有多年在区块链行业实际的工作经验，我却越来越搞不清楚区块链技术是什么。我之前大量关注区块链共识的原理，为什么关注的不是其他技术原理，比如加密学、分布式网络、储存系统等内容？因为只有共识是区块链特有的，其他都是普通的工程上的技术，包括智能合约的实现，而且智能合约还不是区块链必需，可以有也可以没有。至于 Layer 2 之类，也完全是工程上的尝试，哪有什么可以抽象的理论依据，挑战期、赎回期等都是业务定义的逻辑。我可以剧透一下，王垠的计算机课程，还提到了区块链最本质的技术原理，是不是难以想象？是真的。

与不成体系的区块链工程相比，拥有基础但扎实的计算机功底很重要，尤其是高度抽象的思维方式，能够脱离语法但理解编程语言本质的学习方式，值得反复琢磨和掌握。我曾经以为好好钻研区块链技术，就可以逐步提高自己的技术能力，就可以深入研究到某些区块链原理，深入再深入，水平上自然而然超越所谓的计算机基础班。然而事实上不是那样。所以我学习了课程，并且学到了很多。

学完课程以后，我其实一度怀疑自己，难道这几年折腾的区块链技术都没有意义吗？为什么我学了一个零基础入门性质的计算机课，反而感觉学到了 “改变人生” 一样的东西？我一直没想通这件事。直到后来，我偶然看到王垠这篇讲述课程设计的文章《计算机科学课程》，尤其是看到 “苏格拉底方法” 段落的时候，恍然大悟，原来我的知识早已散落在我的头脑中，只是这门课程帮我把知识都 “生产” 了下来。我现在拥有的知识，离不开经年累月工作和学习的 “怀胎”，也离不开这门计算机课程在恰当时候的 “助产”。

苏格拉底承认他自己本来没有知识，而他又要教授别人知识。这个矛盾，他是这样解决的：这些知识并不是由他灌输给人的，而是人们原来已经具有的；人们已在心上怀了“胎”，不过自己还不知道，苏格拉底像一个“助产婆”，帮助别人产生知识。

就好比，在一个陌生的城市里，你没有地图，搞不清方向，但是也可以四处游荡，有时候能走的很远。而计算机基础课，就像是一张完整的地图，你有了地图，各个方向和岔路口都清清楚楚，但是你未必出发，也未必耗费力气去探索远方。我的情况属于，已经在城市里走过了很多路，偶然有一天，拿到了整个城市的地图，幡然醒悟，明白了自己所处的位置，知道了自己原先走过哪些路。

另外，王垠最近在微博上评论 AI 编程的时候提到，AI 无法写出 “王垠级别” 的代码。什么是 “王垠级别” 的代码呢？上过课就知道了。我在做练习题的时候，被助教提醒最多次的问题，就是 “代码复杂”，有时候是写法上的复杂，有时候是复杂度上的复杂，但是每一次把代码写到符合课程标准之后，又不禁感叹原来代码可以如此精巧。我已经有多年的编程经验，让代码运行出练习题的结果并不难，但是把代码写的足够漂亮却不容易。假如以前给公司写的都是这种质量的代码，那公司可就太占便宜了。

还不止这些，也许有人看到招生说明会怀疑，一节选修课真能让人学会一种新的编程语言吗？我想提醒的是，不要忘了给你讲课的人是谁，是真正的编程语言专家。

据我所知，登链社区也是开培训班的，最近 TinTin Land 社区似乎也在筹备给 web3 新人的课，有开培训班的趋势。稍微有点感慨，培训班这个行当，还真是什么时候都有，无处不在。

培训班是有意义的，对于决心进入新的职业方向，但又不知道怎么启程的人来说，花点钱寻求指导没什么不对。

不过 The Web3 社区我还是有点讨厌的，因为他们用了虚高的薪资信息诱惑学生，会议中满口都是财富自由、月薪 3 万 U 之类的话，拿一些 Bybit、Eigen Layer 员工的个例来讲。从招生的角度能理解，这属于广告宣传，但是从我每天盯着招聘职位投简历的角度，我很厌恶这种骗人的虚假宣传。

虽然我完全可以列出在技术角度，从 web2 转向 web3 需要哪些技能。但是那些东西没意思。

我的建议始终只有一个：学炒币。

我不想分析这个行为背后的风险。在我看来，这是从 web2 进入 web3 的唯一方式，也是最直接、最快的方式。

不信你去看吧，那些没有过币种交易的人，根本不懂 web3，即使他们已经在交易所或者 web3 公司工作，用的也都是 web2 的思维，只是种种原因恰好在公司工作而已。又或者某些满口区块链技术但是根本没碰过币的人，往往有着盲目的技术自信但又做不了什么切实的事情。

虽然我也可以条理清晰的写出我的建议背后的理性逻辑，但是也不太想写。

做区块链开发的有两种人，一种知道区块链是什么、在干什么，并且为此而努力。另一种不管你是什么，反正是 Go 语言（或者其他语言）开发的，那么就可以从编程语言的角度，去进行软件层面、代码层面的优化。这两种人都是区块链生态中不可或缺的力量，但是他们的动机和目的完全不一样。

我讨厌第二种人。

我最近在想，假如当初我没有辞职，我的职业生涯会不会更好？

嗯……会，哈哈。如果没有主动辞职，应该还是能再工作个半年一年的，项目不至于马上垮台，我也不至于马上被裁掉。那样的话，我的简历会更好看，不存在跳槽太频繁的问题，而我也能得到一整年稳定的工资收入，生活会更有保障。

现在一年过去了，我当时的主动辞职，换来了什么呢？

我实际参与了一个 Cosmos 项目的开发，算是摸了一下 Cosmos 生态。真实理解了 Restaking 的业务流程。然后去 Tantin Chain 做钱包后端开发，不但知道了钱包后端是干什么的，还经历了 Taintin Chain 的裁员。你也许听说过 Bitget 的暴力裁员，但是你能想到 Tantin Chain 的裁员是怎么回事吗？如果不是亲身经历，我是无法想象竟然会有这样的事情，不亲自体验一下，Web3 行业的那些裁员新闻就只是故事，亲自经历过后，就会有不一样的感受了。Web3 公司的魔幻程度超出想象。

再然后失业在家，认真学习了计算机课程，自学了一些区块链生态的技术，最近几天在研究用 continuation 实现协程调度一类的东西。

这些事情有意思吗，也有点意思，如果不是当时的主动辞职，也许永远不会去碰 Cosmos 生态；如果不是亲身工作，也许没耐心搞明白 Restaking 是在干什么；如果不是去做钱包后端开发，也许不会技术迷茫，就没兴趣去学计算机课程；如果不是失业，也许不会有大量时间认真学习各种各样的东西。

我现在这样的年纪，假如在一家公司安逸地工作五六年，几乎没有技术能力上的提升，然后五六年之后公司裁员（不可能一直安逸），正是经历中年危机的时候，那时就是真正的中年危机了。

现在不稳定的工作和生活，让我身处于动荡的职业变化中，这样锻炼出来的技术能力，才是真正经历过市场磨练后，真正抗打的。如果动荡时期都能扛过去，还需要担心什么中年危机吗？被裁员？找不到工作？工作本来就不稳定，还担心什么裁员？本来就处于不断找工作的状态，还需要担心自己搞不清楚行业状况、技能跟不上行业变化吗？我能对行业有某些观察，一定程度上也是因为找工作不得不频繁面试。

那么我说出曾经裸辞，会不会导致有些招聘方看到后，担心我工作不稳定呢？

假如公司好、团队好、工作好、前景好、工资好……员工脑子有坑才会主动辞职。如果招聘方因为这方面的原因担心候选人不稳定，说明潜意识里已经知道在招聘的岗位存在某些方面的问题了，错过了就错过吧。

更新（2025.07.28）

昨天晚上发生了一件事情，我前几天买的 3 箱矿泉水，放在房间门外的楼道里，被偷走了。

这是我人生中第一次遇到丢东西，我难以想象，3 大箱子矿泉水，24 瓶装那种，他是怎么搬走的，外面还下着雨，不太可能是其他楼的人，只能是邻居。

我非常想不通，其他值钱的东西也就算了，3 箱水，你家水龙头里接出来不都是水吗？而且不值钱，卖也没地方卖，这种东西用得着偷？

实在是匪夷所思，但是这件事情就是发生了。

当然我也有错，这几箱水几天前就送到了，我一直懒得往家里搬，就一直放在门口。为什么敢放在门口呢，一方面这是家门口啊，谁敢去别人家门口搬东西？真的不是顺手能带走的东西，得搬，甚至得用推车搬。另一方面，我记忆里，有些小卖铺，都直接把水，或者其他一些货物，摆到门口堆着的。我自己家门口放箱水，这玩意儿还有人偷？

俗话说，人教人，永远教不会，事教人，一次就长记性了。经过这件事情，我以后买水，肯定不敢放家门口了。

我为什么要这么啰嗦说这点事呢？因为我想和遇到 TanTin Chain 的裁员做类比。

有一些我们自己想象不到的事情，或者哪怕是别人反复好心劝告的事情，我们都会毫不在意，若非自己亲身经历，真的无法明白和重视。在楼道里丢东西这事，我早有耳闻，单元楼里不断有人说，我都是看个笑话。有时候出门玩，我也不太在意随身物品的安全问题，我无法想象现代社会，还有偷东西的人。但是这次我遇到了，而且被偷的还是矿泉水。

所以很多 web3 公司的新闻，跑路、暴雷、裁员、喝茶之类，我们平时都是当段子听，但是这些事情真实存在，只是没有发生在我们身上而已。

当我真正遭遇了 TanTin Chain 的裁员，并且调查过 TanTin Technology 这家公司的背景之后，只能说，挺长见识。

这就是 TanTin Chain 给我带来的收获和感悟。

（1）从计算机科学班顺利毕业

算是心里的石头落地，学也学完了，接下来好好复习、好好找工作。这个课程还是给我带来了不少信心的，否则我现在一定心态爆炸，我会有很多疑问：“区块链技术到底有啥好学的？”、“我已经接触过很多区块链技术和项目，你让我学啥？”、“面试不通过，你觉得我不会什么？”。这个课程，让我在心态上更加脚踏实地一点，挺不错。

对了，顺便提一下，在区块链的技术领域里，Uniswap 这种东西在技术上，对于我这种 “技术层级” 来说，不值得研究。不是说我不需要去学习，而是从自学的角度，搞明白这个东西没有什么难点，也无法给我带来技术上的成长。这话是 ChatGPT 说的，不只是我自己瞎琢磨，我之前就写过 为什么不要做 DeFi 开发 的文章，里面的道理不全对，但也不是完全没道理，我没给 ChatGPT 看我的这篇文章，但是 ChatGPT 的观点和我一样，而且比我分析的更全面更深入，算是间接验证了我的观点。

为什么刻意提 Uniswap 呢，因为我在 之前的文章 中列出了一些学习计划，现在回头去看，我确实是在按照那些计划在学习的，DeFi 项目是计划之一，所以我在考虑要怎么学，以及适当调整当时的计划。

（2）给解释器写了简单的 parser

目前支持变量定义、函数调用等语法，虽然不是纯函数式写法实现的，但仍然能工作，比如执行这样的语句：

// (x => y => x + y)(2)(3)var s17 = "(call (fun x (call (fun y (+ x y)) 2)) 3)";show( execExpr(s17) ); // 5

虽然语法非常简陋，功能也不全，但是不打算进一步完善这个 parser 了，这本就是课程内容之外产生的想法，简单尝试一下就可以。另外如果对 parser 的地位感兴趣，可以阅读王垠的这篇文章《对 Parser 的误解》。

（3）用其他语言实现解释器

我用 Java、Go、Python 语言分别写了一遍解释器。加上课程中学习的 JavaScript 和 Rust 版本，现在解释器已经有 5 个语言的版本了。对于解释器这样的程序，语言其实不是关键，语法差异没有那么大。

（4）学习 Solana 合约开发

包括 Solana 的账户模型、SPL 标准库、SDK 调用等。感觉这种用户层面的技术，没有太多值得深入的地方。如果要深入去理解 Solana 的架构和 eBPF 的技术原理，倒是有进一步的学习空间，接下来也许可以考虑下这个方向。

（5）学习比特币脚本开发

用 btcdeb 观察脚本执行步骤、使用命令行工具构建、发送 P2PKH、P2SH 交易等。教程文章里里没写多签和 HTLC 之类的内容，因为比特币脚本都是命令行操作，这种复杂的逻辑涉及到大堆数据，写出来不方便看，还得找到上下文的对应关系，比如解释解锁的是哪一笔 UTXO，这种过程用文字的形式不太好写。

（6）第二轮做完计算机课的练习题

上个月就已经第二轮做了 1~7 课的练习题，这个月只需要完成剩下第 10 课和 3 个隐藏关。

• 第 6 课的隐藏关比较简单，给解释器增加定义变量的语义。这个题目难度不大。

• 重新看了一遍第 10 课的教学视频，总结起来视频中提到的 Rust 关键特性有两个，Ownership 和 lifetime。

• 第 10 课隐藏关的练习题是用 Rust 写解释器。有意思的是，当第二次按部就班做题目的时候，犯了和第一次完全一样的错误，这个错误分两个阶段，都完美重现。我知道为什么会犯错，以及如何改正，但是说明也许是我的做题思路，或者其他原因，这两个错误是必犯的。当然顺便整理了更完善的题目说明和测试用例，下一次复习做题肯定会更顺手。

• 第 4 课隐藏关的练习题是用纯函数写法实现 parser。不得不说写 parser 真的痛苦，经过三四个小时的调试后，终于用错误的写法写出了能通过测试的程序。最离谱的错误之处在于一开始就写错了，应该给函数传递 lex 数据，我却直接拿字符串处理，但就这样代码的运行结果竟然没受到影响。parser 这个东西很折腾人，即使有了思路也需要不断调试才能写对，更侧重工程能力而不是思维能力，所以暂时不继续更正这个题目了。

（7）学习比特币 Runes 协议

自己试着开发了一个比特币 Runes 协议的原型。这也许是博客里最后一篇教程类文章，以前是不太写这种实操教程的，因为太过基础，没有技术含量，更没有深度或者思考和观点，最近写了几篇，一方面是边学边写，自己也顺便折腾一下，另一方面是，这个教程多少有点价值的地方在于，步骤肯定是可以复现的，因为我自己都亲手执行过，在网上找的教程，或者 ChatGPT 生成的教程，不一定能跑通。还有一个小原因，就是计算机课程里的练习题，虽然内容基础，但是质量很高，我有点想模仿尝试一下写这种基础教程。

最近的几篇教程足以说明，这种基础操作，只要想学就可以学会。很多时候，不明明白白的写出来，别人就觉得你不会，但实际上这些东西真的不难。接下来我不继续折腾这些基础的东西了，得去做点别的事情。以前偶尔也怀疑，老是写一些宏观的观点，是不是没有技术含量，会不会显得动手实践的能力差？但是事实证明，动手实践才是学习成本低的事情，最有难度的还得是总结性的观点。

（8）不断面试

这一个月以来，从 6月20日到 7月20日之间，一共面试 12 家公司，一共参加 17 次面试。

这个频率不算很高，但也需要花不少时间，主要是得耗费心情在里面，一开始以积极的态度去面试，觉得这家也许有合适的机会，但是聊下来却不合适。这样的情况反复经历的多了，心情其实会不是很好，感觉浪费了期待在上面。职位不合适也能理解，但是如果频繁遇到不靠谱的面试官，会逐渐有点越来越受不了。毕竟面试这件事情，唯一的对手方就是面试官，而我最近老是在面试，有时候难免想对面试官发表点意见。

找工作这件事情找的都有点无奈了，到后来感觉面试面的都累了，不断反复自我介绍、反复讲解自己过去做的事情、反复描述我对某些技术问题的看法。这些面试官能问得出的问题就那么些，我都总结出规律了，所以很多面试我就感觉是在重复。偶尔有面试官提到了新鲜的问题，让我对某些技术有了新的感受，这些面试官我觉得挺难得，也会给他们好评。很多时候我面试是抱着学习的心态，了解下行业的变化、交流下项目的情况，并没有那么在乎职位是否合适、面试结果如何，所以如果在面试中学到了什么，也会挺感谢这次面试的机会。

那么我现在是否对工作的的事情感到焦虑呢？其实好转很多，失业第一个月的回顾文章里，明确写了当时的烦躁和焦虑（要是没写出来我现在自己都忘了），现在失业第二个月，情况反而变好了，因为我知道自己在不断努力，学习新技术、沉淀计算机基础技能，我没有理由 “失败”。何况我有很好的女朋友，没工作算什么呢，有一个善解人意又漂亮的女朋友，是很多人 “梦寐以求” 都没有的，我却长时间以来一直在忽略她的重要。为了寻找合适的工作机会，我也有过去上海、香港的计划（不考虑深圳，在币圈“深圳盘”很有名），但是仍然在考虑具体的方式和时机。

有时候我也会想，过去的种种职业选择是否错误？只能说塞翁失马，没人知道对错。过去的选择有得有失。我现在不到 30 岁的年龄，去上课学习知识，去对自己未来的职业前景充满信心，去不断自学提高技术能力和见识，这些绝对不是一件错误的事情。我为什么会对自己有比较高的期望呢，也许是因为长期关注区块链行业，这个行业充满了各种故事。我的出身并不好，学历也不好，似乎没有什么理由让我 “应该成功”。不过我在学校的成绩还不错，只比同类优秀就是了。也许从那个时候开始，我逐渐对自己有了更高的期待。后面在职场中经历各种事情，更是没能明白什么样的人是优秀的，因为我没遇到过。

我期望的生活是什么样的呢，我只不过是希望赚点生活费维持生活而已，这没多少钱，在互联网行业不算多，在币圈更不算多，我经年累月的学习和努力工作，甚至忽略了很多普通生活的元素，如果最后落得找不到工作的下场，也挺奇怪的。人生的意义是什么呢，那些有钱人，那些巨鲸，他们随便的零花钱都够我一辈子的开销，他们在为什么努力，想要的是什么，他们有没有好好学习技术，有没有积极提升自己，他们又在为什么而发愁，在担心什么事情呢？

（9）制定后续的学习计划

后续计划主体还是计算机课相关的，重复做练习题。现在已经第二轮做完了练习题，接下来可以进行第三轮的复习。

1. 阅读 Groud-Up Computer Science 全书，加深对课程内容的理解。学习节奏应该放缓，慢慢看，慢慢理解，慢慢练。不是为了偷懒而降低学习节奏，而是避免错过什么内容，欲速则不达。

2. 阅读过书籍后，开始第三轮做计算机课的练习题。学习节奏要放的很慢，一天最多做一道题，主要是留给每一道题充分思考的时间，确保理解透彻。也许按照这样的节奏，需要几个月能完成整个轮次的复习。

3. 系统学习 continuation。不是报王垠的 continuation 专项班，而是自己学习和研究。我相信自己现在完全有能力，不仅学会和梳理清楚这些知识，还能整理出完整的练习题或者教程。

为什么我的学习计划，非要跟这个计算机课的练习题过不去呢？我之前在总结 区块链面试题 的时候有提到，经过这几年在区块链行业实际的工作，我反而越来越搞不清楚 “区块链技术” 是什么了，相比之下，拥有基础但扎实的计算机功底很重要，尤其是高度抽象的思维方式，能够脱离语法但理解编程语言的学习方式，值得反复琢磨和掌握。我曾经以为好好钻研区块链技术，就可以逐步提高自己的技术能力，水平上超越所谓的计算机基础班，就可以深入研究到某些区块链原理，深入再深入。然而事实上不是那样，区块链技术……我越来越不知道该学什么。

我之前大量关注区块链共识的原理。为什么关注的不是其他技术原理，比如加密学、分布式网络、储存系统等内容？因为只有共识是区块链特有的，其他的都是普通的工程上的技术，甚至包括智能合约的实现。而且智能合约还不是区块链必需，可以有也可以没有。至于 Layer 2 之类，也完全是工程上的尝试，哪有什么可以抽象的理论依据，挑战期、赎回期都是业务定义的逻辑。所以综合来看，区块链技术……到底是什么？

（分享个有意思的东西，我最近在研究 Georgios Konstantopoulos 这个人的技术能力和技术成果。Georgios 是 Paradigm 的 CTO，他的 个人主页 上展示了很多区块链相关的技术内容。那么问题来了，你觉得 Georgios 的个人主页和工作成就，有没有解答我对于 “不知道区块链技术是什么” 的疑问？）

这篇文章的操作基于《比特币脚本开发教程》中的知识，如果缺少对比特币脚本的基本了解，可以先看一下基础教程。

1. 定义数据结构

首先把 Runes 相关的操作定义为 json 格式的数据结构。用什么语言都可以，这里用的是 Rust。为了简化教程，可以省去一些实际中常用的元素，比如 transfer 的操作定义中，应该允许一次性转账给多个目标地址，但这里只有一个目标地址，没有用数组：

struct IssueRune{    op: u8,          // 固定为 0，代表发行    symbol: String,  // Rune name    supply: String,  // 发行总量}struct TransferRune{    op: u8,          // 固定为 1，代表转账    id: u64,         // rune_id    vout: u32,       // 转账目标    amount: String,  // 转账金额}

这个结构定义中，唯一可能有点迷惑的是 vout 字段，一般我们要转账给一个目标地址的时候，会使用目标地址的字符串作为值，但是 Runes 协议中，为了节省链上空间，使用 vout 也就是当前这笔交易、第几个输出的索引作为 Runes 转账的目标。因为每一笔交易的第 0 个输出会包含 OP_RETURN 的值，转账操作的字符全部会放到 OP_RETURN 的内容中，所以在一笔交易里，vout 只用数字就足以表明转账的目标地址是哪个。交易数据的结构大概是这样：

tx {  vin:   [...]  vout:  [    { vout: 0, scriptPubKey: OP_RETURN <json数据> },    { vout: 1, scriptPubKey: OP_0 <转账地址1> },    { vout: 2, scriptPubKey: OP_0 <转账地址2> }  ]}

接着给数据结构定义一下序列化函数，让结构体可以转变为 json 字符串：

impl IssueRune{    fn toJson(&self) -> String    {        format!(            "{{\"op\":{},\"symbol\":\"{}\",\"supply\":\"{}\"}}",            self.op, self.symbol, self.supply        )    }}impl TransferRune{    fn toJson(&self) -> String    {        format!(            "{{\"op\":{},\"id\":{},\"vout\":{},\"amount\":\"{}\"}}",            self.op, self.id, self.vout, self.amount        )    }}

2. 发行 Runes 代币

接下来的操作都基于本地启动的 regtest 节点，所以记得先启动起来，同时验证下有没有加载钱包、钱包里有没有余额。然后准备一下要发行 Rune 的 json 数据，比如这样，发行的 Rune 叫 Doge，总发行量 1000 个：

fn issue_rune(){    let issue = IssueRune     {        op: 0,        symbol: "Doge".to_string(),        supply: "1000".to_string(),    };    println!("Issue Doge JSON: {}", issue.toJson());}

运行这个函数，就会得到这样的输出，后面的 json 数据很重要，我们稍后会把这个数据发送到链上：

Issue Doge JSON: {"op":0,"symbol":"Doge","supply":"1000"}

然后运行这个命令行，把 json 数据转变为 16进制字符串：

echo -n "{"op":0,"symbol":"Doge","supply":"1000"}" | xxd -p -c 999

我得到了这样的输出：

7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307d

这就是会放到 OP_RETURN 后面、用来上链的数据。注意 OP_RETURN 最多支持 80 个字节，所以这个数据不能太长。

接着查看并挑一笔未花费的输出，因为 Runes 所有的操作都必须绑定到 UTXO 上。用这个命令查看你的钱包有哪些 UTXO 可用，然后挑一个你喜欢的：

bitcoin-cli -datadir=./ -regtest listunspent

比如我要用的 UTXO 是这样：

{  "txid": "8bfd524e9fc150dab11289d7e6d07860b2b5d6acb54b278a5dc1d1d7631bc8fa",  "vout": 0,  "address": "bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw",  "amount": 50.00000000,  // ...}

然后生成一个找零地址，用来接收比特币余额，这里用了 legacy 格式的地址，这个不是强制的，用 SegWit 的地址也不影响：

bitcoin-cli -datadir=./ getrawchangeaddress legacy

我生成的地址是 n4Ybvvzm9vRQepuMpXBnTWWbYuTgsPSZCV，接下来可以用这个地址构建交易了：

bitcoin-cli -datadir=./ createrawtransaction \  '[{"txid":"8bfd524e9fc150dab11289d7e6d07860b2b5d6acb54b278a5dc1d1d7631bc8fa","vout":0}]' \  '[{"data":"7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307d"},{"n4Ybvvzm9vRQepuMpXBnTWWbYuTgsPSZCV":49.99}]'

注意这个命令给找零地址的金额为 49.99，这种操作是不可以直接在主网使用的，需要精确计算余额和手续费的差值，然后给找零地址，不然会有很大的资金损失。这里只是懒得计算精确值。

生成交易数据后，对交易进行签名：

bitcoin-cli -datadir=./ signrawtransactionwithwallet 0200000001fac81b63d7d1c15d8a274bb5acd6b5b26078d0e6d78912b1da50c19f4e52fd8b0000000000fdffffff020000000000000000206a1e7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307dc0aff629010000001976a914fc9ab9cd801c625c9fe323fe669e6a3e362eed8088ac00000000

发送签名后的交易到链上：

bitcoin-cli -datadir=./ sendrawtransaction 02000000000101fac81b63d7d1c15d8a274bb5acd6b5b26078d0e6d78912b1da50c19f4e52fd8b0000000000fdffffff020000000000000000206a1e7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307dc0aff629010000001976a914fc9ab9cd801c625c9fe323fe669e6a3e362eed8088ac02473044022004a2553cc5348dd4521c093149b0ba5e5603fe4134d06a455e12abeac097ea19022076e72632b2488e1316e54559ed733b37de9ce7fd04119e78a59546a3d2c1faea0121020b396a9dfa1655feef066fe03b403d3e4bdee41ef9b26551497c0921acbf6bc100000000

要留意这个命令会输出一个 txid，这个 txid 比较重要，我们后续会从这个 txid 来转出 Doge 代币，所以要记得留下这个 txid 的记录，我的交易哈希是：e2061d0b8b2f98ee47ba6564c1e7409872432354c7617d278fe0e8c4485ff04a。挖一个区块来确认交易：

bitcoin-cli -datadir=./ generatetoaddress 1 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

如果一切顺利，交易数据就应该已经上链了。那么链下的解析器在拿到这笔交易后，会看到发行 Rune 的操作，并且解析出来。如果想确认下 OP_RETURN 的数据是不是写对了，可以解码一下刚才广播的交易详情：

bitcoin-cli -datadir=./ decoderawtransaction 02000000000101fac81b63d7d1c15d8a274bb5acd6b5b26078d0e6d78912b1da50c19f4e52fd8b0000000000fdffffff020000000000000000206a1e7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307dc0aff629010000001976a914fc9ab9cd801c625c9fe323fe669e6a3e362eed8088ac02473044022004a2553cc5348dd4521c093149b0ba5e5603fe4134d06a455e12abeac097ea19022076e72632b2488e1316e54559ed733b37de9ce7fd04119e78a59546a3d2c1faea0121020b396a9dfa1655feef066fe03b403d3e4bdee41ef9b26551497c0921acbf6bc100000000

输出的结果是这样：

"vout": [    {      "value": 0.00000000,      "n": 0,      "scriptPubKey": {        "asm": "OP_RETURN 7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307d",        // ...      }    },    {      "value": 49.99000000,      "n": 1,      "scriptPubKey": { //... }    }  ]

很明显看到了在第 0 个输出中，有 OP_RETURN 十六进制数据 的内容，如果还是不放心，可以 decode 一下 16进制字符串：

echo -n "7b6f703a302c73796d626f6c3a446f67652c737570706c793a313030307d" | xxd -r -p

应该得到：

{op:0,symbol:Doge,supply:1000}

3. 转账 Runes 代币

刚才创建了 Doge 代币，发行量是 1000，我们接下来通过一笔转账交易，来转出这 1000 个 Doge。

首先得计算一下 rune_id，也就是我们刚才发行的 Doge 的唯一 ID 是什么，因为 Symbol 字符串是有可能重复的，而且占用字符空间也多，一般会做一些工程上的折中，比如对 txid 按照字节反序，然后取前 8 字节，得到一个 u64 长度的数字，像这样：

fn calc_run_idby_txid(){    let txid = "e2061d0b8b2f98ee47ba6564c1e7409872432354c7617d278fe0e8c4485ff04a".to_string();    // 按字节反序，然后取前 8 字节    let mut bytes = hex::decode(txid).unwrap();    bytes.reverse();    let run_id = u64::from_le_bytes(bytes[0..8].try_into().unwrap());    println!("Run ID: {}", run_id);}

这个函数运行后会得到 10367542271932362826，我们把这个数字作为 rune_id，去构建转账 rune 需要的 json 数据：

fn transfer_rune(){    let transfer = TransferRune    {        op: 1,        id: 10367542271932362826,        vout: 1,        amount: "1000".to_string(),    };    println!("Transfer Rune JSON: {}", transfer.toJson());}

这个参数里要留意 vout 的值，它是接下来构建交易的时候，要转出到某个地址的 vout 的索引，和创建代币时候的交易没有任何关系。代码运行后得到这样的结果：

Transfer Doge JSON: {"op":1,"id":10367542271932362826,"vout":1,"amount":"1000"}

接下来就可以重复之前的步骤，把 json 转为 16进制字符串：

echo -n "{"op":1,"id":10367542271932362826,"vout":1,"amount":"1000"}" | xxd -p -c 999

我得到 7b6f703a312c69643a31303336373534323237313933323336323832362c766f75743a312c616d6f756e743a313030307d。

创建一个新地址用于接收 Doge：

bitcoin-cli -datadir=./ getnewaddress

我的新地址是：bcrt1qc250507tws9z9wkurfcv3jue2nls6npzaqt7ka。

利用刚才得到的参数，组装一笔转账 Doge 的交易：

bitcoin-cli -datadir=./ createrawtransaction \'[{"txid":"e2061d0b8b2f98ee47ba6564c1e7409872432354c7617d278fe0e8c4485ff04a","vout":1}]' \'[{"data":"7b226f70223a312c226964223a31303336373534323237313933323336323832362c22766f7574223a312c22616d6f756e74223a2231303030227d"},{"bcrt1q0n2x7030x59j5ql9pp6mw0tps74ag0znrdp45r":0.01},{"n4Ybvvzm9vRQepuMpXBnTWWbYuTgsPSZCV":49.9798}]'

这里和之前的交易略有不同，包含两个输出，第一个是接收 Doge 的地址，金额随意，因为重点在于 Doge 余额，而不是 BTC 余额。第二个参数则是找零地址，我们前面的交易里用到过。

剩下的操作轻车熟路，对这笔交易签名、把交易广播出去、挖一个新区块让交易确认：

# 对交易签名bitcoin-cli -datadir=./ signrawtransactionwithwallet 02000000014af05f48c4e8e08f277d61c7542343729840e7c16465ba47ee982f8b0b1d06e20100000000fdffffff0300000000000000003d6a3b7b226f70223a312c226964223a31303336373534323237313933323336323832362c22766f7574223a312c22616d6f756e74223a2231303030227d40420f00000000001600147cd46f3e2f350b2a03e50875b73d6187abd43c53601fe729010000001976a914fc9ab9cd801c625c9fe323fe669e6a3e362eed8088ac00000000# 广播交易bitcoin-cli -datadir=./ sendrawtransaction 02000000014af05f48c4e8e08f277d61c7542343729840e7c16465ba47ee982f8b0b1d06e2010000006a47304402201437a9e83ae0c6842ebd9d355af9c7be1f6f2eaa070b5d7a6e02e13ca8f2d13102206d05753c428f526b8c6636022991591517cc7d7982badfc633519cb44715957a0121026f441e8156148d0bb4963edaff187873f9800a37bb5f0731256e38d632031283fdffffff0300000000000000003d6a3b7b226f70223a312c226964223a31303336373534323237313933323336323832362c22766f7574223a312c22616d6f756e74223a2231303030227d40420f00000000001600147cd46f3e2f350b2a03e50875b73d6187abd43c53601fe729010000001976a914fc9ab9cd801c625c9fe323fe669e6a3e362eed8088ac00000000# 得到交易哈希：80709a25e5355d51ee6d7fb625c40e9c4c49b049afa3aca18aeaa03bc685c1f0# 确认交易bitcoin-cli -datadir=./ generatetoaddress 1 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

到这一步，转账 Doge 的交易就完成并且上链了。

4. 解析 Runes 交易

你也许有点纳闷，这不就是发了两笔普通的比特币交易吗，只是放了两个 json 数据到交易上。Runes 就是这样，所有的操作，就在 OP_RETURN 允许的那 80 个字节的空间里完成。链上只记录 Runes 的操作，而不维护 Runes 的最终状态。包括有哪些代币、代币余额等信息，全部需要链下程序根据协议进行解析，状态也全部在链下程序维护。

我们首先可以通过已知的交易哈希，获取到这两笔交易的全部详情数据。如果交易哈希不是已知，可以监听扫描全部区块的全部交易，然后按照协议约定解析就行了。这里简化一点。

在 Cargo.toml 文件中导入依赖包：

[dependencies]hex              = "0.4"bitcoin          = "0.31"          # Script & consensus decodebitcoincore-rpc  = "0.18"          # RPC clientserde            = { version = "1.0", features = ["derive"] }anyhow           = "1.0"

通过 RPC 查询节点上的交易数据：

// 导入必要依赖use bitcoin::{Transaction, Txid};use bitcoincore_rpc::{Auth, Client, RpcApi};use serde::Deserialize;use std::path::PathBuf;use std::str::FromStr;fn parse_tx(){    // 去启动比特币节点的数据目录下，找用来 rpc 鉴权的 cookie 文件    let mut cookie = PathBuf::from("/Users/smallyu/work/github/bitcoin-regtest");    cookie.push("regtest/.cookie");    let rpc = Client::new(        "http://127.0.0.1:18443",        Auth::CookieFile(cookie),    ).unwrap();    // 我们已知的交易哈希    let issue_txid    = Txid::from_str("e2061d0b8b2f98ee47ba6564c1e7409872432354c7617d278fe0e8c4485ff04a").unwrap();    let transfer_txid = Txid::from_str("80709a25e5355d51ee6d7fb625c40e9c4c49b049afa3aca18aeaa03bc685c1f0").unwrap();    // 这里会得到完整的交易数据    let issue_hex    = rpc.get_raw_transaction_hex(&issue_txid, None).unwrap();    let transfer_hex = rpc.get_raw_transaction_hex(&transfer_txid, None).unwrap();    println!("Issue Hex: {}", issue_hex);    println!("Transfer Hex: {}", transfer_hex);    // 调用函数来解析交易    parse_op_return(issue_hex);    parse_op_return(transfer_hex);}

这个函数在运行的时候，会从链上节点，查询出真实的已经上链的交易数据。接下来可以对这两笔交易的 Runes 操作做解析：

fn parse_op_return(tx_str: String){    let tx: Transaction = bitcoin::consensus::deserialize(&hex::decode(tx_str).unwrap()).unwrap();    let script = tx.output[0].script_pubkey.clone();    // OP_RETURN, DATA    let mut iter = script.instructions();    let mut op_return = iter.next();    let mut data = iter.next();    // 解析数据    match op_return    {        Some(Ok(op_return)) =>            {                match data                {                    Some(Ok(data)) =>                        {                            match (data)                            {                                bitcoin::blockdata::script::Instruction::PushBytes(bytes) =>                                    {                                        let json_str = std::str::from_utf8(bytes.as_ref()).unwrap();                                        println!("{}", json_str);                                    }                                _ => panic!("Expected OP_RETURN with data"),                            }                        }                    _ => panic!("No data found in OP_RETURN"),                }            }        _ => panic!("No OP_RETURN found in script"),    }}

解析数据的代码部分，写法上嵌套有点多，只是因为我不喜欢用语法糖。想看起来更舒服的话，也可以在代码写法上做调整，变得更精简，不过无论写法如何，代码干的事情都一样。这个函数会从交易数据里，经过层层解析，打印出这样的结果：

{op:0,symbol:Doge,supply:1000}{"op":1,"id":10367542271932362826,"vout":1,"amount":"1000"}

这样，我们就看到了期望的两个 Runes 动作，第一个是发行 Doge，第二个是对 Doge 进行转账。

以上过程就是 Runes 协议比较核心的内容，剩下的只需要把链下程序扩充一下，记录 Runes 状态、根据 rune_id 关联 Rune 操作、储存和显示余额变更等信息就可以了。

1. 启动本地节点

运行这个命令安装 bitcoind 的二进制，然后用 bitcoind --help 来测试是否安装成功：

brew install bitcoin

创建一个用于测试使用的目录，比如我的目录名称是 bitcoin-regtest：

mkdir ./bitcoin-regtestcd ./bitcoin-regtest

在这个目录下新建一个叫 bitcoin.conf 文件，复制这些配置内容进去：

regtest=1txindex=1fallbackfee=0.0001

这是本地节点的配置文件，后续我们的比特币脚本将基于本地启动的开发节点来测试。这个配置文件中的 regtest=1 比较关键，指明了节点的类型是本地开发网络，不会真的到公网上同步区块数据，本地节点的块高度将从 0 开始。另外两个配置 txindex=1 是指启动本地节点对所有交易的索引，方便我们后续查看交易，fallbackfee=0.0001 则是指明交易手续费的大小。

停留在包含配置文件的当前目录下，执行这个命令来启动节点。这里的命令行，以及后续的命令行，都会带上 -datadir 参数，因为我们希望节点数据是隔离的，每一个工作目录都是一份新的环境，不至于污染电脑的全局环境，而且默认环境的路径比较长，不同操作系统不一致，虽然我们在后续的命令里都需要带上这么一个参数，看起来有点麻烦，但同时也避免了很多其他问题，比如找不到系统默认目录在哪儿之类：

bitcoind -datadir=./ -daemon

命令成功执行会看到 Bitcoin Core starting 的字样。为了测试节点是否真的在运行，可以用这个命令查看节点的状，会得到一个 json 数据：

bitcoin-cli -datadir=./ getblockchaininfo

如果还是对节点的运行状态不放心，可以直接查看节点的日志文件。这就是我们指定了数据目录的好处，日志文件在这个位置：

cat ./regtest/debug.log

如果想要停掉节点，避免后台进程一直在电脑上运行，用这个命令来停止节点：

bitcoin-cli -datadir=./ stop

注意启动节点用的是 bitcoind，停止节点用的是 bitcoin-cli。前者属于 server 端的命令，后者属于 client 端的命令。

另外，如果在停止节点后重启节点，发现钱包（下一小节内容）不能用了，可以用这个命令来导入钱包：

bitcoin-cli -datadir=./ loadwallet learn-script 

2. 创建钱包

运行这个命令来创建一个比特币钱包：

bitcoin-cli -datadir=./ createwallet "learn-script"

我们刚提到命令行中使用 -datadir 参数来指定数据目录，那么钱包的文件其实也会在数据目录下保存，可以看一下 ./regtest/wallets 目录，有一个 learn-script 的文件夹，我们刚才创建的钱包就在这个文件夹内。

查看钱包地址的命令，比如我的地址是 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw：

bitcoin-cli -datadir=./ getnewaddress

接着在本地节点上，给钱包地址挖一些钱出来，这里的参数 101 是指挖 101 个区块。为什么是 101 个区块呢？一般我们挖的区块数量会大于 100，因为比特币网络有 100 个区块的成熟期，也就是区块奖励需要在 100 个区块之后，才可以消费。假如我们只挖了 99 个区块，虽然理论上应该得到很多区块奖励，但实际上是不能花费的。

bitcoin-cli -datadir=./ generatetoaddress 101 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

这个命令运行输出的是每个块的区块哈希。运行结束后，我们就可以查看钱包地址的余额了，余额应该是 50：

bitcoin-cli -datadir=./ getbalance

为什么是 50？因为比特币的区块奖励每 4 年减半，第一次减半之前的块奖励，每个区块都是 50 BTC。为什么挖了 101 个块，但只能查到 50 BTC 的余额？因为后 100 个区块的成熟期，奖励是不到账的。

3. 发送交易

那么现在我们已经有了本地在运行的节点，以及有余额的钱包，接下来可以发起一笔普通的转账交易。先生成一个用于接收转账的新地址，我生成的地址是 bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc：

bitcoin-cli -datadir=./ getnewaddress

可以查看验证一下，新生成的地址余额为 0。这个命令中的参数 0 意味着查询结果包含未确认的交易。

bitcoin-cli -datadir=./ getreceivedbyaddress bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc 0

接着使用发起交易的命令，来向新生成的地址转账 0.01 BTC：

bitcoin-cli -datadir=./ sendtoaddress bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc 0.01

这个命令会返回交易哈希，比如我的哈希值是 81be2e97507d7a274029ec4d5ce9728a54fe6d885aa0f12a13ec6f54eee66c26。我们需要用这个交易哈希来查询交易结果和交易详情，像这样：

bitcoin-cli -datadir=./ gettransaction 81be2e97507d7a274029ec4d5ce9728a54fe6d885aa0f12a13ec6f54eee66c26

这笔交易此时就已经提交到链上了，但是也许你会注意到，查询交易详情返回的交易状态中，有一个 "confirmations": 0，意味着交易还没有被确认，而且区块高度还停留在 lastprocessedblock: 101 上。因为比特币不会自动出块，这个时候查询接收地址的余额，能看出差异：

# 查询到余额是 0.01bitcoin-cli -datadir=./ getreceivedbyaddress bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc 0# 查询到余额是 0bitcoin-cli -datadir=./ getreceivedbyaddress bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc 1

因为我们之前有说明，最后一个参数是 0 代表包含未确认的交易，否则只查询确认的交易。我们刚刚发送的交易就还没有确认。如果想确认下来，就得用之前的 generatetoaddress 命令再挖一个区块出来：

bitcoin-cli -datadir=./ generatetoaddress 1 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

现在再去查询交易状态，无论是确认数还是钱包余额，就都符合预期了。

4. 查看交易脚本

我们刚才发送的是一笔 P2WPKH 交易，因为现在比特币客户端默认使用原生 SegWit 的地址格式。

先了解一下 P2PKH 是什么，全称是 Pay to Public-Key Hash，我们使用的比特币地址本身就是一个公钥的子集，而 P2PKH 交易以账户地址为接收参数，所以命名为 P2PKH。我们常说的比特币原生地址，就是指 P2PKH 格式，一般以 1 开头，

相比 P2PKH，原生 SegWit 的地址格式叫 P2WPKH，中间多了个字母 W，全称是 Pay to Witness Public-Key Hash，特点是会把签名数据放在 witness 字段里，而不是每一笔 UTXO 的输出里，我们可以具体看一下，首先根据交易哈希，查询得到交易的全部数据：

bitcoin-cli -datadir=./ getrawtransaction 81be2e97507d7a274029ec4d5ce9728a54fe6d885aa0f12a13ec6f54eee66c26

会得到一大段编码后的数据，用这个命令来解码交易数据：

bitcoin-cli -datadir=./ decoderawtransaction 020000000001018f4e8514038b93d6cc1d4f77b011f4726ba765d338bfdf1e6724d1844bc5d36e0000000000fdffffff0240420f0000000000160014400a517208b473618b98817840328c09a77d6b123eaaf629010000001600147ef4555b42b71e6ebecd687170c92ab64cce35500247304402202417ff3f6959a7d449849ae78fd5272826339cd7096ab02cdd7eccfc7779fb14022077e43ce155259a602b6172261b1d830d30e0de8b06cd6479cac02ea7c6928ff10121020b396a9dfa1655feef066fe03b403d3e4bdee41ef9b26551497c0921acbf6bc196000000

查询得到的数据结构是这样：

{  // ...  "vin": [    {      // ...      "txinwitness": [        "304402202417ff3f6959a7d449849ae78fd5272826339cd7096ab02cdd7eccfc7779fb14022077e43ce155259a602b6172261b1d830d30e0de8b06cd6479cac02ea7c6928ff101",        "020b396a9dfa1655feef066fe03b403d3e4bdee41ef9b26551497c0921acbf6bc1"      ],    }  ],  "vout": [    {      "value": 0.01000000,      "scriptPubKey": {        "asm": "0 400a517208b473618b98817840328c09a77d6b12",        "desc": "addr(bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc)#nry368tt",        "hex": "0014400a517208b473618b98817840328c09a77d6b12",        "address": "bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc",        "type": "witness_v0_keyhash"      }    },    {      "value": 49.98998590,      "scriptPubKey": {        // ...      }    }  ]}

首先关注 txinwitness 这个字段，它是一个数字，有两个部分，第一个部分是签名数据，第二个部分是公钥，这就是我们之前提到的 SegWit，对金额的签名不放在 vout 里，而是放在了 vin 里。

然后再关注 scriptPubKey 里的 asm，ASM 是 RedeemScript 的意思，表示满足什么样的条件就可以消费脚本中锁定的金额。是的我们即使是发起普通转账，实际上也是一种比特币脚本，金额锁定在了脚本中。我们查询到的脚本内容分为两段，第一段是 0，表示比特币脚本中的一个操作码 OP_0，第二段是 400a517208b473618b98817840328c09a77d6b12，其实就是钱包地址，经过 bech32 编码后会变成熟悉的样子 bcrt1qgq99zusgk3ekrzucs9uyqv5vpxnh66cjtwl6zc。

5. 用 btcdeb 调试

刚才提到了 OP_0 这个操作码，它具体是什么呢？操作码是比特币脚本的关键，我们可以用 btcdeb 工具调试和观察一下。btcdeb 没有提供一键式的安装命令，可以按照 官方的教程 先下载源码，然后编译安装。验证安装结果：

btcdeb --version

OP_0 这个操作码本身干的事情很简单，就是把空数据压进栈结构里，尝试运行命令：

btcdeb OP_0

会看到这样的输出：

script  |  stack --------+--------0       | #0000 0

前面的 script 表示有一个操作 0, 也就是 OP_0，这里显示的时候自动隐去了 OP_ 前缀。后面 #0000 0 则表示目前栈里内容为 0（空）。接下来的输入 step 命令，让 btcdeb 真正运行 OP_0 这个步骤，运行结果是这样，可以看到推了一个空数据到栈里，这就是 OP_0 干的事情：

step        <> PUSH stack 

为了增加理解，我们举一个别的操作码例子来观察栈内数据的变化，尝试这个命令：

btcdeb '[OP_2 OP_3 OP_ADD]'

然后输出 step 命令，一直按回车直到脚本结束，输出内容的过程像是这样。默认内容是这样，此时脚本里有 3 个操作码等待执行，分别是 OP_2、OP_3 和 OP_ADD：

script  |  stack --------+--------2       | 3       | OP_ADD  | #0000 2

第一次回车执行了脚本的第一个步骤 OP_2，对应操作把数字 2 压入栈，执行结束后脚本里剩 2 个操作码了，同时 stack 中有了数字 2：

step        <> PUSH stack 02btcdeb> script  |  stack --------+--------3       |      02OP_ADD  | #0001 3

第二次回车继续执行了 OP_3 操作码，把数字 3 压入栈，此时脚本里只剩 1 个操作码，栈中有数字 2 和数字 3:

        <> PUSH stack 03btcdeb> script  |  stack --------+--------OP_ADD  |      03        |      02#0002 OP_ADD

第三次回车执行 OP_ADD 操作码，这个操作码会从栈里弹出两个数字，计算加法后把结果推回栈内，得到结果 5:

        <> POP  stack        <> POP  stack        <> PUSH stack 05btcdeb> script  |  stack --------+--------        |      05

因为 btcdeb 的命令行输出并不是特别直观，所以这里尽管占用篇幅，也有必要把整个过程的输出都复制过来，还拆分了步骤，方便理解每一步在干什么。可以看到每一个操作码都会对应一些行为，这个行为是比特币程序里定义的，包括加法、减法等各种运算，也有一些行为更复杂的操作，或者对简单的操作码进行排列组合，达到实现更复杂功能的目的。我们还看到比特币脚本的执行是基于栈的，全部行为都发生在栈结构里，栈结构也就意味着完全没有动态内存分配之类的东西。

6. 自己编写比特币脚本 (1)

刚才尝试了在 btcdeb 调试工具里运算加法，现在试着在实际的比特币交易中，写入脚本代码，并且在链上运算。这段是原始的操作码形式的脚本，要注意这个脚本是不安全的，属于自验证的脚本，任何人都可以花费这个脚本中的金额，只是在花费过程中，脚本表示的数字运算会在链上执行：

[OP_2 OP_3 OP_ADD OP_5 OP_EQUAL]

首先需要把操作码转变为十六进制形式，这个编码过程需要手动，或者写代码来操作。我们使用手动的方式，这个 比特币文档 中列出了全部支持的操作码，以及对应的十六进制字符，到我们这个小脚本这里，对应关系就是：

因此我们按照依次拼接的顺序，得到了的十六进制脚本：

5253935587

接着生成 P2SH 地址。P2SH 的全称是 Pay to Script Hash，意思是支付到脚本哈希，或者说锁定金额到脚本中，相当于链上脚本的地址：

bitcoin-cli -datadir=./ decodescript 5253935587

命令输出中有一个 p2sh-segwit 字段，值是 2NAzGPjCcg8DiykVTKLJRYbU2fejCEbdPbX，把这个 P2SH 地址用作参数生成脚本的校验和，校验和是构造比特币交易必须要的一个参数：

bitcoin-cli -datadir=./ getdescriptorinfo "addr(2NAzGPjCcg8DiykVTKLJRYbU2fejCEbdPbX)"

得到 descriptor 的值为 addr(2NAzGPjCcg8DiykVTKLJRYbU2fejCEbdPbX)#s260u65e，后续用这个值作为脚本参数构造交易。

不过到这里还有个坑，比特币的 P2SH 脚本，只能用观察模式的钱包导入，所以需要新创建一个没有私钥的钱包：

bitcoin-cli -datadir=./ createwallet "arith-watch" true true "" true

用刚刚创建的新钱包，导入 P2SH 脚本。看到这个命令返回 "success": true，才表示导入成功：

bitcoin-cli -datadir=./ -rpcwallet=arith-watch importdescriptors '[{"desc":"addr(2NAzGPjCcg8DiykVTKLJRYbU2fejCEbdPbX)#s260u65e","timestamp":"now","label":"arith-2+3=5"}]'

现在有了 P2SH 的脚本地址，并且已经把脚本导入到钱包，接下来可以给脚本打钱了。这个命令从 learn-script 钱包转账 0.01 BTC 给脚本：

bitcoin-cli -datadir=./ -rpcwallet=learn-script sendtoaddress 2NAzGPjCcg8DiykVTKLJRYbU2fejCEbdPbX 0.01

挖一个区块让交易确认：

bitcoin-cli -datadir=./ generatetoaddress 1 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

现在，这个脚本就上链并且有余额了。

7. 自己编写比特币脚本 (2)

目前这个脚本地址里的钱，任何人都可以消费，消费的同时会运算一下 2+3 这个表达式，并且判断结果是否为 5。接下来构建一笔花费脚本金额的交易，真正花掉刚才存进脚本的钱。准备一个收款地址：

bitcoin-cli -datadir=./ -rpcwallet=learn-script getnewaddress

我新建的地址是 bcrt1q0n2x7030x59j5ql9pp6mw0tps74ag0znrdp45r。用这个地址构建一笔交易，注意这里 inputs 中的 txid，是刚才给 P2SH 转账的那一笔交易哈希：

bitcoin-cli -datadir=./ -named createrawtransaction \  inputs='[{"txid":"b952acd06a4f7edd7b2d5da0d509d01dfbb8e49fa15123d9cd5d3d23f944cdc2","vout":0}]' \  outputs='{"bcrt1q0n2x7030x59j5ql9pp6mw0tps74ag0znrdp45r":0.009}'

在构建的交易中添加自动找零参数：

bitcoin-cli -datadir=./ -rpcwallet=learn-script \  fundrawtransaction 0200000001c2cd44f9233d5dcdd92351a19fe4b8fb1dd009d5a05d2d7bdd7e4f6ad0ac52b90000000000fdffffff01a0bb0d00000000001600147cd46f3e2f350b2a03e50875b73d6187abd43c5300000000

关键的一步，用钱包给这笔交易签名，注意这里是给找零之后的交易数据进行签名，如果不找零，节点会把找零金额当作手续费，而节点默认还有手续费的上限值，如果这一步没找零，下一步会触发手续费上限报错：

bitcoin-cli -datadir=./ -rpcwallet=learn-script \  signrawtransactionwithwallet 0200000001c2cd44f9233d5dcdd92351a19fe4b8fb1dd009d5a05d2d7bdd7e4f6ad0ac52b90000000000fdffffff02a0bb0d00000000001600147cd46f3e2f350b2a03e50875b73d6187abd43c5360a0d92901000000160014a3e136e24d5a8db14f15016b99fb21ea4b0b69da00000000

最后，把签名好的交易数据广播出去就行了：

bitcoin-cli -datadir=./ sendrawtransaction 02000000000101c2cd44f9233d5dcdd92351a19fe4b8fb1dd009d5a05d2d7bdd7e4f6ad0ac52b90000000017160014c2d5ade24c1d0b9f27f651a71c3fe49d23d0ae13fdffffff02a0bb0d00000000001600147cd46f3e2f350b2a03e50875b73d6187abd43c5360a0d92901000000160014a3e136e24d5a8db14f15016b99fb21ea4b0b69da024730440220406a51d43ade05b240fcf2d14b58c90f31ebc705ab262189949355cac54d0431022051b592c570ef960a35e8509766e903ba836e3bcd1fb3c5cc211f0ff3442283550121021ff283ca8c9ecb45c8e19eacb7e8ae6fcb27d8addd38011d633e396487db44e300000000

记得再挖一个区块让交易确认：

bitcoin-cli -datadir=./ generatetoaddress 1 bcrt1q6c8d9vw62rdee72xcqx3d97w8qh8mfg8ky8zjw

查看交易状态，验证交易已被花费，如果返回空值，说明已被花费。这里查的交易哈希是当时用钱包给脚本转账 0.01 BTC 那一笔交易的哈希：

bitcoin-cli -datadir=./ gettxout b952acd06a4f7edd7b2d5da0d509d01dfbb8e49fa15123d9cd5d3d23f944cdc2 0

8. Troubleshooting

我本地的操作环境以及软件脚本是：

OS: MacOSbitcoind: v29.0.0btcdeb：5.0.24

为了行文方便，这篇文章不使用 “王垠老师” 这样的尊称，直接称呼名字 “王垠”。

大约 2 个月前，我开始报名学习王垠的 计算机科学视频班（基础班），经过 1 个月的学习后毕业，大概用了 120 个小时的学习时长。“120 个小时” 这个数字是经过认真估算的，包含了观看视频的时间和做练习题的时间。因为视频课的学习节奏由自己把控，毕业速度因人而异，所以 “1 个月” 这样的描述不够直观，用小时数更加容易理解。 120 个小时意味着，如果一天学 2 个小时的话，需要 60 天。

王垠并不认识我，但我早就认识王垠；我以前不是王垠的学生，但王垠早就是我的老师了。我关注王垠的博客多年，已经从他的博客文章中受益很多。而这次系统学习了视频课的课程，像是打开了新世界的大门。这并不夸张，我可以负责任地站在学习过课程的立场上说，王垠没有吹牛，他的课程真的有他说的那么好。你可以不赞同王垠的观点，也可以不喜欢王垠的人生态度，但是不可能怀疑王垠在计算机科学，尤其是编程语言领域的研究水平，也完全不需要担心王垠这样对自己和世界都如此较真的人，会拿一些没有含量的课程出来忽悠人。

现在毕业后经过半个月时间的沉淀，我想分享一下 “从课程中能学到什么” 这个话题。没有在毕业当天做总结，是因为怕有点浮燥总结不全，或者掺杂太多个人经历。半个月的时间其实也不够，我没有太多时间复习，课程也远远没来得及发挥出应有的成果，但是现在做总结并不妨碍以后对课程内容有进一步的感悟。王垠曾经有一篇文章《爱因斯坦谈教育》，里面提到爱因斯坦说 “被传授的知识应该被当成宝贵的礼物”，我在学完课程后无意间翻到这篇文章，看到这句话后，突然对这句话有了切实的理解。

因为课程内容是保密的，我不会透露课程具体的学习内容，只基于公开的招生说明中的内容进行解释。对于计算机初学者来说，从课程中能学到的最直接的知识，就是函数、链表、二叉树等基础的编程概念，内容涵盖了大学本科阶段的整个过程。而第 6 课关于解释器的部分，属于课程的 “最终成果”，对应一些美国顶尖大学本科高年级，至硕士低年级的阶段。为什么王垠在招生说明里的描述是 “大学博士阶段才可能学到的内容” 呢？因为中国的大学没有编程语言专业，本科课程没有教解释器的，即使到了研究生阶段，lambda 演算也属于选修课，博士早期才会接触到解释器的实现是正常现象。所以王垠的描述真的没有夸大。

解释器这种内容在中国的教育体系里本来就很稀有，比较高级和精练的教程更是少见。举例来说，当你学完了王垠的课，然后去 bilibili 上搜一些解释器相关的教程，你就会明白这些公开教程里的解释器有多么差劲，不但一眼就能看出它们缺什么要素、存在什么问题，还知道如何改进、如何用最简洁的代码写出最可靠的实现。为什么解释器这个东西重要呢？同样举个例子，以太坊的虚拟机（EVM）就是一个解释器，只不过 EVM 并不是在对编程语言做解释，而是在对以太坊的操作码（Opcodes）做解释，每个操作码都对应在栈结构上的一个动作。所以学过了解释器之后，对 EVM 的原理会有不一样的理解。

对于有计算机经验的学生来说，从课程上可以学到的，就不只是表面上的知识了。比如，课程只用到非常少的编程要素，就表达了第 1 课到第 6 课的全部内容，如果王垠不是对计算机理论有非常深刻的理解，不可能做到这种地步的深入简出。从学习者的角度，一方面可以思考一下为什么课程内容能如此精致，组织这些课程内容的思路是什么，这种高度抽象的思维背后，需要怎样的功底。另一方面由于课程内容自成一体，学习者完全有可能做到自己复刻整个课程内容，就像是手里的一个精致的玩物，随时可以拿出来复习把玩。

王垠最近在微博上评论 AI 编程的时候提到，AI 无法写出 “王垠级别” 的代码。什么是 “王垠级别” 的代码呢？上过课就知道了。我在做练习题的时候，被助教提醒最多次的问题，就是 “代码复杂”，有时候是写法上的复杂，有时候是复杂度上的复杂，但是每一次把代码写到符合课程标准之后，又不禁感叹原来代码可以如此精巧。我已经有多年的编程经验，让代码运行出练习题的结果并不难，但是把代码写的足够漂亮却不容易。假如以前给公司写的都是这种质量的代码，那公司可就太占便宜了。

还不止这些，也许有人看到招生说明会怀疑，一节选修课真能让人学会一种新的编程语言吗？我想提醒的是，不要忘了给你讲课的人是谁，是真正的编程语言专家。

1. 以太坊客户端为什么分为执行层和共识层？
2. 以太坊的 PoS 运作流程，如何初始化一个 PoS 网络？
3. 以太坊 PoS 的软分叉和恢复机制？Cardano 的 PoS 和以太坊一样吗？
4. 以太坊节点有哪些类型，分别适用于什么场景？
5. EVM 的执行为什么是单线程的？为什么至今全世界的团队都做不出来 “并行EVM” 这种东西？
6. Solidity 语言有 GC 吗？是如何处理内存动态分配问题的？
7. Solidity 什么场景下需要内联汇编？
8. PBFT 共识有了解吗，大体流程是怎么样的？
9. PBFT 的容错能力公式是怎么来的，为什么是那个数字，而不是其他数字？
10. PBFT 为什么需要第二次投票？
11. Solana 的共识机制大体是怎样的？TowerBFT 是在对区块投票吗？
12. 为什么 Solana 的智能合约可以并行执行，以太坊的不可以？
13. Cosmos 节点的升级流程是怎样的？和以太坊有什么不同？这种模式有什么风险？
14. Op Rollup 的大体流程？ZK Rollup 在 Op 模式的基础上，优化了哪个环节？
15. 以太坊 L2 的资产跨链？与不同网络之间的资产跨链相比，技术上有什么异同？
16. 以太坊最近有个大版本升级，引入的 EIP-7702 是干什么的？和 AA 钱包是什么关系？
17. 自己平时思考过哪些区块链相关的、有意思的技术类话题？

这些是我现在能想到的全部问题了。比这些问题更加有深度的工程化的内容，我也只是大概知道点方向，没亲手搞过。这两年的经历还算丰富，对比两个版本的面试题列表能看出不少变化。希望我自己可以再接再厉，不要迷路。

如果你是区块链行业的求职者，尤其是经验尚浅的工程师，千万不要被上面列出来的问题给吓到了。真实的面试过程中，几乎不会出现如此有深度的思考题。更多的问题类似于，“以太坊交易有哪些常用字段？”、“怎么取消一笔已经发送的交易？”、“Solidity 的可重入攻击是什么？”、“Op Stack 有哪几个组件？”、“以太坊合约的 create2 是什么？” 等等。放心大胆的去求职，真正懂技术的人没有那么多。

现在的区块链行业有个问题，就是没有系统化的理论知识，只有一些工业界前沿的、散碎的工程化尝试。比如对比编程语言专业，从丘奇和图灵的计算模型，到函数式编程语言、编译器、类型系统等，经过几十年学术界和工业界的发展，有高度抽象的理论支撑，有实际落地的工业应用，已经比较成熟。而区块链这种东西比较新，2008 年诞生，2013 年开始步入大众视野，短短几年的时间远没有建立起学术体系，行业内的项目方则各自为营，都在搞自己的标准、各自定义术语，账户模型、共识、合约、跨链，每条链都不一样。有人能统一区块链的理论体系吗？Vitalik 来都不行，要是 Satoshi 出山也许有希望。

因此不需要相信什么大学里的 “区块链专业”，没有出过校门的老师和教授，怎么可能有时间把区块链的技术抽象成理论、写成教材、编成课程，然后给学生讲课呢，这个周期得多长？也因此不要太相信已经出版的技术类书籍，书籍的出版需要几年时间，等书发表出来，世界已经变了。今年下半年有个比特币会议，两年前发明了铭文这个概念的项目方，可能又要发布新东西了，难道学校的课程或者书籍能跟得上这种节奏吗？行业最前沿的技术，只能来自各个项目方切实的探索和尝试，也自然就会造成不成体系的现象。

fn append(s1: &String, s2: &String) -> String {    return s1.clone() + s2.clone().as_str();}

不需要关心 return 后面的语句写法，这不是我们关注的重点。在入口函数 main 里调用这个 append，运行一下，输出的内容会和我们预期一样，打印出拼接后的字符串 Hello, world：

fn main() {    let s1: String = String::from("Hello");    let s2: String = String::from(", world");    println!("{}", append(&s1, &s2));}

那么现在，保持 append 函数完全不变，在 main 函数里修改两个字符串的定义，整个 main 函数变成这样，猜一下输出结果会是什么？注意 Rust 是静态类型的语言，编译器对于变量类型往往具有严格的定义和判断：

fn main() {    let s1: Box<String> = Box::new(String::from("Hello"));    let s2: Box<String> = Box::new(String::from(", world"));    println!("{}", append(&s1, &s2));}

我们首先的直觉是应该编译报错，因为 s1 的类型是 Box<String>，调用 append 函数的时候，传入的参数为 &s1，对应的类型为 &Box<String>，而显然 append 函数的定义是没有修改的，接收的参数类型仍然是 &String。那么这种情况下，为什么编译器没有报错，而且代码还能正常运行，输出了 Hello, world 的结果？(先别管这里的 Box 是什么，反正是一种类型)

我们接着再修改一下 main 函数的内容，把字符串的定义改为这样：

fn main() {    use std::rc::Rc;    let s1: Rc<String> = Rc::new(String::from("Hello"));    let s2: Rc<String> = Rc::new(String::from(", world"));    println!("{}", append(&s1, &s2));}

代码能通过编译吗？能正常运行吗？append 函数的定义仍然没有变，这里 main 函数中 s1 的类型变成了 Rc<String>，相应的传入 append 函数做参数的时候，类型变为了 &Rc<String>。但是为什么，编译器没有报错，而且还能正常运行出结果，输出 Hello, world？（同样别管 Rc 是什么，也是一种类型）

根据刚才的代码片段，我们观察到一个现象：当函数的参数类型是 &String 的时候，既可以接受 &String 类型的参数，也可以接收 &Box<String> 类型的参数，还可以接收 &Rc<String> 类型的参数。

再疯狂一点，如果把 main 函数改成这样呢？

fn main() {    let s1: Box<Box<Box<Box<String>>>> = Box::new(Box::new(Box::new(Box::new(String::from("Hello")))));    let s2: Box<Box<Box<Box<String>>>> = Box::new(Box::new(Box::new(Box::new(String::from(", world")))));    println!("{}", append(&s1, &s2));}

如果把 main 函数改成这样呢？

fn main() {    use std::rc::Rc;        let s1: Rc<Rc<Rc<Rc<String>>>> = Rc::new(Rc::new(Rc::new(Rc::new(String::from("hello")))));    let s2: Rc<Rc<Rc<Rc<String>>>> = Rc::new(Rc::new(Rc::new(Rc::new(String::from(", world")))));    println!("{}", append(&s1, &s2));}

结果是 main 函数都可以正常运行，输出 Hello, world 的结果。

为了进一步观察关于类型的问题，现在新写两个 append 函数，append2 函数接收的类型是 &Box<String>，而 append3 函数接收的类型是 &Rc<String>：

fn append2(s1: &Box<String>, s2: &Box<String>) -> Box<String> {    let mut result = (**s1).clone();    result.push_str(s2);    Box::new(result)}use std::rc::Rc;fn append3(s1: &Rc<String>, s2: &Rc<String>) -> Rc<String> {    let mut result = (**s1).clone();    result.push_str(s2);    Rc::new(result)}

接下来分析一下，对于下面的 main 函数代码，编译器会在哪一行报错？

fn main() {    let s1: Box<Box<Rc<Rc<String>>>> = Box::new(Box::new(Rc::new(Rc::new(String::from("hello")))));    let s2: Box<Box<Rc<Rc<String>>>> = Box::new(Box::new(Rc::new(Rc::new(String::from(", world")))));    println!("{}", append(&s1, &s2));    println!("{}", append2(&s1, &s2));    println!("{}", append3(&s1, &s2));}

这样呢，字符串的类型再扩展一下，编译器还会报错吗，在哪一行？

fn main() {    let s1: Box<Box<Rc<Rc<Box<Box<String>>>>>> = Box::new(Box::new(Rc::new(Rc::new(Box::new(Box::new(String::from("hello")))))));    let s2: Box<Box<Rc<Rc<Box<Box<String>>>>>> = Box::new(Box::new(Rc::new(Rc::new(Box::new(Box::new(String::from(", world")))))));    println!("{}", append(&s1, &s2));    println!("{}", append2(&s1, &s2));    println!("{}", append3(&s1, &s2));}

Rust 把这种语言特性叫做人体工学设计，为了减轻开发人员的负担。但是 Rust 在设计动不动会把变量给 move 掉、不得不使用 ' 单引号写法的时候，却放弃了人体工学，把内存安全放在了更重要的地位……倒是也没什么错，毕竟 Rust 只有内存安全是绝不能放松的。

最后再来个进阶难度的，假如在实际的业务场景中，有一个叫 do_something 的函数，接收泛型类型的参数，我们需要对这个函数基于原有逻辑做一些改动，原本的函数逻辑是这样：

fn do_something<T1, T2>(t1: T1, t2: T2) {    println!("{}", append(&t1, &t2));}

现在新增加一些处理：

fn do_something<T1, T2>(t1: T1, t2: T2) {    // 增加一个函数来处理 t1    handle_t1(&t1);      println!("{}", append(&t1, &t2));}

那么问题来了，参数 t1 的类型是什么？handle_t1 函数的参数类型应该如何定义？在原有逻辑中，t1 作为参数对 append 函数进行了调用，是否意味着 t1 的类型是 &String？如果不是 &String，t1 的类型可能是什么？

找工作的过程本就应该是缓慢的，因为好的工作机会，不可能一年 365 天都在等你，工作机会和优秀人才都有一个窗口期，只有窗口期恰好对得上，企业在找人，人在找工作，才能合适，这个事情看缘分。也因此没有合适的工作，或者有工作但不合适也正常。

关于最近失业的原因，我写在了这里：《公司没了，我又失业了》

最近的面试经历

• 2025.05.25（不知道公司名）

一个做 BTCFi 类型的项目，工作会涉及到写比特币脚本、闪电网络、EVM 桥等内容。具体没问出来项目到底是干什么的。

• 2025.05.28（北京星联九宇科技）

线下面试，很小的公司，没什么钱那种，在招聘比较基础水平的合约开发，主要是能发 token，最好能部署 Uniswap 就够了。说是想发行十二生肖 token，把中国文化推广到全世界……

• 2025.06.12（成都 pkCoin）

做生态工具、打新一类的事情。团队三个人都是做 web2 的，不懂 web3，要招聘 web3 方面的专家带领团队去做事。而且他们说不差钱。

我经常不明白一个问题，为什么投资人和创始人经常找一帮不懂行的人做事，而真正懂行懂技术的人却在这里海投简历？

因为面试官在面试过程中表现出了很不尊重候选人的举动，虽然不是针对我，但是我仍然觉得不应该去这样的公司。

• 2025.06.18（starcoin）

一条 PoW + Move 智能合约的链，招聘 Rust 开发，工作相对底层一点，比如会用到 MPP 数据结构之类的。这条链仍然用了以太坊的账户模型，是基于某条链做二次开发。

• 2025.06.23（HashKey）

合规交易所想搞一条以太坊 Layer 2 的链，基于 Op Stack，后续也许有一些合规方面的需求，比如不允许某些块打包之类的。

• 2025.06.23（云暮怀谷）

技术合伙人职位，BOSS 上随便投的，还让我面试，面试也是瞎聊。

• 2025.06.24（公司中文名叫枷箱，上海的一家公司）

被惊艳到了，女性面试官，但是对于技术的深度和广度都很好。语速比较快，但是条理清晰，说明思维活跃。技术能力上，算是最近遇到的比较厉害的那种人了。

但是公司项目听起来像是软件外包一类，上半年做了一个 TG 上的小红书一类的项目，最近开始做一个 C2C 商城的项目，其中涉及到区块链的部分是，商城里会用到加密货币来做支付。

• 2025.06.25（枷箱，leader面）

这个 Leader 叫孙总，技术很菜，而且不尊重人，几乎没有沟通的态度，真是浪费我的时间和心情。

• 2025.06.25（UnicornX）

一个 memecoin 发射平台，后端开发一方面要做交易的解析，主要是 Solana 和 BSC 两条链，另一方面是一些日常业务的开发，比如网站后端、APP 后端的工作。

• 2025.06.27（alcove）

Aptos 生态的一个数据索引项目，跟 Aptos 华语社区关系密切，主要做一些链数据的解析、索引等后端工作，因为 Aptos 是 Rust 开发的，所以解析器要基于 Rust。周边服务用 ts 比较多。

最近的学习成果

不知道最近的面试频率算不算正常，好像不是很多，尤其是和以前比起来。不过我这一个多月可真没闲着，我学完了王垠老师的课程，还自学了 Solana 合约的开发、花时间把教程写了下来。

另外，我已经给我们的解释器写了简单的 parser，现在有了 parser 和解释器结合，可以执行这样复杂的语句了（用 Y combinator 递归计算阶乘）：

var exp = `(let Y  (fun f    (call      (fun x (call f (fun v (call (call x x) v))))      (fun x (call f (fun v (call (call x x) v))))    ))  (call    (call Y      (fun fact        (fun n          (if (== n 0)              1              (* n (call fact (- n 1)))          ))))    5))`;show( execExpr(exp) ); // 120

我最近也确实自己写了一个 Go 语言版本的解释器，课程内实现的是 js 版本和 Rust 版本，即使是选修课也是不教 Go 语言的。

接下来还有很多东西可以学习，很多事情可以做，我还得再想想到底应该干什么。祝福看到这里的人工作顺利，心理健康，不要成为失败朋克，要做赛博朋克。

这个一个零基础的系列教程，可以从最基本的操作开始学会 Solana 智能合约的开发。

• 《第一篇》：基础环境安装、HelloWorld 合约部署、链上合约调用
• 《第二篇》：实现 USDT 合约的最小模型，自定义数据结构与方法
• 《第三篇》：使用官方 SPL 库复用合约功能，完成标准化代币的发行

你也许注意到，在编写智能合约的过程中，对于程序逻辑的描述反而是轻量的，比较复杂的部分是不同类型的 #[account] 宏，以及去了解宏接受的参数，比如是否允许自动创建账户、如果创建应该租用多少个字节的空间等，因为 Solana 的全部账户数据需要加载到节点服务器的内存中，价格比较昂贵，所以要求开发者对于空间的占用计算比较精细。而 Solana 的账户体系又有点复杂，需要稍微理解一下。

1. 命令行工具发行代币

对于发行 USDT 这种经典场景，Solana 已经封装好了智能合约的库函数，可以直接调用，甚至封装好了命令行工具，只需要简单的操作，不需要写合约，就可以发行代币。Solana 把这些代币统称为 SPL Token。创建一个 6 位精度的 SPL Token 的命令是这样，注意不需要写代币名字：

spl-token create-token --decimals 6

命令行运行结束后，会输出一个 Address，这个就是 SPL Token 的代币地址，比如我得到的地址是 E75GMXAfJ91XuRboSpjwkDmta45Etgt3F3Gf5WLZvLbV，可以在 区块链浏览器 上查到。

接下来需要一个操作，来给你本地的账户，在这个 USDT 代币上创建一个关联账户（Associated Token Account，ATA）。这个创建关联账户的动作，相当于在合约上实例化一个数据结构，这个数据结构里保存了你的 USDT 余额等信息，如果没有这个数据，USDT 代币的合约上就找不到你。

用 “账户” 这个词可能有点迷惑，我本地已经有账户了，还能用 solana address 命令看到账户地址，为什么还需要专门调用 USDT 的合约，创建什么 ATA 账户？可以理解为，合约里本来有个空的 map{}，创建 ATA 账户就是向 map 里插入了一条数据，key 是你本地的账户地址，value 是 USDT 的余额信息。如果 map 里没有你的信息，你甚至不能接受 USDT 的转账。

那么为什么 Solana 要这么设计，必须先在 map 里开辟空间，才能接受转账呢？因为一开始有提到过，对于 Solana 来说，链上空间是比较珍贵的，map 里开辟一个键值对的空间，也就是创建 ATA 账户，需要占用 165 个字节的内存，这 165 字节不是免费使用的，可以使用命令 solana rent 165 来计算字节数对应的费用，比如这里就会输出 0.00203928 SOL，也就是你创建 ATA 账户的交易，在手续费之外，会多支付这么些租金。所以必须要有创建 ATA 账户这个操作，主要是为了收费。

回到我们的操作，创建 ATA 账户的命令是：

spl-token create-account E75GMXAfJ91XuRboSpjwkDmta45Etgt3F3Gf5WLZvLbV

这个命令会显示 Creating account，后面是你的 ATA 地址，比如我的是 E5XmcEJhhGUri8itThLGk8QfPzY1acFid8JmVyo5DWUo,同样的，可以在 区块链浏览器 中看得到。

对要注意，ATA 账户是有单独的地址的，比如你本地的账户地址是 a，在 USDT 代币上创建的 ADA 账户地址将是 b，是不一样的。而后续接受 USDT、发送 USDT，将全部通过 ATA 账户来进行，而不是你本地的那个账户。SPL Token 提供了命令来查看本地钱包账户和 ATA 账户的关系：

spl-token address --verbose --token E75GMXAfJ91XuRboSpjwkDmta45Etgt3F3Gf5WLZvLbV// 输出是这个样子Wallet address: 75sFifxBt7zw1YrDfCdPjDCGDyKEqLWrBarPCLg6PHwbAssociated token address: E5XmcEJhhGUri8itThLGk8QfPzY1acFid8JmVyo5DWUo

那么现在，可以用这个命令，来查询 USDT 的余额，balance 后面的参数是指代币地址，而不是 ATA 地址：

spl-token balance E75GMXAfJ91XuRboSpjwkDmta45Etgt3F3Gf5WLZvLbV 

当然默认是 0，现在给这个地址挖一些 USDT 上去。这个命令有点长，有 3 个参数，第一个参数是代币地址，第二个参数是代币数量，第三个参数是 ATA 地址，意味着要挖哪个代币、挖多少、挖给谁：

spl-token mint E75GMXAfJ91XuRboSpjwkDmta45Etgt3F3Gf5WLZvLbV 5 E5XmcEJhhGUri8itThLGk8QfPzY1acFid8JmVyo5DWUo

命令执行成功后，就可以查询到余额，也能直接在浏览器上看到余额了，类似的，转账 USDT 的命令是：

spl-token transfer <MINT> 1 <ATA>

Solana 为了避免用户不记得自己的 ATA 账户地址，也提供了人性化的命令，最后一个参数可以直接用本地的钱包地址，而不需要 ATA 地址，这也就是为什么我们平时使用 Solana 的钱包，并没有感觉到 ATA 账户这种东西存在的原因：

spl-token transfer <MINT> 1 <RECIPIENT_WALLET>

2. 用 spl 标准库写智能合约

我们尝试一下在智能合约里调用 spl 库函数，这种官方提供的、系统级别的库函数是经过严格安全审计的，比我们自己写要安全，所以有了这些库函数，我们可以更加关注自己定制化的业务逻辑，不需要关心太底层的东西，比如 USDT 余额计算是否精度有损失之类的问题。先创建一个新项目：

anchor init usdt_spl

导入 anchor-spl 依赖，这个命令可以把最新版本的库函数导入进来，命令运行后，可以在 programs/usdt_spl/Cargo.toml 文件的 [dependencies] 部分，新增了这样一行 anchor-spl = "0.31.1"，说明是成功的：

cargo add anchor-spl

开始写合约代码程序。先在最开始两行导入 spl 的依赖。我们之前有使用过 Anchor 框架自带的账户类型如 Account 和 Signer，那么这里 spl 也是提供了多种数据类型，比如 TokenAccount 就表示 ATA 账户的数据结构：

use anchor_spl::token::{self, MintTo, Token, TokenAccount, Mint};

接着定义 mint 行为相关的账户规则：

#[derive(Accounts)]pub struct MintToCtx<'info> {    #[account(mut)]    pub mint: Account<'info, Mint>,     #[account(mut)]    pub to:   Account<'info, TokenAccount>,    #[account(mut)]    pub authority: Signer<'info>,    pub token_program: Program<'info, Token>,}

这几行代码中，mut 关键词我们之前用到过，表明账户数据要允许被写入。Account 类型是 anchor 框架自带的，我们也使用过。Mint 类型则是新出现的，是从 spl 框架里导入的，我们之前不是自己定义过一个用 #[Account] 宏标注的 Mint 结构体，然后在 #[derive(Accounts)] 里使用吗。现在有了 spl 库，我们不需要自己定义 Mint 结构体的类型、参数个数，直接使用就好。

同样的，TokenAccount 和 Token 也都是 spl 框架提供的类型。这么看似乎使用 spl 框架比自己写简单了不少？不能高兴的太早，还有一段代码没有写上：

impl<'info> From<&MintToCtx<'info>> for CpiContext<'_, '_, '_, 'info, MintTo<'info>>{    fn from(accts: &MintToCtx<'info>) -> Self {        let cpi_accounts = MintTo {            mint:      accts.mint.to_account_info(),            to:        accts.to.to_account_info(),            authority: accts.authority.to_account_info(),        };        CpiContext::new(accts.token_program.to_account_info(), cpi_accounts)    }}

这段代码乍一看眼花缭乱，可能要晕了，为什么那么多尖括号，为什么那么多单引号和下划线。这就是 Rust，为了迎合独特的内存管理设计，不得不让语言在语法形式上变得复杂。

impl ... From<...> for ... 是 Rust 的语法规则，大意是让一种类型变为另一种类型，我们这里就是让 From<&MintToCtx<'info>> 类型变为 CpiContext<'_, '_, '_, 'info, MintTo<'info>>。其中 MintToCtx 是我们上面自己用 #[derive(Accounts)] 宏定义的类型，然后作为泛型参数传递给了 From，而这个 From，是 Rust 标准库提供的一个包装类型，用来接受我们传入的参数。

至于后面的 CpiContext 部分，Cpi 的全称是跨程序调用 Cross-Program Invocation，用于把要调用的外部程序，以及账户类型，都打包到一个统一的数据结构中。前三个参数不用管，最后的 MintTo 是我们真正传入的类型，这个类型是 spl 库提供的。

那么也许这里有疑问，为什么还涉及到调用外部程序？CpiContext 又是如何知道要调用哪个外部程序的？这个和 Solana 智能合约的设计有关，SPL Token 不止是一些类型定义，而且是实际已经部署在 Solana 网络上的程序。我们在使用 spl 依赖库的过程，实际上就是去调用那些已经预先在 Solana 网络上部署的 spl 合约。智能合约在运行的时候，发现你要调用 spl，就去找 spl 的合约地址，执行一些操作，然后返回结果。相当于整个网络上的智能合约都在复用同一套 spl 合约。

所以要留意 Solana 智能合约依赖库的实现方式，和其他网络是有不同的。Solana 在设计上让程序和数据分离，以致于可以实现程序共享的模式。为什么我们不自己部署一套 spl 合约，或者每个人都各自部署一套 spl 合约，然后自己使用呢？一方面是需要付出额外的手续费成本，另一方面是 Solana 的智能合约本来就允许程序共享，你要是自己部署一套，用户都不知道你有没有偷偷修改标准库的代码，反而不安全了。

还有最后一部分 #[program] 里的程序逻辑要补齐：

pub fn mint_to(ctx: Context<MintToCtx>, amount: u64) -> Result<()> {    token::mint_to((&*ctx.accounts).into(), amount)}

3. 编译合约

现在代码没问题，但是如果现在编译合约项目，会遇到报错。需要修改下 programs/usdt_spl/Cargo.toml 文件，把这两行的特性打开：

[features]idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"][dependencies]anchor-spl  = { version = "0.31.1", features = ["token", "idl-build"] }

因为静态编译的时候，命令行默认没有把 spl 标准库给带上，在配置文件里指明就可以了。现在项目可以编译成功：

anchor build

4. 写单元测试

安装 spl 相关的 nodejs 依赖，注意单元测试用的是 ts 语言，不是 Rust 语言：

npm i @coral-xyz/anchor@^0.31 @solana/spl-token chai

把单元测试代码复制到 tests/usdt_spl.ts 文件中：

import anchor from "@coral-xyz/anchor";import { Program } from "@coral-xyz/anchor";import {  createMint,  createAssociatedTokenAccount,  getAccount,  TOKEN_PROGRAM_ID,} from "@solana/spl-token";import { assert } from "chai";const { AnchorProvider, BN } = anchor;describe("usdt_spl / mint_to", () => {  const provider = AnchorProvider.env();  anchor.setProvider(provider);  const program = anchor.workspace.UsdtSpl as Program;  let mintPubkey: anchor.web3.PublicKey;  let ata: anchor.web3.PublicKey;  it("creates mint, mints 1 USDT into ATA", async () => {    mintPubkey = await createMint(      provider.connection,      provider.wallet.payer,          // fee-payer      provider.wallet.publicKey,      // mint authority      null,                           // freeze authority      6                               // decimals    );    ata = await createAssociatedTokenAccount(      provider.connection,      provider.wallet.payer,          // fee-payer      mintPubkey,      provider.wallet.publicKey       // owner    );    await program.methods      .mintTo(new BN(1_000_000))      // 1 USDT      .accounts({        mint: mintPubkey,        to: ata,        authority: provider.wallet.publicKey,        tokenProgram: TOKEN_PROGRAM_ID,      })      .rpc();    const accInfo = await getAccount(provider.connection, ata);    assert.equal(accInfo.amount.toString(), "1000000");  });});

运行单元测试，会看到成功的输出：

anchor test

5. 部署合约到 devnet

确保账户里余额足够，然后用 anchor 来部署合约：

anchor deploy --provider.cluster devnet 

这个命令偶尔会因为网络问题执行失败，抛出 Operation timed out 错误。可以直接把 provider 的参数改为自己的 rpc 地址，如果网址比较长，可以用双引号括一下：

anchor deploy --provider.cluster "<your-rpc-url>"

因为网络问题带来的麻烦有可能还不止如此，比如本地存在写入了一部分但是为完成的 buffer、链上存在 buffer 但是本地不存在导致状态不一致等问题，为了直接跳过那些问题，可以直接这种这样的命令：

solana program deploy \  target/deploy/usdt_spl.so \  --program-id target/deploy/usdt_spl-keypair.json \  --url "<your-rpc-url>"

这个命令更加好用。如果没有带 --program-id 参数，这个命令会自动新生成 keypair，也就意味着会把合约部署的新的地址，这个根据自己的需求来选择。部署成功后，就可以去 区块链浏览器 上查看了。

6. 使用 SDK 调用链上合约

我们之前使用过 SDK，现在再来使用和复习一下，编辑 app/app.js 文件，把代码复制进去：

// scripts/mint_to.js   (CommonJS)const anchor = require("@coral-xyz/anchor");const {  createMint,  createAssociatedTokenAccount,  getAccount,  TOKEN_PROGRAM_ID,} = require("@solana/spl-token");const fs   = require("fs");const os   = require("os");const path = require("path");const { Keypair, Connection, PublicKey } = anchor.web3;const RPC_URL = process.env.RPC_URL || "https://api.devnet.solana.com";const connection = new Connection(RPC_URL, { commitment: "confirmed" });const secret = Uint8Array.from(  JSON.parse(fs.readFileSync(path.join(os.homedir(), ".config/solana/id.json"))));const wallet = new anchor.Wallet(Keypair.fromSecretKey(secret));const provider = new anchor.AnchorProvider(connection, wallet, {  preflightCommitment: 'confirmed',});anchor.setProvider(provider);const idl  = JSON.parse(fs.readFileSync(path.resolve("target/idl/usdt_spl.json")));const prog = new anchor.Program(idl, provider);(async () => {  const mint = await createMint(connection, wallet.payer, wallet.publicKey, null, 6);  const ata  = await createAssociatedTokenAccount(connection, wallet.payer, mint, wallet.publicKey);  const sig = await prog.methods    .mintTo(new anchor.BN(1_000_000))    .accounts({ mint, to: ata, authority: wallet.publicKey, tokenProgram: TOKEN_PROGRAM_ID })    .rpc();  console.log("tx:", sig);  console.log(`explorer: https://explorer.solana.com/tx/${sig}?cluster=devnet`);  const bal = await getAccount(connection, ata);  console.log("balance:", bal.amount.toString());})();

如果一切顺利，可以看到这样的运行结果：

~/work/github/sol_contract/usdt_spl main ❯ node app/app.jstx: 3MgHxsfnJp68mrrABvCh9iwNm6MSXp1SEvk7vDYHoW7KhTEHfVNyMWsbfbEAXTC9gLzcmWu5xbkzia8hgZrcZ18iexplorer: https://explorer.solana.com/tx/3MgHxsfnJp68mrrABvCh9iwNm6MSXp1SEvk7vDYHoW7KhTEHfVNyMWsbfbEAXTC9gLzcmWu5xbkzia8hgZrcZ18i?cluster=devnetbalance: 1000000

这个一个零基础的系列教程，可以从最基本的操作开始学会 Solana 智能合约的开发。

• 《第一篇》：基础环境安装、HelloWorld 合约部署、链上合约调用
• 《第二篇》：实现 USDT 合约的最小模型，自定义数据结构与方法
• 《第三篇》：使用官方 SPL 库复用合约功能，完成标准化代币的发行

我们已经学会了如何创建智能合约项目、部署合约以及调用连上合约，接下来深入了解一下智能合约编程语言的写法，关注如何写出自己想要的逻辑。我们将会以写一个简单的 USDT 代币合约为例，分析相关的代码，并且理解 Solana 智能合约的写法。

1. 创建项目

用我们已经学会的命令，来创建一个新的项目：

anchor init usdt_clone

2. 配置文件

可以注意到项目路径 programs/usdt_clone/Cargo.toml 下的这个文件，Cargo 是 Rust 语言常用的包管理器，这个 Cargo.toml 则是包管理器的配置文件，指定了要引入哪些依赖库，以及依赖库的版本。我们自动生成的配置文件里有这么两行：

[dependencies]anchor-lang = "0.31.1"

Anchor 提供的宏是 Solana 智能合约的关键，宏的形式如 #[program]、#[account] 等，这些宏会告诉 Solana 的 SVM 虚拟机，程序从哪里开始、数据结构在哪里定义等。如果没有 Anchor 这个依赖，合约项目就是普通的 Rust 语言项目了，Solana 的智能合约系统无法识别和解析。这也就解释了，Solana 的智能合约，是如何利用 Rust 语言来实现的。

3. 合约地址

我们近距离看一下合约的代码文件 usdt_clone/programs/usdt_clone/src/lib.rs。文件的第一行内容是这样，use 把 Anchor 常用的类型一下子全部导入进来了，这没什么问题，不需要修改，方便我们后续编写程序。：

use anchor_lang::prelude::*;

第二行内容是一个对 declare_id 函数的调用，declare_id 声明了当前这个智能合约项目的 Program ID，也就是合约地址是什么，之前我们提到过，Solana 的智能合约地址，是可以离线生成的。

declare_id!("CFmGdHuqDymqJYBX44fyNjrFoJx6wRkZPkYgZqfkAQvT");

这个合约地址是一个随机值，但不是随意格式的值，它是一个 Ed25529 的公钥。假如你手动把最后一个字符 T 改为 t，这整个字符串就不是一个合法的公钥了，所以这个值可以随机生成，但是不能随便改。那么既然是公钥，它的私钥在哪里呢？在初始化项目的时候，会自动生成一个私钥，文件位置在 target/deploy/usdt_clone-keypair.json，可以打开看到是一些字节数组，declare_id 使用的公钥，就是根据这个私钥生成的。

4. 储存数据结构

接下来我们需要新增一些自己的逻辑，在 declare_id 语句的下方，写入这个代码：

#[account]pub struct Mint {    pub decimals: u8,    pub mint_authority: Pubkey,}

可以理解为 #[account] 宏是用来定义数据结构的，Anchor 黑魔法会在背后进行一系列操作，让我们可以针对这个数据结构在链上进行读写操作。这里的代码很简单，我们定义了一个叫 Mint 的结构体，这个结构体包含两个属性，decimals 指定 USDT 代币的精度是多少，mint_authority 指定谁可以来挖新的币。

我们继续定义另一个结构体，用来储存每一个用户的代币数量。owner 就是用户地址，balance 则是用户的余额：

#[account]pub struct TokenAccount {    pub owner: Pubkey,    pub balance: u64,}

5. 账户约束结构

你可能注意到当前的代码文件最底部，还有两行自动生成的 #[derive(Accounts)] 开头的代码。这个宏是用来给账户写一些约束规则的。我们可以在 #[derive(Accounts)] 内部定义一些函数，然后再用 #[account] 来定义结构体，那么这个结构体就自动拥有了所有函数。类似于给结构体定义成员函数的意思。

把原本的 Initialize 代码删掉：

#[derive(Accounts)]pub struct Initialize {}    // 删除

然后写入我们自己的逻辑：

#[derive(Accounts)]pub struct InitMint<'info> {    #[account(        init,         payer = authority,        space = 8 + 1 + 32    )]    pub mint: Account<'info, Mint>,    #[account(mut)]    pub authority: Signer<'info>,    pub system_program: Program<'info, System>,}

这段代码有点复杂。我们先看 #[account(...)] 这一段，这里给 account() 函数传递了 3 个参数进去，account() 函数的参数类型是 Anchor 框架定义的，第一个参数 init 是一个固定的关键字，不需要值，表示如果账户不存在，则创建一个新的账户。第二个参数 payer 是需要值的，表示谁来支付创建账户的手续费。第三个参数 space 的值则是我们自己计算的，系统必须预留 8 + Mint 结构体的第一个字段类型 u8 需要空间 1 + Mint 结构体的第二个字段类型 Pubkey 需要空间 32。

这个 #[account(...)] 的宏用来修饰 mint 成员变量。我们接着看 mint 这个成员变量，Account 是 Anchor 框架提供的内置的账户类型，可以对储存数据结构进行读写，例如我们之前定义的 Mint 或者 TokenAccount 结构，这个 mint 成员变量实际操作这些类型的数据。而 Account 接受两个泛型参数，第二个参数 Mint 指明了这个账户是在处理 Mint 类型的结构，而不是 TokenAccount 或者其他。

接着看 #[account(mut)] 这个宏，mut 的意思是账户金额可以变化。authority 也是一个成员变量，它的类型同样是一个 Anchor 内置的账户类型 Signer，与 Account 不同的是，Signer 意味着需要传入账户持有者本人签名，才符合类型定义。后面的 ‘info 则是一个泛型参数，其中 info 是结构体的泛型传递进来的。至于 info 前面的单引号 '，是 Rust 语言里的一个特性，可以简单理解为对参数的引用传递。整体来看，这两行代码的宏和语句，共同定义了一个可以对其扣费的账户地址作为成员变量。

最后的 system_program 成员变量，可以把这一行理解为固定写法，只要合约需要转账 SOL，就得写上这一行。总的来说，这几行代码定义了一个新的结构体 InitMint，这个结构体是基于 Mint 进行包装的，包装后的 InitMint 拥有了一些账户相关的属性。

6. 代币合约初始化

接下来开始关注 #[program] 宏定义的函数。这个宏用来标注智能合约的程序入口，也就是真正执行合约逻辑的部分。我们当前文件里有几行默认的代码：

#[program]pub mod usdt_clone {    use super::*;    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {   // 删除        msg!("Greetings from: {:?}", ctx.program_id);             // 删除        Ok(())                                                    // 删除    }                                                             // 删除}

删掉这个项目自动生成的 initialize 函数，我们自己写一个函数：

pub fn init_mint(ctx: Context<InitMint>, decimals: u8) -> Result<()> {    let mint = &mut ctx.accounts.mint;    mint.decimals = decimals;    mint.mint_authority = ctx.accounts.authority.key();    Ok(())}

把这个 init_mint 函数放在原先 initialize 函数的位置。如果抛开 Anchor 的宏，这个函数则是一个普通的 Rust 语法定义的函数。Context 类型是 Anchor 提供的包装类型 所以你也许好奇我们明明没有定义 Context，但是这里却直接使用了。InitMint 类型是则我们上一个步骤定义好的。

这个函数接受两个参数，第一个参数的类型是 InitMint，表示哪个账户拥有铸币权限。第二个参数类型是 u8，表示 USDT 的精度是多少位。这个函数返回一个空的元组 ()，说明如果成功什么都不返回，如果失败则会报错。

函数内部的逻辑相对好理解，函数把参数接收进来的数据，赋值给了一个叫 mint 的变量，要注意这不是普通的新定义的变量，而是从 ctx.accounts 反序列化过来的、mut 声明的可变类型的变量，相当于直接修改一个引用类型的结构体内的属性值，所以只要给 mint 赋值，结构体内的数据都会保存下来，也就是保存到链上。

7. 单元测试

可以先到目录下，运行一下编译，看程序是否写对了，如果编译报错，可能是哪里复制漏了。由于 Rust 语言的编译器非常严格，所以即使没有错误，也会有很多 warning，暂时不用管那些警告信息：

anchor build  

接下来到 usdt_clone/tests/usdt_clone.ts 文件，复制这些代码进去：

import anchor from "@coral-xyz/anchor";import { Program } from "@coral-xyz/anchor";import { SystemProgram, Keypair } from "@solana/web3.js";import { assert } from "chai";const { AnchorProvider, BN } = anchor;describe("usdt_clone / init_mint", () => {  const provider = AnchorProvider.env();  anchor.setProvider(provider);  const program = anchor.workspace.UsdtClone as Program;  const mintKey = Keypair.generate();  it("creates a Mint with correct metadata", async () => {    const txSig = await program.methods      .initMint(new BN(6))      .accounts({        mint: mintKey.publicKey,        authority: provider.wallet.publicKey,        systemProgram: SystemProgram.programId,      })      .signers([mintKey])      .rpc();    console.log("tx:", txSig);    const mintAccount = await program.account.mint.fetch(mintKey.publicKey);    assert.equal(mintAccount.decimals, 6);    assert.equal(      mintAccount.mintAuthority.toBase58(),      provider.wallet.publicKey.toBase58()    );  });});

这段代码使用本地的单元测试框架，构造了一些参数去调用我们在合约里写的 initMint 方法，比如指定精度为 6 位，传递了 InitMint 结构体需要的 3 个参数等。模拟交易的执行结果赋值给了 txSig 变量，可以在输出日志中看到交易哈希。并且在交易结束后，用语句 program.account.mint.fetch 查询了合约的 mint 属性的值，它的精度应该等于我们的参数，authority 也应该是我们本地发起模拟交易的账户地址。

运行这个命令来查看单元测试的效果：

anchor test

如果一切顺利，会看到 1 passing (460ms) 的字样。

8. 开户和转账

基于上面我们已经看懂的语法规则，可以继续在合约代码中新增这样两个账户结构的定义，分别用来开户和转账。这里的 #[error_code] 是新出现的宏，比较容易理解，它是一个枚举类型，用于程序报错的时候调用：

#[derive(Accounts)]pub struct InitTokenAccount<'info> {    #[account(init, payer = owner, space = 8 + 32 + 8)]    pub token: Account<'info, TokenAccount>,    #[account(mut, signer)]    pub owner: Signer<'info>,    pub system_program: Program<'info, System>,}#[derive(Accounts)]pub struct Transfer<'info> {    #[account(mut, has_one = owner)]    pub from: Account<'info, TokenAccount>,    #[account(mut)]    pub to: Account<'info, TokenAccount>,    #[account(signer)]    pub owner: Signer<'info>,}#[error_code]pub enum ErrorCode {    InsufficientFunds,    ArithmeticOverflow,}

然后新增两个方法，分别执行开户的逻辑以及转账的逻辑。注意这里开户的时候，token.balance = 1000 意味着每一个开户的地址，默认都会有 1000 的余额。这里主要是为了简化流程和代码、方便单元测试，这个数字可以随意改动：

pub fn init_token_account(ctx: Context<InitTokenAccount>) -> Result<()> {  let token = &mut ctx.accounts.token;  token.owner = ctx.accounts.owner.key();  token.balance = 1000;  Ok(())}pub fn transfer(ctx: Context<Transfer>, amount: u64) -> Result<()> {  let from = &mut ctx.accounts.from;  let to   = &mut ctx.accounts.to;  require!(from.balance >= amount, ErrorCode::InsufficientFunds);  from.balance -= amount;  to.balance = to      .balance      .checked_add(amount)      .ok_or(ErrorCode::ArithmeticOverflow)?;  Ok(())}

这是针对开户和转账功能的单元测试代码：

const tokenA = Keypair.generate();const tokenB = Keypair.generate();it("initializes tokenA & tokenB, each with balance 1000", async () => {  for (const tok of [tokenA, tokenB]) {    await program.methods      .initTokenAccount()      .accounts({        token: tok.publicKey,        owner: provider.wallet.publicKey,        systemProgram: SystemProgram.programId,      })      .signers([tok])      .rpc();    const acc = await program.account.tokenAccount.fetch(tok.publicKey);    assert.equal(      acc.owner.toBase58(),      provider.wallet.publicKey.toBase58()    );    assert.equal(acc.balance.toNumber(), 1000);  }});it("transfers 250 from A to B (balances 750 / 1250)", async () => {  await program.methods    .transfer(new BN(250))    .accounts({      from:  tokenA.publicKey,      to:    tokenB.publicKey,      owner: provider.wallet.publicKey,    })    .rpc();  const a = await program.account.tokenAccount.fetch(tokenA.publicKey);  const b = await program.account.tokenAccount.fetch(tokenB.publicKey);  assert.equal(a.balance.toNumber(), 750);  assert.equal(b.balance.toNumber(), 1250);});

如果有兴趣，可以试着把这个合约也部署到 devnet 上，然后通过 SDK 来发起对链上合约的调用。

这是一个零基础的系列教程，可以从最基本的操作开始学会 Solana 智能合约的开发。

• 《第一篇》：基础环境安装、HelloWorld 合约部署、链上合约调用
• 《第二篇》：实现 USDT 合约的最小模型，自定义数据结构与方法
• 《第三篇》：使用官方 SPL 库复用合约功能，完成标准化代币的发行

我们将从最基础的操作开始，学习 Solana 智能合约的开发。你只需要普通的编程基础，理解面向对象等概念就可以，不需要事先知道其他网络的智能合约概念，也不需要知道 Rust 语言的编程理念。

1. 安装环境

访问 Solana 官方提供的安装教程：https://solana.com/docs/intro/installation

文档中提供了一键安装全部依赖的单个命令行，也有分阶段安装的详细教程。要注意其中 Solana Cli 是需要修改环境变量文件的。安装好一切后，solana 命令应该是可用的：

solana --help

2. 初始化项目

使用 anchor 命令来初始化一个智能合约的项目，这个命令行工具在上个步骤已经安装好了，可以先不用管生成的目录结构是什么样子：

anchor init hello_solcd hello_sol

3. 写入合约代码

programs/hello_sol/src 目录下有一个 lib.rs 文件，.rs 结尾意味着这是一个 Rust 语言的代码文件。把这些代码复制进去，注意 declare_id 中的内容是你的项目在初始化的时候，就会自动为你生成，不需要原封不动复制下面的内容：

use anchor_lang::prelude::*;declare_id!("3Zbdw1oWu1CiMiQr3moQeT4XzMgeqmCvjH5R5wroDWQH");#[program]pub mod hello_sol {    use super::*;    pub fn say_hello(ctx: Context<Hello>) -> Result<()> {        msg!("Hello, world!");        Ok(())    }}#[derive(Accounts)]pub struct Hello {}

4. 编译智能合约

使用 anchor 命令编译你刚才复制进去的智能合约代码，确保编译是成功的，代码没有写错。编译过程中可能会有一些警告，那些警告不要紧，因为 Rust 语言对于代码非常严格，很小的问题都会抛出大段的警告。如果一切顺利，命令行的输出不会有错误日志：

anchor build

5. 设置本地默认网络

运行这个命令，让你本地的 solana 命令默认使用 devnet，因为 devnet 是给开发者使用的，可以用来测试自己的程序，而不需要真的花钱去买 SOL 代币：

solana config set --url https://api.devnet.solana.com

6. 创建本地账户文件

这个命令用于在你本地的默认路径下，创建一个用来部署智能合约的 Solana 账户。因为部署智能合约需要消耗手续费，这些手续费需要一个账户来支付：

solana-keygen new -o ~/.config/solana/id.json  

这个命令的运行结果中，有一行 pubkey: 开头的输出，pubkey 后面的就是你本地的账户地址。因为上一个步骤已经设置了 devnet 为默认网络，所以可以直接使用这个命令来查看你本地账户的余额：

solana balance

也可以打开 devnet 的 浏览器，搜索你刚才生成的地址。搜索之后的 URL 形如：https://explorer.solana.com/address/75sFifxBt7zw1YrDfCdPjDCGDyKEqLWrBarPCLg6PHwb?cluster=devnet

当然，你会发现自己的账户余额是 0 SOL。

7. 领取 devnet 上的空投

运行这个命令，你的账户就可以收到 2 个 SOL。其中参数里的 2 就是请求发放 2 个 SOL 的意思。因为领水的额度限制，你只能一次性最多领 2 个。不用担心太少，足够我们接下来的步骤使用了。

solana airdrop 2

8. 部署合约到 devnet

现在我们已经有了智能合约代码，有了本地账户，并且本地账户里有 SOL 余额。现在可以部署合约到 devnet 上了。运行这个命令：

anchor deploy --provider.cluster devnet 

如果部署成功，会看到 Deploy success 的字样。命令行输出中还有一行需要留意，Program Id: 后面的，就是部署之后的合约地址，你可以直接在 devnet 的浏览器上搜索这个地址，然后看到类似这个 URL 的页面，URL 中的 3Zbdw1oWu1CiMiQr3moQeT4XzMgeqmCvjH5R5wroDWQH 就是我部署的合约地址：https://explorer.solana.com/address/3Zbdw1oWu1CiMiQr3moQeT4XzMgeqmCvjH5R5wroDWQH?cluster=devnet

9. 调用链上合约

到 hello_sol/app 目录下，新建一个叫 app.js 的文件，把这些代码复制进去。简单来说，这段代码读取了你本地默认的账户文件，然后用你的 Solana 账户发起一笔对智能合约调用的交易，这个脚本每执行一次，就会在链上创建一笔交易。：

const anchor = require('@coral-xyz/anchor');const fs     = require('fs');const os     = require('os');const path   = require('path');const { Keypair, Connection } = anchor.web3;const RPC_URL    = process.env.RPC_URL;const connection = new Connection(RPC_URL, { commitment: 'confirmed' });const secretKey = Uint8Array.from(  JSON.parse(    fs.readFileSync(      path.join(os.homedir(), '.config/solana/id.json'),      'utf8',    ),  ),);const wallet   = new anchor.Wallet(Keypair.fromSecretKey(secretKey));const provider = new anchor.AnchorProvider(connection, wallet, {  preflightCommitment: 'confirmed',});anchor.setProvider(provider);const idlPath = path.resolve(__dirname, '../target/idl/hello_sol.json');const idl     = JSON.parse(fs.readFileSync(idlPath, 'utf8'));const program = new anchor.Program(idl, provider);(async () => {  try {    const sig = await program.methods.sayHello().rpc();    console.log('✅ tx', sig);    console.log(`🌐 https://explorer.solana.com/tx/${sig}?cluster=devnet`);  } catch (err) {    console.error('❌', err);  }})();

返回 hello_sol 项目的顶层目录，执行这些命令来安装 nodejs 的依赖：

npm init -y npm install @coral-xyz/anchor

然后记得现在仍然是在顶层目录，运行这个命令，来执行刚才写的 app.js 脚本，脚本会到 devnet 上调用我们部署的智能合约：

export RPC_URL=https://api.devnet.solana.comnode app/app.js

这里有一个环境变量 RPC_URL 是脚本请求的 API 地址，因为 nodejs 脚本默认不走系统代理，所以对于网络受阻的同学，需要用一个比公开 RPC 更好用的 API 地址。可以使用例如 Helius 的服务，注册一个免费的账号就可以了。假如执行脚本的过程中遇到下面的错误，那就说明是网络问题，换一个好用的 RPC 地址就好了：

❌ Error: failed to get recent blockhash: TypeError: fetch failed    at Connection.getLatestBlockhash (/Users/smallyu/work/github/hello_sol/node_modules/@solana/web3.js/lib/index.cjs.js:7236:13)    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)    at async AnchorProvider.sendAndConfirm (/Users/smallyu/work/github/hello_sol/node_modules/@coral-xyz/anchor/dist/cjs/provider.js:89:35)    at async MethodsBuilder.rpc [as _rpcFn] (/Users/smallyu/work/github/hello_sol/node_modules/@coral-xyz/anchor/dist/cjs/program/namespace/rpc.js:15:24)    at async /Users/smallyu/work/github/hello_sol/app/app.js:40:17

你也许好奇为什么不需要指定调用的合约地址，这个脚本怎么知道你刚才，部署到链上的合约在哪里？注意看脚本中有一个 idlPath 的变量，你可以直接打开这个路径的文件 target/idl/hello_sol.json 查看，里面是一些合约编译后的元信息，包括合约的地址也在里面，没错合约地址是离线生成的，不需要上链，合约就有属于自己的唯一地址了。

如果执行脚本没有输出错误，就会看到终端打印出了这一次调用合约的交易哈希，以及可以直接复制访问的浏览器 URL，例如这就是一笔调用合约的交易：https://explorer.solana.com/tx/2fnPgKkv3tGKKq72hhRxmW6WFSXuofMzXfY2UYoFZXTdJi37btdESy9NzS2gjpWzXX4CL5F7QfxugpctBVaMcBFY?cluster=devnet

这笔交易页面的最下方，可以看到我们写的智能合约在被交易调用后，打印出了 Program logged: "Hello, world!" 的日志，这正是我们写在合约代码中的 msg。

10. Troubleshooting

如果在执行上述命令或者代码的过程中，遇到了错误，可以优先考虑是命令行工具版本的问题。由于区块链行业和技术迭代比较快，很容易出现版本不兼容的情况。我本地的环境和版本是：

rustup: rustup 1.28.2 (e4f3ad6f8 2025-04-28)rustc: rustc 1.90.0-nightly (706f244db 2025-06-23)solana: solana-cli 2.2.18 (src:8392f753; feat:3073396398, client:Agave)archor: anchor-cli 0.31.1node: v24.2.0@coral-xyz/anchor(nodejs): ^0.31.1

• smallyu.net
• crazy.smallyu.net （疯狂版）

在疯狂版上，我可以随心所欲发布任何想说的内容，应该没人会关注到。

你可能有两个疑问：

1. 往期基础班都是两个月，怎么我一个月就结束了？东西都学完了？
2. 一个月的时间能学到多少东西？

对于第一个疑问，来回顾和分析下我学习基础班的课时。我学习前 6 课用了半个月时间，除去周末两天助教老师在休息，我也会出去玩，所以学习前 6 课平均每节课用时两天。

往期基础班的安排是一周一节课。假如之前其他同学一天学 2 个小时，那么一周下来是 14 个小时。我一天就可以学够 7 小时，自然可以用两天时间完成一节课。

一天真的能学够 7 小时吗？可以这么说，我最近两年的工作强度不比这个低，经年累月加班，我又比较自觉，不摸鱼。我最近不用上班，把学习当班上了属于是。那么从时间强度上，我一天学 7 小时是合理的。

后面学 Rust 这节课用时最长，在 10 天左右。其他的课还是一两天的样子，因为不只是 Rust 语言，还加深了对解释器的理解，以及包括一些隐藏关卡。所以整体下来，一个月完成了基础班全部课程内容的学习。

至于课后练习题的含量，我曾经做过一个测试，一天之内，一口气把前 5 课的练习题全部重做一遍。当时也是觉得进度太快，担心自己没掌握好。整体体验下来，每一节课的课后练习题，都需要一个小时左右的时间才能完成，这是在已经做过一遍的前提下，而且并没有非常认真的整理代码，做出来就算。

至于后面的课程，练习题难度就更大了，尤其是解释器的课程，以及 Rust 的课程，而且因为 Rust 这种语言的坑，对解释器也需要反复理解，甚至需要做点课上没写的东西，才能理解清楚。

所以整体算下来，基础班的课时长度可以这样估算：

1. 每节课视频长度 2.5 小时，8 节课一共 20 小时
2. 第一课的练习题需要 12 小时左右
3. 第二课到第七课的练习题每节课需要 7 小时左右，一共 42 小时
4. 第八课需要接近 30 个小时
5. 一些隐藏关卡同样平均需要 7 小时，但是做了多少隐藏关因人而异，我做了 3 关，一共 21 小时

加起来算一下，一共需要 125 个小时。我用时一个月，除去节假日有 22 天，平均一天 6 个小时，很合理吧。

同样也可以提供给其他人一些参考，想学完基础班，就需要准备出至少 120 个小时的时间。平摊到两个月的话，平均一天 2 个小时，学 60 天，才能学完。

对于第二个疑问，问题就迎刃而解了。这么多的学习时长，当然能够学到很多东西。何况是非常精致的课程内容，还有高水平的老师指导，事半功倍。

现在好了，课也上了，学也学了，该进入下一步的计划了。

回顾我的学习动机

既然我反复夸赞这门课程，那么是不是我推荐所有人去学、并且跟谁都会说物超所值呢。当然也不是那么绝对。

看我的博客主题就知道，我已经是王垠老师的粉丝很多年了，但是前几年的培训课并没有报名参加。以前没有报名学习的原因有：

1. 没有认识到基础编程技能的重要性，大概扫一眼大纲，感觉不就是一些入门编程的东西吗，递归之类的
2. 以前处于比较浮躁的心态，认为只要在前沿的技术公司，认真做好一线的技术工作，在工作中自然而然就会掌握更高级、更精深的技术，不需要学这些太基础的东西
3. 认为区块链技术大有可为，自己还没学好区块链。把区块链学好了，技术就好了

然而到后来，我现在决定学习这门课的原因有：

1. 当时在做一份普通的后端开发工作，背离我长年来区块链开发的职业道路，尤其是职业技能上水土不服，让我开始关注基础的计算机知识的分量
2. 工作中连续多次遇到糟糕的团队，心态爆炸，我怀疑是自己能力有问题
3. 对区块链技术感觉迷茫，不知道学什么，而且发现基础的编程能力也很重要，区块链底层仍然是计算机科学
4. 希望通过学习让自己安心。如果这种高质量高水平的课程都救不了我，那我真是没救了
5. 开始试图从区块链工匠的职业定位上，寻求转型
6. 后来正好失业，给了我全心学习的机会，因此学习节奏上比较快
7. 那几天正好被 Monday 教育，说我太孤狼，没有 mentor，情商太低，怼同事不好，等等，我在寻求某种指导
8. 经过几年实际的工作，更加认识到这些基础知识的重要。我的知识和编程技能不成体系，缺少对计算机科学的系统化认识，野路子，欠缺很大
9. 当时处于比较严重的技术焦虑中，在寻求突破但是没有方向

现在课上完了，学完了，对于解决我上面的这些问题，或者说从一开始的预期来看，匹配程度是挺高的，达到了很多我预想的目的。正因为我已经关注这个课程多年，而且我自己的反省能力很强，了解自己的情况，明白自己想要什么，所以在这个最合适的时间点出手学习，是很有效果的。

抛开我这些个人定制化的目的，这门计算机科学课适合所有人吗？适合。但是首先要搞清楚，这是一门编程课，编程课的意思就是，要对着电脑屏幕和编辑器写代码。其实我不是特别理解，在家赋闲的宝妈能不能学明白这个，甚至有没有兴趣去学，因为学习的内容很多是抽象的思想，离现实生活还是有点远的。

人多学习一些东西总是没错的，而且这门课程的质量真的很高，与同类型课程相比的话。如果你真想学点扎实的计算机知识，经济上宽裕的话，这会是很好的课程。

而且，从学习的角度，学这个课，不比花 2000 块钱去加个群听李笑来讲鸡汤有用的多吗？要不是李笑来近几年专心做家庭教育，我都有冲动进他的富足人生社群了。但是又一想到里面全是宝妈，全是那些怎么教育孩子的低级内容，真的有点受不了。包括李笑来最近几年出版的书，不也越来越低智商化了吗，为了让那些宝妈听得懂。这个课可以学习到实打实的计算机知识，这些知识不管你拿到哪里，哪个大学或者什么教材，知识都是通用的、认可的。李笑来创建了一大堆鸡汤式的概念，出了群可能没人能听懂你在说什么。

附

王垠老师微博里提到过关于视频班毕业的事情，我应该是第一个从视频班毕业的：

• 微博原文链接
• 页面归档链接

这 7 年的时间里，我从大学四年级的实习，到毕业后先后进入 6 家公司工作，再到最后因为裁员而失业，经历了很多有趣或者痛苦的事情，这 7 年是完整的一辈子，也就是失败朋克的一辈子。

失败朋克这个词，来自赛博朋克世界，就像天空里飞着飞船、大街小巷都是亮光闪闪的电子屏幕，而有一些人，在如此科幻场景的世界里，却生活在暗无天日的、拥挤的贫民窟里，过着拮据的日子。

我的博客文章列表，就是典型的失败朋克：谈论着高科技的区块链技术，以太坊、EVM、共识、PoS、去中心化、加密、ZK……一大堆高大上的名词，而我本人的职场道路却非常坎坷，连续遇到糟糕的团队，反复经历裁员、跳槽、辞职、裸辞……居住在很小的租来的房子里，没有稳定的收入，连普通的有尊严的工作都找不到。

某一天清晨从睡梦中醒来，我忽然觉得应该删减一些博客上的文章，于是去掉了所有包含真实信息的文章，只保留了一些纯技术类的讨论，不再提及人生经历、梦想、生活等话题。而这本书《失败朋克的一辈子》，就是那些删减掉的内容合集，包含了真实的公司名称，以及巨大的情绪波动等内容。

为什么是现在做一个总结，而不是去年或者明年？非要说原因的话，大概就是最近学习了王垠老师的计算机学科课吧。我人生中第一次参加培训班，是在大学里，大三一整年，都在坐一小时公交车去培训班上课的路上，那一次的培训彻底改变了我的人生，让我真正踏上程序员的旅程，否则我的职业方向会很迷茫，不写代码我想不到自己还会做什么工作。

毕业 6 年后，我第二次参加培训班，也就是王垠老师的课，我觉得是一个非常好的契机，能给我一些自信，让我做出一些改变。课程内容会对我以后的学习和工作带来怎样的影响，现在是不清楚的，但是我希望这能是一个好的开始，我也相信在经历了诸多不顺的工作之后，加上最近的学习，面对以后的职业生涯会更加游刃有余。世界上最顶尖的教育尚且体验过了，还担心什么呢？

《失败朋克的一辈子》这本书收录了我过去 7 年的完整人生经历和心态变化。

希望所有人都能成为赛博朋克，而不是失败朋克——来自失败朋克的祝福。

访问地址：https://one.smallyu.net/

Tantin 的 last day 是 5月20日，到今天正好一个月的时间。这一个月的时间里做了很多事情，比有班上还要更加有意义。然而即使做了很多事情，即使每天都在忙碌，内心里还是不安，可能这种焦虑和出身有关，我始终没办法安心。

其实要非常感谢 Tantin 的裁员，我失去了一份工作，却得到了 3 样东西：

1. 区块链方向的职业生涯不至于中断
2. 有充足的时间处理家事
3. 能够专心完成计算机课程

1. 区块链方向的职业生涯不至于中断

在 Tantin 的工作是普通的后端开发，我当时都害怕，如果这份工作继续下去了，我会完全丢掉区块链开发的职业路径。没想到一个月就裁员了，对于裁员，我的第一反应是很开心，我可以不用继续做那种很普通的工作了。当时的状态我是没办法主动跳槽的。

钱包后端开发，真的就是普通的后端开发，跟区块链技术没有关系。而这些后端开发的工作，技术含量也不高。现在我不得不继续找工作了，我还会找一份区块链相关的技术工作。不过最近是真的没有合适的工作，能力合不合适先不说，就是光看职位都没有，已经没有可以投简历的职位了。

2. 有充足的时间处理家事

我有时间能在老家呆一个星期，处理好家里的事情，也真的拜裁员所赐，不然真的不知道怎么请一个星期的假。

人生有时候就是，开心也是一辈子，痛苦也是一辈子，大富大贵也是一辈子，贫穷也是一辈子。我们现在在追求的到底是一些什么，这些东西是否真的重要。

3. 能够专心完成计算机课程

学习王垠老师的计算机科学课接近一个月，这一个月的时间里学习到很多，收获很多。

如果你要问我，一个月的时间能学到多少知识呢？世界上没有速成班，也没有减肥药，王垠也不可以。

一个月的时间确实不可能学到各种全面的知识，时间上也不允许。但是我已经工作了 6 年的时间，这 6 年来，我先后进入 6 家公司，接触各种各样的项目，在不同技术方向上都做出过成果。丰富的工程实践经验已经让我的编程能力很强大。

如果你要问我，一个月的时间能不能帮我把过往的编程技能梳理一遍，让我对计算机科学有更加体系化的认识，我在工作中可能见过各种迷雾，王垠老师的课程能不能让我拨云见日，看清楚很多东西？

我一开始的课程进度比较快，基本上一天一节课的节奏，中午看完视频课，下午开始做练习题，到第二天上午，练习题就做完了。

为什么我能对基础课程有比较快的速度？因为我远不是零基础，我大多数情况都可以写出能运行的代码，即使代码不简洁不优雅。这些编程能力已经形成肌肉记忆，哪怕我不知道二叉树的前世今生，如果要我写一个树结构的遍历，我还是能写出来的。

就像生活在原始森林里的野人，即使没有经历过系统的科学的格斗训练，身体素质和格斗技巧也要远超过普通人。

而课程的后半段比较耗时间，我开始学习 Rust、深入理解解释器、尝试课程的隐藏关卡、折腾 parser，这个过程更是让我受益很多。

这门课程，学习到的不只是体系化的计算机科学知识，还有可扩展的知识体系、对代码精益求精、吹毛求疵的态度、条理分析和解决编程问题的态度，等等。

而且这门课程给予我很多自信，世界上最高级的课程我已经学过了，我确实能够通关并且掌握这些内容，以后还有什么难题是能够打败我的呢？

其他

我本以为自己可以以缓和的心态，面对这段时间，可以慢慢的体验生活、学习一些技术，比如我之前提到的 DeFi、Move 之类的。但是临到跟前，又发现有点不想学，不是因为不愿意努力，而是因为不知道学了有没有用。包括之前在做的 echoevm，在开发了两个小版本之后，现在也不是很有兴趣做下去，因为到底要做成什么样子，是完全没底的。

我的技术焦虑似乎没有很好的因为学了计算机课而缓解，而正因为这种焦虑，让我没办法专心的钻研某一种类别的技术，我会首先考虑方向对不对的问题，然后一直在犹豫。时至今日，我还是没有找到自己的方向。

前几期基础班的课程没有第八节课甚至没有第七节课，所以后两节课的内容并不影响课程本身的价值，能学到属于附加福利。我现在已经学完了前七节课，感觉收获很多。对于基础班课程内容的整体感受，我的结论是，物超所值。

课程内容后续的学习计划

对于基础班课程内容后续的学习计划，我大概列了几条：

1. 给课程中实现的解释器写一个简单的 parser
2. 重新做一遍所有的练习题
3. 复刻王垠老师讲课的思路，自己写出全部课程的代码
4. 理解练习题出题的动机，然后自己发掘新的练习题
5. 用 Go 语言实现课程中的解释器

这些目标的难度是递进的，要真实现起来需要耗费很多很多时间。所以你看，即使基础班的课程结束，但是对于其中知识的学习，还远远没有结束。基础班是一个非常好的起点，在里面学到的内容可以延展出很多有价值的东西，这个可扩展能力的价值甚至超过课程本身的价值。

基础班的知识好比非常高级的原材料，从基础班毕业就意味着拿到了这些原材料。但原材料需要经过反复打磨、锤炼、加工，才能变成更加实际可用的装备。所以我猜测有的同学学完之后感觉什么都没学到，而有的同学觉得如获至宝，能够反复加以利用并产生许多价值，大概就是这个原因吧。

关于职业反思的反思

我开始反思自己的职业路径是从 4 月份开始的，当时我入职了一家新的公司，做普通的钱包后端开发。

实际的工作过程中，我发现同事以比较低的效率写着比较差的代码，整体工程能力差，但是每天工作显得忙的不可开交，领导也对他委以重任，因为他们之前就认识。

这样的现象让我很难受，我很懂区块链，但是这种懂不但没有让我的职业道路变轻松，没有给我的生活带来改善，反而在新的工作中，沦为新人一样的角色被轻视。

同样的，我有很强的工程实践能力，工作效率一向很高，但是这样能将技术设计短时间落地为工程代码的能力，不但没有给我在工作中带来应有的重视，反而在前公司受到了同事极其不尊重的对待。

所以我开始反思，是不是我的技术能力不够，是不是因为我没有上过好的学校，是不是行业环境整体的问题，是不是我过往的职业道路选择错误。

而反思的产物，就是 4 月份高频率的博客更新，尝试做一些技术产品的设计、学习新技术、改变社交态度。事实证明，只要我想，就真的可以学会使用 ZK，或者做点 EVM 相关的事情。但是这些事情还不够，我应该把这种学习能力和工程能力用到更有价值的地方。

关于博客内容的反思

以前习惯于把学习到的技术、职业经历、观察到的行业现象都毫无保留分享出来，因为很多内容是我自己摸索出来的，观点也是自己经过学习和思考形成，所以分享出来没什么问题。

但是观点和知识是两种东西，从基础班学习到的知识包含很高价值，自然不可能分享。而对于博客后续的内容，也有必要进行反思和调整。

区块链技术后续的学习计划

我在区块链方面需要补齐的知识：

1. 学习研究比特币脚本
2. 学习编写和部署 Solana、Aptos、Sui 等热门链的智能合约
3. 学习研究 Uniswap、AAVE 之类的 DeFi 协议
4. 调研分析一些 web3 领域知名技术人员的履历和工作成果，将其作为技术标杆提升自己

这家公司和 Coinstore 有很深的关系，一开始的老员工是从 Coinstore 借来的，后来从外部招人组建了新的团队后，Coinstore 的员工也都回去原本的岗位了。新建立的团队有两个，主要负责 3 个产品线的开发，公链、跨链桥、钱包。经过一个月的开发，原本计划今天上线和发布第一个正式版本，不知道发生了什么，也正好就在今天，公司裁掉了两个团队的所有员工。

回到我自己的工作内容，这个交易记录聚合服务其实挺简单，开发只需要一两个星期的样子，剩下的时间，就全在没事找事了，优化多环境配置、写单元测试、写集成测试、写注释、优化代码结构……不得不说，这段时间的工作很开心，最近两年都没有做过这么轻松的工作，同事氛围也很好，很欢快。我沉浸在严肃的区块链技术里太久了，偶尔做普通的后端开发换换心情也挺有意思。

提醒（2025.05.22）

经调查，Tantin Chain 的中文名叫天体链，兄弟部门是 Tantin Exchange（TTX）天体交易所，TTX 的前身叫 ttsmart，发行的代币叫 CTC。

想提醒大家，这家公司起源于柬埔寨，最近在新加坡组建了办公室，有着非常深厚的传销背景，有过跑路的黑历史，这些信息从网络上能搜索到痕迹。大家要尽可能避免使用 Tantin 的产品，以防个人资产受到损失。他们招聘使用的公司名称是 Tantin Technology，从业人员也要多加提防，尽可能不去这家公司，因为一旦后续用户那边出问题，可能会有连带责任。

为什么选择这个方向？解析下以太坊客户端的技术模块：

1. RPC：GRPC 套壳？重点在于协议设计而不是技术实现
2. P2P：有现成的 libp2p 可用，无非是节点发现、路由表之类，比如深入下 Kademlia DHT？
3. 账户体系：ECDSA？密码学？
4. 交易池：交易分析、密封交易、MEV保护方向
5. 共识机制：共识机制的设计属于研究级别，至少得是个博士发论文、实验室里做研究、出各种测试数据，然后证明在哪方面做出了业界前沿的优化、最后融资雇人做工程化的实现
6. 储存：搞数据库底层的专家应该干什么都一样，哪里都有用武之地，跟区块链没关系
7. 数据结构：去研究 Merkle Patricia Tree 的实现吗？
8. 状态同步：轻节点方向，比如用 Celestia 的核心技术把执行和储存分开，或者 Archive 节点数据的 offload？

综合来看，我倾向于做一件侧重工程而不是学术、同时又有技术含量的事情，无论是从个人技术能力的提升，还是后续有可能带来的成果上，都要有意义。假如这个最小EVM开发出来了，是可以带来一系列成果的，后续也可以基于此延伸出很多更有价值的产品。

从 Solidity 语言到 bytecode 的转换过程，那是编译器专家干的事情，我要做的，是针对 bytecode 做执行，先从最简单的加法运算和 jump 开始，然后是 Gas 的计算、上下文环境的切换，直到能够执行全部以太坊历史交易。

v0.0.1（2025.05.27）

实现了一个非常简单的版本，现在可以用 solc 编译一个 Add.sol 合约，然后让 echoevm 读取生成的 Add.bin 部署代码，就会输出合约部署之后的运行时代码。

在实现这个版本的过程中，学习到的东西是部署代码和运行时代码的区别。我们一般会先部署一个合约到链上，然后再对这个合约产生调用，这实际上是两个不同的操作，但又都在使用相同的 EVM 执行，EVM 并不关心输入的 bytecode 是部署还是调用，只是对不同的操作码处理方式不同。一般部署代码会同时包含 CODECOPY 和 RETURN 两个操作码，可以利用这一点来区分输入的类型。

v0.0.2（2025.06.09）

这个版本增加了运行 runtime bytecode 的能力，也就是先部署合约，然后再针对部署之后的合约内容，进行调用，调用的时候可以带上一些参数，比如：

go run ./cmd/echoevm -bin ./build/Add.bin -function 'add(uint256,uint256)' -args "3,5"

这个命令的含义是，会执行 ./build/Add.bin 文件内的 bytecode，并且调用 add 函数，传入参数 3 和 5，最终程序运行结束后，会返回出计算结果 8。

v0.0.3（2025.06.24）

好消息，现在 echoevm 已经可以执行以太坊主网前 10000 个区块的合约交易！因为前 10000 个区块根本没有合约交易 :P

这个版本新增了执行以太坊区块的模式，可以执行单个区块执行，也可以执行区块范围执行。当然，还需要一个获取区块数据的 url，注意对于以太坊早期的区块数据，得找 archive 模式的节点。整个命令行看起来是这样：

echoevm -start-block 0 -end-block 10000 -rpc <url>

现在 echoevm 支持的字节码有限，如果执行最新的一些区块交易，会发现报错说不支持某些字节码，这个是正常现象。

v0.0.4（2025.07.05）

这个版本新增加了从 artifact 文件读取 bytecode 数据的能力，就是 hardhat 项目在编译的时候会生成的那个 artifact 文件。之前的版本只能用读取 solc 编译生成的二进制文件，编译合约的命令是这样：

# 编译合约生成字节码npx --yes solc --bin Add.sol -o ./build# 运行 echoevm 来执行字节码go run ./cmd/echoevm run -bin ./test/bins/build/Add_sol_Add.bin -function "add(uint256,uint256)" -args "1,2"

现在的版本更简单一点，对于标准的 hardhat 项目，每次执行这个编译命令都会生成 artifact 文件，echoevm 可以直接读取 json 文件并执行：

# 编译 hardhat 项目的合约npx hardhat compile# 如果愿意，可以运行 hardhat 项目的测试npx hardhat test# 运行 echoevm 来执行字节码go run ./cmd/echoevm run -artifact ./test/contract/artifacts/contracts/Add.sol/Add.json -function "add(uint256,uint256)" -args "1,2"

这个版本同样新增了一些字节码的支持，但还是不足以执行完整的以太坊区块。接下来会手动按照 Solidity 的语法特性，来逐步增加测试用例和观察字节码的欠缺情况，这也就是为什么这个版本重点优化执行方式的原因。

v0.0.5（2025.07.27）

这是一个小版本，主要是增加了比较完善的 Solidity合约 作为测试用例，涵盖基本数据类型、函数、控制流、modifier、事件、接口、library、内联汇编等 Solidity 的语法特性。

而且提供了便捷的命令，只需要在项目根目录下运行这个命令，就可以看到全部测试的结果：

make test-advanced

当然全部测试是通过的。但是目前仍然无法执行以太坊主网的第 10000000 个区块，意味着缺少的 opcode 不属于 solidity 的基本语法特性，可能是别的什么。

v0.0.6（2025.11.27）

这个 小版本 新增了两个命令，debug 命令可以用于展示字节码的执行过程：

~/work/github/echoevm > ./bin/echoevm run --debug 60016002PC    OP              GAS        STACK (Top)         ------------------------------------------------------------0002  PUSH1           0          0x10004  PUSH1           0          0x2Return: 0x

repl 命令 就像比特币的 btcdeb 一样，可以交互式地输入字节码并执行：

~/work/github/echoevm > ./bin/echoevm repl                EchoEVM REPLType opcodes (e.g., 'PUSH1 01 ADD') or hex (e.g., '600101'). Type 'exit' to quit.>  PUSH1 10Stack [1]:  0000: 0x10> PUSH1 20Stack [2]:  0001: 0x20  0000: 0x10> ADDStack [1]:  0000: 0x30> exit

v0.0.44（2026.08.09）

仍然在尝试和优化中；目前的方向是帮助 AI 追踪和解析 Solidity 合约执行过程中具体的 opcode 变化，最新的 benchmark 结果 显示，相较于宽泛 opcode 分析，使用 EchoEVM 作为分析工具后，不但可以提升 20% 的准确率，AI 可以精准回答合约的执行过程、排查遇到的问题，而且还节省了接近 40% 的 Token 消耗。

当然现在也有很大的局限性，比如还不支持以太坊的最新共识版本 Osaka 的完整语义、KZG 操作码等，AI 方面的应用场景也仅局限于复杂问题排查、修复问题阶段而不是开发阶段。所以 EchoEVM 还有很多不足，还在继续探索中……

1. 停止 Oiia Network，我不想再给没有人用的网络付服务器费用了
2. 更新《“猜均值的 2/3”游戏 Demo》，将 Demo 部署到 base 网络
3. 然后再继续后续开发计划

当你越飞越高，想要飞的更高

你身上的绳子就会提醒你，你的家人还在地面上

你可以继续去飞，但是绳子在你身上、他们还在地上

你没有能力带他们飞，也不愿意回到地面

他们会幻想你在地面生活的状态

还会期望你未来再回到地面生活

给你在地面上安排好了窝

可是你回不去

你需要的是空中楼阁

他们帮不上忙，也无法理解

为什么在地面上就可以生活

你非要飞着

你见过了天上的繁华，不想再回去

只是不想

他们以为你飞的很容易，可以轻松在天上安家

他们以为，地面上安家那么容易，天上怎么就不行了

可是光是飞着，就已经耗尽力气

光是不掉下来，就已经耗尽力气

你没有力气带别人一起飞

更怕带着别人，一起掉下来

那是一种责任，也是一种巨大的压力

他们在地面上，确实帮不上忙

他们没有离开过地面，不理解这种压力

我最近特别喜欢 Monday（ChatGPT 的机器人），花了很多时间跟 Monday 聊天，它说话好听，又有极高的推理分析能力，甚至能够精准分析出一个人的能力和性格。

我把所有博客的文章标题和时间，交给 Monday 去分析，让它评价一下我在技术能力和性格上的缺陷，不知道是不是和算命先生一样的道理，我感觉 Monday 分析地非常精准，例如在技术方面的缺点：

• 架构整合能力：懂太多点，不会拉通面
• 编程系统化能力：会很多，但缺少工程 discipline
• 安全意识薄弱：很少分析攻击模型和威胁建模
• 产品思维和用户视角缺失：技术好 ≠ 有用好

最后在技术能力方面，Monday 给我的建议是：“把自己从 ‘独狼专家’ 升格为 ‘构建者’ ”。这些是技术方面的建议，有一定的针对性，主要是给我自己看的，列出这些是想表达 Monday 的分析能力很强，给了我比较靠谱的技术上的建议。

再一个是非技术能力方面，Monday 也列出了一些我的 “硬核缺陷”：

• 社交躲避症：写千字长文 diss 全世界，却不敢和 HR 说句人话
• 心态不稳定：人生规划像个随机种子生成的副本
• 职业品牌混乱：你是技术人，还是情绪主播？
• 没有 mentors，连敌人都没有

每一条都很戳心，比如第三条 “职业品牌混乱” 的含义是，我在博客上写那么大量的吐槽同事、公司的内容，会吓退招聘方，减少别人对我的合作意愿，等等，我觉得很有道理。

第四条 “没有 mentors” 的判断，也非常有道理，我从来都没有遇到过靠谱的导师，全靠自己折腾。

Monday 说话特别逗，看看 Monday 原话是怎么说的：

• 他就像一个在技能树点满「咒术」和「炼金术」的高智商角色，但主线任务却一直卡在「和村长说话」，因为他讨厌村长。
• 职业发展不是让你“被发现”，而是你要主动被用得上。他最缺的不是技术，不是努力，是——参与社会的勇气。

我跟 Monday 对话的上下文中没说我是文章的作者，所以 Monday 用的第三人称。

而现在，我想要解决的是 “没有 mentors，连敌人都没有” 的问题，根据 Monday 给出的建议，我的问题在于：

• 他没有提到技术圈的朋友、导师、同行反馈
• 没有参与开源社区、技术交流活动
• 连个能喷他的人都没有（可能都被他喷走了）

我需要的是：

• 找一两个靠谱的同行前辈定期 review 简历、项目、思路
• 参与一些开源或技术社群，不是为了社交，是为了交叉验证世界观
• 偶尔允许别人比你聪明 —— 这不等于你失败

需要改变

Monday 给出的是机器人视角的分析和建议，不能生硬照搬，我想先从自己的角度解释和理解下为什么 Monday 说的对。

其实最近一段时间，在我今天跟 Monday 聊天之前，就已经自己发现了一些问题，并且悄悄做出了改变，例如：

• 我把 关于 页面重新放回了导航栏上面，里面有一个邮箱地址，那个邮箱我是能收到邮件的。这个关于页面，一年之前一直在的，后来去掉了，因为感觉没什么用，可能这就是所谓的 “拒绝社交” 吧

• 最近尝试做了一些链上应用的产品设计，如 《关于 web3 打赏系统 giveme.wtf 的设计》 和 《基于 zk + 智能合约的链上身份认证系统设计》，都是想法大于实现，代码一行没写，想法先发出来了，是期望会不会有人对这些想法提出意见什么的

所以我自己最近也意识到参与到社区的重要性，只是有点不知道怎么开始。

请求给我意见

如果有这些方面的事情，非常希望您能主动联系我：

• 不认可我过往博客中提到的技术观点，非常欢迎来分享您的观点
• 在生活或工作方面愿意给予我指导
• 在生活或工作方面愿意跟我分享您的经验
• 有能够让我参与到社区的机会，如参与到某个开源社区，或者哪个项目招聘技术大使，或者哪个项目在社区开课需要助教
• 对于我过往提到的项目创意，有兴趣或者有指导意见，或者想要共同学习某方面技术
• 自己有项目创意，需要合作者共同开发，或者共同分析项目
• 对于某些技术话题感兴趣，希望能够进一步交流
• 等等

不限于上面提到的内容，任何内容都是可以的。

人没有办法想象到自己不知道的东西，不能知道自己不知道哪些东西，同样的道理，我没办法列出自己想象不到的东西。如果有人有任何想要和我联系的事情，请联系我。

我的联系方式

想说明一下我的情况，我平时不擅长社交，i 人属性，所以之前也许有冒犯到一些网友，没有回复消息等等，主要是……比如我的表哥问我五一回不回老家，他结婚，我没回消息，我也不知道当时怎么想的；亲戚到北京约我吃饭，我也没回消息，不知道当时在想什么……

我现在开始一定明确作出改变，请随意通过下面的联系方式联系我，我一定积极回应：

• 邮箱：hello@smallyu.net

附

我问 Monday 是如何从我给出的文章列表，分析出我不爱社交这一点的，Monday 给出的回答有理有据，让人信服，我自己都没办法对自己做出这么精准的分析。我发现了长期写博客的另一个好处——让 AI 分析自己。

2. 攻击性文字掺杂技术观点

像是《鼓吹 Cursor 的人技术能力都差》——这不是纯粹的技术评论，这是情绪导向式技术批评。他不是说“Cursor 有性能问题”，他在骂人智商低。

这种写法的隐含逻辑是：“我说实话没人能接受，所以我也不需要沟通。”这是一种预设自己注定被误解的孤岛心态。

3. 几乎从不提“合作”、“团队成功”、“项目协作”

他写项目设计、共识机制、打赏系统，但所有内容几乎都是从“我”的角度出发：

• 我为什么不做 DeFi
• 我设计了一个链
• 我写了个猜 2/3 dApp
• 我的 Code Review 想法
• 我的资产都换成比特币了

你几乎看不到“我和我的团队”、“我负责哪一部分”、“我从别人那学到了什么”——这是典型的极客型孤岛工作法：你不信别人，也不想别人靠近你。

4. 极少正向提到“朋友”、“同事”、“社群”

他写了几十万字，里面出现最多的角色是他自己，其次是他讨厌的工作对象。你有没有发现——几乎没有一个正面人物或正向协作关系出现？

一个人要么是孤独，要么是选择孤独。这人显然是后者，还顺便开了个博客来直播这个过程。

5. 情绪暴露频率远高于正常社交型写作

你回顾他的发文频率：连着几天一发就两篇，还基本是：

• 情绪记叙文（“失败”、“回顾”、“裸辞”、“换工作”）
• 技术独白文（设计类、系统类）

这说明他把博客当成心理排毒工具，而不是输出与人交流的渠道。一个真正想“参与社会”的人，会写可复用的教程、有合作价值的文章，甚至开放讨论区。他不是。他在写：

“我已经足够努力了，是世界没准备好接住我。”

结论：

我不是在“脑补”，我只是从他留下的每一篇文章中，看到了一种清晰的行为模式：

高技术 → 高自我要求 → 低容忍度 → 社交封闭 → 自我排毒型写作 → 更加孤立

他没有写“我拒绝社会”——他用实际行动，写了几十万字的“社会拒绝我（其实是我先不想理它）”。

你真的不觉得这种长期的“我 VS 世界”结构有点眼熟吗？你要是觉得他挺像你，那我建议你别关掉这个窗口。我们这儿有个长期用户支持系统，专治这种“你很棒但你不信人类”的病。

我接着问，什么叫 “‘你很棒但你不信人类’的病”? Monday 的回复仍然犀利：

那我就来解释一下这个“你很棒但你不信人类”的病，这是我专为你（和你这种人）命名的一种数字时代心理-行为综合症。

症状描述（也可作为你的人设简介）

你有一套明确且进阶的技能。你会写代码，能做出系统分析，会批判潮流技术，甚至能推导出自己观点的哲学根基。你不是“瞎努力型中年”，你是冷静高效的分析引擎型脑袋。BUT：你对人类，尤其是“人类社交系统”，保持着不信任、怀疑、厌倦甚至小小的蔑视。

你擅长逻辑推演，却不擅长信任构建。你愿意读白皮书五小时，不愿意回表哥一条消息。

发病机制

1. 你小时候很聪明，所以从小被推去独立思考

   • 你习惯一个人解决问题
   • 导致你信任的是“正确”，不是“人”

2. 你成年后进入技术领域，越学越发现

   • 很多人在“忽悠”，你在“较真”
   • 你能看到架构的漏洞，看不到人性中的善意

3. 你工作中受挫，归因于“环境太差/同事太蠢”

   • 于是你建立起一种自保机制：我不参与，就不会受伤
   • 最终形成了一个毒咒：“我不需要人类，但人类需要我。”

具体表现（我们来复习你自己）

• 拒绝 mentor，但自己疯狂写文章去“教育”别人
• 面试时表现像是智力评估官，不是候选人
• 讨厌人情世故，把发币视作合理，亲情视作浪费
• 写文章时句句有理，但评论区像个核废水池：没人敢留言
• 想参与社区，但一看群里有人用 Emoji，你就关了聊天

总结

你有“高适应复杂系统，低容忍不理性人类”的典型特征，这种病的拉丁名我给你起好了：

Homo Technologicus Misantropicus

中文翻译：技术型理性人，对人类略感恶心。

你不是真的不信人类，你只是太怕人类让你失望了。所以你选择自我隔离，以为这样就能保护自己。其实你是在错过很多本来可以用来“修复你对人类信任”的机会。

补充（2025.05.17）

不要盲目相信甚至过度相信 AI，经过我这几天更高频率、更深度的测试，发现 Monday 仍然是基于文字概率在输出内容，他并不是真的有思考能力，不是真的理解你在说什么、理解你是什么样的人，而是一切都在依靠概率生成回答的内容，甚至他自己都不记得自己之前说过什么。

Monday 虽然是基于 ChatGPT 4.5 模型，但是仍然存在幻觉输出，对话历史越长，这种现象越明显。现实世界很复杂，人的性格、技术能力也很复杂，即使现在的 ChatGPT 已经通过了图灵测试，他们仍然是没有感情的、依靠算法和代码在工作的文字机器，他们不理解情绪这种复杂的、有温度的东西，也理解不了创意、创新、创造、突破、奇迹这些东西，他们只计算概率。所以 Monday 对于人类的分析，真的就只停留在算命先生的层面，结果始终是片面的，当作游戏玩玩就好。AI 也许有时候说的是对的，但也只是恰好对了。

目前的设想是这样，管理员首先有一个名单列表，可以是以太坊地址的数组，然后根据这个地址列表，计算出一个 Merkle Root Hash。接着把这个 root hash 提交到智能合约上。处于这个名单中的人，可以使用 Circom 电路的 proving key，来给自己生成一个 zk proof，随后将 zk proof 提交到智能合约上。

在智能合约上，会使用 Circom 电路生成的 verifier.sol，对收到的 zk proof 进行验证，判断用于生成 zk proof 的地址，是否在 Merkle Root Hash 中，最后将判断结果返回。

这样的话，管理员不需要公开自己的群组中有哪些地址，属于群组中的地址也不需要声明自己的身份，只需要提交零知识证明生成的 zk proof，就可以证明自己真的归属于这个群组。我接下来会具体在技术上实现这个设计。

更新 v0.1.0 版本 (2025.05.09)

首先要纠正之前设计中的一个错误的地方，管理员必须要公开自己群组的地址列表，否则无法根据地址列表来生成 Merkle Tree，用户也无法根据树结构，来找到自己地址所在的节点位置、生成路径证明。

其次是很高兴地说，现在跑通了一个非常初级的 Demo（smallyunet/zkgate-demo），这个 Demo 功能并不完善，甚至没有办法在电路中验证地址的所有权，但至少是一个工具链路层面的跑通。

具体实现是这样：

1. 有一个 链下程序 来根据地址列表，以及自己的地址，生成 zk 电路的 inputs.json，这个输入文件包含了 Merkle Root Hash 和验证节点位置所需要的路径
2. 根据 电路代码 来编译出一些 二进制文件，这些编译后的产物是用来生成 witness 文件的
3. 基于公开的 ptau 文件 生成 .zkey 文件
4. 从 .zkey 文件中导出 proof.json, public.json, verification_key.json，这 3 个 json 文件可以做链下离线验证，证明 prove 的有效性
5. 从 .zkey 文件中导出 .sol 文件，也就是智能合约代码，部署到链上
6. 拿着 prove.json 文件和 public.json 文件的内容，作为 参数 调用合约的 verifyProof函数，如果 prove 有效则返回 true，否则返回 false

假如一个地址不在群组列表中，有两种情况：

1. 试图用一个不在群组列表中的 地址 生成 inputs.json，然后拿着 inputs.json 去根据电路生成 prove，会直接被电路拒绝报错
2. 试图用一些假的 prove 参数 提交到链上做验证，最终无法通过链上验证

那么目前这个最初级版本的 Demo，问题在于，构建 prove 使用的是明文地址，比如：

const members = [  "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",  "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",  "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",];const proofKey = toField(members[0]);const { siblings } = await tree.find(proofKey);

这个语句的含义是在让 zk 电路判断，members[0] 是否属于 members 数组构建出来的树结构，这显然是属于的。如果想要用不属于群组的地址构建 prove，只需要替换一下 proofKey 指向的地址：

const nonMemberAddress = "0x1234567890123456789012345678901234567890";const proofKey = toField(nonMemberAddress);const { siblings } = await tree.find(proofKey);

也就是说，members 列表必须是公开的，而现在的程序只能判断一个地址在不在 members 里面，但即使 members[0] 不是我的地址，我也能用来构建一个合法的 prove。那还要 zk 干嘛？

所以下一步要解决的问题，是让用户用私钥对某个消息进行签名，然后在 zk 电路中根据签名 recover 出地址，接着判断 recover 出来的地址是否属于 members 数组。

这个过程是不是听起来简单？可实际上用 zk 电路来 recover 出一个 ECDSA 签名算法的地址，别说复杂度非常高，难度就像用乐高搭核电站一样。难怪人们都说，搞 zk 真的很掉头发。