verify tx already exists

Author: alexjavabraz

src/__tests__/unit/tx-history.controller.unit.ts

@@ -18,6 +18,7 @@ describe('TxHistoryController', () => {
   let rskNodeService: RskNodeService;
   let storeTransaction: sinon.SinonStub;
   let getTransactionHistoryByAddress: sinon.SinonStub;
+  let getTransactionByHash: sinon.SinonStub;
   let getTx: sinon.SinonStub;
   let getRskTransaction: sinon.SinonStub;
   let context: any;
@@ -33,9 +34,11 @@ describe('TxHistoryController', () => {
     getRskTransaction = rskNodeService.getTransaction as sinon.SinonStub;
     storeTransaction = txHistoryService.storeTransaction as sinon.SinonStub;
     getTransactionHistoryByAddress = txHistoryService.getTransactionHistoryByAddress as sinon.SinonStub;
+    getTransactionByHash = txHistoryService.getTransactionByHash as sinon.SinonStub;
 
     getTx.resolves({});
     getRskTransaction.resolves({});
+    getTransactionByHash.resolves(null);
 
     controller = new TxHistoryController(
       bitcoinService,
@@ -115,6 +118,32 @@ describe('TxHistoryController', () => {
       sinon.assert.notCalled(storeTransaction);
       expect(response.statusCode).to.equal(200);
     });
+
+    it('should return 200 and not store when transaction already exists in database', async () => {
+      const txHistory: TxHistory = {
+        userAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
+        txHash: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        providerHash: 'ExistingTxHash',
+        fromTokenName: 'BTC',
+        fromNetworkName: 'Bitcoin',
+        toTokenName: 'RBTC',
+        toNetworkName: 'Rootstock',
+        fromAmount: '0.001',
+        toAmount: '0.0009',
+        date: new Date('2024-01-03'),
+        sdkProvider: 'FLYOVER',
+      } as TxHistory;
+
+      getTransactionByHash.resolves(txHistory);
+
+      const response = await controller.storeTransaction(txHistory);
+
+      sinon.assert.calledOnce(getTransactionByHash);
+      sinon.assert.notCalled(getTx);
+      sinon.assert.notCalled(getRskTransaction);
+      sinon.assert.notCalled(storeTransaction);
+      expect(response.statusCode).to.equal(200);
+    });
   });
 
   describe('getTransactionHistory', () => {

src/controllers/tx-history.controller.ts

@@ -52,11 +52,16 @@ export class TxHistoryController {
     txHistory: TxHistory,
   ): Promise<Response> {
     try {
-      const transactionExists = await this.verifyTransactionExists(txHistory);
+      const transactionExists = await this.verifyTransactionExistsOnBlockchain(txHistory);
       if (!transactionExists) {
         return this.response.status(200).send();
       }
 
+      const transactionExistsInDatabase = await this.verifyTransactionExistsInDatabase(txHistory.txHash);
+      if (transactionExistsInDatabase) {
+        return this.response.status(200).send();
+      }
+
       const result = await this.txHistoryService.storeTransaction(txHistory);
       if (result) {
         return this.response.status(200).send();
@@ -73,7 +78,12 @@ export class TxHistoryController {
     }
   }
 
-  private async verifyTransactionExists(txHistory: TxHistory): Promise<boolean> {
+  private async verifyTransactionExistsInDatabase(txHash: string): Promise<boolean> {
+    const transaction = await this.txHistoryService.getTransactionByHash(txHash);
+    return !!transaction;
+  }
+
+  private async verifyTransactionExistsOnBlockchain(txHistory: TxHistory): Promise<boolean> {
     const sourceNetwork = txHistory.fromNetworkName?.trim().toLowerCase();
 
     try {
@@ -83,6 +93,8 @@ export class TxHistoryController {
         await this.rskNodeService.getTransaction(txHistory.txHash);
       }
 
+      
+
       return true;
     } catch (error: unknown) {
       const errorMessage = error instanceof Error ? error.message : String(error);

src/models/register-payload.model.ts

@@ -7,7 +7,7 @@ export class RegisterPayload extends Model {
     type: 'string',
     required: true,
     jsonSchema: {
-      pattern: '^(0x[a-fA-F0-9]{64}|[a-fA-F0-9]{64}|[A-Za-z0-9]{12})$',
+      pattern: '^(0x[a-fA-F0-9]{64}|[a-fA-F0-9]{64}|[a-zA-Z0-9]+)$',
       errorMessage: 'Must be a valid transaction hash or provider identifier'
     }
   })