chore: add poc

Signed-off-by: nikolay <[email protected]>

Author: natanasow

packages/relay/src/lib/precheck.ts

@@ -104,9 +104,9 @@ export class Precheck {
       throw predefined.RESOURCE_NOT_FOUND(`Account nonce unavailable for address: ${tx.from}.`);
     }
 
-    if (accountNonce > tx.nonce) {
-      throw predefined.NONCE_TOO_LOW(tx.nonce, accountNonce);
-    }
+    // if (accountNonce > tx.nonce) {
+    //   throw predefined.NONCE_TOO_LOW(tx.nonce, accountNonce);
+    // }
   }
 
   /**

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

@@ -271,7 +271,10 @@ export class TransactionService implements ITransactionService {
     await this.validateRawTransaction(parsedTx, networkGasPriceInWeiBars, requestDetails);
 
     // Save the transaction to the transaction pool before submitting it to the network
-    await this.transactionPoolService.saveTransaction(parsedTx.from!, parsedTx);
+    const isUpdated = await this.transactionPoolService.saveOrUpdate(parsedTx.from!, parsedTx);
+    if (isUpdated) {
+      return Utils.computeTransactionHash(transactionBuffer);
+    }
 
     /**
      * Note: If the USE_ASYNC_TX_PROCESSING feature flag is enabled,
@@ -498,6 +501,10 @@ export class TransactionService implements ITransactionService {
 
     const sessionKey = await this.lockService.acquireLock(parsedTx.from!);
 
+    const foundTx = await this.transactionPoolService.getBySenderAndNonce(parsedTx.from!.toLowerCase(), parsedTx.nonce);
+
+    transactionBuffer = Buffer.from(this.prune0x(foundTx!), 'hex');
+
     this.eventEmitter.emit('eth_execution', {
       method: constants.ETH_SEND_RAW_TRANSACTION,
     });
@@ -510,7 +517,7 @@ export class TransactionService implements ITransactionService {
     );
 
     // Remove the transaction from the transaction pool after submission
-    await this.transactionPoolService.removeTransaction(originalCallerAddress, parsedTx.serialized);
+    await this.transactionPoolService.removeTransaction(originalCallerAddress, foundTx!);
     await this.lockService.releaseLock(parsedTx.from!, sessionKey);
 
     sendRawTransactionError = error;

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

@@ -73,6 +73,52 @@ export class TransactionPoolService implements ITransactionPoolService {
     }
   }
 
+  async saveOrUpdate(address: string, tx: Transaction): Promise<boolean> {
+    const addr = address.toLowerCase();
+    const nonce = tx.nonce;
+
+    // @ts-ignore
+    const pending = this.storage.pendingTransactions.get(addr) ?? new Set<string>();
+
+    let existingTx: string | null = null;
+    const updatedPending = new Set<string>();
+
+    // Replace or keep list entries
+    for (const item of pending) {
+      const parsed = Transaction.from(item);
+      if (parsed.nonce === nonce) {
+        existingTx = item;
+        updatedPending.add(tx.serialized);
+      } else {
+        updatedPending.add(item);
+      }
+    }
+
+    // If no existing tx with same nonce → just save new
+    if (!existingTx) {
+      await this.saveTransaction(addr, tx);
+      return false;
+    }
+
+    // Update pending set
+    // @ts-ignore
+    this.storage.pendingTransactions.set(addr, updatedPending);
+
+    // Update global index
+    // @ts-ignore
+    const globalIndex = this.storage.globalTransactionIndex;
+    const updatedGlobal = new Set<string>();
+
+    for (const item of globalIndex) {
+      updatedGlobal.add(item === existingTx ? tx.serialized : item);
+    }
+
+    // @ts-ignore
+    this.storage.globalTransactionIndex = updatedGlobal;
+
+    return true;
+  }
+
   /**
    * Removes a specific transaction from the pending pool.
    * This is typically called when a transaction is confirmed or fails on the consensus layer.
@@ -136,4 +182,19 @@ export class TransactionPoolService implements ITransactionPoolService {
 
     return payloads;
   }
+
+  async getBySenderAndNonce(sender: string, nonce: number): Promise<string> {
+    // TODO: create a method in the storage layers
+    // @ts-ignore
+    const txs = this.storage.pendingTransactions.get(sender.toLowerCase());
+
+    let foundTx = '';
+    txs?.forEach((txIt) => {
+      if (Transaction.from(txIt).nonce == nonce) {
+        foundTx = txIt;
+      }
+    });
+
+    return foundTx;
+  }
 }

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

@@ -143,6 +143,66 @@ describe('@api-batch-2 RPC Server Acceptance Tests', function () {
     }
   });
 
+  describe('Replace TX pool transaction', function () {
+    it('should replace a transaction with the same nonce', async function () {
+      const gasPrice = await relay.gasPrice();
+      const nonce = await relay.getAccountNonce(accounts[0].address);
+
+      const txHashes = [];
+      let txForOverrideHash;
+      let txForOverrideNonce;
+      for (let i = 0; i < 6; i++) {
+        const itNonce = nonce + i;
+        const transaction = {
+          type: 2,
+          chainId: Number(CHAIN_ID),
+          nonce: itNonce,
+          maxPriorityFeePerGas: gasPrice,
+          maxFeePerGas: gasPrice,
+          gasLimit: 1_000_000,
+          to: accounts[1].address,
+          value: Utils.add0xPrefix(Utils.toHex(ethers.parseUnits('1', 10))),
+        };
+
+        const signedTx = await accounts[0].wallet.signTransaction(transaction);
+        const transactionHash = await relay.sendRawTransaction(signedTx);
+
+        if (i == 4) {
+          txForOverrideHash = transactionHash;
+          txForOverrideNonce = itNonce;
+        } else {
+          txHashes.push(transactionHash);
+        }
+      }
+
+      const signedTx = await accounts[0].wallet.signTransaction({
+        type: 2,
+        chainId: Number(CHAIN_ID),
+        nonce: txForOverrideNonce,
+        maxPriorityFeePerGas: gasPrice,
+        maxFeePerGas: gasPrice,
+        gasLimit: 1_000_000,
+        to: accounts[1].address,
+        value: Utils.add0xPrefix(Utils.toHex(ethers.parseUnits('2', 10))),
+      });
+      const transactionHash = await relay.sendRawTransaction(signedTx);
+
+      expect(txHashes).to.have.length(5);
+      for (const txHash of txHashes) {
+        const receipt = await relay.pollForValidTransactionReceipt(txHash);
+        expect(receipt.status).to.equal('0x1');
+      }
+
+      const txForOverrideReceipt = await relay.call(RelayCalls.ETH_ENDPOINTS.ETH_GET_TRANSACTION_RECEIPT, [
+        txForOverrideHash,
+      ]);
+      expect(txForOverrideReceipt).to.be.null;
+
+      const receipt = await relay.pollForValidTransactionReceipt(transactionHash);
+      expect(receipt.status).to.equal('0x1');
+    });
+  });
+
   describe('eth_estimateGas', async function () {
     let basicContract: ethers.Contract;
     let basicContractAddress: string;