mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-19 13:21:37 +00:00
82d1112bae
eth_sendTransaction and eth_sendRawTransaction returned the generic -32000 code for submission failures, so callers had to string-match the message to distinguish e.g. a nonce error from an underpriced replacement. Map submission/pool errors to the standardized JSON-RPC error-code catalog shared across EVM clients in ethereum/execution-apis (src/error-groups: ExecutionErrors 1-199, GasErrors 800-999, TxPoolErrors 1000-1199), while preserving the original error message. Errors without a catalog code are returned unchanged, keeping the existing -32000 default.
257 lines
9.4 KiB
Go
257 lines
9.4 KiB
Go
// Copyright 2024 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 ethapi
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/txpool"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
)
|
|
|
|
// revertError is an API error that encompasses an EVM revert with JSON error
|
|
// code and a binary data blob.
|
|
type revertError struct {
|
|
error
|
|
reason string // revert reason hex encoded
|
|
}
|
|
|
|
type txSyncTimeoutError struct {
|
|
msg string
|
|
hash common.Hash
|
|
}
|
|
|
|
// ErrorCode returns the JSON error code for a revert.
|
|
// See: https://ethereum.org/en/developers/docs/apis/json-rpc/#error-codes
|
|
func (e *revertError) ErrorCode() int {
|
|
return 3
|
|
}
|
|
|
|
// ErrorData returns the hex encoded revert reason.
|
|
func (e *revertError) ErrorData() interface{} {
|
|
return e.reason
|
|
}
|
|
|
|
// newRevertError creates a revertError instance with the provided revert data.
|
|
func newRevertError(revert []byte) *revertError {
|
|
err := vm.ErrExecutionReverted
|
|
|
|
reason, errUnpack := abi.UnpackRevert(revert)
|
|
if errUnpack == nil {
|
|
err = fmt.Errorf("%w: %v", vm.ErrExecutionReverted, reason)
|
|
}
|
|
return &revertError{
|
|
error: err,
|
|
reason: hexutil.Encode(revert),
|
|
}
|
|
}
|
|
|
|
// TxIndexingError is an API error that indicates the transaction indexing is not
|
|
// fully finished yet with JSON error code and a binary data blob.
|
|
type TxIndexingError struct{}
|
|
|
|
// NewTxIndexingError creates a TxIndexingError instance.
|
|
func NewTxIndexingError() *TxIndexingError { return &TxIndexingError{} }
|
|
|
|
// Error implement error interface, returning the error message.
|
|
func (e *TxIndexingError) Error() string {
|
|
return "transaction indexing is in progress"
|
|
}
|
|
|
|
// ErrorCode returns the JSON error code for a revert.
|
|
// See: https://ethereum.org/en/developers/docs/apis/json-rpc/#error-codes
|
|
func (e *TxIndexingError) ErrorCode() int {
|
|
return -32000 // to be decided
|
|
}
|
|
|
|
// ErrorData returns the hex encoded revert reason.
|
|
func (e *TxIndexingError) ErrorData() interface{} { return "transaction indexing is in progress" }
|
|
|
|
type callError struct {
|
|
Message string `json:"message"`
|
|
Code int `json:"code"`
|
|
Data string `json:"data,omitempty"`
|
|
}
|
|
|
|
type invalidTxError struct {
|
|
Message string `json:"message"`
|
|
Code int `json:"code"`
|
|
}
|
|
|
|
func (e *invalidTxError) Error() string { return e.Message }
|
|
func (e *invalidTxError) ErrorCode() int { return e.Code }
|
|
|
|
const (
|
|
errCodeNonceTooHigh = -38011
|
|
errCodeNonceTooLow = -38010
|
|
errCodeBaseFeeTooLow = -38012
|
|
errCodeIntrinsicGas = -38013
|
|
errCodeInsufficientFunds = -38014
|
|
errCodeBlockGasLimitReached = -38015
|
|
errCodeBlockNumberInvalid = -38020
|
|
errCodeBlockTimestampInvalid = -38021
|
|
errCodeSenderIsNotEOA = -38024
|
|
errCodeMaxInitCodeSizeExceeded = -38025
|
|
errCodeClientLimitExceeded = -38026
|
|
errCodeInternalError = -32603
|
|
errCodeInvalidParams = -32602
|
|
errCodeVMError = -32015
|
|
errCodeTxSyncTimeout = 4
|
|
)
|
|
|
|
func txValidationError(err error) *invalidTxError {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
switch {
|
|
case errors.Is(err, core.ErrNonceTooHigh):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeNonceTooHigh}
|
|
case errors.Is(err, core.ErrNonceTooLow):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeNonceTooLow}
|
|
case errors.Is(err, core.ErrSenderNoEOA):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeSenderIsNotEOA}
|
|
case errors.Is(err, core.ErrFeeCapVeryHigh):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeInvalidParams}
|
|
case errors.Is(err, core.ErrTipVeryHigh):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeInvalidParams}
|
|
case errors.Is(err, core.ErrTipAboveFeeCap):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeInvalidParams}
|
|
case errors.Is(err, core.ErrFeeCapTooLow):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeBaseFeeTooLow}
|
|
case errors.Is(err, core.ErrInsufficientFunds):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeInsufficientFunds}
|
|
case errors.Is(err, core.ErrIntrinsicGas):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeIntrinsicGas}
|
|
case errors.Is(err, core.ErrInsufficientFundsForTransfer):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeInsufficientFunds}
|
|
case errors.Is(err, vm.ErrMaxInitCodeSizeExceeded):
|
|
return &invalidTxError{Message: err.Error(), Code: errCodeMaxInitCodeSizeExceeded}
|
|
}
|
|
return &invalidTxError{
|
|
Message: err.Error(),
|
|
Code: errCodeInternalError,
|
|
}
|
|
}
|
|
|
|
// Standardized JSON-RPC error codes for transaction submission, shared across
|
|
// EVM clients via the execution-apis error-code catalog (src/error-groups):
|
|
// ExecutionErrors (1-199), GasErrors (800-999) and TxPoolErrors (1000-1199).
|
|
// See https://github.com/ethereum/execution-apis/tree/master/src/error-groups.
|
|
const (
|
|
errCodeStdNonceTooLow = 1
|
|
errCodeStdNonceTooHigh = 2
|
|
errCodeStdIntrinsicGas = 800
|
|
errCodeStdGasPriceTooLow = 802
|
|
errCodeStdGasExceedsBlockLimit = 803
|
|
errCodeStdTipAboveFeeCap = 804
|
|
errCodeStdGasUintOverflow = 805
|
|
errCodeStdFeeCapTooLow = 806
|
|
errCodeStdTipVeryHigh = 807
|
|
errCodeStdFeeCapVeryHigh = 808
|
|
errCodeStdInsufficientFunds = 809
|
|
errCodeStdAlreadyKnown = 1000
|
|
errCodeStdInvalidSender = 1001
|
|
errCodeStdReplaceUnderpriced = 1002
|
|
)
|
|
|
|
// txSubmitError maps an error returned while submitting a transaction to the
|
|
// pool (eth_sendTransaction / eth_sendRawTransaction) to its standardized
|
|
// execution-apis JSON-RPC error code, preserving the original error message.
|
|
// Errors without a catalog code are returned unchanged, so they keep geth's
|
|
// default behavior (the generic -32000 code).
|
|
func txSubmitError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if code, ok := txSubmitErrorCode(err); ok {
|
|
return &invalidTxError{Message: err.Error(), Code: code}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// txSubmitErrorCode returns the standardized error code for a transaction
|
|
// submission error, and whether a code is defined for it.
|
|
func txSubmitErrorCode(err error) (int, bool) {
|
|
switch {
|
|
// TxPoolErrors (1000-1199)
|
|
case errors.Is(err, txpool.ErrAlreadyKnown):
|
|
return errCodeStdAlreadyKnown, true
|
|
case errors.Is(err, txpool.ErrInvalidSender):
|
|
return errCodeStdInvalidSender, true
|
|
case errors.Is(err, txpool.ErrReplaceUnderpriced):
|
|
return errCodeStdReplaceUnderpriced, true
|
|
// GasErrors (800-999)
|
|
case errors.Is(err, core.ErrIntrinsicGas):
|
|
return errCodeStdIntrinsicGas, true
|
|
case errors.Is(err, txpool.ErrTxGasPriceTooLow):
|
|
return errCodeStdGasPriceTooLow, true
|
|
case errors.Is(err, txpool.ErrGasLimit):
|
|
return errCodeStdGasExceedsBlockLimit, true
|
|
case errors.Is(err, core.ErrTipAboveFeeCap):
|
|
return errCodeStdTipAboveFeeCap, true
|
|
case errors.Is(err, core.ErrGasUintOverflow):
|
|
return errCodeStdGasUintOverflow, true
|
|
case errors.Is(err, core.ErrFeeCapTooLow):
|
|
return errCodeStdFeeCapTooLow, true
|
|
case errors.Is(err, core.ErrTipVeryHigh):
|
|
return errCodeStdTipVeryHigh, true
|
|
case errors.Is(err, core.ErrFeeCapVeryHigh):
|
|
return errCodeStdFeeCapVeryHigh, true
|
|
case errors.Is(err, core.ErrInsufficientFunds), errors.Is(err, core.ErrInsufficientFundsForTransfer):
|
|
return errCodeStdInsufficientFunds, true
|
|
// ExecutionErrors (1-199)
|
|
case errors.Is(err, core.ErrNonceTooLow):
|
|
return errCodeStdNonceTooLow, true
|
|
case errors.Is(err, core.ErrNonceTooHigh):
|
|
return errCodeStdNonceTooHigh, true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
type invalidParamsError struct{ message string }
|
|
|
|
func (e *invalidParamsError) Error() string { return e.message }
|
|
func (e *invalidParamsError) ErrorCode() int { return errCodeInvalidParams }
|
|
|
|
type clientLimitExceededError struct{ message string }
|
|
|
|
func (e *clientLimitExceededError) Error() string { return e.message }
|
|
func (e *clientLimitExceededError) ErrorCode() int { return errCodeClientLimitExceeded }
|
|
|
|
type invalidBlockNumberError struct{ message string }
|
|
|
|
func (e *invalidBlockNumberError) Error() string { return e.message }
|
|
func (e *invalidBlockNumberError) ErrorCode() int { return errCodeBlockNumberInvalid }
|
|
|
|
type invalidBlockTimestampError struct{ message string }
|
|
|
|
func (e *invalidBlockTimestampError) Error() string { return e.message }
|
|
func (e *invalidBlockTimestampError) ErrorCode() int { return errCodeBlockTimestampInvalid }
|
|
|
|
type blockGasLimitReachedError struct{ message string }
|
|
|
|
func (e *blockGasLimitReachedError) Error() string { return e.message }
|
|
func (e *blockGasLimitReachedError) ErrorCode() int { return errCodeBlockGasLimitReached }
|
|
|
|
func (e *txSyncTimeoutError) Error() string { return e.msg }
|
|
func (e *txSyncTimeoutError) ErrorCode() int { return errCodeTxSyncTimeout }
|
|
func (e *txSyncTimeoutError) ErrorData() interface{} { return e.hash.Hex() }
|