feat: Add precheck for blob transactions (#2540)

* feat: add precheck for tx type 3

Signed-off-by: Ivo Yankov <[email protected]>

* test: add unit tests

Signed-off-by: Ivo Yankov <[email protected]>

---------

Signed-off-by: Ivo Yankov <[email protected]>

Author: Ivo-Yankov

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

@@ -169,6 +169,11 @@ export const predefined = {
     code: -32601,
     message: 'Unsupported JSON-RPC method',
   }),
+  UNSUPPORTED_TRANSACTION_TYPE: new JsonRpcError({
+    name: 'Unsupported transaction type',
+    code: -32611,
+    message: 'Unsupported transaction type',
+  }),
   VALUE_TOO_LOW: new JsonRpcError({
     name: 'Value too low',
     code: -32602,

packages/relay/src/lib/precheck.ts

@@ -52,6 +52,7 @@ export class Precheck {
    * @param gasPrice
    */
   async sendRawTransactionCheck(parsedTx: ethers.Transaction, gasPrice: number, requestId?: string) {
+    this.transactionType(parsedTx, requestId);
     this.gasLimit(parsedTx, requestId);
     const mirrorAccountInfo = await this.verifyAccount(parsedTx, requestId);
     await this.nonce(parsedTx, mirrorAccountInfo.ethereum_nonce, requestId);
@@ -301,4 +302,17 @@ export class Precheck {
       throw predefined.TRANSACTION_SIZE_TOO_BIG(String(transactionSize), String(transactionSizeLimit));
     }
   }
+
+  transactionType(tx: Transaction, requestId?: string) {
+    // Blob transactions are not supported as per HIP 866
+    if (tx.type === 3) {
+      const requestIdPrefix = formatRequestIdMessage(requestId);
+      this.logger.trace(
+        `${requestIdPrefix} Transaction with type=${
+          tx.type
+        } is unsupported for sendRawTransaction(transaction=${JSON.stringify(tx)})`,
+      );
+      throw predefined.UNSUPPORTED_TRANSACTION_TYPE;
+    }
+  }
 }

packages/relay/tests/helpers.ts

@@ -341,6 +341,7 @@ export { expectUnsupportedMethod, expectedError, signTransaction, mockData, rand
 export const bytecode =
   '0x608060405234801561001057600080fd5b5060405161078938038061078983398181016040528101906100329190';
 export const blockHashTrimmed = '0x3c08bbbee74d287b1dcd3f0ca6d1d2cb92c90883c4acf9747de9f3f3162ad25b';
+export const blobVersionedHash = '0x3c08bbbee74d287b1dcd3f0ca6d1d2cb92c90883c4acf9747de9f3f3162ad25b';
 export const blockHash = `${blockHashTrimmed}999fc7e86699f60f2a3fb3ed9a646c6b`;
 export const blockHash2 = `${blockHashTrimmed}999fc7e86699f60f2a3fb3ed9a646c6c`;
 export const blockHash3 = `${blockHashTrimmed}999fc7e86699f60f2a3fb3ed9a646c6d`;

packages/relay/tests/lib/eth/eth_sendRawTransaction.spec.ts

@@ -218,5 +218,23 @@ describe('@ethSendRawTransaction eth_sendRawTransaction spec', async function ()
       expect(`Error invoking RPC: ${response.message}`).to.equal(predefined.INTERNAL_ERROR(response.message).message);
       sinon.assert.calledOnce(sdkClientStub.submitEthereumTransaction);
     });
+
+    it('should throw precheck error for type=3 transactions', async function () {
+      const type3tx = {
+        ...transaction,
+        type: 3,
+        maxFeePerBlobGas: transaction.gasPrice,
+        blobVersionedHashes: [ethereumHash],
+      };
+      const signed = await signTransaction(type3tx);
+
+      await RelayAssertions.assertRejection(
+        predefined.UNSUPPORTED_TRANSACTION_TYPE,
+        ethImpl.sendRawTransaction,
+        false,
+        ethImpl,
+        [signed, getRequestId()],
+      );
+    });
   });
 });

packages/relay/tests/lib/precheck.spec.ts

@@ -25,7 +25,7 @@ const registry = new Registry();
 
 import pino from 'pino';
 import { Precheck } from '../../src/lib/precheck';
-import { expectedError, mockData, signTransaction } from '../helpers';
+import { blobVersionedHash, contractAddress1, expectedError, mockData, signTransaction } from '../helpers';
 import { MirrorNodeClient } from '../../src/lib/clients';
 import axios from 'axios';
 import MockAdapter from 'axios-mock-adapter';
@@ -61,6 +61,7 @@ describe('Precheck', async function () {
   );
   const oneTinyBar = ethers.parseUnits('1', 10);
   const defaultGasPrice = 720_000_000_000;
+  const defaultGasLimit = 1_000_000;
   const defaultChainId = Number('0x12a');
   let precheck: Precheck;
   let mock: MockAdapter;
@@ -579,4 +580,48 @@ describe('Precheck', async function () {
       expect(error.code).to.equal(-32603);
     });
   });
+
+  describe('transactionType', async function () {
+    const defaultTx = {
+      value: oneTinyBar,
+      gasPrice: defaultGasPrice,
+      gasLimit: defaultGasLimit,
+      chainId: defaultChainId,
+      nonce: 5,
+      to: contractAddress1,
+    };
+
+    it('should accept legacy transactions', async () => {
+      const signedLegacy = await signTransaction(defaultTx);
+      expect(precheck.transactionType(ethers.Transaction.from(signedLegacy))).not.to.throw;
+    });
+
+    it('should accept London transactions', async () => {
+      const signedLondon = await signTransaction({
+        ...defaultTx,
+        type: 2,
+        maxPriorityFeePerGas: defaultGasPrice,
+        maxFeePerGas: defaultGasPrice,
+      });
+      expect(precheck.transactionType(ethers.Transaction.from(signedLondon))).not.to.throw;
+    });
+
+    it('should reject Cancun transactions', async () => {
+      let error;
+      try {
+        const signedCancun = await signTransaction({
+          ...defaultTx,
+          type: 3,
+          maxFeePerBlobGas: defaultGasPrice,
+          blobVersionedHashes: [blobVersionedHash],
+        });
+        precheck.transactionType(ethers.Transaction.from(signedCancun));
+      } catch (e) {
+        error = e;
+      }
+      expect(error).to.be.an.instanceOf(JsonRpcError);
+      expect(error.message).to.equal(predefined.UNSUPPORTED_TRANSACTION_TYPE.message);
+      expect(error.code).to.equal(predefined.UNSUPPORTED_TRANSACTION_TYPE.code);
+    });
+  });
 });

packages/server/tests/acceptance/rpc_batch3.spec.ts

@@ -2021,4 +2021,40 @@ describe('@api-batch-3 RPC Server Acceptance Tests', function () {
       }
     });
   });
+
+  describe('Shard Blob Transactions', async function () {
+    let defaultLondonTransactionData, defaultGasPrice, defaultGasLimit;
+    let defaultBlobVersionedHashes = ['0x6265617665726275696c642e6f7267476265617665726275696c642e6f726747'];
+
+    before(() => {
+      defaultGasPrice = numberTo0x(Assertions.defaultGasPrice);
+      defaultGasLimit = numberTo0x(3_000_000);
+
+      defaultLondonTransactionData = {
+        value: ONE_TINYBAR,
+        chainId: Number(CHAIN_ID),
+        maxPriorityFeePerGas: defaultGasPrice,
+        maxFeePerGas: defaultGasPrice,
+        gasLimit: defaultGasLimit,
+      };
+    });
+
+    it('Type 3 transactions are not supported for eth_sendRawTransaction', async () => {
+      const transaction = {
+        ...defaultLondonTransactionData,
+        type: 3,
+        maxFeePerBlobGas: defaultGasPrice,
+        blobVersionedHashes: defaultBlobVersionedHashes,
+      };
+
+      const signedTx = await accounts[0].wallet.signTransaction(transaction);
+      await Assertions.assertPredefinedRpcError(
+        predefined.UNSUPPORTED_TRANSACTION_TYPE,
+        relay.sendRawTransaction,
+        false,
+        relay,
+        [signedTx, requestId],
+      );
+    });
+  });
 });