|
|
|
|
// Copyright 2016 The go-ethereum Authors
|
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
|
//
|
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
|
// 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.
|
|
|
|
|
//
|
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
|
//
|
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
package vm
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
|
"github.com/ethereum/go-ethereum/core/stateless"
|
|
|
|
|
"github.com/ethereum/go-ethereum/core/tracing"
|
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
|
"github.com/ethereum/go-ethereum/params"
|
|
|
|
|
"github.com/ethereum/go-ethereum/trie/utils"
|
|
|
|
|
"github.com/holiman/uint256"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// StateDB is an EVM database for full state querying.
|
|
|
|
|
type StateDB interface {
|
|
|
|
|
CreateAccount(common.Address)
|
|
|
|
|
CreateContract(common.Address)
|
|
|
|
|
|
core/state: move state log mechanism to a separate layer (#30569)
This PR moves the logging/tracing-facilities out of `*state.StateDB`,
in to a wrapping struct which implements `vm.StateDB` instead.
In most places, it is a pretty straight-forward change:
- First, hoisting the invocations from state objects up to the statedb.
- Then making the mutation-methods simply return the previous value, so
that the external logging layer could log everything.
Some internal code uses the direct object-accessors to mutate the state,
particularly in testing and in setting up state overrides, which means
that these changes are unobservable for the hooked layer. Thus, configuring
the overrides are not necessarily part of the API we want to publish.
The trickiest part about the layering is that when the selfdestructs are
finally deleted during `Finalise`, there's the possibility that someone
sent some ether to it, which is burnt at that point, and thus needs to
be logged. The hooked layer reaches into the inner layer to figure out
these events.
In package `vm`, the conversion from `state.StateDB + hooks` into a
hooked `vm.StateDB` is performed where needed.
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
1 month ago
|
|
|
SubBalance(common.Address, *uint256.Int, tracing.BalanceChangeReason) uint256.Int
|
|
|
|
|
AddBalance(common.Address, *uint256.Int, tracing.BalanceChangeReason) uint256.Int
|
|
|
|
|
GetBalance(common.Address) *uint256.Int
|
|
|
|
|
|
|
|
|
|
GetNonce(common.Address) uint64
|
|
|
|
|
SetNonce(common.Address, uint64)
|
|
|
|
|
|
|
|
|
|
GetCodeHash(common.Address) common.Hash
|
|
|
|
|
GetCode(common.Address) []byte
|
|
|
|
|
SetCode(common.Address, []byte)
|
|
|
|
|
GetCodeSize(common.Address) int
|
|
|
|
|
|
|
|
|
|
AddRefund(uint64)
|
|
|
|
|
SubRefund(uint64)
|
|
|
|
|
GetRefund() uint64
|
|
|
|
|
|
|
|
|
|
GetCommittedState(common.Address, common.Hash) common.Hash
|
|
|
|
|
GetState(common.Address, common.Hash) common.Hash
|
core/state: move state log mechanism to a separate layer (#30569)
This PR moves the logging/tracing-facilities out of `*state.StateDB`,
in to a wrapping struct which implements `vm.StateDB` instead.
In most places, it is a pretty straight-forward change:
- First, hoisting the invocations from state objects up to the statedb.
- Then making the mutation-methods simply return the previous value, so
that the external logging layer could log everything.
Some internal code uses the direct object-accessors to mutate the state,
particularly in testing and in setting up state overrides, which means
that these changes are unobservable for the hooked layer. Thus, configuring
the overrides are not necessarily part of the API we want to publish.
The trickiest part about the layering is that when the selfdestructs are
finally deleted during `Finalise`, there's the possibility that someone
sent some ether to it, which is burnt at that point, and thus needs to
be logged. The hooked layer reaches into the inner layer to figure out
these events.
In package `vm`, the conversion from `state.StateDB + hooks` into a
hooked `vm.StateDB` is performed where needed.
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
1 month ago
|
|
|
SetState(common.Address, common.Hash, common.Hash) common.Hash
|
|
|
|
|
GetStorageRoot(addr common.Address) common.Hash
|
|
|
|
|
|
|
|
|
|
GetTransientState(addr common.Address, key common.Hash) common.Hash
|
|
|
|
|
SetTransientState(addr common.Address, key, value common.Hash)
|
|
|
|
|
|
core/state: move state log mechanism to a separate layer (#30569)
This PR moves the logging/tracing-facilities out of `*state.StateDB`,
in to a wrapping struct which implements `vm.StateDB` instead.
In most places, it is a pretty straight-forward change:
- First, hoisting the invocations from state objects up to the statedb.
- Then making the mutation-methods simply return the previous value, so
that the external logging layer could log everything.
Some internal code uses the direct object-accessors to mutate the state,
particularly in testing and in setting up state overrides, which means
that these changes are unobservable for the hooked layer. Thus, configuring
the overrides are not necessarily part of the API we want to publish.
The trickiest part about the layering is that when the selfdestructs are
finally deleted during `Finalise`, there's the possibility that someone
sent some ether to it, which is burnt at that point, and thus needs to
be logged. The hooked layer reaches into the inner layer to figure out
these events.
In package `vm`, the conversion from `state.StateDB + hooks` into a
hooked `vm.StateDB` is performed where needed.
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
1 month ago
|
|
|
SelfDestruct(common.Address) uint256.Int
|
|
|
|
|
HasSelfDestructed(common.Address) bool
|
|
|
|
|
|
core/state: move state log mechanism to a separate layer (#30569)
This PR moves the logging/tracing-facilities out of `*state.StateDB`,
in to a wrapping struct which implements `vm.StateDB` instead.
In most places, it is a pretty straight-forward change:
- First, hoisting the invocations from state objects up to the statedb.
- Then making the mutation-methods simply return the previous value, so
that the external logging layer could log everything.
Some internal code uses the direct object-accessors to mutate the state,
particularly in testing and in setting up state overrides, which means
that these changes are unobservable for the hooked layer. Thus, configuring
the overrides are not necessarily part of the API we want to publish.
The trickiest part about the layering is that when the selfdestructs are
finally deleted during `Finalise`, there's the possibility that someone
sent some ether to it, which is burnt at that point, and thus needs to
be logged. The hooked layer reaches into the inner layer to figure out
these events.
In package `vm`, the conversion from `state.StateDB + hooks` into a
hooked `vm.StateDB` is performed where needed.
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
1 month ago
|
|
|
// SelfDestruct6780 is post-EIP6780 selfdestruct, which means that it's a
|
|
|
|
|
// send-all-to-beneficiary, unless the contract was created in this same
|
|
|
|
|
// transaction, in which case it will be destructed.
|
|
|
|
|
// This method returns the prior balance, along with a boolean which is
|
|
|
|
|
// true iff the object was indeed destructed.
|
|
|
|
|
SelfDestruct6780(common.Address) (uint256.Int, bool)
|
|
|
|
|
|
|
|
|
|
// Exist reports whether the given account exists in state.
|
|
|
|
|
// Notably this should also return true for self-destructed accounts.
|
|
|
|
|
Exist(common.Address) bool
|
|
|
|
|
// Empty returns whether the given account is empty. Empty
|
|
|
|
|
// is defined according to EIP161 (balance = nonce = code = 0).
|
|
|
|
|
Empty(common.Address) bool
|
|
|
|
|
|
|
|
|
|
AddressInAccessList(addr common.Address) bool
|
|
|
|
|
SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
|
|
|
|
|
// AddAddressToAccessList adds the given address to the access list. This operation is safe to perform
|
|
|
|
|
// even if the feature/fork is not active yet
|
|
|
|
|
AddAddressToAccessList(addr common.Address)
|
|
|
|
|
// AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform
|
|
|
|
|
// even if the feature/fork is not active yet
|
|
|
|
|
AddSlotToAccessList(addr common.Address, slot common.Hash)
|
|
|
|
|
|
|
|
|
|
// PointCache returns the point cache used in computations
|
|
|
|
|
PointCache() *utils.PointCache
|
|
|
|
|
|
|
|
|
|
Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)
|
|
|
|
|
|
|
|
|
|
RevertToSnapshot(int)
|
|
|
|
|
Snapshot() int
|
|
|
|
|
|
|
|
|
|
AddLog(*types.Log)
|
|
|
|
|
AddPreimage(common.Hash, []byte)
|
|
|
|
|
|
|
|
|
|
Witness() *stateless.Witness
|
core/state: move state log mechanism to a separate layer (#30569)
This PR moves the logging/tracing-facilities out of `*state.StateDB`,
in to a wrapping struct which implements `vm.StateDB` instead.
In most places, it is a pretty straight-forward change:
- First, hoisting the invocations from state objects up to the statedb.
- Then making the mutation-methods simply return the previous value, so
that the external logging layer could log everything.
Some internal code uses the direct object-accessors to mutate the state,
particularly in testing and in setting up state overrides, which means
that these changes are unobservable for the hooked layer. Thus, configuring
the overrides are not necessarily part of the API we want to publish.
The trickiest part about the layering is that when the selfdestructs are
finally deleted during `Finalise`, there's the possibility that someone
sent some ether to it, which is burnt at that point, and thus needs to
be logged. The hooked layer reaches into the inner layer to figure out
these events.
In package `vm`, the conversion from `state.StateDB + hooks` into a
hooked `vm.StateDB` is performed where needed.
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
1 month ago
|
|
|
|
|
|
|
|
// Finalise must be invoked at the end of a transaction
|
|
|
|
|
Finalise(bool)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// CallContext provides a basic interface for the EVM calling conventions. The EVM
|
|
|
|
|
// depends on this context being implemented for doing subcalls and initialising new EVM contracts.
|
|
|
|
|
type CallContext interface {
|
|
|
|
|
// Call calls another contract.
|
|
|
|
|
Call(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
|
|
|
|
|
// CallCode takes another contracts code and execute within our own context
|
|
|
|
|
CallCode(env *EVM, me ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error)
|
|
|
|
|
// DelegateCall is same as CallCode except sender and value is propagated from parent to child scope
|
|
|
|
|
DelegateCall(env *EVM, me ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error)
|
|
|
|
|
// Create creates a new contract
|
|
|
|
|
Create(env *EVM, me ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error)
|
|
|
|
|
}
|
