Add some sample files so linting can be tested

dependencies.d.ts

@@ -0,0 +1,5 @@
+declare module 'loglevel' {
+  function debug(message: string | Record<string, unknown>): void;
+  const log = { debug };
+  export default log;
+}

ui/helpers/utils/storage-helpers.ts

@@ -0,0 +1,30 @@
+import localforage from 'localforage';
+
+type SerializableValue = Record<string, unknown>;
+
+export async function getStorageItem(
+  key: string,
+): Promise<SerializableValue | undefined> {
+  try {
+    const serializedData = await localforage.getItem<string | null>(key);
+    if (serializedData === null) {
+      return undefined;
+    }
+
+    return JSON.parse(serializedData) as SerializableValue;
+  } catch (err) {
+    return undefined;
+  }
+}
+
+export async function setStorageItem(
+  key: string,
+  value: SerializableValue,
+): Promise<void> {
+  try {
+    const serializedData = JSON.stringify(value);
+    await localforage.setItem(key, serializedData);
+  } catch (err) {
+    console.warn(err);
+  }
+}

ui/helpers/utils/tx-helper.js → ui/helpers/utils/tx-helper.ts

@@ -2,16 +2,23 @@ import log from 'loglevel';
 import { transactionMatchesNetwork } from '../../../shared/modules/transaction.utils';
 import { valuesFor } from './util';
 
+type Message = {
+  metamaskNetworkId: string;
+  time: number;
+};
+
+type MessagesByKey = Record<string, Message> | null | undefined;
+
 export default function txHelper(
-  unapprovedTxs,
-  unapprovedMsgs,
-  personalMsgs,
-  decryptMsgs,
-  encryptionPublicKeyMsgs,
-  typedMessages,
-  network,
-  chainId,
-) {
+  unapprovedTxs: MessagesByKey,
+  unapprovedMsgs: MessagesByKey,
+  personalMsgs: MessagesByKey,
+  decryptMsgs: MessagesByKey,
+  encryptionPublicKeyMsgs: MessagesByKey,
+  typedMessages: MessagesByKey,
+  network: string,
+  chainId: string,
+): Message[] {
   log.debug('tx-helper called with params:');
   log.debug({
     unapprovedTxs,
@@ -25,33 +32,35 @@ export default function txHelper(
   });
 
   const txValues = network
-    ? valuesFor(unapprovedTxs).filter((txMeta) =>
+    ? (valuesFor(unapprovedTxs) as Message[]).filter((txMeta) =>
         transactionMatchesNetwork(txMeta, chainId, network),
       )
-    : valuesFor(unapprovedTxs);
+    : (valuesFor(unapprovedTxs) as Message[]);
   log.debug(`tx helper found ${txValues.length} unapproved txs`);
 
-  const msgValues = valuesFor(unapprovedMsgs);
+  const msgValues = valuesFor(unapprovedMsgs) as Message[];
   log.debug(`tx helper found ${msgValues.length} unsigned messages`);
   let allValues = txValues.concat(msgValues);
 
-  const personalValues = valuesFor(personalMsgs);
+  const personalValues = valuesFor(personalMsgs) as Message[];
   log.debug(
     `tx helper found ${personalValues.length} unsigned personal messages`,
   );
   allValues = allValues.concat(personalValues);
 
-  const decryptValues = valuesFor(decryptMsgs);
+  const decryptValues = valuesFor(decryptMsgs) as Message[];
   log.debug(`tx helper found ${decryptValues.length} decrypt requests`);
   allValues = allValues.concat(decryptValues);
 
-  const encryptionPublicKeyValues = valuesFor(encryptionPublicKeyMsgs);
+  const encryptionPublicKeyValues = valuesFor(
+    encryptionPublicKeyMsgs,
+  ) as Message[];
   log.debug(
     `tx helper found ${encryptionPublicKeyValues.length} encryptionPublicKey requests`,
   );
   allValues = allValues.concat(encryptionPublicKeyValues);
 
-  const typedValues = valuesFor(typedMessages);
+  const typedValues = valuesFor(typedMessages) as Message[];
   log.debug(`tx helper found ${typedValues.length} unsigned typed messages`);
   allValues = allValues.concat(typedValues);