Merge branch 'feat/transaction-pool' into 4394-update-nonce-precheck-method

# Conflicts:
#	packages/relay/src/lib/eth.ts
#	packages/relay/src/lib/services/ethService/transactionService/TransactionService.ts

Author: natanasow

packages/relay/src/lib/relay.ts

@@ -201,7 +201,6 @@ export class Relay {
 
     hapiService.eventEmitter.on('execute_transaction', (args: IExecuteTransactionEventPayload) => {
       this.metricService.captureTransactionMetrics(args).then();
-      // TODO: Call transactionPoolService.onConsensusResult(args) when service is available
     });
 
     hapiService.eventEmitter.on('execute_query', (args: IExecuteQueryEventPayload) => {

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

@@ -484,20 +484,20 @@ export class TransactionService implements ITransactionService {
     networkGasPriceInWeiBars: number,
     requestDetails: RequestDetails,
   ): Promise<string | JsonRpcError> {
-    // although we validdate on earlier stages that we have
+    // although we validate in earlier stages that we have
     // a signed transaction, we need to assert it again here in order to satisfy the type checker
     this.assertSignedTransaction(parsedTx);
     let sendRawTransactionError: any;
 
     const originalCallerAddress = parsedTx.from?.toString() || '';
 
+    // Save the transaction to the transaction pool before submitting it to the network
+    await this.transactionPoolService.saveTransaction(originalCallerAddress, parsedTx);
+
     this.eventEmitter.emit('eth_execution', {
       method: constants.ETH_SEND_RAW_TRANSACTION,
     });
 
-    // Save the transaction to the transaction pool before submitting it to the network
-    await this.transactionPoolService.saveTransaction(originalCallerAddress, parsedTx);
-
     const { txSubmitted, submittedTransactionId, error } = await this.submitTransaction(
       transactionBuffer,
       originalCallerAddress,
@@ -527,9 +527,6 @@ export class TransactionService implements ITransactionService {
           this.mirrorNodeClient.getMirrorNodeRequestRetryCount(),
         );
 
-        // Remove the transaction from the transaction pool after successful submission
-        await this.transactionPoolService.removeTransaction(originalCallerAddress, contractResult.hash);
-
         if (!contractResult) {
           if (
             sendRawTransactionError instanceof SDKClientError &&
@@ -552,6 +549,9 @@ export class TransactionService implements ITransactionService {
           );
         }
 
+        // Remove the transaction from the transaction pool after successful submission
+        await this.transactionPoolService.removeTransaction(originalCallerAddress, contractResult.hash);
+
         return contractResult.hash;
       } catch (e: any) {
         sendRawTransactionError = e;

packages/relay/src/lib/services/transactionPoolService/transactionPoolService.ts

@@ -48,12 +48,13 @@ export class TransactionPoolService implements ITransactionPoolService {
    */
   async saveTransaction(address: string, tx: Transaction): Promise<void> {
     const txHash = tx.hash;
+    const addressLowerCased = address.toLowerCase();
 
     if (!txHash) {
       throw new Error('Transaction hash is required for storage');
     }
 
-    const result = await this.storage.addToList(address, txHash);
+    const result = await this.storage.addToList(addressLowerCased, txHash);
 
     if (!result.ok) {
       throw new Error('Failed to add transaction to list');
@@ -62,33 +63,6 @@ export class TransactionPoolService implements ITransactionPoolService {
     this.logger.debug({ address, txHash, pendingCount: result.newValue }, 'Transaction saved to pool');
   }
 
-  /**
-   * Handles consensus results and updates the pool state accordingly.
-   *
-   * @param payload - The transaction execution event payload containing transaction details.
-   * @returns A promise that resolves when the consensus result has been processed.
-   */
-  async onConsensusResult(payload: IExecuteTransactionEventPayload): Promise<void> {
-    const { transactionHash, originalCallerAddress, transactionId } = payload;
-
-    if (!transactionHash) {
-      this.logger.warn({ transactionId }, 'Transaction hash not available in execution event');
-      return;
-    }
-
-    const remainingCount = await this.removeTransaction(originalCallerAddress, transactionHash);
-
-    this.logger.debug(
-      {
-        transactionHash,
-        address: originalCallerAddress,
-        transactionId,
-        remainingCount,
-      },
-      'Transaction removed from pool after consensus',
-    );
-  }
-
   /**
    * Removes a specific transaction from the pending pool.
    * This is typically called when a transaction is confirmed or fails on the consensus layer.
@@ -98,7 +72,8 @@ export class TransactionPoolService implements ITransactionPoolService {
    * @returns A promise that resolves to the new pending transaction count for the address.
    */
   async removeTransaction(address: string, txHash: string): Promise<number> {
-    return await this.storage.removeFromList(address, txHash);
+    const addressLowerCased = address.toLowerCase();
+    return await this.storage.removeFromList(addressLowerCased, txHash);
   }
 
   /**
@@ -108,7 +83,8 @@ export class TransactionPoolService implements ITransactionPoolService {
    * @returns A promise that resolves to the number of pending transactions.
    */
   async getPendingCount(address: string): Promise<number> {
-    return await this.storage.getList(address);
+    const addressLowerCased = address.toLowerCase();
+    return await this.storage.getList(addressLowerCased);
   }
 
   /**

packages/relay/src/lib/types/transactionPool.ts

@@ -2,8 +2,6 @@
 
 import { Transaction } from 'ethers';
 
-import { IExecuteTransactionEventPayload } from './events';
-
 /**
  * Result of attempting to add a transaction to the pending list.
  *
@@ -26,14 +24,6 @@ export interface TransactionPoolService {
    */
   saveTransaction(address: string, tx: Transaction): Promise<void>;
 
-  /**
-   * Handles consensus results and updates the pool state accordingly.
-   *
-   * @param payload - The transaction execution event payload containing transaction details.
-   * @returns A promise that resolves when the consensus result has been received.
-   */
-  onConsensusResult(payload: IExecuteTransactionEventPayload): Promise<void>;
-
   /**
    * Retrieves the number of pending transactions for a given address.
    *

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

@@ -288,6 +288,34 @@ describe('@ethSendRawTransaction eth_sendRawTransaction spec', async function ()
       );
     });
 
+    it('should save and remove transaction from transaction pool on success path', async function () {
+      const signed = await signTransaction(transaction);
+      const txPool = ethImpl['transactionService']['transactionPoolService'] as any;
+
+      const saveStub = sinon.stub(txPool, 'saveTransaction').resolves();
+      const removeStub = sinon.stub(txPool, 'removeTransaction').resolves();
+
+      restMock.onGet(contractResultEndpoint).reply(200, JSON.stringify({ hash: ethereumHash }));
+      sdkClientStub.submitEthereumTransaction.resolves({
+        txResponse: {
+          transactionId: TransactionId.fromString(transactionIdServicesFormat),
+        } as unknown as TransactionResponse,
+        fileId: null,
+      });
+
+      const result = await ethImpl.sendRawTransaction(signed, requestDetails);
+
+      expect(result).to.equal(ethereumHash);
+      sinon.assert.calledOnce(saveStub);
+      sinon.assert.calledWithMatch(saveStub, accountAddress, sinon.match.object);
+
+      sinon.assert.calledOnce(removeStub);
+      sinon.assert.calledWith(removeStub, accountAddress, ethereumHash);
+
+      saveStub.restore();
+      removeStub.restore();
+    });
+
     withOverriddenEnvsInMochaTest({ USE_ASYNC_TX_PROCESSING: false }, () => {
       it('[USE_ASYNC_TX_PROCESSING=true] should throw internal error when transaction returned from mirror node is null', async function () {
         const signed = await signTransaction(transaction);
@@ -307,6 +335,35 @@ describe('@ethSendRawTransaction eth_sendRawTransaction spec', async function ()
         expect(`Error invoking RPC: ${response.message}`).to.equal(predefined.INTERNAL_ERROR(response.message).message);
       });
 
+      it('should save and remove transaction (fallback path uses parsedTx.hash)', async function () {
+        const signed = await signTransaction(transaction);
+        const expectedTxHash = Utils.computeTransactionHash(Buffer.from(signed.replace('0x', ''), 'hex'));
+        const txPool = ethImpl['transactionService']['transactionPoolService'] as any;
+
+        const saveStub = sinon.stub(txPool, 'saveTransaction').resolves();
+        const removeStub = sinon.stub(txPool, 'removeTransaction').resolves();
+
+        // Cause MN polling to fail, forcing fallback
+        restMock.onGet(contractResultEndpoint).reply(404, JSON.stringify(mockData.notFound));
+        sdkClientStub.submitEthereumTransaction.resolves({
+          txResponse: {
+            transactionId: TransactionId.fromString(transactionIdServicesFormat),
+          } as unknown as TransactionResponse,
+          fileId: null,
+        });
+
+        await ethImpl.sendRawTransaction(signed, requestDetails);
+
+        sinon.assert.calledOnce(saveStub);
+        sinon.assert.calledWithMatch(saveStub, accountAddress, sinon.match.object);
+
+        sinon.assert.calledOnce(removeStub);
+        sinon.assert.calledWith(removeStub, accountAddress, expectedTxHash);
+
+        saveStub.restore();
+        removeStub.restore();
+      });
+
       it('[USE_ASYNC_TX_PROCESSING=false] should throw internal error when transactionID is invalid', async function () {
         const signed = await signTransaction(transaction);
 

packages/relay/tests/lib/services/transactionPoolService/transactionPoolService.spec.ts

@@ -130,87 +130,6 @@ describe('TransactionPoolService Test Suite', function () {
     });
   });
 
-  describe('onConsensusResult', () => {
-    it('should successfully remove transaction from pool when transaction hash is provided', async () => {
-      const remainingCount = 1;
-      const payload = createTestEventPayload();
-
-      mockStorage.removeFromList.resolves(remainingCount);
-
-      await transactionPoolService.onConsensusResult(payload);
-
-      expect(mockStorage.removeFromList.calledOnceWith(testAddress, testTxHash)).to.be.true;
-    });
-
-    it('should handle missing transaction hash gracefully', async () => {
-      const payload = createTestEventPayload({ transactionHash: undefined });
-
-      await transactionPoolService.onConsensusResult(payload);
-
-      expect(mockStorage.removeFromList.called).to.be.false;
-    });
-
-    it('should handle empty transaction hash gracefully', async () => {
-      const payload = createTestEventPayload({ transactionHash: '' });
-
-      await transactionPoolService.onConsensusResult(payload);
-
-      expect(mockStorage.removeFromList.called).to.be.false;
-    });
-
-    it('should throw storage errors during transaction removal', async () => {
-      const payload = createTestEventPayload();
-      const storageError = new Error('Storage removal failed');
-      mockStorage.removeFromList.rejects(storageError);
-
-      // Should throw - errors are no longer caught
-      await expect(transactionPoolService.onConsensusResult(payload)).to.be.rejectedWith('Storage removal failed');
-
-      expect(mockStorage.removeFromList.calledOnceWith(testAddress, testTxHash)).to.be.true;
-    });
-
-    it('should throw when removal fails', async () => {
-      const payload = createTestEventPayload();
-      mockStorage.removeFromList.rejects(new Error('Storage error'));
-
-      // Should throw when storage fails
-      await expect(transactionPoolService.onConsensusResult(payload)).to.be.rejectedWith('Storage error');
-    });
-
-    it('should use originalCallerAddress from payload for transaction removal', async () => {
-      const customAddress = '0x999999999999999999999999999999999999999';
-      const payload = createTestEventPayload({ originalCallerAddress: customAddress });
-
-      mockStorage.removeFromList.resolves(0);
-
-      await transactionPoolService.onConsensusResult(payload);
-
-      expect(mockStorage.removeFromList.calledOnceWith(customAddress, testTxHash)).to.be.true;
-    });
-
-    it('should handle multiple transaction removals correctly', async () => {
-      const payload1 = createTestEventPayload();
-      const payload2 = createTestEventPayload({
-        transactionHash: '0xabcdef1234567890',
-        originalCallerAddress: '0x1111111111111111111111111111111111111111',
-      });
-
-      mockStorage.removeFromList.resolves(0);
-
-      await transactionPoolService.onConsensusResult(payload1);
-      await transactionPoolService.onConsensusResult(payload2);
-
-      expect(mockStorage.removeFromList.calledTwice).to.be.true;
-      expect(mockStorage.removeFromList.firstCall.calledWith(testAddress, testTxHash)).to.be.true;
-      expect(
-        mockStorage.removeFromList.secondCall.calledWith(
-          '0x1111111111111111111111111111111111111111',
-          '0xabcdef1234567890',
-        ),
-      ).to.be.true;
-    });
-  });
-
   describe('removeTransaction', () => {
     it('should successfully remove transaction from pool', async () => {
       const remainingCount = 1;