diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 13eec1a070..b7ea3fcd72 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -955,7 +955,7 @@ func (fb *filterBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNum return nil, nil case rpc.LatestBlockNumber: return fb.bc.CurrentHeader(), nil - case rpc.CommittedBlockNumber: + case rpc.FinalizedBlockNumber: if fb.bc.Config().XDPoS == nil { return nil, errors.New("only XDPoS v2 supports committed block lookup") } diff --git a/consensus/XDPoS/api.go b/consensus/XDPoS/api.go index 3029505360..67a9d7698a 100644 --- a/consensus/XDPoS/api.go +++ b/consensus/XDPoS/api.go @@ -192,7 +192,7 @@ func (api *API) GetMasternodesByNumber(number *rpc.BlockNumber) MasternodesStatu var header *types.Header if number == nil || *number == rpc.LatestBlockNumber { header = api.chain.CurrentHeader() - } else if *number == rpc.CommittedBlockNumber { + } else if *number == rpc.FinalizedBlockNumber { if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil { header = api.chain.GetHeaderByHash(info.Hash) } @@ -403,7 +403,7 @@ func (api *API) getHeaderFromApiBlockNum(number *rpc.BlockNumber) (*types.Header var header *types.Header if number == nil || *number == rpc.LatestBlockNumber { header = api.chain.CurrentHeader() - } else if *number == rpc.CommittedBlockNumber { + } else if *number == rpc.FinalizedBlockNumber { if info := api.XDPoS.EngineV2.GetLatestCommittedBlockInfo(); info != nil { header = api.chain.GetHeaderByHash(info.Hash) } diff --git a/eth/api_backend.go b/eth/api_backend.go index 25a3a0d0fc..35b3be4d1e 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -86,7 +86,7 @@ func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumb if number == rpc.LatestBlockNumber { return b.eth.blockchain.CurrentBlock().Header(), nil } - if number == rpc.CommittedBlockNumber { + if number == rpc.FinalizedBlockNumber { if b.eth.chainConfig.XDPoS == nil { 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 { return b.eth.blockchain.CurrentBlock(), nil } - if number == rpc.CommittedBlockNumber { + if number == rpc.FinalizedBlockNumber { if b.eth.chainConfig.XDPoS == nil { return nil, errors.New("PoW does not support confirmed block lookup") } diff --git a/eth/filters/filter.go b/eth/filters/filter.go index d9819ee01d..5de7039e2e 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -131,8 +131,8 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) { if hdr == nil { return 0, errors.New("latest header not found") } - case rpc.CommittedBlockNumber.Int64(): - hdr, _ = f.sys.backend.HeaderByNumber(ctx, rpc.CommittedBlockNumber) + case rpc.FinalizedBlockNumber.Int64(): + hdr, _ = f.sys.backend.HeaderByNumber(ctx, rpc.FinalizedBlockNumber) if hdr == nil { return 0, errors.New("committed header not found") } diff --git a/eth/filters/filter_system_test.go b/eth/filters/filter_system_test.go index 2c55993baa..6cb8896b46 100644 --- a/eth/filters/filter_system_test.go +++ b/eth/filters/filter_system_test.go @@ -79,7 +79,7 @@ func (b *testBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumbe return nil, nil } num = *number - case rpc.CommittedBlockNumber: + case rpc.FinalizedBlockNumber: return nil, nil default: num = uint64(blockNr) diff --git a/eth/filters/filter_test.go b/eth/filters/filter_test.go index 05d348ff5b..cf4655ca39 100644 --- a/eth/filters/filter_test.go +++ b/eth/filters/filter_test.go @@ -300,13 +300,13 @@ func TestFilters(t *testing.T) { 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}]`, }, { - 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", }, { - 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", }, { - 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", }, { f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), diff --git a/eth/gasprice/feehistory.go b/eth/gasprice/feehistory.go index 598972181a..10a3716447 100644 --- a/eth/gasprice/feehistory.go +++ b/eth/gasprice/feehistory.go @@ -178,8 +178,8 @@ func (oracle *Oracle) resolveBlockRange(ctx context.Context, reqEnd rpc.BlockNum case rpc.LatestBlockNumber: // Retrieved above. resolved = headBlock - case rpc.CommittedBlockNumber: - resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.CommittedBlockNumber) + case rpc.FinalizedBlockNumber: + resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.FinalizedBlockNumber) case rpc.EarliestBlockNumber: resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.EarliestBlockNumber) } diff --git a/eth/gasprice/feehistory_test.go b/eth/gasprice/feehistory_test.go index 7fc77d57ed..ecf5efa942 100644 --- a/eth/gasprice/feehistory_test.go +++ b/eth/gasprice/feehistory_test.go @@ -50,7 +50,7 @@ func TestFeeHistory(t *testing.T) { {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, []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 { config := Config{ diff --git a/eth/gasprice/gasprice_test.go b/eth/gasprice/gasprice_test.go index 69a2b9a0ac..62661c3058 100644 --- a/eth/gasprice/gasprice_test.go +++ b/eth/gasprice/gasprice_test.go @@ -48,7 +48,7 @@ func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber if number == rpc.EarliestBlockNumber { number = 0 } - if number == rpc.CommittedBlockNumber { + if number == rpc.FinalizedBlockNumber { return b.chain.CurrentBlock().Header(), nil } if number == rpc.LatestBlockNumber { @@ -71,7 +71,7 @@ func (b *testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) if number == rpc.EarliestBlockNumber { number = 0 } - if number == rpc.CommittedBlockNumber { + if number == rpc.FinalizedBlockNumber { return b.chain.CurrentBlock(), nil } if number == rpc.LatestBlockNumber { diff --git a/rpc/types.go b/rpc/types.go index 62384c8264..01f6350ae9 100644 --- a/rpc/types.go +++ b/rpc/types.go @@ -65,7 +65,7 @@ type BlockNumber int64 type EpochNumber int64 const ( - CommittedBlockNumber = BlockNumber(-3) + FinalizedBlockNumber = BlockNumber(-3) LatestBlockNumber = BlockNumber(-2) PendingBlockNumber = BlockNumber(-1) EarliestBlockNumber = BlockNumber(0) @@ -96,29 +96,30 @@ func (bn *BlockNumber) UnmarshalJSON(data []byte) error { *bn = PendingBlockNumber return nil case "committed", "finalized": - *bn = CommittedBlockNumber + *bn = FinalizedBlockNumber return nil } - var blckNum uint64 var err error - - //Check if input is valid hex string before converting. + var number uint64 if hexutil.Has0xPrefix(input) { - blckNum, err = hexutil.DecodeUint64(input) + // Convert input to hexadecimal integer. + number, err = hexutil.DecodeUint64(input) + if err != nil { + return fmt.Errorf("fail to decode %s, err: %v", input, err) + } } else { - //Else try converting input directly into uint64 value - blckNum, err = strconv.ParseUint(input, 10, 64) + // 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 err != nil { - return err + if number > math.MaxInt64 { + return fmt.Errorf("block number %s is larger than MaxInt64", input) } - - if blckNum > math.MaxInt64 { - return errors.New("block number larger than int64") - } - *bn = BlockNumber(blckNum) + *bn = BlockNumber(number) return nil } @@ -142,7 +143,7 @@ func (bn BlockNumber) String() string { return "latest" case PendingBlockNumber: return "pending" - case CommittedBlockNumber: + case FinalizedBlockNumber: return "committed" default: if bn < 0 { @@ -213,7 +214,7 @@ func (bnh *BlockNumberOrHash) UnmarshalJSON(data []byte) error { bnh.BlockNumber = &bn return nil case "committed", "finalized": - bn := CommittedBlockNumber + bn := FinalizedBlockNumber bnh.BlockNumber = &bn return nil default: diff --git a/rpc/types_test.go b/rpc/types_test.go index 5ace764f22..c07b2d6975 100644 --- a/rpc/types_test.go +++ b/rpc/types_test.go @@ -47,8 +47,8 @@ func TestBlockNumberJSONUnmarshal(t *testing.T) { 11: {`"pending"`, false, PendingBlockNumber}, 12: {`"latest"`, false, LatestBlockNumber}, 13: {`"earliest"`, false, EarliestBlockNumber}, - 14: {`"committed"`, false, CommittedBlockNumber}, - 15: {`"finalized"`, false, CommittedBlockNumber}, + 14: {`"committed"`, false, FinalizedBlockNumber}, + 15: {`"finalized"`, false, FinalizedBlockNumber}, 16: {`someString`, true, BlockNumber(0)}, 17: {`""`, true, BlockNumber(0)}, 18: {``, true, BlockNumber(0)}, @@ -98,8 +98,8 @@ func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) { 11: {`"pending"`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)}, 12: {`"latest"`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)}, 13: {`"earliest"`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)}, - 14: {`"committed"`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, - 15: {`"finalized"`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, + 14: {`"committed"`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)}, + 15: {`"finalized"`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)}, 16: {`someString`, true, BlockNumberOrHash{}}, 17: {`""`, true, BlockNumberOrHash{}}, 18: {``, true, BlockNumberOrHash{}}, @@ -111,8 +111,8 @@ func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) { 24: {`{"blockNumber":"pending"}`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)}, 25: {`{"blockNumber":"latest"}`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)}, 26: {`{"blockNumber":"earliest"}`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)}, - 27: {`{"blockNumber":"committed"}`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, - 28: {`{"blockNumber":"finalized"}`, false, BlockNumberOrHashWithNumber(CommittedBlockNumber)}, + 27: {`{"blockNumber":"committed"}`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)}, + 28: {`{"blockNumber":"finalized"}`, false, BlockNumberOrHashWithNumber(FinalizedBlockNumber)}, 29: {`{"blockNumber":"0x1", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`, true, BlockNumberOrHash{}}, } @@ -150,8 +150,8 @@ func TestBlockNumberOrHash_WithNumber_MarshalAndUnmarshal(t *testing.T) { {"pending", int64(PendingBlockNumber)}, {"latest", int64(LatestBlockNumber)}, {"earliest", int64(EarliestBlockNumber)}, - {"committed", int64(CommittedBlockNumber)}, - {"finalized", int64(CommittedBlockNumber)}, + {"committed", int64(FinalizedBlockNumber)}, + {"finalized", int64(FinalizedBlockNumber)}, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { @@ -182,7 +182,7 @@ func TestBlockNumberOrHash_StringAndUnmarshal(t *testing.T) { BlockNumberOrHashWithNumber(PendingBlockNumber), BlockNumberOrHashWithNumber(LatestBlockNumber), BlockNumberOrHashWithNumber(EarliestBlockNumber), - BlockNumberOrHashWithNumber(CommittedBlockNumber), + BlockNumberOrHashWithNumber(FinalizedBlockNumber), BlockNumberOrHashWithNumber(32), BlockNumberOrHashWithHash(common.Hash{0xaa}, false), }