refactor: refactored debug_getRawReceipts to not reuse eth_getBlockReceipts functionality (#4892)

Signed-off-by: Bartosz Solka <bartosz.solka@blockydevs.com>

Author: BartoszSolkaBD

docs/openrpc.json

@@ -1413,10 +1413,10 @@
       "description": "![](https://raw.githubusercontent.com/hiero-ledger/hiero-json-rpc-relay/main/docs/images/http_label.png)",
       "params": [
         {
-          "name": "Block",
+          "name": "block",
           "required": true,
           "schema": {
-            "$ref": "#/components/schemas/BlockNumberOrTag"
+            "$ref": "#/components/schemas/BlockNumberOrTagOrHash"
           }
         }
       ],

packages/relay/src/index.ts

@@ -35,7 +35,7 @@ export interface Debug {
 
   traceBlockByHash(blockHash: string, tracerObject: BlockTracerConfig, requestDetails: RequestDetails): Promise<any>;
 
-  getRawReceipts(blockHashOrNumber: string, requestDetails: RequestDetails): Promise<string[] | null>;
+  getRawReceipts(blockHashOrNumber: string, requestDetails: RequestDetails): Promise<string[]>;
 }
 
 export interface Web3 {

packages/relay/src/lib/debug.ts

@@ -4,7 +4,7 @@ import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services'
 import type { Logger } from 'pino';
 
 import { decodeErrorMessage, mapKeysAndValues, numberTo0x, prepend0x, strip0x, tinybarsToWeibars } from '../formatters';
-import { type Debug, Eth } from '../index';
+import { type Debug } from '../index';
 import { Utils } from '../utils';
 import { MirrorNodeClient } from './clients';
 import type { ICacheClient } from './clients/cache/ICacheClient';
@@ -13,8 +13,7 @@ import { IOpcodesResponse } from './clients/models/IOpcodesResponse';
 import constants, { CallType, TracerType } from './constants';
 import { cache, RPC_LAYOUT, rpcMethod, rpcParamLayoutConfig } from './decorators';
 import { predefined } from './errors/JsonRpcError';
-import { encodeReceiptToHex } from './receiptSerialization';
-import { CommonService } from './services';
+import { BlockService, CommonService, IBlockService } from './services';
 import {
   BlockTracerConfig,
   CallTracerResult,
@@ -67,10 +66,10 @@ export class DebugImpl implements Debug {
   private readonly cacheService: ICacheClient;
 
   /**
-   * The Eth implementation used for handling Ethereum-specific JSON-RPC requests.
+   * The Block Service implementation that takes care of all block API operations.
    * @private
    */
-  private readonly eth: Eth;
+  private readonly blockService: IBlockService;
 
   /**
    * Creates an instance of DebugImpl.
@@ -79,14 +78,14 @@ export class DebugImpl implements Debug {
    * @param {MirrorNodeClient} mirrorNodeClient - The client for interacting with the mirror node.
    * @param {Logger} logger - The logger used for logging output from this class.
    * @param {ICacheClient} cacheService - Service for managing cached data.
-   * @param {Eth} eth - The Eth implementation used for handling Ethereum-specific JSON-RPC requests.
+   * @param {string} chainId - The chain identifier for the current blockchain environment.
    */
-  constructor(mirrorNodeClient: MirrorNodeClient, logger: Logger, cacheService: ICacheClient, eth: Eth) {
+  constructor(mirrorNodeClient: MirrorNodeClient, logger: Logger, cacheService: ICacheClient, chainId: string) {
     this.logger = logger;
     this.common = new CommonService(mirrorNodeClient, logger, cacheService);
     this.mirrorNodeClient = mirrorNodeClient;
     this.cacheService = cacheService;
-    this.eth = eth;
+    this.blockService = new BlockService(cacheService, chainId, this.common, mirrorNodeClient, logger);
   }
 
   /**
@@ -268,7 +267,7 @@ export class DebugImpl implements Debug {
    * @rpcMethod Exposed as debug_getRawReceipts RPC endpoint
    * @rpcParamValidationRules Applies JSON-RPC parameter validation according to the API specification
    *
-   * @param {string} blockNumber - The number of the block to retrieve.
+   * @param {string} blockHashOrNumber - The block hash or block number.
    * @param {RequestDetails} requestDetails - The request details for logging and tracking.
    * @throws {Error} Throws an error if the debug API is not enabled or if an exception occurs.
    * @returns {Promise<string[] | null>} A Promise that resolves to an array of EIP-2718 binary-encoded receipts or null if block not found.
@@ -279,16 +278,14 @@ export class DebugImpl implements Debug {
    */
   @rpcMethod
   @rpcParamValidationRules({
-    0: { type: 'blockNumber', required: true },
+    0: { type: ['blockNumber', 'blockHash'], required: true },
   })
-  @cache()
-  async getRawReceipts(blockNumber: string, requestDetails: RequestDetails): Promise<string[] | null> {
+  @cache({
+    skipParams: [{ index: '0', value: constants.NON_CACHABLE_BLOCK_PARAMS }],
+  })
+  async getRawReceipts(blockHashOrNumber: string, requestDetails: RequestDetails): Promise<string[]> {
     DebugImpl.requireDebugAPIEnabled();
-    const receipts = await this.eth.getBlockReceipts(blockNumber, requestDetails);
-    if (!receipts) {
-      return null;
-    }
-    return receipts.map((receipt) => encodeReceiptToHex(receipt));
+    return await this.blockService.getRawReceipts(blockHashOrNumber, requestDetails);
   }
 
   /**

packages/relay/src/lib/factories/transactionReceiptFactory.ts

@@ -5,6 +5,7 @@ import { LogsBloomUtils } from '../../logsBloomUtils';
 import constants from '../constants';
 import { Log } from '../model';
 import { ITransactionReceipt } from '../types';
+import { IReceiptRlpInput } from '../types/IReceiptRlpInput';
 
 /**
  * Parameters specific to creating a synthetic transaction receipt from logs
@@ -25,6 +26,12 @@ interface IRegularTransactionReceiptParams {
   to: string | null;
 }
 
+interface IRegularTransactionReceiptRlpInputParams {
+  logs: Log[];
+  receiptResponse: any;
+  blockGasUsedBeforeTransaction: number;
+}
+
 /**
  * Factory for creating different types of transaction receipts
  */
@@ -57,6 +64,31 @@ class TransactionReceiptFactory {
     };
   }
 
+  /**
+   * Creates a minimal receipt payload for RLP-encoding of a synthetic transaction.
+   *
+   * Builds an `IReceiptRlpInput` from synthetic logs only, without resolving any
+   * addresses or constructing a full `ITransactionReceipt`. The returned shape
+   * contains the fields required for Yellow Paper receipt encoding, including a zero
+   * cumulative gas used, zero gas used, a logs bloom computed from the first
+   * synthetic log, default root and status values, the transaction index from
+   * the first log, and a fallback type of `0x0`.
+   *
+   * @param syntheticLogs - Logs belonging to the synthetic transaction.
+   * @returns Minimal receipt data suitable for RLP encoding.
+   */
+  public static createSyntheticReceiptRlpInput(syntheticLogs: Log[]): IReceiptRlpInput {
+    return {
+      cumulativeGasUsed: constants.ZERO_HEX,
+      logs: syntheticLogs,
+      logsBloom: LogsBloomUtils.buildLogsBloom(syntheticLogs[0].address, syntheticLogs[0].topics),
+      root: constants.DEFAULT_ROOT_HASH,
+      status: constants.ONE_HEX,
+      transactionIndex: syntheticLogs[0].transactionIndex,
+      type: constants.ZERO_HEX, // fallback to 0x0 from HAPI transactions
+    };
+  }
+
   /**
    * Creates a regular transaction receipt from mirror node contract result data
    *
@@ -127,6 +159,32 @@ class TransactionReceiptFactory {
     return receipt;
   }
 
+  /**
+   * Creates a minimal receipt payload for RLP-encoding of a regular transaction.
+   *
+   * Builds an `IReceiptRlpInput` from mirror node contract result data and the
+   * running cumulative gas used before this transaction. The returned shape
+   * contains only the fields required for Yellow Paper receipt encoding, including the updated cumulative gas used,
+   * logs and bloom, root and status, transaction index, and normalized type.
+   * @param params - Parameters required to build the RLP input, including
+   *   contract result data, associated logs, and the cumulative gas used prior
+   *   to this transaction.
+   * @returns Minimal receipt data suitable for RLP encoding.
+   */
+  public static createReceiptRlpInput(params: IRegularTransactionReceiptRlpInputParams): IReceiptRlpInput {
+    const { receiptResponse, logs, blockGasUsedBeforeTransaction } = params;
+
+    return {
+      cumulativeGasUsed: numberTo0x(blockGasUsedBeforeTransaction + receiptResponse.gas_used),
+      logs: logs,
+      logsBloom: receiptResponse.bloom === constants.EMPTY_HEX ? constants.EMPTY_BLOOM : receiptResponse.bloom,
+      root: receiptResponse.root || constants.DEFAULT_ROOT_HASH,
+      status: receiptResponse.status,
+      transactionIndex: numberTo0x(receiptResponse.transaction_index),
+      type: nanOrNumberTo0x(receiptResponse.type),
+    };
+  }
+
   /**
    * Helper method to determine if a receipt response includes a contract address
    *
@@ -149,4 +207,9 @@ class TransactionReceiptFactory {
   }
 }
 
-export { ISyntheticTransactionReceiptParams, IRegularTransactionReceiptParams, TransactionReceiptFactory };
+export {
+  ISyntheticTransactionReceiptParams,
+  IRegularTransactionReceiptParams,
+  IRegularTransactionReceiptRlpInputParams,
+  TransactionReceiptFactory,
+};

packages/relay/src/lib/receiptSerialization.ts

@@ -16,17 +16,33 @@ import { bytesToInt, concatBytes, hexToBytes, intToBytes } from '@ethereumjs/uti
 
 import { prepend0x, toHexString } from '../formatters';
 import constants from './constants';
-import type { ITransactionReceipt } from './types';
+import type { Log } from './model';
+import { IReceiptRlpInput } from './types/IReceiptRlpInput';
 
-// Log shape used for encoding: address, topics[], data (per Yellow Paper log structure)
-function encodeLogsForReceipt(logs: ITransactionReceipt['logs']): [Uint8Array, Uint8Array[], Uint8Array][] {
+/**
+ * Converts receipt logs into the RLP encoded log structure.
+ *
+ * Each log becomes a 3-tuple [address, topics[], data] per the Yellow Paper
+ * (address and data as bytes; topics as array of 32-byte topic hashes).
+ *
+ * @param logs - The logs array from the transaction receipt (see {@link Log}).
+ * @returns Array of [address, topics, data] as Uint8Arrays for RLP encoding.
+ */
+function encodeLogsForReceipt(logs: Log[]): [Uint8Array, Uint8Array[], Uint8Array][] {
   return logs.map((log) => [hexToBytes(log.address), log.topics.map((t) => hexToBytes(t)), hexToBytes(log.data)]);
 }
 
 /**
- * Encodes a single receipt to EIP-2718 binary form (hex string).
+ * Encodes a single transaction receipt to EIP-2718 binary form.
+ *
+ * Produces the RLP-encoded 4-tuple (receipt_root_or_status, cumulative_gas_used,
+ * logs_bloom, logs) per the Ethereum Yellow Paper. For typed transactions (type !== 0),
+ * the output is the single-byte type prefix followed by that RLP payload (EIP-2718).
+ *
+ * @param receipt - The transaction receipt to encode (see {@link ITransactionReceipt}).
+ * @returns Hex string (0x-prefixed) of the encoded receipt, suitable for receipts root hashing.
  */
-export function encodeReceiptToHex(receipt: ITransactionReceipt): string {
+export function encodeReceiptToHex(receipt: IReceiptRlpInput): string {
   const txType = receipt.type !== null ? bytesToInt(hexToBytes(receipt.type)) : 0;
 
   // First field: receipt root or status (post-Byzantium)

packages/relay/src/lib/relay.ts

@@ -375,7 +375,7 @@ export class Relay {
     this.txpoolImpl = new TxPoolImpl(transactionPoolService);
 
     // Create Debug and Admin implementations
-    this.debugImpl = new DebugImpl(this.mirrorNodeClient, this.logger, this.cacheService, this.ethImpl);
+    this.debugImpl = new DebugImpl(this.mirrorNodeClient, this.logger, this.cacheService, chainId);
     this.adminImpl = new AdminImpl(this.cacheService);
 
     // Create HBAR spending plan config service

packages/relay/src/lib/services/ethService/blockService/BlockService.ts

@@ -3,13 +3,13 @@
 import { Logger } from 'pino';
 
 import { numberTo0x } from '../../../../formatters';
+import { ICacheClient } from '../../../clients/cache/ICacheClient';
 import { MirrorNodeClient } from '../../../clients/mirrorNodeClient';
 import constants from '../../../constants';
 import { Block } from '../../../model';
 import { ITransactionReceipt, MirrorNodeBlock, RequestDetails } from '../../../types';
 import { IBlockService, ICommonService } from '../../index';
 import { WorkersPool } from '../../workersService/WorkersPool';
-import { ICacheClient } from '../../../clients/cache/ICacheClient';
 
 export class BlockService implements IBlockService {
   /**
@@ -115,6 +115,25 @@ export class BlockService implements IBlockService {
     );
   }
 
+  /**
+   * Gets the raw transaction receipts for a block by block hash or block number.
+   *
+   * @param {string} blockHashOrBlockNumber The block hash or block number
+   * @param {RequestDetails} requestDetails The request details for logging and tracking
+   * @returns {Promise<string[]>} Array of raw block receipts for the block
+   */
+  public async getRawReceipts(blockHashOrBlockNumber: string, requestDetails: RequestDetails): Promise<string[]> {
+    return WorkersPool.run(
+      {
+        type: 'getRawReceipts',
+        blockHashOrBlockNumber,
+        requestDetails,
+      },
+      this.mirrorNodeClient,
+      this.cacheService,
+    );
+  }
+
   /**
    * Gets the number of transaction in a block by its block hash.
    *

packages/relay/src/lib/services/ethService/blockService/IBlockService.ts

@@ -13,6 +13,7 @@ export interface IBlockService {
   getBlockTransactionCountByHash: (hash: string, requestDetails: RequestDetails) => Promise<string | null>;
   getBlockTransactionCountByNumber: (blockNum: string, requestDetails: RequestDetails) => Promise<string | null>;
   getBlockReceipts: (blockHash: string, requestDetails: RequestDetails) => Promise<ITransactionReceipt[] | null>;
+  getRawReceipts: (blockHashOrBlockNumber: string, requestDetails: RequestDetails) => Promise<string[]>;
   getUncleByBlockHashAndIndex: (blockHash: string, index: string) => null;
   getUncleByBlockNumberAndIndex: (blockNumOrTag: string, index: string) => null;
   getUncleCountByBlockHash: (blockHash: string) => string;