WIP: Tokensation Feature

.github/workflows/release-builds.yml

@@ -62,9 +62,9 @@ jobs:
           rm -r -fo win -ErrorAction Ignore
           mkdir win 
           cd win
-          curl https://github.com/DeFiCh/ain/releases/download/v1.0.2/defichain-1.0.2-x86_64-w64-mingw32.zip -O defichain-1.0.2-x86_64-w64-mingw32.zip
-          Expand-Archive -LiteralPath .\defichain-1.0.2-x86_64-w64-mingw32.zip -DestinationPath .
-          Copy-Item .\defichain-1.0.2\bin\defid.exe .
+          curl https://github.com/DeFiCh/ain/releases/download/v1.2.0/defichain-1.2.0-x86_64-w64-mingw32.zip -O defichain-1.2.0-x86_64-w64-mingw32.zip
+          Expand-Archive -LiteralPath .\defichain-1.2.0-x86_64-w64-mingw32.zip -DestinationPath .
+          Copy-Item .\defichain-1.2.0\bin\defid.exe .
           cd ..\.. 
           Copy-Item temp\win\defid.exe binary\win\defid.exe
           icacls binary\win\defid.exe /grant everyone:F

electron-app/src/app.ts

@@ -1,7 +1,7 @@
 import log from 'loglevel';
 import * as path from 'path';
 import * as url from 'url';
-import { app, BrowserWindow, Menu, protocol, dialog } from 'electron';
+import { app, BrowserWindow, Menu, protocol } from 'electron';
 import { autoUpdater } from 'electron-updater';
 
 import DefiProcessManager from './services/defiprocessmanager';
@@ -21,6 +21,8 @@ import {
   STOP_BINARY_AND_QUEUE,
 } from './constants';
 import initiateElectronUpdateManager from './ipc-events/electronupdatemanager';
+import ElectronLogger from './services/electronLogger';
+import initiateBackupImportWalletManager from './ipc-events/backupAndImportWallet';
 
 declare var process: {
   argv: any;
@@ -44,8 +46,8 @@ export default class App {
     if (process.mas) app.setName(process.env.npm_package_name);
     this.allowQuit = false;
     autoUpdater.autoDownload = false;
+    autoUpdater.logger = ElectronLogger;
     /* For future purpose */
-    initiateElectronUpdateManager(autoUpdater);
   }
 
   run() {
@@ -61,12 +63,14 @@ export default class App {
     this.createWindow();
     this.createMenu();
     // initiate ipcMain events
-    initiateIpcEvents();
+    initiateIpcEvents(autoUpdater);
 
     /* For future purpose */
     autoUpdater.checkForUpdatesAndNotify().catch((e) => {
       log.error(e);
     });
+    initiateElectronUpdateManager(autoUpdater, this.mainWindow);
+    initiateBackupImportWalletManager(this.mainWindow);
   };
 
   initiateInterceptFileProtocol() {
@@ -162,8 +166,7 @@ export default class App {
 
     this.mainWindow.hide();
     event.preventDefault();
-    const defiProcessManager = new DefiProcessManager();
-    await defiProcessManager.stop();
+    await DefiProcessManager.stop();
     this.allowQuit = true;
     return app.quit();
   };

electron-app/src/constants/app.ts

@@ -16,6 +16,8 @@ export const SECOND_INSTANCE = 'second-instance';
 export const RESTART_APP = 'restart-app';
 
 export const DARWIN = 'darwin';
+export const MAC = 'mac';
+export const WIN = 'win';
 export const WIN_32 = 'win32';
 export const LINUX = 'linux';
 export const AIX = 'aix';
@@ -29,3 +31,4 @@ export const DEFAULT_ELECTRON_FORMAT =
   '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [IPC-MAIN-{level}] {text}';
 export const DISCLAIMER_DIALOG_TIMER = 10000;
 export const STOP_BINARY_INTERVAL = 500;
+export const REINDEX_ERROR_STRING = 'restart with -reindex';

electron-app/src/constants/dirpath.ts

@@ -1,7 +1,12 @@
 import path from 'path';
 import { app } from 'electron';
 import { rootPath } from 'electron-root-path';
-import { getPlatform } from '../utils';
+import {
+  getPlatform,
+  isDataDirDefined,
+  getCustomDebugLogFilePath,
+  getDefaultDebugLogFilePath,
+} from '../utils';
 
 export const APP_NAME = app.name;
 export const IS_DEV = process.env.NODE_ENV === 'development';
@@ -14,9 +19,41 @@ export const CONFIG_FILE_NAME = path.join(APP_DIR, '/defi.conf');
 export const UI_CONFIG_FILE_NAME = path.join(APP_DIR, '/defi.ui.yaml');
 export const PID_FILE_NAME = path.join(APP_DIR, '/defi.pid');
 
+export const BINARY_LOG_FILE_NAME = 'debug.log';
+
 export const BINARY_FILE_NAME = getPlatform() === 'win' ? 'defid.exe' : 'defid';
 export const BINARY_FILE_PATH = IS_DEV
   ? path.join(rootPath, './binary', getPlatform())
   : IS_PACKAGED
   ? path.join(__dirname, '../../../../..', 'binary', getPlatform())
   : path.join(rootPath, '../', 'binary', getPlatform());
+
+export const CONFIG_FILE_PATH = path.join(HOME_PATH, '/.defi', 'defi.conf');
+
+export const BASE_FILE_PATH = isDataDirDefined(CONFIG_FILE_PATH)
+  ? path.join(getCustomDebugLogFilePath(CONFIG_FILE_PATH))
+  : getDefaultDebugLogFilePath(HOME_PATH);
+
+export const DEBUG_LOG_FILE_PATH = path.join(
+  BASE_FILE_PATH,
+  BINARY_LOG_FILE_NAME
+);
+
+export const WALLET_DAT = 'wallet.dat';
+
+export const TESTNET_BASE_FOLDER = path.join(
+  BASE_FILE_PATH,
+  'testnet3',
+  'wallets'
+);
+
+export const REGTEST_BASE_FOLDER = path.join(
+  BASE_FILE_PATH,
+  'regtest',
+  'wallets'
+);
+
+export const MAINNET_BASE_FOLDER =
+  getPlatform() === 'linux'
+    ? BASE_FILE_PATH
+    : path.join(BASE_FILE_PATH, 'wallets');

electron-app/src/constants/ipcevents.ts

@@ -12,3 +12,25 @@ export const MENU_BACKUP_WALLET = 'menu-backup-wallet';
 export const MENU_IMPORT_WALLET = 'menu-import-wallet';
 
 export const STOP_BINARY_AND_QUEUE = 'stop-binary-and-queue';
+
+export const UPDATE_PROGRESS_VALUE = 'download-progress';
+
+export const UPDATE_PROGRESS_COMPLETED = 'update-downloaded';
+
+export const UPDATE_PROGRESS_FAILURE = 'update-downloaded-error';
+
+export const POST_UPDATE_ACTION = 'post-update-action';
+
+export const START_DOWNLOAD_UPDATE = 'start-download-update';
+
+export const SHOW_UPDATE_AVAILABLE = 'show-update-available';
+
+export const CLOSE_APP = 'close-app';
+
+export const FORCE_KILL_QUEUE_AND_SHUTDOWN = 'force-kill-queue-and-shutdown';
+
+export const WALLET_BACKUP = 'wallet-backup';
+
+export const BACKUP_WALLET_DAT = 'backup-wallet-dat';
+
+export const START_BACKUP_WALLET = 'start-backup-wallet';

electron-app/src/controllers/logs.ts

@@ -0,0 +1,29 @@
+import * as log from '../services/electronLogger';
+import DialogManager from '../services/dialogmanager';
+import { getFileData, writeFile } from '../utils';
+
+export default class Logs {
+  async download(data: string, extension: string) {
+    try {
+      const dialogManager = new DialogManager();
+      const paths = await dialogManager.saveFilePath();
+      if (!paths.length) {
+        throw new Error('No valid path available');
+      }
+      paths.slice(-5).includes(extension)
+        ? writeFile(paths, data)
+        : writeFile(paths + extension, data);
+    } catch (err) {
+      log.error(err);
+    }
+  }
+
+  async read(filePath: string) {
+    try {
+      const data = getFileData(filePath);
+      return data;
+    } catch (err) {
+      log.error(err);
+    }
+  }
+}

electron-app/src/controllers/wallets.ts

@@ -1,6 +1,29 @@
+import path from 'path';
 import * as log from '../services/electronLogger';
 import DialogManager from '../services/dialogmanager';
-import { MENU_BACKUP_WALLET, MENU_IMPORT_WALLET } from '../constants';
+import {
+  MENU_BACKUP_WALLET,
+  MENU_IMPORT_WALLET,
+  START_BACKUP_WALLET,
+  WALLET_DAT,
+} from '../constants';
+import { copyFile, getBaseFolder, responseMessage } from '../utils';
+
+const saveFileDailog = async (
+  extensions: { name: string; extensions: string[] }[]
+) => {
+  const dialogManager = new DialogManager();
+  const paths = await dialogManager.saveFilePath(extensions);
+  if (!paths.length) {
+    throw new Error('No valid path available');
+  }
+  return paths;
+};
+
+const appendExtension = (paths: string, extension: string) => {
+  const isDatFile = paths.lastIndexOf('.');
+  return isDatFile === -1 ? `${paths}.${extension}` : paths;
+};
 
 export default class Wallet {
   async load(bw: Electron.BrowserWindow) {
@@ -15,14 +38,33 @@ export default class Wallet {
 
   async backup(bw: Electron.BrowserWindow) {
     try {
-      const dialogManager = new DialogManager();
-      const paths = await dialogManager.saveFilePath();
-      if (!paths.length) {
-        throw new Error('No valid path available');
-      }
-      bw.webContents.send(MENU_BACKUP_WALLET, { paths });
+      const paths = await saveFileDailog([
+        { name: 'Text file', extensions: ['txt'] },
+      ]);
+
+      bw.webContents.send(MENU_BACKUP_WALLET, {
+        paths: appendExtension(paths, 'txt'),
+      });
+      return responseMessage(true, {});
     } catch (err) {
       log.error(err);
+      return responseMessage(false, {
+        message: err.message,
+      });
     }
   }
+
+  async backupWalletDat() {
+    const paths = await saveFileDailog([
+      { name: 'Wallet', extensions: ['dat'] },
+    ]);
+    const dest = appendExtension(paths, 'dat');
+    const baseFolder = getBaseFolder();
+    const src = path.join(baseFolder, WALLET_DAT);
+    return copyFile(src, dest);
+  }
+
+  async startBackupWallet(bw: Electron.BrowserWindow) {
+    bw.webContents.send(START_BACKUP_WALLET);
+  }
 }

electron-app/src/ipc-events/appUpdateManager.ts

@@ -0,0 +1,15 @@
+import { CancellationToken } from 'electron-updater';
+import { app, ipcMain } from 'electron';
+import { POST_UPDATE_ACTION, START_DOWNLOAD_UPDATE } from '../constants';
+
+export default function initiateAppUpdateManager(autoUpdater: any) {
+  ipcMain.on(POST_UPDATE_ACTION, () => {
+    autoUpdater.quitAndInstall();
+    app.exit();
+  });
+
+  ipcMain.on(START_DOWNLOAD_UPDATE, () => {
+    const cancellationToken = new CancellationToken();
+    autoUpdater.downloadUpdate(cancellationToken);
+  });
+}

electron-app/src/ipc-events/backupAndImportWallet.ts

@@ -0,0 +1,25 @@
+import { ipcMain } from 'electron';
+import { WALLET_BACKUP, BACKUP_WALLET_DAT } from '../constants';
+import Wallet from '../controllers/wallets';
+import { responseMessage } from '../utils';
+
+const initiateBackupImportWalletManager = (bw: Electron.BrowserWindow) => {
+  ipcMain.on(WALLET_BACKUP, async (event: Electron.IpcMainEvent) => {
+    const wallet = new Wallet();
+    event.returnValue = await wallet.backup(bw);
+  });
+
+  ipcMain.on(BACKUP_WALLET_DAT, async (event: Electron.IpcMainEvent) => {
+    try {
+      const wallet = new Wallet();
+      await wallet.backupWalletDat();
+      event.returnValue = responseMessage(true, {});
+    } catch (err) {
+      event.returnValue = responseMessage(false, {
+        message: err.message,
+      });
+    }
+  });
+};
+
+export default initiateBackupImportWalletManager;

electron-app/src/ipc-events/defiprocessmanager.ts

@@ -1,20 +1,31 @@
 import { ipcMain } from 'electron';
 import DefiProcessManager from '../services/defiprocessmanager';
-import { START_DEFI_CHAIN, STOP_DEFI_CHAIN, RESTART_APP } from '../constants';
+import {
+  START_DEFI_CHAIN,
+  STOP_DEFI_CHAIN,
+  RESTART_APP,
+  CLOSE_APP,
+  FORCE_KILL_QUEUE_AND_SHUTDOWN,
+} from '../constants';
 
 export default function initiateDefiProcessManager() {
   ipcMain.on(START_DEFI_CHAIN, async (event, arg) => {
-    const defiProcessManager = new DefiProcessManager();
-    await defiProcessManager.start(arg, event);
+    await DefiProcessManager.start(arg, event);
   });
 
   ipcMain.on(STOP_DEFI_CHAIN, async (event) => {
-    const defiProcessManager = new DefiProcessManager();
-    event.returnValue = await defiProcessManager.stop();
+    event.returnValue = await DefiProcessManager.stop();
   });
 
   ipcMain.on(RESTART_APP, async (event, args) => {
-    const defiProcessManager = new DefiProcessManager();
-    event.returnValue = await defiProcessManager.restart(args, event);
+    event.returnValue = await DefiProcessManager.restart(args, event);
+  });
+
+  ipcMain.on(CLOSE_APP, async () => {
+    await DefiProcessManager.closeApp();
+  });
+
+  ipcMain.on(FORCE_KILL_QUEUE_AND_SHUTDOWN, async () => {
+    await DefiProcessManager.forceClose();
   });
 }