API-160: tx pool endpoint tests + new cs image

config/config.e2e.mainnet.yaml

@@ -31,9 +31,9 @@ features:
     hitsThreshold: 100
     ttl: 12
   transactionPool:
-    enabled: false
+    enabled: true
   transactionPoolWarmer:
-    enabled: false
+    enabled: true
     cronExpression: '*/5 * * * * *'
     ttlInSeconds: 60
   updateCollectionExtraDetails:

src/test/chain-simulator/docker/docker-compose.yml

@@ -20,7 +20,7 @@ services:
 
   chainsimulator:
     container_name: chainsimulator
-    image: multiversx/chainsimulator:v1.8.4-barnard-test
+    image: multiversx/chainsimulator:v1.8.4-barnard-test2
     command: ["--node-override-config", "./overridable-config.toml"]
     volumes:
       - ./overridable-config.toml:/multiversx/overridable-config.toml

src/test/chain-simulator/pool.cs-e2e.ts

@@ -0,0 +1,75 @@
+import axios from 'axios';
+import { config } from './config/env.config';
+import { ChainSimulatorUtils } from './utils/test.utils';
+import { fundAddress } from './utils/chain.simulator.operations';
+
+describe('Pool e2e tests with chain simulator', () => {
+  beforeAll(async () => {
+    await ChainSimulatorUtils.waitForEpoch(2);
+    await fundAddress(config.chainSimulatorUrl, config.aliceAddress);
+    await new Promise((resolve) => setTimeout(resolve, 20000));
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('GET /pool', () => {
+    it('should return status code 200', async () => {
+      const response = await axios.get(`${config.apiServiceUrl}/pool`);
+      const txsPool = response.data;
+
+      expect(response.status).toBe(200);
+      expect(txsPool).toBeInstanceOf(Array);
+    });
+
+    it('should return the transaction pool', async () => {
+      const response = await axios.get(
+        `${config.apiServiceUrl}/pool`,
+      );
+      const pool = response.data;
+      const expectedProperties = [
+        'txHash',
+        'nonce',
+        'receiver',
+        'gasPrice',
+        'gasLimit',
+      ];
+
+      for (const tx of pool) {
+        for (const property of expectedProperties) {
+          expect(tx).toHaveProperty(property);
+        }
+      }
+    });
+  });
+
+  describe('GET /pool/:txhash', () => {
+    it('should return status code 200 and the transaction', async () => {
+      const poolResponse = await axios.get(
+        `${config.apiServiceUrl}/pool?size=1`,
+      );
+      const response = await axios.get(
+        `${config.apiServiceUrl}/pool/${poolResponse.data[0].txHash}`,
+      );
+      const tx = response.data;
+
+      expect(response.status).toBe(200);
+      expect(tx).toHaveProperty(
+        'txHash',
+        poolResponse.data[0].txHash,
+      );
+    });
+
+    it('should return status code 404 for non-existent tx hash', async () => {
+      const nonExistentTxHash = '0000000000000000000000000000000000000000000000000000000000000000';
+      try {
+        await axios.get(
+          `${config.apiServiceUrl}/pool/${nonExistentTxHash}`,
+        );
+      } catch (error: any) {
+        expect(error.response.status).toBe(404);
+      }
+    });
+  });
+});

src/test/chain-simulator/utils/chain.simulator.operations.ts

@@ -118,10 +118,10 @@ export async function sendTransaction(
     const tx = {
       sender: args.sender,
       receiver: args.receiver,
-      nonce: nonce,
+      nonce: nonce + (args.nonceOffset ?? 0),
       value: args.value,
       gasPrice: 1000000000,
-      gasLimit: args.gasLimit,
+      gasLimit: args.gasLimit ?? (50_000 + 1_500 * args.dataField.length),
       data: Buffer.from(args.dataField).toString('base64'),
       signature: 'a'.repeat(128),
       chainID: 'chain',
@@ -133,6 +133,16 @@ export async function sendTransaction(
       tx,
     );
     const txHash = txHashResponse.data.data.txHash;
+    if (args.nonceOffset) {
+      // when a nonce offset is present, it means that the transaction won't be executed in real time, so we should early exit
+      console.log(`Broadcasted tx hash ${txHash} of sender ${args.sender} with nonce ${tx.nonce}`);
+      console.log(JSON.stringify(tx));
+      await axios.post(
+        `${args.chainSimulatorUrl}/simulator/generate-blocks/1`,
+      );
+      return txHash;
+    }
+
     await axios.post(
       `${args.chainSimulatorUrl}/simulator/generate-blocks-until-transaction-processed/${txHash}`,
     );
@@ -172,6 +182,7 @@ export class SendTransactionArgs {
   dataField: string = '';
   value?: string = '0';
   gasLimit?: number = 100_000_000;
+  nonceOffset?: number = 0; // useful for scenarios where a higher nonce is desired
 
   constructor(options: Partial<SendTransactionArgs> = {}) {
     Object.assign(this, options);

src/test/jest-api.json

@@ -17,4 +17,4 @@
     "../.."
   ],
   "testTimeout": 180000
-}
+}