core,console: replace noarg fmt.Errorf with errors.New

console/bridge.go

@@ -18,6 +18,7 @@ package console
 
 import (
  "encoding/json"
+ "errors"
  "fmt"
  "io"
  "reflect"
@@ -77,18 +78,18 @@ func (b *bridge) NewAccount(call jsre.Call) (goja.Value, error) {
  return nil, err
  }
  if password != confirm {
- return nil, fmt.Errorf("passwords don't match!")
+ return nil, errors.New("passwords don't match!")
  }
  // A single string password was specified, use that
  case len(call.Arguments) == 1 && call.Argument(0).ToString() != nil:
  password = call.Argument(0).ToString().String()
  default:
- return nil, fmt.Errorf("expected 0 or 1 string argument")
+ return nil, errors.New("expected 0 or 1 string argument")
  }
  // Password acquired, execute the call and return
  newAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("newAccount"))
  if !callable {
- return nil, fmt.Errorf("jeth.newAccount is not callable")
+ return nil, errors.New("jeth.newAccount is not callable")
  }
  ret, err := newAccount(goja.Null(), call.VM.ToValue(password))
  if err != nil {
@@ -102,7 +103,7 @@ func (b *bridge) NewAccount(call jsre.Call) (goja.Value, error) {
 func (b *bridge) OpenWallet(call jsre.Call) (goja.Value, error) {
  // Make sure we have a wallet specified to open
  if call.Argument(0).ToObject(call.VM).ClassName() != "String" {
- return nil, fmt.Errorf("first argument must be the wallet URL to open")
+ return nil, errors.New("first argument must be the wallet URL to open")
  }
  wallet := call.Argument(0)
 
@@ -115,7 +116,7 @@ func (b *bridge) OpenWallet(call jsre.Call) (goja.Value, error) {
  // Open the wallet and return if successful in itself
  openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
  if !callable {
- return nil, fmt.Errorf("jeth.openWallet is not callable")
+ return nil, errors.New("jeth.openWallet is not callable")
  }
  val, err := openWallet(goja.Null(), wallet, passwd)
  if err == nil {
@@ -198,7 +199,7 @@ func (b *bridge) readPassphraseAndReopenWallet(call jsre.Call) (goja.Value, erro
  }
  openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
  if !callable {
- return nil, fmt.Errorf("jeth.openWallet is not callable")
+ return nil, errors.New("jeth.openWallet is not callable")
  }
  return openWallet(goja.Null(), wallet, call.VM.ToValue(input))
 }
@@ -219,7 +220,7 @@ func (b *bridge) readPinAndReopenWallet(call jsre.Call) (goja.Value, error) {
  }
  openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
  if !callable {
- return nil, fmt.Errorf("jeth.openWallet is not callable")
+ return nil, errors.New("jeth.openWallet is not callable")
  }
  return openWallet(goja.Null(), wallet, call.VM.ToValue(input))
 }
@@ -230,13 +231,13 @@ func (b *bridge) readPinAndReopenWallet(call jsre.Call) (goja.Value, error) {
 // the RPC call.
 func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
  if len(call.Arguments) < 1 {
- return nil, fmt.Errorf("usage: unlockAccount(account, [ password, duration ])")
+ return nil, errors.New("usage: unlockAccount(account, [ password, duration ])")
  }
 
  account := call.Argument(0)
  // Make sure we have an account specified to unlock.
  if goja.IsUndefined(account) || goja.IsNull(account) || account.ExportType().Kind() != reflect.String {
- return nil, fmt.Errorf("first argument must be the account to unlock")
+ return nil, errors.New("first argument must be the account to unlock")
  }
 
  // If password is not given or is the null value, prompt the user for it.
@@ -250,7 +251,7 @@ func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
  passwd = call.VM.ToValue(input)
  } else {
  if call.Argument(1).ExportType().Kind() != reflect.String {
- return nil, fmt.Errorf("password must be a string")
+ return nil, errors.New("password must be a string")
  }
  passwd = call.Argument(1)
  }
@@ -259,15 +260,15 @@ func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
  duration := goja.Null()
  if !goja.IsUndefined(call.Argument(2)) && !goja.IsNull(call.Argument(2)) {
  if !isNumber(call.Argument(2)) {
- return nil, fmt.Errorf("unlock duration must be a number")
+ return nil, errors.New("unlock duration must be a number")
  }
  duration = call.Argument(2)
  }
 
  // Send the request to the backend and return.
  unlockAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("unlockAccount"))
  if !callable {
- return nil, fmt.Errorf("jeth.unlockAccount is not callable")
+ return nil, errors.New("jeth.unlockAccount is not callable")
  }
  return unlockAccount(goja.Null(), account, passwd, duration)
 }
@@ -277,7 +278,7 @@ func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
 // jeth.sign) with it to actually execute the RPC call.
 func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
  if nArgs := len(call.Arguments); nArgs < 2 {
- return nil, fmt.Errorf("usage: sign(message, account, [ password ])")
+ return nil, errors.New("usage: sign(message, account, [ password ])")
  }
  var (
  message = call.Argument(0)
@@ -286,10 +287,10 @@ func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
  )
 
  if goja.IsUndefined(message) || message.ExportType().Kind() != reflect.String {
- return nil, fmt.Errorf("first argument must be the message to sign")
+ return nil, errors.New("first argument must be the message to sign")
  }
  if goja.IsUndefined(account) || account.ExportType().Kind() != reflect.String {
- return nil, fmt.Errorf("second argument must be the account to sign with")
+ return nil, errors.New("second argument must be the account to sign with")
  }
 
  // if the password is not given or null ask the user and ensure password is a string
@@ -301,25 +302,25 @@ func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
  }
  passwd = call.VM.ToValue(input)
  } else if passwd.ExportType().Kind() != reflect.String {
- return nil, fmt.Errorf("third argument must be the password to unlock the account")
+ return nil, errors.New("third argument must be the password to unlock the account")
  }
 
  // Send the request to the backend and return
  sign, callable := goja.AssertFunction(getJeth(call.VM).Get("sign"))
  if !callable {
- return nil, fmt.Errorf("jeth.sign is not callable")
+ return nil, errors.New("jeth.sign is not callable")
  }
  return sign(goja.Null(), message, account, passwd)
 }
 
 // Sleep will block the console for the specified number of seconds.
 func (b *bridge) Sleep(call jsre.Call) (goja.Value, error) {
  if nArgs := len(call.Arguments); nArgs < 1 {
- return nil, fmt.Errorf("usage: sleep(<number of seconds>)")
+ return nil, errors.New("usage: sleep(<number of seconds>)")
  }
  sleepObj := call.Argument(0)
  if goja.IsUndefined(sleepObj) || goja.IsNull(sleepObj) || !isNumber(sleepObj) {
- return nil, fmt.Errorf("usage: sleep(<number of seconds>)")
+ return nil, errors.New("usage: sleep(<number of seconds>)")
  }
  sleep := sleepObj.ToFloat()
  time.Sleep(time.Duration(sleep * float64(time.Second)))
@@ -336,17 +337,17 @@ func (b *bridge) SleepBlocks(call jsre.Call) (goja.Value, error) {
  )
  nArgs := len(call.Arguments)
  if nArgs == 0 {
- return nil, fmt.Errorf("usage: sleepBlocks(<n blocks>[, max sleep in seconds])")
+ return nil, errors.New("usage: sleepBlocks(<n blocks>[, max sleep in seconds])")
  }
  if nArgs >= 1 {
  if goja.IsNull(call.Argument(0)) || goja.IsUndefined(call.Argument(0)) || !isNumber(call.Argument(0)) {
- return nil, fmt.Errorf("expected number as first argument")
+ return nil, errors.New("expected number as first argument")
  }
  blocks = call.Argument(0).ToInteger()
  }
  if nArgs >= 2 {
  if goja.IsNull(call.Argument(1)) || goja.IsUndefined(call.Argument(1)) || !isNumber(call.Argument(1)) {
- return nil, fmt.Errorf("expected number as second argument")
+ return nil, errors.New("expected number as second argument")
  }
  sleep = call.Argument(1).ToInteger()
  }
@@ -421,7 +422,7 @@ func (b *bridge) Send(call jsre.Call) (goja.Value, error) {
  JSON := call.VM.Get("JSON").ToObject(call.VM)
  parse, callable := goja.AssertFunction(JSON.Get("parse"))
  if !callable {
- return nil, fmt.Errorf("JSON.parse is not a function")
+ return nil, errors.New("JSON.parse is not a function")
  }
  resultVal, err := parse(goja.Null(), call.VM.ToValue(string(result)))
  if err != nil {

core/block_validator.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+ "errors"
  "fmt"
 
  "github.com/ethereum/go-ethereum/consensus"
@@ -71,14 +72,14 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
  if header.WithdrawalsHash != nil {
  // Withdrawals list must be present in body after Shanghai.
  if block.Withdrawals() == nil {
- return fmt.Errorf("missing withdrawals in block body")
+ return errors.New("missing withdrawals in block body")
  }
  if hash := types.DeriveSha(block.Withdrawals(), trie.NewStackTrie(nil)); hash != *header.WithdrawalsHash {
  return fmt.Errorf("withdrawals root hash mismatch (header value %x, calculated %x)", *header.WithdrawalsHash, hash)
  }
  } else if block.Withdrawals() != nil {
  // Withdrawals are not allowed prior to shanghai fork
- return fmt.Errorf("withdrawals present in block body")
+ return errors.New("withdrawals present in block body")
  }
 
  if !v.bc.HasBlockAndState(block.ParentHash(), block.NumberU64()-1) {

core/blockchain.go

@@ -87,6 +87,8 @@ var (
 
  errInsertionInterrupted = errors.New("insertion is interrupted")
  errChainStopped = errors.New("blockchain is stopped")
+ errInvalidOldChain = errors.New("invalid old chain")
+ errInvalidNewChain = errors.New("invalid new chain")
 )
 
 const (
@@ -865,7 +867,7 @@ func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error {
  return fmt.Errorf("export failed on #%d: not found", nr)
  }
  if nr > first && block.ParentHash() != parentHash {
- return fmt.Errorf("export failed: chain reorg during export")
+ return errors.New("export failed: chain reorg during export")
  }
  parentHash = block.Hash()
  if err := block.EncodeRLP(w); err != nil {
@@ -2097,10 +2099,10 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
  }
  }
  if oldBlock == nil {
- return errors.New("invalid old chain")
+ return errInvalidOldChain
  }
  if newBlock == nil {
- return errors.New("invalid new chain")
+ return errInvalidNewChain
  }
  // Both sides of the reorg are at the same number, reduce both until the common
  // ancestor is found
@@ -2120,11 +2122,11 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
  // Step back with both chains
  oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1)
  if oldBlock == nil {
- return fmt.Errorf("invalid old chain")
+ return errInvalidOldChain
  }
  newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1)
  if newBlock == nil {
- return fmt.Errorf("invalid new chain")
+ return errInvalidNewChain
  }
  }
 

core/chain_indexer.go

@@ -19,6 +19,7 @@ package core
 import (
  "context"
  "encoding/binary"
+ "errors"
  "fmt"
  "sync"
  "sync/atomic"
@@ -403,7 +404,7 @@ func (c *ChainIndexer) processSection(section uint64, lastHead common.Hash) (com
  if header == nil {
  return common.Hash{}, fmt.Errorf("block #%d [%x..] not found", number, hash[:4])
  } else if header.ParentHash != lastHead {
- return common.Hash{}, fmt.Errorf("chain reorged during section processing")
+ return common.Hash{}, errors.New("chain reorged during section processing")
  }
  if err := c.backend.Process(c.ctx, header); err != nil {
  return common.Hash{}, err

core/genesis.go

@@ -73,7 +73,7 @@ func ReadGenesis(db ethdb.Database) (*Genesis, error) {
  }
  blob := rawdb.ReadGenesisStateSpec(db, stored)
  if blob == nil {
- return nil, fmt.Errorf("genesis state missing from db")
+ return nil, errors.New("genesis state missing from db")
  }
  if len(blob) != 0 {
  if err := genesis.Alloc.UnmarshalJSON(blob); err != nil {
@@ -82,11 +82,11 @@ func ReadGenesis(db ethdb.Database) (*Genesis, error) {
  }
  genesis.Config = rawdb.ReadChainConfig(db, stored)
  if genesis.Config == nil {
- return nil, fmt.Errorf("genesis config missing from db")
+ return nil, errors.New("genesis config missing from db")
  }
  genesisBlock := rawdb.ReadBlock(db, stored, 0)
  if genesisBlock == nil {
- return nil, fmt.Errorf("genesis block missing from db")
+ return nil, errors.New("genesis block missing from db")
  }
  genesisHeader := genesisBlock.Header()
  genesis.Nonce = genesisHeader.Nonce.Uint64()
@@ -366,7 +366,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, gen
  // are returned to the caller unless we're already at block zero.
  head := rawdb.ReadHeadHeader(db)
  if head == nil {
- return newcfg, stored, fmt.Errorf("missing head header")
+ return newcfg, stored, errors.New("missing head header")
  }
  compatErr := storedcfg.CheckCompatible(newcfg, head.Number.Uint64(), head.Time)
  if compatErr != nil && ((head.Number.Uint64() != 0 && compatErr.RewindToBlock != 0) || (head.Time != 0 && compatErr.RewindToTime != 0)) {

core/rawdb/freezer.go

@@ -434,7 +434,7 @@ func (f *Freezer) MigrateTable(kind string, convert convertLegacyFn) error {
  // TODO(s1na): This is a sanity-check since as of now no process does tail-deletion. But the migration
  // process assumes no deletion at tail and needs to be modified to account for that.
  if table.itemOffset.Load() > 0 || table.itemHidden.Load() > 0 {
- return fmt.Errorf("migration not supported for tail-deleted freezers")
+ return errors.New("migration not supported for tail-deleted freezers")
  }
  ancientsPath := filepath.Dir(table.index.Name())
  // Set up new dir for the migrated table, the content of which

core/state/snapshot/journal.go

@@ -305,7 +305,7 @@ func iterateJournal(db ethdb.KeyValueReader, callback journalCallback) error {
  }
  if baseRoot := rawdb.ReadSnapshotRoot(db); baseRoot != parent {
  log.Warn("Loaded snapshot journal", "diskroot", baseRoot, "diffs", "unmatched")
- return fmt.Errorf("mismatched disk and diff layers")
+ return errors.New("mismatched disk and diff layers")
  }
  for {
  var (

core/state_processor.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+ "errors"
  "fmt"
  "math/big"
 
@@ -92,7 +93,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
  // Fail if Shanghai not enabled and len(withdrawals) is non-zero.
  withdrawals := block.Withdrawals()
  if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number(), block.Time()) {
- return nil, nil, 0, fmt.Errorf("withdrawals before shanghai")
+ return nil, nil, 0, errors.New("withdrawals before shanghai")
  }
  // Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
  p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), withdrawals)

core/types/log_test.go

@@ -18,7 +18,7 @@ package types
 
 import (
  "encoding/json"
- "fmt"
+ "errors"
  "reflect"
  "testing"
 
@@ -97,7 +97,7 @@ var unmarshalLogTests = map[string]struct {
  },
  "missing data": {
  input: `{"address":"0xecf8f87f810ecf450940c9f60066b4a7a501d6a7","blockHash":"0x656c34545f90a730a19008c0e7a7cd4fb3895064b48d6d69761bd5abad681056","blockNumber":"0x1ecfa4","logIndex":"0x2","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x00000000000000000000000080b2c9d7cbbf30a1b0fc8983c647d754c6525615","0x000000000000000000000000f9dff387dcb5cc4cca5b91adb07a95f54e9f1bb6"],"transactionHash":"0x3b198bfd5d2907285af009e9ae84a0ecd63677110d89d7e030251acb87f6487e","transactionIndex":"0x3"}`,
- wantError: fmt.Errorf("missing required field 'data' for Log"),
+ wantError: errors.New("missing required field 'data' for Log"),
  },
 }
 

core/types/transaction_test.go

@@ -526,7 +526,7 @@ func assertEqual(orig *Transaction, cpy *Transaction) error {
  }
  if orig.AccessList() != nil {
  if !reflect.DeepEqual(orig.AccessList(), cpy.AccessList()) {
- return fmt.Errorf("access list wrong!")
+ return errors.New("access list wrong!")
  }
  }
  return nil