If mined status is not mined and cancel reason not set, then show the cancel link, refactoring

src/SmartTransactionsController.test.ts

@@ -152,6 +152,7 @@ const createStateAfterPending = () => {
     {
       uuid: 'uuid1',
       status: 'pending',
+      cancellable: true,
       statusMetadata: {
         cancellationFeeWei: 0,
         cancellationReason: 'not_cancelled',
@@ -179,6 +180,7 @@ const createStateAfterSuccess = () => {
     {
       uuid: 'uuid2',
       status: 'success',
+      cancellable: false,
       statusMetadata: {
         cancellationFeeWei: 36777567771000,
         cancellationReason: 'not_cancelled',

src/SmartTransactionsController.ts

@@ -29,18 +29,14 @@ import {
   generateHistoryEntry,
   getStxProcessingTime,
   handleFetch,
+  isSmartTransactionCancellable,
 } from './utils';
 import { CHAIN_IDS } from './constants';
 
 const { safelyExecute } = util;
 
-// TODO: JSDoc all methods
-// TODO: Remove all comments (* ! ?)
 const SECOND = 1000;
-const MINUTE = SECOND * 60;
-
 export const DEFAULT_INTERVAL = SECOND * 5;
-export const CANCELLABLE_INTERVAL = MINUTE;
 
 export interface SmartTransactionsControllerConfig extends BaseConfig {
   interval: number;
@@ -447,10 +443,13 @@ export default class SmartTransactionsController extends BaseController<
 
     const data = await this.fetch(url);
 
-    Object.entries(data).forEach(([uuid, smartTransaction]) => {
+    Object.entries(data).forEach(([uuid, stxStatus]) => {
       this.updateSmartTransaction({
-        statusMetadata: smartTransaction as SmartTransactionsStatus,
-        status: calculateStatus(smartTransaction as SmartTransactionsStatus),
+        statusMetadata: stxStatus as SmartTransactionsStatus,
+        status: calculateStatus(stxStatus as SmartTransactionsStatus),
+        cancellable: isSmartTransactionCancellable(
+          stxStatus as SmartTransactionsStatus,
+        ),
         uuid,
       });
     });
@@ -590,18 +589,6 @@ export default class SmartTransactionsController extends BaseController<
       cancellable: true,
     });
 
-    setTimeout(() => {
-      if (!this.isNewSmartTransaction(data.uuid)) {
-        // Only do this for an existing smart transaction. If an STX is not in the list anymore
-        // (e.g. because it was cancelled and a new one was submitted, which deletes the first one),
-        // do not try to update the old one, because it would create a new one with most
-        // of the required STX params missing. It would only have "uuid" and "cancellable" params.
-        this.updateSmartTransaction({
-          uuid: data.uuid,
-          cancellable: false,
-        });
-      }
-    }, CANCELLABLE_INTERVAL);
     nonceLock.releaseLock();
     return data;
   }

src/utils.test.ts

@@ -172,4 +172,44 @@ describe('src/utils.js', () => {
       expect(processingTime).toStrictEqual(3);
     });
   });
+
+  describe('isSmartTransactionCancellable', () => {
+    const createStxStatus = (customProps = {}) => {
+      return {
+        error: undefined,
+        minedTx: SmartTransactionMinedTx.NOT_MINED,
+        cancellationFeeWei: 10000,
+        cancellationReason: SmartTransactionCancellationReason.NOT_CANCELLED,
+        deadlineRatio: 10,
+        minedHash: undefined,
+        ...customProps,
+      };
+    };
+
+    it('returns true if minedTx is NOT_MINED and cancellationReason is NOT_CANCELLED', () => {
+      const stxStatus = createStxStatus();
+      expect(utils.isSmartTransactionCancellable(stxStatus)).toBe(true);
+    });
+
+    it('returns true if minedTx is NOT_MINED and cancellationReason is undefined', () => {
+      const stxStatus = createStxStatus({
+        cancellationReason: undefined,
+      });
+      expect(utils.isSmartTransactionCancellable(stxStatus)).toBe(true);
+    });
+
+    it('returns false if minedTx is NOT_MINED and cancellationReason is USER_CANCELLED', () => {
+      const stxStatus = createStxStatus({
+        cancellationReason: SmartTransactionCancellationReason.USER_CANCELLED,
+      });
+      expect(utils.isSmartTransactionCancellable(stxStatus)).toBe(false);
+    });
+
+    it('returns false if minedTx is CANCELLED and cancellationReason is NOT_CANCELLED', () => {
+      const stxStatus = createStxStatus({
+        minedTx: SmartTransactionMinedTx.CANCELLED,
+      });
+      expect(utils.isSmartTransactionCancellable(stxStatus)).toBe(false);
+    });
+  });
 });

src/utils.ts

@@ -16,8 +16,8 @@ export function isSmartTransactionPending(smartTransaction: SmartTransaction) {
 }
 
 export const isSmartTransactionStatusResolved = (
-  status: SmartTransactionsStatus | string,
-) => status === 'uuid_not_found';
+  stxStatus: SmartTransactionsStatus | string,
+) => stxStatus === 'uuid_not_found';
 
 // TODO use actual url once API is defined
 export function getAPIRequestURL(apiType: APIType, chainId: string): string {
@@ -53,8 +53,8 @@ export function getAPIRequestURL(apiType: APIType, chainId: string): string {
   }
 }
 
-export const calculateStatus = (status: SmartTransactionsStatus) => {
-  if (isSmartTransactionStatusResolved(status)) {
+export const calculateStatus = (stxStatus: SmartTransactionsStatus) => {
+  if (isSmartTransactionStatusResolved(stxStatus)) {
     return SmartTransactionStatuses.RESOLVED;
   }
   const cancellations = [
@@ -64,28 +64,28 @@ export const calculateStatus = (status: SmartTransactionsStatus) => {
     SmartTransactionCancellationReason.INVALID_NONCE,
     SmartTransactionCancellationReason.USER_CANCELLED,
   ];
-  if (status?.minedTx === SmartTransactionMinedTx.NOT_MINED) {
+  if (stxStatus?.minedTx === SmartTransactionMinedTx.NOT_MINED) {
     if (
-      status.cancellationReason ===
+      stxStatus.cancellationReason ===
       SmartTransactionCancellationReason.NOT_CANCELLED
     ) {
       return SmartTransactionStatuses.PENDING;
     }
 
     const isCancellation =
       cancellations.findIndex(
-        (cancellation) => cancellation === status.cancellationReason,
+        (cancellation) => cancellation === stxStatus.cancellationReason,
       ) > -1;
-    if (status.cancellationReason && isCancellation) {
-      return cancellationReasonToStatusMap[status.cancellationReason];
+    if (stxStatus.cancellationReason && isCancellation) {
+      return cancellationReasonToStatusMap[stxStatus.cancellationReason];
     }
-  } else if (status?.minedTx === SmartTransactionMinedTx.SUCCESS) {
+  } else if (stxStatus?.minedTx === SmartTransactionMinedTx.SUCCESS) {
     return SmartTransactionStatuses.SUCCESS;
-  } else if (status?.minedTx === SmartTransactionMinedTx.CANCELLED) {
+  } else if (stxStatus?.minedTx === SmartTransactionMinedTx.CANCELLED) {
     return SmartTransactionStatuses.CANCELLED;
-  } else if (status?.minedTx === SmartTransactionMinedTx.REVERTED) {
+  } else if (stxStatus?.minedTx === SmartTransactionMinedTx.REVERTED) {
     return SmartTransactionStatuses.REVERTED;
-  } else if (status?.minedTx === SmartTransactionMinedTx.UNKNOWN) {
+  } else if (stxStatus?.minedTx === SmartTransactionMinedTx.UNKNOWN) {
     return SmartTransactionStatuses.UNKNOWN;
   }
   return SmartTransactionStatuses.UNKNOWN;
@@ -172,3 +172,14 @@ export async function handleFetch(request: string, options?: RequestInit) {
   }
   return json;
 }
+
+export const isSmartTransactionCancellable = (
+  stxStatus: SmartTransactionsStatus,
+): boolean => {
+  return (
+    stxStatus.minedTx === SmartTransactionMinedTx.NOT_MINED &&
+    (!stxStatus.cancellationReason ||
+      stxStatus.cancellationReason ===
+        SmartTransactionCancellationReason.NOT_CANCELLED)
+  );
+};