feat: wallet api - part 1/2

main/index.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { app, dialog } = require('electron')
+const { app, dialog, shell } = require('electron')
 const log = require('electron-log')
 const path = require('node:path')
 
@@ -108,7 +108,8 @@ const ctx = {
   confirmChangeWalletAddress: () => { throw new Error('never get here') },
   restartToUpdate: () => { throw new Error('never get here') },
   openReleaseNotes: () => { throw new Error('never get here') },
-  getUpdaterStatus: () => { throw new Error('never get here') }
+  getUpdaterStatus: () => { throw new Error('never get here') },
+  browseTransactionTracker: (/** @type {string} */ transactionHash) => { shell.openExternal(`https://explorer.glif.io/tx/${transactionHash}`) }
 }
 
 app.on('before-quit', () => {

main/ipc.js

@@ -26,10 +26,15 @@ function setupIpcMain (/** @type {Context} */ ctx) {
   ipcMain.handle('saturn:getFilAddress', saturnNode.getFilAddress)
   ipcMain.handle('saturn:setFilAddress', (_event, address) => saturnNode.setFilAddress(address))
   // Station-wide config
-  ipcMain.handle('station:getFilAddress', saturnNode.getFilAddress)
-  ipcMain.handle('station:setFilAddress', (_event, address) => saturnNode.setFilAddress(address))
   ipcMain.handle('station:getOnboardingCompleted', stationConfig.getOnboardingCompleted)
   ipcMain.handle('station:setOnboardingCompleted', (_event) => stationConfig.setOnboardingCompleted())
+  // Wallet-wide config
+  ipcMain.handle('station:getStationWalletAddress', stationConfig.getStationWalletAddress)
+  ipcMain.handle('station:getDestinationWalletAddress', stationConfig.getDestinationWalletAddress)
+  ipcMain.handle('station:setDestinationWalletAddress', (_event, address) => stationConfig.setDestinationWalletAddress(address))
+  ipcMain.handle('station:getStationWalletBalance', stationConfig.getStationWalletBalance)
+  ipcMain.handle('station:getStationWalletTransactionsHistory', stationConfig.getStationWalletTransactionsHistory)
+  ipcMain.handle('station:trasnferAllFundsToDestinationWallet', (_event, _args) => stationConfig.trasnferAllFundsToDestinationWallet())
 
   ipcMain.handle('station:getAllActivities', (_event, _args) => ctx.getAllActivities())
   ipcMain.handle('station:getTotalJobsCompleted', (_event, _args) => ctx.getTotalJobsCompleted())
@@ -39,6 +44,7 @@ function setupIpcMain (/** @type {Context} */ ctx) {
   ipcMain.handle('station:restartToUpdate', (_event, _args) => ctx.restartToUpdate())
   ipcMain.handle('station:openReleaseNotes', (_event) => ctx.openReleaseNotes())
   ipcMain.handle('station:getUpdaterStatus', (_events, _args) => ctx.getUpdaterStatus())
+  ipcMain.handle('station:browseTransactionTracker', (_events, transactoinHash) => ctx.browseTransactionTracker(transactoinHash))
 }
 
 module.exports = {

main/preload.js

@@ -2,6 +2,7 @@
 
 /** @typedef {import('electron').IpcRendererEvent} IpcRendererEvent */
 /** @typedef {import('./typings').Activity} Activity */
+/** @typedef {import('./typings').FILTransaction} TransactionMessage */
 
 const { contextBridge, ipcRenderer } = require('electron')
 
@@ -22,14 +23,19 @@ contextBridge.exposeInMainWorld('electron', {
     isReady: () => ipcRenderer.invoke('saturn:isReady'),
     getLog: () => ipcRenderer.invoke('saturn:getLog'),
     getWebUrl: () => ipcRenderer.invoke('saturn:getWebUrl'),
-    getFilAddress: () => ipcRenderer.invoke('saturn:getFilAddress'),
-    setFilAddress: (/** @type {string | undefined} */ address) => ipcRenderer.invoke('saturn:setFilAddress', address)
+    getFilAddress: () => ipcRenderer.invoke('saturn:getFilAddress'), // soon to be removed
+    setFilAddress: (/** @type {string | undefined} */ address) => ipcRenderer.invoke('saturn:setFilAddress', address) // soon to be removed
   },
   stationConfig: {
-    getFilAddress: () => ipcRenderer.invoke('station:getFilAddress'),
-    setFilAddress: (/** @type {string | undefined} */ address) => ipcRenderer.invoke('station:setFilAddress', address),
     getOnboardingCompleted: () => ipcRenderer.invoke('station:getOnboardingCompleted'),
-    setOnboardingCompleted: () => ipcRenderer.invoke('station:setOnboardingCompleted')
+    setOnboardingCompleted: () => ipcRenderer.invoke('station:setOnboardingCompleted'),
+    getStationWalletAddress: () => ipcRenderer.invoke('station:getStationWalletAddress'),
+    getDestinationWalletAddress: () => ipcRenderer.invoke('station:getDestinationWalletAddress'),
+    setDestinationWalletAddress: (/** @type {string | undefined} */ address) => ipcRenderer.invoke('station:setDestinationWalletAddress', address),
+    getStationWalletBalance: () => ipcRenderer.invoke('station:getStationWalletBalance'),
+    getStationWalletTransactionsHistory: () => ipcRenderer.invoke('station:getStationWalletTransactionsHistory'),
+    trasnferAllFundsToDestinationWallet: () => ipcRenderer.invoke('station:trasnferAllFundsToDestinationWallet'),
+    browseTransactionTracker: (/** @type {string } */ transactoinHash) => ipcRenderer.invoke('station:browseTransactionTracker', transactoinHash)
   },
   stationEvents: {
     onActivityLogged: (/** @type {(value: Activity) => void} */ callback) => {
@@ -54,6 +60,18 @@ contextBridge.exposeInMainWorld('electron', {
       const listener = () => callback()
       ipcRenderer.on('station:update-available', listener)
       return () => ipcRenderer.removeListener('station:update-available', listener)
+    },
+    onBalanceUpdate: (/** @type {(value: number) => void} */ callback) => {
+      /** @type {(event: IpcRendererEvent, ...args: any[]) => void} */
+      const listener = (_event, balance) => callback(balance)
+      ipcRenderer.on('station:wallet-balance-update', listener)
+      return () => ipcRenderer.removeListener('station:wallet-balance-update', listener)
+    },
+    onTransactionUpdate: (/** @type {(value: TransactionMessage) => void} */ callback) => {
+      /** @type {(event: IpcRendererEvent, ...args: any[]) => void} */
+      const listener = (_event, transactions) => callback(transactions)
+      ipcRenderer.on('station:transaction-update', listener)
+      return () => ipcRenderer.removeListener('station:transaction-update', listener)
     }
   },
   dialogs: {

main/station-config.js

@@ -7,9 +7,12 @@ const ConfigKeys = {
   OnboardingCompleted: 'station.OnboardingCompleted',
   TrayOperationExplained: 'station.TrayOperationExplained',
   StationID: 'station.StationID',
-  FilAddress: 'station.FilAddress'
+  FilAddress: 'station.FilAddress',
+  DestinationFilAddress: 'station.FilAddress' // todo - replace by 'station.DestinationFilAddress'
 }
 
+/** @typedef {import('./typings').FILTransaction} TransactionMessage */
+
 // Use this to test migrations
 // https://github.com/sindresorhus/electron-store/issues/205
 // require('electron').app.setVersion('9999.9.9')
@@ -35,6 +38,7 @@ console.log('Loading Station configuration from', configStore.path)
 let OnboardingCompleted = /** @type {boolean} */ (configStore.get(ConfigKeys.OnboardingCompleted, false))
 let TrayOperationExplained = /** @type {boolean} */ (configStore.get(ConfigKeys.TrayOperationExplained, false))
 let FilAddress = /** @type {string | undefined} */ (configStore.get(ConfigKeys.FilAddress))
+let DestinationFilAddress = /** @type {string | undefined} */ (configStore.get(ConfigKeys.DestinationFilAddress))
 const StationID = /** @type {string} */ (configStore.get(ConfigKeys.StationID, randomUUID()))
 
 /**
@@ -85,16 +89,65 @@ function setFilAddress (address) {
 /**
  * @returns {string}
  */
-function getStationID () {
+function getStationID() {
   return StationID
 }
 
+/**
+ * @returns {string}
+ */
+function getStationWalletAddress() {
+  return FilAddress || '' // needs refactor
+}
+
+/**
+ * @returns {string | undefined}
+ */
+function getDestinationWalletAddress() {
+  return DestinationFilAddress
+}
+
+/**
+ * @param {string | undefined} address
+ */
+function setDestinationWalletAddress(address) {
+  DestinationFilAddress = address
+  configStore.set(ConfigKeys.DestinationFilAddress, DestinationFilAddress)
+}
+
+/**
+ * @returns {number}
+ */
+function getStationWalletBalance() {
+  return 0 // todo - backend logic
+}
+
+/**
+ * @returns { TransactionMessage[] }
+ */
+function getStationWalletTransactionsHistory() {
+  return [] // todo - backend logic
+}
+
+/**
+ * @returns void
+ */
+function trasnferAllFundsToDestinationWallet() {
+  return {} // todo - backend logic
+}
+
 module.exports = {
   getOnboardingCompleted,
   setOnboardingCompleted,
   getTrayOperationExplained,
   setTrayOperationExplained,
   getFilAddress,
   setFilAddress,
-  getStationID
+  getStationID,
+  getStationWalletAddress,
+  getDestinationWalletAddress,
+  setDestinationWalletAddress,
+  getStationWalletBalance,
+  getStationWalletTransactionsHistory,
+  trasnferAllFundsToDestinationWallet
 }

main/typings.d.ts

@@ -1,5 +1,6 @@
 export type ActivitySource = 'Station' | 'Saturn';
 export type ActivityType = 'info' | 'error';
+export type TransactionStatus = 'sent' | 'processing' | 'failed'
 
 export interface Activity {
   id: string;
@@ -9,6 +10,15 @@ export interface Activity {
   message: string;
 }
 
+export type FILTransaction = {
+  hash: string
+  timestamp: number
+  status: TransactionStatus
+  outgoing: boolean
+  amount: string
+  address: string
+}
+
 export type RecordActivityArgs = Omit<Activity, 'id' | 'timestamp'>;
 
 export type ModuleJobStatsMap = Record<string, number>;
@@ -28,5 +38,6 @@ export interface Context {
 
   openReleaseNotes: () => void,
   restartToUpdate: () => void,
-  getUpdaterStatus: () => {updateAvailable: boolean}
+  getUpdaterStatus: () => {updateAvailable: boolean},
+  browseTransactionTracker: (transactionHash: string) => void
 }

renderer/src/components/Saturn.tsx

@@ -1,10 +1,10 @@
 import { useEffect } from 'react'
-import { getFilAddress, startSaturnNode } from '../lib/station-config'
+import { getDestinationWalletAddress, startSaturnNode } from '../lib/station-config'
 
 const Saturn = () => {
   useEffect(() => {
     (async () => {
-      if (await getFilAddress()) {
+      if (await getDestinationWalletAddress()) {
         startSaturnNode()
       }
     })()

renderer/src/hooks/StationActivity.tsx

@@ -0,0 +1,54 @@
+import { useState, useEffect } from 'react'
+import { getTotalJobsCompleted, getAllActivities, getTotalEarnings } from '../lib/station-config'
+import { ActivityEventMessage } from '../typings'
+
+interface StationActivity {
+  totalJobs: number,
+  totalEarnings: number,
+  activities: ActivityEventMessage[] | []
+}
+const useStationActivity = (): StationActivity => {
+  const [totalJobs, setTotalJobs] = useState<number>(0)
+  const [activities, setActivities] = useState<ActivityEventMessage[]>([])
+  const [totalEarnings, setTotalEarnigs] = useState<number>(0)
+
+  useEffect(() => {
+    const loadStoredInfo = async () => setTotalJobs(await getTotalJobsCompleted())
+    loadStoredInfo()
+  }, [])
+
+  useEffect(() => {
+    const loadStoredInfo = async () => setActivities(await getAllActivities())
+    loadStoredInfo()
+  }, [])
+
+  useEffect(() => {
+    const loadStoredInfo = async () => setTotalEarnigs(await getTotalEarnings())
+    loadStoredInfo()
+  }, [])
+
+  useEffect(() => {
+    const unsubscribeOnJobProcessed = window.electron.stationEvents.onJobProcessed(setTotalJobs)
+    return () => {
+      unsubscribeOnJobProcessed()
+    }
+  }, [])
+
+  useEffect(() => {
+    const unsubscribeOnActivityLogged = window.electron.stationEvents.onActivityLogged(setActivities)
+    return () => {
+      unsubscribeOnActivityLogged()
+    }
+  }, [])
+
+  useEffect(() => {
+    const unsubscribeOnEarningsChanged = window.electron.stationEvents.onEarningsChanged(setTotalEarnigs)
+    return () => {
+      unsubscribeOnEarningsChanged()
+    }
+  }, [])
+
+  return { totalJobs, totalEarnings, activities }
+}
+
+export default useStationActivity

renderer/src/hooks/StationWallet.tsx

@@ -0,0 +1,98 @@
+import { useState, useEffect } from 'react'
+import {
+  getDestinationWalletAddress,
+  setDestinationWalletAddress,
+  getStationWalletAddress,
+  getStationWalletBalance,
+  getStationWalletTransactionsHistory
+} from '../lib/station-config'
+import { FILTransaction } from '../typings'
+
+interface Wallet {
+  stationAddress: string,
+  destinationFilAddress: string | undefined,
+  walletBalance: number,
+  walletTransactions: FILTransaction[] | [],
+  editDestinationAddress: (address: string|undefined) => void,
+  currentTransaction: FILTransaction | undefined,
+  dismissCurrentTransaction: () => void
+}
+
+const useWallet = (): Wallet => {
+  const [stationAddress, setStationAddress] = useState<string>('')
+  const [destinationFilAddress, setDestinationFilAddress] = useState<string | undefined>()
+  const [walletBalance, setWalletBalance] = useState<number>(0)
+  const [walletTransactions, setWalletTransactions] = useState<FILTransaction[]>([])
+  const [currentTransaction, setCurrentTransaction] = useState<FILTransaction | undefined>()
+
+  const editDestinationAddress = async (address: string | undefined) => {
+    await setDestinationWalletAddress(address)
+    setDestinationFilAddress(address)
+  }
+
+  const dismissCurrentTransaction = () => {
+    if (currentTransaction && currentTransaction.status !== 'processing') {
+      setWalletTransactions([currentTransaction, ...walletTransactions])
+      setCurrentTransaction(undefined)
+    }
+  }
+
+  useEffect(() => {
+    const loadStoredInfo = async () => {
+      setDestinationFilAddress(await getDestinationWalletAddress())
+    }
+    loadStoredInfo()
+  }, [destinationFilAddress])
+
+  useEffect(() => {
+    const loadStoredInfo = async () => {
+      setStationAddress(await getStationWalletAddress())
+    }
+    loadStoredInfo()
+  }, [stationAddress])
+
+  useEffect(() => {
+    const loadStoredInfo = async () => {
+      setWalletBalance(await getStationWalletBalance())
+    }
+    loadStoredInfo()
+  }, [])
+
+  useEffect(() => {
+    const loadStoredInfo = async () => {
+      setWalletTransactions(await getStationWalletTransactionsHistory())
+    }
+    loadStoredInfo()
+  }, [])
+
+  useEffect(() => {
+    const updateWalletTransactionsArray = (transactions: FILTransaction[]) => {
+      const newCurrentTransaction = transactions[0]
+      if (newCurrentTransaction.status === 'processing' || (currentTransaction && +currentTransaction.timestamp === +newCurrentTransaction.timestamp)) {
+        setCurrentTransaction(newCurrentTransaction)
+        if (newCurrentTransaction.status !== 'processing') { setTimeout(() => { setWalletTransactions(transactions); setCurrentTransaction(undefined) }, 6000) }
+
+        const transactionsExceptLatest = transactions.filter((t) => { return t !== newCurrentTransaction })
+        setWalletTransactions(transactionsExceptLatest)
+      } else {
+        setWalletTransactions(transactions)
+      }
+    }
+
+    const unsubscribeOnTransactionUpdate = window.electron.stationEvents.onTransactionUpdate(updateWalletTransactionsArray)
+    return () => {
+      unsubscribeOnTransactionUpdate()
+    }
+  }, [currentTransaction])
+
+  useEffect(() => {
+    const unsubscribeOnBalanceUpdate = window.electron.stationEvents.onBalanceUpdate(setWalletBalance)
+    return () => {
+      unsubscribeOnBalanceUpdate()
+    }
+  }, [walletBalance])
+
+  return { stationAddress, destinationFilAddress, walletBalance, walletTransactions, editDestinationAddress, currentTransaction, dismissCurrentTransaction }
+}
+
+export default useWallet