forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-18 10:50:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

all: use FinalizedBlockNumber instead of CommittedBlockNumber (#1847)

Browse source
This commit is contained in:
Daniel Liu 2025-12-11 18:49:51 +08:00 committed by GitHub
parent 6ccbf98292
commit 94d0fceffe
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 43 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
accounts/abi/bind/backends/simulated.go
View file

@ -955,7 +955,7 @@ func (fb *filterBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNum
return nil, nil return nil, nil
case rpc.LatestBlockNumber: case rpc.LatestBlockNumber:
return fb.bc.CurrentHeader(), nil return fb.bc.CurrentHeader(), nil
case rpc.CommittedBlockNumber: case rpc.FinalizedBlockNumber:
if fb.bc.Config().XDPoS == nil { if fb.bc.Config().XDPoS == nil {
return nil, errors.New("only XDPoS v2 supports committed block lookup") return nil, errors.New("only XDPoS v2 supports committed block lookup")
} }

4
consensus/XDPoS/api.go
View file

@ -192,7 +192,7 @@ func (api *API) GetMasternodesByNumber(number *rpc.BlockNumber) MasternodesStatu
var header *types.Header var header *types.Header
if number == nil || *number == rpc.LatestBlockNumber { if number == nil || *number == rpc.LatestBlockNumber {
header = api.chain.CurrentHeader() header = api.chain.CurrentHeader()
} else if *number == rpc.CommittedBlockNumber { } else if *number == rpc.FinalizedBlockNumber {
if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil { if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil {
header = api.chain.GetHeaderByHash(info.Hash) header = api.chain.GetHeaderByHash(info.Hash)
} }
@ -403,7 +403,7 @@ func (api *API) getHeaderFromApiBlockNum(number *rpc.BlockNumber) (*types.Header
var header *types.Header var header *types.Header
if number == nil || *number == rpc.LatestBlockNumber { if number == nil || *number == rpc.LatestBlockNumber {
header = api.chain.CurrentHeader() header = api.chain.CurrentHeader()
} else if *number == rpc.CommittedBlockNumber { } else if *number == rpc.FinalizedBlockNumber {
if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil { if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil {
header = api.chain.GetHeaderByHash(info.Hash) header = api.chain.GetHeaderByHash(info.Hash)
} }

4
eth/api_backend.go
View file

@ -86,7 +86,7 @@ func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumb
if number == rpc.LatestBlockNumber { if number == rpc.LatestBlockNumber {
return b.eth.blockchain.CurrentBlock().Header(), nil return b.eth.blockchain.CurrentBlock().Header(), nil
} }
if number == rpc.CommittedBlockNumber { if number == rpc.FinalizedBlockNumber {
if b.eth.chainConfig.XDPoS == nil { if b.eth.chainConfig.XDPoS == nil {
return nil, errors.New("PoW does not support confirmed block lookup") return nil, errors.New("PoW does not support confirmed block lookup")
} }
@ -138,7 +138,7 @@ func (b *EthAPIBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumbe
if number == rpc.LatestBlockNumber { if number == rpc.LatestBlockNumber {
return b.eth.blockchain.CurrentBlock(), nil return b.eth.blockchain.CurrentBlock(), nil
} }
if number == rpc.CommittedBlockNumber { if number == rpc.FinalizedBlockNumber {
if b.eth.chainConfig.XDPoS == nil { if b.eth.chainConfig.XDPoS == nil {
return nil, errors.New("PoW does not support confirmed block lookup") return nil, errors.New("PoW does not support confirmed block lookup")
} }

4
eth/filters/filter.go
View file

@ -131,8 +131,8 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) {
if hdr == nil { if hdr == nil {
return 0, errors.New("latest header not found") return 0, errors.New("latest header not found")
} }
case rpc.CommittedBlockNumber.Int64(): case rpc.FinalizedBlockNumber.Int64():
hdr, _ = f.sys.backend.HeaderByNumber(ctx, rpc.CommittedBlockNumber) hdr, _ = f.sys.backend.HeaderByNumber(ctx, rpc.FinalizedBlockNumber)
if hdr == nil { if hdr == nil {
return 0, errors.New("committed header not found") return 0, errors.New("committed header not found")
} }

2
eth/filters/filter_system_test.go
View file

@ -79,7 +79,7 @@ func (b *testBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumbe
return nil, nil return nil, nil
} }
num = *number num = *number
case rpc.CommittedBlockNumber: case rpc.FinalizedBlockNumber:
return nil, nil return nil, nil
default: default:
num = uint64(blockNr) num = uint64(blockNr)

6
eth/filters/filter_test.go
View file

@ -300,13 +300,13 @@ func TestFilters(t *testing.T) {
f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x21fd39694cbcc8cc5046b3b7d5200101edf9c85218da613a8851eb5e3d195241","transactionIndex":"0x0","blockHash":"0x8a956d79ca6468ff23c97615a4aa24a55bdaff78767ee28d3e2e02ecb407a0de","logIndex":"0x0","removed":false}]`, want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x21fd39694cbcc8cc5046b3b7d5200101edf9c85218da613a8851eb5e3d195241","transactionIndex":"0x0","blockHash":"0x8a956d79ca6468ff23c97615a4aa24a55bdaff78767ee28d3e2e02ecb407a0de","logIndex":"0x0","removed":false}]`,
}, { }, {
f: sys.NewRangeFilter(int64(rpc.CommittedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
err: "committed header not found", err: "committed header not found",
}, { }, {
f: sys.NewRangeFilter(int64(rpc.CommittedBlockNumber), int64(rpc.CommittedBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil),
err: "committed header not found", err: "committed header not found",
}, { }, {
f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.CommittedBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil),
err: "committed header not found", err: "committed header not found",
}, { }, {
f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil),

4
eth/gasprice/feehistory.go
View file

@ -178,8 +178,8 @@ func (oracle *Oracle) resolveBlockRange(ctx context.Context, reqEnd rpc.BlockNum
case rpc.LatestBlockNumber: case rpc.LatestBlockNumber:
// Retrieved above. // Retrieved above.
resolved = headBlock resolved = headBlock
case rpc.CommittedBlockNumber: case rpc.FinalizedBlockNumber:
resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.CommittedBlockNumber) resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.FinalizedBlockNumber)
case rpc.EarliestBlockNumber: case rpc.EarliestBlockNumber:
resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.EarliestBlockNumber) resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.EarliestBlockNumber)
} }

2
eth/gasprice/feehistory_test.go
View file

@ -50,7 +50,7 @@ func TestFeeHistory(t *testing.T) {
{false, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 1, nil}, {false, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 1, nil},
{true, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 2, nil}, {true, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 2, nil},
{true, 1000, 1000, 2, rpc.PendingBlockNumber, []float64{0, 10}, 32, 2, nil}, {true, 1000, 1000, 2, rpc.PendingBlockNumber, []float64{0, 10}, 32, 2, nil},
{false, 1000, 1000, 2, rpc.CommittedBlockNumber, []float64{0, 10}, 32, 1, nil}, {false, 1000, 1000, 2, rpc.FinalizedBlockNumber, []float64{0, 10}, 32, 1, nil},
} }
for i, c := range cases { for i, c := range cases {
config := Config{ config := Config{

4
eth/gasprice/gasprice_test.go
View file

@ -48,7 +48,7 @@ func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber
if number == rpc.EarliestBlockNumber { if number == rpc.EarliestBlockNumber {
number = 0 number = 0
} }
if number == rpc.CommittedBlockNumber { if number == rpc.FinalizedBlockNumber {
return b.chain.CurrentBlock().Header(), nil return b.chain.CurrentBlock().Header(), nil
} }
if number == rpc.LatestBlockNumber { if number == rpc.LatestBlockNumber {
@ -71,7 +71,7 @@ func (b *testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber)
if number == rpc.EarliestBlockNumber { if number == rpc.EarliestBlockNumber {
number = 0 number = 0
} }
if number == rpc.CommittedBlockNumber { if number == rpc.FinalizedBlockNumber {
return b.chain.CurrentBlock(), nil return b.chain.CurrentBlock(), nil
} }
if number == rpc.LatestBlockNumber { if number == rpc.LatestBlockNumber {

35
rpc/types.go
View file

@ -65,7 +65,7 @@ type BlockNumber int64
type EpochNumber int64 type EpochNumber int64
const ( const (
CommittedBlockNumber = BlockNumber(-3) FinalizedBlockNumber = BlockNumber(-3)
LatestBlockNumber = BlockNumber(-2) LatestBlockNumber = BlockNumber(-2)
PendingBlockNumber = BlockNumber(-1) PendingBlockNumber = BlockNumber(-1)
EarliestBlockNumber = BlockNumber(0) EarliestBlockNumber = BlockNumber(0)
@ -96,29 +96,30 @@ func (bn *BlockNumber) UnmarshalJSON(data []byte) error {
*bn = PendingBlockNumber *bn = PendingBlockNumber
return nil return nil
case "committed", "finalized": case "committed", "finalized":
*bn = CommittedBlockNumber *bn = FinalizedBlockNumber
return nil return nil
} }
var blckNum uint64
var err error var err error
var number uint64
//Check if input is valid hex string before converting.
if hexutil.Has0xPrefix(input) { if hexutil.Has0xPrefix(input) {
blckNum, err = hexutil.DecodeUint64(input) // Convert input to hexadecimal integer.
} else { number, err = hexutil.DecodeUint64(input)
//Else try converting input directly into uint64 value
blckNum, err = strconv.ParseUint(input, 10, 64)
}
if err != nil { if err != nil {
return err return fmt.Errorf("fail to decode %s, err: %v", input, err)
}
} else {
// Convert input to decimal uint64.
number, err = strconv.ParseUint(input, 10, 64)
if err != nil {
return fmt.Errorf("fail to parse %s, err: %v", input, err)
}
} }
if blckNum > math.MaxInt64 { if number > math.MaxInt64 {
return errors.New("block number larger than int64") return fmt.Errorf("block number %s is larger than MaxInt64", input)
} }
*bn = BlockNumber(blckNum) *bn = BlockNumber(number)
return nil return nil
} }
@ -142,7 +143,7 @@ func (bn BlockNumber) String() string {
return "latest" return "latest"
case PendingBlockNumber: case PendingBlockNumber:
return "pending" return "pending"
case CommittedBlockNumber: case FinalizedBlockNumber:
return "committed" return "committed"
default: default:
if bn < 0 { if bn < 0 {
@ -213,7 +214,7 @@ func (bnh *BlockNumberOrHash) UnmarshalJSON(data []byte) error {
bnh.BlockNumber = &bn bnh.BlockNumber = &bn
return nil return nil
case "committed", "finalized": case "committed", "finalized":
bn := CommittedBlockNumber bn := FinalizedBlockNumber
bnh.BlockNumber = &bn bnh.BlockNumber = &bn
return nil return nil
default: default:

18
rpc/types_test.go
View file

@ -47,8 +47,8 @@ func TestBlockNumberJSONUnmarshal(t *testing.T) {
11: {`"pending"`, false, PendingBlockNumber}, 11: {`"pending"`, false, PendingBlockNumber},
12: {`"latest"`, false, LatestBlockNumber}, 12: {`"latest"`, false, LatestBlockNumber},
13: {`"earliest"`, false, EarliestBlockNumber}, 13: {`"earliest"`, false, EarliestBlockNumber},
14: {`"committed"`, false, CommittedBlockNumber}, 14: {`"committed"`, false, FinalizedBlockNumber},
15: {`"finalized"`, false, CommittedBlockNumber}, 15: {`"finalized"`, false, FinalizedBlockNumber},
16: {`someString`, true, BlockNumber(0)}, 16: {`someString`, true, BlockNumber(0)},
17: {`""`, true, BlockNumber(0)}, 17: {`""`, true, BlockNumber(0)},
18: {``, true, BlockNumber(0)}, 18: {``, true, BlockNumber(0)},
@ -98,8 +98,8 @@ func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) {
11: {`"pending"`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)}, 11: {`"pending"`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)},
12: {`"latest"`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)}, 12: {`"latest"`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)},
13: {`"earliest"`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)}, 13: {`"earliest"`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)},
14: {`"committed"`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, 14: {`"committed"`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)},
15: {`"finalized"`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, 15: {`"finalized"`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)},
16: {`someString`, true, BlockNumberOrHash{}}, 16: {`someString`, true, BlockNumberOrHash{}},
17: {`""`, true, BlockNumberOrHash{}}, 17: {`""`, true, BlockNumberOrHash{}},
18: {``, true, BlockNumberOrHash{}}, 18: {``, true, BlockNumberOrHash{}},
@ -111,8 +111,8 @@ func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) {
24: {`{"blockNumber":"pending"}`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)}, 24: {`{"blockNumber":"pending"}`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)},
25: {`{"blockNumber":"latest"}`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)}, 25: {`{"blockNumber":"latest"}`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)},
26: {`{"blockNumber":"earliest"}`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)}, 26: {`{"blockNumber":"earliest"}`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)},
27: {`{"blockNumber":"committed"}`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, 27: {`{"blockNumber":"committed"}`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)},
28: {`{"blockNumber":"finalized"}`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, 28: {`{"blockNumber":"finalized"}`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)},
29: {`{"blockNumber":"0x1", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`, true, BlockNumberOrHash{}}, 29: {`{"blockNumber":"0x1", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`, true, BlockNumberOrHash{}},
} }
@ -150,8 +150,8 @@ func TestBlockNumberOrHash_WithNumber_MarshalAndUnmarshal(t *testing.T) {
{"pending", int64(PendingBlockNumber)}, {"pending", int64(PendingBlockNumber)},
{"latest", int64(LatestBlockNumber)}, {"latest", int64(LatestBlockNumber)},
{"earliest", int64(EarliestBlockNumber)}, {"earliest", int64(EarliestBlockNumber)},
{"committed", int64(CommittedBlockNumber)}, {"committed", int64(FinalizedBlockNumber)},
{"finalized", int64(CommittedBlockNumber)}, {"finalized", int64(FinalizedBlockNumber)},
} }
for _, test := range tests { for _, test := range tests {
t.Run(test.name, func(t *testing.T) { t.Run(test.name, func(t *testing.T) {
@ -182,7 +182,7 @@ func TestBlockNumberOrHash_StringAndUnmarshal(t *testing.T) {
BlockNumberOrHashWithNumber(PendingBlockNumber), BlockNumberOrHashWithNumber(PendingBlockNumber),
BlockNumberOrHashWithNumber(LatestBlockNumber), BlockNumberOrHashWithNumber(LatestBlockNumber),
BlockNumberOrHashWithNumber(EarliestBlockNumber), BlockNumberOrHashWithNumber(EarliestBlockNumber),
BlockNumberOrHashWithNumber(CommittedBlockNumber), BlockNumberOrHashWithNumber(FinalizedBlockNumber),
BlockNumberOrHashWithNumber(32), BlockNumberOrHashWithNumber(32),
BlockNumberOrHashWithHash(common.Hash{0xaa}, false), BlockNumberOrHashWithHash(common.Hash{0xaa}, false),
} }