Ethereum 以太坊智能合约调用源码分析

0 前言

基于 Ethereum Coffice (v.1.8.8) 分析
需要区块链基础知识
有 C++/JAVA 基础就能理解文中 go 代码
本文不包含合约部署的前序步骤，即sol源码编译打包过程，请参考网络上其他文章
流程图使用 ProcessOn.com 在线绘制
合约调用与交易的流程大同小异，可参考之前笔者文章“Ethereum 以太坊智能合约部署源码分析”

整体流程图如下所示：

1 API 发起智能合约执行交易

在部署好的智能合约上，可以发起合约调用。每次合约调用将生成一笔新的交易，Ethereum 区块链网络需要处理交易上链事件。下面是交易发起过程用到的两个主要数据结构：

1.1 相关数据结构

客户端侧传输数据结构展示：

/*
file: ethapi\api.go
*/
type SendTxArgs struct {
    From     common.Address  `json:"from"`
    To       *common.Address `json:"to"`
    Gas      *hexutil.Uint64 `json:"gas"`
    GasPrice *hexutil.Big    `json:"gasPrice"`
    Value    *hexutil.Big    `json:"value"`
    Nonce    *hexutil.Uint64 `json:"nonce"`
    Data  *hexutil.Bytes `json:"data"`
    Input *hexutil.Bytes `json:"input"`
}

Ethereum 交易数据结构展示：

/*
file: core\types\transaction.go
*/
type Transaction struct {
    data txdata
    hash atomic.Value
    size atomic.Value
    from atomic.Value
}

type txdata struct {
    AccountNonce uint64          `json:"nonce"    gencodec:"required"`
    Price        *big.Int        `json:"gasPrice" gencodec:"required"`
    GasLimit     uint64          `json:"gas"      gencodec:"required"`
    Recipient    *common.Address `json:"to"       rlp:"nil"`
    Amount       *big.Int        `json:"value"    gencodec:"required"`
    Payload      []byte          `json:"input"    gencodec:"required"`

    V *big.Int `json:"v" gencodec:"required"`
    R *big.Int `json:"r" gencodec:"required"`
    S *big.Int `json:"s" gencodec:"required"`

    Hash *common.Hash `json:"hash" rlp:"-"`
}

1.2 流程图细节

ethapi/api.go 识别到这是一次交易发送请求，调用 SendTransaction() 函数，进一步向底层发送消息。首先，函数会检查发送交易账户的合法性，并且为交易设置一系列的初始值，例如 gas, nonce 等。交易信息填满后，放到交易池中，等待下一步处理。
1a. 根据传入信息创建 Transaction 。注意此处有个判断语句，根据 To 是否有值来确定是合约创建或调用。

if args.To == nil { // 合约调用时，此处to不为空
    return types.NewContractCreation(...)
}
return types.NewTransaction(...)

1b. SignTx() 使用交易发起者信息对交易进行签名。此处有wallet的概念，官方源码注释中多次提到“USB”。笔者网上检索后知道这是以太坊推出的硬件钱包，它是一个安全存储私钥的硬件设备，通过USB与电脑连接。在进行交易时，发送交易到 Ethereum 区块链网络时，需要使用硬件钱包的私钥进行交易签名。下面引用一段对于硬件钱包的说明：

Ledger的硬件钱包围绕“安全元件”或安全芯片进行架构。这是和芯片及PIN支付或SIM卡中使用的相同技术。这些芯片为物理攻击提供保护，大大提升私钥的安全性。我们的研发人员来自安全行业（曾服务于数字安全领域的全球领先企业Gemalto金雅拓，Oberthur 欧贝特等企业），我们在智能卡和安全嵌入式操作系统领域拥有丰富的经验。
1
2
3
4
5
var chainID *big.Int
if config := s.b.ChainConfig(); config.IsEIP155(s.b.CurrentBlock().Number()) {
    chainID = config.ChainId
}
signed, err := wallet.SignTx(account, tx, chainID)

若是检测到 Ethereum 软件未运行，将直接反馈空的交易信息

/*
file: accouts\usbwallet\ledger.go
*/
if w.offline() {
    return common.Address{}, nil, accounts.ErrWalletClosed
}

1c. submitTransaction() 将交易推进交易池，等待下一步处理。

func submitTransaction(...) (common.Hash, error) {
    if err := b.SendTx(ctx, tx); err != nil {
        return common.Hash{}, err
    }
    if tx.To() == nil {
        ...
        addr := crypto.CreateAddress(from, tx.Nonce())
        log.Info(... "contract", addr.Hex())
    } 
    ...
    return tx.Hash(), nil
}

入池操作会调用如下关键函数。交易池分为两个交易列表， pending 中存放可执行的交易， queue 中存放排队中暂不可执行的交易，他们之间可以相互转换。入池之前，pool.validateTx() 会对交易签名进行初步检查，对于一笔合法的新交易， pool.enqueueTx() 会将其先放入 queue 列表，随后 promoteExecutables() 视条件将其移入 pending 中。

/*
file: core\tx_pool.go
*/
func (pool *TxPool) addTx(...) error {
    ...
    replace, err := pool.add(tx, local)
    if err != nil {
        return err
    }

    if !replace {
        from, _ := types.Sender(pool.signer, tx) 
        pool.promoteExecutables([]common.Address{from})
    }
    return nil
}

2 Worker 交易打包出块

随着交易池的增长，矿工服务根据一定的条件完成交易打包与出块操作。生成的块将在网络中通过P2P服务传播。
(细节待完成)

3 Blockchain 区块上链

3.1 概述

在收到网络上的传送来的区块后，触发 blockchain.go 的 InsertChain() 函数，进入区块的处理过程: 区块链校验 -> 区块头验证->区块体验证->交易处理->状态验证->区块上链。

/*
file: core\blockchain.go
*/
func (bc *BlockChain) insertChain(chain types.Blocks) (...) {
    for i := 1; i < len(chain); i++ {
        if chain[i].NumberU64() != chain[i-1].NumberU64()+1 || chain[i].ParentHash() != chain[i-1].Hash() {
            ...
            return 0, nil, nil, ...
        }
    }
    ...
    abort, results := bc.engine.VerifyHeaders(...)
    ...
    for i, block := range chain {
        ...
        err := <-results
        if err == nil {
            err = bc.Validator().ValidateBody(block)
        }
        ...
        state, err := state.New(parent.Root(), bc.stateCache)
        if err != nil {
            return i, events, coalescedLogs, err
        }

        receipts, logs, usedGas, err := bc.processor.Process(...)
        if err != nil {
            bc.reportBlock(block, receipts, err)
            return i, events, coalescedLogs, err
        }

        err = bc.Validator().ValidateState(...)
        if err != nil {
            bc.reportBlock(block, receipts, err)
            return i, events, coalescedLogs, err
        }

        status, err := bc.WriteBlockWithState(...)
        if err != nil {
            return i, events, coalescedLogs, err
        }
        switch status {
        case CanonStatTy:
            ...
        case SideStatTy:
            ...
    }
    ...
    return 0, events, coalescedLogs, nil
}

Message 数据结构展示

type Message struct {
    to         *common.Address
    from       common.Address
    nonce      uint64
    amount     *big.Int
    gasLimit   uint64
    gasPrice   *big.Int
    data       []byte
    checkNonce bool
}

3.2 流程图细节

交易处理过程调用 state_processer.go 的 Process() 函数对区块中的所有交易进行逐一处理。

/*
file: core\state_processor.go
*/
func (p *StateProcessor) Process(...) (types.Receipts, []*types.Log, uint64, error) {
    ...
    for i, tx := range block.Transactions() {
        statedb.Prepare(tx.Hash(), block.Hash(), i)
        receipt, _, err := ApplyTransaction(...)
        if err != nil {
            return nil, nil, 0, err
        }
        receipts = append(receipts, receipt)
        allLogs = append(allLogs, receipt.Logs...)
    }

    p.engine.Finalize(...)

    return receipts, allLogs, *usedGas, nil
}

2a. AsMessage() 函数将 Transaction 数据结构转换为 Message 数据结构

msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
if err != nil {
    return nil, 0, err
}

2b. newEvm() 为合约的执行创建虚拟机环境。

1 2	context := NewEVMContext(msg, header, bc, author) vmenv := vm.NewEVM(context, statedb, config, cfg)

2c. ApplyMessage() 创建一个新的状态变更实例，并且调用 state_transition.go 的 TransitionDb() 函数应用合约代码到这个实例中，发生实质上的状态转移记录。 TransitionDb() 首先会进行交易执行的入口检查，确认 nonce, gas 是否合法可用；随后根据是合约创建还是合约调用，选择 Create() 或者 Call()，在合约部署中，此处会调用 Call()

/*
file: core\state_transition.go
*/
func (st *StateTransition) TransitionDb() () {
    if err = st.preCheck(); err != nil {
        return
    }
    ...
    contractCreation := msg.To() == nil
    ...
    if contractCreation {
        ret, _, st.gas, vmerr = evm.Create(...)
    } else {
        st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
        ret, st.gas, vmerr = evm.Call(...)  // 合约调用
    }
    ...
    return ret, st.gasUsed(), vmerr != nil, err
}

下面进入到合约调用最核心的流程，由 core\vm\evm.go 的 Call() 完成。在真正调用前，会做一些基本的合法性检查，例如余额是否足够进行转账，账户合法性等。注意此处若对象账户不存在，内部会为账户地址创建新的账户。run() 函数将执行合约代码，第三个参数为nil，代表不调用合约中的任何函数，只是初始化。

Tips：Ethereum 中，在进行账户的查询功能和转账功能时，都是合约调用交易。但是我们知道，查询动作实际无需上链，转账才需要。Ethereum 把这项控制设计在了智能合约的编写中，通过sol语言的函数修饰关键字来控制。

在Solidity中constant、view、pure三个函数修饰词的作用是告诉编译器，函数不改变/不读取状态变量，这样函数执行就可以不消耗gas了，因为不需要矿工来验证。在Solidity v4.17之前，只有constant，后续版本将constant拆成了view和pure。view的作用和constant一模一样，可以读取状态变量但是不能改；pure则更为严格，pure修饰的函数不能改也不能读状态变量，智能操作函数内部变量，否则编译通不过。
作者：Kirn
链接：https://www.jianshu.com/p/52eec7ac5413

/*
file: core\vm\evm.go
*/
func (evm *EVM) Call(...) (...) {
    if evm.vmConfig.NoRecursion && evm.depth > 0 {
        return nil, gas, nil
    }
    if evm.depth > int(params.CallCreateDepth) {
        return nil, gas, ErrDepth
    }
    // 余额是否充足
    if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
        return nil, gas, ErrInsufficientBalance
    }

    var (
        to       = AccountRef(addr)
        snapshot = evm.StateDB.Snapshot()
    )
    if !evm.StateDB.Exist(addr) {
        ...
        // 对方地址无账户，则创建
        evm.StateDB.CreateAccount(addr)
    }

    // 在DB层面执行转账动作
    evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
    // 为当前合约执行创建一个临时的合约
    contract := NewContract(caller, to, value, gas)
    contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))

    ...

    ret, err = run(evm, contract, input)
    // 调用失败，根据快照回滚数据
    if err != nil {
        evm.StateDB.RevertToSnapshot(snapshot)
        ...
    }
    return ret, contract.Gas, err
}

blockchain.go 的 WriteBlockWithState() 将掉用 accessors_chain.go 的 3a. WriteBlock() 3b. WriteReceipts() 写入区块和收据。

4 API 获取收据

4.1 概述

在上面的流程中，交易执行完毕后，不会显式地向请求端回复任何交易执行的具体情况。在 Ethereum 区块链网络中，需要请求端显式地请求交易收据，以此来确认交易执行的情况。从上一节的第3步骤可知，交易执行收据已经写入了db中，请求端要做的是发生获取交易收据请求。

4.2 流程图细节

ethapi/api.go 识别到这是一次交易发送请求，调用 GetTransactionReceipt() 函数，进一步向底层发送消息。如果收据中的合约地址不是全0，则认为是一次合约部署过程，填写交易中的合约地址到收据中供请求端使用。
4a. 调用ReadTransaction() 函数，获取交易的基础信息
4b. 调用GetReceipts() 函数，获取交易收据，其内部会调用 ReadHeadNumber() 和 ReadReceipts() 函数辅助操作。

/*
file: ethapi/api.go
*/
func (s *PublicTransactionPoolAPI) GetTransactionReceipt(...) (...) {
    tx, blockHash, blockNumber, index := rawdb.ReadTransaction(...)
    ...
    receipts, err := s.b.GetReceipts(ctx, blockHash)
    if err != nil {
        return nil, err
    }
    ...
    if receipt.ContractAddress != (common.Address{}) {
        fields["contractAddress"] = receipt.ContractAddress
    }
    return fields, nil
}

——————————THE END——————————

本文文字和图片均属博主原创。未经授权，不得转载。