菜单
文章 ETH

6.ETH-挖矿算法

beautifulremi

beautifulremi

• 阅读本文需 28 分钟

在比特币网络中，ASIC矿机的出现使得拥有大规模、高算力硬件的矿工占据了绝对优势，普通用户使用CPU或GPU几乎无法参与挖矿。为避免重蹈覆辙，新加密货币的开发者设计了新的挖矿算法。其特点是内存困难（Memory-hard）。这意味着该算法在进行哈希计算时，不仅需要大量的计算能力，还需要极大的内存带宽和容量。

莱特币-Scrypt算法

Scrypt 算法由加拿大计算机科学家科林·珀西瓦尔（Colin Percival）于2009年发明，它与比特币使用的 SHA-256 算法在设计哲学上有本质的区别。它不仅仅是一个简单的哈希函数，而是一个可调节难度的密钥派生函数 (Key Derivation Function, KDF)，其设计精髓在于通过消耗大量内存来增加破解难度。

核心参数

在开始挖矿之前，需要先设定好关键参数。Scrypt 有三个关键参数来控制其挖矿的难度和资源消耗：

  1. N (CPU/Memory Cost) - 内存成本参数:
    • 这是最重要的参数，直接决定了算法需要消耗多少内存。
    • 它必须是2的幂（例如 1024, 2048, 16384）。
    • 内存占用量与 N 成正比。N 越大，需要的内存就越多，计算时间也越长。这是实现“内存困难”的核心。
  2. r (Block Size) - 块大小参数:
    • 这个参数决定了 ROMix 函数（下面会讲到）中混合块的大小，同时也影响着内存访问的模式和粒度。
    • r 的值会影响 N 对内存占用的乘数效应。总内存占用约为 128 * N * r 字节。
  3. p (Parallelization) - 并行化参数:
    • 这个参数决定了可以并行计算多少个独立的 ROMix 过程。
    • p 越大，意味着可以通过增加硬件投入（多核CPU或多台机器）来有限地加速计算。对于加密货币挖矿，这个值通常设为1，以最大化单个任务的难度，抵御大规模并行硬件（如ASIC）的优势。

整个算法可以分为两个主要阶段。

第一阶段： Salsa20/8 Core

这个阶段的目标是先将输入的“密码”（Password）和“盐值”（Salt）初步混合，并扩展成一个更长的数据块，为第二阶段的大规模内存操作做准备。

这一步通常使用一个成熟的密钥派生函数 PBKDF2 (Password-Based Key Derivation Function 2) 来完成。

  1. 输入: 密码（在莱特币中，这是区块头信息）、盐值（同样来自区块头）。
  2. 过程: 使用 HMAC-SHA256 作为伪随机函数，对密码和盐进行 p * 128 * r 字节长度的扩展。
  3. 输出: 得到一个长长的字节数组，我们称之为 B。

第二阶段：ROMix

这是 Scrypt 内存消耗的来源。ROMix 的意思是“只读内存混合”（Read-Only Memory Mix）。它会对第一阶段生成的 B 数组进行一系列极其耗费内存的变换。

ROMix 过程可以分解如下：

  1. 创建巨大的内存向量 V:
    • 算法在内存中申请一块巨大的空间，用来存放一个向量（可以理解为一个大数组） V。V 的大小由参数 N 决定，它将包含 N 个元素。
    • V 的总大小约为 128 * N * r 字节，这正是 Scrypt 内存消耗的直接来源。对于莱特币，N=1024, r=1, p=1，所以内存占用约为 128KB。虽然看起来不大，但在需要极高速运算的芯片上集成大量这种独立的128KB高速RAM单元，成本会急剧上升。
  2. 顺序填充 V:
    • 算法将第一阶段的输出 B 分割成 p 块。
    • 对于每一块，算法会把它作为初始值，然后通过一个名为 BlockMix 的内部函数进行迭代计算，依次生成 V[0], V[1], V[2], ..., V[N-1]。
    • BlockMix 本身基于一个名为 Salsa20/8 的快速流密码，它能很好地混合数据，确保数据的随机性。
    • 到目前为止，内存访问还是顺序的，比较简单。
  3. **伪随机内存访问:
    • 当 V 被完全填充后，Scrypt 开始了它最关键的操作。
    • 算法会进行 N 次循环。在每一次循环中： a. 它会将当前的数据块进行哈希，得到一个整数 j。 b. 这个整数 j 会被用来计算一个伪随机的内存地址，指向向量 V 中的某个位置（V[j]）。 c. 算法会跳转到这个内存地址，读取 V[j] 的值。 d. 将读取到的 V[j] 与当前的数据块再次进行 BlockMix 混合，生成一个新的数据块。
    • 这个过程重复 N 次，意味着计算机必须在巨大的向量 V 中进行 N 次快速、随机的“横跳”读取。
  4. 输出:
    • 经过 N 次“横跳”混合后，得到一个最终的数据块。这个数据块就是 ROMix 函数的输出。

“内存困难”的关键就在于上述第3步：伪随机内存访问。

  • 为了能快速完成这 N 次“横跳”读取，整个巨大的向量 V 必须完整地存放在高速的RAM（或GPU的显存）中。
  • 如果试图将 V 存放在慢速的硬盘或SSD上，每一次读取都会产生巨大的延迟（所谓的 seek time），整个计算过程会变得极其缓慢，毫无竞争力。
  • 这就迫使所有计算参与者都必须配备足够大的高速内存。对于ASIC设计者来说，在芯片上集成GB级别的SRAM（静态随机存取存储器）成本高昂且不切实际，而使用外部DRAM又会受限于带宽瓶颈，难以达到极致的速度优势，从而达到了“抗ASIC”的目的。

ROMix 计算完成后，会得到一个最终的数据块。这个数据块会再次被送入第一阶段使用的 PBKDF2 函数，进行最后一次哈希计算，从而派生出最终的密钥（或在加密货币中，是用于难度比较的最终哈希值）。

注：盐值

盐值是为了对抗“彩虹表攻击”（Rainbow Table Attack），保护即使用户使用了弱密码或相同密码，其哈希值也不会轻易被破解。

  • 问题所在：如果黑客获取了一个数据库，里面存有大量用户的密码哈希值。由于很多人会使用相同的简单密码（如 "123456", "password" 等），这些密码的哈希值都是固定不变的。
  • 彩虹表：黑客可以事先计算好海量常用密码的哈希值，并存成一个巨大的查询表，这就是“彩虹表”。当黑客拿到你的密码哈希值后，他不需要去破解，只需去查表，如果表里有匹配的项，他瞬间就能知道你的原始密码是什么。

盐值（Salt）是一个在哈希计算之前，被附加到原始密码上的随机字符串。

  • 工作流程：
    1. 当用户注册时，系统不仅记录他的密码，还会为他随机生成一个独一无二的盐值（例如 A7f#3d）。
    2. 系统将这个盐值和用户的原始密码拼接在一起（例如 "123456" + "A7f#3d"）。
    3. 然后对这个拼接后的新字符串进行哈希计算。
    4. 最后，将哈希值和这个公开的盐值一起存入数据库。
  • 效果：
    • 对抗彩虹表：现在，黑客的彩虹表完全失效了。因为他的表是基于 "123456" 计算的，而数据库里存的是 "123456" + "A7f#3d" 的哈希值，两者完全不同。黑客必须为每一个盐值重新单独计算一张彩虹表，这在计算上是不可行的。
    • 保护相同密码：即使用户A和用户B都使用了 "123456" 作为密码，由于系统为他们生成了两个不同的盐值，他们最终存入数据库的哈希值也是完全不同的。这使得黑客无法通过对比哈希值发现“撞密码”的情况。

注：ROMix的数据变化

在 Scrypt 的 ROMix 核心阶段，伪随机内存访问循环开始之前，用作输入的“最初的数据块”是顺序填充巨大内存向量 V 时生成的最后一个数据块。

ROMix 的流程：

  1. 顺序填充阶段：算法首先在内存中创建了一个巨大的向量 V。然后，它使用一个初始块 B，通过 BlockMix 函数迭代计算，生成并顺序填满了整个向量 V（即 V[0], V[1], V[2], ..., V[N-1]）。
  2. 获取初始块：在完成第 N-1 个元素的填充后，BlockMix 函数会输出一个结果。这个结果就是用来启动下一阶段的**“最初的数据块”**（我们称之为 X）。
  3. 伪随机访问阶段：
    • 循环 N 次开始。
    • 第1次循环：将 X 作为输入，计算出一个伪随机地址 j，然后从 V[j] 读取数据，并与 X 混合，生成新的 X。
    • 第2次循环：使用上一步生成的新 X，计算出另一个伪随机地址 k，从 V[k] 读取数据并混合……如此循环往复。

所以，这个“最初的数据块”并不是从 V 中任意挑选的，而是上一个阶段（顺序填充）计算流程自然产生的结果，起到了承上启下的作用。

注：伪随机函数

在莱特币中，必须使用“伪随机” (Pseudo-random) 而不是“真随机” (True-random)，这是为了保证结果的确定性和可验证性。

在密码学和区块链中，所有计算都必须是确定性的。这意味着对于完全相同的输入，无论何时何地，由谁来计算，都必须得到完全相同的输出。

  • 对于密码验证：当你输入密码登录时，系统必须能用相同的盐值和算法，计算出与数据库中存储的完全一样的哈希值，才能验证成功。
  • 对于区块链挖矿：网络中的所有节点都必须能够独立验证一个矿工找到的Nonce是否正确。他们需要使用相同的区块头信息和那个Nonce，运行完全相同的Scrypt算法，并验证最终结果是否小于目标难度。

缺陷与不足

1. ASIC 抗性的最终失败

这是 Scrypt 算法最核心、也是最广为人知的缺陷，并且这个缺陷最终也导致了挖矿中心化。

  • 初衷：Scrypt 通过“内存困难”的设计，旨在让制造专用集成电路（ASIC）矿机的成本和难度远高于使用通用图形处理器（GPU），从而让普通人也能参与挖矿，维护网络的去中心化。
  • 现实：这个目标只在短期内实现了。对于像莱特币这样具有足够高市值和流动性的加密货币，其挖矿利润为硬件制造商提供了强大的经济激励。只要有足够的利润空间，就一定会有公司投入巨资研发专用硬件。
  • 结果：大约在2014年，市场上开始出现第一批商用 Scrypt ASIC 矿机（例如宙斯矿机 ZeusMiner）。这些矿机的算力和能效比远超同期最顶级的GPU，迅速终结了GPU挖矿的盈利能力。

2. 验证相对沉重

对于莱特币，SPV 客户端为了验证区块头的工作量证明，必须亲自执行一次 Scrypt 算法。

  • 内存和计算消耗：正如我们之前讨论的，Scrypt 的核心是“内存困难”。即使是验证过程（参数 N 相对固定，例如 N=1024），也需要在设备的 RAM 中分配一个向量（例如128KB），并进行上千次的伪随机内存访问和计算。
  • 带来的问题：
    • 资源消耗更高：相比于比特币几乎可以忽略不计的验证开销，Scrypt 的验证过程会占用更多的 CPU 时间和 RAM。对于资源极其有限的设备（如低端智能手机、物联网设备、硬件钱包），这会带来明显的性能负担，消耗更多电量。
    • 同步速度更慢：当一个 SPV 钱包首次启动或长时间离线后重新连接时，它需要下载并验证成千上万个区块头。由于每一个区块头的验证都相对缓慢，整个同步过程会比比特币的 SPV 客户端慢得多。
    • 提高了轻客户端的门槛：Scrypt 的“重量”实际上提高了运行一个真正独立的轻客户端的硬件门槛，这与去中心化的精神相悖。如果设备的性能不足以流畅地自行验证，用户可能被迫更信任钱包服务商提供的中心化服务器，从而削弱了 SPV 的安全性。

3. “抵抗”策略的内在矛盾与不稳定性

面对 ASIC 的出现，一些社区试图通过不断升级算法来维持抵抗力，但这本身也带来了问题。

  • 算法“军备竞赛”：一些项目尝试推出 Scrypt 的变种，如 Scrypt-N。这种算法的内存需求参数 N 会随时间自动增加，理论上可以持续领先于 ASIC 的研发周期。
  • 硬分叉风险：每一次算法的修改都需要通过硬分叉（Hard Fork）来完成。这不仅给开发者带来巨大工作量，也给社区带来了分裂的风险和网络的不确定性。最终，这种“猫鼠游戏”被证明是不可持续的，大多数项目最终放弃了抵抗。这表明，试图通过不断改变规则来对抗市场规律是一种脆弱的策略。

4. 验证时间与安全性的两难困境

Scrypt 算法的一个内在缺陷是，增强其安全性的手段（即增加内存需求）会损害网络的性能。

  • 提高 N 值的代价：理论上，可以通过大幅提高 Scrypt 的内存成本参数 N 来让当前的 ASIC 失效。
  • 负面影响：然而，N 值的增加不仅会拖慢矿工的挖矿速度，同样也会显著增加网络中每一个普通节点验证区块所需的时间和内存。如果验证一个区块需要很长时间，网络的交易确认速度就会变慢，运行全节点的门槛也会变高，这同样会损害网络的去中心化和可用性。设计者必须在所谓的“ASIC 抗性”和网络整体性能之间做出艰难的权衡。

以太坊-Ethash算法

整个算法可以分为两个主要阶段：准备阶段（生成DAG）和挖矿阶段（计算MixHash）。

第一阶段：准备工作（DAG）

在寻宝游戏开始前，系统需要先生成一张巨大且复杂的藏宝图，这张图就是DAG（Directed Acyclic Graph，有向无环图）。这张图不是永久不变的，它会定期更新，大约每30,000个区块（约100小时）更新一次，这个周期称为一个“Epoch”。

DAG的生成过程本身就很复杂，旨在防止有人能“即时生成”一张小地图来作弊。它分为两步：

第一步：生成Cache

输入: Epoch 号（一个从0开始递增的整数）。

  1. 计算种子哈希 (Seed Hash)
    • 具体数据: 一个 Epoch 的长度被定义为 30,000 个区块。根据以太坊平均13-15秒的出块时间，一个Epoch大约持续 4-5天。
    • 流程：从一个32字节的全零哈希开始，对其进行30,000次 Keccak-256 (SHA3) 哈希，得到Epoch 1的种子。要计算Epoch 350的种子，就必须在Epoch 349的种子上再进行一次哈希。这个过程确保了种子的生成是顺序且耗时的。
  2. 初始化与迭代填充缓存
    • 具体数据: 缓存的初始大小（Epoch 0时）为 16MB。
    • 增长规律: 每经过一个Epoch（30,000个块），缓存的大小会线性增长 128KB。
    • 流程：系统首先根据当前Epoch号计算出缓存所需的确切大小，并申请内存。然后，将种子哈希作为cache[0]，并通过 cache[i] = keccak256(cache[i-1]) 的方式迭代填充整个缓存。
  3. 最终置换与“乱序”处理
    • 流程：在缓存被初步填充后，算法会对其进行3轮整体的“乱序”置换。这个过程使用 FNV 快速哈希函数混合数据，确保缓存内每个元素都与其他众多元素产生了复杂的依赖关系，为下一步生成DAG提供高质量的“原料”。

这个设计确保了矿工必须事先花费时间和资源存储好完整的、当前Epoch对应的DAG文件，才能开始挖矿。

第二步：生成DAG

输入: 上一步生成的完整缓存（Cache），以及要计算的数据项索引 i。

第一阶段：初始化混合值（Mix）

在进入核心的64次循环之前，我们需要一个起始点。这个起始点被称为“混合值”（Mix），它本身就是一个64字节的数据块。

  1. 确定起始数据：算法首先从缓存（Cache）中，根据我们想要生成的DAG项的索引 i，定位到一份初始数据。
    • 读取位置：i % (cache_size / 64)。用 i 对“缓存中的元素总数”取模，得到一个在缓存范围内的索引。
    • 读取内容：从这个位置读取一个64字节的数据块。
  2. 生成初始“混合值”：将上一步读取到的64字节数据作为我们的第一个“混合值”mix。这个mix就是进入核心循环前的初始状态。

第二阶段：核心混合循环（The 64 Rounds）

这是整个流程最关键的部分。它会迭代64次，我们把每一次循环的计数器称为 j（从0到63）。下面是单次循环（第 j 次）内部的精确步骤：

步骤 2.1：计算伪随机的缓存地址 p

这是为了决定“下一步要去缓存的哪个位置取cache数据”。这个地址的计算必须是伪随机且依赖于当前状态的。

  • 输入：
    1. 当前的“混合值”mix（64字节）。
    2. 当前的循环次数 j（一个整数）。
  • 计算过程：
    1. 算法首先将 mix 中的第一个32字节整数与 j 进行异或（XOR）操作。这样做是为了确保即使 mix 值碰巧重复，每一次循环的输入也是独一无二的。
    2. 然后，对这个异或后的结果使用 FNV（Fowler–Noll–Vo） 函数进行哈希。FNV是一种速度极快的非加密哈希函数，非常适合在这种需要快速混合数据和生成伪随机数的场景下使用。
    3. FNV哈希的结果会得到一个整数，将这个整数对 (cache_size / 64) 取模，从而得到一个在缓存有效范围内的索引，我们称之为地址 p。
  • 目的：这一步的输出 p 就是我们下一步要去缓存中“取货”的地址。由于 p 依赖于 mix，而 mix 在每一轮都在变化，所以这64次访问的地址序列是完全不可预测的。
步骤 2.2：从缓存中读取数据
  • 有了地址 p，算法会直接访问缓存（Cache）。
  • 它会从 cache 的第 p 个元素位置开始，连续读取 128字节 的数据。（在Ethash的实现中，通常是读取两个相邻的64字节数据块）。
  • 我们将这128字节的数据称为 data_from_cache。
步骤 2.3：更新混合值（The Mixing）
  • 输入：
    1. 当前的“混合值”mix。
    2. 刚刚从缓存中读取的 data_from_cache（128字节）。
  • 计算过程：算法再次使用 FNV 函数，但这次是将 mix 和 data_from_cache 作为输入进行混合。FNV函数会将这两个输入值以一种复杂的方式结合，生成一个新的64字节哈希值。
  • 输出：这个新的哈希值将覆盖旧的mix，成为下一次循环（j+1次）的输入。

以上三个步骤（计算地址 -> 读取数据 -> 更新混合值）会精确地重复64次。

第三阶段：最终处理

当64次循环全部结束后，我们会得到一个最终的、经过了64次复杂混合的“混合值”mix。

但这还不是最终的DAG数据项。

  1. 算法会将这个最终的 mix 值再进行一次压缩哈希（在Ethash中是一种特定的Keccak哈希变体）。
  2. 这个哈希函数的输出，一个64字节的数据块，才是我们最终想要的 DAG[i]，整个DAG就是这样生成的。

第二阶段：挖矿与验证

当矿工的GPU加载了完整的DAG文件后，挖矿过程才正式开始。

  1. 初始哈希（Initial Hash）
    • 矿工将区块头信息（不包含 mixHash 和 nonce）和一个随机选择的nonce（一个64位的数字）打包在一起。
    • 对这个打包好的数据进行Keccak-256（SHA3）哈希计算，得到一个初始哈希值。
  2. 循环计算“混合哈希”（MixHash）
    • 这是Ethash算法最核心的部分，也是体现其“内存困难”的地方。
    • 算法会利用上一步的初始哈希值和nonce，作为“指针”，去访问整个DAG中的特定位置。
    • 它会进行64轮循环计算。在每一轮中：
      • 算法会根据上一轮的结果，伪随机地从DAG中选取多个（具体来说是128个字节）数据页。
      • 将这些从DAG中读取的数据与当前正在计算的“混合值”（mix）进行复杂的混合运算。
    • 关键点：由于每一轮都需要从巨大的DAG中读取伪随机位置的数据，这对内存的带宽和延迟提出了极高的要求。如果内存速度不够快，或者容量不足以装下整个DAG（导致需要从慢速的硬盘读取），挖矿效率将大打折扣。这就是为什么拥有高带宽显存的GPU在Ethash挖矿中表现出色的原因。

最终验证

  • 经过64轮循环后，会得到一个最终的mixHash。
  • 然后，算法将这个mixHash和初始哈希值再次进行一次哈希计算，得到一个最终结果值 Result。
  • 矿工将这个Result与当前网络的目标难度（Target Difficulty）进行比较。
    • 如果 Result 小于 目标难度，这个nonce就是正确的“答案”。矿工成功挖到了这个区块，可以将它广播到全网，并获得奖励。
    • 如果 Result 大于或等于 目标难度，则寻宝失败。矿工需要更换一个新的nonce，然后重复上述第1至3步，直到找到正确的答案为止。

Ethash算法的特性

  • 双重依赖：挖矿（计算MixHash）依赖于DAG，而DAG的生成又依赖于一个较小的缓存（Cache）。这使得“轻客户端”（只需要验证区块，不需要挖矿）只需存储较小的缓存即可，降低了网络参与的门槛。
  • 内存带宽瓶颈：算法的核心不在于单纯的计算强度（CPU/ASIC擅长），而在于从海量数据中进行快速、随机的读取。这恰好是GPU的“甜点区”，却是ASIC设计的“噩梦区”，因为要将GB级别的存储和高速逻辑集成在一块芯片上，成本极高，且DAG的持续增长会让这种专用芯片很快过时。
  • 动态难度：DAG的周期性增长和大小增加，意味着对硬件的内存要求是不断提高的，这为算法的长期ASIC抗性增加了一道动态的防线。

预挖矿(Pre-mining)

预挖矿指的是在一个加密货币项目（尤其是采用工作量证明PoW机制的）正式向公众发布并开放挖矿之前，项目的创始人或开发团队自己先行挖出（或在创世区块中直接生成）一部分代币。

目的与动机：

  • 正面理由：
    • 发展资金： 将预挖出的代币作为基金会储备，用于支付未来多年的开发、营销、法律合规等费用。
    • 激励团队： 奖励创始团队、早期贡献者和开发者，确保他们有动力长期为项目服务。
    • 生态建设： 用于未来的生态系统扶持计划，如提供开发者补助金（Grants）、举办黑客松、激励社区等。
  • 负面影响：
    • 不公平的起点： 预挖矿被许多加密货币纯粹主义者认为是“原罪”。它给了创始人一种不公平的优势，让他们能够以几乎为零的成本获取大量代币。
    • 潜在的砸盘风险： 团队持有的巨量低成本代币就像一颗“定时炸弹”。如果他们在代币价格上涨后大量抛售（Dump），会瞬间摧毁市场信心，导致价格暴跌，让后期进入的投资者蒙受巨大损失。
    • 违背去中心化精神： 像比特币（Bitcoin）那样无预挖的“公平启动”（Fair Launch）被认为是去中心化的黄金标准。而预挖矿从第一天起就造成了代币供应的中心化，权力集中在少数人手中。
    • 透明度问题： 社区往往难以监督预挖代币的使用情况，可能导致滥用或腐败。

ETH中，预挖矿指在2015年7月30日网络正式启动时，在创世区块（Genesis Block）中被预先设定好并直接生成的初始供应分配。在创世区块中，总共创建了约 7,200 万个 ETH。这批“预挖”的代币分配如下：

  1. 约 6,000 万 ETH (占比约 83%)：
    • 归属：分配给在2014年预售中投入比特币的所有投资者。这部分ETH的数量和分配地址是根据预售的结果精确计算并写入创世状态的。这完美连接了Pre-sale和Pre-mining两个环节。
  2. 约 1,200 万 ETH (占比约 17%)：
    • 归属：这部分分配给了早期贡献者和以太坊基金会，可以被视为更传统意义上的“团队份额”或“发展基金”。它被进一步细分为两个部分：
      • 早期贡献者池：约600万ETH，分配给在预售前就已经为项目做出重要贡献的核心开发者和成员。
      • 长期储备池：约600万ETH，分配给以太坊基金会（Ethereum Foundation）。这是一个非营利组织，其任务是支持和促进以太坊协议及其生态系统的长期发展。

预售(Pre-sale)

预售指的是一个加密货币项目在进行公开发行（如ICO、IEO）之前，向一小部分早期投资者（如风险投资机构、战略合作伙伴、大户等）提前出售其代币。这更像是一种私募融资行为。

目的与动机：

  • 募集启动资金： 这是最主要的目的。在产品尚未完全开发完成时，通过预售获取资金，用于支持技术开发、团队扩张、市场推广和法律咨询等。
  • 引入战略资源： 预售的投资者通常不仅仅是提供资金，他们可能是能带来技术指导、行业人脉、市场渠道等宝贵资源的战略合作伙伴。
  • 价格发现与市场验证： 预售的成功与否可以作为项目市场吸引力的早期信号，帮助团队判断项目的受欢迎程度。

预售的特点：

  • 价格折扣： 预售阶段的投资者通常能以比公募价格低很多的折扣价购买代币，这是对他们早期支持和承担更高风险的回报。
  • 投资门槛高： 预售通常只对少数受邀的、资金量大的机构或个人投资者开放。
  • 锁仓期与释放计划（Vesting）： 这是预售中至关重要的一环。为了防止早期投资者在代币一上线交易所后就立即抛售砸盘，他们的代币几乎总会被“锁仓”，并按照一个预定的时间表（例如，在1-4年内每月或每季度线性释放）逐步解锁。

以太坊的预售被称为 "Ether Sale"，它在 2014年7月至8月 期间进行，持续了42天。这在当时是一次极具开创性的网络众筹活动。

  • 目的：为以太坊这个宏大且复杂的项目筹集开发资金。当时，Vitalik Buterin 和其他联合创始人需要资金来支付全职开发人员的工资、法律费用以及运营开销。
  • 方式：投资者使用比特币（BTC）来参与预售。他们将BTC发送到一个指定的地址，作为回报，他们获得了在未来以太坊网络正式启动时接收ETH（以太币）的权利。
  • 具体数据：
    • 募集总额：成功募集了超过 31,500 个比特币。
    • 当时价值：按当时的价格计算，约合 1,830 万美元，这在当时是一笔巨款。
    • 售出ETH数量：共售出了大约 6,000 万个 ETH。
    • 定价：预售价格是分阶段的。活动初期，1个BTC可以兑换2000个ETH；后期，价格逐渐上涨，到最后阶段1个BTC只能兑换1337个ETH，以此来鼓励早期参与。

这次成功的预售为以太坊的后续开发提供了至关重要的燃料。以太坊的成功使其众筹模式被广为效仿，直接催生了2017年的ICO（首次代币发行）狂潮，成千上万的项目都遵循了“发布白皮书 -> 进行代币预售 -> 开发项目”这一路径。

分享