fix: adjust auto lock features

packages/adena-extension/src/App/use-app.ts

@@ -1,6 +1,7 @@
 import { useEffect } from 'react';
 import { useLocation } from 'react-router-dom';
 
+import { ADENA_WALLET_EXTENSION_ID } from '@common/constants/storage.constant';
 import { useAccountName } from '@hooks/use-account-name';
 import { useWalletContext } from '@hooks/use-context';
 import { useCurrentAccount } from '@hooks/use-current-account';
@@ -19,6 +20,10 @@ const useApp = (): void => {
   const { pathname, key } = useLocation();
   const { scrollMove } = useScrollHistory();
 
+  useEffect(() => {
+    chrome?.runtime?.connect({ name: ADENA_WALLET_EXTENSION_ID });
+  }, []);
+
   useEffect(() => {
     checkNetworkState();
   }, [pathname]);

packages/adena-extension/src/background.ts

@@ -1,4 +1,5 @@
-import { AlarmKey } from '@common/constants/alarm-key.constant';
+import { AlarmKey, SCHEDULE_ALARMS } from '@common/constants/alarm-key.constant';
+import { ADENA_WALLET_EXTENSION_ID } from '@common/constants/storage.constant';
 import { MemoryProvider } from '@common/provider/memory/memory-provider';
 import { ChromeLocalStorage } from '@common/storage';
 import { CommandHandler } from '@inject/message/command-handler';
@@ -9,6 +10,8 @@ import { MessageHandler } from './inject/message';
 const inMemoryProvider = new MemoryProvider();
 inMemoryProvider.init();
 
+initAlarms();
+
 function existsWallet(): Promise<boolean> {
   const storage = new ChromeLocalStorage();
   return storage
@@ -53,39 +56,57 @@ chrome.action.onClicked.addListener(async () => {
 });
 
 chrome.runtime.onConnect.addListener(async (port) => {
+  if (port.name !== ADENA_WALLET_EXTENSION_ID) {
+    return;
+  }
+
   inMemoryProvider.addConnection();
-  await chrome.alarms.clear(AlarmKey.EXPIRED_PASSWORD);
+  inMemoryProvider.updateExpiredTimeBy(null);
 
   port.onDisconnect.addListener(async () => {
     inMemoryProvider.removeConnection();
 
-    if (inMemoryProvider.isActive()) {
-      await chrome.alarms.clear(AlarmKey.EXPIRED_PASSWORD);
-    } else {
-      await chrome.alarms.create(AlarmKey.EXPIRED_PASSWORD, {
-        delayInMinutes: inMemoryProvider.getExpiredPasswordDurationMinutes(),
-      });
+    if (!inMemoryProvider.isActive()) {
+      const expiredTime = new Date().getTime() + inMemoryProvider.getExpiredPasswordDurationTime();
+      inMemoryProvider.updateExpiredTimeBy(expiredTime);
+
+      console.info('Password Expired time:', new Date(expiredTime));
     }
   });
 });
 
 chrome.alarms.onAlarm.addListener(async (alarm) => {
-  if (alarm.name === AlarmKey.EXPIRED_PASSWORD) {
-    await chrome.alarms.clear(AlarmKey.EXPIRED_PASSWORD);
+  try {
+    const currentTime = new Date().getTime();
+    chrome.storage.local.set({ SESSION: currentTime });
 
-    if (inMemoryProvider.isActive()) {
-      return;
-    }
+    switch (alarm?.name) {
+      case AlarmKey.EXPIRED_PASSWORD:
+        if (!inMemoryProvider.isExpired(currentTime)) {
+          return;
+        }
+
+        await chrome.storage.session.clear();
+        await clearInMemoryKey(inMemoryProvider);
 
-    await chrome.storage.session.clear();
-    await clearInMemoryKey(inMemoryProvider);
+        inMemoryProvider.updateExpiredTimeBy(null);
+        console.info('Password Expired');
+
+        break;
+      default:
+        break;
+    }
+  } catch (error) {
+    console.error(error);
   }
+
+  return true;
 });
 
 chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
   // Check metadata when tab is updated
   if (changeInfo.status === 'complete') {
-    chrome.tabs.sendMessage(tabId, CommandMessage.command('checkMetadata'));
+    chrome.tabs.sendMessage(tabId, CommandMessage.command('checkMetadata')).catch(console.info);
   }
 });
 
@@ -97,3 +118,24 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 
   return MessageHandler.createHandler(inMemoryProvider, message, sender, sendResponse);
 });
+
+function initAlarms(): void {
+  SCHEDULE_ALARMS.map(initAlarmWithDelay);
+}
+
+function initAlarmWithDelay(alarm: { key: string; periodInMinutes: number; delay: number }): void {
+  if (alarm.delay === 0) {
+    chrome.alarms.create(alarm.key, {
+      periodInMinutes: alarm.periodInMinutes,
+    });
+    return;
+  }
+
+  setTimeout(
+    () =>
+      chrome.alarms.create(alarm.key, {
+        periodInMinutes: alarm.periodInMinutes,
+      }),
+    alarm.delay,
+  );
+}

packages/adena-extension/src/common/constants/alarm-key.constant.ts

@@ -1,3 +1,13 @@
 export enum AlarmKey {
   EXPIRED_PASSWORD = 'EXPIRED_PASSWORD',
+  WAKE_ALARM = 'WAKE_ALARM',
+  WAKE_ALARM_DELAY_20S = 'WAKE_ALARM_DELAY_20S',
+  WAKE_ALARM_DELAY_40S = 'WAKE_ALARM_DELAY_40S',
 }
+
+export const SCHEDULE_ALARMS: { key: string; periodInMinutes: number; delay: number }[] = [
+  { key: AlarmKey.EXPIRED_PASSWORD, periodInMinutes: 1, delay: 0 },
+  { key: AlarmKey.WAKE_ALARM, periodInMinutes: 1, delay: 0 },
+  { key: AlarmKey.WAKE_ALARM_DELAY_20S, periodInMinutes: 1, delay: 20_000 },
+  { key: AlarmKey.WAKE_ALARM_DELAY_40S, periodInMinutes: 1, delay: 40_000 },
+];

packages/adena-extension/src/common/constants/storage.constant.ts

@@ -1,3 +1,5 @@
+export const ADENA_WALLET_ID = 'adena-wallet';
+export const ADENA_WALLET_EXTENSION_ID = 'adena-wallet-extension';
 export const WALLET_EXPORT_TYPE_STORAGE_KEY = 'WALLET_EXPORT_TYPE' as const;
 export const WALLET_EXPORT_ACCOUNT_ID = 'WALLET_EXPORT_ACCOUNT_ID' as const;
 export const QUESTIONNAIRE_EXPIRATION_MIN = 30 * 24 * 60;

packages/adena-extension/src/common/provider/memory/memory-provider.ts

@@ -4,6 +4,7 @@ export class MemoryProvider {
   private memory: Map<string, any> = new Map();
   private activeConnections = 0;
   private expiredPasswordDuration = EXPIRED_PASSWORD_DURATION_MIN;
+  private expiredTime: number | null = null;
 
   public get = <T = any>(key: string): T | null => {
     if (!this.memory.get(key)) {
@@ -33,11 +34,27 @@ export class MemoryProvider {
     return this.activeConnections > 0;
   }
 
-  public getExpiredPasswordDurationMinutes(): number {
-    return this.expiredPasswordDuration;
+  public getExpiredPasswordDurationTime(): number {
+    return this.expiredPasswordDuration * 60 * 1000;
   }
 
   public setExpiredPasswordDurationMinutes(duration: number): void {
     this.expiredPasswordDuration = duration;
   }
+
+  public isExpired(time: number): boolean {
+    if (this.isActive()) {
+      return false;
+    }
+
+    if (!this.expiredTime) {
+      return false;
+    }
+
+    return this.expiredTime < time;
+  }
+
+  public updateExpiredTimeBy(time: number | null): void {
+    this.expiredTime = time;
+  }
 }

packages/adena-extension/src/common/utils/crypto-utils.ts

@@ -16,7 +16,7 @@ export const encryptPassword = async (
   password: string,
 ): Promise<{ encryptedKey: string; encryptedPassword: string }> => {
   const result = await sendMessage(CommandMessage.command('encryptPassword', { password }));
-  if (result.code !== 200) {
+  if (!result || result.code !== 200) {
     throw new Error('Encryption key not initialized.');
   }
 
@@ -34,7 +34,7 @@ export const decryptPassword = async (iv: string, encryptedPassword: string): Pr
       encryptedPassword,
     }),
   );
-  if (result?.code !== 200 || !result?.data?.password) {
+  if (!result || result?.code !== 200 || !result?.data?.password) {
     throw new Error('Encryption key not initialized.');
   }
 
@@ -45,8 +45,11 @@ export const clearInMemoryKey = async (): Promise<void> => {
   await sendMessage(CommandMessage.command('clearEncryptKey'));
 };
 
-function sendMessage<T = any>(message: CommandMessageData): Promise<CommandMessageData<T>> {
-  return new Promise((resolve) => {
+function sendMessage<T = any>(message: CommandMessageData): Promise<CommandMessageData<T> | null> {
+  return new Promise<CommandMessageData<T> | null>((resolve) => {
     chrome.runtime.sendMessage(message, resolve);
+  }).catch((error) => {
+    console.warn(error);
+    return null;
   });
 }

packages/adena-extension/src/components/pages/router/side-menu-layout/side-menu-container.tsx

@@ -97,7 +97,13 @@ const SideMenuContainer: React.FC<SideMenuContainerProps> = ({ open, setOpen })
     setOpen(false);
     await walletService.lockWallet();
     await clearWallet();
-    await chrome.runtime.sendMessage(CommandMessage.command('clearPopup'));
+
+    try {
+      await chrome.runtime.sendMessage(CommandMessage.command('clearPopup'));
+    } catch (error) {
+      console.warn(error);
+    }
+
     await loadAccounts();
     navigate(RoutePath.Login, { replace: true });
   }, [walletService, navigate]);

packages/adena-extension/src/content.ts

@@ -3,18 +3,6 @@ import { EventMessageData } from '@inject/message';
 import { CommandHandler } from '@inject/message/command-handler';
 import { CommandMessageData } from '@inject/message/command-message';
 
-const sendMessage = (event: MessageEvent): void => {
-  const message = event.data;
-  chrome.runtime.sendMessage(message, (response) => {
-    Promise.resolve(response).then((result) => {
-      event.source?.postMessage(result, {
-        targetOrigin: event.origin,
-      });
-    });
-    return true;
-  });
-};
-
 const loadScript = (): void => {
   const container = document.head || document.documentElement;
   const scriptElement = document.createElement('script');
@@ -62,6 +50,21 @@ const initExtensionListener = (): void => {
   });
 };
 
+const sendMessage = (event: MessageEvent): void => {
+  const message = event.data;
+
+  chrome.runtime.sendMessage(message, (response) => {
+    Promise.resolve(response)
+      .then((result) => {
+        event.source?.postMessage(result, {
+          targetOrigin: event.origin,
+        });
+      })
+      .catch(console.info);
+    return true;
+  });
+};
+
 loadScript();
 initListener();
 initExtensionListener();

packages/adena-extension/src/hooks/use-event.tsx

@@ -12,7 +12,7 @@ export const useEvent = (): UseEventReturn => {
         return;
       }
       const tabId = currentTab.id;
-      chrome.tabs.sendMessage(tabId, message);
+      chrome.tabs.sendMessage(tabId, message).catch(console.warn);
     });
   }
 

packages/adena-extension/src/inject/executor/executor.ts

@@ -170,7 +170,11 @@ export class AdenaExecutor {
       key: this.eventKey,
     };
 
-    window.postMessage(this.eventMessage, window.location.origin);
+    try {
+      window.postMessage(this.eventMessage, window.location.origin);
+    } catch (error) {
+      console.warn(error);
+    }
     this.messages[this.eventKey] = {
       request: this.eventMessage,
       response: undefined,

packages/adena-extension/src/inject/message/command-handler.ts

@@ -71,7 +71,7 @@ export class CommandHandler {
         return;
       }
     } catch (error) {
-      console.error(error);
+      console.info(error);
       sendResponse(makeInternalErrorResponse(message));
     }
 

packages/adena-extension/src/inject/message/commands/encrypt.ts

@@ -6,7 +6,7 @@ const KEY_LENGTH = 256; // AES-256 key length
 const IV_LENGTH = 12; // GCM nonce length (12 bytes is recommended)
 
 export async function getInMemoryKey(memoryProvider: MemoryProvider): Promise<CryptoKey | null> {
-  const key = memoryProvider.get(MEMORY_KEY) || null;
+  const key = memoryProvider?.get(MEMORY_KEY) || null;
   if (!key) {
     const generated = await generateInMemoryKey();
     memoryProvider.set(MEMORY_KEY, generated);
@@ -49,6 +49,10 @@ export const decryptPassword = async (
   iv: string,
   encryptedPassword: string,
 ): Promise<string> => {
+  if (!key || !iv || !encryptedPassword) {
+    return '';
+  }
+
   const encryptedData = Buffer.from(encryptedPassword, 'base64');
   const ivBytes = Buffer.from(iv, 'base64');
   const dec = new TextDecoder();