Implementation of the debug_getRawReceipts method

jsonrpc/debug_endpoint.go

@@ -34,6 +34,9 @@ type debugBlockchainStore interface {
 	// GetHeaderByNumber gets a header using the provided number
 	GetHeaderByNumber(uint64) (*types.Header, bool)
 
+	// GetReceiptsByHash returns the receipts by block hash
+	GetReceiptsByHash(types.Hash) ([]*types.Receipt, error)
+
 	// ReadTxLookup returns a block hash in which a given txn was mined
 	ReadTxLookup(txnHash types.Hash) (uint64, bool)
 
@@ -295,6 +298,33 @@ func (d *Debug) GetRawTransaction(txHash types.Hash) (interface{}, error) {
 	)
 }
 
+// GetRawReceipts retrieves the binary-encoded receipts of a single block.
+func (d *Debug) GetRawReceipts(filter BlockNumberOrHash) (interface{}, error) {
+	return d.throttling.AttemptRequest(
+		context.Background(),
+		func() (interface{}, error) {
+			header, err := GetHeaderFromBlockNumberOrHash(filter, d.store)
+			if err != nil {
+				return nil, err
+			}
+
+			receipts, err := d.store.GetReceiptsByHash(header.Hash)
+			if err != nil {
+				return nil, err
+			}
+
+			result := make([][]byte, len(receipts))
+
+			for i, receipt := range receipts {
+				b := receipt.MarshalRLP()
+				result[i] = b
+			}
+
+			return result, nil
+		},
+	)
+}
+
 func (d *Debug) traceBlock(
 	block *types.Block,
 	config *TraceConfig,

jsonrpc/debug_endpoint_test.go

@@ -19,6 +19,7 @@ import (
 type debugEndpointMockStore struct {
 	headerFn            func() *types.Header
 	getHeaderByNumberFn func(uint64) (*types.Header, bool)
+	getReceiptsByHashFn func(types.Hash) ([]*types.Receipt, error)
 	readTxLookupFn      func(types.Hash) (uint64, bool)
 	getPendingTxFn      func(types.Hash) (*types.Transaction, bool)
 	getBlockByHashFn    func(types.Hash, bool) (*types.Block, bool)
@@ -38,6 +39,10 @@ func (s *debugEndpointMockStore) GetHeaderByNumber(num uint64) (*types.Header, b
 	return s.getHeaderByNumberFn(num)
 }
 
+func (s *debugEndpointMockStore) GetReceiptsByHash(hash types.Hash) ([]*types.Receipt, error) {
+	return s.getReceiptsByHashFn(hash)
+}
+
 func (s *debugEndpointMockStore) ReadTxLookup(txnHash types.Hash) (uint64, bool) {
 	return s.readTxLookupFn(txnHash)
 }
@@ -1070,6 +1075,97 @@ func TestGetRawTransaction(t *testing.T) {
 	}
 }
 
+func TestGetRawReceipts(t *testing.T) {
+	t.Parallel()
+
+	const (
+		cumulativeGasUsed = 28000
+		gasUsed           = 26000
+	)
+
+	rec := createTestReceipt(nil, cumulativeGasUsed, gasUsed, testTx1.Hash())
+	receipts := []*types.Receipt{rec}
+
+	tests := []struct {
+		name   string
+		filter BlockNumberOrHash
+		store  *debugEndpointMockStore
+		result interface{}
+		err    bool
+	}{
+		{
+			name:   "HeaderNotFound",
+			filter: EarliestBlockNumberOrHash,
+			store: &debugEndpointMockStore{
+				getHeaderByNumberFn: func(num uint64) (*types.Header, bool) {
+					assert.Equal(t, uint64(0), num)
+
+					return nil, false
+				},
+			},
+			result: nil,
+			err:    true,
+		},
+		{
+			name:   "ReceiptsNotFound",
+			filter: LatestBlockNumberOrHash,
+
+			store: &debugEndpointMockStore{
+				headerFn: func() *types.Header {
+					return testLatestBlock.Header
+				},
+				getBlockByHashFn: func(hash types.Hash, full bool) (*types.Block, bool) {
+					return testLatestBlock, true
+				},
+				getReceiptsByHashFn: func(hash types.Hash) ([]*types.Receipt, error) {
+					return nil, ErrExecutionTimeout
+				},
+			},
+			result: nil,
+			err:    true,
+		},
+		{
+			name:   "Success",
+			filter: LatestBlockNumberOrHash,
+			store: &debugEndpointMockStore{
+				headerFn: func() *types.Header {
+					return testLatestBlock.Header
+				},
+
+				getBlockByHashFn: func(hash types.Hash, full bool) (*types.Block, bool) {
+					return testLatestBlock, true
+				},
+
+				getReceiptsByHashFn: func(hash types.Hash) ([]*types.Receipt, error) {
+					return receipts, nil
+				},
+			},
+			result: [][]byte{rec.MarshalRLP()},
+			err:    false,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			endpoint := NewDebug(test.store, 100000)
+
+			res, err := endpoint.GetRawReceipts(test.filter)
+
+			assert.Equal(t, test.result, res)
+
+			if test.err {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
 func Test_newTracer(t *testing.T) {
 	t.Parallel()