死磕以太坊源码分析之state

配合以下代码进行阅读:https://github.com/blockchainGuide/

希望读者在阅读过程中发现问题可以及时评论哦,大家一起进步。

源码目录

|-database.go 底层的存储设计
|-dump.go 用来dumpstateDB数据
|-iterator.go,用来遍历Trie
|-journal.go,用来记录状态的改变
|-state_object.go 通过state object操作账户值,并将修改后的storage trie写入数据库
|-statedb.go,以太坊整个的状态
|-sync.go,用来和downloader结合起来同步state

基础概念

状态机

以太坊的本质就是一个基于交易的状态机(transaction-based state machine)。在计算机科学中,一个 状态机 是指可以读取一系列的输入,然后根据这些输入,会转换成一个新的状态出来的东西。

我们从创世纪状态(genesis state)开始,在网络中还没有任何交易的时候产生状态。当第一个区块执行第一个交易时候开始产生状态,直到执行完N个交易,第一个区块的最终状态产生,第二个区块的第一笔交易执行后将会改变第一个区块链的最终状态,以此类推,从而产生最终的区块状态。

以太坊状态数据库

区块的状态数据并非保存在链上,而是将这些状态维护在默克尔压缩前缀树中,在区块链上仅记录对应的Trie Root 值。使用LevelDB维护树的持久化内容,而这个用来维护映射的数据库叫做 StateDB

首先我们用一张图来大致了解一下StateDB

可以看到图中一共有两种状态,一个是世界状态Trie,一个是storage Trie,两者都是MPT树,世界状态包含了一个个的账户状态,账户状态通过以账户地址为键,维护在表示世界状态的树中,而每个账户状态中存储这账户存储树的Root。账户状态存储一下信息:

  1. nonce: 表示此账户发出的交易数量
  2. balance: 账户余额
  3. storageRoot: 账户存储树的Root根,用来存储合约信息
  4. codeHash: 账户的 EVM 代码哈希值,当这个地址接收到一个消息调用时,这些代码会被执行; 它和其它字段不同,创建后不可更改。如果 codeHash 为空,则说明该账户是一个简单的外部账户,只存在 noncebalance

接下来将会分析State相关的一些类,着重关注statedb.go、state_object.go、database.go,其中涉及的Trie相关的代码可以参照:死磕以太坊源码分析之MPT树-下

关键的数据结构

Account

Account存储的是账户状态信息。

type Account struct {
Nonce uint64 //账户发出的交易数量
Balance *big.Int // 账户的余额
Root common.Hash //账户存储树的Root根,用来存储合约信息
CodeHash []byte // 账户的 EVM 代码哈希值
}

StateObject

表示一个状态对象,可以从中获取到账户状态信息。

type stateObject struct {
address common.Address
addrHash common.Hash // 账户地址哈希
data Account
db *StateDB // 所属的StateDB
dbErr error //VM不处理db层的错误,先记录下来,最后返回,只能保存1个错误,保存的第一个错误 // Write caches.
trie Trie // storage trie, 使用trie组织stateObj的数据
code Code // 合约字节码,在加载代码时设置 //将原始条目的存储高速缓存存储到dedup重写中,为每个事务重置
originStorage Storage //在整个块的末尾需要刷新到磁盘的存储条目
pendingStorage Storage //在当前事务执行中已修改的存储条目
dirtyStorage Storage

StateDB

用来存储状态对象。

type StateDB struct {
db Database
trie Trie // 当前所有账户组成的MPT树 // 这几个相关账户状态修改
stateObjects map[common.Address]*stateObject // 存储缓存的账户状态信息
stateObjectsPending map[common.Address]struct{} // 状态对象已经完成但是还没有写入到Trie中
stateObjectsDirty map[common.Address]struct{} // 在当前执行中修改的状态对象 ,用于后续commit
}

三者之间的关系:

StateDB->Trie->Account->stateObject

从StateDB中取出Trie根,根据地址从Trie树中获取账户的rlp编码数据,再进行解码成Account,然后根据Account生成stateObject

StateDB存储状态

StateDB读写状态主要关心以下几个文件:

  • database.go
  • state_object.go
  • statedb.go

接下来分别介绍这么几个文件,相当关键。

database.go

根据世界状态root打开世界状态树

StateDB中打开一个Trie大致经历以下过程:

OpenTrie(root common.Hash)->NewSecure->New

根据账户地址和 stoage root打开状态存储树

创建一个账户的存储Trie过程如下:

OpenStorageTrie(addrHash, root common.Hash)->NewSecure-New

Account和StateObject

以太坊的账户分为普通账户和合约账户,以Account表示,Account是账户的数据,不包含账户地址,账户需要使用地址来表示,地址在stateObject中。

type Account struct {
Nonce uint64
Balance *big.Int
Root common.Hash // 存储树的merkle树根 账户状态
CodeHash []byte //合约账户专属,合约代码编译后的Hash值
}
type stateObject struct {
address common.Address // 账户地址
addrHash common.Hash // 账户地址哈希
data Account
db *StateDB // 所属的StateDB
dbErr error //VM不处理db层的错误,先记录下来,最后返回,只能保存1个错误,保存存的第一个错误
trie Trie // storage trie, 使用trie组织stateObj的数据
code Code // 合约字节码,在加载代码时设置
originStorage Storage //将原始条目的存储高速缓存存储到dedup重写中,为每个事务重置
pendingStorage Storage //在整个块的末尾需要刷新到磁盘的存储条目
dirtyStorage Storage //在当前事务执行中已修改的存储条目
}

创建StateObject

创建状态对象会在两个地方进行调用:

  1. 检索或者创建状态对象
  2. 创建账户

最终都会去调用createObject创建一个新的状态对象。如果有一个现有的帐户给定的地址,老的将被覆盖并作为第二个返回值返回

func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
prev = s.getDeletedStateObject(addr)// 如果存在老的,获取用来以后删除掉 newobj = newObject(s, addr, Account{})
newobj.setNonce(0)
if prev == nil {
s.journal.append(createObjectChange{account: &addr})
} else {
s.journal.append(resetObjectChange{prev: prev})
}
s.setStateObject(newobj)
return newobj, prev
}

state_object.go

state_object.go是很重要的文件,我们直接通过比较重要的函数来了解它。

增加账户余额

AddBalance->SetBalance

将对象的存储树保存到db

主要就做了两件事:

  1. updateTrie将缓存的存储修改写入对象的存储Trie。
  2. 将所有节点写入到trie的内存数据库中
func (s *stateObject) CommitTrie(db Database) error {
s.updateTrie(db)
...
root, err := s.trie.Commit(nil)
...
}

第一件事会在下面继续讲,第二件事可以参照我之前关于 死磕以太坊源码分析之MPT树-下的讲解。

①:将缓存的存储修改写入对象的存储Trie

主要流程: 最终还是调用了trie.go的insert方法

updateTrie->TryUpdate->insert

  1. s.finalise()dirtyStorage中的所有数据移动到pendingStorage
  2. 根据账户哈希和账户root打开账户存储树
  3. keytrie中的value关联,更新数据
func (s *stateObject) updateTrie(db Database) Trie {
s.finalise() ①
... tr := s.getTrie(db) ②
for key, value := range s.pendingStorage {
...
if (value == common.Hash{}) {
s.setError(tr.TryDelete(key[:]))
continue
}
...
s.setError(tr.TryUpdate(key[:], v)) ③
}
...
}

整个核心也就是updateTrie,调用了trieinsert方法进行处理。

②:将所有节点写入到trie的内存数据库,其key以sha3哈希形式存储

流程:

trie.Commit->t.trie.Commit->t.hashRoot

func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
if len(t.getSecKeyCache()) > 0 {
t.trie.db.lock.Lock()
for hk, key := range t.secKeyCache {
t.trie.db.insertPreimage(common.BytesToHash([]byte(hk)), key)
}
t.trie.db.lock.Unlock() t.secKeyCache = make(map[string][]byte)
}
return t.trie.Commit(onleaf)
}

如果KeyCache中已经有了,直接插入到磁盘数据库,否则的话插入到Trie的内存数据库。

将trie根设置为的当前根哈希

func (s *stateObject) updateRoot(db Database) {
s.updateTrie(db)
if metrics.EnabledExpensive {
defer func(start time.Time) { s.db.StorageHashes += time.Since(start) }(time.Now())
}
s.data.Root = s.trie.Hash()
}

方法也比较简单,底层调用UpdateTrie然后再更新root.

State_object.go的核心方法也就这么些内容。

statedb.go

创建账户

创建账户的核心就是创建状态对象,然后再初始化值。

func (s *StateDB) CreateAccount(addr common.Address) {
newObj, prev := s.createObject(addr)
if prev != nil {
newObj.setBalance(prev.data.Balance)
}
}
func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
prev = s.getDeletedStateObject(addr) newobj = newObject(s, addr, Account{})
newobj.setNonce(0)
if prev == nil {
s.journal.append(createObjectChange{account: &addr})
} else {
s.journal.append(resetObjectChange{prev: prev})
}
s.setStateObject(newobj)
return newobj, prev
}

删除、更新、获取状态对象

func (s *StateDB) deleteStateObject(obj *stateObject)
func (s *StateDB) updateStateObject(obj *stateObject)
func (s *StateDB) getStateObject(obj *stateObject) {

这三个方法底层分别都是调用Trie.TryDelete、Trie.TryUpdate、Trie.TryGet方法来分别获取。

这里大致的讲一下getStateObject,代码如下:

func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
// Prefer live objects if any is available
if obj := s.stateObjects[addr]; obj != nil {
return obj
}
// Track the amount of time wasted on loading the object from the database
if metrics.EnabledExpensive {
defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())
}
// Load the object from the database
enc, err := s.trie.TryGet(addr[:])
if len(enc) == 0 {
s.setError(err)
return nil
}
var data Account
if err := rlp.DecodeBytes(enc, &data); err != nil {
log.Error("Failed to decode state object", "addr", addr, "err", err)
return nil
}
// Insert into the live set
obj := newObject(s, addr, data)
s.setStateObject(obj)
return obj
}

大致就做了以下几件事:

  1. 先从StateDB中获取stateObjects,有的话就返回。
  2. 如果没有的话就从stateDBtrie中获取账户状态数据,获取到rlp编码的数据之后,将其解码。
  3. 根据状态数据Account 构造stateObject

余额操作

余额的操作大致有添加、减少、和设定。我们就拿添加来分析:

根据地址获取stateObject,然后addBalance.

func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) {
stateObject := s.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.AddBalance(amount)
}
}

储存快照和回退快照

func (s *StateDB) Snapshot() int
func (s *StateDB) RevertToSnapshot(revid int)

储存快照和回退快照,我们可以在提交交易的流程中找到:

func (w *worker) commitTransaction(tx *types.Transaction, coinbase common.Address) ([]*types.Log, error) {
snap := w.current.state.Snapshot() receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &coinbase, w.current.gasPool, w.current.state, w.current.header, tx, &w.current.header.GasUsed, *w.chain.GetVMConfig())
if err != nil {
w.current.state.RevertToSnapshot(snap)
return nil, err
}
w.current.txs = append(w.current.txs, tx)
w.current.receipts = append(w.current.receipts, receipt) return receipt.Logs, nil
}

首先我们会对当前状态进行快照,然后执行ApplyTransaction,如果在预执行交易的阶段出错了,那么会回退到备份的快照位置。之前的修改全部会回退。

计算状态Trie的当前根哈希

计算状态Trie的当前根哈希是由IntermediateRoot来完成的。

①:确定所有的脏存储状态(简单理解就是当前执行修改的所有对象)

func (s *StateDB) Finalise(deleteEmptyObjects bool) {
for addr := range s.journal.dirties {
obj, exist := s.stateObjects[addr]
if !exist {
continue
}
if obj.suicided || (deleteEmptyObjects && obj.empty()) {
obj.deleted = true
} else {
obj.finalise()
}
s.stateObjectsPending[addr] = struct{}{}
s.stateObjectsDirty[addr] = struct{}{}
}
s.clearJournalAndRefund()
}

其实这个跟state_objectfinalise方法是一个方式,底层就是调用了obj.finalisedirty状态的所有数据全部推入到pending中去,等待处理。

②:处理stateObjectsPending中的数据

先更新账户的Root根,然后再将将给定的对象写入trie

for addr := range s.stateObjectsPending {
obj := s.stateObjects[addr]
if obj.deleted {
s.deleteStateObject(obj)
} else {
obj.updateRoot(s.db)
s.updateStateObject(obj)
}
}

将状态写入底层内存Trie数据库

这部分功能由commit方法完成。

  1. 计算状态Trie的当前根哈希
  2. 将状态对象中的所有更改写入到存储树

第一步在上面已经讲过了,第二步的内容如下:

for addr := range s.stateObjectsDirty {
if obj := s.stateObjects[addr]; !obj.deleted {
....
if err := obj.CommitTrie(s.db); err != nil {
return common.Hash{}, err
}
}
}

核心就是objectCommitTrie,这也是上面state_object的内容。

总结流程如下:

1.IntermediateRoot

2.CommitTrie->updateTrie->trie.Commit->trie.db.insertPreimage(已经有了直接持久化到硬盘数据库)

​ ->t.trie.Commit(没有就提交到存储树中)

最后看一下以太坊数据库的读写过程:

如果觉得文章还可以,关注下https://github.com/blockchainGuide此项目哦,欢迎有想法的人一起维护。

参考

https://mindcarver.cn

https://github.com/blockchainGuide

https://www.jianshu.com/p/20d7f7c37b03

https://hackernoon.com/getting-deep-into-ethereum-how-data-is-stored-in-ethereum-e3f669d96033

https://web.xidian.edu.cn/qqpei/files/Blockchain/4_Data.pdf

http://www.ltk100.com/article-112-1.html

https://learnblockchain.cn/books/geth/part3/statedb.html

死磕以太坊源码分析之state的更多相关文章

  1. 以太坊源码分析(52)以太坊fast sync算法

    this PR aggregates a lot of small modifications to core, trie, eth and other packages to collectivel ...

  2. Geth命令用法-参数详解 and 以太坊源码文件目录

    本文是对以太坊客户端geth命令的解析 命令用法 geth [选项] 命令 [命令选项] [参数-] 版本 1.7.3-stable 命令 account 管理账户 attach 启动交互式JavaS ...

  3. vuex源码分析(二) state及strict属性 详解

    state也就是vuex里的值,也即是整个vuex的状态,而strict和state的设置有关,如果设置strict为true,那么不能直接修改state里的值,只能通过mutation来设置 例1: ...

  4. 以太坊的crypto模块--以太坊源码学习

    以太坊的crypto模块 该模块分为两个部分一个是实现sha3,一个是实现secp256k1(这也是比特币中使用的签名算法). 需要说明的是secp256k1有两种实现方式,一种是依赖libsecp2 ...

  5. 以太坊系列之三: 以太坊的crypto模块--以太坊源码学习

    以太坊的crypto模块 该模块分为两个部分一个是实现sha3,一个是实现secp256k1(这也是比特币中使用的签名算法). 需要说明的是secp256k1有两种实现方式,一种是依赖libsecp2 ...

  6. 以太坊系列之一: 以太坊RLP用法-以太坊源码学习

    RLP (递归长度前缀)提供了一种适用于任意二进制数据数组的编码,RLP已经成为以太坊中对对象进行序列化的主要编码方式.RLP的唯一目标就是解决结构体的编码问题:对原子数据类型(比如,字符串,整数型, ...

  7. 以太坊系列之六: p2p模块--以太坊源码学习

    p2p模块 p2p模块对外暴露了Server关键结构,帮助上层管理复杂的p2p网路,使其集中于Protocol的实现,只关注于数据的传输. Server使用discover模块,在指定的UDP端口管理 ...

  8. 以太坊源码学习 – EVM

    学习文档链接:here 一.虚拟机外 主要功能: 执行前将Transaction类型转化成Message,创建虚拟机(EVM)对象,计算一些Gas消耗,以及执行交易完毕后创建收据(Receipt)对象 ...

  9. 以太坊系列之五: p2p的nat模块--以太坊源码学习

    p2p的nat模块 该模块相对比较简单,因为nat的真正实现并不在此模块,主要是使用了第三方的nat-upnp和nat-pmp来实现真正的穿透(端口映射). 对外公布的接口 ```go // An i ...

  10. netty之NioEventLoopGroup源码分析二

    大家好,今天我准备死磕NioEventLoopGroup的源码,首先讲下概念,NioEventLoopGroup 它是一个线程池,存放NioEventLoop,一个数组,今天打算先看下这行代码的初始化 ...

随机推荐

  1. 初识NodeJS,一个基于GoogleV8引擎的Javascript运行环境

    思考 首先我们来思考一个问题:我们都知道几乎所有现代主流浏览器都全面支持了ECMAScript 5.1版标准,而JavaScript的标准是ECMAScript.那么我们就容易认为JavaScript ...

  2. Can't create/write to file '/tmp/#sql_887d_0.MYD' (Errcode: 17)

    lsof |grep "#sql_887d_0.MYD" 如果没有被占用就可以删掉 . https://wordpress.org/support/topic/cant-creat ...

  3. jmeter随笔(8)--请求post的 数据为空

    1.请求post的 数据为空 分析:发现是java 解决方法: 查看 2.获取文本中数据乱码问题 问题:文本保存为UTF-8编码格式 获取的数据乱码: 分析:这是编码格式的问题 解决办法: 将文件保存 ...

  4. No.011 Container With Most Water

    11. Container With Most Water Total Accepted: 86363 Total Submissions: 244589 Difficulty: Medium Giv ...

  5. Deep Learning 学习随记(三)续 Softmax regression练习

    上一篇讲的Softmax regression,当时时间不够,没把练习做完.这几天学车有点累,又特别想动动手自己写写matlab代码 所以等到了现在,这篇文章就当做上一篇的续吧. 回顾: 上一篇最后给 ...

  6. iOS 写给iOS开发者的React Native学习路线(转)

    我是一名iOS开发者,断断续续一年前开始接触React Native,最近由于工作需要,专职学习React Native也有一个多月了.网络上知识资源非常的多,但能让人豁然开朗.迅速学习的还是少数,我 ...

  7. Recycleview实现复杂布局

    Recycleview实现复杂布局 首先 附上Demo链接和效果供大家参考 Demo 实现思路 代码思考 时间是一切财富中最宝贵的财富. -- 德奥弗拉斯多 <a 实现思路 开始看到设计稿子的时 ...

  8. VS根据数据库生成实体类

    一.在类库项目上添加新项 二. 三.依次填入数据库连接 选择数据库 就可以生成数据库实体

  9. 李飞飞确认将离职!谷歌云AI总帅换人,卡耐基&#183;梅隆老教授接棒

    https://mp.weixin.qq.com/s/i1uwZALu1BcOq0jAMvPdBw 看点:李飞飞正式回归斯坦福,新任谷歌云AI总帅还是个教授,不过这次是全职. 智东西9月11日凌晨消息 ...

  10. xml约束的概念

    1 xml 约束的概念 XML 指可扩展标记语言(EXtensible Markup Language) XML 是一种标记语言,很类似 HTML XML 的设计宗旨是传输数据,而非显示数据 XML ...