feat: implement Jumbo Transaction support and enhance pre-requisite validation for eth_sendRawTransaction

.github/workflows/acceptance.yml

@@ -24,6 +24,7 @@ jobs:
           - { name: 'API Batch 3', testfilter: 'api_batch3' }
           - { name: 'ERC20', testfilter: 'erc20' }
           - { name: 'Rate Limiter', testfilter: 'ratelimiter', test_ws_server: true }
+          - { name: 'SendRawTransaction Extension', testfilter: 'sendRawTransactionExtension' }
           - { name: 'HBar Limiter Batch 1', testfilter: 'hbarlimiter_batch1' }
           - { name: 'HBar Limiter Batch 2', testfilter: 'hbarlimiter_batch2' }
           - { name: 'HBar Limiter Batch 3', testfilter: 'hbarlimiter_batch3' }

package.json

@@ -69,6 +69,7 @@
     "acceptancetest:cache-service": "nyc ts-mocha packages/server/tests/acceptance/index.spec.ts  -g '@cache-service' --exit",
     "acceptancetest:rpc_api_schema_conformity": "nyc ts-mocha packages/server/tests/acceptance/index.spec.ts  -g '@api-conformity' --exit",
     "acceptancetest:serverconfig": "nyc ts-mocha packages/server/tests/acceptance/index.spec.ts  -g '@server-config' --exit",
+    "acceptancetest:sendRawTransactionExtension": "nyc ts-mocha packages/server/tests/acceptance/index.spec.ts  -g '@sendRawTransactionExtension' --exit",
     "build": "npx lerna run build",
     "build-and-test": "npx lerna run build && npx lerna run test",
     "build:docker": "docker build . -t ${npm_package_name}",

packages/config-service/src/services/globalConfig.ts

@@ -117,6 +117,12 @@ const _CONFIG = {
     required: false,
     defaultValue: 3600000,
   },
+  CALL_DATA_SIZE_LIMIT: {
+    envName: 'CALL_DATA_SIZE_LIMIT',
+    type: 'number',
+    required: false,
+    defaultValue: 131072, // 128KB
+  },
   CHAIN_ID: {
     envName: 'CHAIN_ID',
     type: 'string',
@@ -141,6 +147,12 @@ const _CONFIG = {
     required: false,
     defaultValue: 50_000_000,
   },
+  CONTRACT_CODE_SIZE_LIMIT: {
+    envName: 'CONTRACT_CODE_SIZE_LIMIT',
+    type: 'number',
+    required: false,
+    defaultValue: 24576, // 24KB
+  },
   CONTRACT_QUERY_TIMEOUT_RETRIES: {
     envName: 'CONTRACT_QUERY_TIMEOUT_RETRIES',
     type: 'number',
@@ -405,6 +417,12 @@ const _CONFIG = {
     required: false,
     defaultValue: 1,
   },
+  JUMBO_TX_ENABLED: {
+    envName: 'JUMBO_TX_ENABLED',
+    type: 'boolean',
+    required: false,
+    defaultValue: false,
+  },
   LIMIT_DURATION: {
     envName: 'LIMIT_DURATION',
     type: 'number',
@@ -644,7 +662,7 @@ const _CONFIG = {
     envName: 'SEND_RAW_TRANSACTION_SIZE_LIMIT',
     type: 'number',
     required: false,
-    defaultValue: 131072,
+    defaultValue: 133120, // 130 KB
   },
   SERVER_HOST: {
     envName: 'SERVER_HOST',

packages/relay/src/lib/clients/sdkClient.ts

@@ -139,15 +139,17 @@ export class SDKClient {
     networkGasPriceInWeiBars: number,
     currentNetworkExchangeRateInCents: number,
   ): Promise<{ txResponse: TransactionResponse; fileId: FileId | null }> {
+    const jumboTxEnabled = ConfigService.get('JUMBO_TX_ENABLED');
     const ethereumTransactionData: EthereumTransactionData = EthereumTransactionData.fromBytes(transactionBuffer);
     const ethereumTransaction = new EthereumTransaction();
     const interactingEntity = ethereumTransactionData.toJSON()['to'].toString();
+
     let fileId: FileId | null = null;
 
-    // if callData's size is greater than `fileAppendChunkSize` => employ HFS to create new file to carry the rest of the contents of callData
-    if (ethereumTransactionData.callData.length <= this.fileAppendChunkSize) {
+    if (jumboTxEnabled || ethereumTransactionData.callData.length <= this.fileAppendChunkSize) {
       ethereumTransaction.setEthereumData(ethereumTransactionData.toBytes());
     } else {
+      // if JUMBO_TX_ENABLED is false and callData's size is greater than `fileAppendChunkSize` => employ HFS to create new file to carry the rest of the contents of callData
       fileId = await this.createFile(
         ethereumTransactionData.callData,
         this.clientMain,
@@ -163,10 +165,11 @@ export class SDKClient {
       ethereumTransactionData.callData = new Uint8Array();
       ethereumTransaction.setEthereumData(ethereumTransactionData.toBytes()).setCallDataFileId(fileId);
     }
-    const networkGasPriceInTinyBars = weibarHexToTinyBarInt(networkGasPriceInWeiBars);
 
     ethereumTransaction.setMaxTransactionFee(
-      Hbar.fromTinybars(Math.floor(networkGasPriceInTinyBars * constants.MAX_TRANSACTION_FEE_THRESHOLD)),
+      Hbar.fromTinybars(
+        Math.floor(weibarHexToTinyBarInt(networkGasPriceInWeiBars) * constants.MAX_TRANSACTION_FEE_THRESHOLD),
+      ),
     );
 
     return {

packages/relay/src/lib/constants.ts

@@ -230,6 +230,10 @@ export default {
   },
 
   MAX_TRANSACTION_FEE_THRESHOLD: ConfigService.get('MAX_TRANSACTION_FEE_THRESHOLD'),
+  SEND_RAW_TRANSACTION_SIZE_LIMIT: ConfigService.get('SEND_RAW_TRANSACTION_SIZE_LIMIT'),
+  CONTRACT_CODE_SIZE_LIMIT: ConfigService.get('CONTRACT_CODE_SIZE_LIMIT'),
+  CALL_DATA_SIZE_LIMIT: ConfigService.get('CALL_DATA_SIZE_LIMIT'),
+
   INVALID_EVM_INSTRUCTION: '0xfe',
   EMPTY_BLOOM: '0x' + '0'.repeat(512),
   ZERO_HEX: '0x0',

packages/relay/src/lib/errors/JsonRpcError.ts

@@ -279,11 +279,21 @@ export const predefined = {
     code: -32001,
     message: 'Filter not found',
   }),
-  TRANSACTION_SIZE_TOO_BIG: (actualSize: string, expectedSize: string) =>
+  TRANSACTION_SIZE_LIMIT_EXCEEDED: (actualSize: number, expectedSize: number) =>
     new JsonRpcError({
       code: -32201,
       message: `Oversized data: transaction size ${actualSize}, transaction limit ${expectedSize}`,
     }),
+  CALL_DATA_SIZE_LIMIT_EXCEEDED: (actualSize: number, expectedSize: number) =>
+    new JsonRpcError({
+      code: -32201,
+      message: `Oversized data: call data size ${actualSize}, call data size limit ${expectedSize}`,
+    }),
+  CONTRACT_CODE_SIZE_LIMIT_EXCEEDED: (actualSize: number, expectedSize: number) =>
+    new JsonRpcError({
+      code: -32201,
+      message: `Oversized data: contract code size ${actualSize}, contract code size limit ${expectedSize}`,
+    }),
   BATCH_REQUESTS_DISABLED: new JsonRpcError({
     code: -32202,
     message: 'Batch requests are disabled',

packages/relay/src/lib/precheck.ts

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
-import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services';
 import { ethers, Transaction } from 'ethers';
 import { Logger } from 'pino';
 
@@ -35,7 +34,7 @@ export class Precheck {
    * @param {string | Transaction} transaction - The transaction to parse.
    * @returns {Transaction} The parsed transaction.
    */
-  public static parseTxIfNeeded(transaction: string | Transaction): Transaction {
+  public static parseRawTransaction(transaction: string | Transaction): Transaction {
     return typeof transaction === 'string' ? Transaction.from(transaction) : transaction;
   }
 
@@ -60,6 +59,9 @@ export class Precheck {
     networkGasPriceInWeiBars: number,
     requestDetails: RequestDetails,
   ): Promise<void> {
+    this.contractCodeSize(parsedTx);
+    this.callDataSize(parsedTx);
+    this.transactionSize(parsedTx);
     this.transactionType(parsedTx, requestDetails);
     this.gasLimit(parsedTx, requestDetails);
     const mirrorAccountInfo = await this.verifyAccount(parsedTx, requestDetails);
@@ -317,35 +319,34 @@ export class Precheck {
   }
 
   /**
-   * Converts hex string to bytes array
-   * @param {string} hex - The hex string you want to convert.
-   * @returns {Uint8Array} The bytes array.
+   * Validates that the transaction size is within the allowed limit.
+   * The serialized transaction length is converted from hex string length to byte count
+   * by subtracting the '0x' prefix (2 characters) and dividing by 2 (since each byte is represented by 2 hex characters).
+   *
+   * @param {Transaction} tx - The transaction to validate.
+   * @throws {JsonRpcError} If the transaction size exceeds the configured limit.
    */
-  hexToBytes(hex: string): Uint8Array {
-    if (hex === '') {
-      throw predefined.INTERNAL_ERROR('Passed hex an empty string');
+  transactionSize(tx: Transaction): void {
+    const totalRawTransactionSizeInBytes = tx.serialized.replace('0x', '').length / 2;
+    const transactionSizeLimit = constants.SEND_RAW_TRANSACTION_SIZE_LIMIT;
+    if (totalRawTransactionSizeInBytes > transactionSizeLimit) {
+      throw predefined.TRANSACTION_SIZE_LIMIT_EXCEEDED(totalRawTransactionSizeInBytes, transactionSizeLimit);
     }
-
-    if (hex.startsWith('0x') && hex.length == 2) {
-      throw predefined.INTERNAL_ERROR('Hex cannot be 0x');
-    } else if (hex.startsWith('0x') && hex.length != 2) {
-      hex = hex.slice(2);
-    }
-
-    return Uint8Array.from(Buffer.from(hex, 'hex'));
   }
 
   /**
-   * Checks the size of the transaction.
-   * @param {string} transaction - The transaction to check.
+   * Validates that the call data size is within the allowed limit.
+   * The data field length is converted from hex string length to byte count
+   * by subtracting the '0x' prefix (2 characters) and dividing by 2 (since each byte is represented by 2 hex characters).
+   *
+   * @param {Transaction} tx - The transaction to validate.
+   * @throws {JsonRpcError} If the call data size exceeds the configured limit.
    */
-  checkSize(transaction: string): void {
-    const transactionToBytes: Uint8Array = this.hexToBytes(transaction);
-    const transactionSize: number = transactionToBytes.length;
-    const transactionSizeLimit: number = ConfigService.get('SEND_RAW_TRANSACTION_SIZE_LIMIT');
-
-    if (transactionSize > transactionSizeLimit) {
-      throw predefined.TRANSACTION_SIZE_TOO_BIG(String(transactionSize), String(transactionSizeLimit));
+  callDataSize(tx: Transaction): void {
+    const totalCallDataSizeInBytes = tx.data.replace('0x', '').length / 2;
+    const callDataSizeLimit = constants.CALL_DATA_SIZE_LIMIT;
+    if (totalCallDataSizeInBytes > callDataSizeLimit) {
+      throw predefined.CALL_DATA_SIZE_LIMIT_EXCEEDED(totalCallDataSizeInBytes, callDataSizeLimit);
     }
   }
 
@@ -378,4 +379,21 @@ export class Precheck {
       }
     }
   }
+
+  /**
+   * Validates that the contract code size is within the allowed limit.
+   * This check is only performed for contract creation transactions (where tx.to is null).
+   * This limits contract code size to prevent excessive gas consumption.
+   *
+   * @param {Transaction} tx - The transaction to validate.
+   * @throws {JsonRpcError} If the contract code size exceeds the configured limit.
+   */
+  contractCodeSize(tx: Transaction): void {
+    if (!tx.to) {
+      const contractCodeSize = tx.data.replace('0x', '').length / 2;
+      if (contractCodeSize > constants.CONTRACT_CODE_SIZE_LIMIT) {
+        throw predefined.CONTRACT_CODE_SIZE_LIMIT_EXCEEDED(contractCodeSize, constants.CONTRACT_CODE_SIZE_LIMIT);
+      }
+    }
+  }
 }

packages/relay/src/lib/services/ethService/transactionService/TransactionService.ts

@@ -298,11 +298,12 @@ export class TransactionService implements ITransactionService {
    */
   async sendRawTransaction(transaction: string, requestDetails: RequestDetails): Promise<string | JsonRpcError> {
     const transactionBuffer = Buffer.from(this.prune0x(transaction), 'hex');
-
+    const parsedTx = Precheck.parseRawTransaction(transaction);
     const networkGasPriceInWeiBars = Utils.addPercentageBufferToGasPrice(
       await this.common.getGasPriceInWeibars(requestDetails),
     );
-    const parsedTx = await this.parseRawTxAndPrecheck(transaction, networkGasPriceInWeiBars, requestDetails);
+
+    await this.validateRawTransaction(parsedTx, networkGasPriceInWeiBars, requestDetails);
 
     /**
      * Note: If the USE_ASYNC_TX_PROCESSING feature flag is enabled,
@@ -536,18 +537,17 @@ export class TransactionService implements ITransactionService {
   }
 
   /**
-   * Parses a raw transaction and performs prechecks
-   * @param transaction The raw transaction string
+   * Validates a parsed transaction by performing prechecks
+   * @param parsedTx The parsed Ethereum transaction to validate
    * @param networkGasPriceInWeiBars The current network gas price in wei bars
    * @param requestDetails The request details for logging and tracking
-   * @returns {Promise<EthersTransaction>} A promise that resolves to the parsed Ethereum transaction
+   * @throws {JsonRpcError} If validation fails
    */
-  private async parseRawTxAndPrecheck(
-    transaction: string,
+  private async validateRawTransaction(
+    parsedTx: EthersTransaction,
     networkGasPriceInWeiBars: number,
     requestDetails: RequestDetails,
-  ): Promise<EthersTransaction> {
-    const parsedTx = Precheck.parseTxIfNeeded(transaction);
+  ): Promise<void> {
     try {
       if (this.logger.isLevelEnabled('debug')) {
         this.logger.debug(
@@ -557,9 +557,7 @@ export class TransactionService implements ITransactionService {
         );
       }
 
-      this.precheck.checkSize(transaction);
       await this.precheck.sendRawTransactionCheck(parsedTx, networkGasPriceInWeiBars, requestDetails);
-      return parsedTx;
     } catch (e: any) {
       this.logger.error(
         `${requestDetails.formattedRequestId} Precheck failed: transaction=${JSON.stringify(parsedTx)}`,