feat: add the reason when ignoring a transactions (#408)

**Request-logic:**
* reasons added on ignored transactions

Author: vrolland

packages/request-logic/src/request-logic.ts

@@ -229,23 +229,35 @@ export default class RequestLogic implements Types.IRequestLogic {
   public async getRequestFromId(requestId: string): Promise<Types.IReturnGetRequestFromId> {
     const resultGetTx = await this.transactionManager.getTransactionsByChannelId(requestId);
     const actions = resultGetTx.result.transactions;
+    let ignoredTransactions: any[] = [];
 
     // array of transaction without duplicates to avoid replay attack
     const actionsConfirmedWithoutDuplicates = Utils.uniqueByProperty(
       actions
         .map((t: any) => {
-          // We ignore the transaction.data that cannot be parsed
           try {
             return { action: JSON.parse(t.transaction.data), timestamp: t.timestamp };
           } catch (e) {
+            // We ignore the transaction.data that cannot be parsed
+            ignoredTransactions.push({
+              reason: 'JSON parsing error',
+              transaction: t,
+            });
             return;
           }
         })
         .filter((elem: any) => elem !== undefined),
       'action',
     );
     // Keeps the transaction ignored
-    const ignoredTransactions = actionsConfirmedWithoutDuplicates.duplicates;
+    ignoredTransactions = ignoredTransactions.concat(
+      actionsConfirmedWithoutDuplicates.duplicates.map(tx => {
+        return {
+          reason: 'Duplicated transaction',
+          transaction: tx,
+        };
+      }),
+    );
 
     // second parameter is null, because the first action must be a creation (no state expected)
     const request = actionsConfirmedWithoutDuplicates.uniqueItems.reduce(
@@ -259,7 +271,7 @@ export default class RequestLogic implements Types.IRequestLogic {
           );
         } catch (e) {
           // if an error occurs during the apply we ignore the action
-          ignoredTransactions.push(actionConfirmed.action);
+          ignoredTransactions.push({ reason: e.message, transaction: actionConfirmed });
           return requestState;
         }
       },
@@ -296,21 +308,33 @@ export default class RequestLogic implements Types.IRequestLogic {
     const allRequestAndMeta = Object.keys(getChannelsResult.result.transactions).map(channelId => {
       // Parses and removes corrupted or duplicated transactions
 
+      let ignoredTransactions: any[] = [];
+
       const actionsConfirmedWithoutDuplicates = Utils.uniqueByProperty(
         transactionsByChannel[channelId]
           .map((t: any) => {
-            // We ignore the transaction.data that cannot be parsed
             try {
               return { action: JSON.parse(t.transaction.data), timestamp: t.timestamp };
             } catch (e) {
+              // We ignore the transaction.data that cannot be parsed
+              ignoredTransactions.push({
+                reason: 'JSON parsing error',
+                transaction: t,
+              });
               return;
             }
           })
           .filter((elem: any) => elem !== undefined),
         'action',
       );
+
       // Keeps the transaction ignored
-      const ignoredTransactions = actionsConfirmedWithoutDuplicates.duplicates;
+      ignoredTransactions = ignoredTransactions.concat(
+        actionsConfirmedWithoutDuplicates.duplicates.map(tx => ({
+          reason: 'Duplicated transaction',
+          transaction: tx,
+        })),
+      );
 
       // second parameter is null, because the first action must be a creation (no state expected)
       const request = actionsConfirmedWithoutDuplicates.uniqueItems.reduce(
@@ -324,7 +348,7 @@ export default class RequestLogic implements Types.IRequestLogic {
             );
           } catch (e) {
             // if an error occurs during the apply we ignore the action
-            ignoredTransactions.push(actionConfirmed);
+            ignoredTransactions.push({ reason: e.message, transaction: actionConfirmed });
             return requestState;
           }
         },

packages/request-logic/test/index.test.ts

@@ -532,7 +532,12 @@ describe('index', () => {
 
       expect(request, 'request result is wrong').to.deep.equal({
         meta: {
-          ignoredTransactions: [{ action: actionReduce2, timestamp: 4 }],
+          ignoredTransactions: [
+            {
+              reason: 'Duplicated transaction',
+              transaction: { action: actionReduce2, timestamp: 4 },
+            },
+          ],
           transactionManagerMeta: meta,
         },
         result: {
@@ -732,15 +737,14 @@ describe('index', () => {
     });
 
     it('should ignored the corrupted data (not parsable JSON)', async () => {
+      const transactionNotParsable = {
+        timestamp: 2,
+        transaction: { data: '{NOT parsable}' },
+      };
       const listActions: Promise<TransactionTypes.IReturnGetTransactions> = Promise.resolve({
         meta: {},
         result: {
-          transactions: [
-            {
-              timestamp: 2,
-              transaction: { data: '{NOT parsable}' },
-            },
-          ],
+          transactions: [transactionNotParsable],
         },
       });
 
@@ -756,11 +760,20 @@ describe('index', () => {
       );
 
       const request = await requestLogic.getRequestFromId(requestId);
+      expect(
+        request.meta.ignoredTransactions && request.meta.ignoredTransactions.length,
+      ).to.be.equal(1);
+      expect(
+        request.meta.ignoredTransactions && request.meta.ignoredTransactions[0],
+      ).to.be.deep.equal({
+        reason: 'JSON parsing error',
+        transaction: transactionNotParsable,
+      });
       expect(request.result.request, 'request should be null').to.be.null;
     });
 
     it('should ignored the corrupted data (e.g: wrong properties)', async () => {
-      const actionCreateCorrupted: any = Utils.signature.sign(
+      const actionCorrupted: Types.IAction = Utils.signature.sign(
         {
           name: Types.ACTION_NAME.CREATE,
           parameters: {
@@ -781,7 +794,7 @@ describe('index', () => {
           transactions: [
             {
               timestamp: 2,
-              transaction: { data: JSON.stringify(actionCreateCorrupted) },
+              transaction: { data: JSON.stringify(actionCorrupted) },
             },
           ],
         },
@@ -799,12 +812,19 @@ describe('index', () => {
       );
 
       const request = await requestLogic.getRequestFromId(requestId);
+
       expect(
         request.meta.ignoredTransactions && request.meta.ignoredTransactions.length,
       ).to.be.equal(1);
       expect(
         request.meta.ignoredTransactions && request.meta.ignoredTransactions[0],
-      ).to.be.deep.equal(actionCreateCorrupted);
+      ).to.be.deep.equal({
+        reason: 'action.parameters.expectedAmount must be a string representing a positive integer',
+        transaction: {
+          action: actionCorrupted,
+          timestamp: 2,
+        },
+      });
       expect(request.result.request, 'request should be null').to.be.null;
     });
   });