Geth v1.12.2 nits

accounts/abi/bind/backends/simulated.go

@@ -62,8 +62,6 @@ import (
 var (
 	_ bind.AcceptedContractCaller = (*SimulatedBackend)(nil)
 	_ bind.ContractBackend        = (*SimulatedBackend)(nil)
-	_ bind.ContractFilterer       = (*SimulatedBackend)(nil)
-	_ bind.ContractTransactor     = (*SimulatedBackend)(nil)
 	_ bind.DeployBackend          = (*SimulatedBackend)(nil)
 
 	_ interfaces.ChainReader            = (*SimulatedBackend)(nil)
@@ -147,7 +145,7 @@ func (b *SimulatedBackend) Close() error {
 	return nil
 }
 
-// Commit imports all the pending transactions as a single block and starts a
+// Commit imports all the accepted transactions as a single block and starts a
 // fresh new state.
 func (b *SimulatedBackend) Commit(accept bool) common.Hash {
 	b.mu.Lock()
@@ -171,7 +169,7 @@ func (b *SimulatedBackend) Commit(accept bool) common.Hash {
 	return blockHash
 }
 
-// Rollback aborts all pending transactions, reverting to the last committed state.
+// Rollback aborts all accepted transactions, reverting to the last committed state.
 func (b *SimulatedBackend) Rollback() {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -206,7 +204,7 @@ func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error {
 	defer b.mu.Unlock()
 
 	if len(b.acceptedBlock.Transactions()) != 0 {
-		return errors.New("pending block dirty")
+		return errors.New("accepted block dirty")
 	}
 	block, err := b.blockByHash(ctx, parent)
 	if err != nil {
@@ -293,10 +291,10 @@ func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common
 	return receipt, nil
 }
 
-// TransactionByHash checks the pool of pending transactions in addition to the
-// blockchain. The isPending return value indicates whether the transaction has been
+// TransactionByHash checks the pool of accepted transactions in addition to the
+// blockchain. The isAccepted return value indicates whether the transaction has been
 // mined yet. Note that the transaction may not be part of the canonical chain even if
-// it's not pending.
+// it's not accepted.
 func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -537,7 +535,7 @@ func (b *SimulatedBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, erro
 	return big.NewInt(1), nil
 }
 
-// EstimateGas executes the requested code against the currently pending block/state and
+// EstimateGas executes the requested code against the currently accepted block/state and
 // returns the used amount of gas.
 func (b *SimulatedBackend) EstimateGas(ctx context.Context, call interfaces.CallMsg) (uint64, error) {
 	b.mu.Lock()
@@ -641,7 +639,7 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call interfaces.Call
 	return hi, nil
 }
 
-// callContract implements common code between normal and pending contract calls.
+// callContract implements common code between normal and accepted contract calls.
 // state is modified during execution, make sure to copy it if necessary.
 func (b *SimulatedBackend) callContract(ctx context.Context, call interfaces.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
 	// Gas prices post 1559 need to be initialized
@@ -711,7 +709,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call interfaces.Cal
 	return core.ApplyMessage(vmEnv, msg, gasPool)
 }
 
-// SendTransaction updates the pending block to include the given transaction.
+// SendTransaction updates the accepted block to include the given transaction.
 func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
 	b.mu.Lock()
 	defer b.mu.Unlock()

accounts/abi/bind/bind.go

@@ -151,7 +151,7 @@ func BindHelper(types []string, abis []string, bytecodes []string, fsigs []map[s
 			normalized := original
 			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
 			// Ensure there is no duplicated identifier
-			identifiers := callIdentifiers
+			var identifiers = callIdentifiers
 			if !original.IsConstant() {
 				identifiers = transactIdentifiers
 			}

accounts/abi/event.go

@@ -59,6 +59,7 @@ type Event struct {
 	// e.g.	 event foo(uint32 a, int b) = "foo(uint32,int256)"
 	// Please note that "int" is substitute for its canonical representation "int256"
 	Sig string
+
 	// ID returns the canonical representation of the event's signature used by the
 	// abi definition to identify event names and types.
 	ID common.Hash

cmd/evm/internal/t8ntool/transaction.go

@@ -149,7 +149,7 @@ func Transaction(ctx *cli.Context) error {
 			r.Address = sender
 		}
 		// Check intrinsic gas
-		rules := chainConfig.AvalancheRules(new(big.Int), 0)
+		rules := chainConfig.Rules(new(big.Int), 0)
 		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, rules); err != nil {
 			r.Error = err
 			results = append(results, r)

cmd/utils/cmd.go

@@ -0,0 +1,45 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// Package utils contains internal helper functions for go-ethereum commands.
+package utils
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+)
+
+// Fatalf formats a message to standard error and exits the program.
+// The message is also printed to standard output if standard error
+// is redirected to a different file.
+func Fatalf(format string, args ...interface{}) {
+	w := io.MultiWriter(os.Stdout, os.Stderr)
+	if runtime.GOOS == "windows" {
+		// The SameFile check below doesn't work on Windows.
+		// stdout is unlikely to get redirected though, so just print there.
+		w = os.Stdout
+	} else {
+		outf, _ := os.Stdout.Stat()
+		errf, _ := os.Stderr.Stat()
+		if outf != nil && errf != nil && os.SameFile(outf, errf) {
+			w = os.Stderr
+		}
+	}
+	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
+	os.Exit(1)
+}

cmd/utils/flags.go

@@ -19,34 +19,11 @@ package utils
 
 import (
 	"fmt"
-	"io"
-	"os"
-	"runtime"
 	"strings"
 
 	"github.com/urfave/cli/v2"
 )
 
-// Fatalf formats a message to standard error and exits the program.
-// The message is also printed to standard output if standard error
-// is redirected to a different file.
-func Fatalf(format string, args ...interface{}) {
-	w := io.MultiWriter(os.Stdout, os.Stderr)
-	if runtime.GOOS == "windows" {
-		// The SameFile check below doesn't work on Windows.
-		// stdout is unlikely to get redirected though, so just print there.
-		w = os.Stdout
-	} else {
-		outf, _ := os.Stdout.Stat()
-		errf, _ := os.Stderr.Stat()
-		if outf != nil && errf != nil && os.SameFile(outf, errf) {
-			w = os.Stderr
-		}
-	}
-	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
-	os.Exit(1)
-}
-
 // CheckExclusive verifies that only a single instance of the provided flags was
 // set by the user. Each flag might optionally be followed by a string type to
 // specialize it further.

core/predicate_check_test.go

@@ -297,7 +297,7 @@ func TestCheckPredicate(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			require := require.New(t)
 			// Create the rules from TestChainConfig and update the predicates based on the test params
-			rules := params.TestChainConfig.AvalancheRules(common.Big0, 0)
+			rules := params.TestChainConfig.Rules(common.Big0, 0)
 			if test.createPredicates != nil {
 				for address, predicater := range test.createPredicates(t) {
 					rules.Predicaters[address] = predicater
@@ -423,7 +423,7 @@ func TestCheckPredicatesOutput(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			require := require.New(t)
 			// Create the rules from TestChainConfig and update the predicates based on the test params
-			rules := params.TestChainConfig.AvalancheRules(common.Big0, 0)
+			rules := params.TestChainConfig.Rules(common.Big0, 0)
 			predicater := precompileconfig.NewMockPredicater(gomock.NewController(t))
 			predicater.EXPECT().PredicateGas(gomock.Any()).Return(uint64(0), nil).Times(len(test.testTuple))
 

core/rawdb/accessors_chain.go

@@ -86,7 +86,7 @@ type NumberHash struct {
 	Hash   common.Hash
 }
 
-// ReadAllHashesInRange retrieves all the hashes assigned to blocks at a certain
+// ReadAllHashesInRange retrieves all the hashes assigned to blocks at certain
 // heights, both canonical and reorged forks included.
 // This method considers both limits to be _inclusive_.
 func ReadAllHashesInRange(db ethdb.Iteratee, first, last uint64) []*NumberHash {
@@ -205,12 +205,11 @@ func WriteHeadBlockHash(db ethdb.KeyValueWriter, hash common.Hash) {
 
 // ReadHeaderRLP retrieves a block header in its raw RLP database encoding.
 func ReadHeaderRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {
-	// Then try to look up the data in leveldb.
 	data, _ := db.Get(headerKey(number, hash))
 	if len(data) > 0 {
 		return data
 	}
-	return nil // Can't find the data anywhere.
+	return nil
 }
 
 // HasHeader verifies the existence of a block header corresponding to the hash.
@@ -274,12 +273,11 @@ func deleteHeaderWithoutNumber(db ethdb.KeyValueWriter, hash common.Hash, number
 
 // ReadBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.
 func ReadBodyRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {
-	// Then try to look up the data in leveldb.
 	data, _ := db.Get(blockBodyKey(number, hash))
 	if len(data) > 0 {
 		return data
 	}
-	return nil // Can't find the data anywhere.
+	return nil
 }
 
 // ReadCanonicalBodyRLP retrieves the block body (transactions and uncles) for the canonical
@@ -349,12 +347,11 @@ func HasReceipts(db ethdb.Reader, hash common.Hash, number uint64) bool {
 
 // ReadReceiptsRLP retrieves all the transaction receipts belonging to a block in RLP encoding.
 func ReadReceiptsRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {
-	// Then try to look up the data in leveldb.
 	data, _ := db.Get(blockReceiptsKey(number, hash))
 	if len(data) > 0 {
 		return data
 	}
-	return nil // Can't find the data anywhere.
+	return nil
 }
 
 // ReadRawReceipts retrieves all the transaction receipts belonging to a block.

core/state/state_object.go

@@ -31,7 +31,6 @@ import (
 	"fmt"
 	"io"
 	"math/big"
-	"sync"
 	"time"
 
 	"github.com/ava-labs/subnet-evm/core/types"
@@ -72,11 +71,6 @@ func (s Storage) Copy() Storage {
 // - Account values as well as storages can be accessed and modified through the object.
 // - Finally, call commit to return the changes of storage trie and update account data.
 type stateObject struct {
-	// dataLock protects the [data] field to prevent a race condition
-	// in the transaction pool tests. TODO remove after re-implementing
-	// tx pool to be synchronous.
-	dataLock sync.RWMutex
-
 	db       *StateDB
 	address  common.Address      // address of ethereum account
 	addrHash common.Hash         // hash of ethereum address of the account
@@ -538,8 +532,6 @@ func (s *stateObject) SetNonce(nonce uint64) {
 }
 
 func (s *stateObject) setNonce(nonce uint64) {
-	s.dataLock.Lock()
-	defer s.dataLock.Unlock()
 	s.data.Nonce = nonce
 }
 
@@ -552,7 +544,5 @@ func (s *stateObject) Balance() *big.Int {
 }
 
 func (s *stateObject) Nonce() uint64 {
-	s.dataLock.RLock()
-	defer s.dataLock.RUnlock()
 	return s.data.Nonce
 }

core/state/statedb.go

@@ -312,7 +312,7 @@ func (s *StateDB) AddRefund(gas uint64) {
 }
 
 // SubRefund removes gas from the refund counter.
-// This method will panic if the refund counter goes below zero
+// This method will set the refund counter to 0 if the gas is greater than the current refund.
 func (s *StateDB) SubRefund(gas uint64) {
 	s.journal.append(refundChange{prev: s.refund})
 	if gas > s.refund {

core/state_transition.go

@@ -447,7 +447,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	var (
 		msg              = st.msg
 		sender           = vm.AccountRef(msg.From)
-		rules            = st.evm.ChainConfig().AvalancheRules(st.evm.Context.BlockNumber, st.evm.Context.Time)
+		rules            = st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber, st.evm.Context.Time)
 		contractCreation = msg.To == nil
 	)
 

core/txpool/legacypool/legacypool.go

@@ -707,7 +707,7 @@ func (pool *LegacyPool) validateTx(tx *types.Transaction, local bool) error {
 
 	opts := &txpool.ValidationOptionsWithState{
 		State: pool.currentState,
-		Rules: pool.chainconfig.AvalancheRules(
+		Rules: pool.chainconfig.Rules(
 			pool.currentHead.Load().Number,
 			pool.currentHead.Load().Time,
 		),

core/txpool/validation.go

@@ -114,7 +114,7 @@ func ValidateTransaction(tx *types.Transaction, blobs []kzg4844.Blob, commits []
 	}
 	// Ensure the transaction has more gas than the bare minimum needed to cover
 	// the transaction metadata
-	intrGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, opts.Config.AvalancheRules(head.Number, head.Time))
+	intrGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, opts.Config.Rules(head.Number, head.Time))
 	if err != nil {
 		return err
 	}

core/types/transaction.go

@@ -461,16 +461,6 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
 	return &Transaction{inner: cpy, time: tx.time}, nil
 }
 
-// FirstSeen is the time a transaction is first seen.
-func (tx *Transaction) FirstSeen() time.Time {
-	return tx.time
-}
-
-// SetFirstSeen sets overwrites the time a transaction is first seen.
-func (tx *Transaction) SetFirstSeen(t time.Time) {
-	tx.time = t
-}
-
 // Transactions implements DerivableList for transactions.
 type Transactions []*Transaction
 

core/vm/evm.go

@@ -194,7 +194,7 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig
 		StateDB:     statedb,
 		Config:      config,
 		chainConfig: chainConfig,
-		chainRules:  chainConfig.AvalancheRules(blockCtx.BlockNumber, blockCtx.Time),
+		chainRules:  chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Time),
 	}
 	evm.interpreter = NewEVMInterpreter(evm)
 	return evm
@@ -242,7 +242,8 @@ func (evm *EVM) Interpreter() *EVMInterpreter {
 func (evm *EVM) SetBlockContext(blockCtx BlockContext) {
 	evm.Context = blockCtx
 	num := blockCtx.BlockNumber
-	evm.chainRules = evm.chainConfig.AvalancheRules(num, blockCtx.Time)
+	timestamp := blockCtx.Time
+	evm.chainRules = evm.chainConfig.Rules(num, timestamp)
 }
 
 // Call executes the contract associated with the addr with the given input as

core/vm/memory_table.go

@@ -88,7 +88,6 @@ func memoryCall(stack *Stack) (uint64, bool) {
 	}
 	return y, false
 }
-
 func memoryDelegateCall(stack *Stack) (uint64, bool) {
 	x, overflow := calcMemSize64(stack.Back(4), stack.Back(5))
 	if overflow {