roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

core,console: replace noarg fmt.Errorf with errors.New (#27332)

Browse Source 
* core: replace noarg fmt.Errorf with errors.New

Signed-off-by: jsvisa <delweng@gmail.com>

* console: replace noarg fmt.Errorf with errors.New

Signed-off-by: jsvisa <delweng@gmail.com>

* core: go autoimport

Signed-off-by: jsvisa <delweng@gmail.com>

* core: dry

Signed-off-by: jsvisa <delweng@gmail.com>

---------

Signed-off-by: jsvisa <delweng@gmail.com>
This commit is contained in:
Delweng 2023-05-25 20:24:09 +08:00 committed by GitHub
parent 690249de7b
commit 6c732766c8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 47 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
console/bridge.go
View File

@ -18,6 +18,7 @@ package console
import ( import (
"encoding/json" "encoding/json"
"errors"
"fmt" "fmt"
"io" "io"
"reflect" "reflect"
@ -77,18 +78,18 @@ func (b *bridge) NewAccount(call jsre.Call) (goja.Value, error) {
return nil, err return nil, err
} }
if password != confirm { 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 // A single string password was specified, use that
case len(call.Arguments) == 1 && call.Argument(0).ToString() != nil: case len(call.Arguments) == 1 && call.Argument(0).ToString() != nil:
password = call.Argument(0).ToString().String() password = call.Argument(0).ToString().String()
default: 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 // Password acquired, execute the call and return
newAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("newAccount")) newAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("newAccount"))
if !callable { 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)) ret, err := newAccount(goja.Null(), call.VM.ToValue(password))
if err != nil { 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) { func (b *bridge) OpenWallet(call jsre.Call) (goja.Value, error) {
// Make sure we have a wallet specified to open // Make sure we have a wallet specified to open
if call.Argument(0).ToObject(call.VM).ClassName() != "String" { 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) 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 // Open the wallet and return if successful in itself
openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet")) openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
if !callable { 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) val, err := openWallet(goja.Null(), wallet, passwd)
if err == nil { 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")) openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
if !callable { 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)) 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")) openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet"))
if !callable { 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)) 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. // the RPC call.
func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) { func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
if len(call.Arguments) < 1 { 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) account := call.Argument(0)
// Make sure we have an account specified to unlock. // Make sure we have an account specified to unlock.
if goja.IsUndefined(account) || goja.IsNull(account) || account.ExportType().Kind() != reflect.String { 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. // 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) passwd = call.VM.ToValue(input)
} else { } else {
if call.Argument(1).ExportType().Kind() != reflect.String { 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) passwd = call.Argument(1)
} }
@ -259,7 +260,7 @@ func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
duration := goja.Null() duration := goja.Null()
if !goja.IsUndefined(call.Argument(2)) && !goja.IsNull(call.Argument(2)) { if !goja.IsUndefined(call.Argument(2)) && !goja.IsNull(call.Argument(2)) {
if !isNumber(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) duration = call.Argument(2)
} }
@ -267,7 +268,7 @@ func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) {
// Send the request to the backend and return. // Send the request to the backend and return.
unlockAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("unlockAccount")) unlockAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("unlockAccount"))
if !callable { 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) 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. // jeth.sign) with it to actually execute the RPC call.
func (b *bridge) Sign(call jsre.Call) (goja.Value, error) { func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
if nArgs := len(call.Arguments); nArgs < 2 { 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 ( var (
message = call.Argument(0) 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 { 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 { 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 // if the password is not given or null ask the user and ensure password is a string
@ -301,13 +302,13 @@ func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
} }
passwd = call.VM.ToValue(input) passwd = call.VM.ToValue(input)
} else if passwd.ExportType().Kind() != reflect.String { } 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 // Send the request to the backend and return
sign, callable := goja.AssertFunction(getJeth(call.VM).Get("sign")) sign, callable := goja.AssertFunction(getJeth(call.VM).Get("sign"))
if !callable { 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) return sign(goja.Null(), message, account, passwd)
} }
@ -315,11 +316,11 @@ func (b *bridge) Sign(call jsre.Call) (goja.Value, error) {
// Sleep will block the console for the specified number of seconds. // Sleep will block the console for the specified number of seconds.
func (b *bridge) Sleep(call jsre.Call) (goja.Value, error) { func (b *bridge) Sleep(call jsre.Call) (goja.Value, error) {
if nArgs := len(call.Arguments); nArgs < 1 { 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) sleepObj := call.Argument(0)
if goja.IsUndefined(sleepObj) || goja.IsNull(sleepObj) || !isNumber(sleepObj) { 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() sleep := sleepObj.ToFloat()
time.Sleep(time.Duration(sleep * float64(time.Second))) 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) nArgs := len(call.Arguments)
if nArgs == 0 { 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 nArgs >= 1 {
if goja.IsNull(call.Argument(0)) || goja.IsUndefined(call.Argument(0)) || !isNumber(call.Argument(0)) { 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() blocks = call.Argument(0).ToInteger()
} }
if nArgs >= 2 { if nArgs >= 2 {
if goja.IsNull(call.Argument(1)) || goja.IsUndefined(call.Argument(1)) || !isNumber(call.Argument(1)) { 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() 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) JSON := call.VM.Get("JSON").ToObject(call.VM)
parse, callable := goja.AssertFunction(JSON.Get("parse")) parse, callable := goja.AssertFunction(JSON.Get("parse"))
if !callable { 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))) resultVal, err := parse(goja.Null(), call.VM.ToValue(string(result)))
if err != nil { if err != nil {

5
core/block_validator.go
View File

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

12
core/blockchain.go
View File

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

3
core/chain_indexer.go
View File

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

8
core/genesis.go
View File

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

2
core/rawdb/freezer.go
View File

@ -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 // 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. // process assumes no deletion at tail and needs to be modified to account for that.
if table.itemOffset.Load() > 0 || table.itemHidden.Load() > 0 { 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()) ancientsPath := filepath.Dir(table.index.Name())
// Set up new dir for the migrated table, the content of which // Set up new dir for the migrated table, the content of which

2
core/state/snapshot/journal.go
View File

@ -305,7 +305,7 @@ func iterateJournal(db ethdb.KeyValueReader, callback journalCallback) error {
} }
if baseRoot := rawdb.ReadSnapshotRoot(db); baseRoot != parent { if baseRoot := rawdb.ReadSnapshotRoot(db); baseRoot != parent {
log.Warn("Loaded snapshot journal", "diskroot", baseRoot, "diffs", "unmatched") 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 { for {
var ( var (

3
core/state_processor.go
View File

@ -17,6 +17,7 @@
package core package core
import ( import (
"errors"
"fmt" "fmt"
"math/big" "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. // Fail if Shanghai not enabled and len(withdrawals) is non-zero.
withdrawals := block.Withdrawals() withdrawals := block.Withdrawals()
if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number(), block.Time()) { 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) // 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) p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), withdrawals)

4
core/types/log_test.go
View File

@ -18,7 +18,7 @@ package types
import ( import (
"encoding/json" "encoding/json"
"fmt" "errors"
"reflect" "reflect"
"testing" "testing"
@ -97,7 +97,7 @@ var unmarshalLogTests = map[string]struct {
}, },
"missing data": { "missing data": {
input: `{"address":"0xecf8f87f810ecf450940c9f60066b4a7a501d6a7","blockHash":"0x656c34545f90a730a19008c0e7a7cd4fb3895064b48d6d69761bd5abad681056","blockNumber":"0x1ecfa4","logIndex":"0x2","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x00000000000000000000000080b2c9d7cbbf30a1b0fc8983c647d754c6525615","0x000000000000000000000000f9dff387dcb5cc4cca5b91adb07a95f54e9f1bb6"],"transactionHash":"0x3b198bfd5d2907285af009e9ae84a0ecd63677110d89d7e030251acb87f6487e","transactionIndex":"0x3"}`, 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"),
}, },
} }

2
core/types/transaction_test.go
View File

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