state_transition.go 9.54 KB
Newer Older
1
// Copyright 2014 The go-ethereum Authors
2
// This file is part of the go-ethereum library.
3
//
4
// The go-ethereum library is free software: you can redistribute it and/or modify
5 6 7 8
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
9
// The go-ethereum library is distributed in the hope that it will be useful,
10
// but WITHOUT ANY WARRANTY; without even the implied warranty of
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 13 14
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
15
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
16

obscuren's avatar
obscuren committed
17
package core
18 19

import (
20
	"fmt"
21
	"math"
22
	"math/big"
23

obscuren's avatar
obscuren committed
24
	"github.com/ethereum/go-ethereum/common"
obscuren's avatar
obscuren committed
25
	"github.com/ethereum/go-ethereum/core/vm"
26
	"github.com/ethereum/go-ethereum/params"
27 28
)

obscuren's avatar
obscuren committed
29
/*
30 31 32
The State Transitioning Model

A state transition is a change made when a transaction is applied to the current world state
33
The state transitioning model does all the necessary work to work out a valid new state root.
34 35 36 37 38 39 40 41 42 43 44 45

1) Nonce handling
2) Pre pay gas
3) Create a new state object if the recipient is \0*32
4) Value transfer
== If contract creation ==
  4a) Attempt to run transaction data
  4b) If valid, use result as code for the new state object
== end ==
5) Run Script section
6) Derive new state root
*/
46
type StateTransition struct {
47 48 49 50
	gp         *GasPool
	msg        Message
	gas        uint64
	gasPrice   *big.Int
51
	initialGas uint64
52 53 54
	value      *big.Int
	data       []byte
	state      vm.StateDB
55
	evm        *vm.EVM
56 57
}

58
// Message represents a message sent to a contract.
59
type Message interface {
60
	From() common.Address
61
	To() *common.Address
62 63

	GasPrice() *big.Int
64
	Gas() uint64
65 66 67
	Value() *big.Int

	Nonce() uint64
68
	CheckNonce() bool
69
	Data() []byte
70
}
obscuren's avatar
obscuren committed
71

72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
// ExecutionResult includes all output after executing given evm
// message no matter the execution itself is successful or not.
type ExecutionResult struct {
	UsedGas    uint64 // Total used gas but include the refunded gas
	Err        error  // Any error encountered during the execution(listed in core/vm/errors.go)
	ReturnData []byte // Returned data from evm(function result or data supplied with revert opcode)
}

// Unwrap returns the internal evm error which allows us for further
// analysis outside.
func (result *ExecutionResult) Unwrap() error {
	return result.Err
}

// Failed returns the indicator whether the execution is successful or not
func (result *ExecutionResult) Failed() bool { return result.Err != nil }

// Return is a helper function to help caller distinguish between revert reason
// and function return. Return returns the data after execution if no error occurs.
func (result *ExecutionResult) Return() []byte {
	if result.Err != nil {
		return nil
	}
	return common.CopyBytes(result.ReturnData)
}

// Revert returns the concrete revert reason if the execution is aborted by `REVERT`
// opcode. Note the reason can be nil if no data supplied with revert opcode.
func (result *ExecutionResult) Revert() []byte {
	if result.Err != vm.ErrExecutionReverted {
		return nil
	}
	return common.CopyBytes(result.ReturnData)
}

107
// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
108
func IntrinsicGas(data []byte, contractCreation, isHomestead bool, isEIP2028 bool) (uint64, error) {
109 110
	// Set the starting gas for the raw transaction
	var gas uint64
111
	if contractCreation && isHomestead {
112
		gas = params.TxGasContractCreation
113
	} else {
114
		gas = params.TxGas
115
	}
116
	// Bump the required gas by the amount of transactional data
117
	if len(data) > 0 {
118 119
		// Zero and non-zero bytes are priced differently
		var nz uint64
120 121 122 123
		for _, byt := range data {
			if byt != 0 {
				nz++
			}
obscuren's avatar
obscuren committed
124
		}
125
		// Make sure we don't exceed uint64 for all data combinations
126 127 128 129 130
		nonZeroGas := params.TxDataNonZeroGasFrontier
		if isEIP2028 {
			nonZeroGas = params.TxDataNonZeroGasEIP2028
		}
		if (math.MaxUint64-gas)/nonZeroGas < nz {
131
			return 0, ErrGasUintOverflow
132
		}
133
		gas += nz * nonZeroGas
134 135 136

		z := uint64(len(data)) - nz
		if (math.MaxUint64-gas)/params.TxDataZeroGas < z {
137
			return 0, ErrGasUintOverflow
138 139
		}
		gas += z * params.TxDataZeroGas
obscuren's avatar
obscuren committed
140
	}
141
	return gas, nil
obscuren's avatar
obscuren committed
142 143
}

144
// NewStateTransition initialises and returns a new state transition object.
145
func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition {
146
	return &StateTransition{
147 148 149 150 151 152 153
		gp:       gp,
		evm:      evm,
		msg:      msg,
		gasPrice: msg.GasPrice(),
		value:    msg.Value(),
		data:     msg.Data(),
		state:    evm.StateDB,
154
	}
155 156 157 158 159 160 161 162 163
}

// ApplyMessage computes the new state by applying the given message
// against the old state within the environment.
//
// ApplyMessage returns the bytes returned by any EVM execution (if it took place),
// the gas used (which includes gas refunds) and an error if it failed. An error always
// indicates a core error meaning that the message would always fail for that particular
// state and would never be accepted within a block.
164
func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) (*ExecutionResult, error) {
165
	return NewStateTransition(evm, msg, gp).TransitionDb()
166 167
}

168 169 170 171
// to returns the recipient of the message.
func (st *StateTransition) to() common.Address {
	if st.msg == nil || st.msg.To() == nil /* contract creation */ {
		return common.Address{}
172
	}
173
	return *st.msg.To()
174 175
}

176
func (st *StateTransition) buyGas() error {
177
	mgval := new(big.Int).Mul(new(big.Int).SetUint64(st.msg.Gas()), st.gasPrice)
178 179
	if have, want := st.state.GetBalance(st.msg.From()), mgval; have.Cmp(want) < 0 {
		return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From().Hex(), have, want)
180
	}
181
	if err := st.gp.SubGas(st.msg.Gas()); err != nil {
182 183
		return err
	}
184
	st.gas += st.msg.Gas()
185

186
	st.initialGas = st.msg.Gas()
187
	st.state.SubBalance(st.msg.From(), mgval)
188 189 190
	return nil
}

191
func (st *StateTransition) preCheck() error {
192 193
	// Make sure this transaction's nonce is correct.
	if st.msg.CheckNonce() {
194 195 196 197 198 199 200
		stNonce := st.state.GetNonce(st.msg.From())
		if msgNonce := st.msg.Nonce(); stNonce < msgNonce {
			return fmt.Errorf("%w: address %v, tx: %d state: %d", ErrNonceTooHigh,
				st.msg.From().Hex(), msgNonce, stNonce)
		} else if stNonce > msgNonce {
			return fmt.Errorf("%w: address %v, tx: %d state: %d", ErrNonceTooLow,
				st.msg.From().Hex(), msgNonce, stNonce)
201
		}
202
	}
203
	return st.buyGas()
204 205
}

206
// TransitionDb will transition the state by applying the current message and
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
// returning the evm execution result with following fields.
//
// - used gas:
//      total gas used (including gas being refunded)
// - returndata:
//      the returned data from evm
// - concrete execution error:
//      various **EVM** error which aborts the execution,
//      e.g. ErrOutOfGas, ErrExecutionReverted
//
// However if any consensus issue encountered, return the error directly with
// nil evm execution result.
func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
	// First check this message satisfies all consensus rules before
	// applying the message. The rules include these clauses
	//
	// 1. the nonce of the message caller is correct
	// 2. caller has enough balance to cover transaction fee(gaslimit * gasprice)
	// 3. the amount of gas required is available in the block
	// 4. the purchased gas is enough to cover intrinsic usage
	// 5. there is no overflow when calculating intrinsic gas
	// 6. caller has enough balance to cover asset transfer for **topmost** call

	// Check clauses 1-3, buy gas if everything is correct
	if err := st.preCheck(); err != nil {
		return nil, err
233
	}
234
	msg := st.msg
235
	sender := vm.AccountRef(msg.From())
236 237
	homestead := st.evm.ChainConfig().IsHomestead(st.evm.Context.BlockNumber)
	istanbul := st.evm.ChainConfig().IsIstanbul(st.evm.Context.BlockNumber)
238
	contractCreation := msg.To() == nil
239

240
	// Check clauses 4-5, subtract intrinsic gas if everything is correct
241
	gas, err := IntrinsicGas(st.data, contractCreation, homestead, istanbul)
242
	if err != nil {
243
		return nil, err
244
	}
245
	if st.gas < gas {
246
		return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gas, gas)
247
	}
248
	st.gas -= gas
249

250
	// Check clause 6
251
	if msg.Value().Sign() > 0 && !st.evm.Context.CanTransfer(st.state, msg.From(), msg.Value()) {
252
		return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From().Hex())
253
	}
254
	var (
255 256
		ret   []byte
		vmerr error // vm errors do not effect consensus and are therefore not assigned to err
257
	)
258
	if contractCreation {
259
		ret, _, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
obscuren's avatar
obscuren committed
260
	} else {
obscuren's avatar
obscuren committed
261
		// Increment the nonce for the next transaction
262
		st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
263
		ret, st.gas, vmerr = st.evm.Call(sender, st.to(), st.data, st.gas, st.value)
264
	}
265
	st.refundGas()
266
	st.state.AddBalance(st.evm.Context.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))
267

268 269 270 271 272
	return &ExecutionResult{
		UsedGas:    st.gasUsed(),
		Err:        vmerr,
		ReturnData: ret,
	}, nil
273
}
obscuren's avatar
obscuren committed
274

275
func (st *StateTransition) refundGas() {
276
	// Apply refund counter, capped to half of the used gas.
277 278 279 280 281
	refund := st.gasUsed() / 2
	if refund > st.state.GetRefund() {
		refund = st.state.GetRefund()
	}
	st.gas += refund
282

283 284
	// Return ETH for remaining gas, exchanged at the original rate.
	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
285
	st.state.AddBalance(st.msg.From(), remaining)
obscuren's avatar
obscuren committed
286

287 288
	// Also return remaining gas to the block gas counter so it is
	// available for the next transaction.
289
	st.gp.AddGas(st.gas)
obscuren's avatar
obscuren committed
290 291
}

292 293 294
// gasUsed returns the amount of gas used up by the state transition.
func (st *StateTransition) gasUsed() uint64 {
	return st.initialGas - st.gas
obscuren's avatar
obscuren committed
295
}