R4R: Feature/ivan/migrate get block range to op geth

ethclient/ethclient_test.go

@@ -25,6 +25,7 @@ import (
  "net"
  "net/http"
  "reflect"
+ "strings"
  "testing"
  "time"
 
@@ -343,6 +344,15 @@ func TestEthClientHistoricalBackend(t *testing.T) {
  testHistoricalRPC(t, client)
 }
 
+func TestEthClientGetBlockRangeBackend(t *testing.T) {
+ backend, _ := newTestBackend(t, true)
+ client, _ := backend.Attach()
+ defer backend.Close()
+ defer client.Close()
+
+ testGetBlockRangeRPC(t, client)
+}
+
 func TestEthClient(t *testing.T) {
  backend, chain := newTestBackend(t, false)
  client, _ := backend.Attach()
@@ -802,6 +812,44 @@ func testEstimateGas(t *testing.T, client *rpc.Client) {
  }
 }
 
+func testGetBlockRangeRPC(t *testing.T, client *rpc.Client) {
+ type args struct {
+ startNumber string
+ endNumber string
+ fullTx bool
+ }
+ tests := []struct {
+ name string
+ args args
+ wantBlocksLength int
+ wantErr bool
+ containsErr string
+ }{
+ {"0-0", args{"0x0", "0x0", true}, 1, false, ""},
+ {"0-1", args{"0x0", "0x1", true}, 2, false, ""},
+ {"0-2", args{"0x0", "0x2", true}, 3, false, ""},
+ {"0-30", args{"0x0", "0x1e", true}, 0, true, "block in range not indexed, this should never happen"},
+ {"0-1030", args{"0x0", "0x406", true}, 0, true, "requested block range is too large (max is 1000"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := make([]map[string]interface{}, 0)
+ err := client.CallContext(context.Background(), &got, "eth_getBlockRange", tt.args.startNumber, tt.args.endNumber, tt.args.fullTx)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("BlockChainAPI.GetBlockRange() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(len(got), tt.wantBlocksLength) {
+ t.Errorf("BlockChainAPI.GetBlockRange() = %v, want %v", len(got), tt.wantBlocksLength)
+ }
+ if tt.wantErr && !strings.Contains(err.Error(), tt.containsErr) {
+ t.Errorf("BlockChainAPI.GetBlockRange() error = %v, wantErr %v", err, tt.containsErr)
+ return
+ }
+ })
+ }
+}
+
 func testHistoricalRPC(t *testing.T, client *rpc.Client) {
  ec := NewClient(client)
 

internal/ethapi/api.go

@@ -952,6 +952,38 @@ func headerByNumberOrHash(ctx context.Context, b Backend, blockNrOrHash rpc.Bloc
  return header, err
 }
 
+func (s *BlockChainAPI) GetBlockRange(ctx context.Context, startNumber rpc.BlockNumber, endNumber rpc.BlockNumber, fullTx bool) ([]map[string]interface{}, error) {
+ // Basic assertions about start and end block numbers.
+ if endNumber < startNumber {
+ return nil, fmt.Errorf("start of block range (%d) is greater than end of block range (%d)", startNumber, endNumber)
+ }
+
+ // Assert that the number of blocks is < 1k (? configurable?).
+ if endNumber-startNumber > 1000 {
+ return nil, fmt.Errorf("requested block range is too large (max is 1000, requested %d blocks)", endNumber-startNumber)
+ }
+
+ // Make sure the end exists. If start doesn't exist, will be caught immediately below.
+ if _, err := s.GetBlockByNumber(ctx, endNumber, fullTx); err != nil {
+ return nil, fmt.Errorf("end of requested block range (%d) does not exist: %w", endNumber, err)
+ }
+
+ // Create an empty output array.
+ blocks := make([]map[string]interface{}, 0)
+ // For each block in range, get block and append to array.
+ for number := startNumber; number <= endNumber; number++ {
+ block, err := s.GetBlockByNumber(ctx, number, fullTx)
+ if err != nil {
+ return nil, err
+ }
+ if block == nil {
+ return nil, errors.New("block in range not indexed, this should never happen")
+ }
+ blocks = append(blocks, block)
+ }
+ return blocks, nil
+}
+
 // OverrideAccount indicates the overriding fields of account during the execution
 // of a message call.
 // Note, state and stateDiff can't be specified at the same time. If state is