Fix breaking changes due to BlockNumber special values

Author: m-Peter

api/api.go

@@ -295,15 +295,12 @@ func (b *BlockChainAPI) GetTransactionByBlockNumberAndIndex(
 		return nil, err
 	}
 
-	if blockNumber < rpc.EarliestBlockNumber {
-		latestBlockNumber, err := b.blocks.LatestEVMHeight()
-		if err != nil {
-			return handleError[*ethTypes.Transaction](err, l, b.collector)
-		}
-		blockNumber = rpc.BlockNumber(latestBlockNumber)
+	height, err := resolveBlockNumber(blockNumber, b.blocks)
+	if err != nil {
+		return nil, err
 	}
 
-	block, err := b.blocks.GetByHeight(uint64(blockNumber))
+	block, err := b.blocks.GetByHeight(height)
 	if err != nil {
 		return handleError[*ethTypes.Transaction](err, l, b.collector)
 	}
@@ -387,6 +384,7 @@ func (b *BlockChainAPI) GetBlockByHash(
 //   - When blockNr is -2 the chain latest block is returned.
 //   - When blockNr is -3 the chain finalized block is returned.
 //   - When blockNr is -4 the chain safe block is returned.
+//   - When blockNr is -5 the chain earliest block is returned.
 //   - When fullTx is true all transactions in the block are returned, otherwise
 //     only the transaction hash is returned.
 func (b *BlockChainAPI) GetBlockByNumber(
@@ -403,13 +401,9 @@ func (b *BlockChainAPI) GetBlockByNumber(
 		return nil, err
 	}
 
-	height := uint64(blockNumber)
-	var err error
-	if blockNumber < 0 {
-		height, err = b.blocks.LatestEVMHeight()
-		if err != nil {
-			return handleError[*ethTypes.Block](err, l, b.collector)
-		}
+	height, err := resolveBlockNumber(blockNumber, b.blocks)
+	if err != nil {
+		return handleError[*ethTypes.Block](err, l, b.collector)
 	}
 
 	block, err := b.blocks.GetByHeight(height)
@@ -430,7 +424,7 @@ func (b *BlockChainAPI) GetBlockByNumber(
 func (b *BlockChainAPI) GetBlockReceipts(
 	ctx context.Context,
 	blockNumberOrHash rpc.BlockNumberOrHash,
-) ([]map[string]interface{}, error) {
+) ([]map[string]any, error) {
 	l := b.logger.With().
 		Str("endpoint", "getBlockReceipts").
 		Str("hash", blockNumberOrHash.String()).
@@ -442,29 +436,29 @@ func (b *BlockChainAPI) GetBlockReceipts(
 
 	height, err := resolveBlockTag(&blockNumberOrHash, b.blocks, b.logger)
 	if err != nil {
-		return handleError[[]map[string]interface{}](err, l, b.collector)
+		return handleError[[]map[string]any](err, l, b.collector)
 	}
 
 	block, err := b.blocks.GetByHeight(height)
 	if err != nil {
-		return handleError[[]map[string]interface{}](err, l, b.collector)
+		return handleError[[]map[string]any](err, l, b.collector)
 	}
 
-	receipts := make([]map[string]interface{}, len(block.TransactionHashes))
+	receipts := make([]map[string]any, len(block.TransactionHashes))
 	for i, hash := range block.TransactionHashes {
 		tx, err := b.transactions.Get(hash)
 		if err != nil {
-			return handleError[[]map[string]interface{}](err, l, b.collector)
+			return handleError[[]map[string]any](err, l, b.collector)
 		}
 
 		receipt, err := b.receipts.GetByTransactionID(hash)
 		if err != nil {
-			return handleError[[]map[string]interface{}](err, l, b.collector)
+			return handleError[[]map[string]any](err, l, b.collector)
 		}
 
 		receipts[i], err = ethTypes.MarshalReceipt(receipt, tx)
 		if err != nil {
-			return handleError[[]map[string]interface{}](err, l, b.collector)
+			return handleError[[]map[string]any](err, l, b.collector)
 		}
 	}
 
@@ -510,15 +504,12 @@ func (b *BlockChainAPI) GetBlockTransactionCountByNumber(
 		return nil, err
 	}
 
-	if blockNumber < rpc.EarliestBlockNumber {
-		latestBlockNumber, err := b.blocks.LatestEVMHeight()
-		if err != nil {
-			return handleError[*hexutil.Uint](err, l, b.collector)
-		}
-		blockNumber = rpc.BlockNumber(latestBlockNumber)
+	height, err := resolveBlockNumber(blockNumber, b.blocks)
+	if err != nil {
+		return handleError[*hexutil.Uint](err, l, b.collector)
 	}
 
-	block, err := b.blocks.GetByHeight(uint64(blockNumber))
+	block, err := b.blocks.GetByHeight(height)
 	if err != nil {
 		return handleError[*hexutil.Uint](err, l, b.collector)
 	}
@@ -638,10 +629,15 @@ func (b *BlockChainAPI) GetLogs(
 	latest := big.NewInt(int64(h))
 
 	// if special value, use latest block number
-	if from.Cmp(models.EarliestBlockNumber) < 0 {
+	if from.Cmp(models.EarliestBlockNumber) == 0 {
+		from = big.NewInt(0)
+	} else if from.Cmp(models.PendingBlockNumber) < 0 {
 		from = latest
 	}
-	if to.Cmp(models.EarliestBlockNumber) < 0 {
+
+	if to.Cmp(models.EarliestBlockNumber) == 0 {
+		to = big.NewInt(0)
+	} else if to.Cmp(models.PendingBlockNumber) < 0 {
 		to = latest
 	}
 
@@ -797,14 +793,9 @@ func (b *BlockChainAPI) FeeHistory(
 		)
 	}
 
-	lastBlockNumber := uint64(lastBlock)
-	var err error
-	if lastBlock < 0 {
-		// From the special block tags, we only support "latest".
-		lastBlockNumber, err = b.blocks.LatestEVMHeight()
-		if err != nil {
-			return handleError[*ethTypes.FeeHistoryResult](err, l, b.collector)
-		}
+	lastBlockNumber, err := resolveBlockNumber(lastBlock, b.blocks)
+	if err != nil {
+		return handleError[*ethTypes.FeeHistoryResult](err, l, b.collector)
 	}
 
 	var (
@@ -1046,17 +1037,17 @@ func (b *BlockChainAPI) GetUncleByBlockHashAndIndex(
 	ctx context.Context,
 	blockHash common.Hash,
 	index hexutil.Uint,
-) (map[string]interface{}, error) {
-	return map[string]interface{}{}, nil
+) (map[string]any, error) {
+	return map[string]any{}, nil
 }
 
 // GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index.
 func (b *BlockChainAPI) GetUncleByBlockNumberAndIndex(
 	ctx context.Context,
 	blockNumber rpc.BlockNumber,
 	index hexutil.Uint,
-) (map[string]interface{}, error) {
-	return map[string]interface{}{}, nil
+) (map[string]any, error) {
+	return map[string]any{}, nil
 }
 
 // MaxPriorityFeePerGas returns a suggestion for a gas tip cap for dynamic fee transactions.

api/debug.go

@@ -359,7 +359,11 @@ func (d *DebugAPI) traceBlockByNumber(
 	number rpc.BlockNumber,
 	config *tracers.TraceConfig,
 ) ([]*txTraceResult, error) {
-	block, err := d.blocks.GetByHeight(uint64(number.Int64()))
+	height, err := resolveBlockNumber(number, d.blocks)
+	if err != nil {
+		return nil, err
+	}
+	block, err := d.blocks.GetByHeight(height)
 	if err != nil {
 		return nil, err
 	}

api/utils.go

@@ -55,29 +55,31 @@ func resolveBlockTag(
 }
 
 func resolveBlockNumber(
-	number rpc.BlockNumber,
+	blockNumber rpc.BlockNumber,
 	blocksDB storage.BlockIndexer,
 ) (uint64, error) {
-	height := number.Int64()
-
 	// if special values (latest) we return latest executed height
 	//
 	// all the special values are:
+	//	EarliestBlockNumber  = BlockNumber(-5)
 	//	SafeBlockNumber      = BlockNumber(-4)
 	//	FinalizedBlockNumber = BlockNumber(-3)
 	//	LatestBlockNumber    = BlockNumber(-2)
 	//	PendingBlockNumber   = BlockNumber(-1)
 	//
 	// EVM on Flow does not have these concepts, but the latest block is the closest fit
-	if height < 0 {
-		executed, err := blocksDB.LatestEVMHeight()
+	height := uint64(blockNumber)
+	var err error
+	if blockNumber == rpc.EarliestBlockNumber {
+		height = 0
+	} else if blockNumber <= rpc.PendingBlockNumber {
+		height, err = blocksDB.LatestEVMHeight()
 		if err != nil {
 			return 0, err
 		}
-		height = int64(executed)
 	}
 
-	return uint64(height), nil
+	return height, nil
 }
 
 // decodeHash parses a hex-encoded 32-byte hash. The input may optionally

models/block.go

@@ -14,9 +14,12 @@ import (
 )
 
 var (
-	LatestBlockNumber   = big.NewInt(-2)
-	EarliestBlockNumber = big.NewInt(0)
-	zeroGethHash        = gethCommon.HexToHash("0x0")
+	EarliestBlockNumber  = big.NewInt(-5)
+	SafeBlockNumber      = big.NewInt(-4)
+	FinalizedBlockNumber = big.NewInt(-3)
+	LatestBlockNumber    = big.NewInt(-2)
+	PendingBlockNumber   = big.NewInt(-1)
+	zeroGethHash         = gethCommon.HexToHash("0x0")
 )
 
 func GenesisBlock(chainID flow.ChainID) *Block {