aboutsummaryrefslogtreecommitdiffstats
path: root/core/execution.go
diff options
context:
space:
mode:
Diffstat (limited to 'core/execution.go')
-rw-r--r--core/execution.go164
1 files changed, 102 insertions, 62 deletions
diff --git a/core/execution.go b/core/execution.go
index 1cb507ee7..576e05851 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -27,40 +27,93 @@ import (
// Call executes within the given contract
func Call(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice, value *big.Int) (ret []byte, err error) {
- ret, _, err = exec(env, caller, &addr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, value)
+ // Depth check execution. Fail if we're trying to execute above the
+ // limit.
+ if env.Depth() > int(params.CallCreateDepth.Int64()) {
+ caller.ReturnGas(gas, gasPrice)
+
+ return nil, vm.DepthError
+ }
+ if !env.CanTransfer(caller.Address(), value) {
+ caller.ReturnGas(gas, gasPrice)
+
+ return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
+ }
+
+ snapshotPreTransfer := env.SnapshotDatabase()
+ var (
+ from = env.Db().GetAccount(caller.Address())
+ to vm.Account
+ )
+ if !env.Db().Exist(addr) {
+ if vm.Precompiled[addr.Str()] == nil && env.ChainConfig().IsEIP158(env.BlockNumber()) && value.BitLen() == 0 {
+ caller.ReturnGas(gas, gasPrice)
+ return nil, nil
+ }
+
+ to = env.Db().CreateAccount(addr)
+ } else {
+ to = env.Db().GetAccount(addr)
+ }
+ env.Transfer(from, to, value)
+
+ // initialise a new contract and set the code that is to be used by the
+ // EVM. The contract is a scoped environment for this execution context
+ // only.
+ contract := vm.NewContract(caller, to, value, gas, gasPrice)
+ contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
+ defer contract.Finalise()
+
+ ret, err = env.Vm().Run(contract, input)
+ // When an error was returned by the EVM or when setting the creation code
+ // above we revert to the snapshot and consume any gas remaining. Additionally
+ // when we're in homestead this also counts for code storage gas errors.
+ if err != nil {
+ contract.UseGas(contract.Gas)
+
+ env.RevertToSnapshot(snapshotPreTransfer)
+ }
return ret, err
}
// CallCode executes the given address' code as the given contract address
func CallCode(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice, value *big.Int) (ret []byte, err error) {
- callerAddr := caller.Address()
- ret, _, err = exec(env, caller, &callerAddr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, value)
- return ret, err
-}
+ // Depth check execution. Fail if we're trying to execute above the
+ // limit.
+ if env.Depth() > int(params.CallCreateDepth.Int64()) {
+ caller.ReturnGas(gas, gasPrice)
-// DelegateCall is equivalent to CallCode except that sender and value propagates from parent scope to child scope
-func DelegateCall(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice *big.Int) (ret []byte, err error) {
- callerAddr := caller.Address()
- originAddr := env.Origin()
- callerValue := caller.Value()
- ret, _, err = execDelegateCall(env, caller, &originAddr, &callerAddr, &addr, env.Db().GetCodeHash(addr), input, env.Db().GetCode(addr), gas, gasPrice, callerValue)
- return ret, err
-}
+ return nil, vm.DepthError
+ }
+ if !env.CanTransfer(caller.Address(), value) {
+ caller.ReturnGas(gas, gasPrice)
-// Create creates a new contract with the given code
-func Create(env vm.Environment, caller vm.ContractRef, code []byte, gas, gasPrice, value *big.Int) (ret []byte, address common.Address, err error) {
- ret, address, err = exec(env, caller, nil, nil, crypto.Keccak256Hash(code), nil, code, gas, gasPrice, value)
- // Here we get an error if we run into maximum stack depth,
- // See: https://github.com/ethereum/yellowpaper/pull/131
- // and YP definitions for CREATE instruction
+ return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
+ }
+
+ var (
+ snapshotPreTransfer = env.SnapshotDatabase()
+ to = env.Db().GetAccount(caller.Address())
+ )
+ // initialise a new contract and set the code that is to be used by the
+ // EVM. The contract is a scoped environment for this execution context
+ // only.
+ contract := vm.NewContract(caller, to, value, gas, gasPrice)
+ contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
+ defer contract.Finalise()
+
+ ret, err = env.Vm().Run(contract, input)
if err != nil {
- return nil, address, err
+ contract.UseGas(contract.Gas)
+
+ env.RevertToSnapshot(snapshotPreTransfer)
}
- return ret, address, err
+
+ return ret, err
}
-func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.Address, codeHash common.Hash, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
- evm := env.Vm()
+// Create creates a new contract with the given code
+func Create(env vm.Environment, caller vm.ContractRef, code []byte, gas, gasPrice, value *big.Int) (ret []byte, address common.Address, err error) {
// Depth check execution. Fail if we're trying to execute above the
// limit.
if env.Depth() > int(params.CallCreateDepth.Int64()) {
@@ -68,36 +121,24 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A
return nil, common.Address{}, vm.DepthError
}
-
if !env.CanTransfer(caller.Address(), value) {
caller.ReturnGas(gas, gasPrice)
return nil, common.Address{}, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
}
- var createAccount bool
- if address == nil {
- // Create a new account on the state
- nonce := env.Db().GetNonce(caller.Address())
- env.Db().SetNonce(caller.Address(), nonce+1)
- addr = crypto.CreateAddress(caller.Address(), nonce)
- address = &addr
- createAccount = true
- }
+ // Create a new account on the state
+ nonce := env.Db().GetNonce(caller.Address())
+ env.Db().SetNonce(caller.Address(), nonce+1)
snapshotPreTransfer := env.SnapshotDatabase()
var (
+ addr = crypto.CreateAddress(caller.Address(), nonce)
from = env.Db().GetAccount(caller.Address())
- to vm.Account
+ to = env.Db().CreateAccount(addr)
)
- if createAccount {
- to = env.Db().CreateAccount(*address)
- } else {
- if !env.Db().Exist(*address) {
- to = env.Db().CreateAccount(*address)
- } else {
- to = env.Db().GetAccount(*address)
- }
+ if env.ChainConfig().IsEIP158(env.BlockNumber()) {
+ env.Db().SetNonce(addr, 1)
}
env.Transfer(from, to, value)
@@ -105,19 +146,19 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A
// EVM. The contract is a scoped environment for this execution context
// only.
contract := vm.NewContract(caller, to, value, gas, gasPrice)
- contract.SetCallCode(codeAddr, codeHash, code)
+ contract.SetCallCode(&addr, crypto.Keccak256Hash(code), code)
defer contract.Finalise()
- ret, err = evm.Run(contract, input)
+ ret, err = env.Vm().Run(contract, nil)
// if the contract creation ran successfully and no errors were returned
// calculate the gas required to store the code. If the code could not
// be stored due to not enough gas set an error and let it be handled
// by the error checking condition below.
- if err == nil && createAccount {
+ if err == nil {
dataGas := big.NewInt(int64(len(ret)))
dataGas.Mul(dataGas, params.CreateDataGas)
if contract.UseGas(dataGas) {
- env.Db().SetCode(*address, ret)
+ env.Db().SetCode(addr, ret)
} else {
err = vm.CodeStoreOutOfGasError
}
@@ -126,46 +167,45 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A
// When an error was returned by the EVM or when setting the creation code
// above we revert to the snapshot and consume any gas remaining. Additionally
// when we're in homestead this also counts for code storage gas errors.
- if err != nil && (env.RuleSet().IsHomestead(env.BlockNumber()) || err != vm.CodeStoreOutOfGasError) {
+ if err != nil && (env.ChainConfig().IsHomestead(env.BlockNumber()) || err != vm.CodeStoreOutOfGasError) {
contract.UseGas(contract.Gas)
env.RevertToSnapshot(snapshotPreTransfer)
+
+ // Nothing should be returned when an error is thrown.
+ return nil, addr, err
}
return ret, addr, err
}
-func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toAddr, codeAddr *common.Address, codeHash common.Hash, input, code []byte, gas, gasPrice, value *big.Int) (ret []byte, addr common.Address, err error) {
- evm := env.Vm()
+// DelegateCall is equivalent to CallCode except that sender and value propagates from parent scope to child scope
+func DelegateCall(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice *big.Int) (ret []byte, err error) {
// Depth check execution. Fail if we're trying to execute above the
// limit.
if env.Depth() > int(params.CallCreateDepth.Int64()) {
caller.ReturnGas(gas, gasPrice)
- return nil, common.Address{}, vm.DepthError
+ return nil, vm.DepthError
}
- snapshot := env.SnapshotDatabase()
-
- var to vm.Account
- if !env.Db().Exist(*toAddr) {
- to = env.Db().CreateAccount(*toAddr)
- } else {
- to = env.Db().GetAccount(*toAddr)
- }
+ var (
+ snapshot = env.SnapshotDatabase()
+ to = env.Db().GetAccount(caller.Address())
+ )
// Iinitialise a new contract and make initialise the delegate values
- contract := vm.NewContract(caller, to, value, gas, gasPrice).AsDelegate()
- contract.SetCallCode(codeAddr, codeHash, code)
+ contract := vm.NewContract(caller, to, caller.Value(), gas, gasPrice).AsDelegate()
+ contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
defer contract.Finalise()
- ret, err = evm.Run(contract, input)
+ ret, err = env.Vm().Run(contract, input)
if err != nil {
contract.UseGas(contract.Gas)
env.RevertToSnapshot(snapshot)
}
- return ret, addr, err
+ return ret, err
}
// generic transfer method
generated by cgit (git 2.34.1) at 2024-12-18 16:07:44 +0800