2015-07-06 19:54:22 -05:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 11:48:40 -05:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-06 19:54:22 -05:00
|
|
|
//
|
2015-07-23 11:35:11 -05:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-06 19:54:22 -05:00
|
|
|
// 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.
|
|
|
|
//
|
2015-07-22 11:48:40 -05:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-06 19:54:22 -05:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 11:48:40 -05:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 19:54:22 -05:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 11:48:40 -05:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 19:54:22 -05:00
|
|
|
|
2014-12-04 03:28:02 -06:00
|
|
|
package core
|
2014-06-13 05:58:01 -05:00
|
|
|
|
|
|
|
import (
|
2020-12-04 05:22:19 -06:00
|
|
|
"fmt"
|
2017-11-13 05:47:27 -06:00
|
|
|
"math"
|
2014-07-29 17:31:15 -05:00
|
|
|
"math/big"
|
2015-03-09 12:05:56 -05:00
|
|
|
|
2015-03-16 05:27:38 -05:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2021-05-17 08:13:22 -05:00
|
|
|
cmath "github.com/ethereum/go-ethereum/common/math"
|
2021-02-25 08:26:57 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2015-03-23 10:59:09 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2024-01-19 04:41:17 -06:00
|
|
|
"github.com/ethereum/go-ethereum/crypto/kzg4844"
|
2015-04-01 22:17:15 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2024-01-23 07:51:58 -06:00
|
|
|
"github.com/holiman/uint256"
|
2014-06-13 05:58:01 -05:00
|
|
|
)
|
|
|
|
|
2020-04-22 03:25:36 -05:00
|
|
|
// ExecutionResult includes all output after executing given evm
|
|
|
|
// message no matter the execution itself is successful or not.
|
|
|
|
type ExecutionResult struct {
|
2023-11-28 14:31:47 -06:00
|
|
|
UsedGas uint64 // Total used gas, not including the refunded gas
|
|
|
|
RefundedGas uint64 // Total gas refunded after execution
|
|
|
|
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)
|
2020-04-22 03:25:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2017-11-13 05:47:27 -06:00
|
|
|
// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
|
2024-02-21 02:00:01 -06:00
|
|
|
func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation bool, isHomestead, isEIP2028, isEIP3860 bool) (uint64, error) {
|
2017-11-13 05:47:27 -06:00
|
|
|
// Set the starting gas for the raw transaction
|
|
|
|
var gas uint64
|
2021-02-25 08:26:57 -06:00
|
|
|
if isContractCreation && isHomestead {
|
2017-11-13 05:47:27 -06:00
|
|
|
gas = params.TxGasContractCreation
|
2015-11-27 08:40:29 -06:00
|
|
|
} else {
|
2017-11-13 05:47:27 -06:00
|
|
|
gas = params.TxGas
|
2015-11-27 08:40:29 -06:00
|
|
|
}
|
2023-01-11 03:05:47 -06:00
|
|
|
dataLen := uint64(len(data))
|
2017-11-13 05:47:27 -06:00
|
|
|
// Bump the required gas by the amount of transactional data
|
2023-01-11 03:05:47 -06:00
|
|
|
if dataLen > 0 {
|
2017-11-13 05:47:27 -06:00
|
|
|
// Zero and non-zero bytes are priced differently
|
|
|
|
var nz uint64
|
2015-06-25 07:46:44 -05:00
|
|
|
for _, byt := range data {
|
|
|
|
if byt != 0 {
|
|
|
|
nz++
|
|
|
|
}
|
2015-04-08 13:47:32 -05:00
|
|
|
}
|
2017-11-13 05:47:27 -06:00
|
|
|
// Make sure we don't exceed uint64 for all data combinations
|
2019-08-14 07:53:21 -05:00
|
|
|
nonZeroGas := params.TxDataNonZeroGasFrontier
|
|
|
|
if isEIP2028 {
|
|
|
|
nonZeroGas = params.TxDataNonZeroGasEIP2028
|
|
|
|
}
|
|
|
|
if (math.MaxUint64-gas)/nonZeroGas < nz {
|
2020-04-22 03:25:36 -05:00
|
|
|
return 0, ErrGasUintOverflow
|
2017-11-13 05:47:27 -06:00
|
|
|
}
|
2019-08-14 07:53:21 -05:00
|
|
|
gas += nz * nonZeroGas
|
2017-11-13 05:47:27 -06:00
|
|
|
|
2023-01-11 03:05:47 -06:00
|
|
|
z := dataLen - nz
|
2017-11-13 05:47:27 -06:00
|
|
|
if (math.MaxUint64-gas)/params.TxDataZeroGas < z {
|
2020-04-22 03:25:36 -05:00
|
|
|
return 0, ErrGasUintOverflow
|
2017-11-13 05:47:27 -06:00
|
|
|
}
|
|
|
|
gas += z * params.TxDataZeroGas
|
2023-01-11 03:05:47 -06:00
|
|
|
|
|
|
|
if isContractCreation && isEIP3860 {
|
|
|
|
lenWords := toWordSize(dataLen)
|
|
|
|
if (math.MaxUint64-gas)/params.InitCodeWordGas < lenWords {
|
|
|
|
return 0, ErrGasUintOverflow
|
|
|
|
}
|
|
|
|
gas += lenWords * params.InitCodeWordGas
|
|
|
|
}
|
2015-04-08 13:47:32 -05:00
|
|
|
}
|
2021-02-25 08:26:57 -06:00
|
|
|
if accessList != nil {
|
|
|
|
gas += uint64(len(accessList)) * params.TxAccessListAddressGas
|
|
|
|
gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas
|
|
|
|
}
|
2017-11-13 05:47:27 -06:00
|
|
|
return gas, nil
|
2015-04-08 13:47:32 -05:00
|
|
|
}
|
|
|
|
|
2023-01-11 03:05:47 -06:00
|
|
|
// toWordSize returns the ceiled word size required for init code payment calculation.
|
|
|
|
func toWordSize(size uint64) uint64 {
|
|
|
|
if size > math.MaxUint64-31 {
|
|
|
|
return math.MaxUint64/32 + 1
|
|
|
|
}
|
|
|
|
|
|
|
|
return (size + 31) / 32
|
|
|
|
}
|
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
// A Message contains the data derived from a single transaction that is relevant to state
|
|
|
|
// processing.
|
|
|
|
type Message struct {
|
2023-07-15 16:27:36 -05:00
|
|
|
To *common.Address
|
|
|
|
From common.Address
|
|
|
|
Nonce uint64
|
|
|
|
Value *big.Int
|
|
|
|
GasLimit uint64
|
|
|
|
GasPrice *big.Int
|
|
|
|
GasFeeCap *big.Int
|
|
|
|
GasTipCap *big.Int
|
|
|
|
Data []byte
|
|
|
|
AccessList types.AccessList
|
|
|
|
BlobGasFeeCap *big.Int
|
|
|
|
BlobHashes []common.Hash
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
|
2023-04-05 06:09:25 -05:00
|
|
|
// When SkipAccountChecks is true, the message nonce is not checked against the
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
// account nonce in state. It also disables checking that the sender is an EOA.
|
|
|
|
// This field will be set to true for operations like RPC eth_call.
|
|
|
|
SkipAccountChecks bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// TransactionToMessage converts a transaction into a Message.
|
|
|
|
func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) {
|
|
|
|
msg := &Message{
|
|
|
|
Nonce: tx.Nonce(),
|
|
|
|
GasLimit: tx.Gas(),
|
|
|
|
GasPrice: new(big.Int).Set(tx.GasPrice()),
|
|
|
|
GasFeeCap: new(big.Int).Set(tx.GasFeeCap()),
|
|
|
|
GasTipCap: new(big.Int).Set(tx.GasTipCap()),
|
|
|
|
To: tx.To(),
|
|
|
|
Value: tx.Value(),
|
|
|
|
Data: tx.Data(),
|
|
|
|
AccessList: tx.AccessList(),
|
|
|
|
SkipAccountChecks: false,
|
2023-06-05 08:43:25 -05:00
|
|
|
BlobHashes: tx.BlobHashes(),
|
2023-07-15 16:27:36 -05:00
|
|
|
BlobGasFeeCap: tx.BlobGasFeeCap(),
|
2014-12-18 08:18:13 -06:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
// If baseFee provided, set gasPrice to effectiveGasPrice.
|
|
|
|
if baseFee != nil {
|
|
|
|
msg.GasPrice = cmath.BigMin(msg.GasPrice.Add(msg.GasTipCap, baseFee), msg.GasFeeCap)
|
|
|
|
}
|
|
|
|
var err error
|
|
|
|
msg.From, err = types.Sender(s, tx)
|
|
|
|
return msg, err
|
2016-03-31 17:30:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool) (*ExecutionResult, error) {
|
2017-11-13 05:47:27 -06:00
|
|
|
return NewStateTransition(evm, msg, gp).TransitionDb()
|
2014-06-13 05:58:01 -05:00
|
|
|
}
|
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
// StateTransition represents a state transition.
|
|
|
|
//
|
|
|
|
// == The State Transitioning Model
|
|
|
|
//
|
|
|
|
// A state transition is a change made when a transaction is applied to the current world
|
|
|
|
// state. The state transitioning model does all the necessary work to work out a valid new
|
|
|
|
// state root.
|
|
|
|
//
|
|
|
|
// 1. Nonce handling
|
|
|
|
// 2. Pre pay gas
|
|
|
|
// 3. Create a new state object if the recipient is nil
|
|
|
|
// 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
|
|
|
|
type StateTransition struct {
|
|
|
|
gp *GasPool
|
|
|
|
msg *Message
|
|
|
|
gasRemaining uint64
|
|
|
|
initialGas uint64
|
|
|
|
state vm.StateDB
|
|
|
|
evm *vm.EVM
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewStateTransition initialises and returns a new state transition object.
|
|
|
|
func NewStateTransition(evm *vm.EVM, msg *Message, gp *GasPool) *StateTransition {
|
|
|
|
return &StateTransition{
|
|
|
|
gp: gp,
|
|
|
|
evm: evm,
|
|
|
|
msg: msg,
|
|
|
|
state: evm.StateDB,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-10 08:33:25 -05:00
|
|
|
// to returns the recipient of the message.
|
|
|
|
func (st *StateTransition) to() common.Address {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if st.msg == nil || st.msg.To == nil /* contract creation */ {
|
2018-04-10 08:33:25 -05:00
|
|
|
return common.Address{}
|
2015-08-30 03:19:10 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
return *st.msg.To
|
2014-06-13 05:58:01 -05:00
|
|
|
}
|
|
|
|
|
2017-05-10 20:55:48 -05:00
|
|
|
func (st *StateTransition) buyGas() error {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
mgval := new(big.Int).SetUint64(st.msg.GasLimit)
|
2024-03-05 07:48:27 -06:00
|
|
|
mgval.Mul(mgval, st.msg.GasPrice)
|
2023-07-15 16:27:36 -05:00
|
|
|
balanceCheck := new(big.Int).Set(mgval)
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if st.msg.GasFeeCap != nil {
|
2023-07-15 16:27:36 -05:00
|
|
|
balanceCheck.SetUint64(st.msg.GasLimit)
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
balanceCheck = balanceCheck.Mul(balanceCheck, st.msg.GasFeeCap)
|
|
|
|
balanceCheck.Add(balanceCheck, st.msg.Value)
|
2021-05-30 12:37:52 -05:00
|
|
|
}
|
2023-07-15 16:27:36 -05:00
|
|
|
if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) {
|
2023-07-27 08:53:28 -05:00
|
|
|
if blobGas := st.blobGasUsed(); blobGas > 0 {
|
|
|
|
// Check that the user has enough funds to cover blobGasUsed * tx.BlobGasFeeCap
|
|
|
|
blobBalanceCheck := new(big.Int).SetUint64(blobGas)
|
2023-07-15 16:27:36 -05:00
|
|
|
blobBalanceCheck.Mul(blobBalanceCheck, st.msg.BlobGasFeeCap)
|
|
|
|
balanceCheck.Add(balanceCheck, blobBalanceCheck)
|
2023-07-27 08:53:28 -05:00
|
|
|
// Pay for blobGasUsed * actual blob fee
|
|
|
|
blobFee := new(big.Int).SetUint64(blobGas)
|
2023-10-02 04:49:29 -05:00
|
|
|
blobFee.Mul(blobFee, st.evm.Context.BlobBaseFee)
|
2023-07-15 16:27:36 -05:00
|
|
|
mgval.Add(mgval, blobFee)
|
|
|
|
}
|
|
|
|
}
|
2024-01-23 07:51:58 -06:00
|
|
|
balanceCheckU256, overflow := uint256.FromBig(balanceCheck)
|
|
|
|
if overflow {
|
|
|
|
return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex())
|
|
|
|
}
|
|
|
|
if have, want := st.state.GetBalance(st.msg.From), balanceCheckU256; have.Cmp(want) < 0 {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want)
|
2014-06-13 05:58:01 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if err := st.gp.SubGas(st.msg.GasLimit); err != nil {
|
2014-06-13 05:58:01 -05:00
|
|
|
return err
|
|
|
|
}
|
2024-03-05 02:47:58 -06:00
|
|
|
st.gasRemaining = st.msg.GasLimit
|
2017-01-04 13:17:24 -06:00
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.initialGas = st.msg.GasLimit
|
2024-01-23 07:51:58 -06:00
|
|
|
mgvalU256, _ := uint256.FromBig(mgval)
|
|
|
|
st.state.SubBalance(st.msg.From, mgvalU256)
|
2014-06-13 05:58:01 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-05-10 20:55:48 -05:00
|
|
|
func (st *StateTransition) preCheck() error {
|
2021-08-23 04:49:39 -05:00
|
|
|
// Only check transactions that are not fake
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg := st.msg
|
|
|
|
if !msg.SkipAccountChecks {
|
2021-08-23 04:49:39 -05:00
|
|
|
// Make sure this transaction's nonce is correct.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
stNonce := st.state.GetNonce(msg.From)
|
|
|
|
if msgNonce := msg.Nonce; stNonce < msgNonce {
|
2020-12-04 05:22:19 -06:00
|
|
|
return fmt.Errorf("%w: address %v, tx: %d state: %d", ErrNonceTooHigh,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), msgNonce, stNonce)
|
2020-12-04 05:22:19 -06:00
|
|
|
} else if stNonce > msgNonce {
|
|
|
|
return fmt.Errorf("%w: address %v, tx: %d state: %d", ErrNonceTooLow,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), msgNonce, stNonce)
|
2021-11-11 08:00:58 -06:00
|
|
|
} else if stNonce+1 < stNonce {
|
|
|
|
return fmt.Errorf("%w: address %v, nonce: %d", ErrNonceMax,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), stNonce)
|
2016-07-11 04:58:10 -05:00
|
|
|
}
|
2021-08-23 04:49:39 -05:00
|
|
|
// Make sure the sender is an EOA
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
codeHash := st.state.GetCodeHash(msg.From)
|
|
|
|
if codeHash != (common.Hash{}) && codeHash != types.EmptyCodeHash {
|
2021-08-23 04:49:39 -05:00
|
|
|
return fmt.Errorf("%w: address %v, codehash: %s", ErrSenderNoEOA,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), codeHash)
|
2021-08-23 04:49:39 -05:00
|
|
|
}
|
2021-08-07 12:38:18 -05:00
|
|
|
}
|
2021-06-08 05:05:41 -05:00
|
|
|
// Make sure that transaction gasFeeCap is greater than the baseFee (post london)
|
2021-05-17 08:13:22 -05:00
|
|
|
if st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) {
|
2021-06-10 00:02:51 -05:00
|
|
|
// Skip the checks if gas fields are zero and baseFee was explicitly disabled (eth_call)
|
2023-11-08 03:22:08 -06:00
|
|
|
skipCheck := st.evm.Config.NoBaseFee && msg.GasFeeCap.BitLen() == 0 && msg.GasTipCap.BitLen() == 0
|
|
|
|
if !skipCheck {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if l := msg.GasFeeCap.BitLen(); l > 256 {
|
2021-06-10 00:02:51 -05:00
|
|
|
return fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), l)
|
2021-06-10 00:02:51 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if l := msg.GasTipCap.BitLen(); l > 256 {
|
2021-06-10 00:02:51 -05:00
|
|
|
return fmt.Errorf("%w: address %v, maxPriorityFeePerGas bit length: %d", ErrTipVeryHigh,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), l)
|
2021-06-10 00:02:51 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if msg.GasFeeCap.Cmp(msg.GasTipCap) < 0 {
|
2021-06-10 00:02:51 -05:00
|
|
|
return fmt.Errorf("%w: address %v, maxPriorityFeePerGas: %s, maxFeePerGas: %s", ErrTipAboveFeeCap,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap)
|
2021-06-10 00:02:51 -05:00
|
|
|
}
|
|
|
|
// This will panic if baseFee is nil, but basefee presence is verified
|
|
|
|
// as part of header validation.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if msg.GasFeeCap.Cmp(st.evm.Context.BaseFee) < 0 {
|
2023-11-08 03:22:08 -06:00
|
|
|
return fmt.Errorf("%w: address %v, maxFeePerGas: %s, baseFee: %s", ErrFeeCapTooLow,
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg.From.Hex(), msg.GasFeeCap, st.evm.Context.BaseFee)
|
2021-06-10 00:02:51 -05:00
|
|
|
}
|
2021-05-17 08:13:22 -05:00
|
|
|
}
|
|
|
|
}
|
2023-07-15 16:27:36 -05:00
|
|
|
// Check the blob version validity
|
|
|
|
if msg.BlobHashes != nil {
|
2024-01-17 08:06:14 -06:00
|
|
|
// The to field of a blob tx type is mandatory, and a `BlobTx` transaction internally
|
|
|
|
// has it as a non-nillable value, so any msg derived from blob transaction has it non-nil.
|
|
|
|
// However, messages created through RPC (eth_call) don't have this restriction.
|
|
|
|
if msg.To == nil {
|
|
|
|
return ErrBlobTxCreate
|
|
|
|
}
|
2023-07-15 16:27:36 -05:00
|
|
|
if len(msg.BlobHashes) == 0 {
|
2024-01-17 08:06:14 -06:00
|
|
|
return ErrMissingBlobHashes
|
2023-07-15 16:27:36 -05:00
|
|
|
}
|
|
|
|
for i, hash := range msg.BlobHashes {
|
2024-01-19 04:41:17 -06:00
|
|
|
if !kzg4844.IsValidVersionedHash(hash[:]) {
|
|
|
|
return fmt.Errorf("blob %d has invalid hash version", i)
|
2023-07-15 16:27:36 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-11-08 03:22:08 -06:00
|
|
|
// Check that the user is paying at least the current blob fee
|
2023-07-15 16:27:36 -05:00
|
|
|
if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) {
|
2023-07-27 08:53:28 -05:00
|
|
|
if st.blobGasUsed() > 0 {
|
2023-11-08 03:22:08 -06:00
|
|
|
// Skip the checks if gas fields are zero and blobBaseFee was explicitly disabled (eth_call)
|
|
|
|
skipCheck := st.evm.Config.NoBaseFee && msg.BlobGasFeeCap.BitLen() == 0
|
|
|
|
if !skipCheck {
|
|
|
|
// This will panic if blobBaseFee is nil, but blobBaseFee presence
|
|
|
|
// is verified as part of header validation.
|
|
|
|
if msg.BlobGasFeeCap.Cmp(st.evm.Context.BlobBaseFee) < 0 {
|
|
|
|
return fmt.Errorf("%w: address %v blobGasFeeCap: %v, blobBaseFee: %v", ErrBlobFeeCapTooLow,
|
|
|
|
msg.From.Hex(), msg.BlobGasFeeCap, st.evm.Context.BlobBaseFee)
|
|
|
|
}
|
2023-07-15 16:27:36 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-05-10 20:55:48 -05:00
|
|
|
return st.buyGas()
|
2014-06-19 06:41:17 -05:00
|
|
|
}
|
|
|
|
|
2017-11-13 05:47:27 -06:00
|
|
|
// TransitionDb will transition the state by applying the current message and
|
2020-04-22 03:25:36 -05:00
|
|
|
// returning the evm execution result with following fields.
|
|
|
|
//
|
2022-09-10 06:25:40 -05:00
|
|
|
// - used gas: total gas used (including gas being refunded)
|
|
|
|
// - returndata: the returned data from evm
|
|
|
|
// - concrete execution error: various EVM errors which abort the execution, e.g.
|
|
|
|
// ErrOutOfGas, ErrExecutionReverted
|
2020-04-22 03:25:36 -05:00
|
|
|
//
|
|
|
|
// 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
|
2014-06-19 06:41:17 -05:00
|
|
|
}
|
2022-03-31 04:51:44 -05:00
|
|
|
|
2023-04-04 08:50:13 -05:00
|
|
|
if tracer := st.evm.Config.Tracer; tracer != nil {
|
|
|
|
tracer.CaptureTxStart(st.initialGas)
|
2022-03-31 04:51:44 -05:00
|
|
|
defer func() {
|
2023-04-04 08:50:13 -05:00
|
|
|
tracer.CaptureTxEnd(st.gasRemaining)
|
2022-03-31 04:51:44 -05:00
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
|
|
|
msg = st.msg
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
sender = vm.AccountRef(msg.From)
|
2022-09-27 06:42:57 -05:00
|
|
|
rules = st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber, st.evm.Context.Random != nil, st.evm.Context.Time)
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
contractCreation = msg.To == nil
|
2022-03-31 04:51:44 -05:00
|
|
|
)
|
2017-05-10 20:55:48 -05:00
|
|
|
|
2020-04-22 03:25:36 -05:00
|
|
|
// Check clauses 4-5, subtract intrinsic gas if everything is correct
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
gas, err := IntrinsicGas(msg.Data, msg.AccessList, contractCreation, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai)
|
2018-02-14 14:02:51 -06:00
|
|
|
if err != nil {
|
2020-04-22 03:25:36 -05:00
|
|
|
return nil, err
|
2018-02-14 14:02:51 -06:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if st.gasRemaining < gas {
|
|
|
|
return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining, gas)
|
2014-06-13 05:58:01 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.gasRemaining -= gas
|
2014-06-13 05:58:01 -05:00
|
|
|
|
2020-04-22 03:25:36 -05:00
|
|
|
// Check clause 6
|
2024-01-23 07:51:58 -06:00
|
|
|
value, overflow := uint256.FromBig(msg.Value)
|
|
|
|
if overflow {
|
|
|
|
return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From.Hex())
|
|
|
|
}
|
|
|
|
if !value.IsZero() && !st.evm.Context.CanTransfer(st.state, msg.From, value) {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From.Hex())
|
2020-04-22 03:25:36 -05:00
|
|
|
}
|
2021-02-25 08:26:57 -06:00
|
|
|
|
2023-01-11 03:05:47 -06:00
|
|
|
// Check whether the init code size has been exceeded.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if rules.IsShanghai && contractCreation && len(msg.Data) > params.MaxInitCodeSize {
|
|
|
|
return nil, fmt.Errorf("%w: code size %v limit %v", ErrMaxInitCodeSizeExceeded, len(msg.Data), params.MaxInitCodeSize)
|
2023-01-11 03:05:47 -06:00
|
|
|
}
|
|
|
|
|
2022-11-16 03:18:52 -06:00
|
|
|
// Execute the preparatory steps for state transition which includes:
|
|
|
|
// - prepare accessList(post-berlin)
|
|
|
|
// - reset transient storage(eip 1153)
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.state.Prepare(rules, msg.From, st.evm.Context.Coinbase, msg.To, vm.ActivePrecompiles(rules), msg.AccessList)
|
2022-11-16 03:18:52 -06:00
|
|
|
|
2016-12-05 19:16:03 -06:00
|
|
|
var (
|
2020-04-22 03:25:36 -05:00
|
|
|
ret []byte
|
|
|
|
vmerr error // vm errors do not effect consensus and are therefore not assigned to err
|
2016-12-05 19:16:03 -06:00
|
|
|
)
|
2015-11-27 08:40:29 -06:00
|
|
|
if contractCreation {
|
2024-01-23 07:51:58 -06:00
|
|
|
ret, _, st.gasRemaining, vmerr = st.evm.Create(sender, msg.Data, st.gasRemaining, value)
|
2014-07-07 06:59:09 -05:00
|
|
|
} else {
|
2015-03-24 09:23:16 -05:00
|
|
|
// Increment the nonce for the next transaction
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.state.SetNonce(msg.From, st.state.GetNonce(sender.Address())+1)
|
2024-01-23 07:51:58 -06:00
|
|
|
ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), msg.Data, st.gasRemaining, value)
|
2015-07-06 04:54:11 -05:00
|
|
|
}
|
2021-08-09 09:34:20 -05:00
|
|
|
|
2023-11-28 14:31:47 -06:00
|
|
|
var gasRefund uint64
|
2022-03-31 04:51:44 -05:00
|
|
|
if !rules.IsLondon {
|
2021-05-07 01:25:32 -05:00
|
|
|
// Before EIP-3529: refunds were capped to gasUsed / 2
|
2023-11-28 14:31:47 -06:00
|
|
|
gasRefund = st.refundGas(params.RefundQuotient)
|
2021-05-07 01:25:32 -05:00
|
|
|
} else {
|
|
|
|
// After EIP-3529: refunds are capped to gasUsed / 5
|
2023-11-28 14:31:47 -06:00
|
|
|
gasRefund = st.refundGas(params.RefundQuotientEIP3529)
|
2021-05-07 01:25:32 -05:00
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
effectiveTip := msg.GasPrice
|
2022-03-31 04:51:44 -05:00
|
|
|
if rules.IsLondon {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
effectiveTip = cmath.BigMin(msg.GasTipCap, new(big.Int).Sub(msg.GasFeeCap, st.evm.Context.BaseFee))
|
2021-05-17 08:13:22 -05:00
|
|
|
}
|
2024-01-23 07:51:58 -06:00
|
|
|
effectiveTipU256, _ := uint256.FromBig(effectiveTip)
|
2022-07-15 04:32:54 -05:00
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
if st.evm.Config.NoBaseFee && msg.GasFeeCap.Sign() == 0 && msg.GasTipCap.Sign() == 0 {
|
2022-07-15 04:32:54 -05:00
|
|
|
// Skip fee payment when NoBaseFee is set and the fee fields
|
|
|
|
// are 0. This avoids a negative effectiveTip being applied to
|
|
|
|
// the coinbase when simulating calls.
|
|
|
|
} else {
|
2024-01-23 07:51:58 -06:00
|
|
|
fee := new(uint256.Int).SetUint64(st.gasUsed())
|
|
|
|
fee.Mul(fee, effectiveTipU256)
|
2022-07-15 04:32:54 -05:00
|
|
|
st.state.AddBalance(st.evm.Context.Coinbase, fee)
|
|
|
|
}
|
2014-07-24 05:04:15 -05:00
|
|
|
|
2020-04-22 03:25:36 -05:00
|
|
|
return &ExecutionResult{
|
2023-11-28 14:31:47 -06:00
|
|
|
UsedGas: st.gasUsed(),
|
|
|
|
RefundedGas: gasRefund,
|
|
|
|
Err: vmerr,
|
|
|
|
ReturnData: ret,
|
2020-04-22 03:25:36 -05:00
|
|
|
}, nil
|
2014-07-24 05:04:15 -05:00
|
|
|
}
|
2014-12-18 14:58:26 -06:00
|
|
|
|
2023-11-28 14:31:47 -06:00
|
|
|
func (st *StateTransition) refundGas(refundQuotient uint64) uint64 {
|
2021-05-07 01:25:32 -05:00
|
|
|
// Apply refund counter, capped to a refund quotient
|
|
|
|
refund := st.gasUsed() / refundQuotient
|
2017-11-13 05:47:27 -06:00
|
|
|
if refund > st.state.GetRefund() {
|
|
|
|
refund = st.state.GetRefund()
|
|
|
|
}
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.gasRemaining += refund
|
2017-01-04 13:17:24 -06:00
|
|
|
|
2017-11-13 05:47:27 -06:00
|
|
|
// Return ETH for remaining gas, exchanged at the original rate.
|
2024-01-23 07:51:58 -06:00
|
|
|
remaining := uint256.NewInt(st.gasRemaining)
|
2024-03-05 07:48:27 -06:00
|
|
|
remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice))
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.state.AddBalance(st.msg.From, remaining)
|
2014-12-18 14:58:26 -06:00
|
|
|
|
2015-09-02 05:55:11 -05:00
|
|
|
// Also return remaining gas to the block gas counter so it is
|
|
|
|
// available for the next transaction.
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
st.gp.AddGas(st.gasRemaining)
|
2023-11-28 14:31:47 -06:00
|
|
|
|
|
|
|
return refund
|
2014-12-18 14:58:26 -06:00
|
|
|
}
|
|
|
|
|
2017-11-13 05:47:27 -06:00
|
|
|
// gasUsed returns the amount of gas used up by the state transition.
|
|
|
|
func (st *StateTransition) gasUsed() uint64 {
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
return st.initialGas - st.gasRemaining
|
2014-12-18 14:58:26 -06:00
|
|
|
}
|
2023-07-15 16:27:36 -05:00
|
|
|
|
2023-08-01 02:07:25 -05:00
|
|
|
// blobGasUsed returns the amount of blob gas used by the message.
|
2023-07-27 08:53:28 -05:00
|
|
|
func (st *StateTransition) blobGasUsed() uint64 {
|
|
|
|
return uint64(len(st.msg.BlobHashes) * params.BlobTxBlobGasPerBlob)
|
2023-07-15 16:27:36 -05:00
|
|
|
}
|