以太坊源码解读(19)EVM 创建智能合约

我们要知道,evm解释器的执行上下文是stateTransition,是交易,但evm的服务对象是智能合约。智能合约与evm的解释器有紧密的联系,所以我们这一节先从智能合约的创建和执行开始学习。

合约创建函数的调用时机,一是Worker执行交易的过程,交易如果是合约创建,则会在EVM执行交易时生成智能合约地址并部署智能合约;二是通过opCreate指令,这个指令使得在智能合约内部创建新的智能合约成为可能。

1、交易执行前的检查
2、确保当前要创建的地址在世界状态中没有合约存在,如果存在,直接返回;
3、创建一个新账户,设置新账户为nonce为1;
4、进行转账
5、创建一个待执行的合约对象,并执行;
6、处理返回值

我们首先看一看创建一个合约所需要的参数:

func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, 
contractAddr common.Address, leftOverGas uint64, err error) {
	contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
	return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr)
}

caller:转出方地址;
code:代码(input)
gas:当前交易的剩余gas;
value:转账额度;

Create()方法首先对发送者地址(caller.Address)和账户的nonce进行keccak256计算得到合约地址,然后将合约地址传入create()方法,后者是合约创建的真正函数。

首先,在执行交易之前需要进行检查:1、深度判断;2、余额是否足够;

// 如果递归深度大于1024,直接退出
if evm.depth > int(params.CallCreateDepth) {
	return nil, common.Address{}, gas, ErrDepth
}
// 判断交易发起方账户余额是否足够,否则直接退出
if !evm.CanTransfer(evm.StateDB, caller.Address(), value) {
	return nil, common.Address{}, gas, ErrInsufficientBalance
}

然后,给交易发送者的账户nonce加1(普通转账时,是在外面加1的,即在TransitionDb中),然后判断当前要创建的地址在是世界状态中没有合约存在,如果存在直接返回。

nonce := evm.StateDB.GetNonce(caller.Address())
evm.StateDB.SetNonce(caller.Address(), nonce+1)

// 传入的合约地址nonce不为0,或contractHash不为空
contractHash := evm.StateDB.GetCodeHash(address)
if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != emptyCodeHash) {
	return nil, common.Address{}, 0, ErrContractAddressCollision
}

第三步,如果上面两个检查都没有问题,那么我们就可以创建新的合约账户了。先用合约地址创建一个合约账户,然后给合约账户设置nonce为1。

// 先对当前StateDB进行快照
snapshot := evm.StateDB.Snapshot()
// 创建新合约并将合约的nonce设置为1
evm.StateDB.CreateAccount(address)
if evm.ChainConfig().IsEIP158(evm.BlockNumber) {
    evm.StateDB.SetNonce(address, 1)
}

下图比较直观的看到我们的合约储存在什么地方以及账户的结构:

第四步是进行转账,将我们构建合约交易时的value转入智能合约账户。转账的过程很简单,就是sender的账户减减(--),合约账户加加(++)。

evm.Transfer(evm.StateDB, caller.Address(), address, value)

第五步是创建合约对象,并执行。

contract := NewContract(caller, AccountRef(address), value, gas)
contract.SetCodeOptionalHash(&address, codeAndHash)

// 如果vm配置规定不允许递归,但递归深度大于0,则直接退出
if evm.vmConfig.NoRecursion && evm.depth > 0 {
    return nil, address, gas, nil
}

if evm.vmConfig.Debug && evm.depth == 0 {
    evm.vmConfig.Tracer.CaptureStart(caller.Address(), address, true, codeAndHash.code, gas, value)
}

start := time.Now()

使用caller地址 、合约地址、转账额和交易余额传入NewContract()方法。然后执行contract.SetCodeOptionalHash(),将合约代码code设置到合约中:

func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash) {
	c.Code = codeAndHash.code
	c.CodeHash = codeAndHash.hash
	c.CodeAddr = addr
}

执行合约初始化代码

ret, err := run(evm, contract, nil, false)

run()函数将contract交给了evm解释器,返回interpreter.Run(contract, input, readOnly)的执行结果。至于interpreter如何执行合约,我们后面再分析。

func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, error) {
	if contract.CodeAddr != nil {
		precompiles := PrecompiledContractsHomestead
		if evm.ChainConfig().IsByzantium(evm.BlockNumber) {
			precompiles = PrecompiledContractsByzantium
		}
		if p := precompiles[*contract.CodeAddr]; p != nil {
			return RunPrecompiledContract(p, input, contract)
		}
	}
	for _, interpreter := range evm.interpreters {
		if interpreter.CanRun(contract.Code) {
			if evm.interpreter != interpreter {
				// Ensure that the interpreter pointer is set back
				// to its current value upon return.
				defer func(i Interpreter) {
					evm.interpreter = i
				}(evm.interpreter)
				evm.interpreter = interpreter
			}
			return interpreter.Run(contract, input, readOnly)
		}
	}
	return nil, ErrNoCompatibleInterpreter
}

第六步,处理返回值

run函数的两个返回值分别是ret(合约代码)和err,我们需要判断合约代码的长度以及err是否为nil:

// 约定合约代码最大长度为24576
maxCodeSizeExceeded := evm.ChainConfig().IsEIP158(evm.BlockNumber) && len(ret) > params.MaxCodeSize
// 如果执行没有错且代码长度不超过24576
if err == nil && !maxCodeSizeExceeded {
    // 计算本次合约创建消耗的gas,每字节200gas
    createDataGas := uint64(len(ret)) * params.CreateDataGas
    // 如果交易gas余额足够,则成功部署合约,将合约代码设置到账户储存中
    if contract.UseGas(createDataGas) {
        evm.StateDB.SetCode(address, ret)
    // 否则返回余额不足
    } else {
        err = ErrCodeStoreOutOfGas
    }
}

// 如果代码长度受限或执行错误
if maxCodeSizeExceeded || (err != nil && (evm.ChainConfig().IsHomestead(evm.BlockNumber) || err != ErrCodeStoreOutOfGas)) {
    // 则恢复之前的快照
    evm.StateDB.RevertToSnapshot(snapshot)
    // 如果不是revert指令导致的错误,要扣除所有的gas
    if err != errExecutionReverted {
        contract.UseGas(contract.Gas)
    }
}
// 如果只是代码过长,则返回相应的错误
if maxCodeSizeExceeded && err == nil {
    err = errMaxCodeSizeExceeded
}
if evm.vmConfig.Debug && evm.depth == 0 {
    evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
}
// 最后返回合约代码、合约地址、gas余额和错误
return ret, address, contract.Gas, err

值得注意的是,如果代码执行错误是revert错误,则不会收取gas,否则gas会被扣除。那么这个revert是什么?revert是evm中的一条指令,在我们智能函数编程语言中(solidity)中有require和revert这两个判断。如果require和revert判断错误,那么就会返回一个revert指令错误,此时就不会收取gas。这也就是为什么solidity中require和revert执行不会扣除gas的原因。当然,这个方法是在拜占庭分叉后出现的。

最后,一张图看看智能合约创建的过程:

在了解合约调用之前,我们需要知道调用合约的本质是什么。在我们创建合约的时候,由run函数初始化的智能合约code(ret)储存在stateDB中。也就是说在内存中并没有Contract这个对象, ...