diff --git a/src/main/ipcs/bs-version-ipcs.ts b/src/main/ipcs/bs-version-ipcs.ts
index f76ddd8b..23914528 100644
--- a/src/main/ipcs/bs-version-ipcs.ts
+++ b/src/main/ipcs/bs-version-ipcs.ts
@@ -7,13 +7,22 @@ import path from 'path';
 import { exec } from 'child_process';
 import { SteamService } from '../services/steam.service';
 import { BS_APP_ID } from '../constants';
+import { IpcRequest } from 'shared/models/ipc-models.model';
 
-ipcMain.on('bs-version.request-versions', async (event, args) => {
-    UtilsService.getInstance().ipcSend('bs-version.request-versions', await BSVersionManagerService.getInstance().getAvailableVersions());
+ipcMain.on('bs-version.request-versions', (event, req: IpcRequest<void>) => {
+   BSVersionManagerService.getInstance().getAvailableVersions().then(versions => {
+      UtilsService.getInstance().newIpcSenc(req.responceChannel, {success: true, data: versions});
+   }).catch(() => {
+      UtilsService.getInstance().newIpcSenc(req.responceChannel, {success: false});
+   })
 });
 
-ipcMain.on('bs-version.installed-versions', async (event, args) => {
-    UtilsService.getInstance().ipcSend('bs-version.installed-versions', await BSInstallerService.getInstance().getInstalledBsVersion())
+ipcMain.on('bs-version.installed-versions', async (event, req: IpcRequest<void>) => {
+   BSInstallerService.getInstance().getInstalledBsVersion().then(versions => {
+      UtilsService.getInstance().newIpcSenc(req.responceChannel, {success: true, data: versions});
+   }).catch(() => {
+      UtilsService.getInstance().newIpcSenc(req.responceChannel, {success: false});
+   })
 });
 
 ipcMain.on("bs-version.open-folder", async (event, args: BSVersion) => {
diff --git a/src/renderer/services/bs-version-manager.service.ts b/src/renderer/services/bs-version-manager.service.ts
index 358fa5f5..41640012 100644
--- a/src/renderer/services/bs-version-manager.service.ts
+++ b/src/renderer/services/bs-version-manager.service.ts
@@ -1,62 +1,66 @@
 import { BSVersion } from "../../main/services/bs-version-manager.service";
 import { BehaviorSubject } from "rxjs";
+import { IpcService } from "./ipc.service";
 
 export class BSVersionManagerService {
 
-    private static instance: BSVersionManagerService;
+   private static instance: BSVersionManagerService;
 
-    public readonly installedVersions$: BehaviorSubject<BSVersion[]> = new BehaviorSubject([]);
-    public readonly availableVersions$: BehaviorSubject<BSVersion[]> = new BehaviorSubject([]);
+   public readonly ipcService: IpcService;
+
+   public readonly installedVersions$: BehaviorSubject<BSVersion[]> = new BehaviorSubject([]);
+   public readonly availableVersions$: BehaviorSubject<BSVersion[]> = new BehaviorSubject([]); 
+
+   private constructor(){
+      this.ipcService = IpcService.getInstance();
 
-    private constructor(){
         window.electron.ipcRenderer.on('bs-version.request-versions', (versions: BSVersion[]) => {
             this.availableVersions$.next(versions);
         });
         window.electron.ipcRenderer.on('bs-version.installed-versions', (versions: BSVersion[]) => {
             this.setInstalledVersions(versions);
-        });
-
+        }); 
         this.askAvailableVersions();
         this.askInstalledVersions();
+    } 
+
+   public static getInstance(){
+      if(!BSVersionManagerService.instance){ BSVersionManagerService.instance = new BSVersionManagerService(); }
+      return BSVersionManagerService.instance;
+   }
+
+   public setInstalledVersions(versions: BSVersion[]){
+      const sorted: BSVersion[] = versions.sort((a, b) => +b.ReleaseDate - +a.ReleaseDate)
+      const steamIndex = sorted.findIndex(v => v.steam);
+      if(steamIndex > 0){
+         [sorted[0], sorted[steamIndex]] = [sorted[steamIndex], sorted[0]];
+      }
+      const cleanedSort = [...new Map(sorted.map(version => [`${version.BSVersion}-${version.steam}`, version])).values()]
+      this.installedVersions$.next(cleanedSort);
     }
 
-    public static getInstance(){
-        if(!BSVersionManagerService.instance){ BSVersionManagerService.instance = new BSVersionManagerService(); }
-        return BSVersionManagerService.instance;
-    }
+   public getInstalledVersions(): BSVersion[]{
+      return this.installedVersions$.value;
+   }
 
-    public setInstalledVersions(versions: BSVersion[]){
-        const sorted: BSVersion[] = versions.sort((a, b) => +b.ReleaseDate - +a.ReleaseDate)
-        const steamIndex = sorted.findIndex(v => v.steam);
-        if(steamIndex > 0){
-            [sorted[0], sorted[steamIndex]] = [sorted[steamIndex], sorted[0]];
-        }
-        const cleanedSort = [...new Map(sorted.map(version => [`${version.BSVersion}-${version.steam}`, version])).values()]
-        this.installedVersions$.next(cleanedSort);
-    }
+   public askAvailableVersions(): void{
+      this.ipcService.send<BSVersion[]>("bs-version.request-versions").then(res => this.availableVersions$.next(res.data));
+   }
 
-    public getInstalledVersions(): BSVersion[]{
-        return this.installedVersions$.value;
-    }
+   public askInstalledVersions(): void{
+      this.ipcService.send<BSVersion[]>("bs-version.installed-versions").then(res => this.setInstalledVersions(res.data));
+   }
 
-    public askAvailableVersions(): void{
-        window.electron.ipcRenderer.sendMessage("bs-version.request-versions", null);
-    }
-
-    public askInstalledVersions(): void{
-        window.electron.ipcRenderer.sendMessage("bs-version.installed-versions", null);
-    }
-
-    public getAvailableYears(): string[]{
+   public getAvailableYears(): string[]{
       return [...new Set(this.availableVersions$.value.map(v => v.year))].sort((a, b) => b.localeCompare(a));
-    }
+   }
 
-    public isVersionInstalled(version: BSVersion): boolean{
+   public isVersionInstalled(version: BSVersion): boolean{
       return !!this.getInstalledVersions().find(v => v.BSVersion === version.BSVersion && v.steam === version.steam);
-    }
+   }
 
-    public getAvaibleVersionsOfYear(year: string): BSVersion[]{
+   public getAvaibleVersionsOfYear(year: string): BSVersion[]{
       return this.availableVersions$.value.filter(v => v.year === year).sort((a, b) => +b.ReleaseDate - +a.ReleaseDate);
-    }
+   }
 
 }